nhl-api-ts 0.0.0-stage → 0.1.0

package/dist/api/query/filters/game-type.mjs

@@ -0,0 +1,16 @@
+import { QueryBase } from '#src/api/query/filters/base.mjs';
+export class GameTypeQuery extends QueryBase {
+    gameType;
+    gameTypeQ = 'gameTypeId';
+    /** @param gameType 1=Preseason, 2=Regular season, 3=Playoffs */
+    constructor(gameType) {
+        super();
+        this.gameType = gameType;
+    }
+    toQuery() {
+        return `${this.gameTypeQ}=${this.gameType}`;
+    }
+    validate() {
+        return true;
+    }
+}

package/dist/api/query/filters/goalie-sorts.d.mts

@@ -0,0 +1,3 @@
+import type { SortExpr } from '#src/api/query/sorting/sorting-options.mjs';
+/** Default sorting criteria for goalie stats reports. */
+export declare function goalieStatsSorts(report: string): SortExpr[];

package/dist/api/query/filters/goalie-sorts.mjs

@@ -0,0 +1,55 @@
+/** Default sorting criteria for goalie stats reports. */
+export function goalieStatsSorts(report) {
+    switch (report) {
+        case 'summary':
+            return [
+                { property: 'wins', direction: 'DESC' },
+                { property: 'gamesPlayed', direction: 'ASC' },
+                { property: 'playerId', direction: 'ASC' },
+            ];
+        case 'advanced':
+            return [
+                { property: 'qualityStart', direction: 'DESC' },
+                { property: 'goalsAgainstAverage', direction: 'ASC' },
+                { property: 'playerId', direction: 'ASC' },
+            ];
+        case 'bios':
+            return [
+                { property: 'lastName', direction: 'ASC_CI' },
+                { property: 'goalieFullName', direction: 'ASC_CI' },
+                { property: 'playerId', direction: 'ASC' },
+            ];
+        case 'daysrest':
+            return [
+                { property: 'wins', direction: 'DESC' },
+                { property: 'savePct', direction: 'DESC' },
+                { property: 'playerId', direction: 'ASC' },
+            ];
+        case 'penaltyShots':
+            return [
+                { property: 'penaltyShotsSaves', direction: 'DESC' },
+                { property: 'penaltyShotSavePct', direction: 'DESC' },
+                { property: 'playerId', direction: 'ASC' },
+            ];
+        case 'savesByStrength':
+            return [
+                { property: 'wins', direction: 'DESC' },
+                { property: 'savePct', direction: 'DESC' },
+                { property: 'playerId', direction: 'ASC' },
+            ];
+        case 'shootout':
+            return [
+                { property: 'shootoutWins', direction: 'DESC' },
+                { property: 'shootoutSavePct', direction: 'DESC' },
+                { property: 'playerId', direction: 'ASC' },
+            ];
+        case 'startedVsRelieved':
+            return [
+                { property: 'gamesStarted', direction: 'DESC' },
+                { property: 'gamesStartedSavePct', direction: 'DESC' },
+                { property: 'playerId', direction: 'ASC' },
+            ];
+        default:
+            return [{}];
+    }
+}

package/dist/api/query/filters/home-road.d.mts

@@ -0,0 +1,9 @@
+import { QueryBase } from '#src/api/query/filters/base.mjs';
+export declare class HomeRoadQuery extends QueryBase {
+    readonly homeRoad: string;
+    private readonly homeRoadQ;
+    /** @param homeRoad H or R to indicate home or road games. */
+    constructor(homeRoad: string);
+    toQuery(): string;
+    validate(): boolean;
+}

package/dist/api/query/filters/home-road.mjs

@@ -0,0 +1,16 @@
+import { QueryBase } from '#src/api/query/filters/base.mjs';
+export class HomeRoadQuery extends QueryBase {
+    homeRoad;
+    homeRoadQ = 'homeRoad';
+    /** @param homeRoad H or R to indicate home or road games. */
+    constructor(homeRoad) {
+        super();
+        this.homeRoad = homeRoad;
+    }
+    toQuery() {
+        return `${this.homeRoadQ}='${this.homeRoad}'`;
+    }
+    validate() {
+        return true;
+    }
+}

package/dist/api/query/filters/index.d.mts

