@bluebottle_gg/league-broadcast-client 0.1.0 → 0.2.0

package/dist/index.js

@@ -326,6 +326,134 @@ function shallowEqual(a, b) {
   return true;
 }
 
+// src/reactivity/ChampSelectStateStore.ts
+var ChampSelectStateStore = class {
+  constructor(initialState) {
+    /** 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({
+      champSelectData: initialState,
+      isActive: initialState.isActive,
+      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.
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Selectors
+  // ---------------------------------------------------------------------------
+  /**
+   * Create a **subscribable slice** that only triggers when the selected
+   * value changes according to `equalityFn` (defaults to `===`).
+   */
+  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.
+   */
+  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 champ-select data snapshot and notify listeners. */
+  _setChampSelectData(data) {
+    this.version++;
+    this.snapshot = Object.freeze({
+      champSelectData: data,
+      isActive: data.isActive,
+      version: this.version
+    });
+    this.emit();
+  }
+  /** @internal Replace entire snapshot (used on champ select end / reset). */
+  _reset(data) {
+    this.version++;
+    this.snapshot = Object.freeze({
+      champSelectData: data,
+      isActive: data.isActive,
+      version: this.version
+    });
+    this.emit();
+  }
+  emit() {
+    this.listeners.forEach((l) => l());
+  }
+};
+
 // src/reactivity/structuralShare.ts
 function structuralShare(prev, next) {
   if (Object.is(prev, next)) {
@@ -358,6 +486,14 @@ function structuralShare(prev, next) {
   const nextKeys = Object.keys(nextObj);
   const prevKeys = Object.keys(prevObj);
   let changed = nextKeys.length !== prevKeys.length;
+  if (!changed) {
+    for (const key of prevKeys) {
+      if (!Object.prototype.hasOwnProperty.call(nextObj, key)) {
+        changed = true;
+        break;
+      }
+    }
+  }
   const result = Object.create(
     Object.getPrototypeOf(next)
   );
@@ -398,156 +534,829 @@ var ingameFrontendData = class {
   }
 };
 
+// types/pregame/champselectstatedata.ts
+var champSelectStateData = class {
+  constructor() {
+    this.isActive = false;
+    this.isConnected = false;
+    this.isTestingEnvironment = false;
+    this.blueTeam = {};
+    this.redTeam = {};
+    this.metaData = {};
+    this.timer = {};
+  }
+};
+
+// src/api/ApiClient.ts
+var ApiClient = class {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+  /** Update the base URL (e.g. after reconnecting to a different host/port). */
+  updateBaseUrl(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+  /** Current base URL. */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  // ── HTTP verbs ──────────────────────────────────────────────────────────
+  async get(path) {
+    return this.request("GET", path);
+  }
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  async put(path, body) {
+    return this.request("PUT", path, body);
+  }
+  async patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+  async delete(path) {
+    return this.request("DELETE", path);
+  }
+  /**
+   * POST with a raw string body (e.g. base64 image data).
+   * Sets Content-Type to text/plain instead of application/json.
+   */
+  async postRaw(path, rawBody) {
+    return this.request("POST", path, rawBody, "text/plain");
+  }
+  /**
+   * PUT with a raw string body (e.g. base64 image data).
+   * Sets Content-Type to text/plain instead of application/json.
+   */
+  async putRaw(path, rawBody) {
+    return this.request("PUT", path, rawBody, "text/plain");
+  }
+  // ── Internal ────────────────────────────────────────────────────────────
+  buildUrl(path) {
+    const base = this.baseUrl.endsWith("/") ? this.baseUrl.slice(0, -1) : this.baseUrl;
+    const cleanPath = path.startsWith("/") ? path.slice(1) : path;
+    return `${base}/${cleanPath}`;
+  }
+  async request(method, path, body, contentType) {
+    const url = this.buildUrl(path);
+    const headers = {};
+    let bodyStr;
+    if (body !== void 0) {
+      if (contentType === "text/plain") {
+        headers["Content-Type"] = "text/plain";
+        bodyStr = String(body);
+      } else {
+        headers["Content-Type"] = "application/json";
+        bodyStr = JSON.stringify(body);
+      }
+    }
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: bodyStr
+    });
+    if (!res.ok) {
+      const errorBody = await res.text().catch(() => "");
+      throw new ApiError(res.status, res.statusText, errorBody, url);
+    }
+    return this.parseResponse(res);
+  }
+  async parseResponse(res) {
+    const text = await res.text();
+    if (!text || text.length === 0) return void 0;
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+};
+var ApiError = class extends Error {
+  constructor(status, statusText, body, url) {
+    super(`API Error ${status} (${statusText}) at ${url}`);
+    this.status = status;
+    this.statusText = statusText;
+    this.body = body;
+    this.url = url;
+    this.name = "ApiError";
+  }
+};
+
+// src/api/generated/PreGameApi.ts
+var PreGameApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** `POST championselect/mock/{doMocking}` */
+  async mockChampionSelect(doMocking, randomizationinterval) {
+    return this.client.post(`championselect/mock/${doMocking}${randomizationinterval !== void 0 ? `?randomizationinterval=${encodeURIComponent(String(randomizationinterval))}` : ""}`);
+  }
+  /** `GET championselect/mock` */
+  async getMockingStatus() {
+    return this.client.get("championselect/mock");
+  }
+  /** `GET championselect/bans` */
+  async getBans() {
+    return this.client.get("championselect/bans");
+  }
+  /** `GET championselect/frontend` */
+  async getFrontendUrl() {
+    return this.client.get("championselect/frontend");
+  }
+  /** `GET championselect/stage/{stageSide}/teamid` */
+  async getTeamIdOnSide(stageSide) {
+    return this.client.get(`championselect/stage/${stageSide}/teamid`);
+  }
+  /** `POST championselect/frontend` */
+  async changeRouting(uri) {
+    return this.client.post(`championselect/frontend?uri=${encodeURIComponent(String(uri))}`);
+  }
+  /** `GET championselect/stage/{stageside}/{slotid}` */
+  async getPlayerPUUIDInSlot(stageside, slotid) {
+    return this.client.get(`championselect/stage/${stageside}/${slotid}`);
+  }
+};
+
+// src/api/generated/GameApi.ts
+var GameApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** `GET game/current` */
+  async getCurrentGame() {
+    return this.client.get("game/current");
+  }
+  /** `GET game/previous` */
+  async getPreviousGame() {
+    return this.client.get("game/previous");
+  }
+  /** `GET game/{gameid}` */
+  async getGame(gameid) {
+    return this.client.get(`game/${gameid}`);
+  }
+  /** `PATCH game/{gameid}` */
+  async updateGame(gameid, game) {
+    return this.client.patch(`game/${gameid}`, game);
+  }
+  /** `PUT game/{gameid}/teams` */
+  async setSideSelection(gameid, teams) {
+    return this.client.put(`game/${gameid}/teams`, teams);
+  }
+  /** `GET game/{gameid}/teams` */
+  async getTeamsInGame(gameid) {
+    return this.client.get(`game/${gameid}/teams`);
+  }
+  /** `DELETE game/{gameid}/winner` */
+  async removeGameWinner(gameid) {
+    return this.client.delete(`game/${gameid}/winner`);
+  }
+  /** `PUT game/{gameid}/winner/{teamid}` */
+  async setGameWinner(gameid, teamid) {
+    return this.client.put(`game/${gameid}/winner/${teamid}`);
+  }
+  /** `GET game/{gameid}/bans` */
+  async getBans(gameid) {
+    return this.client.get(`game/${gameid}/bans`);
+  }
+  /** `GET game/{gameid}/bans/{teamid}` */
+  async getBansForTeam(gameid, teamid) {
+    return this.client.get(`game/${gameid}/bans/${teamid}`);
+  }
+  /** `PUT game/{gameid}/bans` */
+  async setBans(gameid, bans) {
+    return this.client.put(`game/${gameid}/bans`, bans);
+  }
+  /** `PUT game/{gameid}/bans/{teamid}` */
+  async setBansForTeam(gameid, teamid, bans) {
+    return this.client.put(`game/${gameid}/bans/${teamid}`, bans);
+  }
+  /** `GET game/{gameid}/picks` */
+  async getPicks(gameid) {
+    return this.client.get(`game/${gameid}/picks`);
+  }
+  /** `GET game/{gameid}/picks/{teamid}` */
+  async getPicksForTeam(gameid, teamid) {
+    return this.client.get(`game/${gameid}/picks/${teamid}`);
+  }
+  /** `PUT game/{gameid}/picks` */
+  async setPicks(gameid, picks) {
+    return this.client.put(`game/${gameid}/picks`, picks);
+  }
+  /** `PUT game/{gameid}/picks/{teamid}` */
+  async setPicksForTeam(gameid, teamid, picks) {
+    return this.client.put(`game/${gameid}/picks/${teamid}`, picks);
+  }
+};
+
+// src/api/generated/GameStateApi.ts
+var GameStateApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** `GET game/state/time` */
+  async getGameTime() {
+    return this.client.get("game/state/time");
+  }
+  /** `GET game/state/team/{teamId}/dragons` */
+  async getTeamDragons(teamId) {
+    return this.client.get(`game/state/team/${teamId}/dragons`);
+  }
+  /** `PATCH game/state/team/{teamId}/dragons` */
+  async updateTeamDragons(teamId, dragons) {
+    return this.client.patch(`game/state/team/${teamId}/dragons`, dragons);
+  }
+  /** `GET game/state/team/all/index` */
+  async getActiveTeams() {
+    return this.client.get("game/state/team/all/index");
+  }
+  /** `GET game/state/team/all/participant` */
+  async getAllTeamParticipants() {
+    return this.client.get("game/state/team/all/participant");
+  }
+  /** `GET game/state/team/{teamId}/participant` */
+  async getTeamParticipants(teamId) {
+    return this.client.get(`game/state/team/${teamId}/participant`);
+  }
+  /** `GET game/state/team/all/participant/order` */
+  async getTeamParticipantOrder() {
+    return this.client.get("game/state/team/all/participant/order");
+  }
+  /** `PUT game/state/team/all/participant/order` */
+  async updateTeamParticipantOrder(orderedNames) {
+    return this.client.put("game/state/team/all/participant/order", orderedNames);
+  }
+};
+
+// src/api/generated/MatchApi.ts
+var MatchApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** `GET match/season/{seasonId}/simple` */
+  async getSimpleMatches(seasonId) {
+    return this.client.get(`match/season/${seasonId}/simple`);
+  }
+  /** `GET match/season/{seasonId}` */
+  async getMatches(seasonId) {
+    return this.client.get(`match/season/${seasonId}`);
+  }
+  /** `GET match/simple` */
+  async getAllSimpleMatches() {
+    return this.client.get("match/simple");
+  }
+  /** `GET match` */
+  async getAllMatches() {
+    return this.client.get("match");
+  }
+  /** `GET match/current` */
+  async getCurrentMatch() {
+    return this.client.get("match/current");
+  }
+  /** `POST match/current` */
+  async completeCurrentMatch() {
+    return this.client.post("match/current");
+  }
+  /** `GET match/current/id` */
+  async getCurrentMatchId() {
+    return this.client.get("match/current/id");
+  }
+  /** `GET match/previous/id` */
+  async getPreviousMatchId() {
+    return this.client.get("match/previous/id");
+  }
+  /** `POST match/current/{seriesid}` */
+  async setCurrentMatch(seriesid) {
+    return this.client.post(`match/current/${seriesid}`);
+  }
+  /** `GET match/current/bestof` */
+  async getCurrentMatchBestOf() {
+    return this.client.get("match/current/bestof");
+  }
+  /** `PUT match/current/bestof` */
+  async setCurrentMatchBestOf(type) {
+    return this.client.put("match/current/bestof", type);
+  }
+  /** `GET match/current/teams` */
+  async getCurrentMatchTeams() {
+    return this.client.get("match/current/teams");
+  }
+  /** `PUT match/current/teams` */
+  async setCurrentMatchTeams(teamIds) {
+    return this.client.put("match/current/teams", teamIds);
+  }
+  /** `GET match/current/game` */
+  async getCurrentGame() {
+    return this.client.get("match/current/game");
+  }
+  /** `GET match/current/ruleset` */
+  async getCurrentMatchRuleset() {
+    return this.client.get("match/current/ruleset");
+  }
+  /** `PUT match/current/ruleset/{ruleset}` */
+  async setCurrentMatchRuleset(ruleset) {
+    return this.client.put(`match/current/ruleset/${ruleset}`);
+  }
+  /** `GET match/current/fearless/bans` */
+  async getBans() {
+    return this.client.get("match/current/fearless/bans");
+  }
+  /** `GET match/current/onstage` */
+  async getCurrentMatchOnStage() {
+    return this.client.get("match/current/onstage");
+  }
+  /** `GET match/{matchid}` */
+  async getMatch(matchid) {
+    return this.client.get(`match/${matchid}`);
+  }
+  /** `DELETE match/{matchid}` */
+  async deleteMatch(matchid) {
+    return this.client.delete(`match/${matchid}`);
+  }
+  /** `GET match/{matchid}/teams` */
+  async getMatchTeams(matchid) {
+    return this.client.get(`match/${matchid}/teams`);
+  }
+  /** `PUT match/{matchid}/teams` */
+  async setMatchTeams(matchid, teamIds) {
+    return this.client.put(`match/${matchid}/teams`, teamIds);
+  }
+  /** `GET match/{matchid}/games` */
+  async getMatchGames(matchid) {
+    return this.client.get(`match/${matchid}/games`);
+  }
+  /** `GET match/{matchid}/winner` */
+  async getMatchWinner(matchid) {
+    return this.client.get(`match/${matchid}/winner`);
+  }
+  /** `PUT match/{matchid}/winner/{teamid}` */
+  async setMatchWinner(matchid, teamid) {
+    return this.client.put(`match/${matchid}/winner/${teamid}`);
+  }
+  /** `DELETE match/{matchid}/winner` */
+  async removeMatchWinner(matchid) {
+    return this.client.delete(`match/${matchid}/winner`);
+  }
+  /** `GET match/{matchid}/bestof` */
+  async getMatchBestOf(matchid) {
+    return this.client.get(`match/${matchid}/bestof`);
+  }
+  /** `PUT match/{matchid}/bestof/{type}` */
+  async setMatchBestOf(matchid, type) {
+    return this.client.put(`match/${matchid}/bestof/${type}`);
+  }
+  /** `GET match/{matchid}/ruleset` */
+  async getMatchRuleset(matchid) {
+    return this.client.get(`match/${matchid}/ruleset`);
+  }
+  /** `PUT match/{matchid}/ruleset/{ruleset}` */
+  async setMatchRuleset(matchid, ruleset) {
+    return this.client.put(`match/${matchid}/ruleset/${ruleset}`);
+  }
+  /** `GET match/{matchid}/name` */
+  async getMatchName(matchid) {
+    return this.client.get(`match/${matchid}/name`);
+  }
+  /** `PATCH match/{matchid}/name/{matchName}` */
+  async setMatchName(matchid, matchName) {
+    return this.client.patch(`match/${matchid}/name/${matchName}`);
+  }
+  /** `PATCH match/{matchid}` */
+  async updateMatch(matchid, matchUpdate) {
+    return this.client.patch(`match/${matchid}`, matchUpdate);
+  }
+  /** `GET match/{matchid}/fearless/bans` */
+  async getMatchBans(matchid) {
+    return this.client.get(`match/${matchid}/fearless/bans`);
+  }
+  /** `GET match/{seriesid}/onstage` */
+  async getMatchOnStage(seriesid) {
+    return this.client.get(`match/${seriesid}/onstage`);
+  }
+  /** `PUT match` */
+  async addMatch(match) {
+    return this.client.put("match", match);
+  }
+  /** `GET match/{matchId}/stage/team/{stageSide}` */
+  async getTeamOnStageSide(matchId, stageSide) {
+    return this.client.get(`match/${matchId}/stage/team/${stageSide}`);
+  }
+  /** `GET match/current/stage/team/{stageSide}` */
+  async getTeamOnStageSideCurrent(stageSide) {
+    return this.client.get(`match/current/stage/team/${stageSide}`);
+  }
+};
+
+// src/api/generated/SeasonApi.ts
+var SeasonApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** `GET season/current` */
+  async getCurrentSeason() {
+    return this.client.get("season/current");
+  }
+  /** `GET season/current/match` */
+  async getCurrentSeasonScheduledMatch() {
+    return this.client.get("season/current/match");
+  }
+  /** `GET season/current/id` */
+  async getCurrentSeasonId() {
+    return this.client.get("season/current/id");
+  }
+  /** `POST season/current` */
+  async setCurrentSeason(newCurrentSeasonId) {
+    return this.client.post("season/current", newCurrentSeasonId);
+  }
+  /** `GET season/current/teams` */
+  async getCurrentSeasonTeams() {
+    return this.client.get("season/current/teams");
+  }
+  /** `GET season/current/teamswithmembers` */
+  async getCurrentSeasonTeamsWithMembers() {
+    return this.client.get("season/current/teamswithmembers");
+  }
+  /** `GET season/current/icon` */
+  async getCurrentSeasonIcon() {
+    return this.client.get("season/current/icon");
+  }
+  /** `PUT season/current/icon` */
+  async setCurrentSeasonIcon() {
+    return this.client.put("season/current/icon");
+  }
+  /** `GET season` */
+  async getAllSeasons() {
+    return this.client.get("season");
+  }
+  /** `GET season/{seasonId}` */
+  async getSeasonById(seasonId) {
+    return this.client.get(`season/${seasonId}`);
+  }
+  /** `GET season/{seasonId}/matches` */
+  async getMatchesInSeason(seasonId) {
+    return this.client.get(`season/${seasonId}/matches`);
+  }
+  /** `GET season/{seasonId}/matches/count` */
+  async getMatchesInSeasonCount(seasonId) {
+    return this.client.get(`season/${seasonId}/matches/count`);
+  }
+  /** `GET season/{seasonId}/matches/day/{day}` */
+  async getMatchesInSeasonOnDay(seasonId, day) {
+    return this.client.get(`season/${seasonId}/matches/day/${day}`);
+  }
+  /** `GET season/{seasonId}/teams` */
+  async getTeamsInSeason(seasonId) {
+    return this.client.get(`season/${seasonId}/teams`);
+  }
+  /** `GET season/{seasonId}/teamswithmembers` */
+  async getTeamsWithMembersInSeason(seasonId) {
+    return this.client.get(`season/${seasonId}/teamswithmembers`);
+  }
+  /** `POST season` */
+  async createOrUpdateSeason(seasonData) {
+    return this.client.post("season", seasonData);
+  }
+  /** `GET season/{seasonId}/icon` */
+  async getSeasonIcon(seasonId) {
+    return this.client.get(`season/${seasonId}/icon`);
+  }
+  /** `PUT season/{seasonId}/icon` */
+  async setSeasonIcon(seasonId) {
+    return this.client.put(`season/${seasonId}/icon`);
+  }
+  /** `DELETE season/{seasonId}` */
+  async deleteSeason(seasonId) {
+    return this.client.delete(`season/${seasonId}`);
+  }
+};
+
+// src/api/generated/IngameApi.ts
+var IngameApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** `GET ingame/status` */
+  async getGameState() {
+    return this.client.get("ingame/status");
+  }
+  /** `POST ingame/enable` */
+  async enableComponent() {
+    return this.client.post("ingame/enable");
+  }
+  /** `POST ingame/disable` */
+  async disableComponent() {
+    return this.client.post("ingame/disable");
+  }
+  /** `POST ingame/mock/{doMocking}` */
+  async mockIngame(doMocking) {
+    return this.client.post(`ingame/mock/${doMocking}`);
+  }
+  /** `GET ingame/mock` */
+  async getMockingStatus() {
+    return this.client.get("ingame/mock");
+  }
+  /** `GET ingame/frontend` */
+  async getFrontendUrl() {
+    return this.client.get("ingame/frontend");
+  }
+  /** `GET ingame/showing` */
+  async getCurrentCommonSerializationOptions() {
+    return this.client.get("ingame/showing");
+  }
+  /** `POST ingame/showing` */
+  async setCurrentCommonSerializationOptions(data) {
+    return this.client.post("ingame/showing", data);
+  }
+  /** `GET ingame/showing/{socketid}` */
+  async getCurrentFrontendSerializationOptions(socketid) {
+    return this.client.get(`ingame/showing/${socketid}`);
+  }
+  /** `POST ingame/showing/{socketid}` */
+  async setCurrentFrontendSerializationOptions(socketid, data) {
+    return this.client.post(`ingame/showing/${socketid}`, data);
+  }
+  /** `GET ingame/stage/{stageSide}/{playerSlot}/networkId` */
+  async getPlayerPUUIDInSlot(stageSide, playerSlot) {
+    return this.client.get(`ingame/stage/${stageSide}/${playerSlot}/networkId`);
+  }
+  /** `GET ingame/stage/{stageSide}/ingameteamid` */
+  async getIngameTeamOnStageSide(stageSide) {
+    return this.client.get(`ingame/stage/${stageSide}/ingameteamid`);
+  }
+  /** `GET ingame/state/activeOverlays` */
+  async getActiveOverlays() {
+    return this.client.get("ingame/state/activeOverlays");
+  }
+};
+
+// src/api/RestApi.ts
+var RestApi = class {
+  constructor(baseUrl) {
+    this.client = new ApiClient(baseUrl);
+    this.ingame = new IngameApi(this.client);
+    this.game = new GameApi(this.client);
+    this.match = new MatchApi(this.client);
+    this.season = new SeasonApi(this.client);
+    this.preGame = new PreGameApi(this.client);
+    this.gameState = new GameStateApi(this.client);
+  }
+  /**
+   * Update the base URL for all API modules (e.g. after changing host/port).
+   */
+  updateBaseUrl(baseUrl) {
+    this.client.updateBaseUrl(baseUrl);
+  }
+  /**
+   * Get direct access to the underlying HTTP client for custom requests.
+   */
+  getHttpClient() {
+    return this.client;
+  }
+};
+
 // src/LeagueBroadcastClient.ts
 var LeagueBroadcastClient = class {
   constructor(config) {
     this.gameState = 0 /* OutOfGame */;
-    this.isTestingEnvironment = false;
-    // Event handlers
+    this._isTestingEnvironment = false;
+    this.champSelectWasActive = false;
+    // -- In-game event handlers -------------------------------------------------
     this.stateUpdateHandlers = /* @__PURE__ */ new Set();
     this.gameStatusHandlers = /* @__PURE__ */ new Set();
-    this.eventHandlers = {};
+    this.ingameEventHandlers = {};
+    // -- Pre-game event handlers ------------------------------------------------
+    this.champSelectUpdateHandlers = /* @__PURE__ */ new Set();
+    this.champSelectEventHandlers = {};
     this.config = {
       host: config.host,
       port: config.port ?? 58869,
-      wsRoute: config.wsRoute ?? "/ws/in",
+      ingameWsRoute: config.ingameWsRoute ?? "/ws/in",
+      preGameWsRoute: config.preGameWsRoute ?? "/ws/pre",
       apiRoute: config.apiRoute ?? "/api",
       cacheRoute: config.cacheRoute ?? "/cache",
       useHttps: config.useHttps ?? false,
       autoConnect: config.autoConnect ?? true
     };
-    this.ws = new WebSocketManager();
+    const httpProtocol = this.config.useHttps ? "https" : "http";
+    const apiBaseUrl = `${httpProtocol}://${this.config.host}:${this.config.port}${this.config.apiRoute}`;
+    this.api = new RestApi(apiBaseUrl);
+    this.ingameWs = new WebSocketManager();
     this.gameData = new ingameFrontendData();
-    this.store = new GameStateStore(this.gameData, this.gameState);
-    this.setupMessageHandler();
+    this.ingameStore = new GameStateStore(this.gameData, this.gameState);
+    this.setupIngameMessageHandler();
+    this.preGameWs = new WebSocketManager();
+    this.champSelectData = new champSelectStateData();
+    this.preGameStore = new ChampSelectStateStore(this.champSelectData);
+    this.setupPreGameMessageHandler();
     if (this.config.autoConnect) {
       this.connect();
     }
   }
+  // ===========================================================================
+  // Connection management
+  // ===========================================================================
   /**
-   * Connect to the League Broadcast backend
+   * Connect to both in-game and pre-game WebSocket endpoints.
+   *
+   * Both connections are attempted in parallel. If either fails the returned
+   * promise rejects, but the other connection may still succeed.
    */
   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;
+    const base = `${protocol}://${this.config.host}:${this.config.port}`;
+    const ingameUrl = `${base}${this.config.ingameWsRoute}`;
+    const preGameUrl = `${base}${this.config.preGameWsRoute}`;
+    const results = await Promise.allSettled([
+      this.ingameWs.connect(ingameUrl),
+      this.preGameWs.connect(preGameUrl)
+    ]);
+    const failures = results.filter((r) => r.status === "rejected");
+    if (failures.length > 0) {
+      const reasons = failures.map(
+        (r) => r.reason
+      );
+      console.error(
+        "[LeagueBroadcastClient] One or more connections failed:",
+        reasons
+      );
+      throw reasons[0];
     }
   }
   /**
-   * Disconnect from the League Broadcast backend
+   * Disconnect from both WebSocket endpoints.
    */
   disconnect() {
-    this.ws.disconnect();
+    this.ingameWs.disconnect();
+    this.preGameWs.disconnect();
   }
   /**
-   * Check if connected to the backend
+   * Whether the in-game WebSocket is connected.
    */
