saltfish/dist/managers/AnalyticsManager.d.ts

An interactive video-guided tour system for web applications

import type { SaltfishConfig, UserData } from '../types';
import type { EventManager } from './EventManager';
import { EventSubscriberManager } from './EventSubscriberManager';
/**
 * Manager class for tracking and reporting analytics events
 *
 * This class handles tracking of various events in the player, including:
 * - Standard events: playlistStart, playlistComplete, stepStarted, stepComplete
 * - Player state events: playerPaused, playerResumed, playerMinimized, playerMaximized
 * - Error events
 *
 * Events are queued and sent in batches to the backend analytics API.
 */
export declare class AnalyticsManager extends EventSubscriberManager {
    private config;
    private user;
    private eventQueue;
    private isSending;
    private flushInterval;
    private sessionId;
    private analyticsEnabled;
    private boundVisibilityHandler;
    /**
     * Creates a new AnalyticsManager
     * @param eventManager - Optional event manager to subscribe to events
     */
    constructor(eventManager?: EventManager);
    /**
     * Subscribe to relevant player events for analytics tracking
     */
    protected subscribeToEvents(): void;
    /**
     * Initializes the analytics manager
     * @param config - Saltfish configuration
     * @param sessionId - Unique session identifier
     */
    initialize(config: SaltfishConfig, sessionId?: string): void;
    /**
     * Sets the current user
     * @param user - User data
     */
    setUser(user: UserData): void;
    /**
     * Tracks a playlist start event
     * @param playlistId - playlist ID
     */
    trackPlaylistStart(playlistId: string): void;
    /**
     * Tracks a playlist completion event
     * @param playlistId - playlist ID
     */
    trackPlaylistComplete(playlistId: string): void;
    /**
     * Tracks a step started event
     * @param playlistId - playlist ID
     * @param stepId - Step ID
     */
    trackStepStarted(playlistId: string, stepId: string): void;
    /**
     * Tracks a step completion event
     * @param playlistId - playlist ID
     * @param stepId - Step ID
     */
    trackStepComplete(playlistId: string, stepId: string): void;
    /**
     * Tracks an interaction event
     * @param playlistId - playlist ID
     * @param stepId - Step ID
     * @param interactionData - Interaction data
     */
    trackInteraction(playlistId: string, stepId: string, interactionData: Record<string, any>): void;
    /**
     * Tracks an error event
     * @param playlistId - playlist ID
     * @param error - Error object
     * @param stepId - Optional step ID
     * @param errorType - Optional error type/category (e.g., 'playlist', 'video', 'network', 'initialization')
     * @param videoUrl - Optional video URL that failed
     * @param mediaErrorCode - Optional browser MediaError code
     * @param mediaErrorMessage - Optional browser MediaError message
     * @param failureReason - Optional failure reason categorization
     */
    trackError(playlistId: string, error: Error, stepId?: string, errorType?: string, videoUrl?: string, mediaErrorCode?: number, mediaErrorMessage?: string, failureReason?: string): void;
    /**
     * Tracks a generic event
     * @param event - Event data
     */
    private trackEvent;
    /**
     * Manually flush queued events immediately
     * This is useful for ensuring events are sent before player destruction
     */
    flush(): Promise<void>;
    /**
     * Sends queued events to the backend
     */
    private flushEvents;
    /**
     * Handles visibility change events to flush analytics when page is hidden
     * Uses sendBeacon for reliable delivery during page unload
     */
    private handleVisibilityChange;
    /**
     * Flushes events using sendBeacon API for reliable delivery during page unload
     * sendBeacon is fire-and-forget and survives page navigation/close
     */
    private flushWithBeacon;
    /**
     * Cleans up resources used by the analytics manager
     */
    destroy(): void;
    /**
     * Gets the current runId from the player
     * @returns The current runId or null if not available
     */
    private getRunId;
}
//# sourceMappingURL=AnalyticsManager.d.ts.map