@maestro_io/maestro-web-sdk 5.2.0 → 5.3.0

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

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

@@ -1,124 +0,0 @@
-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_scoreboard',
-                platform: 'fantasyictv_bbd',
-            },
-        });
-    }
-}
-export default FantasyService;

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,48 +0,0 @@
-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, onArrowPress: onArrowPress, 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;