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

package/dist/src/services/UserSettingsManager.js

@@ -0,0 +1,155 @@
+import { Observable } from '@/helpers/Observable';
+import { DEFAULT_USER_SETTINGS, } from '@/interfaces/IUserSettings';
+import { MaestroPanelType } from '@/models/IPanel';
+const PANEL_TYPE_SETTINGS_KEY_MAP = {
+    [MaestroPanelType.BETS]: 'bets',
+    [MaestroPanelType.STATS]: 'stats',
+    [MaestroPanelType.KEY_PLAYS]: 'keyPlays',
+    [MaestroPanelType.FANTASY]: 'fantasy',
+    [MaestroPanelType.SHOP]: 'shop',
+};
+/**
+ * UserSettingsManager - Singleton service for managing user settings
+ * Uses Observable pattern for reactive updates across the SDK
+ */
+export class UserSettingsManager {
+    constructor() {
+        Object.defineProperty(this, "_settings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._settings = new Observable(DEFAULT_USER_SETTINGS);
+    }
+    /**
+     * Get the singleton instance of UserSettingsManager
+     */
+    static getInstance() {
+        if (!UserSettingsManager.instance) {
+            UserSettingsManager.instance = new UserSettingsManager();
+        }
+        return UserSettingsManager.instance;
+    }
+    /**
+     * Get the current settings as an Observable
+     */
+    get settings() {
+        return this._settings;
+    }
+    /**
+     * Get the current settings value (snapshot)
+     */
+    getCurrentSettings() {
+        return this._settings.value;
+    }
+    /**
+     * Update user settings with validation and merge logic
+     * @param userSettings - New settings to apply
+     */
+    updateSettings(userSettings) {
+        if (!this.validateSettings(userSettings)) {
+            console.warn('Invalid user settings provided, using default setting');
+            return;
+        }
+        const mergedSettings = this.mergeSettings(this._settings.value, userSettings);
+        this._settings.value = mergedSettings;
+    }
+    /**
+     * Get settings for a specific panel type
+     * @param panelType - Panel type to get settings for
+     */
+    getPanelSettings(panelType) {
+        return this._settings.value.panels?.[panelType];
+    }
+    /**
+     * Check if a panel should be hidden
+     * @param panelType - Panel type to check
+     */
+    isPanelHidden(panelType) {
+        const panelKey = this.mapPanelTypeToSettingsKey(panelType);
+        if (!panelKey)
+            return false;
+        const panelSettings = this.getPanelSettings(panelKey);
+        return panelSettings?.hidePanel === true;
+    }
+    /**
+     * Check if wagers should be hidden for betting panel
+     */
+    shouldHideWagers() {
+        const betsSettings = this.getPanelSettings('bets');
+        return betsSettings?.hideWagers === true;
+    }
+    /**
+     * Reset settings to defaults
+     */
+    resetToDefaults() {
+        this._settings.value = DEFAULT_USER_SETTINGS;
+    }
+    /**
+     * Validate settings structure and values
+     * @param settings - Settings to validate
+     */
+    validateSettings(settings) {
+        if (!settings || typeof settings !== 'object') {
+            return false;
+        }
+        // Validate panels object if present
+        if (settings.panels && typeof settings.panels !== 'object') {
+            return false;
+        }
+        // Validate individual panel settings
+        if (settings.panels) {
+            for (const [panelKey, panelSettings] of Object.entries(settings.panels)) {
+                if (panelSettings && typeof panelSettings !== 'object') {
+                    return false;
+                }
+                // Validate boolean properties
+                if (panelSettings) {
+                    for (const [key, value] of Object.entries(panelSettings)) {
+                        if (value !== undefined && typeof value !== 'boolean') {
+                            console.warn(`Invalid setting value for ${panelKey}.${key}: expected boolean, got ${typeof value}`);
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
+        return true;
+    }
+    /**
+     * Merge user settings with current settings (deep merge)
+     * @param currentSettings - Current settings
+     * @param userSettings - New settings to merge
+     */
+    mergeSettings(currentSettings, userSettings) {
+        const merged = {
+            panels: {
+                ...currentSettings.panels,
+            },
+        };
+        if (userSettings.panels) {
+            for (const [panelKey, panelSettings] of Object.entries(userSettings.panels)) {
+                if (panelSettings) {
+                    const currentPanelSettings = merged.panels[panelKey];
+                    const mergedPanelSettings = { ...currentPanelSettings };
+                    // Filter out undefined values and only merge defined ones
+                    for (const [settingKey, settingValue] of Object.entries(panelSettings)) {
+                        if (settingValue !== undefined) {
+                            mergedPanelSettings[settingKey] = settingValue;
+                        }
+                    }
+                    merged.panels[panelKey] = mergedPanelSettings;
+                }
+            }
+        }
+        return merged;
+    }
+    /**
+     * Map MaestroPanelType to settings key
+     * @param panelType - Panel type from MaestroPanelType enum
+     */
+    mapPanelTypeToSettingsKey(panelType) {
+        return PANEL_TYPE_SETTINGS_KEY_MAP[panelType] || null;
+    }
+}

package/dist/src/test-polyfills.js

@@ -0,0 +1,15 @@
+// This file must be the first import in test files
+// Handle globalThis for Node.js < 12
+if (typeof globalThis === 'undefined') {
+    global.globalThis = global;
+}
+// Polyfill for FinalizationRegistry in Node.js < 14.6.0
+const globalWithFR = globalThis;
+if (typeof globalWithFR.FinalizationRegistry === 'undefined') {
+    globalWithFR.FinalizationRegistry = class FinalizationRegistry {
+        constructor(_callback) { }
+        register(_target, _heldValue, _unregisterToken) { }
+        unregister(_unregisterToken) { }
+    };
+}
+export {};

package/dist/src/types/OverlayTypes.js

@@ -0,0 +1,4 @@
+export const OverlayType = {
+    WinningBet: 'winningBet',
+    FantasyPlayerEvent: 'fantasyPlayerEvent',
+};

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

@@ -10,7 +10,6 @@ import IMaestroKeyPlaysResponse from '../modules/key-plays/interfaces/IKeyPlaysR
 import { MaestroPanelType } from '@/models/IPanel';
 import { IUserSettings } from '../interfaces/IUserSettings';
 import { PanelManagerViewModel } from './PanelManagerViewModel';
-import AnalyticsService from '@/services/AnalyticsService/AnalyticsService';
 import FantasyViewModel from '@/modules/fantasy/view-model/FantasyViewModel';
 import ShopViewModel from '@/modules/shop/view-model/ShopViewModel';
 export declare class MaestroEventViewModel extends ViewModel implements IMaestroEvent {
@@ -27,11 +26,11 @@ export declare class MaestroEventViewModel extends ViewModel implements IMaestro
     shopViewModel: ShopViewModel | null;
     panelManagerViewModel: PanelManagerViewModel;
     navigation: SpatialNavigation;
-    analyticsService: AnalyticsService;
     constructor(eventId: string | undefined, delegate: IMaestroEventDelegate);
     setActivePanel(panelType: MaestroPanelType): void;
     updatePlayerTimeCode(timestamp: number): void;
     getPlayerTimeCode(): number | null;
+    setPanelData(panelData: Record<string, any>): void;
     deinit(): Promise<void>;
     updateKeyPlaysData(data: IMaestroKeyPlaysResponse | null): Promise<void>;
     updateUserSettings(settings: IUserSettings): Promise<void>;

package/dist/src/view-models/MaestroEventViewModel.js

@@ -0,0 +1,307 @@
+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 { UserSettingsManager } from '../services/UserSettingsManager';
+import { PanelManagerViewModel } from './PanelManagerViewModel';
+import SDK from '..';
+import StaticService from '@/services/StaticService';
+import FantasyViewModel from '@/modules/fantasy/view-model/FantasyViewModel';
+import ShopViewModel from '@/modules/shop/view-model/ShopViewModel';
+export class MaestroEventViewModel extends ViewModel {
+    constructor(eventId = '', delegate) {
+        super();
+        Object.defineProperty(this, "_eventId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Observable('')
+        });
+        Object.defineProperty(this, "_title", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Observable('')
+        });
+        Object.defineProperty(this, "_isLive", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Observable(false)
+        });
+        Object.defineProperty(this, "_isShowingPanel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Observable(false)
+        });
+        Object.defineProperty(this, "playerTimeCode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "delegate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "keyPlaysViewModel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fantasyViewModel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "betsViewModel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "statsViewModel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "shopViewModel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "panelManagerViewModel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "navigation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._eventId.value = eventId;
+        this.delegate = delegate;
+        const pageConfig = SDK.getPageConfig();
+        // Conditionally instantiate view models based on page configuration
+        this.keyPlaysViewModel = StaticService.isPanelAvailable(pageConfig, 'espnKeyPlays')
+            ? new KeyPlaysViewModel()
+            : null;
+        this.betsViewModel = StaticService.isPanelAvailable(pageConfig, 'espnBet')
+            ? new BetsViewModel(eventId, delegate)
+            : null;
+        this.statsViewModel = StaticService.isPanelAvailable(pageConfig, 'espnStats')
+            ? new StatsViewModel(eventId, delegate)
+            : null;
+        this.fantasyViewModel = StaticService.isPanelAvailable(pageConfig, 'espnFantasy')
+            ? new FantasyViewModel(eventId, delegate)
+            : null;
+        this.shopViewModel = StaticService.isPanelAvailable(pageConfig, 'espnShop')
+            ? new ShopViewModel(eventId)
+            : null;
+        this.panelManagerViewModel = new PanelManagerViewModel();
+        this.navigation = new SpatialNavigation({
+            throttle: 150,
+            throttleKeypresses: true,
+        });
+    }
+    setActivePanel(panelType) {
+        const index = this.panelManagerViewModel.getIndex(panelType);
+        if (index === null) {
+            console.warn(`Panel type "${panelType}" not found.`);
+            return;
+        }
+        if (!this.navigation.paused) {
+            console.warn('Cannot set active panel while navigation is not paused. Doing so will cause focus issues.');
+            return;
+        }
+        this.panelManagerViewModel.setActivePanel(panelType);
+        this.navigation.focusKey = `PANEL_NAV_BUTTON_${index}`;
+    }
+    updatePlayerTimeCode(timestamp) {
+        const timestampDate = new Date(timestamp);
+        if (isNaN(timestampDate.getTime())) {
+            console.warn('Invalid timestamp provided:', timestamp);
+            console.warn('Make sure the timestamp is a valid number. \nhttps://developers.maestro.io/sdk/web/maestro-event-interface/state/updatePlayerTimeCode');
+            return;
+        }
+        this.playerTimeCode = timestamp;
+        this.keyPlaysViewModel?.onUpdatePlayerTimeCode(this.playerTimeCode);
+        this.statsViewModel?.onUpdatePlayerTimeCode(this.playerTimeCode);
+    }
+    getPlayerTimeCode() {
+        return this.playerTimeCode;
+    }
+    setPanelData(panelData) {
+        const panelTypes = Object.keys(panelData);
+        // Map panel types to view model instances
+        const viewModels = {
+            espnStats: this.statsViewModel,
+            espnBet: this.betsViewModel,
+            espnKeyPlays: this.keyPlaysViewModel,
+            espnFantasy: this.fantasyViewModel,
+            espnShop: this.shopViewModel,
+        };
+        for (const panelType of panelTypes) {
+            const data = panelData[panelType];
+            if (!data)
+                continue;
+            const viewModel = viewModels[panelType];
+            if (!viewModel) {
+                // Panel is not initialized, so we ignore the data
+                console.log(`[setPanelData] Panel '${panelType}' not initialized/supported. Data ignored.`);
+            }
+            else {
+                // Panel exists, call its setPanelData method
+                if (panelType === 'espnStats' && viewModel.setPanelData) {
+                    viewModel.setPanelData(data);
+                }
+            }
+        }
+    }
+    async deinit() {
+        this.betsViewModel?.cleanup();
+        this.statsViewModel?.cleanup();
+        this.fantasyViewModel?.cleanup();
+        this.shopViewModel?.cleanup();
+        this.navigation.destroy();
+        try {
+            await this.didHidePanel();
+        }
+        catch (error) {
+            console.error('Error during didHidePanel in deinit:', error);
+        }
+    }
+    updateKeyPlaysData(data) {
+        if (!this.keyPlaysViewModel) {
+            return Promise.resolve();
+        }
+        return this.keyPlaysViewModel.setKeyPlays(data, this.playerTimeCode);
+    }
+    updateUserSettings(settings) {
+        return new Promise((resolve) => {
+            UserSettingsManager.getInstance().updateSettings(settings);
+            resolve();
+        });
+    }
+    startFocusManagement() {
+        this.navigation.setCurrentFocusedKey(this.navigation.focusKey || 'PANEL_NAV_BUTTON_0', {});
+        setTimeout(() => {
+            this.navigation.resume();
+        }, 0);
+        return Promise.resolve();
+    }
+    didStartPlayingClip(index) {
+        if (!this.keyPlaysViewModel)
+            return;
+        this.keyPlaysViewModel.lastPlayedClipIndex.value = index;
+        this.keyPlaysViewModel.currentClipPlaybackProgress.value = 0;
+        this.keyPlaysViewModel.currentlyPlayingClipIndex.value = index;
+        this.keyPlaysViewModel.clearLoadFailureStatus(index);
+    }
+    didStopPlayingClip(index) {
+        if (!this.keyPlaysViewModel)
+            return;
+        this.keyPlaysViewModel.lastPlayedClipIndex.value = index;
+        this.keyPlaysViewModel.currentlyPlayingClipIndex.value = null;
+        this.keyPlaysViewModel.currentClipPlaybackProgress.value = null;
+    }
+    didFailToPlayClip(index) {
+        this.keyPlaysViewModel?.handleKeyPlayLoadFailure(index);
+    }
+    didUpdatePlaybackProgressOfClip(index, to) {
+        if (!this.keyPlaysViewModel)
+            return;
+        this.keyPlaysViewModel.currentClipPlaybackProgress.value = to;
+        this.keyPlaysViewModel.clearLoadFailureStatus(index);
+    }
+    async didShowPanel() {
+        this.isShowingPanel = true;
+    }
+    async didHidePanel() {
+        this.isShowingPanel = false;
+        this.navigation.focusKey = null;
+    }
+    didShowOverlay() {
+        throw new Error('Method not implemented.');
+    }
+    didHideOverlay() {
+        throw new Error('Method not implemented.');
+    }
+    currentEventDoesNotSupportKeyPlays() {
+        if (this.keyPlaysViewModel) {
+            this.keyPlaysViewModel.errorState.value = 'unsupportedEvent';
+        }
+    }
+    getCurrentEventID() {
+        return this.eventId.value;
+    }
+    getCurrentlyPlayingClipIndex() {
+        return this.keyPlaysViewModel?.currentlyPlayingClipIndex.value ?? null;
+    }
+    getLastPlayedClipIndex() {
+        return this.keyPlaysViewModel?.lastPlayedClipIndex.value ?? null;
+    }
+    getCurrentClipPlaybackProgress() {
+        return this.keyPlaysViewModel?.currentClipPlaybackProgress.value ?? null;
+    }
+    getKeyPlaysCount() {
+        return this.keyPlaysViewModel?.allItems.length ?? 0;
+    }
+    get eventId() {
+        return this._eventId;
+    }
+    get title() {
+        return this._title;
+    }
+    get isLive() {
+        return this._isLive;
+    }
+    get isShowingPanel() {
+        return this._isShowingPanel.value;
+    }
+    set isShowingPanel(value) {
+        this._isShowingPanel.value = value;
+    }
+    simulateUseCase(useCase, panelType, testData) {
+        switch (panelType) {
+            case 'bets':
+                if (this.betsViewModel) {
+                    this.betsViewModel.simulateUseCase(useCase, testData);
+                }
+                else {
+                    console.warn('BetsViewModel is not initialized');
+                }
+                break;
+            case 'stats':
+                if (this.statsViewModel) {
+                    this.statsViewModel.simulateUseCase(useCase, testData);
+                }
+                else {
+                    console.warn('StatsViewModel is not initialized');
+                }
+                break;
+            default:
+                throw new Error(`Unsupported panel type: ${panelType}`);
+        }
+    }
+    /**
+     * This method is called when the user navigates to the MaestroEventViewModel.
+     * It will pause navigation and start focus management.
+     */
+    deliverFocus() {
+        this.navigation.pause();
+        this.delegate.startFocusManagement();
+    }
+}