@maestro_io/maestro-web-sdk 1.0.0 → 2.0.1

package/dist/models/IModel.d.ts

@@ -0,0 +1,7 @@
+export default interface IModel {
+    _id?: string;
+    archived?: boolean;
+    created?: number;
+    modified?: number;
+    tags?: string[];
+}

package/dist/models/IPanel.d.ts

@@ -0,0 +1,20 @@
+export declare const MaestroPanelType: {
+    readonly KEY_PLAYS: "keyPlays";
+    readonly STATS: "stats";
+    readonly FANTASY: "fantasy";
+    readonly BETS: "bets";
+};
+export type MaestroPanelType = (typeof MaestroPanelType)[keyof typeof MaestroPanelType];
+export interface PanelTypeInfo {
+    id: MaestroPanelType;
+    name: string;
+    imageNamePrefix: string;
+    usesSectionHeaders: boolean;
+    iconName: string;
+}
+export declare const PANEL_TYPE_INFO: Record<MaestroPanelType, PanelTypeInfo>;
+export declare const getPanelName: (panelType: MaestroPanelType) => string;
+export declare const getImageNamePrefix: (panelType: MaestroPanelType) => string;
+export declare const usesSectionHeaders: (panelType: MaestroPanelType) => boolean;
+export declare const getIconName: (panelType: MaestroPanelType) => string;
+export declare const getAllPanelTypes: () => MaestroPanelType[];

package/dist/models/ITheme.d.ts

@@ -0,0 +1,77 @@
+import IModel from './IModel';
+type ObjectValues<T> = T[keyof T];
+export default interface ITheme extends IModel {
+    button: IThemeButton;
+    channelOfflineThumbnail?: string;
+    colors: IThemeColors;
+    creator: string;
+    desktopBackground?: string;
+    icon?: string;
+    logo?: string;
+    mobileBackground?: string;
+    mode?: ThemeModes;
+    name: string;
+    owner: string;
+    siteId?: string;
+    type: ThemeTypes;
+    typography: IThemeTypography;
+}
+export interface IThemeColors {
+    accentPrimary: string;
+    accentSecondary: string;
+    accentTertiary: string;
+    alertConfirmation: string;
+    alertError: string;
+    alertWarning: string;
+    highlightPrimary: string;
+    highlightSecondary: string;
+    highlightTertiary: string;
+    surface1: string;
+    surface2: string;
+    surface3: string;
+    surface4: string;
+    surface5: string;
+    surface6: string;
+    text100: string;
+    text200: string;
+    text300: string;
+    text400: string;
+    text500: string;
+}
+export interface IThemeButton {
+    borderRadius: BorderRadius;
+    textCapitalization: TextCapitalization;
+}
+export interface IThemeTypography {
+    body: string;
+    headline: string;
+}
+export interface IClassicThemeOptions {
+    accentPrimary: string;
+    accentSecondary: string;
+}
+export declare const BORDER_RADIUS: {
+    readonly rounded: "rounded";
+    readonly square: "square";
+    readonly pill: "pill";
+};
+export type BorderRadius = ObjectValues<typeof BORDER_RADIUS>;
+export declare const TEXT_CAPITALIZATION: {
+    readonly lowercase: "lowercase";
+    readonly original: "original";
+    readonly uppercase: "uppercase";
+};
+export type TextCapitalization = ObjectValues<typeof TEXT_CAPITALIZATION>;
+export declare const THEME_TYPES: {
+    readonly ADMIN: "admin";
+    readonly ADVANCED: "advanced";
+    readonly CLASSIC: "classic";
+    readonly CUSTOM: "custom";
+};
+export type ThemeTypes = ObjectValues<typeof THEME_TYPES>;
+export declare const THEME_MODES: {
+    readonly DARK: "dark";
+    readonly LIGHT: "light";
+};
+export type ThemeModes = ObjectValues<typeof THEME_MODES>;
+export {};

package/dist/modules/key-plays/constants.d.ts

@@ -0,0 +1,3 @@
+import IMaestroKeyPlaysResponse from './interfaces/IKeyPlaysResponse';
+export declare const KEY_PLAYS_RESPONSE_MOCK_DATA: IMaestroKeyPlaysResponse;
+export declare const BASE_64_KEY_PLAY_THUMBNAIL_FALLBACK = "data:image/jpeg;base64,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";

package/dist/modules/key-plays/interfaces/IKeyPlays.d.ts

