@maestro_io/maestro-web-sdk 5.2.0 → 5.2.2

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

@@ -1,132 +0,0 @@
-import SDK from '@/index';
-import { captureException } from '@/sentry';
-import { stringHashCode } from '@/helpers/strings';
-const DEFAULT_FANTASY_POLLING_INTERVAL = 60000;
-export default class FantasyPolling {
-    constructor(service) {
-        Object.defineProperty(this, "polling", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {
-                interval: DEFAULT_FANTASY_POLLING_INTERVAL,
-                task: null,
-                lastResponseHash: null,
-            }
-        });
-        Object.defineProperty(this, "fantasyService", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.fantasyService = service;
-    }
-    /**
-     * Refresh polling for fantasy data
-     */
-    async refresh(params, callback) {
-        // First stop any existing polling
-        this.stop();
-        // Start the poll loop
-        await this.start(params, callback);
-    }
-    /**
-     * Stop polling for fantasy data
-     */
-    stop() {
-        if (this.polling.task) {
-            this.polling.task.stop();
-            this.polling.task = null;
-        }
-    }
-    removeLastResponseHash() {
-        this.polling.lastResponseHash = null;
-    }
-    async start(params, callback) {
-        try {
-            this.polling.task = this.fantasyService.pollFantasy(params, this.polling.interval, (response) => {
-                this.updateInterval(params, response.headers, callback);
-                this.processPolledData(response.data, callback);
-            }, (error) => this.handlePollingError(error, params.swid));
-        }
-        catch (error) {
-            captureException(error, {
-                context: 'FantasyViewModel.pollFantasy',
-            });
-            console.error('[FANTASY] Error setting up fantasy polling:', error);
-        }
-    }
-    /**
-     * @description Update polling interval checking either response header or panel config.
-     * Refresh polling if necessary.
-     */
-    updateInterval(params, headers, callback) {
-        const headerInterval = this.getResponseHeaderPollingIntervalValue(headers);
-        const panelConfigInterval = this.getPanelConfigInterval();
-        const newInterval = headerInterval || panelConfigInterval; // order matters here
-        // Only update if we have a valid new interval and it's different from current
-        if (newInterval && newInterval !== this.polling.interval) {
-            console.log(`[Fantasy] Updating fantasy polling interval from ${this.polling.interval}ms to ${newInterval}ms`);
-            this.polling.interval = newInterval;
-            // Restart polling with the new interval
-            this.refresh(params, callback);
-        }
-    }
-    getResponseHeaderPollingIntervalValue(headers) {
-        const newInterval = headers['polling-interval'];
-        if (!newInterval) {
-            return null;
-        }
-        const parsedInterval = parseInt(newInterval, 10);
-        if (isNaN(parsedInterval) || parsedInterval <= 0) {
-            console.warn(`[Fantasy] Invalid polling interval header received: ${newInterval}.`);
-            return null;
-        }
-        return parsedInterval * 1000; // Convert seconds to milliseconds
-    }
-    getPanelConfigInterval() {
-        const config = SDK.getPageConfig();
-        const panel = config?.panels?.find((p) => p.panel_type === 'espnFantasy');
-        if (!panel) {
-            return null;
-        }
-        const fantasyPollingInterval = panel.renderer?.block_data?.fan_polling_interval;
-        if (!fantasyPollingInterval) {
-            return null;
-        }
-        const parsedInterval = parseInt(fantasyPollingInterval, 10);
-        if (isNaN(parsedInterval) || parsedInterval <= 0) {
-            console.warn(`[FANTASY] Invalid fantasy polling interval from panel config: ${fantasyPollingInterval}.`);
-            return null;
-        }
-        return parsedInterval * 1000; // Convert seconds to milliseconds
-    }
-    /**
-     * Process data received from polling
-     */
-    processPolledData(data, callback) {
-        // Calculate hash for the response to check if it's different from the last one
-        const responseHash = stringHashCode(JSON.stringify(data));
-        // Check if this is the same as the last successful response
-        if (this.polling.lastResponseHash === responseHash) {
-            console.log('[Fantasy] Fantasy Response hash is the same as last successful response - skipping update');
-            return;
-        }
-        this.polling.lastResponseHash = responseHash;
-        callback(data);
-    }
-    /**
-     * Handle errors that occur during fantasy polling
-     */
-    handlePollingError(error, swid) {
-        console.error('[FANTASY] Fantasy polling error:', error);
-        captureException(error, {
-            context: 'FantasyViewModel.pollFantasy',
-            extra: {
-                swid: swid ? `${swid.substring(0, 8)}...` : 'unknown',
-                pollingInterval: this.polling.interval,
-            },
-        });
-    }
-}

