@maestro_io/maestro-web-sdk 3.3.1 → 4.0.0-beta.2

package/dist/src/modules/fantasy/view/MatchupSingle/MatchupSingle.js

@@ -0,0 +1,108 @@
+import { withFocusable, } from '@/external/spatial-navigation';
+import React from 'react';
+import LeagueCard from '../../components/LeagueCard';
+import './MatchupSingle.styles.css';
+import Image from '@/components/atoms/Image';
+import SDK from '@/index';
+import ExpandedSingleAthleteCards from './ExpandedSingleAthleteCards';
+import ActiveAthletesMarquee from '../ActiveAthletesMarquee';
+class MatchupSingle extends React.Component {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                expanded: false,
+            }
+        });
+        Object.defineProperty(this, "onAthleteArrowPress", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (index) => (d) => {
+                if (d === 'left') {
+                    SDK.getMaestroEventViewModel().deliverFocus();
+                    return false;
+                }
+                if (d === 'up' && index === 0) {
+                    SDK.getMaestroEventViewModel().navigation.setFocus(this.focusKey);
+                    this.setState({
+                        expanded: false,
+                    });
+                    return false;
+                }
+                if (d === 'down' &&
+                    index === this.props.item.roster.length &&
+                    !this.props.item.topPlayers.length) {
+                    this.setState({
+                        expanded: false,
+                    }, () => {
+                        SDK.getMaestroEventViewModel().navigation.navigateByDirection('down');
+                    });
+                    return false;
+                }
+                if (d === 'down' &&
+                    index ===
+                        this.props.item.roster.length + this.props.item.topPlayers.length - 1) {
+                    this.setState({
+                        expanded: false,
+                    }, () => {
+                        SDK.getMaestroEventViewModel().navigation.navigateByDirection('down');
+                    });
+                    return false;
+                }
+                return true;
+            }
+        });
+        Object.defineProperty(this, "onAthleteBackPress", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                this.setState({
+                    expanded: false,
+                }, () => {
+                    SDK.getMaestroEventViewModel().navigation.setFocus(this.focusKey);
+                });
+            }
+        });
+    }
+    get focusKey() {
+        return this.props.item.id;
+    }
+    onEnterPress() {
+        if (!this.shouldExpand) {
+            this.props.onEnterPress();
+            return;
+        }
+        const newValue = !this.state.expanded;
+        this.setState({
+            expanded: newValue,
+        }, () => {
+            if (newValue) {
+                SDK.getMaestroEventViewModel().navigation.setFocus(`${this.focusKey}-athlete-0`);
+            }
+        });
+        this.props.onEnterPress();
+    }
+    get shouldExpand() {
+        return this.props.item.roster.length > 0;
+    }
+    render() {
+        return (React.createElement(LeagueCard, { leagueColor: this.props.item.league.color, leagueLogo: this.props.item.league.logo, renderTitle: () => (React.createElement("div", null,
+                React.createElement("div", null, this.props.item.league.title),
+                this.props.item.league.subtitle && (React.createElement("div", { className: "subtitle" }, this.props.item.league.subtitle)))), expanded: this.state.expanded, shouldExpand: this.shouldExpand, ...this.props, onEnterPress: this.onEnterPress.bind(this), focusKey: this.focusKey },
+            React.createElement("div", { className: "matchup-single" },
+                React.createElement(Image, { src: this.props.item.team.logo, width: 64, height: 64, alt: "Matchup Single Team logo" }),
+                React.createElement("div", { className: "points T50 FONT_BOLD" },
+                    this.props.item.team.points.toFixed(1),
+                    ' ',
+                    this.props.item.team.scoringType,
+                    " Points")),
+            !this.state.expanded && (React.createElement(ActiveAthletesMarquee, { activeAthletes: this.props.item.activeAthletes })),
+            this.state.expanded && (React.createElement(ExpandedSingleAthleteCards, { topPlayers: this.props.item.topPlayers, focusKey: this.focusKey, items: this.props.item.roster, onArrowPress: this.onAthleteArrowPress.bind(this), onBackPress: this.onAthleteBackPress.bind(this) }))));
+    }
+}
+export default withFocusable()(MatchupSingle);

