board-game-engine 1.0.5 → 2.0.1

package/src/client/client.ts

@@ -0,0 +1,306 @@
+import { Client as BoardgameIOClient } from "@mnbroatch/boardgame.io/client";
+import { Debug } from "@mnbroatch/boardgame.io/debug";
+import { SocketIO } from "@mnbroatch/boardgame.io/multiplayer";
+import { serialize, deserialize } from "wackson";
+import gameFactory from "../game-factory/game-factory.js";
+import type { BoardGameEngineGame, BgioArguments } from "../game-factory/game-factory.js";
+import type { Condition, GameFactoryInput } from "../types/bagel-types.js";
+import { registry } from "../registry.js";
+import simulateMove from "../utils/simulate-move.js";
+import getCurrentMoves from "../utils/get-current-moves.js";
+import type { GetCurrentMovesClient, GetCurrentMovesState } from "../utils/get-current-moves.js";
+import resolveProperties from "../utils/resolve-properties.js";
+import type { BgioResolveState } from "../utils/bgio-resolve-types.js";
+import checkConditions from "../utils/check-conditions.js";
+import preparePayload from "../utils/prepare-payload.js";
+import getSteps from "../utils/get-steps.js";
+import createPayload from "../utils/create-payload.js";
+
+export interface ClientOptions {
+  boardgameIOGame?: BoardGameEngineGame;
+  /** JSON string of a {@link GameFactoryInput} rule object */
+  gameRules?: string;
+  gameName?: string;
+  server?: string;
+  numPlayers?: number;
+  debug?: {
+    collapseOnLoad?: boolean;
+    impl?: typeof Debug;
+  };
+  matchID?: string;
+  playerID?: string | null;
+  credentials?: string;
+  multiplayer?: ReturnType<typeof SocketIO>;
+  onClientUpdate?: () => void;
+}
+
+interface MoveBuilder {
+  targets: unknown[];
+  stepIndex: number;
+  eliminatedMoves: string[];
+}
+
+export class Client {
+  options: ClientOptions;
+  game: BoardGameEngineGame;
+  client?: ReturnType<typeof BoardgameIOClient>;
+  moveBuilder?: MoveBuilder;
+  optimisticWinner?: unknown | null;
+
+  constructor (options: ClientOptions) {
+    this.options = options;
+    this.game = options.boardgameIOGame
+      || gameFactory(JSON.parse(options.gameRules as string) as GameFactoryInput, options.gameName ?? "");
+
+    if (!options.boardgameIOGame) {
+      this.moveBuilder = { targets: [], stepIndex: 0, eliminatedMoves: [] };
+      this.optimisticWinner = null;
+    }
+  }
+
+  connect () {
+    const {
+      server,
+      numPlayers,
+      debug = {
+        collapseOnLoad: true,
+        impl: Debug,
+      },
+      matchID,
+      playerID,
+      credentials,
+      multiplayer = SocketIO({ server, socketOpts: { transports: ["websocket", "polling"] } }),
+    } = this.options;
+
+    try {
+      const clientOptions = !credentials
+        ? { game: this.game, numPlayers, debug }
+        : {
+            game: this.game,
+            multiplayer,
+            matchID,
+            playerID: playerID ?? undefined,
+            credentials,
+            numPlayers,
+            debug,
+          };
+
+      this.client = BoardgameIOClient(clientOptions as Parameters<typeof BoardgameIOClient>[0]);
+      this.client.subscribe(() => this.update());
+      this.client.start();
+      return this;
+    } catch (error: unknown) {
+      const err = error as { message?: string; stack?: string };
+      console.error("Failed to join game:", err?.message ?? error);
+      if (err?.stack) console.error(err.stack);
+    }
+  }
+
+  update () {
+    this.options.onClientUpdate?.();
+  }
+
+  getState () {
+    const bgioState = this.client?.getState();
+    if (!bgioState) return {};
+
+    const state = this.options.boardgameIOGame
+      ? bgioState
+      : {
+        ...bgioState,
+        G: deserialize(JSON.stringify(bgioState.G), registry),
+      };
+
+    const gameover = this.optimisticWinner ?? state?.ctx?.gameover;
+
+    const currentMoves = gameover
+      ? []
+      : getCurrentMoves(state as GetCurrentMovesState, this.client as GetCurrentMovesClient);
+
+    if (this.options.boardgameIOGame) {
+      return {
+        state,
+        gameover,
+        moves: this.client!.moves,
+        currentMoves,
+      };
+    }
+
+    const _wrappedMoves = Object.entries(currentMoves)
+      .reduce<Record<string, unknown>>((acc, [moveName, rawMove]) => {
+        const move = (payload: unknown) => {
+          this.client!.moves[moveName](preparePayload(payload));
+        };
+        (move as { moveInstance?: unknown }).moveInstance = (rawMove as { moveInstance: unknown }).moveInstance;
+        return { ...acc, [moveName]: move };
+      }, {});
+
+    const { allClickable, _possibleMoveMeta } = getPossibleMoves(state, _wrappedMoves, this.moveBuilder!);
+
+    return { state, gameover, allClickable, _wrappedMoves, _possibleMoveMeta };
+  }
+
+  doStep (_target: unknown) {
+    if (this.options.boardgameIOGame) return;
+
+    const { state, _wrappedMoves, _possibleMoveMeta } = this.getState() as {
+      state: { G: { bank: { locate: (id: unknown) => unknown } } };
+      _wrappedMoves: Record<string, { (p: unknown): void; moveInstance: unknown }>;
+      _possibleMoveMeta: Record<string, { clickableForMove: Set<unknown> }>;
+    };
+
+    const target = (_target as { abstract?: boolean; entityId?: unknown; value?: unknown }).abstract
+      ? _target
+      : state.G.bank.locate((_target as { entityId: unknown }).entityId);
+
+    const newEliminated = Object.entries(_possibleMoveMeta)
+      .filter(([_, meta]) => !hasTarget(meta.clickableForMove, target))
+      .map(([name]) => name)
+      .concat(this.moveBuilder!.eliminatedMoves);
+
+    if (newEliminated.length === Object.keys(_wrappedMoves).length) {
+      console.error("invalid move with target:", (target as { rule?: unknown })?.rule);
+      return;
+    }
+
+    const remainingMoveEntries = Object.entries(_possibleMoveMeta)
+      .filter(([name]) => !newEliminated.includes(name));
+
+    if (isMoveCompleted(
+      state,
+      _wrappedMoves as Record<string, { moveInstance: { rule: unknown } }>,
+      remainingMoveEntries,
+      this.moveBuilder!.stepIndex
+    )) {
+      const [moveName] = remainingMoveEntries[0];
+      const move = _wrappedMoves[moveName];
+      const payload = createPayload(
+        state as unknown as BgioResolveState,
+        (move as { moveInstance: { rule: Parameters<typeof getSteps>[1] } }).moveInstance.rule,
+        [...this.moveBuilder!.targets, target],
+        { moveInstance: (move as { moveInstance: unknown }).moveInstance }
+      );
+
+      this.optimisticWinner = getWinnerAfterMove(state, this.game, (move as { moveInstance: unknown }).moveInstance, payload);
+      move(payload);
+      this.moveBuilder = { targets: [], stepIndex: 0, eliminatedMoves: [] };
+    } else {
+      this.moveBuilder = {
+        eliminatedMoves: newEliminated,
+        stepIndex: this.moveBuilder!.stepIndex + 1,
+        targets: [...this.moveBuilder!.targets, target],
+      };
+    }
+
+    this.update();
+  }
+
+  reset () {
+    if (this.options.boardgameIOGame) return;
+    this.moveBuilder = { targets: [], stepIndex: 0, eliminatedMoves: [] };
+    this.optimisticWinner = null;
+    this.update();
+  }
+
+  undoStep () {
+    if (this.options.boardgameIOGame) return;
+    if (this.moveBuilder!.targets.length) {
+      this.moveBuilder = {
+        targets: this.moveBuilder!.targets.slice(0, -1),
+        stepIndex: Math.max(0, this.moveBuilder!.stepIndex - 1),
+        eliminatedMoves: [],
+      };
+    }
+    this.update();
+  }
+}
+
+function hasTarget (clickableSet: Set<unknown>, target: unknown) {
+  if (!(target as { abstract?: boolean }).abstract) return clickableSet.has(target);
+  return [...clickableSet].some((item) => (item as { abstract?: boolean; value?: unknown }).abstract && (item as { value: unknown }).value === (target as { value: unknown }).value);
+}
+
+function getPossibleMoves (
+  bgioState: unknown,
+  moves: Record<string, unknown>,
+  moveBuilder: MoveBuilder
+) {
+  const { eliminatedMoves, stepIndex } = moveBuilder;
+  const _possibleMoveMeta: Record<string, { clickableForMove: Set<unknown> }> = {};
+  const allClickable = new Set<unknown>();
+
+  Object.entries(moves)
+    .filter(([moveName]) => !eliminatedMoves.includes(moveName))
+    .forEach(([moveName, move]) => {
+      const moveRule = resolveProperties(bgioState as BgioResolveState, {
+        ...(move as { moveInstance: { rule: Record<string, unknown> } }).moveInstance.rule,
+        moveName,
+      }) as { arguments?: Record<string, unknown> };
+
+      const context = {
+        moveInstance: (move as { moveInstance: unknown }).moveInstance,
+        moveArguments: moveRule.arguments,
+      };
+
+      const targets = moveBuilder.targets.map((t) =>
+        (t as { abstract?: boolean }).abstract ? t : (bgioState as { G: { bank: { locate: (id: unknown) => unknown } } }).G.bank.locate((t as { entityId: unknown }).entityId)
+      );
+
+      const payload = createPayload(
+        bgioState as BgioResolveState,
+        moveRule as Parameters<typeof getSteps>[1],
+        targets,
+        context
+      );
+
+      context.moveArguments = { ...context.moveArguments, ...payload.arguments };
+
+      const moveIsAllowed = checkConditions(
+        bgioState as BgioResolveState,
+        (moveRule as { conditions?: Condition[] }).conditions,
+        {},
+        context
+      ).conditionsAreMet;
+      const moveSteps = getSteps(
+        bgioState as BgioResolveState,
+        moveRule as Parameters<typeof getSteps>[1]
+      );
+
+      const clickableForMove = new Set(
+        (moveIsAllowed && moveSteps?.[stepIndex]?.getClickable(context)) || []
+      );
+
+      _possibleMoveMeta[moveName] = { clickableForMove };
+      clickableForMove.forEach((entity) => allClickable.add(entity));
+    });
+
+  return { _possibleMoveMeta, allClickable };
+}
+
+function isMoveCompleted (
+  state: unknown,
+  moves: Record<string, { moveInstance: { rule: unknown } }>,
+  remainingMoveEntries: [string, unknown][],
+  stepIndex: number
+) {
+  return remainingMoveEntries.length === 1 &&
+    getSteps(
+      state as BgioResolveState,
+      moves[remainingMoveEntries[0][0]].moveInstance.rule as Parameters<typeof getSteps>[1]
+    ).length === stepIndex + 1;
+}
+
+function getWinnerAfterMove (
+  state: unknown,
+  game: BoardGameEngineGame,
+  moveInstance: unknown,
+  movePayload: unknown
+) {
+  const simulatedG = simulateMove(
+    state as unknown as BgioResolveState,
+    preparePayload(movePayload) as { arguments: Record<string, number | { abstract?: boolean; entityId?: unknown }> },
+    { moveInstance: moveInstance as { doMove: (...args: unknown[]) => unknown } }
+  );
+  const endIf = game.endIf as ((ctx: BgioArguments) => unknown) | undefined;
+  return endIf?.({ ...state as object, G: JSON.parse(serialize(simulatedG)) } as BgioArguments);
+}

