@dreamboard-games/sdk 0.5.0-alpha.3 → 0.5.0-alpha.4

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   AmbiguousTargetError,
   createGameInstance
-} from "./chunk-SP234IY4.js";
+} from "./chunk-OOFMBCFF.js";
 import {
   BoardStaticProjectionSchema,
   CancelInteractionCommandSchema,
@@ -36,7 +36,7 @@ import {
   parsePluginSessionDescriptor,
   parsePluginToHostEnvelope,
   staticSource
-} from "./chunk-ZPRKWPEP.js";
+} from "./chunk-UG2Q4NLG.js";
 import "./chunk-DMFVAZI2.js";
 import {
   InputDomainSchema,
@@ -49,11 +49,14 @@ import {
   createHexBoardGeometry,
   digestPluginRuntimeJson,
   encodeCanonicalPluginRuntimeJson
-} from "./chunk-FMM5LVJW.js";
-import "./chunk-VUWNJXLJ.js";
+} from "./chunk-XU6WJW6K.js";
+import {
+  inputValueKey,
+  requireLookup
+} from "./chunk-3JXUL4VN.js";
 
 // src/package-set.ts
-var DREAMBOARD_SDK_VERSION = true ? "0.5.0-alpha.3" : "0.0.0-development";
+var DREAMBOARD_SDK_VERSION = true ? "0.5.0-alpha.4" : "0.0.0-development";
 var DREAMBOARD_SDK_PACKAGES = {
   "@dreamboard-games/sdk": DREAMBOARD_SDK_VERSION
 };
@@ -89,6 +92,10 @@ function iframeSource(options = {}) {
     recover: () => send({ type: "runtime.resume" }),
     close: () => target.removeEventListener("message", receive)
   });