-  isConnected() {
-    return this.ws.isConnected();
+  isIngameConnected() {
+    return this.ingameWs.isConnected();
   }
   /**
-   * Get the current game data
+   * Whether the pre-game WebSocket is connected.
    */
-  getGameData() {
+  isPreGameConnected() {
+    return this.preGameWs.isConnected();
+  }
+  // ===========================================================================
+  // In-game data access
+  // ===========================================================================
+  /** Get the current in-game data. */
+  getIngameData() {
     return this.gameData;
   }
-  /**
-   * Get the current game state
-   */
-  getGameState() {
+  /** Get the current game state. */
+  getIngameState() {
     return this.gameState;
   }
-  /**
-   * Check if in testing environment
-   */
+  /** Whether the backend is in a testing / replay environment. */
   isInTestingEnvironment() {
-    return this.isTestingEnvironment;
+    return this._isTestingEnvironment;
   }
-  /**
-   * Register a handler for state updates
-   */
-  onStateUpdate(handler) {
+  // ===========================================================================
+  // Pre-game data access
+  // ===========================================================================
+  /** Get the current champion-select state. */
+  getChampSelectData() {
+    return this.champSelectData;
+  }
+  /** Whether champion select is currently active. */
+  isChampSelectActive() {
+    return this.champSelectData.isActive;
+  }
+  // ===========================================================================
+  // In-game event handlers
+  // ===========================================================================
+  /** Register a handler for in-game state updates. */
+  onIngameStateUpdate(handler) {
     this.stateUpdateHandlers.add(handler);
     return () => this.stateUpdateHandlers.delete(handler);
   }
-  /**
-   * Register a handler for game status changes
-   */
-  onGameStatusChange(handler) {
+  /** Register a handler for in-game status changes (running, paused, out of game). */
+  onIngameStatusChange(handler) {
     this.gameStatusHandlers.add(handler);
     return () => this.gameStatusHandlers.delete(handler);
   }
-  /**
-   * Register handlers for game events
-   */
-  onGameEvents(handlers) {
-    this.eventHandlers = { ...this.eventHandlers, ...handlers };
+  /** Register handlers for in-game events (kills, objectives, etc.). */
+  onIngameEvents(handlers) {
+    this.ingameEventHandlers = { ...this.ingameEventHandlers, ...handlers };
   }
-  /**
-   * Register a handler for connection events
-   */
-  onConnect(handler) {
-    return this.ws.onConnect(handler);
+  // ===========================================================================
+  // Pre-game event handlers
+  // ===========================================================================
+  /** Register a handler for champ-select state updates. */
+  onChampSelectUpdate(handler) {
+    this.champSelectUpdateHandlers.add(handler);
+    return () => this.champSelectUpdateHandlers.delete(handler);
   }
-  /**
-   * Register a handler for disconnection events
-   */
-  onDisconnect(handler) {
-    return this.ws.onDisconnect(handler);
+  /** Register handlers for champ-select lifecycle and action events. */
+  onChampSelectEvents(handlers) {
+    this.champSelectEventHandlers = {
+      ...this.champSelectEventHandlers,
+      ...handlers
+    };
   }
-  /**
-   * Register a handler for error events
-   */
-  onError(handler) {
-    return this.ws.onError(handler);
+  // ===========================================================================
+  // Connection event handlers
+  // ===========================================================================
+  /** Register a handler for in-game connection. */
+  onIngameConnect(handler) {
+    return this.ingameWs.onConnect(handler);
   }
-  // ---------------------------------------------------------------------------
-  // Reactive API — convenience wrappers around this.store
-  // ---------------------------------------------------------------------------
+  /** Register a handler for in-game disconnection. */
+  onIngameDisconnect(handler) {
+    return this.ingameWs.onDisconnect(handler);
+  }
+  /** Register a handler for in-game connection errors. */
+  onIngameError(handler) {
+    return this.ingameWs.onError(handler);
+  }
+  /** Register a handler for pre-game connection. */
+  onPreGameConnect(handler) {
+    return this.preGameWs.onConnect(handler);
+  }
+  /** Register a handler for pre-game disconnection. */
+  onPreGameDisconnect(handler) {
+    return this.preGameWs.onDisconnect(handler);
+  }
+  /** Register a handler for pre-game connection errors. */
+  onPreGameError(handler) {
+    return this.preGameWs.onError(handler);
+  }
+  // ===========================================================================
+  // Reactive API — in-game (convenience wrappers around this.store)
+  // ===========================================================================
   /**
-   * Create a subscribable slice of game state.
+   * Create a subscribable slice of **in-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);
+   * const kills = client.selectIngame(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);
+  selectIngame(selector, equalityFn) {
+    return this.ingameStore.select(selector, equalityFn);
   }
   /**
-   * Watch a derived value and invoke `callback` whenever it changes.
+   * Watch a derived **in-game** value and invoke `callback` whenever it changes.
    * Returns an unsubscribe function.
    *
    * ```ts
-   * client.watch(
+   * client.watchIngame(
    *   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);
+  watchIngame(selector, callback, equalityFn) {
+    return this.ingameStore.watch(selector, callback, equalityFn);
   }
+  // ===========================================================================
+  // Reactive API — pre-game (convenience wrappers around this.preGameStore)
+  // ===========================================================================
   /**
-   * Get the base HTTP URL for API requests
+   * Create a subscribable slice of **pre-game** (champion select) state.
+   *
+   * ```tsx
+   * const timer = client.selectChampSelect(s => s.champSelectData.timer);
+   * function DraftTimer() {
+   *   const value = useSyncExternalStore(timer.subscribe, timer.getSnapshot);
+   *   return <span>{value?.timeRemaining}</span>;
+   * }
+   * ```
+   */
+  selectChampSelect(selector, equalityFn) {
+    return this.preGameStore.select(selector, equalityFn);
+  }
+  /**
+   * Watch a derived **pre-game** value and invoke `callback` whenever it
+   * changes. Returns an unsubscribe function.
+   *
+   * ```ts
+   * client.watchChampSelect(
+   *   s => s.champSelectData.timer.timeRemaining,
+   *   (remaining, prev) => console.log(`Time: ${prev} → ${remaining}`),
+   * );
+   * ```
    */
+  watchChampSelect(selector, callback, equalityFn) {
+    return this.preGameStore.watch(selector, callback, equalityFn);
+  }
+  // ===========================================================================
+  // URLs
+  // ===========================================================================
+  /** 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
-   */
+  /** Get the base URL for cache requests (optionally resolve a path). */
   getCacheUrl(path) {
     const protocol = this.config.useHttps ? "https" : "http";
     const baseUrl = `${protocol}://${this.config.host}:${this.config.port}${this.config.cacheRoute}`;
@@ -569,11 +1378,11 @@ var LeagueBroadcastClient = class {
     }
     return `${baseUrl}/${cleanPath}`;
   }
-  /**
-   * Setup message handler for WebSocket messages
-   */
-  setupMessageHandler() {
-    this.ws.onMessage((messageData) => {
+  // ===========================================================================
+  // Private — in-game message handling
+  // ===========================================================================
+  setupIngameMessageHandler() {
+    this.ingameWs.onMessage((messageData) => {
       switch (messageData.type) {
         case "ingame-state-update":
           this.handleStateUpdate(messageData.state, messageData.events);
@@ -587,84 +1396,210 @@ var LeagueBroadcastClient = class {
       }
     });
   }
-  /**
-   * Handle state update from backend
-   */
   handleStateUpdate(state, events) {
-    const nextData = Object.assign(new ingameFrontendData(), state);
+    const nextData = {
+      gameTime: 0,
+      playbackSpeed: 0,
+      gameVersion: "",
+      gameStatus: 0 /* OutOfGame */,
+      ...state
+    };
     this.gameData = structuralShare(this.gameData, nextData);
     if (!state.gameTime || state.gameTime === 0) {
       this.handleGameStatusUpdate(0 /* OutOfGame */, false);
     }
-    this.store._setGameData(this.gameData);
+    this.ingameStore._setGameData(this.gameData);
     this.stateUpdateHandlers.forEach((handler) => handler(this.gameData));
     this.handleGameEvents(events);
   }
-  /**
-   * Handle game status update
-   */
   handleGameStatusUpdate(gameStatus, isTestingEnvironment = false) {
-    this.isTestingEnvironment = isTestingEnvironment;
+    this._isTestingEnvironment = isTestingEnvironment;
     if (gameStatus === 0 /* OutOfGame */ && this.gameState !== 0 /* OutOfGame */) {
       this.endGame();
       return;
     }
     this.gameState = gameStatus;
-    this.store._setGameState(gameStatus);
+    this.ingameStore._setGameState(gameStatus);
     this.gameStatusHandlers.forEach(
       (handler) => handler(gameStatus, isTestingEnvironment)
     );
   }
-  /**
-   * Handle game events
-   */
   handleGameEvents(events) {
-    if (!events) {
-      return;
-    }
-    if (events.player && this.eventHandlers.onPlayerEvent) {
+    if (!events) return;
+    if (events.player && this.ingameEventHandlers.onPlayerEvent) {
       events.player.forEach(
-        (event) => this.eventHandlers.onPlayerEvent(event)
+        (event) => this.ingameEventHandlers.onPlayerEvent(event)
       );
     }
-    if (events.team && this.eventHandlers.onTeamEvent) {
-      events.team.forEach((event) => this.eventHandlers.onTeamEvent(event));
+    if (events.team && this.ingameEventHandlers.onTeamEvent) {
+      events.team.forEach(
+        (event) => this.ingameEventHandlers.onTeamEvent(event)
+      );
     }
-    if (events.objective && this.eventHandlers.onObjectiveEvent) {
+    if (events.objective && this.ingameEventHandlers.onObjectiveEvent) {
       events.objective.forEach(
-        (event) => this.eventHandlers.onObjectiveEvent(event)
+        (event) => this.ingameEventHandlers.onObjectiveEvent(event)
       );
     }
-    if (events.firstTower !== void 0 && this.eventHandlers.onFirstTowerEvent) {
-      this.eventHandlers.onFirstTowerEvent(events.firstTower);
+    if (events.firstTower !== void 0 && this.ingameEventHandlers.onFirstTowerEvent) {
+      this.ingameEventHandlers.onFirstTowerEvent(events.firstTower);
     }
-    if (events.announcements && this.eventHandlers.onAnnouncementEvent) {
+    if (events.announcements && this.ingameEventHandlers.onAnnouncementEvent) {
       events.announcements.forEach(
-        (event) => this.eventHandlers.onAnnouncementEvent(event)
+        (event) => this.ingameEventHandlers.onAnnouncementEvent(event)
       );
     }
-    if (events.killFeed && this.eventHandlers.onKillFeedEvent) {
+    if (events.killFeed && this.ingameEventHandlers.onKillFeedEvent) {
       events.killFeed.forEach(
-        (event) => this.eventHandlers.onKillFeedEvent(event)
+        (event) => this.ingameEventHandlers.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._isTestingEnvironment = false;
+    this.ingameStore._reset(this.gameData, 0 /* OutOfGame */);
     this.gameStatusHandlers.forEach(
       (handler) => handler(0 /* OutOfGame */, false)
     );
     this.stateUpdateHandlers.forEach((handler) => handler(this.gameData));
   }
+  // ===========================================================================
+  // Private — pre-game message handling
+  // ===========================================================================
+  setupPreGameMessageHandler() {
+    this.preGameWs.onMessage((messageData) => {
+      switch (messageData.type) {
+        case "champion-select-state-update":
+          this.handleChampSelectStateUpdate(messageData.state);
+          break;
+        case "champion-select-action":
+          this.handleChampSelectAction(messageData.action);
+          break;
+        case "frontend-route-update":
+          this.handleRouteUpdate(messageData.uri);
+          break;
+      }
+    });
+  }
+  handleChampSelectStateUpdate(state) {
+    const nextData = {
+      isActive: false,
+      isConnected: false,
+      isTestingEnvironment: false,
+      blueTeam: {},
+      redTeam: {},
+      metaData: {},
+      timer: {},
+      ...state
+    };
+    this.champSelectData = structuralShare(this.champSelectData, nextData);
+    if (nextData.isActive && !this.champSelectWasActive) {
+      this.champSelectWasActive = true;
+      this.champSelectEventHandlers.onChampSelectStart?.();
+    } else if (!nextData.isActive && this.champSelectWasActive) {
+      this.champSelectWasActive = false;
+      this.endChampSelect();
+      return;
+    }
+    this.preGameStore._setChampSelectData(this.champSelectData);
+    this.champSelectUpdateHandlers.forEach(
+      (handler) => handler(this.champSelectData)
+    );
+  }
+  handleChampSelectAction(action) {
+    this.champSelectEventHandlers.onAction?.(action);
+  }
+  handleRouteUpdate(uri) {
+    this.champSelectEventHandlers.onRouteUpdate?.(uri);
+  }
+  endChampSelect() {
+    console.log("[LeagueBroadcastClient] Champ select ended, resetting data");
+    this.champSelectData = new champSelectStateData();
+    this.preGameStore._reset(this.champSelectData);
+    this.champSelectEventHandlers.onChampSelectEnd?.();
+    this.champSelectUpdateHandlers.forEach(
+      (handler) => handler(this.champSelectData)
+    );
+  }
 };
 
-export { GameState, GameStateStore, LeagueBroadcastClient, WebSocketManager, shallowEqual };
+// types/pregame/pickbanphase.ts
+var PickBanPhase = /* @__PURE__ */ ((PickBanPhase2) => {
+  PickBanPhase2[PickBanPhase2["BEGIN"] = 0] = "BEGIN";
+  PickBanPhase2[PickBanPhase2["BAN1"] = 1] = "BAN1";
+  PickBanPhase2[PickBanPhase2["BAN2"] = 2] = "BAN2";
+  PickBanPhase2[PickBanPhase2["PICK1"] = 3] = "PICK1";
+  PickBanPhase2[PickBanPhase2["PICK2"] = 4] = "PICK2";
+  PickBanPhase2[PickBanPhase2["END"] = 5] = "END";
+  PickBanPhase2[PickBanPhase2["WAIT"] = 6] = "WAIT";
+  return PickBanPhase2;
+})(PickBanPhase || {});
+
+// types/pregame/actiontype.ts
+var ActionType = /* @__PURE__ */ ((ActionType2) => {
+  ActionType2[ActionType2["TEN_BANS_REVEAL"] = 0] = "TEN_BANS_REVEAL";
+  ActionType2[ActionType2["PHASE_TRANSITION"] = 1] = "PHASE_TRANSITION";
+  ActionType2[ActionType2["PICK"] = 2] = "PICK";
+  ActionType2[ActionType2["BAN"] = 3] = "BAN";
+  return ActionType2;
+})(ActionType || {});
+
+// types/pregame/actionsubtype.ts
+var ActionSubType = /* @__PURE__ */ ((ActionSubType2) => {
+  ActionSubType2[ActionSubType2["START"] = 0] = "START";
+  ActionSubType2[ActionSubType2["HOVER"] = 1] = "HOVER";
+  ActionSubType2[ActionSubType2["LOCK"] = 2] = "LOCK";
+  return ActionSubType2;
+})(ActionSubType || {});
+
+// types/pregame/timelineactiontype.ts
+var TimeLineActionType = /* @__PURE__ */ ((TimeLineActionType2) => {
+  TimeLineActionType2[TimeLineActionType2["HoverPick"] = 0] = "HoverPick";
+  TimeLineActionType2[TimeLineActionType2["Pick"] = 1] = "Pick";
+  TimeLineActionType2[TimeLineActionType2["Ban"] = 2] = "Ban";
+  return TimeLineActionType2;
+})(TimeLineActionType || {});
+
+// types/shared/bestoftype.ts
+var BestOfType = /* @__PURE__ */ ((BestOfType2) => {
+  BestOfType2[BestOfType2["BestOf1"] = 1] = "BestOf1";
+  BestOfType2[BestOfType2["BestOf2"] = 2] = "BestOf2";
+  BestOfType2[BestOfType2["BestOf3"] = 3] = "BestOf3";
+  BestOfType2[BestOfType2["BestOf5"] = 5] = "BestOf5";
+  BestOfType2[BestOfType2["BestOf7"] = 7] = "BestOf7";
+  return BestOfType2;
+})(BestOfType || {});
+
+// types/shared/matchruleset.ts
+var MatchRuleSet = /* @__PURE__ */ ((MatchRuleSet2) => {
+  MatchRuleSet2[MatchRuleSet2["Standard"] = 0] = "Standard";
+  MatchRuleSet2[MatchRuleSet2["PartialFearless"] = 1] = "PartialFearless";
+  MatchRuleSet2[MatchRuleSet2["Fearless"] = 2] = "Fearless";
+  return MatchRuleSet2;
+})(MatchRuleSet || {});
+
+// src/util/ingameScoreboardBottomPlayerDataUtils.ts
+function getSortedInventory(playerData) {
+  if (!playerData.items) return Array(6).fill({ id: 0 });
+  const items = playerData.items?.filter((item) => item.slot < 6) ?? [];
+  const regularItems = items.sort(
+    (a, b) => (a?.cost ?? 0) - (b?.cost ?? 0)
+  );
+  while (regularItems.length < 6) {
+    regularItems.unshift(void 0);
+  }
+  return regularItems ?? [];
+}
+function getTrinket(playerData) {
+  return playerData.items?.find((item) => item.slot === 6);
+}
+function getRoleQuest(playerData) {
+  return playerData.items?.find((item) => item.slot === 8);
+}
+
+export { ActionSubType, ActionType, ApiClient, ApiError, BestOfType, ChampSelectStateStore, GameApi, GameState, GameStateApi, GameStateStore, IngameApi, LeagueBroadcastClient, MatchApi, MatchRuleSet, PickBanPhase, PreGameApi, RestApi, SeasonApi, TimeLineActionType, WebSocketManager, getRoleQuest, getSortedInventory, getTrinket, shallowEqual };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map