@tailgatefantasysports/seasonservice 0.5.1 → 0.6.1

package/SeasonService.js

@@ -71,28 +71,64 @@ module.exports = class SeasonService {
     }
 
     /**
-     * Get the previous complete season, including all types.
-     * @summary Starting from `date`, walk backwards by one week to the nearest season.
-     * Using that seasons `season` property continue to walk backwards to find all types of previous season.
+     * Get the last season that finished, including all of its types.
+     * @summary Walks backwards from `date` a whole season at a time until it reaches one whose
+     * every frame has ended, then collects that season's frames keyed by type.
+     *
+     * Stepping back one *frame* is not enough. Mid-season, one frame back is the same season's
+     * preseason. And in the gap between a season's preseason and its regular season, the
+     * nearest frame behind `date` is that same season's preseason — a season that has barely
+     * begun, not the last one to finish.
+     *
      * @param {object} date - date to begin search
-     * @returns {object}
+     * @returns {object|null} frames keyed by type, or null when no earlier season exists
      */
     getPreviousFullSeason(date) {
-        let frame = this.getPreviousSeason(date);
+        let frame = this.getSeason(date) || this._getSeasonDirection(date, -1);
+
+        while (frame && !this._isSeasonFinished(frame.season, date))
+            frame = this._skipSeason(frame);
+
         if (!frame)
-            return null
+            return null;
 
         const full = { };
-        let season = frame.season,
-            newFrame = frame;
-        while (newFrame && newFrame.season === season) {
-            full[newFrame.type] = newFrame;
-            newFrame = this.getPreviousSeason(new Date(newFrame.start - 1))
+        const season = frame.season;
+        while (frame && frame.season === season) {
+            full[frame.type] = frame;
+            frame = this._getSeasonDirection(new Date(frame.start - 1), -1);
         }
 
         return full;
     }
 
+    /**
+     * Whether every configured frame of a season has ended by `date`.
+     * @param {string|number} season - season key into the timeframes config
+     * @param {object} date - js date to measure against
+     * @returns {boolean}
+     */
+    _isSeasonFinished(season, date) {
+        const frames = this.timeframes[season];
+        if (!frames)
+            return false;
+
+        return Object.values(frames).every(({ end }) => end <= date);
+    }
+
+    /**
+     * Walks backwards past every frame of `frame`'s season to the nearest frame before it.
+     * @param {object} frame - season frame to step back from
+     * @returns {object|undefined} the preceding season's latest frame, if any
+     */
+    _skipSeason(frame) {
+        const season = frame.season;
+        while (frame && frame.season === season)
+            frame = this._getSeasonDirection(new Date(frame.start - 1), -1);
+
+        return frame;
+    }
+
     /**
      * Returns the regular season frame for a given season year, or null if not configured.
      * @param {string|number} seasonYear

package/__tests__/SeasonService.test.js

@@ -127,21 +127,28 @@ describe('GetPreviousFullSeason', () => {
                 end: new Date('2022-04-01')
             }
         }],
+        // Inside season 3, so season 3 is the *current* season and cannot be the previous one.
+        // The answer is season 2, whole. This previously returned season 3's preseason and
+        // regular frames — a partial, in-progress season reported as a finished one.
         ['Exists - start inside frame', new Date('2022-02-02'), {
-            [types.preseason]: {
-                season: "3",
-                type: types.preseason,
-                start: new Date('2022-01-01'),
-                end: new Date('2022-02-01')
-            },
             [types.regular]: {
-                season: "3",
+                season: "2",
                 type: types.regular,
-                start: new Date('2022-02-01'),
-                end: new Date('2022-03-01')
+                start: new Date('2021-03-01'),
+                end: new Date('2021-04-01')
             },
         }],
-        ['Doesn\'t exist', new Date('2019-01-01'), null]
+        ['Doesn\'t exist', new Date('2019-01-01'), null],
+        // Mid-season, one frame back is the *same* season's preseason. Skipping only the
+        // current frame rather than the whole season would report season 3 as previous.
+        ['Exists - mid regular season', new Date('2022-02-20'), {
+            [types.regular]: {
+                season: "2",
+                type: types.regular,
+                start: new Date('2021-03-01'),
+                end: new Date('2021-04-01')
+            },
+        }]
     ])('%s', (_tName, inp, expected) => {
         // setup
         // execute
@@ -150,4 +157,39 @@ describe('GetPreviousFullSeason', () => {
         // assert
         expect(season).toStrictEqual(expected);
     });
+});
+
+describe('GetPreviousFullSeason — real calendar', () => {
+    // The configured singleton, not the bare class the synthetic fixtures above use.
+    const { SeasonService: configured } = require('../index');
+
+    // The case this method exists for: during the 2026 preseason the app asks what last season
+    // was, to show finished-season stats. It used to answer "2026 preseason" — the frame the
+    // date sits in — so the app showed preseason stats beside a regular-season fixture.
+    test.each([
+        ['from the 2026 preseason', new Date('2026-08-23T00:00:00Z')],
+        ['from mid 2026 regular season', new Date('2026-11-01T00:00:00Z')],
+        ['from the 2026 off-season', new Date('2026-05-01T00:00:00Z')],
+        // The gap between the 2026 preseason ending and week 1 kicking off. No frame contains
+        // these dates, and the nearest one behind them is the 2026 preseason.
+        ['from the day the 2026 preseason ends', new Date('2026-09-02T00:00:00Z')],
+        ['from the eve of the 2026 regular season', new Date('2026-09-08T18:00:00Z')]
+    ])('%s answers 2025, whole', (_tName, date) => {
+        const full = configured.getPreviousFullSeason(date);
+        expect(full).not.toBeNull();
+
+        const frames = Object.values(full);
+        expect(frames.every(f => f.season === '2025')).toBe(true);
+        expect(frames.map(f => f.type).sort()).toEqual(
+            [types.preseason, types.regular, types.postseason].sort());
+    });
+
+    test('never reports the season the date sits inside', () => {
+        const inPreseason = new Date('2026-08-23T00:00:00Z');
+        const current = configured.getSeason(inPreseason);
+        const full = configured.getPreviousFullSeason(inPreseason);
+
+        expect(current.season).toBe('2026');
+        expect(Object.values(full).some(f => f.season === current.season)).toBe(false);
+    });
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tailgatefantasysports/seasonservice",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "description": "Generic Season Service",
   "main": "index.js",
   "scripts": {