@maestro_io/maestro-web-sdk 2.1.1 → 2.1.2

package/dist/external/spatial-navigation/utils.js

@@ -0,0 +1,6 @@
+export const DIRECTION_LEFT = 'left';
+export const DIRECTION_RIGHT = 'right';
+export const DIRECTION_UP = 'up';
+export const DIRECTION_DOWN = 'down';
+export const KEY_ENTER = 'enter';
+export const KEY_BACK = 'back';

package/dist/external/spatial-navigation/visualDebugger.js

@@ -0,0 +1,76 @@
+// We'll make VisualDebugger no-op for any environments lacking a DOM (e.g. SSR and React Native non-web platforms).
+const hasDOM = typeof window !== 'undefined' && window.document;
+const WIDTH = hasDOM ? window.innerWidth : 0;
+const HEIGHT = hasDOM ? window.innerHeight : 0;
+class VisualDebugger {
+    constructor() {
+        Object.defineProperty(this, "debugCtx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "layoutsCtx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (hasDOM) {
+            this.debugCtx = VisualDebugger.createCanvas('sn-debug', 1010);
+            this.layoutsCtx = VisualDebugger.createCanvas('sn-layouts', 1000);
+        }
+        else {
+            this.debugCtx = null;
+            this.layoutsCtx = null;
+        }
+    }
+    static createCanvas(id, zIndex) {
+        const canvas = (document.querySelector(`#${id}`) ||
+            document.createElement('canvas'));
+        canvas.setAttribute('id', id);
+        const ctx = canvas.getContext('2d');
+        if (!ctx) {
+            throw new Error('Could not get 2d context from canvas');
+        }
+        canvas.style.cssText = `position: fixed; top: 0; left: 0; z-index: ${zIndex}`;
+        document.body.appendChild(canvas);
+        canvas.width = WIDTH;
+        canvas.height = HEIGHT;
+        return ctx;
+    }
+    clear() {
+        if (!hasDOM || !this.debugCtx) {
+            return;
+        }
+        this.debugCtx.clearRect(0, 0, WIDTH, HEIGHT);
+    }
+    clearLayouts() {
+        if (!hasDOM || !this.layoutsCtx) {
+            return;
+        }
+        this.layoutsCtx.clearRect(0, 0, WIDTH, HEIGHT);
+    }
+    drawLayout(layout, focusKey, parentFocusKey) {
+        if (!hasDOM || !this.layoutsCtx) {
+            return;
+        }
+        this.layoutsCtx.strokeStyle = 'green';
+        this.layoutsCtx.strokeRect(layout.left, layout.top, layout.width, layout.height);
+        this.layoutsCtx.font = '8px monospace';
+        this.layoutsCtx.fillStyle = 'red';
+        this.layoutsCtx.fillText(focusKey, layout.left, layout.top + 10);
+        this.layoutsCtx.fillText(parentFocusKey, layout.left, layout.top + 25);
+        this.layoutsCtx.fillText(`left: ${layout.left}`, layout.left, layout.top + 40);
+        this.layoutsCtx.fillText(`top: ${layout.top}`, layout.left, layout.top + 55);
+    }
+    drawPoint(x, y, color = 'blue', size = 10) {
+        if (!hasDOM || !this.debugCtx) {
+            return;
+        }
+        this.debugCtx.strokeStyle = color;
+        this.debugCtx.lineWidth = 3;
+        this.debugCtx.strokeRect(x - size / 2, y - size / 2, size, size);
+    }
+}
+export default VisualDebugger;

package/dist/external/spatial-navigation/withFocusable.js

@@ -0,0 +1,238 @@
+/* eslint-disable react/no-find-dom-node */
+import { findDOMNode } from 'react-dom';
+import PropTypes from 'prop-types';
+import { Component, createElement } from 'react';
+import SpatialNavigation, { ROOT_FOCUS_KEY } from './spatialNavigation';
+// Helper functions to replace lodash and recompose
+const uniqueId = (prefix) => `${prefix}${Math.random().toString(36).substr(2, 9)}`;
+const noop = () => { };
+const omit = (obj, keys) => {
+    const result = { ...obj };
+    keys.forEach((key) => delete result[key]);
+    return result;
+};
+const withFocusable = ({ forgetLastFocusedChild: configForgetLastFocusedChild = false, trackChildren: configTrackChildren = false, autoRestoreFocus: configAutoRestoreFocus, blockNavigationOut: configBlockNavigationOut = false, } = {}) => {
+    return (WrappedComponent) => {
+        var _a;
+        return _a = class WithFocusable extends Component {
+                constructor() {
+                    super(...arguments);
+                    Object.defineProperty(this, "state", {
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                        value: {
+                            realFocusKey: this.props.focusKey || uniqueId('sn:focusable-item-'),
+                            focused: false,
+                            hasFocusedChild: false,
+                            parentFocusKey: this.props.parentFocusKey || ROOT_FOCUS_KEY,
+                        }
+                    });
+                    Object.defineProperty(this, "setFocus", {
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                        value: (focusKey) => {
+                            if (!SpatialNavigation.isNativeMode()) {
+                                SpatialNavigation.setFocus(focusKey);
+                            }
+                        }
+                    });
+                    Object.defineProperty(this, "navigateByDirection", {
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                        value: SpatialNavigation.navigateByDirection
+                    });
+                    Object.defineProperty(this, "stealFocus", {
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                        value: () => {
+                            SpatialNavigation.setFocus(this.state.realFocusKey, {
+                                focusKey: this.state.realFocusKey,
+                            });
+                        }
+                    });
+                    Object.defineProperty(this, "onUpdateFocus", {
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                        value: (focused) => {
+                            this.setState({ focused });
+                        }
+                    });
+                    Object.defineProperty(this, "onUpdateHasFocusedChild", {
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                        value: (hasFocusedChild) => {
+                            this.setState({ hasFocusedChild });
+                        }
+                    });
+                    Object.defineProperty(this, "onEnterPressHandler", {
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                        value: (details) => {
+                            const { onEnterPress = noop, ...rest } = this.props;
+                            onEnterPress(rest, details);
+                        }
+                    });
+                    Object.defineProperty(this, "onEnterReleaseHandler", {
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                        value: () => {
+                            const { onEnterRelease = noop, ...rest } = this.props;
+                            onEnterRelease(rest);
+                        }
+                    });
+                    Object.defineProperty(this, "onBackPressHandler", {
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                        value: (details) => {
+                            const { onBackPress = noop, ...rest } = this.props;
+                            onBackPress(rest, details);
+                        }
+                    });
+                    Object.defineProperty(this, "onArrowPressHandler", {
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                        value: (direction, details) => {
+                            const { onArrowPress = noop, ...rest } = this.props;
+                            return onArrowPress(direction, rest, details);
+                        }
+                    });
+                    Object.defineProperty(this, "onBecameFocusedHandler", {
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                        value: (layout, details) => {
+                            const { onBecameFocused = noop, ...rest } = this.props;
+                            onBecameFocused(layout, rest, details);
+                        }
+                    });
+                    Object.defineProperty(this, "onBecameBlurredHandler", {
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                        value: (layout, details) => {
+                            const { onBecameBlurred = noop, ...rest } = this.props;
+                            onBecameBlurred(layout, rest, details);
+                        }
+                    });
+                }
+                getChildContext() {
+                    return {
+                        parentFocusKey: this.state.realFocusKey,
+                    };
+                }
+                componentDidMount() {
+                    const { realFocusKey: focusKey, parentFocusKey } = this.state;
+                    const { preferredChildFocusKey, forgetLastFocusedChild = false, trackChildren, focusable = true, autoRestoreFocus = true, blockNavigationOut = false, } = this.props;
+                    let node;
+                    if (SpatialNavigation.isNativeMode()) {
+                        node = document.createElement('div');
+                    }
+                    else {
+                        const domNode = findDOMNode(this);
+                        if (!domNode) {
+                            throw new Error('Could not find DOM node');
+                        }
+                        node = domNode;
+                    }
+                    SpatialNavigation.addFocusable({
+                        focusKey,
+                        node,
+                        parentFocusKey,
+                        preferredChildFocusKey,
+                        onEnterPressHandler: this.onEnterPressHandler,
+                        onEnterReleaseHandler: this.onEnterReleaseHandler,
+                        onBackPressHandler: this.onBackPressHandler,
+                        onArrowPressHandler: this.onArrowPressHandler,
+                        onBecameFocusedHandler: this.onBecameFocusedHandler,
+                        onBecameBlurredHandler: this.onBecameBlurredHandler,
+                        onUpdateFocus: this.onUpdateFocus,
+                        onUpdateHasFocusedChild: this.onUpdateHasFocusedChild,
+                        forgetLastFocusedChild: configForgetLastFocusedChild || forgetLastFocusedChild,
+                        trackChildren: configTrackChildren || trackChildren,
+                        blockNavigationOut: configBlockNavigationOut || blockNavigationOut,
+                        autoRestoreFocus: configAutoRestoreFocus !== undefined
+                            ? configAutoRestoreFocus
+                            : autoRestoreFocus,
+                        focusable,
+                    });
+                }
+                componentDidUpdate() {
+                    const { realFocusKey: focusKey } = this.state;
+                    const { preferredChildFocusKey, focusable = true, blockNavigationOut = false, } = this.props;
+                    let node;
+                    if (SpatialNavigation.isNativeMode()) {
+                        node = document.createElement('div');
+                    }
+                    else {
+                        const domNode = findDOMNode(this);
+                        if (!domNode) {
+                            throw new Error('Could not find DOM node');
+                        }
+                        node = domNode;
+                    }
+                    SpatialNavigation.updateFocusable(focusKey, {
+                        node,
+                        preferredChildFocusKey,
+                        focusable,
+                        blockNavigationOut: configBlockNavigationOut || blockNavigationOut,
+                    });
+                }
+                componentWillUnmount() {
+                    const { realFocusKey: focusKey } = this.state;
+                    SpatialNavigation.removeFocusable({ focusKey });
+                }
+                render() {
+                    const props = {
+                        ...this.props,
+                        ...this.state,
+                        setFocus: this.setFocus,
+                        navigateByDirection: this.navigateByDirection,
+                        stealFocus: this.stealFocus,
+                        onUpdateFocus: this.onUpdateFocus,
+                        onUpdateHasFocusedChild: this.onUpdateHasFocusedChild,
+                    };
+                    const filteredProps = omit(props, [
+                        'onBecameFocusedHandler',
+                        'onBecameBlurredHandler',
+                        'onEnterPressHandler',
+                        'onEnterReleaseHandler',
+                        'onArrowPressHandler',
+                        'onUpdateFocus',
+                        'onUpdateHasFocusedChild',
+                        'forgetLastFocusedChild',
+                        'trackChildren',
+                        'autoRestoreFocus',
+                    ]);
+                    return createElement(WrappedComponent, filteredProps);
+                }
+            },
+            Object.defineProperty(_a, "contextTypes", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: {
+                    parentFocusKey: PropTypes.string,
+                }
+            }),
+            Object.defineProperty(_a, "childContextTypes", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: {
+                    parentFocusKey: PropTypes.string,
+                }
+            }),
+            _a;
+    };
+};
+export default withFocusable;