@@ -0,0 +1,14 @@
+export { QueryBase } from '#src/api/query/filters/base.mjs';
+export { DecisionQuery } from '#src/api/query/filters/decision.mjs';
+export { DraftQuery } from '#src/api/query/filters/draft.mjs';
+export { ExperienceQuery } from '#src/api/query/filters/experience.mjs';
+export { FranchiseQuery } from '#src/api/query/filters/franchise.mjs';
+export { GameTypeQuery } from '#src/api/query/filters/game-type.mjs';
+export { goalieStatsSorts } from '#src/api/query/filters/goalie-sorts.mjs';
+export { HomeRoadQuery } from '#src/api/query/filters/home-road.mjs';
+export { NationalityQuery } from '#src/api/query/filters/nationality.mjs';
+export { OpponentQuery } from '#src/api/query/filters/opponent.mjs';
+export { PositionQuery, PositionTypes, } from '#src/api/query/filters/position.mjs';
+export { SeasonQuery } from '#src/api/query/filters/season.mjs';
+export { ShootCatchesQuery } from '#src/api/query/filters/shoot-catch.mjs';
+export { StatusQuery, type StatusQueryOptions, } from '#src/api/query/filters/status.mjs';

package/dist/api/query/filters/index.mjs

@@ -0,0 +1,14 @@
+export { QueryBase } from '#src/api/query/filters/base.mjs';
+export { DecisionQuery } from '#src/api/query/filters/decision.mjs';
+export { DraftQuery } from '#src/api/query/filters/draft.mjs';
+export { ExperienceQuery } from '#src/api/query/filters/experience.mjs';
+export { FranchiseQuery } from '#src/api/query/filters/franchise.mjs';
+export { GameTypeQuery } from '#src/api/query/filters/game-type.mjs';
+export { goalieStatsSorts } from '#src/api/query/filters/goalie-sorts.mjs';
+export { HomeRoadQuery } from '#src/api/query/filters/home-road.mjs';
+export { NationalityQuery } from '#src/api/query/filters/nationality.mjs';
+export { OpponentQuery } from '#src/api/query/filters/opponent.mjs';
+export { PositionQuery, PositionTypes, } from '#src/api/query/filters/position.mjs';
+export { SeasonQuery } from '#src/api/query/filters/season.mjs';
+export { ShootCatchesQuery } from '#src/api/query/filters/shoot-catch.mjs';
+export { StatusQuery, } from '#src/api/query/filters/status.mjs';

package/dist/api/query/filters/nationality.d.mts

@@ -0,0 +1,12 @@
+import { QueryBase } from '#src/api/query/filters/base.mjs';
+/**
+ * Country/Nationality codes can be found via the `client.misc.countries()`
+ * endpoint, e.g. "CAN", "USA", "SWE", "FIN", "CZE", "RUS".
+ */
+export declare class NationalityQuery extends QueryBase {
+    readonly nationCode: string;
+    private readonly nationQ;
+    constructor(nationCode: string);
+    validate(): boolean;
+    toQuery(): string;
+}

package/dist/api/query/filters/nationality.mjs

@@ -0,0 +1,19 @@
+import { QueryBase } from '#src/api/query/filters/base.mjs';
+/**
+ * Country/Nationality codes can be found via the `client.misc.countries()`
+ * endpoint, e.g. "CAN", "USA", "SWE", "FIN", "CZE", "RUS".
+ */
+export class NationalityQuery extends QueryBase {
+    nationCode;
+    nationQ = 'nationalityCode';
+    constructor(nationCode) {
+        super();
+        this.nationCode = nationCode;
+    }
+    validate() {
+        return true;
+    }
+    toQuery() {
+        return `${this.nationQ}='${this.nationCode}'`;
+    }
+}

package/dist/api/query/filters/opponent.d.mts

@@ -0,0 +1,10 @@
+import { QueryBase } from '#src/api/query/filters/base.mjs';
+import type { Id } from '#src/utils.mjs';
+export declare class OpponentQuery extends QueryBase {
+    readonly opponentId: Id;
+    private readonly opponentQ;
+    /** Opponent filter. Takes in the ID of the opponent franchise. */
+    constructor(opponentFranchiseId: Id);
+    toQuery(): string;
+    validate(): boolean;
+}

package/dist/api/query/filters/opponent.mjs

@@ -0,0 +1,16 @@
+import { QueryBase } from '#src/api/query/filters/base.mjs';
+export class OpponentQuery extends QueryBase {
+    opponentId;
+    opponentQ = 'opponentFranchiseId';
+    /** Opponent filter. Takes in the ID of the opponent franchise. */
+    constructor(opponentFranchiseId) {
+        super();
+        this.opponentId = opponentFranchiseId;
+    }
+    toQuery() {
+        return `${this.opponentQ}=${this.opponentId}`;
+    }
+    validate() {
+        return true;
+    }
+}

