@maestro_io/maestro-web-sdk 4.0.0-beta.3 → 4.0.0-beta.5

package/dist/src/modules/shop/view-model/ShopViewModel.ShopPolling.js

@@ -1,111 +0,0 @@
-import { captureException } from '@/sentry';
-import { stringHashCode } from '@/helpers/strings';
-const DEFAULT_SHOP_POLLING_INTERVAL = 30000; // 30 seconds
-export default class ShopPolling {
-    constructor(service) {
-        Object.defineProperty(this, "polling", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {
-                interval: DEFAULT_SHOP_POLLING_INTERVAL,
-                task: null,
-                lastResponseHash: null,
-            }
-        });
-        Object.defineProperty(this, "shopService", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.shopService = service;
-    }
-    /**
-     * Refresh polling for shop data
-     */
-    refresh(callback) {
-        // First stop any existing polling
-        this.stop();
-        // Start the poll loop
-        this.start(callback);
-    }
-    /**
-     * Stop polling for shop data
-     */
-    stop() {
-        if (this.polling.task) {
-            this.polling.task.stop();
-            this.polling.task = null;
-        }
-    }
-    removeLastResponseHash() {
-        this.polling.lastResponseHash = null;
-    }
-    start(callback) {
-        try {
-            this.polling.task = this.shopService.pollShopData(this.polling.interval, (response) => {
-                this.updateInterval(response.headers, callback);
-                this.processPolledData(response.data, callback);
-            }, (error) => this.handlePollingError(error));
-        }
-        catch (error) {
-            captureException(error, {
-                context: 'ShopViewModel.pollShop',
-            });
-            console.error('[SHOP] Error setting up shop polling:', error);
-        }
-    }
-    /**
-     * @description Update polling interval checking either response header or panel config.
-     * Refresh polling if necessary.
-     */
-    updateInterval(headers, callback) {
-        const headerInterval = this.getResponseHeaderPollingIntervalValue(headers);
-        // Only update if we have a valid new interval and it's different from current
-        if (headerInterval && headerInterval !== this.polling.interval) {
-            console.log(`[SHOP] Updating shop polling interval from ${this.polling.interval}ms to ${headerInterval}ms`);
-            this.polling.interval = headerInterval;
-            // Restart polling with the new interval
-            this.refresh(callback);
-        }
-    }
-    getResponseHeaderPollingIntervalValue(headers) {
-        const newInterval = headers['polling-interval'];
-        if (!newInterval) {
-            return null;
-        }
-        const parsedInterval = parseInt(newInterval, 10);
-        if (isNaN(parsedInterval) || parsedInterval <= 0) {
-            console.warn(`[SHOP] Invalid polling interval header received: ${newInterval}.`);
-            return null;
-        }
-        return parsedInterval * 1000; // Convert seconds to milliseconds
-    }
-    /**
-     * Process data received from polling
-     */
-    processPolledData(data, callback) {
-        // Calculate hash for the response to check if it's different from the last one
-        const responseHash = stringHashCode(JSON.stringify(data));
-        // Check if this is the same as the last successful response
-        if (this.polling.lastResponseHash === responseHash) {
-            console.log('[SHOP] Shop Response hash is the same as last successful response - skipping update');
-            return;
-        }
-        this.polling.lastResponseHash = responseHash;
-        callback(data);
-    }
-    /**
-     * Handle errors that occur during shop polling
-     */
-    handlePollingError(error) {
-        console.error('[SHOP] Shop polling error:', error);
-        captureException(error, {
-            context: 'ShopViewModel.pollShop',
-            extra: {
-                pollingInterval: this.polling.interval,
-            },
-        });
-    }
-}

package/dist/src/modules/shop/view-model/ShopViewModel.d.ts