package/dist/src/modules/espn/fantasy/view-model/FantasyViewModel.LeagueManagerPolling.d.ts

@@ -1,32 +0,0 @@
-import FantasyService, { LeagueManagerPollingParams } from '@/modules/espn/fantasy/services/FantasyService';
-import { ILeagueManagerResponse, ILeagueManagerRotoResponse } from '../types';
-export default class LeagueManagerPolling {
-    private polling;
-    private fantasyService;
-    constructor(service: FantasyService);
-    /**
-     * Refresh polling for league manager data
-     */
-    refresh(key: string, params: LeagueManagerPollingParams, callback: (data: ILeagueManagerResponse | ILeagueManagerRotoResponse) => void): void;
-    /**
-     * Stop polling for fantasy data
-     */
-    stop(key: string): void;
-    private start;
-    /**
-     * Process data received from polling
-     */
-    private processPolledData;
-    /**
-     * @description Update polling interval checking either response header or panel config.
-     * Refresh polling if necessary.
-     */
-    private updateInterval;
-    private getResponseHeaderPollingIntervalValue;
-    private getPanelConfigInterval;
-    stopAll(): void;
-    /**
-     * Handle errors that occur during league manager polling
-     */
-    private handlePollingError;
-}

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

@@ -1,141 +0,0 @@
-import SDK from '@/index';
-import { captureException } from '@/sentry';
-import { stringHashCode } from '@/helpers/strings';
-const DEFAULT_LEAGUE_MANAGER_POLLING_INTERVAL = 60000;
-export default class LeagueManagerPolling {
-    constructor(service) {
-        Object.defineProperty(this, "polling", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {}
-        });
-        Object.defineProperty(this, "fantasyService", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.fantasyService = service;
-    }
-    /**
-     * Refresh polling for league manager data
-     */
-    refresh(key, params, callback) {
-        // First stop any existing polling
-        this.stop(key);
-        // Initialize polling state if it doesn't exist
-        if (!this.polling[key]) {
-            this.polling[key] = {
-                interval: DEFAULT_LEAGUE_MANAGER_POLLING_INTERVAL,
-                lastResponseHash: null,
-                task: null,
-            };
-        }
-        // Start the poll loop
-        this.start(key, params, callback);
-    }
-    /**
-     * Stop polling for fantasy data
-     */
-    stop(key) {
-        if (this.polling[key]?.task) {
-            this.polling[key]?.task?.stop?.();
-            this.polling[key].task = null;
-        }
-    }
-    start(key, params, callback) {
-        try {
-            this.polling[key].task = this.fantasyService.pollLeagueManager(params, this.polling[key].interval, (response) => {
-                this.updateInterval(key, params, callback, response.headers);
-                this.processPolledData(key, response.data, callback);
-            }, (error) => this.handlePollingError(error, key, params));
-        }
-        catch (error) {
-            captureException(error, {
-                context: 'FantasyViewModel.pollLeagueManager',
-            });
-            console.error('[FANTASY] Error setting up league manager polling:', error);
-        }
-    }
-    /**
-     * Process data received from polling
-     */
-    processPolledData(key, data, callback) {
-        // Calculate hash for the response to check if it's different from the last one
-        const responseHash = stringHashCode(JSON.stringify(data));
-        // Check if this is the same as the last successful response
-        if (this.polling[key].lastResponseHash === responseHash) {
-            console.log('[Fantasy] League manager Response hash is the same as last successful response - skipping update');
-            return;
-        }
-        this.polling[key].lastResponseHash = responseHash;
-        callback(data);
-    }
-    /**
-     * @description Update polling interval checking either response header or panel config.
-     * Refresh polling if necessary.
-     */
-    updateInterval(key, params, callback, headers) {
-        const headerInterval = this.getResponseHeaderPollingIntervalValue(headers);
-        const panelConfigInterval = this.getPanelConfigInterval();
-        const newInterval = headerInterval || panelConfigInterval; // order matters here
-        // Only update if we have a valid new interval and it's different from current
-        if (newInterval && newInterval !== this.polling[key]?.interval) {
-            console.log(`[Fantasy] Updating league manager polling interval from ${this.polling[key]?.interval}ms to ${newInterval}ms`);
-            this.polling[key].interval = newInterval;
-            // Restart polling with the new interval
-            this.refresh(key, params, callback);
-        }
-    }
-    getResponseHeaderPollingIntervalValue(headers) {
-        const newInterval = headers['polling-interval'];
-        if (!newInterval) {
-            return null;
-        }
-        const parsedInterval = parseInt(newInterval, 10);
-        if (isNaN(parsedInterval) || parsedInterval <= 0) {
-            console.warn(`[Fantasy] Invalid polling interval header received: ${newInterval}.`);
-            return null;
-        }
-        return parsedInterval * 1000; // Convert seconds to milliseconds
-    }
-    getPanelConfigInterval() {
-        const config = SDK.getPageConfig();
-        const panel = config?.panels?.find((p) => p.panel_type === 'espnFantasy');
-        if (!panel) {
-            return null;
-        }
-        const fantasyPollingInterval = panel.renderer?.block_data?.lm_polling_interval;
-        if (!fantasyPollingInterval) {
-            return null;
-        }
-        const parsedInterval = parseInt(fantasyPollingInterval, 10);
-        if (isNaN(parsedInterval) || parsedInterval <= 0) {
-            console.warn(`[FANTASY] Invalid league manager polling interval from panel config: ${fantasyPollingInterval}.`);
-            return null;
-        }
-        return parsedInterval * 1000; // Convert seconds to milliseconds
-    }
-    stopAll() {
-        Object.keys(this.polling).forEach((key) => {
-            this.stop(key);
-        });
-        this.polling = {};
-    }
-    /**
-     * Handle errors that occur during league manager polling
-     */
-    handlePollingError(error, key, params) {
-        console.error('[FANTASY] League manager polling error:', error);
-        captureException(error, {
-            context: 'FantasyViewModel.pollLeagueManager',
-            extra: {
-                key,
-                leagueId: params?.leagueId,
-                game: params?.game,
-                pollingInterval: this.polling[key]?.interval,
-            },
-        });
-    }
-}

