@dreamboard-games/cli 0.1.30-alpha.0 → 0.1.30-alpha.10

package/dist/runtime-packages/ui-host-runtime/src/session-ingress.ts

@@ -1,219 +0,0 @@
-import type {
-  HostSessionEvent,
-  HostSessionSnapshot,
-} from "@dreamboard-games/api-client";
-import type {
-  GameplayPerspective,
-  GameplayViewport,
-  SessionContext,
-} from "./session-model.js";
-import {
-  contextFromHostEventContext,
-  contextFromHostSnapshot,
-  gameplayViewportFromSnapshot,
-} from "./session-model.js";
-
-type WireSessionIngressSnapshot = HostSessionSnapshot;
-type WireSessionIngressEvent = HostSessionEvent;
-interface WireSessionIngressActionSubmitResponse {
-  success: boolean;
-  version: number;
-  actionSetVersion: string;
-  accepted?: boolean | null;
-  durabilityStatus?: "COMMITTED" | null;
-  update?: WireSessionIngressEvent | null;
-  errorCode?: string | null;
-  message?: string | null;
-  clientActionId?: string | null;
-}
-
-export type HostSessionWireSnapshot = WireSessionIngressSnapshot;
-export type HostSessionWireEvent = WireSessionIngressEvent;
-export type HostActionSubmitWireResponse =
-  WireSessionIngressActionSubmitResponse;
-
-export type NormalizedSessionSnapshot =
-  | {
-      type: "lobby";
-      context: SessionContext;
-      gameplay: null;
-      preferredPlayerId: string | null;
-    }
-  | {
-      type: "gameplay";
-      context: SessionContext;
-      perspective: GameplayPerspective;
-      gameplay: GameplayViewport;
-    }
-  | {
-      type: "ended";
-      context: SessionContext;
-      gameplay: null;
-      preferredPlayerId: string | null;
-    };
-
-export type NormalizedSessionEvent =
-  | {
-      type: "session.snapshot";
-      snapshot: NormalizedSessionSnapshot;
-      context: SessionContext;
-      gameplay: GameplayViewport | null;
-    }
-  | {
-      type: "session.lobbyUpdated";
-      context: SessionContext | null;
-      gameplay: GameplayViewport | null;
-    }
-  | {
-      type: "session.gameplayUpdated";
-      context: SessionContext | null;
-      gameplay: GameplayViewport;
-      perspective: GameplayPerspective;
-    }
-  | {
-      type: "session.historyUpdated";
-      context: SessionContext | null;
-      gameplay: GameplayViewport | null;
-    }
-  | {
-      type: "session.ended";
-      context: SessionContext | null;
-      gameplay: GameplayViewport | null;
-    }
-  | {
-      type: "session.error";
-      message: string;
-      code?: string;
-      context: SessionContext | null;
-      gameplay: GameplayViewport | null;
-    };
-
-export type NormalizedSubmitResponse = NormalizedSessionEvent | null;
-
-export function normalizeSnapshot(
-  snapshot: HostSessionWireSnapshot,
-  options: {
-    userId: string | null;
-    previousGameplay?: GameplayViewport | null;
-  },
-): NormalizedSessionSnapshot {
-  const context = contextFromHostSnapshot(snapshot, options.userId);
-  if (snapshot.type !== "gameplay") {
-    return {
-      type: snapshot.type,
-      context,
-      gameplay: null,
-      preferredPlayerId: null,
-    };
-  }
-  return {
-    type: "gameplay",
-    context,
-    perspective: { playerId: snapshot.gameplay.perspectivePlayerId },
-    gameplay: gameplayViewportFromSnapshot(
-      snapshot.gameplay,
-      options.previousGameplay,
-    ),
-  };
-}
-
-export function normalizeEvent(
-  event: HostSessionWireEvent,
-  options: {
-    currentContext: SessionContext | null;
-    currentGameplay: GameplayViewport | null;
-    userId: string | null;
-  },
-): NormalizedSessionEvent {
-  const context = options.currentContext;
-  switch (event.type) {
-    case "session.snapshot": {
-      const normalized = normalizeSnapshot(event.snapshot, {
-        userId: options.userId,
-        previousGameplay: options.currentGameplay,
-      });
-      return {
-        type: "session.snapshot",
-        snapshot: normalized,
-        context: normalized.context,
-        gameplay: normalized.gameplay,
-      };
-    }
-    case "session.lobbyUpdated":
-      return {
-        type: "session.lobbyUpdated",
-        context: context
-          ? contextFromHostEventContext(
-              { ...context, userId: options.userId },
-              event.context,
-              event.lobby,
-            )
-          : null,
-        gameplay: options.currentGameplay,
-      };
-    case "session.gameplayUpdated":
-      return {
-        type: "session.gameplayUpdated",
-        context: context
-          ? contextFromHostEventContext(
-              { ...context, userId: options.userId },
-              event.context,
-            )
-          : null,
-        gameplay: gameplayViewportFromSnapshot(
-          event.gameplay,
-          options.currentGameplay,
-        ),
-        perspective: { playerId: event.gameplay.perspectivePlayerId },
-      };
-    case "session.historyUpdated":
-      return {
-        type: "session.historyUpdated",
-        context: context
-          ? contextFromHostEventContext(
-              { ...context, userId: options.userId },
-              event.context,
-            )
-          : null,
-        gameplay: options.currentGameplay,
-      };
-    case "session.ended":
-      return {
-        type: "session.ended",
-        context: context
-          ? contextFromHostEventContext(
-              { ...context, userId: options.userId },
-              event.context,
-              event.lobby,
-            )
-          : null,
-        gameplay: options.currentGameplay,
-      };
-    case "session.error":
-      return {
-        type: "session.error",
-        message: event.message,
-        code: event.code,
-        context,
-        gameplay: options.currentGameplay,
-      };
-  }
-}
-
-export function normalizeSubmitResponse(
-  response: HostActionSubmitWireResponse,
-  options: {
-    currentContext: SessionContext | null;
-    currentGameplay: GameplayViewport | null;
-    userId: string | null;
-  },
-): NormalizedSubmitResponse {
-  if (!response.accepted || !response.update) {
-    return null;
-  }
-  return normalizeEvent(response.update, {
-    currentContext: options.currentContext,
-    currentGameplay: options.currentGameplay,
-    userId: options.userId,
-  });
-}

