@maestro_io/maestro-web-sdk 5.0.0 → 5.1.1

package/dist/src/modules/espn/fantasy/services/FantasyService.d.ts

@@ -0,0 +1,76 @@
+import { IFantasyResponse, ILeagueManagerResponse, IPromoResponse, TournamentChallenge } from '@/modules/espn/fantasy/types';
+export type LeagueManagerPollingParams = {
+    /**
+     * NBA, NFL, etc.
+     */
+    game: string;
+    /**
+     * 2025
+     */
+    seasonId: number;
+    /**
+     * The league ID
+     */
+    leagueId: number;
+    token: string;
+    proGameId: string;
+    teamId: number;
+};
+export type FantasyPollingParams = {
+    swid: string;
+    jwt: string;
+    eventId: string;
+};
+export type TournamentChallengePollingParams = {
+    challengeId: string;
+    competitionId: string;
+    token: string;
+};
+/**
+ * Service for handling fantasy API calls
+ */
+declare class FantasyService {
+    private networkManager;
+    leagueManagerOverrideBaseUrl: string;
+    fantasyOverrideBaseUrl: string;
+    gambitOverrideBaseUrl: string;
+    constructor();
+    get fantasyBaseUrl(): string;
+    get leagueManagerBaseUrl(): string;
+    get tournamentChallengeBaseUrl(): string;
+    /**
+     * Polls the fantasy API at regular intervals
+     * @param swid - The SWID of the user
+     * @param interval - Polling interval in milliseconds
+     * @param onData - Callback invoked with the data on each successful poll
+     * @param onError - Optional callback invoked on error
+     */
+    pollFantasy({ eventId, jwt, swid }: FantasyPollingParams, interval: number, onData: (data: {
+        data: IFantasyResponse;
+        headers: Record<string, string>;
+    }) => void, onError?: (error: Error) => void): {
+        stop: () => void;
+    };
+    pollLeagueManager({ game, leagueId, seasonId, token, proGameId, teamId, }: LeagueManagerPollingParams, interval: number, onData: (data: {
+        data: ILeagueManagerResponse;
+        headers: Record<string, string>;
+    }) => void, onError?: (error: Error) => void): {
+        stop: () => void;
+    };
+    getPromo(): Promise<IPromoResponse>;
+    /**
+     * Polls the tournament challenge API at regular intervals
+     * @param challengeId - The challenge ID
+     * @param interval - Polling interval in milliseconds
+     * @param onData - Callback invoked with the data on each successful poll
+     * @param onError - Optional callback invoked on error
+     * @returns Object with a stop function to cancel polling
+     */
+    pollTournamentChallenge({ challengeId, competitionId, token }: TournamentChallengePollingParams, interval: number, onData: (data: {
+        data: TournamentChallenge;
+        headers: Record<string, string>;
+    }) => void, onError?: (error: Error) => void): {
+        stop: () => void;
+    };
+}
+export default FantasyService;

package/dist/src/modules/espn/fantasy/services/FantasyService.js

