nhl-tui 0.1.0

package/dist/app/polling.js

@@ -0,0 +1,241 @@
+import { useEffect, useEffectEvent } from "react";
+import { compareScoreboardDateToToday } from "./dates.js";
+import { diffGame, diffGames } from "../domain/diff.js";
+import { normalizeDetail, normalizeLeaders, normalizeScoreboard, normalizeStandings, } from "../domain/normalize.js";
+function getSoonestUpcomingDelta(games, now) {
+    const deltas = games
+        .filter((game) => game.phase === "upcoming")
+        .map((game) => game.startTimeEpochMs - now)
+        .sort((left, right) => left - right);
+    return deltas[0];
+}
+export function getScoreboardPollDelayMs(games, scoreboardDate, now = Date.now()) {
+    const dateRelation = compareScoreboardDateToToday(scoreboardDate, new Date(now));
+    if (dateRelation < 0) {
+        return 300000;
+    }
+    if (dateRelation > 0) {
+        return 120000;
+    }
+    if (!games.length) {
+        return 15000;
+    }
+    if (games.some((game) => game.phase === "live")) {
+        return 5000;
+    }
+    const soonestUpcoming = getSoonestUpcomingDelta(games, now);
+    if (soonestUpcoming !== undefined) {
+        if (soonestUpcoming <= 5 * 60_000 && soonestUpcoming >= -30 * 60_000) {
+            return 3000;
+        }
+        if (soonestUpcoming <= 30 * 60_000 && soonestUpcoming > 5 * 60_000) {
+            return 10000;
+        }
+    }
+    if (games.every((game) => game.phase === "final")) {
+        return 180000;
+    }
+    return 60000;
+}
+export function getDetailPollDelayMs(tab, game, now = Date.now()) {
+    if (!game) {
+        return 4000;
+    }
+    if (game.phase === "live") {
+        if (tab === "pbp") {
+            return 2500;
+        }
+        if (tab === "box") {
+            return 7000;
+        }
+        return 5000;
+    }
+    if (game.phase === "upcoming") {
+        return Math.min(getScoreboardPollDelayMs([game], game.startTimeUtc.slice(0, 10), now), tab === "pbp" ? 5000 : 8000);
+    }
+    return undefined;
+}
+function formatError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+export function useAppPolling({ client, dispatch, stateRef, scoreboardDate, screenType, screenGameId, screenTab, manualRefreshToken, }) {
+    const fetchScoreboard = useEffectEvent(async () => {
+        const currentScoreboardDate = stateRef.current.scoreboardDate;
+        try {
+            const receivedAt = Date.now();
+            const payload = await client.fetchScoreboard(currentScoreboardDate);
+            const games = normalizeScoreboard(payload);
+            const previousGames = stateRef.current.games;
+            const events = diffGames(previousGames, games, receivedAt);
+            dispatch({
+                type: "scoreboard_loaded",
+                scoreboardDate: currentScoreboardDate,
+                games,
+                receivedAt,
+                events,
+            });
+        }
+        catch (error) {
+            dispatch({
+                type: "poll_failed",
+                resource: "scoreboard",
+                error: formatError(error),
+                scoreboardDate: currentScoreboardDate,
+            });
+        }
+    });
+    const fetchStandings = useEffectEvent(async () => {
+        const currentScoreboardDate = stateRef.current.scoreboardDate;
+        if (stateRef.current.standingsByDate[currentScoreboardDate]) {
+            return;
+        }
+        try {
+            const receivedAt = Date.now();
+            const payload = await client.fetchStandings(currentScoreboardDate);
+            const standings = normalizeStandings(payload, currentScoreboardDate, receivedAt);
+            dispatch({
+                type: "standings_loaded",
+                scoreboardDate: currentScoreboardDate,
+                standings,
+                receivedAt,
+            });
+        }
+        catch (error) {
+            dispatch({
+                type: "poll_failed",
+                resource: "standings",
+                error: formatError(error),
+                scoreboardDate: currentScoreboardDate,
+            });
+        }
+    });
+    const fetchLeaders = useEffectEvent(async () => {
+        if (stateRef.current.leaders) {
+            return;
+        }
+        try {
+            const receivedAt = Date.now();
+            const [skaterPayload, goaliePayload] = await Promise.all([
+                client.fetchSkaterLeaders(10),
+                client.fetchGoalieLeaders(10),
+            ]);
+            const leaders = normalizeLeaders(skaterPayload, goaliePayload, receivedAt);
+            dispatch({
+                type: "leaders_loaded",
+                leaders,
+                receivedAt,
+            });
+        }
+        catch (error) {
+            if (stateRef.current.screen.type === "leaders") {
+                dispatch({
+                    type: "poll_failed",
+                    resource: "leaders",
+                    error: formatError(error),
+                });
+            }
+        }
+    });
+    const fetchDetail = useEffectEvent(async () => {
+        const screen = stateRef.current.screen;
+        if (screen.type !== "game") {
+            return;
+        }
+        try {
+            const receivedAt = Date.now();
+            let payload;
+            if (screen.tab === "pbp") {
+                payload = await client.fetchPlayByPlay(screen.gameId);
+            }
+            else if (screen.tab === "box") {
+                payload = await client.fetchBoxScore(screen.gameId);
+            }
+            else {
+                const landing = await client.fetchSummary(screen.gameId);
+                let box;
+                try {
+                    box = await client.fetchBoxScore(screen.gameId);
+                }
+                catch {
+                    box = undefined;
+                }
+                payload = { landing, box };
+            }
+            const detail = normalizeDetail(screen.tab, payload, receivedAt);
+            const previousGame = stateRef.current.gameDetails[screen.gameId]?.game ??
+                stateRef.current.games.find((game) => game.id === screen.gameId);
+            const events = diffGame(previousGame, detail.game, receivedAt);
+            dispatch({
+                type: "game_detail_loaded",
+                gameId: screen.gameId,
+                detail,
+                receivedAt,
+                events,
+            });
+        }
+        catch (error) {
+            dispatch({
+                type: "poll_failed",
+                resource: "game",
+                error: formatError(error),
+                gameId: screen.gameId,
+            });
+        }
+    });
+    const fetchCurrentView = useEffectEvent(async () => {
+        if (stateRef.current.screen.type === "scoreboard") {
+            await fetchScoreboard();
+            return;
+        }
+        if (stateRef.current.screen.type === "standings") {
+            await fetchStandings();
+            return;
+        }
+        if (stateRef.current.screen.type === "leaders") {
+            await fetchLeaders();
+            return;
+        }
+        await fetchDetail();
+    });
+    useEffect(() => {
+        let disposed = false;
+        let timer;
+        const loop = async () => {
+            await fetchCurrentView();
+            if (disposed) {
+                return;
+            }
+            const state = stateRef.current;
+            let delay = getScoreboardPollDelayMs(state.games, state.scoreboardDate);
+            const screen = state.screen;
+            if (screen.type === "standings" || screen.type === "leaders") {
+                delay = undefined;
+            }
+            if (screen.type === "game") {
+                const currentGame = state.gameDetails[screen.gameId]?.game ??
+                    state.games.find((game) => game.id === screen.gameId);
+                delay = getDetailPollDelayMs(screen.tab, currentGame);
+            }
+            if (delay === undefined) {
+                return;
+            }
+            timer = setTimeout(loop, delay);
+        };
+        timer = setTimeout(loop, 0);
+        return () => {
+            disposed = true;
+            if (timer) {
+                clearTimeout(timer);
+            }
+        };
+    }, [fetchCurrentView, scoreboardDate, screenType, screenGameId, screenTab]);
+    useEffect(() => {
+        if (manualRefreshToken === 0) {
+            return;
+        }
+        void fetchCurrentView();
+    }, [fetchCurrentView, manualRefreshToken]);
+}