package/dist/helpers/Observable.js

@@ -0,0 +1,37 @@
+/**
+ * Basic observable implementation for view models
+ */
+export class Observable {
+    constructor(initialValue) {
+        Object.defineProperty(this, "listeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "_value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._value = initialValue;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(newValue) {
+        this._value = newValue;
+        this.notify();
+    }
+    subscribe(listener) {
+        this.listeners.push(listener);
+        // Return unsubscribe function
+        return () => {
+            this.listeners = this.listeners.filter((l) => l !== listener);
+        };
+    }
+    notify() {
+        this.listeners.forEach((listener) => listener(this._value));
+    }
+}

package/dist/helpers/deliver-focus.js

@@ -0,0 +1,12 @@
+import { pause } from '@/external/spatial-navigation';
+import SDK from '..';
+/**
+ * @description Useful when you want to lose the focus of the SDK and delegate it to the Client App.
+ */
+const deliverFocus = (e) => {
+    const eventVm = SDK.getMaestroEventViewModel();
+    e.dataset['focused'] = 'false';
+    pause();
+    eventVm.delegate.startFocusManagement();
+};
+export default deliverFocus;

package/dist/index.d.ts

@@ -2,11 +2,11 @@ import IMaestroEventDelegate from './interfaces/IMaestroEventDelegate';
 import IMaestroManager, { SDKConfigParams } from './interfaces/IMaestroManager';
 import IMaestroEvent from './interfaces/IMaestroEvent';
 import { MaestroEventViewModel } from './view-models/MaestroEventViewModel';
-import type IMaestroKeyPlaysResponse from './modules/key-plays/interfaces/IKeyPlaysResponse';
+import IMaestroKeyPlaysResponse from './modules/key-plays/interfaces/IKeyPlaysResponse';
 export { default as Overlay } from './components/molecules/Overlay/Overlay';
-export { OverlayType, type IMaestroOverlayEvent, type IOverlaySize, type IOverlayPosition, type IFantasyPayload, type IOverlayAnalyticsEvent } from './types/OverlayTypes';
-export { type IWinningBet } from './models/IWinningBet';
-export { type IMaestroEventDelegate, type IMaestroEvent, type IMaestroKeyPlaysResponse, };
+export { OverlayType, IMaestroOverlayEvent, IOverlaySize, IOverlayPosition, IFantasyPayload, IOverlayAnalyticsEvent, } from './types/OverlayTypes';
+export { IWinningBet } from './models/IWinningBet';
+export { IMaestroEventDelegate, IMaestroEvent, IMaestroKeyPlaysResponse };
 export type Environment = 'development' | 'staging' | 'production';
 /**
  * Main SDK class that serves as the entry point for the Maestro TV SDK

package/dist/index.js

@@ -0,0 +1,192 @@
+import ReactRenderer from './external/ReactRenderer';
+import { MaestroEventViewModel } from './view-models/MaestroEventViewModel';
+// Export overlay components and types for client apps
+export { default as Overlay } from './components/molecules/Overlay/Overlay';
+export { OverlayType, } from './types/OverlayTypes';
+const AUTHORIZED_CLIENTS = ['664b9c57d59a7a431542d814'];
+/**
+ * Main SDK class that serves as the entry point for the Maestro TV SDK
+ * Follows a singleton pattern similar to the Swift implementation
+ */
+class MaestroWebSDK {
+    constructor(renderer) {
+        Object.defineProperty(this, "renderer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "siteID", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "userID", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maestroJwt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "clientAppToken", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "clientAppSwid", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maestroEventViewModel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.renderer = renderer;
+    }
+    /**
+     * @description Returns the MaestroWebSDK instance
+     * @returns {MaestroWebSDK} - The MaestroWebSDK instance
+     */
+    static getInstance() {
+        if (!MaestroWebSDK.instance) {
+            const renderer = new ReactRenderer();
+            MaestroWebSDK.instance = new MaestroWebSDK(renderer);
+        }
+        return MaestroWebSDK.instance;
+    }
+    async userDidStartWatchingEvent(eventID, delegate) {
+        if (!this.isAuthorizedClient) {
+            throw new Error('Unauthorized use of SDK');
+        }
+        this.maestroEventViewModel = new MaestroEventViewModel(eventID, delegate);
+        return this.maestroEventViewModel;
+    }
+    userDidStopWatchingEvent(_) {
+        if (this.maestroEventViewModel) {
+            this.maestroEventViewModel.deinit();
+            this.maestroEventViewModel = null;
+        }
+    }
+    configure(configParams) {
+        if (configParams.siteID) {
+            this.setSiteID(configParams.siteID);
+        }
+        if (configParams.maestroJwt) {
+            this.setMaestroJwt(configParams.maestroJwt);
+        }
+        if (configParams.clientAppToken) {
+            this.setClientAppToken(configParams.clientAppToken);
+        }
+        if (configParams.clientAppSwid) {
+            this.setClientAppSwid(configParams.clientAppSwid);
+        }
+        console.info('MaestroWebSDK configured', configParams);
+    }
+    /**
+     * Checks if this is an authorized client based on siteID
+     */
+    get isAuthorizedClient() {
+        const siteID = this.getSiteID();
+        return Boolean(siteID && AUTHORIZED_CLIENTS.includes(siteID));
+    }
+    /**
+     * Sets the site ID for the SDK
+     * @param siteID The site ID to set
+     */
+    setSiteID(siteID) {
+        this.siteID = siteID;
+    }
+    getSiteID() {
+        return this.siteID;
+    }
+    /**
+     * Sets the user ID for the SDK
+     * @param userID The user ID to set
+     */
+    setUserID(userID) {
+        this.userID = userID;
+    }
+    getUserID() {
+        return this.userID;
+    }
+    /**
+     * Gets the event view model
+     * @returns The current event view model
+     */
+    getMaestroEventViewModel() {
+        if (!this.maestroEventViewModel) {
+            throw new Error('No Maestro Event View Model set');
+        }
+        return this.maestroEventViewModel;
+    }
+    /**
+     * Gets the view models container
+     * @returns The current view models
+     */
+    getMaestroViewModels() {
+        return this.renderer.viewModels;
+    }
+    async renderPanel(id) {
+        if (!this.renderer.viewModels) {
+            if (!this.maestroEventViewModel) {
+                throw new Error('No Maestro Event View Model set.');
+            }
+            let eventId = 'default-event-id';
+            if (id) {
+                eventId = id;
+            }
+            await this.renderer.setViewModels(eventId, this.maestroEventViewModel.delegate);
+        }
+        return this.renderer.renderPanel(id);
+    }
+    setMaestroJwt(jwt) {
+        this.maestroJwt = jwt;
+    }
+    setClientAppSwid(swid) {
+        this.clientAppSwid = swid;
+    }
+    setClientAppToken(jwt) {
+        this.clientAppToken = jwt;
+    }
+    async authenticateUser(swid, token) {
+        this.setClientAppSwid(swid);
+        this.setClientAppToken(token);
+        if (this.getMaestroEventViewModel().betsViewModel.initialized) {
+            // Stop polling bets if the user is deauthenticated
+            this.getMaestroEventViewModel().betsViewModel.refreshPolling();
+        }
+    }
+    async deauthenticateUser() {
+        this.setClientAppSwid(undefined);
+        this.setClientAppToken(undefined);
+        if (this.getMaestroEventViewModel().betsViewModel.initialized) {
+            // Stop polling bets if the user is deauthenticated
+            this.getMaestroEventViewModel().betsViewModel.refreshPolling();
+        }
+    }
+    getCurrentMaestroJwt() {
+        return this.maestroJwt;
+    }
+    getClientAppToken() {
+        return this.clientAppToken;
+    }
+    getCurrentUserID() {
+        return this.userID;
+    }
+    getClientAppSwid() {
+        return this.clientAppSwid;
+    }
+}
+const SDK = MaestroWebSDK.getInstance();
+export default SDK;

package/dist/interfaces/IMaestroEvent.js

@@ -0,0 +1,6 @@
+const TEST_USE_CASES = {
+    betsTabLoadFailure: 'betsTabLoadFailure',
+    betsMockData: 'betsMockData',
+    betsLiveData: 'betsLiveData',
+};
+export {};

package/dist/interfaces/IMaestroEventDelegate.js

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

package/dist/interfaces/IMaestroManager.js

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