@smoregg/sdk 2.0.0 → 2.1.0

package/dist/cjs/screen.cjs

@@ -5,7 +5,7 @@ var protocol = require('./transport/protocol.cjs');
 var errors = require('./errors.cjs');
 var events = require('./events.cjs');
 var logger = require('./logger.cjs');
-var config = require('./config.cjs');
+var shared = require('./shared.cjs');
 
 const DEFAULT_TIMEOUT = 1e4;
 function validatePlayerIndex(playerIndex, controllers) {
@@ -36,17 +36,16 @@ class ScreenImpl {
   handlerToTransport = /* @__PURE__ */ new Map();
   // Pending handlers registered via on() before transport is ready
   _pendingHandlers = [];
-  // Lifecycle callback arrays
-  _onAllReadyCallbacks = /* @__PURE__ */ new Set();
-  _onControllerJoinCallbacks = /* @__PURE__ */ new Set();
-  _onControllerLeaveCallbacks = /* @__PURE__ */ new Set();
-  _onControllerDisconnectCallbacks = /* @__PURE__ */ new Set();
-  _onControllerReconnectCallbacks = /* @__PURE__ */ new Set();
-  _onCharacterUpdatedCallbacks = /* @__PURE__ */ new Set();
-  _onRateLimitedCallbacks = /* @__PURE__ */ new Set();
-  _onErrorCallbacks = /* @__PURE__ */ new Set();
+  // Unified lifecycle listener map (supports both onXxx() and on('$xxx') patterns)
+  _lifecycleListeners = /* @__PURE__ */ new Map();
+  // Outbound message buffer (messages sent before ready)
+  _outboundBuffer = [];
   // Whether all-ready has fired
   _allReadyFired = false;
+  // Self-connection awareness
+  _isConnected = false;
+  // Protocol versioning
+  _protocolVersion = protocol.PROTOCOL_VERSION;
   // Ready promise
   _readyResolve;
   _readyReject;
@@ -108,8 +107,17 @@ class ScreenImpl {
           this._readyReject(error);
           return;
         }
-        this.transport = new PostMessageTransport.PostMessageTransport(parentOrigin);
+        this.transport = this.config.transport ?? new PostMessageTransport.PostMessageTransport(parentOrigin);
         this._roomCode = initData.roomCode;
+        const serverProtocolVersion = initData.protocolVersion;
+        if (serverProtocolVersion !== void 0) {
+          this._protocolVersion = serverProtocolVersion;
+          if (serverProtocolVersion !== protocol.PROTOCOL_VERSION) {
+            this.logger.warn(
+              `Protocol version mismatch: SDK v${protocol.PROTOCOL_VERSION}, server v${serverProtocolVersion}. Some features may not work correctly.`
+            );
+          }
+        }
         this._controllers = this.mapControllersFromInit(initData.players);
         if (this._controllers.length === 0) {
           this.logger.warn("Screen initialized with zero controllers");
@@ -119,13 +127,28 @@ class ScreenImpl {
           this.setupUserEventHandler(event, handler);
         }
         this._pendingHandlers = [];
+        this._isConnected = true;
         this._isReady = true;
+        for (const buffered of this._outboundBuffer) {
+          try {
+            switch (buffered.method) {
+              case "broadcast":
+                this.broadcast(buffered.args[0], buffered.args[1]);
+                break;
+              case "sendToController":
+                this.sendToController(buffered.args[0], buffered.args[1], buffered.args[2]);
+                break;
+            }
+          } catch (err) {
+            this.handleError(err instanceof errors.SmoreSDKError ? err : new errors.SmoreSDKError("UNKNOWN", "Failed to flush buffered message"));
+          }
+        }
+        this._outboundBuffer = [];
         this.logger.lifecycle("Screen ready", {
           roomCode: this._roomCode,
           controllers: this._controllers.length
         });
-        const autoReady = config.getGlobalConfig().autoReady ?? true;
-        if (autoReady) {
+        if (this.config.autoReady !== false) {
           this.logger.lifecycle("Auto-signaling ready (autoReady enabled)");
           this.signalReady();
         }
@@ -143,13 +166,13 @@ class ScreenImpl {
           for (const nc of newControllers) {
             if (!oldControllers.some((oc) => oc.playerIndex === nc.playerIndex)) {
               this.logger.lifecycle("Controller joined (via update)", { playerIndex: nc.playerIndex });
-              this._onControllerJoinCallbacks.forEach((cb) => cb(nc.playerIndex, nc));
+              this._emitLifecycle("$controller-join", nc.playerIndex, nc);
             }
           }
           for (const oc of oldControllers) {
             if (!newControllers.some((nc) => nc.playerIndex === oc.playerIndex)) {
               this.logger.lifecycle("Controller left (via update)", { playerIndex: oc.playerIndex });
-              this._onControllerLeaveCallbacks.forEach((cb) => cb(oc.playerIndex));
+              this._emitLifecycle("$controller-leave", oc.playerIndex);
             }
           }
         }
@@ -159,18 +182,11 @@ class ScreenImpl {
       }
     };
     window.addEventListener("message", this.boundMessageHandler);
-    window.parent.postMessage({ type: "_bridge:ready" }, parentOrigin);
+    window.parent.postMessage({ type: "_bridge:ready", protocolVersion: protocol.PROTOCOL_VERSION }, parentOrigin);
     this.logger.lifecycle("Sent _bridge:ready to parent");
   }
   mapControllersFromInit(players) {
-    return players.map((p, index) => ({
-      playerIndex: p.playerIndex ?? index,
-      // Fallback to `nickname` for defensive compatibility (server currently always sends `name`)
-      nickname: p.nickname || p.name || `Player ${index + 1}`,
-      connected: p.connected !== false,
-      // Fallback to `appearance` for defensive compatibility (server currently always sends `character`)
-      appearance: p.appearance ?? p.character
-    }));
+    return players.map((p, index) => shared.mapPlayerDTO(p, index));
   }
   setupEventHandlers() {
     if (!this.transport) return;
@@ -178,16 +194,11 @@ class ScreenImpl {
       const payload = data;
       const playerData = payload?.player;
       if (playerData && typeof playerData.playerIndex === "number") {
-        const controllerInfo = {
-          playerIndex: playerData.playerIndex,
-          nickname: playerData.nickname || playerData.name || `Player ${playerData.playerIndex + 1}`,
-          connected: playerData.connected !== false,
-          appearance: playerData.appearance ?? playerData.character
-        };
+        const controllerInfo = shared.mapPlayerDTO(playerData, playerData.playerIndex);
         if (this._controllers.some((c) => c.playerIndex === controllerInfo.playerIndex)) return;
         this._controllers = [...this._controllers, controllerInfo];
         this.logger.lifecycle("Controller joined", { playerIndex: controllerInfo.playerIndex });
-        this._onControllerJoinCallbacks.forEach((cb) => cb(controllerInfo.playerIndex, controllerInfo));
+        this._emitLifecycle("$controller-join", controllerInfo.playerIndex, controllerInfo);
       }
     });
     this.registerTransportHandler(events.SMORE_EVENTS.PLAYER_LEFT, (data) => {
@@ -197,7 +208,7 @@ class ScreenImpl {
         if (!this._controllers.some((c) => c.playerIndex === playerIndex)) return;
         this._controllers = this._controllers.filter((c) => c.playerIndex !== playerIndex);
         this.logger.lifecycle("Controller left", { playerIndex });
-        this._onControllerLeaveCallbacks.forEach((cb) => cb(playerIndex));
+        this._emitLifecycle("$controller-leave", playerIndex);
       }
     });
     this.registerTransportHandler(events.SMORE_EVENTS.PLAYER_DISCONNECTED, (data) => {
@@ -208,24 +219,19 @@ class ScreenImpl {
           (c) => c.playerIndex === playerIndex ? { ...c, connected: false } : c
         );
         this.logger.lifecycle("Controller disconnected", { playerIndex });
-        this._onControllerDisconnectCallbacks.forEach((cb) => cb(playerIndex));
+        this._emitLifecycle("$controller-disconnect", playerIndex);
       }
     });
     this.registerTransportHandler(events.SMORE_EVENTS.PLAYER_RECONNECTED, (data) => {
       const payload = data;
       const playerData = payload?.player;
       if (playerData && typeof playerData.playerIndex === "number") {
-        const controllerInfo = {
-          playerIndex: playerData.playerIndex,
-          nickname: playerData.nickname || playerData.name || `Player ${playerData.playerIndex + 1}`,
-          connected: true,
-          appearance: playerData.appearance ?? playerData.character
-        };
+        const controllerInfo = shared.mapPlayerDTO(playerData, playerData.playerIndex);
         this._controllers = this._controllers.map(
           (c) => c.playerIndex === controllerInfo.playerIndex ? controllerInfo : c
         );
         this.logger.lifecycle("Controller reconnected", { playerIndex: controllerInfo.playerIndex });
-        this._onControllerReconnectCallbacks.forEach((cb) => cb(controllerInfo.playerIndex, controllerInfo));
+        this._emitLifecycle("$controller-reconnect", controllerInfo.playerIndex, controllerInfo);
       }
     });
     this.registerTransportHandler(events.SMORE_EVENTS.PLAYER_CHARACTER_UPDATED, (data) => {
@@ -238,19 +244,32 @@ class ScreenImpl {
           (c) => c.playerIndex === pi ? { ...c, appearance } : c
         );
         this.logger.lifecycle("Player character updated", { playerIndex: pi });
-        this._onCharacterUpdatedCallbacks.forEach((cb) => cb(pi, appearance ?? null));
+        this._emitLifecycle("$character-updated", pi, appearance ?? null);
       }
     });
     this.registerTransportHandler(events.SMORE_EVENTS.RATE_LIMITED, (data) => {
       const payload = data;
-      const event = payload?.event ?? "unknown";
-      this.logger.warn(`Rate limited: ${event}`);
-      this._onRateLimitedCallbacks.forEach((cb) => cb(event));
+      const eventName = payload?.event ?? "unknown";
+      this.handleError(
+        new errors.SmoreSDKError("RATE_LIMITED", `Server rate-limited event: ${eventName}`, {
+          details: { event: eventName }
+        })
+      );
     });
     this.registerTransportHandler(events.SMORE_EVENTS.ALL_READY, () => {
       this.logger.lifecycle("All participants ready");
       this._allReadyFired = true;
-      this._onAllReadyCallbacks.forEach((cb) => cb());
+      this._emitLifecycle("$all-ready");
+    });
+    this.registerTransportHandler(events.SMORE_EVENTS.SELF_DISCONNECTED, () => {
+      this._isConnected = false;
+      this.logger.lifecycle("Connection lost");
+      this._emitLifecycle("$connection-change", false);
+    });
+    this.registerTransportHandler(events.SMORE_EVENTS.SELF_RECONNECTED, () => {
+      this._isConnected = true;
+      this.logger.lifecycle("Connection restored");
+      this._emitLifecycle("$connection-change", true);
     });
   }
   /**
@@ -319,6 +338,45 @@ class ScreenImpl {
   get isDestroyed() {
     return this._isDestroyed;
   }
+  get isConnected() {
+    return this._isConnected;
+  }
+  get protocolVersion() {
+    return this._protocolVersion;
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle Listener Helpers
+  // ---------------------------------------------------------------------------
+  _addLifecycleListener(event, listener) {
+    let set = this._lifecycleListeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this._lifecycleListeners.set(event, set);
+    }
+    set.add(listener);
+    return () => {
+      set.delete(listener);
+      if (set.size === 0) this._lifecycleListeners.delete(event);
+    };
+  }
+  _emitLifecycle(event, ...args) {
+    this._lifecycleListeners.get(event)?.forEach((cb) => {
+      try {
+        cb(...args);
+      } catch (err) {
+        this.handleError(
+          new errors.SmoreSDKError("UNKNOWN", `Error in lifecycle handler for "${event}"`, {
+            cause: err instanceof Error ? err : void 0,
+            details: { event }
+          })
+        );
+      }
+    });
+  }
+  _hasLifecycleListeners(event) {
+    const set = this._lifecycleListeners.get(event);
+    return set !== void 0 && set.size > 0;
+  }
   // ---------------------------------------------------------------------------
   // Lifecycle Methods
   // ---------------------------------------------------------------------------
@@ -326,52 +384,28 @@ class ScreenImpl {
     if (this._allReadyFired) {
       callback();
     }
-    this._onAllReadyCallbacks.add(callback);
-    return () => {
-      this._onAllReadyCallbacks.delete(callback);
-    };
+    return this._addLifecycleListener("$all-ready", callback);
   }
   onControllerJoin(callback) {
-    this._onControllerJoinCallbacks.add(callback);
-    return () => {
-      this._onControllerJoinCallbacks.delete(callback);
-    };
+    return this._addLifecycleListener("$controller-join", callback);
   }
   onControllerLeave(callback) {
-    this._onControllerLeaveCallbacks.add(callback);
-    return () => {
-      this._onControllerLeaveCallbacks.delete(callback);
-    };
+    return this._addLifecycleListener("$controller-leave", callback);
   }
   onControllerDisconnect(callback) {
-    this._onControllerDisconnectCallbacks.add(callback);
-    return () => {
-      this._onControllerDisconnectCallbacks.delete(callback);
-    };
+    return this._addLifecycleListener("$controller-disconnect", callback);
   }
   onControllerReconnect(callback) {
-    this._onControllerReconnectCallbacks.add(callback);
-    return () => {
-      this._onControllerReconnectCallbacks.delete(callback);
-    };
+    return this._addLifecycleListener("$controller-reconnect", callback);
   }
   onCharacterUpdated(callback) {
-    this._onCharacterUpdatedCallbacks.add(callback);
-    return () => {
-      this._onCharacterUpdatedCallbacks.delete(callback);
-    };
-  }
-  onRateLimited(callback) {
-    this._onRateLimitedCallbacks.add(callback);
-    return () => {
-      this._onRateLimitedCallbacks.delete(callback);
-    };
+    return this._addLifecycleListener("$character-updated", callback);
   }
   onError(callback) {
-    this._onErrorCallbacks.add(callback);
-    return () => {
-      this._onErrorCallbacks.delete(callback);
-    };
+    return this._addLifecycleListener("$error", callback);
+  }
+  onConnectionChange(callback) {
+    return this._addLifecycleListener("$connection-change", callback);
   }
   // ---------------------------------------------------------------------------
   // Communication Methods
@@ -380,7 +414,6 @@ class ScreenImpl {
    * Send type-safe events to all controllers.
    *
    * Uses EventMap generic for compile-time type checking of event names and data payloads.
-   * Runtime behavior is identical to broadcastRaw - both call validateEventName at runtime.
    *
    * @note Data should be an object. Primitive values will be wrapped as `{ data: value }` by the relay server.
    * @note Maximum payload size is 64KB. Data exceeding this limit will be silently dropped by the server.
@@ -389,31 +422,18 @@ class ScreenImpl {
    *
    * Warning: Avoid sending primitive values directly (string, number, boolean).
    * Wrap in an object: broadcast('event', { value: 42 }) instead of broadcast('event', 42)
-   *
-   * @see broadcastRaw for bypassing TypeScript type checking (runtime behavior identical)
    */
   broadcast(event, data) {
-    this.ensureReady("broadcast");
-    events.validateEventName(event);
-    this.logger.send(event, data);
-    this.transport.emit(event, data);
-  }
-  /**
-   * Send events to all controllers without TypeScript type checking.
-   *
-   * Bypasses EventMap generic type checks at compile time.
-   * Runtime behavior is identical to broadcast - both call validateEventName at runtime.
-   *
-   * Use this when you need dynamic event names or when working without a predefined EventMap.
-   *
-   * @note Data should be an object. Primitive values will be wrapped as `{ data: value }` by the relay server.
-   * @note Maximum payload size is 64KB. Data exceeding this limit will be silently dropped by the server.
-   *
-   * @see broadcast for type-safe version using EventMap generic
-   */
-  broadcastRaw(event, data) {
-    this.ensureReady("broadcastRaw");
+    if (this._isDestroyed) {
+      throw new errors.SmoreSDKError("DESTROYED", "Cannot call broadcast() after destroy()");
+    }
+    if (!this._isReady || !this.transport) {
+      this._outboundBuffer.push({ method: "broadcast", args: [event, data] });
+      this.logger.debug(`Buffered broadcast "${event}" (screen not ready yet)`);
+      return;
+    }
     events.validateEventName(event);
+    shared.validatePayloadSize(data);
     this.logger.send(event, data);
     this.transport.emit(event, data);
   }
