@maestro_io/maestro-web-sdk 4.0.2 → 5.1.0

package/dist/src/sentry.js

@@ -1,31 +1,51 @@
-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/];
+// BrowserClient type is inferred from dynamic import
 let sentryClient = null;
-const initSentry = () => {
-    if (process.env.NODE_ENV === 'test') {
+let pendingErrors = [];
+let isInitializing = false;
+const initSentry = async () => {
+    if (sentryClient || isInitializing)
         return;
+    if (process.env.NODE_ENV === 'test')
+        return;
+    isInitializing = true;
+    try {
+        const { BrowserClient, defaultStackParser, defaultIntegrations, makeFetchTransport, } = await import('@sentry/browser');
+        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),
+        });
+        // Flush pending errors
+        pendingErrors.forEach(({ error, extra }) => {
+            sentryClient?.captureException(error, extra);
+        });
+        pendingErrors = [];
+    }
+    catch (e) {
+        console.error('[maestro-web-sdk] Failed to load Sentry:', e);
+    }
+    finally {
+        isInitializing = false;
     }
-    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;
+    if (sentryClient) {
+        sentryClient.captureException(error, extra);
+    }
+    else {
+        pendingErrors.push({ error, extra });
+        initSentry(); // Trigger lazy init
     }
-    sentryClient.captureException(error, extra);
 };
 export default initSentry;

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

@@ -2,6 +2,7 @@ import InsightsPayloadBuilder from '../InsightsService/InsightsPayloadBuilder';
 import InsightsService from '../InsightsService/InsightsService';
 import { PageConfig } from '../StaticService/types';
 import { BaseMetadata } from './types';
+import { MaestroPanelType } from '@/models/IPanel';
 type KeyPlaysClickedAction = {
     type: 'espnKeyPlays';
     name: 'key_play_clicked';
@@ -67,10 +68,10 @@ declare class AnalyticsService {
     constructor();
     private trackAction;
     private trackImpression;
-    panelView(panelType: 'espnStats' | 'espnKeyPlays' | 'espnBet' | 'espnFantasy' | 'espnShop', metadata?: Record<string, any>): Promise<void>;
+    panelView(panelType: MaestroPanelType, 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;
+    getPanelDataFromPageConfig(type: MaestroPanelType, pageConfig: PageConfig | null): PanelData;
     SDKSessionStart(): Promise<void>;
     pageSessionStart(): Promise<void>;
     pageSessionEnd(): Promise<void>;

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

@@ -1,5 +1,5 @@
-import SDK from '../..';
 import InsightsPayloadBuilder from '../InsightsService/InsightsPayloadBuilder';
+import SDK from '../..';
 import InsightsService from '../InsightsService/InsightsService';
 import { version } from '../../../package.json';
 import { captureException } from '@/sentry';
@@ -247,6 +247,7 @@ class AnalyticsService {
                     page_session: this.pageSessionId,
                 },
             });
+            console.log('AnalyticsService: pageSessionEnd', eventInsightsData);
             await this.insightsService.action(eventInsightsData);
         }
         catch (err) {
@@ -310,6 +311,7 @@ class AnalyticsService {
                     pinchback_session: this.pinchBackSessionId,
                 },
             });
