@maestro_io/maestro-web-sdk 2.1.1 → 2.1.3

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

@@ -0,0 +1,767 @@
+import { Observable } from '../../../helpers/Observable';
+import BetsService from '../../../services/BetsService';
+// Import ViewModel with correct path
+import { ViewModel } from '../../../view-models/ViewModel';
+import { MOCK_BETS_API_RESPONSE } from '../mocks';
+import SDK from '@/index';
+// 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)
+        });
+        // 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, "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, "initialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.eventId = eventId;
+        this.delegate = delegate;
+        this.betsService = new BetsService(delegate);
+        this.pollingInterval = options.pollingInterval || DEFAULT_POLLING_INTERVAL;
+        this.useMockData = options.useMockData || false;
+        this.betsService = new BetsService(delegate);
+    }
+    /**
+     * Initialize the ViewModel and start data fetching
+     */
+    async init() {
+        await this.fetchNewData();
+        this.refreshPolling();
+        this.initialized = true;
+    }
+    /**
+     * Clean up resources when the ViewModel is no longer needed
+     */
+    cleanup() {
+        this.stopPolling();
+        this.initialized = false;
+    }
+    /**
+     * 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();
+    }
+    /**
+     * Poll with the correct method based on authentication status
+     */
+    async pollWithInterval() {
+        try {
+            // Check if the user is authenticated
+            const isAuthenticated = await this.delegate.userIsAuthenticated();
+            if (isAuthenticated) {
+                // Get user credentials
+                const swid = (await this.delegate.getUserSWID()) || '';
+                const jwt = (await this.delegate.getUserToken()) || '';
+                // Start personalized polling
+                this.pollingTask = this.betsService.pollPersonalizedBets(this.eventId, swid, jwt, this.pollingInterval, this.processPolledData.bind(this), this.handlePollingError.bind(this));
+            }
+            else {
+                // Start non-personalized polling
+                this.pollingTask = this.betsService.pollNonPersonalizedBets(this.eventId, this.pollingInterval, this.processPolledData.bind(this), this.handlePollingError.bind(this));
+            }
+        }
+        catch (error) {
+            console.error('Error setting up polling:', error);
+            // If there's an error, fall back to non-personalized polling
+            this.pollingTask = this.betsService.pollNonPersonalizedBets(this.eventId, this.pollingInterval, this.processPolledData.bind(this), this.handlePollingError.bind(this));
+        }
+    }
+    /**
+     * Process data received from polling
+     */
+    processPolledData(data) {
+        // Calculate hash for the response to check if it's different from the last one
+        const responseHash = JSON.stringify(data).hashCode();
+        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('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('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?.length) {
+            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.promos) {
+            return null;
+        }
+        return {
+            type: 'promo',
+            data: {
+                title: data.promos.title || '',
+                description: data.promos.description || '',
+                logo: data.promos.logo || '',
+                qrCode: data.promos.qrCode || '',
+            },
+            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;
+        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 isHomeFavoured = homeTeam.favored ?? true;
+        const isInProgress = gameState === 'in';
+        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 = '';
+        for (const oddsItem of odds) {
+            switch (oddsItem.type) {
+                case 'pointSpread':
+                    if (isInProgress) {
+                        // For in-progress games, use "close" for CO and "live" for current
+                        if (isHomeFavoured) {
+                            if (oddsItem.state === 'close') {
+                                for (const value of oddsItem.values) {
+                                    if (value.type === 'home') {
+                                        homeTeamStartGameFirstLine = value.line ?? '';
+                                        homeTeamStartGameSecondLine = value.odds ?? '';
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            if (oddsItem.state === 'close') {
+                                for (const value of oddsItem.values) {
+                                    if (value.type === 'away') {
+                                        awayTeamStartGameFirstLine = value.line ?? '';
+                                        awayTeamStartGameSecondLine = value.odds ?? '';
+                                    }
+                                }
+                            }
+                        }
+                        if (oddsItem.state === 'live') {
+                            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 ?? '';
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        // For pre/post games, use "open" for CO and "close" for current
+                        if (isHomeFavoured) {
+                            if (oddsItem.state === 'open') {
+                                for (const value of oddsItem.values) {
+                                    if (value.type === 'home') {
+                                        homeTeamStartGameFirstLine = value.line ?? '';
+                                        homeTeamStartGameSecondLine = value.odds ?? '';
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            if (oddsItem.state === 'open') {
+                                for (const value of oddsItem.values) {
+                                    if (value.type === 'away') {
+                                        awayTeamStartGameFirstLine = value.line ?? '';
+                                        awayTeamStartGameSecondLine = value.odds ?? '';
+                                    }
+                                }
+                            }
+                        }
+                        if (oddsItem.state === 'close') {
+                            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 ?? '';
+                                }
+                            }
+                        }
+                    }
+                    break;
+                case 'total':
+                    if (isInProgress) {
+                        if (isHomeFavoured) {
+                            if (oddsItem.state === 'close') {
+                                for (const value of oddsItem.values) {
+                                    if (value.type === 'over') {
+                                        awayTeamStartGameFirstLine = value.line ?? '';
+                                        awayTeamStartGameSecondLine = value.odds ?? '';
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            if (oddsItem.state === 'close') {
+                                for (const value of oddsItem.values) {
+                                    if (value.type === 'under') {
+                                        homeTeamStartGameFirstLine = value.line ?? '';
+                                        homeTeamStartGameSecondLine = value.odds ?? '';
+                                    }
+                                }
+                            }
+                        }
+                        if (oddsItem.state === 'live') {
+                            for (const value of oddsItem.values) {
+                                if (value.type === 'under') {
+                                    homeTotalFirstLine = value.line ?? '';
+                                    homeTotalSecondLine = value.odds ?? '';
+                                }
+                                if (value.type === 'over') {
+                                    awayTotalFirstLine = value.line ?? '';
+                                    awayTotalSecondLine = value.odds ?? '';
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        if (isHomeFavoured) {
+                            if (oddsItem.state === 'open') {
+                                for (const value of oddsItem.values) {
+                                    if (value.type === 'over') {
+                                        awayTeamStartGameFirstLine = value.line ?? '';
+                                        awayTeamStartGameSecondLine = value.odds ?? '';
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            if (oddsItem.state === 'open') {
+                                for (const value of oddsItem.values) {
+                                    if (value.type === 'under') {
+                                        homeTeamStartGameFirstLine = value.line ?? '';
+                                        homeTeamStartGameSecondLine = value.odds ?? '';
+                                    }
+                                }
+                            }
+                        }
+                        if (oddsItem.state === 'close') {
+                            for (const value of oddsItem.values) {
+                                if (value.type === 'under') {
+                                    homeTotalFirstLine = value.line ?? '';
+                                    homeTotalSecondLine = value.odds ?? '';
+                                }
+                                if (value.type === 'over') {
+                                    awayTotalFirstLine = value.line ?? '';
+                                    awayTotalSecondLine = value.odds ?? '';
+                                }
+                            }
+                        }
+                    }
+                    break;
+                case 'moneyline':
+                    if (isInProgress) {
+                        if (oddsItem.state === 'live') {
+                            for (const value of oddsItem.values) {
+                                if (value.type === 'home') {
+                                    homeMoneylineFirstLine = value.odds ?? '';
+                                }
+                                if (value.type === 'away') {
+                                    awayMoneylineFirstLine = value.odds ?? '';
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        if (oddsItem.state === 'close') {
+                            for (const value of oddsItem.values) {
+                                if (value.type === 'home') {
+                                    homeMoneylineFirstLine = value.odds ?? '';
+                                }
+                                if (value.type === 'away') {
+                                    awayMoneylineFirstLine = value.odds ?? '';
+                                }
+                            }
+                        }
+                    }
+                    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 sixPack = {
+            awayTeamOdds,
+            homeTeamOdds,
+            gameState,
+            sport: sport,
+        };
+        return {
+            id: `sixpack-${eventId}`,
+            type: 'sixPack',
+            data: sixPack,
+            teamInfo: {
+                home: homeTeam,
+                away: awayTeam,
+            },
+        };
+    }
+    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',
+        };
+    }
+    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;
+        }
+        return hotProps
+            .filter((hotProp) => hotProp.selections && hotProp.selections.length > 0)
+            .map((hotProp) => {
+            const data = {
+                items: hotProp.selections.map((item) => ({
+                    id: item.id,
+                    selectionText: hotProp.text,
+                    marketText: item.text,
+                    odds: item.odds.current || '',
+                    icon: item.icon,
+                    iconDark: item.iconDark,
+                    status: item.status,
+                    type: item.type,
+                })),
+            };
+            return {
+                data,
+                type: 'hotProps',
+                id: `hotProps-${hotProp.id}`,
+            };
+        });
+    }
+    /**
+     * 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;
+        }
+    }
+    /**
+     * 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;
+            }
+            // Check if the user is authenticated
+            const isAuthenticated = await this.delegate.userIsAuthenticated();
+            if (isAuthenticated) {
+                await this.fetchPersonalizedData();
+            }
+            else {
+                await this.fetchNonPersonalizedData();
+            }
+            this.isDataLoading.value = false;
+        }
+        catch (error) {
+            console.error('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 = await this.delegate.getUserSWID();
+            const jwt = await this.delegate.getUserToken();
+            if (!swid || !jwt) {
+                throw new Error('Missing authentication data (SWID or JWT)');
+            }
+            const response = await this.betsService.getPersonalizedBets(this.eventId, swid, jwt);
+            // Process the response
+            this.processPolledData(response);
+        }
+        catch (error) {
+            console.error('Error fetching personalized bets:', error);
+            // Fall back to non-personalized data
+            await this.fetchNonPersonalizedData();
+        }
+    }
+    /**
+     * Fetch non-personalized bet data
+     */
+    async fetchNonPersonalizedData() {
+        const response = await this.betsService.getNonPersonalizedBets(this.eventId);
+        // Process the response
+        this.processPolledData(response);
+    }
+    /**
+     * 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';
+        SDK.getMaestroEventViewModel().navigation.setFocus('PANEL_NAV_BUTTON_1');
+        setTimeout(async () => {
+            await this.fetchNewData();
+        }, 100);
+    }
+}
+if (!String.prototype.hashCode) {
+    String.prototype.hashCode = function () {
+        let hash = 0;
+        for (let i = 0; i < this.length; i++) {
+            const char = this.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash; // Convert to 32bit integer
+        }
+        return hash;
+    };
+}
+export default BetsViewModel;