refactor: reformat code and introduce IGameContextExport

- Reformat `src/core/game.ts` and sample types to use 2-space
  indentation
- Add `IGameContextExport` to hide internal test properties
- Update `CombatGameContext` to use the exported context type

src/core/game.ts

@@ -1,35 +1,46 @@
-import {MutableSignal, mutableSignal} from "@/utils/mutable-signal";
+import { MutableSignal, mutableSignal } from "@/utils/mutable-signal";
 import {
   Command,
-    CommandRegistry, CommandResult,
+  CommandRegistry,
+  CommandResult,
   CommandRunnerContextExport,
   CommandSchema,
   createCommandRegistry,
-    createCommandRunnerContext, parseCommandSchema,
+  createCommandRunnerContext,
+  parseCommandSchema,
 } from "@/utils/command";
-import {PromptValidator} from "@/utils/command/command-runner";
+import { PromptValidator } from "@/utils/command/command-runner";
-import {Mulberry32RNG, ReadonlyRNG, RNG} from "@/utils/rng";
+import { Mulberry32RNG, ReadonlyRNG, RNG } from "@/utils/rng";
 
-export interface IGameContext<TState extends Record<string, unknown> = {} > {
+export interface IGameContext<TState extends Record<string, unknown> = {}> {
   get value(): TState;
   get rng(): ReadonlyRNG;
   produce(fn: (draft: TState) => void): void;
   produceAsync(fn: (draft: TState) => void): Promise<void>;
   run<T>(input: string): Promise<CommandResult<T>>;
   runParsed<T>(command: Command): Promise<CommandResult<T>>;
-    prompt: <TResult,TArgs extends any[]=any[]>(def: PromptDef<TArgs>, validator: PromptValidator<TResult,TArgs>, currentPlayer?: string | null) => Promise<TResult>;
+  prompt: <TResult, TArgs extends any[] = any[]>(
+    def: PromptDef<TArgs>,
+    validator: PromptValidator<TResult, TArgs>,
+    currentPlayer?: string | null,
+  ) => Promise<TResult>;
 
   // test only
   _state: MutableSignal<TState>;
   _commands: CommandRunnerContextExport<IGameContext<TState>>;
   _rng: RNG;
 }
+export type IGameContextExport<TState extends Record<string, unknown> = {}> =
+  Omit<IGameContext<TState>, "_state" | "_commands" | "_rng">;
 
-export function createGameContext<TState extends Record<string, unknown> = {} >(
+export function createGameContext<TState extends Record<string, unknown> = {}>(
   commandRegistry: CommandRegistry<IGameContext<TState>>,
-    initialState?: TState | (() => TState)
+  initialState?: TState | (() => TState),
 ): IGameContext<TState> {
-    const stateValue = typeof initialState === 'function' ? initialState() : initialState ?? {} as TState;
+  const stateValue =
+    typeof initialState === "function"
+      ? initialState()
+      : (initialState ?? ({} as TState));
   const state = mutableSignal(stateValue);
   let commands: CommandRunnerContextExport<IGameContext<TState>> = null as any;
 
@@ -53,7 +64,12 @@ export function createGameContext<TState extends Record<string, unknown> = {} >(
       return commands.runParsed<T>(command);
     },
     prompt(def, validator, currentPlayer) {
-            return commands.prompt(def.schema, validator, def.hintText, currentPlayer);
+      return commands.prompt(
+        def.schema,
+        validator,
+        def.hintText,
+        currentPlayer,
+      );
     },
 
     _state: state,
@@ -61,20 +77,28 @@ export function createGameContext<TState extends Record<string, unknown> = {} >(
     _rng: new Mulberry32RNG(),
   };
 
-    context._commands = commands = createCommandRunnerContext(commandRegistry, context);
+  context._commands = commands = createCommandRunnerContext(
+    commandRegistry,
+    context,
+  );
 
   return context;
 }
 
-export type PromptDef<TArgs extends any[]=any[]> = {
+export type PromptDef<TArgs extends any[] = any[]> = {
-    schema: CommandSchema,
+  schema: CommandSchema;
+  hintText?: string;
+};
+export function createPromptDef<TArgs extends any[] = any[]>(
+  schema: CommandSchema | string,
   hintText?: string,
-}
+): PromptDef<TArgs> {
-export function createPromptDef<TArgs extends any[]=any[]>(schema: CommandSchema | string, hintText?: string): PromptDef<TArgs> {
+  schema = typeof schema === "string" ? parseCommandSchema(schema) : schema;
-    schema = typeof schema === 'string' ? parseCommandSchema(schema) : schema;
   return { schema, hintText };
 }
 
-export function createGameCommandRegistry<TState extends Record<string, unknown> = {} >() {
+export function createGameCommandRegistry<
+  TState extends Record<string, unknown> = {},
+>() {
   return createCommandRegistry<IGameContext<TState>>();
 }

src/samples/slay-the-spire-like/system/combat/types.ts

@@ -1,10 +1,13 @@
 import type { PlayerDeck } from "../deck/types";
-import {EnemyData, IntentData} from "@/samples/slay-the-spire-like/system/types";
+import {
-import {EffectData} from "@/samples/slay-the-spire-like/system/types";
+  EnemyData,
-import {GridInventory} from "@/samples/slay-the-spire-like/system/grid-inventory";
+  IntentData,
-import {GameItemMeta} from "@/samples/slay-the-spire-like/system/progress";
+} from "@/samples/slay-the-spire-like/system/types";
+import { EffectData } from "@/samples/slay-the-spire-like/system/types";
+import { GridInventory } from "@/samples/slay-the-spire-like/system/grid-inventory";
+import { GameItemMeta } from "@/samples/slay-the-spire-like/system/progress";
 
-export type EffectTable = Record<string, {data: EffectData, stacks: number}>;
+export type EffectTable = Record<string, { data: EffectData; stacks: number }>;
 
 export type CombatEntity = {
   id: string; // player is just "player"
@@ -19,7 +22,7 @@ export type PlayerEntity = CombatEntity & {
   maxEnergy: number;
   deck: PlayerDeck;
   itemEffects: Record<string, EffectTable>;
-}
+};
 
 export type EnemyEntity = CombatEntity & {
   enemy: EnemyData;
@@ -30,13 +33,15 @@ export type EnemyEntity = CombatEntity & {
 export type CombatPhase = "playerTurn" | "enemyTurn" | "combatEnd";
 export type CombatResult = "victory" | "defeat";
 
-export type LootEntry = {
+export type LootEntry =
+  | {
       type: "gold";
       amount: number;
-} | {
+    }
-    type: "item",
+  | {
+      type: "item";
       itemId: string;
-};
+    };
 
 export type CombatState = {
   enemies: EnemyEntity[];
@@ -50,4 +55,5 @@ export type CombatState = {
   loot: LootEntry[];
 };
 
-export type CombatGameContext = import("@/core/game").IGameContext<CombatState>;
+export type CombatGameContext =
+  import("@/core/game").IGameContextExport<CombatState>;