fix: update all

packages/website/src/components/Performance/TankRow.tsx

@@ -20,7 +20,7 @@ export const TankRow = memo<TankRowProps>(
     const averages = averageDefinitions.averages[tank.id];
     const ratio = useAveragesExclusionRatio();
     const playerCountPeriod = Performance.use(
-      (state) => state.playerCountPeriod
+      (state) => state.playerCountPeriod,
     );
     const { locale } = useLocale();
 
@@ -29,107 +29,109 @@ export const TankRow = memo<TankRowProps>(
         <TankRowHeaderCell tank={tank} />
 
         <CompareCell
-          value={averages.mu.wins / averages.mu.battles}
+          value={averages.mu!.wins / averages.mu!.battles}
           truth={average.winrate}
           align="center"
         >
-          {((averages.mu.wins / averages.mu.battles) * 100).toFixed(1)}%
+          {((averages.mu!.wins / averages.mu!.battles) * 100).toFixed(1)}%
         </CompareCell>
         <Table.Cell align="center">
           {formatCompact(
             locale,
-            Math.round(ratio * averages.samples[playerCountPeriod])
+            Math.round(ratio * averages.samples![playerCountPeriod]),
           )}
         </Table.Cell>
         <CompareCell
-          value={averages.mu.damage_dealt / averages.mu.battles}
+          value={averages.mu!.damage_dealt / averages.mu!.battles}
           truth={average.damage}
           align="center"
         >
           {Math.round(
-            averages.mu.damage_dealt / averages.mu.battles
+            averages.mu!.damage_dealt / averages.mu!.battles,
           ).toLocaleString(locale)}
         </CompareCell>
         <CompareCell
-          value={averages.mu.survived_battles / averages.mu.battles}
+          value={averages.mu!.survived_battles / averages.mu!.battles}
           truth={average.survival}
           align="center"
         >
           {Math.round(
-            (averages.mu.survived_battles / averages.mu.battles) * 100
+            (averages.mu!.survived_battles / averages.mu!.battles) * 100,
           )}
           %
         </CompareCell>
         <CompareCell
-          value={averages.mu.xp / averages.mu.battles}
+          value={averages.mu!.xp / averages.mu!.battles}
           truth={average.xp}
           align="center"
         >
-          {Math.round(averages.mu.xp / averages.mu.battles).toLocaleString(
-            locale
+          {Math.round(averages.mu!.xp / averages.mu!.battles).toLocaleString(
+            locale,
           )}
         </CompareCell>
         <CompareCell
-          value={averages.mu.frags / averages.mu.battles}
+          value={averages.mu!.frags / averages.mu!.battles}
           truth={average.kills}
           align="center"
         >
-          {(averages.mu.frags / averages.mu.battles).toFixed(2)}
+          {(averages.mu!.frags / averages.mu!.battles).toFixed(2)}
         </CompareCell>
         <CompareCell
-          value={averages.mu.spotted / averages.mu.battles}
+          value={averages.mu!.spotted / averages.mu!.battles}
           truth={average.spots}
           align="center"
         >
-          {(averages.mu.spotted / averages.mu.battles).toFixed(2)}
+          {(averages.mu!.spotted / averages.mu!.battles).toFixed(2)}
         </CompareCell>
         <CompareCell
-          value={averages.mu.hits / averages.mu.shots}
+          value={averages.mu!.hits / averages.mu!.shots}
           truth={average.accuracy}
           align="center"
         >
-          {Math.round((averages.mu.hits / averages.mu.shots) * 100)}%
+          {Math.round((averages.mu!.hits / averages.mu!.shots) * 100)}%
         </CompareCell>
         <CompareCell
-          value={averages.mu.shots / averages.mu.battles}
+          value={averages.mu!.shots / averages.mu!.battles}
           truth={average.shots}
           align="center"
         >
-          {(averages.mu.shots / averages.mu.battles).toFixed(1)}
+          {(averages.mu!.shots / averages.mu!.battles).toFixed(1)}
         </CompareCell>
         <CompareCell
-          value={averages.mu.hits / averages.mu.battles}
+          value={averages.mu!.hits / averages.mu!.battles}
           truth={average.hits}
           align="center"
         >
-          {(averages.mu.hits / averages.mu.battles).toFixed(1)}
+          {(averages.mu!.hits / averages.mu!.battles).toFixed(1)}
         </CompareCell>
         <CompareCell
-          value={averages.mu.damage_dealt / averages.mu.damage_received}
+          value={averages.mu!.damage_dealt / averages.mu!.damage_received}
           truth={average.damageRatio}
           align="center"
         >
-          {(averages.mu.damage_dealt / averages.mu.damage_received).toFixed(2)}
+          {(averages.mu!.damage_dealt / averages.mu!.damage_received).toFixed(
+            2,
+          )}
         </CompareCell>
         <CompareCell
-          value={averages.mu.damage_received / averages.mu.battles}
+          value={averages.mu!.damage_received / averages.mu!.battles}
           truth={average.damageReceived}
           direction={CompareCellDirection.LOWER_IS_BETTER}
           align="center"
         >
           {Math.round(
-            averages.mu.damage_received / averages.mu.battles
+            averages.mu!.damage_received / averages.mu!.battles,
           ).toLocaleString(locale)}
         </CompareCell>
         <CompareCell
-          value={averages.mu.capture_points / averages.mu.battles}
+          value={averages.mu!.capture_points / averages.mu!.battles}
           truth={average.capturePoints}
           align="center"
         >
-          {(averages.mu.capture_points / averages.mu.battles).toFixed(2)}
+          {(averages.mu!.capture_points / averages.mu!.battles).toFixed(2)}
         </CompareCell>
       </Table.Row>
     );
   },
-  (prev, next) => prev.tank.id === next.tank.id
+  (prev, next) => prev.tank.id === next.tank.id,
 );

packages/website/src/components/Performance/Tanks.tsx

@@ -49,10 +49,10 @@ export function Tanks({ skeleton }: MaybeSkeletonComponentProps) {
   const filteredTanks = usePromise(
     () =>
       filterTanks(filters, tankList).then((tanks) =>
-        tanks.filter(({ id }) => id in averageDefinitions.averages)
+        tanks.filter(({ id }) => id in averageDefinitions.averages),
       ),
     // react-promise-suspense has awful type annotations
-    [filters] as any
+    [filters] as any,
   );
   const tanksMapped = useMemo(
     () =>
@@ -60,7 +60,7 @@ export function Tanks({ skeleton }: MaybeSkeletonComponentProps) {
         id,
         ...averageDefinitions.averages[id],
       })),
-    [filters]
+    [filters],
   );
   const tanksSorted = useMemo(() => {
     const { playerCountPeriod } = Performance.state;
@@ -69,83 +69,85 @@ export function Tanks({ skeleton }: MaybeSkeletonComponentProps) {
       case "accuracy":
         return tanksMapped.sort(
           (a, b) =>
-            sort.direction * (a.mu.hits / a.mu.shots - b.mu.hits / b.mu.shots)
+            sort.direction *
+            (a.mu!.hits / a.mu!.shots - b.mu!.hits / b.mu!.shots),
         );
       case "capture_points":
         return tanksMapped.sort(
           (a, b) =>
             sort.direction *
-            (a.mu.capture_points / a.mu.battles -
-              b.mu.capture_points / b.mu.battles)
+            (a.mu!.capture_points / a.mu!.battles -
+              b.mu!.capture_points / b.mu!.battles),
         );
       case "damage":
         return tanksMapped.sort(
           (a, b) =>
             sort.direction *
-            (a.mu.damage_dealt / a.mu.battles -
-              b.mu.damage_dealt / b.mu.battles)
+            (a.mu!.damage_dealt / a.mu!.battles -
+              b.mu!.damage_dealt / b.mu!.battles),
         );
       case "damage_ratio":
         return tanksMapped.sort(
           (a, b) =>
             sort.direction *
-            (a.mu.damage_dealt / a.mu.damage_received -
-              b.mu.damage_dealt / b.mu.damage_received)
+            (a.mu!.damage_dealt / a.mu!.damage_received -
+              b.mu!.damage_dealt / b.mu!.damage_received),
         );
       case "damage_taken":
         return tanksMapped.sort(
           (a, b) =>
             sort.direction *
-            (a.mu.damage_received / a.mu.battles -
-              b.mu.damage_received / b.mu.battles)
+            (a.mu!.damage_received / a.mu!.battles -
+              b.mu!.damage_received / b.mu!.battles),
         );
       case "hits":
         return tanksMapped.sort(
           (a, b) =>
             sort.direction *
-            (a.mu.hits / a.mu.battles - b.mu.hits / b.mu.battles)
+            (a.mu!.hits / a.mu!.battles - b.mu!.hits / b.mu!.battles),
         );
       case "kills":
         return tanksMapped.sort(
           (a, b) =>
             sort.direction *
-            (a.mu.frags / a.mu.battles - b.mu.frags / b.mu.battles)
+            (a.mu!.frags / a.mu!.battles - b.mu!.frags / b.mu!.battles),
         );
       case "shots":
         return tanksMapped.sort(
           (a, b) =>
             sort.direction *
-            (a.mu.shots / a.mu.battles - b.mu.shots / b.mu.battles)
+            (a.mu!.shots / a.mu!.battles - b.mu!.shots / b.mu!.battles),
         );
       case "players":
         return tanksMapped.sort(
           (a, b) =>
             sort.direction *
-            (a.samples[playerCountPeriod] - b.samples[playerCountPeriod])
+            (a.samples![playerCountPeriod] - b.samples![playerCountPeriod]),
         );
       case "spots":
         return tanksMapped.sort(
           (a, b) =>
             sort.direction *
-            (a.mu.spotted / a.mu.battles - b.mu.spotted / b.mu.battles)
+            (a.mu!.spotted / a.mu!.battles - b.mu!.spotted / b.mu!.battles),
         );
       case "survival":
         return tanksMapped.sort(
           (a, b) =>
             sort.direction *
-            (a.mu.survived_battles / a.mu.battles -
-              b.mu.survived_battles / b.mu.battles)
+            (a.mu!.survived_battles / a.mu!.battles -
+              b.mu!.survived_battles / b.mu!.battles),
         );
       case "winrate":
         return tanksMapped.sort(
           (a, b) =>
             sort.direction *
-            (a.mu.wins / a.mu.battles - b.mu.wins / b.mu.battles)
+            (a.mu!.wins / a.mu!.battles - b.mu!.wins / b.mu!.battles),
         );
       case "xp":
         return tanksMapped.sort(
           (a, b) =>
-            sort.direction * (a.mu.xp / a.mu.battles - b.mu.xp / b.mu.battles)
+            sort.direction *
+            (a.mu!.xp / a.mu!.battles - b.mu!.xp / b.mu!.battles),
         );
     }
   }, [filters, sort]);
