fix: no cross-bot imports

This commit is contained in:
TrèsAbhi committed 2024-09-07 23:00:56 -05:00
1 parent 6c0b46725d
commit 7c6f381bbe
58 files changed
+233 -252

No files matched your search

@@ -1,5 +1,4 @@
import { Region } from '@blitzkit/core';
import { RatingInfo } from '../../../../bot/src/commands/ratingLeaderboard';
import { RatingInfo, Region } from '@blitzkit/core';
import { context } from '../blitzkit/context';
import { patientFetch } from '../blitzkit/patientFetch';
import regionToRegionSubdomain from './regionToRegionSubdomain';
@@ -1,8 +1,6 @@
import { Region } from '@blitzkit/core';
import {
LeagueTop,
RatingPlayer,
} from '../../../../bot/src/commands/ratingLeaderboard';
import { LeagueTop } from '@blitzkit/core/src/blitz/rating';
import { RatingPlayer } from '@blitzkit/core/src/statistics/deltaBkrlBlitzStats';
import { context } from '../blitzkit/context';
import { patientFetch } from '../blitzkit/patientFetch';
import regionToRegionSubdomain from './regionToRegionSubdomain';
@@ -1,5 +1,4 @@
import { Region } from '@blitzkit/core';
import { RatingNeighbors } from '../../../../bot/src/commands/ratingLeaderboard';
import { RatingNeighbors, Region } from '@blitzkit/core';
import { patientFetch } from '../blitzkit/patientFetch';
import { withCORSProxy } from '../blitzkit/withCORSProxy';
import regionToRegionSubdomain from './regionToRegionSubdomain';
@@ -1,45 +0,0 @@
import { tankDefinitions, tankNames } from '@blitzkit/core';
import { Locale } from 'discord.js';
import { go } from 'fuzzysort';
import markdownEscape from 'markdown-escape';
import { tankNamesTechTreeOnly } from '../../../../bot/src/core/discord/autocompleteTanks';
import { translator } from '../../../../bot/src/core/localization/translator';
import { UserError } from '../../hooks/userError';
export default async function resolveTankId(
tank: string | number,
locale: Locale,
techTreeOnly = false,
) {
const { translate } = translator(locale);
const number = typeof tank === 'string' ? Number(tank) : tank;
if (Number.isNaN(number)) {
const searchResult = go(
`${tank}`,
await (techTreeOnly ? tankNamesTechTreeOnly : tankNames),
{
keys: ['searchableName', 'searchableNameDeburr', 'camouflages'],
limit: 1,
},
);
if (searchResult.length === 0) {
throw new UserError(
translate('bot.common.errors.tank_name_not_found', [
markdownEscape(`${tank}`),
]),
);
} else {
return searchResult[0].obj.id;
}
} else {
if ((await tankDefinitions)[number]) {
return number;
} else {
throw new UserError(
translate('bot.common.errors.tank_id_not_found', [`${number}`]),
);
}
}
}
@@ -1,54 +0,0 @@
import { Region } from '@blitzkit/core';
import { ClanList } from '../../../../bot/src/types/clanList';
import fetchBlitz from './fetchBlitz';
export default async function searchClansAcrossRegions(
search: string,
limit = 25,
) {
const trimmed = search.trim();
if (trimmed.length < 3 && trimmed.length > 100) return [];
const normalizedLimit = Math.floor(limit / 3);
// TODO: remove splice once wargaming fixes the functionality of the limit felid
return (
await Promise.all([
fetchBlitz<ClanList>('com', 'clans/list', {
search,
limit: normalizedLimit,
}).then((value) =>
value
.map((account) => ({
...account,
region: 'com' as Region,
}))
.splice(0, normalizedLimit),
),
fetchBlitz<ClanList>('eu', 'clans/list', {
search,
limit: normalizedLimit,
}).then((value) =>
value
.map((account) => ({
...account,
region: 'eu' as Region,
}))
.splice(0, normalizedLimit),
),
fetchBlitz<ClanList>('asia', 'clans/list', {
search,
limit: normalizedLimit,
}).then((value) =>
value
.map((account) => ({
...account,
region: 'asia' as Region,
}))
.splice(0, normalizedLimit),
),
])
)
.filter(Boolean)
.flat();
}
@@ -1,32 +0,0 @@
import {
StatFilters,
tankDefinitions,
Tier,
TIER_ROMAN_NUMERALS,
} from '@blitzkit/core';
import { Locale } from 'discord.js';
import { translator } from '../../../../bot/src/core/localization/translator';
export async function filtersToDescription(
{ nation, tier, tankType, treeType, tank }: StatFilters,
locale: Locale,
) {
const { translate } = translator(locale);
const awaitedTankDefinitions = await tankDefinitions;
const info: string[] = [];
// TODO: somehow localize tank names?
if (tank) return awaitedTankDefinitions[tank].name;
if (nation) info.push(translate(`common.nations.${nation}`));
if (tier) {
info.push(
translate('bot.common.filters.tier', [TIER_ROMAN_NUMERALS[tier as Tier]]),
);
}
if (tankType) info.push(translate(`common.tank_class_short.${tankType}`));
if (treeType) info.push(translate(`common.tree_type.${treeType}`));
return info.length === 0
? translate('bot.common.filters.none')
: info.join(', ');
}
@@ -1,6 +1,6 @@
import { Region, asset } from '@blitzkit/core';
import { RatingInfo } from '@blitzkit/core/src/blitz/leagues';
import { superDecompress } from '@blitzkit/core/src/blitzkit/superDecompress';
import { RatingInfo } from '../../../../bot/src/commands/ratingLeaderboard';
const cache: Record<
Region,
@@ -1,29 +0,0 @@
import { usersDatabase } from '@blitzkit/core';
import { client } from '../../../../bot/src/core/discord/client';
const EXIT_EVENTS = [
'beforeExit',
'exit',
'SIGINT',
'SIGTERM',
'SIGUSR1',
'SIGUSR2',
];
async function cleanup() {
console.log('Cleaning up...');
await Promise.all([usersDatabase.$disconnect(), client.destroy()]);
console.log('Gracefully exiting...');
EXIT_EVENTS.forEach((event) => process.off(event, cleanup));
process.exit(0);
}
export function registerProcesses() {
process.on('uncaughtException', console.error);
client.on('error', console.error);
EXIT_EVENTS.forEach((event) => process.on(event, cleanup));
}
@@ -1,18 +0,0 @@
import { Region } from '@blitzkit/core';
import buttonLink from '../../../../bot/src/core/discord/buttonLink';
import { getAccountInfo } from '../blitz/getAccountInfo';
export async function getBlitzStarsLinkButton(
region: Region,
id: number,
tankId?: number,
) {
const { nickname } = await getAccountInfo(region, id);
return buttonLink(
`https://www.blitzstars.com/player/${region}/${nickname}${
tankId ? `/tank/${tankId!}` : ''
}`,
'BlitzStars',
);
}
@@ -1,63 +0,0 @@
import { Region, emptyAllStats } from '@blitzkit/core';
import {
GetHistoriesOptions,
Histories,
History,
getHistoriesDefaultOptions,
} from '../../../../bot/src/types/histories';
import { getAccountInfo } from '../blitz/getAccountInfo';
import { PlayerStats } from './getPlayerStats';
export default async function getPlayerHistories(
server: Region,
id: number,
options?: Partial<GetHistoriesOptions>,
) {
const mergedOptions = { ...getHistoriesDefaultOptions, ...options };
const response = await fetch(
`https://www.blitzstars.com/api/playerstats/${id}`,
);
const playerHistories = ((await response.json()) as PlayerStats).map(
(history) =>
({
all: history.statistics.all,
last_battle_time: history.last_battle_time,
} satisfies History),
);
let lastNonCompliantIndex = -1;
let hasCompliedOnce = false;
const filtered = playerHistories.filter(({ last_battle_time }, index) => {
const complies =
last_battle_time >= mergedOptions.start &&
last_battle_time <= mergedOptions.end;
if (complies && !hasCompliedOnce) hasCompliedOnce = true;
if (!hasCompliedOnce) lastNonCompliantIndex = index;
return complies;
});
const latestNodes: Histories = [];
if (mergedOptions.includeLatestHistories) {
const { last_battle_time, statistics } = await getAccountInfo(server, id);
latestNodes.push({ all: statistics.all, last_battle_time });
}
const previousNodes: Histories = [];
if (mergedOptions.includePreviousHistories) {
if (lastNonCompliantIndex !== -1) {
previousNodes.push(
playerHistories[lastNonCompliantIndex] ??
({
all: emptyAllStats,
last_battle_time: -Infinity,
} satisfies History),
);
}
}
return [...latestNodes, ...filtered, ...previousNodes] satisfies Histories;
}
@@ -1,37 +0,0 @@
import { BlitzStats, Region } from '@blitzkit/core';
interface IndividualPlayerStats {
clan: { clan_id: number; name: string; tag: string };
statistics: {
all: BlitzStats;
wn8: number;
wn7: number;
average_tier: number;
};
last_battle_time: number;
nickname: string;
account_id: number;
achievements: {
account_id: number;
[key: string]: number;
};
region: Region;
}
export type PlayerStats = IndividualPlayerStats[];
export async function getPlayerStats<
Ids extends number | number[],
ReturnType = Ids extends number ? PlayerStats : PlayerStats[],
>(region: Region, ids: Ids) {
const stats = await Promise.all(
((typeof ids === 'number' ? [ids] : ids) as number[]).map((id) =>
fetch(`https://www.blitzstars.com/api/playerstats/${id}`).then(
(response) => response.json() as Promise<PlayerStats>,
),
),
);
if (typeof ids === 'number') return stats[0] as ReturnType;
return stats as ReturnType;
}
@@ -1,105 +0,0 @@
import { BlitzStats, tankDefinitions } from '@blitzkit/core';
import { context } from '../blitzkit/context';
interface SpecialStats {
winrate: number;
damageRatio: number;
kdr: number;
damagePerBattle: number;
killsPerBattle: number;
hitsPerBattle: number;
spotsPerBattle: number;
wpm: number;
dpm: number;
kpm: number;
hitRate: number;
survivalRate: number;
}
export type Percentiles = [
number,
number,
number,
number,
number,
number,
number,
number,
number,
];
export interface SpecialPercentiles {
winRate: Percentiles;
damageRatio: Percentiles;
kdr: Percentiles;
damagePerBattle: Percentiles;
killsPerBattle: Percentiles;
hitsPerBattle: Percentiles;
spotsPerBattle: Percentiles;
wpm: Percentiles;
dpm: Percentiles;
kpm: Percentiles;
hitRate: Percentiles;
survivalRate: Percentiles;
}
export interface MeanSd {
winrateMean: number;
winrateSd: number;
hitRateMean: number;
hitRateSd: number;
survivalRateMean: number;
survivalRateSd: number;
damageRatioMean: number;
damageRatioSd: number;
kdrMean: number;
kdrSd: number;
dpbMean: number;
dpbSd: number;
kpbMean: number;
kpbSd: number;
hpbMean: number;
hpbSd: number;
spbMean: number;
spbSd: number;
}
export interface IndividualTankAverage {
_id: number;
battle_life_time: number;
total_battle_life_time: number;
number_of_players: number;
tank_id: number;
all: BlitzStats;
special: SpecialStats;
percentiles: SpecialPercentiles;
percentiles_player_count: number;
meanSd: MeanSd;
shotEff: number;
last_update: number;
}
tankDefinitions;
export type TankAverages = Record<number, IndividualTankAverage>;
export const tankAverages = fetch(
context === 'website'
? '/api/tank-averages'
: 'https://www.blitzstars.com/api/tankaverages.json',
)
.then((response) => response.json())
.then((json) => {
if (context === 'server') {
const partialTankAverages: TankAverages = {};
(json as IndividualTankAverage[]).forEach((individualTankAverage) => {
partialTankAverages[individualTankAverage.tank_id] =
individualTankAverage;
});
return partialTankAverages;
} else {
return json as TankAverages;
}
});