@maestro_io/maestro-web-sdk 4.0.2 → 5.1.0

package/dist/src/modules/{stats → espn/stats}/view-model/StatsViewModel.js

@@ -1,9 +1,9 @@
-import { Observable } from '../../../helpers/Observable';
-import { ViewModel } from '../../../view-models/ViewModel';
+import { Observable } from '../../../../helpers/Observable';
+import { ViewModel } from '../../../../view-models/ViewModel';
 import { MOCK_STATS_API_PRE_GAME_RESPONSE } from '../mocks';
-import StatsService from '@/services/StatsService';
+import { isTabbedStatisticsArray, isTeamStatistic, isHockeyScoringSummary, isMlbScoringSummary, } from '../interfaces/IStats';
+import StatsService from '../services/StatsService';
 import { formatLastPlayMarquee, parseDriveDescription, } from '../utils/driveSummaryUtils';
-import AnalyticsService from '@/services/AnalyticsService/AnalyticsService';
 import { setImageDimensions } from '@/helpers/url';
 import SDK from '@/index';
 import { captureException } from '@/sentry';
@@ -22,15 +22,17 @@ const STATS_ITEM_TYPE_CARD_MAP = {
     gameLeaders: 'leaders',
     headerTeam: 'header',
     matchPredictor: 'predictor',
+    playerSeasonStats: 'playerStats',
     promotion: 'promotion',
     recentGames: 'previousGames',
     scoringSummary: 'scoringSummary',
     teamStats: 'entities',
     winProbability: 'winProbability',
+    careerMatchup: 'careerMatchup',
     penalties: 'penaltySummary',
 };
 export class StatsViewModel extends ViewModel {
-    constructor(eventId, delegate, options = {}) {
+    constructor(eventId, delegate, analyticsService, options = {}) {
         super();
         Object.defineProperty(this, "isDataLoading", {
             enumerable: true,
@@ -140,7 +142,7 @@ export class StatsViewModel extends ViewModel {
         this.eventId = eventId;
         this.useMockData = options.useMockData || false;
         this.statsService = new StatsService(delegate);
-        this.analyticsService = new AnalyticsService();
+        this.analyticsService = analyticsService;
     }
     /**
      * Sets panel-specific data configuration
@@ -369,22 +371,39 @@ export class StatsViewModel extends ViewModel {
         if (matchPredictor) {
             statsItems.push(matchPredictor);
         }
-        const driveSummary = this.parseDriveSummary(data);
-        if (driveSummary.length > 0) {
-            statsItems.push(...driveSummary);
+        const careerMatchup = this.parseCareerMatchup(data);
+        if (careerMatchup) {
+            statsItems.push(careerMatchup);
         }
-        const activeAthletes = this.parseActiveAthletes(data);
-        if (activeAthletes) {
-            statsItems.push(activeAthletes);
+        const playerSeasonStats = this.parsePlayerSeasonStats(data);
+        if (playerSeasonStats) {
+            statsItems.push(playerSeasonStats);
         }
         const scoringSummary = this.parseScoringSummary(data);
         if (scoringSummary) {
             statsItems.push(scoringSummary);
         }
+        const winProbability = this.parseWinProbability(data);
+        if (winProbability) {
+            statsItems.push(winProbability);
+        }
+        // Team Stats (prefer season stats when available; fallback to game stats)
+        const teamStats = this.parseTeamSeasonStatistics(data) || this.parseTeamsStatistics(data);
+        if (teamStats) {
+            statsItems.push(teamStats);
+        }
+        const driveSummary = this.parseDriveSummary(data);
+        if (driveSummary.length > 0) {
+            statsItems.push(...driveSummary);
+        }
         const penalties = this.parsePenalties(data);
         if (penalties) {
             statsItems.push(penalties);
         }
+        const activeAthletes = this.parseActiveAthletes(data);
+        if (activeAthletes) {
+            statsItems.push(activeAthletes);
+        }
         const gameLeaders = this.parseGameLeaders(data);
         if (gameLeaders) {
             statsItems.push(gameLeaders);
@@ -393,14 +412,6 @@ export class StatsViewModel extends ViewModel {
         if (recentGames) {
             statsItems.push(recentGames);
         }
-        const winProbability = this.parseWinProbability(data);
-        if (winProbability) {
-            statsItems.push(winProbability);
-        }
-        const teamsStatistics = this.parseTeamsStatistics(data);
-        if (teamsStatistics) {
-            statsItems.push(teamsStatistics);
-        }
         const promotion = this.parsePromotion(data);
         if (promotion) {
             statsItems.push(promotion);
@@ -462,16 +473,22 @@ export class StatsViewModel extends ViewModel {
         for (let i = 0; i < awayTeam.statistics.length; i++) {
             const awayStat = awayTeam.statistics[i];
             const homeStat = homeTeam.statistics[i];
-            statistics.push({
-                awayTeamDisplayValue: awayStat?.displayValue || '0',
-                displayName: awayStat.displayName || '',
-                homeTeamDisplayValue: homeStat?.displayValue || '0',
-                awayTeamValue: awayStat?.value || 0,
-                homeTeamValue: homeStat?.value || 0,
-            });
+            if (isTeamStatistic(awayStat) && isTeamStatistic(homeStat)) {
+                statistics.push({
+                    awayTeamDisplayValue: awayStat?.displayValue || '0',
+                    displayName: awayStat.displayName || '',
+                    homeTeamDisplayValue: homeStat?.displayValue || '0',
+                    awayTeamValue: awayStat?.value || 0,
+                    homeTeamValue: homeStat?.value || 0,
+                });
+            }
+        }
+        if (!statistics.length) {
+            return null;
         }
         return {
             type: 'teamStats',
+            title: 'Team Stats',
             awayTeam: {
                 logo: awayTeam.logo,
                 displayName: awayTeam.displayName || '',
@@ -487,6 +504,78 @@ export class StatsViewModel extends ViewModel {
             statistics,
         };
     }
+    parseTeamSeasonStatistics(data) {
+        const teams = data.entities?.teams || {};
+        if (!Object.keys(teams).length ||
+            !data.statTeams ||
+            !data.statTeams.title ||
+            !data.statTeams.sections?.length ||
+            !data.statTeams.teams?.length) {
+            return null;
+        }
+        const awayTeamKey = data.statTeams.teams[0]?.$key;
+        const homeTeamKey = data.statTeams.teams[1]?.$key;
+        if (!awayTeamKey || !homeTeamKey) {
+            return null;
+        }
+        const awayTeam = teams[awayTeamKey];
+        const homeTeam = teams[homeTeamKey];
+        if (!homeTeam || !awayTeam) {
+            return null;
+        }
+        const tabbedStatistics = {};
+        data.statTeams.sections.forEach((section) => {
+            if (!!section.$key && !!section.title) {
+                const sectionKeyStatistics = [];
+                if (isTabbedStatisticsArray(homeTeam.statistics) &&
+                    isTabbedStatisticsArray(awayTeam.statistics)) {
+                    const homeSectionStats = homeTeam.statistics.find((st) => st.$key === section.$key);
+                    const awaySectionStats = awayTeam.statistics.find((st) => st.$key === section.$key);
+                    if (homeSectionStats &&
+                        awaySectionStats &&
+                        awaySectionStats.stats?.length &&
+                        homeSectionStats.stats?.length) {
+                        for (let i = 0; i < awaySectionStats.stats.length; i++) {
+                            const awayStat = awaySectionStats.stats[i];
+                            const homeStat = homeSectionStats.stats[i];
+                            sectionKeyStatistics.push({
+                                awayTeamDisplayValue: awayStat?.displayValue || '0',
+                                displayName: awayStat.displayName || '',
+                                homeTeamDisplayValue: homeStat?.displayValue || '0',
+                                awayTeamValue: awayStat?.displayValue
+                                    ? Number(awayStat.displayValue)
+                                    : 0,
+                                homeTeamValue: homeStat?.displayValue
+                                    ? Number(homeStat.displayValue)
+                                    : 0,
+                            });
+                        }
+                        tabbedStatistics[section.$key] = {
+                            title: section.title,
+                            entries: sectionKeyStatistics,
+                        };
+                    }
+                }
+            }
+        });
+        return {
+            type: 'teamStats',
+            title: data.statTeams.title,
+            awayTeam: {
+                abbreviation: awayTeam.abbreviation,
+                displayName: awayTeam.displayName || '',
+                color: awayTeam.color || '',
+                logo: awayTeam.logo,
+            },
+            homeTeam: {
+                abbreviation: homeTeam.abbreviation,
+                displayName: homeTeam.displayName || '',
+                color: homeTeam.color || '',
+                logo: homeTeam.logo,
+            },
+            tabbedStatistics,
+        };
+    }
     parseMatchPredictor(data) {
         const teams = data.entities?.teams;
         const predictor = data.predictor;
@@ -534,31 +623,137 @@ export class StatsViewModel extends ViewModel {
             backgroundImage: promotion.backgroundImage || '',
         };
     }
+    parseCareerMatchup(response) {
+        const careerMatchup = response.careerMatchup;
+        const athletes = response.entities?.athletes;
+        if (!careerMatchup || !careerMatchup.sections) {
+            return null;
+        }
+        const toText = (value) => {
+            if (typeof value === 'string')
+                return value;
+            if (value && typeof value === 'object') {
+                const maybeDisplayName = value
+                    .displayName;
+                if (typeof maybeDisplayName === 'string')
+                    return maybeDisplayName;
+            }
+            return '';
+        };
+        const sections = careerMatchup.sections
+            .filter((section) => !!section)
+            .map((section) => {
+            const items = (section.items || [])
+                .filter((item) => !!item)
+                .map((item) => {
+                const athleteKey = item.athlete?.$key;
+                const athlete = athletes && athleteKey ? athletes[athleteKey] : undefined;
+                // Determine if this item should be highlighted (e.g. warning color)
+                // This abstraction allows the View to be sport-agnostic.
+                // Currently only "On Deck" in MLB triggers this.
+                const statusText = toText(item.status);
+                const isHighlighted = statusText === 'On Deck';
+                return {
+                    status: statusText,
+                    type: toText(item.type) || '',
+                    displayName: toText(item.displayName) || '',
+                    athlete,
+                    isHighlighted,
+                };
+            });
+            const statistics = (section.statistics || [])
+                .filter((stat) => !!stat)
+                .map((stat) => ({
+                abbreviation: stat.abbreviation || '',
+                displayValue: stat.displayValue || '',
+            }));
+            return {
+                items,
+                statistics,
+            };
+        });
+        return {
+            type: 'careerMatchup',
+            title: careerMatchup.title || '',
+            sections,
+        };
+    }
     parseHeaderTeams(response) {
+        return (this.parseHeaderTeamsFromTeamHeader(response) ||
+            this.parseHeaderTeamsFromHeader(response));
+    }
+    parseHeaderTeamsFromHeader(response) {
+        const headerTeams = response.header?.teams ||
+            [];
+        if (headerTeams.length === 0) {
+            return null;
+        }
+        return this.buildHeaderTeamsItem({
+            response,
+            headerTeams,
+            linescoresHeader: response.header?.linescoresHeader || [],
+            linescoresRowHeader: undefined,
+            isLiveFromHeaderSource: false,
+        });
+    }
+    parseHeaderTeamsFromTeamHeader(response) {
+        const headerTeams = response.header?.teams ||
+            [];
+        const teamHeaderTeams = response.teamHeader?.teams || [];
+        if (teamHeaderTeams.length === 0) {
+            return null;
+        }
+        const teamHeaderHasLinescores = teamHeaderTeams.some((t) => Array.isArray(t.linescores) && t.linescores.length > 0);
+        const teamHeaderHasLinescoresHeader = (response.teamHeader?.linescoresHeader?.length || 0) > 0;
+        if (!teamHeaderHasLinescores &&
+            !teamHeaderHasLinescoresHeader &&
+            headerTeams.length > 0) {
+            return null;
+        }
+        const linescoresRowHeader = response.teamHeader?.style?.linescores?.rowHeader === 'teamLogo'
+            ? 'teamLogo'
+            : undefined;
+        return this.buildHeaderTeamsItem({
+            response,
+            headerTeams: teamHeaderTeams,
+            linescoresHeader: response.teamHeader?.linescoresHeader || [],
+            linescoresRowHeader,
+            isLiveFromHeaderSource: teamHeaderHasLinescores || teamHeaderHasLinescoresHeader,
+        });
+    }
+    buildHeaderTeamsItem(params) {
+        const { response, headerTeams, linescoresHeader: rawLinescoresHeader, linescoresRowHeader, isLiveFromHeaderSource, } = params;
         const teams = response.entities?.teams;
-        if (!teams || !response.header?.teams) {
+        if (!teams || headerTeams.length === 0) {
             return null;
         }
-        const homeTeamHeader = response.header.teams.find((t) => {
+        const homeTeamHeader = headerTeams.find((t) => {
             const team = teams[t.$key];
             return team && team.homeAway === 'home';
         });
-        const awayTeamHeader = response.header.teams.find((t) => {
+        const awayTeamHeader = headerTeams.find((t) => {
             const team = teams[t.$key];
             return team && team.homeAway === 'away';
         });
-        if (!homeTeamHeader || !awayTeamHeader) {
+        // If home/away isn't provided, fall back to list order.
+        const fallbackAwayTeamHeader = headerTeams[0];
+        const fallbackHomeTeamHeader = headerTeams[1];
+        const resolvedHomeTeamHeader = homeTeamHeader || fallbackHomeTeamHeader;
+        const resolvedAwayTeamHeader = awayTeamHeader || fallbackAwayTeamHeader;
+        if (!resolvedHomeTeamHeader || !resolvedAwayTeamHeader) {
             return null;
         }
-        const homeTeam = teams[homeTeamHeader.$key];
-        const awayTeam = teams[awayTeamHeader.$key];
+        const homeTeam = teams[resolvedHomeTeamHeader.$key];
+        const awayTeam = teams[resolvedAwayTeamHeader.$key];
         if (!homeTeam || !awayTeam) {
             return null;
         }
         const statistics = [];
         const statisticsSet = new Set();
-        const awayStatistics = awayTeam.statistics || [];
-        const homeStatistics = homeTeam.statistics || [];
+        const rawAwayStats = awayTeam.statistics || [];
+        const rawHomeStats = homeTeam.statistics || [];
+        const awayStatistics = rawAwayStats.filter(isTeamStatistic);
+        const homeStatistics = rawHomeStats.filter(isTeamStatistic);
         [...awayStatistics, ...homeStatistics].forEach((st) => {
             statisticsSet.add(st.$key);
         });
@@ -566,6 +761,9 @@ export class StatsViewModel extends ViewModel {
         statisticsSet.forEach((statKey) => {
             const awayStat = awayStatistics.find((st) => st.$key === statKey);
             const homeStat = homeStatistics.find((st) => st.$key === statKey);
+            if (!awayStat || !homeStat) {
+                return;
+            }
             statistics.push({
                 displayName: awayStat?.displayName || homeStat?.displayName || '',
                 awayTeamValue: awayStat?.value || 0,
@@ -574,32 +772,77 @@ export class StatsViewModel extends ViewModel {
                 homeTeamDisplayValue: homeStat?.displayValue || '0',
             });
         });
+        const buildLinescores = (t) => {
+            if (t.linescores && t.linescores.length > 0) {
+                return t.linescores.map((l) => l.displayValue);
+            }
+            if (typeof t.score === 'string' && t.score.length > 0) {
+                return [t.score];
+            }
+            return [];
+        };
+        const maybeDetails = (t) => {
+            if (Array.isArray(t.details) && t.details.filter(Boolean).length > 0) {
+                return t.details.filter(Boolean);
+            }
+            return undefined;
+        };
+        const awayDetails = maybeDetails(resolvedAwayTeamHeader);
+        const homeDetails = maybeDetails(resolvedHomeTeamHeader);
+        let linescoresHeader = rawLinescoresHeader;
+        let awayTeamLinescores = buildLinescores(resolvedAwayTeamHeader);
+        let homeTeamLinescores = buildLinescores(resolvedHomeTeamHeader);
+        // If more than 9 innings are present, show only the last 9 innings plus R, H, E
+        const hasLinescoresAndHeader = linescoresHeader.length > 0 &&
+            (awayTeamLinescores.length > 0 || homeTeamLinescores.length > 0);
+        if (hasLinescoresAndHeader && linescoresRowHeader === 'teamLogo') {
+            const lastThreeHeaders = linescoresHeader.slice(-3);
+            const isMlbFormat = lastThreeHeaders.includes('R') ||
+                lastThreeHeaders.includes('H') ||
+                lastThreeHeaders.includes('E');
+            if (isMlbFormat && linescoresHeader.length > 12) {
+                // More than 9 innings + 3 stats (R, H, E)
+                const statsCount = 3; // R, H, E
+                const inningsCount = linescoresHeader.length - statsCount;
+                const maxInningsToShow = 9;
+                if (inningsCount > maxInningsToShow) {
+                    const inningsToRemove = inningsCount - maxInningsToShow;
+                    // Slice header to keep last 9 innings + stats (R, H, E)
+                    linescoresHeader = linescoresHeader.slice(inningsToRemove);
+                    // Apply same slicing to team linescores
+                    awayTeamLinescores = awayTeamLinescores.slice(inningsToRemove);
+                    homeTeamLinescores = homeTeamLinescores.slice(inningsToRemove);
+                }
+            }
+        }
+        const isLive = response.gameState === 'in' ||
+            response.gameState === 'post' ||
+            isLiveFromHeaderSource;
         return {
             type: 'headerTeam',
-            linescoresHeader: response.header.linescoresHeader || [],
-            isLive: response.gameState === 'in' || response.gameState === 'post',
+            linescoresHeader,
+            linescoresRowHeader,
+            isLive,
             statistics,
             awayTeam: {
                 abbreviation: awayTeam.abbreviation,
                 color: awayTeam.color,
                 id: awayTeam.id,
-                linescores: awayTeamHeader?.linescores?.map((l) => l.displayValue) || [
-                    awayTeamHeader.score || '0',
-                ],
+                linescores: awayTeamLinescores,
                 logo: awayTeam.logo,
                 name: awayTeam.name,
                 record: awayTeam.record,
+                ...(awayDetails ? { details: awayDetails } : {}),
             },
             homeTeam: {
                 abbreviation: homeTeam.abbreviation,
                 color: homeTeam.color,
                 id: homeTeam.id,
-                linescores: homeTeamHeader?.linescores?.map((l) => l.displayValue) || [
-                    homeTeamHeader.score || '0',
-                ],
+                linescores: homeTeamLinescores,
                 logo: homeTeam.logo,
                 name: homeTeam.name,
                 record: homeTeam.record,
+                ...(homeDetails ? { details: homeDetails } : {}),
             },
         };
     }
@@ -891,47 +1134,143 @@ export class StatsViewModel extends ViewModel {
         }
         const teams = data.entities?.teams;
         const athletes = data.entities?.athletes;
-        const sections = scoringSummary.sections.map((section) => {
-            const scores = section.items
-                .filter((item) => item?.team?.$key && item?.athlete?.$key)
-                .map((item) => {
-                const team = teams?.[item.team.$key];
-                const athlete = athletes?.[item.athlete.$key];
-                const [athleteNumber, ...athleteNameWithAssists] = item.title.split(' ');
-                let athleteAssists = '';
-                let athleteName = '';
-                if (athleteNameWithAssists.length > 0) {
-                    athleteAssists =
-                        athleteNameWithAssists[athleteNameWithAssists.length - 1];
-                    athleteName = athleteNameWithAssists.slice(0, -1).join(' ');
+        // Handle MLB Scoring Summary
+        if (isMlbScoringSummary(scoringSummary)) {
+            const sections = [];
+            for (const section of scoringSummary.sections) {
+                if (!section.title || !section.items?.length) {
+                    continue;
                 }
-                return {
-                    teamLogo: team?.logo,
-                    teamName: team?.abbreviation,
-                    athletePosition: athlete?.position?.abbreviation || '',
-                    athleteNumber,
-                    athleteName,
-                    athleteAssists,
-                    athleteThumbnail: athlete?.headshot
-                        ? setImageDimensions(athlete.headshot, 200, 144)
-                        : undefined,
-                    description: item.description,
-                    clock: item.clock,
-                };
-            });
+                const items = [];
+                for (const item of section.items) {
+                    if (!item?.team?.$key || !item?.athlete?.$key) {
+                        continue;
+                    }
+                    const team = teams?.[item.team.$key];
+                    const athlete = athletes?.[item.athlete.$key];
+                    const athleteNumber = `#${athlete?.jersey || ''}`;
+                    const athleteName = athlete?.shortName || '';
+                    if (!team || !athlete) {
+                        continue;
+                    }
+                    const textParts = [];
+                    if (athleteNumber) {
+                        textParts.push({
+                            featured: false,
+                            title: athleteNumber,
+                        });
+                    }
+                    if (athleteName) {
+                        textParts.push({
+                            featured: true,
+                            title: athleteName,
+                        });
+                    }
+                    items.push({
+                        teamLogo: team?.logo || '',
+                        teamName: team?.abbreviation,
+                        headshot: athlete?.headshot
+                            ? setImageDimensions(athlete.headshot, 200, 144)
+                            : undefined,
+                        athleteShortName: athlete?.shortName || '',
+                        athleteJersey: athlete?.jersey || '',
+                        athletePosition: athlete?.position?.abbreviation || '',
+                        text: item?.text || '',
+                        shortText: textParts,
+                        header: (item?.header || []).map((h, index) => ({
+                            featured: h.featured ?? false,
+                            title: `${h.title ?? ''}${index === 0 ? ',' : ''}`,
+                        })),
+                    });
+                }
+                if (items.length > 0) {
+                    sections.push({
+                        title: section.title,
+                        items,
+                    });
+                }
+            }
+            if (sections.length === 0) {
+                return null;
+            }
             return {
-                title: section.title,
-                scores,
+                type: 'scoringSummary',
+                tag: 'mlb',
+                title: scoringSummary.title || 'Scoring Summary',
+                sections,
             };
-        });
-        if (!sections.length || sections.every((s) => s.scores.length === 0)) {
-            return null;
         }
-        return {
-            type: 'scoringSummary',
-            title: scoringSummary.title,
-            sections,
-        };
+        // Handle Hockey Scoring Summary - transform to unified format
+        else if (isHockeyScoringSummary(scoringSummary)) {
+            const hockeySummary = scoringSummary;
+            const sections = [];
+            for (const section of hockeySummary.sections || []) {
+                const items = [];
+                for (const item of section.items || []) {
+                    if (!item?.team?.$key || !item?.athlete?.$key || !item?.title) {
+                        continue;
+                    }
+                    const team = item.team && item.team.$key ? teams?.[item.team.$key] : undefined;
+                    const atheleteKey = item.athlete?.$key || '';
+                    const athlete = athletes?.[atheleteKey];
+                    const itemTitle = item.title || '';
+                    const [athleteNumber, ...athleteNameWithAssists] = itemTitle.split(' ');
+                    let athleteAssists = '';
+                    let athleteName = '';
+                    if (athleteNameWithAssists.length > 0) {
+                        athleteAssists =
+                            athleteNameWithAssists[athleteNameWithAssists.length - 1];
+                        athleteName = athleteNameWithAssists.slice(0, -1).join(' ');
+                    }
+                    const header = [];
+                    if (item.clock) {
+                        header.push({ featured: true, title: item.clock });
+                    }
+                    if (team?.abbreviation) {
+                        header.push({ featured: false, title: team.abbreviation });
+                    }
+                    const textParts = [];
+                    if (athleteNumber) {
+                        textParts.push({ featured: false, title: athleteNumber });
+                    }
+                    if (athleteName) {
+                        textParts.push({ featured: true, title: athleteName });
+                    }
+                    if (athleteAssists) {
+                        textParts.push({ featured: false, title: athleteAssists });
+                    }
+                    items.push({
+                        teamLogo: team?.logo || '',
+                        teamName: team?.abbreviation || '',
+                        header,
+                        text: item?.description || '',
+                        shortText: textParts,
+                        headshot: athlete?.headshot
+                            ? setImageDimensions(athlete.headshot, 200, 144)
+                            : undefined,
+                        athleteShortName: athleteName,
+                        athletePosition: athlete?.position?.abbreviation || '',
+                        athleteJersey: athleteNumber,
+                    });
+                }
+                if (items.length > 0) {
+                    sections.push({
+                        title: section?.title || '',
+                        items,
+                    });
+                }
+            }
+            if (sections.length === 0) {
+                return null;
+            }
+            return {
+                type: 'scoringSummary',
+                tag: 'hockey',
+                title: hockeySummary.title || 'Scoring Summary',
+                sections,
+            };
+        }
+        return null;
     }
     parsePenalties(data) {
         const penalties = data.penaltySummary;
@@ -941,49 +1280,137 @@ export class StatsViewModel extends ViewModel {
         const teams = data.entities?.teams;
         const athletes = data.entities?.athletes;
         const sections = penalties.sections.map((section) => {
-            const scores = section.items
+            const items = section.items
                 .filter((item) => item?.team?.$key && item?.athlete?.$key)
                 .map((item) => {
                 const team = teams?.[item.team.$key];
                 const athlete = athletes?.[item.athlete.$key];
                 const [athleteNumber, ...athleteName] = item.title.split(' ');
+                const athleteDisplayName = (athleteName ?? []).join(' ') || '';
+                const textParts = [];
+                if (athleteNumber) {
+                    textParts.push({
+                        featured: false,
+                        title: athleteNumber,
+                    });
+                }
+                if (athleteDisplayName) {
+                    textParts.push({
+                        featured: true,
+                        title: athleteDisplayName,
+                    });
+                }
                 return {
-                    teamLogo: team?.logo,
-                    teamName: team?.abbreviation,
-                    athletePosition: athlete?.position?.abbreviation || '',
-                    athleteNumber,
-                    athleteName: athleteName.join(' '),
-                    athleteThumbnail: athlete?.headshot
+                    teamLogo: team?.logo || '',
+                    teamName: team?.abbreviation || '',
+                    header: [{ title: item.clock || '', featured: false }],
+                    text: item.description || '',
+                    shortText: textParts,
+                    headshot: athlete?.headshot
                         ? setImageDimensions(athlete.headshot, 200, 144)
                         : undefined,
-                    description: item.description,
-                    clock: item.clock,
+                    athleteShortName: athleteName.join(' '),
+                    athletePosition: athlete?.position?.abbreviation || '',
+                    athleteJersey: athleteNumber || '',
                 };
             });
             return {
                 title: section.title,
-                scores,
+                items,
             };
         });
-        if (!sections.length || sections.every((s) => s.scores.length === 0)) {
+        if (!sections.length || sections.every((s) => s.items.length === 0)) {
             return null;
         }
         return {
             type: 'penalties',
+            tag: 'penalties',
             title: penalties.title,
             sections,
         };
     }
-    /**
-     * Simulate a use case using mock StatsApiResponse data
-     */
-    simulateUseCase(_useCase, testData) {
-        if (testData) {
-            this.processData(testData);
-            this.hasEverSuccessfullyLoaded.value = true;
-            this.errorState.value = 'none';
-            this.isDataLoading.value = false;
+    parsePlayerSeasonStats(data) {
+        const playerStats = data.playerStats;
+        const teams = data.entities?.teams;
+        const athletes = data.entities?.athletes;
+        if (!playerStats?.teams?.length || !teams) {
+            return null;
+        }
+        const parsedTeams = [];
+        for (const playerStatsTeam of playerStats.teams) {
+            if (!playerStatsTeam.$key) {
+                continue;
+            }
+            const team = teams[playerStatsTeam.$key];
+            if (!team) {
+                continue;
+            }
+            const sections = [];
+            for (const section of playerStatsTeam.sections || []) {
+                if (!section.title || !section.items?.length) {
+                    continue;
+                }
+                const items = [];
+                for (const item of section.items) {
+                    if (!item.title) {
+                        continue;
+                    }
+                    const athleteKey = item.athlete?.$key;
+                    const athlete = athleteKey
+                        ? athletes?.[athleteKey]
+                        : undefined;
+                    const statistics = item.athlete?.statistics || [];
+                    const featuredStat = statistics.find((s) => s.featured);
+                    items.push({
+                        title: item.title,
+                        headshot: athlete?.headshot
+                            ? setImageDimensions(athlete.headshot, 256, 144)
+                            : '',
+                        position: athlete?.position?.abbreviation || '',
+                        jersey: athlete?.jersey || '',
+                        featuredStat: featuredStat
+                            ? {
+                                displayValue: featuredStat.displayValue || '',
+                                label: featuredStat.label || '',
+                            }
+                            : null,
+                        statistics: statistics
+                            .filter((s) => !s.featured)
+                            .map((s) => ({
+                            displayValue: s.displayValue || '',
+                            label: s.label || '',
+                        })),
+                        playerStatus: item?.status
+                            ? {
+                                displayName: item.status.displayName ?? '',
+                                type: item.status.type ?? '',
+                            }
+                            : null,
+                    });
+                }
+                if (items.length > 0) {
+                    sections.push({
+                        title: section.title,
+                        items,
+                    });
+                }
+            }
+            if (sections.length > 0) {
+                parsedTeams.push({
+                    teamKey: playerStatsTeam.$key,
+                    shortDisplayName: team.shortDisplayName || team.displayName || '',
+                    color: team.color || '',
+                    sections,
+                });
+            }
         }
+        if (parsedTeams.length === 0) {
+            return null;
+        }
+        return {
+            type: 'playerSeasonStats',
+            teams: parsedTeams,
+        };
     }
 }
 export default StatsViewModel;