@@ -0,0 +1,31 @@
+export default interface IKeyPlay {
+    id: string;
+    description: string;
+    homeTeamName: string;
+    awayTeamName: string;
+    homeTeamScore?: number;
+    awayTeamScore?: number;
+    clipID: string;
+    teamImageUrl?: string;
+    playerImageUrl?: string;
+    thumbnailImageUrl?: string;
+    section?: string;
+}
+export declare const KEY_PLAYS_LOAD_FAILURE_STATUS: {
+    readonly noFailure: "noFailure";
+    readonly recentFailure: "recentFailure";
+    readonly nonRecentFailure: "nonRecentFailure";
+};
+type KeyPlayLoadFailureStatus = (typeof KEY_PLAYS_LOAD_FAILURE_STATUS)[keyof typeof KEY_PLAYS_LOAD_FAILURE_STATUS];
+export declare const KEY_PLAYS_ERROR_STATE: {
+    readonly unsupportedEvent: "unsupportedEvent";
+    readonly unpopulatedEvent: "unpopulatedEvent";
+    readonly tabLoadFailure: "tabLoadFailure";
+};
+type KeyPlaysErrorState = (typeof KEY_PLAYS_ERROR_STATE)[keyof typeof KEY_PLAYS_ERROR_STATE];
+export declare const KEY_PLAYS_PANEL_SCROLL_VIEW_ITEM_TYPE: {
+    readonly keyPlay: "keyPlay";
+    readonly sectionHeader: "sectionHeader";
+};
+type KeyPlaysPanelScrollViewItemType = (typeof KEY_PLAYS_PANEL_SCROLL_VIEW_ITEM_TYPE)[keyof typeof KEY_PLAYS_PANEL_SCROLL_VIEW_ITEM_TYPE];
+export { type KeyPlaysPanelScrollViewItemType, type KeyPlayLoadFailureStatus, type KeyPlaysErrorState, };

package/dist/modules/key-plays/interfaces/IKeyPlaysResponse.d.ts

@@ -0,0 +1,44 @@
+type TeamId = string;
+type AthleteId = string;
+export default interface IMaestroKeyPlaysResponse {
+    entities: {
+        team: Record<TeamId, IMaestroKeyPlaysTeam>;
+        athlete: Record<AthleteId, MaestroKeyPlaysAthlete>;
+    };
+    sections: MaestroKeyPlaysSection[];
+}
+interface IMaestroKeyPlaysTeam {
+    id: string;
+    displayName: string;
+    shortName: string;
+    color: string;
+    alternateColor: string;
+    homeAway: string;
+    displayOrder: string;
+    logoRef: string;
+    logoDarkRef: string;
+}
+interface MaestroKeyPlaysAthlete {
+    id: string;
+    shortName: string;
+    headshot: string;
+}
+interface MaestroKeyPlaysSection {
+    title: string;
+    items: MaestroKeyPlay[];
+}
+interface MaestroKeyPlay {
+    description: string;
+    team: string;
+    wallClock: string;
+    displayClock: string;
+    shortPeriod: string;
+    scoringPlay: boolean;
+    athlete: string;
+    thumbnail: string;
+    thumbnailType: string;
+    clipID: string;
+    awayScore?: string;
+    homeScore?: string;
+}
+export {};

package/dist/modules/key-plays/view/KeyPlayCardScoreTagView.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export default class ScoreCard extends React.Component<{
+    awayTeamScore?: number;
+    homeTeamScore?: number;
+    homeTeamName: string;
+    awayTeamName: string;
+}, {}> {
+    render(): React.JSX.Element;
+}

package/dist/modules/key-plays/view/KeyPlayCardView.d.ts

