board-game-engine 2.0.1 → 2.1.1

package/src/utils/bgio-resolve-types.ts

@@ -1,27 +0,0 @@
-import type { RuleWithConditions } from "../types/rule-with-conditions.js";
-
-/** boardgame.io match args + engine `G` after setup (deserialized, many fields). */
-export type BgioResolveState = {
-  ctx: Record<string, unknown>;
-  G: Record<string, unknown>;
-  playerID?: string;
-} & Record<string, unknown>;
-
-/** Bank API on `G` used by resolution and moves (subset of {@link Bank} methods). */
-export type BankApi = {
-  find: (a: unknown, t: unknown, c: unknown) => unknown;
-  findAll: (a: unknown, t: unknown, c: unknown) => unknown[];
-  findParent: (t: unknown) => unknown;
-  getOne: (a: BgioResolveState, rule: RuleWithConditions & { state?: unknown }, c: Record<string, unknown>) => unknown;
-  getMultiple: (
-    a: BgioResolveState,
-    rule: RuleWithConditions & { state?: unknown },
-    count: number,
-    c: Record<string, unknown>
-  ) => unknown[];
-  returnToBank: (a: BgioResolveState, entity: { entityId: number; rule: Record<string, unknown> }) => void;
-};
-
-export function bankOf (bg: BgioResolveState): BankApi {
-  return (bg.G as { bank: BankApi }).bank;
-}

package/src/utils/check-conditions.ts

@@ -1,28 +0,0 @@
-import conditionFactory from "../game-factory/condition/condition-factory.js";
-import type { Condition as ConditionRule } from "../types/bagel-types.js";
-
-export default function checkConditions (
-  bgioArguments: unknown,
-  conditions: ConditionRule[] = [],
-  payload: Record<string, unknown> = {},
-  context: Record<string, unknown> = {}
-) {
-  const results: unknown[] = [];
-  let failedAt: unknown;
-  for (const conditionRule of conditions) {
-    const result = conditionFactory(conditionRule as ConditionRule)!
-      .check(bgioArguments, payload, context);
-    if (!(result as { conditionIsMet: boolean }).conditionIsMet) {
-      failedAt = conditionRule;
-      break;
-    } else {
-      results.push(result);
-    }
-  }
-
-  return {
-    results,
-    failedAt,
-    conditionsAreMet: results.length === conditions.length,
-  };
-}

package/src/utils/create-payload.ts

@@ -1,19 +0,0 @@
-import getSteps from "./get-steps.js";
-
-export default function createPayload (
-  bgioState: Parameters<typeof getSteps>[0],
-  moveRule: Parameters<typeof getSteps>[1],
-  targets: unknown[],
-  _context: Record<string, unknown>
-) {
-  const argNames = getSteps(
-    bgioState,
-    moveRule
-  ).map((s) => s.argName);
-  return {
-    arguments: targets.reduce<Record<string, unknown>>((acc, target, i) => ({
-      ...acc,
-      [argNames[i]]: target,
-    }), {}),
-  };
-}

package/src/utils/deserialize-bgio-arguments.ts

@@ -1,10 +0,0 @@
-import { deserialize } from "wackson";
-import { registry } from "../registry.js";
-import type { BgioResolveState } from "./bgio-resolve-types.js";
-
-export default function deserializeBgioArguments (bgioArguments: BgioResolveState): BgioResolveState {
-  return {
-    ...bgioArguments,
-    G: deserialize(JSON.stringify(bgioArguments.G), registry) as Record<string, unknown>,
-  };
-}

package/src/utils/do-moves.ts

@@ -1,22 +0,0 @@
-import type { MoveDefinition } from "../types/bagel-types.js";
-import moveFactory from "../game-factory/move/move-factory.js";
-
-export default function doMoves (
-  bgioArguments: { G: unknown; [k: string]: unknown },
-  moves: MoveDefinition[] = [],
-  context: { game: Record<string, unknown> } & Record<string, unknown>
-) {
-  if (!moves?.length) {
-    return bgioArguments.G;
-  }
-
-  moves.forEach((moveRule) => {
-    moveFactory(moveRule, context.game).moveInstance!.doMove(
-      bgioArguments,
-      undefined,
-      context
-    );
-  });
-
-  return bgioArguments.G;
-}

