@maestro_io/maestro-web-sdk 5.2.0 → 5.3.0

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

@@ -1,1416 +0,0 @@
-import { Observable } from '../../../../helpers/Observable';
-import { ViewModel } from '../../../../view-models/ViewModel';
-import { MOCK_STATS_API_PRE_GAME_RESPONSE } from '../mocks';
-import { isTabbedStatisticsArray, isTeamStatistic, isHockeyScoringSummary, isMlbScoringSummary, } from '../interfaces/IStats';
-import StatsService from '../services/StatsService';
-import { formatLastPlayMarquee, parseDriveDescription, } from '../utils/driveSummaryUtils';
-import { setImageDimensions } from '@/helpers/url';
-import SDK from '@/index';
-import { captureException } from '@/sentry';
-import { stringHashCode } from '@/helpers/strings';
-const STATS_ERROR_STATE = {
-    NONE: 'none',
-    TAB_LOAD_FAILURE: 'tabLoadFailure',
-};
-// Constants for configuration
-const DEFAULT_POLLING_INTERVAL = 10000; // 10 seconds
-const SMART_POLLING_DELAY = 1000; // 1 second delay after smart polling immediate call
-// The interval for polling stats data (in milliseconds)
-const STATS_ITEM_TYPE_CARD_MAP = {
-    activeAthletes: 'activeAthletes',
-    driveSummary: 'drives',
-    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, analyticsService, options = {}) {
-        super();
-        Object.defineProperty(this, "isDataLoading", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Observable(true)
-        });
-        Object.defineProperty(this, "hasEverSuccessfullyLoaded", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Observable(false)
-        });
-        Object.defineProperty(this, "eventId", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "statsItems", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Observable([])
-        });
-        Object.defineProperty(this, "errorState", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Observable('none')
-        });
-        Object.defineProperty(this, "currentGameState", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Observable('')
-        });
-        Object.defineProperty(this, "statsService", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "analyticsService", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        // Properties
-        Object.defineProperty(this, "useMockData", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "lastResponseHash", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        // Enhanced timecode-related properties
-        Object.defineProperty(this, "currentPlayerTimeCode", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "timecodePollingTask", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "smartPollingTimeout", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "timecodePollingState", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {
-                isActive: false,
-                currentUrl: null,
-                lastUpdateTime: 0,
-            }
-        });
-        Object.defineProperty(this, "onEngage", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (type) => {
-                this.analyticsService.panelClick({
-                    type: 'espnStats',
-                    name: 'stats_item_clicked',
-                    metadata: {
-                        card: [STATS_ITEM_TYPE_CARD_MAP[type]],
-                        game_state: [this.currentGameState.value],
-                    },
-                });
-            }
-        });
-        this.eventId = eventId;
-        this.useMockData = options.useMockData || false;
-        this.statsService = new StatsService(delegate);
-        this.analyticsService = analyticsService;
-    }
-    /**
-     * Sets panel-specific data configuration
-     * @param panelData - Object containing panel configuration
-     */
-    setDataToPanel(panelData) {
-        if ('overrideUrl' in panelData) {
-            const overrideUrl = panelData.overrideUrl;
-            if (typeof overrideUrl === 'string' && overrideUrl.length > 0) {
-                console.log('[StatsViewModel] Setting overrideUrl:', overrideUrl);
-                this.statsService.overrideUrl = overrideUrl;
-            }
-        }
-    }
-    /**
-     * Initialize the ViewModel and start data fetching
-     */
-    async init() {
-        if (this.useMockData) {
-            await this.fetchMockData();
-        }
-        else {
-            // Get the current timecode from MaestroEventViewModel instead of defaulting to null
-            // This ensures we don't override the current timecode when switching tabs
-            const currentTimeCode = this.getCurrentTimeCode();
-            this.onUpdatePlayerTimeCode(currentTimeCode);
-            this.analyticsService.panelView('espnStats');
-        }
-    }
-    /**
-     * Get the current timecode from the MaestroEventViewModel
-     * This prevents the stats panel from always defaulting to real-time data
-     */
-    getCurrentTimeCode() {
-        try {
-            // Access the MaestroEventViewModel through the imported SDK to get current timecode
-            const maestroEventViewModel = SDK.getMaestroEventViewModel();
-            if (maestroEventViewModel &&
-                typeof maestroEventViewModel.getPlayerTimeCode === 'function') {
-                return maestroEventViewModel.getPlayerTimeCode();
-            }
-        }
-        catch (error) {
-            captureException(error, {
-                context: 'StatsViewModel.getCurrentTimeCode',
-            });
-            console.warn('Could not get current timecode from MaestroEventViewModel:', error);
-        }
-        // Fallback to null (real-time) if we can't get the current timecode
-        return null;
-    }
-    /**
-     * Clean up resources when the ViewModel is no longer needed
-     */
-    cleanup() {
-        this.stopTimecodePolling();
-        this.clearSmartPollingTimeout();
-        this.resetTimecodePollingState();
-    }
-    /**
-     * Handle player timecode updates with enhanced logging and validation
-     *
-     * @param playerTimeCode - The timecode in milliseconds, or null for live
-     */
-    onUpdatePlayerTimeCode(playerTimeCode) {
-        this.currentPlayerTimeCode = playerTimeCode;
-        if (this.useMockData) {
-            return;
-        }
-        try {
-            this.performSmartPolling(playerTimeCode);
-        }
-        catch (error) {
-            captureException(error, {
-                context: 'StatsViewModel.onUpdatePlayerTimeCode',
-            });
-            console.error('Error handling player timecode update:', error);
-            this.handleTimecodeError('Error handling player timecode update', error);
-        }
-    }
-    clearTabLoadFailure() {
-        this.errorState.value = 'none';
-        const currentTimeCode = this.getCurrentTimeCode();
-        this.onUpdatePlayerTimeCode(currentTimeCode);
-    }
-    /**
-     * Implement smart polling strategy: immediate API call + delayed polling resumption
-     *
-     * @param playerTimeCode - The timecode in milliseconds, or null
-     */
-    async performSmartPolling(playerTimeCode) {
-        this.clearSmartPollingTimeout();
-        this.stopTimecodePolling();
-        try {
-            const immediateStats = await this.statsService.getStatsByUrl(playerTimeCode);
-            if (!immediateStats) {
-                throw new Error('API returned undefined or null response');
-            }
-            this.processPolledData(immediateStats);
-            this.smartPollingTimeout = window.setTimeout(() => {
-                this.startTimecodePolling(playerTimeCode);
-                this.smartPollingTimeout = null;
-            }, SMART_POLLING_DELAY);
-        }
-        catch (error) {
-            captureException(error, {
-                context: 'StatsViewModel.performSmartPolling',
-            });
-            console.error('Error during smart polling immediate call:', error);
-            this.handleTimecodeError('Error during smart polling immediate call', error);
-            this.stopTimecodePolling();
-            this.startTimecodePolling(playerTimeCode);
-        }
-    }
-    /**
-     * Enhanced error handling for timecode-related operations
-     *
-     * @param context - Description of where the error occurred
-     * @param error - The error that occurred
-     */
-    handleTimecodeError(context, error) {
-        const errorDetails = {
-            context,
-            errorType: error?.constructor?.name || 'Unknown',
-            errorMessage: error instanceof Error ? error.message : String(error),
-            timestamp: new Date().toISOString(),
-            currentTimecode: this.currentPlayerTimeCode,
-            hasExistingData: this.statsItems.value.length > 0,
-            lastResponseHash: this.lastResponseHash,
-            url: this.timecodePollingState.currentUrl,
-        };
-        console.error(`${context}:`, errorDetails);
-        if (!this.hasEverSuccessfullyLoaded.value) {
-            this.errorState.value = 'tabLoadFailure';
-        }
-    }
-    /**
-     * Clear any pending smart polling timeout
-     */
-    clearSmartPollingTimeout() {
-        if (this.smartPollingTimeout) {
-            clearTimeout(this.smartPollingTimeout);
-            this.smartPollingTimeout = null;
-        }
-    }
-    /**
-     * Reset timecode polling state
-     */
-    resetTimecodePollingState() {
-        this.timecodePollingState = {
-            isActive: false,
-            currentUrl: null,
-            lastUpdateTime: 0,
-        };
-    }
-    /**
-     * Start timecode-based polling with enhanced logging
-     *
-     * @param playerTimeCode - The timecode in milliseconds, or null
-     */
-    startTimecodePolling(playerTimeCode) {
-        this.stopTimecodePolling();
-        try {
-            this.timecodePollingTask = this.statsService.pollStatsByUrl(playerTimeCode, DEFAULT_POLLING_INTERVAL, (data) => {
-                this.processPolledData(data);
-            }, (error) => {
-                console.error('Timecode polling error:', error);
-                this.handleTimecodeError('Timecode polling error', error);
-            });
-            this.timecodePollingState.isActive = true;
-        }
-        catch (error) {
-            captureException(error, {
-                context: 'StatsViewModel.startTimecodePolling',
-            });
-            console.error('Error setting up timecode-based Stats polling:', error);
-            this.handleTimecodeError('Error setting up timecode-based Stats polling', error);
-        }
-    }
-    /**
-     * Stop timecode-based polling with enhanced logging
-     */
-    stopTimecodePolling() {
-        if (this.timecodePollingTask) {
-            this.timecodePollingTask.stop();
-            this.timecodePollingTask = null;
-        }
-        this.timecodePollingState.isActive = false;
-    }
-    /**
-     * Fetch mock data for testing
-     */
-    async fetchMockData() {
-        this.processData(MOCK_STATS_API_PRE_GAME_RESPONSE);
-        this.hasEverSuccessfullyLoaded.value = true;
-        this.isDataLoading.value = false;
-    }
-    /**
-     * Process polled data with hash comparison to avoid unnecessary re-renders
-     * Enhanced with comprehensive logging to show data changes
-     *
-     * @param data - The stats data received from the API
-     */
-    processPolledData(data) {
-        const responseString = JSON.stringify(data);
-        const currentHash = stringHashCode(responseString);
-        if (this.hasEverSuccessfullyLoaded.value &&
-            currentHash === this.lastResponseHash) {
-            return;
-        }
-        this.lastResponseHash = currentHash;
-        this.hasEverSuccessfullyLoaded.value = true;
-        this.errorState.value = 'none';
-        this.processData(data);
-        if (data.gameState === 'post') {
-            this.stopTimecodePolling();
-        }
-    }
-    processData(data) {
-        const statsItems = [];
-        const headerTeam = this.parseHeaderTeams(data);
-        if (headerTeam) {
-            statsItems.push(headerTeam);
-        }
-        const matchPredictor = this.parseMatchPredictor(data);
-        if (matchPredictor) {
-            statsItems.push(matchPredictor);
-        }
-        const careerMatchup = this.parseCareerMatchup(data);
-        if (careerMatchup) {
-            statsItems.push(careerMatchup);
-        }
-        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);
-        }
-        const recentGames = this.parseRecentGames(data);
-        if (recentGames) {
-            statsItems.push(recentGames);
-        }
-        const promotion = this.parsePromotion(data);
-        if (promotion) {
-            statsItems.push(promotion);
-        }
-        // Update the stats items observable
-        this.statsItems.value = statsItems;
-        this.currentGameState.value = data.gameState;
-    }
-    parseDriveSummary(data) {
-        const teams = data.entities?.teams;
-        const drives = data.drives;
-        if (!teams || !drives || drives.length === 0) {
-            return [];
-        }
-        const result = [];
-        for (const drive of drives) {
-            if (!drive?.team?.$key) {
-                continue;
-            }
-            const plays = [...(drive.plays || [])].reverse();
-            const lastPlay = plays[plays.length - 1] || null;
-            let lastPlayMarquee = '';
-            if (lastPlay) {
-                lastPlayMarquee = formatLastPlayMarquee(lastPlay);
-            }
-            const { plays: playsQuantity, time, yards } = parseDriveDescription(drive.description || '');
-            const team = teams[drive.team.$key];
-            if (!team) {
-                continue;
-            }
-            result.push({
-                id: drive.id,
-                lastPlayMarquee,
-                plays,
-                playsQuantity,
-                team,
-                time,
-                type: 'driveSummary',
-                yards,
-            });
-        }
-        return result;
-    }
-    parseTeamsStatistics(data) {
-        const teams = data.entities?.teams;
-        if (!teams) {
-            return null;
-        }
-        const awayTeam = Object.values(teams).find((team) => team.homeAway === 'away');
-        const homeTeam = Object.values(teams).find((team) => team.homeAway === 'home');
-        if (!awayTeam || !homeTeam) {
-            return null;
-        }
-        // Ensure both teams have statistics
-        if (!awayTeam.statistics || !homeTeam.statistics) {
-            return null;
-        }
-        const statistics = [];
-        for (let i = 0; i < awayTeam.statistics.length; i++) {
-            const awayStat = awayTeam.statistics[i];
-            const homeStat = homeTeam.statistics[i];
-            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 || '',
-                color: awayTeam.color || '',
-                abbreviation: awayTeam.abbreviation || '',
-            },
-            homeTeam: {
-                logo: homeTeam.logo,
-                displayName: homeTeam.displayName || '',
-                color: homeTeam.color || '',
-                abbreviation: homeTeam.abbreviation || '',
-            },
-            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;
-        if (!teams || !predictor || !predictor.homeTeam || !predictor.awayTeam) {
-            return null;
-        }
-        // Get team data
-        const homeTeam = teams[predictor.homeTeam.team.$key];
-        const awayTeam = teams[predictor.awayTeam.team.$key];
-        if (!homeTeam || !awayTeam) {
-            return null;
-        }
-        // Parse percentages
-        const homePercentage = parseFloat(predictor.homeTeam.gameProjection);
-        const awayPercentage = parseFloat(predictor.awayTeam.gameProjection);
-        return {
-            type: 'matchPredictor',
-            header: predictor.header,
-            imageUrl: predictor.imageUrl,
-            awayTeam: {
-                percentage: awayPercentage,
-                abbreviation: awayTeam.abbreviation,
-                logo: awayTeam.logo,
-                displayName: awayTeam.displayName || '',
-            },
-            homeTeam: {
-                percentage: homePercentage,
-                abbreviation: homeTeam.abbreviation,
-                logo: homeTeam.logo,
-                displayName: homeTeam.displayName || '',
-            },
-        };
-    }
-    parsePromotion(response) {
-        const promotion = response.promotion;
-        if (!promotion) {
-            return null;
-        }
-        return {
-            type: 'promotion',
-            title: promotion.title || '',
-            description: promotion.description || '',
-            logo: promotion.logo || '',
-            qrCode: promotion.qrCode || '',
-            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 || headerTeams.length === 0) {
-            return null;
-        }
-        const homeTeamHeader = headerTeams.find((t) => {
-            const team = teams[t.$key];
-            return team && team.homeAway === 'home';
-        });
-        const awayTeamHeader = headerTeams.find((t) => {
-            const team = teams[t.$key];
-            return team && team.homeAway === 'away';
-        });
-        // 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[resolvedHomeTeamHeader.$key];
-        const awayTeam = teams[resolvedAwayTeamHeader.$key];
-        if (!homeTeam || !awayTeam) {
-            return null;
-        }
-        const statistics = [];
-        const statisticsSet = new Set();
-        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);
-        });
-        // Ensure all statistics from both teams are included
-        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,
-                homeTeamValue: homeStat?.value || 0,
-                awayTeamDisplayValue: awayStat?.displayValue || '0',
-                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,
-            linescoresRowHeader,
-            isLive,
-            statistics,
-            awayTeam: {
-                abbreviation: awayTeam.abbreviation,
-                color: awayTeam.color,
-                id: awayTeam.id,
-                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: homeTeamLinescores,
-                logo: homeTeam.logo,
-                name: homeTeam.name,
-                record: homeTeam.record,
-                ...(homeDetails ? { details: homeDetails } : {}),
-            },
-        };
-    }
-    parseRecentGames(response) {
-        const teams = response.entities?.teams;
-        const previousGames = response.previousGames;
-        if (!teams || !previousGames || previousGames.length === 0) {
-            return null;
-        }
-        const awayTeamPreviousGame = previousGames.find((game) => game?.displayOrder === 1);
-        const homeTeamPreviousGame = previousGames.find((game) => game?.displayOrder === 2);
-        if (!awayTeamPreviousGame || !homeTeamPreviousGame) {
-            return null;
-        }
-        if (!awayTeamPreviousGame.events || !homeTeamPreviousGame.events) {
-            return null;
-        }
-        if (!awayTeamPreviousGame.team?.$key || !homeTeamPreviousGame.team?.$key) {
-            return null;
-        }
-        const awayTeam = teams[awayTeamPreviousGame.team.$key];
-        const homeTeam = teams[homeTeamPreviousGame.team.$key];
-        if (!awayTeam || !homeTeam) {
-            return null;
-        }
-        const previousGame = {
-            type: 'recentGames',
-            awayTeam: {
-                events: [...awayTeamPreviousGame.events]
-                    .reverse()
-                    .filter((event) => event?.team?.$key)
-                    .map((event) => {
-                    const eventTeam = teams[event.team.$key];
-                    return {
-                        gameResult: event.gameResult,
-                        homeAway: event.team.homeAway,
-                        score: event.score,
-                        teamLogo: eventTeam?.logo,
-                    };
-                }),
-                logo: awayTeam.logo,
-                name: awayTeam.shortDisplayName,
-            },
-            homeTeam: {
-                events: [...homeTeamPreviousGame.events]
-                    .reverse()
-                    .filter((event) => event?.team?.$key)
-                    .map((event) => {
-                    const eventTeam = teams[event.team.$key];
-                    return {
-                        gameResult: event.gameResult,
-                        homeAway: event.team.homeAway,
-                        score: event.score,
-                        teamLogo: eventTeam?.logo,
-                    };
-                }),
-                logo: homeTeam.logo,
-                name: homeTeam.shortDisplayName,
-            },
-        };
-        return previousGame;
-    }
-    parseWinProbability(response) {
-        const winProbability = response.winProbability;
-        if (!winProbability ||
-            !winProbability.homeTeam ||
-            !winProbability.awayTeam) {
-            return null;
-        }
-        const teams = response.entities?.teams;
-        if (!teams) {
-            return null;
-        }
-        const homeTeam = teams[winProbability.homeTeam.team.$key];
-        const awayTeam = teams[winProbability.awayTeam.team.$key];
-        if (!homeTeam || !awayTeam) {
-            return null;
-        }
-        return {
-            type: 'winProbability',
-            chartImageUrl: winProbability.imageUrl,
-            awayTeam: {
-                id: awayTeam.id,
-                abbreviation: awayTeam.abbreviation,
-                logo: awayTeam.logo,
-                winPercentage: winProbability.awayTeam.winPercentage,
-            },
-            homeTeam: {
-                id: homeTeam.id,
-                abbreviation: homeTeam.abbreviation,
-                logo: homeTeam.logo,
-                winPercentage: winProbability.homeTeam.winPercentage,
-            },
-        };
-    }
-    parseGameLeaders(response) {
-        if (!response.entities?.athletes || !response.entities?.teams) {
-            return null;
-        }
-        const leaders = response.leaders;
-        const isPre = response.gameState === 'pre';
-        if (!leaders || leaders.length === 0) {
-            return null;
-        }
-        const items = [];
-        for (const leader of leaders) {
-            if (!leader.away || !leader.home) {
-                continue;
-            }
-            if (!leader.away?.athlete?.$key || !leader.home?.athlete?.$key) {
-                continue;
-            }
-            const awayAthlete = response.entities.athletes[leader.away.athlete.$key];
-            const homeAthlete = response.entities.athletes[leader.home.athlete.$key];
-            if (!awayAthlete || !homeAthlete) {
-                continue;
-            }
-            const awayAthleteStatistics = leader.away.athlete.statistics || [];
-            const homeAthleteStatistics = leader.home.athlete.statistics || [];
-            const value = {
-                displayName: leader.displayName,
-                awayAthlete: {
-                    id: awayAthlete.id,
-                    displayName: awayAthlete.displayName,
-                    headshot: awayAthlete.headshot
-                        ? setImageDimensions(awayAthlete.headshot, 256, 144)
-                        : '',
-                    position: awayAthlete.position?.abbreviation || '-',
-                    shortName: awayAthlete.shortName,
-                    jersey: awayAthlete.jersey,
-                    statistics: awayAthleteStatistics,
-                },
-                homeAthlete: {
-                    id: homeAthlete.id,
-                    displayName: homeAthlete.displayName,
-                    headshot: homeAthlete.headshot
-                        ? setImageDimensions(homeAthlete.headshot, 256, 144)
-                        : '',
-                    position: homeAthlete.position?.abbreviation || '-',
-                    shortName: homeAthlete.shortName,
-                    jersey: homeAthlete.jersey,
-                    statistics: homeAthleteStatistics,
-                },
-            };
-            items.push(value);
-        }
-        if (!items.length) {
-            return null;
-        }
-        return {
-            type: 'gameLeaders',
-            items,
-            displayText: isPre ? 'Season Leaders' : 'Game Leaders',
-        };
-    }
-    parseActiveAthletes(response) {
-        const activeAthletes = response.activeAthletes;
-        const { awayTeam, homeTeam } = this.getActiveAthletesTeamInfo(response);
-        const athletes = [];
-        if (!response.entities?.athletes ||
-            !activeAthletes ||
-            awayTeam.index === -1 ||
-            homeTeam.index === -1) {
-            return null;
-        }
-        for (let i = 0; i < activeAthletes.teams[awayTeam.index].athletes.length; i++) {
-            const awayAthlete = activeAthletes.teams[awayTeam.index].athletes[i];
-            const homeAthlete = activeAthletes.teams[homeTeam.index].athletes[i];
-            if (!awayAthlete?.$key || !homeAthlete?.$key) {
-                continue;
-            }
-            const awayAthleteInfo = response.entities.athletes[awayAthlete.$key];
-            const homeAthleteInfo = response.entities.athletes[homeAthlete.$key];
-            if (!awayAthleteInfo || !homeAthleteInfo) {
-                continue;
-            }
-            const awayAthleteStatistics = [];
-            const homeAthleteStatistics = [];
-            const awayStatLine = awayAthlete.statLine || '';
-            const homeStatLine = homeAthlete.statLine || '';
-            awayStatLine
-                .trim()
-                .split(',')
-                .forEach((st, index) => {
-                const [awayDisplayValue, awayAbbreviation] = st.trim().split(' ');
-                const homeStats = homeStatLine.trim().split(',')[index];
-                if (!homeStats) {
-                    return;
-                }
-                const [homeDisplayValue, homeAbbreviation] = homeStats
-                    .trim()
-                    .split(' ');
-                awayAthleteStatistics.push({
-                    displayValue: awayDisplayValue || '0',
-                    abbreviation: awayAbbreviation || '-',
-                    value: parseFloat(awayDisplayValue) || 0,
-                });
-                homeAthleteStatistics.push({
-                    displayValue: homeDisplayValue || '0',
-                    abbreviation: homeAbbreviation || '-',
-                    value: parseFloat(homeDisplayValue) || 0,
-                });
-            });
-            athletes.push({
-                awayAthlete: {
-                    id: awayAthleteInfo.id,
-                    displayName: awayAthleteInfo.displayName,
-                    headshot: awayAthleteInfo.headshot
-                        ? setImageDimensions(awayAthleteInfo.headshot, 256, 144)
-                        : '',
-                    position: awayAthleteInfo.position?.abbreviation || '-',
-                    shortName: awayAthleteInfo.shortName,
-                    jersey: awayAthleteInfo.jersey,
-                    statistics: awayAthleteStatistics,
-                    minifiedStatistics: awayAthlete.statLine,
-                },
-                homeAthlete: {
-                    id: homeAthleteInfo.id,
-                    displayName: homeAthleteInfo.displayName,
-                    headshot: homeAthleteInfo.headshot
-                        ? setImageDimensions(homeAthleteInfo.headshot, 256, 144)
-                        : '',
-                    position: homeAthleteInfo.position?.abbreviation || '-',
-                    shortName: homeAthleteInfo.shortName,
-                    jersey: homeAthleteInfo.jersey,
-                    statistics: homeAthleteStatistics,
-                    minifiedStatistics: homeAthlete.statLine,
-                },
-            });
-        }
-        if (!athletes.length) {
-            return null;
-        }
-        return {
-            type: 'activeAthletes',
-            awayTeam,
-            homeTeam,
-            athletes,
-            displayText: activeAthletes.displayText,
-        };
-    }
-    getActiveAthletesTeamInfo(data) {
-        const teams = data.activeAthletes?.teams || [];
-        let awayTeam = {
-            index: -1,
-            id: '',
-            logo: '',
-            name: '-',
-        };
-        let homeTeam = {
-            index: -1,
-            id: '',
-            logo: '',
-            name: '-',
-        };
-        const entitiesTeams = data.entities?.teams;
-        if (!entitiesTeams) {
-            return { awayTeam, homeTeam };
-        }
-        for (let i = 0; i < teams.length; i++) {
-            const teamInfo = teams[i];
-            const team = entitiesTeams[teamInfo.team.$key];
-            if (!team) {
-                continue;
-            }
-            if (team.homeAway === 'away') {
-                awayTeam = {
-                    index: i,
-                    id: team.id,
-                    logo: team.logo,
-                    name: team.name || '-',
-                };
-            }
-            else if (team.homeAway === 'home') {
-                homeTeam = {
-                    index: i,
-                    id: team.id,
-                    logo: team.logo,
-                    name: team.name || '-',
-                };
-            }
-        }
-        return { awayTeam, homeTeam };
-    }
-    parseScoringSummary(data) {
-        const scoringSummary = data.scoringSummary;
-        if (!scoringSummary || !scoringSummary.sections) {
-            return null;
-        }
-        const teams = data.entities?.teams;
-        const athletes = data.entities?.athletes;
-        // Handle MLB Scoring Summary
-        if (isMlbScoringSummary(scoringSummary)) {
-            const sections = [];
-            for (const section of scoringSummary.sections) {
-                if (!section.title || !section.items?.length) {
-                    continue;
-                }
-                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 {
-                type: 'scoringSummary',
-                tag: 'mlb',
-                title: scoringSummary.title || 'Scoring Summary',
-                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;
-        if (!penalties || !penalties.sections) {
-            return null;
-        }
-        const teams = data.entities?.teams;
-        const athletes = data.entities?.athletes;
-        const sections = penalties.sections.map((section) => {
-            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 || '',
-                    header: [{ title: item.clock || '', featured: false }],
-                    text: item.description || '',
-                    shortText: textParts,
-                    headshot: athlete?.headshot
-                        ? setImageDimensions(athlete.headshot, 200, 144)
-                        : undefined,
-                    athleteShortName: athleteName.join(' '),
-                    athletePosition: athlete?.position?.abbreviation || '',
-                    athleteJersey: athleteNumber || '',
-                };
-            });
-            return {
-                title: section.title,
-                items,
-            };
-        });
-        if (!sections.length || sections.every((s) => s.items.length === 0)) {
-            return null;
-        }
-        return {
-            type: 'penalties',
-            tag: 'penalties',
-            title: penalties.title,
-            sections,
-        };
-    }
-    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;