@stream-io/video-client 1.11.6 → 1.11.7

package/dist/index.cjs.js

@@ -9,8 +9,6 @@ var uaParserJs = require('ua-parser-js');
 var rxjs = require('rxjs');
 var SDP = require('sdp-transform');
 var https = require('https');
-var WebSocket$1 = require('isomorphic-ws');
-var base64Js = require('base64-js');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -3195,42 +3193,6 @@ function getRandomBytes(length) {
     getRandomValues(bytes);
     return bytes;
 }
-function convertErrorToJson(err) {
-    const jsonObj = {};
-    if (!err)
-        return jsonObj;
-    try {
-        Object.getOwnPropertyNames(err).forEach((key) => {
-            jsonObj[key] = Object.getOwnPropertyDescriptor(err, key);
-        });
-    }
-    catch (_) {
-        return {
-            error: 'failed to serialize the error',
-        };
-    }
-    return jsonObj;
-}
-/**
- * isOnline safely return the navigator.online value for browser env
- * if navigator is not in global object, it always return true
- */
-function isOnline(logger) {
-    const nav = typeof navigator !== 'undefined'
-        ? navigator
-        : typeof window !== 'undefined' && window.navigator
-            ? window.navigator
-            : undefined;
-    if (!nav) {
-        logger('warn', 'isOnline failed to access window.navigator and assume browser is online');
-        return true;
-    }
-    // RN navigator has undefined for onLine
-    if (typeof nav.onLine !== 'boolean') {
-        return true;
-    }
-    return nav.onLine;
-}
 /**
  * listenForConnectionChanges - Adds an event listener fired on browser going online or offline
  */
@@ -3246,6 +3208,13 @@ function removeConnectionEventListeners(cb) {
         window.removeEventListener('online', cb);
     }
 }