package/dist/src/modules/fantasy/view/MatchupSingle/SingleAthleteCard/SingleAthleteCard.js

@@ -0,0 +1,18 @@
+import { withFocusable, } from '@/external/spatial-navigation';
+import React from 'react';
+import './SingleAthleteCard.styles.css';
+import HeadshotImage from '@/components/molecules/HeadshotImage';
+const SingleAthleteCard = (props) => {
+    return (React.createElement("div", { className: "roster-single-athlete-card focus-ring FONT_BOLD", "data-focused": props.focused },
+        React.createElement("div", { className: "image-wrapper" },
+            React.createElement(HeadshotImage, { src: props.athleteHeadshot, alt: "Roster Single Athlete Card Headshot" }),
+            React.createElement("div", { className: "athlete-position-badge" },
+                ' ',
+                React.createElement("span", null, props.athletesSlot))),
+        React.createElement("div", { className: "content" },
+            React.createElement("div", { className: "name T05_ALT" },
+                props.athleteAbbrevName,
+                React.createElement("div", { className: "TEXT_200" }, props.teamTriCode)),
+            props.proGameStatusLines.map((line, index) => (React.createElement("div", { className: "pro-game-stats-line TEXT_200", key: `${line}-${index}` }, line))))));
+};
+export default withFocusable()(SingleAthleteCard);

package/dist/src/modules/fantasy/view/MatchupSingle/SingleAthleteCard/index.js

@@ -0,0 +1,2 @@
+import SingleAthleteCard from './SingleAthleteCard';
+export default SingleAthleteCard;

package/dist/src/modules/fantasy/view/MatchupSingle/index.js

@@ -0,0 +1,2 @@
+import MatchupSingle from './MatchupSingle';
+export default MatchupSingle;

package/dist/src/modules/fantasy/view/PromoView/PromoView.js

@@ -0,0 +1,12 @@
+import React from 'react';
+import { withFocusable, } from '@/external/spatial-navigation';
+import './PromoView.styles.css';
+import Image from '@/components/atoms/Image';
+const PromoView = (props) => {
+    return (React.createElement("div", { className: "fantasy-promo-view focus-ring T20", "data-focused": props.focused, style: { backgroundImage: `url(${props.item.background})` } },
+        React.createElement(Image, { src: props.item.logo, alt: "Promo Logo", className: "promo-logo" }),
+        React.createElement("div", { className: "title" }, props.item.title),
+        React.createElement(Image, { src: props.item.qrCode, alt: "QR Code", className: "promo-qr-code" }),
+        React.createElement("p", null, props.item.description)));
+};
+export default withFocusable()(PromoView);

package/dist/src/modules/fantasy/view/PromoView/index.js

@@ -0,0 +1,2 @@
+import PromoView from './PromoView';
+export default PromoView;

package/dist/src/modules/fantasy/view/index.js

@@ -0,0 +1,2 @@
+import FantasyView from './FantasyView';
+export default FantasyView;

package/dist/src/modules/fantasy/view-model/FantasyViewModel.FantasyPolling.js