@@ -0,0 +1,124 @@
+import NetworkManager from '../../../../services/NetworkManager/NetworkManager';
+const FANTASY_BASE_URL = 'https://fan.api.espn.com';
+const LEAGUE_MANAGER_BASE_URL = 'https://lm-api-reads.fantasy.espn.com';
+const TOURNAMENT_CHALLENGE_BASE_URL = 'https://gambit-api.fantasy.espn.com';
+const PROMO_URL = 'https://client.espncdn.com/ictv/promo.json';
+/**
+ * Service for handling fantasy API calls
+ */
+class FantasyService {
+    constructor() {
+        Object.defineProperty(this, "networkManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "leagueManagerOverrideBaseUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "fantasyOverrideBaseUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "gambitOverrideBaseUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        this.networkManager = new NetworkManager();
+    }
+    get fantasyBaseUrl() {
+        return this.fantasyOverrideBaseUrl || FANTASY_BASE_URL;
+    }
+    get leagueManagerBaseUrl() {
+        return this.leagueManagerOverrideBaseUrl || LEAGUE_MANAGER_BASE_URL;
+    }
+    get tournamentChallengeBaseUrl() {
+        return this.gambitOverrideBaseUrl || TOURNAMENT_CHALLENGE_BASE_URL;
+    }
+    /**
+     * Polls the fantasy API at regular intervals
+     * @param swid - The SWID of the user
+     * @param interval - Polling interval in milliseconds
+     * @param onData - Callback invoked with the data on each successful poll
+     * @param onError - Optional callback invoked on error
+     */
+    pollFantasy({ eventId, jwt, swid }, interval, onData, onError) {
+        return this.networkManager.pollExternalApiRequestWithHeaders({
+            endpoint: `${this.fantasyBaseUrl}/apis/v2/fans/${swid}`,
+            interval,
+            headers: {
+                'x-p13n-auth': jwt,
+            },
+            onData,
+            onError,
+            params: {
+                displayHiddenPrefs: true,
+                prefType: 'fantasy',
+                context: 'fantasy',
+                useCookieAuth: true,
+                source: 'fantasyictv-bbd',
+                featureFlags: 'challengeEntries',
+                filterType: 'FANTASY_CTV',
+                platform: 'fantasyictv_bbd',
+                swid,
+                eventId,
+            },
+        });
+    }
+    pollLeagueManager({ game, leagueId, seasonId, token, proGameId, teamId, }, interval, onData, onError) {
+        return this.networkManager.pollExternalApiRequestWithHeaders({
+            endpoint: `${this.leagueManagerBaseUrl}/apis/v3/games/${game}/seasons/${seasonId}/segments/0/leagues/${leagueId}/scoreboard`,
+            interval,
+            onData,
+            onError,
+            headers: {
+                'x-p13n-auth': token,
+            },
+            params: {
+                view: 'ictv_scoreboard',
+                platform: 'fantasyictv_bbd',
+                proGameId,
+                teamId,
+            },
+        });
+    }
+    getPromo() {
+        return this.networkManager.externalApiRequest({
+            endpoint: PROMO_URL,
+            useCache: true,
+        });
+    }
+    /**
+     * Polls the tournament challenge API at regular intervals
+     * @param challengeId - The challenge ID
+     * @param interval - Polling interval in milliseconds
+     * @param onData - Callback invoked with the data on each successful poll
+     * @param onError - Optional callback invoked on error
+     * @returns Object with a stop function to cancel polling
+     */
+    pollTournamentChallenge({ challengeId, competitionId, token }, interval, onData, onError) {
+        return this.networkManager.pollExternalApiRequestWithHeaders({
+            endpoint: `${this.tournamentChallengeBaseUrl}/apis/v1/challenges/${challengeId}/scoreboard`,
+            interval,
+            onData,
+            onError,
+            headers: {
+                'x-p13n-auth': token,
+            },
+            params: {
+                competitionId,
+                view: 'ictv_challenges',
+                platform: 'fantasyictv_bbd',
+            },
+        });
+    }
+}
+export default FantasyService;

package/dist/src/modules/espn/fantasy/types.d.ts

@@ -0,0 +1,294 @@
+export interface IPromoResponse {
+    fantasy: {
+        promotion: {
+            title: string;
+            description: string;
+            background: string;
+            logo: string;
+            qrCode: string;
+            fallbackUrl: string;
+        };
+    };
+    'tc-pre'?: {
+        promotion: {
+            title: string;
+            description: string;
+            background: string;
+            logo: string;
+            qrCode: string;
+            fallbackUrl: string;
+        };
+    };
+    'tc-live'?: {
+        promotion: {
+            title: string;
+            description: string;
+            background: string;
+            logo: string;
+            qrCode: string;
+            fallbackUrl: string;
+        };
+    };
+}
+export interface IFantasyResponse {
+    preferences?: Preference[];
+    fantasyData?: FantasyData;
+}
+export interface Preference {
+    id?: string;
+    createDate?: number;
+    lastUpdateDate?: number;
+    metaData?: {
+        entry?: {
+            entryId?: number;
+            entryMetadata?: {
+                teamName?: string;
+                teamAbbrev?: string;
+                leagueFormatTypeId?: number;
+                leagueSubTypeId?: number;
+                customizable?: boolean;
+                active?: boolean;
+                draftComplete?: boolean;
+                scoringTypeId?: number;
+                leagueTypeId?: number;
+                draftInProgress?: boolean;
+            };
+            firstScoringPeriodId?: number;
+            gameId?: number;
+            groups?: {
+                groupId?: number;
+                groupSize?: number;
+                groupName?: string;
+                groupManager?: boolean;
+                draftDate?: number | string | null;
+                draftType?: number;
+                draftStatus?: number;
+                leagueStatus?: number;
+                fantasyCastHref?: string;
+                href?: string;
+            }[];
+            logoType?: string;
+            logoUrl?: string;
+            restrictionType?: number;
+            seasonId?: number;
+            entryURL?: string;
+            scoreboardFeedURL?: string;
+            abbrev?: string;
+            name?: string;
+            description?: string;
+            logoURL?: string;
+            signupURL?: string;
+            href?: string;
+        };
+        inSeason?: boolean;
+        isLive?: boolean;
+        currentScoringPeriodId?: number;
+    };
+    contentSourceId?: number;
+    sortGlobal?: number;
+    isHidden?: boolean;
+    typeId?: number;
+    type?: {
+        id?: number;
+        name?: string;
+        code?: string;
+        isDeletable?: boolean;
+        isDelegated?: boolean;
+        maxAllowed?: number;
+    };
+    bu?: number;
+}
+export interface ChallengeInformation {
+    id: string | number;
+    gameType: string;
+}
+export interface FantasyData {
+    totalFantasyLeagues?: number;
+    leaguesBySportLeague?: Record<string, number>;
+    totalChallengeEntries?: number;
+    challengeInformation?: ChallengeInformation[];
+}
+export interface ILeagueManagerResponse {
+    gameId?: number;
+    id?: number;
+    leagueName?: string;
+    livePlayers?: any[];
+    matchups?: Matchup[];
+    scoringPeriodId?: number;
+    scoringType?: string;
+    seasonId?: number;
+    segmentId?: number;
+    sportColor?: string;
+    sportLogo?: string;
+    topPlayers?: Player[];
+}
+export interface Matchup {
+    away?: Team;
+    home?: Team;
+    id?: number;
+    name?: string;
+}
+export interface Team {
+    currentScoringPeriodPoints?: number;
+    id?: number;
+    logo?: string;
+    name?: string;
+    owners?: Owner[];
+    points?: number;
+    score?: string;
+    record?: string;
+    roster?: RosterItem[];
+    winProbability?: number;
+    projectedPoints?: string;
+}
+export interface Owner {
+    firstName?: string;
+    id?: string;
+    lastName?: string;
+}
+export interface RosterItem {
+    displayOrder?: number;
+    player?: Player;
+    slot?: string;
+}
+export interface Player {
+    abbrevName?: string;
+    currentlyWatching?: boolean;
+    firstName?: string;
+    fullName?: string;
+    headshot?: string;
+    id?: number;
+    injuryStatus?: string;
+    lastName?: string;
+    lastNewsDate?: number;
+    percentRostered?: number;
+    points?: number;
+    projectedPoints?: number;
+    positions?: string;
+    statLine?: string;
+    playerStatus?: string;
+    proGameStatusLines?: string[];
+    proTeam?: ProTeam;
+}
+export interface ProTeam {
+    alternateColor?: string;
+    color?: string;
+    darkLogo?: string;
+    id?: number;
+    live?: boolean;
+    triCode?: string;
+}
+export interface ILeagueManagerRotoResponse {
+    gameId?: number;
+    id?: number;
+    leagueName?: string;
+    name?: string;
+    livePlayers?: any[];
+    matchups?: MatchupSingleEntry[];
+    scoringPeriodId?: number;
+    scoringType?: string;
+    seasonId?: number;
+    segmentId?: number;
+    sportColor?: string;
+    sportLogo?: string;
+    topPlayers?: Player[];
+}
+export interface MatchupSingleEntry {
+    id?: number;
+    teams?: Team[];
+}
+export declare const isLeagueManagerRotoResponse: (response: ILeagueManagerResponse | ILeagueManagerRotoResponse) => response is ILeagueManagerRotoResponse;
+export declare const isLeagueManagerHeadToHeadResponse: (response: ILeagueManagerResponse | ILeagueManagerRotoResponse) => response is ILeagueManagerResponse;
+export interface TournamentPick {
+    propositionId?: string;
+    outcomeId?: string;
+}
+export interface TournamentPropositionOutcome {
+    id?: string;
+    name?: string;
+}
+export interface TournamentProposition {
+    id?: string;
+    outcomes?: TournamentPropositionOutcome[];
+}
+export interface TournamentChallengeEntry {
+    id?: string;
+    name?: string;
+    rank?: number;
+    score?: number;
+    percentile?: number;
+    isComplete?: boolean;
+    entryStatusIcon?: string;
+    finalPick?: TournamentPick & {
+        primaryLogo?: string;
+        secondaryLogo?: string;
+        result?: string;
+    };
+    picks?: TournamentPick[];
+}
+export interface TournamentChallenge {
+    id?: string;
+    key?: string;
+    name?: string;
+    abbrev?: string;
+    logo?: string;
+    logoDark?: string;
+    state?: 'PRE' | 'LIVE' | 'POST';
+    locked?: boolean;
+    lockDate?: string | number;
+    scoringPeriodLabel?: string;
+    upcomingGames?: any[];
+    entries?: TournamentChallengeEntry[];
+    propositions?: TournamentProposition[];
+}
+export declare const isTournamentChallenge: (data: any) => data is TournamentChallenge;
+export type TournamentChallengeHeaderItem = {
+    type: 'tournament-challenge-header';
+    id: string;
+    name: string;
+    abbrev: string;
+    logo: string;
+    logoDark: string;
+    state: 'PRE' | 'LIVE' | 'POST';
+    scoringPeriodLabel: string;
+    upcomingGames: any[];
+};
+export type TournamentBracketCardItem = {
+    type: 'tournament-bracket-card';
+    id: string;
+    name: string;
+    rank: number;
+    score: number;
+    percentile: number;
+    entryStatusIcon: string;
+    finalPick: TournamentPick & {
+        primaryLogo?: string;
+        secondaryLogo?: string;
+        result?: string;
+    };
+    picks?: TournamentPick[];
+    isComplete: boolean;
+    tournamentId: string;
+    tournamentAbbrev: string;
+    tournamentLogo: string;
+    userPickName?: string;
+    propositions?: TournamentProposition[];
+};
+export type FantasyHeaderItem = {
+    type: 'fantasy-header';
+    id: string;
+    title: string;
+};
+export interface IFantasyViewModel {
+    cleanup(): void;
+}
+export type TournamentOverflowQRItem = {
+    type: 'tournament-overflow-qr';
+    id: string;
+    background: string;
+    logo: string;
+    qrCode: string;
+    title: string;
+    description: string;
+    tournamentId: string;
+};

package/dist/src/modules/espn/fantasy/types.js

@@ -0,0 +1,9 @@
+export const isLeagueManagerRotoResponse = (response) => {
+    return (response.matchups?.[0]?.teams !== undefined);
+};
+export const isLeagueManagerHeadToHeadResponse = (response) => {
+    return response.matchups?.[0]?.home !== undefined;
+};
+export const isTournamentChallenge = (data) => {
+    return data.entries?.[0]?.id !== undefined;
+};

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

@@ -0,0 +1,21 @@
+import React from 'react';
+import './ActiveAthletesMarquee.styles.css';
+type Props = {
+    activeAthletes: {
+        abbrevName: string;
+        points: string;
+    }[];
+};
+type State = {
+    shouldAnimate: boolean;
+};
+declare class ActiveAthletesMarquee extends React.Component<Props, State> {
+    private containerRef;
+    private marqueeRef;
+    constructor(props: Props);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: Props): void;
+    checkOverflow: () => void;
+    render(): JSX.Element;
+}
+export default ActiveAthletesMarquee;

