@codingfactory/socialkit-vue 0.3.1 → 0.5.0

package/dist/services/echo.js

@@ -0,0 +1,712 @@
+/**
+ * Configurable Echo/Reverb client for SocialKit-powered frontends.
+ */
+const TRANSIENT_PUSHER_CLOSE_CODE = 1006;
+const CONNECTION_STATE_RECONCILE_DELAYS_MS = [0, 50, 250, 1000, 5000];
+const FAST_RECONNECT_RETRY_COUNT = 10;
+const MAX_RECONNECT_DELAY_MS = 30000;
+const STEADY_RECONNECT_DELAY_MS = 60000;
+const HEALTH_CHECK_INTERVAL_MS = 45000;
+const DISCONNECT_SUPPRESSION_RESET_MS = 2000;
+const noopLogger = {
+    debug: () => undefined,
+    warn: () => undefined,
+    error: () => undefined
+};
+function getBrowserWindow() {
+    return typeof window === 'undefined' ? null : window;
+}
+function getBrowserDocument() {
+    return typeof document === 'undefined' ? null : document;
+}
+function ensurePusherGlobal(pusher) {
+    const liveWindow = getBrowserWindow();
+    if (liveWindow && pusher !== undefined) {
+        ;
+        liveWindow.Pusher = pusher;
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function hasString(obj, key) {
+    return typeof obj[key] === 'string';
+}
+function getPresenceField(payload, snakeKey, camelKey) {
+    const snakeValue = payload[snakeKey];
+    if (typeof snakeValue === 'string' && snakeValue.trim().length > 0) {
+        return snakeValue;
+    }
+    const camelValue = payload[camelKey];
+    if (typeof camelValue === 'string' && camelValue.trim().length > 0) {
+        return camelValue;
+    }
+    return null;
+}
+function normalizePresenceStatus(rawStatus) {
+    if (typeof rawStatus !== 'string') {
+        return null;
+    }
+    const normalizedStatus = rawStatus.trim().toLowerCase();
+    if (normalizedStatus === 'online'
+        || normalizedStatus === 'idle'
+        || normalizedStatus === 'dnd'
+        || normalizedStatus === 'offline') {
+        return normalizedStatus;
+    }
+    return null;
+}
+function normalizePresenceStatusChangedPayload(data, resolveTenantScope) {
+    if (!isRecord(data)) {
+        return null;
+    }
+    const userId = getPresenceField(data, 'user_id', 'userId');
+    const status = normalizePresenceStatus(data.status);
+    if (!userId || !status) {
+        return null;
+    }
+    const payload = {
+        user_id: userId,
+        tenant_scope: getPresenceField(data, 'tenant_scope', 'tenantScope') ?? resolveTenantScope(),
+        status,
+        ts: getPresenceField(data, 'ts', 'timestamp') ?? new Date().toISOString()
+    };
+    const tenantIdValue = data.tenant_id ?? data.tenantId;
+    if (typeof tenantIdValue === 'string') {
+        payload.tenant_id = tenantIdValue;
+    }
+    else if (tenantIdValue === null) {
+        payload.tenant_id = null;
+    }
+    const lastSeenValue = data.last_seen_at ?? data.lastSeenAt;
+    if (typeof lastSeenValue === 'string') {
+        payload.last_seen_at = lastSeenValue;
+    }
+    else if (lastSeenValue === null) {
+        payload.last_seen_at = null;
+    }
+    return payload;
+}
+export function isValidPresenceStatusChangedEvent(data) {
+    if (!isRecord(data)) {
+        return false;
+    }
+    return hasString(data, 'user_id')
+        && (data.status === 'online' || data.status === 'idle' || data.status === 'dnd' || data.status === 'offline');
+}
+export function isValidLiveCircleCountUpdatedEvent(data) {
+    if (!isRecord(data)) {
+        return false;
+    }
+    return hasString(data, 'circle_id') && typeof data.count === 'number';
+}
+export function isValidTutorialCommentAddedEvent(data) {
+    if (!isRecord(data) || !hasString(data, 'tutorial_id') || !isRecord(data.comment)) {
+        return false;
+    }
+    const comment = data.comment;
+    return hasString(comment, 'id')
+        && hasString(comment, 'author_id')
+        && hasString(comment, 'author_name')
+        && hasString(comment, 'body')
+        && hasString(comment, 'created_at');
+}
+export function isValidTutorialProgressUpdatedEvent(data) {
+    if (!isRecord(data)) {
+        return false;
+    }
+    if (!hasString(data, 'tutorial_id')
+        || !hasString(data, 'user_id')
+        || !hasString(data, 'current_step_id')
+        || typeof data.progress_percent !== 'number'
+        || typeof data.is_completed !== 'boolean'
+        || !hasString(data, 'updated_at')) {
+        return false;
+    }
+    if (!Array.isArray(data.completed_steps)) {
+        return false;
+    }
+    return data.completed_steps.every((stepId) => typeof stepId === 'string');
+}
+export function isValidProfileStatsUpdatedEvent(data) {
+    if (!isRecord(data) || !isRecord(data.stats)) {
+        return false;
+    }
+    const stats = data.stats;
+    return typeof stats.followers_count === 'number' && typeof stats.following_count === 'number';
+}
+export function isValidProfileActivityCreatedEvent(data) {
+    if (!isRecord(data) || !isRecord(data.activity)) {
+        return false;
+    }
+    const activity = data.activity;
+    return hasString(activity, 'id') && hasString(activity, 'activity_type') && hasString(activity, 'created_at');
+}
+export function isValidStoryTrayUpdatedEvent(data) {
+    if (!isRecord(data)) {
+        return false;
+    }
+    return hasString(data, 'story_id') && hasString(data, 'author_id');
+}
+function getPusherErrorCode(error) {
+    if (!isRecord(error) || !isRecord(error.data)) {
+        return null;
+    }
+    return typeof error.data.code === 'number' ? error.data.code : null;
+}
+function resolvePusherConnection(echo) {
+    const connector = echo?.connector;
+    return connector?.pusher?.connection ?? null;
+}
+function guardedListen(channel, event, validator, callback, label, logger) {
+    const handler = (data) => {
+        if (!validator(data)) {
+            logger.warn(`Dropping malformed ${label} event`, data);
+            return;
+        }
+        try {
+            callback(data);
+        }
+        catch (error) {
+            logger.error(`Error handling ${label} event`, error);
+        }
+    };
+    channel.listen(event, handler);
+    return handler;
+}
+export function createEchoService(config) {
+    const logger = {
+        ...noopLogger,
+        ...config.logger
+    };
+    const resolveTenantScope = () => {
+        const tenantScope = config.resolveTenantScope?.();
+        return typeof tenantScope === 'string' && tenantScope.length > 0 ? tenantScope : 'global';
+    };
+    let echoInstance = null;
+    let suppressNextDisconnectEvent = false;
+    let suppressDisconnectResetTimeoutId = null;
+    let connectionStateReconcileTimeoutId = null;
+    let connectionStateReconcileAttempt = 0;
+    let connectionStatus = 'disconnected';
+    const connectionCallbacks = new Set();
+    const reconnectCallbacks = new Set();
+    let hasConnectedAtLeastOnce = false;
+    let reconnectAttempts = 0;
+    let reconnectTimeoutId = null;
+    let healthCheckIntervalId = null;
+    let connectionGeneration = 0;
+    function clearConnectionStateReconcile() {
+        if (connectionStateReconcileTimeoutId) {
+            clearTimeout(connectionStateReconcileTimeoutId);
+            connectionStateReconcileTimeoutId = null;
+        }
+        connectionStateReconcileAttempt = 0;
+    }
+    function updateConnectionStatus(status) {
+        if (connectionStatus === status) {
+            return;
+        }
+        const previousStatus = connectionStatus;
+        connectionStatus = status;
+        logger.debug(`Connection status changed to ${status}`);
+        for (const callback of connectionCallbacks) {
+            callback(status);
+        }
+        if (status !== 'connected') {
+            return;
+        }
+        const recoveredConnection = hasConnectedAtLeastOnce && previousStatus !== 'connected';
+        hasConnectedAtLeastOnce = true;
+        if (!recoveredConnection) {
+            return;
+        }
+        for (const callback of reconnectCallbacks) {
+            callback();
+        }
+    }
+    function scheduleConnectionStateReconcile(connection) {
+        clearConnectionStateReconcile();
+        const reconcile = () => {
+            connectionStateReconcileTimeoutId = null;
+            if (getConnectionStatus() !== 'connecting') {
+                clearConnectionStateReconcile();
+                return;
+            }
+            if (connection.state === 'connected') {
+                updateConnectionStatus('connected');
+                clearConnectionStateReconcile();
+                return;
+            }
+            connectionStateReconcileAttempt += 1;
+            const nextDelay = CONNECTION_STATE_RECONCILE_DELAYS_MS[connectionStateReconcileAttempt];
+            if (typeof nextDelay !== 'number') {
+                clearConnectionStateReconcile();
+                return;
+            }
+            connectionStateReconcileTimeoutId = setTimeout(reconcile, nextDelay);
+        };
+        connectionStateReconcileTimeoutId = setTimeout(reconcile, CONNECTION_STATE_RECONCILE_DELAYS_MS[0]);
+    }
+    function stopHealthCheck() {
+        if (healthCheckIntervalId) {
+            clearInterval(healthCheckIntervalId);
+            healthCheckIntervalId = null;
+        }
+    }
+    function startHealthCheck() {
+        if (healthCheckIntervalId) {
+            return;
+        }
+        healthCheckIntervalId = setInterval(() => {
+            const liveDocument = getBrowserDocument();
+            if (liveDocument?.hidden) {
+                return;
+            }
+            const status = getConnectionStatus();
+            if (status === 'disconnected' || status === 'error') {
+                logger.debug('Health check: connection is down, triggering reconnect');
+                reconnectAttempts = 0;
+                scheduleReconnect();
+            }
+        }, HEALTH_CHECK_INTERVAL_MS);
+    }
+    function scheduleReconnect() {
+        const delay = reconnectAttempts < FAST_RECONNECT_RETRY_COUNT
+            ? Math.min(1000 * Math.pow(2, reconnectAttempts), MAX_RECONNECT_DELAY_MS)
+            : STEADY_RECONNECT_DELAY_MS;
+        reconnectAttempts += 1;
+        logger.debug(`Scheduling reconnect attempt ${reconnectAttempts} in ${delay}ms`);
+        if (reconnectTimeoutId) {
+            clearTimeout(reconnectTimeoutId);
+        }
+        reconnectTimeoutId = setTimeout(() => {
+            logger.debug(`Reconnect attempt ${reconnectAttempts}`);
+            reconnectEcho();
+        }, delay);
+    }
+    function initializeEcho() {
+        connectionGeneration += 1;
+        const thisGeneration = connectionGeneration;
+        if (suppressDisconnectResetTimeoutId) {
+            clearTimeout(suppressDisconnectResetTimeoutId);
+            suppressDisconnectResetTimeoutId = null;
+        }
+        clearConnectionStateReconcile();
+        const token = config.getToken();
+        if (!token) {
+            logger.warn('No auth token available, skipping initialization');
+            return null;
+        }
+        if (echoInstance) {
+            logger.debug('Already initialized');
+            return echoInstance;
+        }
+        ensurePusherGlobal(config.pusher);
+        logger.debug('Initializing connection to Reverb...');
+        const echoOptions = config.resolveConnectionConfig(token);
+        logger.debug('Resolved config', {
+            host: echoOptions.wsHost,
+            port: echoOptions.wsPort,
+            tls: echoOptions.forceTLS,
+            path: echoOptions.wsPath ?? '(default)',
+            authEndpoint: echoOptions.authEndpoint
+        });
+        echoInstance = new config.Echo(echoOptions);
+        const liveWindow = getBrowserWindow();
+        if (liveWindow) {
+            ;
+            liveWindow.Echo = echoInstance;
+            if (config.initializedEvent) {
+                liveWindow.dispatchEvent(new CustomEvent(config.initializedEvent));
+            }
+        }
+        const connection = resolvePusherConnection(echoInstance);
+        if (!connection) {
+            logger.error('Unable to access Pusher connection');
+            return echoInstance;
+        }
+        connection.bind('connected', () => {
+            if (thisGeneration !== connectionGeneration) {
+                logger.debug('Ignoring stale connected event from old connection');
+                return;
+            }
+            logger.debug('Connected to Reverb WebSocket server');
+            clearConnectionStateReconcile();
+            suppressNextDisconnectEvent = false;
+            if (suppressDisconnectResetTimeoutId) {
+                clearTimeout(suppressDisconnectResetTimeoutId);
+                suppressDisconnectResetTimeoutId = null;
+            }
+            updateConnectionStatus('connected');
+            reconnectAttempts = 0;
+            if (reconnectTimeoutId) {
+                clearTimeout(reconnectTimeoutId);
+                reconnectTimeoutId = null;
+            }
+            startHealthCheck();
+        });
+        connection.bind('disconnected', () => {
+            if (thisGeneration !== connectionGeneration) {
+                logger.debug('Ignoring stale disconnected event from old connection');
+                return;
+            }
+            if (suppressNextDisconnectEvent) {
+                logger.debug('Skipping reconnect for intentional disconnect');
+                suppressNextDisconnectEvent = false;
+                if (suppressDisconnectResetTimeoutId) {
+                    clearTimeout(suppressDisconnectResetTimeoutId);
+                    suppressDisconnectResetTimeoutId = null;
+                }
+                return;
+            }
+            logger.warn('Disconnected from Reverb WebSocket server');
+            updateConnectionStatus('disconnected');
+            scheduleReconnect();
+        });
+        connection.bind('error', (error) => {
+            if (thisGeneration !== connectionGeneration) {
+                logger.debug('Ignoring stale error event from old connection');
+                return;
+            }
+            const errorCode = getPusherErrorCode(error);
+            if (errorCode === TRANSIENT_PUSHER_CLOSE_CODE) {
+                if (suppressNextDisconnectEvent) {
+                    logger.debug('Ignoring PusherError 1006 during intentional disconnect');
+                    return;
+                }
+                logger.debug('Received PusherError 1006; treating as disconnected');
+                updateConnectionStatus('disconnected');
+                scheduleReconnect();
+                return;
+            }
+            logger.error('Connection error', error);
+            updateConnectionStatus('error');
+            scheduleReconnect();
+        });
+        connection.bind('unavailable', () => {
+            if (thisGeneration !== connectionGeneration) {
+                logger.debug('Ignoring stale unavailable event from old connection');
+                return;
+            }
+            if (suppressNextDisconnectEvent) {
+                logger.debug('Ignoring unavailable event during intentional disconnect');
+                return;
+            }
+            logger.debug('Connection unavailable; scheduling reconnect');
+            updateConnectionStatus('disconnected');
+            scheduleReconnect();
+        });
+        connection.bind('connecting', () => {
+            if (thisGeneration !== connectionGeneration) {
+                logger.debug('Ignoring stale connecting event from old connection');
+                return;
+            }
+            logger.debug('Connecting to Reverb WebSocket server');
+            updateConnectionStatus('connecting');
+            scheduleConnectionStateReconcile(connection);
+        });
+        updateConnectionStatus('connecting');
+        if (connection.state === 'connected') {
+            updateConnectionStatus('connected');
+        }
+        scheduleConnectionStateReconcile(connection);
+        return echoInstance;
+    }
+    function getEcho() {
+        const liveWindow = getBrowserWindow();
+        if (!echoInstance && liveWindow?.Echo) {
+            echoInstance = liveWindow.Echo;
+            const liveConnection = resolvePusherConnection(echoInstance);
+            if (liveConnection?.state === 'connected') {
+                updateConnectionStatus('connected');
+            }
+        }
+        return echoInstance;
+    }
+    function disconnectEcho(options = {}) {
+        const preventReconnect = options.preventReconnect ?? true;
+        if (!preventReconnect) {
+            suppressNextDisconnectEvent = false;
+            if (suppressDisconnectResetTimeoutId) {
+                clearTimeout(suppressDisconnectResetTimeoutId);
+                suppressDisconnectResetTimeoutId = null;
+            }
+        }
+        clearConnectionStateReconcile();
+        stopHealthCheck();
+        if (echoInstance) {
+            if (preventReconnect) {
+                suppressNextDisconnectEvent = true;
+                if (suppressDisconnectResetTimeoutId) {
+                    clearTimeout(suppressDisconnectResetTimeoutId);
+                }
+                suppressDisconnectResetTimeoutId = setTimeout(() => {
+                    suppressNextDisconnectEvent = false;
+                    suppressDisconnectResetTimeoutId = null;
+                }, DISCONNECT_SUPPRESSION_RESET_MS);
+                if (reconnectTimeoutId) {
+                    clearTimeout(reconnectTimeoutId);
+                    reconnectTimeoutId = null;
+                }
+            }
+            logger.debug('Disconnecting...');
+            echoInstance.disconnect();
+            echoInstance = null;
+            const liveWindow = getBrowserWindow();
+            if (liveWindow) {
+                delete liveWindow.Echo;
+            }
+        }
+        if (preventReconnect && !options.skipStatusUpdate) {
+            updateConnectionStatus('disconnected');
+        }
+    }
+    function getConnectionStatus() {
+        const liveState = resolvePusherConnection(getBrowserWindow()?.Echo ?? null)?.state;
+        if (liveState === 'connected' && connectionStatus !== 'connected') {
+            updateConnectionStatus('connected');
+        }
+        return connectionStatus;
+    }
+    function onConnectionStatusChange(callback) {
+        connectionCallbacks.add(callback);
+        return () => {
+            connectionCallbacks.delete(callback);
+        };
+    }
+    function onEchoReconnected(callback) {
+        reconnectCallbacks.add(callback);
+        return () => {
+            reconnectCallbacks.delete(callback);
+        };
+    }
+    function subscribeToPresenceStatus(callback) {
+        const echo = getEcho();
+        if (!echo) {
+            logger.warn('Cannot subscribe to presence status, not connected');
+            return;
+        }
+        const channelName = `online-users.${resolveTenantScope()}`;
+        logger.debug(`Subscribing to ${channelName}`);
+        const channel = echo.join(channelName);
+        const presenceEventNames = [
+            '.PresenceStatusChanged',
+            'PresenceStatusChanged',
+            '.presence.status.changed',
+            'presence.status.changed',
+            '.Presence.StatusChanged',
+            'Presence.StatusChanged',
+            '.Modules\\Presence\\Events\\UserPresenceStatusChanged',
+            'Modules\\Presence\\Events\\UserPresenceStatusChanged'
+        ];
+        for (const eventName of presenceEventNames) {
+            const validator = (rawEvent) => isRecord(rawEvent);
+            guardedListen(channel, eventName, validator, (rawEvent) => {
+                const event = normalizePresenceStatusChangedPayload(rawEvent, resolveTenantScope);
+                if (!event) {
+                    logger.warn('Dropping malformed PresenceStatusChanged event', rawEvent);
+                    return;
+                }
+                logger.debug('Presence status event received', event);
+                callback(event);
+            }, 'PresenceStatusChanged', logger);
+        }
+    }
+    function unsubscribeFromPresenceStatus() {
+        const echo = getEcho();
+        if (!echo) {
+            return;
+        }
+        const channelName = `online-users.${resolveTenantScope()}`;
+        logger.debug(`Unsubscribing from ${channelName}`);
+        echo.leave(channelName);
+    }
+    function subscribeToLiveCircleCount(circleId, callback) {
+        const echo = getEcho();
+        if (!echo) {
+            logger.warn('Cannot subscribe to live circle count, not connected');
+            return () => undefined;
+        }
+        const channelName = `live-circle.${circleId}`;
+        logger.debug(`Subscribing to ${channelName}`);
+        const channel = echo.private(channelName);
+        const handler = guardedListen(channel, '.LiveCircleCountUpdated', isValidLiveCircleCountUpdatedEvent, (data) => {
+            logger.debug('Live circle count updated event received', data);
+            callback(data);
+        }, 'LiveCircleCountUpdated', logger);
+        let cleanedUp = false;
+        return () => {
+            if (cleanedUp) {
+                return;
+            }
+            cleanedUp = true;
+            const stoppableChannel = channel;
+            if (typeof stoppableChannel.stopListening !== 'function') {
+                return;
+            }
+            stoppableChannel.stopListening('.LiveCircleCountUpdated', handler);
+        };
+    }
+    function subscribeToTutorialComments(tutorialId, callback) {
+        const echo = getEcho() ?? initializeEcho();
+        if (!echo) {
+            logger.warn('Cannot subscribe to tutorial comments, not connected');
+            return () => undefined;
+        }
+        const channelName = `tutorial.${tutorialId}.comments`;
+        logger.debug(`Subscribing to ${channelName}`);
+        const channel = echo.private(channelName);
+        const handler = guardedListen(channel, '.comment.added', isValidTutorialCommentAddedEvent, (data) => {
+            logger.debug('Tutorial comment added event received', data);
+            callback(data);
+        }, 'comment.added', logger);
+        let cleanedUp = false;
+        return () => {
+            if (cleanedUp) {
+                return;
+            }
+            cleanedUp = true;
+            const stoppableChannel = channel;
+            if (typeof stoppableChannel.stopListening !== 'function') {
+                return;
+            }
+            stoppableChannel.stopListening('.comment.added', handler);
+        };
+    }
+    function subscribeToTutorialProgress(tutorialId, callback) {
+        const echo = getEcho() ?? initializeEcho();
+        if (!echo) {
+            logger.warn('Cannot subscribe to tutorial progress, not connected');
+            return () => undefined;
+        }
+        const channelName = `tutorial.${tutorialId}.progress`;
+        logger.debug(`Subscribing to ${channelName}`);
+        const channel = echo.private(channelName);
+        channel.listen('pusher:subscription_error', (error) => {
+            logger.warn(`Channel subscription failed for ${channelName}`, error);
+        });
+        const handler = guardedListen(channel, '.progress.updated', isValidTutorialProgressUpdatedEvent, (data) => {
+            logger.debug('Tutorial progress updated event received', data);
+            callback(data);
+        }, 'progress.updated', logger);
+        let cleanedUp = false;
+        return () => {
+            if (cleanedUp) {
+                return;
+            }
+            cleanedUp = true;
+            const stoppableChannel = channel;
+            if (typeof stoppableChannel.stopListening !== 'function') {
+                return;
+            }
+            stoppableChannel.stopListening('.progress.updated', handler);
+        };
+    }
+    function subscribeToProfileUpdates(userId, callbacks) {
+        const echo = getEcho();
+        if (!echo) {
+            logger.warn('Cannot subscribe to profile updates, not connected');
+            return;
+        }
+        const channelName = `profiles.${userId}`;
+        logger.debug(`Subscribing to ${channelName}`);
+        const channel = echo.private(channelName);
+        if (callbacks.onStatsUpdated) {
+            const onStatsUpdated = callbacks.onStatsUpdated;
+            guardedListen(channel, '.Profiles.StatsUpdated', isValidProfileStatsUpdatedEvent, (data) => {
+                logger.debug('Profile stats updated event received', data);
+                onStatsUpdated(data);
+            }, 'Profiles.StatsUpdated', logger);
+        }
+        if (callbacks.onActivityCreated) {
+            const onActivityCreated = callbacks.onActivityCreated;
+            guardedListen(channel, '.Profiles.ActivityCreated', isValidProfileActivityCreatedEvent, (data) => {
+                logger.debug('Profile activity created event received', data);
+                onActivityCreated(data);
+            }, 'Profiles.ActivityCreated', logger);
+        }
+    }
+    function unsubscribeFromProfileUpdates(userId) {
+        const echo = getEcho();
+        if (!echo) {
+            return;
+        }
+        const channelName = `profiles.${userId}`;
+        logger.debug(`Unsubscribing from ${channelName}`);
+        echo.leave(channelName);
+    }
+    function subscribeToStoryTray(callbacks) {
+        const echo = getEcho() ?? initializeEcho();
+        if (!echo) {
+            logger.warn('Cannot subscribe to story tray channel, not connected');
+            return false;
+        }
+        const channelName = `story-tray.${resolveTenantScope()}`;
+        logger.debug(`Subscribing to ${channelName}`);
+        const channel = echo.private(channelName);
+        if (callbacks.onStoryTrayUpdated) {
+            const onStoryTrayUpdated = callbacks.onStoryTrayUpdated;
+            guardedListen(channel, '.StoryTrayUpdated', isValidStoryTrayUpdatedEvent, (data) => {
+                logger.debug('Story tray updated event received', data);
+                onStoryTrayUpdated(data);
+            }, 'StoryTrayUpdated', logger);
+        }
+        return true;
+    }
+    function unsubscribeFromStoryTray() {
+        const echo = getEcho();
+        if (!echo) {
+            return;
+        }
+        const channelName = `story-tray.${resolveTenantScope()}`;
+        logger.debug(`Unsubscribing from ${channelName}`);
+        echo.leave(channelName);
+    }
+    function reconnectEcho(options = {}) {
+        if (options.resetBackoff) {
+            reconnectAttempts = 0;
+        }
+        if (reconnectTimeoutId) {
+            clearTimeout(reconnectTimeoutId);
+            reconnectTimeoutId = null;
+        }
+        updateConnectionStatus('connecting');
+        if (echoInstance) {
+            logger.debug('Disconnecting before reconnect');
+            disconnectEcho({ preventReconnect: true, skipStatusUpdate: true });
+        }
+        try {
+            echoInstance = initializeEcho();
+            if (!echoInstance) {
+                logger.error('Reconnect failed: initializeEcho returned null');
+                updateConnectionStatus('error');
+                scheduleReconnect();
+            }
+        }
+        catch (error) {
+            logger.error('Reconnect failed', error);
+            updateConnectionStatus('error');
+            scheduleReconnect();
+        }
+    }
+    return {
+        initializeEcho,
+        getEcho,
+        disconnectEcho,
+        reconnectEcho,
+        getConnectionStatus,
+        onConnectionStatusChange,
+        onEchoReconnected,
+        subscribeToPresenceStatus,
+        unsubscribeFromPresenceStatus,
+        subscribeToLiveCircleCount,
+        subscribeToTutorialComments,
+        subscribeToTutorialProgress,
+        subscribeToProfileUpdates,
+        unsubscribeFromProfileUpdates,
+        subscribeToStoryTray,
+        unsubscribeFromStoryTray
+    };
+}
+//# sourceMappingURL=echo.js.map