@smoregg/sdk 1.2.0 → 2.0.0

package/dist/esm/controller.js

@@ -1,7 +1,7 @@
 import { PostMessageTransport } from './transport/PostMessageTransport.js';
 import { isBridgeMessage, validateInitPayload } from './transport/protocol.js';
 import { SmoreSDKError } from './errors.js';
-import { validateEventName, SMORE_EVENTS } from './events.js';
+import { SMORE_EVENTS, validateEventName } from './events.js';
 import { DebugLogger } from './logger.js';
 import { getGlobalConfig } from './config.js';
 
@@ -14,22 +14,38 @@ class ControllerImpl {
   _myIndex = -1;
   _isReady = false;
   _isDestroyed = false;
+  _initTimeoutId = null;
   boundMessageHandler = null;
   registeredHandlers = [];
   eventListeners = /* @__PURE__ */ new Map();
   // Maps user-facing handler -> transport wrappedHandler for proper cleanup in on()/off()
   handlerToTransport = /* @__PURE__ */ new Map();
   _controllers = [];
-  // 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 DebugLogger(config.debug, "[SmoreController]");
-    if (config.listeners) {
-      for (const event of Object.keys(config.listeners)) {
-        validateEventName(event);
-      }
-    }
+    this.ready = new Promise((resolve, reject) => {
+      this._readyResolve = resolve;
+      this._readyReject = reject;
+    });
+    this.startInitialization();
   }
   // ---------------------------------------------------------------------------
   // Properties (readonly)
