@maestro_io/maestro-web-sdk 4.0.0 → 4.0.1

package/dist/src/modules/stats/view/MatchPredictor/MatchPredictorView.d.ts

@@ -0,0 +1,98 @@
+/// <reference types="prop-types" />
+import React from 'react';
+import './MatchPredictorView.styles.css';
+import { WithFocusableProps } from '@/external/spatial-navigation';
+import { StatsMatchPredictorItem } from '../../view-model/StatsViewModel';
+export interface MatchPredictorProps {
+    item: StatsMatchPredictorItem;
+}
+declare const _default: {
+    new (props: (MatchPredictorProps & WithFocusableProps) | Readonly<MatchPredictorProps & 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<MatchPredictorProps & 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<MatchPredictorProps & 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<MatchPredictorProps & WithFocusableProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<MatchPredictorProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<MatchPredictorProps & WithFocusableProps>, prevState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<MatchPredictorProps & WithFocusableProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<MatchPredictorProps & WithFocusableProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<MatchPredictorProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<MatchPredictorProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+    };
+    new (props: MatchPredictorProps & 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<MatchPredictorProps & 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<MatchPredictorProps & 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<MatchPredictorProps & WithFocusableProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<MatchPredictorProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<MatchPredictorProps & WithFocusableProps>, prevState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<MatchPredictorProps & WithFocusableProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<MatchPredictorProps & WithFocusableProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<MatchPredictorProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<MatchPredictorProps & 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/MatchPredictor/MatchPredictorView.js

@@ -0,0 +1,60 @@
+import React, { Component } from 'react';
+import './MatchPredictorView.styles.css';
+import { withFocusable, } from '@/external/spatial-navigation';
+import DonutChart from './DonutChart/DonutChart';
+import Image from '@/components/atoms/Image';
+class MatchPredictorView extends Component {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                shouldRenderPredictorImage: Boolean(this.props.item.imageUrl),
+            }
+        });
+        Object.defineProperty(this, "handleImageError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                this.setState({ shouldRenderPredictorImage: false });
+            }
+        });
+    }
+    render() {
+        const { item } = this.props;
+        const { shouldRenderPredictorImage } = this.state;
+        return (React.createElement("section", { className: "match-predictor-view focus-ring", "data-focused": this.props.focused },
+            React.createElement("div", { className: "match-predictor-header" },
+                React.createElement("h2", { className: "T05_ALT" }, item.header)),
+            React.createElement("div", { className: "match-predictor-percentages" },
+                React.createElement("div", { className: "team-percentage away-team" },
+                    React.createElement("span", { className: "percentage-value T70" },
+                        item.awayTeam.percentage,
+                        "%"),
+                    React.createElement("div", { className: "team-info" },
+                        React.createElement("div", { className: "legend-item away" },
+                            React.createElement("div", { className: "legend-pattern away-pattern" }),
+                            React.createElement("span", { className: "T02" }, item.awayTeam.abbreviation)))),
+                React.createElement("div", { className: "team-percentage home-team" },
+                    React.createElement("span", { className: "percentage-value T70" },
+                        item.homeTeam.percentage,
+                        "%"),
+                    React.createElement("div", { className: "team-info" },
+                        React.createElement("div", { className: "legend-item home" },
+                            React.createElement("div", { className: "legend-pattern home-pattern" }),
+                            React.createElement("span", { className: "T02" }, item.homeTeam.abbreviation))))),
+            React.createElement("div", { className: "donut-chart-container" }, shouldRenderPredictorImage && item.imageUrl ? (React.createElement("div", { className: "actual-chart" },
+                React.createElement(Image, { src: item.imageUrl, alt: "Match Predictor Chart", className: "predictor-chart-image", onError: this.handleImageError }))) : (React.createElement("div", { className: "svg-chart-fallback" },
+                React.createElement("div", { className: "svg-donut-container" },
+                    React.createElement(DonutChart, { awayPercentage: item.awayTeam.percentage, homePercentage: item.homeTeam.percentage }),
+                    React.createElement("div", { className: "donut-center" },
+                        React.createElement("div", { className: "center-team-logos" },
+                            React.createElement("div", { className: "center-logo away-center-logo" }, item.awayTeam.logo ? (React.createElement(Image, { src: item.awayTeam.logo, alt: item.awayTeam.displayName, className: "center-logo-image" })) : (React.createElement("span", { className: "center-logo-fallback T30" }, item.awayTeam.abbreviation))),
+                            React.createElement("div", { className: "center-divider" }),
+                            React.createElement("div", { className: "center-logo home-center-logo" }, item.homeTeam.logo ? (React.createElement(Image, { src: item.homeTeam.logo, alt: item.homeTeam.displayName, className: "center-logo-image" })) : (React.createElement("span", { className: "center-logo-fallback T30" }, item.homeTeam.abbreviation)))))))))));
+    }
+}
+export default withFocusable()(MatchPredictorView);

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

