@dreamboard-games/ui-sdk 0.0.43 → 0.0.45

package/src/hooks/useBoardInteractions.test.tsx

@@ -64,7 +64,10 @@ function createDescriptor(
             }
           : {
               type: "choice" as const,
-              choices: [{ value: "fallback", label: "Fallback" }],
+              choices: [
+                { value: "fallback", label: "Fallback" },
+                { value: "player-2", label: "Player 2" },
+              ],
             },
       };
     });
@@ -147,9 +150,11 @@ function render<T>(
   recorder?: RecordedSubmit[],
   setupDraft?: (store: InteractionUiStoreApi) => void,
   submitOverride?: RuntimeAPI["submitInteraction"],
+  storeRef?: { current?: InteractionUiStoreApi },
 ): T {
   const runtime = createRuntime(snapshot, recorder, submitOverride);
   const draftStore = createInteractionUiStore();
+  if (storeRef) storeRef.current = draftStore;
   setupDraft?.(draftStore);
   let captured!: T;
   function Harness() {
@@ -229,6 +234,73 @@ test("useBoardInteractions skips unavailable handles when merging eligibility",
   expect(Array.from(board.eligible.edge)).toEqual(["e-2"]);
 });
 
+test("useBoardInteractions resolves dependent target eligibility from the draft", () => {
+  const session = createSessionState();
+  const snapshot = createSnapshot(session, [
+    createDescriptor({
+      interactionId: "craftAtWorkshop",
+      surface: "board-space",
+      inputs: [
+        {
+          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 blocked = render(snapshot, () => useBoardInteractions());
+  expect(Array.from(blocked.eligible.space)).toEqual([]);
+  expect(blocked.isEligible("workshop-a", "space")).toBe(false);
+
+  const ready = render(
+    snapshot,
+    () => useBoardInteractions(),
+    undefined,
+    (store) => {
+      store.setInput("play.craftAtWorkshop", "itemId", "anvil");
+    },
+  );
+  expect(Array.from(ready.eligible.space)).toEqual(["workshop-a"]);
+  expect(ready.isEligible("workshop-a", "space")).toBe(true);
+  expect(ready.isEligible("workshop-b", "space")).toBe(false);
+});
+
 test("useBoardInteractions unarmed matching interactions require an explicit route", async () => {
   const session = createSessionState();
   const snapshot = createSnapshot(session, [
@@ -288,7 +360,7 @@ test("useBoardInteractions equal-rank unarmed matches throw BoardInteractionConf
   }
 });
 
-test("useBoardInteractions target-kind select skips unavailable handles and returns null when nothing matches", async () => {
+test("useBoardInteractions target-kind select skips unavailable handles and returns none when nothing matches", async () => {
   const session = createSessionState();
   const snapshot = createSnapshot(session, [
     createDescriptor({
@@ -304,11 +376,11 @@ test("useBoardInteractions target-kind select skips unavailable handles and retu
   const board = render(snapshot, () => useBoardInteractions(), recorder);
 
   const fired = await board.select.vertex("v-1");
-  expect(fired).toBeNull();
+  expect(fired).toEqual({ status: "none" });
   expect(recorder).toEqual([]);
 });
 
-test("useBoardInteractions target-kind select merges extraInputs and backfills null for missing required inputs", async () => {
+test("useBoardInteractions target-kind select exposes pending input instead of backfilling null for missing required inputs", async () => {
   const session = createSessionState();
   const snapshot = createSnapshot(session, [
     createDescriptor({
@@ -323,19 +395,20 @@ test("useBoardInteractions target-kind select merges extraInputs and backfills n
   const recorder: RecordedSubmit[] = [];
   const board = render(snapshot, () => useBoardInteractions(), recorder);
 
-  await board.select.space("space-7");
-  expect(recorder).toEqual([
-    {
-      playerId: "player-1",
-      interactionId: "moveRobber",
-      params: { spaceId: "space-7", stealFromPlayerId: null },
-    },
-  ]);
+  const pending = await board.select.space("space-7");
+  expect(pending.status).toBe("pending");
+  if (pending.status !== "pending") {
+    throw new Error("Expected pending board selection result");
+  }
+  expect(pending.interactionKey).toBe("play.moveRobber");
+  expect(pending.missingInputs).toEqual(["stealFromPlayerId"]);
+  expect(recorder).toEqual([]);
 
   recorder.length = 0;
-  await board.select.space("space-7", {
+  const submitted = await board.select.space("space-7", {
     stealFromPlayerId: "player-2",
   });
+  expect(submitted.status).toBe("submitted");
   expect(recorder).toEqual([
     {
       playerId: "player-1",
@@ -345,6 +418,103 @@ test("useBoardInteractions target-kind select merges extraInputs and backfills n
   ]);
 });
 
+test("useBoardInteractions pending input arms the descriptor and stores the target draft", async () => {
+  const session = createSessionState();
+  const snapshot = createSnapshot(session, [
+    createDescriptor({
+      interactionId: "moveRobber",
+      surface: "board-tile",
+      commit: { mode: "autoWhenReady" },
+      targets: { spaceId: ["space-7"] },
+      keys: ["spaceId", "stealFromPlayerId"],
+    }),
+  ]);
+
+  const storeRef: { current?: InteractionUiStoreApi } = {};
+  const board = render(
+    snapshot,
+    () => useBoardInteractions(),
+    undefined,
+    (store) => {
+      store.setInput("play.moveRobber", "spaceId", "space-7");
+      store.arm("board:space", "play.moveRobber");
+    },
+    undefined,
+    storeRef,
+  );
+
+  const pending = await board.select.space("space-7");
+  expect(pending.status).toBe("pending");
+  if (pending.status !== "pending") {
+    throw new Error("Expected pending board selection result");
+  }
+  expect(pending.interactionKey).toBe("play.moveRobber");
+  expect(pending.missingInputs).toEqual(["stealFromPlayerId"]);
+  expect(storeRef.current?.getDraft("play.moveRobber")).toEqual({
+    spaceId: "space-7",
+  });
+  expect(storeRef.current?.getArmed("board:space")).toBe("play.moveRobber");
+});
+
+test("useBoardInteractions explicit target selection follows the same no-null pending behavior", async () => {
+  const session = createSessionState();
+  const descriptor = createDescriptor({
+    interactionId: "moveRobber",
+    surface: "board-tile",
+    commit: { mode: "autoWhenReady" },
+    targets: { spaceId: ["space-7"] },
+    keys: ["spaceId", "stealFromPlayerId"],
+  });
+  const snapshot = createSnapshot(session, [descriptor]);
+
+  const recorder: RecordedSubmit[] = [];
+  const board = render(snapshot, () => useBoardInteractions(), recorder);
+
+  const result = await board.selectTarget(
+    descriptor,
+    "space",
+    "space-7",
+    "spaceId",
+  );
+  expect(result.status).toBe("pending");
+  if (result.status !== "pending") {
+    throw new Error("Expected pending board selection result");
+  }
+  expect(result.missingInputs).toEqual(["stealFromPlayerId"]);
+  expect(recorder).toEqual([]);
+});
+
+test("useBoardInteractions submitted board target clears draft and arm state", async () => {
+  const session = createSessionState();
+  const snapshot = createSnapshot(session, [
+    createDescriptor({
+      interactionId: "moveRobber",
+      surface: "board-tile",
+      commit: { mode: "autoWhenReady" },
+      targets: { spaceId: ["space-7"] },
+      keys: ["spaceId", "stealFromPlayerId"],
+    }),
+  ]);
+
+  const storeRef: { current?: InteractionUiStoreApi } = {};
+  const board = render(
+    snapshot,
+    () => useBoardInteractions(),
+    [],
+    (store) => {
+      store.setInput("play.moveRobber", "stealFromPlayerId", "player-2");
+      store.arm("board:space", "play.moveRobber");
+    },
+    undefined,
+    storeRef,
+  );
+
+  const result = await board.select.space("space-7");
+  expect(result.status).toBe("submitted");
+  expect(storeRef.current?.getDraft("play.moveRobber")).toEqual({});
+  expect(storeRef.current?.getArmed("board:space")).toBeNull();
+});
+
 test("useBoardInteractions targetLayers expose reducer eligibility sets", () => {
   const session = createSessionState();
   const snapshot = createSnapshot(session, [
@@ -423,7 +593,7 @@ test("useBoardInteractions targetLayers apply extraInputs and onBeforeSelect", a
   let beforeCount = 0;
   const board = render(snapshot, () => useBoardInteractions(), recorder);
 
-  await board.targetLayers
+  const result = await board.targetLayers
     .space({
       extraInputs: (targetId) => ({
         stealFromPlayerId: targetId === "space-7" ? "player-2" : null,
@@ -435,6 +605,7 @@ test("useBoardInteractions targetLayers apply extraInputs and onBeforeSelect", a
     .selectTargetId?.("space-7");
 
   expect(beforeCount).toBe(1);
+  expect(result?.status).toBe("submitted");
   expect(recorder).toEqual([
     {
       playerId: "player-1",
@@ -444,6 +615,50 @@ test("useBoardInteractions targetLayers apply extraInputs and onBeforeSelect", a
   ]);
 });
 
+test("useBoardInteractions many-target board input submits only when selection minimum is satisfied", async () => {
+  const session = createSessionState();
+  const snapshot = createSnapshot(session, [
+    createDescriptor({
+      interactionId: "buildJumpGate",
+      surface: "board-edge",
+      commit: { mode: "autoWhenReady" },
+      inputs: [
+        {
+          key: "edgeIds",
+          kind: "board-edge",
+          domain: {
+            type: "target",
+            targetKind: "edge",
+            eligibleTargets: ["e-1", "e-2"],
+            selection: { mode: "many", min: 2, max: 2, distinct: true },
+          },
+        },
+      ],
+    }),
+  ]);
+
+  const recorder: RecordedSubmit[] = [];
+  const board = render(snapshot, () => useBoardInteractions(), recorder);
+
+  const first = await board.select.edge("e-1");
+  expect(first.status).toBe("pending");
+  if (first.status !== "pending") {
+    throw new Error("Expected pending board selection result");
+  }
+  expect(first.missingInputs).toEqual(["edgeIds"]);
+  expect(recorder).toEqual([]);
+
+  const second = await board.select.edge("e-2");
+  expect(second.status).toBe("submitted");
+  expect(recorder).toEqual([
+    {
+      playerId: "player-1",
+      interactionId: "buildJumpGate",
+      params: { edgeIds: ["e-1", "e-2"] },
+    },
+  ]);
+});
+
 test("useBoardInteractions targetLayers route submit failures to onError", async () => {
   const session = createSessionState();
   const snapshot = createSnapshot(session, [
@@ -570,7 +785,11 @@ test("useBoardInteractions only exposes hand-card board targets after the card a
   expect(Array.from(armed.eligible.space)).toEqual(["space-7"]);
 
   const fired = await armed.select.space("space-7");
-  expect(fired).toBe("play.playKnight");
+  expect(fired.status).toBe("submitted");
+  if (fired.status !== "submitted") {
+    throw new Error("Expected submitted board selection result");
+  }
+  expect(fired.interactionKey).toBe("play.playKnight");
   expect(recorder).toEqual([
     {
       playerId: "player-1",
@@ -580,7 +799,7 @@ test("useBoardInteractions only exposes hand-card board targets after the card a
   ]);
 });
 
-test("useBoardInteractions armed follow-up beats unarmed ambient board action", async () => {
+test("useBoardInteractions armed pending input beats unarmed ambient board action", async () => {
   const session = createSessionState();
   const snapshot = createSnapshot(session, [
     createDescriptor({
@@ -611,7 +830,11 @@ test("useBoardInteractions armed follow-up beats unarmed ambient board action",
   );
 
   const fired = await board.select.edge("e-shared");
-  expect(fired).toBe("play.playRoadBuilding");
+  expect(fired.status).toBe("submitted");
+  if (fired.status !== "submitted") {
+    throw new Error("Expected submitted board selection result");
+  }
+  expect(fired.interactionKey).toBe("play.playRoadBuilding");
   expect(recorder).toEqual([
     {
       playerId: "player-1",