+function isErrorResponse(res) {
+    return !res.status || res.status < 200 || 300 <= res.status;
+}
+// Type guards to check WebSocket error type
+function isCloseEvent(res) {
+    return res.code !== undefined;
+}
 
 /**
  * Checks whether we are using React Native
@@ -3349,7 +3318,7 @@ const retryable = async (rpc, signal) => {
     return result;
 };
 
-const version = "1.11.6";
+const version = "1.11.7";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -11521,68 +11490,6 @@ class Call {
     }
 }
 
-class InsightMetrics {
-    constructor() {
-        this.connectionStartTimestamp = null;
-        this.wsTotalFailures = 0;
-        this.wsConsecutiveFailures = 0;
-        this.instanceClientId = randomId();
-    }
-}
-/**
- * postInsights is not supposed to be used by end users directly within chat application, and thus is kept isolated
- * from all the client/connection code/logic.
- *
- * @param insightType
- * @param insights
- */
-const postInsights = async (insightType, insights) => {
-    const maxAttempts = 3;
-    for (let i = 0; i < maxAttempts; i++) {
-        try {
-            await axios.post(`https://chat-insights.getstream.io/insights/${insightType}`, insights);
-        }
-        catch (e) {
-            await sleep((i + 1) * 3000);
-            continue;
-        }
-        break;
-    }
-};
-function buildWsFatalInsight(connection, event) {
-    return {
-        ...event,
-        ...buildWsBaseInsight(connection),
-    };
-}
-function buildWsBaseInsight(connection) {
-    const { client } = connection;
-    return {
-        ready_state: connection.ws?.readyState,
-        url: connection._buildUrl(),
-        api_key: client.key,
-        start_ts: client.insightMetrics.connectionStartTimestamp,
-        end_ts: new Date().getTime(),
-        auth_type: client.getAuthType(),
-        token: client.tokenManager.token,
-        user_id: client.userID,
-        user_details: client._user,
-        // device: client.options.device,
-        device: 'browser',
-        client_id: connection.connectionID,
-        ws_details: connection.ws,
-        ws_consecutive_failures: client.insightMetrics.wsConsecutiveFailures,
-        ws_total_failures: client.insightMetrics.wsTotalFailures,
-        request_id: connection.requestID,
-        online: typeof navigator !== 'undefined' ? navigator?.onLine : null,
-        user_agent: typeof navigator !== 'undefined' ? navigator?.userAgent : null,
-        instance_client_id: client.insightMetrics.instanceClientId,
-    };
-}
-function buildWsSuccessAfterFailureInsight(connection) {
-    return buildWsBaseInsight(connection);
-}
-
 /**
  * Saving a long-lived reference to a promise that can reject can be unsafe,
  * since rejecting the promise causes an unhandled rejection error (even if the
@@ -11610,9 +11517,6 @@ function makeSafePromise(promise) {
     return unwrapPromise;
 }
 
-// Type guards to check WebSocket error type
-const isCloseEvent = (res) => res.code !== undefined;
-const isErrorEvent = (res) => res.error !== undefined;
 /**
  * StableWSConnection - A WS connection that reconnects upon failure.
  * - the browser will sometimes report that you're online or offline
@@ -11647,12 +11551,9 @@ class StableWSConnection {
          */
         this._buildUrl = () => {
             const params = new URLSearchParams();
-            // const qs = encodeURIComponent(this.client._buildWSPayload(this.requestID));
-            // params.set('json', qs);
             params.set('api_key', this.client.key);
             params.set('stream-auth-type', this.client.getAuthType());
             params.set('X-Stream-Client', this.client.getUserAgent());
-            // params.append('authorization', this.client._getToken()!);
             return `${this.client.wsBaseURL}/connect?${params.toString()}`;
         };
         /**
@@ -11701,7 +11602,6 @@ class StableWSConnection {
                     custom: user.custom,
                 },
             };
-            this.authenticationSent = true;
             this.ws?.send(JSON.stringify(authMessage));
             this._log('onopen() - onopen callback', { wsID });
         };
@@ -11718,7 +11618,6 @@ class StableWSConnection {
             if (!this.isResolved && data && data.type === 'connection.error') {
                 this.isResolved = true;
                 if (data.error) {
-                    // @ts-expect-error - the types of _errorFromWSEvent are incorrect
                     this.rejectPromise?.(this._errorFromWSEvent(data, false));
                     return;
                 }
@@ -11760,9 +11659,13 @@ class StableWSConnection {
                 // this is a permanent error raised by stream..
                 // usually caused by invalid auth details
                 const error = new Error(`WS connection reject with error ${event.reason}`);
+                // @ts-expect-error
                 error.reason = event.reason;
+                // @ts-expect-error
                 error.code = event.code;
+                // @ts-expect-error
                 error.wasClean = event.wasClean;
+                // @ts-expect-error
                 error.target = event.target;
                 this.rejectPromise?.(error);
                 this._log(`onclose() - WS connection reject with error ${event.reason}`, {
@@ -11789,7 +11692,7 @@ class StableWSConnection {
             this.totalFailures += 1;
             this._setHealth(false);
             this.isConnecting = false;
-            this.rejectPromise?.(this._errorFromWSEvent(event));
+            this.rejectPromise?.(new Error(`WebSocket error: ${event}`));
             this._log(`onerror() - WS connection resulted into error`, { event });
             this._reconnect();
         };
@@ -11799,7 +11702,6 @@ class StableWSConnection {
          *
          * @param {boolean} healthy boolean indicating if the connection is healthy or not
          * @param {boolean} dispatchImmediately boolean indicating to dispatch event immediately even if the connection is unhealthy
-         *
          */
         this._setHealth = (healthy, dispatchImmediately = false) => {
             if (healthy === this.isHealthy)
@@ -11824,7 +11726,6 @@ class StableWSConnection {
         };
         /**
          * _errorFromWSEvent - Creates an error object for the WS event
-         *
          */
         this._errorFromWSEvent = (event, isWSFailure = true) => {
             let code;
@@ -11832,17 +11733,18 @@ class StableWSConnection {
             let message;
             if (isCloseEvent(event)) {
                 code = event.code;
-                statusCode = 'unknown';
                 message = event.reason;
+                statusCode = 0;
             }
-            if (isErrorEvent(event)) {
-                code = event.error.code;
-                statusCode = event.error.StatusCode;
-                message = event.error.message;
-            }
-            // Keeping this `warn` level log, to avoid cluttering of error logs from ws failures.
-            this._log(`_errorFromWSEvent() - WS failed with code ${code}`, { event }, 'warn');
-            const error = new Error(`WS failed with code ${code} and reason - ${message}`);
+            else {
+                const { error } = event;
+                code = error.code;
+                message = error.message;
+                statusCode = error.StatusCode;
+            }
+            const msg = `WS failed with code: ${code} and reason: ${message}`;
+            this._log(msg, { event }, 'warn');
+            const error = new Error(msg);
             error.code = code;
             /**
              * StatusCode does not exist on any event types but has been left
@@ -11867,10 +11769,8 @@ class StableWSConnection {
          * Schedules a next health check ping for websocket.
          */
         this.scheduleNextPing = () => {
-            if (this.healthCheckTimeoutRef) {
-                clearTimeout(this.healthCheckTimeoutRef);
-            }
             // 30 seconds is the recommended interval (messenger uses this)
+            clearTimeout(this.healthCheckTimeoutRef);
             this.healthCheckTimeoutRef = setTimeout(() => {
                 // send the healthcheck..., server replies with a health check event
                 const data = [{ type: 'health.check', client_id: this.client.clientID }];
@@ -11889,9 +11789,7 @@ class StableWSConnection {
          * to be reconnected.
          */
         this.scheduleConnectionCheck = () => {
-            if (this.connectionCheckTimeoutRef) {
-                clearTimeout(this.connectionCheckTimeoutRef);
-            }
+            clearTimeout(this.connectionCheckTimeoutRef);
             this.connectionCheckTimeoutRef = setTimeout(() => {
                 const now = new Date();
                 if (this.lastEvent &&
@@ -11909,8 +11807,6 @@ class StableWSConnection {
         this.totalFailures = 0;
         /** We only make 1 attempt to reconnect at the same time.. */
         this.isConnecting = false;
-        /** True after the auth payload is sent to the server */
-        this.authenticationSent = false;
         /** To avoid reconnect if client is disconnected */
         this.isDisconnected = false;
         /** Boolean that indicates if the connection promise is resolved */
@@ -12018,18 +11914,10 @@ class StableWSConnection {
         this.isConnecting = false;
         this.isDisconnected = true;
         // start by removing all the listeners
-        if (this.healthCheckTimeoutRef) {
-            clearInterval(this.healthCheckTimeoutRef);
-        }
-        if (this.connectionCheckTimeoutRef) {
-            clearInterval(this.connectionCheckTimeoutRef);
-        }
+        clearInterval(this.healthCheckTimeoutRef);
+        clearInterval(this.connectionCheckTimeoutRef);
         removeConnectionEventListeners(this.onlineStatusChanged);
         this.isHealthy = false;
-        // remove ws handlers...
-        if (this.ws && this.ws.removeAllListeners) {
-            this.ws.removeAllListeners();
-        }
         let isClosedPromise;
         // and finally close...
         // Assigning to local here because we will remove it from this before the
@@ -12062,12 +11950,10 @@ class StableWSConnection {
      * @return {ConnectAPIResponse<ConnectedEvent>} Promise that completes once the first health check message is received
      */
     async _connect() {
-        if (this.isConnecting ||
-            (this.isDisconnected && this.client.options.enableWSFallback))
+        if (this.isConnecting)
             return; // simply ignore _connect if it's currently trying to connect
         this.isConnecting = true;
         this.requestID = randomId();
-        this.client.insightMetrics.connectionStartTimestamp = new Date().getTime();
         let isTokenReady = false;
         try {
             this._log(`_connect() - waiting for token`);
@@ -12091,7 +11977,8 @@ class StableWSConnection {
                 wsURL,
                 requestID: this.requestID,
             });
-            this.ws = new WebSocket$1(wsURL);
+            const WS = this.client.options.WebSocketImpl ?? WebSocket;
+            this.ws = new WS(wsURL);
             this.ws.onopen = this.onopen.bind(this, this.wsID);
             this.ws.onclose = this.onclose.bind(this, this.wsID);
             this.ws.onerror = this.onerror.bind(this, this.wsID);
@@ -12101,11 +11988,6 @@ class StableWSConnection {
             if (response) {
                 this.connectionID = response.connection_id;
                 this.client.resolveConnectionId?.(this.connectionID);
-                if (this.client.insightMetrics.wsConsecutiveFailures > 0 &&
-                    this.client.options.enableInsights) {
-                    postInsights('ws_success_after_failure', buildWsSuccessAfterFailureInsight(this));
-                    this.client.insightMetrics.wsConsecutiveFailures = 0;
-                }
                 return response;
             }
         }
@@ -12114,12 +11996,6 @@ class StableWSConnection {
             this.isConnecting = false;
             // @ts-ignore
             this._log(`_connect() - Error - `, err);
-            if (this.client.options.enableInsights) {
-                this.client.insightMetrics.wsConsecutiveFailures++;
-                this.client.insightMetrics.wsTotalFailures++;
-                const insights = buildWsFatalInsight(this, convertErrorToJson(err));
-                postInsights?.('ws_fatal', insights);
-            }
             this.client.rejectConnectionId?.(err);
             throw err;
         }
@@ -12153,7 +12029,7 @@ class StableWSConnection {
             this._log('_reconnect() - Abort (2) since already connecting or healthy');
             return;
         }
-        if (this.isDisconnected && this.client.options.enableWSFallback) {
+        if (this.isDisconnected) {
             this._log('_reconnect() - Abort (3) since disconnect() is called');
             return;
         }
@@ -12195,7 +12071,6 @@ class StableWSConnection {
         // ws connection from now on.
         this.wsID += 1;
         try {
-            this?.ws?.removeAllListeners();
             this?.ws?.close();
         }
         catch (e) {
@@ -12207,36 +12082,16 @@ class StableWSConnection {
     }
 }
 
-function isString(arrayOrString) {
-    return typeof arrayOrString === 'string';
-}
-function isMapStringCallback(arrayOrString, callback) {
-    return !!callback && isString(arrayOrString);
-}
-function map(arrayOrString, callback) {
-    const res = [];
-    if (isString(arrayOrString) && isMapStringCallback(arrayOrString, callback)) {
-        for (let k = 0, len = arrayOrString.length; k < len; k++) {
-            if (arrayOrString.charAt(k)) {
-                const kValue = arrayOrString.charAt(k);
-                const mappedValue = callback(kValue, k, arrayOrString);
-                res[k] = mappedValue;
-            }
-        }
-    }
-    else if (!isString(arrayOrString) &&
-        !isMapStringCallback(arrayOrString, callback)) {
-        for (let k = 0, len = arrayOrString.length; k < len; k++) {
-            if (k in arrayOrString) {
-                const kValue = arrayOrString[k];
-                const mappedValue = callback(kValue, k, arrayOrString);
-                res[k] = mappedValue;
-            }
-        }
+function getUserFromToken(token) {
+    const fragments = token.split('.');
+    if (fragments.length !== 3) {
+        return '';
     }
-    return res;
+    const b64Payload = fragments[1];
+    const payload = decodeBase64(b64Payload);
+    const data = JSON.parse(payload);
+    return data.user_id;
 }
-const encodeBase64 = (data) => base64Js.fromByteArray(new Uint8Array(map(data, (char) => char.charCodeAt(0))));
 // base-64 decoder throws exception if encoded string is not padded by '=' to make string length
 // in multiples of 4. So gonna use our own method for this purpose to keep backwards compatibility
 // https://github.com/beatgammit/base64-js/blob/master/index.js#L26
@@ -12258,29 +12113,6 @@ const decodeBase64 = (s) => {
     return r;
 };
 
-/**
- *
- * @param {string} userId the id of the user
- * @return {string}
- */
-function DevToken(userId) {
-    return [
-        'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9', //{"alg": "HS256", "typ": "JWT"}
-        encodeBase64(JSON.stringify({ user_id: userId })),
-        'devtoken', // hardcoded signature
-    ].join('.');
-}
-function UserFromToken(token) {
-    const fragments = token.split('.');
-    if (fragments.length !== 3) {
-        return '';
-    }
-    const b64Payload = fragments[1];
-    const payload = decodeBase64(b64Payload);
-    const data = JSON.parse(payload);
-    return data.user_id;
-}
-
 /**
  * TokenManager
  *
@@ -12289,8 +12121,6 @@ function UserFromToken(token) {
 class TokenManager {
     /**
      * Constructor
-     *
-     * @param {Secret} secret
      */
     constructor(secret) {
         /**
@@ -12343,7 +12173,7 @@ class TokenManager {
                 // Allow empty token for anonymous users
                 if (isAnonymous && tokenOrProvider === '')
                     return;
-                const tokenUserId = UserFromToken(tokenOrProvider);
+                const tokenUserId = getUserFromToken(tokenOrProvider);
                 if (tokenOrProvider != null &&
                     (tokenUserId == null ||
                         tokenUserId === '' ||
@@ -12358,7 +12188,6 @@ class TokenManager {
         // Fetches a token from tokenProvider function and sets in tokenManager.
         // In case of static token, it will simply resolve to static token.
         this.loadToken = () => {
-            // eslint-disable-next-line no-async-promise-executor
             this.loadTokenPromise = new Promise(async (resolve, reject) => {
                 if (this.type === 'static') {
                     return resolve(this.token);
@@ -12387,236 +12216,11 @@ class TokenManager {
         };
         this.isStatic = () => this.type === 'static';
         this.loadTokenPromise = null;
-        if (secret) {
-            this.secret = secret;
-        }
+        this.secret = secret;
         this.type = 'static';
     }
 }
 
-const APIErrorCodes = {
-    '-1': { name: 'InternalSystemError', retryable: true },
-    '2': { name: 'AccessKeyError', retryable: false },
-    '3': { name: 'AuthenticationFailedError', retryable: true },
-    '4': { name: 'InputError', retryable: false },
-    '6': { name: 'DuplicateUsernameError', retryable: false },
-    '9': { name: 'RateLimitError', retryable: true },
-    '16': { name: 'DoesNotExistError', retryable: false },
-    '17': { name: 'NotAllowedError', retryable: false },
-    '18': { name: 'EventNotSupportedError', retryable: false },
-    '19': { name: 'ChannelFeatureNotSupportedError', retryable: false },
-    '20': { name: 'MessageTooLongError', retryable: false },
-    '21': { name: 'MultipleNestingLevelError', retryable: false },
-    '22': { name: 'PayloadTooBigError', retryable: false },
-    '23': { name: 'RequestTimeoutError', retryable: true },
-    '24': { name: 'MaxHeaderSizeExceededError', retryable: false },
-    '40': { name: 'AuthErrorTokenExpired', retryable: false },
-    '41': { name: 'AuthErrorTokenNotValidYet', retryable: false },
-    '42': { name: 'AuthErrorTokenUsedBeforeIssuedAt', retryable: false },
-    '43': { name: 'AuthErrorTokenSignatureInvalid', retryable: false },
-    '44': { name: 'CustomCommandEndpointMissingError', retryable: false },
-    '45': { name: 'CustomCommandEndpointCallError', retryable: true },
-    '46': { name: 'ConnectionIDNotFoundError', retryable: false },
-    '60': { name: 'CoolDownError', retryable: true },
-    '69': { name: 'ErrWrongRegion', retryable: false },
-    '70': { name: 'ErrQueryChannelPermissions', retryable: false },
-    '71': { name: 'ErrTooManyConnections', retryable: true },
-    '99': { name: 'AppSuspendedError', retryable: false },
-};
-function isAPIError(error) {
-    return error.code !== undefined;
-}
-function isErrorRetryable(error) {
-    if (!error.code)
-        return false;
-    const err = APIErrorCodes[`${error.code}`];
-    if (!err)
-        return false;
-    return err.retryable;
-}
-function isConnectionIDError(error) {
-    return error.code === 46; // ConnectionIDNotFoundError
-}
-function isWSFailure(err) {
-    if (typeof err.isWSFailure === 'boolean') {
-        return err.isWSFailure;
-    }
-    try {
-        return JSON.parse(err.message).isWSFailure;
-    }
-    catch (_) {
-        return false;
-    }
-}
-function isErrorResponse(res) {
-    return !res.status || res.status < 200 || 300 <= res.status;
-}
-
-var ConnectionState;
-(function (ConnectionState) {
-    ConnectionState["Closed"] = "CLOSED";
-    ConnectionState["Connected"] = "CONNECTED";
-    ConnectionState["Connecting"] = "CONNECTING";
-    ConnectionState["Disconnected"] = "DISCONNECTED";
-    ConnectionState["Init"] = "INIT";
-})(ConnectionState || (ConnectionState = {}));
-class WSConnectionFallback {
-    constructor(client) {
-        /** @private */
-        this._onlineStatusChanged = (event) => {
-            this._log(`_onlineStatusChanged() - ${event.type}`);
-            if (event.type === 'offline') {
-                this._setState(ConnectionState.Closed);
-                this.cancelToken?.cancel('disconnect() is called');
-                this.cancelToken = undefined;
-                return;
-            }
-            if (event.type === 'online' && this.state === ConnectionState.Closed) {
-                this.connect(true);
-            }
-        };
-        /** @private */
-        this._req = async (params, config, retry) => {
-            if (!this.cancelToken && !params.close) {
-                this.cancelToken = axios.CancelToken.source();
-            }
-            try {
-                const res = await this.client.doAxiosRequest('get', this.client.baseURL.replace(':3030', ':8900') + '/longpoll', // replace port if present for testing with local API
-                undefined, {
-                    config: { ...config, cancelToken: this.cancelToken?.token },
-                    params,
-                    publicEndpoint: true,
-                });
-                this.consecutiveFailures = 0; // always reset in case of no error
-                return res;
-            }
-            catch (err) {
-                this.consecutiveFailures += 1;
-                // @ts-ignore
-                if (retry && isErrorRetryable(err)) {
-                    this._log(`_req() - Retryable error, retrying request`);
-                    await sleep(retryInterval(this.consecutiveFailures));
-                    return this._req(params, config, retry);
-                }
-                throw err;
-            }
-        };
-        /** @private */
-        this._poll = async () => {
-            while (this.state === ConnectionState.Connected) {
-                try {
-                    const data = await this._req({}, {
-                        timeout: 30000,
-                    }, true); // 30s => API responds in 20s if there is no event
-                    if (data.events?.length) {
-                        for (let i = 0; i < data.events.length; i++) {
-                            this.client.dispatchEvent(data.events[i]);
-                        }
-                    }
-                }
-                catch (err) {
-                    if (axios.isCancel(err)) {
-                        this._log(`_poll() - axios canceled request`);
-                        return;
-                    }
-                    /** client.doAxiosRequest will take care of TOKEN_EXPIRED error */
-                    // @ts-ignore
-                    if (isConnectionIDError(err)) {
-                        this._log(`_poll() - ConnectionID error, connecting without ID...`);
-                        this._setState(ConnectionState.Disconnected);
-                        this.connect(true);
-                        return;
-                    }
-                    // @ts-ignore
-                    if (isAPIError(err) && !isErrorRetryable(err)) {
-                        this._setState(ConnectionState.Closed);
-                        return;
-                    }
-                    await sleep(retryInterval(this.consecutiveFailures));
-                }
-            }
-        };
-        /**
-         * connect try to open a longpoll request
-         * @param reconnect should be false for first call and true for subsequent calls to keep the connection alive and call recoverState
-         */
-        this.connect = async (reconnect = false) => {
-            if (this.state === ConnectionState.Connecting) {
-                this._log('connect() - connecting already in progress', { reconnect }, 'warn');
-                return;
-            }
-            if (this.state === ConnectionState.Connected) {
-                this._log('connect() - already connected and polling', { reconnect }, 'warn');
-                return;
-            }
-            this._setState(ConnectionState.Connecting);
-            this.connectionID = undefined; // connect should be sent with empty connection_id so API creates one
-            try {
-                const { event } = await this._req({ json: this.client._buildWSPayload() }, {
-                    timeout: 8000, // 8s
-                }, reconnect);
-                this._setState(ConnectionState.Connected);
-                this.connectionID = event.connection_id;
-                this.client.resolveConnectionId?.();
-                // @ts-expect-error
-                this.client.dispatchEvent(event);
-                this._poll();
-                return event;
-            }
-            catch (err) {
-                this._setState(ConnectionState.Closed);
-                this.client.rejectConnectionId?.();
-                throw err;
-            }
-        };
-        /**
-         * isHealthy checks if there is a connectionID and connection is in Connected state
-         */
-        this.isHealthy = () => {
-            return !!this.connectionID && this.state === ConnectionState.Connected;
-        };
-        this.disconnect = async (timeout = 2000) => {
-            removeConnectionEventListeners(this._onlineStatusChanged);
-            this._setState(ConnectionState.Disconnected);
-            this.cancelToken?.cancel('disconnect() is called');
-            this.cancelToken = undefined;
-            const connection_id = this.connectionID;
-            this.connectionID = undefined;
-            try {
-                await this._req({ close: true, connection_id }, {
-                    timeout,
-                }, false);
-                this._log(`disconnect() - Closed connectionID`);
-            }
-            catch (err) {
-                this._log(`disconnect() - Failed`, { err }, 'error');
-            }
-        };
-        this.client = client;
-        this.state = ConnectionState.Init;
-        this.consecutiveFailures = 0;
-        addConnectionEventListeners(this._onlineStatusChanged);
-    }
-    _log(msg, extra = {}, level = 'info') {
-        this.client.logger(level, 'WSConnectionFallback:' + msg, {
-            ...extra,
-        });
-    }
-    _setState(state) {
-        this._log(`_setState() - ${state}`);
-        // transition from connecting => connected
-        if (this.state === ConnectionState.Connecting &&
-            state === ConnectionState.Connected) {
-            this.client.dispatchEvent({ type: 'connection.changed', online: true });
-        }
-        if (state === ConnectionState.Closed ||
-            state === ConnectionState.Disconnected) {
-            this.client.dispatchEvent({ type: 'connection.changed', online: false });
-        }
-        this.state = state;
-    }
-}
-
 const getLocationHint = async (hintUrl = `https://hint.stream-io-video.com/`, timeout = 2000, maxAttempts = 3) => {
     const logger = getLogger(['location-hint']);
     let attempt = 0;
@@ -12659,9 +12263,6 @@ class StreamClient {
      */
     constructor(key, options) {
         this.listeners = {};
-        this.devToken = (userID) => {
-            return DevToken(userID);
-        };
         this.getAuthType = () => {
             return this.anonymous ? 'anonymous' : 'jwt';
         };
@@ -12679,7 +12280,7 @@ class StreamClient {
             }
             return hint;
         };
-        this._getConnectionID = () => this.wsConnection?.connectionID || this.wsFallback?.connectionID;
+        this._getConnectionID = () => this.wsConnection?.connectionID;
         this._hasConnectionID = () => Boolean(this._getConnectionID());
         /**
          * connectUser - Set the current user and open a WebSocket connection
@@ -12755,11 +12356,7 @@ class StreamClient {
          *                https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
          */
         this.closeConnection = async (timeout) => {
-            await Promise.all([
-                this.wsConnection?.disconnect(timeout),
-                this.wsFallback?.disconnect(timeout),
-            ]);
-            return Promise.resolve();
+            await this.wsConnection?.disconnect(timeout);
         };
         /**
          * Creates a new WebSocket connection with the current user. Returns empty promise, if there is an active connection
@@ -12773,12 +12370,11 @@ class StreamClient {
                 this.logger('info', 'client:openConnection() - connection already in progress');
                 return await wsPromise;
             }
-            if ((this.wsConnection?.isHealthy || this.wsFallback?.isHealthy()) &&
-                this._hasConnectionID()) {
+            if (this.wsConnection?.isHealthy && this._hasConnectionID()) {
                 this.logger('info', 'client:openConnection() - openConnection called twice, healthy connection already exists');
                 return;
             }
-            this._setupConnectionIdPromise();
+            await this._setupConnectionIdPromise();
             this.clientID = `${this.userID}--${randomId()}`;
             const newWsPromise = this.connect();
             this.wsPromiseSafe = makeSafePromise(newWsPromise);
@@ -12805,11 +12401,7 @@ class StreamClient {
             this.resolveConnectionId = undefined;
         };
         this.connectGuestUser = async (user) => {
-            this.guestUserCreatePromise = this.doAxiosRequest('post', '/guest', {
-                user: {
-                    ...user,
-                },
-            }, { publicEndpoint: true });
+            this.guestUserCreatePromise = this.doAxiosRequest('post', '/guest', { user }, { publicEndpoint: true });
             const response = await this.guestUserCreatePromise;
             this.guestUserCreatePromise.finally(() => (this.guestUserCreatePromise = undefined));
             return this.connectUser(response.user, response.access_token);
@@ -12819,7 +12411,7 @@ class StreamClient {
          */
         this.connectAnonymousUser = async (user, tokenOrProvider) => {
             addConnectionEventListeners(this.updateNetworkConnectionStatus);
-            this._setupConnectionIdPromise();
+            await this._setupConnectionIdPromise();
             this.anonymous = true;
             await this._setToken(user, tokenOrProvider, this.anonymous);
             this._setUser(user);
@@ -13013,78 +12605,17 @@ class StreamClient {
             if (!this.userID || !this._user) {
                 throw Error('Call connectUser or connectAnonymousUser before starting the connection');
             }
-            if (!this.wsBaseURL) {
+            if (!this.wsBaseURL)
                 throw Error('Websocket base url not set');
-            }
-            if (!this.clientID) {
+            if (!this.clientID)
                 throw Error('clientID is not set');
-            }
-            if (!this.wsConnection &&
-                (this.options.warmUp || this.options.enableInsights)) {
-                this._sayHi();
-            }
             // The StableWSConnection handles all the reconnection logic.
-            if (this.options.wsConnection && this.node) {
-                // Intentionally avoiding adding ts generics on wsConnection in options since its only useful for unit test purpose.
-                this.options.wsConnection.setClient(this);
-                this.wsConnection = this.options
-                    .wsConnection;
-            }
-            else {
-                this.wsConnection = new StableWSConnection(this);
-            }
-            try {
-                // if fallback is used before, continue using it instead of waiting for WS to fail
-                if (this.wsFallback) {
-                    return await this.wsFallback.connect();
-                }
-                this.logger('info', 'StreamClient.connect: this.wsConnection.connect()');
-                // if WSFallback is enabled, ws connect should timeout faster so fallback can try
-                return await this.wsConnection.connect(this.options.enableWSFallback
-                    ? this.defaultWSTimeoutWithFallback
-                    : this.defaultWSTimeout);
-            }
-            catch (err) {
-                // run fallback only if it's WS/Network error and not a normal API error
-                // make sure browser is online before even trying the longpoll
-                if (this.options.enableWSFallback &&
-                    // @ts-ignore
-                    isWSFailure(err) &&
-                    isOnline(this.logger)) {
-                    this.logger('warn', 'client:connect() - WS failed, fallback to longpoll');
-                    this.dispatchEvent({ type: 'transport.changed', mode: 'longpoll' });
-                    this.wsConnection._destroyCurrentWSConnection();
-                    this.wsConnection.disconnect().then(); // close WS so no retry
-                    this.wsFallback = new WSConnectionFallback(this);
-                    return await this.wsFallback.connect();
-                }
-                throw err;
-            }
-        };
-        /**
-         * Check the connectivity with server for warmup purpose.
-         *
-         * @private
-         */
-        this._sayHi = () => {
-            const client_request_id = randomId();
-            const opts = {
-                headers: axios.AxiosHeaders.from({
-                    'x-client-request-id': client_request_id,
-                }),
-            };
-            this.doAxiosRequest('get', this.baseURL + '/hi', null, opts).catch((e) => {
-                if (this.options.enableInsights) {
-                    postInsights('http_hi_failed', {
-                        api_key: this.key,
-                        err: e,
-                        client_request_id,
-                    });
-                }
-            });
+            this.wsConnection = new StableWSConnection(this);
+            this.logger('info', 'StreamClient.connect: this.wsConnection.connect()');
+            return await this.wsConnection.connect(this.defaultWSTimeout);
         };
         this.getUserAgent = () => {
-            const version = "1.11.6";
+            const version = "1.11.7";
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };
@@ -13132,18 +12663,6 @@ class StreamClient {
                 return null;
             return this.tokenManager.getToken();
         };
-        /**
-         * encode ws url payload
-         * @private
-         * @returns json string
-         */
-        this._buildWSPayload = (client_request_id) => {
-            return JSON.stringify({
-                user_id: this.userID,
-                user_details: this._user,
-                client_request_id,
-            });
-        };
         this.updateNetworkConnectionStatus = (event) => {
             if (event.type === 'offline') {
                 this.logger('debug', 'device went offline');
@@ -13172,7 +12691,6 @@ class StreamClient {
         this.options = {
             timeout: 5000,
             withCredentials: false, // making sure cookies are not sent
-            warmUp: false,
             ...inputOptions,
         };
         if (this.node && !this.options.httpsAgent) {
@@ -13182,16 +12700,6 @@ class StreamClient {
             });
         }
         this.setBaseURL(this.options.baseURL || 'https://video.stream-io-api.com/video');
-        if (typeof process !== 'undefined' &&
-            'env' in process &&
-            process.env.STREAM_LOCAL_TEST_RUN) {
-            this.setBaseURL('http://localhost:3030/video');
-        }
-        if (typeof process !== 'undefined' &&
-            'env' in process &&
-            process.env.STREAM_LOCAL_TEST_HOST) {
-            this.setBaseURL(`http://${process.env.STREAM_LOCAL_TEST_HOST}/video`);
-        }
         this.axiosInstance = axios.create({
             ...this.options,
             baseURL: this.baseURL,
@@ -13208,8 +12716,6 @@ class StreamClient {
         // generated from secret.
         this.tokenManager = new TokenManager(this.secret);
         this.consecutiveFailures = 0;
-        this.insightMetrics = new InsightMetrics();
-        this.defaultWSTimeoutWithFallback = 6000;
         this.defaultWSTimeout = 15000;
         this.logger = isFunction(inputOptions.logger)
             ? inputOptions.logger