@maestro_io/maestro-web-sdk 4.0.0 → 4.0.2

package/dist/src/modules/stats/view/PlayerSeasonStats/PlayerSeasonStatsView.js

@@ -0,0 +1,165 @@
+import React, { useState, useRef, useEffect } from 'react';
+import './PlayerSeasonStats.styles.css';
+import Icon from '@/components/atoms/SvgIcon';
+import { withFocusable, } from '@/external/spatial-navigation';
+import PlayerSeasonStatsCard from './PlayerSeasonStatsCard';
+import PlayerSeasonStatsMinified from './PlayerSeasonStatsMinified';
+import ExpandedPlayerStats from './ExpandedPlayerStats';
+import ActionButton from '@/components/molecules/ActionButton';
+import SDK from '@/index';
+const TeamCard = (props) => {
+    const { team } = props;
+    const [expanded, setExpanded] = useState(false);
+    const [activeTabKey, setActiveTabKey] = useState(team.sections[0]?.title || null);
+    const [isTabFocused, setIsTabFocused] = useState(false);
+    const arrowPressTimeoutRef = useRef(null);
+    const cardFocusKey = `player-season-stats-${team.teamKey}`;
+    // Cleanup timeout on unmount
+    useEffect(() => {
+        return () => {
+            if (arrowPressTimeoutRef.current) {
+                clearTimeout(arrowPressTimeoutRef.current);
+            }
+        };
+    }, []);
+    // Toggle expand on Enter key
+    const handleEnterPress = (innerProps, details) => {
+        props.onEnterPress?.(innerProps, details);
+        const newValue = !expanded;
+        setExpanded(newValue);
+        if (newValue) {
+            // Focus first player card (not tabs)
+            SDK.getMaestroEventViewModel().navigation.setFocus(getExpandedPlayerFocusKey());
+        }
+    };
+    const getExpandedPlayerFocusKey = (tabIndex) => {
+        const activeSection = team.sections.find((s) => s.title === activeTabKey) || team.sections[0];
+        if (!activeSection) {
+            console.error('[BBD] [PlayerSeasonStatsView] [getExpandedPlayerFocusKey] No active section found');
+            return 'invalid-focus-key';
+        }
+        const index = tabIndex || team.sections.indexOf(activeSection);
+        return `expanded-player-${team.teamKey}-${index}-0`;
+    };
+    // Collapse on boundary navigation (UP at first, DOWN at last)
+    const handleExpandedPlayerArrowPress = (arrowProps) => (d) => {
+        // Clear existing timeout
+        if (arrowPressTimeoutRef.current) {
+            clearTimeout(arrowPressTimeoutRef.current);
+        }
+        const { playerIndex } = arrowProps;
+        const activeSection = team.sections.find((s) => s.title === activeTabKey) || team.sections[0];
+        if (d === 'left') {
+            SDK.getMaestroEventViewModel().deliverFocus();
+            return false;
+        }
+        // UP at first player -> navigate to tabs (if any) or back to card
+        if (d === 'up' && playerIndex === 0) {
+            if (team.sections.length > 1) {
+                SDK.getMaestroEventViewModel().navigation.setFocus(`player-stats-tab-${team.teamKey}-${activeTabKey}`);
+            }
+            else {
+                SDK.getMaestroEventViewModel().navigation.setFocus(cardFocusKey);
+            }
+            return false;
+        }
+        // DOWN at last player -> collapse and navigate down
+        if (d === 'down' &&
+            activeSection &&
+            Array.isArray(activeSection.items) &&
+            playerIndex === activeSection.items.length - 1) {
+            setExpanded(false);
+            SDK.getMaestroEventViewModel().navigation.navigateByDirection('down');
+            return false;
+        }
+        // 175ms delay for navigation (allow max-height transition)
+        arrowPressTimeoutRef.current = setTimeout(() => {
+            SDK.getMaestroEventViewModel().navigation.navigateByDirection(d);
+        }, 175);
+        return false;
+    };
+    // Tab navigation handler
+    const handleTabArrowPress = (_tabKey, tabIndex) => (d) => {
+        if (d === 'left' && tabIndex === 0) {
+            setIsTabFocused(false);
+            SDK.getMaestroEventViewModel().deliverFocus();
+            return false;
+        }
+        if (d === 'up') {
+            // Collapse and focus back to card
+            setIsTabFocused(false);
+            setExpanded(false);
+            SDK.getMaestroEventViewModel().navigation.setFocus(cardFocusKey);
+            return false;
+        }
+        if (d === 'down') {
+            setIsTabFocused(false);
+            // Focus first player in active section using current tab index
+            SDK.getMaestroEventViewModel().navigation.setFocus(getExpandedPlayerFocusKey(tabIndex));
+            return false;
+        }
+        if (d === 'right' && tabIndex === team.sections.length - 1) {
+            return false; // Prevent right navigation out of tabs
+        }
+        return true; // Allow left/right between tabs
+    };
+    const handleBackPress = () => {
+        setExpanded(false);
+        SDK.getMaestroEventViewModel().navigation.setFocus(cardFocusKey);
+    };
+    const onArrowPress = (d) => {
+        if (d === 'left') {
+            SDK.getMaestroEventViewModel().deliverFocus();
+            return false;
+        }
+        return true;
+    };
+    const renderTabs = () => {
+        if (!expanded || team.sections.length <= 1)
+            return null;
+        return (React.createElement("div", { className: "player-stats-tabs" }, team.sections.map((section, index) => (React.createElement(ActionButton, { key: section.title, focusKey: `player-stats-tab-${team.teamKey}-${section.title}`, parentFocusKey: cardFocusKey, onBecameFocused: () => {
+                setActiveTabKey(section.title);
+                setIsTabFocused(true);
+            }, onArrowPress: handleTabArrowPress(section.title, index), "data-focused": isTabFocused && activeTabKey === section.title, "data-active": activeTabKey === section.title }, section.title)))));
+    };
+    const renderExpandedContent = () => {
+        const activeSection = team.sections.find((s) => s.title === activeTabKey) || team.sections[0];
+        if (!activeSection) {
+            console.error('[BBD] [PlayerSeasonStatsView] [renderExpandedContent] No active section found');
+            return null;
+        }
+        return (React.createElement(React.Fragment, null,
+            renderTabs(),
+            React.createElement(ExpandedPlayerStats, { players: activeSection.items, teamKey: team.teamKey, tabIndex: team.sections.indexOf(activeSection), parentFocusKey: cardFocusKey, onArrowPress: handleExpandedPlayerArrowPress, onBackPress: handleBackPress, onEnterPress: props.onEnterPress })));
+    };
+    const renderCollapsedContent = () => {
+        // For collapsed view, show the first section (e.g., "Hitting")
+        const section = team.sections[0];
+        if (!section || !section.items.length) {
+            return null;
+        }
+        const firstPlayer = section.items[0];
+        const secondPlayer = section.items[1];
+        return (React.createElement("div", { className: "collapsed-content" },
+            React.createElement(PlayerSeasonStatsCard, { player: firstPlayer, focusable: false }),
+            secondPlayer && React.createElement(PlayerSeasonStatsMinified, { player: secondPlayer })));
+    };
+    return (React.createElement(FocusableWrapper, { focusKey: cardFocusKey, trackChildren: expanded, onEnterPress: handleEnterPress, onBecameFocused: props.onBecameFocused, onArrowPress: onArrowPress, expanded: expanded, team: team }, expanded ? renderExpandedContent() : renderCollapsedContent()));
+};
+const Wrapper = (props) => {
+    return (React.createElement("section", { className: "player-season-stats focus-ring", "data-focused": props.focused },
+        React.createElement("div", { className: "header" },
+            React.createElement("h5", { className: "T05_ALT" }, props.team.shortDisplayName),
+            React.createElement("div", { className: "icon-container", "data-focused": props.focused },
+                React.createElement(Icon, { iconName: props.expanded ? 'collapse' : 'expand', height: 48, width: 48 }))),
+        props.children));
+};
+const FocusableWrapper = withFocusable()(Wrapper);
+const PlayerSeasonStatsView = (props) => {
+    const { item } = props;
+    if (!item.teams.length) {
+        return null;
+    }
+    return (React.createElement("div", { className: "player-season-stats-container" }, item.teams.map((team) => (React.createElement(TeamCard, { key: team.teamKey, ...props, team: team })))));
+};
+export default PlayerSeasonStatsView;

