@maestro_io/maestro-web-sdk 2.1.2 → 2.2.0

package/dist/modules/stats/view/StatsView.d.ts

@@ -1,9 +1,9 @@
 import React, { Component } from 'react';
 import './StatsView.styles.css';
-import { StatsApiResponse } from '../interfaces/IStats';
+import { StatsItem } from '../view-model/StatsViewModel';
 interface StatsViewState {
     container: HTMLDivElement | null;
-    statsData: StatsApiResponse | null;
+    statsItems: StatsItem[];
     isDataLoading: boolean;
 }
 declare class StatsView extends Component<{}, StatsViewState> {
@@ -14,7 +14,7 @@ declare class StatsView extends Component<{}, StatsViewState> {
     constructor(props: {});
     componentDidMount(): void;
     componentWillUnmount(): void;
-    renderStatsComponents: () => React.JSX.Element | null;
+    renderItems: () => React.JSX.Element[] | null;
     render(): React.JSX.Element;
 }
 export default StatsView;

package/dist/modules/stats/view/TeamStats/TeamStatsView.d.ts

@@ -0,0 +1,52 @@
+/// <reference types="prop-types" />
+import React from 'react';
+import './TeamStatsView.styles.css';
+import { WithFocusableProps } from '@/external/spatial-navigation';
+import { TeamStatsItem } from '../../view-model/StatsViewModel';
+export interface TeamStatsViewProps {
+    item: TeamStatsItem;
+}
+declare const _default: {
+    new (props?: (TeamStatsViewProps & WithFocusableProps) | undefined, 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<TeamStatsViewProps & 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: TeamStatsViewProps & 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<TeamStatsViewProps & WithFocusableProps>;
+        context: any;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<TeamStatsViewProps & WithFocusableProps>, nextContext: any): void;
+        shouldComponentUpdate?(nextProps: Readonly<TeamStatsViewProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
+        componentWillUpdate?(nextProps: Readonly<TeamStatsViewProps & 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>;
+    };
+};
+export default _default;

package/dist/modules/stats/view/TeamStats/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './TeamStatsView';
+export type { TeamStatsViewProps } from './TeamStatsView';

package/dist/modules/stats/view/Teams/Teams.d.ts

@@ -2,29 +2,14 @@
 import React from 'react';
 import './TeamsView.styles.css';
 import { WithFocusableProps } from '@/external/spatial-navigation';
-type Team = {
-    color?: string;
-    id: string;
-    logo: string;
-    name?: string;
-    abbreviation: string;
-    record?: string;
-    linescores: string[];
-};
-export type HeaderTeamStatItem = {
-    isLive: boolean;
-    linescoresHeader: string[];
-    statistics?: {
-        displayName: string;
-        homeTeamValue: number;
-        awayTeamValue: number;
-    }[];
-    homeTeam: Team;
-    awayTeam: Team;
+import { HeaderTeamStatItem } from '../../view-model/StatsViewModel';
+type TeamsProps = {
+    item: HeaderTeamStatItem;
 };
 declare const _default: {
-    new (props?: (HeaderTeamStatItem & WithFocusableProps) | undefined, context?: any): {
+    new (props?: (TeamsProps & WithFocusableProps) | undefined, context?: any): {
         state: import("../../../../external/spatial-navigation/withFocusable").WithFocusableState;
+        navigation: import("../../../../external/spatial-navigation/spatialNavigation").default;
         getChildContext(): {
             parentFocusKey: string;
         };
@@ -42,20 +27,20 @@ declare const _default: {
         componentDidMount(): void;
         componentDidUpdate(): void;
         componentWillUnmount(): void;
-        render(): React.ReactElement<HeaderTeamStatItem & 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: HeaderTeamStatItem & 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;
+        render(): React.ReactElement<TeamsProps & 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: TeamsProps & 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<HeaderTeamStatItem & WithFocusableProps>;
+        }> & Readonly<TeamsProps & WithFocusableProps>;
         context: any;
         refs: {
             [key: string]: React.ReactInstance;
         };
         componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<HeaderTeamStatItem & WithFocusableProps>, nextContext: any): void;
-        shouldComponentUpdate?(nextProps: Readonly<HeaderTeamStatItem & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
-        componentWillUpdate?(nextProps: Readonly<HeaderTeamStatItem & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+        componentWillReceiveProps?(nextProps: Readonly<TeamsProps & WithFocusableProps>, nextContext: any): void;
+        shouldComponentUpdate?(nextProps: Readonly<TeamsProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
+        componentWillUpdate?(nextProps: Readonly<TeamsProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
     };
     contextTypes: {
         parentFocusKey: import("prop-types").Requireable<string>;

package/dist/modules/stats/view/WinProbability/WinProbability.d.ts

@@ -2,24 +2,14 @@
 import React from 'react';
 import './WinProbability.styles.css';
 import { WithFocusableProps } from '@/external/spatial-navigation';
-export type WinProbabilityStatsItem = {
-    chartImageUrl: string;
-    awayTeam: {
-        id: string;
-        abbreviation: string;
-        logo: string;
-        winPercentage: string;
-    };
-    homeTeam: {
-        id: string;
-        abbreviation: string;
-        logo: string;
-        winPercentage: string;
-    };
+import { WinProbabilityStatsItem } from '../../view-model/StatsViewModel';
+type WinProbabilityProps = {
+    item: WinProbabilityStatsItem;
 };
 declare const _default: {
-    new (props?: (WinProbabilityStatsItem & WithFocusableProps) | undefined, context?: any): {
+    new (props?: (WinProbabilityProps & WithFocusableProps) | undefined, context?: any): {
         state: import("../../../../external/spatial-navigation/withFocusable").WithFocusableState;
+        navigation: import("../../../../external/spatial-navigation/spatialNavigation").default;
         getChildContext(): {
             parentFocusKey: string;
         };
@@ -37,20 +27,20 @@ declare const _default: {
         componentDidMount(): void;
         componentDidUpdate(): void;
         componentWillUnmount(): void;
-        render(): React.ReactElement<WinProbabilityStatsItem & 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: WinProbabilityStatsItem & 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;
+        render(): React.ReactElement<WinProbabilityProps & 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: WinProbabilityProps & 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<WinProbabilityStatsItem & WithFocusableProps>;
+        }> & Readonly<WinProbabilityProps & WithFocusableProps>;
         context: any;
         refs: {
             [key: string]: React.ReactInstance;
         };
         componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<WinProbabilityStatsItem & WithFocusableProps>, nextContext: any): void;
-        shouldComponentUpdate?(nextProps: Readonly<WinProbabilityStatsItem & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
-        componentWillUpdate?(nextProps: Readonly<WinProbabilityStatsItem & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+        componentWillReceiveProps?(nextProps: Readonly<WinProbabilityProps & WithFocusableProps>, nextContext: any): void;
+        shouldComponentUpdate?(nextProps: Readonly<WinProbabilityProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
+        componentWillUpdate?(nextProps: Readonly<WinProbabilityProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
     };
     contextTypes: {
         parentFocusKey: import("prop-types").Requireable<string>;

package/dist/modules/stats/view/components/AthletesStatistics/AthletesStatistics.d.ts

@@ -1,14 +1,30 @@
 /// <reference types="prop-types" />
 import React from 'react';
 import { WithFocusableProps } from '@/external/spatial-navigation';
-import { LeaderStatsItem } from '../../GameLeaders/GameLeaders';
 import './AthleteStatistics.styles.css';
-type AthletesStatisticsProps = {
-    item: LeaderStatsItem;
+import { LeaderStatistic } from '@/modules/stats/interfaces/IStats';
+type Athlete = {
+    id: string;
+    displayName: string;
+    headshot: string;
+    position: string;
+    shortName: string;
+    jersey: string;
+    statistics: LeaderStatistic[];
+    minifiedStatistics?: string;
+};
+export type AthletesStatisticsItem = {
+    displayName?: string;
+    awayAthlete: Athlete;
+    homeAthlete: Athlete;
+};
+export type AthletesStatisticsProps = {
+    item: AthletesStatisticsItem;
 };
 declare const _default: {
     new (props?: (AthletesStatisticsProps & WithFocusableProps) | undefined, context?: any): {
         state: import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState;
+        navigation: import("../../../../../external/spatial-navigation/spatialNavigation").default;
         getChildContext(): {
             parentFocusKey: string;
         };

package/dist/modules/stats/view/components/AthletesStatistics/StatisticTable.d.ts

@@ -1,10 +1,4 @@
 import React from 'react';
-type LeadersStatisticTableProps = {
-    statistics: {
-        awayAthleteValue: string;
-        abbreviation: string;
-        homeAthleteValue: string;
-    }[];
-};
-declare const StatisticsTable: (props: LeadersStatisticTableProps) => React.JSX.Element;
+import { AthletesStatisticsProps } from './AthletesStatistics';
+declare const StatisticsTable: (props: AthletesStatisticsProps) => React.JSX.Element;
 export default StatisticsTable;

package/dist/modules/stats/view/index.d.ts

@@ -1 +1,2 @@
 export { default } from './StatsView';
+export { default as TeamStatsView } from './TeamStats';

package/dist/modules/stats/view-model/StatsViewModel.d.ts

@@ -1,14 +1,122 @@
 import { Observable } from '../../../helpers/Observable';
 import { ViewModel } from '../../../view-models/ViewModel';
-import { StatsApiResponse } from '../interfaces/IStats';
+import { DrivePlay, Team } from '../interfaces/IStats';
+import { AthletesStatisticsItem } from '../view/components/AthletesStatistics/AthletesStatistics';
+import StatsService from '@/services/StatsService';
+import IMaestroEventDelegate from '@/interfaces/IMaestroEventDelegate';
+declare const STATS_ERROR_STATE: {
+    readonly NONE: "none";
+    readonly TAB_LOAD_FAILURE: "tabLoadFailure";
+};
+export type BetsErrorState = typeof STATS_ERROR_STATE[keyof typeof STATS_ERROR_STATE];
+export type HeaderTeamStatItem = {
+    type: 'headerTeam';
+    isLive: boolean;
+    linescoresHeader: string[];
+    statistics?: {
+        displayName: string;
+        homeTeamValue: number;
+        awayTeamValue: number;
+    }[];
+    homeTeam: Pick<Team, 'color' | 'id' | 'logo' | 'name' | 'abbreviation' | 'record'> & {
+        linescores: string[];
+    };
+    awayTeam: Pick<Team, 'color' | 'id' | 'logo' | 'name' | 'abbreviation' | 'record'> & {
+        linescores: string[];
+    };
+};
+type RecentGamesPreviousGame = {
+    score: string;
+    gameResult: string;
+    teamLogo: string;
+    homeAway: string;
+};
+type RecentGamesTeam = {
+    logo: string;
+    name?: string;
+    events: RecentGamesPreviousGame[];
+};
+export type RecentGamesStatsItem = {
+    type: 'recentGames';
+    awayTeam: RecentGamesTeam;
+    homeTeam: RecentGamesTeam;
+};
+export type WinProbabilityStatsItem = {
+    type: 'winProbability';
+    chartImageUrl: string;
+    awayTeam: Pick<Team, 'id' | 'abbreviation' | 'logo'> & {
+        winPercentage: string;
+    };
+    homeTeam: Pick<Team, 'id' | 'abbreviation' | 'logo'> & {
+        winPercentage: string;
+    };
+};
+export type GameLeadersStatsItem = {
+    type: 'gameLeaders';
+    items: AthletesStatisticsItem[];
+};
+export type ActiveAthletesItem = {
+    type: 'activeAthletes';
+    displayText: string;
+    awayTeam: Pick<Team, 'id' | 'logo' | 'name'>;
+    homeTeam: Pick<Team, 'id' | 'logo' | 'name'>;
+    athletes: AthletesStatisticsItem[];
+};
+export type StatsPromotionItem = {
+    type: 'promotion';
+    title: string;
+    description: string;
+    logo: string;
+    qrCode: string;
+    backgroundImage: string;
+};
+export type StatsMatchPredictorItem = {
+    type: 'matchPredictor';
+    header: string;
+    imageUrl: string;
+    awayTeam: Pick<Team, 'abbreviation' | 'logo' | 'displayName'> & {
+        percentage: number;
+    };
+    homeTeam: Pick<Team, 'abbreviation' | 'logo' | 'displayName'> & {
+        percentage: number;
+    };
+};
+export type TeamStatsItem = {
+    type: 'teamStats';
+    awayTeam: Pick<Team, 'logo' | 'displayName' | 'color' | 'abbreviation'>;
+    homeTeam: Pick<Team, 'logo' | 'displayName' | 'color' | 'abbreviation'>;
+    statistics: {
+        displayName: string;
+        awayTeamDisplayValue: string;
+        homeTeamDisplayValue: string;
+        awayTeamValue: number;
+        homeTeamValue: number;
+    }[];
+};
+export type DriveSummaryItem = {
+    type: 'driveSummary';
+    id: string;
+    team: Pick<Team, 'logo' | 'displayName'>;
+    playsQuantity: string;
+    yards: string;
+    time: string;
+    lastPlayMarquee: string;
+    plays: DrivePlay[];
+};
+export type StatsItem = HeaderTeamStatItem | RecentGamesStatsItem | WinProbabilityStatsItem | GameLeadersStatsItem | ActiveAthletesItem | StatsPromotionItem | StatsMatchPredictorItem | TeamStatsItem | DriveSummaryItem;
 export declare class StatsViewModel extends ViewModel {
-    statsData: Observable<StatsApiResponse | null>;
     isDataLoading: Observable<boolean>;
     hasEverSuccessfullyLoaded: Observable<boolean>;
+    eventId: string;
+    statsItems: Observable<StatsItem[]>;
+    errorState: Observable<BetsErrorState>;
+    statsService: StatsService;
+    private pollingInterval;
     private useMockData;
-    initialized: boolean;
-    constructor(_eventId: string, // TODO: Will be used when implementing real API calls
-    options?: {
+    private pollingTask;
+    private lastResponseHash;
+    constructor(eventId: string, delegate: IMaestroEventDelegate, options?: {
+        pollingInterval?: number;
         useMockData?: boolean;
     });
     /**
@@ -27,5 +135,41 @@ export declare class StatsViewModel extends ViewModel {
      * Fetch mock data for testing
      */
     private fetchMockData;
+    /**
+     * Refresh polling for bet data
+     */
+    refreshPolling(): void;
+    /**
+     * Poll with the correct method based on authentication status
+     */
+    private pollWithInterval;
+    /**
+     * Handle errors that occur during polling
+     */
+    private handlePollingError;
+    /**
+     * Process data received from polling
+     */
+    private processPolledData;
+    private processData;
+    private parseDriveSummary;
+    private parseTeamsStatistics;
+    private parseMatchPredictor;
+    private parsePromotion;
+    private parseHeaderTeams;
+    private parseRecentGames;
+    private parseWinProbability;
+    private parseGameLeaders;
+    private parseActiveAthletes;
+    private getActiveAthletesTeamInfo;
+    /**
+     * Stop polling for bet data
+     */
+    stopPolling(): void;
+}
+declare global {
+    interface String {
+        hashCode(): number;
+    }
 }
 export default StatsViewModel;

package/dist/services/StatsService.d.ts

@@ -0,0 +1,36 @@
+import NetworkManager from './NetworkManager/NetworkManager';
+import { StatsApiResponse } from '../modules/stats/interfaces/IStats';
+import IMaestroEventDelegate from '@/interfaces/IMaestroEventDelegate';
+/**
+ * Service for handling stats-related API calls
+ */
+declare class StatsService {
+    networkManager: NetworkManager;
+    constructor(delegate: IMaestroEventDelegate);
+    /**
+     * Get stats for an event
+     *
+     * @param eventID - The ID of the event
+     * @param gameState - Optional game state filter (e.g., 'pre', 'in', 'post')
+     * @returns Promise with the stats data
+     */
+    getStats(eventID: string, gameState?: string): Promise<StatsApiResponse>;
+    /**
+     * Start polling for stats
+     *
+     * @param eventID - The ID of the event
+     * @param gameState - Optional game state filter (e.g., 'pre', 'in', 'post')
+     * @param interval - The polling interval in milliseconds
+     * @param onData - Callback for successful data fetch
+     * @param onError - Callback for errors
+     * @returns Object with a stop function to stop polling
+     */
+    pollStats(eventID: string, gameState: string | undefined, interval: number, onData: (data: StatsApiResponse) => void, onError?: (error: Error) => void): {
+        stop: () => void;
+    };
+    /**
+     * Get the endpoint for stats
+     */
+    statsEndpoint(eventID: string): string;
+}
+export default StatsService;

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

@@ -4,6 +4,7 @@ import { Observable } from '../helpers/Observable';
 import { ViewModel } from './ViewModel';
 import KeyPlaysViewModel from '../modules/key-plays/view-model/KeyPlaysViewModel';
 import BetsViewModel from '../modules/bets/view-model/BetsViewModel';
+import SpatialNavigation from '@/external/spatial-navigation/spatialNavigation';
 import StatsViewModel from '../modules/stats/view-model/StatsViewModel';
 import IMaestroKeyPlaysResponse from '../modules/key-plays/interfaces/IKeyPlaysResponse';
 import { MaestroPanelType } from '@/models/IPanel';
@@ -16,6 +17,7 @@ export declare class MaestroEventViewModel extends ViewModel implements IMaestro
     keyPlaysViewModel: KeyPlaysViewModel;
     betsViewModel: BetsViewModel;
     statsViewModel: StatsViewModel;
+    navigation: SpatialNavigation;
     constructor(eventId: string | undefined, delegate: IMaestroEventDelegate);
     deinit(): void;
     updateKeyPlaysData(data: IMaestroKeyPlaysResponse | null): Promise<void>;
@@ -40,4 +42,9 @@ export declare class MaestroEventViewModel extends ViewModel implements IMaestro
     get isShowingPanel(): boolean;
     set isShowingPanel(value: boolean);
     simulateUseCase<T = any>(useCase: TestUseCase, panelType: MaestroPanelType, testData?: T): void;
+    /**
+     * This method is called when the user navigates to the MaestroEventViewModel.
+     * It will pause navigation and start focus management.
+     */
+    deliverFocus(): void;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@maestro_io/maestro-web-sdk",
   "private": false,
-  "version": "2.1.2",
+  "version": "2.2.0",
   "type": "commonjs",
   "license": "MIT",
   "main": "dist/maestro-web-sdk.umd.js",

package/dist/MaestroEventDelegate.js

@@ -1,60 +0,0 @@
-import SDK from '.';
-import { KEY_PLAYS_RESPONSE_MOCK_DATA } from './modules/key-plays/constants';
-const playbackProgressIntervals = {};
-let keyPlayClipError = true;
-const allPlays = KEY_PLAYS_RESPONSE_MOCK_DATA.sections.reduce((prev, curr) => prev + curr.items.length, 0);
-/**
- * Our own implementation of the IMaestroEventDelegate interface. Useful for Development and Testing
- */
-export default class MaestroEventDelegate {
-    getBettingAPIBaseURL() {
-        return 'http://localhost:8080/espn-api';
-    }
-    userRequestedNewKeyPlaysData() {
-        throw new Error('Method not implemented.');
-    }
-    startFocusManagement() {
-        return Promise.resolve();
-    }
-    userIsAuthenticated() {
-        const swid = SDK.getClientAppSwid();
-        const appToken = SDK.getClientAppToken();
-        return Promise.resolve(Boolean(swid && appToken));
-    }
-    getUserSWID() {
-        return Promise.resolve(SDK.getClientAppSwid() || null);
-    }
-    getUserToken() {
-        return Promise.resolve(SDK.getClientAppToken() || null);
-    }
-    playClip(atIndex) {
-        Object.values(playbackProgressIntervals).forEach((interval) => {
-            clearInterval(interval);
-        });
-        // Do something with the clip index
-        const event = SDK.getMaestroEventViewModel();
-        if (atIndex === 0 && keyPlayClipError) {
-            keyPlayClipError = false;
-            event.didFailToPlayClip(atIndex);
-            this.playClip(atIndex + 1);
-            return;
-        }
-        event.didStartPlayingClip(atIndex);
-        // Simulate playback progress
-        let progress = 0;
-        playbackProgressIntervals[atIndex] = setInterval(() => {
-            progress += 0.002;
-            if (progress >= 1) {
-                clearInterval(playbackProgressIntervals[atIndex]);
-                event.didStopPlayingClip(atIndex);
-                // if index is still under allPlays boundary, play next clip
-                if (atIndex + 1 < allPlays) {
-                    return this.playClip(atIndex + 1);
-                }
-            }
-            else {
-                event.didUpdatePlaybackProgressOfClip(atIndex, progress);
-            }
-        }, 10);
-    }
-}

package/dist/components/atoms/BaseButton/BaseButton.js

@@ -1,11 +0,0 @@
-import React from 'react';
-import './BaseButton.styles.css';
-import FocusableItem from '@/components/core/ScrollableContainer/FocusableItem';
-class BaseButton extends React.Component {
-    render() {
-        const className = ['base-button', this.props.className].join(' ');
-        return (React.createElement(FocusableItem, null,
-            React.createElement("button", { ...this.props, className: className }, this.props.children)));
-    }
-}
-export default BaseButton;

package/dist/components/atoms/BaseButton/index.js

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

package/dist/components/atoms/Image/index.js

@@ -1,30 +0,0 @@
-import React from 'react';
-class Image extends React.Component {
-    constructor(props) {
-        super(props);
-        Object.defineProperty(this, "state", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {
-                failed: false,
-            }
-        });
-        Object.defineProperty(this, "handleError", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: () => {
-                this.setState({ failed: true });
-            }
-        });
-    }
-    render() {
-        if (this.state.failed) {
-            console.warn('Image failed to load:', this.props.src);
-            return null;
-        }
-        return (React.createElement("img", { alt: this.props.alt || 'Image', ...this.props, onError: this.handleError }));
-    }
-}
-export default Image;