@@ -432,24 +452,17 @@ class ScreenImpl {
    * @param data - Event data payload
    */
   sendToController(playerIndex, event, data) {
-    this.ensureReady("sendToController");
-    events.validateEventName(event);
-    validatePlayerIndex(playerIndex, this._controllers);
-    if (data && typeof data === "object" && "targetPlayerIndex" in data) {
-      this.logger.warn(
-        `Event "${event}" data contains reserved field "targetPlayerIndex" which will be overwritten for routing.`
-      );
+    if (this._isDestroyed) {
+      throw new errors.SmoreSDKError("DESTROYED", "Cannot call sendToController() after destroy()");
+    }
+    if (!this._isReady || !this.transport) {
+      this._outboundBuffer.push({ method: "sendToController", args: [playerIndex, event, data] });
+      this.logger.debug(`Buffered sendToController "${event}" -> Player ${playerIndex} (screen not ready yet)`);
+      return;
     }
-    this.logger.send(`${event} -> Player ${playerIndex}`, data);
-    this.transport.emit(event, {
-      targetPlayerIndex: playerIndex,
-      ...data && typeof data === "object" ? data : { data }
-    });
-  }
-  sendToControllerRaw(playerIndex, event, data) {
-    this.ensureReady("sendToControllerRaw");
     events.validateEventName(event);
     validatePlayerIndex(playerIndex, this._controllers);
+    shared.validatePayloadSize(data);
     if (data && typeof data === "object" && "targetPlayerIndex" in data) {
       this.logger.warn(
         `Event "${event}" data contains reserved field "targetPlayerIndex" which will be overwritten for routing.`
@@ -484,6 +497,16 @@ class ScreenImpl {
    * are queued and activated when the transport becomes available.
    */
   on(event, handler) {
+    if (typeof event === "string" && event.startsWith("$")) {
+      const validEvents = events.SCREEN_LIFECYCLE_EVENTS;
+      if (!validEvents.has(event)) {
+        throw new errors.SmoreSDKError("INVALID_EVENT", `Unknown lifecycle event: "${event}". Valid lifecycle events: ${Array.from(validEvents).join(", ")}`);
+      }
+      if (event === "$all-ready" && this._allReadyFired) {
+        handler();
+      }
+      return this._addLifecycleListener(event, handler);
+    }
     events.validateEventName(event);
     let handlers = this.eventHandlers.get(event);
     if (!handlers) {
@@ -546,6 +569,23 @@ class ScreenImpl {
    * @returns Unsubscribe function to remove the handler before it fires
    */
   once(event, handler) {
+    if (typeof event === "string" && event.startsWith("$")) {
+      const validEvents = events.SCREEN_LIFECYCLE_EVENTS;
+      if (!validEvents.has(event)) {
+        throw new errors.SmoreSDKError("INVALID_EVENT", `Unknown lifecycle event: "${event}"`);
+      }
+      if (event === "$all-ready" && this._allReadyFired) {
+        handler();
+        return () => {
+        };
+      }
+      const wrapper = (...args) => {
+        unsub();
+        handler(...args);
+      };
+      const unsub = this._addLifecycleListener(event, wrapper);
+      return unsub;
+    }
     const wrappedHandler = (playerIndex, data) => {
       unsubscribe();
       handler(playerIndex, data);
@@ -554,6 +594,14 @@ class ScreenImpl {
     return unsubscribe;
   }
   off(event, handler) {
+    if (typeof event === "string" && event.startsWith("$")) {
+      if (!handler) {
+        this._lifecycleListeners.delete(event);
+      } else {
+        this._lifecycleListeners.get(event)?.delete(handler);
+      }
+      return;
+    }
     if (!handler) {
       this.eventHandlers.delete(event);
       this.transport?.off(event);
@@ -581,6 +629,21 @@ class ScreenImpl {
       );
     }
   }
+  removeAllListeners(event) {
+    if (event) {
+      this.eventHandlers.delete(event);
+      this.transport?.off(event);
+      this.registeredTransportHandlers = this.registeredTransportHandlers.filter((h) => h.event !== event);
+      for (const [key, val] of this.handlerToTransport) {
+        if (val.event === event) this.handlerToTransport.delete(key);
+      }
+      this._pendingHandlers = this._pendingHandlers.filter((p) => p.event !== event);
+    } else {
+      for (const evt of [...this.eventHandlers.keys()]) {
+        this.removeAllListeners(evt);
+      }
+    }
+  }
   // ---------------------------------------------------------------------------
   // Utilities
   // ---------------------------------------------------------------------------
@@ -590,9 +653,6 @@ class ScreenImpl {
   getControllerCount() {
     return this._controllers.filter((c) => c.connected).length;
   }
-  hasAnyConnectedControllers() {
-    return this._controllers.some((c) => c.connected);
-  }
   // ---------------------------------------------------------------------------
   // Cleanup
   // ---------------------------------------------------------------------------
@@ -616,14 +676,9 @@ class ScreenImpl {
     this.eventHandlers.clear();
     this.handlerToTransport.clear();
     this._pendingHandlers = [];
-    this._onAllReadyCallbacks.clear();
-    this._onControllerJoinCallbacks.clear();
-    this._onControllerLeaveCallbacks.clear();
-    this._onControllerDisconnectCallbacks.clear();
-    this._onControllerReconnectCallbacks.clear();
-    this._onCharacterUpdatedCallbacks.clear();
-    this._onRateLimitedCallbacks.clear();
-    this._onErrorCallbacks.clear();
+    this._lifecycleListeners.clear();
+    this._isConnected = false;
+    this._outboundBuffer = [];
     if (this.transport instanceof PostMessageTransport.PostMessageTransport) {
       this.transport.destroy();
     }
@@ -639,8 +694,8 @@ class ScreenImpl {
   handleError(error) {
     this.logger.warn(`Error in handler: ${error.message}`);
     const smoreError = error.toSmoreError();
-    if (this._onErrorCallbacks.size > 0) {
-      this._onErrorCallbacks.forEach((cb) => cb(smoreError));
+    if (this._hasLifecycleListeners("$error")) {
+      this._emitLifecycle("$error", smoreError);
     } else {
       this.logger.error(error.message, error.details);
     }