@@ -1,77 +0,0 @@
-import { Observable } from '../../../helpers/Observable';
-import { ViewModel } from '../../../view-models/ViewModel';
-import { IShopSection, IShopProduct, IShopBrowseCard, IShopDefaultItem } from '../types';
-import { TestUseCase } from '@/interfaces/IMaestroEvent';
-declare const SHOP_ERROR_STATE: {
-    readonly NONE: "none";
-    readonly TAB_LOAD_FAILURE: "tabLoadFailure";
-    readonly EMPTY_SHOP: "emptyShop";
-};
-export type ShopErrorState = typeof SHOP_ERROR_STATE[keyof typeof SHOP_ERROR_STATE];
-/**
- * ViewModel for Shop panel
- * Manages shop data fetching, polling, and state
- */
-export declare class ShopViewModel extends ViewModel {
-    sections: Observable<IShopSection[]>;
-    isDataLoading: Observable<boolean>;
-    errorState: Observable<ShopErrorState>;
-    hasEverSuccessfullyLoaded: Observable<boolean>;
-    promoData: Observable<IShopDefaultItem | null>;
-    private shopService;
-    private analyticsService;
-    private shopPolling;
-    private useMockData;
-    private mockDataType;
-    initialized: boolean;
-    constructor(eventId: string, options?: {
-        useMockData?: boolean;
-        mockDataType?: 'nfl' | 'nba' | 'ncf' | 'empty' | 'single';
-    });
-    /**
-     * Initialize the ViewModel and start data fetching
-     */
-    init(): void;
-    /**
-     * Clean up resources when the ViewModel is no longer needed
-     */
-    cleanup(): void;
-    /**
-     * Track panel view event
-     */
-    private trackPanelView;
-    /**
-     * Parse price string to number, handling currency formats
-     */
-    private parsePriceToNumber;
-    /**
-     * Track shop item card click event
-     */
-    trackItemClick(card: 'product_summary' | 'want more' | 'product_detail' | 'fallback', item: IShopProduct | IShopBrowseCard | null, section: IShopSection | null): Promise<void>;
-    /**
-     * Refresh polling for shop data
-     */
-    refreshPolling(): void;
-    /**
-     * Process the shop data and update the sections
-     */
-    private processShopData;
-    setTabLoadFailure(): void;
-    /**
-     * Fetch new shop data immediately (one-time)
-     */
-    fetchNewData(): void;
-    /**
-     * Fetch mock data for testing
-     */
-    private fetchMockData;
-    /**
-     * Simulate different use cases for testing
-     */
-    simulateUseCase<T = any>(useCase: TestUseCase, data: T): void;
-    /**
-     * Clear tab load failure and retry
-     */
-    clearTabLoadFailure(): void;
-}
-export default ShopViewModel;

package/dist/src/modules/shop/view-model/ShopViewModel.js

