@maestro_io/maestro-web-sdk 2.1.2 → 2.2.0

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/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',
-};

package/dist/view-models/MaestroEventViewModel.js

@@ -1,156 +0,0 @@
-import { Observable } from '../helpers/Observable';
-import { ViewModel } from './ViewModel';
-import KeyPlaysViewModel from '../modules/key-plays/view-model/KeyPlaysViewModel';
-import BetsViewModel from '../modules/bets/view-model/BetsViewModel';
-import SpatialNavigation from '@/external/spatial-navigation/spatialNavigation';
-import StatsViewModel from '../modules/stats/view-model/StatsViewModel';
-export class MaestroEventViewModel extends ViewModel {
-    constructor(eventId = '', delegate) {
-        super();
-        Object.defineProperty(this, "_eventId", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Observable('')
-        });
-        Object.defineProperty(this, "_title", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Observable('')
-        });
-        Object.defineProperty(this, "_isLive", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Observable(false)
-        });
-        Object.defineProperty(this, "_isShowingPanel", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Observable(false)
-        });
-        Object.defineProperty(this, "delegate", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "keyPlaysViewModel", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new KeyPlaysViewModel()
-        });
-        Object.defineProperty(this, "betsViewModel", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "statsViewModel", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this._eventId.value = eventId;
-        this.delegate = delegate;
-        this.betsViewModel = new BetsViewModel(eventId, delegate);
-        this.statsViewModel = new StatsViewModel(eventId, { useMockData: true });
-        SpatialNavigation.init();
-    }
-    deinit() {
-        this.betsViewModel.cleanup();
-        this.statsViewModel.cleanup();
-        SpatialNavigation.destroy();
-    }
-    updateKeyPlaysData(data) {
-        return this.keyPlaysViewModel.setKeyPlays(data);
-    }
-    startFocusManagement() {
-        SpatialNavigation.setFocus('');
-        SpatialNavigation.resume();
-        setTimeout(() => {
-            SpatialNavigation.setFocus('PANEL_NAV_BUTTON_0');
-        }, 0);
-        return Promise.resolve();
-    }
-    didStartPlayingClip(index) {
-        this.keyPlaysViewModel.lastPlayedClipIndex.value = index;
-        this.keyPlaysViewModel.currentClipPlaybackProgress.value = 0;
-        this.keyPlaysViewModel.currentlyPlayingClipIndex.value = index;
-        this.keyPlaysViewModel.clearLoadFailureStatus(index);
-    }
-    didStopPlayingClip(index) {
-        this.keyPlaysViewModel.lastPlayedClipIndex.value = index;
-        this.keyPlaysViewModel.currentlyPlayingClipIndex.value = null;
-        this.keyPlaysViewModel.currentClipPlaybackProgress.value = null;
-    }
-    didFailToPlayClip(index) {
-        this.keyPlaysViewModel.handleKeyPlayLoadFailure(index);
-    }
-    didUpdatePlaybackProgressOfClip(index, to) {
-        this.keyPlaysViewModel.currentClipPlaybackProgress.value = to;
-        this.keyPlaysViewModel.clearLoadFailureStatus(index);
-    }
-    didShowPanel() {
-        this.isShowingPanel = true;
-        // Analytics call ?
-        return Promise.resolve();
-    }
-    async didHidePanel() {
-        this.isShowingPanel = false;
-        SpatialNavigation.pause();
-        // Analytics call?
-    }
-    didShowOverlay() {
-        throw new Error('Method not implemented.');
-    }
-    didHideOverlay() {
-        throw new Error('Method not implemented.');
-    }
-    currentEventDoesNotSupportKeyPlays() {
-        this.keyPlaysViewModel.errorState.value = 'unsupportedEvent';
-    }
-    getCurrentEventID() {
-        return this.eventId.value;
-    }
-    getCurrentlyPlayingClipIndex() {
-        return this.keyPlaysViewModel.currentlyPlayingClipIndex.value;
-    }
-    getLastPlayedClipIndex() {
-        return this.keyPlaysViewModel.lastPlayedClipIndex.value;
-    }
-    getCurrentClipPlaybackProgress() {
-        return this.keyPlaysViewModel.currentClipPlaybackProgress.value;
-    }
-    getKeyPlaysCount() {
-        return this.keyPlaysViewModel.allItems.length;
-    }
-    get eventId() {
-        return this._eventId;
-    }
-    get title() {
-        return this._title;
-    }
-    get isLive() {
-        return this._isLive;
-    }
-    get isShowingPanel() {
-        return this._isShowingPanel.value;
-    }
-    set isShowingPanel(value) {
-        this._isShowingPanel.value = value;
-    }
-    simulateUseCase(useCase, panelType, testData) {
-        switch (panelType) {
-            case 'bets':
-                this.betsViewModel.simulateUseCase(useCase, testData);
-                break;
-            default:
-                throw new Error(`Unsupported panel type: ${panelType}`);
-        }
-    }
-}