@maestro_io/maestro-web-sdk 2.0.2 → 2.1.0

package/dist/external/LocalStorageCacheManager.d.ts

@@ -1,10 +1,65 @@
-import { ICacheManager, ProduceCacheKeyParams } from './ports/cacheManager';
-declare class LocalStorageCacheManager implements ICacheManager {
-    private cacheDuration;
-    constructor(cacheDuration?: number);
-    produceCacheKey(payload: ProduceCacheKeyParams): string;
-    setCache(key: string, data: unknown): void;
-    getCache<T = any>(key: string): T | null;
+import { ICacheManager } from './ports/cacheManager';
+/**
+ * Manages caching using localStorage with support for TTL, size limits, and versioning.
+ * This class implements the ICacheManager interface and provides methods for setting, getting,
+ * and clearing cache entries.
+ */
+export default class LocalStorageCacheManager implements ICacheManager {
+    private readonly prefix;
+    private readonly cacheDuration;
+    private readonly maxSize;
+    private readonly version;
+    private readonly accessLog;
+    /**
+     * Creates a new LocalStorageCacheManager instance.
+     * @param cacheDuration - The time-to-live (TTL) for cache entries in milliseconds.
+     * @param maxSize - The maximum size of the cache in bytes.
+     * @param version - The version of the cache. Used to invalidate cache entries when the version changes.
+     */
+    constructor(cacheDuration?: number, maxSize?: number, version?: string);
+    /**
+     * Produces a cache key by combining the prefix, version, and the provided key.
+     * @param key - The key to be used in the cache.
+     * @returns The generated cache key.
+     */
+    produceCacheKey(key: string): string;
+    /**
+     * Calculates the current size of the cache in bytes.
+     * @returns The total size of the cache in bytes.
+     */
+    private getCurrentSize;
+    /**
+     * Cleans up old cache entries based on their TTL.
+     */
+    private cleanupOldEntries;
+    /**
+     * Cleans up least recently used cache entries when the cache is full.
+     */
+    private cleanupLRUEntries;
+    /**
+     * Sets a value in the cache with the specified key.
+     * @param key - The key to store the value under.
+     * @param data - The value to be stored in the cache.
+     */
+    setCache(key: string, data: any): void;
+    /**
+     * Retrieves a value from the cache by its key.
+     * @param key - The key to retrieve the value for.
+     * @returns The cached value, or null if the key is not found or the entry has expired.
+     */
+    getCache(key: string): any;
+    /**
+     * Clears a specific cache entry by its key.
+     * @param key - The key of the cache entry to clear.
+     */
     clearCache(key: string): void;
+    /**
+     * Clears all cache entries that match the specified pattern.
+     * @param pattern - The pattern to match against cache keys.
+     */
+    clearCacheByPattern(pattern: string): void;
+    /**
+     * Clears all cache entries.
+     */
+    clearAllCache(): void;
 }
-export default LocalStorageCacheManager;

package/dist/external/mocks/MockExternalNetworkClient.d.ts

@@ -0,0 +1,90 @@
+import { INetworkClient } from '../ports/networkClient';
+/**
+ * A mock implementation of the INetworkClient interface for testing
+ * and development purposes.
+ */
+declare class MockNetworkClient implements INetworkClient {
+    private mockResponses;
+    private mockErrors;
+    private defaultResponse;
+    private defaultError;
+    private latestRequest;
+    private delay;
+    /**
+     * Constructor for MockNetworkClient
+     *
+     * @param mockResponses - Optional initial mock responses mapping
+     * @param mockErrors - Optional initial mock errors mapping
+     * @param defaultResponse - Default response for unmocked endpoints
+     * @param delay - Simulated network delay in milliseconds
+     */
+    constructor({ mockResponses, mockErrors, defaultResponse, delay, }?: {
+        mockResponses?: Record<string, any>;
+        mockErrors?: Record<string, Error>;
+        defaultResponse?: any;
+        delay?: number;
+    });
+    /**
+     * Get the latest request made to this mock client
+     */
+    getLatestRequest(): {
+        method: string;
+        endpoint: string;
+        data?: any;
+        params?: any;
+        headers?: Record<string, string> | undefined;
+    } | null;
+    /**
+     * Set a mock response for a specific endpoint
+     *
+     * @param endpoint - The API endpoint
+     * @param response - The mock response data
+     */
+    setMockResponse(endpoint: string, response: any): void;
+    /**
+     * Set a mock error for a specific endpoint
+     *
+     * @param endpoint - The API endpoint
+     * @param error - The error to throw
+     */
+    setMockError(endpoint: string, error: Error): void;
+    /**
+     * Set a default mock response for all unmocked endpoints
+     *
+     * @param response - The default response data
+     */
+    setDefaultResponse(response: any): void;
+    /**
+     * Set a default error for all endpoints not configured with specific errors
+     *
+     * @param error - The default error
+     */
+    setDefaultError(error: Error | null): void;
+    /**
+     * Set the simulated network delay
+     *
+     * @param delayMs - Delay in milliseconds
+     */
+    setDelay(delayMs: number): void;
+    /**
+     * Clear all mock responses and errors
+     */
+    reset(): void;
+    /**
+     * Helper method to handle the common response/error/delay logic
+     */
+    private handleRequest;
+    /**
+     * Mock implementation of the get method
+     */
+    get<TResponseData = any>(endpoint: string, params?: Record<string, any>, headers?: Record<string, string>): Promise<TResponseData>;
+    /**
+     * Mock implementation of the post method
+     */
+    post<TRequestData = any, TResponseData = any>(endpoint: string, data: TRequestData): Promise<TResponseData>;
+    /**
+     * Mock implementation of setAuthentication
+     */
+    setAuthentication(token: string | null, apiKey: string | null): void;
+}
+export default MockNetworkClient;

package/dist/external/ports/cacheManager.d.ts

@@ -10,6 +10,8 @@ export interface ProduceCacheKeyParams {
 export interface ICacheManager {
     setCache(key: string, data: unknown): void;
     getCache<T = any>(key: string): T | null;
-    produceCacheKey(params: ProduceCacheKeyParams): string;
     clearCache(key: string): void;
+    clearAllCache(): void;
+    clearCacheByPattern(pattern: string): void;
+    produceCacheKey(key: string): string;
 }

package/dist/external/ports/networkClient.d.ts

@@ -1,5 +1,5 @@
 export interface INetworkClient {
-    get<TResponseData = any>(endpoint: string, params?: any): Promise<TResponseData>;
+    get<TResponseData = any>(endpoint: string, params?: Record<string, any>, headers?: Record<string, string>): Promise<TResponseData>;
     post<TRequestData = any, TResponseData = any>(endpoint: string, data: TRequestData): Promise<TResponseData>;
     setAuthentication(token: string | null, apiKey: string | null): void;
 }

package/dist/external/spatial-navigation/spatialNavigation.d.ts

@@ -1,21 +1,18 @@
-import { Direction, Layout } from './utils';
+import { Details, Direction, KEY_BACK, Layout } from './utils';
 import { KEY_ENTER } from './utils';
 export declare const ROOT_FOCUS_KEY = "SN:ROOT";
-export type KeyType = Direction | typeof KEY_ENTER;
+export type KeyType = Direction | typeof KEY_ENTER | typeof KEY_BACK;
 export interface KeyMap {
-    [key: string]: number;
+    [key: string]: number[];
 }
 interface FocusableComponent {
     focusKey: string;
     node: HTMLElement;
     parentFocusKey: string | null;
-    onEnterPressHandler?: (details: {
-        pressedKeys: Record<string, number>;
-    }) => void;
+    onEnterPressHandler?: (details: Details) => void;
+    onBackPressHandler?: (details: Details) => void;
     onEnterReleaseHandler?: () => void;
-    onArrowPressHandler?: (direction: Direction, details: {
-        pressedKeys: Record<string, number>;
-    }) => boolean | void;
+    onArrowPressHandler?: (direction: Direction, details: Details) => boolean | void;
     onBecameFocusedHandler?: (layout: Layout, details: any) => void;
     onBecameBlurredHandler?: (layout: Layout, details: any) => void;
     onUpdateFocus?: (isFocused: boolean) => void;
@@ -49,13 +46,10 @@ interface AddFocusableOptions {
     focusKey: string;
     node: HTMLElement;
     parentFocusKey: string | null;
-    onEnterPressHandler?: (details: {
-        pressedKeys: Record<string, number>;
-    }) => void;
+    onEnterPressHandler?: (details: Details) => void;
     onEnterReleaseHandler?: () => void;
-    onArrowPressHandler?: (direction: Direction, details: {
-        pressedKeys: Record<string, number>;
-    }) => boolean | void;
+    onBackPressHandler?: (details: Details) => void;
+    onArrowPressHandler?: (direction: Direction, details: Details) => boolean | void;
     onBecameFocusedHandler?: (layout: Layout, details: any) => void;
     onBecameBlurredHandler?: (layout: Layout, details: any) => void;
     forgetLastFocusedChild?: boolean;
@@ -118,20 +112,17 @@ declare class SpatialNavigation {
     getEventType(keyCode: number): KeyType | undefined;
     bindEventHandlers(): void;
     unbindEventHandlers(): void;
-    onEnterPress(details: {
-        pressedKeys: Record<string, number>;
-    }): void;
+    onEnterPress(details: Details): void;
+    onBackPress(details: Details): void;
     onEnterRelease(): void;
-    onArrowPress(direction: Direction, details: {
-        pressedKeys: Record<string, number>;
-    }): boolean | void;
+    onArrowPress(direction: Direction, details: Details): boolean | void;
     navigateByDirection(direction: Direction, details?: Record<string, any>): void;
     onKeyEvent(event: KeyboardEvent): void;
     smartNavigate(direction: Direction, fromParentFocusKey: string | null, details: Record<string, any>): void;
     saveLastFocusedChildKey(component: FocusableComponent | undefined, focusKey: string): void;
     log(functionName: string, debugString: string, ...rest: any[]): void;
     getNextFocusKey(targetFocusKey: string): string;
-    addFocusable({ focusKey, node, parentFocusKey, onEnterPressHandler, onEnterReleaseHandler, onArrowPressHandler, onBecameFocusedHandler, onBecameBlurredHandler, forgetLastFocusedChild, trackChildren, onUpdateFocus, onUpdateHasFocusedChild, preferredChildFocusKey, autoRestoreFocus, focusable, blockNavigationOut, }: AddFocusableOptions): void;
+    addFocusable({ focusKey, node, parentFocusKey, onEnterPressHandler, onEnterReleaseHandler, onBackPressHandler, onArrowPressHandler, onBecameFocusedHandler, onBecameBlurredHandler, forgetLastFocusedChild, trackChildren, onUpdateFocus, onUpdateHasFocusedChild, preferredChildFocusKey, autoRestoreFocus, focusable, blockNavigationOut, }: AddFocusableOptions): void;
     removeFocusable({ focusKey }: {
         focusKey: string;
     }): void;

package/dist/external/spatial-navigation/utils.d.ts

@@ -3,6 +3,7 @@ export declare const DIRECTION_RIGHT = "right";
 export declare const DIRECTION_UP = "up";
 export declare const DIRECTION_DOWN = "down";
 export declare const KEY_ENTER = "enter";
+export declare const KEY_BACK = "back";
 export type Direction = typeof DIRECTION_LEFT | typeof DIRECTION_RIGHT | typeof DIRECTION_UP | typeof DIRECTION_DOWN;
 export interface Layout {
     x: number;
@@ -13,3 +14,7 @@ export interface Layout {
     top: number;
     node: HTMLElement;
 }
+export interface Details {
+    pressedKeys: Record<string, number>;
+    layout?: Layout;
+}

package/dist/external/spatial-navigation/withFocusable.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
 import PropTypes from 'prop-types';
-import { Direction, Layout } from './utils';
+import { Details, Direction, Layout } from './utils';
 interface WithFocusableConfig {
     forgetLastFocusedChild?: boolean;
     trackChildren?: boolean;
@@ -16,16 +16,14 @@ export interface WithFocusableProps {
     trackChildren?: boolean;
     autoRestoreFocus?: boolean;
     blockNavigationOut?: boolean;
+    hasFocusedChild?: boolean;
     focusable?: boolean;
-    onEnterPress?: (props: any, details: {
-        pressedKeys: Record<string, number>;
-    }) => void;
+    onEnterPress?: (props: any, details: Details) => void;
     onEnterRelease?: (props: any) => void;
-    onArrowPress?: (direction: Direction, props: any, details: {
-        pressedKeys: Record<string, number>;
-    }) => boolean | void;
-    onBecameFocused?: (layout: Layout, props: any, details: any) => void;
-    onBecameBlurred?: (layout: Layout, props: any, details: any) => void;
+    onBackPress?: (props: any, details: Details) => void;
+    onArrowPress?: (direction: Direction, props: any, details: Details) => boolean | void;
+    onBecameFocused?: (layout: Layout, props: any, details: Details) => void;
+    onBecameBlurred?: (layout: Layout, props: any, details: Details) => void;
 }
 export interface WithFocusableState {
     realFocusKey: string;
@@ -44,15 +42,12 @@ declare const withFocusable: <P extends object>({ forgetLastFocusedChild: config
         stealFocus: () => void;
         onUpdateFocus: (focused: boolean) => void;
         onUpdateHasFocusedChild: (hasFocusedChild: boolean) => void;
-        onEnterPressHandler: (details: {
-            pressedKeys: Record<string, number>;
-        }) => void;
+        onEnterPressHandler: (details: Details) => void;
         onEnterReleaseHandler: () => void;
-        onArrowPressHandler: (direction: Direction, details: {
-            pressedKeys: Record<string, number>;
-        }) => boolean | void;
-        onBecameFocusedHandler: (layout: Layout, details: any) => void;
-        onBecameBlurredHandler: (layout: Layout, details: any) => void;
+        onBackPressHandler: (details: Details) => void;
+        onArrowPressHandler: (direction: Direction, details: Details) => boolean | void;
+        onBecameFocusedHandler: (layout: Layout, details: Details) => void;
+        onBecameBlurredHandler: (layout: Layout, details: Details) => void;
         componentDidMount(): void;
         componentDidUpdate(): void;
         componentWillUnmount(): void;

package/dist/index.d.ts

@@ -3,6 +3,9 @@ import IMaestroManager, { SDKConfigParams } from './interfaces/IMaestroManager';
 import IMaestroEvent from './interfaces/IMaestroEvent';
 import { MaestroEventViewModel } from './view-models/MaestroEventViewModel';
 import type IMaestroKeyPlaysResponse from './modules/key-plays/interfaces/IKeyPlaysResponse';
+export { default as Overlay } from './components/molecules/Overlay/Overlay';
+export { OverlayType, type IMaestroOverlayEvent, type IOverlaySize, type IOverlayPosition, type IFantasyPayload, type IOverlayAnalyticsEvent } from './types/OverlayTypes';
+export { type IWinningBet } from './models/IWinningBet';
 export { type IMaestroEventDelegate, type IMaestroEvent, type IMaestroKeyPlaysResponse, };
 export type Environment = 'development' | 'staging' | 'production';
 /**
@@ -13,19 +16,19 @@ declare class MaestroWebSDK implements IMaestroManager {
     private static instance;
     private renderer;
     private siteID?;
-    private jwt?;
     private userID?;
+    private maestroJwt?;
+    private clientAppToken?;
+    private clientAppSwid?;
     private maestroEventViewModel;
     private constructor();
-    userDidStartWatchingEvent(eventID: string, delegate: IMaestroEventDelegate): Promise<IMaestroEvent>;
-    userDidStopWatchingEvent(eventId: string): void;
-    authenticateUser(_: string, __: string): Promise<void>;
-    deauthenticateUser(): Promise<void>;
     /**
      * @description Returns the MaestroWebSDK instance
      * @returns {MaestroWebSDK} - The MaestroWebSDK instance
      */
     static getInstance(): MaestroWebSDK;
+    userDidStartWatchingEvent(eventID: string, delegate: IMaestroEventDelegate): Promise<IMaestroEvent>;
+    userDidStopWatchingEvent(_: string): void;
     configure(configParams: SDKConfigParams): void;
     /**
      * Checks if this is an authorized client based on siteID
@@ -37,12 +40,6 @@ declare class MaestroWebSDK implements IMaestroManager {
      */
     setSiteID(siteID?: string): void;
     getSiteID(): string | undefined;
-    /**
-     * Sets the JWT token for authentication
-     * @param jwt The JWT token to set
-     */
-    setJwt(jwt: string): void;
-    getJwt(): string | undefined;
     /**
      * Sets the user ID for the SDK
      * @param userID The user ID to set
@@ -54,7 +51,21 @@ declare class MaestroWebSDK implements IMaestroManager {
      * @returns The current event view model
      */
     getMaestroEventViewModel(): MaestroEventViewModel;
+    /**
+     * Gets the view models container
+     * @returns The current view models
+     */
+    getMaestroViewModels(): import("./view-models").MaestroViewModels | null;
     renderPanel(id: string): Promise<() => void>;
+    setMaestroJwt(jwt: string | undefined): void;
+    setClientAppSwid(swid: string | undefined): void;
+    setClientAppToken(jwt: string | undefined): void;
+    authenticateUser(swid: string, token: string): Promise<void>;
+    deauthenticateUser(): Promise<void>;
+    getCurrentMaestroJwt(): string | undefined;
+    getClientAppToken(): string | undefined;
+    getCurrentUserID(): string | undefined;
+    getClientAppSwid(): string | undefined;
 }
 declare const SDK: MaestroWebSDK;
 export default SDK;

package/dist/interfaces/IMaestroEvent.d.ts

@@ -1,3 +1,4 @@
+import { MaestroPanelType } from '@/models/IPanel';
 import IMaestroKeyPlaysResponse from '../modules/key-plays/interfaces/IKeyPlaysResponse';
 /**
  * This is the public API that the app can use to make calls to the SDK related to the currently-loaded event.
@@ -59,4 +60,12 @@ export default interface IMaestroEvent {
      * @description Feeds the SDK new key plays data. A null value indicates a failure to retrieve the data.
      */
     updateKeyPlaysData(data: IMaestroKeyPlaysResponse | null): Promise<void>;
+    simulateUseCase<T = any>(useCase: TestUseCase, panelType: MaestroPanelType, testData?: T): void;
 }
+declare const TEST_USE_CASES: {
+    readonly betsTabLoadFailure: "betsTabLoadFailure";
+    readonly betsMockData: "betsMockData";
+    readonly betsLiveData: "betsLiveData";
+};
+export type TestUseCase = typeof TEST_USE_CASES[keyof typeof TEST_USE_CASES];
+export {};

package/dist/interfaces/IMaestroEventDelegate.d.ts

@@ -15,4 +15,21 @@ export default interface IMaestroEventDelegate {
      * @description SDK can notify the client app when its time to handle the focus management
      */
     startFocusManagement(): Promise<void>;
+    /**
+     * @description Check if the user is authenticated for betting
+     */
+    userIsAuthenticated(): Promise<boolean>;
+    /**
+     * @description Get the user's SWID for authenticated betting requests
+     */
+    getUserSWID(): Promise<string | null>;
+    /**
+     * @description Get the user's Cookie token for authenticated betting requests
+     */
+    getUserToken(): Promise<string | null>;
+    /**
+     * @description Get the API endpoint for betting-related requests.
+     * This endpoint is used to fetch betting data, such as odds and betting lines.
+     */
+    getBettingAPIBaseURL(): string;
 }

package/dist/interfaces/IMaestroManager.d.ts

@@ -17,14 +17,22 @@ export type SDKConfigParams = {
      * The site ID to use for the SDK.
      */
     siteID?: string;
-    /**
-     * The JWT token to use for authentication.
-     */
-    jwt?: string;
     /**
      * The user ID of the logged account.
      */
     userID?: string;
+    /**
+     * The Maestro JWT token for authentication.
+     */
+    maestroJwt?: string;
+    /**
+     * The client app Cookie Token for authentication.
+     */
+    clientAppToken?: string;
+    /**
+     * The client app SWID for authentication.
+     */
+    clientAppSwid?: string;
 };
 /**
  This is the MaestroKit top-level API for initializing and configuring the framework.  It encompasses all functionality that is not specific to an event.
@@ -42,12 +50,12 @@ export default interface IMaestroManager {
      */
     configure(configParams: SDKConfigParams): void;
     /**
-     Tells the SDK the user has opened an event in the app's player.
-     Arguments:
-     - eventID: The Event ID for the event opened in the player.
-     - delegate: an instance of the app's implementation of IMaestroEventDelegate
-     The function returns an instance of MaestroEventViewModel, which includes an implementation of IMaestroEvent.  IMaestroEvent represents the app-facing portion of the MaestroKit API related to the currently-loaded event.  So after `userDidStartWatchingEvent` is called, the SDK has access to the API detailed in `MaestroEventDelegate` for making calls to the app, and the app has access to the API detailed in `IMaestroEvent` for making calls to the SDK.
-    */
+       Tells the SDK the user has opened an event in the app's player.
+       Arguments:
+       - eventID: The Event ID for the event opened in the player.
+       - delegate: an instance of the app's implementation of IMaestroEventDelegate
+       The function returns an instance of MaestroEventViewModel, which includes an implementation of IMaestroEvent.  IMaestroEvent represents the app-facing portion of the MaestroKit API related to the currently-loaded event.  So after `userDidStartWatchingEvent` is called, the SDK has access to the API detailed in `MaestroEventDelegate` for making calls to the app, and the app has access to the API detailed in `IMaestroEvent` for making calls to the SDK.
+      */
     userDidStartWatchingEvent(eventID: string, delegate: IMaestroEventDelegate): Promise<IMaestroEvent>;
     /**
      * @description Tells the SDK the user has closed an event that was open in the app's player.
@@ -55,11 +63,11 @@ export default interface IMaestroManager {
      */
     userDidStopWatchingEvent(eventID: string): void;
     /**
-     * @description Authenticates user.
-     * @param id - The user's ID.
-     * @param jwt - The user's jwt.
+     * @description Authenticates user with SWID and Token.
+     * @param swid - The user's SWID.
+     * @param token - The user's Cookie Token.
      */
-    authenticateUser(id: string, jwt: string): Promise<void>;
+    authenticateUser(swid: string, token: string): Promise<void>;
     /**
      * Logs out currently-authenticated user.
      */
@@ -70,13 +78,18 @@ export default interface IMaestroManager {
      */
     getSiteID(): string | undefined;
     /**
-     * Gets the JWT token for authentication
-     * @returns The JWT token
+     * Gets the current JWT token used in conjunction with the user's SWID.
+     * @returns The current JWT token
+     */
+    getClientAppToken(): string | undefined;
+    /**
+     * Gets the current user ID.
+     * @returns The current user ID
      */
-    getJwt(): string | undefined;
+    getCurrentUserID(): string | undefined;
     /**
-     * Gets the user ID for the SDK
-     * @returns The user ID
+     * Gets the current SWID.
+     * @returns The current SWID
      */
-    getUserID(): string | undefined;
+    getClientAppSwid(): string | undefined;
 }