@maestro_io/maestro-web-sdk 4.0.2 → 5.1.0

package/dist/src/modules/espn/fantasy/view/TournamentBracketCard/TournamentBracketCard.d.ts

@@ -0,0 +1,101 @@
+/// <reference types="prop-types" />
+import { WithFocusableProps } from '@/external/spatial-navigation';
+import React from 'react';
+import './TournamentBracketCard.styles.css';
+import { TournamentBracketCardItem } from '../../types';
+type Props = {
+    item: TournamentBracketCardItem;
+};
+export declare const TournamentBracketCard: (props: Props & WithFocusableProps) => JSX.Element;
+declare const _default: {
+    new (props: (Props & WithFocusableProps) | Readonly<Props & WithFocusableProps>): {
+        state: import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState;
+        navigation: import("../../../../../external/spatial-navigation/spatialNavigation").default;
+        getChildContext(): {
+            parentFocusKey: string;
+        };
+        setFocus: (focusKey: string) => void;
+        navigateByDirection: (direction: import("../../../../../external/spatial-navigation/utils").Direction, details?: import("../../../../../external/spatial-navigation/utils").Details) => void;
+        stealFocus: () => void;
+        onUpdateFocus: (focused: boolean) => void;
+        onUpdateHasFocusedChild: (hasFocusedChild: boolean) => void;
+        onEnterPressHandler: (details: import("../../../../../external/spatial-navigation/utils").Details) => void;
+        onClickPressHandler: (details: import("../../../../../external/spatial-navigation/utils").Details) => void;
+        onEnterReleaseHandler: () => void;
+        onBackPressHandler: (details: import("../../../../../external/spatial-navigation/utils").Details) => void;
+        onArrowPressHandler: (direction: import("../../../../../external/spatial-navigation/utils").Direction, details: import("../../../../../external/spatial-navigation/utils").Details) => boolean | void;
+        onBecameFocusedHandler: (layout: import("../../../../../external/spatial-navigation/utils").Layout, details: import("../../../../../external/spatial-navigation/utils").Details) => void;
+        onBecameBlurredHandler: (layout: import("../../../../../external/spatial-navigation/utils").Layout, details: import("../../../../../external/spatial-navigation/utils").Details) => void;
+        componentDidMount(): void;
+        componentDidUpdate(): void;
+        componentWillUnmount(): void;
+        render(): React.ReactElement<Props & WithFocusableProps, string | React.JSXElementConstructor<any>>;
+        context: any;
+        setState<K extends keyof import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>(state: import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState | ((prevState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>, props: Readonly<Props & WithFocusableProps>) => import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState | Pick<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState, K> | null) | Pick<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Props & WithFocusableProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<Props & WithFocusableProps>, nextState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Props & WithFocusableProps>, prevState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Props & WithFocusableProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props & WithFocusableProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Props & WithFocusableProps>, nextState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Props & WithFocusableProps>, nextState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+    };
+    new (props: Props & WithFocusableProps, context: any): {
+        state: import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState;
+        navigation: import("../../../../../external/spatial-navigation/spatialNavigation").default;
+        getChildContext(): {
+            parentFocusKey: string;
+        };
+        setFocus: (focusKey: string) => void;
+        navigateByDirection: (direction: import("../../../../../external/spatial-navigation/utils").Direction, details?: import("../../../../../external/spatial-navigation/utils").Details) => void;
+        stealFocus: () => void;
+        onUpdateFocus: (focused: boolean) => void;
+        onUpdateHasFocusedChild: (hasFocusedChild: boolean) => void;
+        onEnterPressHandler: (details: import("../../../../../external/spatial-navigation/utils").Details) => void;
+        onClickPressHandler: (details: import("../../../../../external/spatial-navigation/utils").Details) => void;
+        onEnterReleaseHandler: () => void;
+        onBackPressHandler: (details: import("../../../../../external/spatial-navigation/utils").Details) => void;
+        onArrowPressHandler: (direction: import("../../../../../external/spatial-navigation/utils").Direction, details: import("../../../../../external/spatial-navigation/utils").Details) => boolean | void;
+        onBecameFocusedHandler: (layout: import("../../../../../external/spatial-navigation/utils").Layout, details: import("../../../../../external/spatial-navigation/utils").Details) => void;
+        onBecameBlurredHandler: (layout: import("../../../../../external/spatial-navigation/utils").Layout, details: import("../../../../../external/spatial-navigation/utils").Details) => void;
+        componentDidMount(): void;
+        componentDidUpdate(): void;
+        componentWillUnmount(): void;
+        render(): React.ReactElement<Props & WithFocusableProps, string | React.JSXElementConstructor<any>>;
+        context: any;
+        setState<K extends keyof import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>(state: import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState | ((prevState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>, props: Readonly<Props & WithFocusableProps>) => import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState | Pick<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState, K> | null) | Pick<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Props & WithFocusableProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<Props & WithFocusableProps>, nextState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Props & WithFocusableProps>, prevState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Props & WithFocusableProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props & WithFocusableProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Props & WithFocusableProps>, nextState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Props & WithFocusableProps>, nextState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+    };
+    contextTypes: {
+        parentFocusKey: import("prop-types").Requireable<string>;
+    };
+    childContextTypes: {
+        parentFocusKey: import("prop-types").Requireable<string>;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default _default;

package/dist/src/modules/{fantasy → espn/fantasy}/view/TournamentBracketCard/TournamentBracketCard.js

@@ -6,6 +6,7 @@ export const TournamentBracketCard = (props) => {
     const { item } = props;
     // Percentile is stored as 0-100, display as percentage
     const percentileText = `${item.percentile}%`;
+    const { userPickName } = item;
     return (React.createElement("div", { className: "tournament-bracket-card focus-ring", "data-focused": props.focused, "data-complete": item.isComplete, style: {
             '--league-color': '#F51824',
         } },
@@ -15,19 +16,22 @@ export const TournamentBracketCard = (props) => {
                 React.createElement("div", { className: "tournament-bracket-card-name-row" },
                     React.createElement("span", { className: "tournament-bracket-card-entry-name T10 FONT_BOLD" }, item.name),
                     item.entryStatusIcon && (React.createElement(Image, { src: item.entryStatusIcon, width: 24, height: 24, className: "tournament-bracket-card-status-icon", alt: "Entry Status" }))),
-                React.createElement("div", { className: "tournament-bracket-card-subtitle TEXT_200 T02" }, item.tournamentAbbrev))),
+                React.createElement("div", { className: "tournament-bracket-card-subtitle TEXT_200 T10 FONT_BOLD" }, item.tournamentAbbrev))),
         React.createElement("div", { className: "tournament-bracket-card-divider" }),
-        React.createElement("div", { className: "tournament-bracket-card-content" },
+        React.createElement("div", { className: `tournament-bracket-card-content ${userPickName ? '' : 'without-footer'}` },
             item.finalPick?.primaryLogo && (React.createElement(Image, { src: item.finalPick.primaryLogo, width: 64, height: 64, className: "tournament-bracket-card-team-logo", alt: "Final Pick Team Logo" })),
             React.createElement("div", { className: "tournament-bracket-card-stats" },
-                React.createElement("div", { className: "tournament-bracket-card-stat" },
+                React.createElement("div", { className: `tournament-bracket-card-stat ${item.finalPick?.primaryLogo ? '' : 'no-logo'}` },
                     React.createElement("div", { className: "tournament-bracket-card-stat-value T20 FONT_BOLD" }, item.rank),
-                    React.createElement("div", { className: "tournament-bracket-card-stat-label TEXT_200 T02" }, "RANK")),
+                    React.createElement("div", { className: "tournament-bracket-card-stat-label TEXT_200 T02 FONT_BOLD" }, "RANK")),
                 React.createElement("div", { className: "tournament-bracket-card-stat" },
                     React.createElement("div", { className: "tournament-bracket-card-stat-value T20 FONT_BOLD" }, percentileText),
-                    React.createElement("div", { className: "tournament-bracket-card-stat-label TEXT_200 T02" }, "PCT")),
+                    React.createElement("div", { className: "tournament-bracket-card-stat-label TEXT_200 T02 FONT_BOLD" }, "PCT")),
                 React.createElement("div", { className: "tournament-bracket-card-stat" },
                     React.createElement("div", { className: "tournament-bracket-card-stat-value T20 FONT_BOLD" }, item.score.toLocaleString()),
-                    React.createElement("div", { className: "tournament-bracket-card-stat-label TEXT_200 T02" }, "PTS"))))));
+                    React.createElement("div", { className: "tournament-bracket-card-stat-label TEXT_200 T02 FONT_BOLD" }, "PTS"))),
+            userPickName && (React.createElement("div", { className: "tournament-bracket-card-footer T10" },
+                React.createElement("span", { className: "tournament-bracket-card-footer-label FONT_BOLD" }, "Your Pick for this Game:"),
+                React.createElement("span", { className: "tournament-bracket-card-footer-value FONT_BOLD" }, userPickName))))));
 };
 export default withFocusable()(TournamentBracketCard);