package/dist/runtime-packages/ui-host-runtime/src/session-live-runtime.ts

@@ -1,117 +0,0 @@
-import type { HostSessionWireEvent } from "./session-ingress.js";
-import type { SSEManager, SSERecoveryEvent } from "./sse-manager.js";
-
-export interface SSEManagerLike {
-  connect: (
-    sessionId: string,
-    options: {
-      source?: string;
-      playerId?: string;
-    },
-  ) => Promise<void> | void;
-  disconnect: () => void;
-  on: SSEManager["on"];
-  onAnyMessage: SSEManager["onAnyMessage"];
-}
-
-export interface SessionLiveRuntime {
-  connectSession: (
-    sessionId: string,
-    options: { source?: string; playerId?: string },
-  ) => void;
-  reconnectGameplay: (
-    sessionId: string,
-    playerId: string,
-    source: string,
-  ) => void;
-  requestGameplayResync: (
-    sessionId: string,
-    playerId: string,
-    source: string,
-  ) => void;
-  closeStreams: () => void;
-  getConnectedSessionId: () => string | null;
-}
-
-export function createSessionLiveRuntime(options: {
-  createSseManager: () => SSEManagerLike;
-  onConnectionChange: (
-    channel: "lobby" | "gameplay",
-    connected: boolean,
-  ) => void;
-  onConnectionError: (error: unknown) => void;
-  onConnectionRecovering: (details: SSERecoveryEvent) => void;
-  onLiveMessage: (message: HostSessionWireEvent) => void;
-}): SessionLiveRuntime {
-  let connectedSessionId: string | null = null;
-  let sessionManager: SSEManagerLike | null = null;
-  let unsubscribeSession: (() => void) | null = null;
-
-  const attachConnectionHandlers = (
-    manager: SSEManagerLike,
-    channel: "lobby" | "gameplay",
-  ) => {
-    manager.on("connected", () => options.onConnectionChange(channel, true));
-    manager.on("disconnected", () =>
-      options.onConnectionChange(channel, false),
-    );
-    manager.on("error", (error) => {
-      options.onConnectionChange(channel, false);
-      options.onConnectionError(error);
-    });
-    manager.on("recovering", (details) => {
-      options.onConnectionChange(channel, false);
-      options.onConnectionRecovering(details);
-    });
-  };
-
-  const closeStreams = () => {
-    unsubscribeSession?.();
-    unsubscribeSession = null;
-    sessionManager?.disconnect();
-    sessionManager = null;
-    connectedSessionId = null;
-    options.onConnectionChange("lobby", false);
-    options.onConnectionChange("gameplay", false);
-  };
-
-  const openSession = (
-    sessionId: string,
-    playerId: string | undefined,
-    source: string,
-  ) => {
-    closeStreams();
-    connectedSessionId = sessionId;
-    sessionManager = options.createSseManager();
-    attachConnectionHandlers(sessionManager, playerId ? "gameplay" : "lobby");
-    unsubscribeSession = sessionManager.onAnyMessage(options.onLiveMessage);
-    void sessionManager.connect(sessionId, {
-      source,
-      playerId,
-    });
-  };
-
-  return {
-    connectSession: (sessionId, connectOptions) => {
-      openSession(
-        sessionId,
-        connectOptions.playerId,
-        connectOptions.source ?? "connect-session",
-      );
-    },
-    reconnectGameplay: (sessionId, playerId, source) => {
-      openSession(sessionId, playerId, source);
-    },
-    requestGameplayResync: (sessionId, playerId, source) => {
-      if (!sessionManager) {
-        return;
-      }
-      void sessionManager.connect(sessionId, {
-        source,
-        playerId,
-      });
-    },
-    closeStreams,
-    getConnectedSessionId: () => connectedSessionId,
-  };
-}