@tailgatefantasysports/seasonservice 0.5.0 → 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/__tests__/index.test.js

@@ -7,7 +7,9 @@ describe('Service', () => {
             ['2020 Post', new Date('2021-01-20T00:00:00Z'), '2020', 2, new Date('2021-01-07T00:00:00Z'), new Date('2021-02-07T00:00:00Z')],
             ['2021 Beta', new Date('2021-06-20T00:00:00Z'), 'BETA', 'beta', new Date('2021-06-16T00:00:00Z'), new Date('2021-08-05T00:00:00Z')],
             ['2021 Regular', new Date('2021-09-10T00:00:00Z'), '2021', 1, new Date('2021-09-08T00:00:00Z'), new Date('2022-01-12T00:00:00Z')],
-            ['2021 Post', new Date('2022-01-20T00:00:00Z'), '2021', 2, new Date('2022-01-12T00:00:00Z'), new Date('2022-02-15T00:00:00Z')]
+            ['2021 Post', new Date('2022-01-20T00:00:00Z'), '2021', 2, new Date('2022-01-12T00:00:00Z'), new Date('2022-02-15T00:00:00Z')],
+            ['2026 Preseason', new Date('2026-08-13T23:00:00Z'), '2026', 0, new Date('2026-08-12T00:00:00Z'), new Date('2026-09-02T00:00:00Z')],
+            ['2026 Regular', new Date('2026-10-11T23:00:00Z'), '2026', 1, new Date('2026-09-09T00:00:00Z'), new Date('2027-01-13T00:00:00Z')]
         ])('%s', (_tName, date, season, type, start, end) => {
             let frame = SeasonService.getSeason(date);
                 expect(frame.season).toBe(season);
@@ -15,6 +17,34 @@ describe('Service', () => {
                 expect(frame.start).toStrictEqual(start);
                 expect(frame.end).toStrictEqual(end);
         });
+
+        // The Aug 6 Hall of Fame game sits outside the preseason frame on
+        // purpose — the game sync drops it, so week 1 is the Aug 13-15 slate.
+        test('2026 Hall of Fame game is outside the preseason frame', () => {
+            expect(SeasonService.getSeason(new Date('2026-08-06T23:00:00Z'))).toBeUndefined();
+        });
+    });
+
+    // Each frame's weeks must line up with the provider's week numbering:
+    // dates below are the first and last day of each slate on the real 2026
+    // schedule, at 7pm ET.
+    describe('Get Week — 2026 slates match provider weeks', () => {
+        test.each([
+            ['Preseason Week 1 open', new Date('2026-08-13T23:00:00Z'), 1],
+            ['Preseason Week 1 close', new Date('2026-08-15T23:00:00Z'), 1],
+            ['Preseason Week 2 open', new Date('2026-08-20T23:00:00Z'), 2],
+            ['Preseason Week 2 close', new Date('2026-08-23T23:00:00Z'), 2],
+            ['Preseason Week 3 open', new Date('2026-08-27T23:00:00Z'), 3],
+            ['Preseason Week 3 close', new Date('2026-08-29T23:00:00Z'), 3],
+            ['Regular Week 1 open', new Date('2026-09-09T23:00:00Z'), 1],
+            ['Regular Week 1 close', new Date('2026-09-14T23:00:00Z'), 1],
+            ['Regular Week 2 open', new Date('2026-09-17T23:00:00Z'), 2],
+            ['Regular Week 17 open', new Date('2026-12-31T23:00:00Z'), 17],
+            ['Regular Week 17 close', new Date('2027-01-04T23:00:00Z'), 17],
+            ['Regular Week 18', new Date('2027-01-10T23:00:00Z'), 18]
+        ])('%s', (_tName, date, week) => {
+            expect(SeasonService.getWeek(date).week).toBe(week);
+        });
     });
 });
 

package/app.config.js

@@ -89,12 +89,17 @@ module.exports = {
             }
         },
         2026: {
+            // Frames start the Wednesday 00:00Z before their week 1 games so the
+            // service's week N matches the provider's week N. The Aug 6 Hall of
+            // Fame game is intentionally outside the preseason frame — the game
+            // sync filters it out (its "Hall of Fame Weekend" label has no week
+            // number), so preseason week 1 is the Aug 13-15 slate.
             [types.preseason]: {
-                start: new Date('2026-08-05T00:00:00Z'),
-                end: new Date('2026-09-06T00:00:00Z')
+                start: new Date('2026-08-12T00:00:00Z'),
+                end: new Date('2026-09-02T00:00:00Z')
             },
             [types.regular]: {
-                start: new Date('2026-09-06T00:00:00Z'),
+                start: new Date('2026-09-09T00:00:00Z'),
                 end: new Date('2027-01-13T00:00:00Z'),
             },
             [types.postseason]: {

package/package.json

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