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

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

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import InsightsPayloadBuilder from '../InsightsService/InsightsPayloadBuilder';
 import InsightsService from '../InsightsService/InsightsService';
 import { PageConfig } from '../StaticService/types';
@@ -59,10 +58,12 @@ type PanelData = {
 declare class AnalyticsService {
     insightsService: InsightsService;
     insightsPayloadBuilder: InsightsPayloadBuilder;
-    sessionId: string;
-    sessionBeaconTimeoutId: NodeJS.Timeout | null;
-    isSessionBeaconRunning: boolean;
-    isSessionActive: boolean;
+    private SDKSessionId;
+    private pageSessionId;
+    private pinchBackSessionId;
+    private pageSessionBeaconTimeoutId;
+    private isPageSessionBeaconRunning;
+    private isPageSessionActive;
     constructor();
     private trackAction;
     private trackImpression;
@@ -70,8 +71,12 @@ declare class AnalyticsService {
     panelClick({ type, metadata, name }: PanelClickPayload): Promise<void>;
     getBaseMetadataFromPageConfig(pageConfig: PageConfig | null): BaseMetadata;
     getPanelDataFromPageConfig(type: 'espnBet' | 'espnStats' | 'espnKeyPlays' | 'espnFantasy' | 'espnShop', pageConfig: PageConfig | null): PanelData;
-    sessionStart(): Promise<void>;
-    sessionEnd(): Promise<void>;
+    SDKSessionStart(): Promise<void>;
+    pageSessionStart(): Promise<void>;
+    pageSessionEnd(): Promise<void>;
+    pinchBackSessionStart(): Promise<void>;
+    pinchBackSessionEnd(): Promise<void>;
+    SDKSessionEnd(): Promise<void>;
     private scheduleNextBeacon;
     private sendSessionBeacon;
     private sessionBeacon;

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

@@ -0,0 +1,402 @@
+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 event = SDK.getMaestroEventViewModel().getCurrentEventID();
+        const airing = metadata?.external_field_4 === 'airing'
+            ? metadata.external_field_1 || ''
+            : '';
+        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.js

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

package/dist/src/services/BetsService.js

@@ -0,0 +1,122 @@
+import { HttpMethod } from './NetworkManager/NetworkManager';
+import NetworkManagerFactory from './NetworkManager/NetworkManagerFactory';
+/**
+ * Service for handling bets-related API calls
+ */
+class BetsService {
+    constructor(delegate) {
+        Object.defineProperty(this, "networkManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.networkManager = NetworkManagerFactory.createBetsNetworkManager(delegate.getBettingAPIBaseURL());
+    }
+    /**
+     * 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
+     */
+    async getNonPersonalizedBets(eventID) {
+        return this.networkManager.externalApiRequest({
+            endpoint: this.nonPersonalizedBetsEndpoint(eventID),
+            method: HttpMethod.GET,
+            params: {},
+            headers: {},
+        });
+    }
+    /**
+     * 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
+     */
+    async getPersonalizedBets(eventID, swid, jwt) {
+        return this.networkManager.externalApiRequest({
+            endpoint: this.personalizedBetsEndpoint(eventID),
+            method: HttpMethod.GET,
+            params: { swid },
+            headers: { 'x-p13n-auth': jwt },
+        });
+    }
+    /**
+     * 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
+     */
+    async getPersonalizedBetsWithHeaders(eventID, swid, jwt) {
+        return this.networkManager.externalApiRequestWithHeaders({
+            endpoint: this.personalizedBetsEndpoint(eventID),
+            method: HttpMethod.GET,
+            params: { swid },
+            headers: { 'x-p13n-auth': jwt },
+        });
+    }
+    /**
+     * 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, swid, jwt, interval, onData, onError) {
+        return this.networkManager.pollExternalApiRequest({
+            endpoint: this.personalizedBetsEndpoint(eventID),
+            interval,
+            method: HttpMethod.GET,
+            params: { swid },
+            headers: { 'x-p13n-auth': jwt },
+            onData,
+            onError,
+        });
+    }
+    /**
+     * 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, swid, jwt, interval, onData, onError) {
+        return this.networkManager.pollExternalApiRequestWithHeaders({
+            endpoint: this.personalizedBetsEndpoint(eventID),
+            interval,
+            method: HttpMethod.GET,
+            params: { swid },
+            headers: { 'x-p13n-auth': jwt },
+            onData,
+            onError,
+        });
+    }
+    /**
+     * Get the endpoint for non-personalized bets
+     *
+     * @deprecated This endpoint is no longer used.
+     */
+    nonPersonalizedBetsEndpoint(eventID) {
+        return `/site/v2/events/${eventID}/odds`;
+    }
+    /**
+     * Get the endpoint for personalized bets
+     */
+    personalizedBetsEndpoint(eventID) {
+        return `/personalized/site/v2/events/${eventID}/odds`;
+    }
+}
+export default BetsService;

package/dist/src/services/FantasyService.js

@@ -0,0 +1,92 @@
+import NetworkManagerFactory from './NetworkManager/NetworkManagerFactory';
+/**
+ * Service for handling fantasy API calls
+ */
+class FantasyService {
+    constructor() {
+        Object.defineProperty(this, "fantasyClient", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "leagueManagerClient", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "promoClient", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.fantasyClient = NetworkManagerFactory.createForService({
+            externalBaseURL: 'https://fan.api.espn.com/apis/v2/fans',
+            serviceType: 'fantasy',
+        });
+        this.leagueManagerClient = NetworkManagerFactory.createForService({
+            externalBaseURL: 'https://lm-api-reads.fantasy.espn.com/apis/v3/games',
+            serviceType: 'fantasy',
+        });
+        this.promoClient = NetworkManagerFactory.createForService({
+            externalBaseURL: 'https://client.espncdn.com/ictv/promo.json',
+            serviceType: 'fantasy',
+        });
+    }
+    /**
+     * Polls the fantasy API at regular intervals
+     * @param swid - The SWID of the user
+     * @param interval - Polling interval in milliseconds
+     * @param onData - Callback invoked with the data on each successful poll
+     * @param onError - Optional callback invoked on error
+     */
+    pollFantasy({ eventId, jwt, swid }, interval, onData, onError) {
+        return this.fantasyClient.pollExternalApiRequestWithHeaders({
+            endpoint: swid,
+            interval,
+            headers: {
+                'x-p13n-auth': jwt,
+            },
+            onData,
+            onError,
+            params: {
+                displayHiddenPrefs: true,
+                prefType: 'fantasy',
+                context: 'fantasy',
+                useCookieAuth: true,
+                source: 'fantasyictv-bbd',
+                featureFlags: 'challengeEntries',
+                filterType: 'FANTASY_CTV',
+                platform: 'fantasyictv_bbd',
+                swid,
+                eventId,
+            },
+        });
+    }
+    pollLeagueManager({ game, leagueId, seasonId, token, proGameId, teamId, }, interval, onData, onError) {
+        return this.leagueManagerClient.pollExternalApiRequestWithHeaders({
+            endpoint: `/${game}/seasons/${seasonId}/segments/0/leagues/${leagueId}/scoreboard`,
+            interval,
+            onData,
+            onError,
+            headers: {
+                'x-p13n-auth': token,
+            },
+            params: {
+                view: 'ictv_scoreboard',
+                platform: 'fantasyictv_bbd',
+                proGameId,
+                teamId,
+            },
+        });
+    }
+    getPromo() {
+        return this.promoClient.externalApiRequest({
+            endpoint: '',
+            useCache: true,
+        });
+    }
+}
+export default FantasyService;

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

@@ -0,0 +1,9 @@
+import { Observable } from '../../helpers/Observable';
+import { PageConfig } from './types';
+export default class PageService {
+    configObservable: Observable<any>;
+    private client;
+    constructor();
+    fetchPageConfig(siteId: string, eventId: string): Promise<PageConfig | null>;
+    static isPanelAvailable(pageConfig: PageConfig | null, panelType: string): any;
+}