@@ -161,11 +163,11 @@ export function Tanks({ skeleton }: MaybeSkeletonComponentProps) {
   const sum = useCallback(
     (slice: (tank: BlitzkitStats) => number) => {
       return tanksSorted.reduce(
-        (acc, tank) => acc + tank.samples[playerCountPeriod] * slice(tank.mu),
-        0
+        (acc, tank) => acc + tank.samples![playerCountPeriod] * slice(tank.mu!),
+        0,
       );
     },
-    [tanksSorted]
+    [tanksSorted],
   );
 
   const battles = sum(({ battles }) => battles);
@@ -209,7 +211,7 @@ export function Tanks({ skeleton }: MaybeSkeletonComponentProps) {
         <Table.Cell align="center">
           {formatCompact(
             locale,
-            ratio * averageDefinitions.samples[playerCountPeriod]
+            ratio * averageDefinitions.samples![playerCountPeriod],
           )}
         </Table.Cell>
         <Table.Cell align="center">
@@ -255,12 +257,12 @@ export function Tanks({ skeleton }: MaybeSkeletonComponentProps) {
               key={index}
               onIntersection={() => {
                 setLoadedRows((state) =>
-                  Math.min(state + 2, tanksSorted.length)
+                  Math.min(state + 2, tanksSorted.length),
                 );
               }}
             />
           );
-        }
+        },
       )}
     </Table.Body>
   );