@maestro_io/maestro-web-sdk 5.2.0 → 5.2.2

package/dist/src/modules/espn/bets/view-model/BetsViewModel.js

@@ -1,947 +0,0 @@
-import { Observable } from '../../../../helpers/Observable';
-import BetsService from '../services/BetsService';
-import { UserSettingsManager } from '../../../../services/UserSettingsManager';
-// Import ViewModel with correct path
-import { ViewModel } from '../../../../view-models/ViewModel';
-import { MOCK_BETS_API_RESPONSE } from '../mocks';
-import SDK from '@/index';
-import { captureException } from '@/sentry';
-import { stringHashCode } from '@/helpers/strings';
-// The interval for polling bet data (in milliseconds)
-const DEFAULT_POLLING_INTERVAL = 30000; // 30 seconds
-const BET_ITEM_TYPE = {
-    ODDS: 'odds',
-    USER_BETS: 'userBets',
-    PROMO: 'promo',
-    HOT_PROPS: 'hotProps',
-    LOCATION_DISCLAIMER: 'locationDisclaimer',
-    GAMBLING_MESSAGE: 'gamblingMessage',
-};
-const BET_ERROR_STATE = {
-    NONE: 'none',
-    TAB_LOAD_FAILURE: 'tabLoadFailure',
-};
-const isPersonalizedBetsResponse = (data) => {
-    return (typeof data === 'object' &&
-        data !== null &&
-        'event' in data &&
-        typeof data.event === 'object');
-};
-export class BetsViewModel extends ViewModel {
-    constructor(eventId, delegate, analyticsService, options = {}) {
-        super();
-        // Observable properties
-        Object.defineProperty(this, "betsItems", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Observable([])
-        });
-        Object.defineProperty(this, "isDataLoading", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Observable(true)
-        });
-        Object.defineProperty(this, "errorState", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Observable('none')
-        });
-        Object.defineProperty(this, "hasEverSuccessfullyLoaded", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Observable(false)
-        });
-        Object.defineProperty(this, "hideWagers", {
-            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, "betsService", {
-            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, "pollingInterval", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "pollingTask", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "lastNonPersonalizedResponseHash", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "lastPersonalizedResponseHash", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "useMockData", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "userSettingsManager", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "settingsSubscription", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "initialized", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        this.eventId = eventId;
-        this.delegate = delegate;
-        this.betsService = new BetsService(delegate);
-        this.analyticsService = analyticsService;
-        this.pollingInterval = DEFAULT_POLLING_INTERVAL;
-        this.useMockData = options.useMockData || false;
-        this.userSettingsManager = UserSettingsManager.getInstance();
-        // Initialize hide_wagers setting
-        this.hideWagers.value = this.userSettingsManager.shouldHideWagers();
-        // Subscribe to settings changes
-        this.settingsSubscription = this.userSettingsManager.settings.subscribe(() => {
-            this.updateHideWagersFromSettings();
-        });
-        this.betsService = new BetsService(delegate);
-    }
-    /**
-     * Initialize the ViewModel and start data fetching
-     */
-    async init() {
-        // Track panel view on initialization
-        this.trackPanelView();
-        await this.fetchNewData();
-        this.refreshPolling();
-        this.initialized = true;
-    }
-    /**
-     * Clean up resources when the ViewModel is no longer needed
-     */
-    cleanup() {
-        this.stopPolling();
-        // Clean up settings subscription
-        if (this.settingsSubscription) {
-            this.settingsSubscription();
-            this.settingsSubscription = null;
-        }
-        this.initialized = false;
-    }
-    /**
-     * Track panel view event
-     */
-    async trackPanelView() {
-        try {
-            const betCounts = this.getUserBetCounts();
-            await this.analyticsService.panelView('espnBet', betCounts);
-        }
-        catch (error) {
-            captureException(error, {
-                context: 'BetsViewModel.trackPanelView',
-            });
-            console.error('[BET] Error tracking panel view:', error);
-        }
-    }
-    /**
-     * Track card click event
-     */
-    async trackCardClick(cardType, betType) {
-        try {
-            const betCounts = this.getUserBetCounts();
-            const metadata = {
-                ...betCounts,
-                card: cardType,
-                bet_type: betType || null,
-            };
-            await this.analyticsService.panelClick({
-                type: 'espnBet',
-                name: 'bets_item_clicked',
-                metadata,
-            });
-        }
-        catch (error) {
-            captureException(error, {
-                context: 'BetsViewModel.trackCardClick',
-                cardType,
-                betType,
-            });
-            console.error('[BET] Error tracking card click:', error);
-        }
-    }
-    /**
-     * Get user bet counts for analytics
-     */
-    getUserBetCounts() {
-        try {
-            let inGameBets = 0;
-            let totalBets = 0;
-            // Count bets from current data
-            for (const item of this.betsItems.value) {
-                if (item.type === 'userBets') {
-                    const userBetsItem = item;
-                    const allBets = [
-                        ...userBetsItem.data.bets.live,
-                        ...userBetsItem.data.bets.settled,
-                        ...userBetsItem.data.bets.upcoming,
-                    ];
-                    totalBets = allBets.length;
-                    inGameBets = userBetsItem.data.bets.live.length;
-                    break;
-                }
-            }
-            return {
-                in_game_bets: inGameBets,
-                total_bets: totalBets,
-            };
-        }
-        catch (error) {
-            captureException(error, {
-                context: 'BetsViewModel.getUserBetCounts',
-            });
-            console.error('[BET] Error getting user bet counts:', error);
-            return {
-                in_game_bets: 0,
-                total_bets: 0,
-            };
-        }
-    }
-    /**
-     * Refresh polling for bet data
-     */
-    refreshPolling() {
-        // First stop any existing polling
-        this.stopPolling();
-        if (this.useMockData) {
-            return;
-        }
-        // We'll determine whether to use authenticated polling in the polling task
-        this.pollingTask = {
-            stop: () => {
-                // This will be replaced when actual polling starts
-            },
-        };
-        // Start the poll loop
-        this.pollWithInterval();
-    }
-    /**
-     * Get user credentials from delegate
-     */
-    async getUserCredentials() {
-        const swid = (await this.delegate.getUserSWID()) || '';
-        const jwt = (await this.delegate.getUserToken()) || '';
-        return { swid, jwt };
-    }
-    /**
-     * @description Update polling interval checking either response header or panel config.
-     * Refresh polling if necessary.
-     */
-    updatePollingInterval(headers) {
-        const headerInterval = this.getResponseHeaderPollingIntervalValue(headers);
-        const panelConfigInterval = this.getPanelConfigInterval();
-        const newInterval = headerInterval || panelConfigInterval; // order matters here
-        if (newInterval && newInterval !== this.pollingInterval) {
-            this.pollingInterval = newInterval;
-            console.log(`[BET] Updating polling interval to ${this.pollingInterval} milliseconds`);
-            // If we have an active polling task, restart it with the new interval
-            this.refreshPolling();
-        }
-    }
-    getPanelConfigInterval() {
-        const config = SDK.getPageConfig();
-        const panel = config?.panels?.find((p) => p.panel_type === 'espnBet');
-        if (!panel) {
-            return null;
-        }
-        const oddsPollingInterval = panel.renderer?.block_data?.odds_polling_interval;
-        if (!oddsPollingInterval) {
-            return null;
-        }
-        const parsedInterval = parseInt(oddsPollingInterval, 10);
-        if (isNaN(parsedInterval) || parsedInterval <= 0) {
-            console.warn(`[BET] Invalid polling interval from panel config: ${oddsPollingInterval}.`);
-            return null;
-        }
-        return parsedInterval * 1000; // Convert seconds to milliseconds
-    }
-    getResponseHeaderPollingIntervalValue(headers) {
-        const newInterval = headers['polling-interval'];
-        if (!newInterval) {
-            return null;
-        }
-        const parsedInterval = parseInt(newInterval, 10);
-        if (isNaN(parsedInterval) || parsedInterval <= 0) {
-            console.warn(`[BET] Invalid polling interval header received: ${newInterval}.`);
-            return null;
-        }
-        return parsedInterval * 1000; // Convert seconds to milliseconds
-    }
-    /**
-     * Poll with the personalized endpoint for both authenticated and anonymous users
-     *
-     * SWID format is provided by the client app delegate:
-     * - Logged in: {6D201B58-440C-47A6-970B-0F8C78C0BAB8} (with curly braces)
-     * - Anonymous: 6D201B58-440C-47A6-970B-0F8C78C0BAB8 (without curly braces)
-     * - Failsafe: Empty string if local storage fails
-     */
-    async pollWithInterval() {
-        try {
-            // Always use personalized endpoint
-            const { swid, jwt } = await this.getUserCredentials();
-            // Start personalized polling for both authenticated and anonymous users with headers
-            this.pollingTask = this.betsService.pollPersonalizedBetsWithHeaders(this.eventId, swid, jwt, this.pollingInterval, (response) => {
-                this.updatePollingInterval(response.headers);
-                this.processPolledData(response.data);
-            }, this.handlePollingError.bind(this));
-        }
-        catch (error) {
-            captureException(error, {
-                context: 'BetsViewModel.pollWithInterval',
-            });
-            console.error('[BET] Error setting up polling:', error);
-        }
-    }
-    /**
-     * Process data received from polling
-     */
-    processPolledData(data) {
-        // Calculate hash for the response to check if it's different from the last one
-        const responseHash = stringHashCode(JSON.stringify(data));
-        const isPersonalized = isPersonalizedBetsResponse(data);
-        if (isPersonalized) {
-            // Check if this is the same as the last successful response
-            if (this.lastPersonalizedResponseHash === responseHash &&
-                this.hasEverSuccessfullyLoaded.value) {
-                console.log('[BET] Response hash is the same as last successful response - skipping update');
-                return;
-            }
-            // Update tracking variables
-            this.lastPersonalizedResponseHash = responseHash;
-            //   this.lastSuccessfulResponsePersonalized =
-            //     data as IPersonalizedBetsResponse;
-        }
-        else {
-            // Check if this is the same as the last successful response
-            if (this.lastNonPersonalizedResponseHash === responseHash &&
-                this.hasEverSuccessfullyLoaded.value) {
-                console.log('[BET] Response hash is the same as last successful response - skipping update');
-                return;
-            }
-            // Update tracking variables
-            this.lastNonPersonalizedResponseHash = responseHash;
-            //   this.lastSuccessfulResponseNonPersonalized = data as IBetsResponse;
-        }
-        // Update state
-        this.hasEverSuccessfullyLoaded.value = true;
-        this.errorState.value = 'none';
-        // Process the response and update betsItems
-        // This is a placeholder - you would need to implement the actual logic
-        // for parsing different parts of the response (sixPacks, hot props, etc.)
-        this.processBetsData(data);
-    }
-    /**
-     * Process the bets data and update the betsItems
-     */
-    processBetsData(data) {
-        // Clear current items
-        const newItems = [];
-        if (!Object.keys(data).length) {
-            return;
-        }
-        // 1. Process regular odds (always available in both response types)
-        const sixPack = this.processSixPackData(data);
-        if (sixPack) {
-            newItems.push(sixPack);
-        }
-        // 2. Process location disclaimer if this is a personalized response
-        const locationDisclaimer = this.processLocationDisclaimer(data);
-        if (locationDisclaimer) {
-            newItems.push(locationDisclaimer);
-        }
-        // 3. Process user bets if this is a personalized response
-        const userBets = this.processUserBetsData(data);
-        if (userBets) {
-            newItems.push(userBets);
-        }
-        // 4. Process featured(hot props) bets if available
-        const hotProps = this.processHotProps(data);
-        if (hotProps) {
-            newItems.push(hotProps);
-        }
-        // 5. Process promo code
-        const promoCode = this.processPromoCode(data);
-        if (promoCode) {
-            newItems.push(promoCode);
-        }
-        // 6. Process gambling message if available
-        const gamblingMessage = this.processGamblingMessage(data);
-        if (gamblingMessage) {
-            newItems.push(gamblingMessage);
-        }
-        // Update the observable
-        this.betsItems.value = newItems;
-    }
-    processLocationDisclaimer(data) {
-        const isPersonalized = isPersonalizedBetsResponse(data);
-        if (!isPersonalized || !data.disclaimers?.location) {
-            return null;
-        }
-        return {
-            type: 'locationDisclaimer',
-            id: 'locationDisclaimer',
-            data: {
-                text: data.disclaimers.location,
-            },
-        };
-    }
-    processPromoCode(data) {
-        const isPersonalized = isPersonalizedBetsResponse(data);
-        if (!isPersonalized || !data.promotion) {
-            return null;
-        }
-        return {
-            type: 'promo',
-            data: {
-                title: data.promotion.title || '',
-                description: data.promotion.description || '',
-                logo: data.promotion.logo || '',
-                qrCode: data.promotion.qrCode || '',
-                backgroundImage: data.promotion.backgroundImage || '',
-            },
-            id: `promo-${data.event?.id || data.id}`,
-        };
-    }
-    processGamblingMessage(data) {
-        const isPersonalized = isPersonalizedBetsResponse(data);
-        if (!isPersonalized || !data.disclaimers?.gambling) {
-            return null;
-        }
-        return {
-            type: 'gamblingMessage',
-            id: 'gamblingMessage',
-            data: {
-                text: data.disclaimers.gambling,
-            },
-        };
-    }
-    processSixPackData(response) {
-        const isPersonalized = isPersonalizedBetsResponse(response);
-        const teams = response.entities?.teams;
-        const odds = !isPersonalized
-            ? response.bets?.odds
-            : response.event?.bets?.odds;
-        const gameState = !isPersonalized
-            ? response.gameState
-            : response.event?.gameState;
-        const sport = !isPersonalized ? response.sport : response.event?.sport;
-        const eventId = !isPersonalized ? response.id : response.event?.id;
-        const isSoccer = !isPersonalized
-            ? response.sport === 'soccer'
-            : response.event?.sport === 'soccer';
-        if (!odds || !gameState || !sport || !eventId || !teams) {
-            return null;
-        }
-        const teamArray = Object.values(teams);
-        let awayTeam;
-        let homeTeam;
-        // Find home and away teams from odds
-        for (const team of Object.values(teams)) {
-            const spreadOdds = odds.find((odd) => odd.type === 'pointSpread');
-            if (spreadOdds) {
-                if (spreadOdds.values.some((v) => v.team === team.id && v.type === 'home')) {
-                    homeTeam = team;
-                }
-                else if (spreadOdds.values.some((v) => v.team === team.id && v.type === 'away')) {
-                    awayTeam = team;
-                }
-            }
-        }
-        // Fallback logic if we couldn't determine from odds
-        if (!homeTeam || !awayTeam) {
-            console.warn('Could not determine home/away teams from odds, using first two teams');
-            switch (teamArray.length) {
-                case 0:
-                    throw new Error('No teams found in response');
-                case 1:
-                    // Only one team - unusual case, but handle gracefully
-                    homeTeam = teamArray[0];
-                    awayTeam = teamArray[0]; // Same team as both home and away (shouldn't happen)
-                    break;
-                case 2:
-                    // Default to first team as home, second as away
-                    homeTeam = teamArray[0];
-                    awayTeam = teamArray[1];
-                    break;
-                default:
-                    // More than 2 teams - take first two and log warning
-                    homeTeam = teamArray[0];
-                    awayTeam = teamArray[1];
-                    console.warn(`Warning: Unexpected team count (${teamArray.length}) in six pack response`);
-            }
-        }
-        if (!awayTeam || !homeTeam) {
-            throw new Error('Could not determine home or away team from response');
-        }
-        const isInProgress = gameState === 'in';
-        const isHomeFavoured = (() => {
-            if (isSoccer && !isInProgress) {
-                return homeTeam.favoredAtOpen ?? true;
-            }
-            return homeTeam.favored ?? true;
-        })();
-        const isAwayFavoured = (() => {
-            if (isSoccer && !isInProgress) {
-                return awayTeam.favoredAtOpen ?? false;
-            }
-            return awayTeam.favored ?? false;
-        })();
-        let awayTeamStartGameFirstLine = '';
-        let awayTeamStartGameSecondLine = '';
-        let homeTeamStartGameFirstLine = '';
-        let homeTeamStartGameSecondLine = '';
-        let awaySpreadFirstLine = '';
-        let awaySpreadSecondLine = '';
-        let homeSpreadFirstLine = '';
-        let homeSpreadSecondLine = '';
-        let awayTotalFirstLine = '';
-        let awayTotalSecondLine = '';
-        let homeTotalFirstLine = '';
-        let homeTotalSecondLine = '';
-        let awayMoneylineFirstLine = '';
-        let homeMoneylineFirstLine = '';
-        let drawGameStateFirstLine = '';
-        let drawGameStateSecondLine = '';
-        let drawMoneylineFirstLine = '';
-        const itemTypeSet = new Set();
-        const orderedColumns = [];
-        for (const oddsItem of odds) {
-            if (!itemTypeSet.has(oddsItem.type)) {
-                orderedColumns.push({
-                    type: oddsItem.type,
-                    abbreviation: oddsItem.abbreviation,
-                });
-                itemTypeSet.add(oddsItem.type);
-            }
-            const isLive = oddsItem.state === 'live';
-            const isClose = oddsItem.state === 'close';
-            const isOpen = oddsItem.state === 'open';
-            // For every odd type and using the correct state based on game state, get the odds and lines for the home and away team.
-            // There are special handlings for the 'start of game' lines. It can be from 'spread', 'total' or 'moneyline' depending on which team is favoured, sport, etc.
-            switch (oddsItem.type) {
-                case 'pointSpread': {
-                    const spreadCorrectState = isInProgress ? isLive : isClose;
-                    if (spreadCorrectState) {
-                        for (const value of oddsItem.values) {
-                            if (value.type === 'home') {
-                                homeSpreadFirstLine = value.line ?? '';
-                                homeSpreadSecondLine = value.odds ?? '';
-                            }
-                            if (value.type === 'away') {
-                                awaySpreadFirstLine = value.line ?? '';
-                                awaySpreadSecondLine = value.odds ?? '';
-                            }
-                        }
-                    }
-                    const pointsSpreadStartOfGameCorrectState = isInProgress
-                        ? isClose
-                        : isOpen;
-                    if (pointsSpreadStartOfGameCorrectState && !isSoccer) {
-                        if (isHomeFavoured) {
-                            for (const value of oddsItem.values) {
-                                if (value.type === 'home') {
-                                    homeTeamStartGameFirstLine = value.line ?? '';
-                                    homeTeamStartGameSecondLine = value.odds ?? '';
-                                }
-                            }
-                        }
-                        if (isAwayFavoured) {
-                            for (const value of oddsItem.values) {
-                                if (value.type === 'away') {
-                                    awayTeamStartGameFirstLine = value.line ?? '';
-                                    awayTeamStartGameSecondLine = value.odds ?? '';
-                                }
-                            }
-                        }
-                    }
-                    break;
-                }
-                case 'total': {
-                    const totalCorrectState = isInProgress ? isLive : isClose;
-                    if (totalCorrectState) {
-                        for (const value of oddsItem.values) {
-                            if (value.type === 'over') {
-                                if (isSoccer) {
-                                    homeTotalFirstLine = value.line ?? '';
-                                    homeTotalSecondLine = value.odds ?? '';
-                                }
-                                else {
-                                    awayTotalFirstLine = value.line ?? '';
-                                    awayTotalSecondLine = value.odds ?? '';
-                                }
-                            }
-                            if (value.type === 'under') {
-                                if (isSoccer) {
-                                    awayTotalFirstLine = value.line ?? '';
-                                    awayTotalSecondLine = value.odds ?? '';
-                                }
-                                else {
-                                    homeTotalFirstLine = value.line ?? '';
-                                    homeTotalSecondLine = value.odds ?? '';
-                                }
-                            }
-                        }
-                    }
-                    const totalStartOfGameCorrectState = isInProgress ? isClose : isOpen;
-                    if (totalStartOfGameCorrectState) {
-                        // If home is not favoured, use total as the start of the game line
-                        if (!isHomeFavoured) {
-                            for (const value of oddsItem.values) {
-                                if ((isSoccer && value.type === 'over') ||
-                                    (!isSoccer && value.type === 'under')) {
-                                    homeTeamStartGameFirstLine = value.line ?? '';
-                                    homeTeamStartGameSecondLine = value.odds ?? '';
-                                }
-                            }
-                        }
-                        // If away is not favoured, use total as the start of the game line
-                        if (!isAwayFavoured) {
-                            for (const value of oddsItem.values) {
-                                if ((isSoccer && value.type === 'under') ||
-                                    (!isSoccer && value.type === 'over')) {
-                                    awayTeamStartGameFirstLine = value.line ?? '';
-                                    awayTeamStartGameSecondLine = value.odds ?? '';
-                                }
-                            }
-                        }
-                    }
-                    break;
-                }
-                case 'moneyline': {
-                    const mlCorrectState = isInProgress ? isLive : isClose;
-                    if (mlCorrectState) {
-                        for (const value of oddsItem.values) {
-                            if (value.type === 'home') {
-                                homeMoneylineFirstLine = value.odds ?? '';
-                            }
-                            if (value.type === 'away') {
-                                awayMoneylineFirstLine = value.odds ?? '';
-                            }
-                        }
-                    }
-                    // soccer logic
-                    if (isSoccer) {
-                        const moneyLineStartOfGameCorrectState = isInProgress
-                            ? isClose
-                            : isOpen;
-                        // find draw value
-                        for (const value of oddsItem.values) {
-                            if (value.type === 'draw') {
-                                if (moneyLineStartOfGameCorrectState) {
-                                    drawGameStateFirstLine = value.odds ?? '';
-                                    drawGameStateSecondLine = 'DRAW';
-                                }
-                                if (mlCorrectState) {
-                                    drawMoneylineFirstLine = value.odds ?? '';
-                                }
-                            }
-                        }
-                        if (moneyLineStartOfGameCorrectState) {
-                            if (isHomeFavoured) {
-                                for (const value of oddsItem.values) {
-                                    if (value.type === 'home') {
-                                        homeTeamStartGameFirstLine = value.odds ?? '';
-                                        homeTeamStartGameSecondLine = oddsItem.abbreviation ?? '';
-                                    }
-                                }
-                            }
-                            if (isAwayFavoured) {
-                                for (const value of oddsItem.values) {
-                                    if (value.type === 'away') {
-                                        awayTeamStartGameFirstLine = value.odds ?? '';
-                                        awayTeamStartGameSecondLine = oddsItem.abbreviation ?? '';
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    break;
-                }
-            }
-        }
-        // Create the six pack data structure
-        const awayTeamOdds = {
-            teamAbbreviation: awayTeam.abbreviation ?? '',
-            startOfGameFirstLine: awayTeamStartGameFirstLine,
-            startOfGameSecondLine: awayTeamStartGameSecondLine,
-            gameSpreadFirstLine: awaySpreadFirstLine,
-            gameSpreadSecondLine: awaySpreadSecondLine,
-            totalPointsFirstLine: awayTotalFirstLine,
-            totalPointsSecondLine: awayTotalSecondLine,
-            moneylineFirstLine: awayMoneylineFirstLine,
-        };
-        const homeTeamOdds = {
-            teamAbbreviation: homeTeam.abbreviation ?? '',
-            startOfGameFirstLine: homeTeamStartGameFirstLine,
-            startOfGameSecondLine: homeTeamStartGameSecondLine,
-            gameSpreadFirstLine: homeSpreadFirstLine,
-            gameSpreadSecondLine: homeSpreadSecondLine,
-            totalPointsFirstLine: homeTotalFirstLine,
-            totalPointsSecondLine: homeTotalSecondLine,
-            moneylineFirstLine: homeMoneylineFirstLine,
-        };
-        const drawOdds = {
-            teamAbbreviation: 'DRAW',
-            startOfGameFirstLine: drawGameStateFirstLine,
-            startOfGameSecondLine: drawGameStateSecondLine,
-            gameSpreadFirstLine: '',
-            gameSpreadSecondLine: '',
-            totalPointsFirstLine: '',
-            totalPointsSecondLine: '',
-            moneylineFirstLine: drawMoneylineFirstLine,
-        };
-        const sixPack = {
-            topTeamOdds: isSoccer ? homeTeamOdds : awayTeamOdds,
-            bottomTeamOdds: isSoccer ? awayTeamOdds : homeTeamOdds,
-            drawOdds: drawGameStateFirstLine &&
-                drawGameStateSecondLine &&
-                drawMoneylineFirstLine
-                ? drawOdds
-                : undefined,
-            orderedColumns,
-            gameState,
-        };
-        return {
-            id: `sixpack-${eventId}`,
-            type: 'sixPack',
-            data: sixPack,
-            teamInfo: {
-                home: homeTeam,
-                away: awayTeam,
-            },
-            hideWagers: this.hideWagers.value,
-        };
-    }
-    processUserBetsData(data) {
-        const isPersonalized = isPersonalizedBetsResponse(data);
-        if (!isPersonalized || !data.event || !data.betsModule) {
-            return null;
-        }
-        const betItems = {
-            live: data.betsModule.live.filter((bet) => bet.type !== 'promo'),
-            settled: data.betsModule.settled.filter((bet) => bet.type !== 'promo'),
-            upcoming: data.betsModule.upcoming.filter((bet) => bet.type !== 'promo'),
-        };
-        return {
-            data: {
-                bets: betItems,
-                defaultTab: data.betsModule.defaultTab,
-            },
-            id: `userBets-${data.event.id}`,
-            type: 'userBets',
-            hideWagers: this.hideWagers.value,
-        };
-    }
-    processHotProps(response) {
-        const isPersonalized = isPersonalizedBetsResponse(response);
-        const hotProps = isPersonalized
-            ? response.event?.featured
-            : response.featured;
-        if (!hotProps || !Array.isArray(hotProps)) {
-            return null;
-        }
-        const hasData = hotProps.every((hotProp) => Boolean(hotProp && hotProp.id));
-        if (!hasData) {
-            return null;
-        }
-        const filteredHotProps = hotProps.filter((hotProp) => hotProp.selections.length > 0);
-        return {
-            type: 'hotProps',
-            hideWagers: this.hideWagers.value,
-            id: 'hotProps',
-            data: {
-                items: filteredHotProps.map((hotProp) => {
-                    const bet = hotProp.selections[0];
-                    return {
-                        id: bet.id,
-                        odds: bet.odds.current || '',
-                        marketText: bet.text,
-                        selectionText: hotProp.text,
-                        status: bet.status,
-                        type: bet.type,
-                        icon: bet.icon,
-                        iconDark: bet.iconDark,
-                        outcome: bet.outcome,
-                    };
-                }),
-            },
-        };
-    }
-    /**
-     * Handle errors that occur during polling
-     */
-    handlePollingError(error) {
-        console.error('Polling error:', error);
-        if (!this.hasEverSuccessfullyLoaded.value) {
-            // If we've never had a successful load, show an error state
-            this.errorState.value = 'tabLoadFailure';
-            this.betsItems.value = [];
-        }
-        else {
-            // If we had a previous successful load, keep showing the old data
-            // No need to update errorState or betsItems
-        }
-    }
-    /**
-     * Stop polling for bet data
-     */
-    stopPolling() {
-        if (this.pollingTask) {
-            this.pollingTask.stop();
-            this.pollingTask = null;
-        }
-        if (this.isDataLoading.value) {
-            this.isDataLoading.value = false;
-        }
-    }
-    /**
-     * Fetch new bet data immediately (one-time)
-     */
-    async fetchNewData() {
-        this.isDataLoading.value = true;
-        try {
-            // Handle mock data if enabled
-            if (this.useMockData) {
-                this.betsItems.value = [];
-                await this.fetchMockData();
-                return;
-            }
-            // Always use personalized endpoint for both authenticated and anonymous users
-            await this.fetchPersonalizedData();
-            this.isDataLoading.value = false;
-        }
-        catch (error) {
-            captureException(error, {
-                context: 'BetsViewModel.fetchNewData',
-            });
-            console.error('[BET] Error fetching bet data:', error);
-            if (!this.hasEverSuccessfullyLoaded.value) {
-                this.errorState.value = 'tabLoadFailure';
-                this.betsItems.value = [];
-            }
-            this.isDataLoading.value = false;
-        }
-    }
-    /**
-     * Fetch personalized bet data
-     */
-    async fetchPersonalizedData() {
-        try {
-            const { swid, jwt } = await this.getUserCredentials();
-            const response = await this.betsService.getPersonalizedBets(this.eventId, swid, jwt);
-            // Process the response
-            this.processPolledData(response);
-        }
-        catch (error) {
-            captureException(error, {
-                context: 'BetsViewModel.fetchPersonalizedData',
-            });
-            console.error('[BET] Error fetching personalized bets:', error);
-            throw error;
-        }
-    }
-    /**
-     * Fetch mock data for testing
-     */
-    async fetchMockData() {
-        this.processBetsData(MOCK_BETS_API_RESPONSE);
-        this.hasEverSuccessfullyLoaded.value = true;
-        this.errorState.value = 'none';
-        this.isDataLoading.value = false;
-    }
-    clearTabLoadFailure() {
-        this.errorState.value = 'none';
-        setTimeout(() => {
-            this.refreshPolling();
-        }, 100);
-    }
-    /**
-     * Check if wagers should be hidden based on user settings
-     */
-    shouldHideWagers() {
-        return this.hideWagers.value;
-    }
-    /**
-     * Update hideWagers Observable from current settings
-     */
-    updateHideWagersFromSettings() {
-        this.hideWagers.value = this.userSettingsManager.shouldHideWagers();
-        this.refreshBetItemsWithNewSettings();
-    }
-    refreshBetItemsWithNewSettings() {
-        this.betsItems.value = this.betsItems.value.map((item) => {
-            if (item.type === 'sixPack') {
-                return {
-                    ...item,
-                    hideWagers: this.hideWagers.value,
-                };
-            }
-            if (item.type === 'userBets') {
-                return {
-                    ...item,
-                    hideWagers: this.hideWagers.value,
-                };
-            }
-            if (item.type === 'hotProps') {
-                return {
-                    ...item,
-                    hideWagers: this.hideWagers.value,
-                };
-            }
-            return item;
-        });
-    }
-}
-export default BetsViewModel;