package/dist/src/modules/stats/view/PlayerSeasonStats/index.d.ts

@@ -0,0 +1 @@
+export { default } from './PlayerSeasonStatsView';

package/dist/src/modules/stats/view/PlayerSeasonStats/index.js

@@ -0,0 +1 @@
+export { default } from './PlayerSeasonStatsView';

package/dist/src/modules/stats/view/RecentGames/RecentGames.d.ts

@@ -0,0 +1,98 @@
+/// <reference types="prop-types" />
+import { WithFocusableProps } from '@/external/spatial-navigation';
+import React from 'react';
+import './RecentGames.styles.css';
+import { RecentGamesStatsItem } from '../../view-model/StatsViewModel';
+type RecentGamesProps = {
+    item: RecentGamesStatsItem;
+};
+declare const _default: {
+    new (props: (RecentGamesProps & WithFocusableProps) | Readonly<RecentGamesProps & WithFocusableProps>): {
+        state: import("../../../../external/spatial-navigation/withFocusable").WithFocusableState;
+        navigation: import("../../../../external/spatial-navigation/spatialNavigation").default;
+        getChildContext(): {
+            parentFocusKey: string;
+        };
+        setFocus: (focusKey: string) => void;
+        navigateByDirection: (direction: import("../../../../external/spatial-navigation/utils").Direction, details?: Record<string, any>) => void;
+        stealFocus: () => void;
+        onUpdateFocus: (focused: boolean) => void;
+        onUpdateHasFocusedChild: (hasFocusedChild: boolean) => void;
+        onEnterPressHandler: (details: import("../../../../external/spatial-navigation/utils").Details) => void;
+        onEnterReleaseHandler: () => void;
+        onBackPressHandler: (details: import("../../../../external/spatial-navigation/utils").Details) => void;
+        onArrowPressHandler: (direction: import("../../../../external/spatial-navigation/utils").Direction, details: import("../../../../external/spatial-navigation/utils").Details) => boolean | void;
+        onBecameFocusedHandler: (layout: import("../../../../external/spatial-navigation/utils").Layout, details: import("../../../../external/spatial-navigation/utils").Details) => void;
+        onBecameBlurredHandler: (layout: import("../../../../external/spatial-navigation/utils").Layout, details: import("../../../../external/spatial-navigation/utils").Details) => void;
+        componentDidMount(): void;
+        componentDidUpdate(): void;
+        componentWillUnmount(): void;
+        render(): React.ReactElement<RecentGamesProps & WithFocusableProps, string | React.JSXElementConstructor<any>>;
+        context: any;
+        setState<K extends keyof import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>(state: import("../../../../external/spatial-navigation/withFocusable").WithFocusableState | ((prevState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, props: Readonly<RecentGamesProps & WithFocusableProps>) => import("../../../../external/spatial-navigation/withFocusable").WithFocusableState | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K> | null) | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<RecentGamesProps & WithFocusableProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<RecentGamesProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<RecentGamesProps & WithFocusableProps>, prevState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<RecentGamesProps & WithFocusableProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<RecentGamesProps & WithFocusableProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<RecentGamesProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<RecentGamesProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+    };
+    new (props: RecentGamesProps & WithFocusableProps, context: any): {
+        state: import("../../../../external/spatial-navigation/withFocusable").WithFocusableState;
+        navigation: import("../../../../external/spatial-navigation/spatialNavigation").default;
+        getChildContext(): {
+            parentFocusKey: string;
+        };
+        setFocus: (focusKey: string) => void;
+        navigateByDirection: (direction: import("../../../../external/spatial-navigation/utils").Direction, details?: Record<string, any>) => void;
+        stealFocus: () => void;
+        onUpdateFocus: (focused: boolean) => void;
+        onUpdateHasFocusedChild: (hasFocusedChild: boolean) => void;
+        onEnterPressHandler: (details: import("../../../../external/spatial-navigation/utils").Details) => void;
+        onEnterReleaseHandler: () => void;
+        onBackPressHandler: (details: import("../../../../external/spatial-navigation/utils").Details) => void;
+        onArrowPressHandler: (direction: import("../../../../external/spatial-navigation/utils").Direction, details: import("../../../../external/spatial-navigation/utils").Details) => boolean | void;
+        onBecameFocusedHandler: (layout: import("../../../../external/spatial-navigation/utils").Layout, details: import("../../../../external/spatial-navigation/utils").Details) => void;
+        onBecameBlurredHandler: (layout: import("../../../../external/spatial-navigation/utils").Layout, details: import("../../../../external/spatial-navigation/utils").Details) => void;
+        componentDidMount(): void;
+        componentDidUpdate(): void;
+        componentWillUnmount(): void;
+        render(): React.ReactElement<RecentGamesProps & WithFocusableProps, string | React.JSXElementConstructor<any>>;
+        context: any;
+        setState<K extends keyof import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>(state: import("../../../../external/spatial-navigation/withFocusable").WithFocusableState | ((prevState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, props: Readonly<RecentGamesProps & WithFocusableProps>) => import("../../../../external/spatial-navigation/withFocusable").WithFocusableState | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K> | null) | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<RecentGamesProps & WithFocusableProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<RecentGamesProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<RecentGamesProps & WithFocusableProps>, prevState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<RecentGamesProps & WithFocusableProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<RecentGamesProps & WithFocusableProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<RecentGamesProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<RecentGamesProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+    };
+    contextTypes: {
+        parentFocusKey: import("prop-types").Requireable<string>;
+    };
+    childContextTypes: {
+        parentFocusKey: import("prop-types").Requireable<string>;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default _default;

package/dist/src/modules/stats/view/RecentGames/RecentGames.js

@@ -0,0 +1,23 @@
+import { withFocusable, } from '@/external/spatial-navigation';
+import React from 'react';
+import './RecentGames.styles.css';
+import Image from '@/components/atoms/Image';
+const RecentGames = (props) => {
+    const item = props.item;
+    return (React.createElement("section", { className: "recent-games focus-ring", "data-focused": props.focused },
+        React.createElement("h5", { className: "T05_ALT" }, "Recent Games"),
+        React.createElement("div", { className: "recent-games-teams" }, [item.awayTeam, item.homeTeam].map((team, index) => (React.createElement("div", { className: "team-container", key: team.name || team.logo || index },
+            React.createElement(Image, { src: team.logo, alt: team.name || '', crossOrigin: "anonymous" }),
+            React.createElement("span", { className: "T05_ALT" }, team.name))))),
+        React.createElement("div", { className: "recent-games-list-group" }, [item.awayTeam, item.homeTeam].map((team, index) => (React.createElement("div", { className: "recent-games-list", key: team.name || team.logo || index }, team.events.map((event) => (React.createElement("div", { className: "recent-game-item T10", key: event.teamLogo +
+                event.score +
+                event.gameResult +
+                event.homeAway },
+            React.createElement("div", { className: "recent-game-item-team" },
+                React.createElement("span", null, event.homeAway === 'home' ? 'VS' : '@'),
+                React.createElement(Image, { src: event.teamLogo, alt: `${team.name} event ${event.score}`, crossOrigin: "anonymous" })),
+            React.createElement("div", { className: "recent-game-item-result" },
+                React.createElement("span", { "data-result": event.gameResult }, event.gameResult),
+                event.score))))))))));
+};
+export default withFocusable()(RecentGames);

package/dist/src/modules/stats/view/RecentGames/index.d.ts

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

package/dist/src/modules/stats/view/RecentGames/index.js

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

package/dist/src/modules/stats/view/ScoringSummary/ExpandedScores/ExpandedScores.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import { IScoreSection } from '@/modules/stats/view-model/StatsViewModel';
+import './ExpandedScores.styles.css';
+import { Direction } from '@/external/spatial-navigation/utils';
+type Props = {
+    item: IScoreSection[];
+    noScoresText: string;
+    type: 'scoringSummary' | 'penalties';
+    onArrowPress: (props: {
+        index: number;
+        scoreIndex: number;
+    }) => (direction: Direction) => boolean;
+    onBackPress: () => void;
+    onEnterPress: () => void;
+    parentFocusKey: string;
+};
+declare class ExpandedScores extends React.Component<Props> {
+    refsArray: HTMLDivElement[];
+    titleRefsArray: HTMLDivElement[];
+    wrapperRef: HTMLDivElement | null;
+    state: {
+        maxHeight: string;
+        scrolled: boolean;
+    };
+    updateMaxHeight(sectionIndex: number, scoreFocusedIndex: number): void;
+    scrollToElement(focusedIndex: number): void;
+    onBecameFocused: (sectionIndex: number, scoreFocusedIndex: number) => () => void;
+    render(): JSX.Element;
+}
+export default ExpandedScores;

package/dist/src/modules/stats/view/ScoringSummary/ExpandedScores/ExpandedScores.js

@@ -0,0 +1,123 @@
+import React from 'react';
+import ScoreItem from '../ScoreItem';
+import './ExpandedScores.styles.css';
+import { withFocusable, } from '@/external/spatial-navigation';
+const NoScoresComponent = (props) => (React.createElement("div", { className: "no-scores T10 focus-ring", "data-focused": props.focused }, props.children));
+const NoScores = withFocusable()(NoScoresComponent);
+const SECTION_TITLE_HEIGHT = 60;
+const MAX_SCORES_PER_SECTION = 10;
+class ExpandedScores extends React.Component {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "refsArray", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "titleRefsArray", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "wrapperRef", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                maxHeight: '0',
+                scrolled: false,
+            }
+        });
+        Object.defineProperty(this, "onBecameFocused", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (sectionIndex, scoreFocusedIndex) => () => {
+                this.updateMaxHeight(sectionIndex, scoreFocusedIndex);
+                // set timeout to account for max-height animation transition
+                if (this.wrapperRef) {
+                    const handleTransitionEnd = () => {
+                        this.scrollToElement(scoreFocusedIndex);
+                        this.wrapperRef?.removeEventListener('transitionend', handleTransitionEnd);
+                        this.titleRefsArray.forEach((ref, i) => {
+                            ref.dataset.sectionFocused = String(i === sectionIndex);
+                        });
+                    };
+                    this.wrapperRef.addEventListener('transitionend', handleTransitionEnd, {
+                        once: true,
+                    });
+                }
+            }
+        });
+    }
+    updateMaxHeight(sectionIndex, scoreFocusedIndex) {
+        const items = this.refsArray.slice(scoreFocusedIndex);
+        const itemsMaxHeight = items.reduce((prev, curr) => {
+            if (!curr) {
+                return prev;
+            }
+            return prev + curr.clientHeight;
+        }, 0);
+        const titles = this.titleRefsArray.slice(sectionIndex);
+        const titlesHeight = titles.reduce((prev, curr) => {
+            if (!curr) {
+                return prev;
+            }
+            return prev + curr.clientHeight;
+        }, 0);
+        const totalMaxHeight = itemsMaxHeight + titlesHeight;
+        this.setState({ maxHeight: `${totalMaxHeight}px` });
+    }
+    scrollToElement(focusedIndex) {
+        const element = this.refsArray[focusedIndex];
+        if (!element) {
+            return;
+        }
+        if (this.wrapperRef) {
+            const wrapperRect = this.wrapperRef.getBoundingClientRect();
+            const elementRect = element.getBoundingClientRect();
+            const scrollTop = elementRect.top -
+                wrapperRect.top +
+                this.wrapperRef.scrollTop -
+                SECTION_TITLE_HEIGHT;
+            this.wrapperRef.scrollTo({
+                top: scrollTop,
+                behavior: 'smooth',
+            });
+            const hasScrolled = scrollTop > SECTION_TITLE_HEIGHT;
+            if (hasScrolled !== this.state.scrolled) {
+                this.setState({ scrolled: hasScrolled });
+            }
+        }
+    }
+    render() {
+        const { onArrowPress, onBackPress, onEnterPress } = this.props;
+        return (React.createElement("div", { className: "expanded-scores", style: {
+                maxHeight: this.state.maxHeight,
+            }, ref: (ref) => {
+                this.wrapperRef = ref;
+            }, "data-scrolled": this.state.scrolled }, this.props.item.map((item, i) => (React.createElement("div", { key: item.title, className: "expanded-score" },
+            React.createElement("div", { className: "title T05_ALT", ref: (ref) => {
+                    this.titleRefsArray[i] = ref;
+                } }, item.title),
+            !item.scores.length ? (React.createElement("div", { ref: (ref) => {
+                    this.refsArray[i * MAX_SCORES_PER_SECTION] = ref;
+                }, className: "score-item-wrapper" },
+                React.createElement(NoScores, { focusKey: `expanded-${this.props.type}-${i}-0`, parentFocusKey: this.props.parentFocusKey, onBackPress: onBackPress, onEnterPress: onEnterPress, onBecameFocused: this.onBecameFocused(i, i * MAX_SCORES_PER_SECTION), onArrowPress: onArrowPress({ index: i, scoreIndex: 0 }) }, this.props.noScoresText))) : (item.scores.map((score, scoreIndex) => (React.createElement("div", { ref: (ref) => {
+                    this.refsArray[scoreIndex + i * MAX_SCORES_PER_SECTION] = ref;
+                }, key: score.description, className: "score-item-wrapper" },
+                React.createElement(ScoreItem, { key: score.description, item: score, focusKey: `expanded-${this.props.type}-${i}-${scoreIndex}`, parentFocusKey: this.props.parentFocusKey, onArrowPress: onArrowPress({
+                        index: i,
+                        scoreIndex,
+                    }), onBackPress: onBackPress, onBecameFocused: this.onBecameFocused(i, scoreIndex + i * MAX_SCORES_PER_SECTION), onEnterPress: onEnterPress }))))))))));
+    }
+}
+export default ExpandedScores;

