@smoregg/sdk 1.2.0 → 2.0.0

package/dist/cjs/screen.cjs

@@ -28,122 +28,139 @@ class ScreenImpl {
   _roomCode = "";
   _isReady = false;
   _isDestroyed = false;
+  _initTimeoutId = null;
   eventHandlers = /* @__PURE__ */ new Map();
   registeredTransportHandlers = [];
   boundMessageHandler = null;
-  // Maps user-facing handler → transport wrappedHandler for proper cleanup in on()/off()
+  // Maps user-facing handler -> transport wrappedHandler for proper cleanup in on()/off()
   handlerToTransport = /* @__PURE__ */ new Map();
-  // Tracks event names registered via config.listeners so off(event) without handler won't remove them
-  _configListenerEvents = /* @__PURE__ */ new Set();
+  // 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();
+  // Whether all-ready has fired
+  _allReadyFired = false;
+  // Ready promise
+  _readyResolve;
+  _readyReject;
+  ready;
   constructor(config = {}) {
     this.config = config;
     this.logger = new logger.DebugLogger(config.debug, "[SmoreScreen]");
-    if (config.listeners) {
-      for (const event of Object.keys(config.listeners)) {
-        events.validateEventName(event);
-      }
-    }
+    this.ready = new Promise((resolve, reject) => {
+      this._readyResolve = resolve;
+      this._readyReject = reject;
+    });
+    this.startInitialization();
   }
   // ---------------------------------------------------------------------------
-  // Initialization (called by factory)
+  // Initialization (called in constructor)
   // ---------------------------------------------------------------------------
-  async initialize() {
+  startInitialization() {
     this.logger.lifecycle("Initializing screen...");
     const parentOrigin = this.config.parentOrigin ?? "*";
     const timeout = this.config.timeout ?? DEFAULT_TIMEOUT;
-    return new Promise((resolve, reject) => {
-      const timeoutId = setTimeout(() => {
-        this.cleanup();
-        const error = new errors.SmoreSDKError(
-          "TIMEOUT",
-          `Screen initialization timed out after ${timeout}ms. Make sure the parent frame sends _bridge:init. Check that the iframe has correct sandbox attributes (allow-scripts required) and same-origin/cross-origin settings. Create a new Screen instance to retry (this instance has been cleaned up).`,
-          { details: { timeout } }
-        );
-        this.handleError(error);
-        reject(error);
-      }, timeout);
-      this.boundMessageHandler = (e) => {
-        if (parentOrigin !== "*" && e.origin !== parentOrigin) return;
-        const msg = e.data;
-        if (!protocol.isBridgeMessage(msg)) return;
-        if (msg.type === "_bridge:init") {
-          clearTimeout(timeoutId);
-          const initPayload = msg.payload;
-          try {
-            protocol.validateInitPayload(initPayload);
-          } catch (err) {
-            const error = new errors.SmoreSDKError(
-              "INIT_FAILED",
-              `Invalid _bridge:init payload: ${err instanceof Error ? err.message : String(err)}`,
-              { details: { payload: initPayload } }
-            );
-            this.logger.warn("_bridge:init validation failed", error);
-            this.handleError(error);
-            reject(error);
-            return;
-          }
-          const initData = initPayload;
-          if (initData.side !== "host") {
-            const error = new errors.SmoreSDKError(
-              "INIT_FAILED",
-              `Received init for wrong side: ${initData.side}. Expected "host".`,
-              { details: { side: initData.side } }
-            );
-            this.handleError(error);
-            reject(error);
-            return;
-          }
-          this.transport = new PostMessageTransport.PostMessageTransport(parentOrigin);
-          this._roomCode = initData.roomCode;
-          this._controllers = this.mapControllersFromInit(initData.players);
-          if (this._controllers.length === 0) {
-            this.logger.warn("Screen initialized with zero controllers");
-          }
-          this.setupEventHandlers();
-          this._isReady = true;
-          this.logger.lifecycle("Screen ready", {
-            roomCode: this._roomCode,
-            controllers: this._controllers.length
-          });
-          this.config.onReady?.();
-          const autoReady = this.config.autoReady ?? config.getGlobalConfig().autoReady ?? true;
-          if (autoReady) {
-            this.logger.lifecycle("Auto-signaling ready (autoReady enabled)");
-            this.signalReady();
-          }
-          resolve();
-        } else if (msg.type === "_bridge:update") {
-          if (!this._isReady) {
-            this.logger.debug("Ignoring _bridge:update before init completes");
-            return;
-          }
-          const updateData = msg.payload;
-          if (updateData.players && Array.isArray(updateData.players)) {
-            const oldControllers = this._controllers;
-            const newControllers = this.mapControllersFromInit(updateData.players);
-            this._controllers = newControllers;
-            for (const nc of newControllers) {
-              if (!oldControllers.some((oc) => oc.playerIndex === nc.playerIndex)) {
-                this.logger.lifecycle("Controller joined (via update)", { playerIndex: nc.playerIndex });
-                this.config.onControllerJoin?.(nc.playerIndex, nc);
-              }
+    this._initTimeoutId = setTimeout(() => {
+      this.cleanup();
+      const error = new errors.SmoreSDKError(
+        "TIMEOUT",
+        `Screen initialization timed out after ${timeout}ms. Make sure the parent frame sends _bridge:init. Check that the iframe has correct sandbox attributes (allow-scripts required) and same-origin/cross-origin settings. Create a new Screen instance to retry (this instance has been cleaned up).`,
+        { details: { timeout } }
+      );
+      this.handleError(error);
+      this._readyReject(error);
+    }, timeout);
+    this.boundMessageHandler = (e) => {
+      if (parentOrigin !== "*" && e.origin !== parentOrigin) return;
+      const msg = e.data;
+      if (!protocol.isBridgeMessage(msg)) return;
+      if (msg.type === "_bridge:init") {
+        clearTimeout(this._initTimeoutId);
+        const initPayload = msg.payload;
+        try {
+          protocol.validateInitPayload(initPayload);
+        } catch (err) {
+          const error = new errors.SmoreSDKError(
+            "INIT_FAILED",
+            `Invalid _bridge:init payload: ${err instanceof Error ? err.message : String(err)}`,
+            { details: { payload: initPayload } }
+          );
+          this.logger.warn("_bridge:init validation failed", error);
+          this.handleError(error);
+          this._readyReject(error);
+          return;
+        }
+        const initData = initPayload;
+        if (initData.side !== "host") {
+          const error = new errors.SmoreSDKError(
+            "INIT_FAILED",
+            `Received init for wrong side: ${initData.side}. Expected "host".`,
+            { details: { side: initData.side } }
+          );
+          this.handleError(error);
+          this._readyReject(error);
+          return;
+        }
+        this.transport = new PostMessageTransport.PostMessageTransport(parentOrigin);
+        this._roomCode = initData.roomCode;
+        this._controllers = this.mapControllersFromInit(initData.players);
+        if (this._controllers.length === 0) {
+          this.logger.warn("Screen initialized with zero controllers");
+        }
+        this.setupEventHandlers();
+        for (const { event, handler } of this._pendingHandlers) {
+          this.setupUserEventHandler(event, handler);
+        }
+        this._pendingHandlers = [];
+        this._isReady = true;
+        this.logger.lifecycle("Screen ready", {
+          roomCode: this._roomCode,
+          controllers: this._controllers.length
+        });
+        const autoReady = config.getGlobalConfig().autoReady ?? true;
+        if (autoReady) {
+          this.logger.lifecycle("Auto-signaling ready (autoReady enabled)");
+          this.signalReady();
+        }
+        this._readyResolve();
+      } else if (msg.type === "_bridge:update") {
+        if (!this._isReady) {
+          this.logger.debug("Ignoring _bridge:update before init completes");
+          return;
+        }
+        const updateData = msg.payload;
+        if (updateData.players && Array.isArray(updateData.players)) {
+          const oldControllers = this._controllers;
+          const newControllers = this.mapControllersFromInit(updateData.players);
+          this._controllers = newControllers;
+          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));
             }
-            for (const oc of oldControllers) {
-              if (!newControllers.some((nc) => nc.playerIndex === oc.playerIndex)) {
-                this.logger.lifecycle("Controller left (via update)", { playerIndex: oc.playerIndex });
-                this.config.onControllerLeave?.(oc.playerIndex);
-              }
+          }
+          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.logger.lifecycle("Room updated", {
-            controllers: this._controllers.length
-          });
         }
-      };
-      window.addEventListener("message", this.boundMessageHandler);
-      window.parent.postMessage({ type: "_bridge:ready" }, parentOrigin);
-      this.logger.lifecycle("Sent _bridge:ready to parent");
-    });
+        this.logger.lifecycle("Room updated", {
+          controllers: this._controllers.length
+        });
+      }
+    };
+    window.addEventListener("message", this.boundMessageHandler);
+    window.parent.postMessage({ type: "_bridge:ready" }, parentOrigin);
+    this.logger.lifecycle("Sent _bridge:ready to parent");
   }
   mapControllersFromInit(players) {
     return players.map((p, index) => ({
@@ -170,7 +187,7 @@ class ScreenImpl {
         if (this._controllers.some((c) => c.playerIndex === controllerInfo.playerIndex)) return;
         this._controllers = [...this._controllers, controllerInfo];
         this.logger.lifecycle("Controller joined", { playerIndex: controllerInfo.playerIndex });
-        this.config.onControllerJoin?.(controllerInfo.playerIndex, controllerInfo);
+        this._onControllerJoinCallbacks.forEach((cb) => cb(controllerInfo.playerIndex, controllerInfo));
       }
     });
     this.registerTransportHandler(events.SMORE_EVENTS.PLAYER_LEFT, (data) => {
@@ -180,7 +197,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.config.onControllerLeave?.(playerIndex);
+        this._onControllerLeaveCallbacks.forEach((cb) => cb(playerIndex));
       }
     });
     this.registerTransportHandler(events.SMORE_EVENTS.PLAYER_DISCONNECTED, (data) => {
@@ -191,7 +208,7 @@ class ScreenImpl {
           (c) => c.playerIndex === playerIndex ? { ...c, connected: false } : c
         );
         this.logger.lifecycle("Controller disconnected", { playerIndex });
-        this.config.onControllerDisconnect?.(playerIndex);
+        this._onControllerDisconnectCallbacks.forEach((cb) => cb(playerIndex));
       }
     });
     this.registerTransportHandler(events.SMORE_EVENTS.PLAYER_RECONNECTED, (data) => {
@@ -208,38 +225,33 @@ class ScreenImpl {
           (c) => c.playerIndex === controllerInfo.playerIndex ? controllerInfo : c
         );
         this.logger.lifecycle("Controller reconnected", { playerIndex: controllerInfo.playerIndex });
-        this.config.onControllerReconnect?.(controllerInfo.playerIndex, controllerInfo);
+        this._onControllerReconnectCallbacks.forEach((cb) => cb(controllerInfo.playerIndex, controllerInfo));
       }
     });
     this.registerTransportHandler(events.SMORE_EVENTS.PLAYER_CHARACTER_UPDATED, (data) => {
       const payload = data;
       const playerData = payload?.player;
       if (playerData && typeof playerData.playerIndex === "number") {
+        const pi = playerData.playerIndex;
         const appearance = playerData.character ?? null;
         this._controllers = this._controllers.map(
-          (c) => c.playerIndex === playerData.playerIndex ? { ...c, appearance } : c
+          (c) => c.playerIndex === pi ? { ...c, appearance } : c
         );
-        this.logger.lifecycle("Player character updated", { playerIndex: playerData.playerIndex });
-        this.config.onCharacterUpdated?.(playerData.playerIndex, appearance ?? null);
+        this.logger.lifecycle("Player character updated", { playerIndex: pi });
+        this._onCharacterUpdatedCallbacks.forEach((cb) => cb(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.config.onRateLimited?.(event);
+      this._onRateLimitedCallbacks.forEach((cb) => cb(event));
     });
     this.registerTransportHandler(events.SMORE_EVENTS.ALL_READY, () => {
       this.logger.lifecycle("All participants ready");
-      this.config.onAllReady?.();
+      this._allReadyFired = true;
+      this._onAllReadyCallbacks.forEach((cb) => cb());
     });
-    if (this.config.listeners) {
-      for (const [event, handler] of Object.entries(this.config.listeners)) {
-        if (!handler) continue;
-        this._configListenerEvents.add(event);
-        this.setupUserEventHandler(event, handler);
-      }
-    }
   }
   /**
    * Sets up a user event handler with playerIndex extraction.
@@ -281,6 +293,7 @@ class ScreenImpl {
       this.eventHandlers.set(event, handlers);
     }
     handlers.add(handler);
+    this.handlerToTransport.set(handler, { event, transportHandler: wrappedHandler });
   }
   registerTransportHandler(event, handler) {
     if (!this.transport) return;
@@ -307,6 +320,60 @@ class ScreenImpl {
     return this._isDestroyed;
   }
   // ---------------------------------------------------------------------------
+  // Lifecycle Methods
+  // ---------------------------------------------------------------------------
+  onAllReady(callback) {
+    if (this._allReadyFired) {
+      callback();
+    }
+    this._onAllReadyCallbacks.add(callback);
+    return () => {
+      this._onAllReadyCallbacks.delete(callback);
+    };
+  }
+  onControllerJoin(callback) {
+    this._onControllerJoinCallbacks.add(callback);
+    return () => {
+      this._onControllerJoinCallbacks.delete(callback);
+    };
+  }
+  onControllerLeave(callback) {
+    this._onControllerLeaveCallbacks.add(callback);
+    return () => {
+      this._onControllerLeaveCallbacks.delete(callback);
+    };
+  }
+  onControllerDisconnect(callback) {
+    this._onControllerDisconnectCallbacks.add(callback);
+    return () => {
+      this._onControllerDisconnectCallbacks.delete(callback);
+    };
+  }
+  onControllerReconnect(callback) {
+    this._onControllerReconnectCallbacks.add(callback);
+    return () => {
+      this._onControllerReconnectCallbacks.delete(callback);
+    };
+  }
+  onCharacterUpdated(callback) {
+    this._onCharacterUpdatedCallbacks.add(callback);
+    return () => {
+      this._onCharacterUpdatedCallbacks.delete(callback);
+    };
+  }
+  onRateLimited(callback) {
+    this._onRateLimitedCallbacks.add(callback);
+    return () => {
+      this._onRateLimitedCallbacks.delete(callback);
+    };
+  }
+  onError(callback) {
+    this._onErrorCallbacks.add(callback);
+    return () => {
+      this._onErrorCallbacks.delete(callback);
+    };
+  }
+  // ---------------------------------------------------------------------------
   // Communication Methods
   // ---------------------------------------------------------------------------
   /**
@@ -413,11 +480,8 @@ class ScreenImpl {
   /**
    * Register an event handler for messages from controllers.
    *
-   * **Important:** If called before the Screen is ready (i.e., before `await createScreen()`
-   * resolves or before the `onReady` callback fires), the handler is stored locally but
-   * will NOT be registered with the transport layer. This means the handler will never
-   * fire for events received during the pre-ready window. Always call `on()` after
-   * initialization completes, or use `config.listeners` for handlers needed from the start.
+   * Can be called before the Screen is ready. Handlers registered before ready
+   * are queued and activated when the transport becomes available.
    */
   on(event, handler) {
     events.validateEventName(event);
@@ -427,9 +491,8 @@ class ScreenImpl {
       this.eventHandlers.set(event, handlers);
     }
     handlers.add(handler);
-    let wrappedHandler = null;
     if (this.transport) {
-      wrappedHandler = (data) => {
+      const wrappedHandler = (data) => {
         this.logger.receive(event, data);
         const payload = data;
         const { playerIndex, ...rest } = payload;
@@ -449,16 +512,22 @@ class ScreenImpl {
       };
       this.registerTransportHandler(event, wrappedHandler);
       this.handlerToTransport.set(handler, { event, transportHandler: wrappedHandler });
+    } else {
+      this._pendingHandlers.push({ event, handler });
     }
     return () => {
       handlers?.delete(handler);
       if (handlers?.size === 0) {
         this.eventHandlers.delete(event);
       }
-      if (wrappedHandler) {
-        this.transport?.off(event, wrappedHandler);
+      this._pendingHandlers = this._pendingHandlers.filter(
+        (p) => !(p.event === event && p.handler === handler)
+      );
+      const entry = this.handlerToTransport.get(handler);
+      if (entry) {
+        this.transport?.off(event, entry.transportHandler);
         this.registeredTransportHandlers = this.registeredTransportHandlers.filter(
-          (h) => h.handler !== wrappedHandler
+          (h) => h.handler !== entry.transportHandler
         );
         this.handlerToTransport.delete(handler);
       }
@@ -475,16 +544,6 @@ class ScreenImpl {
    * @param event - Event name to listen for
    * @param handler - Handler function to call once
    * @returns Unsubscribe function to remove the handler before it fires
-   *
-   * @example
-   * ```ts
-   * const unsubscribe = screen.once('ready', (playerIndex, data) => {
-   *   console.log('Ready event received');
-   * });
-   *
-   * // To remove before the event fires:
-   * unsubscribe();
-   * ```
    */
   once(event, handler) {
     const wrappedHandler = (playerIndex, data) => {
@@ -496,24 +555,13 @@ class ScreenImpl {
   }
   off(event, handler) {
     if (!handler) {
-      if (this._configListenerEvents.has(event)) {
-        for (const [key, val] of this.handlerToTransport) {
-          if (val.event === event) {
-            this.transport?.off(event, val.transportHandler);
-            this.registeredTransportHandlers = this.registeredTransportHandlers.filter(
-              (h) => h.handler !== val.transportHandler
-            );
-            this.handlerToTransport.delete(key);
-          }
-        }
-      } else {
-        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.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 {
       const handlers = this.eventHandlers.get(event);
       handlers?.delete(handler);
@@ -528,6 +576,9 @@ class ScreenImpl {
         );
         this.handlerToTransport.delete(handler);
       }
+      this._pendingHandlers = this._pendingHandlers.filter(
+        (p) => !(p.event === event && p.handler === handler)
+      );
     }
   }
   // ---------------------------------------------------------------------------
@@ -539,25 +590,6 @@ class ScreenImpl {
   getControllerCount() {
     return this._controllers.filter((c) => c.connected).length;
   }
-  /**
-   * Check if there is at least one connected controller.
-   * Useful for detecting when all players have disconnected
-   * (e.g., to pause the game or show a waiting screen).
-   *
-   * Use this in onControllerDisconnect callback to detect when all controllers have disconnected.
-   *
-   * @example
-   * ```ts
-   * const screen = await createScreen<MyEvents>({
-   *   onControllerDisconnect: (playerIndex) => {
-   *     if (!screen.hasAnyConnectedControllers()) {
-   *       console.log('All controllers disconnected!');
-   *       screen.broadcast('waiting-for-players', {});
-   *     }
-   *   },
-   * });
-   * ```
-   */
   hasAnyConnectedControllers() {
     return this._controllers.some((c) => c.connected);
   }
@@ -573,12 +605,25 @@ class ScreenImpl {
     this.logger.lifecycle("Screen destroyed");
   }
   cleanup() {
+    if (this._initTimeoutId) {
+      clearTimeout(this._initTimeoutId);
+      this._initTimeoutId = null;
+    }
     for (const { event, handler } of this.registeredTransportHandlers) {
       this.transport?.off(event, handler);
     }
     this.registeredTransportHandlers = [];
     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();
     if (this.transport instanceof PostMessageTransport.PostMessageTransport) {
       this.transport.destroy();
     }
@@ -594,8 +639,8 @@ class ScreenImpl {
   handleError(error) {
     this.logger.warn(`Error in handler: ${error.message}`);
     const smoreError = error.toSmoreError();
-    if (this.config.onError) {
-      this.config.onError(smoreError);
+    if (this._onErrorCallbacks.size > 0) {
+      this._onErrorCallbacks.forEach((cb) => cb(smoreError));
     } else {
       this.logger.error(error.message, error.details);
     }
@@ -611,17 +656,14 @@ class ScreenImpl {
     if (!this._isReady || !this.transport) {
       throw new errors.SmoreSDKError(
         "NOT_READY",
-        `Cannot call ${method}() before screen is ready. Use await createScreen() or onReady callback.`,
+        `Cannot call ${method}() before screen is ready. Use await screen.ready.`,
         { details: { method } }
       );
     }
   }
 }
 function createScreen(config) {
-  const screen = new ScreenImpl(config);
-  const promise = screen.initialize().then(() => screen);
-  promise.instance = screen;
-  return promise;
+  return new ScreenImpl(config);
 }
 
 exports.createScreen = createScreen;