package/dist/src/modules/espn/fantasy/view-model/FantasyViewModel.TournamentPolling.d.ts

@@ -1,32 +0,0 @@
-import FantasyService, { TournamentChallengePollingParams } from '@/modules/espn/fantasy/services/FantasyService';
-import { TournamentChallenge } from '../types';
-export default class TournamentPolling {
-    private polling;
-    private fantasyService;
-    constructor(service: FantasyService);
-    /**
-     * Refresh polling for tournament challenge data
-     */
-    refresh(key: string, params: TournamentChallengePollingParams, callback: (data: TournamentChallenge) => void): void;
-    /**
-     * Stop polling for tournament challenge data
-     */
-    stop(key: string): void;
-    private start;
-    /**
-     * @description Update polling interval checking either response header or panel config.
-     * Refresh polling if necessary.
-     */
-    private updateInterval;
-    private getResponseHeaderPollingIntervalValue;
-    private getPanelConfigInterval;
-    /**
-     * Process data received from polling
-     */
-    private processPolledData;
-    stopAll(): void;
-    /**
-     * Handle errors that occur during tournament polling
-     */
-    private handlePollingError;
-}

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

@@ -1,140 +0,0 @@
-import SDK from '@/index';
-import { captureException } from '@/sentry';
-import { stringHashCode } from '@/helpers/strings';
-const DEFAULT_TOURNAMENT_POLLING_INTERVAL = 60000;
-export default class TournamentPolling {
-    constructor(service) {
-        Object.defineProperty(this, "polling", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {}
-        });
-        Object.defineProperty(this, "fantasyService", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.fantasyService = service;
-    }
-    /**
-     * Refresh polling for tournament challenge data
-     */
-    refresh(key, params, callback) {
-        // First stop any existing polling
-        this.stop(key);
-        // Initialize polling state if it doesn't exist
-        if (!this.polling[key]) {
-            this.polling[key] = {
-                interval: DEFAULT_TOURNAMENT_POLLING_INTERVAL,
-                lastResponseHash: null,
-                task: null,
-            };
-        }
-        // Start the poll loop
-        this.start(key, params, callback);
-    }
-    /**
-     * Stop polling for tournament challenge data
-     */
-    stop(key) {
-        if (this.polling[key]?.task) {
-            this.polling[key]?.task?.stop?.();
-            this.polling[key].task = null;
-        }
-    }
-    start(key, params, callback) {
-        try {
-            this.polling[key].task = this.fantasyService.pollTournamentChallenge(params, this.polling[key].interval, (response) => {
-                this.updateInterval(key, params, callback, response.headers);
-                this.processPolledData(key, response.data, callback);
-            }, (error) => this.handlePollingError(error, key, params));
-        }
-        catch (error) {
-            captureException(error, {
-                context: 'FantasyViewModel.pollTournamentChallenge',
-            });
-            console.error('[TOURNAMENT] Error setting up tournament polling:', error);
-        }
-    }
-    /**
-     * @description Update polling interval checking either response header or panel config.
-     * Refresh polling if necessary.
-     */
-    updateInterval(key, params, callback, headers) {
-        const headerInterval = this.getResponseHeaderPollingIntervalValue(headers);
-        const panelConfigInterval = this.getPanelConfigInterval();
-        const newInterval = headerInterval || panelConfigInterval; // order matters here
-        // Only update if we have a valid new interval and it's different from current
-        if (newInterval && newInterval !== this.polling[key]?.interval) {
-            console.log(`[TOURNAMENT] Updating tournament polling interval from ${this.polling[key]?.interval}ms to ${newInterval}ms`);
-            this.polling[key].interval = newInterval;
-            // Restart polling with the new interval
-            this.refresh(key, params, callback);
-        }
-    }
-    getResponseHeaderPollingIntervalValue(headers) {
-        const newInterval = headers['polling-interval'];
-        if (!newInterval) {
-            return null;
-        }
-        const parsedInterval = parseInt(newInterval, 10);
-        if (isNaN(parsedInterval) || parsedInterval <= 0) {
-            console.warn(`[TOURNAMENT] Invalid polling interval header received: ${newInterval}.`);
-            return null;
-        }
-        return parsedInterval * 1000; // Convert seconds to milliseconds
-    }
-    getPanelConfigInterval() {
-        const config = SDK.getPageConfig();
-        const panel = config?.panels?.find((p) => p.panel_type === 'espnFantasy');
-        if (!panel) {
-            return null;
-        }
-        const tournamentPollingInterval = panel.renderer?.block_data?.gambit_polling_interval;
-        if (!tournamentPollingInterval) {
-            return null;
-        }
-        const parsedInterval = parseInt(tournamentPollingInterval, 10);
-        if (isNaN(parsedInterval) || parsedInterval <= 0) {
-            console.warn(`[TOURNAMENT] Invalid tournament polling interval from panel config: ${tournamentPollingInterval}.`);
-            return null;
-        }
-        return parsedInterval * 1000; // Convert seconds to milliseconds
-    }
-    /**
-     * Process data received from polling
-     */
-    processPolledData(key, data, callback) {
-        // Calculate hash for the response to check if it's different from the last one
-        const responseHash = stringHashCode(JSON.stringify(data));
-        // Check if this is the same as the last successful response
-        if (this.polling[key].lastResponseHash === responseHash) {
-            console.log('[TOURNAMENT] Tournament Response hash is the same as last successful response - skipping update');
-            return;
-        }
-        this.polling[key].lastResponseHash = responseHash;
-        callback(data);
-    }
-    stopAll() {
-        Object.keys(this.polling).forEach((key) => {
-            this.stop(key);
-        });
-        this.polling = {};
-    }
-    /**
-     * Handle errors that occur during tournament polling
-     */
-    handlePollingError(error, key, params) {
-        console.error('[TOURNAMENT] Tournament polling error:', error);
-        captureException(error, {
-            context: 'FantasyViewModel.pollTournamentChallenge',
-            extra: {
-                key,
-                challengeId: params?.challengeId,
-                pollingInterval: this.polling[key]?.interval,
-            },
-        });
-    }
-}

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

