@dreamboard-games/ui-sdk 0.0.43 → 0.0.46

package/src/primitives/game.tsx

@@ -0,0 +1,213 @@
+import { createContext, useContext, useMemo, type ReactNode } from "react";
+import type { PlayerId } from "@dreamboard/manifest-contract";
+import { usePluginState } from "../context/PluginStateContext.js";
+import { usePluginSession } from "../context/PluginSessionContext.js";
+import { useActivePlayers } from "../hooks/useActivePlayers.js";
+import { useGameView } from "../hooks/useGameView.js";
+import { usePlayerInfo } from "../hooks/usePlayerInfo.js";
+import { usePlayerTurnOrder } from "../hooks/usePlayerTurnOrder.js";
+import type { Player } from "../types/player-state.js";
+
+export type GamePlayer<PlayerIdValue extends string = PlayerId> = Omit<
+  Player,
+  "playerId"
+> & {
+  playerId: PlayerIdValue;
+};
+
+export type GamePlayerEntry<PlayerIdValue extends string = PlayerId> =
+  GamePlayer<PlayerIdValue> & {
+    index: number;
+    isActive: boolean;
+    isCurrentPlayer: boolean;
+    isControllable: boolean;
+  };
+
+export interface GamePlayersState<PlayerIdValue extends string = PlayerId> {
+  byId: ReadonlyMap<PlayerIdValue, GamePlayer<PlayerIdValue>>;
+  order: readonly PlayerIdValue[];
+  entries: ReadonlyArray<GamePlayerEntry<PlayerIdValue>>;
+  active: readonly PlayerIdValue[];
+  current: GamePlayer<PlayerIdValue> | null;
+}
+
+export interface GameMeState<PlayerIdValue extends string = PlayerId> {
+  playerId: PlayerIdValue | null;
+  player: GamePlayer<PlayerIdValue> | null;
+  controllablePlayerIds: readonly PlayerIdValue[];
+  canAct: boolean;
+}
+
+export interface GameTurnState<
+  PlayerIdValue extends string = PlayerId,
+  PhaseValue extends string = string,
+> {
+  phase: PhaseValue | null;
+  stage: string | null;
+  activePlayerIds: readonly PlayerIdValue[];
+  currentPlayerId: PlayerIdValue | null;
+  order: readonly PlayerIdValue[];
+  isMine: boolean;
+}
+
+export interface GameRenderState<
+  ViewValue = unknown,
+  PlayerIdValue extends string = PlayerId,
+  PhaseValue extends string = string,
+> {
+  view: ViewValue;
+  phase: PhaseValue | null;
+  stage: string | null;
+  session: ReturnType<typeof usePluginSession>;
+  me: GameMeState<PlayerIdValue>;
+  turn: GameTurnState<PlayerIdValue, PhaseValue>;
+  players: GamePlayersState<PlayerIdValue>;
+}
+
+export interface GameRootProps<
+  ViewValue = unknown,
+  PlayerIdValue extends string = PlayerId,
+  PhaseValue extends string = string,
+> {
+  onActionError?: (error: unknown) => void;
+  children: (
+    state: GameRenderState<ViewValue, PlayerIdValue, PhaseValue>,
+  ) => ReactNode;
+}
+
+type GameActionErrorHandler = (error: unknown) => void;
+
+const GameActionErrorContext = createContext<GameActionErrorHandler | null>(
+  null,
+);
+
+export function useGameActionError(): GameActionErrorHandler | null {
+  return useContext(GameActionErrorContext);
+}
+
+function fallbackPlayer<PlayerIdValue extends string>(
+  playerId: PlayerIdValue,
+): GamePlayer<PlayerIdValue> {
+  return {
+    playerId,
+    name: playerId,
+  };
+}
+
+export function GameRoot<
+  ViewValue = unknown,
+  PlayerIdValue extends string = PlayerId,
+  PhaseValue extends string = string,
+>({
+  children,
+  onActionError,
+}: GameRootProps<ViewValue, PlayerIdValue, PhaseValue>) {
+  const view = useGameView() as ViewValue;
+  const session = usePluginSession();
+  const playerInfo = usePlayerInfo();
+  const activePlayers = useActivePlayers().map(
+    (playerId) => playerId as PlayerIdValue,
+  );
+  const turnOrder = usePlayerTurnOrder().map(
+    (playerId) => playerId as PlayerIdValue,
+  );
+  const phase = usePluginState(
+    (state) => state.gameplay.currentPhase,
+  ) as PhaseValue | null;
+  const stage = usePluginState((state) => state.gameplay.currentStage);
+
+  const playersById = useMemo(() => {
+    const next = new Map<PlayerIdValue, GamePlayer<PlayerIdValue>>();
+    playerInfo.forEach((player, key) => {
+      const playerId = key as PlayerIdValue;
+      next.set(playerId, {
+        ...player,
+        playerId,
+      });
+    });
+    return next;
+  }, [playerInfo]);
+
+  const controllingPlayerId =
+    session.controllingPlayerId == null
+      ? null
+      : (session.controllingPlayerId as PlayerIdValue);
+  const controllablePlayerIds = session.controllablePlayerIds.map(
+    (playerId) => playerId as PlayerIdValue,
+  );
+  const currentPlayerId = activePlayers[0] ?? turnOrder[0] ?? null;
+  const currentPlayer = currentPlayerId
+    ? (playersById.get(currentPlayerId) ?? fallbackPlayer(currentPlayerId))
+    : null;
+  const mePlayer = controllingPlayerId
+    ? (playersById.get(controllingPlayerId) ??
+      fallbackPlayer(controllingPlayerId))
+    : null;
+
+  const entries = useMemo<ReadonlyArray<GamePlayerEntry<PlayerIdValue>>>(
+    () =>
+      turnOrder.map((playerId, index) => {
+        const player = playersById.get(playerId) ?? fallbackPlayer(playerId);
+        return {
+          ...player,
+          index,
+          isActive: activePlayers.includes(playerId),
+          isCurrentPlayer: playerId === controllingPlayerId,
+          isControllable: controllablePlayerIds.includes(playerId),
+        };
+      }),
+    [
+      activePlayers,
+      controllablePlayerIds,
+      controllingPlayerId,
+      playersById,
+      turnOrder,
+    ],
+  );
+
+  const rendered = (
+    <>
+      {children({
+        view,
+        phase,
+        stage,
+        session,
+        me: {
+          playerId: controllingPlayerId,
+          player: mePlayer,
+          controllablePlayerIds,
+          canAct:
+            controllingPlayerId != null &&
+            activePlayers.includes(controllingPlayerId),
+        },
+        turn: {
+          phase,
+          stage,
+          activePlayerIds: activePlayers,
+          currentPlayerId,
+          order: turnOrder,
+          isMine:
+            controllingPlayerId != null &&
+            activePlayers.includes(controllingPlayerId),
+        },
+        players: {
+          byId: playersById,
+          order: turnOrder,
+          entries,
+          active: activePlayers,
+          current: currentPlayer,
+        },
+      })}
+    </>
+  );
+  if (!onActionError) return rendered;
+  return (
+    <GameActionErrorContext.Provider value={onActionError}>
+      {rendered}
+    </GameActionErrorContext.Provider>
+  );
+}
+
+export const Game = {
+  Root: GameRoot,
+};