@@ -0,0 +1,3 @@
+import MatchPredictorView from './MatchPredictorView';
+export default MatchPredictorView;
+export { MatchPredictorProps } from './MatchPredictorView';

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

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

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

@@ -0,0 +1,9 @@
+import { PenaltiesItem } from '../../view-model/StatsViewModel';
+import { Layout } from '@/external/spatial-navigation/utils';
+type PenaltiesProps = {
+    item: PenaltiesItem;
+    onBecameFocused: (layout: Layout) => void;
+    onEnterPress: () => void;
+};
+declare const Penalties: (props: PenaltiesProps) => JSX.Element;
+export default Penalties;

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

@@ -0,0 +1,6 @@
+import React from 'react';
+import ScoringSummary from '../ScoringSummary';
+const Penalties = (props) => {
+    return (React.createElement(ScoringSummary, { item: props.item, noScoresText: "No Penalties", onBecameFocused: props.onBecameFocused, onEnterPress: props.onEnterPress }));
+};
+export default Penalties;

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

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

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

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

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

@@ -0,0 +1,16 @@
+import { PlayerSeasonStatsPlayerItem } from '../../view-model/StatsViewModel';
+import { Details, Direction } from '@/external/spatial-navigation/utils';
+type Props = {
+    players: PlayerSeasonStatsPlayerItem[];
+    teamKey: string;
+    tabIndex: number;
+    parentFocusKey: string;
+    onArrowPress: (props: {
+        tabIndex: number;
+        playerIndex: number;
+    }) => (d: Direction) => boolean;
+    onBackPress: () => void;
+    onEnterPress?: (props: any, d: Details) => void;
+};
+declare const ExpandedPlayerStats: (props: Props) => JSX.Element;
+export default ExpandedPlayerStats;

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

@@ -0,0 +1,66 @@
+import React, { useState, useRef, useCallback, useLayoutEffect } from 'react';
+import PlayerSeasonStatsCard from './PlayerSeasonStatsCard';
+const ExpandedPlayerStats = (props) => {
+    const { players, teamKey, tabIndex, parentFocusKey, onArrowPress, onBackPress, onEnterPress, } = props;
+    const [maxHeight, setMaxHeight] = useState('auto');
+    const [scrolled, setScrolled] = useState(false);
+    const refsArray = useRef([]);
+    const wrapperRef = useRef(null);
+    const hasInitialized = useRef(false);
+    // Set initial max-height after first render when refs are populated
+    useLayoutEffect(() => {
+        if (!hasInitialized.current && refsArray.current.length > 0) {
+            const totalHeight = refsArray.current.reduce((prev, curr) => {
+                if (!curr)
+                    return prev;
+                return prev + curr.clientHeight;
+            }, 0);
+            if (totalHeight > 0) {
+                setMaxHeight(`${totalHeight}px`);
+                hasInitialized.current = true;
+            }
+        }
+    });
+    // Reset refs when players change
+    useLayoutEffect(() => {
+        refsArray.current = [];
+        hasInitialized.current = false;
+        setMaxHeight('auto');
+    }, [players]);
+    // Calculate max-height from focused index to end
+    const updateMaxHeight = useCallback((focusedIndex) => {
+        const items = refsArray.current.slice(focusedIndex);
+        const totalHeight = items.reduce((prev, curr) => {
+            if (!curr)
+                return prev;
+            return prev + curr.clientHeight;
+        }, 0);
+        setMaxHeight(`${totalHeight}px`);
+    }, []);
+    // Scroll to element after transition
+    const scrollToElement = useCallback((focusedIndex) => {
+        const element = refsArray.current[focusedIndex];
+        if (!element || !wrapperRef.current)
+            return;
+        const wrapperRect = wrapperRef.current.getBoundingClientRect();
+        const elementRect = element.getBoundingClientRect();
+        const scrollTop = elementRect.top - wrapperRect.top + wrapperRef.current.scrollTop;
+        wrapperRef.current.scrollTo({ top: scrollTop, behavior: 'smooth' });
+        setScrolled(scrollTop > 60);
+    }, []);
+    const handleBecameFocused = useCallback((focusedIndex) => () => {
+        updateMaxHeight(focusedIndex);
+        if (wrapperRef.current) {
+            const handleTransitionEnd = () => {
+                scrollToElement(focusedIndex);
+                wrapperRef.current?.removeEventListener('transitionend', handleTransitionEnd);
+            };
+            wrapperRef.current.addEventListener('transitionend', handleTransitionEnd, { once: true });
+        }
+    }, [updateMaxHeight, scrollToElement]);
+    return (React.createElement("div", { className: "expanded-player-stats", style: { maxHeight }, ref: wrapperRef, "data-scrolled": scrolled }, players.map((player, index) => (React.createElement("div", { key: player.title, ref: (ref) => {
+            refsArray.current[index] = ref;
+        }, className: "expanded-player-item" },
+        React.createElement(PlayerSeasonStatsCard, { player: player, focusKey: `expanded-player-${teamKey}-${tabIndex}-${index}`, parentFocusKey: parentFocusKey, onArrowPress: onArrowPress({ tabIndex, playerIndex: index }), onBackPress: onBackPress, onBecameFocused: handleBecameFocused(index), onEnterPress: onEnterPress }))))));
+};
+export default ExpandedPlayerStats;

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

