@maestro_io/maestro-web-sdk 5.2.1 → 5.2.2

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

@@ -1,815 +0,0 @@
-import { Observable } from '@/helpers/Observable';
-import { captureException } from '@/sentry';
-import SDK from '@/index';
-import FantasyService from '@/modules/espn/fantasy/services/FantasyService';
-import { isLeagueManagerHeadToHeadResponse, isLeagueManagerRotoResponse, } from '../types';
-import FantasyPolling from './FantasyViewModel.FantasyPolling';
-import LeagueManagerPolling from './FantasyViewModel.LeagueManagerPolling';
-import TournamentPolling from './FantasyViewModel.TournamentPolling';
-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, analyticsService, 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)
-        });
-        Object.defineProperty(this, "isLoadingTc", {
-            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, "tournamentPolling", {
-            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
-        });
-        Object.defineProperty(this, "_promoData", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "_fantasyLeagues", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "_tournamentChallenges", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "_promoItem", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "_tcProcessingCount", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        this.useMockData = options.useMockData || false;
-        this.eventId = eventId;
-        this.delegate = delegate;
-        this.analyticsService = analyticsService;
-        this.fantasyService = new FantasyService();
-        this.fantasyPolling = new FantasyPolling(this.fantasyService);
-        this.leagueManagerPolling = new LeagueManagerPolling(this.fantasyService);
-        this.tournamentPolling = new TournamentPolling(this.fantasyService);
-    }
-    /**
-     * Initialize the ViewModel and start data fetching
-     */
-    async init() {
-        // Track panel view on initialization
-        this.trackPanelView();
-        await this.fetchData();
-    }
-    handleFetchError(error, context = 'FantasyViewModel.fetchData') {
-        captureException(error, { context });
-        console.error('[FANTASY] Error in ' + context + ':', error);
-        this.isDataLoading.value = false;
-        if (!this.hasEverSuccessfullyLoaded.value) {
-            this.errorState.value = 'tabLoadFailure';
-        }
-    }
-    async fetchData() {
-        try {
-            this.isDataLoading.value = true;
-            const isAuthenticated = await this.delegate.userIsAuthenticated();
-            if (!isAuthenticated) {
-                this.isDataLoading.value = false;
-                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), this.handleFetchError.bind(this));
-            }
-        }
-        catch (error) {
-            this.handleFetchError(error);
-        }
-    }
-    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.tournamentPolling.stopAll();
-        this.leagueSortOrder.clear();
-        this.itemToLeagueKey.clear();
-        this._fantasyLeagues = [];
-        this._tournamentChallenges = [];
-        this._promoItem = null;
-        this._tcProcessingCount = 0;
-        this.isLoadingTc.value = false;
-        this.fantasyItems.value = [];
-        this.hasEverSuccessfullyLoaded.value = false;
-    }
-    /**
-     * 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();
-            this.tournamentPolling.stopAll();
-            // Check hide_pickems flag from panel config
-            const config = SDK.getPageConfig();
-            const panel = config?.panels?.find((p) => p.panel_type === 'espnFantasy');
-            const hidePickems = panel?.renderer?.block_data?.hide_pickems || false;
-            const hasChallenges = (data.fantasyData?.challengeInformation || []).length > 0;
-            const noData = (data.fantasyData?.totalChallengeEntries || 0) +
-                (data.fantasyData?.totalFantasyLeagues || 0) ===
-                0;
-            // Clear and rebuild the sort order map based on preferences array order
-            this.leagueSortOrder.clear();
-            this.itemToLeagueKey.clear();
-            // Clear internal lists on full refresh
-            this._fantasyLeagues = [];
-            this._tournamentChallenges = [];
-            if (!hidePickems && hasChallenges) {
-                this.isLoadingTc.value = true;
-                data.fantasyData?.challengeInformation?.forEach((challenge) => {
-                    if (challenge.gameType === 'BRACKET') {
-                        this._tcProcessingCount++;
-                        const key = `tc-${challenge.id}-${token}`;
-                        this.tournamentPolling.refresh(key, {
-                            challengeId: String(challenge.id),
-                            competitionId: this.eventId,
-                            token,
-                        }, (data) => {
-                            this.parseTournamentChallenge(data);
-                            this._tcProcessingCount--;
-                            if (this._tcProcessingCount === 0) {
-                                this.isLoadingTc.value = false;
-                                this.rebuildFantasyItems();
-                            }
-                        }, (error) => {
-                            this.handleFetchError(error, 'FantasyViewModel.processFantasy.tournamentChallenge');
-                        });
-                    }
-                });
-                // If no BRACKET challenges were found, set isLoadingTc back to false
-                if (this._tcProcessingCount === 0) {
-                    this.isLoadingTc.value = false;
-                }
-            }
-            else {
-                this.isLoadingTc.value = false;
-            }
-            if (noData || (data.preferences || []).length === 0) {
-                const promo = await this.getPromoData();
-                if (promo) {
-                    this._promoItem = {
-                        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,
-                    };
-                }
-            }
-            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);
-                            }
-                        }
-                    }
-                }, (error) => {
-                    this.handleFetchError(error, 'FantasyViewModel.processFantasy.leagueManager');
-                });
-            }
-            // Mark successful load
-            this.hasEverSuccessfullyLoaded.value = true;
-            this.errorState.value = 'none';
-            this.isDataLoading.value = false;
-            // Initial rebuild even if empty, to ensure state is clean
-            this.rebuildFantasyItems();
-        }
-        catch (error) {
-            this.handleFetchError(error, 'FantasyViewModel.processFantasy');
-        }
-    }
-    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') {
-            this.fantasyItems.value = [item];
-            return;
-        }
-        if (item.type === 'promo') {
-            this._promoItem = item;
-        }
-        // Store the league key for this item if provided
-        if (leagueKey) {
-            this.itemToLeagueKey.set(item.id, leagueKey);
-        }
-        if (item.type === 'matchup-pair' ||
-            item.type === 'matchup-single' ||
-            item.type === 'inactiveLeague') {
-            const existingItemIndex = this._fantasyLeagues.findIndex((i) => i.id === item.id);
-            if (existingItemIndex !== -1) {
-                this._fantasyLeagues[existingItemIndex] = item;
-            }
-            else {
-                this._fantasyLeagues.push(item);
-            }
-            // Sort items inside the group
-            this._fantasyLeagues.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;
-            });
-        }
-        const existingGroupIndex = this._tournamentChallenges.findIndex((g) => g.id === leagueKey);
-        if (item.type === 'fantasy-header') {
-            if (existingGroupIndex !== -1) {
-                this._tournamentChallenges[existingGroupIndex].header = item;
-            }
-            else if (leagueKey) {
-                this._tournamentChallenges.push({
-                    type: 'fantasy-group',
-                    id: leagueKey,
-                    header: item,
-                    items: [],
-                });
-            }
-        }
-        else if (item.type === 'tournament-bracket-card' ||
-            item.type === 'tournament-overflow-qr') {
-            if (existingGroupIndex !== -1) {
-                const group = this._tournamentChallenges[existingGroupIndex];
-                const existingItemIndex = group.items.findIndex((i) => i.id === item.id);
-                if (existingItemIndex !== -1) {
-                    group.items[existingItemIndex] = item;
-                }
-                else {
-                    group.items.push(item);
-                }
-            }
-            else if (leagueKey) {
-                this._tournamentChallenges.push({
-                    type: 'fantasy-group',
-                    id: leagueKey,
-                    header: {
-                        type: 'fantasy-header',
-                        id: `${leagueKey}-header`,
-                        title: '',
-                    },
-                    items: [item],
-                });
-            }
-        }
-        this.rebuildFantasyItems();
-    }
-    rebuildFantasyItems() {
-        const items = [];
-        if (this._tournamentChallenges.length > 0) {
-            items.push(...this._tournamentChallenges);
-        }
-        if (this._fantasyLeagues.length > 0) {
-            items.push({
-                type: 'fantasy-group',
-                id: 'header-fantasy-leagues-group',
-                header: {
-                    type: 'fantasy-header',
-                    id: 'header-fantasy-leagues',
-                    title: 'Fantasy Leagues',
-                },
-                items: this._fantasyLeagues,
-            });
-        }
-        if (this._promoItem &&
-            this._tournamentChallenges.length === 0 &&
-            this._fantasyLeagues.length === 0 &&
-            items.length === 0 &&
-            !this.isLoadingTc.value) {
-            items.push(this._promoItem);
-        }
-        this.fantasyItems.value = items;
-    }
-    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,
-        };
-    }
-    async getPromoData() {
-        if (this._promoData) {
-            return this._promoData;
-        }
-        try {
-            this._promoData = await this.fantasyService.getPromo();
-            return this._promoData;
-        }
-        catch (error) {
-            captureException(error, {
-                context: 'FantasyViewModel.getPromoData',
-            });
-            return null;
-        }
-    }
-    async parseTournamentChallenge(data) {
-        if (!data.id) {
-            return;
-        }
-        let validEntries = data.entries?.filter((entry) => entry.id) || [];
-        if (validEntries.length === 0) {
-            return;
-        }
-        const header = {
-            type: 'fantasy-header',
-            id: `${data.id}-header`,
-            title: data.name || 'Tournament Challenge',
-        };
-        this.append(header, data.id);
-        const existingGroupIndex = this._tournamentChallenges.findIndex((g) => g.id === data.id);
-        if (existingGroupIndex !== -1) {
-            this._tournamentChallenges[existingGroupIndex].items = [];
-        }
-        const totalEntries = validEntries.length;
-        const entriesToShow = validEntries.slice(0, 5);
-        for (const entry of entriesToShow) {
-            let userPickName;
-            if (data.propositions && entry.picks) {
-                for (const pick of entry.picks) {
-                    if (!pick.propositionId || !pick.outcomeId)
-                        continue;
-                    const proposition = data.propositions.find((p) => p.id === pick.propositionId);
-                    if (proposition && proposition.outcomes) {
-                        const outcome = proposition.outcomes.find((o) => o.id === pick.outcomeId);
-                        if (outcome && outcome.name) {
-                            userPickName = outcome.name;
-                            break;
-                        }
-                    }
-                }
-            }
-            const card = {
-                type: 'tournament-bracket-card',
-                id: entry.id,
-                name: entry.name || '',
-                rank: entry.rank || 0,
-                score: entry.score || 0,
-                percentile: Math.round((entry.percentile || 0) * 100),
-                entryStatusIcon: entry.entryStatusIcon || '',
-                finalPick: entry.finalPick
-                    ? {
-                        propositionId: entry.finalPick.propositionId,
-                        outcomeId: entry.finalPick.outcomeId,
-                        primaryLogo: entry.finalPick.outcomePicked?.primaryLogo,
-                        secondaryLogo: entry.finalPick.outcomePicked
-                            ?.secondaryLogo,
-                        result: entry.finalPick.result,
-                    }
-                    : { propositionId: '', outcomeId: '' },
-                isComplete: entry.isComplete || false,
-                picks: entry.picks,
-                tournamentId: data.id,
-                tournamentAbbrev: data.abbrev || '',
-                tournamentLogo: data.logo || '',
-                propositions: data.propositions,
-                userPickName,
-            };
-            this.append(card, data.id);
-        }
-        if (totalEntries > 5 && data.state === 'LIVE') {
-            const promoData = await this.getPromoData();
-            const isLocked = data.locked === true;
-            const qrCodeVariant = isLocked ? 'tc-live' : 'tc-pre';
-            const promoVariant = promoData?.[qrCodeVariant];
-            if (promoVariant) {
-                const overflowQR = {
-                    type: 'tournament-overflow-qr',
-                    id: `${data.id}-overflow`,
-                    background: promoVariant.promotion.background,
-                    logo: promoVariant.promotion.logo,
-                    qrCode: promoVariant.promotion.qrCode,
-                    title: promoVariant.promotion.title,
-                    description: promoVariant.promotion.description,
-                    tournamentId: data.id,
-                };
-                this.append(overflowQR, data.id);
-            }
-        }
-    }
-    /**
-     * 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);
-    }
-    setDataToPanel(data) {
-        if (data.leagueManagerOverrideBaseUrl) {
-            this.fantasyService.leagueManagerOverrideBaseUrl =
-                data.leagueManagerOverrideBaseUrl;
-        }
-        if (data.fantasyOverrideBaseUrl) {
-            this.fantasyService.fantasyOverrideBaseUrl = data.fantasyOverrideBaseUrl;
-        }
-        if (data.gambitOverrideBaseUrl) {
-            this.fantasyService.gambitOverrideBaseUrl = data.gambitOverrideBaseUrl;
-        }
-    }
-}
-export default FantasyViewModel;