+            console.log('AnalyticsService: pinchBackSessionEnd', eventInsightsData);
             await this.insightsService.action(eventInsightsData);
         }
         catch (err) {

package/dist/src/services/InsightsService/InsightsPayloadBuilder.d.ts

@@ -149,7 +149,7 @@ export default class InsightsPayloadBuilder {
          * @description Site slug.
          * @example site.slug
          */
-        si_s: string;
+        si_s: string | undefined;
         /**
          * @description Session ID, which can be used to track the session across requests. You might wanna keep this fixed for the session you're in using a local storage or something related.
          */

package/dist/src/services/InsightsService/InsightsPayloadBuilder.js

@@ -326,8 +326,7 @@ export default class InsightsPayloadBuilder {
              * @description Site slug.
              * @example site.slug
              */
-            // TODO: grab from page config when available
-            si_s: 'espn',
+            si_s: this.pageConfig?.site.slug,
         };
     }
     getUserInsights() {

package/dist/src/services/InsightsService/InsightsService.js

@@ -1,6 +1,6 @@
 import AxiosNetworkClient from '@/external/AxiosNetworkClient';
-import SDK from '@/index';
 import { captureException } from '@/sentry';
+import SDK from '@/index';
 const INSIGHTS_BASE_URL = 'https://insights.maestro.io';
 export default class InsightsService {
     constructor() {

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

@@ -33,6 +33,11 @@ declare class NetworkManager {
      * Set authentication for Maestro APIs
      */
     setAuthentication(token: string | null, apiKey: string | null): void;
+    /**
+     * Execute a request with optional caching
+     * Extracts duplicated cache logic from request methods
+     */
+    private withCache;
     /**
      * Handle errors from network requests
      */
@@ -67,6 +72,7 @@ declare class NetworkManager {
     }): Promise<T>;
     /**
      * Make a request to an external API and return both data and headers
+     * Note: Only data is cached, headers are not persisted
      */
     externalApiRequestWithHeaders<T = any>({ endpoint, method, params, data, headers, useCache, skipResponseBodyDeserialization, }: {
         endpoint: string;

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

@@ -89,6 +89,28 @@ class NetworkManager {
     setAuthentication(token, apiKey) {
         this.maestroClient.setAuthentication(token, apiKey);
     }
+    /**
+     * Execute a request with optional caching
+     * Extracts duplicated cache logic from request methods
+     */
+    async withCache(cacheParams, useCache, fetchFn) {
+        const cacheKey = this.cacheManager.produceCacheKey(JSON.stringify({
+            endpoint: cacheParams.endpoint,
+            params: cacheParams.params,
+            data: null,
+        }));
+        if (useCache) {
+            const cachedData = this.cacheManager.getCache(cacheKey);
+            if (cachedData) {
+                return cachedData;
+            }
+        }
+        const response = await fetchFn();
+        if (useCache) {
+            this.cacheManager.setCache(cacheKey, response);
+        }
+        return response;
+    }
     /**
      * Handle errors from network requests
      */
@@ -134,19 +156,8 @@ class NetworkManager {
             requestHeaders['Authorization'] = `Bearer ${maestroDefaultHeaders.jwt}`;
             requestHeaders['Content-type'] = 'application/json';
         }
-        // Check cache if using GET and cache is enabled
-        if (method === HttpMethod.GET && useCache) {
-            const cacheKey = this.cacheManager.produceCacheKey(JSON.stringify({
-                endpoint,
-                params,
-                data: null,
-            }));
-            const cachedData = this.cacheManager.getCache(cacheKey);
-            if (cachedData) {
-                return cachedData;
-            }
-        }
-        try {
+        const shouldCache = method === HttpMethod.GET && useCache;
+        const fetchFn = async () => {
             let response;
             if (method === HttpMethod.GET) {
                 response = await this.maestroClient.get(endpoint, params, requestHeaders);
@@ -157,20 +168,13 @@ class NetworkManager {
             else {
                 throw new Error(`Method ${method} not implemented`);
             }
-            // Handle empty response if needed
             if (skipResponseBodyDeserialization && !response) {
                 response = {};
             }
-            // Cache the response for GET requests
-            if (method === HttpMethod.GET && useCache) {
-                const cacheKey = this.cacheManager.produceCacheKey(JSON.stringify({
-                    endpoint,
-                    params,
-                    data: null,
-                }));
-                this.cacheManager.setCache(cacheKey, response);
-            }
             return response;
+        };
+        try {
+            return await this.withCache({ endpoint, params }, shouldCache, fetchFn);
         }
         catch (error) {
             return this.handleError(error);
@@ -180,19 +184,8 @@ class NetworkManager {
      * Make a request to an external API
      */
     async externalApiRequest({ endpoint, method = HttpMethod.GET, params = {}, data = null, headers = {}, useCache = false, skipResponseBodyDeserialization = false, }) {
-        // Check cache if using GET and cache is enabled
-        if (method === HttpMethod.GET && useCache) {
-            const cacheKey = this.cacheManager.produceCacheKey(JSON.stringify({
-                endpoint,
-                params,
-                data: null,
-            }));
-            const cachedData = this.cacheManager.getCache(cacheKey);
-            if (cachedData) {
-                return cachedData;
-            }
-        }
-        try {
+        const shouldCache = method === HttpMethod.GET && useCache;
+        const fetchFn = async () => {
             let response;
             if (method === HttpMethod.GET) {
                 response = await this.externalClient.get(endpoint, params, headers);
@@ -203,20 +196,13 @@ class NetworkManager {
             else {
                 throw new Error(`Method ${method} not implemented`);
             }
-            // Handle empty response if needed
             if (skipResponseBodyDeserialization && !response) {
                 response = {};
             }
-            // Cache the response for GET requests
-            if (method === HttpMethod.GET && useCache) {
-                const cacheKey = this.cacheManager.produceCacheKey(JSON.stringify({
-                    endpoint,
-                    params,
-                    data: null,
-                }));
-                this.cacheManager.setCache(cacheKey, response);
-            }
             return response;
+        };
+        try {
+            return await this.withCache({ endpoint, params }, shouldCache, fetchFn);
         }
         catch (error) {
             return this.handleError(error);
@@ -224,18 +210,15 @@ class NetworkManager {
     }
     /**
      * Make a request to an external API and return both data and headers
+     * Note: Only data is cached, headers are not persisted
      */
     async externalApiRequestWithHeaders({ endpoint, method = HttpMethod.GET, params = {}, data = null, headers = {}, useCache = false, skipResponseBodyDeserialization = false, }) {
-        // Check cache if using GET and cache is enabled
-        if (method === HttpMethod.GET && useCache) {
-            const cacheKey = this.cacheManager.produceCacheKey(JSON.stringify({
-                endpoint,
-                params,
-                data: null,
-            }));
+        const shouldCache = method === HttpMethod.GET && useCache;
+        const cacheKey = this.cacheManager.produceCacheKey(JSON.stringify({ endpoint, params, data: null }));
+        // Check cache - return cached data with empty headers
+        if (shouldCache) {
             const cachedData = this.cacheManager.getCache(cacheKey);
             if (cachedData) {
-                // Return cached data with empty headers since we don't cache headers
                 return { data: cachedData, headers: {} };
             }
         }
@@ -250,17 +233,11 @@ class NetworkManager {
             else {
                 throw new Error(`Method ${method} not implemented`);
             }
-            // Handle empty response if needed
             if (skipResponseBodyDeserialization && !response.data) {
                 response.data = {};
             }
-            // Cache the response data for GET requests (headers are not cached)
-            if (method === HttpMethod.GET && useCache) {
-                const cacheKey = this.cacheManager.produceCacheKey(JSON.stringify({
-                    endpoint,
-                    params,
-                    data: null,
-                }));
+            // Cache only data, not headers
+            if (shouldCache) {
                 this.cacheManager.setCache(cacheKey, response.data);
             }
             return response;

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

@@ -1,99 +1,3 @@
-/**
- * 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
  */

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

@@ -1,10 +1 @@
-/**
- * Service types for different NetworkManager contexts
- */
-export const ServiceType = {
-    STATS: 'stats',
-    BETS: 'bets',
-    MAESTRO: 'maestro',
-    FANTASY: 'fantasy',
-    SHOP: 'shop',
-};
+export {};

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

@@ -1,12 +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();
-    fetchPageConfig(siteId: string, eventId: string): Promise<PageConfig | null>;
+    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

@@ -2,8 +2,11 @@ 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',
+};
 export default class StaticService {
-    constructor() {
+    constructor(siteId) {
         Object.defineProperty(this, "configObservable", {
             enumerable: true,
             configurable: true,
@@ -16,24 +19,46 @@ export default class StaticService {
             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: 'https://static-prod.us-central1-espn-prod.gcp.maestro.io',
+                baseURL,
                 delay: 1000,
                 retries: 5,
             }),
         });
     }
-    fetchPageConfig(siteId, eventId) {
+    async fetchPageConfigByMetadata(siteId, metadataValue) {
         try {
-            return this.client.externalApiRequest({
-                endpoint: `/pages/sites/${siteId}/metadata/${eventId}.json`,
+            return await this.client.externalApiRequest({
+                endpoint: `/pages/sites/${siteId}/metadata/${metadataValue}.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));
+            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);
         }
     }

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

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