@maestro_io/maestro-web-sdk 4.0.0 → 4.0.1

package/dist/src/modules/fantasy/view/index.d.ts

@@ -0,0 +1,2 @@
+import FantasyView from './FantasyView';
+export default FantasyView;

package/dist/src/modules/fantasy/view/index.js

@@ -0,0 +1,2 @@
+import FantasyView from './FantasyView';
+export default FantasyView;

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

@@ -0,0 +1,32 @@
+import FantasyService, { FantasyPollingParams } from '@/services/FantasyService';
+import { IFantasyResponse } from '../types';
+export default class FantasyPolling {
+    private polling;
+    private fantasyService;
+    constructor(service: FantasyService);
+    /**
+     * Refresh polling for fantasy data
+     */
+    refresh(params: FantasyPollingParams, callback: (data: IFantasyResponse) => void): Promise<void>;
+    /**
+     * Stop polling for fantasy data
+     */
+    stop(): void;
+    removeLastResponseHash(): 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;
+    /**
+     * Handle errors that occur during fantasy polling
+     */
+    private handlePollingError;
+}

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

@@ -0,0 +1,132 @@
+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/fantasy/view-model/FantasyViewModel.LeagueManagerPolling.d.ts

@@ -0,0 +1,32 @@
+import FantasyService, { LeagueManagerPollingParams } from '@/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/fantasy/view-model/FantasyViewModel.LeagueManagerPolling.js

@@ -0,0 +1,141 @@
+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/fantasy/view-model/FantasyViewModel.d.ts

@@ -0,0 +1,148 @@
+import { Observable } from '@/helpers/Observable';
+import IMaestroEventDelegate from '@/interfaces/IMaestroEventDelegate';
+type NotLoggedInFantasyItem = {
+    id: string;
+    type: 'notLoggedIn';
+};
+export type PromoFantasyItem = {
+    id: string;
+    type: 'promo';
+    background: string;
+    logo: string;
+    title: string;
+    qrCode: 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 | MatchupPairItem | MatchupSingleItem | InactiveLeague | PromoFantasyItem;
+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>;
+    private eventId;
+    private delegate;
+    private analyticsService;
+    private fantasyService;
+    private fantasyPolling;
+    private leagueManagerPolling;
+    errorState: Observable<FantasyErrorState>;
+    private leagueSortOrder;
+    private itemToLeagueKey;
+    private useMockData;
+    constructor(eventId: string, delegate: IMaestroEventDelegate, 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 parseHeadToHead;
+    private parseTopPlayers;
+    private parseInactiveLeague;
+    /**
+     * Fetch mock data for testing
+     */
+    private fetchMockData;
+    clearTabLoadFailure(): void;
+}
+export default FantasyViewModel;