nhle-api 0.5.4 → 0.6.0

package/lib/toolkit.js

@@ -0,0 +1,1194 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/constants/edge-adv.ts
+var edge_adv_exports = {};
+__export(edge_adv_exports, {
+  PositionFilterEnum: () => PositionFilterEnum,
+  SaveLocationCategoryEnum: () => SaveLocationCategoryEnum,
+  SaveLocationSortEnum: () => SaveLocationSortEnum,
+  SavePercentage5v5SortEnum: () => SavePercentage5v5SortEnum,
+  SavePercentageSortEnum: () => SavePercentageSortEnum,
+  ShotLocationCategoryEnum: () => ShotLocationCategoryEnum,
+  ShotLocationSortEnum: () => ShotLocationSortEnum,
+  ShotSpeedSortEnum: () => ShotSpeedSortEnum,
+  SkatersStrengthEnum: () => SkatersStrengthEnum,
+  SkatingDistanceSortEnum: () => SkatingDistanceSortEnum,
+  SkatingSpeedSortEnum: () => SkatingSpeedSortEnum,
+  ZoneTimeSortEnum: () => ZoneTimeSortEnum
+});
+var SaveLocationCategoryEnum = {
+  /** Save Percentage */
+  "SV%": "save-pctg",
+  /** Saves */
+  SV: "saves",
+  /** Shots Against */
+  SA: "shots-against",
+  /** Goals Against */
+  GA: "goals-against"
+};
+var ShotLocationSortEnum = {
+  /** All shot locations */
+  ALL: "all",
+  /** High-danger (i.e. close-range) shot locations */
+  HIGH: "high",
+  /** Mid-range shot locations */
+  MID: "mid",
+  /** Long-range shot locations */
+  LONG: "long"
+};
+var SaveLocationSortEnum = ShotLocationSortEnum;
+var SavePercentage5v5SortEnum = {
+  /**5v5 Save %: The percentage of shots a goalie stops at even strength (5-on-5). */
+  "5v5-SV%": "save-pctg",
+  /**5v5 Save % in Close Situations: A “close situation” is the time during which a game is tied in the first or second period, or within one goal in the third period. This stats helps how goalies perform in high-pressure situations.*/
+  "5v5-SV%-Close": "save-pctg-close",
+  /**5v5 Shots Against: The total number of shots a goalie faces at even strength (5-on-5).*/
+  "5v5-SA": "shots",
+  /**5v5 Shots Against per 60 Minutes: The total number of shots a goalie faces at even strength (5-on-5) normalized to a 60-minute game. */
+  "5v5-SA/60": "shots-per-60"
+};
+var SavePercentageSortEnum = {
+  /** Starts above .900 */
+  GAMES: "games",
+  /** Percentage of starts above .900 */
+  PCTG: "pctg"
+};
+var PositionFilterEnum = {
+  /** Center */
+  ALL: "all",
+  /** Left Wing */
+  FWD: "forwards",
+  /** Right Wing */
+  DEF: "defense"
+};
+var SkatersStrengthEnum = {
+  /** All strengths */
+  ALL: "all",
+  /** Even strength */
+  ES: "es",
+  /** Power play */
+  PP: "pp",
+  /** Short-handed */
+  PK: "pk"
+};
+var ShotSpeedSortEnum = {
+  /** Hardest shot recorded by player */
+  MAX: "max",
+  /** Shots over 100 mph */
+  "OVER-100": "over-100",
+  /** Shots between 90 and 99 mph */
+  "90-99": "90-99",
+  /** Shots between 80 and 89 mph */
+  "80-89": "80-89",
+  /** Shots between 70 and 79 mph */
+  "70-79": "70-79"
+};
+var SkatingSpeedSortEnum = {
+  /** Fastest skating speed recorded by player */
+  TOP: "max",
+  /** Speed bursts recorded over 22 mph */
+  "OVER-22": "over-22",
+  /** Speed bursts recorded between 20 and 22 mph */
+  "20-22": "20-22",
+  /** Speed bursts recorded between 18 and 20 mph */
+  "18-20": "18-20"
+};
+var SkatingDistanceSortEnum = {
+  /** Total distance skated */
+  TOTAL: "total",
+  /** Average distance skated per 60 minutes */
+  "PER-60": "per-60",
+  /** Maximum distance skated in a single period */
+  "MAX-PERIOD": "max-period",
+  /** Maximum distance skated in a single game */
+  "MAX-GAME": "max-game"
+};
+var ShotLocationCategoryEnum = {
+  /** Total shots on goal */
+  SOG: "sog",
+  /** Total goals */
+  G: "goals",
+  /** Shooting percentage */
+  "SH%": "shooting-pctg"
+};
+var ZoneTimeSortEnum = {
+  /** Percentage of time spent in the offensive zone */
+  OZ: "offensive",
+  /** Percentage of time spent in the defensive zone */
+  DZ: "defensive",
+  /** Percentage of time spent in the neutral zone */
+  NZ: "neutral"
+};
+
+// src/constants/nhl.ts
+var nhl_exports = {};
+__export(nhl_exports, {
+  CURRENT: () => CURRENT,
+  END_SEASON: () => END_SEASON,
+  END_YEAR: () => END_YEAR,
+  GameStateEnum: () => GameStateEnum,
+  GameTypeEnum: () => GameTypeEnum,
+  InactiveTeamsEnum: () => InactiveTeamsEnum,
+  InactiveTeamsReverseEnum: () => InactiveTeamsReverseEnum,
+  PLAYER_ID_RANGE: () => PLAYER_ID_RANGE,
+  PeriodTypeEnum: () => PeriodTypeEnum,
+  PlayoffSeriesEnum: () => PlayoffSeriesEnum,
+  SEASON_RANGE: () => SEASON_RANGE,
+  START_SEASON: () => START_SEASON,
+  START_YEAR: () => START_YEAR,
+  SeasonsArray: () => SeasonsArray,
+  SeriesLetterByRound: () => SeriesLetterByRound,
+  SeriesLetterEnum: () => SeriesLetterEnum,
+  TEAM_ID_RANGE: () => TEAM_ID_RANGE,
+  TeamsEnum: () => TeamsEnum,
+  TeamsReverseEnum: () => TeamsReverseEnum,
+  YEAR_RANGE: () => YEAR_RANGE
+});
+
+// src/utils/date.ts
+var NHL_TIMEZONE = "America/New_York";
+var getNHLDate = (date) => new Intl.DateTimeFormat("en-CA", {
+  timeZone: NHL_TIMEZONE,
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit"
+}).format(date);
+var getCurrentNHLDate = () => getNHLDate(/* @__PURE__ */ new Date());
+var getNHLMonth = (date) => {
+  return new Intl.DateTimeFormat("en-CA", {
+    timeZone: NHL_TIMEZONE,
+    year: "numeric",
+    month: "2-digit"
+  }).format(date);
+};
+var getCurrentNHLMonth = () => getNHLMonth(/* @__PURE__ */ new Date());
+var getYear = (date) => new Intl.DateTimeFormat("en-CA", {
+  timeZone: NHL_TIMEZONE,
+  year: "numeric"
+}).format(date);
+var getCurrentNHLYear = () => getYear(/* @__PURE__ */ new Date());
+var getSeason = (date) => {
+  const format = new Intl.DateTimeFormat("en-CA", {
+    timeZone: NHL_TIMEZONE,
+    year: "numeric",
+    month: "numeric"
+  }).formatToParts(date instanceof Date ? date : new Date(date));
+  const month = format.find((part) => part.type === "month")?.value;
+  const year = format.find((part) => part.type === "year")?.value;
+  if (!year) {
+    throw new Error("Invalid date provided, could not extract year");
+  }
+  if (month && parseInt(month, 10) < 7) {
+    return `${parseInt(year, 10) - 1}${year}`;
+  }
+  return `${year}${parseInt(year, 10) + 1}`;
+};
+var getCurrentSeason = () => getSeason(/* @__PURE__ */ new Date());
+var NHL_START_DATE = /* @__PURE__ */ new Date("1917-12-01");
+var NHL_END_DATE = /* @__PURE__ */ new Date(
+  `${getCurrentSeason().slice(4, 8)}-06-30`
+);
+
+// src/constants/nhl.ts
+var TeamsEnum = {
+  /** Anaheim Ducks */
+  ANA: 24,
+  /** Boston Bruins */
+  BOS: 6,
+  /** Buffalo Sabres */
+  BUF: 7,
+  /** Calgary Flames */
+  CGY: 20,
+  /** Carolina Hurricanes */
+  CAR: 12,
+  /** Chicago Blackhawks */
+  CHI: 16,
+  /** Colorado Avalanche */
+  COL: 21,
+  /** Columbus Blue Jackets */
+  CBJ: 29,
+  /** Dallas Stars */
+  DAL: 25,
+  /** Detroit Red Wings */
+  DET: 17,
+  /** Edmonton Oilers */
+  EDM: 22,
+  /** Florida Panthers */
+  FLA: 13,
+  /** Los Angeles Kings */
+  LAK: 26,
+  /** Minnesota Wild*/
+  MIN: 30,
+  /** Montreal Canadiens */
+  MTL: 8,
+  /** New Jersey Devils */
+  NJD: 1,
+  /** Nashville Predators */
+  NSH: 18,
+  /** New York Islanders */
+  NYI: 2,
+  /** New York Rangers */
+  NYR: 3,
+  /** Ottawa Senators */
+  OTT: 9,
+  /** Philadelphia Flyers */
+  PHI: 4,
+  /** Pittsburgh Penguins */
+  PIT: 5,
+  /** San Jose Sharks */
+  SJS: 28,
+  /** Seattle Kraken */
+  SEA: 55,
+  /** St. Louis Blues */
+  STL: 19,
+  /** Tampa Bay Lightning */
+  TBL: 14,
+  /** Toronto Maple Leafs */
+  TOR: 10,
+  /** Utah Hockey Club */
+  UTA: 59,
+  /** Vancouver Canucks */
+  VAN: 23,
+  /** Vegas Golden Knights */
+  VGK: 54,
+  /** Winnipeg Jets */
+  WPG: 52,
+  /** Washington Capitals */
+  WSH: 15
+};
+var TeamsReverseEnum = Object.fromEntries(
+  Object.entries(TeamsEnum).map(([key, value]) => [value, key])
+);
+var InactiveTeamsEnum = {
+  /** Atlanta Flames (not active) */
+  AFM: 47,
+  /** Arizona Coyotes (not active) */
+  ARI: 53,
+  /** Atlanta Thrashers (not active) */
+  ATL: 11,
+  /**  Brooklyn Americans - (not active) */
+  BRK: 51,
+  /** California Golden Seals (aka Bay Area Seals) - (not active) */
+  CGS: 56,
+  /** Cleveland Barons - (not active) */
+  CLE: 49,
+  /** Colorado Rockies - (not active) */
+  CLR: 35,
+  /** Detroit Cougars - (not active) */
+  DCG: 40,
+  /** Detroit Falcons - (not active) */
+  DFL: 50,
+  /** Hamilton Tigers - (not active) */
+  HAM: 37,
+  /** Hartford Whalers - (not active) */
+  HFD: 34,
+  /** Kansas City Scouts - (not active) */
+  KCS: 48,
+  /** Montreal Maroons - (not active) */
+  MMR: 43,
+  /** Minnesota North Stars - (not active) */
+  MNS: 31,
+  /** Montreal Wanderers - (not active) */
+  MWN: 41,
+  /** New York Americans - (not active) */
+  NYA: 44,
+  /** California Seals (aka Oakland Seals) - (not active) */
+  OAK: 46,
+  /** Phoenix Coyotes - (not active) */
+  PHX: 27,
+  /** Pittsburgh Pirates - (not active) */
+  PIR: 38,
+  /** Quebec Bulldogs - (not active) */
+  QBD: 42,
+  /** Philadelphia Quakers - (not active) */
+  QUA: 39,
+  /** Quebec Nordiques - (not active) */
+  QUE: 32,
+  /** Ottawa Senators (original franchise) - (not active) */
+  SEN: 36,
+  /** St. Louis Eagles - (not active) */
+  SLE: 45,
+  /** Toronto Hockey Club (aka Toronto Arenas) - (not active) */
+  TAN: 57,
+  /** Toronto St. Patricks - (not active) */
+  TSP: 58,
+  /** Winnipeg Jets (original franchise) - (not active) */
+  WIN: 33
+};
+var InactiveTeamsReverseEnum = Object.fromEntries(
+  Object.entries(InactiveTeamsEnum).map(([key, value]) => [value, key])
+);
+var SeasonsArray = [
+  19171918,
+  19181919,
+  19191920,
+  19201921,
+  19211922,
+  19221923,
+  19231924,
+  19241925,
+  19251926,
+  19261927,
+  19271928,
+  19281929,
+  19291930,
+  19301931,
+  19311932,
+  19321933,
+  19331934,
+  19341935,
+  19351936,
+  19361937,
+  19371938,
+  19381939,
+  19391940,
+  19401941,
+  19411942,
+  19421943,
+  19431944,
+  19441945,
+  19451946,
+  19461947,
+  19471948,
+  19481949,
+  19491950,
+  19501951,
+  19511952,
+  19521953,
+  19531954,
+  19541955,
+  19551956,
+  19561957,
+  19571958,
+  19581959,
+  19591960,
+  19601961,
+  19611962,
+  19621963,
+  19631964,
+  19641965,
+  19651966,
+  19661967,
+  19671968,
+  19681969,
+  19691970,
+  19701971,
+  19711972,
+  19721973,
+  19731974,
+  19741975,
+  19751976,
+  19761977,
+  19771978,
+  19781979,
+  19791980,
+  19801981,
+  19811982,
+  19821983,
+  19831984,
+  19841985,
+  19851986,
+  19861987,
+  19871988,
+  19881989,
+  19891990,
+  19901991,
+  19911992,
+  19921993,
+  19931994,
+  19941995,
+  19951996,
+  19961997,
+  19971998,
+  19981999,
+  19992e3,
+  20002001,
+  20012002,
+  20022003,
+  20032004,
+  20052006,
+  20062007,
+  20072008,
+  20082009,
+  20092010,
+  20102011,
+  20112012,
+  20122013,
+  20132014,
+  20142015,
+  20152016,
+  20162017,
+  20172018,
+  20182019,
+  20192020,
+  20202021,
+  20212022,
+  20222023,
+  20232024,
+  20242025,
+  20252026
+];
+var SeriesLetterEnum = {
+  /** Atlantic Division Round 1: D1 vs WC# */
+  A: "A",
+  /** Atlantic Division Round 1: D2 vs D3 */
+  B: "B",
+  /** Metropolitan Division Round 1: D1 vs WC# */
+  C: "C",
+  /** Metropolitan Division Round 1: D2 vs D3 */
+  D: "D",
+  /** Central Division Round 1: D1 vs WC# */
+  E: "E",
+  /** Central Division Round 1: D2 vs D3 */
+  F: "F",
+  /** Pacific Division Round 1: D1 vs WC# */
+  G: "G",
+  /** Pacific Division Round 1: D2 vs D3 */
+  H: "H",
+  /** Atlantic Division Round 2: Aw vs Bw */
+  I: "I",
+  /** Metropolitan Division Round 2: Cw vs Dw */
+  J: "J",
+  /** Central Division Round 2: Ew vs Fw */
+  K: "K",
+  /** Pacific Division Round 2: Gw vs Hw */
+  L: "L",
+  /** Eastern Conference Finals */
+  M: "M",
+  /** Western Conference Finals*/
+  N: "N",
+  /** Stanley Cup Finals */
+  O: "O"
+};
+var SeriesLetterByRound = {
+  R1: ["A", "B", "C", "D", "E", "F", "G", "H"],
+  R2: ["I", "J", "K", "L"],
+  CF: ["M", "N"],
+  SCF: ["O"]
+};
+var PlayoffSeriesEnum = {
+  Atlantic_R1_D1_vs_WC: "A",
+  Atlantic_R1_D2_vs_D3: "B",
+  Metropolitan_R1_D1_vs_WC: "C",
+  Metropolitan_R1_D2_vs_D3: "D",
+  Central_R1_D1_vs_WC: "E",
+  Central_R1_D2_vs_D3: "F",
+  Pacific_R1_D1_vs_WC: "G",
+  Pacific_R1_D2_vs_D3: "H",
+  Atlantic_R2_Aw_vs_Bw: "I",
+  Metropolitan_R2_Cw_vs_Dw: "J",
+  Central_R2_Ew_vs_Fw: "K",
+  Pacific_R2_Gw_vs_Hw: "L",
+  Eastern_Conference_Finals: "M",
+  Western_Conference_Finals: "N",
+  Stanley_Cup_Finals: "O"
+};
+var GameStateEnum = {
+  /** Future */
+  FUT: "FUT",
+  /** Live */
+  LIV: "LIV",
+  /** Finished */
+  FIN: "FIN"
+};
+var PeriodTypeEnum = {
+  /** Regulation */
+  REG: "REG",
+  /** Overtime */
+  OT: "OT",
+  /** Shootout */
+  SO: "SO"
+};
+var GameTypeEnum = {
+  /** Pre-season */
+  PRE: 1,
+  /** Regular season */
+  REG: 2,
+  /** Post-season (aka playoffs) */
+  POST: 3,
+  /** All-Star Game (unconfirmed) */
+  ASG: 4,
+  /** International (unconfirmed) */
+  INTL: 19
+};
+var SEASON_RANGE = {
+  START: SeasonsArray[0],
+  END: SeasonsArray.at(-1)
+};
+var START_SEASON = SEASON_RANGE.START;
+var END_SEASON = SEASON_RANGE.END;
+var YEAR_RANGE = {
+  START: parseInt(SEASON_RANGE.START.toString().slice(0, 4), 10),
+  END: parseInt(SEASON_RANGE.END.toString().slice(4, 8), 10)
+};
+var START_YEAR = YEAR_RANGE.START;
+var END_YEAR = YEAR_RANGE.END;
+var CURRENT = {
+  /** The season for today's date, so the default never goes stale. */
+  SEASON: Number(getCurrentSeason()),
+  YEAR: YEAR_RANGE.END
+};
+var PLAYER_ID_RANGE = { MIN: 8444e3, MAX: 8489999 };
+var TEAM_ID_RANGE = { MIN: 1, MAX: 59 };
+
+// src/constants/index.ts
+({ ...edge_adv_exports });
+
+// src/utils/cayenne-query-builder.ts
+var CayenneQueryBuilder = class {
+  conditions = [];
+  currentLogicalOp = "and";
+  groupStack = [];
+  /**
+   * Start a new logical group
+   * All subsequent conditions will be added to this group until endGroup() is called
+   * @returns This builder instance for chaining
+   * @example
+   * builder
+   *   .equals('field1', 'value1')
+   *   .group()
+   *   .equals('field2', 'value2')
+   *   .or()
+   *   .equals('field3', 'value3')
+   *   .endGroup()
+   *   // Generates: "field1=value1 and (field2=value2 or field3=value3)"
+   */
+  group() {
+    this.groupStack.push({
+      conditions: this.conditions,
+      logicalOp: this.currentLogicalOp
+    });
+    this.conditions = [];
+    this.currentLogicalOp = "and";
+    return this;
+  }
+  /**
+   * End the current logical group
+   * @returns This builder instance for chaining
+   * @throws Error if there's no open group
+   */
+  endGroup() {
+    if (this.groupStack.length === 0) {
+      throw new Error("Cannot end group: no open group found");
+    }
+    const groupConditions = this.conditions;
+    const parent = this.groupStack.pop();
+    if (!parent) {
+      throw new Error("Failed to restore parent context");
+    }
+    this.conditions = parent.conditions;
+    const groupLogicalOp = parent.logicalOp;
+    this.currentLogicalOp = parent.logicalOp;
+    const group = {
+      type: "group",
+      conditions: groupConditions,
+      logicalOp: groupLogicalOp
+    };
+    this.conditions.push(group);
+    return this;
+  }
+  /**
+   * Set the logical operator to AND for subsequent conditions
+   * @returns This builder instance for chaining
+   */
+  and() {
+    this.currentLogicalOp = "and";
+    return this;
+  }
+  /**
+   * Set the logical operator to OR for subsequent conditions
+   * @returns This builder instance for chaining
+   */
+  or() {
+    this.currentLogicalOp = "or";
+    return this;
+  }
+  /**
+   * Add an equality condition
+   * @param field - The field name to filter on
+   * @param value - The value to match
+   * @returns This builder instance for chaining
+   */
+  equals(field, value) {
+    this.conditions.push({
+      field,
+      operator: "=",
+      value,
+      logicalOp: this.currentLogicalOp
+    });
+    return this;
+  }
+  /**
+   * Add a not-equal condition
+   * @param field - The field name to filter on
+   * @param value - The value to exclude
+   * @returns This builder instance for chaining
+   */
+  notEquals(field, value) {
+    this.conditions.push({
+      field,
+      operator: "!=",
+      value,
+      logicalOp: this.currentLogicalOp
+    });
+    return this;
+  }
+  /**
+   * Add a less-than condition
+   * @param field - The field name to filter on
+   * @param value - The upper bound (exclusive)
+   * @returns This builder instance for chaining
+   */
+  lessThan(field, value) {
+    this.conditions.push({
+      field,
+      operator: "<",
+      value,
+      logicalOp: this.currentLogicalOp
+    });
+    return this;
+  }
+  /**
+   * Add a greater-than condition
+   * @param field - The field name to filter on
+   * @param value - The lower bound (exclusive)
+   * @returns This builder instance for chaining
+   */
+  greaterThan(field, value) {
+    this.conditions.push({
+      field,
+      operator: ">",
+      value,
+      logicalOp: this.currentLogicalOp
+    });
+    return this;
+  }
+  /**
+   * Add a less-than-or-equal condition
+   * @param field - The field name to filter on
+   * @param value - The upper bound (inclusive)
+   * @returns This builder instance for chaining
+   */
+  lessThanOrEqual(field, value) {
+    this.conditions.push({
+      field,
+      operator: "<=",
+      value,
+      logicalOp: this.currentLogicalOp
+    });
+    return this;
+  }
+  /**
+   * Add a greater-than-or-equal condition
+   * @param field - The field name to filter on
+   * @param value - The lower bound (inclusive)
+   * @returns This builder instance for chaining
+   */
+  greaterThanOrEqual(field, value) {
+    this.conditions.push({
+      field,
+      operator: ">=",
+      value,
+      logicalOp: this.currentLogicalOp
+    });
+    return this;
+  }
+  /**
+   * Add an IN condition to match multiple values
+   * @param field - The field name to filter on
+   * @param values - Array of values to match against
+   * @returns This builder instance for chaining
+   * @example
+   * builder.in('playerId', [8476791, 8477933, 8478402])
+   * // Generates: "playerId in (8476791, 8477933, 8478402)"
+   */
+  in(field, values) {
+    if (values.length === 0) {
+      throw new Error("IN condition requires at least one value");
+    }
+    this.conditions.push({
+      field,
+      operator: "in",
+      value: values,
+      logicalOp: this.currentLogicalOp
+    });
+    return this;
+  }
+  /**
+   * Add a LIKE condition for pattern matching
+   * @param field - The field name to filter on
+   * @param pattern - The pattern to match (supports % for wildcards)
+   * @returns This builder instance for chaining
+   * @example
+   * builder.like('playerName', '%McDavid%')
+   * // Generates: "playerName like '%McDavid%'"
+   */
+  like(field, pattern) {
+    this.conditions.push({
+      field,
+      operator: "like",
+      value: pattern,
+      logicalOp: this.currentLogicalOp
+    });
+    return this;
+  }
+  /**
+   * Add a raw condition string
+   * Useful for complex expressions or unsupported operators
+   * @param condition - The raw condition string (e.g., "playerId=8476791")
+   * @returns This builder instance for chaining
+   */
+  raw(condition) {
+    this.conditions.push({
+      field: "__raw__",
+      operator: "=",
+      value: condition,
+      logicalOp: this.currentLogicalOp
+    });
+    return this;
+  }
+  /**
+   * Build the cayenneExp string
+   * @returns The formatted cayenneExp string ready for API consumption
+   */
+  build() {
+    if (this.groupStack.length > 0) {
+      throw new Error(
+        `Cannot build: ${this.groupStack.length} group(s) still open. Call endGroup() to close them.`
+      );
+    }
+    const buildExpression = (items, depth = 0) => {
+      return items.map((item, index) => {
+        let expr = "";
+        if ("type" in item && item.type === "group") {
+          const groupExpr = buildExpression(
+            item.conditions,
+            depth + 1
+          );
+          expr = `(${groupExpr})`;
+        } else if ("field" in item) {
+          const condition = item;
+          if (condition.field === "__raw__") {
+            expr = String(condition.value);
+          } else if (condition.operator === "in") {
+            const values = Array.isArray(condition.value) ? condition.value.join(", ") : condition.value;
+            expr = `${condition.field} in (${values})`;
+          } else if (condition.operator === "like") {
+            expr = `${condition.field} like '${condition.value}'`;
+          } else {
+            expr = `${condition.field}${condition.operator}${condition.value}`;
+          }
+        }
+        if (index < items.length - 1) {
+          const nextItem = items[index + 1];
+          if (nextItem) {
+            const nextLogicalOp = ("logicalOp" in nextItem ? nextItem.logicalOp : void 0) || "and";
+            expr += ` ${nextLogicalOp}`;
+          }
+        }
+        return expr;
+      }).join(" ");
+    };
+    return buildExpression(this.conditions);
+  }
+  /**
+   * Clear all conditions
+   * @returns This builder instance for chaining
+   */
+  clear() {
+    this.conditions = [];
+    return this;
+  }
+  /**
+   * Get the number of conditions currently in the builder
+   */
+  count() {
+    return this.conditions.length;
+  }
+};
+function createCayenneQuery() {
+  return new CayenneQueryBuilder();
+}
+function buildCayenneExp(filters) {
+  const builder = new CayenneQueryBuilder();
+  Object.entries(filters).forEach(([field, value]) => {
+    builder.equals(field, value);
+  });
+  return builder.build();
+}
+
+// src/utils/normalize.ts
+var alternateAbbreviations = {
+  CLS: "CBJ",
+  CAL: "CGY",
+  LA: "LAK",
+  "L.A": "LAK",
+  MON: "MTL",
+  NJ: "NJD",
+  "N.J": "NJD",
+  SJ: "SJS",
+  "S.J": "SJS",
+  TB: "TBL",
+  "T.B": "TBL",
+  UTAH: "UTA"
+  // confirm if the NHL has a standard for players with no team associated
+  // NA: 'N/A',
+  // '(N/A)': 'N/A',
+};
+var normalizeAbbrev = (abbrev) => {
+  const upperAbbrev = abbrev.toUpperCase();
+  return alternateAbbreviations[upperAbbrev] ?? upperAbbrev;
+};
+
+// src/utils/team-branding.ts
+var TEAM_BRANDING = {
+  ANA: {
+    name: "Anaheim Ducks",
+    primaryColor: "#F47A38",
+    colors: {
+      orange: "#F47A38",
+      metallicGold: "#B9975B",
+      silver: "#C1C6C8",
+      black: "#000000"
+    }
+  },
+  BOS: {
+    name: "Boston Bruins",
+    primaryColor: "#FFB81C",
+    colors: { gold: "#FFB81C", black: "#000000" }
+  },
+  BUF: {
+    name: "Buffalo Sabres",
+    primaryColor: "#003087",
+    colors: {
+      royalBlue: "#003087",
+      gold: "#FFB81C",
+      white: "#FFFFFF"
+    }
+  },
+  CGY: {
+    name: "Calgary Flames",
+    primaryColor: "#D2001C",
+    colors: { red: "#D2001C", yellow: "#FAAF19", white: "#FFFFFF" }
+  },
+  CAR: {
+    name: "Carolina Hurricanes",
+    primaryColor: "#CE1126",
+    colors: {
+      red: "#CE1126",
+      white: "#FFFFFF",
+      gray: "#A4A9AD",
+      black: "#000000"
+    }
+  },
+  CHI: {
+    name: "Chicago Blackhawks",
+    primaryColor: "#CF0A2C",
+    colors: {
+      red: "#CF0A2C",
+      orange: "#FF671B",
+      green: "#00833E",
+      yellow: "#FFD100",
+      tan: "#D18A00",
+      blue: "#001970",
+      black: "#000000",
+      white: "#FFFFFF"
+    }
+  },
+  COL: {
+    name: "Colorado Avalanche",
+    primaryColor: "#6F263D",
+    colors: {
+      burgundy: "#6F263D",
+      blue: "#236192",
+      silver: "#A2AAAD",
+      black: "#000000"
+    }
+  },
+  CBJ: {
+    name: "Columbus Blue Jackets",
+    primaryColor: "#002654",
+    colors: {
+      unionBlue: "#002654",
+      goalRed: "#CE1126",
+      capitalSilver: "#A4A9AD"
+    }
+  },
+  DAL: {
+    name: "Dallas Stars",
+    primaryColor: "#006847",
+    colors: {
+      victoryGreen: "#006847",
+      silver: "#8F8F8C",
+      black: "#111111"
+    }
+  },
+  DET: {
+    name: "Detroit Red Wings",
+    primaryColor: "#CE1126",
+    colors: { red: "#CE1126", white: "#FFFFFF" }
+  },
+  EDM: {
+    name: "Edmonton Oilers",
+    primaryColor: "#041E42",
+    colors: { blue: "#041E42", orange: "#FF4C00" }
+  },
+  FLA: {
+    name: "Florida Panthers",
+    primaryColor: "#041E42",
+    colors: { navy: "#041E42", red: "#C8102E", tan: "#B9975B" }
+  },
+  LAK: {
+    name: "Los Angeles Kings",
+    primaryColor: "#111111",
+    colors: { black: "#111111", silver: "#A2AAAD", white: "#FFFFFF" }
+  },
+  MIN: {
+    name: "Minnesota Wild",
+    primaryColor: "#A6192E",
+    colors: {
+      ironRangeRed: "#A6192E",
+      forestGreen: "#154734",
+      gold: "#EAAA00",
+      minnesotaWheat: "#DDCBA4"
+    }
+  },
+  MTL: {
+    name: "Montreal Canadiens",
+    primaryColor: "#AF1E2D",
+    colors: { red: "#AF1E2D", blue: "#192168" }
+  },
+  NJD: {
+    name: "New Jersey Devils",
+    primaryColor: "#CE1126",
+    colors: { red: "#CE1126", black: "#000000", white: "#FFFFFF" }
+  },
+  NSH: {
+    name: "Nashville Predators",
+    primaryColor: "#FFB81C",
+    colors: { gold: "#FFB81C", navyBlue: "#041E42", white: "#FFFFFF" }
+  },
+  NYI: {
+    name: "New York Islanders",
+    primaryColor: "#00539B",
+    colors: { blue: "#00539B", orange: "#F47D30" }
+  },
+  NYR: {
+    name: "New York Rangers",
+    primaryColor: "#0038A8",
+    colors: { blue: "#0038A8", red: "#CE1126", white: "#FFFFFF" }
+  },
+  OTT: {
+    name: "Ottawa Senators",
+    primaryColor: "#000000",
+    colors: {
+      black: "#000000",
+      red: "#DA1A32",
+      gold: "#B79257",
+      white: "#FFFFFF"
+    }
+  },
+  PHI: {
+    name: "Philadelphia Flyers",
+    primaryColor: "#F74902",
+    colors: {
+      flyersOrange: "#F74902",
+      black: "#000000",
+      white: "#FFFFFF"
+    }
+  },
+  PIT: {
+    name: "Pittsburgh Penguins",
+    primaryColor: "#000000",
+    colors: {
+      black: "#000000",
+      gold: "#CFC493",
+      yellow: "#FCB514",
+      white: "#FFFFFF"
+    }
+  },
+  SJS: {
+    name: "San Jose Sharks",
+    primaryColor: "#006D75",
+    colors: {
+      teal: "#006D75",
+      orange: "#EA7200",
+      black: "#000000",
+      white: "#FFFFFF"
+    }
+  },
+  SEA: {
+    name: "Seattle Kraken",
+    primaryColor: "#001628",
+    colors: {
+      deepSeaBlue: "#001628",
+      iceBlue: "#99D9D9",
+      boundlessBlue: "#355464",
+      shadowBlue: "#68A2B9",
+      redAlert: "#E9072B"
+    }
+  },
+  STL: {
+    name: "St. Louis Blues",
+    primaryColor: "#002F87",
+    colors: {
+      blue: "#002F87",
+      yellow: "#FCB514",
+      navyBlue: "#041E42",
+      white: "#FFFFFF"
+    }
+  },
+  TBL: {
+    name: "Tampa Bay Lightning",
+    primaryColor: "#002868",
+    colors: { blue: "#002868", white: "#FFFFFF" }
+  },
+  TOR: {
+    name: "Toronto Maple Leafs",
+    primaryColor: "#00205B",
+    colors: { blue: "#00205B", white: "#FFFFFF" }
+  },
+  UTA: {
+    name: "Utah Mammoth",
+    primaryColor: "#69B3E7",
+    colors: {
+      mountainBlue: "#69B3E7",
+      rockBlack: "#010101",
+      saltWhite: "#FFFFFF"
+    }
+  },
+  VAN: {
+    name: "Vancouver Canucks",
+    primaryColor: "#00205B",
+    colors: {
+      blue: "#00205B",
+      green: "#00843D",
+      darkBlue: "#041C2C",
+      gray: "#99999A",
+      white: "#FFFFFF"
+    }
+  },
+  VGK: {
+    name: "Vegas Golden Knights",
+    primaryColor: "#B4975A",
+    colors: {
+      gold: "#B4975A",
+      steelGray: "#333F42",
+      red: "#C8102E",
+      black: "#000000",
+      white: "#FFFFFF"
+    }
+  },
+  WSH: {
+    name: "Washington Capitals",
+    primaryColor: "#041E42",
+    colors: { navy: "#041E42", red: "#C8102E", white: "#FFFFFF" }
+  },
+  WPG: {
+    name: "Winnipeg Jets",
+    primaryColor: "#041E42",
+    colors: {
+      navy: "#041E42",
+      blue: "#004C97",
+      red: "#AC162C",
+      maroon: "#7B303E",
+      darkGray: "#55565A",
+      silver: "#8E9090",
+      white: "#FFFFFF"
+    }
+  }
+};
+var HISTORICAL_TEAM_COLORS = {
+  ANA: {
+    period: "1993-2006",
+    colors: {
+      green: "#00685E",
+      purple: "#532A44",
+      yellow: "#FCC72C",
+      black: "#241E24"
+    }
+  },
+  ARI: {
+    period: "1996-2014",
+    colors: {
+      brickRed: "#8C2633",
+      green: "#154734",
+      desertSand: "#DDCBA4",
+      brown: "#A9431E",
+      purple: "#5F259F"
+    }
+  },
+  BUF: {
+    period: "2006-2020",
+    colors: {
+      navyBlue: "#002654",
+      yellow: "#FCB514",
+      silver: "#ADAFAA",
+      red: "#C8102E"
+    }
+  },
+  CGY: {
+    period: "1994-2020",
+    colors: {
+      red: "#C8102E",
+      gold: "#F1BE48",
+      black: "#111111",
+      white: "#FFFFFF"
+    }
+  },
+  LAK: {
+    period: "1967-1988",
+    colors: {
+      purple: "#572A84",
+      goldenYellow: "#FFC80C",
+      white: "#FFFFFF"
+    }
+  },
+  OTT: {
+    period: "2007-2020",
+    colors: {
+      red: "#C52032",
+      gold: "#C2912C",
+      black: "#000000",
+      white: "#FFFFFF"
+    }
+  }
+};
+var NHL_LOGO_ASSET_URL = "https://assets.nhle.com/logos/nhl/svg";
+function getTeamBranding(abbreviation) {
+  const normalized = normalizeAbbrev(
+    abbreviation
+  );
+  return TEAM_BRANDING[normalized];
+}
+function getTeamLogoUrl(abbreviation, options = {}) {
+  const normalized = normalizeAbbrev(
+    abbreviation
+  );
+  if (!getTeamBranding(normalized)) {
+    throw new RangeError(
+      `Unknown active NHL team abbreviation: ${abbreviation}`
+    );
+  }
+  const theme = options.theme ?? "light";
+  const secondary = options.secondary ? "_secondary" : "";
+  return `${NHL_LOGO_ASSET_URL}/${normalized}${secondary}_${theme}.svg`;
+}
+
+// src/utils/utils.ts
+function resolvePath(template, params) {
+  let resolvedPath = template;
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0) continue;
+    resolvedPath = resolvedPath.replace(`{${key}}`, String(value));
+  }
+  return resolvedPath;
+}
+
+export { CayenneQueryBuilder, HISTORICAL_TEAM_COLORS, nhl_exports as NHL, NHL_END_DATE, NHL_START_DATE, NHL_TIMEZONE, TEAM_BRANDING, buildCayenneExp, createCayenneQuery, getCurrentNHLDate, getCurrentNHLMonth, getCurrentNHLYear, getCurrentSeason, getNHLDate, getNHLMonth, getSeason, getTeamBranding, getTeamLogoUrl, getYear, normalizeAbbrev, resolvePath };
+//# sourceMappingURL=toolkit.js.map
+//# sourceMappingURL=toolkit.js.map