package/dist/api/query/filters/position.d.mts

@@ -0,0 +1,16 @@
+import { QueryBase } from '#src/api/query/filters/base.mjs';
+export declare const PositionTypes: {
+    readonly ALL_FORWARDS: 'F';
+    readonly CENTER: 'C';
+    readonly LEFT_WING: 'L';
+    readonly RIGHT_WING: 'R';
+    readonly DEFENSE: 'D';
+};
+export type PositionTypes = (typeof PositionTypes)[keyof typeof PositionTypes];
+export declare class PositionQuery extends QueryBase {
+    readonly position: PositionTypes;
+    private readonly positionQ;
+    constructor(position: PositionTypes);
+    toQuery(): string;
+    validate(): boolean;
+}

package/dist/api/query/filters/position.mjs

@@ -0,0 +1,28 @@
+import { QueryBase } from '#src/api/query/filters/base.mjs';
+export const PositionTypes = {
+    ALL_FORWARDS: 'F',
+    CENTER: 'C',
+    LEFT_WING: 'L',
+    RIGHT_WING: 'R',
+    DEFENSE: 'D',
+};
+export class PositionQuery extends QueryBase {
+    position;
+    positionQ = 'positionCode';
+    constructor(position) {
+        super();
+        this.position = position;
+    }
+    toQuery() {
+        // All forwards require an OR clause
+        if (this.position === PositionTypes.ALL_FORWARDS) {
+            return (`(${this.positionQ}='${PositionTypes.LEFT_WING}' ` +
+                `or ${this.positionQ}='${PositionTypes.RIGHT_WING}' ` +
+                `or ${this.positionQ}='${PositionTypes.CENTER}')`);
+        }
+        return `${this.positionQ}='${this.position}'`;
+    }
+    validate() {
+        return true;
+    }
+}

package/dist/api/query/filters/season.d.mts

@@ -0,0 +1,14 @@
+import { QueryBase } from '#src/api/query/filters/base.mjs';
+import type { Id } from '#src/utils.mjs';
+export declare class SeasonQuery extends QueryBase {
+    readonly seasonStart: Id;
+    readonly seasonEnd: Id;
+    private readonly seasonStartQ;
+    private readonly seasonStartQExp;
+    private readonly seasonEndQ;
+    private readonly seasonEndQExp;
+    /** Seasons in YYYYYYYY format, e.g. 20232024. */
+    constructor(seasonStart: Id, seasonEnd: Id);
+    toQuery(): string;
+    validate(): boolean;
+}

package/dist/api/query/filters/season.mjs

@@ -0,0 +1,24 @@
+import { QueryBase } from '#src/api/query/filters/base.mjs';
+export class SeasonQuery extends QueryBase {
+    seasonStart;
+    seasonEnd;
+    seasonStartQ = 'seasonId';
+    seasonStartQExp = '>=';
+    seasonEndQ = 'seasonId';
+    seasonEndQExp = '<=';
+    /** Seasons in YYYYYYYY format, e.g. 20232024. */
+    constructor(seasonStart, seasonEnd) {
+        super();
+        this.seasonStart = seasonStart;
+        this.seasonEnd = seasonEnd;
+    }
+    toQuery() {
+        let query = `${this.seasonStartQ} ${this.seasonStartQExp} ${this.seasonStart}`;
+        query += ' and ';
+        query += `${this.seasonEndQ} ${this.seasonEndQExp} ${this.seasonEnd}`;
+        return query;
+    }
+    validate() {
+        return true;
+    }
+}

package/dist/api/query/filters/shoot-catch.d.mts

@@ -0,0 +1,9 @@
+import { QueryBase } from '#src/api/query/filters/base.mjs';
+export declare class ShootCatchesQuery extends QueryBase {
+    readonly shootCatch: string;
+    readonly shootCatchQ = "shootsCatches";
+    /** Shoot / catch filter. @param shootCatch L or R */
+    constructor(shootCatch: string);
+    toQuery(): string;
+    validate(): boolean;
+}

package/dist/api/query/filters/shoot-catch.mjs

@@ -0,0 +1,16 @@
+import { QueryBase } from '#src/api/query/filters/base.mjs';
+export class ShootCatchesQuery extends QueryBase {
+    shootCatch;
+    shootCatchQ = 'shootsCatches';
+    /** Shoot / catch filter. @param shootCatch L or R */
+    constructor(shootCatch) {
+        super();
+        this.shootCatch = shootCatch;
+    }
+    toQuery() {
+        return `${this.shootCatchQ}='${this.shootCatch}'`;
+    }
+    validate() {
+        return true;
+    }
+}

