@maestro_io/maestro-web-sdk 2.1.3 → 2.2.1

package/dist/services/NetworkManager/NetworkManager.js

@@ -1,410 +0,0 @@
-import AxiosNetworkClient from '../../external/AxiosNetworkClient';
-import LocalStorageCacheManager from '../../external/LocalStorageCacheManager';
-import { AuthError, BadRequestError, NetworkError, NotFoundError, ServerError, } from './errors';
-// Environment configuration
-export const WorkingEnvironment = {
-    DEVELOPMENT: 'development',
-    STAGING: 'staging',
-    PRODUCTION: 'production',
-};
-// URL configurations based on environment
-export const MAESTRO_BASE_URLS = {
-    [WorkingEnvironment.DEVELOPMENT]: 'https://dev.api.maestro.io',
-    [WorkingEnvironment.STAGING]: 'https://api.us-central1-staging.gcp.maestro.io',
-    [WorkingEnvironment.PRODUCTION]: 'https://api.maestro.io',
-};
-export const SDK_FLAVOR = 'MaestroKit_Web';
-// Common endpoints
-export const ENDPOINTS = {
-    CAN_I_PLAY: '/caniplay/v1',
-    STREAM: '/stream/v1',
-    USER_PROFILE: '/userprofile/v1',
-    ACTIVE_USER: '/active/v2',
-    // Add more endpoints as needed
-};
-// HTTP methods
-export const HttpMethod = {
-    GET: 'GET',
-    POST: 'POST',
-    PUT: 'PUT',
-    DELETE: 'DELETE',
-};
-class NetworkManager {
-    constructor(options = {}, localStorageOverride) {
-        Object.defineProperty(this, "cacheManager", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "maestroClient", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "externalClient", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "environment", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "pollingTasks", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "localStorage", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.environment = options.environment || WorkingEnvironment.PRODUCTION;
-        this.pollingTasks = new Map();
-        // Initialize cache manager
-        this.cacheManager =
-            options.cacheManager ||
-                new LocalStorageCacheManager(options.defaultCacheDuration);
-        // Initialize Maestro API client
-        this.maestroClient =
-            options.networkClient ||
-                new AxiosNetworkClient({
-                    baseURL: MAESTRO_BASE_URLS[this.environment],
-                    retries: 3,
-                    delay: 1000,
-                    backoff: 2,
-                });
-        // Initialize External API client
-        this.externalClient =
-            options.externalNetworkClient ||
-                new AxiosNetworkClient({
-                    baseURL: options.externalBaseURL || '',
-                    retries: 3,
-                    delay: 1000,
-                    backoff: 2,
-                });
-        this.localStorage = localStorageOverride ||
-            (typeof globalThis !== 'undefined' && globalThis.localStorage) || {
-            length: 0,
-            clear: () => { },
-            getItem: () => null,
-            key: () => null,
-            removeItem: () => { },
-            setItem: () => { },
-        };
-    }
-    static getInstance(options, localStorageOverride) {
-        if (!this.instance) {
-            this.instance = new NetworkManager(options, localStorageOverride);
-        }
-        else if (options) {
-            // Update environment if provided
-            if (options.environment) {
-                this.instance.setEnvironment(options.environment);
-            }
-        }
-        return this.instance;
-    }
-    /**
-     * Sets the working environment (development, staging, production)
-     */
-    setEnvironment(environment) {
-        this.environment = environment;
-        // Update base URLs for clients if they have a client property
-        // This is needed for testing and for real clients
-        try {
-            if (this.maestroClient.client?.defaults) {
-                this.maestroClient.client.defaults.baseURL =
-                    MAESTRO_BASE_URLS[environment];
-            }
-        }
-        catch (error) {
-            throw new Error(`Failed to update client base URLs: ${error}`);
-        }
-    }
-    /**
-     * Get current environment
-     */
-    getEnvironment() {
-        return this.environment;
-    }
-    /**
-     * Set authentication for Maestro APIs
-     */
-    setAuthentication(token, apiKey) {
-        this.maestroClient.setAuthentication(token, apiKey);
-    }
-    /**
-     * Handle errors from network requests
-     */
-    handleError(error) {
-        // Check if it's an Axios error with a response
-        if (error.response) {
-            const status = error.response.status;
-            const message = error.response.data?.message || error.message;
-            if (status === 401 || status === 403) {
-                throw new AuthError(message);
-            }
-            else if (status === 404) {
-                throw new NotFoundError(message);
-            }
-            else if (status >= 500) {
-                throw new ServerError(status, message);
-            }
-            else {
-                throw new BadRequestError(status, message);
-            }
-        }
-        else if (error.request) {
-            // Request was made but no response received
-            throw new NetworkError('Network request failed');
-        }
-        else {
-            // Something else happened while setting up the request
-            throw error;
-        }
-    }
-    /**
-     * Make a request to the Maestro API
-     */
-    async maestroApiRequest({ endpoint, method = HttpMethod.GET, params = {}, data = null, headers = {}, useCache = true, maestroDefaultHeaders = null, skipResponseBodyDeserialization = false, }) {
-        // Add SDK flavor to headers
-        const requestHeaders = {
-            'x-maestro-maestro-kit-flavor': SDK_FLAVOR,
-            ...headers,
-        };
-        // Add Maestro default headers if provided
-        if (maestroDefaultHeaders) {
-            requestHeaders['x-maestro-client-id'] = maestroDefaultHeaders.siteId;
-            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 {
-            let response;
-            if (method === HttpMethod.GET) {
-                response = await this.maestroClient.get(endpoint, params, requestHeaders);
-            }
-            else if (method === HttpMethod.POST) {
-                response = await this.maestroClient.post(endpoint, data);
-            }
-            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;
-        }
-        catch (error) {
-            return this.handleError(error);
-        }
-    }
-    /**
-     * Make a request to an external API
-     */
-    async externalApiRequest({ endpoint, method = HttpMethod.GET, params = {}, data = null, headers = {}, useCache = true, 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 {
-            let response;
-            if (method === HttpMethod.GET) {
-                response = await this.externalClient.get(endpoint, params, headers);
-            }
-            else if (method === HttpMethod.POST) {
-                response = await this.externalClient.post(endpoint, data);
-            }
-            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;
-        }
-        catch (error) {
-            return this.handleError(error);
-        }
-    }
-    /**
-     * Start polling a Maestro API endpoint at specified interval
-     */
-    pollMaestroApiRequest({ endpoint, interval, method = HttpMethod.GET, params = {}, data = null, headers = {}, maestroDefaultHeaders = null, skipResponseBodyDeserialization = false, onData, onError, }) {
-        // Create a unique key for this polling task
-        const taskKey = `${endpoint}-${JSON.stringify(params)}-${JSON.stringify(data)}`;
-        // Stop existing polling for this endpoint if it exists
-        if (this.pollingTasks.has(taskKey)) {
-            this.pollingTasks.get(taskKey)?.controller.abort();
-            this.pollingTasks.delete(taskKey);
-        }
-        // Create a new abort controller for cancellation
-        const controller = new AbortController();
-        const signal = controller.signal;
-        // Start the polling
-        (async () => {
-            while (!signal.aborted) {
-                try {
-                    const response = await this.maestroApiRequest({
-                        endpoint,
-                        method,
-                        params,
-                        data,
-                        headers,
-                        maestroDefaultHeaders,
-                        skipResponseBodyDeserialization,
-                        useCache: false, // Don't use cache for polling
-                    });
-                    // Call the callback with the data
-                    onData(response);
-                }
-                catch (error) {
-                    // Call the error callback if provided
-                    if (onError) {
-                        onError(error);
-                    }
-                }
-                // Wait for the interval before next poll
-                if (!signal.aborted) {
-                    await new Promise((resolve) => setTimeout(resolve, interval));
-                }
-            }
-        })();
-        // Store the controller for later cancellation
-        this.pollingTasks.set(taskKey, { controller, interval });
-        // Return a function to stop polling
-        return {
-            stop: () => {
-                if (this.pollingTasks.has(taskKey)) {
-                    this.pollingTasks.get(taskKey)?.controller.abort();
-                    this.pollingTasks.delete(taskKey);
-                }
-            },
-        };
-    }
-    /**
-     * Start polling an external API endpoint at specified interval
-     */
-    pollExternalApiRequest({ endpoint, interval, method = HttpMethod.GET, params = {}, data = null, headers = {}, skipResponseBodyDeserialization = false, onData, onError, }) {
-        // Create a unique key for this polling task
-        const taskKey = `external-${endpoint}-${JSON.stringify(params)}-${JSON.stringify(data)}`;
-        // Stop existing polling for this endpoint if it exists
-        if (this.pollingTasks.has(taskKey)) {
-            this.pollingTasks.get(taskKey)?.controller.abort();
-            this.pollingTasks.delete(taskKey);
-        }
-        // Create a new abort controller for cancellation
-        const controller = new AbortController();
-        const signal = controller.signal;
-        // Start the polling
-        (async () => {
-            while (!signal.aborted) {
-                try {
-                    const response = await this.externalApiRequest({
-                        endpoint,
-                        method,
-                        params,
-                        data,
-                        headers,
-                        skipResponseBodyDeserialization,
-                        useCache: false, // Don't use cache for polling
-                    });
-                    // Call the callback with the data
-                    onData(response);
-                }
-                catch (error) {
-                    // Call the error callback if provided
-                    if (onError) {
-                        onError(error);
-                    }
-                }
-                // Wait for the interval before next poll
-                if (!signal.aborted) {
-                    await new Promise((resolve) => setTimeout(resolve, interval));
-                }
-            }
-        })();
-        // Store the controller for later cancellation
-        this.pollingTasks.set(taskKey, { controller, interval });
-        // Return a function to stop polling
-        return {
-            stop: () => {
-                if (this.pollingTasks.has(taskKey)) {
-                    this.pollingTasks.get(taskKey)?.controller.abort();
-                    this.pollingTasks.delete(taskKey);
-                }
-            },
-        };
-    }
-    /**
-     * Stop all polling tasks
-     */
-    stopAllPolling() {
-        for (const [key, { controller }] of this.pollingTasks.entries()) {
-            controller.abort();
-            this.pollingTasks.delete(key);
-        }
-    }
-    /**
-     * Clear all cached data
-     */
-    clearAllCache() {
-        const originalLength = this.localStorage.length;
-        for (let i = 0; i < originalLength; i++) {
-            const key = this.localStorage.key(i);
-            if (key && key.startsWith('maestro-cache-')) {
-                this.localStorage.removeItem(key);
-            }
-        }
-    }
-}
-// Export singleton instance as default
-export default NetworkManager;

package/dist/services/NetworkManager/errors.js

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

package/dist/services/StatsService.js

@@ -1,68 +0,0 @@
-import NetworkManager, { HttpMethod } from './NetworkManager/NetworkManager';
-/**
- * Service for handling stats-related API calls
- */
-class StatsService {
-    constructor(delegate) {
-        Object.defineProperty(this, "networkManager", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.networkManager = NetworkManager.getInstance({
-            externalBaseURL: delegate.getBettingAPIBaseURL(),
-        });
-    }
-    /**
-     * Get stats for an event
-     *
-     * @param eventID - The ID of the event
-     * @param gameState - Optional game state filter (e.g., 'pre', 'in', 'post')
-     * @returns Promise with the stats data
-     */
-    async getStats(eventID, gameState) {
-        const params = {};
-        if (gameState) {
-            params.gameState = gameState;
-        }
-        return this.networkManager.externalApiRequest({
-            endpoint: this.statsEndpoint(eventID),
-            method: HttpMethod.GET,
-            params,
-            headers: {},
-        });
-    }
-    /**
-     * Start polling for stats
-     *
-     * @param eventID - The ID of the event
-     * @param gameState - Optional game state filter (e.g., 'pre', 'in', 'post')
-     * @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
-     */
-    pollStats(eventID, gameState, interval, onData, onError) {
-        const params = {};
-        if (gameState) {
-            params.gameState = gameState;
-        }
-        return this.networkManager.pollExternalApiRequest({
-            endpoint: this.statsEndpoint(eventID),
-            interval,
-            method: HttpMethod.GET,
-            params,
-            headers: {},
-            onData,
-            onError,
-        });
-    }
-    /**
-     * Get the endpoint for stats
-     */
-    statsEndpoint(eventID) {
-        return `/v4/events/${eventID}/stats`;
-    }
-}
-export default StatsService;

package/dist/services/ThemeManager/constants.js

@@ -1,47 +0,0 @@
-import { BORDER_RADIUS, TEXT_CAPITALIZATION, THEME_MODES, THEME_TYPES, } from '@/models/ITheme';
-const FONT_FAMILY = 'BentonSans-Medium';
-export const DARK_THEME = {
-    _id: '6274067af74b66a544018dac',
-    button: {
-        borderRadius: BORDER_RADIUS.rounded,
-        textCapitalization: TEXT_CAPITALIZATION.uppercase,
-    },
-    colors: {
-        // Accent colors
-        accentPrimary: '#FFFFFF',
-        // Secondary accent colors
-        accentSecondary: '#3C3F47',
-        // Tertiary accent colors
-        accentTertiary: '#0C0C0E',
-        // Surface Colors
-        surface1: '#080A0C',
-        surface2: '#12141A',
-        surface3: '#1B1E26',
-        surface4: '#242833',
-        surface5: '#363C4D',
-        surface6: '#3E4759',
-        // Highlight colors
-        highlightPrimary: '#FFFFFF',
-        highlightSecondary: '#9A9EA9',
-        highlightTertiary: '#0A0C0F',
-        // Alert colors
-        alertConfirmation: '#43D48F',
-        alertWarning: '#F58B00',
-        alertError: '#FF0000',
-        // Text colors
-        text100: '#F8F9FA',
-        text200: '#C2C5CB',
-        text300: '#8D919D',
-        text400: '#5C606B',
-        text500: '#0C0C0E',
-    },
-    creator: '016901e60000000000000000',
-    name: 'Dark Mode',
-    type: THEME_TYPES.CLASSIC,
-    mode: THEME_MODES.DARK,
-    owner: '016901e60000000000000000',
-    typography: {
-        body: FONT_FAMILY,
-        headline: FONT_FAMILY,
-    },
-};

package/dist/test-polyfills.js

@@ -1,15 +0,0 @@
-// This file must be the first import in test files
-// Handle globalThis for Node.js < 12
-if (typeof globalThis === 'undefined') {
-    global.globalThis = global;
-}
-// Polyfill for FinalizationRegistry in Node.js < 14.6.0
-const globalWithFR = globalThis;
-if (typeof globalWithFR.FinalizationRegistry === 'undefined') {
-    globalWithFR.FinalizationRegistry = class FinalizationRegistry {
-        constructor(_callback) { }
-        register(_target, _heldValue, _unregisterToken) { }
-        unregister(_unregisterToken) { }
-    };
-}
-export {};

package/dist/types/OverlayTypes.js

@@ -1,4 +0,0 @@
-export const OverlayType = {
-    WinningBet: 'winningBet',
-    FantasyPlayerEvent: 'fantasyPlayerEvent',
-};