@maestro_io/maestro-web-sdk 4.0.0 → 4.0.1

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

@@ -0,0 +1,103 @@
+/**
+ * Service types for different NetworkManager contexts
+ */
+export declare const ServiceType: {
+    readonly STATS: "stats";
+    readonly BETS: "bets";
+    readonly MAESTRO: "maestro";
+    readonly FANTASY: "fantasy";
+    readonly SHOP: "shop";
+};
+export type ServiceType = typeof ServiceType[keyof typeof ServiceType];
+/**
+ * Configuration for creating service-specific NetworkManager instances
+ */
+export interface ServiceNetworkManagerConfig {
+    serviceType: ServiceType;
+    externalBaseURL: string;
+    defaultCacheDuration?: number;
+}
+/**
+ * Base interface for all NetworkManager instances
+ */
+export interface IServiceNetworkManager {
+    readonly serviceType: ServiceType;
+    readonly externalBaseURL: string;
+    externalApiRequest<T = any>(options: {
+        endpoint: string;
+        method?: string;
+        params?: Record<string, any>;
+        headers?: Record<string, string>;
+        data?: any;
+        useCache?: boolean;
+        skipResponseBodyDeserialization?: boolean;
+    }): Promise<T>;
+    externalApiRequestWithHeaders<T = any>(options: {
+        endpoint: string;
+        method?: string;
+        params?: Record<string, any>;
+        headers?: Record<string, string>;
+        data?: any;
+        useCache?: boolean;
+        skipResponseBodyDeserialization?: boolean;
+    }): Promise<ResponseWithHeaders<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;
+    };
+    pollExternalApiRequestWithHeaders<T = any>(options: {
+        endpoint: string;
+        interval: number;
+        method?: string;
+        params?: Record<string, any>;
+        headers?: Record<string, string>;
+        data?: any;
+        onData: (data: ResponseWithHeaders<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 {
+    defaultCacheDuration?: number;
+}
+/**
+ * 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,10 @@
+/**
+ * Service types for different NetworkManager contexts
+ */
+export const ServiceType = {
+    STATS: 'stats',
+    BETS: 'bets',
+    MAESTRO: 'maestro',
+    FANTASY: 'fantasy',
+    SHOP: 'shop',
+};

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

@@ -0,0 +1,23 @@
+import NetworkManager from './NetworkManager/NetworkManager';
+import { IShopResponse } from '../modules/shop/types';
+import { ResponseWithHeaders } from './NetworkManager/types';
+/**
+ * Service for handling shop-related API calls
+ */
+declare class ShopService {
+    networkManager: NetworkManager;
+    private eventId;
+    constructor(eventId: string);
+    /**
+     * Start polling shop data
+     *
+     * @param interval - The polling interval in milliseconds
+     * @param onData - Callback for successful data fetch with headers
+     * @param onError - Callback for errors
+     * @returns Object with a stop function to stop polling
+     */
+    pollShopData(interval: number, onData: (data: ResponseWithHeaders<IShopResponse>) => void, onError?: (error: Error) => void): {
+        stop: () => void;
+    };
+}
+export default ShopService;

package/dist/src/services/ShopService.js

@@ -0,0 +1,46 @@
+import { HttpMethod } from './NetworkManager/NetworkManager';
+import NetworkManagerFactory from './NetworkManager/NetworkManagerFactory';
+/**
+ * Service for handling shop-related API calls
+ */
+class ShopService {
+    constructor(eventId) {
+        Object.defineProperty(this, "networkManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "eventId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.eventId = eventId;
+        this.networkManager = NetworkManagerFactory.createForService({
+            externalBaseURL: 'https://site.api.espn.com',
+            serviceType: 'shop',
+        });
+    }
+    /**
+     * Start polling shop data
+     *
+     * @param interval - The polling interval in milliseconds
+     * @param onData - Callback for successful data fetch with headers
+     * @param onError - Callback for errors
+     * @returns Object with a stop function to stop polling
+     */
+    pollShopData(interval, onData, onError) {
+        return this.networkManager.pollExternalApiRequestWithHeaders({
+            endpoint: `/apis/site/v2/events/${this.eventId}/shop`,
+            interval,
+            method: HttpMethod.GET,
+            params: {},
+            headers: {},
+            onData,
+            onError,
+        });
+    }
+}
+export default ShopService;

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

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

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

@@ -0,0 +1,59 @@
+import { Observable } from '../../helpers/Observable';
+import AxiosNetworkClient from '@/external/AxiosNetworkClient';
+import { captureException } from '@/sentry';
+import NetworkManager from '../NetworkManager/NetworkManager';
+export default class StaticService {
+    constructor() {
+        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
+        });
+        this.client = new NetworkManager({
+            externalNetworkClient: new AxiosNetworkClient({
+                backoff: 2,
+                baseURL: 'https://static-prod.us-central1-espn-prod.gcp.maestro.io',
+                delay: 1000,
+                retries: 5,
+            }),
+        });
+    }
+    fetchPageConfig(siteId, eventId) {
+        try {
+            return this.client.externalApiRequest({
+                endpoint: `/pages/sites/${siteId}/metadata/${eventId}.json`,
+            });
+        }
+        catch (err) {
+            captureException(err, { siteId, eventId });
+            console.error(`Failed to fetch page configuration for site ${siteId} and event ${eventId}:`, 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,2 @@
+import { PageConfig } from './types';
+export declare const MOCK_PAGE_CONFIG: PageConfig;

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

@@ -0,0 +1,104 @@
+export const MOCK_PAGE_CONFIG = {
+    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',
+        },
+    ],
+    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"}',
+        },
+    },
+    insights: {
+        _id: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJkIjp7Il9pZCI6IjY2NGI5YzU3ZDU5YTdhNDMxNTQyZDgxNCIsImNyZWF0ZWQiOjE3MTYyMzEyNTguOTQ3LCJzbHVnIjoiZXNwbiIsInVpZCI6InNpdGVfdG9rZW4ifSwiaWF0IjoxNzE2MjMxMjU4fQ.Qtl9F3Cvk1wASCK0sycxwQcuih1exjTngfjqhb19oQA',
+    },
+    site: {
+        _id: '664b9c57d59a7a431542d814',
+        domainUrl: 'www.maestro.io/espn',
+        package: {
+            version: '4.06.0',
+            id: 'maestro',
+        },
+    },
+    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: [],
+    },
+};

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

@@ -0,0 +1,76 @@
+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?: string;
+    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;
+        };
+    };
+    theme?: ITheme | null;
+}
+export {};

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

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

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