package/src/game-factory/bank/bank-slot.ts

@@ -0,0 +1,81 @@
+import resolveProperties from "../../utils/resolve-properties.js";
+import type { BgioResolveState } from "../../utils/bgio-resolve-types.js";
+
+class BankSlot {
+  bank: { createEntity: (rule: Record<string, unknown>) => unknown };
+  rule: Record<string, unknown> & { count?: number | string; name?: string };
+  pool: unknown[];
+  remaining: number;
+
+  constructor (rule: Record<string, unknown> & { count?: number | string; name?: string }, bank: BankSlot["bank"]) {
+    this.bank = bank;
+    this.rule = rule;
+    this.pool = [];
+    this.remaining = +((rule.count as number | string) || 1);
+  }
+
+  getOne (bgioArguments: BgioResolveState, options: { state?: unknown }, context: Record<string, unknown>) {
+    return this.getMultiple(bgioArguments, 1, options, context)[0];
+  }
+
+  getMultiple (
+    bgioArguments: BgioResolveState,
+    count: number = Infinity,
+    options: { state?: unknown } = {},
+    context: Record<string, unknown> = {}
+  ) {
+    const toReturn: unknown[] = [];
+
+    if (this.remaining === Infinity && count === Infinity) {
+      throw new Error(`Cannot get infinite pieces from slot with infinite remaining: ${this.rule.name}`);
+    }
+
+    if (count !== Infinity && count > this.remaining) {
+      throw new Error(`Requested ${count} pieces but only ${this.remaining} available in slot: ${this.rule.name}`);
+    }
+
+    const actualCount = count === Infinity ? this.remaining : count;
+
+    if (this.remaining !== Infinity) {
+      this.remaining -= actualCount;
+    }
+
+    const fromPool = Math.min(actualCount, this.pool.length);
+    toReturn.push(...this.pool.splice(0, fromPool));
+
+    const remainder = actualCount - fromPool;
+    if (remainder > 0) {
+      toReturn.push(
+        ...Array.from(new Array(remainder)).map(() =>
+          this.bank.createEntity(this.rule)
+        )
+      );
+    }
+
+    if (options.state) {
+      const newState = resolveProperties(bgioArguments, options.state, context);
+      toReturn.forEach((entity) => {
+        (entity as { state: Record<string, unknown> }).state = {
+          ...(entity as { state: Record<string, unknown> }).state,
+          ...newState as Record<string, unknown>,
+        };
+      });
+    }
+
+    return toReturn;
+  }
+
+  returnToBank (entity: { rule: { state?: unknown }; state?: unknown }) {
+    if (entity.rule.state) {
+      entity.state = entity.rule.state;
+    } else {
+      delete entity.state;
+    }
+    if (this.remaining !== undefined) {
+      this.remaining += 1;
+    }
+    this.pool.push(entity);
+  }
+}
+
+export default BankSlot;

