playball 3.2.0 → 3.4.0

package/README.md

@@ -25,18 +25,27 @@ $ playball
 ```
 
 ### Docker
-```
-$ docker build -t playball .
-$ docker run -it --rm --name playball playball:latest
-```
-
-#### Build options
-
-Update the language encoding of by adding `--build-args`
-
-```
-$ docker build --build-arg LANG=en_US.UTF-8 -t playball .
-```
+Don't have Node.js installed? You can run via Docker instead.
+```
+$ docker run -it --rm paaatrick0/playball
+```
+
+> [!TIP]
+> When running via Docker, times will be shown by default in Eastern Time. To change this, set the `TZ` environment variable to your desired timezone. 
+> 
+> For Central Time use:
+> ```
+> $ docker run -it --rm -e TZ=America/Chicago paaatrick0/playball
+> ```
+> For Mountain Time use:
+> ```
+> $ docker run -it --rm -e TZ=America/Denver paaatrick0/playball
+> ```
+> For Pacific Time use:
+> ```
+> $ docker run -it --rm -e TZ=America/Los_Angeles paaatrick0/playball
+> ```
+> For other timezones see the list of [TZ database time zones](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones).
 
 ### Keys
 #### Global
@@ -60,6 +69,32 @@ key | action
 ----|--------
 <kbd>&darr;</kbd>/<kbd>j</kbd>, <kbd>&uarr;</kbd>/<kbd>k</kbd> | scroll list of all plays
 
+### World Baseball Classic
+
+Watch World Baseball Classic games by setting the sport configuration:
+
+```shell
+playball config sport wbc
+```
+
+Or use an environment variable for one-time viewing:
+
+```shell
+PLAYBALL_SPORT=wbc playball
+```
+
+To switch back to MLB:
+
+```shell
+playball config sport mlb
+```
+
+When running via Docker:
+
+```shell
+docker run -it --rm -e PLAYBALL_SPORT=wbc paaatrick0/playball
+```
+
 ### Configuration
 
 Playball can be configured using the `config` subcommand. To list the current configuration values run the subcommand with no additional arguments:
@@ -122,6 +157,8 @@ key | description | default | allowed values
 `color.walk` | Color of result where play ends on a ball (walk, hit by pitch) in list of plays in game view | green | _See above_
 `favorites` | Teams to highlight in schedule and standings views | | Any one of the following: `ATL`, `AZ`, `BAL`, `BOS`, `CHC`, `CIN`, `CLE`, `COL`, `CWS`, `DET`, `HOU`, `KC`, `LAA`, `LAD`, `MIA`, `MIL`, `MIN`, `NYM`, `NYY`, `OAK`, `PHI`, `PIT`, `SD`, `SEA`, `SF`, `STL`, `TB`, `TEX`, `TOR`, `WSH`. Or a comma-separated list of multiple (e.g. `SEA,MIL`).<br/><br />Note: in some terminals the list must be quoted: `playball config favorites "SEA,MIL"`
 `title` | If enabled, the terminal title will be set to the score of the current game | `false` | `false`, `true`
+`live-delay` | Number of seconds to delay the live game stream. Useful when watching with delayed broadcast streams. | `0` (no delay) | Any positive number
+`sport` | Which sport/league to display | `mlb` | `mlb`, `wbc`
 
 ### Development
 ```

package/dist/cli.js

@@ -10,7 +10,7 @@ const notifier = updateNotifier({
   updateCheckInterval: 1000 * 60 * 60 * 24 * 7 // 1 week
 });
 