@@ -0,0 +1,46 @@
+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: IStatsNetworkManager;
+    overrideUrl: string | null;
+    constructor(delegate: IMaestroEventDelegate);
+    /**
+     * Get stats using a full sync URL (for timecode support)
+     *
+     * @param timeCode - The timecode in milliseconds, or null for 'latest'
+     * @returns Promise with the stats data
+     */
+    getStatsByUrl(timeCode: number | null): Promise<StatsApiResponse>;
+    /**
+     * Start polling using a full sync URL (for timecode support)
+     *
+     * @param timeCode - The timecode in milliseconds, or null for 'latest'
+     * @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
+     */
+    pollStatsByUrl(timeCode: number | null, interval: number, onData: (data: StatsApiResponse) => void, onError?: (error: Error) => void): {
+        stop: () => void;
+    };
+    /**
+     * Build sync URL for timecode-based stats fetching with enhanced logging
+     * Enhanced with comprehensive validation and fallback strategies
+     *
+     * @param timeCode - The timecode in milliseconds, or null for 'latest'
+     * @returns Complete sync URL for the fauxcast stats endpoint
+     * @throws Error if page config is not available or required fields are missing
+     */
+    private getSyncEndpoint;
+    /**
+     * Format timecode for API consumption
+     * @param timeCode - Timecode in milliseconds or null
+     * @returns ISO date string, "pre.json" for pre-game, or "latest" for post-game
+     */
+    private formatTimeCodeForAPI;
+}
+export default StatsService;

package/dist/src/services/StatsService.js