package/src/game-factory/bank/bank.ts

@@ -0,0 +1,125 @@
+import find from "lodash/find.js";
+import filter from "lodash/filter.js";
+import checkConditions from "../../utils/check-conditions.js";
+import type { RuleWithConditions } from "../../types/rule-with-conditions.js";
+import { registry } from "../../registry.js";
+import BankSlot from "./bank-slot.js";
+import type { BgioResolveState } from "../../utils/bgio-resolve-types.js";
+
+class Bank {
+  currentEntityId: number;
+  tracker: Record<number, unknown>;
+  slots: InstanceType<typeof BankSlot>[];
+
+  constructor (entityRules: Record<string, unknown>[]) {
+    this.currentEntityId = 0;
+    this.tracker = {};
+    this.slots = entityRules.map((rule) => new BankSlot(rule, this));
+  }
+
+  createEntity (definition: Record<string, unknown> = {}, options?: Record<string, unknown>) {
+    const Ctor = registry[(definition.entityType || "Entity") as keyof typeof registry] as new (
+      a: unknown,
+      b: Record<string, unknown>,
+      c: number
+    ) => unknown;
+    const entity = new Ctor(
+      {
+        bank: this,
+        fromBank: true,
+        ...options,
+      },
+      definition,
+      this.currentEntityId++
+    );
+    this.track(entity as { entityId: number });
+    return entity;
+  }
+
+  track (entity: { entityId: number }) {
+    this.tracker[entity.entityId] = entity;
+  }
+
+  locate (entityId: unknown) {
+    return this.tracker[entityId as number];
+  }
+
+  findAll (bgioArguments: BgioResolveState, rule: RuleWithConditions, context: Record<string, unknown>) {
+    if (!rule.conditions) {
+      throw new Error(`Cannot find entity with no conditions. Rule: ${JSON.stringify(rule)}`);
+    }
+    return filter(
+      Object.values(this.tracker),
+      (entity) => checkConditions(
+        bgioArguments,
+        rule.conditions,
+        { target: entity },
+        context
+      ).conditionsAreMet
+    );
+  }
+
+  findOne (bgioArguments: BgioResolveState, rule: RuleWithConditions, context: Record<string, unknown>) {
+    return this.findAll(bgioArguments, rule, context)[0];
+  }
+
+  find (bgioArguments: BgioResolveState, rule: RuleWithConditions & { matchMultiple?: boolean }, context: Record<string, unknown>) {
+    return rule.matchMultiple
+      ? this.findAll(bgioArguments, rule, context)
+      : this.findOne(bgioArguments, rule, context);
+  }
+
+  findParent (entity: unknown) {
+    return find(this.tracker, (ent) =>
+      (ent as { entities?: unknown[] }).entities?.includes(entity)
+        || (ent as { spaces?: unknown[] }).spaces?.includes(entity)
+    );
+  }
+
+  getOne (bgioArguments: BgioResolveState, rule: RuleWithConditions & { state?: unknown }, context: Record<string, unknown>) {
+    const slot = this.getSlot(bgioArguments, rule, context);
+    if (!slot) {
+      console.error(`No matching slot for ${JSON.stringify(rule)}`);
+    }
+    return slot!.getOne(bgioArguments, { state: rule.state }, context);
+  }
+
+  getMultiple (bgioArguments: BgioResolveState, rule: RuleWithConditions & { state?: unknown }, count: number, context: Record<string, unknown>) {
+    const slots = this.getSlots(bgioArguments, rule, context);
+    if (!slots.length) {
+      console.error(`No matching slots for ${JSON.stringify(rule)}`);
+    }
+    return slots.reduce<unknown[]>((acc, slot) => [
+      ...acc,
+      ...slot.getMultiple(bgioArguments, count, { state: rule.state }),
+    ], []);
+  }
+
+  getSlot (bgioArguments: BgioResolveState, rule: RuleWithConditions, context: Record<string, unknown>) {
+    return this.slots.find((slot) => checkConditions(
+      bgioArguments,
+      rule.conditions,
+      { target: slot },
+      context
+    ).conditionsAreMet
+    );
+  }
+
+  getSlots (bgioArguments: BgioResolveState, rule: RuleWithConditions, context: Record<string, unknown>) {
+    return this.slots.filter((slot) => checkConditions(
+      bgioArguments,
+      rule.conditions,
+      { target: slot },
+      context
+    ).conditionsAreMet
+    );
+  }
+
+  returnToBank (bgioArguments: BgioResolveState, entity: { entityId: number; rule: Record<string, unknown> }) {
+    (this.findParent(entity) as { remove: (e: unknown) => void }).remove(entity);
+    this.getSlot(bgioArguments, entity.rule as RuleWithConditions, {})!.returnToBank(entity);
+    delete this.tracker[entity.entityId];
+  }
+}
+
+export default Bank;

