feat: search page

packages/website/src/stores/app/index.ts

@@ -1,23 +1,14 @@
-import lodash from 'lodash-es';
 import { create } from 'zustand';
-import { persist } from 'zustand/middleware';
-import { createContextualSafeStore } from '../../core/zustand/createContextualSafeStore';
+import { createContextualStore } from '../../core/zustand/createContextualStore';
 
-export interface App {
+interface AppStore {
   developerMode: boolean;
   policiesAgreementIndex: number;
 }
 
-export const { Provider, use, useMutation, useStore, useDeferred } =
-  createContextualSafeStore(() =>
-    create<App>()(
-      persist(
-        (set) => ({
-          developerMode: false,
-          policiesAgreementIndex: -1,
-          logins: {},
-        }),
-        { name: 'app', merge: (a, b) => lodash.merge(b, a) },
-      ),
-    ),
-  );
+export const App = createContextualStore(() =>
+  create<AppStore>()(() => ({
+    developerMode: false,
+    policiesAgreementIndex: 0,
+  })),
+);

packages/website/src/stores/compareEphemeral.ts

@@ -1,5 +1,6 @@
 import { create } from 'zustand';
-import { DuelMember } from './duel';
+import { createContextualStore } from '../core/zustand/createContextualStore';
+import type { DuelMember } from './duel';
 
 export interface CompareMember extends DuelMember {
   key: string;
@@ -14,10 +15,10 @@ export interface CompareEphemeral {
   };
 }
 
-export const { Provider, use, useMutation, useStore } =
-  createContextualSafeStore(() =>
+export const { Provider, use, useMutation, useStore } = createContextualStore(
+  () =>
     create<CompareEphemeral>()(() => ({
       crewSkills: {},
       members: [],
     })),
-  );
+);

packages/website/src/stores/comparePersistent.ts

@@ -1,15 +1,15 @@
 import lodash from 'lodash-es';
 import { create } from 'zustand';
 import { persist, subscribeWithSelector } from 'zustand/middleware';
-import { createContextualSafeStore } from '../core/zustand/createContextualSafeStore';
+import { createContextualStore } from '../core/zustand/createContextualStore';
 
 export type DeltaMode = 'none' | 'percentage' | 'absolute';
 export interface ComparePersistent {
   deltaMode: DeltaMode;
 }
 
-export const { Provider, use, useMutation, useStore } =
-  createContextualSafeStore(() =>
+export const { Provider, use, useMutation, useStore } = createContextualStore(
+  () =>
     create<ComparePersistent>()(
       persist(
         subscribeWithSelector<ComparePersistent>(() => ({
@@ -21,4 +21,4 @@ export const { Provider, use, useMutation, useStore } =
         },
       ),
     ),
-  );
+);

packages/website/src/stores/duel/index.ts

@@ -10,7 +10,7 @@ import {
 import { create } from 'zustand';
 import { subscribeWithSelector } from 'zustand/middleware';
 import { tankToDuelMember } from '../../core/blitzkit/tankToDuelMember';
-import { createContextualSafeStore } from '../../core/zustand/createContextualSafeStore';
+import { createContextualStore } from '../../core/zustand/createContextualStore';
 
 type EquipmentMatrixItem = -1 | 0 | 1;
 type EquipmentMatrixRow = [
@@ -41,27 +41,26 @@ export interface DuelMember {
   cooldownBooster: number;
 }
 
-export interface Duel {
+export interface DuelStore {
   protagonist: DuelMember;
   antagonist: DuelMember;
 }
 
-export const { Provider, use, useMutation, useStore } =
-  createContextualSafeStore(
-    ({
-      tank,
-      provisionDefinitions,
-    }: {
-      tank: TankDefinition;
-      provisionDefinitions: ProvisionDefinitions;
-    }) => {
-      const protagonist = tankToDuelMember(tank, provisionDefinitions);
+export const Duel = createContextualStore(
+  ({
+    tank,
+    provisionDefinitions,
+  }: {
+    tank: TankDefinition;
+    provisionDefinitions: ProvisionDefinitions;
+  }) => {
+    const protagonist = tankToDuelMember(tank, provisionDefinitions);
 
-      return create<Duel>()(
-        subscribeWithSelector<Duel>(() => ({
-          protagonist,
-          antagonist: protagonist,
-        })),
-      );
-    },
-  );
+    return create<DuelStore>()(
+      subscribeWithSelector<DuelStore>(() => ({
+        protagonist,
+        antagonist: protagonist,
+      })),
+    );
+  },
+);

packages/website/src/stores/embedState/index.ts

@@ -1,6 +1,6 @@
 import * as radixColors from '@radix-ui/colors';
 import { create } from 'zustand';
-import { createContextualSafeStore } from '../../core/zustand/createContextualSafeStore';
+import { createContextualStore } from '../../core/zustand/createContextualStore';
 import {
   type EmbedConfigItemType,
   EmbedItemType,
@@ -104,7 +104,6 @@ export type EmbedConfigItem = (
 
 export type EmbedState = Record<string, EmbedConfigItem['default']>;
 
-export const { Provider, use, useMutation, useStore } =
-  createContextualSafeStore((init: EmbedState) =>
-    create<EmbedState>()(() => init),
-  );
+export const { Provider, use, useMutation, useStore } = createContextualStore(
+  (init: EmbedState) => create<EmbedState>()(() => init),
+);

packages/website/src/stores/session.ts

@@ -2,7 +2,7 @@ import { IndividualTankStats, Region, Stat } from '@blitzkit/core';
 import lodash from 'lodash-es';
 import { create } from 'zustand';
 import { persist } from 'zustand/middleware';
-import { createContextualSafeStore } from '../core/zustand/createContextualSafeStore';
+import { createContextualStore } from '../core/zustand/createContextualStore';
 
 interface SessionBase {
   columns: Stat[];
@@ -24,8 +24,8 @@ interface SessionNotTracking extends SessionBase {
 
 type Session = SessionTracking | SessionNotTracking;
 
-export const { Provider, use, useMutation, useStore } =
-  createContextualSafeStore(() =>
+export const { Provider, use, useMutation, useStore } = createContextualStore(
+  () =>
     create<Session>()(
       persist(
         (set) => ({
@@ -35,4 +35,4 @@ export const { Provider, use, useMutation, useStore } =
         { name: 'session-2', merge: (a, b) => lodash.merge(b, a) },
       ),
     ),
-  );
+);

packages/website/src/stores/tankPerformancePersistent/index.ts

@@ -1,15 +1,15 @@
 import lodash from 'lodash-es';
 import { create } from 'zustand';
 import { persist, subscribeWithSelector } from 'zustand/middleware';
-import { createContextualSafeStore } from '../../core/zustand/createContextualSafeStore';
+import { createContextualStore } from '../../core/zustand/createContextualStore';
 import { PlayerCountPeriod } from './constants';
 
 export interface TankPerformancePersistent {
   playerCountPeriod: PlayerCountPeriod;
 }
 
-export const { Provider, use, useMutation, useStore } =
-  createContextualSafeStore(() =>
+export const { Provider, use, useMutation, useStore } = createContextualStore(
+  () =>
     create<TankPerformancePersistent>()(
       persist(
         subscribeWithSelector<TankPerformancePersistent>(() => ({
@@ -18,4 +18,4 @@ export const { Provider, use, useMutation, useStore } =
         { name: 'tank-performance', merge: (a, b) => lodash.merge(b, a) },
       ),
     ),
-  );
+);

packages/website/src/stores/tankPerformanceSort/index.ts

@@ -1,5 +1,5 @@
 import { create } from 'zustand';
-import { createContextualSafeStore } from '../../core/zustand/createContextualSafeStore';
+import { createContextualStore } from '../../core/zustand/createContextualStore';
 import { TankPerformanceSortTypeNames } from './constants';
 
 export type TankPerformanceSortType = keyof typeof TankPerformanceSortTypeNames;
@@ -9,10 +9,10 @@ export interface TankPerformanceSort {
   direction: -1 | 1;
 }
 
-export const { Provider, use, useMutation, useStore } =
-  createContextualSafeStore(() =>
+export const { Provider, use, useMutation, useStore } = createContextualStore(
+  () =>
     create<TankPerformanceSort>()(() => ({
       type: 'winrate',
       direction: -1,
     })),
-  );
+);

packages/website/src/stores/tankopediaEphemeral.ts

@@ -1,34 +1,11 @@
-import { ModelDefinition } from '@blitzkit/core';
+import type { ModelDefinition } from '@blitzkit/core';
 import { Vector3 } from 'three';
 import { create } from 'zustand';
 import { subscribeWithSelector } from 'zustand/middleware';
-import { XP_MULTIPLIERS } from '../app/tools/tankopedia/[id]/components/Model/TechTreeSection';
 import { ArmorType } from '../components/Armor/components/SpacedArmorScene';
-import { ExternalModuleVariant } from '../components/Armor/components/SpacedArmorSceneComponent';
-import { createContextualSafeStore } from '../core/zustand/createContextualSafeStore';
-
-interface TankopediaEphemeral {
-  shot?: Shot;
-  skills: Record<string, number>;
-  controlsEnabled: boolean;
-  model: ModelDefinition;
-  editStatic: boolean;
-  highlightArmor?: {
-    editingPlate: boolean;
-    name: string;
-    point: Vector3;
-    thickness: number;
-    color: string;
-  } & (
-    | {
-        type: ArmorType.Primary | ArmorType.Spaced;
-        thicknessAngled: number;
-        angle: number;
-      }
-    | { type: ArmorType.External }
-  );
-  xpMultiplier: (typeof XP_MULTIPLIERS)[number];
-}
+import type { ExternalModuleVariant } from '../components/Armor/components/SpacedArmorSceneComponent';
+import type { XP_MULTIPLIERS } from '../components/Tankopedia/TechTreeSection';
+import { createContextualStore } from '../core/zustand/createContextualStore';
 
 export interface ShotLayerBase {
   index: number;
@@ -89,8 +66,8 @@ export type ArmorPiercingLayer =
       gap: number;
     };
 
-export const { Provider, use, useMutation, useStore } =
-  createContextualSafeStore((model: ModelDefinition) =>
+export const TankopediaEphemeral = createContextualStore(
+  (model: ModelDefinition) =>
     create<TankopediaEphemeral>()(
       subscribeWithSelector<TankopediaEphemeral>(() => ({
         editStatic: false,
@@ -100,4 +77,27 @@ export const { Provider, use, useMutation, useStore } =
         xpMultiplier: 1,
       })),
     ),
+);
+
+interface TankopediaEphemeral {
+  shot?: Shot;
+  skills: Record<string, number>;
+  controlsEnabled: boolean;
+  model: ModelDefinition;
+  editStatic: boolean;
+  highlightArmor?: {
+    editingPlate: boolean;
+    name: string;
+    point: Vector3;
+    thickness: number;
+    color: string;
+  } & (
+    | {
+        type: ArmorType.Primary | ArmorType.Spaced;
+        thicknessAngled: number;
+        angle: number;
+      }
+    | { type: ArmorType.External }
   );
+  xpMultiplier: (typeof XP_MULTIPLIERS)[number];
+}

packages/website/src/stores/tankopediaPersistent/index.ts

@@ -1,76 +1,53 @@
-import type { TankClass, Tier, TreeType } from '@blitzkit/core';
-import lodash from 'lodash-es';
+import * as lodash from 'lodash-es';
 import { create } from 'zustand';
-import { persist, subscribeWithSelector } from 'zustand/middleware';
+import { persist } from 'zustand/middleware';
 import { ENVIRONMENTS } from '../../constants/lightingEnvironments';
-import { createContextualSafeStore } from '../../core/zustand/createContextualSafeStore';
+import { createContextualStore } from '../../core/zustand/createContextualStore';
 import { SORT_NAMES, TankopediaDisplay } from './constants';
 
 export type TankopediaSortBy = keyof typeof SORT_NAMES;
 export type TankopediaSortDirection = 'ascending' | 'descending';
 export type TankopediaTestTankDisplay = 'include' | 'exclude' | 'only';
-export interface TankopediaPersistent {
-  model: {
-    visual: {
-      wireframe: boolean;
-      opaque: boolean;
-      environment: (typeof ENVIRONMENTS)[number];
-      showGrid: boolean;
-      greenPenetration: boolean;
-      showEnvironment: boolean;
-      showSpacedArmor: boolean;
-      showExternalModules: boolean;
-      showPrimaryArmor: boolean;
-    };
-  };
+
+export interface TankopediaPersistentStore {
+  wireframe: boolean;
+  opaque: boolean;
+  environment: (typeof ENVIRONMENTS)[number];
+  showGrid: boolean;
+  greenPenetration: boolean;
+  showEnvironment: boolean;
+  showSpacedArmor: boolean;
+  showExternalModules: boolean;
+  showPrimaryArmor: boolean;
+
   sort: {
     by: TankopediaSortBy;
     direction: TankopediaSortDirection;
   };
-  filters: {
-    tiers: Tier[];
-    types: TankClass[];
-    treeTypes: TreeType[];
-    nations: string[];
-    test: TankopediaTestTankDisplay;
-    page: number;
-  };
+
   display: TankopediaDisplay;
 }
 
-export const { Provider, use, useMutation, useStore } =
-  createContextualSafeStore(() =>
-    create<TankopediaPersistent>()(
-      persist(
-        subscribeWithSelector<TankopediaPersistent>(() => ({
-          model: {
-            visual: {
-              showSpacedArmor: true,
-              showExternalModules: true,
-              showPrimaryArmor: true,
-              wireframe: false,
-              opaque: false,
-              environment: ENVIRONMENTS[0],
-              showGrid: true,
-              greenPenetration: false,
-              showEnvironment: false,
-            },
-          },
-          sort: {
-            by: 'meta.none',
-            direction: 'descending',
-          },
-          filters: {
-            tiers: [],
-            types: [],
-            treeTypes: [],
-            nations: [],
-            test: 'include',
-            page: 0,
-          },
-          display: TankopediaDisplay.Model,
-        })),
-        { name: 'tankopedia', merge: (a, b) => lodash.merge(b, a) },
-      ),
+export const TankopediaPersistent = createContextualStore(() =>
+  create<TankopediaPersistentStore>()(
+    persist(
+      (set) => ({
+        wireframe: false,
+        opaque: false,
+        environment: ENVIRONMENTS[0],
+        showGrid: true,
+        greenPenetration: true,
+        showEnvironment: true,
+        showSpacedArmor: true,
+        showExternalModules: true,
+        showPrimaryArmor: true,
+        sort: {
+          by: 'meta.none',
+          direction: 'ascending',
+        },
+        display: TankopediaDisplay.Model,
+      }),
+      { name: 'tankopedia', merge: (a, b) => lodash.merge(b, a) },
     ),
-  );
+  ),
+);