-program.name(pkg.name).description(pkg.description).version(pkg.version).action(main).hook('postAction', () => notifier.notify({
+program.name(pkg.name).description(pkg.description).version(pkg.version).option('--replay <gameId>', 'Replay a game by game ID').option('--date <date>', 'Open schedule to specific date (YYYY-MM-DD)').action(main).hook('postAction', () => notifier.notify({
   isGlobal: true
 }));
 program.command('config').description('Set or get configration values').argument('[key]').argument('[value]').option('--unset', 'Unset configuration value').action((key, value, options) => {

package/dist/components/AllPlays.js

@@ -1,5 +1,6 @@
 import React from 'react';
 import { useSelector } from "react-redux/lib/alternate-renderers.js";
+import PropTypes from 'prop-types';
 import { selectAllPlays, selectTeams } from "../features/games.js";
 import { get } from "../config.js";
 import style from "../style/index.js";
@@ -19,28 +20,46 @@ function getPlayResultColor(play) {
   }
 }
 function formatOut(out) {
-  return ` {bold}${out} out{/}`;
+  return ` {bold}${out} out${out > 1 ? 's' : ''}{/}`;
 }
-function AllPlays() {
+function AllPlays({
+  reverse,
+  scoringOnly
+}) {
   const plays = useSelector(selectAllPlays);
   const teams = useSelector(selectTeams);
   const formatScoreDetail = scoreObj => ` {bold}{${get('color.in-play-runs-bg')}-bg}{${get('color.in-play-runs-fg')}-fg} ` + `${teams.away.abbreviation} ${scoreObj.awayScore} - ` + `${teams.home.abbreviation} ${scoreObj.homeScore}` + ' {/}';
-  let inning = '';
-  const lines = [];
-  plays && plays.slice().reverse().forEach((play, playIdx, plays) => {
-    let lastPlay;
-    if (playIdx < plays.length - 1) {
-      lastPlay = plays[playIdx + 1];
-    }
+  const playsByInning = {};
+  plays === null || plays === void 0 ? void 0 : plays.forEach(play => {
+    var _play$playEvents2;
     const playInning = play.about.halfInning + ' ' + play.about.inning;
-    if (playInning !== inning) {
-      inning = playInning;
-      if (lines.length > 0) {
-        lines.push('');
+    (_play$playEvents2 = play.playEvents) === null || _play$playEvents2 === void 0 ? void 0 : _play$playEvents2.forEach(event => {
+      if (event.type === 'action') {
+        if (scoringOnly && !event.details.isScoringPlay) {
+          return;
+        }
+        if (event.details.eventType === 'batter_timeout' || event.details.eventType === 'mound_visit') {
+          return;
+        }
+        let line = '';
+        if (event.details.event) {
+          line += `{${get('color.other-event')}-fg}[${event.details.event}]{/} `;
+        }
+        line += event.details.description;
+        if (event.details.isOut) {
+          var _event$count;
+          line += formatOut((_event$count = event.count) === null || _event$count === void 0 ? void 0 : _event$count.outs);
+        }
+        if (event.isScoringPlay || event.details.isScoringPlay) {
+          line += formatScoreDetail(event.details);
+        }
+        if (!(playInning in playsByInning)) {
+          playsByInning[playInning] = [];
+        }
+        playsByInning[playInning].push(line);
       }
-      lines.push(`{bold}[${inning.toUpperCase()}]{/}`);
-    }
-    if (play.about.isComplete) {
+    });
+    if (play.about.isComplete && (!scoringOnly || play.about.isScoringPlay)) {
       const color = getPlayResultColor(play);
       let line = `{${color}-fg}[${play.result.event}]{/} ${play.result.description}`;
       if (play.about.hasOut) {
@@ -52,32 +71,35 @@ function AllPlays() {
       if (play.about.isScoringPlay) {
         line += formatScoreDetail(play.result);
       }
-      lines.push(line);
-    }
-    play.playEvents && play.playEvents.slice().reverse().forEach((event, eventIdx, events) => {
-      if (event.type === 'action') {
-        var _event$count;
-        let line = '';
-        if (event.details.event) {
-          line += `{${get('color.other-event')}-fg}[${event.details.event}]{/} `;
-        }
-        line += event.details.description;
-        if (event.isScoringPlay || event.details.isScoringPlay) {
-          line += formatScoreDetail(event.details);
-        }
-        const currentOut = (_event$count = event.count) === null || _event$count === void 0 ? void 0 : _event$count.outs;
-        let prevOut = lastPlay ? lastPlay.count.outs : 0;
-        if (eventIdx < events.length - 1) {
-          var _events$count;
-          prevOut = (_events$count = events[eventIdx + 1].count) === null || _events$count === void 0 ? void 0 : _events$count.outs;
-        }
-        if (currentOut > prevOut) {
-          line += formatOut(currentOut);
-        }
-        lines.push(line);
+      if (!(playInning in playsByInning)) {
+        playsByInning[playInning] = [];
       }
-    });
+      playsByInning[playInning].push(line);
+    }
   });
+  const lines = [];
+  const inningKeys = Object.keys(playsByInning);
+  if (reverse) {
+    inningKeys.reverse();
+  }
+  inningKeys.forEach(inning => {
+    if (lines.length > 0) {
+      lines.push('');
+    }
+    lines.push(`{bold}[${inning.toUpperCase()}]{/}`);
+    if (reverse) {
+      lines.push(...playsByInning[inning].slice().reverse());
+    } else {
+      lines.push(...playsByInning[inning]);
+    }
+  });
+  if (lines.length === 0) {
+    if (scoringOnly) {
+      lines.push('No scoring plays yet');
+    } else {
+      lines.push('No plays yet');
+    }
+  }
   return /*#__PURE__*/React.createElement("box", {
     content: lines.join('\n'),
     focused: true,
@@ -90,4 +112,8 @@ function AllPlays() {
     tags: true
   });
 }
+AllPlays.propTypes = {
+  reverse: PropTypes.bool,
+  scoringOnly: PropTypes.bool
+};
 export default AllPlays;

package/dist/components/App.js

@@ -1,20 +1,26 @@
-import React, { useState } from 'react';
+import React, { useEffect, useState } from 'react';
 import { useDispatch } from "react-redux/lib/alternate-renderers.js";
+import PropTypes from 'prop-types';
+import { parseISO } from 'date-fns';
 import GameList from "./GameList.js";
 import HelpBar from "./HelpBar.js";
-import { setSelectedId } from "../features/games.js";
+import { setLiveGame, setReplayGame } from "../features/games.js";
 import Game from "./Game.js";
 import useKey from "../hooks/useKey.js";
 import Standings from "./Standings.js";
+import { setDate } from "../features/schedule.js";
 const SCHEDULE = 'schedule';
 const STANDINGS = 'standings';
 const GAME = 'game';
-function App() {
+function App({
+  replayId,
+  defaultDate
+}) {
   const [view, setView] = useState(SCHEDULE);
   const dispatch = useDispatch();
   useKey('c', () => {
     setView(SCHEDULE);
-    dispatch(setSelectedId(null));
+    dispatch(setLiveGame(null));
   }, {
     key: 'C',
     label: 'Schedule'
@@ -24,9 +30,19 @@ function App() {
     label: 'Standings'
   });
   const handleGameSelect = game => {
-    dispatch(setSelectedId(game.gamePk));
+    dispatch(setLiveGame(game.gamePk));
     setView(GAME);
   };
+  useEffect(() => {
+    if (replayId) {
+      dispatch(setReplayGame(replayId)).unwrap().then(() => setView(GAME)).catch(() => setView(SCHEDULE));
+    }
+  }, [replayId]);
+  useEffect(() => {
+    if (defaultDate) {
+      dispatch(setDate(parseISO(defaultDate)));
+    }
+  }, [defaultDate]);
   return /*#__PURE__*/React.createElement("element", null, /*#__PURE__*/React.createElement("element", {
     top: 0,
     left: 0,
@@ -39,4 +55,8 @@ function App() {
     height: 1
   }, /*#__PURE__*/React.createElement(HelpBar, null)));
 }
+App.propTypes = {
+  replayId: PropTypes.string,
+  defaultDate: PropTypes.string
+};
 export default App;

package/dist/components/BoxScore.js

@@ -0,0 +1,69 @@
+import React from 'react';
+import { useSelector } from "react-redux/lib/alternate-renderers.js";
+import { selectBoxscore, selectPlayers } from "../features/games.js";
+import Table from "./Table.js";
+function getBatterRows(boxscoreTeam, players) {
+  const batters = Object.values(boxscoreTeam.players).filter(player => player.battingOrder !== undefined).sort((a, b) => parseInt(a.battingOrder) - parseInt(b.battingOrder));
+  const batterNames = batters.map(batter => {
+    var _batter$allPositions, _batter$gameStatus;
+    const name = players[`ID${batter.person.id}`].boxscoreName;
+    const positions = (_batter$allPositions = batter.allPositions) === null || _batter$allPositions === void 0 ? void 0 : _batter$allPositions.map(pos => pos.abbreviation).join('-');
+    const prefix = (_batter$gameStatus = batter.gameStatus) !== null && _batter$gameStatus !== void 0 && _batter$gameStatus.isSubstitute ? ' ' : '';
+    return `${prefix}${name} (${positions})`;
+  });
+  return [...batters.map((batter, idx) => [batterNames[idx], batter.stats.batting.atBats.toString(), batter.stats.batting.runs.toString(), batter.stats.batting.hits.toString(), batter.stats.batting.rbi.toString(), batter.stats.batting.baseOnBalls.toString(), batter.stats.batting.strikeOuts.toString(), batter.seasonStats.batting.avg, batter.seasonStats.batting.ops]), ['Totals', boxscoreTeam.teamStats.batting.atBats.toString(), boxscoreTeam.teamStats.batting.runs.toString(), boxscoreTeam.teamStats.batting.hits.toString(), boxscoreTeam.teamStats.batting.rbi.toString(), boxscoreTeam.teamStats.batting.baseOnBalls.toString(), boxscoreTeam.teamStats.batting.strikeOuts.toString(), '', '']];
+}
+function getPitcherRows(boxscoreTeam, players) {
+  const pitchers = boxscoreTeam.pitchers.map(pitcherId => boxscoreTeam.players['ID' + pitcherId]);
+  const pitcherNames = pitchers.map(pitcher => {
+    const name = players[`ID${pitcher.person.id}`].boxscoreName;
+    const note = pitcher.stats.pitching.note ? ` ${pitcher.stats.pitching.note}` : '';
+    return `${name}${note}`;
+  });
+  return [...pitchers.map((pitcher, idx) => [pitcherNames[idx], pitcher.stats.pitching.inningsPitched, pitcher.stats.pitching.hits.toString(), pitcher.stats.pitching.runs.toString(), pitcher.stats.pitching.earnedRuns.toString(), pitcher.stats.pitching.baseOnBalls.toString(), pitcher.stats.pitching.strikeOuts.toString(), pitcher.stats.pitching.homeRuns.toString(), pitcher.seasonStats.pitching.era]), ['Totals', boxscoreTeam.teamStats.pitching.inningsPitched, boxscoreTeam.teamStats.pitching.hits.toString(), boxscoreTeam.teamStats.pitching.runs.toString(), boxscoreTeam.teamStats.pitching.earnedRuns.toString(), boxscoreTeam.teamStats.pitching.baseOnBalls.toString(), boxscoreTeam.teamStats.pitching.strikeOuts.toString(), boxscoreTeam.teamStats.pitching.homeRuns.toString(), '']];
+}
+function BoxScore({
+  ...props
+}) {
+  const boxscore = useSelector(selectBoxscore);
+  const players = useSelector(selectPlayers);
+  const batterHeader = ['Batters', 'AB', 'R', 'H', 'RBI', 'BB', 'K', 'AVG', 'OPS'];
+  const batterWidths = ['auto', 4, 4, 4, 4, 4, 4, 6, 6];
+  const awayBatterRows = getBatterRows(boxscore.away, players);
+  const homeBatterRows = getBatterRows(boxscore.home, players);
+  const pitcherHeader = ['Pitchers', 'IP', 'H', 'R', 'ER', 'BB', 'K', 'HR', 'ERA'];
+  const pitcherWidths = ['auto', 5, 4, 4, 4, 4, 4, 4, 6];
+  const pitcherStart = Math.max(awayBatterRows.length, homeBatterRows.length) + 2;
+  const awayPitcherRows = getPitcherRows(boxscore.away, players);
+  const homePitcherRows = getPitcherRows(boxscore.home, players);
+  return /*#__PURE__*/React.createElement("element", props, /*#__PURE__*/React.createElement(Table, {
+    top: 0,
+    left: 0,
+    width: "50%-1",
+    headers: batterHeader,
+    widths: batterWidths,
+    rows: awayBatterRows
+  }), /*#__PURE__*/React.createElement(Table, {
+    top: 0,
+    left: "50%+1",
+    width: "50%-1",
+    headers: batterHeader,
+    widths: batterWidths,
+    rows: homeBatterRows
+  }), /*#__PURE__*/React.createElement(Table, {
+    top: pitcherStart,
+    left: 0,
+    width: "50%-1",
+    headers: pitcherHeader,
+    widths: pitcherWidths,
+    rows: awayPitcherRows
+  }), /*#__PURE__*/React.createElement(Table, {
+    top: pitcherStart,
+    left: "50%+1",
+    width: "50%-1",
+    headers: pitcherHeader,
+    widths: pitcherWidths,
+    rows: homePitcherRows
+  }));
+}
+export default BoxScore;

package/dist/components/FinishedGame.js

@@ -1,9 +1,16 @@
-import React, { useEffect } from 'react';
-import { useSelector } from "react-redux/lib/alternate-renderers.js";
+import React, { useEffect, useMemo } from 'react';
+import { useDispatch, useSelector } from "react-redux/lib/alternate-renderers.js";
+import figlet from 'figlet';
 import LineScore from "./LineScore.js";
 import { get } from "../config.js";
-import { selectLineScore, selectTeams, selectDecisions, selectBoxscore, selectGameStatus } from "../features/games.js";
+import { selectBoxscore, selectDecisions, selectGameStatus, selectLineScore, selectSelectedId, selectTeams, setReplayGame } from "../features/games.js";
 import { resetTitle, setTitle } from "../screen.js";
+import useKey from "../hooks/useKey.js";
+import BoxScore from "./BoxScore.js";
+import AllPlays from "./AllPlays.js";
+const BOX_SCORE = 'BOX_SCORE';
+const ALL_PLAYS = 'ALL_PLAYS';
+const SCORING_PLAYS = 'SCORING_PLAYS';
 const getPlayer = (id, boxscore) => {
   var _boxscore$home, _boxscore$away;
   const homePlayer = (_boxscore$home = boxscore.home) === null || _boxscore$home === void 0 || (_boxscore$home = _boxscore$home.players) === null || _boxscore$home === void 0 ? void 0 : _boxscore$home['ID' + id];
@@ -37,24 +44,31 @@ const formatDecisions = (decisions, boxscore) => {
   }
   return content.join('\n');
 };
-const formatScore = (status, linescore) => {
-  let display = '';
-  if (status.detailedState === 'Postponed') {
-    display = status.detailedState;
-    if (status.reason) {
-      display += '\n' + status.reason;
-    }
-  } else {
-    display = `\n${linescore.teams.away.runs} - ${linescore.teams.home.runs}`;
-  }
-  return display;
-};
 function FinishedGame() {
+  const dispatch = useDispatch();
+  const id = useSelector(selectSelectedId);
   const boxscore = useSelector(selectBoxscore);
   const decisions = useSelector(selectDecisions);
   const linescore = useSelector(selectLineScore);
   const status = useSelector(selectGameStatus);
   const teams = useSelector(selectTeams);
+  const [view, setView] = React.useState(BOX_SCORE);
+  useKey('r', () => dispatch(setReplayGame(id)), {
+    key: 'R',
+    label: 'Replay'
+  });
+  useKey('b', () => setView(BOX_SCORE), {
+    key: 'B',
+    label: 'Box Score'
+  });
+  useKey('a', () => setView(ALL_PLAYS), {
+    key: 'A',
+    label: 'All Plays'
+  });
+  useKey('p', () => setView(SCORING_PLAYS), {
+    key: 'P',
+    label: 'Scoring Plays'
+  });
   useEffect(() => {
     if (get('title')) {
       const homeRuns = linescore.teams['home'].runs;
@@ -67,38 +81,61 @@ function FinishedGame() {
       };
     }
   }, [get, linescore, resetTitle, setTitle, teams]);
+  const bigTextOptions = {
+    font: 'Small Block'
+  };
   const awayTeam = `${teams.away.teamName}\n(${teams.away.record.wins}-${teams.away.record.losses})`;
+  const awayRuns = useMemo(() => figlet.textSync(linescore.teams.away.runs, bigTextOptions), [linescore.teams.away.runs]);
   const homeTeam = `${teams.home.teamName}\n(${teams.home.record.wins}-${teams.home.record.losses})`;
-  return /*#__PURE__*/React.createElement("element", null, /*#__PURE__*/React.createElement("element", {
-    height: "60%"
+  const homeRuns = useMemo(() => figlet.textSync(linescore.teams.home.runs, bigTextOptions), [linescore.teams.home.runs]);
+  return /*#__PURE__*/React.createElement("element", null, status.detailedState === 'Postponed' ? /*#__PURE__*/React.createElement("element", null, /*#__PURE__*/React.createElement("box", {
+    top: 1
+  }, "status.detailedState"), /*#__PURE__*/React.createElement("box", {
+    top: 2
+  }, status.reason)) : /*#__PURE__*/React.createElement("element", {
+    top: 1
   }, /*#__PURE__*/React.createElement("box", {
+    top: 1,
+    left: 0,
+    width: "25%",
     content: awayTeam,
-    width: "33%-1",
-    top: "50%",
+    align: "right"
+  }), /*#__PURE__*/React.createElement("box", {
+    top: 0,
+    left: "25%",
+    width: "25%",
+    content: awayRuns,
     align: "center"
   }), /*#__PURE__*/React.createElement("box", {
-    content: formatScore(status, linescore),
-    width: "33%-1",
-    left: "33%",
-    top: "50%",
+    top: 0,
+    left: "50%",
+    width: "25%",
+    content: homeRuns,
     align: "center"
   }), /*#__PURE__*/React.createElement("box", {
+    top: 1,
+    left: "75%",
+    width: "25%",
     content: homeTeam,
-    width: "34%",
-    top: "50%",
-    left: "66%",
-    align: "center"
-  })), /*#__PURE__*/React.createElement("element", {
-    top: "60%+1",
-    height: 3
+    align: "left"
+  }), /*#__PURE__*/React.createElement("element", {
+    top: 5,
+    left: 0,
+    width: "50%-2"
   }, /*#__PURE__*/React.createElement(LineScore, {
-    align: "center",
+    align: "right",
     final: true
   })), /*#__PURE__*/React.createElement("element", {
-    top: "60%+5",
-    left: "50%-20"
+    top: 5,
+    left: "50%+2",
+    width: "50%-2",
+    align: "right"
   }, /*#__PURE__*/React.createElement("box", {
     content: formatDecisions(decisions, boxscore)
-  })));
+  })), /*#__PURE__*/React.createElement("element", {
+    top: 9
+  }, view === BOX_SCORE && /*#__PURE__*/React.createElement(BoxScore, null), view === ALL_PLAYS && /*#__PURE__*/React.createElement(AllPlays, null), view === SCORING_PLAYS && /*#__PURE__*/React.createElement(AllPlays, {
+    scoringOnly: true
+  }))));
 }
 export default FinishedGame;

package/dist/components/Game.js

@@ -1,6 +1,6 @@
 import React, { useEffect, useRef } from 'react';
 import { useDispatch, useSelector } from "react-redux/lib/alternate-renderers.js";
-import { fetchGame, selectGame, selectSelectedId, selectFullUpdateRequired } from "../features/games.js";
+import { fetchGame, selectGame, selectSelectedId, selectFullUpdateRequired, selectDelay } from "../features/games.js";
 import PreviewGame from "./PreviewGame.js";
 import LiveGame from "./LiveGame.js";
 import FinishedGame from "./FinishedGame.js";
@@ -11,13 +11,15 @@ function Game() {
   const game = useSelector(selectGame);
   const fullUpdateRequired = useSelector(selectFullUpdateRequired);
   const id = useSelector(selectSelectedId);
+  const delay = useSelector(selectDelay);
   const timerRef = useRef(null);
   const timestampRef = useRef();
   timestampRef.current = fullUpdateRequired ? null : game === null || game === void 0 || (_game$metaData = game.metaData) === null || _game$metaData === void 0 ? void 0 : _game$metaData.timeStamp;
   const updateGameData = () => {
     dispatch(fetchGame({
       id,
-      start: timestampRef.current
+      start: timestampRef.current,
+      delay
     })).unwrap().then(result => {
       var _result$metaData;
       const wait = (result && ((_result$metaData = result.metaData) === null || _result$metaData === void 0 ? void 0 : _result$metaData.wait) || 10) * 1000;
@@ -29,7 +31,7 @@ function Game() {
     return () => {
       clearTimeout(timerRef.current);
     };
-  }, [id]);
+  }, [id, delay]);
   if (!game) {
     return /*#__PURE__*/React.createElement("element", null);
   }

package/dist/components/GameList.js

@@ -1,9 +1,9 @@
 function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
-import React, { useCallback, useEffect, useRef, useState } from 'react';
+import React, { useCallback, useEffect, useRef } from 'react';
 import { useDispatch, useSelector } from "react-redux/lib/alternate-renderers.js";
 import PropTypes from 'prop-types';
-import { add, format } from 'date-fns';
-import { fetchSchedule, selectData, selectLoading } from "../features/schedule.js";
+import { format } from 'date-fns';
+import { fetchSchedule, nextDay, prevDay, selectData, selectLoading, selectScheduleDate, setDate } from "../features/schedule.js";
 import { teamFavoriteStar } from "../utils.js";
 import Grid from "./Grid.js";
 import useKey from "../hooks/useKey.js";
@@ -98,8 +98,8 @@ function GameList({
   const dispatch = useDispatch();
   const schedule = useSelector(selectData);
   const loading = useSelector(selectLoading);
+  const date = useSelector(selectScheduleDate);
   const timerRef = useRef(null);
-  const [date, setDate] = useState(new Date());
   let games = [];
   if (schedule && schedule.dates.length > 0) {
     games = schedule.dates[0].games.slice().sort(compareGames);
@@ -109,19 +109,15 @@ function GameList({
     timerRef.current = setInterval(() => dispatch(fetchSchedule(date)), 30000);
     return () => clearInterval(timerRef.current);
   }, [date]);
-  useKey('p', useCallback(() => setDate(prev => add(prev, {
-    days: -1
-  })), []), {
+  useKey('p', useCallback(() => dispatch(prevDay()), []), {
     key: 'P',
     label: 'Prev Day'
   });
-  useKey('n', useCallback(() => setDate(prev => add(prev, {
-    days: 1
-  })), []), {
+  useKey('n', useCallback(() => dispatch(nextDay()), []), {
     key: 'N',
     label: 'Next Day'
   });
-  useKey('t', useCallback(() => setDate(new Date()), []), {
+  useKey('t', useCallback(() => dispatch(setDate(new Date())), []), {
     key: 'T',
     label: 'Today'
   });

package/dist/components/LiveGame.js

@@ -2,6 +2,7 @@ import React, { useEffect } from 'react';
 import { useSelector } from "react-redux/lib/alternate-renderers.js";
 import Count from "./Count.js";
 import Bases from "./Bases.js";
+import BoxScore from "./BoxScore.js";
 import LineScore from "./LineScore.js";
 import Matchup from "./Matchup.js";
 import AtBat from "./AtBat.js";
@@ -10,10 +11,27 @@ import InningDisplay from "./InningDisplay.js";
 import { get } from "../config.js";
 import { selectGameStatus, selectLineScore, selectTeams } from "../features/games.js";
 import { resetTitle, setTitle } from "../screen.js";
+import useKey from "../hooks/useKey.js";
+const GAME_STATUS = 'GAME_STATUS';
+const BOX_SCORE = 'BOX_SCORE';
+const SCORING_PLAYS = 'SCORING_PLAYS';
 function LiveGame() {
   const gameStatus = useSelector(selectGameStatus);
   const linescore = useSelector(selectLineScore);
   const teams = useSelector(selectTeams);
+  const [view, setView] = React.useState(GAME_STATUS);
+  useKey('g', () => setView(GAME_STATUS), {
+    key: 'G',
+    label: 'Game Status'
+  });
+  useKey('b', () => setView(BOX_SCORE), {
+    key: 'B',
+    label: 'Box Score'
+  });
+  useKey('p', () => setView(SCORING_PLAYS), {
+    key: 'P',
+    label: 'Scoring Plays'
+  });
   useEffect(() => {
     if (get('title')) {
       const homeRuns = linescore.teams['home'].runs;
@@ -62,7 +80,7 @@ function LiveGame() {
     type: "line",
     top: 3,
     width: "100%"
-  }), /*#__PURE__*/React.createElement("element", {
+  }), view === GAME_STATUS && /*#__PURE__*/React.createElement("element", {
     top: 4,
     left: 1
   }, /*#__PURE__*/React.createElement("element", {
@@ -79,6 +97,16 @@ function LiveGame() {
   }), /*#__PURE__*/React.createElement("element", {
     left: "50%+2",
     width: "50%-2"
-  }, /*#__PURE__*/React.createElement(AllPlays, null))));
+  }, /*#__PURE__*/React.createElement(AllPlays, {
+    reverse: true
+  }))), view === BOX_SCORE && /*#__PURE__*/React.createElement("element", {
+    top: 4,
+    left: 1
+  }, /*#__PURE__*/React.createElement(BoxScore, null)), view === SCORING_PLAYS && /*#__PURE__*/React.createElement("element", {
+    top: 4,
+    left: 1
+  }, /*#__PURE__*/React.createElement(AllPlays, {
+    scoringOnly: true
+  })));
 }
 export default LiveGame;

package/dist/components/PreviewGame.js

@@ -1,6 +1,6 @@
 import React, { useEffect } from 'react';
 import { useSelector } from "react-redux/lib/alternate-renderers.js";
-import { format } from 'date-fns';
+import { format, isSameDay } from 'date-fns';
 import { get } from "../config.js";
 import { selectTeams, selectVenue, selectStartTime, selectBoxscore, selectProbablePitchers, selectGameStatus } from "../features/games.js";
 import { resetTitle, setTitle } from "../screen.js";
@@ -42,10 +42,9 @@ function PreviewGame() {
 
       // Only show the date if it's not today.
       const startDate = new Date(startTime);
-      const today = format(new Date(), 'yyyy-DDD');
-      const gameDay = format(startDate, 'yyyy-DDD');
+      const today = new Date();
       let start = format(startDate, 'p');
-      if (today !== gameDay) {
+      if (!isSameDay(startDate, today)) {
         start = `${format(startDate, 'MMMM d, yyy')} ${start}`;
       }
       setTitle(`${away} - ${home} @ ${start}`);

package/dist/components/Standings.js

@@ -2,7 +2,7 @@ import React, { useEffect } from 'react';
 import PropTypes from 'prop-types';
 import { useDispatch, useSelector } from "react-redux/lib/alternate-renderers.js";
 import { fetchStandings, selectData } from "../features/standings.js";
-import { teamFavoriteStar } from "../utils.js";
+import { teamFavoriteStar, getSport } from "../utils.js";
 function formatHeaderRow(record) {
   return record.division.nameShort.padEnd(15) + '    W' + '    L' + '    PCT' + '    GB' + '  WCGB' + '   L10' + ' STRK';
 }
@@ -49,10 +49,52 @@ Division.propTypes = {
 function Standings() {
   const dispatch = useDispatch();
   const standings = useSelector(selectData);
+  const sport = getSport();
   useEffect(() => dispatch(fetchStandings()), []);
   if (!standings) {
     return /*#__PURE__*/React.createElement("element", null);
   }
+  if (sport === 'wbc') {
+    // WBC Pool Standings
+    if (!standings.records || standings.records.length === 0) {
+      return /*#__PURE__*/React.createElement("box", {
+        top: 0,
+        left: 0,
+        width: "100%",
+        height: "100%"
+      }, /*#__PURE__*/React.createElement("text", {
+        top: 1,
+        left: 2
+      }, "WBC Standings not available during this phase of the tournament."), /*#__PURE__*/React.createElement("text", {
+        top: 3,
+        left: 2
+      }, "Use Schedule view to see games and results."));
+    }
+
+    // Render WBC pools (records likely grouped by pool/division)
+    const halfPoint = Math.ceil(standings.records.length / 2);
+    return /*#__PURE__*/React.createElement("element", null, standings.records.slice(0, halfPoint).map((pool, idx) => {
+      var _pool$division;
+      return /*#__PURE__*/React.createElement(Division, {
+        top: idx * 7,
+        left: 0,
+        width: "50%-1",
+        key: ((_pool$division = pool.division) === null || _pool$division === void 0 ? void 0 : _pool$division.id) || idx,
+        record: pool
+      });
+    }), standings.records.slice(halfPoint).map((pool, idx) => {
+      var _pool$division2;
+      return /*#__PURE__*/React.createElement(Division, {
+        top: idx * 7,
+        left: "50%+1",
+        width: "50%-1",
+        key: ((_pool$division2 = pool.division) === null || _pool$division2 === void 0 ? void 0 : _pool$division2.id) || idx + halfPoint,
+        record: pool
+      });
+    }));
+  }
+
+  // MLB AL/NL Standings (existing logic)
   return /*#__PURE__*/React.createElement("element", null, standings.records.filter(record => record.league.id === 103).map((record, idx) => /*#__PURE__*/React.createElement(Division, {
     top: idx * 7,
     left: 0,

package/dist/components/Table.js

@@ -0,0 +1,44 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+function formatRow(row, widths) {
+  return row.map((cell, idx) => idx === 0 ? cell.padEnd(widths[idx]) : cell.padStart(widths[idx])).join('');
+}
+function Table({
+  headers,
+  widths,
+  rows,
+  ...rest
+}) {
+  const resolvedWidths = widths.map((width, idx) => {
+    if (width !== 'auto') {
+      return width;
+    }
+    return Math.max((headers[idx] || '').length, ...rows.map(row => (row[idx] || '').length));
+  });
+  const headerRow = formatRow(headers, resolvedWidths);
+  const contentRows = rows.map(row => formatRow(row, resolvedWidths));
+  return /*#__PURE__*/React.createElement("element", rest, /*#__PURE__*/React.createElement("box", {
+    top: 0,
+    left: 0,
+    width: "100%",
+    height: 1,
+    fg: "black",
+    bg: "white",
+    wrap: false,
+    content: headerRow
+  }), /*#__PURE__*/React.createElement("box", {
+    top: 1,
+    left: 0,
+    width: "100%",
+    height: rows.length,
+    wrap: false,
+    content: contentRows.join('\n')
+  }));
+}
+Table.propTypes = {
+  headers: PropTypes.arrayOf(PropTypes.string),
+  widths: PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.number, PropTypes.oneOf(['auto'])])),
+  rows: PropTypes.arrayOf(PropTypes.arrayOf(PropTypes.string)),
+  top: PropTypes.number
+};
+export default Table;

package/dist/config.js

@@ -79,6 +79,16 @@ const schema = {
   'title': {
     type: 'boolean',
     default: false
+  },
+  'live-delay': {
+    type: 'number',
+    default: 0,
+    minimum: 0
+  },
+  'sport': {
+    type: 'string',
+    enum: ['mlb', 'wbc'],
+    default: 'mlb'
   }
 };
 const config = new Conf({
@@ -92,11 +102,13 @@ function serialize(value) {
   return value;
 }
 function deserialize(key, value) {
-  var _schema$key, _schema$key2;
+  var _schema$key, _schema$key2, _schema$key3;
   if (value && ((_schema$key = schema[key]) === null || _schema$key === void 0 ? void 0 : _schema$key.type) === 'array') {
     return value.split(/\s*,\s*/);
   } else if (((_schema$key2 = schema[key]) === null || _schema$key2 === void 0 ? void 0 : _schema$key2.type) === 'boolean') {
     return value === 'true';
+  } else if (((_schema$key3 = schema[key]) === null || _schema$key3 === void 0 ? void 0 : _schema$key3.type) === 'number') {
+    return parseInt(value);
   }
   return value;
 }

package/dist/features/games.js

@@ -6,19 +6,42 @@ const {
   createSelector
 } = reduxjsToolkit;
 import jsonpatch from 'json-patch';
+import { UTCDate } from '@date-fns/utc';
+import { addSeconds, differenceInSeconds, format } from 'date-fns';
+import logger from "../logger.js";
+import { get } from "../config.js";
 const initialState = {
   loading: false,
   fullUpdateRequired: false,
   error: null,
   selectedId: null,
+  delay: 0,
   games: {}
 };
+function makeDiffParams(start, end) {
+  const endParam = start ? '&endTimecode=' : '?timecode=';
+  const startParam = start ? `/diffPatch?startTimecode=${start}` : '';
+  if (end) {
+    return `${startParam}${endParam}${end}`;
+  } else {
+    return startParam;
+  }
+}
 export const fetchGame = createAsyncThunk('games/fetch', async ({
   id,
-  start
+  start,
+  delay
 }) => {
-  const diffParams = start ? `/diffPatch?startTimecode=${start}` : '';
+  const end = delay > 0 ? format(addSeconds(new UTCDate(Date.now()), -delay), 'yyyyMMdd_HHmmss') : null;
+  const diffParams = makeDiffParams(start, end);
   const url = `https://statsapi.mlb.com/api/v1.1/game/${id}/feed/live${diffParams}`;
+  logger.info(`GET ${url}`);
+  const response = await axios.get(url);
+  return response.data;
+});
+export const setReplayGame = createAsyncThunk('games/setReplay', async id => {
+  const url = `https://statsapi.mlb.com/api/v1.1/game/${id}/feed/live?fields=gamePk,gameData,datetime,gameInfo,dateTime,firstPitch`;
+  logger.info(`GET ${url}`);
   const response = await axios.get(url);
   return response.data;
 });
@@ -26,11 +49,28 @@ export const gamesSlice = createSlice({
   name: 'games',
   initialState,
   reducers: {
-    setSelectedId(state, action) {
+    setLiveGame(state, action) {
       state.selectedId = action.payload;
+      state.delay = get('live-delay') || 0;
     }
   },
   extraReducers: builder => {
+    builder.addCase(setReplayGame.pending, state => {
+      state.loading = true;
+    });
+    builder.addCase(setReplayGame.fulfilled, (state, action) => {
+      state.loading = false;
+      state.error = null;
+      state.selectedId = action.payload.gamePk;
+      state.fullUpdateRequired = true;
+      const start = action.payload.gameData.gameInfo.firstPitch || action.payload.gameData.datetime.dateTime;
+      state.delay = differenceInSeconds(new Date(), start);
+    });
+    builder.addCase(setReplayGame.rejected, (state, action) => {
+      state.loading = false;
+      state.fullUpdateRequired = true;
+      state.error = action.error;
+    });
     builder.addCase(fetchGame.pending, state => {
       state.loading = true;
     });
@@ -70,13 +110,14 @@ export const gamesSlice = createSlice({
   }
 });
 export const {
-  setSelectedId
+  setLiveGame
 } = gamesSlice.actions;
 const gamesRoot = state => state.games;
 export const selectLoading = createSelector(gamesRoot, root => root.loading);
 export const selectError = createSelector(gamesRoot, root => root.error);
 export const selectFullUpdateRequired = createSelector(gamesRoot, root => root.fullUpdateRequired);
 export const selectSelectedId = createSelector(gamesRoot, root => root.selectedId);
+export const selectDelay = createSelector(gamesRoot, root => root.delay);
 export const selectGame = createSelector([gamesRoot, selectSelectedId], (root, id) => root.games[id]);
 const selectLiveData = createSelector(selectGame, game => game.liveData);
 const selectPlays = createSelector(selectLiveData, data => data.plays);
@@ -90,6 +131,7 @@ export const selectLineScore = createSelector(selectLiveData, data => data.lines
 export const selectDecisions = createSelector(selectLiveData, data => data.decisions);
 const selectGameData = createSelector(selectGame, game => game.gameData);
 export const selectGameStatus = createSelector(selectGameData, game => game.status);
+export const selectPlayers = createSelector(selectGameData, gameData => gameData.players);
 export const selectTeams = createSelector(selectGameData, gameData => gameData.teams);
 export const selectVenue = createSelector(selectGameData, gameData => gameData.venue);
 export const selectStartTime = createSelector(selectGameData, gameData => {

package/dist/features/schedule.js

@@ -5,21 +5,38 @@ const {
   createSlice,
   createSelector
 } = reduxjsToolkit;
-import { format } from 'date-fns';
+import { add, format } from 'date-fns';
+import { getSportId } from "../utils.js";
 const initialState = {
+  scheduleDate: new Date(),
   loading: false,
   error: null,
   data: null
 };
 export const fetchSchedule = createAsyncThunk('schedule/fetch', async date => {
   const dateStr = format(date, 'MM/dd/yyyy');
-  const response = await axios.get(`http://statsapi.mlb.com/api/v1/schedule?sportId=1&hydrate=team,linescore&date=${dateStr}`);
+  const sportId = getSportId();
+  const response = await axios.get(`http://statsapi.mlb.com/api/v1/schedule?sportId=${sportId}&hydrate=team,linescore&date=${dateStr}`);
   return response.data;
 });
 export const scheduleSlice = createSlice({
   name: 'schedule',
   initialState,
-  reducers: {},
+  reducers: {
+    nextDay(state) {
+      state.scheduleDate = add(state.scheduleDate, {
+        days: 1
+      });
+    },
+    prevDay(state) {
+      state.scheduleDate = add(state.scheduleDate, {
+        days: -1
+      });
+    },
+    setDate(state, action) {
+      state.scheduleDate = action.payload;
+    }
+  },
   extraReducers: builder => {
     builder.addCase(fetchSchedule.pending, state => {
       state.loading = true;
@@ -40,4 +57,10 @@ const scheduleSelector = state => state.schedule;
 export const selectLoading = createSelector(scheduleSelector, schedule => schedule.loading);
 export const selectError = createSelector(scheduleSelector, schedule => schedule.error);
 export const selectData = createSelector(scheduleSelector, schedule => schedule.data);
+export const selectScheduleDate = createSelector(scheduleSelector, schedule => schedule.scheduleDate);
+export const {
+  nextDay,
+  prevDay,
+  setDate
+} = scheduleSlice.actions;
 export default scheduleSlice.reducer;

package/dist/features/standings.js

@@ -5,6 +5,7 @@ const {
   createSlice,
   createSelector
 } = reduxjsToolkit;
+import { getSport } from "../utils.js";
 const initialState = {
   loading: false,
   error: null,
@@ -12,9 +13,18 @@ const initialState = {
 };
 const SEASON = new Date().getFullYear();
 export const fetchStandings = createAsyncThunk('standings/fetch', async () => {
-  const url = `https://statsapi.mlb.com/api/v1/standings?leagueId=103,104&season=${SEASON}&standingsTypes=regularSeason&hydrate=division,team`;
-  const response = await axios.get(url);
-  return response.data;
+  const sport = getSport();
+  if (sport === 'wbc') {
+    // WBC standings - try sportId-based endpoint
+    // If no data, return empty structure (component will handle gracefully)
+    const response = await axios.get(`https://statsapi.mlb.com/api/v1/standings?sportId=51&season=${SEASON}`);
+    return response.data;
+  } else {
+    // MLB standings (existing logic)
+    const url = `https://statsapi.mlb.com/api/v1/standings?leagueId=103,104&season=${SEASON}&standingsTypes=regularSeason&hydrate=division,team`;
+    const response = await axios.get(url);
+    return response.data;
+  }
 });
 export const standingsSlice = createSlice({
   name: 'standings',

package/dist/main.js

@@ -5,7 +5,7 @@ import screen from "./screen.js";
 import store from "./store/index.js";
 import log from "./logger.js";
 import App from "./components/App.js";
-export default async function startInterface() {
+export default async function startInterface(options) {
   raf.polyfill();
   process.on('uncaughtException', function (error) {
     log.error('UNCAUGHT EXCEPTION\n' + JSON.stringify(error) + '\n' + error.stack);
@@ -16,5 +16,8 @@ export default async function startInterface() {
   const reactBlessed = await import('react-blessed');
   reactBlessed.render( /*#__PURE__*/React.createElement(Provider, {
     store: store
-  }, /*#__PURE__*/React.createElement(App, null)), screen());
+  }, /*#__PURE__*/React.createElement(App, {
+    replayId: options.replay,
+    defaultDate: options.date
+  })), screen());
 }

package/dist/utils.js

@@ -6,4 +6,26 @@ export function teamFavoriteStar(team) {
     return `{${style}}★{/${style}} `;
   }
   return '';
+}
+
+/**
+ * Get the sport ID for API calls
+ * @returns {string} '51' for WBC, '1' for MLB
+ */
+export function getSportId() {
+  var _process$env$PLAYBALL;
+  // ENV override takes precedence
+  const envSport = (_process$env$PLAYBALL = process.env.PLAYBALL_SPORT) === null || _process$env$PLAYBALL === void 0 ? void 0 : _process$env$PLAYBALL.toLowerCase();
+  const sport = envSport || get('sport') || 'mlb';
+  return sport === 'wbc' ? '51' : '1';
+}
+
+/**
+ * Get the current sport setting
+ * @returns {string} 'mlb' or 'wbc'
+ */
+export function getSport() {
+  var _process$env$PLAYBALL2;
+  const envSport = (_process$env$PLAYBALL2 = process.env.PLAYBALL_SPORT) === null || _process$env$PLAYBALL2 === void 0 ? void 0 : _process$env$PLAYBALL2.toLowerCase();
+  return envSport || get('sport') || 'mlb';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playball",
-  "version": "3.2.0",
+  "version": "3.4.0",
   "description": "Watch MLB games from the comfort of your terminal",
   "keywords": [
     "MLB",
@@ -16,7 +16,8 @@
     "lint": "eslint --ext .jsx,.js src",
     "start": "babel src --out-dir dist --watch",
     "prepublishOnly": "npm run build",
-    "react-devtools": "react-devtools"
+    "react-devtools": "react-devtools",
+    "test": "echo \"No tests yet\""
   },
   "bin": {
     "playball": "./bin/playball.js"
@@ -37,12 +38,14 @@
   "preferGlobal": true,
   "license": "MIT",
   "dependencies": {
+    "@date-fns/utc": "^2.1.1",
     "@reduxjs/toolkit": "^1.8.0",
     "axios": "^0.26.1",
     "blessed": "^0.1.81",
     "commander": "^11.0.0",
     "conf": "^11.0.1",
-    "date-fns": "^2.28.0",
+    "date-fns": "^4.1.0",
+    "figlet": "^1.10.0",
     "json-patch": "^0.7.0",
     "prop-types": "^15.8.1",
     "raf": "^3.4.1",