+  const isOpen = () => {
+    const { connection } = lifecycle.source.store.get();
+    return connection !== "closed" && connection !== "failed";
+  };
   function receive(event) {
     if (event.source !== parent) return;
     const parsed = HostToPluginEnvelopeSchema.safeParse(event.data);
@@ -118,13 +125,11 @@ function iframeSource(options = {}) {
     const payload = envelope.payload;
     if (payload.type === "runtime.init") {
       lifecycle.session(payload.session);
-      if (lifecycle.source.store.get().connection !== "closed")
-        send({ type: "runtime.ready" });
+      if (isOpen()) send({ type: "runtime.ready" });
     } else if (payload.type === "gameplay.frame")
       lifecycle.frame(payload.frame);
     else lifecycle.result(payload);
-    if (lifecycle.source.store.get().connection !== "closed")
-      send({ type: "runtime.ack", sequence: envelope.sequence });
+    if (isOpen()) send({ type: "runtime.ack", sequence: envelope.sequence });
   }
   target.addEventListener("message", receive);
   return lifecycle.source;
@@ -484,7 +489,10 @@ function boardFeature(game, context) {
       return cached.collection;
     const projected = model.view;
     const boards = Object.values(projected?.boards?.byId ?? {}).map((data) => {
-      const board = context.createBoard(data.id, data);
+      const board = context.createBoard(
+        data.id,
+        data
+      );
       let geometry = geometries.get(data);
       if (!geometry && data.layout === "hex") {
         geometry = createHexBoardGeometry({
@@ -500,6 +508,9 @@ function boardFeature(game, context) {
     const byId = new Map(boards.map((board) => [board.id, board]));
     const result = Object.freeze({
       get(id) {
+        return requireLookup(byId.get(id), "Board", id);
+      },
+      find(id) {
         return byId.get(id);
       },
       getAll: () => Object.freeze(boards)
@@ -512,6 +523,115 @@ function boardFeature(game, context) {
     };
     return result;
   }
+  function targetsFor(owner) {
+    const board = owner.data;
+    const captured = captures.get(owner);
+    function matchingTargets(model, kind, id) {
+      const inputKinds = kind === "space" ? ["space", "tile"] : [kind];
+      return model.interactions.list().flatMap(
+        (interaction) => interaction.getInputs().filter((input) => {
+          const domain = input.getDomain();
+          return domain.type === "boardTarget" && inputKinds.includes(String(domain.targetKind)) && (domain.valueKind === "player-board-space" ? board.scope === "perPlayer" && domain.boardId === board.baseId : domain.boardId === board.id);
+        }).map((input) => {
+          const domain = input.getDomain();
+          return {
+            interaction,
+            input,
+            value: domain.type === "boardTarget" && domain.valueKind === "player-board-space" ? Object.freeze({
+              boardId: board.baseId,
+              playerId: board.playerId,
+              spaceId: id
+            }) : id
+          };
+        })
+      );
+    }
+    function target(kind, id) {
+      const matches = matchingTargets(captured.model, kind, id);
+      const eligible = matches.some(
+        ({ input, value }) => input.getIsEligible(value)
+      );
+      const selected = matches.some(
+        ({ input, value }) => input.getIsSelected(value)
+      );
+      const selectable = matches.some(
+        ({ input, value }) => !input.getTargetProps(value).disabled
+      );
+      function select(options) {
+        if (game.getOptions().source !== captured.source || game.snapshot?.me !== captured.model.snapshot?.me)
+          return;
+        const matching = matchingTargets(game.getSnapshot(), kind, id).filter(
+          ({ interaction, input, value: value2 }) => (!options?.interaction || options.interaction === interaction.key) && (!options?.input || options.input === input.key) && !input.getTargetProps(value2).disabled
+        );
+        if (!matching.length) return;
+        if (matching.length > 1) throw new AmbiguousTargetError(id);
+        const domain = matching[0].input.getDomain();
+        if (domain.type !== "boardTarget") return;
+        const value = matching[0].value;
+        const target2 = domain.valueKind === "player-board-space" && typeof value !== "string" ? { kind: "space", valueKind: domain.valueKind, value } : {
+          kind,
+          valueKind: "board-id",
+          value: id,
+          boardId: board.id
+        };
+        context.routeTarget(target2, {
+          interaction: matching[0].interaction.key,
+          input: matching[0].input.key
+        });
+      }
+      return {
+        id,
+        getIsEligible: () => eligible,
+        getIsSelectable: () => selectable,
+        getIsSelected: () => selected,
+        getSelectHandler: (options) => () => select(options),
+        getTargetProps(options) {
+          const candidates = matches.filter(
+            ({ interaction, input, value }) => (!options?.interaction || interaction.key === options.interaction) && (!options?.input || options.input === input.key) && !input.getTargetProps(value).disabled
+          );
+          const only = candidates.length === 1 ? candidates[0] : void 0;
+          return {
+            type: "button",
+            disabled: candidates.length === 0,
+            "data-action": "select",
+            "data-value": only && typeof only.value !== "string" ? JSON.stringify(only.value) : id,
+            "data-board": board.id,
+            "data-interaction": options?.interaction ?? only?.interaction.key,
+            "data-input": only?.input.key,
+            "data-eligible": eligible,
+            "data-selected": selected,
+            "data-disabled": candidates.length === 0,
+            onClick: () => select(options)
+          };
+        }
+      };
+    }
+    return target;
+  }
+  const spaceCollections = /* @__PURE__ */ new WeakMap();
+  function spacesFor(owner) {
+    const cached2 = spaceCollections.get(owner);
+    if (cached2) return cached2;
+    const target = targetsFor(owner);
+    const data = owner.data;
+    const values = Object.freeze(
+      Object.values(data.spaces).map(
+        (space) => Object.freeze({
+          ...target("space", space.id),
+          data: space,
+          board: owner
+        })
+      )
+    );
+    const byId = new Map(values.map((space) => [space.id, space]));
+    const spaces = Object.freeze({
+      get: (id) => requireLookup(byId.get(id), `Space on board ${owner.id}`, id),
+      find: (id) => byId.get(id),
+      getAll: () => values
+    });
+    spaceCollections.set(owner, spaces);
+    return spaces;
+  }
   return {
     root: {
       get boards() {
@@ -519,11 +639,14 @@ function boardFeature(game, context) {
       }
     },
     board: {
+      get spaces() {
+        return spacesFor(this);
+      },
       getLayout(options) {
         const board = this.data;
         if (board.layout === "generic")
           throw new Error(
-            `Board '${board.id}' has no spatial geometry; read its data instead.`
+            `Board '${board.id}' has no spatial geometry; use board.spaces for semantic selection.`
           );
         const {
           hexSize,
@@ -546,70 +669,16 @@ function boardFeature(game, context) {
           x: value.x * viewport.scale + viewport.x,
           y: value.y * viewport.scale + viewport.y
         });
-        function matchingTargets(model, kind) {
-          const inputKinds = kind === "space" ? ["space", "tile"] : [kind];
-          return model.interactions.list().flatMap(
-            (interaction) => interaction.getInputs().filter((input) => {
-              const domain = input.getDomain();
-              return domain.type === "boardTarget" && inputKinds.includes(String(domain.targetKind)) && (domain.boardId === board.id || domain.boardId === board.baseId) && (board.scope !== "perPlayer" || board.playerId === model.me?.id);
-            }).map((input) => ({ interaction, input }))
-          );
-        }
-        function target(kind, id) {
-          const matches = matchingTargets(captured.model, kind);
-          const eligible = matches.some(({ input }) => input.getIsEligible(id));
-          const selected = matches.some(({ input }) => input.getIsSelected(id));
-          const selectable = matches.some(
-            ({ input }) => !input.getTargetProps(id).disabled
-          );
-          function select(options2) {
-            if (game.getOptions().source !== captured.source || game.snapshot?.me !== captured.model.snapshot?.me)
-              return;
-            const matching = matchingTargets(game.getSnapshot(), kind).filter(
-              ({ interaction, input }) => (!options2?.interaction || options2.interaction === interaction.key) && !input.getTargetProps(id).disabled
-            );
-            if (!matching.length) return;
-            const domain = matching[0].input.getDomain();
-            if (domain.type !== "boardTarget") return;
-            context.routeTarget(kind, id, {
-              ...options2,
-              boardId: String(domain.boardId)
-            });
-          }
-          return {
-            id,
-            getIsEligible: () => eligible,
-            getIsSelectable: () => selectable,
-            getIsSelected: () => selected,
-            getSelectHandler: (options2) => () => select(options2),
-            getTargetProps(options2) {
-              const candidates = matches.filter(
-                ({ interaction, input }) => (!options2?.interaction || interaction.key === options2.interaction) && !input.getTargetProps(id).disabled
-              );
-              const only = candidates.length === 1 ? candidates[0] : void 0;
-              return {
-                type: "button",
-                disabled: candidates.length === 0,
-                "data-action": "select",
-                "data-value": id,
-                "data-board": board.id,
-                "data-interaction": options2?.interaction ?? only?.interaction.key,
-                "data-input": only?.input.key,
-                "data-eligible": eligible,
-                "data-selected": selected,
-                "data-disabled": candidates.length === 0,
-                onClick: () => select(options2)
-              };
-            }
-          };
-        }
+        const target = targetsFor(this);
+        const semanticSpaces = spacesFor(this);
         const spaces = Object.freeze(
           geometry.spaces.map((space) => {
             const corners = Object.freeze(space.corners.map(point));
             const center = point(space.center);
             return Object.freeze({
-              ...target("space", space.id),
-              data: board.spaces[space.id],
+              ...semanticSpaces.get(
+                space.id
+              ),
               center,
               points: () => corners,
               transform: `translate(${center.x} ${center.y})`
@@ -655,6 +724,133 @@ function boardFeature(game, context) {
   };
 }
 
+// src/headless/features/drag.ts
+function dragFeature(game, context) {
+  let active = null;
+  let selection;
+  let source = game.getOptions().source;
+  let seat = game.snapshot?.me;
+  let disposed = false;
+  let version = game.snapshot?.version;
+  let lastInteractions = game.interactions;
+  let lastCards = game.cards;
+  let branch = snapshot();
+  function update(next) {
+    if (disposed) return;
+    active = next === null ? null : Object.freeze(next);
+    branch = snapshot();
+    context.invalidate();
+  }
+  function targets(cardId = active?.cardId, selected = selection) {
+    if (!cardId || game.connection !== "ready") return [];
+    const runtime = game;
+    const options = selected;
+    const resolved = (runtime.cards.find(cardId)?.getInteractions() ?? []).flatMap((candidate) => {
+      if (!candidate.getIsAvailable() || options?.interaction && candidate.key !== options.interaction)
+        return [];
+      const inputs = candidate.getInputs();
+      const cardInputs = inputs.filter(
+        (input) => input.getDomain().type === "cardTarget" && (!options?.input || input.key === options.input) && input.getIsEligible(cardId)
+      );
+      return cardInputs.flatMap(
+        (cardInput) => inputs.flatMap((input) => {
+          const domain = input.getDomain();
+          if (domain.type !== "boardTarget") return [];
+          const route = {
+            interactionKey: candidate.key,
+            cardInputKey: cardInput.key,
+            inputKey: input.key
+          };
+          if (domain.valueKind === "player-board-space")
+            return domain.eligibleTargets.filter((value) => !input.getTargetProps(value).disabled).map(
+              (value) => Object.freeze({
+                kind: "space",
+                valueKind: domain.valueKind,
+                value,
+                ...route
+              })
+            );
+          return domain.eligibleTargets.filter((value) => !input.getTargetProps(value).disabled).map(
+            (value) => Object.freeze({
+              kind: domain.targetKind,
+              valueKind: domain.valueKind,
+              value,
+              boardId: domain.boardId,
+              ...route
+            })
+          );
+        })
+      );
+    });
+    return resolved;
+  }
+  function sameTarget(left, right) {
+    return left.kind === right.kind && left.valueKind === right.valueKind && inputValueKey(left.value) === inputValueKey(right.value) && (left.valueKind !== "board-id" || right.valueKind === "board-id" && left.boardId === right.boardId) && left.interactionKey === right.interactionKey && left.cardInputKey === right.cardInputKey && left.inputKey === right.inputKey;
+  }
+  function cancel() {
+    if (active) update(null);
+  }
+  function snapshot() {
+    const captured = active;
+    const dropTargets = Object.freeze(targets());
+    return Object.freeze({
+      active: captured,
+      getCanDrag: (cardId, options) => !disposed && targets(cardId, options).length > 0,
+      begin(cardId, options) {
+        if (disposed || !targets(cardId, options).length) return false;
+        selection = options;
+        update({ cardId, target: null });
+        return true;
+      },
+      getDropTargets: () => dropTargets,
+      setDropTarget(target) {
+        if (!active || disposed) return;
+        if (target && !targets().some((candidate) => sameTarget(candidate, target))) {
+          update({ ...active, target: null });
+          return;
+        }
+        update({ ...active, target });
+      },
+      drop() {
+        const finished = active;
+        const eligible = finished?.target && targets().some((target) => sameTarget(target, finished.target));
+        cancel();
+        if (!disposed && finished?.target && eligible)
+          context.routeCardDrop(finished.cardId, finished.target);
+      },
+      cancel
+    });
+  }
+  const unsubscribe = game.subscribe(() => {
+    const nextSource = game.getOptions().source;
+    const nextSeat = game.snapshot?.me;
+    const nextVersion = game.snapshot?.version;
+    if (nextSource !== source || nextSeat !== seat || nextVersion !== version || game.connection !== "ready") {
+      source = nextSource;
+      seat = nextSeat;
+      version = nextVersion;
+      cancel();
+    }
+  });
+  return {
+    root: {
+      get drag() {
+        if (lastInteractions !== game.interactions || lastCards !== game.cards) {
+          lastInteractions = game.interactions;
+          lastCards = game.cards;
+          branch = snapshot();
+        }
+        return branch;
+      }
+    },
+    dispose() {
+      unsubscribe();
+      cancel();
+      disposed = true;
+    }
+  };
+}
+
 // src/headless/features/pointer-session.ts
 function createPointerSession(callbacks) {
   let disposed = false;
@@ -717,151 +913,6 @@ function createPointerSession(callbacks) {
   };
 }
 
-// src/headless/features/drag.ts
-function dragFeature(game, context) {
-  let active = null;
-  let interaction;
-  let source = game.getOptions().source;
-  let seat = game.snapshot?.me;
-  let disposed = false;
-  let suppressPointerClick = false;
-  let dragged = false;
-  let lastInteractions = game.interactions;
-  let lastCards = game.cards;
-  let branch = snapshot();
-  function update(next) {
-    if (disposed) return;
-    active = next === null ? null : Object.freeze({ ...next, offset: Object.freeze(next.offset) });
-    branch = snapshot();
-    context.invalidate();
-  }
-  function targets() {
-    if (!active) return [];
-    const cardId = active.cardId;
-    return (game.cards.get(cardId)?.getInteractions() ?? []).filter(
-      (candidate) => candidate.getIsAvailable() && (!interaction || candidate.key === interaction) && candidate.getInputs().some(
-        (input) => input.getDomain().type === "cardTarget" && input.getIsEligible(cardId)
-      )
-    ).flatMap(
-      (candidate) => candidate.getInputs().flatMap((input) => {
-        const domain = input.getDomain();
-        if (domain.type !== "boardTarget" || !["space", "edge", "vertex", "tile"].includes(
-          String(domain.targetKind)
-        ))
-          return [];
-        return input.getEligibleTargets().filter(
-          (id) => typeof id === "string" && !input.getTargetProps(id).disabled
-        ).map(
-          (id) => Object.freeze({
-            kind: domain.targetKind,
-            id,
-            boardId: String(domain.boardId),
-            interaction: candidate.key
-          })
-        );
-      })
-    );
-  }
-  function sameTarget(left, right) {
-    return left.kind === right.kind && left.id === right.id && left.boardId === right.boardId && left.interaction === right.interaction;
-  }
-  const pointer = createPointerSession({
-    move: ({ delta }) => {
-      if (Math.hypot(delta.x, delta.y) >= 5) dragged = true;
-      if (active) update({ ...active, offset: delta });
-    },
-    end({ delta }) {
-      if (Math.hypot(delta.x, delta.y) >= 5) dragged = true;
-      suppressPointerClick = true;
-      const finished = active;
-      update(null);
-      if (!finished) return;
-      if (dragged) {
-        if (finished.target)
-          context.routeCardDrop(finished.cardId, finished.target);
-      } else context.routeTarget("card", finished.cardId, { interaction });
-    },
-    cancel: () => {
-      suppressPointerClick = true;
-      update(null);
-    }
-  });
-  function snapshot() {
-    const captured = active;
-    const dropTargets = Object.freeze(targets());
-    return Object.freeze({
-      active: captured,
-      getDropTargets: () => dropTargets,
-      setDropTarget(target) {
-        if (!active || disposed) return;
-        if (target && !targets().some((candidate) => sameTarget(candidate, target)))
-          return;
-        update({ ...active, target });
-      },
-      cancel: () => pointer.cancel()
-    });
-  }
-  const unsubscribe = game.subscribe(() => {
-    const nextSource = game.getOptions().source;
-    const nextSeat = game.snapshot?.me;
-    if (nextSource !== source || nextSeat !== seat) {
-      source = nextSource;
-      seat = nextSeat;
-      pointer.cancel();
-    }
-  });
-  return {
-    root: {
-      get drag() {
-        if (lastInteractions !== game.interactions || lastCards !== game.cards) {
-          lastInteractions = game.interactions;
-          lastCards = game.cards;
-          branch = snapshot();
-        }
-        return branch;
-      }
-    },
-    card: {
-      getDragProps(options) {
-        return {
-          style: {
-            touchAction: "none",
-            transform: active?.cardId === this.id ? `translate(${active.offset.x}px, ${active.offset.y}px)` : void 0
-          },
-          "data-drag-card": this.id,
-          onPointerDown: (event) => {
-            if (disposed || game.cards.get(this.id) !== this || !this.getCanSelect())
-              return;
-            if (!pointer.start(event)) return;
-            suppressPointerClick = false;
-            dragged = false;
-            interaction = options?.interaction;
-            update({ cardId: this.id, offset: { x: 0, y: 0 }, target: null });
-          },
-          onClick: (event) => {
-            if (disposed) return;
-            if (event.detail !== 0 && suppressPointerClick) {
-              suppressPointerClick = false;
-              event.preventDefault();
-              return;
-            }
-            this.select(options);
-          },
-          onPointerMove: pointer.move,
-          onPointerUp: pointer.end,
-          onPointerCancel: pointer.cancel,
-          onLostPointerCapture: pointer.cancel
-        };
-      }
-    },
-    dispose() {
-      unsubscribe();
-      pointer.dispose();
-      disposed = true;
-    }
-  };
-}
-
 // src/headless/features/pan-zoom.ts
 function panZoomFeature(game, context, options = {}) {
   const minScale = options.minScale ?? 0.25;