package/dist/src/modules/espn/fantasy/view/ActiveAthletesMarquee/ActiveAthletesMarquee.js

@@ -0,0 +1,74 @@
+import React from 'react';
+import './ActiveAthletesMarquee.styles.css';
+class ActiveAthletesMarquee extends React.Component {
+    constructor(props) {
+        super(props);
+        Object.defineProperty(this, "containerRef", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "marqueeRef", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "checkOverflow", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                if (this.containerRef && this.marqueeRef) {
+                    const containerWidth = this.containerRef.offsetWidth;
+                    const marqueeWidth = this.marqueeRef.scrollWidth;
+                    this.setState({
+                        shouldAnimate: marqueeWidth > containerWidth,
+                    });
+                }
+            }
+        });
+        this.state = {
+            shouldAnimate: false,
+        };
+    }
+    componentDidMount() {
+        this.checkOverflow();
+    }
+    componentDidUpdate(prevProps) {
+        if (prevProps.activeAthletes !== this.props.activeAthletes) {
+            this.checkOverflow();
+        }
+    }
+    render() {
+        return (React.createElement("div", { ref: (ref) => {
+                this.containerRef = ref;
+            }, className: "active-athletes-container T10", "data-should-animate": this.state.shouldAnimate },
+            React.createElement("div", { ref: (ref) => {
+                    this.marqueeRef = ref;
+                }, className: "active-athletes-marquee FONT_BOLD" },
+                React.createElement("span", { className: "your-team-label" }, "Your Team:"),
+                "\u00A0",
+                !this.props.activeAthletes.length && (React.createElement("span", { className: "active-athlete TEXT_200" }, "No Active Players")),
+                this.props.activeAthletes.map((athlete, i) => (React.createElement("span", { key: athlete.abbrevName + '-active-athlete-' + athlete.points, className: "active-athlete TEXT_200" },
+                    athlete.abbrevName,
+                    " \u2022",
+                    ' ',
+                    React.createElement("span", { className: "athlete-points" }, athlete.points),
+                    this.props.activeAthletes.length - 1 !== i && ' / ',
+                    i === this.props.activeAthletes.length - 1 &&
+                        this.state.shouldAnimate &&
+                        ' / '))),
+                this.state.shouldAnimate &&
+                    this.props.activeAthletes.map((athlete, i) => (React.createElement("span", { key: athlete.abbrevName +
+                            '-active-athlete-duplicate-' +
+                            athlete.points, className: "active-athlete TEXT_200" },
+                        athlete.abbrevName,
+                        " \u2022",
+                        ' ',
+                        React.createElement("span", { className: "athlete-points" }, athlete.points),
+                        this.props.activeAthletes.length - 1 !== i && ' / '))))));
+    }
+}
+export default ActiveAthletesMarquee;

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

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

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

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

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

