saltfish/dist/managers/EventManager.d.ts

An interactive video-guided tour system for web applications

/**
 * Event types that can be subscribed to in the Saltfish Player
 */
export type SaltfishEventName = 'initialized' | 'playlistStarted' | 'playlistEnded' | 'playlistDismissed' | 'stepStarted' | 'stepEnded' | 'playerMinimized' | 'playerMaximized' | 'playerPaused' | 'playerResumed' | 'interactionRequired' | 'interactionCompleted' | 'userDataLoaded' | 'error';
/**
 * Base interface for all event payloads
 */
interface SaltfishEventBase {
    timestamp: number;
}
/**
 * playlist related event payloads
 */
export interface playlistEvent extends SaltfishEventBase {
    playlist: {
        id: string;
        title?: string;
    };
}
/**
 * Step related event payloads
 */
export interface StepEvent extends SaltfishEventBase {
    step: {
        id: string;
        title?: string;
    };
    playlist: {
        id: string;
        title?: string;
    };
}
/**
 * Player state related event payloads
 */
export interface PlayerEvent extends SaltfishEventBase {
    previousState?: string;
    currentState: string;
}
/**
 * Interaction related event payloads
 */
export interface InteractionEvent extends SaltfishEventBase {
    interactionId: string;
    stepId: string;
    playlistId: string;
}
/**
 * Error related event payloads
 */
export interface ErrorEvent extends SaltfishEventBase {
    playlistId?: string;
    stepId?: string;
    error: Error;
    errorType?: string;
}
/**
 * User data related event payloads
 */
export interface UserDataEvent extends SaltfishEventBase {
    userId: string;
    userData: any;
}
/**
 * Union type of all possible event payloads
 */
export type SaltfishEventPayload = playlistEvent | StepEvent | PlayerEvent | InteractionEvent | ErrorEvent | UserDataEvent;
/**
 * Type mapping between event names and their payloads
 */
export interface SaltfishEventMap {
    'initialized': SaltfishEventBase;
    'playlistStarted': playlistEvent;
    'playlistEnded': playlistEvent;
    'playlistDismissed': playlistEvent;
    'stepStarted': StepEvent;
    'stepEnded': StepEvent;
    'playerMinimized': PlayerEvent;
    'playerMaximized': PlayerEvent;
    'playerPaused': PlayerEvent;
    'playerResumed': PlayerEvent;
    'interactionRequired': InteractionEvent;
    'interactionCompleted': InteractionEvent;
    'userDataLoaded': UserDataEvent;
    'error': ErrorEvent;
}
/**
 * Type for event handlers based on event name
 */
export type EventHandler<T extends SaltfishEventName> = (event: SaltfishEventMap[T]) => void;
/**
 * Manager for handling event subscriptions and dispatching
 */
export declare class EventManager {
    private listeners;
    /**
     * Subscribes to an event
     * @param eventName - Name of the event to subscribe to
     * @param handler - Function to call when the event is triggered
     */
    on<T extends SaltfishEventName>(eventName: T, handler: EventHandler<T>): void;
    /**
     * Unsubscribes from an event
     * @param eventName - Name of the event to unsubscribe from
     * @param handler - Handler function to remove
     * @returns true if the handler was removed, false if it wasn't found
     */
    off<T extends SaltfishEventName>(eventName: T, handler: EventHandler<T>): boolean;
    /**
     * Triggers an event, calling all subscribed handlers
     * @param eventName - Name of the event to trigger
     * @param payload - Data to pass to the event handlers
     */
    trigger<T extends SaltfishEventName>(eventName: T, payload: SaltfishEventMap[T]): void;
    /**
     * Removes all event listeners
     */
    removeAllListeners(): void;
    /**
     * Gets the count of listeners for a specific event
     * @param eventName - Name of the event
     * @returns Number of listeners for the event
     */
    getListenerCount(eventName: SaltfishEventName): number;
}
export {};
//# sourceMappingURL=EventManager.d.ts.map