@maestro_io/maestro-web-sdk 4.0.0 → 4.0.1

package/dist/src/services/ThemeManager/constants.js

@@ -0,0 +1,47 @@
+import { BORDER_RADIUS, TEXT_CAPITALIZATION, THEME_MODES, THEME_TYPES, } from '@/models/ITheme';
+const FONT_FAMILY = 'BentonSans-Medium';
+export const DARK_THEME = {
+    _id: '6274067af74b66a544018dac',
+    button: {
+        borderRadius: BORDER_RADIUS.rounded,
+        textCapitalization: TEXT_CAPITALIZATION.uppercase,
+    },
+    colors: {
+        // Accent colors
+        accentPrimary: '#FFFFFF',
+        // Secondary accent colors
+        accentSecondary: '#3C3F47',
+        // Tertiary accent colors
+        accentTertiary: '#0C0C0E',
+        // Surface Colors
+        surface1: '#080A0C',
+        surface2: '#12141A',
+        surface3: '#1B1E26',
+        surface4: '#242833',
+        surface5: '#363C4D',
+        surface6: '#3E4759',
+        // Highlight colors
+        highlightPrimary: '#FFFFFF',
+        highlightSecondary: '#9A9EA9',
+        highlightTertiary: '#0A0C0F',
+        // Alert colors
+        alertConfirmation: '#43D48F',
+        alertWarning: '#F58B00',
+        alertError: '#FF0000',
+        // Text colors
+        text100: '#F8F9FA',
+        text200: '#C2C5CB',
+        text300: '#8D919D',
+        text400: '#5C606B',
+        text500: '#0C0C0E',
+    },
+    creator: '016901e60000000000000000',
+    name: 'Dark Mode',
+    type: THEME_TYPES.CLASSIC,
+    mode: THEME_MODES.DARK,
+    owner: '016901e60000000000000000',
+    typography: {
+        body: FONT_FAMILY,
+        headline: FONT_FAMILY,
+    },
+};

package/dist/src/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/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.d.ts

@@ -0,0 +1 @@
+export {};

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.d.ts

@@ -0,0 +1,43 @@
+import { WinningBet } from '../models/IWinningBet';
+export declare const OverlayType: {
+    readonly WinningBet: "winningBet";
+    readonly FantasyPlayerEvent: "fantasyPlayerEvent";
+};
+export type OverlayType = typeof OverlayType[keyof typeof OverlayType];
+export interface IOverlayPosition {
+    top?: number;
+    left?: number;
+    right?: number;
+    bottom?: number;
+}
+export interface IOverlaySize {
+    width: number;
+    height: number;
+}
+export interface IFantasyPayload {
+    athleteId: string;
+    title: string;
+    metadata: string;
+    headline: string;
+    description: string;
+    image?: string;
+    sportsType: string;
+}
+export interface IMaestroOverlayEvent {
+    type: OverlayType;
+    size: IOverlaySize;
+    position: IOverlayPosition;
+    winningBet?: WinningBet;
+    fantasy?: IFantasyPayload;
+}
+export interface IOverlayAnalyticsEvent {
+    eventName: 'overlayViewed' | 'overlayClicked';
+    attributes: {
+        template: string;
+        templateId?: string;
+        instanceName: string;
+        instanceId: string;
+        fullscreen?: boolean;
+        overlayType: string;
+    };
+}

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

@@ -0,0 +1,63 @@
+import IMaestroEventDelegate from '../interfaces/IMaestroEventDelegate';
+import IMaestroEvent, { TestUseCase } from '../interfaces/IMaestroEvent';
+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';
+import { IUserSettings } from '../interfaces/IUserSettings';
+import { PanelManagerViewModel } from './PanelManagerViewModel';
+import FantasyViewModel from '@/modules/fantasy/view-model/FantasyViewModel';
+import ShopViewModel from '@/modules/shop/view-model/ShopViewModel';
+export declare class MaestroEventViewModel extends ViewModel implements IMaestroEvent {
+    private _eventId;
+    private _title;
+    private _isLive;
+    private _isShowingPanel;
+    private playerTimeCode;
+    delegate: IMaestroEventDelegate;
+    keyPlaysViewModel: KeyPlaysViewModel | null;
+    fantasyViewModel: FantasyViewModel | null;
+    betsViewModel: BetsViewModel | null;
+    statsViewModel: StatsViewModel | null;
+    shopViewModel: ShopViewModel | null;
+    panelManagerViewModel: PanelManagerViewModel;
+    navigation: SpatialNavigation;
+    constructor(eventId: string | undefined, delegate: IMaestroEventDelegate);
+    setActivePanel(panelType: MaestroPanelType): void;
+    updatePlayerTimeCode(timestamp: number): void;
+    getPlayerTimeCode(): number | null;
+    setDataToPanel(panelData: Record<string, any>): void;
+    deinit(): Promise<void>;
+    updateKeyPlaysData(data: IMaestroKeyPlaysResponse | null): Promise<void>;
+    updateUserSettings(settings: IUserSettings): 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);
+    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;
+}