@@ -0,0 +1,8 @@
+import React from 'react';
+import { FantasyHeaderItem } from '../types';
+import './FantasyHeaderView.styles.css';
+type Props = {
+    item: FantasyHeaderItem;
+};
+declare const FantasyHeaderView: React.ForwardRefExoticComponent<Props & React.RefAttributes<HTMLDivElement>>;
+export default FantasyHeaderView;

package/dist/src/modules/espn/fantasy/view/FantasyHeaderView.js

@@ -0,0 +1,8 @@
+import React from 'react';
+import './FantasyHeaderView.styles.css';
+const FantasyHeaderView = React.forwardRef(({ item }, ref) => {
+    const className = 'fantasy-header-view sticky T10 FONT_BOLD';
+    return (React.createElement("div", { ref: ref, className: className }, item.title));
+});
+FantasyHeaderView.displayName = 'FantasyHeaderView';
+export default FantasyHeaderView;

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

@@ -0,0 +1,8 @@
+import React from 'react';
+import { FantasyItem } from '../view-model/FantasyViewModel';
+type Props = {
+    item: FantasyItem;
+    onEnterPress: (item: FantasyItem) => void;
+};
+declare const FantasyItemView: React.FC<Props>;
+export default FantasyItemView;

package/dist/src/modules/espn/fantasy/view/FantasyItemView.js

