nhl-api-ts 0.1.0 → 0.2.1

package/dist/api/teams.mjs

@@ -5,7 +5,9 @@ async function fetchStandingsData(ctx, date) {
 }
 /** Converts a raw standings entry into a `Team`. */
 export function toTeam(teamData) {
-    const nestedDefault = (key) => teamData[key]?.default ?? '';
+    function nestedDefault(key) {
+        return teamData[key]?.default ?? '';
+    }
     return {
         conference: {
             abbr: teamData.conferenceAbbrev ?? '',
@@ -66,11 +68,11 @@ export function withFranchiseIds(teams, franchises) {
  * @param params.date Date in YYYY-MM-DD format. Defaults to "now".
  * @example await client.teams.teams()
  */
-export const teams = async (ctx, { date = 'now' } = {}) => {
+export async function teams(ctx, { date = 'now' } = {}) {
     const standingsData = await fetchStandingsData(ctx, date);
     const franchiseData = await franchises(ctx);
     return withFranchiseIds(standingsData.map(toTeam), franchiseData);
-};
+}
 /**
  * Get the roster for the given team and season.
  *
@@ -78,14 +80,16 @@ export const teams = async (ctx, { date = 'now' } = {}) => {
  * @param params.season Season in YYYYYYYY format, e.g. 20232024
  * @example https://api-web.nhle.com/v1/roster/BUF/20232024
  */
-export const teamRoster = async (ctx, { teamAbbr, season }) => (await ctx.get(Endpoint.API_WEB_V1, `roster/${teamAbbr}/${season}`)).json();
+export async function teamRoster(ctx, { teamAbbr, season }) {
+    return (await ctx.get(Endpoint.API_WEB_V1, `roster/${teamAbbr}/${season}`)).json();
+}
 /**
  * Get a list of all past and current NHL franchises.
  *
  * @example https://api.nhle.com/stats/rest/en/franchise
  */
-export const franchises = async (ctx) => {
+export async function franchises(ctx) {
     const response = await (await ctx.get(Endpoint.API_STATS, 'en/franchise')).json();
     return response.data ?? [];
-};
+}
 export const teamsApi = { teams, teamRoster, franchises };

package/dist/cli/colors.d.mts

@@ -1,7 +1,7 @@
 import { styleText } from 'node:util';
 export type Style = Parameters<typeof styleText>[0];
-export declare const toStdout: (format: Style) => (text: string) => string;
-export declare const toStderr: (format: Style) => (text: string) => string;
+export declare function toStdout(format: Style): (text: string) => string;
+export declare function toStderr(format: Style): (text: string) => string;
 export declare const colors: {
     dim: (text: string) => string;
     pass: (text: string) => string;

package/dist/cli/colors.mjs

@@ -1,6 +1,10 @@
 import { styleText } from 'node:util';
-export const toStdout = (format) => (text) => styleText(format, text, { stream: process.stdout });
-export const toStderr = (format) => (text) => styleText(format, text, { stream: process.stderr });
+export function toStdout(format) {
+    return (text) => styleText(format, text, { stream: process.stdout });
+}
+export function toStderr(format) {
+    return (text) => styleText(format, text, { stream: process.stderr });
+}
 export const colors = {
     dim: toStdout('dim'),
     pass: toStdout(['bold', 'green']),

package/dist/cli/commands.mjs

@@ -5,7 +5,9 @@ import { SKATER_REPORT_TYPES } from '#src/api/query/sorting/sorting-options.mjs'
 export class UsageError extends Error {
 }
 // ---- Reusable argument specs ------------------------------------------------
-const req = (spec) => ({ ...spec, required: true });
+function req(spec) {
+    return { ...spec, required: true };
+}
 const teamAbbr = req({
     name: 'teamAbbr',
     type: 'string',
@@ -26,11 +28,13 @@ const playerId = req({
     type: 'string',
     description: 'NHL player id, e.g. 8478402',
 });
-const date = (description = 'Date in YYYY-MM-DD format') => ({
-    name: 'date',
-    type: 'string',
-    description,
-});
+function date(description = 'Date in YYYY-MM-DD format') {
+    return {
+        name: 'date',
+        type: 'string',
+        description,
+    };
+}
 const gameTypeId = {
     name: 'gameTypeId',
     type: 'int',
@@ -48,29 +52,35 @@ const start = {
     description: 'Pagination offset',
     default: '0',
 };
-const limit = (def) => ({
-    name: 'limit',
-    type: 'int',
-    description: 'Max results',
-    default: def,
-});
-const factCayenneExp = (def) => ({
-    name: 'factCayenneExp',
-    type: 'string',
-    description: 'Base fact filter expression',
-    default: def,
-});
+function limit(def) {
+    return {
+        name: 'limit',
+        type: 'int',
+        description: 'Max results',
+        default: def,
+    };
+}
+function factCayenneExp(def) {
+    return {
+        name: 'factCayenneExp',
+        type: 'string',
+        description: 'Base fact filter expression',
+        default: def,
+    };
+}
 const defaultCayenneExp = {
     name: 'defaultCayenneExp',
     type: 'string',
     description: 'Overrides the generated cayenneExp filter entirely',
 };
-const apiSleepRate = (def) => ({
-    name: 'apiSleepRate',
-    type: 'number',
-    description: 'Seconds to sleep between per-team requests',
-    default: def,
-});
+function apiSleepRate(def) {
+    return {
+        name: 'apiSleepRate',
+        type: 'number',
+        description: 'Seconds to sleep between per-team requests',
+        default: def,
+    };
+}
 // ---- Edge -------------------------------------------------------------------
 const edgeSeasonArgs = [
     { ...season, description: `${season.description}. Defaults to current` },
@@ -81,7 +91,7 @@ const edgeSeasonArgs = [
         default: '2',
     },
 ];
-const edgeCommand = (name, method, idKind, description) => {
+function edgeCommand(name, method, idKind, description) {
     const idArg = idKind === 'player'
         ? [playerId]
         : idKind === 'team'
@@ -101,7 +111,7 @@ const edgeCommand = (name, method, idKind, description) => {
         // biome-ignore lint/suspicious/noExplicitAny: dispatch by method name
         client.edge[method].call(client.edge, values),
     };
-};
+}
 // ---- Stats query-context filters --------------------------------------------
 const queryFilterArgs = [
     {

package/dist/cli/run.mjs

@@ -5,7 +5,9 @@ import { MODULES, UsageError, } from '#src/cli/commands.mjs';
 import { NHLApiException } from '#src/errors.mjs';
 import { createNHLClient } from '#src/nhl-client.mjs';
 const BIN = 'nhl-api-ts';
-const kebab = (name) => name.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
+function kebab(name) {
+    return name.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
+}
 const GLOBAL_OPTIONS = {
     help: { type: 'boolean', short: 'h' },
     version: { type: 'boolean', short: 'v' },
@@ -84,7 +86,7 @@ function commandHelp(mod, cmd) {
     ]
         .filter(Boolean)
         .join(' ');
-    const describe = (arg) => {
+    function describe(arg) {
         const extras = [
             arg.choices ? `one of: ${arg.choices.join(', ')}` : '',
             arg.default !== undefined ? `default: ${arg.default}` : '',
@@ -92,7 +94,7 @@ function commandHelp(mod, cmd) {
         return extras.length
             ? `${arg.description} (${extras.join('; ')})`
             : arg.description;
-    };
+    }
     const sections = [`Usage: ${usage}`, cmd.description];
     if (required.length) {
         sections.push(`Arguments (positional, or as flags):\n${table(required.map((arg) => [
@@ -250,10 +252,10 @@ export async function runCli(argv, io) {
     const [moduleName, commandName] = findTargets(argv);
     const mod = MODULES.find((moduleSpec) => moduleSpec.name === moduleName);
     const cmd = mod?.commands.find((command) => command.name === commandName);
-    const usageError = (message, help) => {
+    function usageError(message, help) {
         io.stderr(`${colors.error(`error: ${message}`)}\n\n${help}`);
         return 2;
-    };
+    }
     let parsed;
     try {
         parsed = parseCommand(argv, cmd);

package/dist/http-client.mjs

@@ -73,11 +73,11 @@ export async function readErrorMessage(response, url) {
  * @throws NHLApiException For other unexpected errors
  */
 export function createGet(config) {
-    const debug = (message) => {
+    function debug(message) {
         if (config.debug) {
             console.error(`nhl-api-ts.http_client - DEBUG - ${message}`);
         }
-    };
+    }
     return async (endpoint, resource, queryParams) => {
         const fullUrl = buildUrl(endpoint, resource, queryParams);
         debug(`GET: ${fullUrl}`);

package/dist/index.d.mts

@@ -18,4 +18,5 @@ export type { Context, Get } from '#src/context.mjs';
 export * from '#src/errors.mjs';
 export { buildUrl, createGet, Endpoint, type QueryParams, type QueryParamValue, } from '#src/http-client.mjs';
 export { createNHLClient, type NHLClient } from '#src/nhl-client.mjs';
-export type { Id, JsonObject } from '#src/utils.mjs';
+export type * from '#src/types/index.mjs';
+export type { Id } from '#src/utils.mjs';

package/dist/nhl-client.d.mts

@@ -1,8 +1,20 @@
+import { type GoalieStatsSummaryParams, type SkaterStatsWithQueryContextParams, statsApi } from '#src/api/stats.mjs';
 import { type ClientOptions } from '#src/config.mjs';
 import type { Context } from '#src/context.mjs';
+import type { GoalieReportRows, SkaterReportRows, StatsApiPage } from '#src/types/index.mjs';
 type Bound<Module> = {
     [Method in keyof Module]: Module[Method] extends (ctx: Context, ...args: infer Args) => infer MethodResponse ? (...args: Args) => MethodResponse : never;
 };
+/**
+ * `Bound` erases generic parameters, so the report-typed stats methods are
+ * spelled out here (without `ctx`) to keep `reportType` / `statsType`
+ * flowing into the row type.
+ */
+interface StatsGenericMethods {
+    skaterStatsWithQueryContext<Report extends keyof SkaterReportRows>(params: SkaterStatsWithQueryContextParams<Report>): Promise<StatsApiPage<SkaterReportRows[Report]>>;
+    goalieStatsSummary<Report extends keyof GoalieReportRows = 'summary'>(params: GoalieStatsSummaryParams<Report>): Promise<GoalieReportRows[Report][]>;
+}
+type StatsClient = Omit<Bound<typeof statsApi>, 'skaterStatsWithQueryContext' | 'goalieStatsSummary'> & StatsGenericMethods;
 /**
  * Builds the main client used to access the NHL API.
  *
@@ -11,7 +23,7 @@ type Bound<Module> = {
  * const client = createNHLClient({ debug: true }); // for a lil extra logging
  * const teams = await client.teams.teams();
  */
-export declare const createNHLClient: (options?: ClientOptions) => {
+export declare function createNHLClient(options?: ClientOptions): {
     readonly config: Readonly<import("#src/config.mjs").Config>;
     readonly teams: Bound<{
         readonly teams: typeof import("#src/api/teams.mjs").teams;
@@ -42,15 +54,7 @@ export declare const createNHLClient: (options?: ClientOptions) => {
         readonly seasonSeriesMatchup: typeof import("#src/api/game-center.mjs").seasonSeriesMatchup;
         readonly gameStory: typeof import("#src/api/game-center.mjs").gameStory;
     }>;
-    readonly stats: Bound<{
-        readonly gametypesPerSeasonDirectoryByTeam: typeof import("#src/api/stats.mjs").gametypesPerSeasonDirectoryByTeam;
-        readonly playerCareerStats: typeof import("#src/api/stats.mjs").playerCareerStats;
-        readonly playerGameLog: typeof import("#src/api/stats.mjs").playerGameLog;
-        readonly teamSummary: typeof import("#src/api/stats.mjs").teamSummary;
-        readonly skaterStatsSummary: typeof import("#src/api/stats.mjs").skaterStatsSummary;
-        readonly skaterStatsWithQueryContext: typeof import("#src/api/stats.mjs").skaterStatsWithQueryContext;
-        readonly goalieStatsSummary: typeof import("#src/api/stats.mjs").goalieStatsSummary;
-    }>;
+    readonly stats: StatsClient;
     readonly misc: Bound<{
         readonly glossary: typeof import("#src/api/misc.mjs").glossary;
         readonly config: typeof import("#src/api/misc.mjs").config;

package/dist/nhl-client.mjs

@@ -5,15 +5,17 @@ import { miscApi } from '#src/api/misc.mjs';
 import { playersApi } from '#src/api/players.mjs';
 import { scheduleApi } from '#src/api/schedule.mjs';
 import { standingsApi } from '#src/api/standings.mjs';
-import { statsApi } from '#src/api/stats.mjs';
+import { statsApi, } from '#src/api/stats.mjs';
 import { teamsApi } from '#src/api/teams.mjs';
 import { resolveConfig } from '#src/config.mjs';
 import { createGet } from '#src/http-client.mjs';
 import { sleep } from '#src/utils.mjs';
-const bind = (ctx, api) => Object.fromEntries(Object.entries(api).map(([key, fn]) => [
-    key,
-    (...args) => fn(ctx, ...args),
-]));
+function bind(ctx, api) {
+    return Object.fromEntries(Object.entries(api).map(([key, fn]) => [
+        key,
+        (...args) => fn(ctx, ...args),
+    ]));
+}
 /**
  * Builds the main client used to access the NHL API.
  *
@@ -22,7 +24,7 @@ const bind = (ctx, api) => Object.fromEntries(Object.entries(api).map(([key, fn]
  * const client = createNHLClient({ debug: true }); // for a lil extra logging
  * const teams = await client.teams.teams();
  */
-export const createNHLClient = (options = {}) => {
+export function createNHLClient(options = {}) {
     const config = resolveConfig(options);
     const ctx = { get: createGet(config), sleep };
     return {
@@ -37,4 +39,4 @@ export const createNHLClient = (options = {}) => {
         players: bind(ctx, playersApi),
         edge: bind(ctx, edgeApi),
     };
-};
+}

package/dist/types/common.d.mts

@@ -0,0 +1,80 @@
+/**
+ * A string union that still accepts values the SDK doesn't know about yet.
+ * Autocomplete lists `Known`, but a new value from the NHL doesn't break
+ * consumers.
+ */
+export type OpenUnion<Known extends string> = Known | (string & {});
+/** A name or label with optional translations; `default` is always present. */
+export interface LocalizedString {
+    default: string;
+    cs?: string;
+    de?: string;
+    es?: string;
+    fi?: string;
+    fr?: string;
+    sk?: string;
+    sv?: string;
+}
+/** 1 = preseason, 2 = regular season, 3 = playoffs. Other codes (4 = all-star) exist. */
+export type GameType = 1 | 2 | 3 | (number & {});
+/** Season in YYYYYYYY form, e.g. 20232024. */
+export type SeasonId = number;
+export type GameState = OpenUnion<'FUT' | 'PRE' | 'LIVE' | 'CRIT' | 'FINAL' | 'OFF'>;
+export type GameScheduleState = OpenUnion<'OK' | 'PPD' | 'SUSP' | 'CNCL' | 'TBD'>;
+export type PeriodType = OpenUnion<'REG' | 'OT' | 'SO'>;
+export type PositionCode = OpenUnion<'C' | 'L' | 'R' | 'D' | 'G'>;
+export type ShootsCatches = OpenUnion<'L' | 'R'>;
+export type ZoneCode = OpenUnion<'O' | 'N' | 'D'>;
+export type ShotType = OpenUnion<'wrist' | 'snap' | 'slap' | 'backhand' | 'tip-in' | 'deflected' | 'wrap-around' | 'bat'>;
+/** Envelope of the stats API (`api.nhle.com/stats/rest`) for paged reports. */
+export interface StatsApiPage<Row> {
+    data: Row[];
+    total: number;
+}
+export interface GameOutcome {
+    lastPeriodType: PeriodType;
+    otPeriods?: number;
+}
+export interface PeriodDescriptor {
+    number: number;
+    periodType: PeriodType;
+    maxRegulationPeriods: number;
+}
+export interface SeriesStatus {
+    round: number;
+    seriesAbbrev: string;
+    seriesTitle: string;
+    seriesLetter: string;
+    neededToWin: number;
+    topSeedTeamAbbrev: string;
+    topSeedWins: number;
+    bottomSeedTeamAbbrev: string;
+    bottomSeedWins: number;
+    gameNumberOfSeries: number;
+}
+export interface TeamLogo {
+    light: string;
+    dark: string;
+}
+export interface TvBroadcast {
+    id: number;
+    market: string;
+    countryCode: string;
+    network: string;
+    sequenceNumber: number;
+}
+export interface OddsPartner {
+    partnerId: number;
+    country: string;
+    name: string;
+    imageUrl: string;
+    siteUrl: string;
+    bgColor: string;
+    textColor: string;
+    accentColor: string;
+}
+/** A betting provider's price for one side of a game. */
+export interface TeamOdd {
+    providerId: number;
+    value: string;
+}

package/dist/types/common.mjs

@@ -0,0 +1,2 @@
+// Response types derived from live NHL API probing. See CONTRIBUTING.md.
+export {};