@@ -65,38 +81,36 @@ class ControllerImpl {
   // ---------------------------------------------------------------------------
   // Initialization
   // ---------------------------------------------------------------------------
-  async initialize() {
+  startInitialization() {
     const parentOrigin = this.config.parentOrigin ?? "*";
     const timeout = this.config.timeout ?? DEFAULT_TIMEOUT;
     this.logger.lifecycle("Initializing controller...", { parentOrigin, timeout });
-    return new Promise((resolve, reject) => {
-      const timeoutId = setTimeout(() => {
-        this.cleanup();
-        const error = new SmoreSDKError(
-          "TIMEOUT",
-          `Controller initialization timed out after ${timeout}ms. Make sure the parent window sends _bridge:init message. Check that the iframe has correct sandbox attributes (allow-scripts required) and same-origin/cross-origin settings. Create a new Controller 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 (!isBridgeMessage(msg)) return;
-        if (msg.type === "_bridge:init") {
-          clearTimeout(timeoutId);
-          this.handleInit(msg, parentOrigin, resolve, reject);
-        } else if (msg.type === "_bridge:update") {
-          this.handleUpdate(msg);
-        }
-      };
-      window.addEventListener("message", this.boundMessageHandler);
-      this.logger.lifecycle("Sending _bridge:ready to parent");
-      window.parent.postMessage({ type: "_bridge:ready" }, parentOrigin);
-    });
+    this._initTimeoutId = setTimeout(() => {
+      this.cleanup();
+      const error = new SmoreSDKError(
+        "TIMEOUT",
+        `Controller initialization timed out after ${timeout}ms. Make sure the parent window sends _bridge:init message. Check that the iframe has correct sandbox attributes (allow-scripts required) and same-origin/cross-origin settings. Create a new Controller 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 (!isBridgeMessage(msg)) return;
+      if (msg.type === "_bridge:init") {
+        clearTimeout(this._initTimeoutId);
+        this.handleInit(msg, parentOrigin);
+      } else if (msg.type === "_bridge:update") {
+        this.handleUpdate(msg);
+      }
+    };
+    window.addEventListener("message", this.boundMessageHandler);
+    this.logger.lifecycle("Sending _bridge:ready to parent");
+    window.parent.postMessage({ type: "_bridge:ready" }, parentOrigin);
   }
-  handleInit(msg, parentOrigin, resolve, reject) {
+  handleInit(msg, parentOrigin) {
     const initPayload = msg.payload;
     this.logger.debug("Received _bridge:init", initPayload);
     try {
@@ -109,7 +123,7 @@ class ControllerImpl {
       );
       this.logger.warn("_bridge:init validation failed", error);
       this.handleError(error);
-      reject(error);
+      this._readyReject(error);
       return;
     }
     const initData = initPayload;
@@ -120,7 +134,7 @@ class ControllerImpl {
         { details: { side: initData.side } }
       );
       this.handleError(error);
-      reject(error);
+      this._readyReject(error);
       return;
     }
     if (initData.myIndex === void 0) {
@@ -130,7 +144,7 @@ class ControllerImpl {
         { details: initData }
       );
       this.handleError(error);
-      reject(error);
+      this._readyReject(error);
       return;
     }
     this.transport = new PostMessageTransport(parentOrigin);
@@ -144,18 +158,21 @@ class ControllerImpl {
       appearance: p.appearance ?? p.character
     }));
     this.setupEventHandlers();
+    for (const { event, handler } of this._pendingHandlers) {
+      this.setupUserEventHandler(event, handler);
+    }
+    this._pendingHandlers = [];
     this._isReady = true;
     this.logger.lifecycle("Controller ready", {
       roomCode: this._roomCode,
       myIndex: this._myIndex
     });
-    this.config.onReady?.();
-    const autoReady = this.config.autoReady ?? getGlobalConfig().autoReady ?? true;
+    const autoReady = getGlobalConfig().autoReady ?? true;
     if (autoReady) {
       this.logger.lifecycle("Auto-signaling ready (autoReady enabled)");
       this.signalReady();
     }
-    resolve();
+    this._readyResolve();
   }
   handleUpdate(msg) {
     if (!this._isReady) {
@@ -175,12 +192,12 @@ class ControllerImpl {
       const oldControllers = this._controllers;
       for (const nc of newControllers) {
         if (!oldControllers.some((oc) => oc.playerIndex === nc.playerIndex)) {
-          this.config.onControllerJoin?.(nc.playerIndex, nc);
+          this._onControllerJoinCallbacks.forEach((cb) => cb(nc.playerIndex, nc));
         }
       }
       for (const oc of oldControllers) {
         if (!newControllers.some((nc) => nc.playerIndex === oc.playerIndex)) {
-          this.config.onControllerLeave?.(oc.playerIndex);
+          this._onControllerLeaveCallbacks.forEach((cb) => cb(oc.playerIndex));
         }
       }
       for (const nc of newControllers) {
@@ -188,11 +205,11 @@ class ControllerImpl {
         if (oc) {
           if (oc.connected && !nc.connected) {
             this.logger.debug("Player disconnected (via update)", { playerIndex: nc.playerIndex });
-            this.config.onControllerDisconnect?.(nc.playerIndex);
+            this._onControllerDisconnectCallbacks.forEach((cb) => cb(nc.playerIndex));
           }
           if (!oc.connected && nc.connected) {
             this.logger.debug("Player reconnected (via update)", { playerIndex: nc.playerIndex });
-            this.config.onControllerReconnect?.(nc.playerIndex, nc);
+            this._onControllerReconnectCallbacks.forEach((cb) => cb(nc.playerIndex, nc));
           }
         }
       }
@@ -219,7 +236,7 @@ class ControllerImpl {
         };
         this._controllers = [...this._controllers, controllerInfo];
         this.logger.debug("Player joined", { playerIndex });
-        this.config.onControllerJoin?.(playerIndex, controllerInfo);
+        this._onControllerJoinCallbacks.forEach((cb) => cb(playerIndex, controllerInfo));
       }
     });
     this.registerHandler(SMORE_EVENTS.PLAYER_LEFT, (raw) => {
@@ -229,7 +246,7 @@ class ControllerImpl {
         if (!this._controllers.some((c) => c.playerIndex === playerIndex)) return;
         this._controllers = this._controllers.filter((c) => c.playerIndex !== playerIndex);
         this.logger.debug("Player left", { playerIndex });
-        this.config.onControllerLeave?.(playerIndex);
+        this._onControllerLeaveCallbacks.forEach((cb) => cb(playerIndex));
       }
     });
     this.registerHandler(SMORE_EVENTS.PLAYER_DISCONNECTED, (raw) => {
@@ -241,7 +258,7 @@ class ControllerImpl {
           (c) => c.playerIndex === playerIndex ? { ...c, connected: false } : c
         );
         this.logger.debug("Player disconnected", { playerIndex });
-        this.config.onControllerDisconnect?.(playerIndex);
+        this._onControllerDisconnectCallbacks.forEach((cb) => cb(playerIndex));
       }
     });
     this.registerHandler(SMORE_EVENTS.PLAYER_RECONNECTED, (raw) => {
@@ -263,56 +280,63 @@ class ControllerImpl {
           (c) => c.playerIndex === playerIndex ? controllerInfo : c
         );
         this.logger.debug("Player reconnected", { playerIndex });
-        this.config.onControllerReconnect?.(playerIndex, controllerInfo);
+        this._onControllerReconnectCallbacks.forEach((cb) => cb(playerIndex, controllerInfo));
       }
     });
     this.registerHandler(SMORE_EVENTS.PLAYER_CHARACTER_UPDATED, (raw) => {
       const payload = raw;
       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.debug("Player character updated", { playerIndex: playerData.playerIndex });
-        this.config.onCharacterUpdated?.(playerData.playerIndex, appearance ?? null);
+        this.logger.debug("Player character updated", { playerIndex: pi });
+        this._onCharacterUpdatedCallbacks.forEach((cb) => cb(pi, appearance ?? null));
       }
     });
     this.registerHandler(SMORE_EVENTS.RATE_LIMITED, (raw) => {
       const data = raw;
       const event = data?.event ?? "unknown";
       this.logger.warn(`Rate limited: ${event}`);
-      this.config.onRateLimited?.(event);
+      this._onRateLimitedCallbacks.forEach((cb) => cb(event));
     });
     this.registerHandler(SMORE_EVENTS.ALL_READY, () => {
       this.logger.lifecycle("All participants ready");
-      this.config.onAllReady?.();
+      this._allReadyFired = true;
+      this._onAllReadyCallbacks.forEach((cb) => cb());
     });
-    if (this.config.onHostDisconnect) {
-      this.logger.warn("onHostDisconnect is reserved for future use and currently non-functional");
-    }
-    if (this.config.onHostReconnect) {
-      this.logger.warn("onHostReconnect is reserved for future use and currently non-functional");
-    }
-    if (this.config.listeners) {
-      for (const [event, handler] of Object.entries(this.config.listeners)) {
-        if (!handler) continue;
-        this._configListenerEvents.add(event);
-        this.registerHandler(event, (data) => {
-          this.logReceive(event, data);
-          try {
-            handler(data);
-          } catch (err) {
-            this.handleError(
-              new SmoreSDKError("UNKNOWN", `Error in handler for event "${event}"`, {
-                cause: err instanceof Error ? err : void 0,
-                details: { event }
-              })
-            );
-          }
-        });
+  }
+  /**
+   * Sets up a user event handler for controller events.
+   * Used for registering pending handlers after transport becomes available.
+   */
+  setupUserEventHandler(event, handler) {
+    const transportHandler = (data) => {
+      this.logReceive(event, data);
+      try {
+        handler(data);
+      } catch (err) {
+        this.handleError(
+          new SmoreSDKError("UNKNOWN", `Error in handler for event "${event}"`, {
+            cause: err instanceof Error ? err : void 0,
+            details: { event }
+          })
+        );
       }
+    };
+    if (this.transport) {
+      this.transport.on(event, transportHandler);
+      this.registeredHandlers.push({ event, handler: transportHandler });
+      this.handlerToTransport.set(handler, { event, transportHandler });
     }
+    let listeners = this.eventListeners.get(event);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      this.eventListeners.set(event, listeners);
+    }
+    listeners.add(handler);
   }
   registerHandler(event, handler) {
     if (!this.transport) return;
@@ -320,13 +344,67 @@ class ControllerImpl {
     this.registeredHandlers.push({ event, handler });
   }
   // ---------------------------------------------------------------------------
+  // 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
   // ---------------------------------------------------------------------------
   /**
    * Send an event to the Screen. Controller-to-Controller direct communication
    * is not supported; all messages must go through the Screen.
    *
-   * Data is sent to the Screen only (not to other controllers). For Screen→Controller communication,
+   * Data is sent to the Screen only (not to other controllers). For Screen->Controller communication,
    * Screen uses broadcast() or sendToController().
    *
    * @note Fire-and-forget sends (no callback) will silently fail if rate-limited.
@@ -360,24 +438,14 @@ class ControllerImpl {
   /**
    * Register a handler for custom events.
    *
+   * Can be called before the Controller is ready. Handlers registered before ready
+   * are queued and activated when the transport becomes available.
+   *
    * When receiving events from Screen's `broadcast()`:
-   *   handler receives `(data)` — no playerIndex included.
+   *   handler receives `(data)` -- no playerIndex included.
    *
    * When receiving events from Screen's `sendToController()`:
-   *   handler receives `(data)` — targeted to this specific controller.
-   *
-   * @note Unlike Screen's `on()` which receives `(playerIndex, data)`,
-   * Controller's `on()` receives only `(data)` since there's only one player per controller.
-   *
-   * Controller's on() handler signature: (data) => void
-   * Unlike Screen's (playerIndex, data) => void, Controller doesn't receive playerIndex
-   * because Controller only receives events from Screen, not from other controllers.
-   * The sender is always the Screen, so playerIndex is not applicable.
-   *
-   * **Important:** If called before the Controller is ready (i.e., before `await createController()`
-   * resolves or before the `onReady` callback fires), the handler is stored locally but
-   * will NOT receive events until the transport is initialized. Always call `on()` after
-   * initialization completes, or use `config.listeners` for handlers needed from the start.
+   *   handler receives `(data)` -- targeted to this specific controller.
    */
   on(event, handler) {
     validateEventName(event);
@@ -387,34 +455,42 @@ class ControllerImpl {
       this.eventListeners.set(event, listeners);
     }
     listeners.add(handler);
-    const transportHandler = (data) => {
-      this.logReceive(event, data);
-      try {
-        handler(data);
-      } catch (err) {
-        this.handleError(
-          new SmoreSDKError("UNKNOWN", `Error in handler for event "${event}"`, {
-            cause: err instanceof Error ? err : void 0,
-            details: { event }
-          })
-        );
-      }
-    };
     if (this.transport) {
+      const transportHandler = (data) => {
+        this.logReceive(event, data);
+        try {
+          handler(data);
+        } catch (err) {
+          this.handleError(
+            new SmoreSDKError("UNKNOWN", `Error in handler for event "${event}"`, {
+              cause: err instanceof Error ? err : void 0,
+              details: { event }
+            })
+          );
+        }
+      };
       this.transport.on(event, transportHandler);
       this.registeredHandlers.push({ event, handler: transportHandler });
       this.handlerToTransport.set(handler, { event, transportHandler });
+    } else {
+      this._pendingHandlers.push({ event, handler });
     }
     return () => {
       listeners?.delete(handler);
       if (listeners?.size === 0) {
         this.eventListeners.delete(event);
       }
-      this.transport?.off(event, transportHandler);
-      this.registeredHandlers = this.registeredHandlers.filter(
-        (h) => h.handler !== transportHandler
+      this._pendingHandlers = this._pendingHandlers.filter(
+        (p) => !(p.event === event && p.handler === handler)
       );
-      this.handlerToTransport.delete(handler);
+      const entry = this.handlerToTransport.get(handler);
+      if (entry) {
+        this.transport?.off(event, entry.transportHandler);
+        this.registeredHandlers = this.registeredHandlers.filter(
+          (h) => h.handler !== entry.transportHandler
+        );
+        this.handlerToTransport.delete(handler);
+      }
     };
   }
   /**
@@ -422,16 +498,6 @@ class ControllerImpl {
    *
    * @note The handler is internally wrapped, so it cannot be removed via
    * `off(event, originalHandler)`. Use the returned unsubscribe function instead.
-   *
-   * @example
-   * ```ts
-   * const unsubscribe = controller.once('game-start', (data) => {
-   *   console.log('Game started!', data);
-   * });
-   *
-   * // To cancel before it fires:
-   * unsubscribe();
-   * ```
    */
   once(event, handler) {
     const unsubscribe = this.on(event, ((data) => {
@@ -442,24 +508,13 @@ class ControllerImpl {
   }
   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.registeredHandlers = this.registeredHandlers.filter(
-              (h) => h.handler !== val.transportHandler
-            );
-            this.handlerToTransport.delete(key);
-          }
-        }
-      } else {
-        this.eventListeners.delete(event);
-        this.transport?.off(event);
-        this.registeredHandlers = this.registeredHandlers.filter((h) => h.event !== event);
-        for (const [key, val] of this.handlerToTransport) {
-          if (val.event === event) this.handlerToTransport.delete(key);
-        }
+      this.eventListeners.delete(event);
+      this.transport?.off(event);
+      this.registeredHandlers = this.registeredHandlers.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 listeners = this.eventListeners.get(event);
       listeners?.delete(handler);
@@ -474,6 +529,9 @@ class ControllerImpl {
         );
         this.handlerToTransport.delete(handler);
       }
+      this._pendingHandlers = this._pendingHandlers.filter(
+        (p) => !(p.event === event && p.handler === handler)
+      );
     }
   }
   // ---------------------------------------------------------------------------
@@ -482,10 +540,15 @@ class ControllerImpl {
   destroy() {
     if (this._isDestroyed) return;
     this.logger.lifecycle("Destroying controller");
-    this.cleanup();
     this._isDestroyed = true;
+    this._isReady = false;
+    this.cleanup();
   }
   cleanup() {
+    if (this._initTimeoutId) {
+      clearTimeout(this._initTimeoutId);
+      this._initTimeoutId = null;
+    }
     this._isReady = false;
     for (const { event, handler } of this.registeredHandlers) {
       this.transport?.off(event, handler);
@@ -493,6 +556,15 @@ class ControllerImpl {
     this.registeredHandlers = [];
     this.eventListeners.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) {
       this.transport.destroy();
       this.transport = null;
@@ -516,15 +588,16 @@ class ControllerImpl {
     if (!this._isReady || !this.transport) {
       throw new SmoreSDKError(
         "NOT_READY",
-        `Cannot call ${method}() before controller is ready. Use await createController() or wait for onReady callback.`,
+        `Cannot call ${method}() before controller is ready. Use await controller.ready.`,
         { details: { method, isReady: this._isReady } }
       );
     }
   }
   handleError(error) {
     this.logger.warn(`Error in handler: ${error.message}`);
-    if (this.config.onError) {
-      this.config.onError(error.toSmoreError());
+    const smoreError = error.toSmoreError();
+    if (this._onErrorCallbacks.size > 0) {
+      this._onErrorCallbacks.forEach((cb) => cb(smoreError));
     } else {
       this.logger.error(error.message, error.details);
     }
@@ -537,10 +610,7 @@ class ControllerImpl {
   }
 }
 function createController(config) {
-  const controller = new ControllerImpl(config ?? {});
-  const promise = controller.initialize().then(() => controller);
-  promise.instance = controller;
-  return promise;
+  return new ControllerImpl(config ?? {});
 }
 
 export { createController };