package/dist/app/store.js

@@ -0,0 +1,39 @@
+import { useReducer } from "react";
+import { todayScoreboardDate } from "./dates.js";
+import { appReducer } from "../domain/reducer.js";
+export const initialState = {
+    screen: {
+        type: "scoreboard",
+    },
+    scoreboardDate: todayScoreboardDate(),
+    games: [],
+    standingsByDate: {},
+    standingsErrorByDate: {},
+    leaders: undefined,
+    leadersErrorMessage: undefined,
+    gameDetails: {},
+    gameDetailErrors: {},
+    scoreboardLoadedDate: undefined,
+    scoreboardUpdatedAt: undefined,
+    scoreboardErrorMessage: undefined,
+    selectedGameId: undefined,
+    bannerQueue: [],
+    activeBanner: undefined,
+    recentEvents: [],
+    manualRefreshToken: 0,
+};
+export function useAppStore() {
+    return useReducer(appReducer, initialState);
+}
+export function selectVisibleGames(state) {
+    return state.games;
+}
+export function selectSelectedGame(state) {
+    return state.games.find((game) => game.id === state.selectedGameId);
+}
+export function selectCurrentStandings(state) {
+    return state.standingsByDate[state.scoreboardDate];
+}
+export function selectCurrentLeaders(state) {
+    return state.leaders;
+}

