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

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

@@ -0,0 +1,974 @@
+import { Observable } from '../../../helpers/Observable';
+import BetsService from '../../../services/BetsService';
+import { UserSettingsManager } from '../../../services/UserSettingsManager';
+import AnalyticsService from '../../../services/AnalyticsService/AnalyticsService';
+// 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, 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 = new 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;
+    }
+    simulateUseCase(useCase, _) {
+        switch (useCase) {
+            case 'betsTabLoadFailure':
+                this.errorState.value = 'tabLoadFailure';
+                break;
+            case 'betsMockData':
+                this.stopPolling();
+                this.useMockData = true;
+                this.lastPersonalizedResponseHash = null;
+                this.lastNonPersonalizedResponseHash = null;
+                this.errorState.value = 'none';
+                this.fetchNewData();
+                break;
+            case 'betsLiveData':
+                this.useMockData = false;
+                this.lastPersonalizedResponseHash = null;
+                this.lastNonPersonalizedResponseHash = null;
+                this.hasEverSuccessfullyLoaded.value = false;
+                this.errorState.value = 'none';
+                this.fetchNewData();
+                this.refreshPolling();
+                break;
+            default:
+                throw new Error(`Unsupported use case: ${useCase}`);
+        }
+    }
+    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;