package/dist/api/query/filters/status.d.mts

@@ -0,0 +1,20 @@
+import { QueryBase } from '#src/api/query/filters/base.mjs';
+export interface StatusQueryOptions {
+    /** Only current active players. */
+    isActive?: boolean;
+    /** Only Hall of Fame players. Takes precedence over `isActive`. */
+    isHallOfFame?: boolean;
+}
+export declare class StatusQuery extends QueryBase {
+    readonly isActive: boolean;
+    readonly isHallOfFame: boolean;
+    private readonly activeQ;
+    private readonly hofQ;
+    /**
+     * Player status. Not supplying either option matches active and inactive
+     * players.
+     */
+    constructor({ isActive, isHallOfFame, }?: StatusQueryOptions);
+    toQuery(): string;
+    validate(): boolean;
+}

package/dist/api/query/filters/status.mjs

@@ -0,0 +1,28 @@
+import { QueryBase } from '#src/api/query/filters/base.mjs';
+export class StatusQuery extends QueryBase {
+    isActive;
+    isHallOfFame;
+    activeQ = 'active';
+    hofQ = 'isInHallOfFame';
+    /**
+     * Player status. Not supplying either option matches active and inactive
+     * players.
+     */
+    constructor({ isActive = false, isHallOfFame = false, } = {}) {
+        super();
+        this.isActive = isActive;
+        this.isHallOfFame = isHallOfFame;
+    }
+    toQuery() {
+        if (this.isHallOfFame) {
+            return `${this.hofQ}=1`;
+        }
+        if (this.isActive) {
+            return `${this.activeQ}=1`;
+        }
+        return '';
+    }
+    validate() {
+        return true;
+    }
+}

package/dist/api/query/filters.d.mts

@@ -0,0 +1,93 @@
+import type { Id } from '#src/utils.mjs';
+export declare const PositionTypes: {
+    readonly ALL_FORWARDS: 'F';
+    readonly CENTER: 'C';
+    readonly LEFT_WING: 'L';
+    readonly RIGHT_WING: 'R';
+    readonly DEFENSE: 'D';
+};
+export type PositionTypes = (typeof PositionTypes)[keyof typeof PositionTypes];
+/** Goalie decision. W=win, L=loss, O=overtime loss. */
+export type Decision = 'W' | 'L' | 'O';
+export interface StatusQueryOptions {
+    /** Only current active players. */
+    isActive?: boolean;
+    /** Only Hall of Fame players. Takes precedence over `isActive`. */
+    isHallOfFame?: boolean;
+}
+export type Filter = {
+    kind: 'decision';
+    decision: Decision;
+} | {
+    kind: 'draft';
+    year: Id;
+    round?: Id;
+} | {
+    kind: 'experience';
+    isRookie: boolean;
+} | {
+    kind: 'franchise';
+    franchiseId: Id;
+} | {
+    kind: 'gameType';
+    gameType: Id;
+} | {
+    kind: 'homeRoad';
+    homeRoad: string;
+} | {
+    kind: 'nationality';
+    nationCode: string;
+} | {
+    kind: 'opponent';
+    opponentId: Id;
+} | {
+    kind: 'position';
+    position: PositionTypes;
+} | {
+    kind: 'season';
+    start: Id;
+    end: Id;
+} | {
+    kind: 'shootCatch';
+    shootCatch: string;
+} | {
+    kind: 'status';
+    isActive: boolean;
+    isHallOfFame: boolean;
+};
+export declare const filter: {
+    /** @param decision W, L, O */
+    readonly decision: (decision: Decision) => Filter;
+    /**
+     * @param year Draft year
+     * @param round Optional draft round. The API seems to default this to "1".
+     */
+    readonly draft: (year: Id, round?: Id) => Filter;
+    /** isRookie: true = rookies only, false = veterans only. */
+    readonly experience: (isRookie: boolean) => Filter;
+    readonly franchise: (franchiseId: Id) => Filter;
+    /** @param gameType 1=Preseason, 2=Regular season, 3=Playoffs */
+    readonly gameType: (gameType: Id) => Filter;
+    /** @param homeRoad H or R to indicate home or road games. */
+    readonly homeRoad: (homeRoad: string) => Filter;
+    /**
+     * Country/Nationality codes can be found via the `client.misc.countries()`
+     * endpoint, e.g. "CAN", "USA", "SWE", "FIN", "CZE", "RUS".
+     */
+    readonly nationality: (nationCode: string) => Filter;
+    /** @param opponentId The ID of the opponent franchise. */
+    readonly opponent: (opponentId: Id) => Filter;
+    readonly position: (position: PositionTypes) => Filter;
+    /** Seasons in YYYYYYYY format, e.g. 20232024. */
+    readonly season: (start: Id, end: Id) => Filter;
+    /** @param shootCatch L or R */
+    readonly shootCatch: (shootCatch: string) => Filter;
+    /**
+     * Player status. Not supplying either option matches active and inactive
+     * players.
+     */
+    readonly status: ({ isActive, isHallOfFame, }?: StatusQueryOptions) => Filter;
+};
+export declare function toQuery(filter: Filter): string;
+/** Returns an error message if the filter is invalid, otherwise undefined. */
+export declare function validateFilter(filter: Filter): string | undefined;