package/src/game-factory/{board.js → board.ts}

@@ -1,3 +1,3 @@
-import Space from './space/space.js'
+import Space from "./space/space.js";
 
 export default class Board extends Space {}

package/src/game-factory/condition/condition-factory.ts

@@ -0,0 +1,59 @@
+import type { Condition as ConditionRule } from "../../types/bagel-types.js";
+import type ConditionBase from "./condition.js";
+import Is from "./is-condition.js";
+import Not from "./not-condition.js";
+import Or from "./or-condition.js";
+import Some from "./some-condition.js";
+import Every from "./every-condition.js";
+import ContainsCondition from "./contains-condition.js";
+import ContainsSameCondition from "./contains-same-condition.js";
+import InLine from "./in-line-condition.js";
+import HasLine from "./has-line-condition.js";
+import IsFull from "./is-full-condition.js";
+import Would from "./would-condition.js";
+import NoPossibleMoves from "./no-possible-moves-condition.js";
+import Evaluate from "./evaluate-condition.js";
+import Position from "./position-condition.js";
+// import BingoCondition from "./bingo-condition.js";
+// import RelativeMoveCondition from "./relative-move-condition.js";
+
+export default function conditionFactory (rule: ConditionRule): ConditionBase | undefined {
+  if (typeof rule !== "object" || rule === null || !("conditionType" in rule)) {
+    return undefined;
+  }
+  const r = rule as { conditionType: string; [k: string]: unknown };
+  if (r.conditionType === "Is") {
+    return new Is(r);
+  } else if (r.conditionType === "Not") {
+    return new Not(r);
+  } else if (r.conditionType === "Or") {
+    return new Or(r);
+  } else if (r.conditionType === "Some") {
+    return new Some(r);
+  } else if (r.conditionType === "Contains") {
+    return new ContainsCondition(r);
+  } else if (r.conditionType === "ContainsSame") {
+    return new ContainsSameCondition(r);
+  } else if (r.conditionType === "Every") {
+    return new Every(r);
+  } else if (r.conditionType === "InLine") {
+    return new InLine(r);
+  } else if (r.conditionType === "HasLine") {
+    return new HasLine(r);
+  } else if (r.conditionType === "IsFull") {
+    return new IsFull(r);
+  } else if (r.conditionType === "Would") {
+    return new Would(r);
+  } else if (r.conditionType === "NoPossibleMoves") {
+    return new NoPossibleMoves(r);
+  } else if (r.conditionType === "Evaluate") {
+    return new Evaluate(r);
+  } else if (r.conditionType === "Position") {
+    return new Position(r);
+  // } else if (rule.conditionType === "bingo") {
+    // return new BingoCondition(rule);
+  // } else if (rule.conditionType === "relativeMove") {
+  //   return new RelativeMoveCondition(rule);
+  }
+  return undefined;
+}

