@maestro_io/maestro-web-sdk 4.0.0 → 4.0.1

package/dist/src/sentry.d.ts

@@ -0,0 +1,3 @@
+declare const initSentry: () => void;
+export declare const captureException: (error: unknown, extra?: any) => void;
+export default initSentry;

package/dist/src/sentry.js

@@ -0,0 +1,31 @@
+import { BrowserClient, defaultStackParser, defaultIntegrations, makeFetchTransport, } from '@sentry/browser';
+import pkg from '../package.json';
+const DEV_DOMAINS = [/bbd-web-sdk\.us-central1-dev\.gcp\.maestro\.io/];
+let sentryClient = null;
+const initSentry = () => {
+    if (process.env.NODE_ENV === 'test') {
+        return;
+    }
+    const isDev = DEV_DOMAINS.find((domain) => domain.test(window.location.href)) !== null;
+    sentryClient = new BrowserClient({
+        dsn: 'https://91444a71cbaefc62e8dc813f22bad3bf@o4506894189330432.ingest.us.sentry.io/4509946717470720',
+        transport: makeFetchTransport,
+        stackParser: defaultStackParser,
+        integrations: defaultIntegrations.filter((integration) => {
+            // filter integrations that use the global variable
+            return !['BrowserApiErrors', 'Breadcrumbs', 'GlobalHandlers'].includes(integration.name);
+        }),
+        tracesSampleRate: isDev ? 1 : 0.1,
+        release: pkg.version,
+        environment: isDev ? 'development' : 'production',
+        enabled: !/localhost/.test(window.location.href),
+    });
+};
+export const captureException = (error, extra) => {
+    if (!sentryClient) {
+        console.error('[maestro-web-sdk] SDK - Sentry Browser Client is not initialized');
+        return;
+    }
+    sentryClient.captureException(error, extra);
+};
+export default initSentry;

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

@@ -0,0 +1,84 @@
+import InsightsPayloadBuilder from '../InsightsService/InsightsPayloadBuilder';
+import InsightsService from '../InsightsService/InsightsService';
+import { PageConfig } from '../StaticService/types';
+import { BaseMetadata } from './types';
+type KeyPlaysClickedAction = {
+    type: 'espnKeyPlays';
+    name: 'key_play_clicked';
+    metadata: {
+        action: string;
+        clip: string;
+        key_play: string;
+    };
+};
+type BetsItemClickedAction = {
+    type: 'espnBet';
+    name: 'bets_item_clicked';
+    metadata: {
+        card: string;
+        bet_type: string | null;
+        in_game_bets: number;
+        total_bets: number;
+    };
+};
+type StatsItemClickedAction = {
+    type: 'espnStats';
+    name: 'stats_item_clicked';
+    metadata: {
+        card: string[];
+        game_state: string[];
+    };
+};
+type FantasyItemClickedAction = {
+    type: 'espnFantasy';
+    name: 'fantasy_item_clicked';
+    metadata: {
+        card: string;
+    };
+};
+type ShopItemClickedAction = {
+    type: 'espnShop';
+    name: 'shop_item_clicked';
+    metadata: {
+        card: string[];
+        game_state: string[];
+        product: string | null;
+        entity_type: string[];
+        entity_name: string[];
+        price: string | null;
+        sale: string[];
+    };
+};
+type PanelClickPayload = KeyPlaysClickedAction | BetsItemClickedAction | StatsItemClickedAction | FantasyItemClickedAction | ShopItemClickedAction;
+type PanelData = {
+    panel_type: string;
+    panel_id: string;
+    panel_name: string;
+};
+declare class AnalyticsService {
+    insightsService: InsightsService;
+    insightsPayloadBuilder: InsightsPayloadBuilder;
+    private SDKSessionId;
+    private pageSessionId;
+    private pinchBackSessionId;
+    private pageSessionBeaconTimeoutId;
+    private isPageSessionBeaconRunning;
+    private isPageSessionActive;
+    constructor();
+    private trackAction;
+    private trackImpression;
+    panelView(panelType: 'espnStats' | 'espnKeyPlays' | 'espnBet' | 'espnFantasy' | 'espnShop', metadata?: Record<string, any>): Promise<void>;
+    panelClick({ type, metadata, name }: PanelClickPayload): Promise<void>;
+    getBaseMetadataFromPageConfig(pageConfig: PageConfig | null): BaseMetadata;
+    getPanelDataFromPageConfig(type: 'espnBet' | 'espnStats' | 'espnKeyPlays' | 'espnFantasy' | 'espnShop', pageConfig: PageConfig | null): PanelData;
+    SDKSessionStart(): Promise<void>;
+    pageSessionStart(): Promise<void>;
+    pageSessionEnd(): Promise<void>;
+    pinchBackSessionStart(): Promise<void>;
+    pinchBackSessionEnd(): Promise<void>;
+    SDKSessionEnd(): Promise<void>;
+    private scheduleNextBeacon;
+    private sendSessionBeacon;
+    private sessionBeacon;
+}
+export default AnalyticsService;

