@bluebottle_gg/league-broadcast-client 1.4.0 → 1.4.1

package/dist/index.d.ts

@@ -2960,6 +2960,7 @@ declare class LeagueBroadcastClient {
     private champSelectData;
     private champSelectWasActive;
     private postGameData;
+    private postGameSeedPromise;
     /** Reactive store for **in-game** state. */
     readonly ingameStore: GameStateStore;
     /** Reactive store for **pre-game** (champion select) state. */
@@ -3002,10 +3003,16 @@ declare class LeagueBroadcastClient {
     private _startClock;
     private _stopClock;
     /**
-     * Connect to both in-game and pre-game WebSocket endpoints.
+     * Connect to the in-game, pre-game, and (unless disabled) post-game
+     * WebSocket endpoints.
      *
-     * Both connections are attempted in parallel. If either fails the returned
-     * promise rejects, but the other connection may still succeed.
+     * All connections are attempted in parallel. If any fails the returned
+     * promise rejects, but the other connections may still succeed.
+     *
+     * On a successful post-game connection the current post-game state
+     * (`isMocking`, `activeComponent`) is seeded from the REST API before the
+     * promise resolves, so pages that connect mid-session see the live backend
+     * state instead of stale defaults.
      */
     connect(): Promise<void>;
     /**
@@ -3164,6 +3171,16 @@ declare class LeagueBroadcastClient {
     private handleRouteUpdate;
     private endChampSelect;
     private setupPostGameMessageHandler;
+    /**
+     * Seed `isMocking` and `activeComponent` from the REST API.
+     *
+     * The post-game WebSocket only broadcasts changes, so a client that
+     * connects while mocking is already enabled or a component is already
+     * active would keep the stale defaults until the next broadcast. Runs on
+     * every (re)connect; event handlers fire only for values that actually
+     * changed. Never rejects — a failed request leaves that field untouched.
+     */
+    private seedPostGameState;
     private handlePostGameRouteUpdate;
     private handlePostGameMockingUpdate;
     private handleActiveComponentChanged;

package/dist/index.js

@@ -1961,6 +1961,7 @@ var LeagueBroadcastClient = class {
     this.gameState = 0 /* OutOfGame */;
     this._isTestingEnvironment = false;
     this.champSelectWasActive = false;
+    this.postGameSeedPromise = null;
     // -- In-game event handlers -------------------------------------------------
     this.stateUpdateHandlers = /* @__PURE__ */ new Set();
     this.gameStatusHandlers = /* @__PURE__ */ new Set();
@@ -2020,6 +2021,9 @@ var LeagueBroadcastClient = class {
     this.postGameData = new postGameStateData();
     this.postGameStore = new PostGameStateStore(this.postGameData);
     this.setupPostGameMessageHandler();
+    this.postGameWs.onConnect(() => {
+      this.postGameSeedPromise = this.seedPostGameState();
+    });
     if (this.config.autoConnect) {
       this.connect();
     }
@@ -2047,10 +2051,16 @@ var LeagueBroadcastClient = class {
   // Connection management
   // ===========================================================================
   /**
-   * Connect to both in-game and pre-game WebSocket endpoints.
+   * Connect to the in-game, pre-game, and (unless disabled) post-game
+   * WebSocket endpoints.
+   *
+   * All connections are attempted in parallel. If any fails the returned
+   * promise rejects, but the other connections may still succeed.
    *
-   * Both connections are attempted in parallel. If either fails the returned
-   * promise rejects, but the other connection may still succeed.
+   * On a successful post-game connection the current post-game state
+   * (`isMocking`, `activeComponent`) is seeded from the REST API before the
+   * promise resolves, so pages that connect mid-session see the live backend
+   * state instead of stale defaults.
    */
   async connect() {
     this.startOverlayHealthIfEnabled();
@@ -2078,6 +2088,9 @@ var LeagueBroadcastClient = class {
       );
       throw reasons[0];
     }
+    if (this.postGameSeedPromise) {
+      await this.postGameSeedPromise;
+    }
   }
   /**
    * Disconnect from both WebSocket endpoints.
@@ -2086,7 +2099,10 @@ var LeagueBroadcastClient = class {
     this.ingameWs.disconnect();
     this.preGameWs.disconnect();
     this.postGameWs.disconnect();
-    this._overlayHealth?.stop();
+    try {
+      this._overlayHealth?.stop();
+    } catch {
+    }
     this._overlayHealth = null;
   }
   /**
@@ -2613,6 +2629,49 @@ var LeagueBroadcastClient = class {
       }
     });
   }
+  /**
+   * Seed `isMocking` and `activeComponent` from the REST API.
+   *
+   * The post-game WebSocket only broadcasts changes, so a client that
+   * connects while mocking is already enabled or a component is already
+   * active would keep the stale defaults until the next broadcast. Runs on
+   * every (re)connect; event handlers fire only for values that actually
+   * changed. Never rejects — a failed request leaves that field untouched.
+   */
+  async seedPostGameState() {
+    const [mockingResult, activeComponentResult] = await Promise.allSettled([
+      this.api.postGame.getMocking(),
+      this.api.postGame.getActivePostGameAnalysis()
+    ]);
+    const nextData = { ...this.postGameData };
+    if (mockingResult.status === "fulfilled") {
+      nextData.isMocking = Boolean(mockingResult.value);
+    }
+    if (activeComponentResult.status === "fulfilled") {
+      const active = activeComponentResult.value ?? null;
+      if (active !== null || this.postGameData.activeComponent != null) {
+        nextData.activeComponent = active;
+      }
+    }
+    const prevData = this.postGameData;
+    this.postGameData = structuralShare(prevData, nextData);
+    if (this.postGameData === prevData) return;
+    this.postGameStore._setPostGameData(this.postGameData);
+    this.postGameUpdateHandlers.forEach(
+      (handler) => handler(this.postGameData)
+    );
+    if (this.postGameData.isMocking !== prevData.isMocking) {
+      this.postGameEventHandlers.onMockingUpdate.forEach(
+        (h) => h(this.postGameData.isMocking)
+      );
+    }
+    const activeComponent = this.postGameData.activeComponent;
+    if (activeComponent != null && activeComponent !== prevData.activeComponent) {
+      this.postGameEventHandlers.onActiveComponentChanged.forEach(
+        (h) => h(activeComponent)
+      );
+    }
+  }
   handlePostGameRouteUpdate(uri) {
     if (typeof uri !== "string" || uri.length === 0) return;
     this.postGameEventHandlers.onRouteUpdate.forEach((h) => h(uri));