@@ -0,0 +1,48 @@
+import React from 'react';
+import { useScrollableContainer } from '@/components/core/ScrollableContainer';
+import FocusableItem from '@/components/core/ScrollableContainer/FocusableItem';
+import SDK from '@/index';
+import LoginView from './LoginView';
+import InactiveLeague from './InactiveLeague';
+import MatchupPair from './MatchupPair';
+import MatchupSingle from './MatchupSingle';
+import PromoView from './PromoView';
+import TournamentBracketCard from './TournamentBracketCard';
+import TournamentOverflowQR from '../components/TournamentOverflowQR';
+const FantasyItemView = ({ item, onEnterPress: onEnterPressProp, }) => {
+    const { scrollToFocusedElement } = useScrollableContainer();
+    const onBecameFocused = (layout) => {
+        scrollToFocusedElement(layout);
+    };
+    const onArrowPress = (d) => {
+        if (d === 'left') {
+            SDK.getMaestroEventViewModel().deliverFocus();
+        }
+    };
+    const onEnterPress = () => {
+        onEnterPressProp(item);
+    };
+    const renderItem = () => {
+        switch (item.type) {
+            case 'notLoggedIn':
+                return (React.createElement(LoginView, { key: item.id, onArrowPress: onArrowPress, onBecameFocused: onBecameFocused, onEnterPress: onEnterPress }));
+            case 'inactiveLeague':
+                return (React.createElement(InactiveLeague, { key: item.id, item: item, onArrowPress: onArrowPress, onBecameFocused: onBecameFocused, onEnterPress: onEnterPress }));
+            case 'matchup-pair':
+                return (React.createElement(MatchupPair, { key: item.id, item: item, onArrowPress: onArrowPress, onBecameFocused: onBecameFocused, onEnterPress: onEnterPress }));
+            case 'matchup-single':
+                return (React.createElement(MatchupSingle, { key: item.id, item: item, onArrowPress: onArrowPress, onBecameFocused: onBecameFocused, onEnterPress: onEnterPress }));
+            case 'promo':
+                return (React.createElement(PromoView, { key: item.id, item: item, onArrowPress: onArrowPress, onBecameFocused: onBecameFocused, onEnterPress: onEnterPress }));
+            case 'tournament-bracket-card':
+                return (React.createElement(TournamentBracketCard, { key: item.id, item: item, onArrowPress: onArrowPress, onBecameFocused: onBecameFocused, onEnterPress: onEnterPress }));
+            case 'tournament-overflow-qr':
+                return (React.createElement(TournamentOverflowQR, { key: item.id, item: item, onEnterPress: onEnterPress, onBecameFocused: onBecameFocused }));
+            default:
+                console.warn('Unknown fantasy item type:', JSON.stringify(item));
+                return null;
+        }
+    };
+    return React.createElement(FocusableItem, null, renderItem());
+};
+export default FantasyItemView;