@@ -1,167 +0,0 @@
-import { Observable } from '@/helpers/Observable';
-import AnalyticsService from '@/services/AnalyticsService/AnalyticsService';
-import IMaestroEventDelegate from '@/interfaces/IMaestroEventDelegate';
-import { TournamentBracketCardItem, FantasyHeaderItem, TournamentOverflowQRItem } from '../types';
-type NotLoggedInFantasyItem = {
-    id: string;
-    type: 'notLoggedIn';
-};
-export type PromoFantasyItem = {
-    id: string;
-    type: 'promo';
-    background: string;
-    logo: string;
-    qrCode: string;
-    title: string;
-    description: string;
-};
-export type InactiveLeague = {
-    id: string;
-    type: 'inactiveLeague';
-    leagueName: string;
-    draftDate?: number;
-    leagueLogo: string;
-    leagueColor: string;
-};
-type MatchupSingleTeam = {
-    points: number;
-    logo: string;
-    scoringType: string;
-};
-export type MatchupSingleRoster = {
-    athleteHeadshot: string;
-    athleteAbbrevName: string;
-    athletesSlot: string;
-    teamTriCode: string;
-    proGameStatusLines: string[];
-};
-export type MatchupActiveAthlete = {
-    abbrevName: string;
-    points: string;
-};
-export type MatchupSingleItem = {
-    id: string;
-    type: 'matchup-single';
-    league: {
-        title: string;
-        subtitle: string | undefined;
-        color: string;
-        logo: string;
-    };
-    team: MatchupSingleTeam;
-    roster: MatchupSingleRoster[];
-    activeAthletes: MatchupActiveAthlete[];
-    topPlayers: TopPlayer[];
-};
-export type TopPlayer = {
-    abbrevName: string;
-    headshot: string;
-    position: string;
-    teamTriCode: string;
-    points: number;
-    rosteredBy: string;
-};
-type MatchupPairTeam = {
-    name: string | undefined;
-    record: string | undefined;
-    points: string | undefined;
-    projectedPoints: string | undefined;
-    logo: string | undefined;
-    winProbability: number | undefined;
-};
-type MatchupPairRosterData = {
-    headshot: string;
-    abbrevName: string;
-    slot: string;
-    triCode: string;
-    points?: number;
-    projectedPoints?: number;
-    stats: string[];
-};
-export type MatchupPairRoster = {
-    away: MatchupPairRosterData;
-    home: MatchupPairRosterData;
-};
-export type MatchupPairItem = {
-    id: string;
-    type: 'matchup-pair';
-    league: {
-        title: string | undefined;
-        subtitle: string | undefined;
-        color: string;
-        logo: string;
-    };
-    awayTeam: MatchupPairTeam;
-    homeTeam: MatchupPairTeam;
-    roster: MatchupPairRoster[];
-    activeAthletes: MatchupActiveAthlete[];
-    topPlayers: TopPlayer[];
-};
-export type FantasyItem = NotLoggedInFantasyItem | PromoFantasyItem | MatchupPairItem | MatchupSingleItem | InactiveLeague | TournamentBracketCardItem | FantasyHeaderItem | FantasyGroupItem | TournamentOverflowQRItem;
-export type FantasyGroupItem = {
-    type: 'fantasy-group';
-    id: string;
-    header: FantasyHeaderItem;
-    items: FantasyItem[];
-};
-declare const FANTASY_ERROR_STATE: {
-    readonly NONE: "none";
-    readonly TAB_LOAD_FAILURE: "tabLoadFailure";
-};
-export type FantasyErrorState = typeof FANTASY_ERROR_STATE[keyof typeof FANTASY_ERROR_STATE];
-export declare class FantasyViewModel {
-    fantasyItems: Observable<FantasyItem[]>;
-    isDataLoading: Observable<boolean>;
-    hasEverSuccessfullyLoaded: Observable<boolean>;
-    isLoadingTc: Observable<boolean>;
-    private eventId;
-    private delegate;
-    private analyticsService;
-    private fantasyService;
-    private fantasyPolling;
-    private leagueManagerPolling;
-    private tournamentPolling;
-    errorState: Observable<FantasyErrorState>;
-    private leagueSortOrder;
-    private itemToLeagueKey;
-    private useMockData;
-    private _promoData;
-    private _fantasyLeagues;
-    private _tournamentChallenges;
-    private _promoItem;
-    private _tcProcessingCount;
-    constructor(eventId: string, delegate: IMaestroEventDelegate, analyticsService: AnalyticsService, options?: {
-        useMockData?: boolean;
-    });
-    /**
-     * Initialize the ViewModel and start data fetching
-     */
-    init(): Promise<void>;
-    private fetchData;
-    onEngage(type: FantasyItem['type']): void;
-    onAskLogin(): void;
-    /**
-     * Clean up resources when the ViewModel is no longer needed
-     */
-    cleanup(): void;
-    /**
-     * Track panel view event
-     */
-    private trackPanelView;
-    private processFantasy;
-    private parseRoto;
-    append(item: FantasyItem | null, leagueKey?: string): void;
-    private rebuildFantasyItems;
-    private parseHeadToHead;
-    private parseTopPlayers;
-    private parseInactiveLeague;
-    private getPromoData;
-    private parseTournamentChallenge;
-    /**
-     * Fetch mock data for testing
-     */
-    private fetchMockData;
-    clearTabLoadFailure(): void;
-    setDataToPanel(data: Record<string, any>): void;
-}
-export default FantasyViewModel;