package/src/utils/entity-matches.ts

@@ -1,30 +0,0 @@
-import matches from "lodash/matches.js";
-import resolveProperties from "./resolve-properties.js";
-import type { BgioResolveState } from "./bgio-resolve-types.js";
-
-function resolveMatcher (
-  bgioArguments: BgioResolveState,
-  matcher: Record<string, unknown>,
-  context: Record<string, unknown>
-) {
-  const resolvedMatcher = { ...matcher };
-  delete resolvedMatcher.state;
-  delete resolvedMatcher.stateGroups;
-  return resolveProperties(bgioArguments, resolvedMatcher, context);
-}
-
-function getEntityMatcher (entity: { rule: Record<string, unknown>; state?: Record<string, unknown> }) {
-  return {
-    ...entity.rule,
-    ...entity.state,
-  };
-}
-
-export default function entityMatches (
-  bgioArguments: BgioResolveState,
-  matcher: Record<string, unknown>,
-  entity: { rule: Record<string, unknown>; state?: Record<string, unknown> },
-  context: Record<string, unknown>
-): boolean {
-  return matches(resolveMatcher(bgioArguments, matcher, context))(getEntityMatcher(entity));
-}

package/src/utils/expr-eval.d.ts

@@ -1,6 +0,0 @@
-declare module "expr-eval" {
-  export class Parser {
-    functions: Record<string, (...args: unknown[]) => unknown>;
-    evaluate (expression: string, variables?: Record<string, unknown>): number;
-  }
-}

package/src/utils/find-met-condition.ts

@@ -1,23 +0,0 @@
-import conditionFactory from "../game-factory/condition/condition-factory.js";
-import type { Condition as ConditionRule } from "../types/bagel-types.js";
-
-export default function findMetCondition (
-  bgioArguments: unknown,
-  conditions: ConditionRule[] = [],
-  payload: Record<string, unknown>,
-  context: Record<string, unknown>,
-) {
-  let success: { conditionRule: unknown; [k: string]: unknown } | undefined;
-  for (const conditionRule of conditions) {
-    const result = conditionFactory(conditionRule as ConditionRule)!
-      .check(bgioArguments, payload, context);
-    if ((result as { conditionIsMet: boolean }).conditionIsMet) {
-      success = {
-        ...result as object,
-        conditionRule,
-      };
-      break;
-    }
-  }
-  return success;
-}

package/src/utils/get-current-moves.ts

@@ -1,39 +0,0 @@
-/**
- * Minimal shape of the boardgame.io client (or stand-in) used to resolve the active move set.
- */
-export interface GetCurrentMovesClient {
-  game: {
-    phases?: Record<string, unknown>;
-    moves?: Record<string, unknown>;
-    turn?: { stages?: Record<string, unknown> };
-  };
-  playerID?: string;
-  stageName?: string;
-}
-
-/** `state` shape expected by {@link getCurrentMoves} (boardgame.io match state). */
-export interface GetCurrentMovesState {
-  ctx: {
-    phase?: string;
-    activePlayers?: Record<string, string>;
-    currentPlayer?: string;
-  };
-}
-
-// get the most specific set of moves for current stage/phase
-// this will probably all break for complex stages with multiple active players
-export default function getCurrentMoves (
-  state: GetCurrentMovesState,
-  client: GetCurrentMovesClient
-): Record<string, unknown> {
-  const { game, playerID, stageName } = client;
-  const phaseName = state.ctx.phase;
-
-  const stageNameToUse = stageName ?? state.ctx.activePlayers?.[playerID ?? state.ctx.currentPlayer ?? ""];
-  const phaseOrRoot =
-    (game as { phases?: Record<string, unknown> }).phases?.[phaseName as string] ?? game;
-  const stageOrPhaseOrRoot =
-    (phaseOrRoot as { turn?: { stages?: Record<string, unknown> } }).turn?.stages?.[stageNameToUse as string] ?? phaseOrRoot;
-
-  return (stageOrPhaseOrRoot as { moves?: Record<string, unknown> }).moves ?? {};
-}

