@maestro_io/maestro-web-sdk 4.0.0 → 4.0.2

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

@@ -0,0 +1,176 @@
+export interface IPromoResponse {
+    fantasy: {
+        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 FantasyData {
+    totalFantasyLeagues?: number;
+    leaguesBySportLeague?: Record<string, number>;
+    totalChallengeEntries?: number;
+}
+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;

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

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

package/dist/src/modules/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/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/fantasy/view/ActiveAthletesMarquee/index.d.ts

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

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

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

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

@@ -0,0 +1,22 @@
+/// <reference types="prop-types" />
+import React from 'react';
+import { Direction, Layout } from '@/external/spatial-navigation/utils';
+import { FantasyItem } from '../view-model/FantasyViewModel';
+type Props = {
+    item: FantasyItem;
+    onEnterPress: (item: FantasyItem) => void;
+};
+declare class FantasyItemView extends React.Component<Props> {
+    static contextTypes: {
+        refsMap: import("prop-types").Requireable<(HTMLElement | null | undefined)[]>;
+        setRef: import("prop-types").Requireable<(...args: any[]) => any>;
+        scrollToFocusedElement: import("prop-types").Requireable<(...args: any[]) => any>;
+    };
+    context: import("@/components/core/ScrollableContainer/ScrollableContainer").ScrollableContainerContextType;
+    onBecameFocused: (layout: Layout) => void;
+    onArrowPress: (d: Direction) => void;
+    onEnterPress: () => void;
+    renderItem(): JSX.Element | null;
+    render(): JSX.Element;
+}
+export default FantasyItemView;

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

@@ -0,0 +1,74 @@
+import React from 'react';
+import { DEFAULT_SCROLLABLE_CONTAINER_CONTEXT, SCROLLABLE_CONTEXT_TYPE, } from '@/components/core/ScrollableContainer/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';
+class FantasyItemView extends React.Component {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "context", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: DEFAULT_SCROLLABLE_CONTAINER_CONTEXT
+        });
+        Object.defineProperty(this, "onBecameFocused", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (layout) => {
+                this.context.scrollToFocusedElement(layout);
+            }
+        });
+        Object.defineProperty(this, "onArrowPress", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (d) => {
+                if (d === 'left') {
+                    SDK.getMaestroEventViewModel().deliverFocus();
+                }
+            }
+        });
+        Object.defineProperty(this, "onEnterPress", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                this.props.onEnterPress(this.props.item);
+            }
+        });
+    }
+    renderItem() {
+        const item = this.props.item;
+        switch (item.type) {
+            case 'notLoggedIn':
+                return (React.createElement(LoginView, { key: item.id, onArrowPress: this.onArrowPress, onBecameFocused: this.onBecameFocused, onEnterPress: this.onEnterPress }));
+            case 'inactiveLeague':
+                return (React.createElement(InactiveLeague, { key: item.id, item: item, onArrowPress: this.onArrowPress, onBecameFocused: this.onBecameFocused, onEnterPress: this.onEnterPress }));
+            case 'matchup-pair':
+                return (React.createElement(MatchupPair, { key: item.id, item: item, onArrowPress: this.onArrowPress, onBecameFocused: this.onBecameFocused, onEnterPress: this.onEnterPress }));
+            case 'matchup-single':
+                return (React.createElement(MatchupSingle, { key: item.id, item: item, onArrowPress: this.onArrowPress, onBecameFocused: this.onBecameFocused, onEnterPress: this.onEnterPress }));
+            case 'promo':
+                return (React.createElement(PromoView, { key: item.id, item: item, onArrowPress: this.onArrowPress, onBecameFocused: this.onBecameFocused, onEnterPress: this.onEnterPress }));
+            default:
+                console.warn('Unknown fantasy item type:', JSON.stringify(item));
+                return null;
+        }
+    }
+    render() {
+        return React.createElement(FocusableItem, null, this.renderItem());
+    }
+}
+Object.defineProperty(FantasyItemView, "contextTypes", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: SCROLLABLE_CONTEXT_TYPE
+});
+export default FantasyItemView;

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

