@dreamboard-games/ui-sdk 0.0.42 → 0.0.45

package/src/utils/interaction-inputs.test.ts

@@ -1,9 +1,18 @@
 import { expect, test } from "bun:test";
 import type { InteractionDescriptor } from "../types/plugin-state.js";
 import {
+  dependentInputKeys,
+  eligibleTargetsByBoardKind,
   hasInteractionFieldErrors,
+  inputKeyForTarget,
+  resolveInteractionInputs,
   validateInteractionInputDomains,
 } from "./interaction-inputs.js";
+import {
+  applyInteractionDraftMutation,
+  getInteractionDraftReadiness,
+  shouldRouteInteractionPending,
+} from "./interaction-router.js";
 
 function descriptor(
   inputs: InteractionDescriptor["inputs"],
@@ -107,3 +116,394 @@ test("many target domains validate count, distinctness, and eligibility", () =>
     ),
   ).toBe(false);
 });
+
+test("dependent domains resolve from current draft and invalidate downstream keys", () => {
+  const interaction = descriptor([
+    {
+      key: "spaceId",
+      kind: "form",
+      domain: {
+        type: "choice",
+        choices: [
+          { value: "hex-a", label: "Hex A" },
+          { value: "hex-b", label: "Hex B" },
+        ],
+      },
+    },
+    {
+      key: "targetPlayerId",
+      kind: "form",
+      domain: {
+        type: "choice",
+        choices: [],
+        dependsOn: ["spaceId"],
+        dependentCases: [
+          {
+            when: { spaceId: "hex-a" },
+            domain: {
+              type: "choice",
+              choices: [{ value: "player-1", label: "Player 1" }],
+            },
+          },
+          {
+            when: { spaceId: "hex-b" },
+            domain: {
+              type: "choice",
+              choices: [{ value: "player-2", label: "Player 2" }],
+            },
+          },
+        ],
+      },
+    },
+  ]);
+
+  const resolved = resolveInteractionInputs(interaction, { spaceId: "hex-b" });
+  expect(resolved[1]?.domain.choices).toEqual([
+    { value: "player-2", label: "Player 2" },
+  ]);
+  expect(
+    validateInteractionInputDomains(interaction, {
+      spaceId: "hex-b",
+      targetPlayerId: "player-1",
+    }),
+  ).toEqual({
+    targetPlayerId: ["Selected choice is not eligible."],
+  });
+  expect(dependentInputKeys(interaction, "spaceId")).toEqual([
+    "targetPlayerId",
+  ]);
+});
+
+test("router draft mutation clears dependent inputs unless they are supplied together", () => {
+  const interaction = descriptor([
+    {
+      key: "spaceId",
+      kind: "form",
+      domain: {
+        type: "choice",
+        choices: [
+          { value: "hex-a", label: "Hex A" },
+          { value: "hex-b", label: "Hex B" },
+        ],
+      },
+    },
+    {
+      key: "targetPlayerId",
+      kind: "form",
+      domain: {
+        type: "choice",
+        choices: [],
+        dependsOn: ["spaceId"],
+        dependentCases: [
+          {
+            when: { spaceId: "hex-a" },
+            domain: {
+              type: "choice",
+              choices: [{ value: "player-1", label: "Player 1" }],
+            },
+          },
+          {
+            when: { spaceId: "hex-b" },
+            domain: {
+              type: "choice",
+              choices: [{ value: "player-2", label: "Player 2" }],
+            },
+          },
+        ],
+      },
+    },
+  ]);
+  const draft: Record<string, unknown> = {
+    spaceId: "hex-a",
+    targetPlayerId: "player-1",
+  };
+  const store = {
+    getDraft: () => draft,
+    setInput: (_interactionKey: string, key: string, value: unknown) => {
+      draft[key] = value;
+    },
+    clearInput: (_interactionKey: string, key?: string) => {
+      if (key) delete draft[key];
+    },
+  };
+
+  expect(
+    applyInteractionDraftMutation(store, interaction, [
+      { key: "spaceId", value: "hex-b" },
+    ]),
+  ).toEqual({ spaceId: "hex-b" });
+  expect(draft).toEqual({ spaceId: "hex-b" });
+
+  expect(
+    applyInteractionDraftMutation(store, interaction, [
+      { key: "spaceId", value: "hex-a" },
+      { key: "targetPlayerId", value: "player-1" },
+    ]),
+  ).toEqual({ spaceId: "hex-a", targetPlayerId: "player-1" });
+  expect(draft).toEqual({ spaceId: "hex-a", targetPlayerId: "player-1" });
+});
+
+test("draft mutation preserves dependent target values that remain eligible", () => {
+  const interaction = descriptor([
+    {
+      key: "componentId",
+      kind: "form",
+      domain: {
+        type: "choice",
+        choices: [
+          { value: "worker-1", label: "Worker 1" },
+          { value: "worker-2", label: "Worker 2" },
+        ],
+      },
+    },
+    {
+      key: "spaceId",
+      kind: "board-space",
+      domain: {
+        type: "target",
+        targetKind: "space",
+        eligibleTargets: ["lumberyard"],
+        dependsOn: ["componentId"],
+        dependentCases: [
+          {
+            when: { componentId: "worker-1" },
+            domain: {
+              type: "target",
+              targetKind: "space",
+              eligibleTargets: ["lumberyard"],
+            },
+          },
+          {
+            when: { componentId: "worker-2" },
+            domain: {
+              type: "target",
+              targetKind: "space",
+              eligibleTargets: ["quarry"],
+            },
+          },
+        ],
+      },
+    },
+  ]);
+  const draft: Record<string, unknown> = { spaceId: "lumberyard" };
+  const store = {
+    getDraft: () => draft,
+    setInput: (_interactionKey: string, key: string, value: unknown) => {
+      draft[key] = value;
+    },
+    clearInput: (_interactionKey: string, key?: string) => {
+      if (key) delete draft[key];
+    },
+  };
+
+  expect(
+    applyInteractionDraftMutation(store, interaction, [
+      { key: "componentId", value: "worker-1" },
+    ]),
+  ).toEqual({ spaceId: "lumberyard", componentId: "worker-1" });
+  expect(draft).toEqual({ spaceId: "lumberyard", componentId: "worker-1" });
+
+  expect(
+    applyInteractionDraftMutation(store, interaction, [
+      { key: "componentId", value: "worker-2" },
+    ]),
+  ).toEqual({ componentId: "worker-2" });
+  expect(draft).toEqual({ componentId: "worker-2" });
+});
+
+test("router readiness includes defaults, dependent domains, and pending routing", () => {
+  const interaction = descriptor([
+    {
+      key: "spaceId",
+      kind: "form",
+      domain: {
+        type: "choice",
+        choices: [{ value: "hex-a", label: "Hex A" }],
+      },
+      defaultValue: "hex-a",
+    },
+    {
+      key: "targetPlayerId",
+      kind: "form",
+      domain: {
+        type: "choice",
+        choices: [{ value: "player-1", label: "Player 1" }],
+        dependsOn: ["spaceId"],
+      },
+    },
+  ]);
+  const missing = getInteractionDraftReadiness(interaction, {});
+
+  expect(missing.values).toEqual({ spaceId: "hex-a" });
+  expect(missing.missingInputs).toEqual(["targetPlayerId"]);
+  expect(missing.readyFrontier).toEqual(["targetPlayerId"]);
+  expect(missing.blockedInputs).toEqual([]);
+  expect(missing.ready).toBe(false);
+  expect(shouldRouteInteractionPending(interaction, missing)).toBe(true);
+
+  const ready = getInteractionDraftReadiness(interaction, {
+    targetPlayerId: "player-1",
+  });
+  expect(ready.ready).toBe(true);
+  expect(shouldRouteInteractionPending(interaction, ready)).toBe(true);
+  expect(
+    shouldRouteInteractionPending(
+      { ...interaction, commit: { mode: "autoWhenReady" } },
+      ready,
+    ),
+  ).toBe(false);
+});
+
+test("router readiness exposes only dependency-ready missing inputs in the frontier", () => {
+  const interaction = descriptor([
+    {
+      key: "itemId",
+      kind: "form",
+      domain: {
+        type: "choice",
+        choices: [
+          { value: "anvil", label: "Anvil" },
+          { value: "loom", label: "Loom" },
+        ],
+      },
+    },
+    {
+      key: "cell",
+      kind: "board-space",
+      domain: {
+        type: "target",
+        targetKind: "space",
+        eligibleTargets: [],
+        dependsOn: ["itemId"],
+        dependentCases: [
+          {
+            when: { itemId: "anvil" },
+            domain: {
+              type: "target",
+              targetKind: "space",
+              eligibleTargets: ["workshop-a"],
+            },
+          },
+          {
+            when: { itemId: "loom" },
+            domain: {
+              type: "target",
+              targetKind: "space",
+              eligibleTargets: ["workshop-b"],
+            },
+          },
+        ],
+      },
+    },
+  ]);
+
+  const initial = getInteractionDraftReadiness(interaction, {});
+  expect(initial.missingInputs).toEqual(["itemId", "cell"]);
+  expect(initial.readyFrontier).toEqual(["itemId"]);
+  expect(initial.blockedInputs).toEqual(["cell"]);
+
+  const afterItem = getInteractionDraftReadiness(interaction, {
+    itemId: "anvil",
+  });
+  expect(afterItem.missingInputs).toEqual(["cell"]);
+  expect(afterItem.readyFrontier).toEqual(["cell"]);
+  expect(afterItem.blockedInputs).toEqual([]);
+  expect(
+    resolveInteractionInputs(interaction, afterItem.values)[1]?.domain,
+  ).toMatchObject({
+    type: "target",
+    targetKind: "space",
+    eligibleTargets: ["workshop-a"],
+  });
+});
+
+test("router readiness exposes all independent missing inputs in the same frontier", () => {
+  const interaction = descriptor([
+    {
+      key: "giveWood",
+      kind: "form",
+      domain: { type: "number", min: 0, max: 3 },
+    },
+    {
+      key: "giveStone",
+      kind: "form",
+      domain: { type: "number", min: 0, max: 3 },
+    },
+    {
+      key: "summary",
+      kind: "form",
+      domain: {
+        type: "choice",
+        choices: [{ value: "confirm", label: "Confirm" }],
+        dependsOn: ["giveWood", "giveStone"],
+      },
+    },
+  ]);
+
+  const initial = getInteractionDraftReadiness(interaction, {});
+  expect(initial.missingInputs).toEqual(["giveWood", "giveStone", "summary"]);
+  expect(initial.readyFrontier).toEqual(["giveWood", "giveStone"]);
+  expect(initial.blockedInputs).toEqual(["summary"]);
+
+  const afterResources = getInteractionDraftReadiness(interaction, {
+    giveWood: 1,
+    giveStone: 2,
+  });
+  expect(afterResources.missingInputs).toEqual(["summary"]);
+  expect(afterResources.readyFrontier).toEqual(["summary"]);
+  expect(afterResources.blockedInputs).toEqual([]);
+});
+
+test("target helpers resolve dependent domains against the current draft", () => {
+  const interaction = descriptor([
+    {
+      key: "itemId",
+      kind: "form",
+      domain: {
+        type: "choice",
+        choices: [{ value: "anvil", label: "Anvil" }],
+      },
+    },
+    {
+      key: "cell",
+      kind: "board-space",
+      domain: {
+        type: "target",
+        targetKind: "space",
+        eligibleTargets: [],
+        dependsOn: ["itemId"],
+        dependentCases: [
+          {
+            when: { itemId: "anvil" },
+            domain: {
+              type: "target",
+              targetKind: "space",
+              eligibleTargets: ["workshop-a"],
+            },
+          },
+        ],
+      },
+    },
+  ]);
+
+  expect(interaction.inputs[1]?.domain).toMatchObject({
+    type: "target",
+    eligibleTargets: [],
+  });
+  expect(
+    resolveInteractionInputs(interaction, { itemId: "anvil" })[1]?.domain,
+  ).toMatchObject({
+    type: "target",
+    eligibleTargets: ["workshop-a"],
+  });
+  expect(eligibleTargetsByBoardKind(interaction, {})).toEqual({});
+  expect(eligibleTargetsByBoardKind(interaction, { itemId: "anvil" })).toEqual({
+    space: ["workshop-a"],
+  });
+  expect(inputKeyForTarget(interaction, "space", "workshop-a", {})).toBeNull();
+  expect(
+    inputKeyForTarget(interaction, "space", "workshop-a", {
+      itemId: "anvil",
+    }),
+  ).toBe("cell");
+});