@@ -0,0 +1,115 @@
+/// <reference types="prop-types" />
+import IKeyPlay from '../interfaces/IKeyPlays';
+import './KeyPlayCardView.styles.css';
+import React from 'react';
+import { WithFocusableProps } from '@/external/spatial-navigation';
+import { RemoteControlProps } from '@/helpers/withRemoteControl';
+type KeyPlayCardViewProps = IKeyPlay & {
+    isPlaying: boolean;
+    playbackProgress: number | null;
+    isScoring: boolean;
+    setFocus?: (focusKey: string) => void;
+    focused?: boolean;
+    setRef: (ref: HTMLDivElement | null) => void;
+};
+export declare class KeyPlayCard extends React.Component<KeyPlayCardViewProps & WithFocusableProps & RemoteControlProps> {
+    private ref;
+    setRef: (ref: HTMLDivElement | null) => void;
+    handleLeftPressed: () => void;
+    render(): React.JSX.Element;
+}
+declare const _default: {
+    new (props?: (IKeyPlay & {
+        isPlaying: boolean;
+        playbackProgress: number | null;
+        isScoring: boolean;
+        setFocus?: ((focusKey: string) => void) | undefined;
+        focused?: boolean | undefined;
+        setRef: (ref: HTMLDivElement | null) => void;
+    } & WithFocusableProps & RemoteControlProps) | undefined, context?: any): {
+        state: import("../../../external/spatial-navigation/withFocusable").WithFocusableState;
+        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: {
+            pressedKeys: Record<string, number>;
+        }) => void;
+        onEnterReleaseHandler: () => void;
+        onArrowPressHandler: (direction: import("../../../external/spatial-navigation/utils").Direction, details: {
+            pressedKeys: Record<string, number>;
+        }) => boolean | void;
+        onBecameFocusedHandler: (layout: import("../../../external/spatial-navigation/utils").Layout, details: any) => void;
+        onBecameBlurredHandler: (layout: import("../../../external/spatial-navigation/utils").Layout, details: any) => void;
+        componentDidMount(): void;
+        componentDidUpdate(): void;
+        componentWillUnmount(): void;
+        render(): React.ReactElement<IKeyPlay & {
+            isPlaying: boolean;
+            playbackProgress: number | null;
+            isScoring: boolean;
+            setFocus?: ((focusKey: string) => void) | undefined;
+            focused?: boolean | undefined;
+            setRef: (ref: HTMLDivElement | null) => void;
+        } & WithFocusableProps & RemoteControlProps>;
+        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: IKeyPlay & {
+            isPlaying: boolean;
+            playbackProgress: number | null;
+            isScoring: boolean;
+            setFocus?: ((focusKey: string) => void) | undefined;
+            focused?: boolean | undefined;
+            setRef: (ref: HTMLDivElement | null) => void;
+        } & WithFocusableProps & RemoteControlProps) => 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<IKeyPlay & {
+            isPlaying: boolean;
+            playbackProgress: number | null;
+            isScoring: boolean;
+            setFocus?: ((focusKey: string) => void) | undefined;
+            focused?: boolean | undefined;
+            setRef: (ref: HTMLDivElement | null) => void;
+        } & WithFocusableProps & RemoteControlProps>;
+        context: any;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<IKeyPlay & {
+            isPlaying: boolean;
+            playbackProgress: number | null;
+            isScoring: boolean;
+            setFocus?: ((focusKey: string) => void) | undefined;
+            focused?: boolean | undefined;
+            setRef: (ref: HTMLDivElement | null) => void;
+        } & WithFocusableProps & RemoteControlProps>, nextContext: any): void;
+        shouldComponentUpdate?(nextProps: Readonly<IKeyPlay & {
+            isPlaying: boolean;
+            playbackProgress: number | null;
+            isScoring: boolean;
+            setFocus?: ((focusKey: string) => void) | undefined;
+            focused?: boolean | undefined;
+            setRef: (ref: HTMLDivElement | null) => void;
+        } & WithFocusableProps & RemoteControlProps>, nextState: Readonly<import("../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
+        componentWillUpdate?(nextProps: Readonly<IKeyPlay & {
+            isPlaying: boolean;
+            playbackProgress: number | null;
+            isScoring: boolean;
+            setFocus?: ((focusKey: string) => void) | undefined;
+            focused?: boolean | undefined;
+            setRef: (ref: HTMLDivElement | null) => void;
+        } & WithFocusableProps & RemoteControlProps>, 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>;
+    };
+};
+export default _default;

package/dist/modules/key-plays/view/KeyPlayErrorStateView.d.ts

@@ -0,0 +1,11 @@
+import { KeyPlaysErrorState } from '../interfaces/IKeyPlays';
+import './KeyPlayErrorStateView.styles.css';
+import React from 'react';
+type Props = {
+    errorState: KeyPlaysErrorState;
+    onRetry: () => void;
+};
+declare class KeyPlayErrorStateView extends React.Component<Props, {}> {
+    render(): React.JSX.Element | null;
+}
+export default KeyPlayErrorStateView;

package/dist/modules/key-plays/view/KeyPlaysView.d.ts

@@ -0,0 +1,53 @@
+import React, { Component } from 'react';
+import './KeyPlaysView.styles.css';
+import { KeyPlaysErrorState } from '../interfaces/IKeyPlays';
+interface IKeyPlayItem {
+    id: string;
+    clipID: string;
+    awayTeamScore?: number;
+    homeTeamScore?: number;
+    awayTeamName: string;
+    homeTeamName: string;
+    description: string;
+    playerImageUrl: string;
+    teamImageUrl: string;
+    thumbnailImageUrl: string;
+}
+interface IKeyPlaySection {
+    title: string;
+    items: IKeyPlayItem[];
+}
+interface IKeyPlaysState {
+    scrolled: boolean;
+    playbackProgress: number | null;
+    playbackIndex: number | null;
+    items: IKeyPlaySection[];
+}
+export declare class KeyPlays extends Component<{}, IKeyPlaysState> {
+    private container;
+    private refsMap;
+    private playbackProgressUnsub;
+    private playbackIndexUnsub;
+    private itemsUnsub;
+    private vm;
+    constructor(props: {});
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private handlePlayClip;
+    private handleItemFocus;
+    private setRef;
+    render(): React.JSX.Element;
+}
+interface KeyPlaysWithErrorStateState {
+    errorState: KeyPlaysErrorState;
+}
+export default class KeyPlaysWithErrorState extends Component<{}, KeyPlaysWithErrorStateState> {
+    private errorStateUnsub;
+    private vm;
+    constructor(props: {});
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private handleRetry;
+    render(): React.JSX.Element;
+}
+export {};

package/dist/modules/key-plays/view-model/KeyPlaysViewModel.d.ts

@@ -0,0 +1,29 @@
+import IMaestroKeyPlaysResponse from '../interfaces/IKeyPlaysResponse';
+import IKeyPlay, { KeyPlayLoadFailureStatus, KeyPlaysErrorState } from '../interfaces/IKeyPlays';
+import { Observable } from '@/helpers/Observable';
+type KeyPlayItem = {
+    title: string;
+    items: IKeyPlay[];
+};
+declare class KeyPlaysViewModel {
+    currentlyPlayingClipIndex: Observable<number | null>;
+    lastPlayedClipIndex: Observable<number | null>;
+    currentClipPlaybackProgress: Observable<number | null>;
+    errorState: Observable<KeyPlaysErrorState | null>;
+    failedClips: Observable<{
+        [key: string]: KeyPlayLoadFailureStatus;
+    }>;
+    items: Observable<KeyPlayItem[]>;
+    isCurrentlyPlaying(index: number): boolean;
+    setKeyPlays(items: IMaestroKeyPlaysResponse | null): Promise<void>;
+    private cleanErrors;
+    playKeyPlay(atIndex: number): Promise<void>;
+    parseNetworkResponse(response: IMaestroKeyPlaysResponse): KeyPlayItem[];
+    get allItems(): IKeyPlay[];
+    clipID(forKeyPlayAtIndex: number): string | undefined;
+    handleKeyPlayLoadFailure(forKeyPlayAtIndex: number): void;
+    loadFailureStatus(forKeyPlayAtIndex: number): KeyPlayLoadFailureStatus;
+    clearLoadFailureStatus(forKeyPlayAtIndex: number): void;
+    userRequestedNewKeyPlaysData(): Promise<void>;
+}
+export default KeyPlaysViewModel;

package/dist/services/NetworkManager.d.ts

@@ -0,0 +1,13 @@
+declare class NetworkManager {
+    private static instance;
+    private cacheManager;
+    private client;
+    private constructor();
+    static getInstance(): NetworkManager;
+    setAuthentication(token: string | null, apiKey: string | null): void;
+    private handleError;
+    get<TResponseData = any>(endpoint: string, params?: Record<string, unknown>): Promise<TResponseData>;
+    post<TRequestData = any, TResponseData = any>(endpoint: string, data: TRequestData): Promise<TResponseData>;
+}
+declare const networkManager: NetworkManager;
+export default networkManager;

package/dist/services/ThemeManager/constants.d.ts

@@ -0,0 +1,2 @@
+import ITheme from '@/models/ITheme';
+export declare const DARK_THEME: ITheme;

package/dist/view-models/MaestroEventViewModel.d.ts

@@ -0,0 +1,37 @@
+import IMaestroEventDelegate from '../interfaces/IMaestroEventDelegate';
+import IMaestroEvent from '../interfaces/IMaestroEvent';
+import { Observable } from '../helpers/Observable';
+import { ViewModel } from './ViewModel';
+import KeyPlaysViewModel from '../modules/key-plays/view-model/KeyPlaysViewModel';
+import IMaestroKeyPlaysResponse from '../modules/key-plays/interfaces/IKeyPlaysResponse';
+export declare class MaestroEventViewModel extends ViewModel implements IMaestroEvent {
+    private _eventId;
+    private _title;
+    private _isLive;
+    private _isShowingPanel;
+    delegate: IMaestroEventDelegate;
+    keyPlaysViewModel: KeyPlaysViewModel;
+    constructor(eventId: string | undefined, delegate: IMaestroEventDelegate);
+    deinit(): void;
+    updateKeyPlaysData(data: IMaestroKeyPlaysResponse | null): Promise<void>;
+    startFocusManagement(): Promise<void>;
+    didStartPlayingClip(index: number): void;
+    didStopPlayingClip(index: number): void;
+    didFailToPlayClip(index: number): void;
+    didUpdatePlaybackProgressOfClip(index: number, to: number): void;
+    didShowPanel(): Promise<void>;
+    didHidePanel(): Promise<void>;
+    didShowOverlay(): Promise<void>;
+    didHideOverlay(): Promise<void>;
+    currentEventDoesNotSupportKeyPlays(): void;
+    getCurrentEventID(): string;
+    getCurrentlyPlayingClipIndex(): number | null;
+    getLastPlayedClipIndex(): number | null;
+    getCurrentClipPlaybackProgress(): number | null;
+    getKeyPlaysCount(): number;
+    get eventId(): Observable<string>;
+    get title(): Observable<string>;
+    get isLive(): Observable<boolean>;
+    get isShowingPanel(): boolean;
+    set isShowingPanel(value: boolean);
+}

package/dist/view-models/PanelManagerViewModel.d.ts

@@ -0,0 +1,18 @@
+import { Observable } from '../helpers/Observable';
+import { MaestroPanelType } from '../models/IPanel';
+export declare class PanelManagerViewModel {
+    private _panels;
+    private _currentPanel;
+    private _newlyFocusedPanel;
+    get panels(): MaestroPanelType[];
+    get panelsObservable(): Observable<MaestroPanelType[]>;
+    get currentPanel(): MaestroPanelType;
+    set currentPanel(value: MaestroPanelType);
+    get currentPanelObservable(): Observable<MaestroPanelType>;
+    get newlyFocusedPanel(): MaestroPanelType | null;
+    set newlyFocusedPanel(value: MaestroPanelType | null);
+    getIndex(forPanelType: MaestroPanelType): number | null;
+    getPanelType(atIndex: number): MaestroPanelType | null;
+    get panelTypeToLeft(): MaestroPanelType | null;
+    get panelTypeToRight(): MaestroPanelType | null;
+}

package/dist/view-models/ViewModel.d.ts

@@ -0,0 +1,12 @@
+import { Observable } from '../helpers/Observable';
+/**
+ * Base view model that implements reactive properties
+ */
+export declare abstract class ViewModel {
+    private _isLoading;
+    private _error;
+    get isLoading(): Observable<boolean>;
+    get error(): Observable<string | null>;
+    protected setLoading(loading: boolean): void;
+    protected setError(error: string | null): void;
+}

package/dist/view-models/index.d.ts

@@ -0,0 +1,17 @@
+import { MaestroEventViewModel } from './MaestroEventViewModel';
+import { PanelManagerViewModel } from './PanelManagerViewModel';
+import IMaestroEventDelegate from '../interfaces/IMaestroEventDelegate';
+import KeyPlaysViewModel from '../modules/key-plays/view-model/KeyPlaysViewModel';
+/**
+ * Aggregates all View Models
+ */
+export declare class MaestroViewModels {
+    readonly eventViewModel: MaestroEventViewModel;
+    readonly panelManagerViewModel: PanelManagerViewModel;
+    readonly keyPlaysViewModel: KeyPlaysViewModel;
+    constructor(eventViewModel: MaestroEventViewModel);
+    /**
+     * Creates view models from an event ID
+     */
+    static fromEventId(eventId: string, delegate: IMaestroEventDelegate): Promise<MaestroViewModels | null>;
+}