@dreamboard-games/ui-sdk 0.0.42 → 0.0.45

package/src/hooks/useInteractionHandle.ts

@@ -17,13 +17,17 @@ import type { InteractionDescriptor } from "../types/plugin-state.js";
 import {
   applyInteractionInputDefaults,
   hasInteractionFieldErrors,
-  inputByKey,
-  isInputValueReady,
   interactionArmScope,
   interactionInputKeys,
   mergeInteractionFieldErrors,
   validateInteractionInputDomains,
 } from "../utils/interaction-inputs.js";
+import {
+  applyInteractionDraftMutation,
+  claimInteractionSubmit,
+  clearInteractionRoute,
+  getInteractionDraftReadiness,
+} from "../utils/interaction-router.js";
 
 /**
  * Anything that can be used as a submit params object. Subset of TS
@@ -115,7 +119,7 @@ export interface InteractionHandle<
   isReady: boolean;
   /**
    * True when this interaction is the currently armed one on its surface.
-   * Armed interactions are the ones that surfaces like `BoardSurface` use
+   * Armed interactions are the ones that board primitives use
    * to highlight eligible targets and route clicks.
    */
   isArmed: boolean;
@@ -184,16 +188,11 @@ export function useInteractionHandle<
       : "open";
 
   const isReady = useMemo(() => {
-    const required = inputKeys;
-    if (required.length === 0) return true;
-    return required.every((key) => {
-      const input = inputByKey(descriptor, key);
-      const value = (values as Record<string, unknown>)[key];
-      return input
-        ? isInputValueReady(input, value)
-        : value !== null && value !== undefined;
-    });
-  }, [descriptor, values, inputKeys]);
+    return getInteractionDraftReadiness(
+      descriptor,
+      values as Record<string, unknown>,
+    ).ready;
+  }, [descriptor, values]);
 
   const requirePlayer = useCallback(() => {
     if (!controllingPlayerId) {
@@ -212,8 +211,13 @@ export function useInteractionHandle<
             : "Interaction submission is already in progress.",
         );
       }
+      if (!claimInteractionSubmit(store, descriptor)) {
+        throw new ValidationError(
+          "SUBMITTING",
+          "Interaction submission is already in progress.",
+        );
+      }
       submittingRef.current = true;
-      store.setSubmitting(interactionKey, true);
       const finalParams = applyInteractionInputDefaults<Params>(
         descriptor,
         params ?? values,
@@ -224,10 +228,7 @@ export function useInteractionHandle<
           interactionId,
           finalParams as Record<string, unknown>,
         );
-        store.clearInput(interactionKey);
-        if (store.getArmed(armScope) === interactionKey) {
-          store.arm(armScope, null);
-        }
+        clearInteractionRoute(store, descriptor);
       } catch (error) {
         throw validationErrorFromUnknown(error);
       } finally {
@@ -242,7 +243,6 @@ export function useInteractionHandle<
       requirePlayer,
       interactionId,
       interactionKey,
-      armScope,
       store,
       status,
     ],