@@ -0,0 +1,132 @@
+import SDK from '@/index';
+import { captureException } from '@/sentry';
+import { stringHashCode } from '@/helpers/strings';
+const DEFAULT_FANTASY_POLLING_INTERVAL = 60000;
+export default class FantasyPolling {
+    constructor(service) {
+        Object.defineProperty(this, "polling", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                interval: DEFAULT_FANTASY_POLLING_INTERVAL,
+                task: null,
+                lastResponseHash: null,
+            }
+        });
+        Object.defineProperty(this, "fantasyService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.fantasyService = service;
+    }
+    /**
+     * Refresh polling for fantasy data
+     */
+    async refresh(params, callback) {
+        // First stop any existing polling
+        this.stop();
+        // Start the poll loop
+        await this.start(params, callback);
+    }
+    /**
+     * Stop polling for fantasy data
+     */
+    stop() {
+        if (this.polling.task) {
+            this.polling.task.stop();
+            this.polling.task = null;
+        }
+    }
+    removeLastResponseHash() {
+        this.polling.lastResponseHash = null;
+    }
+    async start(params, callback) {
+        try {
+            this.polling.task = this.fantasyService.pollFantasy(params, this.polling.interval, (response) => {
+                this.updateInterval(params, response.headers, callback);
+                this.processPolledData(response.data, callback);
+            }, (error) => this.handlePollingError(error, params.swid));
+        }
+        catch (error) {
+            captureException(error, {
+                context: 'FantasyViewModel.pollFantasy',
+            });
+            console.error('[FANTASY] Error setting up fantasy polling:', error);
+        }
+    }
+    /**
+     * @description Update polling interval checking either response header or panel config.
+     * Refresh polling if necessary.
+     */
+    updateInterval(params, headers, callback) {
+        const headerInterval = this.getResponseHeaderPollingIntervalValue(headers);
+        const panelConfigInterval = this.getPanelConfigInterval();
+        const newInterval = headerInterval || panelConfigInterval; // order matters here
+        // Only update if we have a valid new interval and it's different from current
+        if (newInterval && newInterval !== this.polling.interval) {
+            console.log(`[Fantasy] Updating fantasy polling interval from ${this.polling.interval}ms to ${newInterval}ms`);
+            this.polling.interval = newInterval;
+            // Restart polling with the new interval
+            this.refresh(params, callback);
+        }
+    }
+    getResponseHeaderPollingIntervalValue(headers) {
+        const newInterval = headers['polling-interval'];
+        if (!newInterval) {
+            return null;
+        }
+        const parsedInterval = parseInt(newInterval, 10);
+        if (isNaN(parsedInterval) || parsedInterval <= 0) {
+            console.warn(`[Fantasy] Invalid polling interval header received: ${newInterval}.`);
+            return null;
+        }
+        return parsedInterval * 1000; // Convert seconds to milliseconds
+    }
+    getPanelConfigInterval() {
+        const config = SDK.getPageConfig();
+        const panel = config?.panels?.find((p) => p.panel_type === 'espnFantasy');
+        if (!panel) {
+            return null;
+        }
+        const fantasyPollingInterval = panel.renderer?.block_data?.fan_polling_interval;
+        if (!fantasyPollingInterval) {
+            return null;
+        }
+        const parsedInterval = parseInt(fantasyPollingInterval, 10);
+        if (isNaN(parsedInterval) || parsedInterval <= 0) {
+            console.warn(`[FANTASY] Invalid fantasy polling interval from panel config: ${fantasyPollingInterval}.`);
+            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('[Fantasy] Fantasy Response hash is the same as last successful response - skipping update');
+            return;
+        }
+        this.polling.lastResponseHash = responseHash;
+        callback(data);
+    }
+    /**
+     * Handle errors that occur during fantasy polling
+     */
+    handlePollingError(error, swid) {
+        console.error('[FANTASY] Fantasy polling error:', error);
+        captureException(error, {
+            context: 'FantasyViewModel.pollFantasy',
+            extra: {
+                swid: swid ? `${swid.substring(0, 8)}...` : 'unknown',
+                pollingInterval: this.polling.interval,
+            },
+        });
+    }
+}

package/dist/src/modules/fantasy/view-model/FantasyViewModel.LeagueManagerPolling.js

