@dreamboard-games/ui-sdk 0.0.43 → 0.0.45

package/src/primitives/zone.test.tsx

@@ -0,0 +1,305 @@
+import { expect, test } from "bun:test";
+import { renderToString } from "react-dom/server";
+import type {
+  InteractionDescriptor,
+  PluginStateSnapshot,
+} from "../types/plugin-state.js";
+import type { RuntimeAPI, PluginSessionState } from "../types/runtime-api.js";
+import { GameUIProvider } from "./game-ui-provider.js";
+import { Zone } from "./zone.js";
+
+function createSessionState(): PluginSessionState {
+  return {
+    status: "ready",
+    sessionId: "session-1",
+    controllablePlayerIds: ["player-1"],
+    controllingPlayerId: "player-1",
+    userId: "user-1",
+  };
+}
+
+function createSnapshot(): PluginStateSnapshot {
+  return {
+    view: {},
+    gameplay: {
+      currentPhase: "setup",
+      currentStage: null,
+      activePlayers: ["player-1"],
+      zones: {
+        discard: {
+          cardIds: ["card-1", "card-2"],
+          cardsById: {
+            "card-1": '{"id":"card-1","cardType":"tech","properties":{}}',
+            "card-2": '{"id":"card-2","cardType":"tech","properties":{}}',
+          },
+          playableByCardId: {
+            "card-1": [],
+            "card-2": [],
+          },
+        },
+      },
+      availableInteractions: [],
+    },
+    lobby: null,
+    notifications: [],
+    session: createSessionState(),
+    history: null,
+    syncId: 1,
+  };
+}
+
+function createCardDescriptor(
+  interactionId: string,
+  options: Partial<InteractionDescriptor> = {},
+): InteractionDescriptor {
+  return {
+    phaseName: "play",
+    interactionKey: `play.${interactionId}`,
+    interactionId,
+    surface: "hand",
+    kind: "action",
+    label: interactionId,
+    zoneId: "discard",
+    inputs: [
+      {
+        key: "cardId",
+        kind: "card",
+        domain: {
+          type: "target",
+          targetKind: "card",
+          eligibleTargets: ["card-1"],
+        },
+      },
+    ],
+    commit: { mode: "manual" },
+    available: true,
+    ...options,
+  };
+}
+
+function createRuntime(snapshot: PluginStateSnapshot): RuntimeAPI {
+  return {
+    validateInteraction: async () => ({ valid: true }),
+    submitInteraction: async () => undefined,
+    getSessionState: () => snapshot.session,
+    disconnect: () => undefined,
+    getSnapshot: () => snapshot,
+    subscribeToState: () => () => undefined,
+  } as RuntimeAPI;
+}
+
+test("Zone pile primitives expose projected card state headlessly", () => {
+  const html = renderToString(
+    <GameUIProvider runtime={createRuntime(createSnapshot())}>
+      <Zone.PileRoot zone="discard" label="Discard">
+        <Zone.PileLabel />
+        <Zone.PileTrigger>
+          <Zone.PileCount />
+        </Zone.PileTrigger>
+        <Zone.PileDescription />
+        <Zone.PileCards renderCard={(card) => <span>{card.id}</span>} />
+      </Zone.PileRoot>
+    </GameUIProvider>,
+  );
+
+  expect(html).toContain('data-dreamboard-zone-root=""');
+  expect(html).toContain('data-dreamboard-zone-pile-trigger=""');
+  expect(html).toContain('data-card-count="2"');
+  expect(html).toContain("Discard");
+  expect(html).toContain("2 cards");
+  expect(html).not.toContain('data-dreamboard-zone-pile-description=""');
+  expect(html).toContain('data-dreamboard-zone-item=""');
+  expect(html).toContain('data-card-id="card-1"');
+  expect(html).toContain('data-card-id="card-2"');
+});
+
+test("Zone.TopCard and Zone.CardAt render positional cards with zone context", () => {
+  const html = renderToString(
+    <GameUIProvider runtime={createRuntime(createSnapshot())}>
+      <Zone.TopCard zone="discard">
+        {(card) => <span>top:{card.id}</span>}
+      </Zone.TopCard>
+      <Zone.Root zone="discard">
+        <Zone.CardAt index={0}>
+          {(card) => <span>first:{card.id}</span>}
+        </Zone.CardAt>
+        <Zone.CardAt index={-1}>
+          {(card) => <span>bottom:{card.id}</span>}
+        </Zone.CardAt>
+      </Zone.Root>
+    </GameUIProvider>,
+  );
+
+  expect(html).toContain("top:");
+  expect(html).toContain("first:");
+  expect(html).toContain("bottom:");
+  expect(html).toContain('data-card-id="card-1"');
+  expect(html).toContain('data-card-id="card-2"');
+});
+
+test("Zone.CardAt renders empty for hidden, empty, and out-of-range positions", () => {
+  const snapshot = createSnapshot();
+  snapshot.gameplay.zones.empty = {
+    cardIds: [],
+    cardsById: {},
+    playableByCardId: {},
+  };
+
+  const html = renderToString(
+    <GameUIProvider runtime={createRuntime(snapshot)}>
+      <Zone.CardAt zone="empty" index={0} empty={<span>empty-zone</span>} />
+      <Zone.CardAt zone="discard" index={3} empty={<span>out-of-range</span>} />
+      <Zone.CardAt zone="missing" index={0} empty={<span>hidden-zone</span>} />
+    </GameUIProvider>,
+  );
+
+  expect(html).toContain("empty-zone");
+  expect(html).toContain("out-of-range");
+  expect(html).toContain("hidden-zone");
+});
+
+test("Zone.CardAction routes card actions and exposes ambiguity escape hatch", () => {
+  const snapshot = createSnapshot();
+  snapshot.gameplay.zones.discard.playableByCardId = {
+    "card-1": [
+      createCardDescriptor("playCard"),
+      createCardDescriptor("discardCard"),
+    ],
+  };
+  const runtime = createRuntime(snapshot);
+
+  const ambiguousHtml = renderToString(
+    <GameUIProvider runtime={runtime}>
+      <Zone.Root zone="discard">
+        <Zone.Item card="card-1">
+          <Zone.CardAction>Play</Zone.CardAction>
+        </Zone.Item>
+      </Zone.Root>
+    </GameUIProvider>,
+  );
+  const explicitHtml = renderToString(
+    <GameUIProvider runtime={runtime}>
+      <Zone.Root zone="discard">
+        <Zone.Item card="card-1">
+          <Zone.CardAction interaction="play.playCard">Play</Zone.CardAction>
+        </Zone.Item>
+      </Zone.Root>
+    </GameUIProvider>,
+  );
+
+  expect(ambiguousHtml).toContain('data-ambiguous="true"');
+  expect(ambiguousHtml).toContain("disabled=");
+  expect(explicitHtml).toContain('data-dreamboard-zone-card-action=""');
+  expect(explicitHtml).toContain('data-card-id="card-1"');
+  expect(explicitHtml).toContain('data-interaction-key="play.playCard"');
+  expect(explicitHtml).toContain('data-input-name="cardId"');
+  expect(explicitHtml).not.toContain('data-ambiguous="true"');
+});
+
+test("Zone.CardAction explicit input still requires an eligible card target", () => {
+  const snapshot = createSnapshot();
+  snapshot.gameplay.zones.discard.playableByCardId = {
+    "card-1": [
+      createCardDescriptor("playCard", {
+        inputs: [
+          {
+            key: "otherCardId",
+            kind: "card",
+            domain: {
+              type: "target",
+              targetKind: "card",
+              eligibleTargets: ["card-2"],
+            },
+          },
+        ],
+      }),
+    ],
+  };
+
+  const html = renderToString(
+    <GameUIProvider runtime={createRuntime(snapshot)}>
+      <Zone.Root zone="discard">
+        <Zone.Item card="card-1">
+          <Zone.CardAction interaction="play.playCard" input="otherCardId">
+            Play
+          </Zone.CardAction>
+        </Zone.Item>
+      </Zone.Root>
+    </GameUIProvider>,
+  );
+
+  expect(html).toContain('data-interaction-key="play.playCard"');
+  expect(html).toContain('data-input-name="otherCardId"');
+  expect(html).toContain('data-eligible="false"');
+  expect(html).toContain("disabled=");
+});
+
+test("Zone pile primitives hide piles whose zone is not in projection scope", () => {
+  // The `deck` zone has no entry in the snapshot — it isn't in the current
+  // phase's projection scope. The pile renders with hidden semantics and no
+  // PileCards iteration, instead of fabricating items.
+  const html = renderToString(
+    <GameUIProvider runtime={createRuntime(createSnapshot())}>
+      <Zone.PileRoot zone="deck" label="Deck" hiddenDescription="Hidden deck.">
+        <Zone.PileTrigger>
+          <Zone.PileCount />
+        </Zone.PileTrigger>
+        <Zone.PileDescription />
+        <Zone.PileCards renderCard={(card) => <span>{card.id}</span>} />
+      </Zone.PileRoot>
+    </GameUIProvider>,
+  );
+
+  expect(html).toContain('data-card-count="0"');
+  expect(html).toContain("0 cards");
+  expect(html).toContain("Hidden deck.");
+  expect(html).not.toContain('data-dreamboard-zone-list=""');
+  expect(html).not.toContain('data-dreamboard-zone-item=""');
+});
+
+test("Zone pile primitives surface card ids the snapshot withholds as hidden items", () => {
+  // Snapshot exposes cardIds but no cardsById entries — e.g. a future
+  // visibility mode that surfaces a count and ids without contents. The
+  // primitive must not fabricate a `cardType: "unknown"` ViewCard; it should
+  // discriminate via `card.hidden === true`.
+  const snapshot = createSnapshot();
+  snapshot.gameplay.zones.opaque = {
+    cardIds: ["card-x"],
+    cardsById: {},
+    playableByCardId: {},
+  };
+
+  const html = renderToString(
+    <GameUIProvider runtime={createRuntime(snapshot)}>
+      <Zone.PileRoot zone="opaque" label="Opaque">
+        <Zone.PileCards
+          renderCard={(card) =>
+            card.hidden ? <span>hidden:{card.id}</span> : <span>{card.id}</span>
+          }
+        />
+      </Zone.PileRoot>
+    </GameUIProvider>,
+  );
+
+  expect(html).toContain("card-x");
+  expect(html).toContain("hidden:");
+  expect(html).toContain('data-card-hidden="true"');
+  expect(html).not.toContain('data-card-type="unknown"');
+});
+
+test("Zone pile descriptions render when configured", () => {
+  const html = renderToString(
+    <GameUIProvider runtime={createRuntime(createSnapshot())}>
+      <Zone.PileRoot
+        zone="discard"
+        label="Discard"
+        visibleDescription={(count) => `${count} visible cards.`}
+      >
+        <Zone.PileDescription />
+      </Zone.PileRoot>
+    </GameUIProvider>,
+  );
+
+  expect(html).toContain('data-dreamboard-zone-pile-description=""');
+  expect(html).toContain("2 visible cards.");
+});