@@ -1,353 +0,0 @@
-import { Observable } from '../../../helpers/Observable';
-import ShopService from '../../../services/ShopService';
-import AnalyticsService from '../../../services/AnalyticsService/AnalyticsService';
-import { ViewModel } from '../../../view-models/ViewModel';
-import { isShopProduct, } from '../types';
-import { MOCK_SHOP_NFL_RESPONSE, MOCK_SHOP_NBA_RESPONSE, MOCK_SHOP_NCF_RESPONSE, MOCK_SHOP_EMPTY_RESPONSE, MOCK_SHOP_SINGLE_SECTION_RESPONSE, } from '../mocks';
-import { captureException } from '@/sentry';
-import ShopPolling from './ShopViewModel.ShopPolling';
-import SDK from '@/index';
-const SHOP_ERROR_STATE = {
-    NONE: 'none',
-    TAB_LOAD_FAILURE: 'tabLoadFailure',
-    EMPTY_SHOP: 'emptyShop',
-};
-/**
- * ViewModel for Shop panel
- * Manages shop data fetching, polling, and state
- */
-export class ShopViewModel extends ViewModel {
-    constructor(eventId, options = {}) {
-        super();
-        // Observable properties
-        Object.defineProperty(this, "sections", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Observable([])
-        });
-        Object.defineProperty(this, "isDataLoading", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Observable(true)
-        });
-        Object.defineProperty(this, "errorState", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Observable('none')
-        });
-        Object.defineProperty(this, "hasEverSuccessfullyLoaded", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Observable(false)
-        });
-        Object.defineProperty(this, "promoData", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Observable(null)
-        });
-        // Properties
-        Object.defineProperty(this, "shopService", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "analyticsService", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "shopPolling", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "useMockData", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "mockDataType", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'nfl'
-        });
-        Object.defineProperty(this, "initialized", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        this.shopService = new ShopService(eventId);
-        this.analyticsService = new AnalyticsService();
-        this.shopPolling = new ShopPolling(this.shopService);
-        this.useMockData = options.useMockData || false;
-        this.mockDataType = options.mockDataType || 'nfl';
-    }
-    /**
-     * Initialize the ViewModel and start data fetching
-     */
-    init() {
-        // Track panel view on initialization
-        this.trackPanelView();
-        this.fetchNewData();
-        this.initialized = true;
-    }
-    /**
-     * Clean up resources when the ViewModel is no longer needed
-     */
-    cleanup() {
-        this.shopPolling.stop();
-        this.initialized = false;
-    }
-    /**
-     * Track panel view event
-     */
-    async trackPanelView() {
-        try {
-            await this.analyticsService.panelView('espnShop', {});
-        }
-        catch (error) {
-            captureException(error, {
-                context: 'ShopViewModel.trackPanelView',
-            });
-            console.error('[SHOP] Error tracking panel view:', error);
-        }
-    }
-    /**
-     * Parse price string to number, handling currency formats
-     */
-    parsePriceToNumber(priceString) {
-        // Remove currency symbols and spaces
-        const cleaned = priceString.replace(/[^0-9.,]/g, '');
-        // Find the last occurrence of comma or dot (decimal separator)
-        const lastComma = cleaned.lastIndexOf(',');
-        const lastDot = cleaned.lastIndexOf('.');
-        let normalized;
-        if (lastComma > lastDot) {
-            // EU format: €1.234,56 -> comma is decimal separator
-            normalized = cleaned.replace(/\./g, '').replace(',', '.');
-        }
-        else if (lastDot > lastComma) {
-            // US format: $1,234.56 -> dot is decimal separator
-            normalized = cleaned.replace(/,/g, '');
-        }
-        else if (lastComma !== -1) {
-            // Only comma present, assume decimal: €25,00
-            normalized = cleaned.replace(',', '.');
-        }
-        else if (lastDot !== -1) {
-            // Only dot present, assume decimal: $25.00
-            normalized = cleaned;
-        }
-        else {
-            // No separators: 25
-            normalized = cleaned;
-        }
-        return Number(normalized) || 0;
-    }
-    /**
-     * Track shop item card click event
-     */
-    async trackItemClick(card, item, section) {
-        try {
-            let sale = 0;
-            let price = null;
-            const gameState = SDK.getMaestroEventViewModel().statsViewModel?.currentGameState.value ||
-                'unknown';
-            if (item && isShopProduct(item)) {
-                const basePrice = item.price?.displayRetail;
-                const currentPrice = item.price?.displayClearance ||
-                    item.price?.displaySale ||
-                    item.price?.displayRetail;
-                if (currentPrice && basePrice) {
-                    const basePriceNumber = this.parsePriceToNumber(basePrice);
-                    const salePriceNumber = this.parsePriceToNumber(currentPrice);
-                    if (basePriceNumber > 0) {
-                        sale = Math.round((1 - salePriceNumber / basePriceNumber) * 100);
-                    }
-                    else {
-                        sale = 0;
-                    }
-                    price = currentPrice;
-                }
-            }
-            await this.analyticsService.panelClick({
-                type: 'espnShop',
-                name: 'shop_item_clicked',
-                metadata: {
-                    card: [card],
-                    game_state: [gameState],
-                    product: section?.product?.id || null,
-                    entity_type: [section?.product?.type || 'unknown'],
-                    entity_name: [section?.product?.shortDisplayName || 'unknown'],
-                    price,
-                    sale: [`${sale}%`],
-                },
-            });
-        }
-        catch (error) {
-            captureException(error, {
-                context: 'ShopViewModel.trackItemClick',
-                item,
-                section,
-            });
-            console.error('[SHOP] Error tracking shop item click:', error);
-        }
-    }
-    /**
-     * Refresh polling for shop data
-     */
-    refreshPolling() {
-        try {
-            if (this.useMockData) {
-                return;
-            }
-            this.shopPolling.refresh(this.processShopData.bind(this));
-        }
-        catch (err) {
-            this.setTabLoadFailure();
-        }
-    }
-    /**
-     * Process the shop data and update the sections
-     */
-    processShopData(data) {
-        try {
-            const shop = data.shop?.[0];
-            const sections = shop?.sections || [];
-            // Check if there are any sections
-            if (!sections?.length && shop?.defaultItem) {
-                this.errorState.value = 'emptyShop';
-                this.sections.value = [];
-                this.promoData.value = shop.defaultItem;
-                return;
-            }
-            // Update sections and clear error state
-            this.sections.value = sections;
-            this.errorState.value = 'none';
-            this.hasEverSuccessfullyLoaded.value = true;
-            if (this.isDataLoading.value) {
-                this.isDataLoading.value = false;
-            }
-        }
-        catch (err) {
-            captureException(err, {
-                context: 'ShopViewModel.processShopData',
-            });
-            console.error('[SHOP] Error processing shop data:', err);
-            this.setTabLoadFailure();
-        }
-    }
-    setTabLoadFailure() {
-        if (!this.hasEverSuccessfullyLoaded.value) {
-            this.errorState.value = 'tabLoadFailure';
-            this.sections.value = [];
-        }
-        if (this.isDataLoading.value) {
-            this.isDataLoading.value = false;
-        }
-    }
-    /**
-     * Fetch new shop data immediately (one-time)
-     */
-    fetchNewData() {
-        this.isDataLoading.value = true;
-        try {
-            // Handle mock data if enabled
-            if (this.useMockData) {
-                this.sections.value = [];
-                this.fetchMockData();
-                return;
-            }
-            this.refreshPolling();
-        }
-        catch (error) {
-            captureException(error, {
-                context: 'ShopViewModel.fetchNewData',
-            });
-            console.error('[SHOP] Error fetching shop data:', error);
-            this.setTabLoadFailure();
-        }
-    }
-    /**
-     * Fetch mock data for testing
-     */
-    fetchMockData() {
-        let mockData;
-        switch (this.mockDataType) {
-            case 'nba':
-                mockData = MOCK_SHOP_NBA_RESPONSE;
-                break;
-            case 'ncf':
-                mockData = MOCK_SHOP_NCF_RESPONSE;
-                break;
-            case 'empty':
-                mockData = MOCK_SHOP_EMPTY_RESPONSE;
-                break;
-            case 'single':
-                mockData = MOCK_SHOP_SINGLE_SECTION_RESPONSE;
-                break;
-            case 'nfl':
-            default:
-                mockData = MOCK_SHOP_NFL_RESPONSE;
-                break;
-        }
-        this.processShopData(mockData);
-        this.hasEverSuccessfullyLoaded.value = true;
-        this.isDataLoading.value = false;
-    }
-    /**
-     * Simulate different use cases for testing
-     */
-    simulateUseCase(useCase, data) {
-        switch (useCase) {
-            case 'shopTabLoadFailure':
-                this.errorState.value = 'tabLoadFailure';
-                this.sections.value = [];
-                break;
-            case 'shopEmptyState':
-                this.errorState.value = 'emptyShop';
-                this.sections.value = [];
-                break;
-            case 'shopMockData':
-                this.shopPolling.stop();
-                this.useMockData = true;
-                this.mockDataType = data?.mockDataType || 'nfl';
-                this.shopPolling.removeLastResponseHash();
-                this.errorState.value = 'none';
-                this.fetchNewData();
-                break;
-            case 'shopLiveData':
-                this.useMockData = false;
-                this.shopPolling.removeLastResponseHash();
-                this.hasEverSuccessfullyLoaded.value = false;
-                this.errorState.value = 'none';
-                this.fetchNewData();
-                this.refreshPolling();
-                break;
-            default:
-                throw new Error(`Unsupported use case: ${useCase}`);
-        }
-    }
-    /**
-     * Clear tab load failure and retry
-     */
-    clearTabLoadFailure() {
-        this.errorState.value = 'none';
-        this.shopPolling.removeLastResponseHash();
-        setTimeout(() => {
-            this.refreshPolling();
-        }, 100);
-    }
-}
-export default ShopViewModel;