package/dist/api/query/filters.mjs

@@ -0,0 +1,118 @@
+export const PositionTypes = {
+    ALL_FORWARDS: 'F',
+    CENTER: 'C',
+    LEFT_WING: 'L',
+    RIGHT_WING: 'R',
+    DEFENSE: 'D',
+};
+export const filter = {
+    /** @param decision W, L, O */
+    decision: (decision) => ({ kind: 'decision', decision }),
+    /**
+     * @param year Draft year
+     * @param round Optional draft round. The API seems to default this to "1".
+     */
+    draft: (year, round) => ({ kind: 'draft', year, round }),
+    /** isRookie: true = rookies only, false = veterans only. */
+    experience: (isRookie) => ({
+        kind: 'experience',
+        isRookie,
+    }),
+    franchise: (franchiseId) => ({ kind: 'franchise', franchiseId }),
+    /** @param gameType 1=Preseason, 2=Regular season, 3=Playoffs */
+    gameType: (gameType) => ({ kind: 'gameType', gameType }),
+    /** @param homeRoad H or R to indicate home or road games. */
+    homeRoad: (homeRoad) => ({ kind: 'homeRoad', homeRoad }),
+    /**
+     * Country/Nationality codes can be found via the `client.misc.countries()`
+     * endpoint, e.g. "CAN", "USA", "SWE", "FIN", "CZE", "RUS".
+     */
+    nationality: (nationCode) => ({
+        kind: 'nationality',
+        nationCode,
+    }),
+    /** @param opponentId The ID of the opponent franchise. */
+    opponent: (opponentId) => ({ kind: 'opponent', opponentId }),
+    position: (position) => ({
+        kind: 'position',
+        position,
+    }),
+    /** Seasons in YYYYYYYY format, e.g. 20232024. */
+    season: (start, end) => ({ kind: 'season', start, end }),
+    /** @param shootCatch L or R */
+    shootCatch: (shootCatch) => ({
+        kind: 'shootCatch',
+        shootCatch,
+    }),
+    /**
+     * Player status. Not supplying either option matches active and inactive
+     * players.
+     */
+    status: ({ isActive = false, isHallOfFame = false, } = {}) => ({
+        kind: 'status',
+        isActive,
+        isHallOfFame,
+    }),
+};
+export function toQuery(filter) {
+    switch (filter.kind) {
+        case 'decision': {
+            return `decision='${filter.decision}'`;
+        }
+        case 'draft': {
+            return filter.round
+                ? `draftYear=${filter.year} and draftRound=${filter.round}`
+                : `draftYear=${filter.year}`;
+        }
+        case 'experience': {
+            return `isRookie='${filter.isRookie ? '1' : '0'}'`;
+        }
+        case 'franchise': {
+            return `franchiseId=${filter.franchiseId}`;
+        }
+        case 'gameType': {
+            return `gameTypeId=${filter.gameType}`;
+        }
+        case 'homeRoad': {
+            return `homeRoad='${filter.homeRoad}'`;
+        }
+        case 'nationality': {
+            return `nationalityCode='${filter.nationCode}'`;
+        }
+        case 'opponent': {
+            return `opponentFranchiseId=${filter.opponentId}`;
+        }
+        case 'position': {
+            // All forwards require an OR clause
+            if (filter.position === PositionTypes.ALL_FORWARDS) {
+                return (`(positionCode='${PositionTypes.LEFT_WING}' ` +
+                    `or positionCode='${PositionTypes.RIGHT_WING}' ` +
+                    `or positionCode='${PositionTypes.CENTER}')`);
+            }
+            return `positionCode='${filter.position}'`;
+        }
+        case 'season': {
+            return `seasonId >= ${filter.start} and seasonId <= ${filter.end}`;
+        }
+        case 'shootCatch': {
+            return `shootsCatches='${filter.shootCatch}'`;
+        }
+        case 'status': {
+            if (filter.isHallOfFame) {
+                return 'isInHallOfFame=1';
+            }
+            if (filter.isActive) {
+                return 'active=1';
+            }
+            return '';
+        }
+    }
+}
+/** Returns an error message if the filter is invalid, otherwise undefined. */
+export function validateFilter(filter) {
+    if (filter.kind === 'decision' &&
+        !['W', 'L', 'O'].includes(filter.decision)) {
+        return 'Decision value must be one of [W, L, O]';
+    }
+    return undefined;
+}