package/src/game-factory/condition/condition.ts

@@ -0,0 +1,50 @@
+import resolveProperties from "../../utils/resolve-properties.js";
+import type { BgioResolveState } from "../../utils/bgio-resolve-types.js";
+
+export default abstract class Condition {
+  rule: unknown;
+
+  constructor (rule: unknown) {
+    this.rule = rule;
+  }
+
+  check (bgioArguments: unknown, payload: Record<string, unknown>, context: Record<string, unknown>) {
+    const conditionPayload = { ...payload };
+    const newContext = { ...context };
+
+    if (conditionPayload.target) {
+      newContext.originalTarget = conditionPayload.target;
+    }
+
+    const rule = resolveProperties(
+      bgioArguments as BgioResolveState,
+      this.rule,
+      newContext
+    );
+
+    if ((rule as { target?: unknown }).target !== undefined) {
+      conditionPayload.target = (rule as { target: unknown }).target;
+    }
+
+    if ((this.rule as { target?: unknown }).target !== undefined && !conditionPayload.target) {
+      return { conditionIsMet: false };
+    }
+
+    return this.checkCondition(bgioArguments, rule, conditionPayload, newContext);
+  }
+
+  abstract checkCondition (
+    bgioArguments: unknown,
+    rule: unknown,
+    conditionPayload: Record<string, unknown>,
+    newContext: Record<string, unknown>
+  ): { conditionIsMet: boolean; [k: string]: unknown };
+
+  isMet (...args: unknown[]) {
+    return (this.check as (a: unknown, b: Record<string, unknown>, c: Record<string, unknown>) => { conditionIsMet: boolean })(
+      args[0],
+      (args[1] as Record<string, unknown>) ?? {},
+      (args[2] as Record<string, unknown>) ?? {}
+    ).conditionIsMet;
+  }
+}

