@maestro_io/maestro-web-sdk 2.2.0 → 2.2.1

package/dist/modules/bets/view/BetsView.d.ts

@@ -1,23 +1,27 @@
 import React, { Component } from 'react';
 import './BetsView.styles.css';
 import { BetItem, BetsErrorState } from '../view-model/BetsViewModel';
+import { Direction } from '@/external/spatial-navigation/utils';
 interface BetsViewState {
     container: HTMLDivElement | null;
     betsItems: BetItem[];
     isDataLoading: boolean;
     errorState: BetsErrorState;
+    hideWagers: boolean;
 }
 declare class BetsView extends Component<{}, BetsViewState> {
     private container;
     private betsItemsUnsub;
     private isDataLoadingUnsub;
     private errorStateUnsub;
+    private hideWagersUnsub;
     private vm;
     constructor(props: {});
     componentDidMount(): void;
     componentWillUnmount(): void;
     renderBetItem: (item: BetItem) => React.JSX.Element | null;
     clearTabLoadFailure: () => void;
+    onArrowPress: (d: Direction) => void;
     render(): React.JSX.Element;
 }
 export default BetsView;

package/dist/modules/bets/view/UserBets/BetsCard/BetsCard.d.ts

@@ -7,6 +7,7 @@ export declare const EVENTS_COUNT_THRESHOLD = 3;
 export type BaseBetCardProps = {
     bet: IUserBet;
     renderHeaderContent?: (props: WithFocusableProps) => React.ReactNode;
+    hideWagers?: boolean;
 };
 declare const _default: {
     new (props?: (BaseBetCardProps & WithFocusableProps) | undefined, context?: any): {

package/dist/modules/bets/view/UserBets/BetsCard/BetsCardEvent.d.ts

@@ -10,6 +10,7 @@ type BetsCardEventProps = {
     betType: string;
     onBetArrowPress: (eventIndex: number, legIndex: number) => (direction: Direction, props: any, details: Details) => void;
     onBetBackPress: () => void;
+    hideWagers?: boolean;
 };
 declare class BetsCardEvent extends React.Component<BetsCardEventProps> {
     static contextTypes: {

package/dist/modules/bets/view/UserBets/BetsCard/BetsCardFooter.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 import { IUserBet } from '@/modules/bets/interfaces/IBets';
 type BetsCardFooterProps = {
     bet: IUserBet;
+    hideWagers?: boolean;
 };
-declare const BetsCardFooter: (props: BetsCardFooterProps) => React.JSX.Element;
+declare const BetsCardFooter: (props: BetsCardFooterProps) => React.JSX.Element | null;
 export default BetsCardFooter;

package/dist/modules/bets/view/UserBets/Boost/Boost.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 import { IUserBet } from '@/modules/bets/interfaces/IBets';
 type BoostProps = {
     bet: IUserBet;
+    hideWagers?: boolean;
 };
-declare const Boost: ({ bet }: BoostProps) => React.JSX.Element;
+declare const Boost: ({ bet, hideWagers }: BoostProps) => React.JSX.Element;
 export default Boost;

package/dist/modules/bets/view/UserBets/Parlay/Parlay.d.ts

@@ -3,6 +3,7 @@ import './Parlay.styles.css';
 import { IUserBet } from '@/modules/bets/interfaces/IBets';
 type ParlayProps = {
     bet: IUserBet;
+    hideWagers?: boolean;
 };
-declare const Parlay: ({ bet }: ParlayProps) => React.JSX.Element;
+declare const Parlay: ({ bet, hideWagers }: ParlayProps) => React.JSX.Element;
 export default Parlay;

package/dist/modules/bets/view/UserBets/Straight/Straight.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 import { IUserBet } from '@/modules/bets/interfaces/IBets';
 type StraightProps = {
     bet: IUserBet;
+    hideWagers?: boolean;
 };
-declare const Straight: ({ bet }: StraightProps) => React.JSX.Element;
+declare const Straight: ({ bet, hideWagers }: StraightProps) => React.JSX.Element;
 export default Straight;

package/dist/modules/bets/view/UserBets/Teaser/Teaser.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 import { IUserBet } from '@/modules/bets/interfaces/IBets';
 type TeaserProps = {
     bet: IUserBet;
+    hideWagers?: boolean;
 };
-declare const Teaser: ({ bet }: TeaserProps) => React.JSX.Element;
+declare const Teaser: ({ bet, hideWagers }: TeaserProps) => React.JSX.Element;
 export default Teaser;

package/dist/modules/bets/view/components/Bet/Bet.d.ts

@@ -6,6 +6,7 @@ import { IBetLeg } from '@/modules/bets/interfaces/IBets';
 declare const _default: {
     new (props?: ({
         leg: IBetLeg;
+        hideWagers?: boolean | undefined;
     } & WithFocusableProps) | undefined, context?: any): {
         state: import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState;
         navigation: import("../../../../../external/spatial-navigation/spatialNavigation").default;
@@ -28,15 +29,18 @@ declare const _default: {
         componentWillUnmount(): void;
         render(): React.ReactElement<{
             leg: IBetLeg;
+            hideWagers?: boolean | undefined;
         } & 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: {
             leg: IBetLeg;
+            hideWagers?: boolean | undefined;
         } & 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<{
             leg: IBetLeg;
+            hideWagers?: boolean | undefined;
         } & WithFocusableProps>;
         context: any;
         refs: {
@@ -45,12 +49,15 @@ declare const _default: {
         componentWillMount?(): void;
         componentWillReceiveProps?(nextProps: Readonly<{
             leg: IBetLeg;
+            hideWagers?: boolean | undefined;
         } & WithFocusableProps>, nextContext: any): void;
         shouldComponentUpdate?(nextProps: Readonly<{
             leg: IBetLeg;
+            hideWagers?: boolean | undefined;
         } & WithFocusableProps>, nextState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
         componentWillUpdate?(nextProps: Readonly<{
             leg: IBetLeg;
+            hideWagers?: boolean | undefined;
         } & WithFocusableProps>, nextState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
     };
     contextTypes: {

package/dist/modules/bets/view-model/BetsViewModel.d.ts

@@ -74,16 +74,19 @@ export type SixPackBetItem = {
         away: ITeam;
     };
     id: string;
+    hideWagers: boolean;
 };
 export type UserBetsBetItem = {
     type: 'userBets';
     data: IUserBets;
     id: string;
+    hideWagers: boolean;
 };
 export type HotPropsBetItem = {
     type: 'hotProps';
     data: IHotProps;
     id: string;
+    hideWagers: boolean;
 };
 export type BetItem = SixPackBetItem | UserBetsBetItem | PromoBetItem | HotPropsBetItem | LocationDisclaimerBetItem | GamblingMessageBetItem;
 declare const BET_ERROR_STATE: {
@@ -101,6 +104,7 @@ export declare class BetsViewModel extends ViewModel {
     isDataLoading: Observable<boolean>;
     errorState: Observable<BetsErrorState>;
     hasEverSuccessfullyLoaded: Observable<boolean>;
+    hideWagers: Observable<boolean>;
     private eventId;
     private delegate;
     private betsService;
@@ -109,6 +113,8 @@ export declare class BetsViewModel extends ViewModel {
     private lastNonPersonalizedResponseHash;
     private lastPersonalizedResponseHash;
     private useMockData;
+    private userSettingsManager;
+    private settingsSubscription;
     initialized: boolean;
     constructor(eventId: string, delegate: IMaestroEventDelegate, options?: {
         pollingInterval?: number;
@@ -170,6 +176,15 @@ export declare class BetsViewModel extends ViewModel {
     private fetchMockData;
     simulateUseCase<T = any>(useCase: TestUseCase, _: T): void;
     clearTabLoadFailure(): void;
+    /**
+     * Check if wagers should be hidden based on user settings
+     */
+    shouldHideWagers(): boolean;
+    /**
+     * Update hideWagers Observable from current settings (reactive approach)
+     */
+    private updateHideWagersFromSettings;
+    private refreshBetItemsWithNewSettings;
 }
 declare global {
     interface String {

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

@@ -9,6 +9,7 @@ export default interface IKeyPlay {
     teamImageUrl?: string;
     playerImageUrl?: string;
     thumbnailImageUrl?: string;
+    wallClock?: string;
     section?: string;
 }
 export declare const KEY_PLAYS_LOAD_FAILURE_STATUS: {

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

@@ -29,12 +29,12 @@ interface MaestroKeyPlaysSection {
 }
 interface MaestroKeyPlay {
     description: string;
-    team: string;
-    wallClock: string;
-    displayClock: string;
-    shortPeriod: string;
-    scoringPlay: boolean;
-    athlete: string;
+    team?: string;
+    wallClock?: string;
+    displayClock?: string;
+    shortPeriod?: string;
+    scoringPlay?: boolean;
+    athlete?: string;
     thumbnail: string;
     thumbnailType: string;
     clipID: string;

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

@@ -10,17 +10,20 @@ type KeyPlayCardViewProps = IKeyPlay & {
 };
 type KeyPlaysCardViewState = {
     failedClip: KeyPlayLoadFailureStatus | null;
+    imageLoaded: boolean;
 };
 export declare class KeyPlayCardView extends React.Component<KeyPlayCardViewProps & WithFocusableProps, KeyPlaysCardViewState> {
     private failedClipListener;
     private vm;
     state: {
         failedClip: null;
+        imageLoaded: boolean;
     };
     constructor(props: KeyPlayCardViewProps);
     componentDidMount(): void;
     componentWillUnmount(): void;
-    renderImage: () => React.JSX.Element;
+    onLoad: () => void;
+    renderImage: () => React.JSX.Element | null;
     render(): React.JSX.Element;
 }
 export default class KeyPlayCard extends React.Component<Omit<KeyPlayCardViewProps, 'setRef'> & WithFocusableProps> {

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

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

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

@@ -14,8 +14,12 @@ declare class KeyPlaysViewModel {
         [key: string]: KeyPlayLoadFailureStatus;
     }>;
     items: Observable<KeyPlayItem[]>;
+    filteredItems: Observable<KeyPlayItem[]>;
+    onUpdatePlayerTimeCode(playerTimeCode: number | null): void;
+    private filterItemsByPlayerTimeCode;
+    private shouldShowKeyPlay;
     isCurrentlyPlaying(index: number): boolean;
-    setKeyPlays(items: IMaestroKeyPlaysResponse | null): Promise<void>;
+    setKeyPlays(items: IMaestroKeyPlaysResponse | null, playerTimeCode: number | null): Promise<void>;
     private cleanErrors;
     playKeyPlay(atIndex: number): Promise<void>;
     parseNetworkResponse(response: IMaestroKeyPlaysResponse): KeyPlayItem[];

package/dist/services/BetsService.d.ts

@@ -1,11 +1,11 @@
-import NetworkManager from './NetworkManager/NetworkManager';
+import { IBetsNetworkManager } from './NetworkManager/types';
 import { IBetsResponse, IPersonalizedBetsResponse } from '../modules/bets/interfaces/IBets';
 import IMaestroEventDelegate from '@/interfaces/IMaestroEventDelegate';
 /**
  * Service for handling bets-related API calls
  */
 declare class BetsService {
-    networkManager: NetworkManager;
+    networkManager: IBetsNetworkManager;
     constructor(delegate: IMaestroEventDelegate);
     /**
      * Get non-personalized bets for an event

package/dist/services/NetworkManager/NetworkManager.d.ts

@@ -30,15 +30,13 @@ export interface NetworkManagerOptions {
     defaultCacheDuration?: number;
 }
 declare class NetworkManager {
-    private static instance;
     private cacheManager;
     private maestroClient;
     private externalClient;
     private environment;
     private pollingTasks;
     private localStorage;
-    private constructor();
-    static getInstance(options?: NetworkManagerOptions, localStorageOverride?: Storage): NetworkManager;
+    constructor(options?: NetworkManagerOptions, localStorageOverride?: Storage);
     /**
      * Sets the working environment (development, staging, production)
      */

package/dist/services/NetworkManager/NetworkManagerFactory.d.ts

@@ -0,0 +1,42 @@
+import NetworkManager, { NetworkManagerOptions } from './NetworkManager';
+import { ServiceType, ServiceNetworkManagerConfig, IStatsNetworkManager, IBetsNetworkManager, IMaestroNetworkManager, NetworkManagerFactoryConfig } from './types';
+/**
+ * Service-specific NetworkManager that includes metadata about its service type
+ */
+declare class ServiceNetworkManager extends NetworkManager {
+    readonly serviceType: ServiceType;
+    readonly externalBaseURL: string;
+    constructor(serviceType: ServiceType, externalBaseURL: string, options?: NetworkManagerOptions, localStorageOverride?: Storage);
+}
+/**
+ * Factory for creating service-specific NetworkManager instances
+ * This replaces the singleton pattern with a factory pattern
+ */
+export declare class NetworkManagerFactory {
+    private static defaultConfig;
+    /**
+     * Configure factory defaults
+     */
+    static configure(config: NetworkManagerFactoryConfig): void;
+    /**
+     * Create a Stats service NetworkManager
+     */
+    static createStatsNetworkManager(externalBaseURL: string, options?: Partial<NetworkManagerOptions>): IStatsNetworkManager;
+    /**
+     * Create a Bets service NetworkManager
+     */
+    static createBetsNetworkManager(externalBaseURL: string, options?: Partial<NetworkManagerOptions>): IBetsNetworkManager;
+    /**
+     * Create a Maestro service NetworkManager
+     */
+    static createMaestroNetworkManager(options?: Partial<NetworkManagerOptions>): IMaestroNetworkManager;
+    /**
+     * Create a NetworkManager for any service type
+     */
+    static createForService(config: ServiceNetworkManagerConfig, options?: Partial<NetworkManagerOptions>): ServiceNetworkManager;
+    /**
+     * Reset factory to defaults (useful for testing)
+     */
+    static reset(): void;
+}
+export default NetworkManagerFactory;

package/dist/services/NetworkManager/types.d.ts

@@ -0,0 +1,77 @@
+import { WorkingEnvironment } from './NetworkManager';
+/**
+ * Service types for different NetworkManager contexts
+ */
+export declare const ServiceType: {
+    readonly STATS: "stats";
+    readonly BETS: "bets";
+    readonly MAESTRO: "maestro";
+};
+export type ServiceType = typeof ServiceType[keyof typeof ServiceType];
+/**
+ * Configuration for creating service-specific NetworkManager instances
+ */
+export interface ServiceNetworkManagerConfig {
+    serviceType: ServiceType;
+    externalBaseURL: string;
+    environment?: WorkingEnvironment;
+    defaultCacheDuration?: number;
+}
+/**
+ * Base interface for all NetworkManager instances
+ */
+export interface IServiceNetworkManager {
+    readonly serviceType: ServiceType;
+    readonly externalBaseURL: string;
+    getEnvironment(): WorkingEnvironment;
+    externalApiRequest<T = any>(options: {
+        endpoint: string;
+        method?: string;
+        params?: Record<string, any>;
+        headers?: Record<string, string>;
+        data?: any;
+        useCache?: boolean;
+        skipResponseBodyDeserialization?: boolean;
+    }): Promise<T>;
+    pollExternalApiRequest<T = any>(options: {
+        endpoint: string;
+        interval: number;
+        method?: string;
+        params?: Record<string, any>;
+        headers?: Record<string, string>;
+        data?: any;
+        onData: (data: T) => void;
+        onError?: (error: Error) => void;
+    }): {
+        stop: () => void;
+    };
+}
+/**
+ * Stats service NetworkManager interface
+ */
+export interface IStatsNetworkManager extends IServiceNetworkManager {
+    serviceType: 'stats';
+}
+/**
+ * Bets service NetworkManager interface
+ */
+export interface IBetsNetworkManager extends IServiceNetworkManager {
+    serviceType: 'bets';
+}
+/**
+ * Maestro service NetworkManager interface
+ */
+export interface IMaestroNetworkManager extends IServiceNetworkManager {
+    serviceType: 'maestro';
+}
+/**
+ * Union type for all service NetworkManager types
+ */
+export type ServiceNetworkManager = IStatsNetworkManager | IBetsNetworkManager | IMaestroNetworkManager;
+/**
+ * Factory configuration for different service types
+ */
+export interface NetworkManagerFactoryConfig {
+    environment?: WorkingEnvironment;
+    defaultCacheDuration?: number;
+}

package/dist/services/StatsService.d.ts

@@ -1,11 +1,11 @@
-import NetworkManager from './NetworkManager/NetworkManager';
+import { IStatsNetworkManager } from './NetworkManager/types';
 import { StatsApiResponse } from '../modules/stats/interfaces/IStats';
 import IMaestroEventDelegate from '@/interfaces/IMaestroEventDelegate';
 /**
  * Service for handling stats-related API calls
  */
 declare class StatsService {
-    networkManager: NetworkManager;
+    networkManager: IStatsNetworkManager;
     constructor(delegate: IMaestroEventDelegate);
     /**
      * Get stats for an event

package/dist/services/UserSettingsManager.d.ts

@@ -0,0 +1,63 @@
+import { Observable } from '@/helpers/Observable';
+import { IUserSettings, PanelSettings } from '@/interfaces/IUserSettings';
+import { MaestroPanelType } from '@/models/IPanel';
+/**
+ * UserSettingsManager - Singleton service for managing user settings
+ * Uses Observable pattern for reactive updates across the SDK
+ */
+export declare class UserSettingsManager {
+    private static instance;
+    private _settings;
+    private constructor();
+    /**
+     * Get the singleton instance of UserSettingsManager
+     */
+    static getInstance(): UserSettingsManager;
+    /**
+     * Get the current settings as an Observable
+     */
+    get settings(): Observable<IUserSettings>;
+    /**
+     * Get the current settings value (snapshot)
+     */
+    getCurrentSettings(): IUserSettings;
+    /**
+     * Update user settings with validation and merge logic
+     * @param userSettings - New settings to apply
+     */
+    updateSettings(userSettings: IUserSettings): void;
+    /**
+     * Get settings for a specific panel type
+     * @param panelType - Panel type to get settings for
+     */
+    getPanelSettings<T extends keyof NonNullable<IUserSettings['panels']>>(panelType: T): PanelSettings<T> | undefined;
+    /**
+     * Check if a panel should be hidden
+     * @param panelType - Panel type to check
+     */
+    isPanelHidden(panelType: MaestroPanelType): boolean;
+    /**
+     * Check if wagers should be hidden for betting panel
+     */
+    shouldHideWagers(): boolean;
+    /**
+     * Reset settings to defaults
+     */
+    resetToDefaults(): void;
+    /**
+     * Validate settings structure and values
+     * @param settings - Settings to validate
+     */
+    private validateSettings;
+    /**
+     * Merge user settings with current settings (deep merge)
+     * @param currentSettings - Current settings
+     * @param userSettings - New settings to merge
+     */
+    private mergeSettings;
+    /**
+     * Map MaestroPanelType to settings key
+     * @param panelType - Panel type from MaestroPanelType enum
+     */
+    private mapPanelTypeToSettingsKey;
+}

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

@@ -8,19 +8,24 @@ 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';
+import { IUserSettings } from '../interfaces/IUserSettings';
 export declare class MaestroEventViewModel extends ViewModel implements IMaestroEvent {
     private _eventId;
     private _title;
     private _isLive;
     private _isShowingPanel;
+    private playerTimeCode;
     delegate: IMaestroEventDelegate;
     keyPlaysViewModel: KeyPlaysViewModel;
     betsViewModel: BetsViewModel;
     statsViewModel: StatsViewModel;
     navigation: SpatialNavigation;
     constructor(eventId: string | undefined, delegate: IMaestroEventDelegate);
+    updatePlayerTimeCode(timestamp: number): void;
+    getPlayerTimeCode(): number | null;
     deinit(): void;
     updateKeyPlaysData(data: IMaestroKeyPlaysResponse | null): Promise<void>;
+    updateUserSettings(settings: IUserSettings): Promise<void>;
     startFocusManagement(): Promise<void>;
     didStartPlayingClip(index: number): void;
     didStopPlayingClip(index: number): void;

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

@@ -4,6 +4,30 @@ export declare class PanelManagerViewModel {
     private _panels;
     private _currentPanel;
     private _newlyFocusedPanel;
+    private settingsManager;
+    private settingsUnsubscribe;
+    private readonly ALL_PANELS;
+    constructor();
+    /**
+     * Initialize panels based on current settings
+     */
+    private initializePanels;
+    /**
+     * Subscribe to settings changes to update panels dynamically
+     */
+    private subscribeToSettingsChanges;
+    /**
+     * Filter panels based on user settings
+     */
+    private filterPanelsBasedOnSettings;
+    /**
+     * Update panels when settings change
+     */
+    private updatePanelsBasedOnSettings;
+    /**
+     * Cleanup subscriptions
+     */
+    cleanup(): void;
     get panels(): MaestroPanelType[];
     get panelsObservable(): Observable<MaestroPanelType[]>;
     get currentPanel(): MaestroPanelType;

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

@@ -12,6 +12,10 @@ export declare class MaestroViewModels {
     readonly keyPlaysViewModel: KeyPlaysViewModel;
     readonly overlayViewModel: OverlayViewModel;
     constructor(eventViewModel: MaestroEventViewModel);
+    /**
+     * Cleanup all view models
+     */
+    cleanup(): void;
     /**
      * Creates view models from an event ID
      */

package/package.json

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