@maestro_io/maestro-web-sdk 4.0.2 → 5.1.0

package/dist/src/modules/{fantasy → espn/fantasy}/types.d.ts

@@ -9,6 +9,26 @@ export interface IPromoResponse {
             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[];
@@ -78,10 +98,15 @@ export interface Preference {
     };
     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;
@@ -174,3 +199,96 @@ export interface MatchupSingleEntry {
 }
 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/{fantasy → espn/fantasy}/types.js

@@ -4,3 +4,6 @@ export const isLeagueManagerRotoResponse = (response) => {
 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/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;

package/dist/src/modules/{fantasy → espn/fantasy}/view/FantasyView.d.ts

@@ -7,18 +7,25 @@ interface State {
     items: FantasyItem[];
     isDataLoading: boolean;
     errorState: FantasyErrorState;
+    headerHeights: Map<string, number>;
 }
 declare class FantasyView extends Component<{}, State> {
     private container;
     private itemsListener;
     private isDataLoadingListener;
     private errorStateListener;
+    private maxHeightCleanup;
     private vm;
     constructor(props: {});
     get viewModel(): FantasyViewModel;
     componentDidMount(): void;
+    componentDidUpdate(_prevProps: {}, prevState: State): void;
     componentWillUnmount(): void;
+    private recalculateMaxHeight;
+    setContainerRef: (e: HTMLDivElement | null) => void;
     clearTabLoadFailure: () => void;
+    onHeaderRef: (id: string, ref: HTMLDivElement | null) => void;
+    getMaxHeaderHeight: () => number;
     onArrowPress: (d: Direction) => void;
     onEnterPress: (item: FantasyItem) => void;
     renderItems: () => JSX.Element | JSX.Element[] | null;

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

@@ -5,6 +5,8 @@ import SDK from '@/index';
 import TabLoadErrorView from '@/components/molecules/TabLoadError';
 import { captureException } from '@/sentry';
 import FantasyItemView from './FantasyItemView';
+import FantasyHeaderView from './FantasyHeaderView';
+import { setupMaxHeightToBottom } from '@/hooks/useMaxHeightToBottom';
 class FantasyView extends Component {
     constructor(props) {
         super(props);
@@ -32,12 +34,46 @@ class FantasyView extends Component {
             writable: true,
             value: null
         });
+        Object.defineProperty(this, "maxHeightCleanup", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
         Object.defineProperty(this, "vm", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "recalculateMaxHeight", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                if (this.container) {
+                    const rect = this.container.getBoundingClientRect();
+                    this.container.style.maxHeight = `${window.innerHeight - rect.top}px`;
+                }
+            }
+        });
+        Object.defineProperty(this, "setContainerRef", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (e) => {
+                // Update instance variable synchronously
+                this.container = e;
+                // Setup/cleanup height listener with current container reference
+                if (e) {
+                    if (this.maxHeightCleanup) {
+                        this.maxHeightCleanup();
+                    }
+                    // Pass this.container directly (already updated above)
+                    this.maxHeightCleanup = setupMaxHeightToBottom(() => this.container);
+                }
+            }
+        });
         Object.defineProperty(this, "clearTabLoadFailure", {
             enumerable: true,
             configurable: true,
@@ -46,6 +82,35 @@ class FantasyView extends Component {
                 this.viewModel.clearTabLoadFailure();
             }
         });
+        Object.defineProperty(this, "onHeaderRef", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (id, ref) => {
+                if (!ref)
+                    return;
+                const height = ref.clientHeight;
+                this.setState((prev) => {
+                    const current = prev.headerHeights.get(id);
+                    if (current === height)
+                        return null;
+                    const next = new Map(prev.headerHeights);
+                    next.set(id, height);
+                    return { headerHeights: next };
+                });
+            }
+        });
+        Object.defineProperty(this, "getMaxHeaderHeight", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                const { headerHeights } = this.state;
+                if (headerHeights.size === 0)
+                    return 40;
+                return Math.max(...Array.from(headerHeights.values()));
+            }
+        });
         Object.defineProperty(this, "onArrowPress", {
             enumerable: true,
             configurable: true,
@@ -77,7 +142,14 @@ class FantasyView extends Component {
                     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 })));
+                    return items.map((item, i) => {
+                        if (item.type === 'fantasy-group') {
+                            return (React.createElement("div", { key: item.id, className: "fantasy-group-container", style: { position: 'relative' } },
+                                React.createElement(FantasyHeaderView, { ref: (ref) => this.onHeaderRef(item.id, ref), item: item.header }),
+                                item.items.map((subItem) => (React.createElement(FantasyItemView, { key: subItem.id, item: subItem, onEnterPress: this.onEnterPress })))));
+                        }
+                        return (React.createElement(FantasyItemView, { key: item.type + i, item: item, onEnterPress: this.onEnterPress }));
+                    });
                 }
                 catch (error) {
                     captureException(error, { items });
@@ -86,12 +158,14 @@ class FantasyView extends Component {
                 }
             }
         });
-        this.vm = SDK.getMaestroEventViewModel().fantasyViewModel;
+        this.vm = SDK.getMaestroEventViewModel()
+            .fantasyViewModel;
         this.state = {
             container: null,
             items: this.viewModel.fantasyItems.value,
             isDataLoading: this.viewModel.isDataLoading.value,
             errorState: this.viewModel.errorState.value,
+            headerHeights: new Map(),
         };
     }
     get viewModel() {
@@ -101,9 +175,7 @@ class FantasyView extends Component {
         return this.vm;
     }
     componentDidMount() {
-        this.setState({
-            container: this.container,
-        });
+        this.maxHeightCleanup = setupMaxHeightToBottom(() => this.container);
         this.itemsListener = this.viewModel.fantasyItems.subscribe((items) => {
             this.setState({ items });
         });
@@ -116,16 +188,23 @@ class FantasyView extends Component {
         // Initialize the view model
         this.viewModel.init();
     }
+    componentDidUpdate(_prevProps, prevState) {
+        // Recalculate max height when header heights change (due to focus changes)
+        if (prevState.headerHeights !== this.state.headerHeights) {
+            this.recalculateMaxHeight();
+        }
+    }
     componentWillUnmount() {
         this.itemsListener && this.itemsListener();
         this.isDataLoadingListener && this.isDataLoadingListener();
         this.errorStateListener && this.errorStateListener();
+        this.maxHeightCleanup && this.maxHeightCleanup();
         // 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) },
+        return (React.createElement(ScrollableContainer, { scrollableContainerRef: this.container, containerTopOffset: this.getMaxHeaderHeight() || 40, "data-has-error": this.state.errorState !== 'none' },
+            React.createElement("div", { className: "fantasy-view", ref: this.setContainerRef },
                 this.renderItems(),
                 React.createElement("div", { className: "fantasy-bottom-padding" }))));
     }

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

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

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

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