@maestro_io/maestro-web-sdk 3.1.2 → 3.2.0

package/dist/src/modules/fantasy/view-model/FantasyViewModel.d.ts

@@ -0,0 +1,146 @@
+import { Observable } from '@/helpers/Observable';
+import IMaestroEventDelegate from '@/interfaces/IMaestroEventDelegate';
+type NotLoggedInFantasyItem = {
+    id: string;
+    type: 'notLoggedIn';
+};
+export type PromoFantasyItem = {
+    id: string;
+    type: 'promo';
+    background: string;
+    logo: string;
+    title: string;
+    qrCode: string;
+    description: string;
+};
+export type InactiveLeague = {
+    id: string;
+    type: 'inactiveLeague';
+    leagueName: string;
+    draftDate?: number;
+    leagueLogo: string;
+    leagueColor: string;
+};
+type MatchupSingleTeam = {
+    points: number;
+    logo: string;
+    scoringType: string;
+};
+export type MatchupSingleRoster = {
+    athleteHeadshot: string;
+    athleteAbbrevName: string;
+    athletesSlot: string;
+    teamTriCode: string;
+    proGameStatusLines: string[];
+};
+export type MatchupActiveAthlete = {
+    abbrevName: string;
+    points: string;
+};
+export type MatchupSingleItem = {
+    id: string;
+    type: 'matchup-single';
+    league: {
+        title: string;
+        subtitle: string | undefined;
+        color: string;
+        logo: string;
+    };
+    team: MatchupSingleTeam;
+    roster: MatchupSingleRoster[];
+    activeAthletes: MatchupActiveAthlete[];
+    topPlayers: TopPlayer[];
+};
+export type TopPlayer = {
+    abbrevName: string;
+    headshot: string;
+    position: string;
+    teamTriCode: string;
+    points: number;
+    rosteredBy: string;
+};
+type MatchupPairTeam = {
+    name: string | undefined;
+    record: string | undefined;
+    points: string | undefined;
+    projectedPoints: string | undefined;
+    logo: string | undefined;
+    winProbability: number | undefined;
+};
+type MatchupPairRosterData = {
+    headshot: string;
+    abbrevName: string;
+    slot: string;
+    triCode: string;
+    points?: number;
+    projectedPoints?: number;
+    stats: string[];
+};
+export type MatchupPairRoster = {
+    away: MatchupPairRosterData;
+    home: MatchupPairRosterData;
+};
+export type MatchupPairItem = {
+    id: string;
+    type: 'matchup-pair';
+    league: {
+        title: string | undefined;
+        subtitle: string | undefined;
+        color: string;
+        logo: string;
+    };
+    awayTeam: MatchupPairTeam;
+    homeTeam: MatchupPairTeam;
+    roster: MatchupPairRoster[];
+    activeAthletes: MatchupActiveAthlete[];
+    topPlayers: TopPlayer[];
+};
+export type FantasyItem = NotLoggedInFantasyItem | MatchupPairItem | MatchupSingleItem | InactiveLeague | PromoFantasyItem;
+declare const FANTASY_ERROR_STATE: {
+    readonly NONE: "none";
+    readonly TAB_LOAD_FAILURE: "tabLoadFailure";
+};
+export type FantasyErrorState = typeof FANTASY_ERROR_STATE[keyof typeof FANTASY_ERROR_STATE];
+export declare class FantasyViewModel {
+    fantasyItems: Observable<FantasyItem[]>;
+    isDataLoading: Observable<boolean>;
+    hasEverSuccessfullyLoaded: Observable<boolean>;
+    private eventId;
+    private delegate;
+    private analyticsService;
+    private fantasyService;
+    private useMockData;
+    private fantasyPolling;
+    private leagueManagerPolling;
+    errorState: Observable<FantasyErrorState>;
+    constructor(eventId: string, delegate: IMaestroEventDelegate, options?: {
+        useMockData?: boolean;
+    });
+    /**
+     * Initialize the ViewModel and start data fetching
+     */
+    init(): Promise<void>;
+    private fetchData;
+    onEngage(type: FantasyItem['type']): void;
+    onAskLogin(): void;
+    /**
+     * Clean up resources when the ViewModel is no longer needed
+     */
+    cleanup(): void;
+    /**
+     * Track panel view event
+     */
+    private trackPanelView;
+    private processFantasy;
+    private parseRoto;
+    append(item: FantasyItem | null): void;
+    private parseHeadToHead;
+    private parseTopPlayers;
+    private parseInactiveLeague;
+    /**
+     * Fetch mock data for testing
+     */
+    private fetchMockData;
+    clearTabLoadFailure(): void;
+}
+export default FantasyViewModel;

package/dist/src/modules/stats/view-model/StatsViewModel.d.ts

@@ -233,9 +233,4 @@ export declare class StatsViewModel extends ViewModel {
      */
     simulateUseCase<T = any>(_useCase: TestUseCase, testData?: T): void;
 }
-declare global {
-    interface String {
-        hashCode(): number;
-    }
-}
 export default StatsViewModel;

package/dist/src/services/AnalyticsService/AnalyticsService.d.ts

@@ -30,7 +30,14 @@ type StatsItemClickedAction = {
         game_state: string[];
     };
 };