package/src/utils/get-scenario-results.ts

@@ -1,30 +0,0 @@
-import checkConditions from "./check-conditions.js";
-import resolveProperties from "./resolve-properties.js";
-import type { BgioResolveState } from "./bgio-resolve-types.js";
-import type { Condition } from "../types/bagel-types.js";
-export default function getScenarioResults (
-  bgioArguments: BgioResolveState,
-  scenarios: unknown[]
-) {
-  let match: { scenario: { result?: unknown; [k: string]: unknown }; conditionResults: { results: unknown[] } } | undefined;
-  for (const scenario of scenarios) {
-    const conditionResults = checkConditions(
-      bgioArguments,
-      (scenario as { conditions?: Condition[] }).conditions
-    );
-    if (conditionResults.conditionsAreMet) {
-      match = { scenario: scenario as { result?: unknown }, conditionResults };
-      break;
-    }
-  }
-
-  if (match?.scenario?.result) {
-    return resolveProperties(
-      bgioArguments,
-      match.scenario.result,
-      { results: match.conditionResults.results }
-    );
-  } else {
-    return match;
-  }
-}

package/src/utils/get-steps.ts

@@ -1,38 +0,0 @@
-import { bankOf, type BgioResolveState } from "./bgio-resolve-types.js";
-
-// controls order of what players need to click first
-const argNamesMap: Record<string, string[]> = {
-  PlaceNew: ["destination"],
-  RemoveEntity: ["entity"],
-  MoveEntity: ["entity", "destination"],
-  TakeFrom: ["source", "destination"],
-  SetState: ["entity", "state"],
-};
-
-// this might not be where special handling for setstate wants to live
-export default function getSteps (
-  bgioState: BgioResolveState,
-  moveRule: {
-    moveType: string;
-    arguments: Record<string, { playerChoice?: boolean; possibleValues?: unknown[]; [k: string]: unknown }>;
-  }
-) {
-  const names = argNamesMap[moveRule.moveType];
-  if (!names) return [];
-  return names
-    .filter((argName) => moveRule.arguments[argName]?.playerChoice)
-    .map((argName) => ({
-      argName,
-      getClickable: argName === "state"
-        ? () => (moveRule.arguments[argName].possibleValues as unknown[]).map((value) => ({
-            abstract: true,
-            ...moveRule.arguments[argName],
-            value,
-          }))
-        : (context: Record<string, unknown>) => bankOf(bgioState).findAll(
-            bgioState,
-            moveRule.arguments[argName],
-            context
-          ),
-    }));
-}

package/src/utils/get.ts

@@ -1,28 +0,0 @@
-type PathStep = string | number | { flatten: boolean; map?: (string | number)[] };
-
-export default function get (obj: unknown, pathArray: PathStep[]): unknown {
-  let current: unknown = obj;
-
-  for (const step of pathArray) {
-    if (current === undefined) {
-      return current;
-    }
-
-    if (step && typeof step === "object" && "flatten" in step && step.flatten) {
-      if (!Array.isArray(current)) {
-        return undefined;
-      }
-
-      let flat = current.flat() as unknown[];
-
-      if (step.map) {
-        flat = flat.map((item) => get(item, step.map!));
-      }
-      current = flat;
-    } else {
-      current = (current as Record<string | number, unknown>)[step as string | number];
-    }
-  }
-
-  return current;
-}

package/src/utils/json-transformer.ts

@@ -1,17 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,172 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

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

package/tsconfig.build.json

@@ -1,14 +0,0 @@
-{
-  "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

@@ -1,21 +0,0 @@
-{
-  "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"]
-}