package/dist/app/timers.js

@@ -0,0 +1,15 @@
+import { useEffect, useEffectEvent } from "react";
+export function useBannerTimer(activeBanner, onExpire) {
+    const handleExpire = useEffectEvent(onExpire);
+    useEffect(() => {
+        if (!activeBanner) {
+            return undefined;
+        }
+        const timer = setTimeout(() => {
+            handleExpire();
+        }, 3200);
+        return () => {
+            clearTimeout(timer);
+        };
+    }, [activeBanner?.id, handleExpire]);
+}

package/dist/domain/diff.js

@@ -0,0 +1,57 @@
+function buildGoalEvents(gameId, team, delta, timestamp) {
+    if (delta <= 0) {
+        return [];
+    }
+    return Array.from({ length: delta }, () => ({
+        type: "goal_scored",
+        gameId,
+        team,
+        timestamp,
+    }));
+}
+function diffSingleGame(previousGame, nextGame, timestamp) {
+    if (!previousGame) {
+        return [];
+    }
+    const events = [];
+    if (previousGame.phase !== "live" && nextGame.phase === "live") {
+        events.push({
+            type: "game_started",
+            gameId: nextGame.id,
+            timestamp,
+        });
+    }
+    if (previousGame.phase === "live" && nextGame.phase === "final") {
+        events.push({
+            type: "game_ended",
+            gameId: nextGame.id,
+            timestamp,
+        });
+    }
+    if (previousGame.phase === "live" &&
+        nextGame.phase === "live" &&
+        previousGame.periodLabel &&
+        nextGame.periodLabel &&
+        previousGame.periodLabel !== nextGame.periodLabel) {
+        events.push({
+            type: "period_changed",
+            gameId: nextGame.id,
+            period: nextGame.periodLabel,
+            timestamp,
+        });
+    }
+    events.push(...buildGoalEvents(nextGame.id, nextGame.away.abbrev, nextGame.away.score - previousGame.away.score, timestamp));
+    events.push(...buildGoalEvents(nextGame.id, nextGame.home.abbrev, nextGame.home.score - previousGame.home.score, timestamp));
+    return events;
+}
+export function diffGames(previousGames, nextGames, timestamp) {
+    const previousById = new Map(previousGames.map((game) => [game.id, game]));
+    const events = [];
+    for (const nextGame of nextGames) {
+        events.push(...diffSingleGame(previousById.get(nextGame.id), nextGame, timestamp));
+    }
+    return events;
+}
+export function diffGame(previousGame, nextGame, timestamp) {
+    return diffSingleGame(previousGame, nextGame, timestamp);
+}

package/dist/domain/events.js

@@ -0,0 +1,22 @@
+export function createGoalBanners(events, games, createdAt) {
+    const gamesById = new Map(games.map((game) => [game.id, game]));
+    return events.flatMap((event, index) => {
+        if (event.type !== "goal_scored") {
+            return [];
+        }
+        const game = gamesById.get(event.gameId);
+        return [
+            {
+                id: `${event.gameId}:${event.timestamp}:${index}`,
+                type: "goal",
+                gameId: event.gameId,
+                team: event.team,
+                title: `${event.team} GOAL`,
+                subtitle: game
+                    ? `${game.away.abbrev} ${game.away.score} - ${game.home.score} ${game.home.abbrev}`
+                    : undefined,
+                createdAt,
+            },
+        ];
+    });
+}