@@ -0,0 +1,147 @@
+import { HttpMethod } from './NetworkManager/NetworkManager';
+import NetworkManagerFactory from './NetworkManager/NetworkManagerFactory';
+import SDK from '..';
+import { captureException } from '@/sentry';
+/**
+ * Service for handling stats-related API calls
+ */
+class StatsService {
+    constructor(delegate) {
+        Object.defineProperty(this, "networkManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "overrideUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.networkManager = NetworkManagerFactory.createStatsNetworkManager(delegate.getStatsAPIBaseURL());
+    }
+    /**
+     * Get stats using a full sync URL (for timecode support)
+     *
+     * @param timeCode - The timecode in milliseconds, or null for 'latest'
+     * @returns Promise with the stats data
+     */
+    async getStatsByUrl(timeCode) {
+        return this.networkManager.externalApiRequest({
+            endpoint: this.getSyncEndpoint(timeCode),
+            method: HttpMethod.GET,
+            params: {},
+            headers: {},
+        });
+    }
+    /**
+     * Start polling using a full sync URL (for timecode support)
+     *
+     * @param timeCode - The timecode in milliseconds, or null for 'latest'
+     * @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
+     */
+    pollStatsByUrl(timeCode, interval, onData, onError) {
+        return this.networkManager.pollExternalApiRequest({
+            endpoint: this.getSyncEndpoint(timeCode),
+            interval,
+            method: HttpMethod.GET,
+            params: {},
+            headers: {},
+            onData,
+            onError,
+        });
+    }
+    /**
+     * Build sync URL for timecode-based stats fetching with enhanced logging
+     * Enhanced with comprehensive validation and fallback strategies
+     *
+     * @param timeCode - The timecode in milliseconds, or null for 'latest'
+     * @returns Complete sync URL for the fauxcast stats endpoint
+     * @throws Error if page config is not available or required fields are missing
+     */
+    getSyncEndpoint(timeCode) {
+        // Apply overrideUrl if set
+        if (this.overrideUrl) {
+            console.log('[StatsService] Using overrideUrl:', this.overrideUrl);
+            return this.overrideUrl;
+        }
+        const pageConfig = SDK.getPageConfig();
+        if (!pageConfig) {
+            throw new Error('Page config is null or undefined');
+        }
+        const metadata = pageConfig.page.metadata;
+        if (!metadata?.external_field_1 || !metadata?.external_field_5) {
+            throw new Error('Missing eventId or leagueId in page config metadata. Cannot build sync URL. ' +
+                `Required fields: external_field_1 (eventId), external_field_5 (leagueId). Available fields: ${Object.keys(metadata || {}).join(', ')}`);
+        }
+        const eventId = metadata.external_field_1;
+        let leagueId;
+        try {
+            if (metadata.external_field_5) {
+                const leagueData = JSON.parse(metadata.external_field_5);
+                leagueId = leagueData.leagueId;
+                if (!leagueId) {
+                    throw new Error('leagueId not found in parsed JSON');
+                }
+            }
+            else {
+                throw new Error('external_field_5 is empty or undefined');
+            }
+        }
+        catch (parseError) {
+            const error = new Error(`Failed to parse leagueId from external_field_5. Raw value: ${metadata.external_field_5}`);
+            captureException(error, {
+                rawValue: metadata.external_field_5,
+                parseError,
+            });
+            throw error;
+        }
+        if (!eventId.trim() || !leagueId.trim()) {
+            throw new Error('EventId or leagueId is empty string in page config metadata');
+        }
+        const formattedTimeCode = this.formatTimeCodeForAPI(timeCode);
+        return `/${leagueId}/${eventId}/en/us/${formattedTimeCode}`;
+    }
+    /**
+     * Format timecode for API consumption
+     * @param timeCode - Timecode in milliseconds or null
+     * @returns ISO date string, "pre.json" for pre-game, or "latest" for post-game
+     */
+    formatTimeCodeForAPI(timeCode) {
+        if (!timeCode || timeCode === 0) {
+            return 'latest';
+        }
+        if (typeof timeCode !== 'number' ||
+            isNaN(timeCode) ||
+            !isFinite(timeCode)) {
+            console.warn('Invalid timecode provided, using "latest":', timeCode);
+            return 'latest';
+        }
+        try {
+            const date = new Date(timeCode);
+            if (isNaN(date.getTime())) {
+                console.warn('Invalid date from timecode, using "latest":', timeCode);
+                return 'latest';
+            }
+            // For future timecodes, use "latest" since we can't fetch future data
+            const now = Date.now();
+            const timeDiff = now - timeCode;
+            if (timeDiff < 0) {
+                return 'latest';
+            }
+            // Return ISO date string without milliseconds to match API format
+            const isoString = date.toISOString().replace(/\.\d{3}Z$/, 'Z');
+            return isoString;
+        }
+        catch (error) {
+            captureException(error, { timeCode });
+            console.warn('Error formatting timecode, using "latest":', timeCode, error);
+            return 'latest';
+        }
+    }
+}
+export default StatsService;

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

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