package/src/utils/interaction-inputs.ts

@@ -27,13 +27,70 @@ export function applyInteractionInputDefaults<
   return next as Partial<Params>;
 }
 
+export function resolveInputDomain(
+  input: InteractionInputDescriptor,
+  params: Readonly<Record<string, unknown>>,
+): InteractionInputDescriptor {
+  const dependencies = input.domain.dependsOn ?? [];
+  if (dependencies.length === 0) return input;
+  const caseMatch = input.domain.dependentCases?.find((candidate) =>
+    dependencies.every(
+      (key) =>
+        params[key] !== undefined &&
+        params[key] !== null &&
+        String(params[key]) === candidate.when[key],
+    ),
+  );
+  if (!caseMatch) return input;
+  return {
+    ...input,
+    domain: {
+      ...caseMatch.domain,
+      dependsOn: dependencies,
+      dependentCases: input.domain.dependentCases,
+    },
+  };
+}
+
+export function resolveInteractionInputs(
+  descriptor: Pick<InteractionDescriptor, "inputs">,
+  params: Readonly<Record<string, unknown>>,
+): InteractionInputDescriptor[] {
+  return descriptor.inputs.map((input) => resolveInputDomain(input, params));
+}
+
+export function dependentInputKeys(
+  descriptor: Pick<InteractionDescriptor, "inputs">,
+  changedKey: string,
+): string[] {
+  const dependentsByKey = new Map<string, string[]>();
+  for (const input of descriptor.inputs) {
+    for (const dependency of input.domain.dependsOn ?? []) {
+      dependentsByKey.set(dependency, [
+        ...(dependentsByKey.get(dependency) ?? []),
+        input.key,
+      ]);
+    }
+  }
+  const result: string[] = [];
+  const queue = [...(dependentsByKey.get(changedKey) ?? [])];
+  while (queue.length > 0) {
+    const key = queue.shift();
+    if (!key || result.includes(key)) continue;
+    result.push(key);
+    queue.push(...(dependentsByKey.get(key) ?? []));
+  }
+  return result;
+}
+
 export function validateInteractionInputDomains(
   descriptor: Pick<InteractionDescriptor, "inputs">,
   params: Readonly<Record<string, unknown>>,
 ): Partial<Record<string, readonly string[]>> {
   const fieldErrors: Record<string, string[]> = {};
 
-  for (const input of descriptor.inputs) {
+  for (const rawInput of descriptor.inputs) {
+    const input = resolveInputDomain(rawInput, params);
     const value = params[input.key];
     if (value === undefined || value === null) continue;
 
@@ -67,6 +124,32 @@ export function validateInteractionInputDomains(
           `Choose at most ${max} ${pluralize("option", max)}.`,
         );
       }
+      const allowed = new Set(
+        input.domain.choices?.map((choice) => choice.value),
+      );
+      if (
+        allowed.size > 0 &&
+        value.some((item) => !allowed.has(String(item)))
+      ) {
+        pushFieldError(
+          fieldErrors,
+          input.key,
+          "Selected choice is not eligible.",
+        );
+      }
+    }
+
+    if (input.domain.type === "choice") {
+      const allowed = new Set(
+        input.domain.choices?.map((choice) => choice.value),
+      );
+      if (allowed.size > 0 && !allowed.has(value as string | null)) {
+        pushFieldError(
+          fieldErrors,
+          input.key,
+          "Selected choice is not eligible.",
+        );
+      }
     }
 
     if (input.domain.type === "target") {
@@ -176,8 +259,10 @@ export function inputByTarget(
   descriptor: Pick<InteractionDescriptor, "inputs">,
   targetKind: BoardTargetKind | "card",
   targetId: string,
+  params: Readonly<Record<string, unknown>> = {},
 ): InteractionInputDescriptor | null {
-  for (const input of descriptor.inputs) {
+  for (const rawInput of descriptor.inputs) {
+    const input = resolveInputDomain(rawInput, params);
     if (input.domain.type !== "target") continue;
     if (input.domain.targetKind !== targetKind) continue;
     if (input.domain.eligibleTargets?.includes(targetId)) return input;
@@ -188,16 +273,20 @@ export function inputByTarget(
 export function eligibleTargetsForInput(
   descriptor: Pick<InteractionDescriptor, "inputs">,
   key: string,
+  params: Readonly<Record<string, unknown>> = {},
 ): readonly string[] | undefined {
-  const domain = inputByKey(descriptor, key)?.domain;
+  const rawInput = inputByKey(descriptor, key);
+  const domain = rawInput ? resolveInputDomain(rawInput, params).domain : null;
   return domain?.type === "target" ? domain.eligibleTargets : undefined;
 }
 
 export function eligibleTargetsByInput(
   descriptor: Pick<InteractionDescriptor, "inputs">,
+  params: Readonly<Record<string, unknown>> = {},
 ): Record<string, readonly string[]> {
   return Object.fromEntries(
-    descriptor.inputs.flatMap((input) => {
+    descriptor.inputs.flatMap((rawInput) => {
+      const input = resolveInputDomain(rawInput, params);
       const targets =
         input.domain.type === "target"
           ? input.domain.eligibleTargets
@@ -209,6 +298,7 @@ export function eligibleTargetsByInput(
 
 export function eligibleTargetsByBoardKind(
   descriptor: Pick<InteractionDescriptor, "inputs">,
+  params: Readonly<Record<string, unknown>> = {},
 ): Partial<Record<BoardTargetKind, readonly string[]>> {
   const result: Record<BoardTargetKind, Set<string>> = {
     edge: new Set<string>(),
@@ -216,7 +306,8 @@ export function eligibleTargetsByBoardKind(
     space: new Set<string>(),
     tile: new Set<string>(),
   };
-  for (const input of descriptor.inputs) {
+  for (const rawInput of descriptor.inputs) {
+    const input = resolveInputDomain(rawInput, params);
     if (input.domain.type !== "target") continue;
     const targetKind = input.domain.targetKind;
     if (!isBoardTargetKind(targetKind)) continue;
@@ -234,7 +325,7 @@ export function eligibleTargetsByBoardKind(
 export function hasBoardTargetInput(
   descriptor: Pick<InteractionDescriptor, "inputs">,
 ): boolean {
-  return Object.keys(eligibleTargetsByBoardKind(descriptor)).length > 0;
+  return boardTargetKindsOf(descriptor).length > 0;
 }
 
 export function hasCardTargetInput(
@@ -252,10 +343,7 @@ export function interactionArmScope(
     "inputs" | "interactionKey" | "zoneId"
   >,
 ): string {
-  const byKind = eligibleTargetsByBoardKind(descriptor);
-  const boardKinds = (Object.keys(byKind) as BoardTargetKind[]).filter(
-    (kind) => byKind[kind] !== undefined,
-  );
+  const boardKinds = boardTargetKindsOf(descriptor);
   if (boardKinds.length === 1) return `board:${boardKinds[0]}`;
   if (boardKinds.length > 1) return "board";
   if (descriptor.zoneId) return `zone:${descriptor.zoneId}`;
@@ -266,8 +354,22 @@ export function inputKeyForTarget(
   descriptor: Pick<InteractionDescriptor, "inputs">,
   targetKind: BoardTargetKind | "card",
   targetId: string,
+  params: Readonly<Record<string, unknown>> = {},
 ): string | null {
-  return inputByTarget(descriptor, targetKind, targetId)?.key ?? null;
+  return inputByTarget(descriptor, targetKind, targetId, params)?.key ?? null;
+}
+
+function boardTargetKindsOf(
+  descriptor: Pick<InteractionDescriptor, "inputs">,
+): BoardTargetKind[] {
+  const kinds = new Set<BoardTargetKind>();
+  for (const input of descriptor.inputs) {
+    if (input.domain.type !== "target") continue;
+    if (isBoardTargetKind(input.domain.targetKind)) {
+      kinds.add(input.domain.targetKind);
+    }
+  }
+  return [...kinds];
 }
 
 function validateInputSelection(