package/src/game-factory/condition/{contains-condition.js → contains-condition.ts}

@@ -1,17 +1,18 @@
 import _matches from "lodash/matches.js";
+import type { Condition as ConditionRule } from "../../types/bagel-types.js";
 import Condition from "../condition/condition.js";
 import checkConditions from "../../utils/check-conditions.js";
 
 export default class ContainsCondition extends Condition {
-  checkCondition(bgioArguments, rule, payload, context) {
-    const { target } = payload
+  checkCondition (bgioArguments: unknown, rule: unknown, payload: Record<string, unknown>, context: Record<string, unknown>) {
+    const target = payload.target as { entities?: unknown[]; spaces?: unknown[] } | undefined;
     if (!target) {
       return { matches: [], conditionIsMet: false }
     } else {
       const candidates = target.entities ?? target.spaces
-      const matches = candidates?.filter(entity => checkConditions(
+      const matches = candidates?.filter((entity: unknown) => checkConditions(
         bgioArguments,
-        rule,
+        (rule as { conditions?: ConditionRule[] }).conditions,
         { target: entity },
         context
       ).conditionsAreMet) ?? []

package/src/game-factory/condition/{contains-same-condition.js → contains-same-condition.ts}

@@ -3,21 +3,24 @@ import conditionFactory from "./condition-factory.js";
 import Condition from "./condition.js";
 
 export default class ContainsSame extends Condition {
-  checkCondition (bgioArguments, rule, { targets }) {
+  checkCondition (bgioArguments: unknown, rule: unknown, conditionPayload: Record<string, unknown>, _newContext: Record<string, unknown>) {
+    const { targets } = conditionPayload as { targets: { entities?: unknown[]; rule?: unknown }[] };
     if (targets.length === 1 && targets[0].entities?.length) {
       return { conditionIsMet: true }
     }
 
     const [ first, ...restEntities ] = targets;
-    const conditionIsMet = first.entities.some(entity => {
+    const conditionIsMet = (first.entities ?? []).some((entity: unknown) => {
+      const e = entity as { rule?: unknown };
       const condition = conditionFactory({
         conditionType: "Contains",
         conditions: [{
           conditionType: 'Is',
-          matcher: pick(entity.rule, rule.properties)
+          matcher: pick(e.rule as object, (rule as { properties: unknown }).properties as never)
         }]
-      })
-      return restEntities.every(ent => {
+      });
+      if (!condition) return false;
+      return restEntities.every((ent: unknown) => {
         return condition.isMet(bgioArguments, { target: ent })
       })
     })