feat: player evolution

src/core/blitzstars/getPlayerHistories.ts

@@ -0,0 +1,92 @@
+import { BlitzServer } from '../../constants/servers.js';
+import { AccountInfo, AllStats } from '../../types/accountInfo.js';
+import {
+  GetHistoriesOptions,
+  Histories,
+  History,
+  getHistoriesDefaultOptions,
+} from '../../types/histories.js';
+import getWargamingResponse from '../blitz/getWargamingResponse.js';
+import { WARGAMING_APPLICATION_ID } from '../process/args.js';
+import { emptyAllStats } from './getTankStatsOverTime.js';
+
+export interface PlayerHistoryRaw {
+  clan: { clan_id: number; name: string; tag: string };
+  statistics: {
+    all: AllStats;
+    wn8: number;
+    wn7: number;
+    average_tier: number;
+  };
+  last_battle_time: number;
+  nickname: string;
+  account_id: number;
+  achievements: {
+    account_id: number;
+    [key: string]: number;
+  };
+  region: BlitzServer;
+}
+
+export type PlayerHistoriesRaw = PlayerHistoryRaw[];
+
+export default async function getPlayerHistories(
+  server: BlitzServer,
+  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 PlayerHistoriesRaw).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: { all },
+    } = (
+      await getWargamingResponse<AccountInfo>(
+        `https://api.wotblitz.${server}/wotb/account/info/?application_id=${WARGAMING_APPLICATION_ID}&account_id=${id}`,
+      )
+    )[id];
+
+    latestNodes.push({ 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;
+}

src/core/blitzstars/getTankHistories.ts

@@ -1,41 +1,34 @@
 import { BlitzServer } from '../../constants/servers.js';
-import { AllStats } from '../../types/accountInfo.js';
+import {
+  GetHistoriesOptions,
+  Histories,
+  History,
+  getHistoriesDefaultOptions,
+} from '../../types/histories.js';
 import getTankStats from '../blitz/getTankStats.js';
 import { emptyAllStats } from './getTankStatsOverTime.js';
 
-export interface TankHistory {
-  all: AllStats;
-  last_battle_time: number;
-  mark_of_mastery: number;
-  battle_life_time: number;
-  account_id: number;
+export interface TankHistory extends History {
   tank_id: number;
 }
 
-export const emptyTankHistory: TankHistory = {
-  all: emptyAllStats,
-  last_battle_time: -Infinity,
-  mark_of_mastery: 0,
-  battle_life_time: 0,
-  account_id: 0,
-  tank_id: 0,
-};
-
 export type TankHistories = TankHistory[];
 
-export interface GetTankHistoriesOptions {
-  start: number;
-  end: number;
-  includeLatestHistories: boolean;
-  includePreviousHistories: boolean;
+export interface TankHistoryRaw extends TankHistory {
+  mark_of_mastery: number;
+  battle_life_time: number;
+  account_id: number;
+}
+
+export type TankHistoriesRaw = TankHistoryRaw[];
+
+export interface GetTankHistoriesOptions extends GetHistoriesOptions {
   tankId?: number;
 }
 
 export const getTankHistoriesDefaultOptions: GetTankHistoriesOptions = {
-  start: -Infinity,
-  end: Infinity,
-  includeLatestHistories: false,
-  includePreviousHistories: false,
+  ...getHistoriesDefaultOptions,
+  tankId: undefined,
 };
 
 export default async function getTankHistories(
@@ -47,7 +40,16 @@ export default async function getTankHistories(
   const tankHistoriesResponse = await fetch(
     `https://www.blitzstars.com/api/tankhistories/for/${id}/`,
   );
-  const tankHistories = (await tankHistoriesResponse.json()) as TankHistories;
+  const tankHistories = (
+    (await tankHistoriesResponse.json()) as TankHistoriesRaw
+  ).map(
+    (history) =>
+      ({
+        all: history.all,
+        last_battle_time: history.last_battle_time,
+        tank_id: history.tank_id,
+      } satisfies TankHistory),
+  );
   const compliantTanks: number[] = [];
   const lastBattles: Record<number, number> = {};
   const lastNonCompliantIndex: Record<number, number> = {};
@@ -96,15 +98,16 @@ export default async function getTankHistories(
     compliantTanks.forEach((tankId) => {
       if (tankId in lastNonCompliantIndex) {
         previousNodes.push(
-          tankHistories[lastNonCompliantIndex[tankId]] ?? {
-            ...emptyTankHistory,
-            account_id: id,
-            tank_id: tankId,
-          },
+          tankHistories[lastNonCompliantIndex[tankId]] ??
+            ({
+              all: emptyAllStats,
+              last_battle_time: -Infinity,
+              tank_id: tankId,
+            } satisfies TankHistory),
         );
       }
     });
   }
 
-  return [...previousNodes, ...filtered, ...latestNodes];
+  return [...latestNodes, ...filtered, ...previousNodes] satisfies Histories;
 }

src/core/blitzstars/getTankStatsOverTime.ts

@@ -1,8 +1,8 @@
 import { BlitzServer } from '../../constants/servers.js';
 import { AllStats } from '../../types/accountInfo.js';
 import getTankHistories, {
-  TankHistories,
-  TankHistory,
+  TankHistoriesRaw,
+  TankHistoryRaw,
 } from './getTankHistories.js';
 
 export const emptyAllStats: AllStats = {
@@ -25,7 +25,7 @@ export const emptyAllStats: AllStats = {
   wins: 0,
 };
 
-export const emptyTankHistoryNode: TankHistory = {
+export const emptyTankHistoryNode: TankHistoryRaw = {
   account_id: 0,
   battle_life_time: 0,
   last_battle_time: 0,
@@ -45,7 +45,7 @@ export default async function getTankStatsOverTime(
   });
 
   // sort them even though most won't be used
-  const tankSortedHistory: Record<number, TankHistories> = {};
+  const tankSortedHistory: Record<number, TankHistoriesRaw> = {};
   const tankIds: number[] = [];
   history.forEach((node) => {
     if (!tankSortedHistory[node.tank_id]) {

src/core/options/addPeriodSubCommands.ts

@@ -11,7 +11,7 @@ export const RELATIVE_PERIOD_NAMES: Record<Period, string> = {
   '30': '30 days ago',
   '60': '60 days ago',
   '90': '90 days ago',
-  career: 'Start of career',
+  career: 'Extent of data',
   custom: 'Custom period',
 };