@maestro_io/maestro-web-sdk 3.3.1 → 4.0.0-beta.2

package/dist/src/modules/fantasy/view-model/FantasyViewModel.js

@@ -0,0 +1,534 @@
+import { Observable } from '@/helpers/Observable';
+import AnalyticsService from '@/services/AnalyticsService/AnalyticsService';
+import { captureException } from '@/sentry';
+import FantasyService from '@/services/FantasyService';
+import { isLeagueManagerHeadToHeadResponse, isLeagueManagerRotoResponse, } from '../types';
+import FantasyPolling from './FantasyViewModel.FantasyPolling';
+import LeagueManagerPolling from './FantasyViewModel.LeagueManagerPolling';
+import { slugify, stringHashCode } from '@/helpers/strings';
+import { MOCK_FANTASY_RESPONSE } from '../mocks';
+const FANTASY_ERROR_STATE = {
+    NONE: 'none',
+    TAB_LOAD_FAILURE: 'tabLoadFailure',
+};
+export class FantasyViewModel {
+    constructor(eventId, delegate, options = {}) {
+        // Observable properties
+        Object.defineProperty(this, "fantasyItems", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Observable([])
+        });
+        Object.defineProperty(this, "isDataLoading", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Observable(false)
+        });
+        Object.defineProperty(this, "hasEverSuccessfullyLoaded", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Observable(false)
+        });
+        // Properties
+        Object.defineProperty(this, "eventId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "delegate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "analyticsService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fantasyService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fantasyPolling", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "leagueManagerPolling", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "errorState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Observable('none')
+        });
+        Object.defineProperty(this, "leagueSortOrder", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "itemToLeagueKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "useMockData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.useMockData = options.useMockData || false;
+        this.eventId = eventId;
+        this.delegate = delegate;
+        this.analyticsService = new AnalyticsService();
+        this.fantasyService = new FantasyService();
+        this.fantasyPolling = new FantasyPolling(this.fantasyService);
+        this.leagueManagerPolling = new LeagueManagerPolling(this.fantasyService);
+    }
+    /**
+     * Initialize the ViewModel and start data fetching
+     */
+    async init() {
+        // Track panel view on initialization
+        this.trackPanelView();
+        await this.fetchData();
+    }
+    async fetchData() {
+        const isAuthenticated = await this.delegate.userIsAuthenticated();
+        if (!isAuthenticated) {
+            this.append({
+                id: 'not-logged-in',
+                type: 'notLoggedIn',
+            });
+            return;
+        }
+        else if (this.fantasyItems.value.find((i) => i.type === 'notLoggedIn')) {
+            this.fantasyItems.value = [];
+        }
+        const swid = (await this.delegate.getUserSWID()) || '';
+        const jwt = (await this.delegate.getUserToken()) || '';
+        if (this.useMockData) {
+            await this.fetchMockData();
+            return;
+        }
+        else {
+            await this.fantasyPolling.refresh({
+                eventId: this.eventId,
+                swid,
+                jwt,
+            }, this.processFantasy.bind(this));
+        }
+    }
+    onEngage(type) {
+        this.analyticsService.panelClick({
+            type: 'espnFantasy',
+            name: 'fantasy_item_clicked',
+            metadata: {
+                card: type,
+            },
+        });
+    }
+    onAskLogin() {
+        this.fantasyItems.value = [];
+        this.delegate.onPanelEvent({
+            type: 'fantasy:request:login',
+            payload: {
+                onLoginSuccess: async () => {
+                    await this.fetchData();
+                },
+            },
+        });
+    }
+    /**
+     * Clean up resources when the ViewModel is no longer needed
+     */
+    cleanup() {
+        this.fantasyPolling.stop();
+        this.fantasyPolling.removeLastResponseHash();
+        this.leagueManagerPolling.stopAll();
+        this.leagueSortOrder.clear();
+        this.itemToLeagueKey.clear();
+    }
+    /**
+     * Track panel view event
+     */
+    async trackPanelView() {
+        try {
+            await this.analyticsService.panelView('espnFantasy');
+        }
+        catch (error) {
+            captureException(error, {
+                context: 'FantasyViewModel.trackPanelView',
+            });
+            console.error('[FANTASY] Error tracking panel view:', error);
+        }
+    }
+    async processFantasy(data) {
+        try {
+            const token = (await this.delegate.getUserToken()) || '';
+            this.leagueManagerPolling.stopAll();
+            const noData = (data.fantasyData?.totalChallengeEntries || 0) +
+                (data.fantasyData?.totalFantasyLeagues || 0) ===
+                0;
+            if (noData || (data.preferences || []).length === 0) {
+                const promo = await this.fantasyService.getPromo();
+                this.append({
+                    id: 'promo',
+                    type: 'promo',
+                    background: promo.fantasy.promotion.background,
+                    description: promo.fantasy.promotion.description,
+                    logo: promo.fantasy.promotion.logo,
+                    qrCode: promo.fantasy.promotion.qrCode,
+                    title: promo.fantasy.promotion.title,
+                });
+                return;
+            }
+            else if (this.fantasyItems.value.find((i) => i.type === 'promo')) {
+                this.fantasyItems.value = [];
+            }
+            // Clear and rebuild the sort order map based on preferences array order
+            this.leagueSortOrder.clear();
+            this.itemToLeagueKey.clear();
+            for (let i = 0; i < (data.preferences || []).length; i++) {
+                const pref = data.preferences[i];
+                const entry = pref.metaData?.entry || {};
+                const game = entry.abbrev;
+                const seasonId = entry.seasonId;
+                const leagueId = entry.groups?.[0]?.groupId;
+                const draftDate = entry.groups?.[0]?.draftDate;
+                if (!game || !seasonId || !leagueId || !entry.entryId) {
+                    continue;
+                }
+                const key = `${game}-${leagueId}-${seasonId}-${token}`;
+                // Store the array index as the sort order for this league
+                this.leagueSortOrder.set(key, i);
+                this.leagueManagerPolling.refresh(key, {
+                    game,
+                    leagueId,
+                    seasonId,
+                    token,
+                    proGameId: this.eventId,
+                    teamId: entry.entryId,
+                }, (data) => {
+                    if (entry.entryMetadata?.draftComplete === false) {
+                        this.append(this.parseInactiveLeague(data, draftDate), key);
+                    }
+                    else if (isLeagueManagerHeadToHeadResponse(data)) {
+                        const items = this.parseHeadToHead(data, pref);
+                        if (items) {
+                            for (const item of items) {
+                                this.append(item, key);
+                            }
+                        }
+                    }
+                    else if (isLeagueManagerRotoResponse(data)) {
+                        const items = this.parseRoto(data, pref);
+                        if (items) {
+                            for (const item of items) {
+                                this.append(item, key);
+                            }
+                        }
+                    }
+                });
+            }
+            // Mark successful load
+            this.hasEverSuccessfullyLoaded.value = true;
+            this.errorState.value = 'none';
+        }
+        catch (error) {
+            captureException(error, {
+                context: 'FantasyViewModel.processFantasy',
+            });
+            console.error('[FANTASY] Error processing fantasy data:', error);
+            if (!this.hasEverSuccessfullyLoaded.value) {
+                this.errorState.value = 'tabLoadFailure';
+            }
+        }
+    }
+    parseRoto(data, preference) {
+        if (!data.matchups?.length ||
+            !data.leagueName ||
+            !data.scoringType ||
+            !data.gameId) {
+            return null;
+        }
+        const items = [];
+        for (const matchup of data.matchups) {
+            if (!matchup.teams?.length) {
+                continue;
+            }
+            const team = matchup.teams[0];
+            if (!team.logo ||
+                !data.sportLogo ||
+                !data.sportColor ||
+                team.points === undefined) {
+                continue;
+            }
+            const roster = team.roster || [];
+            const matchupRoster = [];
+            const activeAthletes = [];
+            for (const r of roster) {
+                if (!r.player) {
+                    continue;
+                }
+                if (!r.player.abbrevName ||
+                    !r.player.headshot ||
+                    !r.player.proTeam?.triCode ||
+                    !r.slot) {
+                    continue;
+                }
+                matchupRoster.push({
+                    athleteHeadshot: r.player.headshot,
+                    athleteAbbrevName: r.player.abbrevName,
+                    athletesSlot: r.slot,
+                    teamTriCode: r.player.proTeam.triCode,
+                    proGameStatusLines: r.player.proGameStatusLines || [],
+                });
+                if (r.player.currentlyWatching && r.player.points !== undefined) {
+                    activeAthletes.push({
+                        abbrevName: r.player.abbrevName,
+                        points: `${r.player.points} FPTS`,
+                    });
+                }
+            }
+            items.push({
+                id: stringHashCode(JSON.stringify(preference)).toString(),
+                type: 'matchup-single',
+                topPlayers: this.parseTopPlayers(data.topPlayers || []),
+                league: {
+                    color: data.sportColor,
+                    logo: data.sportLogo,
+                    subtitle: data.name,
+                    title: data.leagueName,
+                },
+                team: {
+                    logo: team.logo,
+                    scoringType: data.scoringType.includes('SEASON')
+                        ? 'SEASON'
+                        : data.scoringType,
+                    points: team.points,
+                },
+                roster: matchupRoster,
+                activeAthletes,
+            });
+        }
+        return items;
+    }
+    append(item, leagueKey) {
+        if (!item) {
+            return;
+        }
+        if (item.type === 'notLoggedIn' || item.type === 'promo') {
+            this.fantasyItems.value = [item];
+            return;
+        }
+        // Store the league key for this item
+        if (leagueKey) {
+            this.itemToLeagueKey.set(item.id, leagueKey);
+        }
+        const current = this.fantasyItems.value.find((i) => {
+            return i.id === item.id;
+        });
+        let updatedItems;
+        if (current) {
+            const index = this.fantasyItems.value.indexOf(current);
+            updatedItems = [...this.fantasyItems.value];
+            updatedItems[index] = item;
+        }
+        else {
+            updatedItems = [...this.fantasyItems.value, item];
+        }
+        // Sort items based on their league's position in preferences array
+        updatedItems.sort((a, b) => {
+            const keyA = this.itemToLeagueKey.get(a.id);
+            const keyB = this.itemToLeagueKey.get(b.id);
+            const orderA = keyA !== undefined
+                ? this.leagueSortOrder.get(keyA) ?? Number.MAX_SAFE_INTEGER
+                : Number.MAX_SAFE_INTEGER;
+            const orderB = keyB !== undefined
+                ? this.leagueSortOrder.get(keyB) ?? Number.MAX_SAFE_INTEGER
+                : Number.MAX_SAFE_INTEGER;
+            return orderA - orderB;
+        });
+        this.fantasyItems.value = updatedItems;
+    }
+    parseHeadToHead(data, preference) {
+        if (!data.matchups?.length ||
+            !data.leagueName ||
+            !data.sportColor ||
+            !data.sportLogo ||
+            !data.gameId) {
+            return null;
+        }
+        const items = [];
+        for (const matchup of data.matchups) {
+            if (!matchup.home || !matchup.away) {
+                continue;
+            }
+            const roster = [];
+            const activeAthletes = [];
+            const homeRoster = matchup.home.roster || [];
+            const awayRoster = matchup.away.roster || [];
+            for (let i = 0; i < awayRoster.length; i++) {
+                const singleAwayRoster = awayRoster[i];
+                const singleHomeRoster = homeRoster[i];
+                if (!singleAwayRoster.player || !singleHomeRoster.player)
+                    continue;
+                if (!singleAwayRoster.player.abbrevName ||
+                    !singleAwayRoster.player.headshot ||
+                    !singleAwayRoster.slot ||
+                    !singleAwayRoster.player.proTeam?.triCode ||
+                    !matchup.away?.record) {
+                    continue;
+                }
+                if (!singleHomeRoster.player.abbrevName ||
+                    !singleHomeRoster.player.headshot ||
+                    !singleHomeRoster.slot ||
+                    !singleHomeRoster.player.proTeam?.triCode ||
+                    !matchup.home?.record) {
+                    continue;
+                }
+                roster.push({
+                    away: {
+                        abbrevName: singleAwayRoster.player.abbrevName,
+                        headshot: singleAwayRoster.player.headshot,
+                        points: singleAwayRoster.player.points,
+                        slot: singleAwayRoster.slot,
+                        stats: singleAwayRoster.player.proGameStatusLines || [],
+                        triCode: singleAwayRoster.player.proTeam.triCode,
+                        projectedPoints: singleAwayRoster.player.projectedPoints,
+                    },
+                    home: {
+                        abbrevName: singleHomeRoster.player.abbrevName,
+                        headshot: singleHomeRoster.player.headshot,
+                        points: singleHomeRoster.player.points,
+                        slot: singleHomeRoster.slot,
+                        stats: singleHomeRoster.player.proGameStatusLines || [],
+                        triCode: singleHomeRoster.player.proTeam?.triCode,
+                        projectedPoints: singleHomeRoster.player.projectedPoints,
+                    },
+                });
+                if (singleHomeRoster.player.currentlyWatching &&
+                    singleHomeRoster.player.points !== undefined) {
+                    activeAthletes.push({
+                        abbrevName: singleHomeRoster.player.abbrevName,
+                        points: `${singleHomeRoster.player.points} FPTS`,
+                    });
+                }
+            }
+            items.push({
+                id: stringHashCode(JSON.stringify(preference)).toString(),
+                type: 'matchup-pair',
+                awayTeam: {
+                    logo: matchup.away.logo,
+                    name: matchup.away.name,
+                    points: data.scoringType === 'H2H_POINTS'
+                        ? String(matchup.away.points)
+                        : matchup.away.score,
+                    projectedPoints: matchup.away.projectedPoints,
+                    record: matchup.away.record,
+                    winProbability: matchup.away.winProbability,
+                },
+                homeTeam: {
+                    logo: matchup.home.logo,
+                    name: matchup.home.name,
+                    points: data.scoringType === 'H2H_POINTS'
+                        ? String(matchup.home.points)
+                        : matchup.home.score,
+                    projectedPoints: matchup.home.projectedPoints,
+                    record: matchup.home.record,
+                    winProbability: matchup.home.winProbability,
+                },
+                league: {
+                    color: data.sportColor,
+                    logo: data.sportLogo,
+                    subtitle: matchup.name,
+                    title: data.leagueName,
+                },
+                roster,
+                activeAthletes,
+                topPlayers: this.parseTopPlayers(data.topPlayers || []),
+            });
+        }
+        return items;
+    }
+    parseTopPlayers(players) {
+        const topPlayers = [];
+        for (const p of players) {
+            if (!p.abbrevName ||
+                !p.headshot ||
+                !p.proTeam?.triCode ||
+                p.points === undefined) {
+                continue;
+            }
+            let rosteredBy = '';
+            if (p.percentRostered !== undefined &&
+                p.percentRostered > 0 &&
+                p.playerStatus?.startsWith('Rostered')) {
+                rosteredBy = p.playerStatus;
+            }
+            topPlayers.push({
+                abbrevName: p.abbrevName,
+                headshot: p.headshot,
+                position: p.positions?.split(',')[0] || '',
+                teamTriCode: p.proTeam.triCode,
+                points: p.points,
+                rosteredBy,
+            });
+        }
+        return topPlayers;
+    }
+    parseInactiveLeague(data, draftDate) {
+        if (!data.sportColor || !data.sportLogo || !data.leagueName) {
+            return null;
+        }
+        let draftDateNum = undefined;
+        if (draftDate) {
+            const parsedDate = new Date(Number(draftDate));
+            if (!isNaN(parsedDate.getTime())) {
+                draftDateNum = parsedDate.getTime();
+            }
+        }
+        return {
+            id: slugify(`${data.gameId}-inactive-${data.leagueName}`),
+            leagueColor: data.sportColor,
+            leagueLogo: data.sportLogo,
+            leagueName: data.leagueName,
+            type: 'inactiveLeague',
+            draftDate: draftDateNum,
+        };
+    }
+    /**
+     * Fetch mock data for testing
+     */
+    async fetchMockData() {
+        this.hasEverSuccessfullyLoaded.value = true;
+        await this.processFantasy(MOCK_FANTASY_RESPONSE);
+        this.errorState.value = 'none';
+        this.isDataLoading.value = false;
+    }
+    clearTabLoadFailure() {
+        this.errorState.value = 'none';
+        // Small delay to allow UI to update before refetching
+        setTimeout(() => {
+            this.fetchData();
+        }, 100);
+    }
+}
+export default FantasyViewModel;