@@ -0,0 +1,97 @@
+/// <reference types="prop-types" />
+import React from 'react';
+import { PlayerSeasonStatsPlayerItem } from '../../view-model/StatsViewModel';
+import { WithFocusableProps } from '@/external/spatial-navigation';
+type Props = {
+    player: PlayerSeasonStatsPlayerItem;
+};
+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/PlayerSeasonStats/PlayerSeasonStatsCard.js

@@ -0,0 +1,23 @@
+import React from 'react';
+import HeadshotImage from '@/components/molecules/HeadshotImage';
+import { withFocusable, } from '@/external/spatial-navigation';
+const PlayerSeasonStatsCard = (props) => {
+    const { player, focused } = props;
+    return (React.createElement("div", { className: "player-card focus-ring", "data-focused": focused },
+        React.createElement("div", { className: "image-wrapper" },
+            React.createElement(HeadshotImage, { src: player.headshot, alt: `${player.title} Headshot`, crossOrigin: "anonymous", className: "cardImage" }),
+            player.position && (React.createElement("div", { className: "athlete-position-badge" },
+                React.createElement("span", { className: "T02" }, player.position)))),
+        React.createElement("div", { className: "player-info" },
+            React.createElement("div", { className: "player-name-row" },
+                React.createElement("span", { className: "player-name T05_ALT FONT_BOLD" }, player.title),
+                player.featuredStat && (React.createElement("span", { className: "featured-stat T30 FONT_BOLD" },
+                    React.createElement("span", { className: "featured-value" }, player.featuredStat.displayValue),
+                    React.createElement("span", { className: "featured-label T02" }, player.featuredStat.label)))),
+            player.statistics.length > 0 && (React.createElement("table", { className: "stats-table T10" },
+                React.createElement("thead", null,
+                    React.createElement("tr", null, player.statistics.map((stat, index) => (React.createElement("th", { key: `label-${stat.label}-${index}` }, stat.label))))),
+                React.createElement("tbody", null,
+                    React.createElement("tr", null, player.statistics.map((stat, index) => (React.createElement("td", { key: `value-${stat.label}-${index}`, className: "T10" }, stat.displayValue))))))))));
+};
+export default withFocusable()(PlayerSeasonStatsCard);

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

@@ -0,0 +1,6 @@
+import { PlayerSeasonStatsPlayerItem } from '../../view-model/StatsViewModel';
+type Props = {
+    player: PlayerSeasonStatsPlayerItem;
+};
+declare const PlayerSeasonStatsMinified: (props: Props) => JSX.Element;
+export default PlayerSeasonStatsMinified;

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

@@ -0,0 +1,13 @@
+import React from 'react';
+const PlayerSeasonStatsMinified = (props) => {
+    const { player } = props;
+    return (React.createElement("div", { className: "player-minified" },
+        React.createElement("div", { className: "player-minified-indicator" }),
+        React.createElement("span", { className: "player-minified-text T10" },
+            player.position && React.createElement("span", { className: "position" }, player.position),
+            React.createElement("span", { className: "player-name" }, player.title),
+            player.featuredStat && (React.createElement(React.Fragment, null,
+                React.createElement("span", { className: "featured-value FONT_BOLD" }, player.featuredStat.displayValue),
+                React.createElement("span", { className: "featured-label" }, player.featuredStat.label))))));
+};
+export default PlayerSeasonStatsMinified;

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

@@ -0,0 +1,8 @@
+import './PlayerSeasonStats.styles.css';
+import { WithFocusableProps } from '@/external/spatial-navigation';
+import { PlayerSeasonStatsItem } from '../../view-model/StatsViewModel';
+export type PlayerSeasonStatsViewProps = {
+    item: PlayerSeasonStatsItem;
+};
+declare const PlayerSeasonStatsView: (props: PlayerSeasonStatsViewProps & WithFocusableProps) => JSX.Element | null;
+export default PlayerSeasonStatsView;

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

@@ -0,0 +1,148 @@
+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];
+        return `expanded-player-${team.teamKey}-${tabIndex || team.sections.indexOf(activeSection)}-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 (d === 'up' && playerIndex === 0) {
+            SDK.getMaestroEventViewModel().navigation.setFocus(`player-stats-tab-${team.teamKey}-${activeTabKey}`);
+            return false;
+        }
+        // DOWN at last player -> collapse and navigate down
+        if (d === 'down' && 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];
+        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';