@@ -0,0 +1,141 @@
+import SDK from '@/index';
+import { captureException } from '@/sentry';
+import { stringHashCode } from '@/helpers/strings';
+const DEFAULT_LEAGUE_MANAGER_POLLING_INTERVAL = 60000;
+export default class LeagueManagerPolling {
+    constructor(service) {
+        Object.defineProperty(this, "polling", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "fantasyService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.fantasyService = service;
+    }
+    /**
+     * Refresh polling for league manager data
+     */
+    refresh(key, params, callback) {
+        // First stop any existing polling
+        this.stop(key);
+        // Initialize polling state if it doesn't exist
+        if (!this.polling[key]) {
+            this.polling[key] = {
+                interval: DEFAULT_LEAGUE_MANAGER_POLLING_INTERVAL,
+                lastResponseHash: null,
+                task: null,
+            };
+        }
+        // Start the poll loop
+        this.start(key, params, callback);
+    }
+    /**
+     * Stop polling for fantasy data
+     */
+    stop(key) {
+        if (this.polling[key]?.task) {
+            this.polling[key]?.task?.stop?.();
+            this.polling[key].task = null;
+        }
+    }
+    start(key, params, callback) {
+        try {
+            this.polling[key].task = this.fantasyService.pollLeagueManager(params, this.polling[key].interval, (response) => {
+                this.updateInterval(key, params, callback, response.headers);
+                this.processPolledData(key, response.data, callback);
+            }, (error) => this.handlePollingError(error, key, params));
+        }
+        catch (error) {
+            captureException(error, {
+                context: 'FantasyViewModel.pollLeagueManager',
+            });
+            console.error('[FANTASY] Error setting up league manager polling:', error);
+        }
+    }
+    /**
+     * Process data received from polling
+     */
+    processPolledData(key, 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[key].lastResponseHash === responseHash) {
+            console.log('[Fantasy] League manager Response hash is the same as last successful response - skipping update');
+            return;
+        }
+        this.polling[key].lastResponseHash = responseHash;
+        callback(data);
+    }
+    /**
+     * @description Update polling interval checking either response header or panel config.
+     * Refresh polling if necessary.
+     */
+    updateInterval(key, params, callback, headers) {
+        const headerInterval = this.getResponseHeaderPollingIntervalValue(headers);
+        const panelConfigInterval = this.getPanelConfigInterval();
+        const newInterval = headerInterval || panelConfigInterval; // order matters here
+        // Only update if we have a valid new interval and it's different from current
+        if (newInterval && newInterval !== this.polling[key]?.interval) {
+            console.log(`[Fantasy] Updating league manager polling interval from ${this.polling[key]?.interval}ms to ${newInterval}ms`);
+            this.polling[key].interval = newInterval;
+            // Restart polling with the new interval
+            this.refresh(key, params, callback);
+        }
+    }
+    getResponseHeaderPollingIntervalValue(headers) {
+        const newInterval = headers['polling-interval'];
+        if (!newInterval) {
+            return null;
+        }
+        const parsedInterval = parseInt(newInterval, 10);
+        if (isNaN(parsedInterval) || parsedInterval <= 0) {
+            console.warn(`[Fantasy] Invalid polling interval header received: ${newInterval}.`);
+            return null;
+        }
+        return parsedInterval * 1000; // Convert seconds to milliseconds
+    }
+    getPanelConfigInterval() {
+        const config = SDK.getPageConfig();
+        const panel = config?.panels?.find((p) => p.panel_type === 'espnFantasy');
+        if (!panel) {
+            return null;
+        }
+        const fantasyPollingInterval = panel.renderer?.block_data?.lm_polling_interval;
+        if (!fantasyPollingInterval) {
+            return null;
+        }
+        const parsedInterval = parseInt(fantasyPollingInterval, 10);
+        if (isNaN(parsedInterval) || parsedInterval <= 0) {
+            console.warn(`[FANTASY] Invalid league manager polling interval from panel config: ${fantasyPollingInterval}.`);
+            return null;
+        }
+        return parsedInterval * 1000; // Convert seconds to milliseconds
+    }
+    stopAll() {
+        Object.keys(this.polling).forEach((key) => {
+            this.stop(key);
+        });
+        this.polling = {};
+    }
+    /**
+     * Handle errors that occur during league manager polling
+     */
+    handlePollingError(error, key, params) {
+        console.error('[FANTASY] League manager polling error:', error);
+        captureException(error, {
+            context: 'FantasyViewModel.pollLeagueManager',
+            extra: {
+                key,
+                leagueId: params?.leagueId,
+                game: params?.game,
+                pollingInterval: this.polling[key]?.interval,
+            },
+        });
+    }
+}