@bluebottle_gg/league-broadcast-client 0.1.0

package/dist/index.js

@@ -0,0 +1,670 @@
+// src/WebSocketManager.ts
+var WebSocketManager = class {
+  constructor() {
+    this.socket = null;
+    this.url = "";
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 10;
+    this.reconnectDelay = 5e3;
+    this.reconnectTimeout = null;
+    this.messageHandlers = /* @__PURE__ */ new Set();
+    this.connectionHandlers = /* @__PURE__ */ new Set();
+    this.disconnectionHandlers = /* @__PURE__ */ new Set();
+    this.errorHandlers = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Connect to the WebSocket server
+   */
+  connect(url) {
+    this.url = url;
+    this.cleanup();
+    return new Promise((resolve, reject) => {
+      try {
+        this.socket = new WebSocket(url);
+        this.socket.onopen = () => {
+          console.log("[WebSocketManager] Connected to", url);
+          this.reconnectAttempts = 0;
+          this.connectionHandlers.forEach((handler) => handler());
+          resolve();
+        };
+        this.socket.onmessage = (event) => {
+          if (event.data === "KeepAlive") {
+            return;
+          }
+          try {
+            const data = JSON.parse(event.data);
+            this.messageHandlers.forEach((handler) => handler(data));
+          } catch (error) {
+            console.error(
+              "[WebSocketManager] Failed to parse message:",
+              event.data
+            );
+          }
+        };
+        this.socket.onclose = () => {
+          console.log("[WebSocketManager] Disconnected");
+          this.disconnectionHandlers.forEach((handler) => handler());
+          this.attemptReconnect();
+        };
+        this.socket.onerror = (error) => {
+          console.error("[WebSocketManager] Error:", error);
+          this.errorHandlers.forEach((handler) => handler(error));
+          reject(error);
+        };
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Disconnect from the WebSocket server
+   */
+  disconnect() {
+    if (this.reconnectTimeout !== null) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    if (this.socket) {
+      this.socket.close();
+      this.socket = null;
+    }
+  }
+  /**
+   * Check if connected to the WebSocket server
+   */
+  isConnected() {
+    return this.socket !== null && this.socket.readyState === WebSocket.OPEN;
+  }
+  /**
+   * Send a message to the server
+   */
+  send(message) {
+    if (!this.isConnected()) {
+      console.warn("[WebSocketManager] Cannot send message: not connected");
+      return;
+    }
+    const data = typeof message === "string" ? message : JSON.stringify(message);
+    this.socket.send(data);
+  }
+  /**
+   * Register a message handler
+   */
+  onMessage(handler) {
+    this.messageHandlers.add(handler);
+    return () => this.messageHandlers.delete(handler);
+  }
+  /**
+   * Register a connection handler
+   */
+  onConnect(handler) {
+    this.connectionHandlers.add(handler);
+    return () => this.connectionHandlers.delete(handler);
+  }
+  /**
+   * Register a disconnection handler
+   */
+  onDisconnect(handler) {
+    this.disconnectionHandlers.add(handler);
+    return () => this.disconnectionHandlers.delete(handler);
+  }
+  /**
+   * Register an error handler
+   */
+  onError(handler) {
+    this.errorHandlers.add(handler);
+    return () => this.errorHandlers.delete(handler);
+  }
+  /**
+   * Attempt to reconnect to the server
+   */
+  attemptReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error("[WebSocketManager] Max reconnect attempts reached");
+      return;
+    }
+    this.reconnectAttempts++;
+    console.log(
+      `[WebSocketManager] Reconnecting in ${this.reconnectDelay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`
+    );
+    this.reconnectTimeout = window.setTimeout(() => {
+      this.connect(this.url).catch((error) => {
+        console.error("[WebSocketManager] Reconnect failed:", error);
+      });
+    }, this.reconnectDelay);
+  }
+  /**
+   * Clean up resources
+   */
+  cleanup() {
+    if (this.reconnectTimeout !== null) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    if (this.socket) {
+      this.socket.onopen = null;
+      this.socket.onmessage = null;
+      this.socket.onclose = null;
+      this.socket.onerror = null;
+      if (this.socket.readyState === WebSocket.OPEN) {
+        this.socket.close();
+      }
+      this.socket = null;
+    }
+  }
+};
+
+// src/reactivity/GameStateStore.ts
+var GameStateStore = class {
+  constructor(initialState, initialGameState) {
+    /** Global listeners — called on every state change regardless of selector. */
+    this.listeners = /* @__PURE__ */ new Set();
+    /** Monotonically increasing version — used for cheap stale checks. */
+    this.version = 0;
+    this.snapshot = Object.freeze({
+      gameData: initialState,
+      gameState: initialGameState,
+      version: this.version
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Core API
+  // ---------------------------------------------------------------------------
+  /** Return the current full snapshot. */
+  getSnapshot() {
+    return this.snapshot;
+  }
+  /** Return the current version number. */
+  getVersion() {
+    return this.version;
+  }
+  /**
+   * Subscribe to **all** state changes (unfiltered).
+   * Returns an unsubscribe function.
+   *
+   * This satisfies the `subscribe` half of `useSyncExternalStore` when
+   * combined with `getSnapshot`.
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Selectors — the main reactivity primitive
+  // ---------------------------------------------------------------------------
+  /**
+   * Create a **subscribable slice** that only triggers when the selected
+   * value changes according to `equalityFn` (defaults to `===`).
+   *
+   * The returned object satisfies the `useSyncExternalStore` contract and
+   * can also be used with `watch()` for callback-style subscriptions.
+   *
+   * Selector instances are lightweight — create them freely (e.g. inside
+   * render functions). Referential identity of the *selector function* is
+   * **not** required to be stable.
+   */
+  select(selector, equalityFn = Object.is) {
+    let currentValue = selector(this.snapshot);
+    let lastVersion = this.version;
+    const sliceListeners = /* @__PURE__ */ new Set();
+    const getSnapshot = () => {
+      if (lastVersion !== this.version) {
+        const next = selector(this.snapshot);
+        if (!equalityFn(currentValue, next)) {
+          currentValue = next;
+        }
+        lastVersion = this.version;
+      }
+      return currentValue;
+    };
+    const subscribe = (listener) => {
+      sliceListeners.add(listener);
+      const unsub = this.subscribe(() => {
+        const prev = currentValue;
+        const next = selector(this.snapshot);
+        lastVersion = this.version;
+        if (!equalityFn(prev, next)) {
+          currentValue = next;
+          listener();
+        }
+      });
+      return () => {
+        sliceListeners.delete(listener);
+        unsub();
+      };
+    };
+    return { subscribe, getSnapshot };
+  }
+  // ---------------------------------------------------------------------------
+  // Convenience helpers
+  // ---------------------------------------------------------------------------
+  /**
+   * Watch a derived value and invoke `callback` whenever it changes.
+   * Returns an unsubscribe function.
+   *
+   * This is the simplest API for imperative / vanilla-JS usage:
+   *
+   * ```ts
+   * store.watch(
+   *   s => s.gameData.scoreboard?.teams[0]?.kills,
+   *   kills => console.log('Blue kills:', kills),
+   * );
+   * ```
+   */
+  watch(selector, callback, equalityFn = Object.is) {
+    let prev = selector(this.snapshot);
+    return this.subscribe(() => {
+      const next = selector(this.snapshot);
+      if (!equalityFn(prev, next)) {
+        const old = prev;
+        prev = next;
+        callback(next, old);
+      }
+    });
+  }
+  /**
+   * Watch a derived value and invoke `callback` whenever it changes,
+   * **and** invoke it immediately with the current value.
+   */
+  watchImmediate(selector, callback, equalityFn = Object.is) {
+    const current = selector(this.snapshot);
+    callback(current, void 0);
+    return this.watch(selector, callback, equalityFn);
+  }
+  // ---------------------------------------------------------------------------
+  // Internal — called by LeagueBroadcastClient
+  // ---------------------------------------------------------------------------
+  /** @internal Replace game data snapshot and notify listeners. */
+  _setGameData(data) {
+    this.version++;
+    this.snapshot = Object.freeze({
+      ...this.snapshot,
+      gameData: data,
+      version: this.version
+    });
+    this.emit();
+  }
+  /** @internal Replace game state and notify listeners. */
+  _setGameState(state) {
+    if (this.snapshot.gameState === state) return;
+    this.version++;
+    this.snapshot = Object.freeze({
+      ...this.snapshot,
+      gameState: state,
+      version: this.version
+    });
+    this.emit();
+  }
+  /** @internal Replace entire snapshot (used on game end / reset). */
+  _reset(data, state) {
+    this.version++;
+    this.snapshot = Object.freeze({
+      gameData: data,
+      gameState: state,
+      version: this.version
+    });
+    this.emit();
+  }
+  emit() {
+    this.listeners.forEach((l) => l());
+  }
+};
+function shallowEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+    return false;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!Object.prototype.hasOwnProperty.call(b, key) || !Object.is(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/reactivity/structuralShare.ts
+function structuralShare(prev, next) {
+  if (Object.is(prev, next)) {
+    return prev;
+  }
+  if (!isObject(prev) || !isObject(next)) {
+    return next;
+  }
+  if (Array.isArray(prev) || Array.isArray(next)) {
+    if (!Array.isArray(prev) || !Array.isArray(next)) {
+      return next;
+    }
+    if (prev.length !== next.length) {
+      return next.map(
+        (value, index) => structuralShare(prev[index], value)
+      );
+    }
+    let changed2 = false;
+    const shared = next.map((value, index) => {
+      const nextValue = structuralShare(prev[index], value);
+      if (!Object.is(nextValue, prev[index])) {
+        changed2 = true;
+      }
+      return nextValue;
+    });
+    return changed2 ? shared : prev;
+  }
+  const prevObj = prev;
+  const nextObj = next;
+  const nextKeys = Object.keys(nextObj);
+  const prevKeys = Object.keys(prevObj);
+  let changed = nextKeys.length !== prevKeys.length;
+  const result = Object.create(
+    Object.getPrototypeOf(next)
+  );
+  for (const key of nextKeys) {
+    const prevValue = prevObj[key];
+    const nextValue = nextObj[key];
+    const sharedValue = structuralShare(prevValue, nextValue);
+    result[key] = sharedValue;
+    if (!Object.is(sharedValue, prevValue)) {
+      changed = true;
+    }
+  }
+  return changed ? result : prev;
+}
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+
+// types/shared/gamestate.ts
+var GameState = /* @__PURE__ */ ((GameState2) => {
+  GameState2[GameState2["OutOfGame"] = 0] = "OutOfGame";
+  GameState2[GameState2["Loading"] = 1] = "Loading";
+  GameState2[GameState2["Running"] = 2] = "Running";
+  GameState2[GameState2["Paused"] = 3] = "Paused";
+  GameState2[GameState2["Mocking"] = 4] = "Mocking";
+  GameState2[GameState2["GameOver"] = 5] = "GameOver";
+  GameState2[GameState2["ChampionSelect"] = 6] = "ChampionSelect";
+  return GameState2;
+})(GameState || {});
+
+// types/ingame/ingamefrontenddata.ts
+var ingameFrontendData = class {
+  constructor() {
+    this.gameTime = 0;
+    this.playbackSpeed = 0;
+    this.gameVersion = "";
+    this.gameStatus = 0 /* OutOfGame */;
+  }
+};
+
+// src/LeagueBroadcastClient.ts
+var LeagueBroadcastClient = class {
+  constructor(config) {
+    this.gameState = 0 /* OutOfGame */;
+    this.isTestingEnvironment = false;
+    // Event handlers
+    this.stateUpdateHandlers = /* @__PURE__ */ new Set();
+    this.gameStatusHandlers = /* @__PURE__ */ new Set();
+    this.eventHandlers = {};
+    this.config = {
+      host: config.host,
+      port: config.port ?? 58869,
+      wsRoute: config.wsRoute ?? "/ws/in",
+      apiRoute: config.apiRoute ?? "/api",
+      cacheRoute: config.cacheRoute ?? "/cache",
+      useHttps: config.useHttps ?? false,
+      autoConnect: config.autoConnect ?? true
+    };
+    this.ws = new WebSocketManager();
+    this.gameData = new ingameFrontendData();
+    this.store = new GameStateStore(this.gameData, this.gameState);
+    this.setupMessageHandler();
+    if (this.config.autoConnect) {
+      this.connect();
+    }
+  }
+  /**
+   * Connect to the League Broadcast backend
+   */
+  async connect() {
+    const protocol = this.config.useHttps ? "wss" : "ws";
+    const url = `${protocol}://${this.config.host}:${this.config.port}${this.config.wsRoute}`;
+    try {
+      await this.ws.connect(url);
+    } catch (error) {
+      console.error("[LeagueBroadcastClient] Connection failed:", error);
+      throw error;
+    }
+  }
+  /**
+   * Disconnect from the League Broadcast backend
+   */
+  disconnect() {
+    this.ws.disconnect();
+  }
+  /**
+   * Check if connected to the backend
+   */
+  isConnected() {
+    return this.ws.isConnected();
+  }
+  /**
+   * Get the current game data
+   */
+  getGameData() {
+    return this.gameData;
+  }
+  /**
+   * Get the current game state
+   */
+  getGameState() {
+    return this.gameState;
+  }
+  /**
+   * Check if in testing environment
+   */
+  isInTestingEnvironment() {
+    return this.isTestingEnvironment;
+  }
+  /**
+   * Register a handler for state updates
+   */
+  onStateUpdate(handler) {
+    this.stateUpdateHandlers.add(handler);
+    return () => this.stateUpdateHandlers.delete(handler);
+  }
+  /**
+   * Register a handler for game status changes
+   */
+  onGameStatusChange(handler) {
+    this.gameStatusHandlers.add(handler);
+    return () => this.gameStatusHandlers.delete(handler);
+  }
+  /**
+   * Register handlers for game events
+   */
+  onGameEvents(handlers) {
+    this.eventHandlers = { ...this.eventHandlers, ...handlers };
+  }
+  /**
+   * Register a handler for connection events
+   */
+  onConnect(handler) {
+    return this.ws.onConnect(handler);
+  }
+  /**
+   * Register a handler for disconnection events
+   */
+  onDisconnect(handler) {
+    return this.ws.onDisconnect(handler);
+  }
+  /**
+   * Register a handler for error events
+   */
+  onError(handler) {
+    return this.ws.onError(handler);
+  }
+  // ---------------------------------------------------------------------------
+  // Reactive API — convenience wrappers around this.store
+  // ---------------------------------------------------------------------------
+  /**
+   * Create a subscribable slice of game state.
+   * The slice only notifies listeners when the selected value actually changes.
+   *
+   * Works directly with React 18+ `useSyncExternalStore`:
+   * ```tsx
+   * const kills = client.select(s => s.gameData.scoreboard?.teams[0]?.kills);
+   * function Kills() {
+   *   const value = useSyncExternalStore(kills.subscribe, kills.getSnapshot);
+   *   return <span>{value}</span>;
+   * }
+   * ```
+   */
+  select(selector, equalityFn) {
+    return this.store.select(selector, equalityFn);
+  }
+  /**
+   * Watch a derived value and invoke `callback` whenever it changes.
+   * Returns an unsubscribe function.
+   *
+   * ```ts
+   * client.watch(
+   *   s => s.gameData.scoreboard?.teams[0]?.kills,
+   *   (kills, prev) => console.log(`Kills: ${prev} → ${kills}`),
+   * );
+   * ```
+   */
+  watch(selector, callback, equalityFn) {
+    return this.store.watch(selector, callback, equalityFn);
+  }
+  /**
+   * Get the base HTTP URL for API requests
+   */
+  getApiUrl() {
+    const protocol = this.config.useHttps ? "https" : "http";
+    return `${protocol}://${this.config.host}:${this.config.port}${this.config.apiRoute}`;
+  }
+  /**
+   * Get the base URL for cache requests
+   */
+  getCacheUrl(path) {
+    const protocol = this.config.useHttps ? "https" : "http";
+    const baseUrl = `${protocol}://${this.config.host}:${this.config.port}${this.config.cacheRoute}`;
+    if (!path) {
+      return baseUrl;
+    }
+    let cleanPath = path;
+    if (cleanPath.startsWith("http")) {
+      return cleanPath;
+    }
+    if (cleanPath.startsWith("/")) {
+      cleanPath = cleanPath.slice(1);
+    }
+    if (cleanPath.startsWith("cache")) {
+      cleanPath = cleanPath.slice(5);
+    }
+    if (cleanPath.startsWith("/")) {
+      cleanPath = cleanPath.slice(1);
+    }
+    return `${baseUrl}/${cleanPath}`;
+  }
+  /**
+   * Setup message handler for WebSocket messages
+   */
+  setupMessageHandler() {
+    this.ws.onMessage((messageData) => {
+      switch (messageData.type) {
+        case "ingame-state-update":
+          this.handleStateUpdate(messageData.state, messageData.events);
+          break;
+        case "gameStatus":
+          this.handleGameStatusUpdate(
+            messageData.gameState,
+            messageData.isTestingEnvironment
+          );
+          break;
+      }
+    });
+  }
+  /**
+   * Handle state update from backend
+   */
+  handleStateUpdate(state, events) {
+    const nextData = Object.assign(new ingameFrontendData(), state);
+    this.gameData = structuralShare(this.gameData, nextData);
+    if (!state.gameTime || state.gameTime === 0) {
+      this.handleGameStatusUpdate(0 /* OutOfGame */, false);
+    }
+    this.store._setGameData(this.gameData);
+    this.stateUpdateHandlers.forEach((handler) => handler(this.gameData));
+    this.handleGameEvents(events);
+  }
+  /**
+   * Handle game status update
+   */
+  handleGameStatusUpdate(gameStatus, isTestingEnvironment = false) {
+    this.isTestingEnvironment = isTestingEnvironment;
+    if (gameStatus === 0 /* OutOfGame */ && this.gameState !== 0 /* OutOfGame */) {
+      this.endGame();
+      return;
+    }
+    this.gameState = gameStatus;
+    this.store._setGameState(gameStatus);
+    this.gameStatusHandlers.forEach(
+      (handler) => handler(gameStatus, isTestingEnvironment)
+    );
+  }
+  /**
+   * Handle game events
+   */
+  handleGameEvents(events) {
+    if (!events) {
+      return;
+    }
+    if (events.player && this.eventHandlers.onPlayerEvent) {
+      events.player.forEach(
+        (event) => this.eventHandlers.onPlayerEvent(event)
+      );
+    }
+    if (events.team && this.eventHandlers.onTeamEvent) {
+      events.team.forEach((event) => this.eventHandlers.onTeamEvent(event));
+    }
+    if (events.objective && this.eventHandlers.onObjectiveEvent) {
+      events.objective.forEach(
+        (event) => this.eventHandlers.onObjectiveEvent(event)
+      );
+    }
+    if (events.firstTower !== void 0 && this.eventHandlers.onFirstTowerEvent) {
+      this.eventHandlers.onFirstTowerEvent(events.firstTower);
+    }
+    if (events.announcements && this.eventHandlers.onAnnouncementEvent) {
+      events.announcements.forEach(
+        (event) => this.eventHandlers.onAnnouncementEvent(event)
+      );
+    }
+    if (events.killFeed && this.eventHandlers.onKillFeedEvent) {
+      events.killFeed.forEach(
+        (event) => this.eventHandlers.onKillFeedEvent(event)
+      );
+    }
+  }
+  /**
+   * End the game and reset state
+   */
+  endGame() {
+    console.log("[LeagueBroadcastClient] Game ended, resetting data");
+    this.gameData = new ingameFrontendData();
+    this.gameState = 0 /* OutOfGame */;
+    this.isTestingEnvironment = false;
+    this.store._reset(this.gameData, 0 /* OutOfGame */);
+    this.gameStatusHandlers.forEach(
+      (handler) => handler(0 /* OutOfGame */, false)
+    );
+    this.stateUpdateHandlers.forEach((handler) => handler(this.gameData));
+  }
+};
+
+export { GameState, GameStateStore, LeagueBroadcastClient, WebSocketManager, shallowEqual };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map