@maestro_io/maestro-web-sdk 5.0.0 → 5.1.1

package/dist/src/services/NetworkManager/errors.js

@@ -0,0 +1,45 @@
+// Network error types
+export class NetworkError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NetworkError';
+    }
+}
+export class AuthError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AuthError';
+    }
+}
+export class NotFoundError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NotFoundError';
+    }
+}
+export class ServerError extends Error {
+    constructor(statusCode, message) {
+        super(message);
+        Object.defineProperty(this, "statusCode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = 'ServerError';
+        this.statusCode = statusCode;
+    }
+}
+export class BadRequestError extends Error {
+    constructor(statusCode, message) {
+        super(message);
+        Object.defineProperty(this, "statusCode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = 'BadRequestError';
+        this.statusCode = statusCode;
+    }
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Interface for responses that include both data and headers
+ */
+export interface ResponseWithHeaders<T> {
+    data: T;
+    headers: Record<string, string>;
+}

package/dist/src/services/NetworkManager/types.js

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

package/dist/src/services/StaticService/StaticService.d.ts

@@ -0,0 +1,20 @@
+import { Observable } from '../../helpers/Observable';
+import { GlobalConfig, PageConfig } from './types';
+type FetchPageConfigParams = {
+    siteId: string;
+    metadataValue?: string;
+    pageId?: string;
+};
+export default class StaticService {
+    configObservable: Observable<PageConfig | null>;
+    private client;
+    constructor(siteId: string);
+    private fetchPageConfigByMetadata;
+    fetchPageConfig({ siteId, metadataValue, pageId }: FetchPageConfigParams): Promise<PageConfig | null>;
+    private fetchPageConfigById;
+    static isPanelAvailable(pageConfig: PageConfig | null, panelType: string): boolean | undefined;
+    pollGlobalConfig(onData: (data: GlobalConfig) => void): {
+        stop: () => void;
+    };
+}
+export {};

package/dist/src/services/StaticService/StaticService.js

@@ -0,0 +1,85 @@
+import { Observable } from '../../helpers/Observable';
+import AxiosNetworkClient from '@/external/AxiosNetworkClient';
+import { captureException } from '@/sentry';
+import NetworkManager from '../NetworkManager/NetworkManager';
+const SITE_ID_STATIC_BASE_URL_MAP = {
+    '664b9c57d59a7a431542d814': 'https://static-prod.us-central1-espn-prod.gcp.maestro.io',
+    '6930c214fcb9633b5484de81': 'https://static-prod.us-central1-espn-prod.gcp.maestro.io',
+};
+export default class StaticService {
+    constructor(siteId) {
+        Object.defineProperty(this, "configObservable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Observable(null)
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const baseURL = SITE_ID_STATIC_BASE_URL_MAP[siteId] || 'https://static.gcp.maestro.io';
+        this.client = new NetworkManager({
+            externalNetworkClient: new AxiosNetworkClient({
+                backoff: 2,
+                baseURL,
+                delay: 1000,
+                retries: 5,
+            }),
+        });
+    }
+    async fetchPageConfigByMetadata(siteId, metadataValue) {
+        try {
+            return await this.client.externalApiRequest({
+                endpoint: `/pages/sites/${siteId}/metadata/${metadataValue}.json`,
+            });
+        }
+        catch (err) {
+            captureException(err, { siteId, metadataValue });
+            console.error(`Failed to fetch page configuration for site ${siteId} and metadata value: ${metadataValue}:`, err instanceof Error ? err.message : String(err));
+            return Promise.resolve(null);
+        }
+    }
+    fetchPageConfig({ siteId, metadataValue, pageId }) {
+        if (pageId) {
+            return this.fetchPageConfigById(siteId, pageId);
+        }
+        else if (metadataValue) {
+            return this.fetchPageConfigByMetadata(siteId, metadataValue);
+        }
+        return Promise.resolve(null);
+    }
+    async fetchPageConfigById(siteId, pageId) {
+        try {
+            return await this.client.externalApiRequest({
+                endpoint: `/pages/sites/${siteId}/pages/${pageId}.json`,
+            });
+        }
+        catch (err) {
+            captureException(err, { siteId, pageId });
+            console.error(`Failed to fetch page configuration for site ${siteId} and page ID: ${pageId}:`, err instanceof Error ? err.message : String(err));
+            return Promise.resolve(null);
+        }
+    }
+    static isPanelAvailable(pageConfig, panelType) {
+        return pageConfig?.panels?.some((panel) => panel.panel_type === panelType &&
+            panel.renderer?.supported_platforms?.bbd !== false);
+    }
+    pollGlobalConfig(onData) {
+        // random interval from 4 - 6 minutes
+        const interval = 240000 + Math.floor(Math.random() * 120000);
+        return this.client.pollExternalApiRequest({
+            endpoint: `/config/global.json`,
+            interval,
+            onData,
+            onError: (err) => {
+                captureException(err, {
+                    context: 'StaticService.pollGlobalConfig',
+                });
+                console.error(`Failed to poll global configuration`, err instanceof Error ? err.message : String(err));
+            },
+        });
+    }
+}

package/dist/src/services/StaticService/index.d.ts

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

package/dist/src/services/StaticService/index.js

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

package/dist/src/services/StaticService/mocks.d.ts

@@ -0,0 +1,3 @@
+import { PageConfig } from './types';
+export declare const MOCK_PAGE_CONFIG: PageConfig;
+export declare const MOCK_PAGE_CONFIG_NO_PANELS: PageConfig;

package/dist/src/services/StaticService/mocks.js

@@ -0,0 +1,119 @@
+// Shared page data for all mock configs
+const MOCK_PAGE = {
+    _id: '687e7d05f8d920eec4c8e924',
+    slug: '401769973-1a5f0227-a13e-396c-8cea-8961bc288666',
+    type: 'channel',
+    name: 'NHL Test Game',
+    metadata: {
+        external_field_1: '401769973',
+        external_field_2: '2512ac76-a335-39cb-af51-b9afffc6571d',
+        external_field_3: '1a5f0227-a13e-396c-8cea-8961bc288666',
+        external_field_4: 'event',
+        external_field_5: '{"leagueId":"3040"}',
+    },
+};
+const MOCK_INSIGHTS = {
+    _id: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJkIjp7Il9pZCI6IjY2NGI5YzU3ZDU5YTdhNDMxNTQyZDgxNCIsImNyZWF0ZWQiOjE3MTYyMzEyNTguOTQ3LCJzbHVnIjoiZXNwbiIsInVpZCI6InNpdGVfdG9rZW4ifSwiaWF0IjoxNzE2MjMxMjU4fQ.Qtl9F3Cvk1wASCK0sycxwQcuih1exjTngfjqhb19oQA',
+};
+const MOCK_SITE = {
+    _id: '664b9c57d59a7a431542d814',
+    domainUrl: 'www.maestro.io/espn',
+    package: {
+        version: '4.06.0',
+        id: 'maestro',
+    },
+    slug: 'mock-espn-site',
+};
+const MOCK_THEME = {
+    _id: '66db3b75f682a8c91436c8fc',
+    button: {
+        borderRadius: 'rounded',
+        textCapitalization: 'uppercase',
+    },
+    colors: {
+        accentPrimary: '#fbc010FF',
+        accentSecondary: '#AD850A',
+        accentTertiary: '#FFFFFF',
+        alertConfirmation: '#43D48F',
+        alertError: '#FF0000',
+        alertWarning: '#F4D73D',
+        highlightPrimary: '#F3F7FF',
+        highlightSecondary: '#9DA0A6',
+        highlightTertiary: '#0C0D0D',
+        surface1: '#000000',
+        surface2: '#0D0D0D',
+        surface3: '#1A1A1A',
+        surface4: '#262626',
+        surface5: '#404040',
+        surface6: '#4D4D4D',
+        text100: '#FFF2F2',
+        text200: '#CCC2C2',
+        text300: '#999191',
+        text400: '#666161',
+        text500: '#0D0C0C',
+    },
+    name: 'Landing Page',
+    siteId: '664b9c57d59a7a431542d814',
+    type: 'custom',
+    typography: {
+        body: 'helvetica-lt-std-roman',
+        headline: 'industry-demi',
+    },
+    creator: '664b9c6b70e9a56febd2dbab',
+    owner: '664b9c6b70e9a56febd2dbab',
+    created: 1725643637480,
+    modified: 1733600558188,
+    tags: [],
+};
+const MOCK_PANELS = [
+    {
+        _id: '687e7d03f8d920eec4c8e90f',
+        slug: 'panel-6879b0f23af9e9c90b42a24b-401769973-espnStats-generated',
+        panel_name: 'Stats',
+        panel_type: 'espnStats',
+        icon_name: 'stats',
+    },
+    {
+        _id: '687e7d03f8d920eec4c8e910',
+        slug: 'panel-6879b0f23af9e9c90b42a24b-401769973-espnKeyPlays-generated',
+        panel_name: 'Key Plays',
+        panel_type: 'espnKeyPlays',
+        icon_name: 'keyPlays',
+    },
+    {
+        _id: '687e7d03f8d920eec4c8e911',
+        slug: 'panel-6879b0f23af9e9c90b42a24b-401769973-espnBet-generated',
+        panel_name: 'Bets',
+        panel_type: 'espnBet',
+        icon_name: 'bets',
+    },
+    {
+        _id: '687e7d03f8d920eec4c8e912',
+        slug: 'panel-6879b0f23af9e9c90b42a24b-401769973-espnFantasy-generated',
+        panel_name: 'Fantasy',
+        panel_type: 'espnFantasy',
+        icon_name: 'fantasy',
+    },
+    {
+        _id: '687e7d03f8d920eec4c8e913',
+        slug: 'panel-6879b0f23af9e9c90b42a24b-401769973-espnShop-generated',
+        panel_name: 'Espn Shop',
+        panel_type: 'espnShop',
+        icon_name: 'espnShop',
+    },
+];
+export const MOCK_PAGE_CONFIG = {
+    panels: MOCK_PANELS,
+    page: MOCK_PAGE,
+    insights: MOCK_INSIGHTS,
+    site: MOCK_SITE,
+    theme: MOCK_THEME,
+};
+// Page config without panels for test setup (avoids view model loading)
+export const MOCK_PAGE_CONFIG_NO_PANELS = {
+    panels: [],
+    page: MOCK_PAGE,
+    insights: MOCK_INSIGHTS,
+    site: MOCK_SITE,
+    theme: MOCK_THEME,
+};

package/dist/src/services/StaticService/types.d.ts

@@ -0,0 +1,78 @@
+import { MaestroPanelType } from '@/models/IPanel';
+import ITheme from '@/models/ITheme';
+type PlatformConfig = {
+    analytics: {
+        enabled: boolean;
+        beacon_interval: number;
+    };
+};
+export interface GlobalConfig {
+    shards: string[];
+    bbd: PlatformConfig;
+}
+interface PageConfigPanel<TRendererData = unknown, TBlockData = any> {
+    _id: string;
+    slug: string;
+    panel_name?: string;
+    panel_type?: MaestroPanelType;
+    icon_name?: string;
+    renderer?: {
+        block_data?: TBlockData;
+        icon_name?: string;
+        id?: string;
+        panel_name?: string;
+        panel_type?: string;
+        supported_platforms?: {
+            android?: boolean;
+            bbd?: boolean;
+            roku?: boolean;
+            tvos?: boolean;
+        } & TRendererData;
+    };
+}
+export type PageMetadata = {
+    /**
+     * Event ID or Airing ID
+     */
+    external_field_1?: string;
+    /**
+     * Sport guid
+     */
+    external_field_2?: string;
+    /**
+     * League guid
+     */
+    external_field_3?: string;
+    /**
+     * External field 1 identifier. Can be either 'airing' or 'event'.
+     */
+    external_field_4?: 'airing' | 'event';
+    /**
+     * A stringified JSON object containing additional metadata.
+     */
+    external_field_5?: string;
+};
+export interface PageConfig {
+    panels: PageConfigPanel[];
+    page: {
+        _id: string;
+        slug: string;
+        type: string;
+        name?: string;
+        metadata?: PageMetadata;
+    };
+    insights: {
+        _id: string | null;
+    };
+    site: {
+        _id: string;
+        domainUrl: string;
+        package: {
+            version: string;
+            id: string;
+        };
+        slug: string;
+    };
+    theme?: ITheme | null;
+}
+export {};

package/dist/src/services/StaticService/types.js

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

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

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

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,158 @@
+import { Observable } from '@/helpers/Observable';
+import { DEFAULT_USER_SETTINGS, } from '@/interfaces/IUserSettings';
+import { MaestroPanelType } from '@/models/IPanel';
+const PANEL_TYPE_SETTINGS_KEY_MAP = {
+    [MaestroPanelType.ESPN_BETS]: 'bets',
+    [MaestroPanelType.ESPN_STATS]: 'stats',
+    [MaestroPanelType.ESPN_KEY_PLAYS]: 'keyPlays',
+    [MaestroPanelType.ESPN_FANTASY]: 'fantasy',
+    [MaestroPanelType.ESPN_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) {
+        if (panelType in PANEL_TYPE_SETTINGS_KEY_MAP) {
+            return PANEL_TYPE_SETTINGS_KEY_MAP[panelType];
+        }
+        return 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 {};