@@ -269,13 +269,8 @@ export function useInteractionHandle<
   const validateDraft = useCallback((): DraftValidation<Params> => {
     const rawDraft = { ...values } as Record<string, unknown>;
     const required = inputKeys;
-    const missing = required.filter((key) => {
-      const input = inputByKey(descriptor, key);
-      const value = rawDraft[key];
-      return input
-        ? !isInputValueReady(input, value)
-        : value === null || value === undefined;
-    }) as Array<keyof Params & string>;
+    const missing = getInteractionDraftReadiness(descriptor, rawDraft)
+      .missingInputs as Array<keyof Params & string>;
     const domainFieldErrors = validateInteractionInputDomains(
       descriptor,
       rawDraft,
@@ -392,9 +387,9 @@ export function useInteractionHandle<
 
   const setInput = useCallback(
     <K extends keyof Params & string>(key: K, value: Params[K]) => {
-      store.setInput(interactionKey, key, value as unknown);
+      applyInteractionDraftMutation(store, descriptor, [{ key, value }]);
     },
-    [store, interactionKey],
+    [store, descriptor],
   );
 
   const clearInput = useCallback(

package/src/index.test.ts

@@ -1,14 +1,11 @@
 import { readdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import { expect, test } from "bun:test";
+import type { ComponentProps } from "react";
 import * as components from "./components/index.js";
 import * as defaults from "./defaults/index.js";
 import * as sdk from "./index.js";
-import type {
-  CardCollection,
-  ViewCard,
-  ViewSlotOccupant,
-} from "@dreamboard/sdk-types";
+import type { ViewSlotOccupant } from "@dreamboard/sdk-types";
 import {
   BoardEdgeIdOf,
   BoardSpaceIdOf,
@@ -32,17 +29,6 @@ import {
   type SquareGridProps,
   type SquarePieceState,
   type SquareVertexState,
-  useBoardTopology,
-  useCards,
-  useHandLayout,
-  useHexBoard,
-  useInteractionHandle,
-  useIsMobile,
-  usePanZoom,
-  usePluginRuntime,
-  usePluginState,
-  useSeatInbox,
-  useSquareBoard,
 } from "./index.js";
 
 async function walkFiles(rootDir: string): Promise<string[]> {
@@ -72,15 +58,33 @@ async function walkFiles(rootDir: string): Promise<string[]> {
 test("top-level ui-sdk exports the headless scaffold support surface", () => {
   expect(RuntimeProvider).toBeDefined();
   expect(PluginStateProvider).toBeDefined();
-  expect(usePluginRuntime).toBeDefined();
-  expect(usePluginState).toBeDefined();
-  expect(useHandLayout).toBeDefined();
-  expect(usePanZoom).toBeDefined();
-  expect(useIsMobile).toBeDefined();
   expect(calculateViewBox).toBeDefined();
   expect(toTrackBoardData).toBeDefined();
-  expect(useSeatInbox).toBeDefined();
-  expect(useInteractionHandle).toBeDefined();
+  for (const exportName of [
+    "useActivePlayers",
+    "useBoardInteractions",
+    "useBoardTopology",
+    "useCards",
+    "useGameView",
+    "useHandLayout",
+    "useHexBoard",
+    "useInteractionByKey",
+    "useInteractionHandle",
+    "useIsMobile",
+    "usePanZoom",
+    "usePlayerInfo",
+    "usePlayerTurnOrder",
+    "usePluginActions",
+    "usePluginRuntime",
+    "usePluginSession",
+    "usePluginState",
+    "useRuntimeContext",
+    "useSeatInbox",
+    "useSquareBoard",
+    "useToast",
+  ]) {
+    expect(exportName in sdk).toBe(false);
+  }
 });
 
 test("top-level ui-sdk is the canonical root for visual components", () => {
@@ -91,7 +95,7 @@ test("top-level ui-sdk is the canonical root for visual components", () => {
   expect("ActionButton" in sdk).toBe(true);
   expect("Dialog" in sdk).toBe(true);
   expect("DialogContent" in sdk).toBe(true);
-  expect("PromptDialogHost" in sdk).toBe(true);
+  expect("PromptDialogHost" in sdk).toBe(false);
 });
 
 test("top-level ui-sdk no longer exports the legacy interaction-button theme primitives", () => {
@@ -108,6 +112,19 @@ test("top-level ui-sdk no longer exports the legacy interaction-button theme pri
   }
 });
 
+test("top-level ui-sdk no longer exports secondary interaction shortcuts", () => {
+  for (const exportName of [
+    "InteractionButton",
+    "InteractionDialogForm",
+    "InteractionButtonProps",
+    "InteractionDialogFormProps",
+  ]) {
+    expect(exportName in sdk).toBe(false);
+  }
+  expect("Button" in sdk.Interaction).toBe(false);
+  expect("DialogForm" in sdk.Interaction).toBe(false);
+});
+
 test("top-level ui-sdk publishes the unified Theme contract", () => {
   expect("ThemeProvider" in sdk).toBe(true);
   expect("useTheme" in sdk).toBe(true);
@@ -128,10 +145,27 @@ test("top-level ui-sdk publishes the UI contract registration scaffold", () => {
   });
 
   expect(ui.contract.interactions?.["setup.ready"]).toEqual({});
-  expect(ui.PromptDialogHost).toBeDefined();
+  expect(ui.Game).toBeDefined();
+  expect("PromptDialogHost" in ui).toBe(false);
+  expect("Button" in ui.Interaction).toBe(false);
+  expect("DialogForm" in ui.Interaction).toBe(false);
   expect(ui.PlayerRoster).toBeDefined();
 });
 
+test("empty UI contract buckets stay string-compatible", () => {
+  const ui = sdk.createDreamboardUI({
+    inputs: {},
+    cards: {},
+  });
+  const cardInputProps: ComponentProps<typeof ui.Interaction.CardInput> = {
+    input: "cardId",
+    card: "tech-card-1",
+  };
+
+  expect(ui.Interaction.CardInput).toBeDefined();
+  expect(cardInputProps.input).toBe("cardId");
+});
+
 test("top-level ui-sdk exposes PlayerRoster as the only player roster primitive", () => {
   expect("PlayerRoster" in sdk).toBe(true);
   for (const exportName of [
@@ -180,7 +214,7 @@ test("components subpath does not export shell slot internals", () => {
 
 test("defaults subpath exposes primitive-composed Radix-style defaults", () => {
   expect("GameLayout" in defaults).toBe(true);
-  expect("DefaultPromptInbox" in defaults).toBe(true);
+  expect("DefaultPromptInbox" in defaults).toBe(false);
   expect("DefaultInteractionList" in defaults).toBe(true);
   expect("DefaultInteractionForm" in defaults).toBe(true);
   expect("DefaultZone" in defaults).toBe(true);
@@ -385,18 +419,6 @@ test("tiled board hooks and types accept generated board-state records", () => {
     generatedSquareBoard;
   const _squareTopologyInput: Parameters<typeof useBoardTopology>[0] =
     generatedSquareBoard;
-  const _useCardsArgs: [Parameters<typeof useCards>[0]] = [
-    {
-      cardIds: ["card-1"] as const,
-      cardsById: {
-        "card-1": {
-          id: "card-1",
-          cardType: "goods",
-          properties: {},
-        },
-      },
-    } satisfies CardCollection<string, ViewCard>,
-  ];
   const _readonlySquareEdge = {
     id: "a1$$a2",
     spaceIds: ["a1", "a2"] as const,
@@ -454,7 +476,6 @@ test("tiled board hooks and types accept generated board-state records", () => {
     _hexTopologyInput,
     _squareHookInput,
     _squareTopologyInput,
-    _useCardsArgs,
     _readonlySquareEdge,
     _readonlySquareVertex,
     _squarePiece,
@@ -469,6 +490,5 @@ test("tiled board hooks and types accept generated board-state records", () => {
     _squareVertexId,
   ];
 
-  expect(_useCardsArgs[0].cardsById["card-1"]?.cardType).toBe("goods");
   expect(_trackBoardData.pieces[0]?.spaceId).toBe("start");
 });

package/src/index.ts

@@ -1,4 +1,3 @@
-export * from "./reducer.js";
 export {
   createDreamboardUI,
   type BoardTargetKey,
@@ -12,6 +11,7 @@ export {
   type PromptKey,
   type RegisteredUI,
   type TypedBoard,
+  type TypedGame,
   type TypedInteraction,
   type TypedPhase,
   type TypedPlayerRoster,
@@ -23,34 +23,11 @@ export {
   type ZoneKey,
 } from "./ui-contract.js";
 export * from "./primitives/index.js";
-export {
-  BoardInteractionConflictError,
-  useBoardInteractions,
-  type BoardInteractionsContext,
-  type BoardInteractionsOptions,
-  type BoardTargetLayerFactory,
-  type BoardTargetLayerOptions,
-} from "./hooks/useBoardInteractions.js";
-export { useBoardTopology } from "./hooks/useBoardTopology.js";
-export { useCards } from "./hooks/useCards.js";
-export { useHexBoard } from "./hooks/useHexBoard.js";
-export { useSquareBoard } from "./hooks/useSquareBoard.js";
-export { useHandLayout } from "./hooks/useHandLayout.js";
-export { useInteractionByKey } from "./hooks/useInteractionByKey.js";
-export { useIsMobile } from "./hooks/useIsMobile.js";
-export { usePanZoom, calculateViewBox } from "./hooks/usePanZoom.js";
-export { usePluginRuntime } from "./hooks/usePluginRuntime.js";
+export type { BoardSelectionResult } from "./hooks/useBoardInteractions.js";
+export { calculateViewBox } from "./hooks/usePanZoom.js";
 export { toTrackBoardData } from "./helpers/track-board.js";
-export {
-  PluginStateProvider,
-  usePluginActions,
-  usePluginState,
-} from "./context/PluginStateContext.js";
-export {
-  RuntimeContext,
-  RuntimeProvider,
-  useRuntimeContext,
-} from "./context/RuntimeContext.js";
+export { PluginStateProvider } from "./context/PluginStateContext.js";
+export { RuntimeContext, RuntimeProvider } from "./context/RuntimeContext.js";
 export {
   type ClientParamSchema,
   type ClientParamSchemaMap,
@@ -102,24 +79,41 @@ export {
   normalizeSquareBoardInput,
 } from "./types/tiled-board.js";
 export {
-  InteractionField,
   InteractionForm,
   defaultFormInputs,
   hasDefaultInteractionFormFields,
 } from "./components/InteractionForm.js";
-export type {
-  InteractionFieldProps,
-  InteractionFieldRenderMap,
-  InteractionFieldRenderProps,
-  InteractionFormProps,
-} from "./components/InteractionForm.js";
+export type { InteractionFormProps } from "./components/InteractionForm.js";
 export * from "./components/index.js";
 export type * from "./hooks/useHandLayout.js";
 export type * from "./hooks/usePanZoom.js";
 export type * from "./hooks/usePluginRuntime.js";
-export type { PluginStateSnapshot } from "./types/plugin-state.js";
+export type {
+  InteractionContext,
+  InteractionContextOption,
+  InteractionDescriptor,
+  InputDomainDependencyCase,
+  PluginStateSnapshot,
+} from "./types/plugin-state.js";
+export {
+  hexColor,
+  isHexColor,
+  parseHexColor,
+  type HexColor,
+} from "./types/hex-color.js";
 export type * from "./types/player-state.js";
 export type * from "./types/runtime-api.js";
+export type {
+  DraftValidation,
+  InteractionHandle,
+  InteractionHandleStatus,
+  InteractionParamsShape,
+} from "./hooks/useInteractionHandle.js";
+export type {
+  CardCollection,
+  ViewCard,
+  ViewSlotOccupant,
+} from "@dreamboard/sdk-types";
 export type {
   AnyHexBoardInput,
   AnySquareBoardInput,

package/src/primitives/board.test.tsx

@@ -100,6 +100,25 @@ test("Board.Target exposes reducer-projected target eligibility", () => {
   expect(html).not.toContain('data-ambiguous="true"');
 });
 
+test("Board target kind aliases use the canonical target router surface", () => {
+  const runtime = createRuntime(
+    createSnapshot([createBoardDescriptor("claimSpace")]),
+  );
+
+  const html = renderToString(
+    <GameUIProvider runtime={runtime}>
+      <Board.Root>
+        <Board.SpaceTarget value="space-1">Space one</Board.SpaceTarget>
+      </Board.Root>
+    </GameUIProvider>,
+  );
+
+  expect(html).toContain('data-dreamboard-board-target=""');
+  expect(html).toContain('data-target-kind="space"');
+  expect(html).toContain('data-target-id="space-1"');
+  expect(html).toContain('data-eligible="true"');
+});
+
 test("Board.Target requires explicit routing when equal-priority matches are ambiguous", () => {
   const runtime = createRuntime(
     createSnapshot([
@@ -137,3 +156,57 @@ test("Board.Target requires explicit routing when equal-priority matches are amb
   expect(explicitHtml).toContain('data-input-name="spaceId"');
   expect(explicitHtml).not.toContain('data-ambiguous="true"');
 });
+
+test("Board.State exposes the generated board interaction context", () => {
+  const runtime = createRuntime(
+    createSnapshot([createBoardDescriptor("move")]),
+  );
+  const html = renderToString(
+    <GameUIProvider runtime={runtime}>
+      <Board.Root>
+        <Board.State>
+          {(board) => (
+            <output
+              data-interactions={board.interactions.length}
+              data-eligible={board.isEligible("space-1", "space")}
+            />
+          )}
+        </Board.State>
+      </Board.Root>
+    </GameUIProvider>,
+  );
+
+  expect(html).toContain('data-interactions="1"');
+  expect(html).toContain('data-eligible="true"');
+});
+
+test("Board.HexView joins static hex topology with typed space overlays", () => {
+  const staticBoard = {
+    id: "island",
+    layout: "hex",
+    orientation: "pointy-top",
+    tiles: [
+      { id: "space-1", q: 0, r: 0 },
+      { id: "space-2", q: 1, r: 0 },
+    ],
+    edges: [],
+    vertices: [],
+  } as const;
+  const spaces = [
+    { id: "space-1", terrain: "forest" },
+    { id: "space-2", terrain: "field" },
+  ] as const;
+
+  const html = renderToString(
+    <Board.HexView board={staticBoard} spaces={spaces}>
+      {(view) => (
+        <span>
+          board:{view.id} first:{view.tiles[0]?.view.terrain}
+        </span>
+      )}
+    </Board.HexView>,
+  ).replace(/<!-- -->/g, "");
+
+  expect(html).toContain("board:island");
+  expect(html).toContain("first:forest");
+});