package/dist/src/modules/stats/view/ScoringSummary/ExpandedScores/index.d.ts

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

package/dist/src/modules/stats/view/ScoringSummary/ExpandedScores/index.js

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

package/dist/src/modules/stats/view/ScoringSummary/ScoreItem/ScoreItem.d.ts

@@ -0,0 +1,98 @@
+/// <reference types="prop-types" />
+import React from 'react';
+import { IScoreItem } from '@/modules/stats/view-model/StatsViewModel';
+import { WithFocusableProps } from '@/external/spatial-navigation';
+import './ScoreItem.styles.css';
+type Props = {
+    item: IScoreItem;
+};
+declare const _default: {
+    new (props: (Props & WithFocusableProps) | Readonly<Props & WithFocusableProps>): {
+        state: import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState;
+        navigation: import("../../../../../external/spatial-navigation/spatialNavigation").default;
+        getChildContext(): {
+            parentFocusKey: string;
+        };
+        setFocus: (focusKey: string) => void;
+        navigateByDirection: (direction: import("../../../../../external/spatial-navigation/utils").Direction, details?: Record<string, any>) => void;
+        stealFocus: () => void;
+        onUpdateFocus: (focused: boolean) => void;
+        onUpdateHasFocusedChild: (hasFocusedChild: boolean) => void;
+        onEnterPressHandler: (details: import("../../../../../external/spatial-navigation/utils").Details) => void;
+        onEnterReleaseHandler: () => void;
+        onBackPressHandler: (details: import("../../../../../external/spatial-navigation/utils").Details) => void;
+        onArrowPressHandler: (direction: import("../../../../../external/spatial-navigation/utils").Direction, details: import("../../../../../external/spatial-navigation/utils").Details) => boolean | void;
+        onBecameFocusedHandler: (layout: import("../../../../../external/spatial-navigation/utils").Layout, details: import("../../../../../external/spatial-navigation/utils").Details) => void;
+        onBecameBlurredHandler: (layout: import("../../../../../external/spatial-navigation/utils").Layout, details: import("../../../../../external/spatial-navigation/utils").Details) => void;
+        componentDidMount(): void;
+        componentDidUpdate(): void;
+        componentWillUnmount(): void;
+        render(): React.ReactElement<Props & WithFocusableProps, string | React.JSXElementConstructor<any>>;
+        context: any;
+        setState<K extends keyof import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>(state: import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState | ((prevState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>, props: Readonly<Props & WithFocusableProps>) => import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState | Pick<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState, K> | null) | Pick<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Props & WithFocusableProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<Props & WithFocusableProps>, nextState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Props & WithFocusableProps>, prevState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Props & WithFocusableProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props & WithFocusableProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Props & WithFocusableProps>, nextState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Props & WithFocusableProps>, nextState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+    };
+    new (props: Props & WithFocusableProps, context: any): {
+        state: import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState;
+        navigation: import("../../../../../external/spatial-navigation/spatialNavigation").default;
+        getChildContext(): {
+            parentFocusKey: string;
+        };
+        setFocus: (focusKey: string) => void;
+        navigateByDirection: (direction: import("../../../../../external/spatial-navigation/utils").Direction, details?: Record<string, any>) => void;
+        stealFocus: () => void;
+        onUpdateFocus: (focused: boolean) => void;
+        onUpdateHasFocusedChild: (hasFocusedChild: boolean) => void;
+        onEnterPressHandler: (details: import("../../../../../external/spatial-navigation/utils").Details) => void;
+        onEnterReleaseHandler: () => void;
+        onBackPressHandler: (details: import("../../../../../external/spatial-navigation/utils").Details) => void;
+        onArrowPressHandler: (direction: import("../../../../../external/spatial-navigation/utils").Direction, details: import("../../../../../external/spatial-navigation/utils").Details) => boolean | void;
+        onBecameFocusedHandler: (layout: import("../../../../../external/spatial-navigation/utils").Layout, details: import("../../../../../external/spatial-navigation/utils").Details) => void;
+        onBecameBlurredHandler: (layout: import("../../../../../external/spatial-navigation/utils").Layout, details: import("../../../../../external/spatial-navigation/utils").Details) => void;
+        componentDidMount(): void;
+        componentDidUpdate(): void;
+        componentWillUnmount(): void;
+        render(): React.ReactElement<Props & WithFocusableProps, string | React.JSXElementConstructor<any>>;
+        context: any;
+        setState<K extends keyof import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>(state: import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState | ((prevState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>, props: Readonly<Props & WithFocusableProps>) => import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState | Pick<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState, K> | null) | Pick<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Props & WithFocusableProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<Props & WithFocusableProps>, nextState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Props & WithFocusableProps>, prevState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Props & WithFocusableProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props & WithFocusableProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Props & WithFocusableProps>, nextState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Props & WithFocusableProps>, nextState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+    };
+    contextTypes: {
+        parentFocusKey: import("prop-types").Requireable<string>;
+    };
+    childContextTypes: {
+        parentFocusKey: import("prop-types").Requireable<string>;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default _default;

package/dist/src/modules/stats/view/ScoringSummary/ScoreItem/ScoreItem.js

@@ -0,0 +1,62 @@
+import React from 'react';
+import { withFocusable, } from '@/external/spatial-navigation';
+import Image from '@/components/atoms/Image';
+import './ScoreItem.styles.css';
+import { BASE_64_KEY_PLAY_THUMBNAIL_FALLBACK } from '@/modules/key-plays/constants';
+class ScoreItem extends React.Component {
+    constructor(props) {
+        super(props);
+        Object.defineProperty(this, "mounted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "onLoad", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                if (!this.mounted)
+                    return;
+                this.setState({ imageLoaded: true });
+            }
+        });
+        Object.defineProperty(this, "renderImage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                return (React.createElement("div", { className: "image-wrapper" },
+                    !this.state.imageLoaded && (React.createElement(Image, { src: BASE_64_KEY_PLAY_THUMBNAIL_FALLBACK, crossOrigin: "anonymous", alt: "Player Headshot Loading" })),
+                    this.props.item.athleteThumbnail && (React.createElement(Image, { src: this.props.item.athleteThumbnail, crossOrigin: "anonymous", onLoad: this.onLoad, alt: "Athlete Thumbnail", style: {
+                            display: this.state.imageLoaded ? 'block' : 'none',
+                        } })),
+                    React.createElement("div", { className: "athlete-position-badge T02" },
+                        ' ',
+                        React.createElement("span", null, this.props.item.athletePosition))));
+            }
+        });
+        this.state = {
+            imageLoaded: false,
+        };
+    }
+    componentWillUnmount() {
+        this.mounted = false;
+    }
+    render() {
+        return (React.createElement("div", { className: "score-item focus-ring", "data-focused": this.props.focused },
+            React.createElement("div", { className: "content-wrapper" },
+                this.renderImage(),
+                React.createElement("div", { className: "content-info T02" },
+                    React.createElement("div", { className: "time" },
+                        React.createElement("span", { className: "T10" }, this.props.item.clock),
+                        React.createElement("div", null, this.props.item.teamName)),
+                    React.createElement("div", { className: "description T05_ALT" },
+                        React.createElement("span", null, this.props.item.athleteNumber),
+                        React.createElement("span", { className: "name" }, this.props.item.athleteName),
+                        React.createElement("span", null, this.props.item.athleteAssists)),
+                    React.createElement("div", { className: "assist" }, this.props.item.description)))));
+    }
+}
+export default withFocusable()(ScoreItem);

package/dist/src/modules/stats/view/ScoringSummary/ScoreItem/index.d.ts

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