feat: move tankopedia to tankDefinitions

src/core/blitz/encyclopediaInfo.ts

@@ -1,7 +1,7 @@
 import { WARGAMING_APPLICATION_ID } from '../../constants/wargamingApplicationID';
 import fetchBlitz from './fetchBlitz';
 
-export interface TankopediaInfo {
+export interface EncyclopediaInfo {
   achievement_sections: Record<string, { name: string; order: number }>;
   tanks_updated_at: number;
   languages: Record<string, string>;
@@ -10,6 +10,6 @@ export interface TankopediaInfo {
   game_version: string;
 }
 
-export const tankopediaInfo = fetchBlitz<TankopediaInfo>(
+export const encyclopediaInfo = fetchBlitz<EncyclopediaInfo>(
   `https://api.wotblitz.com/wotb/encyclopedia/info/?application_id=${WARGAMING_APPLICATION_ID}`,
 );

src/core/blitz/getTreeType.ts

@@ -1,8 +1,8 @@
 import { TreeTypeEnum } from '../../components/Tanks';
-import { tankopedia } from '../blitzkrieg/tankopedia';
+import { tankDefinitions } from '../blitzkrieg/definitions/tanks';
 
 export default async function getTreeType(id: number) {
-  const entry = (await tankopedia)[id];
+  const entry = (await tankDefinitions)[id];
 
   if (entry.tree_type === 'collector') return TreeTypeEnum.Collector;
   if (entry.tree_type === 'premium') return TreeTypeEnum.Premium;

src/core/blitz/resolveTankId.ts

@@ -1,12 +1,15 @@
 import { go } from 'fuzzysort';
-import { tankopedia, tanks } from '../blitzkrieg/tankopedia';
+import {
+  tankDefinitions,
+  tanksDefinitionsArray,
+} from '../blitzkrieg/definitions/tanks';
 import { UserError } from '../blitzkrieg/userError';
 
 export default async function resolveTankId(tank: string | number) {
   const number = typeof tank === 'string' ? parseInt(tank) : tank;
 
   if (Number.isNaN(number)) {
-    const searchResult = go(`${tank}`, await tanks, {
+    const searchResult = go(`${tank}`, await tanksDefinitionsArray, {
       keys: ['name'],
       limit: 1,
     });
@@ -19,7 +22,7 @@ export default async function resolveTankId(tank: string | number) {
       return searchResult[0].obj.id;
     }
   } else {
-    if ((await tankopedia)[number]) {
+    if ((await tankDefinitions)[number]) {
       return number;
     } else {
       throw new UserError('Tank not found', {

src/core/blitz/resolveTankName.ts

@@ -1,8 +1,8 @@
-import { tankopedia } from '../blitzkrieg/tankopedia';
+import { tankDefinitions } from '../blitzkrieg/definitions/tanks';
 
 export default async function resolveTankName(tankId: number) {
-  const awaitedTankopedia = await tankopedia;
-  const entry = awaitedTankopedia[tankId];
+  const awaitedTankDefinitions = await tankDefinitions;
+  const entry = awaitedTankDefinitions[tankId];
 
   return entry?.name_short ?? entry?.name ?? `Unknown Tank ${tankId}`;
 }

src/core/blitzkrieg/definitions/tanks.ts

@@ -1,24 +1,8 @@
 import { deburr } from 'lodash';
-import { TankType, TreeTypeString } from '../../components/Tanks';
-import { asset } from './asset';
+import { TankType, TreeTypeString } from '../../../components/Tanks';
+import { asset } from '../asset';
 
-export interface TankopediaEntry {
-  name: string;
-  nation: string;
-  is_premium: boolean;
-  is_collectible: boolean;
-  tier: Tier;
-  cost: { price_credit: number; price_gold: number };
-  images: { preview: string; normal: string };
-  tank_id: number;
-  type: string;
-  description: string;
-}
-export interface Tankopedia {
-  [id: number]: TankopediaEntry | undefined;
-}
-
-export interface BlitzkriegTankopediaEntry {
+export interface TankDefinition {
   id: number;
   nation: string;
   name: string;
@@ -28,15 +12,16 @@ export interface BlitzkriegTankopediaEntry {
   type: TankType;
 }
 
-export type BlitzkriegTankopedia = Record<number, BlitzkriegTankopediaEntry>;
+export type TankDefinitions = Record<number, TankDefinition>;
 
-export const tankopedia = fetch(asset('tankopedia.json'), {
+export const tankDefinitions = fetch(asset('definitions/tanks.json'), {
   cache: 'no-store',
-}).then(async (response) => response.json() as Promise<BlitzkriegTankopedia>);
-const entries = new Promise<BlitzkriegTankopediaEntry[]>(async (resolve) => {
-  resolve(Object.entries(await tankopedia).map(([, entry]) => entry));
+}).then(async (response) => response.json() as Promise<TankDefinitions>);
+
+const entries = new Promise<TankDefinition[]>(async (resolve) => {
+  resolve(Object.entries(await tankDefinitions).map(([, entry]) => entry));
 });
-export const tanks = new Promise<BlitzkriegTankopediaEntry[]>(
+export const tanksDefinitionsArray = new Promise<TankDefinition[]>(
   async (resolve) => {
     resolve((await entries).map((entry) => entry));
   },
@@ -47,7 +32,7 @@ export const tankNames = new Promise<string[]>(async (resolve) => {
 export const tankNamesDiacritics = tankNames.then((tankNames) =>
   Promise.all(
     tankNames.map(async (tankName, index) => {
-      const { id } = (await tanks)[index];
+      const { id } = (await tanksDefinitionsArray)[index];
       const name = tankName ?? `Unknown Tank ${id}`;
       const diacriticless = deburr(name);
 
@@ -99,7 +84,7 @@ export const TIER_ROMAN_NUMERALS: Record<Tier, string> = {
   10: 'X',
 };
 
-export const NATIONS = tanks.then((tanks) => {
+export const NATIONS = tanksDefinitionsArray.then((tanks) => {
   const nationsObject: Record<string, true> = {};
 
   tanks.forEach(({ nation }) => {

src/core/blitzkrieg/filtersToDescription.ts

@@ -1,8 +1,8 @@
 import { TREE_TYPE_NAMES } from '../../components/Tanks';
+import { encyclopediaInfo } from '../blitz/encyclopediaInfo';
 import resolveTankName from '../blitz/resolveTankName';
-import { tankopediaInfo } from '../blitz/tankopediaInfo';
 import { StatFilters } from '../statistics/filterStats';
-import { TIER_ROMAN_NUMERALS, Tier } from './tankopedia';
+import { TIER_ROMAN_NUMERALS, Tier } from './definitions/tanks';
 
 export async function filtersToDescription({
   nation,
@@ -11,13 +11,13 @@ export async function filtersToDescription({
   treeType,
   tank,
 }: StatFilters) {
-  const awaitedTankopediaInfo = await tankopediaInfo;
+  const awaitedEncyclopediaInfo = await encyclopediaInfo;
   const info: string[] = [];
 
   if (tank) return await resolveTankName(tank);
-  if (nation) info.push(awaitedTankopediaInfo.vehicle_nations[nation]);
+  if (nation) info.push(awaitedEncyclopediaInfo.vehicle_nations[nation]);
   if (tier) info.push(`Tier ${TIER_ROMAN_NUMERALS[tier as Tier]}`);
-  if (tankType) info.push(awaitedTankopediaInfo.vehicle_types[tankType]);
+  if (tankType) info.push(awaitedEncyclopediaInfo.vehicle_types[tankType]);
   if (treeType) info.push(TREE_TYPE_NAMES[treeType]);
 
   return info.length === 0 ? 'No filters' : info.join(', ');

src/core/blitzstars/tankAverages.ts

@@ -1,6 +1,6 @@
 import { AllStats } from '../blitz/getAccountInfo';
 import { context } from '../blitzkrieg/context';
-import { tankopedia } from '../blitzkrieg/tankopedia';
+import { tankDefinitions } from '../blitzkrieg/definitions/tanks';
 
 export interface SpecialStats {
   winrate: number;
@@ -80,7 +80,7 @@ export interface IndividualTankAverage {
   last_update: number;
 }
 
-tankopedia;
+tankDefinitions;
 
 export type TankAverages = Record<number, IndividualTankAverage>;
 

src/core/discord/addFilterOptions.ts

@@ -4,7 +4,7 @@ import {
   SlashCommandSubcommandGroupBuilder,
 } from 'discord.js';
 import { TREE_TYPE_NAMES, TreeTypeString } from '../../components/Tanks';
-import { tankopediaInfo } from '../blitz/tankopediaInfo';
+import { encyclopediaInfo } from '../blitz/encyclopediaInfo';
 import addPeriodSubCommands from './addPeriodSubCommands';
 import addTankChoices from './addTankChoices';
 import addTierChoices from './addTierChoices';
@@ -17,7 +17,7 @@ export default async function addFilterOptions<
     option: SlashCommandSubcommandBuilder,
   ) => SlashCommandSubcommandBuilder = (option) => option,
 ): Promise<OptionType> {
-  const awaitedTankopediaInfo = await tankopediaInfo;
+  const awaitedEncyclopediaInfo = await encyclopediaInfo;
 
   addPeriodSubCommands(option, (option) => {
     extra(option);
@@ -28,7 +28,7 @@ export default async function addFilterOptions<
           .setName('nation')
           .setDescription('Nation')
           .addChoices(
-            ...Object.entries(awaitedTankopediaInfo.vehicle_nations).map(
+            ...Object.entries(awaitedEncyclopediaInfo.vehicle_nations).map(
               ([type, name]) => ({ name, value: type }),
             ),
           )
@@ -40,7 +40,7 @@ export default async function addFilterOptions<
           .setName('tank-type')
           .setDescription('Tank type')
           .addChoices(
-            ...Object.entries(awaitedTankopediaInfo.vehicle_types).map(
+            ...Object.entries(awaitedEncyclopediaInfo.vehicle_types).map(
               ([type, name]) => ({
                 name: name.replace(' Tank', ''),
                 value: type,

src/core/discord/autocompleteTanks.ts

@@ -4,7 +4,7 @@ import {
   CacheType,
 } from 'discord.js';
 import { go } from 'fuzzysort';
-import { tankNamesDiacritics } from '../blitzkrieg/tankopedia';
+import { tankNamesDiacritics } from '../blitzkrieg/definitions/tanks';
 import {
   DISCORD_CHOICES_MAX_NAME_SIZE,
   OVERFLOW_SUFFIX,

src/core/statistics/filterStats.ts

@@ -1,5 +1,5 @@
 import { TreeTypeString } from '../../components/Tanks';
-import { tankopedia } from '../blitzkrieg/tankopedia';
+import { tankDefinitions } from '../blitzkrieg/definitions/tanks';
 import { DiffedTankStats } from '../blitzstars/getStatsInPeriod';
 import { tankAverages } from '../blitzstars/tankAverages';
 import calculateWN8 from './calculateWN8';
@@ -20,10 +20,10 @@ export async function filterStats(
   // tank, if provided, takes priority over all other filters
   if (filters.tank) filters = { tank: filters.tank };
 
-  const awaitedTankopedia = await tankopedia;
+  const awaitedTankDefinitions = await tankDefinitions;
   const awaitedTankAverages = await tankAverages;
   const filteredOrder = order.filter((id) => {
-    const entry = awaitedTankopedia[id];
+    const entry = awaitedTankDefinitions[id];
 
     return (
       entry &&
@@ -44,9 +44,9 @@ export async function filterStats(
       awaitedTankAverages[id] ? accumulator + diff[id].battles : accumulator,
     0,
   );
-  const battlesOfTanksWithTankopediaEntry = filteredOrder.reduce<number>(
+  const battlesOfTanksWithTankDefinition = filteredOrder.reduce<number>(
     (accumulator, id) =>
-      awaitedTankopedia[id] ? accumulator + diff[id].battles : accumulator,
+      awaitedTankDefinitions[id] ? accumulator + diff[id].battles : accumulator,
     0,
   );
   const supplementary = {
@@ -63,11 +63,11 @@ export async function filterStats(
     tier:
       filteredOrder.reduce<number>(
         (accumulator, id) =>
-          awaitedTankopedia[id]
-            ? accumulator + awaitedTankopedia[id]!.tier * diff[id].battles
+          awaitedTankDefinitions[id]
+            ? accumulator + awaitedTankDefinitions[id]!.tier * diff[id].battles
             : accumulator,
         0,
-      ) / battlesOfTanksWithTankopediaEntry,
+      ) / battlesOfTanksWithTankDefinition,
   };
 
   return { stats, supplementary, filteredOrder };

src/core/statistics/getTierWeights.ts

@@ -1,16 +1,16 @@
 import { TierWeightsRecord } from '../../components/TierWeights';
 import { AllStats } from '../blitz/getAccountInfo';
-import { tankopedia } from '../blitzkrieg/tankopedia';
+import { tankDefinitions } from '../blitzkrieg/definitions/tanks';
 
 export async function getTierWeights(
   stats: Record<number, AllStats>,
   order: number[] = Object.keys(stats).map(parseInt),
 ) {
-  const awaitedTankopedia = await tankopedia;
+  const awaitedTankDefinitions = await tankDefinitions;
   const tierWeights: TierWeightsRecord = {};
 
   order.forEach((id) => {
-    const entry = awaitedTankopedia[id];
+    const entry = awaitedTankDefinitions[id];
 
     if (!entry) return;
     if (!tierWeights[entry.tier]) tierWeights[entry.tier] = 0;