package/src/primitives/index.ts

@@ -1,29 +1,70 @@
+export { UI, UIRoot, type UIRootProps } from "./ui.js";
 export {
   Board,
+  BoardEdgeTarget,
+  BoardHexGrid,
+  BoardHexView,
   BoardRoot,
+  BoardSpaceTarget,
+  BoardState,
   BoardTarget,
+  BoardVertexTarget,
   useBoardPrimitiveContext,
+  type BoardEdgeTargetProps,
+  type BoardHexGridInteractionFilter,
+  type BoardHexGridInteractions,
+  type BoardHexGridProps,
+  type BoardHexViewProps,
   type BoardRootProps,
+  type BoardSpaceTargetProps,
+  type BoardStateProps,
   type BoardTargetExtraInputs,
   type BoardTargetProps,
+  type BoardVertexTargetProps,
 } from "./board.js";
+export {
+  Game,
+  GameRoot,
+  useGameActionError,
+  type GameMeState,
+  type GamePlayer,
+  type GamePlayerEntry,
+  type GamePlayersState,
+  type GameRenderState,
+  type GameRootProps,
+  type GameTurnState,
+} from "./game.js";
 export {
   Interaction,
   InteractionCardInput,
   InteractionDescription,
+  InteractionDialog,
+  InteractionFormPrimitive,
   InteractionInput,
   InteractionLabel,
   InteractionRoot,
+  InteractionState,
   InteractionSubmit,
+  InteractionSwitch,
   InteractionTrigger,
   InteractionUnavailableMessage,
   InteractionValidationMessage,
   useInteractionPrimitiveContext,
   type InteractionCardInputProps,
+  type InteractionDialogProps,
+  type InteractionDialogRenderState,
+  type InteractionDialogState,
+  type InteractionFieldPrimitiveProps,
+  type InteractionFormPrimitiveProps,
   type InteractionInputProps,
   type InteractionPartProps,
+  type InteractionRouteMap,
   type InteractionRootProps,
+  type InteractionStateProps,
+  type InteractionStateSnapshot,
   type InteractionSubmitProps,
+  type InteractionSwitchProps,
+  type InteractionSwitchRenderState,
   type InteractionTriggerProps,
 } from "./interaction.js";
 export {
@@ -56,12 +97,19 @@ export {
   PromptInboxEmpty,
   PromptInboxItems,
   PromptInboxRoot,
+  PromptDialog,
   PromptMessage,
   PromptOption,
   PromptOptions,
   PromptRoot,
   PromptTitle,
+  type PromptDialogProps,
+  type PromptDialogRenderState,
+  type PromptDialogState,
+  type PromptInboxItemsProps,
+  type PromptOptionRenderItem,
   type PromptOptionProps,
+  type PromptOptionsProps,
   type PromptRootProps,
 } from "./prompt.js";
 export {
@@ -70,14 +118,50 @@ export {
   type PrimitiveCommonProps,
   type PrimitiveDataAttributes,
 } from "./primitive-props.js";
+export {
+  Dice,
+  DiceRoot,
+  DiceValues,
+  normalizeDiceState,
+  useDicePrimitiveContext,
+  type DiceComponents,
+  type DiceRootProps,
+  type DiceState,
+  type DiceValue,
+  type DiceValuesProps,
+} from "./dice.js";
 export {
   Zone,
+  ZoneCardAt,
+  ZoneCardAction,
   ZoneItem,
   ZoneList,
+  ZonePileCards,
+  ZonePileCount,
+  ZonePileDescription,
+  ZonePileLabel,
+  ZonePileRoot,
+  ZonePileTrigger,
   ZoneRoot,
+  ZoneTopCard,
+  useOptionalZonePrimitiveContext,
   useZoneCardContext,
+  useZonePileContext,
   useZonePrimitiveContext,
+  type ZoneCardAtProps,
+  type ZoneCardActionExtraInputs,
+  type ZoneCardActionProps,
+  type ZoneCardActionResult,
+  type ZoneCardRenderItem,
+  type ZonePileCardsProps,
+  type ZonePileContextValue,
+  type ZonePileCountProps,
+  type ZonePileDescriptionProps,
+  type ZonePileLabelProps,
+  type ZonePileRootProps,
+  type ZonePileTriggerProps,
   type ZoneItemProps,
   type ZoneListProps,
   type ZoneRootProps,
+  type ZoneTopCardProps,
 } from "./zone.js";

package/src/primitives/interaction-form-binding.tsx

@@ -0,0 +1,56 @@
+import {
+  InteractionForm,
+  type InteractionFormProps,
+} from "../components/InteractionForm.js";
+import type {
+  InteractionHandle,
+  InteractionParamsShape,
+} from "../hooks/useInteractionHandle.js";
+import type { InteractionDescriptor } from "../types/plugin-state.js";
+
+export type BoundInteractionFormProps<
+  Params extends InteractionParamsShape = InteractionParamsShape,
+  DefaultedKeys extends keyof Params & string = never,
+> = Omit<InteractionFormProps<Params, DefaultedKeys>, "descriptor" | "handle">;
+
+export function castInteractionHandle<
+  Params extends InteractionParamsShape = InteractionParamsShape,
+  DefaultedKeys extends keyof Params & string = never,
+>(handle: InteractionHandle): InteractionHandle<Params, DefaultedKeys> {
+  return handle as InteractionHandle<Params, DefaultedKeys>;
+}
+
+export function castInteractionDraft<
+  Params extends InteractionParamsShape = InteractionParamsShape,
+  DefaultedKeys extends keyof Params & string = never,
+>(
+  draft: Record<string, unknown>,
+): InteractionHandle<Params, DefaultedKeys>["draft"] {
+  return draft as InteractionHandle<Params, DefaultedKeys>["draft"];
+}
+
+export function castInteractionFields<
+  Params extends InteractionParamsShape = InteractionParamsShape,
+>(fields: readonly string[]): ReadonlyArray<keyof Params & string> {
+  return fields as ReadonlyArray<keyof Params & string>;
+}
+
+export function BoundInteractionForm<
+  Params extends InteractionParamsShape = InteractionParamsShape,
+  DefaultedKeys extends keyof Params & string = never,
+>({
+  descriptor,
+  handle,
+  ...props
+}: BoundInteractionFormProps<Params, DefaultedKeys> & {
+  descriptor: InteractionDescriptor;
+  handle: InteractionHandle;
+}) {
+  return (
+    <InteractionForm<Params, DefaultedKeys>
+      descriptor={descriptor}
+      handle={castInteractionHandle<Params, DefaultedKeys>(handle)}
+      {...props}
+    />
+  );
+}

package/src/primitives/interaction-submit.ts

@@ -0,0 +1,90 @@
+import type {
+  InteractionHandle,
+  InteractionParamsShape,
+} from "../hooks/useInteractionHandle.js";
+
+type UnhandledInteractionError = "throw" | "log" | "ignore";
+
+interface RunInteractionActionOptions<Result> {
+  onSuccess?: (result: Result) => void;
+  onError?: (error: unknown) => void;
+  unhandledError?: UnhandledInteractionError;
+}
+
+export interface InteractionSubmitCallbacks {
+  onSubmitSuccess?: () => void;
+  onSubmitError?: (error: unknown) => void;
+}
+
+export async function runInteractionAction<Result>(
+  action: () => Promise<Result>,
+  {
+    onSuccess,
+    onError,
+    unhandledError = "throw",
+  }: RunInteractionActionOptions<Result> = {},
+): Promise<void> {
+  try {
+    const result = await action();
+    onSuccess?.(result);
+  } catch (error) {
+    if (onError) {
+      onError(error);
+      return;
+    }
+    if (unhandledError === "log") {
+      console.error(error);
+      return;
+    }
+    if (unhandledError === "ignore") {
+      return;
+    }
+    throw error;
+  }
+}
+
+export function submitInteractionDraft<
+  Params extends InteractionParamsShape = InteractionParamsShape,
+  DefaultedKeys extends keyof Params & string = never,
+>(
+  handle: InteractionHandle<Params, DefaultedKeys>,
+  callbacks: InteractionSubmitCallbacks = {},
+  options: { unhandledError?: UnhandledInteractionError } = {},
+): Promise<void> {
+  return runInteractionAction(() => handle.submitDraft(), {
+    onSuccess: callbacks.onSubmitSuccess,
+    onError: callbacks.onSubmitError,
+    unhandledError: options.unhandledError,
+  });
+}
+
+export function submitInteraction<
+  Params extends InteractionParamsShape = InteractionParamsShape,
+  DefaultedKeys extends keyof Params & string = never,
+>(
+  handle: InteractionHandle<Params, DefaultedKeys>,
+  callbacks: InteractionSubmitCallbacks = {},
+  options: { unhandledError?: UnhandledInteractionError } = {},
+): Promise<void> {
+  return runInteractionAction(() => handle.submit(), {
+    onSuccess: callbacks.onSubmitSuccess,
+    onError: callbacks.onSubmitError,
+    unhandledError: options.unhandledError,
+  });
+}
+
+export function submitInteractionParams<
+  Params extends InteractionParamsShape = InteractionParamsShape,
+  DefaultedKeys extends keyof Params & string = never,
+>(
+  handle: InteractionHandle<Params, DefaultedKeys>,
+  params: Params,
+  callbacks: InteractionSubmitCallbacks = {},
+  options: { unhandledError?: UnhandledInteractionError } = {},
+): Promise<void> {
+  return runInteractionAction(() => handle.submit(params), {
+    onSuccess: callbacks.onSubmitSuccess,
+    onError: callbacks.onSubmitError,
+    unhandledError: options.unhandledError,
+  });
+}