@maestro_io/maestro-web-sdk 3.3.1 → 4.0.0-beta.1

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

@@ -16,6 +16,6 @@ declare class ActiveAthletesMarquee extends React.Component<Props, State> {
     componentDidMount(): void;
     componentDidUpdate(prevProps: Props): void;
     checkOverflow: () => void;
-    render(): React.JSX.Element;
+    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.js

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

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

@@ -0,0 +1,13 @@
+import React from 'react';
+export default class ErrorBoundary extends React.Component<{
+    children: React.ReactNode;
+}, {
+    hasError: boolean;
+}> {
+    constructor(props: any);
+    static getDerivedStateFromError(error: Error): {
+        hasError: boolean;
+    };
+    componentDidCatch(error: any, errorInfo: any): void;
+    render(): React.JSX.Element;
+}

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

@@ -1,3 +1,4 @@
+/// <reference types="prop-types" />
 import React from 'react';
 import { Direction, Layout } from '@/external/spatial-navigation/utils';
 import { FantasyItem } from '../view-model/FantasyViewModel';
@@ -7,15 +8,15 @@ type Props = {
 };
 declare class FantasyItemView extends React.Component<Props> {
     static contextTypes: {
-        refsMap: React.Requireable<any>;
-        setRef: React.Requireable<any>;
-        scrollToFocusedElement: React.Requireable<any>;
+        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(): React.JSX.Element | null;
-    render(): React.JSX.Element;
+    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

@@ -1,4 +1,4 @@
-import React, { Component } from 'react';
+import { Component } from 'react';
 import './FantasyView.styles.css';
 import { Direction } from '@/external/spatial-navigation/utils';
 import FantasyViewModel, { FantasyErrorState, FantasyItem } from '../view-model/FantasyViewModel';
@@ -21,7 +21,7 @@ declare class FantasyView extends Component<{}, State> {
     clearTabLoadFailure: () => void;
     onArrowPress: (d: Direction) => void;
     onEnterPress: (item: FantasyItem) => void;
-    renderItems: () => React.JSX.Element | React.JSX.Element[] | null;
-    render(): React.JSX.Element;
+    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

@@ -18,6 +18,6 @@ declare class DraftDateCountDown extends React.Component<{
         label: string;
         value: string;
     }[];
-    render(): React.JSX.Element;
+    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;

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

@@ -7,7 +7,7 @@ type Props = {
     item: InactiveLeague;
 };
 declare const _default: {
-    new (props?: (Props & WithFocusableProps) | undefined, context?: any): {
+    new (props: (Props & WithFocusableProps) | Readonly<Props & WithFocusableProps>): {
         state: import("../../../../external/spatial-navigation/withFocusable").WithFocusableState;
         navigation: import("../../../../external/spatial-navigation/spatialNavigation").default;
         getChildContext(): {
@@ -27,20 +27,65 @@ declare const _default: {
         componentDidMount(): void;
         componentDidUpdate(): void;
         componentWillUnmount(): void;
-        render(): React.ReactElement<Props & WithFocusableProps>;
-        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: Props & WithFocusableProps) => import("../../../../external/spatial-navigation/withFocusable").WithFocusableState | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K>) | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K>, callback?: (() => any) | undefined): void;
-        forceUpdate(callBack?: (() => any) | undefined): void;
-        props: Readonly<{
-            children?: React.ReactNode;
-        }> & Readonly<Props & WithFocusableProps>;
+        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?: Record<string, any>) => void;
+        stealFocus: () => void;
+        onUpdateFocus: (focused: boolean) => void;
+        onUpdateHasFocusedChild: (hasFocusedChild: boolean) => void;
+        onEnterPressHandler: (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>;
@@ -48,5 +93,6 @@ declare const _default: {
     childContextTypes: {
         parentFocusKey: import("prop-types").Requireable<string>;
     };
+    contextType?: React.Context<any> | undefined;
 };
 export default _default;

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

@@ -0,0 +1,13 @@
+import React from 'react';
+import { withFocusable, } from '@/external/spatial-navigation';
+import './InactiveLeague.styles.css';
+import LeagueCard from '../../components/LeagueCard';
+import DraftDateCountDown from './DraftDateCountdown';
+class InactiveLeagueView extends React.Component {
+    render() {
+        return (React.createElement(LeagueCard, { leagueColor: this.props.item.leagueColor, leagueLogo: this.props.item.leagueLogo, renderTitle: () => React.createElement("span", null, this.props.item.leagueName), shouldExpand: false, expanded: false, ...this.props },
+            !this.props.item.draftDate ? (React.createElement("div", { className: "T30 FONT_BOLD" }, "Draft Date not set")) : (React.createElement(DraftDateCountDown, { draftDate: this.props.item.draftDate })),
+            React.createElement("div", { className: "description T10" }, "You can try a Mock Draft in the ESPN Fantasy App before Draft Day starts.")));
+    }
+}
+export default withFocusable()(InactiveLeagueView);

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

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