saltfish/dist/core/services/ServiceInterfaces.d.ts

An interactive video-guided tour system for web applications

import type { SaltfishConfig, PlaylistOptions, WatchedPlaylists, Step } from '../../types';
import type { ShadowDOMManager } from '../../managers/ShadowDOMManager';
import type { VideoManager } from '../../managers/VideoManager';
import type { CursorManager } from '../../managers/CursorManager';
import type { InteractionManager } from '../../managers/InteractionManager';
import type { AnalyticsManager } from '../../managers/AnalyticsManager';
import type { SessionManager } from '../../managers/SessionManager';
import type { TransitionManager } from '../../managers/TransitionManager';
import type { TriggerManager } from '../../managers/TriggerManager';
import type { ABTestManager } from '../../managers/ABTestManager';
import type { EventManager } from '../../managers/EventManager';
import type { PlaylistManager } from '../../managers/PlaylistManager';
import type { StepTimeoutManager } from '../../managers/StepTimeoutManager';
import type { UIManager } from '../../managers/UIManager';
import type { StorageManager } from '../../managers/StorageManager';
/**
 * Base interface for all services
 */
export interface Service {
    /**
     * Initialize the service with configuration
     */
    initialize?(config: SaltfishConfig): Promise<void>;
    /**
     * Cleanup service resources
     */
    destroy(): void;
}
/**
 * Service for handling player initialization logic
 */
export interface IPlayerInitializationService extends Service {
    /**
     * Initialize the player with configuration
     */
    initialize(config: SaltfishConfig): Promise<void>;
    /**
     * Fetch user data from backend
     */
    fetchUserData(userId: string, userData?: Record<string, unknown>): Promise<void>;
    /**
     * Load anonymous user data from localStorage
     */
    loadAnonymousUserData(userId: string, userData?: Record<string, unknown>): Promise<void>;
    /**
     * Check for in-progress playlists and resume them
     */
    checkAndResumeInProgressPlaylist(watchedPlaylists: WatchedPlaylists): Promise<boolean>;
    /**
     * Get or create persistent anonymous user ID
     */
    getOrCreateAnonymousUserId(): string;
    /**
     * Get the last config for restoration after reinitialization
     */
    getLastConfig(): SaltfishConfig | null;
}
/**
 * Service for handling user identification and A/B testing
 */
export interface IUserManagementService extends Service {
    /**
     * Identify a user with ID and optional data
     */
    identifyUser(userId: string, userData?: Record<string, unknown>): void;
    /**
     * Identify user anonymously with optional data
     */
    identifyAnonymous(userData?: Record<string, unknown>): Promise<void>;
    /**
     * Record A/B test attempt for analytics
     */
    recordABTestAttempt(playlistId: string): Promise<void>;
    /**
     * Get the last user identification for restoration
     */
    getLastUserIdentification(): {
        userId: string;
        userData?: Record<string, unknown>;
    } | null;
    /**
     * Get the user data loaded promise for waiting on A/B test assignments
     */
    getUserDataLoadedPromise(): Promise<void> | null;
    /**
     * Resolve the user data loaded promise (internal method)
     */
    resolveUserDataLoaded(): void;
}
/**
 * Service for handling playlist lifecycle and coordination
 */
export interface IPlaylistOrchestrator extends Service {
    /**
     * Start a playlist with given options
     */
    startPlaylist(playlistId: string, options?: PlaylistOptions): Promise<void>;
    /**
     * Reset current playlist to initial state
     */
    resetPlaylist(): void;
}
/**
 * Service for handling state machine action registration
 */
export interface IStateMachineActionHandler extends Service {
    /**
     * Register all state machine actions with the store
     */
    registerStateMachineActions(): void;
    /**
     * Get video URL for a step (with translation support)
     */
    getVideoUrl(step: Step): string;
    /**
     * Set the destroy callback for player destruction
     */
    setDestroyCallback(callback: () => void): void;
    /**
     * Find next video URL for preloading
     */
    findNextVideoUrl(currentStep: Step): string | null;
}
/**
 * Service for handling manager coordination and lifecycle
 */
export interface IManagerOrchestrator extends Service {
    /**
     * Set up UI and event updaters
     */
    setupUpdaters(): void;
    /**
     * Handle store state changes
     */
    handleStoreChanges(): void;
    /**
     * Clean up current playlist state
     */
    cleanupCurrentPlaylist(): void;
    /**
     * Clean up playlist while preserving trigger monitoring
     */
    cleanupPlaylist(): void;
    /**
     * Get all managed managers for external access
     */
    getManagers(): ManagedManagers;
}
/**
 * Collection of all manager instances
 * Uses concrete types for now - we'll create interfaces when we split god objects
 */
export interface ManagedManagers {
    shadowDOMManager: ShadowDOMManager;
    videoManager: VideoManager;
    cursorManager: CursorManager;
    interactionManager: InteractionManager;
    analyticsManager: AnalyticsManager;
    sessionManager: SessionManager;
    transitionManager: TransitionManager;
    triggerManager: TriggerManager;
    abTestManager: ABTestManager;
    eventManager: EventManager;
    playlistManager: PlaylistManager;
    stepTimeoutManager: StepTimeoutManager;
    uiManager: UIManager;
    storageManager: StorageManager;
}
/**
 * Factory for creating manager instances
 */
export interface IManagerFactory {
    createManagers(): ManagedManagers;
    resetManagers(managers: ManagedManagers): void;
    destroyManagers(managers: ManagedManagers): void;
}
//# sourceMappingURL=ServiceInterfaces.d.ts.map