uneeq-js 3.6.4 → 3.6.6

package/dist/connection-state-manager.d.ts

@@ -0,0 +1,263 @@
+import { Subject } from 'rxjs';
+/**
+ * Enum representing all possible connection states
+ */
+export declare enum ConnectionState {
+    /** No connection initiated */
+    Idle = "Idle",
+    /** Initial connection attempt in progress */
+    Connecting = "Connecting",
+    /** Video stream has been initialized */
+    VideoInitializing = "VideoInitializing",
+    /** Connection fully established and ready for interaction */
+    Connected = "Connected",
+    /** Attempting to reconnect after unexpected disconnection (hard switch) */
+    Reconnecting = "Reconnecting",
+    /** Planned renderer replacement in progress (soft switch) */
+    SoftSwitching = "SoftSwitching",
+    /** Connection failed permanently */
+    Failed = "Failed",
+    /** Connection intentionally closed */
+    Disconnected = "Disconnected"
+}
+/**
+ * Represents readiness flags that must all be true before connection is considered ready
+ */
+export interface ReadinessFlags {
+    videoInitialized: boolean;
+    dataChannelOpen: boolean;
+    sceneReady: boolean;
+}
+/**
+ * Represents a pending switch request
+ */
+export interface PendingSwitchRequest {
+    type: 'soft' | 'hard';
+    reason: string;
+    requestedAt: number;
+}
+/**
+ * Context information for the current state
+ */
+export interface StateContext {
+    /** Current readiness flags */
+    readiness: ReadinessFlags;
+    /** Number of reconnection attempts made (0-based) */
+    reconnectionAttempts: number;
+    /** Maximum allowed reconnection attempts */
+    maxReconnectionAttempts: number;
+    /** Whether reconnection is allowed */
+    allowReconnection: boolean;
+    /** Current switch request information */
+    switchContext?: {
+        /** Type of switch: 'soft' (planned) or 'hard' (unexpected) */
+        type: 'soft' | 'hard';
+        /** ID of the new signaling instance */
+        newSignalingId: string;
+        /** ID of the old signaling instance */
+        oldSignalingId?: string;
+        /** Timestamp when switch started */
+        startedAt: number;
+    };
+    /** Queue of pending switch requests */
+    pendingSwitchRequests: PendingSwitchRequest[];
+    /** Error message if in Failed state */
+    errorMessage?: string;
+    /** Timestamp of last state change */
+    lastStateChange: number;
+    /** History of state transitions for debugging */
+    stateHistory: Array<{
+        from: ConnectionState;
+        to: ConnectionState;
+        timestamp: number;
+        reason?: string;
+    }>;
+}
+/**
+ * Represents a state change event
+ */
+export interface ConnectionStateChange {
+    from: ConnectionState;
+    to: ConnectionState;
+    timestamp: number;
+    reason?: string;
+    context: StateContext;
+}
+/**
+ * Manages connection state machine for renderer connections
+ * Handles soft switching, hard switching (reconnection), and queuing of multiple switch requests
+ */
+export declare class ConnectionStateManager {
+    private currentState;
+    private context;
+    /** Observable stream of state changes */
+    readonly stateChanges: Subject<ConnectionStateChange>;
+    /** Observable stream of pending switch requests that need to be processed */
+    readonly pendingRequestsToProcess: Subject<PendingSwitchRequest>;
+    /** Timeout in milliseconds for switch operations (30 seconds) */
+    private readonly switchTimeoutMs;
+    /** Handle for the current timeout timer */
+    private timeoutHandle?;
+    /** Stability window in milliseconds before resetting reconnection counter (3 seconds) */
+    private readonly reconnectionStabilityWindowMs;
+    /** Handle for the reconnection stability timer */
+    private stabilityTimerHandle?;
+    /**
+     * @param maxReconnectionAttempts Maximum number of reconnection attempts allowed (default: 3)
+     */
+    constructor(maxReconnectionAttempts?: number);
+    /**
+     * Get the current state
+     */
+    getState(): ConnectionState;
+    /**
+     * Get the full state context
+     */
+    getContext(): Readonly<StateContext>;
+    /**
+     * Check if currently in a specific state
+     */
+    isInState(state: ConnectionState): boolean;
+    /**
+     * Check if all readiness flags are true
+     */
+    isFullyReady(): boolean;
+    /**
+     * Check if connection is in an interactive state (can send messages)
+     */
+    isInteractive(): boolean;
+    /**
+     * Check if currently switching (soft or hard)
+     */
+    isSwitching(): boolean;
+    /**
+     * Check the type of switching in progress
+     */
+    isSwitchingType(type: 'soft' | 'hard'): boolean;
+    /**
+     * Get the current reconnection attempt number (1-based for logging)
+     */
+    getReconnectionAttempt(): number;
+    /**
+     * Check if reconnection is allowed
+     */
+    canReconnect(): boolean;
+    /**
+     * Get a human-readable summary of the current state
+     */
+    getStateSummary(): string;
+    /**
+     * Start a new connection
+     */
+    startConnection(): void;
+    /**
+     * Set video initialized flag
+     */
+    setVideoInitialized(initialized: boolean): void;
+    /**
+     * Set data channel open flag
+     */
+    setDataChannelOpen(open: boolean): void;
+    /**
+     * Set scene ready flag
+     */
+    setSceneReady(ready: boolean): void;
+    /**
+     * Start a soft switch (planned renderer replacement)
+     * @param newSignalingId ID of the new signaling instance
+     * @param oldSignalingId ID of the old signaling instance (optional)
+     * @returns true if switch started, false if already switching
+     */
+    startSoftSwitch(newSignalingId: string, oldSignalingId?: string): boolean;
+    /**
+     * Start reconnection after unexpected disconnection (hard switch)
+     * @param reason Reason for reconnection
+     * @returns true if reconnection started, false if not allowed
+     */
+    startReconnection(reason: string): boolean;
+    /**
+     * Mark reconnection as succeeded
+     * NOTE: The reconnection attempt counter will only be reset after the stability window passes
+     * This prevents infinite loops when the connection repeatedly succeeds then immediately fails
+     */
+    reconnectionSucceeded(): void;
+    /**
+     * Mark reconnection as failed
+     * @param reason Reason for failure (optional)
+     */
+    reconnectionFailed(reason?: string): void;
+    /**
+     * Complete the current switching operation
+     */
+    completeSwitching(): void;
+    /**
+     * Disconnect the session
+     * @param reason Reason for disconnection
+     */
+    disconnect(reason: string): void;
+    /**
+     * Mark the connection as failed
+     * @param reason Reason for failure
+     */
+    fail(reason: string): void;
+    /**
+     * Handle a generic error
+     * @param reason Error message
+     */
+    error(reason: string): void;
+    /**
+     * Reset all readiness flags to false
+     */
+    private resetReadinessFlags;
+    /**
+     * Check if all readiness flags are true and transition to Connected if appropriate
+     */
+    private checkFullyReady;
+    /**
+     * Transition to a new state
+     * @param newState The target state
+     * @param reason Reason for transition (optional)
+     */
+    private transition;
+    /**
+     * Check if a state transition is valid
+     */
+    private isValidTransition;
+    /**
+     * Start a timeout for the current switch operation
+     */
+    private startSwitchTimeout;
+    /**
+     * Cancel the current switch timeout
+     */
+    private cancelSwitchTimeout;
+    /**
+     * Start the reconnection stability timer
+     * Only resets the reconnection attempt counter after the connection has been stable
+     * for the configured duration. This prevents infinite loops when connections
+     * repeatedly succeed then immediately fail.
+     */
+    private startReconnectionStabilityTimer;
+    /**
+     * Cancel the reconnection stability timer
+     * Called when the connection fails before the stability window completes
+     */
+    private cancelReconnectionStabilityTimer;
+    /**
+     * Process any pending switch requests
+     */
+    private processPendingSwitchRequests;
+    /**
+     * Clear all pending switch requests (useful when disconnecting)
+     */
+    clearPendingSwitchRequests(): void;
+    /**
+     * Get the state history for debugging
+     */
+    getStateHistory(): ReadonlyArray<{
+        from: ConnectionState;
+        to: ConnectionState;
+        timestamp: number;
+        reason?: string;
+    }>;
+}

package/dist/connection-state-manager.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/deepgram-stt.d.ts

@@ -37,7 +37,6 @@ export declare class DeepgramSTT {
     private reconnectAttempts;
     private reconnectDelay;
     private reconnectTimeoutId;
-    private wasActiveBeforeReconnect;
     private digitalHumanSpeaking;
     private isUserCurrentlySpeaking;
     private isUiShowingSpeaking;