@@ -0,0 +1,27 @@
+import { Component } from 'react';
+import './FantasyView.styles.css';
+import { Direction } from '@/external/spatial-navigation/utils';
+import FantasyViewModel, { FantasyErrorState, FantasyItem } from '../view-model/FantasyViewModel';
+interface State {
+    container: HTMLDivElement | null;
+    items: FantasyItem[];
+    isDataLoading: boolean;
+    errorState: FantasyErrorState;
+}
+declare class FantasyView extends Component<{}, State> {
+    private container;
+    private itemsListener;
+    private isDataLoadingListener;
+    private errorStateListener;
+    private vm;
+    constructor(props: {});
+    get viewModel(): FantasyViewModel;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    clearTabLoadFailure: () => void;
+    onArrowPress: (d: Direction) => void;
+    onEnterPress: (item: FantasyItem) => void;
+    renderItems: () => JSX.Element | JSX.Element[] | null;
+    render(): JSX.Element;
+}
+export default FantasyView;

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

@@ -0,0 +1,133 @@
+import React, { Component } from 'react';
+import './FantasyView.styles.css';
+import ScrollableContainer from '@/components/core/ScrollableContainer';
+import SDK from '@/index';
+import TabLoadErrorView from '@/components/molecules/TabLoadError';
+import { captureException } from '@/sentry';
+import FantasyItemView from './FantasyItemView';
+class FantasyView extends Component {
+    constructor(props) {
+        super(props);
+        Object.defineProperty(this, "container", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "itemsListener", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "isDataLoadingListener", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "errorStateListener", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "vm", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "clearTabLoadFailure", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                this.viewModel.clearTabLoadFailure();
+            }
+        });
+        Object.defineProperty(this, "onArrowPress", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (d) => {
+                if (d === 'left') {
+                    SDK.getMaestroEventViewModel().deliverFocus();
+                }
+            }
+        });
+        Object.defineProperty(this, "onEnterPress", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (item) => {
+                if (item.type === 'notLoggedIn') {
+                    this.viewModel.onAskLogin();
+                }
+                this.viewModel.onEngage(item.type);
+            }
+        });
+        Object.defineProperty(this, "renderItems", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                const { items } = this.state;
+                if (this.state.errorState === 'tabLoadFailure') {
+                    return (React.createElement(TabLoadErrorView, { onEnterPress: this.clearTabLoadFailure, onArrowPress: this.onArrowPress }));
+                }
+                try {
+                    return items.map((item, i) => (React.createElement(FantasyItemView, { key: item.type + i, item: item, onEnterPress: this.onEnterPress })));
+                }
+                catch (error) {
+                    captureException(error, { items });
+                    console.error('Error rendering fantasy components:', error);
+                    return null;
+                }
+            }
+        });
+        this.vm = SDK.getMaestroEventViewModel().fantasyViewModel;
+        this.state = {
+            container: null,
+            items: this.viewModel.fantasyItems.value,
+            isDataLoading: this.viewModel.isDataLoading.value,
+            errorState: this.viewModel.errorState.value,
+        };
+    }
+    get viewModel() {
+        if (!this.vm) {
+            throw new Error('FantasyViewModel is not initialized');
+        }
+        return this.vm;
+    }
+    componentDidMount() {
+        this.setState({
+            container: this.container,
+        });
+        this.itemsListener = this.viewModel.fantasyItems.subscribe((items) => {
+            this.setState({ items });
+        });
+        this.isDataLoadingListener = this.viewModel.isDataLoading.subscribe((isDataLoading) => {
+            this.setState({ isDataLoading });
+        });
+        this.errorStateListener = this.viewModel.errorState.subscribe((errorState) => {
+            this.setState({ errorState });
+        });
+        // Initialize the view model
+        this.viewModel.init();
+    }
+    componentWillUnmount() {
+        this.itemsListener && this.itemsListener();
+        this.isDataLoadingListener && this.isDataLoadingListener();
+        this.errorStateListener && this.errorStateListener();
+        // Clean up the view model
+        this.viewModel.cleanup();
+    }
+    render() {
+        return (React.createElement(ScrollableContainer, { scrollableContainerRef: this.state.container, containerTopOffset: 40, "data-has-error": this.state.errorState !== 'none' },
+            React.createElement("div", { className: "fantasy-view", ref: (e) => (this.container = e) },
+                this.renderItems(),
+                React.createElement("div", { className: "fantasy-bottom-padding" }))));
+    }
+}
+export default FantasyView;

