board-game-engine 1.0.5 → 2.0.1

package/src/utils/{grid-contains-sequence.js → grid-contains-sequence.ts}

@@ -1,20 +1,37 @@
 // claude ai did most of this
 import _matches from "lodash/matches.js";
+import type { Condition } from "../types/bagel-types.js";
 import checkConditions from "./check-conditions.js";
 
+export type SequenceChunk = {
+  count?: number;
+  minCount?: number;
+  maxCount?: number;
+  conditions?: Condition[];
+};
+
+type GridEntity = { entities?: unknown[]; [k: string]: unknown };
+type GridSpace = { entities?: GridEntity[]; [k: string]: unknown };
+export type GridLike = {
+  attributes: { width: number; height: number };
+  entities?: GridSpace[];
+  areCoordinatesValid: (c: number[]) => boolean;
+  getSpace: (c: number[]) => unknown;
+};
+
 // We'll check reverse directions along each line
-const directions = [
+const directions: [number, number][] = [
   [1, 0],   // horizontal
   [0, 1],   // vertical
   [1, 1],   // diagonal down-right
   [-1, 1],  // diagonal down-left
 ];
 
-const sequenceCache = new WeakMap();
+const sequenceCache = new WeakMap<object, Map<string, { stateKey: string; result: unknown }>>();
 
-function getSequenceKey(sequencePattern, context) {
+function getSequenceKey (sequencePattern: unknown, context: Record<string, unknown>) {
   const contextKey = {
-    moveInstance: context.moveInstance?.id,
+    moveInstance: (context.moveInstance as { id?: unknown } | undefined)?.id,
     moveArguments: context.moveArguments,
     // Add other context properties that conditions might use
   };
@@ -22,17 +39,17 @@ function getSequenceKey(sequencePattern, context) {
 }
 
 // todo: use stable hash library that we're using for game rules hash
-function getGridStateKey(grid) {
+function getGridStateKey (grid: GridLike) {
   const spaces = grid.entities || [];
-  
-  return spaces.map(space => {
+
+  return spaces.map((space) => {
     const entities = space.entities || [];
-    if (entities.length === 0) return 'empty';
-    
-    return entities.map(entity => {
+    if (entities.length === 0) return "empty";
+
+    return entities.map((entity) => {
       const sortedKeys = Object.keys(entity).sort();
-      const stateObj = {};
-      sortedKeys.forEach(key => {
+      const stateObj: Record<string, unknown> = {};
+      sortedKeys.forEach((key) => {
         stateObj[key] = entity[key];
       });
       return JSON.stringify(stateObj);
@@ -40,8 +57,15 @@ function getGridStateKey(grid) {
   }).join(',');
 }
 
-function findSequencesInLine(bgioArguments, lineSpaces, sequencePattern, minSequenceLength, context, reverse = false) {
-  const matches = [];
+function findSequencesInLine (
+  bgioArguments: unknown,
+  lineSpaces: unknown[],
+  sequencePattern: SequenceChunk[],
+  minSequenceLength: number,
+  context: Record<string, unknown>,
+  reverse = false
+) {
+  const matches: unknown[][] = [];
   
   // Use original array or iterate in reverse without creating new array
   const length = lineSpaces.length;
@@ -68,9 +92,9 @@ function findSequencesInLine(bgioArguments, lineSpaces, sequencePattern, minSequ
   return matches;
 }
 
-function getLineStartingPoints(grid, dx, dy) {
+function getLineStartingPoints (grid: GridLike, dx: number, dy: number) {
   const { width, height } = grid.attributes;
-  const starts = [];
+  const starts: [number, number][] = [];
   
   if (dx === 1 && dy === 0) {
     // Horizontal: start at leftmost column
@@ -91,8 +115,8 @@ function getLineStartingPoints(grid, dx, dy) {
   return starts;
 }
 
-function getLineSpaces(grid, startX, startY, dx, dy) {
-  const spaces = [];
+function getLineSpaces (grid: GridLike, startX: number, startY: number, dx: number, dy: number) {
+  const spaces: unknown[] = [];
   let [x, y] = [startX, startY];
   
   while (grid.areCoordinatesValid([x, y])) {
@@ -103,9 +127,16 @@ function getLineSpaces(grid, startX, startY, dx, dy) {
   return spaces;
 }
 
-function tryMatchSequence(bgioArguments, lineSpaces, startIndex, sequencePattern, context, reverse = false) {
+function tryMatchSequence (
+  bgioArguments: unknown,
+  lineSpaces: unknown[],
+  startIndex: number,
+  sequencePattern: SequenceChunk[],
+  context: Record<string, unknown>,
+  reverse = false
+) {
   let spaceIndex = startIndex;
-  const matchedSpaces = [];
+  const matchedSpaces: unknown[] = [];
   const length = lineSpaces.length;
   
   for (const chunk of sequencePattern) {
@@ -122,7 +153,7 @@ function tryMatchSequence(bgioArguments, lineSpaces, startIndex, sequencePattern
     }
     
     let matchedCount = 0;
-    const chunkMatches = [];
+    const chunkMatches: unknown[] = [];
     
     // Greedy: try to match as many as possible up to max
     while (matchedCount < max && spaceIndex < length) {
@@ -152,15 +183,16 @@ function tryMatchSequence(bgioArguments, lineSpaces, startIndex, sequencePattern
   return matchedSpaces.length > 0 ? matchedSpaces : null;
 }
 
-function checkSpaceConditions(bgioArguments, space, conditions, chunkMatches = [], context) {
-  // Early exit if no conditions
-  if (!conditions || conditions.length === 0) {
-    return true;
-  }
-  
+function checkSpaceConditions (
+  bgioArguments: unknown,
+  space: unknown,
+  conditions: Condition[] | undefined,
+  chunkMatches: unknown[] = [],
+  context?: Record<string, unknown>
+) {
   return checkConditions(
     bgioArguments,
-    { conditions },
+    conditions,
     {
       target: space,
       targets: [space, ...chunkMatches] // for ContainsSame, other group conditions
@@ -169,7 +201,12 @@ function checkSpaceConditions(bgioArguments, space, conditions, chunkMatches = [
   ).conditionsAreMet
 }
 
-export default function gridContainsSequence(bgioArguments, grid, sequencePattern, context) {
+export default function gridContainsSequence (
+  bgioArguments: unknown,
+  grid: GridLike,
+  sequencePattern: SequenceChunk[],
+  context: Record<string, unknown>
+) {
   const cacheKey = getSequenceKey(sequencePattern, context);
   let gridCache = sequenceCache.get(grid);
   
@@ -185,10 +222,11 @@ export default function gridContainsSequence(bgioArguments, grid, sequencePatter
     return cacheEntry.result;
   }
   
-  const matches = [];
-  
-  const minSequenceLength = sequencePattern.reduce((sum, chunk) => 
-    sum + (chunk.minCount || chunk.count || 1), 0
+  const matches: unknown[][] = [];
+
+  const minSequenceLength = sequencePattern.reduce(
+    (sum: number, chunk: SequenceChunk) => sum + (chunk.minCount || chunk.count || 1),
+    0
   );
   
   // For each direction, scan each row/column/diagonal once

package/src/utils/json-transformer.ts

@@ -0,0 +1,17 @@
+type TransformRule = {
+  test: (val: unknown) => boolean;
+  replace: (val: unknown) => unknown;
+};
+
+/** Recurse and replace. Circular references not allowed. */
+export default function transformJSON (data: unknown, rules: TransformRule[]): unknown {
+  return JSON.parse(JSON.stringify(data), (_key, value: unknown) => {
+    let result = value;
+    for (const rule of rules) {
+      if (rule.test(result)) {
+        result = rule.replace(result);
+      }
+    }
+    return result;
+  });
+}

package/src/utils/prepare-payload.ts

@@ -0,0 +1,20 @@
+import { serialize } from "wackson";
+
+// todo: remember why reducing to id was preferred?
+export default function preparePayload (payload: unknown): unknown {
+  const p = payload as {
+    arguments?: Record<string, { abstract?: boolean; entityId?: unknown }>;
+  } | null | undefined;
+  if (p?.arguments) {
+    const payloadCopy = {
+      ...p,
+      arguments: Object.entries(p.arguments).reduce<Record<string, unknown>>((acc, [key, argument]) => ({
+        ...acc,
+        [key]: argument.abstract ? argument : argument.entityId,
+      }), {}),
+    };
+    return JSON.parse(serialize(payloadCopy, { deduplicateInstances: false }));
+  } else {
+    return payload;
+  }
+}

package/src/utils/resolve-entity.ts

@@ -0,0 +1,15 @@
+import isPlainObject from "lodash/isPlainObject.js";
+import { bankOf, type BgioResolveState } from "./bgio-resolve-types.js";
+
+const abstractTargetNames = ["state"];
+
+export default function resolveEntity (
+  bgioArguments: BgioResolveState,
+  target: unknown,
+  context: unknown,
+  targetName: string | undefined
+): unknown {
+  return !abstractTargetNames.includes(targetName ?? "") && isPlainObject(target)
+    ? bankOf(bgioArguments).find(bgioArguments, target, context)
+    : target;
+}

package/src/utils/resolve-expression.ts

@@ -0,0 +1,16 @@
+import { Parser } from "expr-eval";
+import resolveProperties from "./resolve-properties.js";
+import type { BgioResolveState } from "./bgio-resolve-types.js";
+
+const parser = new Parser();
+(parser.functions as Record<string, (...args: unknown[]) => unknown>).sum = (...args: unknown[]) =>
+  (args[0] as number[]).reduce((acc, val) => acc + val, 0);
+
+export default function resolveExpression (
+  bgioArguments: BgioResolveState,
+  rule: { expression: string; arguments?: unknown },
+  context: Record<string, unknown>
+): unknown {
+  const args = resolveProperties(bgioArguments, rule.arguments, context) as Record<string, unknown>;
+  return parser.evaluate(rule.expression, args);
+}

package/src/utils/resolve-properties.ts

@@ -0,0 +1,172 @@
+import isPlainObject from "lodash/isPlainObject.js";
+import pick from "lodash/pick.js";
+import get from "./get.js";
+import resolveExpression from "./resolve-expression.js";
+import resolveEntity from "./resolve-entity.js";
+import { bankOf, type BgioResolveState } from "./bgio-resolve-types.js";
+
+export type { BgioResolveState };
+
+const resolutionTerminators = [
+  "conditions",
+  "move",
+  "then",
+  "mapping",
+];
+
+export default function resolveProperties (
+  bgioArguments: BgioResolveState,
+  obj: unknown,
+  context: Record<string, unknown> = {},
+  key?: string
+): unknown {
+  if (!isPlainObject(obj) && !Array.isArray(obj)) {
+    return obj;
+  }
+
+  let resolvedProperties: Record<string, unknown> | unknown[] = Array.isArray(obj)
+    ? [...obj]
+    : { ...(obj as Record<string, unknown>) };
+
+  Object.entries(obj as Record<string, unknown>).forEach(([k, value]) => {
+    if (!resolutionTerminators.includes(k)) {
+      (resolvedProperties as Record<string, unknown>)[k] = resolveProperties(bgioArguments, value, context, k);
+    }
+  });
+
+  const resolved = resolveProperty(bgioArguments, resolvedProperties, context);
+
+  const resolveAsEntity = (resolved as { resolveAsEntity?: boolean } | null)?.resolveAsEntity
+    || key === "target"
+    || key === "targets";
+
+  return resolveAsEntity
+    ? resolveEntity(
+        bgioArguments,
+        resolved,
+        context,
+        key
+      )
+    : resolved;
+}
+
+function resolveProperty (
+  bgioArguments: BgioResolveState,
+  value: unknown,
+  context: Record<string, unknown>
+): unknown {
+  const v = value as Record<string, unknown> | null;
+  if (v?.type === "expression") {
+    const expr = v as { expression: string; arguments?: unknown };
+    return resolveExpression(
+      bgioArguments,
+      {
+        ...expr,
+        arguments: resolveProperties(bgioArguments, expr.arguments, context, "arguments"),
+      },
+      context
+    );
+  } else if (v?.type === "count") {
+    return bankOf(bgioArguments).findAll(
+      bgioArguments,
+      value,
+      context
+    ).length;
+  } else if (v?.type === "contextPath") {
+    return get(context, v.path as Parameters<typeof get>[1]);
+  } else if (v?.type === "ctxPath") {
+    return get(bgioArguments.ctx, v.path as Parameters<typeof get>[1]);
+  } else if (v?.type === "gamePath") {
+    return get(bgioArguments.G, v.path as Parameters<typeof get>[1]);
+  } else if (v?.type === "relativePath" || v?.type === "RelativePath") {
+    const target = resolveProperties(bgioArguments, v.target, context, "target");
+    return get((target as { attributes?: unknown })?.attributes, v.path as Parameters<typeof get>[1]) ?? null;
+  } else if (v?.type === "parent" || v?.type === "Parent") {
+    const originalTarget = v.target
+      ? resolveProperties(bgioArguments, v.target, context, "target")
+      : context.originalTarget;
+    return bankOf(bgioArguments).findParent(originalTarget) ?? null;
+  } else if (v?.type === "map") {
+    return getMappedTargets(
+      bgioArguments,
+      v.targets,
+      v.mapping,
+      context
+    ).map((mappedTarget) => mappedTarget.value);
+  } else if (v?.type === "mapMax") {
+    const mappedTargets = getMappedTargets(
+      bgioArguments,
+      v.targets,
+      v.mapping,
+      context
+    );
+    let maxValue: number | undefined;
+    const maxTargets: unknown[] = [];
+    for (let i = 0, len = mappedTargets.length; i < len; i++) {
+      const { target, value: val } = mappedTargets[i];
+      if (maxValue === undefined || (val as number) > maxValue) {
+        maxValue = val as number;
+        maxTargets.length = 0;
+        maxTargets.push(target);
+      } else if (val === maxValue) {
+        maxTargets.push(target);
+      }
+    }
+    return maxTargets;
+  } else if (v?.type === "pick" || v?.type === "Pick") {
+    const target = resolveProperties(bgioArguments, v.target, context, "target");
+    return pick(
+      resolveProperties(
+        bgioArguments,
+        (target as { attributes?: unknown })?.attributes,
+        context,
+        "attributes"
+      ) as object,
+      v.properties as string[]
+    );
+  } else if (v?.type === "coordinates" || v?.type === "Coordinates") {
+    const originalTarget = v.target
+      ? resolveProperties(bgioArguments, v.target, context, "target")
+      : context.originalTarget;
+    const parent = bankOf(bgioArguments).findParent(originalTarget) as { getCoordinates: (i: unknown) => unknown };
+    return parent.getCoordinates((originalTarget as { rule: { index: unknown } }).rule.index);
+  } else if (v?.type === "relativeCoordinates") {
+    const originalTarget = v.target
+      ? resolveProperties(bgioArguments, v.target, context, "target")
+      : context.originalTarget;
+    const parent = bankOf(bgioArguments).findParent(originalTarget) as {
+      getCoordinates: (i: unknown) => unknown;
+      getRelativeCoordinates: (a: unknown, b: unknown) => unknown;
+      spaces: unknown[];
+      getIndex: (c: unknown) => number;
+    };
+    const oldCoordinates =
+      parent.getCoordinates((originalTarget as { rule: { index: unknown } }).rule.index);
+    const newCoordinates =
+      parent.getRelativeCoordinates(
+        oldCoordinates,
+        resolveProperties(bgioArguments, v.location, context, "location")
+      );
+    return (newCoordinates && parent.spaces[parent.getIndex(newCoordinates)]) ?? null;
+  } else {
+    return value;
+  }
+}
+
+function getMappedTargets (
+  bgioArguments: BgioResolveState,
+  targetsRule: unknown,
+  mapping: unknown,
+  context: Record<string, unknown>
+): Array<{ target: unknown; value: unknown }> {
+  (targetsRule as { resolveAsEntity?: boolean }).resolveAsEntity = true;
+  const resolved = resolveProperties(bgioArguments, targetsRule, context) as unknown[] | undefined;
+  return resolved?.map((target) => ({
+    target,
+    value: resolveProperties(
+      bgioArguments,
+      mapping,
+      { ...context, loopTarget: target },
+    ),
+  })) ?? [];
+}

package/src/utils/simulate-move.ts

@@ -0,0 +1,32 @@
+import { serialize, deserialize } from "wackson";
+import { registry } from "../registry.js";
+import type { BgioResolveState } from "./bgio-resolve-types.js";
+
+export default function simulateMove (
+  bgioArguments: BgioResolveState,
+  payload: { arguments: Record<string, { abstract?: boolean; entityId?: unknown } | number> },
+  context: { moveInstance: { doMove: (...args: unknown[]) => unknown } }
+) {
+  const simulatedG = deserialize(serialize(bgioArguments.G) as string, registry) as {
+    bank: { locate: (id: unknown) => unknown };
+  };
+  const newBgioArguments = {
+    ...bgioArguments,
+    G: simulatedG,
+  };
+  const simulatedPayload = { ...payload, arguments: {} as Record<string, unknown> };
+  Object.entries(payload.arguments).forEach(([argName, arg]) => {
+    simulatedPayload.arguments[argName] = (arg as { abstract?: boolean }).abstract
+      ? arg
+      : simulatedG.bank.locate(typeof arg === "number" ? arg : (arg as { entityId: unknown }).entityId);
+  });
+
+  context.moveInstance.doMove(
+    newBgioArguments,
+    simulatedPayload,
+    context,
+    { skipCheck: true }
+  );
+
+  return simulatedG;
+}

package/src/wackson.d.ts

@@ -0,0 +1,4 @@
+declare module "wackson" {
+  export function serialize (value: unknown, options?: { deduplicateInstances?: boolean }): string;
+  export function deserialize (json: string, registry?: unknown): unknown;
+}

package/tsconfig.build.json

@@ -0,0 +1,14 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "emitDeclarationOnly": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "stripInternal": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "**/*.spec.ts", "e2e"]
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2020", "DOM"],
+    "strict": true,
+    "noImplicitAny": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "allowJs": false,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "rootDir": "."
+  },
+  "include": ["src/**/*.ts", "src/**/*.d.ts"],
+  "exclude": ["node_modules", "dist"]
+}