package/dist/src/modules/{fantasy → espn/fantasy}/view-model/FantasyViewModel.FantasyPolling.d.ts

@@ -1,4 +1,4 @@
-import FantasyService, { FantasyPollingParams } from '@/services/FantasyService';
+import FantasyService, { FantasyPollingParams } from '@/modules/espn/fantasy/services/FantasyService';
 import { IFantasyResponse } from '../types';
 export default class FantasyPolling {
     private polling;

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

@@ -1,4 +1,4 @@
-import FantasyService, { LeagueManagerPollingParams } from '@/services/FantasyService';
+import FantasyService, { LeagueManagerPollingParams } from '@/modules/espn/fantasy/services/FantasyService';
 import { ILeagueManagerResponse, ILeagueManagerRotoResponse } from '../types';
 export default class LeagueManagerPolling {
     private polling;

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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,140 @@
+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/{fantasy → espn/fantasy}/view-model/FantasyViewModel.d.ts

@@ -1,5 +1,7 @@
 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';
@@ -9,8 +11,8 @@ export type PromoFantasyItem = {
     type: 'promo';
     background: string;
     logo: string;
-    title: string;
     qrCode: string;
+    title: string;
     description: string;
 };
 export type InactiveLeague = {
@@ -95,7 +97,13 @@ export type MatchupPairItem = {
     activeAthletes: MatchupActiveAthlete[];
     topPlayers: TopPlayer[];
 };
-export type FantasyItem = NotLoggedInFantasyItem | MatchupPairItem | MatchupSingleItem | InactiveLeague | PromoFantasyItem;
+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";
@@ -105,17 +113,24 @@ 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;
-    constructor(eventId: string, delegate: IMaestroEventDelegate, options?: {
+    private _promoData;
+    private _fantasyLeagues;
+    private _tournamentChallenges;
+    private _promoItem;
+    private _tcProcessingCount;
+    constructor(eventId: string, delegate: IMaestroEventDelegate, analyticsService: AnalyticsService, options?: {
         useMockData?: boolean;
     });
     /**
@@ -136,13 +151,17 @@ export declare class FantasyViewModel {
     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;