package/dist/src/modules/fantasy/view/InactiveLeague/DraftDateCountdown.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import React from 'react';
+declare class DraftDateCountDown extends React.Component<{
+    draftDate: number;
+}> {
+    interval: NodeJS.Timer | null;
+    state: {
+        days: string;
+        hours: string;
+        minutes: string;
+        seconds: string;
+    };
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    updateDate(): void;
+    getFormattedTimestamp(): string;
+    get items(): {
+        label: string;
+        value: string;
+    }[];
+    render(): JSX.Element;
+}
+export default DraftDateCountDown;

package/dist/src/modules/fantasy/view/InactiveLeague/DraftDateCountdown.js

@@ -0,0 +1,95 @@
+import React from 'react';
+class DraftDateCountDown extends React.Component {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "interval", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                days: '0',
+                hours: '0',
+                minutes: '0',
+                seconds: '0',
+            }
+        });
+    }
+    componentDidMount() {
+        this.updateDate();
+        this.interval = setInterval(() => this.updateDate(), 1000);
+    }
+    componentWillUnmount() {
+        if (this.interval) {
+            clearInterval(this.interval);
+        }
+    }
+    updateDate() {
+        const now = new Date();
+        const futureDate = new Date(this.props.draftDate);
+        const totalSeconds = Math.floor((futureDate.getTime() - now.getTime()) / 1000);
+        const days = Math.floor(totalSeconds / (3600 * 24))
+            .toString()
+            .padStart(2, '0');
+        const hours = Math.floor((totalSeconds % (3600 * 24)) / 3600)
+            .toString()
+            .padStart(2, '0');
+        const minutes = Math.floor((totalSeconds % 3600) / 60)
+            .toString()
+            .padStart(2, '0');
+        const seconds = (totalSeconds % 60).toString().padStart(2, '0');
+        this.setState({ days, hours, minutes, seconds });
+        // check if the countdown has ended
+        if (totalSeconds <= 0) {
+            if (this.interval) {
+                clearInterval(this.interval);
+            }
+        }
+    }
+    getFormattedTimestamp() {
+        const date = new Date(this.props.draftDate);
+        const options = {
+            month: 'long',
+            day: 'numeric',
+            hour: 'numeric',
+            minute: 'numeric',
+            hour12: true,
+        };
+        return date.toLocaleString('en-US', options);
+    }
+    get items() {
+        return [
+            {
+                label: 'Days',
+                value: this.state.days,
+            },
+            {
+                label: 'Hours',
+                value: this.state.hours,
+            },
+            {
+                label: 'Minutes',
+                value: this.state.minutes,
+            },
+            {
+                label: 'Seconds',
+                value: this.state.seconds,
+            },
+        ];
+    }
+    render() {
+        return (React.createElement("div", { className: "draft-date T02" },
+            React.createElement("div", { className: "date-countdown" }, this.items.map((item) => (React.createElement("div", { key: item.label, className: "segment" },
+                React.createElement("div", { className: "segment-value T50 FONT_BOLD" }, item.value),
+                React.createElement("div", { className: "segment-label" }, item.label))))),
+            React.createElement("span", null,
+                "Snake Draft | ",
+                this.getFormattedTimestamp())));
+    }
+}
+export default DraftDateCountDown;