-type PanelClickPayload = KeyPlaysClickedAction | BetsItemClickedAction | StatsItemClickedAction;
+type FantasyItemClickedAction = {
+    type: 'espnFantasy';
+    name: 'fantasy_item_clicked';
+    metadata: {
+        card: string;
+    };
+};
+type PanelClickPayload = KeyPlaysClickedAction | BetsItemClickedAction | StatsItemClickedAction | FantasyItemClickedAction;
 type PanelData = {
     panel_type: string;
     panel_id: string;
@@ -46,10 +53,10 @@ declare class AnalyticsService {
     constructor();
     private trackAction;
     private trackImpression;
-    panelView(panelType: 'espnStats' | 'espnKeyPlays' | 'espnBet', metadata?: Record<string, any>): Promise<void>;
+    panelView(panelType: 'espnStats' | 'espnKeyPlays' | 'espnBet' | 'espnFantasy', metadata?: Record<string, any>): Promise<void>;
     panelClick({ type, metadata, name }: PanelClickPayload): Promise<void>;
     getBaseMetadataFromPageConfig(pageConfig: PageConfig | null): BaseMetadata;
-    getPanelDataFromPageConfig(type: 'espnBet' | 'espnStats' | 'espnKeyPlays', pageConfig: PageConfig | null): PanelData;
+    getPanelDataFromPageConfig(type: 'espnBet' | 'espnStats' | 'espnKeyPlays' | 'espnFantasy', pageConfig: PageConfig | null): PanelData;
     sessionStart(): Promise<void>;
     sessionEnd(): Promise<void>;
     private scheduleNextBeacon;

package/dist/src/services/FantasyService.d.ts

@@ -0,0 +1,54 @@
+import NetworkManager from './NetworkManager/NetworkManager';
+import { IFantasyResponse, ILeagueManagerResponse, IPromoResponse } from '@/modules/fantasy/types';
+export type LeagueManagerPollingParams = {
+    /**
+     * NBA, NFL, etc.
+     */
+    game: string;
+    /**
+     * 2025
+     */
+    seasonId: number;
+    /**
+     * The league ID
+     */
+    leagueId: number;
+    token: string;
+    proGameId: string;
+    teamId: number;
+};
+export type FantasyPollingParams = {
+    swid: string;
+    jwt: string;
+    eventId: string;
+};
+/**
+ * Service for handling fantasy API calls
+ */
+declare class FantasyService {
+    fantasyClient: NetworkManager;
+    leagueManagerClient: NetworkManager;
+    promoClient: NetworkManager;
+    constructor();
+    /**
+     * Polls the fantasy API at regular intervals
+     * @param swid - The SWID of the user
+     * @param interval - Polling interval in milliseconds
+     * @param onData - Callback invoked with the data on each successful poll
+     * @param onError - Optional callback invoked on error
+     */
+    pollFantasy({ eventId, jwt, swid }: FantasyPollingParams, interval: number, onData: (data: {
+        data: IFantasyResponse;
+        headers: Record<string, string>;
+    }) => void, onError?: (error: Error) => void): {
+        stop: () => void;
+    };
+    pollLeagueManager({ game, leagueId, seasonId, token, proGameId, teamId, }: LeagueManagerPollingParams, interval: number, onData: (data: {
+        data: ILeagueManagerResponse;
+        headers: Record<string, string>;
+    }) => void, onError?: (error: Error) => void): {
+        stop: () => void;
+    };
+    getPromo(): Promise<IPromoResponse>;
+}
+export default FantasyService;

package/dist/src/services/NetworkManager/types.d.ts

@@ -5,6 +5,7 @@ export declare const ServiceType: {
     readonly STATS: "stats";
     readonly BETS: "bets";
     readonly MAESTRO: "maestro";
+    readonly FANTASY: "fantasy";
 };
 export type ServiceType = typeof ServiceType[keyof typeof ServiceType];
 /**

package/dist/src/view-models/MaestroEventViewModel.d.ts

@@ -11,6 +11,7 @@ import { MaestroPanelType } from '@/models/IPanel';
 import { IUserSettings } from '../interfaces/IUserSettings';
 import { PanelManagerViewModel } from './PanelManagerViewModel';
 import AnalyticsService from '@/services/AnalyticsService/AnalyticsService';
+import FantasyViewModel from '@/modules/fantasy/view-model/FantasyViewModel';
 export declare class MaestroEventViewModel extends ViewModel implements IMaestroEvent {
     private _eventId;
     private _title;
@@ -19,6 +20,7 @@ export declare class MaestroEventViewModel extends ViewModel implements IMaestro
     private playerTimeCode;
     delegate: IMaestroEventDelegate;
     keyPlaysViewModel: KeyPlaysViewModel | null;
+    fantasyViewModel: FantasyViewModel | null;
     betsViewModel: BetsViewModel | null;
     statsViewModel: StatsViewModel | null;
     panelManagerViewModel: PanelManagerViewModel;
@@ -28,7 +30,7 @@ export declare class MaestroEventViewModel extends ViewModel implements IMaestro
     setActivePanel(panelType: MaestroPanelType): void;
     updatePlayerTimeCode(timestamp: number): void;
     getPlayerTimeCode(): number | null;
-    deinit(): void;
+    deinit(): Promise<void>;
     updateKeyPlaysData(data: IMaestroKeyPlaysResponse | null): Promise<void>;
     updateUserSettings(settings: IUserSettings): Promise<void>;
     startFocusManagement(): Promise<void>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@maestro_io/maestro-web-sdk",
   "private": false,
-  "version": "3.1.2",
+  "version": "3.2.0",
   "type": "commonjs",
   "license": "MIT",
   "main": "dist/maestro-web-sdk.umd.js",