@juande_pl/rocketleague-stats-api-client 0.0.0-stage → 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1026 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/node/config.ts
+var config_exports = {};
+__export(config_exports, {
+  DEFAULT_PACKET_SEND_RATE: () => DEFAULT_PACKET_SEND_RATE,
+  MAX_PACKET_SEND_RATE: () => MAX_PACKET_SEND_RATE,
+  STATS_API_INI_FILES: () => STATS_API_INI_FILES,
+  STATS_API_SECTION: () => STATS_API_SECTION,
+  editPacketSendRate: () => editPacketSendRate,
+  ensureStatsApiEnabled: () => ensureStatsApiEnabled,
+  findRocketLeagueInstallDirs: () => findRocketLeagueInstallDirs,
+  findStatsApiIni: () => findStatsApiIni,
+  statsApiIniPaths: () => statsApiIniPaths
+});
+function editPacketSendRate(content, rate = DEFAULT_PACKET_SEND_RATE) {
+  const eol = content.includes("\r\n") ? "\r\n" : "\n";
+  const lines = content.split(/\r?\n/);
+  let sectionStart = -1;
+  let sectionEnd = lines.length;
+  for (let i = 0; i < lines.length; i++) {
+    const match = SECTION_RE.exec(lines[i]);
+    if (!match) continue;
+    if (sectionStart !== -1) {
+      sectionEnd = i;
+      break;
+    }
+    if (match[1].trim().toLowerCase() === STATS_API_SECTION.toLowerCase()) sectionStart = i;
+  }
+  let keyLine = -1;
+  let previous;
+  if (sectionStart !== -1) {
+    for (let i = sectionStart + 1; i < sectionEnd; i++) {
+      const match = KEY_RE.exec(lines[i]);
+      if (match) {
+        keyLine = i;
+        const value = Number.parseFloat(match[2]);
+        previous = Number.isNaN(value) ? void 0 : value;
+        break;
+      }
+    }
+  }
+  const needsUpdate = previous === void 0 || previous <= 0 || previous > MAX_PACKET_SEND_RATE;
+  if (!needsUpdate) return { previous, needsUpdate, content };
+  if (keyLine !== -1) {
+    lines[keyLine] = lines[keyLine].replace(KEY_RE, (_, prefix, _value, suffix) => `${prefix}${rate}${suffix}`);
+  } else if (sectionStart !== -1) {
+    lines.splice(sectionStart + 1, 0, `PacketSendRate=${rate}`);
+  } else {
+    const hasTrailingNewline = lines.length > 0 && lines.at(-1) === "";
+    if (hasTrailingNewline) lines.pop();
+    if (lines.length > 0 && lines.at(-1).trim() !== "") lines.push("");
+    lines.push(`[${STATS_API_SECTION}]`, `PacketSendRate=${rate}`);
+    if (hasTrailingNewline) lines.push("");
+  }
+  return { previous, needsUpdate, content: lines.join(eol) };
+}
+async function exists(file) {
+  try {
+    await (0, import_promises.access)(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readJson(file) {
+  try {
+    return JSON.parse(await (0, import_promises.readFile)(file, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function epicInstallLocation(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const { AppName, InstallLocation } = value;
+  return AppName === EPIC_APP_NAME && typeof InstallLocation === "string" ? InstallLocation : void 0;
+}
+async function findEpicInstalls(programData) {
+  const found = [];
+  const launcherInstalled = await readJson(import_node_path.default.join(programData, "Epic", "UnrealEngineLauncher", "LauncherInstalled.dat"));
+  const list = launcherInstalled?.InstallationList;
+  if (Array.isArray(list)) {
+    for (const item of list) {
+      const location = epicInstallLocation(item);
+      if (location) found.push(location);
+    }
+  }
+  const manifestsDir = import_node_path.default.join(programData, "Epic", "EpicGamesLauncher", "Data", "Manifests");
+  try {
+    for (const file of await (0, import_promises.readdir)(manifestsDir)) {
+      if (!file.toLowerCase().endsWith(".item")) continue;
+      const location = epicInstallLocation(await readJson(import_node_path.default.join(manifestsDir, file)));
+      if (location) found.push(location);
+    }
+  } catch {
+  }
+  return found;
+}
+async function findSteamInstalls(steamDir) {
+  const libraries = [steamDir];
+  try {
+    const vdf = await (0, import_promises.readFile)(import_node_path.default.join(steamDir, "steamapps", "libraryfolders.vdf"), "utf8");
+    for (const match of vdf.matchAll(/"path"\s+"([^"]+)"/g)) libraries.push(match[1].replace(/\\\\/g, "\\"));
+  } catch {
+  }
+  return libraries.map((library) => import_node_path.default.join(library, "steamapps", "common", "rocketleague"));
+}
+async function findRocketLeagueInstallDirs() {
+  if (process.platform !== "win32") return [];
+  const env = process.env;
+  const programData = env.ProgramData ?? "C:\\ProgramData";
+  const programFiles = env.ProgramFiles ?? "C:\\Program Files";
+  const programFilesX86 = env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
+  const candidates = [
+    ...await findEpicInstalls(programData),
+    import_node_path.default.join(programFiles, "Epic Games", "rocketleague"),
+    ...await findSteamInstalls(import_node_path.default.join(programFilesX86, "Steam"))
+  ];
+  return [...new Set(candidates.map((dir) => import_node_path.default.normalize(dir)))];
+}
+function statsApiIniPaths(installDir) {
+  return STATS_API_INI_FILES.map((file) => import_node_path.default.join(installDir, "TAGame", "Config", file));
+}
+async function findStatsApiIni(installDir) {
+  const dirs = installDir ? [installDir] : await findRocketLeagueInstallDirs();
+  const searched = [];
+  for (const dir of dirs) {
+    for (const file of statsApiIniPaths(dir)) {
+      searched.push(file);
+      if (await exists(file)) return { iniPath: file, searched };
+    }
+  }
+  return { iniPath: void 0, searched };
+}
+function describeProblem(previous) {
+  return previous !== void 0 && previous > MAX_PACKET_SEND_RATE ? `PacketSendRate=${previous} is above the maximum of ${MAX_PACKET_SEND_RATE}` : `The Rocket League Stats API is disabled (PacketSendRate=${previous ?? 0})`;
+}
+async function ensureStatsApiEnabled(options = {}) {
+  const rate = options.packetSendRate ?? DEFAULT_PACKET_SEND_RATE;
+  if (!Number.isFinite(rate) || rate <= 0 || rate > MAX_PACKET_SEND_RATE) {
+    throw new RangeError(`packetSendRate must be between 1 and ${MAX_PACKET_SEND_RATE}, got ${rate}.`);
+  }
+  const warn = options.warn === false ? () => {
+  } : options.warn ?? ((message) => console.warn(message));
+  let iniPath = options.iniPath;
+  let searched = iniPath ? [iniPath] : [];
+  if (iniPath === void 0) {
+    ({ iniPath, searched } = await findStatsApiIni(options.installDir));
+  }
+  let content;
+  let encoding;
+  try {
+    if (!iniPath) throw new Error("not found");
+    const buffer = await (0, import_promises.readFile)(iniPath);
+    encoding = buffer[0] === 255 && buffer[1] === 254 ? "utf16le" : "utf8";
+    content = buffer.toString(encoding);
+  } catch {
+    return { status: "not-found", searched };
+  }
+  const edit = editPacketSendRate(content, rate);
+  if (!edit.needsUpdate) return { status: "enabled", iniPath, packetSendRate: edit.previous };
+  try {
+    await (0, import_promises.writeFile)(iniPath, edit.content, encoding);
+  } catch (error) {
+    warn(
+      `[@juande_pl/rocketleague-stats-api-client] ${describeProblem(edit.previous)}, but "${iniPath}" could not be written. Set PacketSendRate=${rate} manually (you may need administrator rights) and restart the game.`
+    );
+    return { status: "write-failed", iniPath, previous: edit.previous, error };
+  }
+  warn(
+    `[@juande_pl/rocketleague-stats-api-client] ${describeProblem(edit.previous)}. PacketSendRate has been set to ${rate} in "${iniPath}". Restart Rocket League for the Stats API to work.`
+  );
+  return { status: "updated", iniPath, previous: edit.previous, packetSendRate: rate, restartRequired: true };
+}
+var import_promises, import_node_path, STATS_API_SECTION, DEFAULT_PACKET_SEND_RATE, MAX_PACKET_SEND_RATE, STATS_API_INI_FILES, EPIC_APP_NAME, SECTION_RE, KEY_RE;
+var init_config = __esm({
+  "src/node/config.ts"() {
+    "use strict";
+    import_promises = require("fs/promises");
+    import_node_path = __toESM(require("path"), 1);
+    STATS_API_SECTION = "TAGame.MatchStatsExporter_TA";
+    DEFAULT_PACKET_SEND_RATE = 30;
+    MAX_PACKET_SEND_RATE = 120;
+    STATS_API_INI_FILES = ["TAStatsAPI.ini", "DefaultStatsAPI.ini"];
+    EPIC_APP_NAME = "Sugar";
+    SECTION_RE = /^\s*\[([^\]]+)\]\s*$/;
+    KEY_RE = /^(\s*PacketSendRate\s*=\s*)([^;\r\n]*?)(\s*(?:;.*)?)$/i;
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BALL_UNTOUCHED_TEAM_NUM: () => BALL_UNTOUCHED_TEAM_NUM,
+  COMMAND_NAMES: () => COMMAND_NAMES,
+  CommandValidationError: () => CommandValidationError,
+  ConnectionError: () => ConnectionError,
+  EVENT_NAMES: () => EVENT_NAMES,
+  ListenerError: () => ListenerError,
+  NotConnectedError: () => NotConnectedError,
+  PERSPECTIVES: () => PERSPECTIVES,
+  RocketLeagueStatsClient: () => RocketLeagueStatsClient,
+  StatsApiError: () => StatsApiError,
+  Team: () => Team,
+  allOf: () => allOf,
+  arrayOf: () => arrayOf,
+  commandDataGuards: () => commandDataGuards,
+  default: () => RocketLeagueStatsClient,
+  eventDataGuards: () => eventDataGuards,
+  isBallHitData: () => isBallHitData,
+  isBallLastTouch: () => isBallLastTouch,
+  isBoolean: () => isBoolean,
+  isBoostPickupData: () => isBoostPickupData,
+  isChangePOVData: () => isChangePOVData,
+  isClockUpdatedSecondsData: () => isClockUpdatedSecondsData,
+  isCommandData: () => isCommandData,
+  isCommandName: () => isCommandName,
+  isCountdownBeginData: () => isCountdownBeginData,
+  isCrossbarHitData: () => isCrossbarHitData,
+  isEventData: () => isEventData,
+  isEventName: () => isEventName,
+  isFocus: () => isFocus,
+  isGame: () => isGame,
+  isGameBall: () => isGameBall,
+  isGameTeam: () => isGameTeam,
+  isGoalReplayEndData: () => isGoalReplayEndData,
+  isGoalReplayStartData: () => isGoalReplayStartData,
+  isGoalReplayWillEndData: () => isGoalReplayWillEndData,
+  isGoalScoredData: () => isGoalScoredData,
+  isInteger: () => isInteger,
+  isLoadReplayData: () => isLoadReplayData,
+  isMatchCreatedData: () => isMatchCreatedData,
+  isMatchDestroyedData: () => isMatchDestroyedData,
+  isMatchEndedData: () => isMatchEndedData,
+  isMatchInitializedData: () => isMatchInitializedData,
+  isMatchPausedData: () => isMatchPausedData,
+  isMatchUnpausedData: () => isMatchUnpausedData,
+  isNumber: () => isNumber,
+  isPerspective: () => isPerspective,
+  isPlayer: () => isPlayer,
+  isPlayerJoinedData: () => isPlayerJoinedData,
+  isPlayerLeftData: () => isPlayerLeftData,
+  isPlayerRef: () => isPlayerRef,
+  isPodiumStartData: () => isPodiumStartData,
+  isRawEventEnvelope: () => isRawEventEnvelope,
+  isRecord: () => isRecord,
+  isReplayCreatedData: () => isReplayCreatedData,
+  isRoundStartedData: () => isRoundStartedData,
+  isSeekReplayData: () => isSeekReplayData,
+  isSetGameSpeedData: () => isSetGameSpeedData,
+  isSetHUDVisibilityData: () => isSetHUDVisibilityData,
+  isSetMatchPausedData: () => isSetMatchPausedData,
+  isStatfeedEventData: () => isStatfeedEventData,
+  isStatsApiCommand: () => isStatsApiCommand,
+  isStatsApiEvent: () => isStatsApiEvent,
+  isString: () => isString,
+  isUpdateStateData: () => isUpdateStateData,
+  isVector: () => isVector,
+  oneOf: () => oneOf,
+  optional: () => optional,
+  parseEventMessage: () => parseEventMessage,
+  shape: () => shape
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/common.ts
+var Team = {
+  Blue: 0,
+  Orange: 1
+};
+var BALL_UNTOUCHED_TEAM_NUM = 255;
+
+// src/types/events.ts
+var EVENT_NAMES = [
+  "UpdateState",
+  "BallHit",
+  "BoostPickup",
+  "ClockUpdatedSeconds",
+  "CountdownBegin",
+  "CrossbarHit",
+  "GoalReplayEnd",
+  "GoalReplayStart",
+  "GoalReplayWillEnd",
+  "GoalScored",
+  "MatchCreated",
+  "MatchDestroyed",
+  "MatchEnded",
+  "MatchInitialized",
+  "MatchPaused",
+  "MatchUnpaused",
+  "PlayerJoined",
+  "PlayerLeft",
+  "PodiumStart",
+  "ReplayCreated",
+  "RoundStarted",
+  "StatfeedEvent"
+];
+
+// src/types/commands.ts
+var COMMAND_NAMES = [
+  "ChangePOV",
+  "LoadReplay",
+  "SeekReplay",
+  "SetGameSpeed",
+  "SetHUDVisibility",
+  "SetMatchPaused"
+];
+var PERSPECTIVES = [
+  /** Freely move around the map. */
+  "Fly",
+  /** Follow the position of a player or ball. */
+  "SoftAttach",
+  /** Follow the position and rotation of a player. */
+  "HardAttach",
+  /** View from a player's perspective. Applied automatically when Focus targets a player and no Perspective is given. */
+  "PlayerView",
+  /** Automatically spectates. */
+  "AutoCam",
+  /** Automatically switches between player views. */
+  "Camera_Director"
+];
+
+// src/guards/primitives.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var isString = (value) => typeof value === "string";
+var isNumber = (value) => typeof value === "number" && Number.isFinite(value);
+var isInteger = (value) => Number.isInteger(value);
+var isBoolean = (value) => typeof value === "boolean";
+function optional(guard) {
+  return (value) => value === void 0 || guard(value);
+}
+function arrayOf(guard) {
+  return (value) => Array.isArray(value) && value.every((item) => guard(item));
+}
+function oneOf(values) {
+  const set = new Set(values);
+  return (value) => set.has(value);
+}
+function shape(spec) {
+  const entries = Object.entries(spec);
+  return (value) => {
+    if (!isRecord(value)) return false;
+    for (const [key, guard] of entries) {
+      if (!guard(value[key])) return false;
+    }
+    return true;
+  };
+}
+function allOf(guard, ...checks) {
+  return (value) => guard(value) && checks.every((check) => check(value));
+}
+
+// src/guards/events.ts
+var isVector = shape({ X: isNumber, Y: isNumber, Z: isNumber });
+var isPlayerRef = shape({
+  Name: isString,
+  Shortcut: isNumber,
+  TeamNum: isNumber
+});
+var isBallLastTouch = shape({
+  Player: isPlayerRef,
+  Speed: isNumber
+});
+var isPlayer = shape({
+  Name: isString,
+  Shortcut: isNumber,
+  TeamNum: isNumber,
+  PrimaryId: isString,
+  Score: isNumber,
+  Goals: isNumber,
+  Shots: isNumber,
+  Assists: isNumber,
+  Saves: isNumber,
+  Touches: isNumber,
+  CarTouches: isNumber,
+  Demos: isNumber,
+  Loadout: optional(arrayOf(isString)),
+  bHasCar: optional(isBoolean),
+  Speed: optional(isNumber),
+  Boost: optional(isNumber),
+  bBoosting: optional(isBoolean),
+  bOnGround: optional(isBoolean),
+  bOnWall: optional(isBoolean),
+  bPowersliding: optional(isBoolean),
+  bDemolished: optional(isBoolean),
+  bSupersonic: optional(isBoolean),
+  PickupClass: optional(isString),
+  Attacker: optional(isPlayerRef)
+});
+var isGameTeam = shape({
+  Name: isString,
+  TeamNum: isNumber,
+  Score: isNumber,
+  ColorPrimary: isString,
+  ColorSecondary: isString
+});
+var isGameBall = shape({ Speed: isNumber, TeamNum: isNumber });
+var isGame = shape({
+  Teams: arrayOf(isGameTeam),
+  PlaylistId: optional(isNumber),
+  TimeSeconds: isNumber,
+  bOvertime: isBoolean,
+  Ball: isGameBall,
+  bReplay: isBoolean,
+  bHasWinner: isBoolean,
+  Winner: isString,
+  Arena: isString,
+  bHasTarget: isBoolean,
+  Target: optional(isPlayerRef),
+  Frame: optional(isNumber),
+  Elapsed: optional(isNumber)
+});
+var matchGuid = optional(isString);
+var isBaseEventData = shape({ MatchGuid: matchGuid });
+var isUpdateStateData = shape({
+  MatchGuid: matchGuid,
+  Players: arrayOf(isPlayer),
+  Game: isGame
+});
+var isBallHitData = shape({
+  MatchGuid: matchGuid,
+  Players: arrayOf(isPlayerRef),
+  Ball: shape({
+    PreHitSpeed: isNumber,
+    PostHitSpeed: isNumber,
+    Location: isVector
+  })
+});
+var isBoostPickupData = shape({
+  MatchGuid: matchGuid,
+  Player: isPlayerRef,
+  Location: isVector,
+  BoostAmount: isNumber,
+  BoostType: oneOf(["BoostType_Pad", "BoostType_Pill"]),
+  bReplay: isBoolean
+});
+var isClockUpdatedSecondsData = shape({
+  MatchGuid: matchGuid,
+  TimeSeconds: isNumber,
+  bOvertime: isBoolean
+});
+var isCrossbarHitData = shape({
+  MatchGuid: matchGuid,
+  BallLocation: isVector,
+  BallSpeed: isNumber,
+  ImpactForce: isNumber,
+  BallLastTouch: isBallLastTouch
+});
+var isGoalScoredData = shape({
+  MatchGuid: matchGuid,
+  GoalSpeed: isNumber,
+  GoalTime: isNumber,
+  ImpactLocation: isVector,
+  Scorer: isPlayerRef,
+  Assister: optional(isPlayerRef),
+  BallLastTouch: isBallLastTouch
+});
+var isMatchEndedData = shape({
+  MatchGuid: matchGuid,
+  WinnerTeamNum: isNumber
+});
+var isPlayerJoinedData = shape({
+  MatchGuid: matchGuid,
+  PlayerName: isString,
+  PrimaryId: isString
+});
+var isPlayerLeftData = shape({
+  MatchGuid: matchGuid,
+  PlayerName: isString,
+  PrimaryId: isString
+});
+var isReplayCreatedData = shape({
+  MatchGuid: matchGuid,
+  FileName: isString,
+  Date: isString
+});
+var isStatfeedEventData = shape({
+  MatchGuid: matchGuid,
+  EventName: isString,
+  Type: isString,
+  MainTarget: isPlayerRef,
+  SecondaryTarget: optional(isPlayerRef)
+});
+var isCountdownBeginData = isBaseEventData;
+var isGoalReplayEndData = isBaseEventData;
+var isGoalReplayStartData = isBaseEventData;
+var isGoalReplayWillEndData = isBaseEventData;
+var isMatchCreatedData = isBaseEventData;
+var isMatchDestroyedData = isBaseEventData;
+var isMatchInitializedData = isBaseEventData;
+var isMatchPausedData = isBaseEventData;
+var isMatchUnpausedData = isBaseEventData;
+var isPodiumStartData = isBaseEventData;
+var isRoundStartedData = isBaseEventData;
+var eventDataGuards = {
+  UpdateState: isUpdateStateData,
+  BallHit: isBallHitData,
+  BoostPickup: isBoostPickupData,
+  ClockUpdatedSeconds: isClockUpdatedSecondsData,
+  CountdownBegin: isCountdownBeginData,
+  CrossbarHit: isCrossbarHitData,
+  GoalReplayEnd: isGoalReplayEndData,
+  GoalReplayStart: isGoalReplayStartData,
+  GoalReplayWillEnd: isGoalReplayWillEndData,
+  GoalScored: isGoalScoredData,
+  MatchCreated: isMatchCreatedData,
+  MatchDestroyed: isMatchDestroyedData,
+  MatchEnded: isMatchEndedData,
+  MatchInitialized: isMatchInitializedData,
+  MatchPaused: isMatchPausedData,
+  MatchUnpaused: isMatchUnpausedData,
+  PlayerJoined: isPlayerJoinedData,
+  PlayerLeft: isPlayerLeftData,
+  PodiumStart: isPodiumStartData,
+  ReplayCreated: isReplayCreatedData,
+  RoundStarted: isRoundStartedData,
+  StatfeedEvent: isStatfeedEventData
+};
+var isEventName = oneOf(EVENT_NAMES);
+function isEventData(name, data) {
+  const guard = eventDataGuards[name];
+  return guard(data);
+}
+function isRawEventEnvelope(value) {
+  return isRecord(value) && isString(value.Event) && (isString(value.Data) || isRecord(value.Data));
+}
+function isStatsApiEvent(value, name) {
+  if (!isRecord(value) || !isEventName(value.Event)) return false;
+  if (name !== void 0 && value.Event !== name) return false;
+  return isEventData(value.Event, value.Data);
+}
+
+// src/guards/commands.ts
+var isFocus = (value) => value === "Ball" || isString(value) && /^\d+$/.test(value);
+var isPerspective = oneOf(PERSPECTIVES);
+function has(record, key, check) {
+  return record[key] !== void 0 && check(record[key]);
+}
+var isChangePOVData = (value) => isRecord(value) && optional(isFocus)(value.Focus) && optional(isPerspective)(value.Perspective) && (value.Focus !== void 0 || value.Perspective !== void 0);
+var isLoadReplayData = (value) => isRecord(value) && optional(isString)(value.FileName) && optional(isString)(value.Path) && (has(value, "FileName", (v) => v !== "") || has(value, "Path", (v) => v !== ""));
+var isSeekReplayData = (value) => isRecord(value) && optional((v) => isInteger(v) && v >= 0)(value.Frame) && optional((v) => isNumber(v) && v >= 0)(value.TimeSeconds) && (value.Frame !== void 0 || value.TimeSeconds !== void 0);
+var isSetGameSpeedData = (value) => isRecord(value) && isNumber(value.Speed) && value.Speed >= 0;
+var isSetHUDVisibilityData = (value) => isRecord(value) && isBoolean(value.bVisible);
+var isSetMatchPausedData = (value) => isRecord(value) && isBoolean(value.bPaused);
+var commandDataGuards = {
+  ChangePOV: isChangePOVData,
+  LoadReplay: isLoadReplayData,
+  SeekReplay: isSeekReplayData,
+  SetGameSpeed: isSetGameSpeedData,
+  SetHUDVisibility: isSetHUDVisibilityData,
+  SetMatchPaused: isSetMatchPausedData
+};
+var isCommandName = oneOf(COMMAND_NAMES);
+function isCommandData(name, data) {
+  const guard = commandDataGuards[name];
+  return guard(data);
+}
+function isStatsApiCommand(value, name) {
+  if (!isRecord(value) || !isCommandName(value.Command)) return false;
+  if (name !== void 0 && value.Command !== name) return false;
+  return isCommandData(value.Command, value.Data);
+}
+
+// src/parse.ts
+function parseEventMessage(raw, options = {}) {
+  const validate = options.validate ?? true;
+  let envelope = raw;
+  if (typeof raw === "string") {
+    try {
+      envelope = JSON.parse(raw);
+    } catch {
+      return { ok: false, reason: "invalid-json", raw };
+    }
+  }
+  if (!isRecord(envelope) || typeof envelope.Event !== "string") {
+    return { ok: false, reason: "invalid-envelope", raw };
+  }
+  const event = envelope.Event;
+  let data = envelope.Data;
+  if (typeof data === "string") {
+    try {
+      data = JSON.parse(data);
+    } catch {
+      return { ok: false, reason: "invalid-data-json", raw, event, data };
+    }
+  }
+  if (!isRecord(data)) {
+    return { ok: false, reason: "invalid-data-json", raw, event, data };
+  }
+  if (!isEventName(event)) {
+    return { ok: false, reason: "unknown-event", raw, event, data };
+  }
+  if (validate && !isEventData(event, data)) {
+    return { ok: false, reason: "invalid-data", raw, event, data };
+  }
+  return { ok: true, event: { Event: event, Data: data } };
+}
+
+// src/errors.ts
+var StatsApiError = class extends Error {
+  name = "StatsApiError";
+};
+var NotConnectedError = class extends StatsApiError {
+  name = "NotConnectedError";
+  constructor(message = "Cannot send a command: the socket is not connected.") {
+    super(message);
+  }
+};
+var CommandValidationError = class extends StatsApiError {
+  constructor(message, command, data) {
+    super(message);
+    this.command = command;
+    this.data = data;
+  }
+  command;
+  data;
+  name = "CommandValidationError";
+};
+var ConnectionError = class extends StatsApiError {
+  name = "ConnectionError";
+};
+var ListenerError = class extends StatsApiError {
+  constructor(eventName, cause) {
+    super(`A listener for "${eventName}" threw an error.`, { cause });
+    this.eventName = eventName;
+  }
+  eventName;
+  name = "ListenerError";
+};
+
+// src/client.ts
+var WS_OPEN = 1;
+function isNodeRuntime() {
+  const proc = globalThis.process;
+  return typeof proc?.versions?.node === "string";
+}
+var RocketLeagueStatsClient = class {
+  /** The WebSocket URL this client connects to. */
+  url;
+  /**
+   * Result of the `.ini` check (see the `ensureStatsApi` option). `undefined` outside Node.js or when
+   * `ensureStatsApi: false`. Never rejects.
+   */
+  statsApiConfig;
+  #autoConnect;
+  #reconnect;
+  #validateEvents;
+  #WebSocket;
+  #socket = null;
+  #state = "idle";
+  #manualClose = false;
+  #reconnectAttempts = 0;
+  #reconnectTimer = null;
+  #listeners = /* @__PURE__ */ new Map();
+  #anyListeners = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    const protocol = options.secure ? "wss" : "ws";
+    this.url = options.url ?? `${protocol}://${options.host ?? "127.0.0.1"}:${options.port ?? 49124}`;
+    this.#autoConnect = options.autoConnect ?? true;
+    this.#validateEvents = options.validateEvents ?? true;
+    this.#WebSocket = options.WebSocket ?? globalThis.WebSocket;
+    const reconnect = options.reconnect ?? true;
+    this.#reconnect = reconnect === false ? null : {
+      initialDelay: 1e3,
+      maxDelay: 3e4,
+      factor: 2,
+      maxAttempts: Number.POSITIVE_INFINITY,
+      ...reconnect === true ? {} : reconnect
+    };
+    const ensureStatsApi = options.ensureStatsApi ?? true;
+    if (ensureStatsApi !== false && isNodeRuntime()) {
+      const ensureOptions = ensureStatsApi === true ? {} : ensureStatsApi;
+      const rate = ensureOptions.packetSendRate;
+      if (rate !== void 0 && !(Number.isFinite(rate) && rate > 0 && rate <= 120)) {
+        throw new RangeError(`packetSendRate must be between 1 and 120, got ${rate}.`);
+      }
+      this.statsApiConfig = Promise.resolve().then(() => (init_config(), config_exports)).then(({ ensureStatsApiEnabled: ensureStatsApiEnabled2 }) => ensureStatsApiEnabled2(ensureOptions));
+    } else {
+      this.statsApiConfig = void 0;
+    }
+    if (this.#autoConnect) {
+      queueMicrotask(() => {
+        if (this.#state === "idle" && !this.#manualClose) this.connect();
+      });
+    }
+  }
+  /** Current connection state. */
+  get state() {
+    return this.#state;
+  }
+  /** `true` when the socket is open and commands can be sent. */
+  get isConnected() {
+    return this.#state === "open" && this.#socket?.readyState === WS_OPEN;
+  }
+  // -----------------------------------------------------------------------
+  // Connection
+  // -----------------------------------------------------------------------
+  /**
+   * Opens the connection. Does nothing if already connecting or connected.
+   * Called automatically unless `autoConnect: false` was passed.
+   */
+  connect() {
+    if (this.#state === "connecting" || this.#state === "open") return;
+    this.#manualClose = false;
+    this.#clearReconnectTimer();
+    const WebSocketImpl = this.#WebSocket;
+    if (!WebSocketImpl) {
+      throw new ConnectionError(
+        'No WebSocket implementation found. Use Node.js >= 22, or pass one via the `WebSocket` option (e.g. from the "ws" package).'
+      );
+    }
+    this.#state = "connecting";
+    let socket;
+    try {
+      socket = new WebSocketImpl(this.url);
+    } catch (cause) {
+      this.#state = "closed";
+      this.#emitError(new ConnectionError(`Failed to create WebSocket for ${this.url}.`, { cause }));
+      this.#scheduleReconnect();
+      return;
+    }
+    this.#socket = socket;
+    socket.addEventListener("open", () => {
+      if (this.#socket !== socket) return;
+      this.#state = "open";
+      this.#reconnectAttempts = 0;
+      this.#emit("connect");
+    });
+    socket.addEventListener("message", (event) => {
+      if (this.#socket !== socket) return;
+      void this.#handleRawMessage(event.data);
+    });
+    socket.addEventListener("error", (cause) => {
+      if (this.#socket !== socket) return;
+      this.#emitError(new ConnectionError(`WebSocket error on ${this.url}.`, { cause }));
+    });
+    socket.addEventListener("close", (event) => {
+      if (this.#socket !== socket) return;
+      this.#socket = null;
+      this.#state = "closed";
+      const willReconnect = this.#scheduleReconnect(true);
+      this.#emit("disconnect", { code: event.code, reason: event.reason, willReconnect });
+    });
+  }
+  /** Closes the connection and stops any pending reconnection. */
+  disconnect(code = 1e3, reason = "Client disconnect") {
+    this.#manualClose = true;
+    this.#clearReconnectTimer();
+    const socket = this.#socket;
+    if (!socket) {
+      if (this.#state !== "idle") this.#state = "closed";
+      return;
+    }
+    socket.close(code, reason);
+  }
+  #scheduleReconnect(deferEmit = false) {
+    const options = this.#reconnect;
+    if (!options || this.#manualClose || this.#reconnectAttempts >= options.maxAttempts) return false;
+    const attempt = ++this.#reconnectAttempts;
+    const delay = Math.min(options.initialDelay * options.factor ** (attempt - 1), options.maxDelay);
+    this.#reconnectTimer = setTimeout(() => {
+      this.#reconnectTimer = null;
+      this.connect();
+    }, delay);
+    const notify = () => this.#emit("reconnecting", { attempt, delay });
+    if (deferEmit) queueMicrotask(notify);
+    else notify();
+    return true;
+  }
+  #clearReconnectTimer() {
+    if (this.#reconnectTimer !== null) {
+      clearTimeout(this.#reconnectTimer);
+      this.#reconnectTimer = null;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Incoming events
+  // -----------------------------------------------------------------------
+  async #handleRawMessage(raw) {
+    let text = raw;
+    if (raw instanceof ArrayBuffer || ArrayBuffer.isView(raw)) {
+      text = new TextDecoder().decode(raw);
+    } else if (typeof Blob !== "undefined" && raw instanceof Blob) {
+      text = await raw.text();
+    }
+    this.handleMessage(text);
+  }
+  /**
+   * Decodes, validates and dispatches one raw message. Called for every socket message;
+   * exposed so messages from another transport (e.g. the TCP port, a recording) can be fed in.
+   */
+  handleMessage(raw) {
+    const result = parseEventMessage(raw, { validate: this.#validateEvents });
+    if (!result.ok) {
+      this.#emit("invalidMessage", result);
+      return;
+    }
+    const { event } = result;
+    this.#dispatch(event.Event, [event.Data, event]);
+    for (const listener of [...this.#anyListeners]) {
+      this.#invoke("*", listener, [event]);
+    }
+  }
+  /**
+   * Listens to a game event (e.g. `'GoalScored'`) or a lifecycle event (e.g. `'connect'`).
+   * The listener's arguments are typed from the event name.
+   *
+   * @returns A function that removes the listener.
+   */
+  on(name, listener) {
+    let set = this.#listeners.get(name);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.#listeners.set(name, set);
+    }
+    set.add(listener);
+    return () => this.off(name, listener);
+  }
+  /** Like {@link on}, but the listener is removed after its first call. */
+  once(name, listener) {
+    const wrapper = ((...args) => {
+      unsubscribe();
+      listener(...args);
+    });
+    const unsubscribe = this.on(name, wrapper);
+    return unsubscribe;
+  }
+  /** Removes a listener added with {@link on}. */
+  off(name, listener) {
+    this.#listeners.get(name)?.delete(listener);
+  }
+  /**
+   * Listens to **every** game event. The argument is a discriminated union: narrow it with `event.Event`.
+   *
+   * ```ts
+   * client.onAny((event) => {
+   *   if (event.Event === 'StatfeedEvent') console.log(event.Data.EventName);
+   * });
+   * ```
+   *
+   * @returns A function that removes the listener.
+   */
+  onAny(listener) {
+    this.#anyListeners.add(listener);
+    return () => this.offAny(listener);
+  }
+  /** Removes a listener added with {@link onAny}. */
+  offAny(listener) {
+    this.#anyListeners.delete(listener);
+  }
+  /** Removes every listener, or every listener of one name. */
+  removeAllListeners(name) {
+    if (name === void 0) {
+      this.#listeners.clear();
+      this.#anyListeners.clear();
+    } else {
+      this.#listeners.delete(name);
+    }
+  }
+  /**
+   * Resolves with the payload of the next occurrence of a game event.
+   * Rejects after `timeout` ms if provided.
+   */
+  waitFor(name, options = {}) {
+    return new Promise((resolve, reject) => {
+      let timer;
+      const unsubscribe = this.once(name, ((data) => {
+        if (timer) clearTimeout(timer);
+        resolve(data);
+      }));
+      if (options.timeout !== void 0) {
+        timer = setTimeout(() => {
+          unsubscribe();
+          reject(new Error(`Timed out after ${options.timeout}ms waiting for "${name}".`));
+        }, options.timeout);
+      }
+    });
+  }
+  #emit(name, ...args) {
+    this.#dispatch(name, args);
+  }
+  #dispatch(name, args) {
+    const set = this.#listeners.get(name);
+    if (!set) return;
+    for (const listener of [...set]) {
+      this.#invoke(name, listener, args);
+    }
+  }
+  #invoke(name, listener, args) {
+    try {
+      listener(...args);
+    } catch (cause) {
+      if (name === "error") return;
+      this.#emitError(new ListenerError(name, cause));
+    }
+  }
+  /** Errors are only reported to `error` listeners; without one they are silently dropped. */
+  #emitError(error) {
+    this.#emit("error", error);
+  }
+  send(commandOrEnvelope, maybeData) {
+    const [command, data] = typeof commandOrEnvelope === "string" ? [commandOrEnvelope, maybeData] : isRecord(commandOrEnvelope) ? [commandOrEnvelope.Command, commandOrEnvelope.Data] : [commandOrEnvelope, void 0];
+    if (!isCommandName(command)) {
+      throw new CommandValidationError(`Unknown command "${String(command)}".`, command, data);
+    }
+    if (!isCommandData(command, data)) {
+      throw new CommandValidationError(`Invalid payload for command "${command}".`, command, data);
+    }
+    const envelope = { Command: command, Data: data };
+    if (!isStatsApiCommand(envelope)) {
+      throw new CommandValidationError(`Invalid command envelope for "${command}".`, command, data);
+    }
+    const socket = this.#socket;
+    if (!socket || !this.isConnected) throw new NotConnectedError();
+    socket.send(JSON.stringify(envelope));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BALL_UNTOUCHED_TEAM_NUM,
+  COMMAND_NAMES,
+  CommandValidationError,
+  ConnectionError,
+  EVENT_NAMES,
+  ListenerError,
+  NotConnectedError,
+  PERSPECTIVES,
+  RocketLeagueStatsClient,
+  StatsApiError,
+  Team,
+  allOf,
+  arrayOf,
+  commandDataGuards,
+  eventDataGuards,
+  isBallHitData,
+  isBallLastTouch,
+  isBoolean,
+  isBoostPickupData,
+  isChangePOVData,
+  isClockUpdatedSecondsData,
+  isCommandData,
+  isCommandName,
+  isCountdownBeginData,
+  isCrossbarHitData,
+  isEventData,
+  isEventName,
+  isFocus,
+  isGame,
+  isGameBall,
+  isGameTeam,
+  isGoalReplayEndData,
+  isGoalReplayStartData,
+  isGoalReplayWillEndData,
+  isGoalScoredData,
+  isInteger,
+  isLoadReplayData,
+  isMatchCreatedData,
+  isMatchDestroyedData,
+  isMatchEndedData,
+  isMatchInitializedData,
+  isMatchPausedData,
+  isMatchUnpausedData,
+  isNumber,
+  isPerspective,
+  isPlayer,
+  isPlayerJoinedData,
+  isPlayerLeftData,
+  isPlayerRef,
+  isPodiumStartData,
+  isRawEventEnvelope,
+  isRecord,
+  isReplayCreatedData,
+  isRoundStartedData,
+  isSeekReplayData,
+  isSetGameSpeedData,
+  isSetHUDVisibilityData,
+  isSetMatchPausedData,
+  isStatfeedEventData,
+  isStatsApiCommand,
+  isStatsApiEvent,
+  isString,
+  isUpdateStateData,
+  isVector,
+  oneOf,
+  optional,
+  parseEventMessage,
+  shape
+});
+//# sourceMappingURL=index.cjs.map