package/dist/src/services/AnalyticsService/AnalyticsService.js

@@ -0,0 +1,404 @@
+import SDK from '../..';
+import InsightsPayloadBuilder from '../InsightsService/InsightsPayloadBuilder';
+import InsightsService from '../InsightsService/InsightsService';
+import { version } from '../../../package.json';
+import { captureException } from '@/sentry';
+const SESSION_BEACON_SECONDS = 240;
+class AnalyticsService {
+    constructor() {
+        Object.defineProperty(this, "insightsService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "insightsPayloadBuilder", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "SDKSessionId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "pageSessionId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "pinchBackSessionId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "pageSessionBeaconTimeoutId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "isPageSessionBeaconRunning", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "isPageSessionActive", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.insightsService = new InsightsService();
+        this.insightsPayloadBuilder = new InsightsPayloadBuilder();
+    }
+    async trackAction(event) {
+        if (process.env.NODE_ENV === 'test') {
+            return;
+        }
+        SDK.getMaestroEventViewModel().delegate.trackAction(event);
+        const eventInsightsData = await this.insightsPayloadBuilder.getPayload({
+            ontology: {
+                class: event.e2_class,
+                family: event.e4_family,
+                order: event.e3_order,
+                kingdom: event.e0_kingdom,
+                phylum: event.e1_phylum,
+                genus: event.e5_genus,
+                species: event.e6_species,
+            },
+            metadata: event.metadata,
+        });
+        await this.insightsService.action(eventInsightsData);
+    }
+    async trackImpression(event) {
+        if (process.env.NODE_ENV === 'test') {
+            return;
+        }
+        SDK.getMaestroEventViewModel().delegate.trackImpression(event);
+        const eventInsightsData = await this.insightsPayloadBuilder.getPayload({
+            ontology: {
+                kingdom: event.e0_kingdom,
+                phylum: event.e1_phylum,
+                class: event.e2_class,
+                order: event.e3_order,
+                family: event.e4_family,
+                genus: event.e5_genus,
+                species: event.e6_species,
+            },
+            metadata: event.metadata,
+        });
+        await this.insightsService.action(eventInsightsData);
+    }
+    async panelView(panelType, metadata) {
+        const config = SDK.getPageConfig();
+        const panelData = this.getPanelDataFromPageConfig(panelType, config);
+        await this.trackImpression({
+            name: 'panel_selected',
+            e0_kingdom: 'panel',
+            e1_phylum: 'view',
+            e2_class: panelData.panel_type,
+            e3_order: panelData.panel_id,
+            e4_family: panelData.panel_name,
+            metadata: {
+                ...(metadata || {}),
+                ...this.getBaseMetadataFromPageConfig(config),
+            },
+        });
+    }
+    async panelClick({ type, metadata, name }) {
+        const config = SDK.getPageConfig();
+        const panelData = this.getPanelDataFromPageConfig(type, config);
+        await this.trackAction({
+            name,
+            e0_kingdom: 'panel',
+            e1_phylum: 'engage',
+            e2_class: panelData.panel_type,
+            e3_order: panelData.panel_id,
+            e4_family: panelData.panel_name,
+            metadata: {
+                ...this.getBaseMetadataFromPageConfig(config),
+                ...metadata,
+            },
+        });
+    }
+    getBaseMetadataFromPageConfig(pageConfig) {
+        if (!pageConfig) {
+            console.warn('Page Config not found. Could not extract metadata.');
+            return {
+                league: '',
+                airing: '',
+                event: '',
+                sport: '',
+            };
+        }
+        const metadata = pageConfig.page.metadata;
+        const airing = metadata?.external_field_4 === 'airing'
+            ? metadata.external_field_1 || ''
+            : '';
+        const event = metadata?.external_field_4 === 'event'
+            ? metadata.external_field_1 || 'unknown'
+            : 'unknown';
+        const sport = metadata?.external_field_2 || '';
+        const league = metadata?.external_field_3 || '';
+        return {
+            league,
+            airing,
+            event,
+            sport,
+        };
+    }
+    getPanelDataFromPageConfig(type, pageConfig) {
+        if (!pageConfig) {
+            console.warn('Page Config not found. Could not extract panel data.');
+            return {
+                panel_id: '',
+                panel_name: '',
+                panel_type: '',
+            };
+        }
+        const panel = pageConfig.panels.find((p) => p.panel_type === type);
+        if (!panel) {
+            console.warn(`Panel of type ${type} not found in Page Config.`);
+            return {
+                panel_id: '',
+                panel_name: '',
+                panel_type: '',
+            };
+        }
+        return {
+            panel_id: panel._id,
+            panel_name: panel.panel_name || '',
+            panel_type: panel.panel_type || '',
+        };
+    }
+    async SDKSessionStart() {
+        try {
+            this.SDKSessionId = Math.random().toString(36).substring(2, 15);
+            const eventInsightsData = await this.insightsPayloadBuilder.getPayload({
+                ontology: {
+                    kingdom: 'session',
+                    phylum: 'start',
+                    class: 'sdk',
+                },
+                metadata: {
+                    version,
+                },
+            });
+            await this.insightsService.action(eventInsightsData);
+        }
+        catch (err) {
+            console.error(`Failed to start SDK session: ${err}`);
+            captureException(err, {
+                context: 'AnalyticsService.SDKSessionStart',
+            });
+        }
+    }
+    async pageSessionStart() {
+        try {
+            this.pageSessionId = Math.random().toString(36).substring(2, 15);
+            this.isPageSessionActive = true;
+            const pageConfig = SDK.getPageConfig();
+            const baseMetadata = this.getBaseMetadataFromPageConfig(pageConfig);
+            const eventInsightsData = await this.insightsPayloadBuilder.getPayload({
+                ontology: {
+                    kingdom: 'session',
+                    phylum: 'start',
+                    class: 'page',
+                },
+                metadata: {
+                    ...baseMetadata,
+                    version,
+                    session: this.SDKSessionId,
+                    page_session: this.pageSessionId,
+                },
+            });
+            await this.insightsService.action(eventInsightsData);
+            // Start the beacon cycle with recursive setTimeout
+            this.scheduleNextBeacon();
+        }
+        catch (err) {
+            console.error(`Failed to start page session: ${err}`);
+            captureException(err, {
+                context: 'AnalyticsService.pageSessionStart',
+            });
+        }
+    }
+    async pageSessionEnd() {
+        try {
+            this.isPageSessionActive = false;
+            const pageConfig = SDK.getPageConfig();
+            const baseMetadata = this.getBaseMetadataFromPageConfig(pageConfig);
+            const eventInsightsData = await this.insightsPayloadBuilder.getPayload({
+                ontology: {
+                    kingdom: 'session',
+                    phylum: 'end',
+                    class: 'page',
+                },
+                metadata: {
+                    ...baseMetadata,
+                    version,
+                    session: this.SDKSessionId,
+                    page_session: this.pageSessionId,
+                },
+            });
+            await this.insightsService.action(eventInsightsData);
+        }
+        catch (err) {
+            console.error(`Failed to end page session: ${err}`);
+            captureException(err, {
+                context: 'AnalyticsService.pageSessionEnd',
+            });
+        }
+        finally {
+            // Clear any pending beacon timeouts
+            if (this.pageSessionBeaconTimeoutId) {
+                clearTimeout(this.pageSessionBeaconTimeoutId);
+                this.pageSessionBeaconTimeoutId = null;
+            }
+            this.pageSessionId = '';
+        }
+    }
+    async pinchBackSessionStart() {
+        try {
+            this.pinchBackSessionId = Math.random().toString(36).substring(2, 15);
+            const pageConfig = SDK.getPageConfig();
+            const baseMetadata = this.getBaseMetadataFromPageConfig(pageConfig);
+            const eventInsightsData = await this.insightsPayloadBuilder.getPayload({
+                ontology: {
+                    kingdom: 'session',
+                    phylum: 'start',
+                    class: 'pinchback',
+                },
+                metadata: {
+                    ...baseMetadata,
+                    version,
+                    session: this.SDKSessionId,
+                    page_session: this.pageSessionId,
+                    pinchback_session: this.pinchBackSessionId,
+                },
+            });
+            await this.insightsService.action(eventInsightsData);
+        }
+        catch (err) {
+            console.error(`Failed to start pinchback session: ${err}`);
+            captureException(err, {
+                context: 'AnalyticsService.pinchBackSessionStart',
+            });
+        }
+    }
+    async pinchBackSessionEnd() {
+        try {
+            const pageConfig = SDK.getPageConfig();
+            const baseMetadata = this.getBaseMetadataFromPageConfig(pageConfig);
+            const eventInsightsData = await this.insightsPayloadBuilder.getPayload({
+                ontology: {
+                    kingdom: 'session',
+                    phylum: 'end',
+                    class: 'pinchback',
+                },
+                metadata: {
+                    ...baseMetadata,
+                    version,
+                    session: this.SDKSessionId,
+                    page_session: this.pageSessionId,
+                    pinchback_session: this.pinchBackSessionId,
+                },
+            });
+            await this.insightsService.action(eventInsightsData);
+        }
+        catch (err) {
+            console.error(`Failed to end pinchback session: ${err}`);
+            captureException(err, {
+                context: 'AnalyticsService.pinchBackSessionEnd',
+            });
+        }
+        finally {
+            this.pinchBackSessionId = '';
+        }
+    }
+    async SDKSessionEnd() {
+        try {
+            const eventInsightsData = await this.insightsPayloadBuilder.getPayload({
+                ontology: {
+                    kingdom: 'session',
+                    phylum: 'end',
+                    class: 'sdk',
+                },
+                metadata: {
+                    version,
+                },
+            });
+            await this.insightsService.action(eventInsightsData);
+        }
+        catch (err) {
+            console.error(`Failed to end SDK session: ${err}`);
+            captureException(err, {
+                context: 'AnalyticsService.SDKSessionEnd',
+            });
+        }
+        finally {
+            this.SDKSessionId = '';
+        }
+    }
+    scheduleNextBeacon() {
+        // Only schedule if page session is still active
+        if (!this.isPageSessionActive) {
+            return;
+        }
+        const globalConfig = SDK.getGlobalConfig();
+        const beaconInterval = globalConfig?.bbd?.analytics?.beacon_interval || SESSION_BEACON_SECONDS;
+        this.pageSessionBeaconTimeoutId = setTimeout(async () => {
+            await this.sendSessionBeacon();
+        }, beaconInterval * 1000);
+    }
+    async sendSessionBeacon() {
+        // Prevent overlapping beacon calls
+        if (this.isPageSessionBeaconRunning || !this.isPageSessionActive) {
+            return;
+        }
+        this.isPageSessionBeaconRunning = true;
+        try {
+            await this.sessionBeacon();
+        }
+        catch (err) {
+            console.error(`Failed to send session beacon: ${err}`);
+            captureException(err, {
+                context: 'AnalyticsService.sendSessionBeacon',
+                SDKSessionId: this.SDKSessionId,
+                pageSessionId: this.pageSessionId,
+            });
+        }
+        finally {
+            this.isPageSessionBeaconRunning = false;
+            // Schedule next beacon only after current one completes
+            if (this.isPageSessionActive) {
+                this.scheduleNextBeacon();
+            }
+        }
+    }
+    async sessionBeacon() {
+        const eventInsightsData = await this.insightsPayloadBuilder.getPayload({
+            ontology: {
+                kingdom: 'session',
+                phylum: 'beacon',
+                class: 'frequent',
+            },
+            metadata: {
+                paywall_gated: false,
+                viewer_id: this.insightsPayloadBuilder.getDevicePermanentID(),
+                is_billable: false,
+                session: this.SDKSessionId,
+                page_session: this.pageSessionId,
+                pinchback_session: this.pinchBackSessionId,
+            },
+        });
+        await this.insightsService.action(eventInsightsData);
+    }
+}
+export default AnalyticsService;

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

@@ -0,0 +1,65 @@
+/**
+ * Generic metadata type that accepts any object extending BaseMetadata
+ */
+export type Metadata = BaseMetadata & {
+    [key: string]: any;
+};
+export type Kingdom = 'panel';
+export type Phylum = 'view' | 'engage';
+/**
+ * Base metadata analytics events should include
+ */
+export interface BaseMetadata {
+    league: string;
+    event: string;
+    airing: string;
+    sport: string;
+}
+export type PanelViewAction = {
+    name: 'panel_selected';
+    e0_kingdom: Kingdom;
+    e1_phylum: Phylum;
+    /**
+     * Panel Type
+     */
+    e2_class: string;
+    /**
+     * Panel ID
+     */
+    e3_order: string;
+    /**
+     * Panel Name
+     */
+    e4_family: string;
+    e5_genus?: string;
+    e6_species?: string;
+    /**
+     * Additional metadata for the panel view action.
+     */
+    metadata: Metadata;
+};
+export type ImpressionTrackEvent = PanelViewAction;
+export type PanelClickAction = {
+    name: string;
+    e0_kingdom: 'panel';
+    e1_phylum: 'engage';
+    /**
+     * Panel Type
+     */
+    e2_class: string;
+    /**
+     * Panel ID.
+     */
+    e3_order: string;
+    /**
+     * Panel Name
+     */
+    e4_family: string;
+    e5_genus?: string;
+    e6_species?: string;
+    /**
+     * Additional metadata for the panel click action.
+     */
+    metadata: Metadata;
+};
+export type ActionTrackEvent = PanelClickAction;

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

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

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

@@ -0,0 +1,81 @@
+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: IBetsNetworkManager;
+    constructor(delegate: IMaestroEventDelegate);
+    /**
+     * Get non-personalized bets for an event
+     *
+     * @deprecated Use getPersonalizedBets instead. This method is kept for backward compatibility.
+     * @param eventID - The ID of the event
+     * @returns Promise with the bets data
+     */
+    getNonPersonalizedBets(eventID: string): Promise<IBetsResponse>;
+    /**
+     * Get personalized bets for an event
+     *
+     * @param eventID - The ID of the event
+     * @param swid - The ESPN SWID parameter (format provided by client app delegate)
+     * @param jwt - The authorization JWT (empty string for anonymous users)
+     * @returns Promise with the personalized bets data
+     */
+    getPersonalizedBets(eventID: string, swid: string, jwt: string): Promise<IPersonalizedBetsResponse>;
+    /**
+     * Get personalized bets for an event with headers
+     *
+     * @param eventID - The ID of the event
+     * @param swid - The ESPN SWID parameter (format provided by client app delegate)
+     * @param jwt - The authorization JWT (empty string for anonymous users)
+     * @returns Promise with the personalized bets data and headers
+     */
+    getPersonalizedBetsWithHeaders(eventID: string, swid: string, jwt: string): Promise<{
+        data: IPersonalizedBetsResponse;
+        headers: Record<string, string>;
+    }>;
+    /**
+     * Start polling for personalized bets
+     *
+     * @param eventID - The ID of the event
+     * @param swid - The ESPN SWID parameter
+     * @param jwt - The authorization JWT
+     * @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
+     */
+    pollPersonalizedBets(eventID: string, swid: string, jwt: string, interval: number, onData: (data: IPersonalizedBetsResponse) => void, onError?: (error: Error) => void): {
+        stop: () => void;
+    };
+    /**
+     * Start polling for personalized bets and return both data and headers
+     *
+     * @param eventID - The ID of the event
+     * @param swid - The ESPN SWID parameter
+     * @param jwt - The authorization JWT
+     * @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
+     */
+    pollPersonalizedBetsWithHeaders(eventID: string, swid: string, jwt: string, interval: number, onData: (response: {
+        data: IPersonalizedBetsResponse;
+        headers: Record<string, string>;
+    }) => void, onError?: (error: Error) => void): {
+        stop: () => void;
+    };
+    /**
+     * Get the endpoint for non-personalized bets
+     *
+     * @deprecated This endpoint is no longer used.
+     */
+    nonPersonalizedBetsEndpoint(eventID: string): string;
+    /**
+     * Get the endpoint for personalized bets
+     */
+    personalizedBetsEndpoint(eventID: string): string;
+}
+export default BetsService;