package/dist/api/query/index.d.mts

@@ -0,0 +1,4 @@
+export { buildQuery, isValidQuery, type QueryContext, } from '#src/api/query/builder.mjs';
+export * from '#src/api/query/filters.mjs';
+export { goalieStatsSorts } from '#src/api/query/sorting/goalie-sorts.mjs';
+export { defaultSortForReport, SKATER_REPORT_TYPES, type SortExpr, } from '#src/api/query/sorting/sorting-options.mjs';

package/dist/api/query/index.mjs

@@ -0,0 +1,4 @@
+export { buildQuery, isValidQuery, } from '#src/api/query/builder.mjs';
+export * from '#src/api/query/filters.mjs';
+export { goalieStatsSorts } from '#src/api/query/sorting/goalie-sorts.mjs';
+export { defaultSortForReport, SKATER_REPORT_TYPES, } from '#src/api/query/sorting/sorting-options.mjs';

package/dist/api/query/sorting/goalie-sorts.d.mts

@@ -0,0 +1,6 @@
+import type { SortExpr } from '#src/api/query/sorting/sorting-options.mjs';
+/**
+ * Default sorting criteria for goalie stats reports. Falls back to the
+ * goalie summary sort for unknown report types.
+ */
+export declare function goalieStatsSorts(report: string): SortExpr[];

package/dist/api/query/sorting/goalie-sorts.mjs

@@ -0,0 +1,59 @@
+const goalieSummaryDefaultSorting = [
+    { property: 'wins', direction: 'DESC' },
+    { property: 'gamesPlayed', direction: 'ASC' },
+    { property: 'playerId', direction: 'ASC' },
+];
+/**
+ * Default sorting criteria for goalie stats reports. Falls back to the
+ * goalie summary sort for unknown report types.
+ */
+export function goalieStatsSorts(report) {
+    switch (report) {
+        case 'summary':
+            return goalieSummaryDefaultSorting;
+        case 'advanced':
+            return [
+                { property: 'qualityStart', direction: 'DESC' },
+                { property: 'goalsAgainstAverage', direction: 'ASC' },
+                { property: 'playerId', direction: 'ASC' },
+            ];
+        case 'bios':
+            return [
+                { property: 'lastName', direction: 'ASC_CI' },
+                { property: 'goalieFullName', direction: 'ASC_CI' },
+                { property: 'playerId', direction: 'ASC' },
+            ];
+        case 'daysrest':
+            return [
+                { property: 'wins', direction: 'DESC' },
+                { property: 'savePct', direction: 'DESC' },
+                { property: 'playerId', direction: 'ASC' },
+            ];
+        case 'penaltyShots':
+            return [
+                { property: 'penaltyShotsSaves', direction: 'DESC' },
+                { property: 'penaltyShotSavePct', direction: 'DESC' },
+                { property: 'playerId', direction: 'ASC' },
+            ];
+        case 'savesByStrength':
+            return [
+                { property: 'wins', direction: 'DESC' },
+                { property: 'savePct', direction: 'DESC' },
+                { property: 'playerId', direction: 'ASC' },
+            ];
+        case 'shootout':
+            return [
+                { property: 'shootoutWins', direction: 'DESC' },
+                { property: 'shootoutSavePct', direction: 'DESC' },
+                { property: 'playerId', direction: 'ASC' },
+            ];
+        case 'startedVsRelieved':
+            return [
+                { property: 'gamesStarted', direction: 'DESC' },
+                { property: 'gamesStartedSavePct', direction: 'DESC' },
+                { property: 'playerId', direction: 'ASC' },
+            ];
+        default:
+            return goalieSummaryDefaultSorting;
+    }
+}