@tailgatefantasysports/seasonservice 0.5.1 → 0.6.0

package/SeasonService.js

@@ -71,23 +71,36 @@ 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` past every frame of the season `date` falls in, then
+     * collects all frames of the season before it, keyed by type.
+     *
+     * A season `date` sits inside has not finished, so it is never the answer. Skipping the
+     * whole season rather than just the current frame matters mid-season: from a regular-season
+     * date, stepping back one frame lands on that same season's preseason, which would report a
+     * partial in-progress season as the previous one.
+     *
      * @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);
+        const current = this.getSeason(date);
+        let frame = current || this._getSeasonDirection(date, -1);
         if (!frame)
-            return null
+            return null;
+
+        if (current) {
+            while (frame && frame.season === current.season)
+                frame = this._getSeasonDirection(new Date(frame.start - 1), -1);
+            if (!frame)
+                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;

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,35 @@ 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')]
+    ])('%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.0",
   "description": "Generic Season Service",
   "main": "index.js",
   "scripts": {