@stream-io/video-client 0.0.39 → 0.0.40

package/dist/index.cjs.js

@@ -6868,7 +6868,7 @@ class StreamSfuClient {
          * from this SFU.
          */
         this.isMigratingAway = false;
-        this.pingIntervalInMs = 25 * 1000;
+        this.pingIntervalInMs = 10 * 1000;
         this.unhealthyTimeoutInMs = this.pingIntervalInMs + 5 * 1000;
         this.close = (code = 1000, reason = 'Requested signal connection close') => {
             this.signalWs.close(code, reason);
@@ -9104,13 +9104,6 @@ const getClientDetails = () => {
  * An object representation of a `Call`.
  */
 class Call {
-    /**
-     * A promise that exposes the reconnection logic
-     * The use-case is for the react-native platform where online/offline events are not available in the window
-     */
-    get rejoin() {
-        return this.rejoinPromise;
-    }
     /**
      * Constructs a new `Call` instance.
      *
@@ -9156,7 +9149,6 @@ class Call {
             if (callingState === exports.CallingState.LEFT) {
                 throw new Error('Cannot leave call that has already been left.');
             }
-            this.rejoinPromise = undefined;
             if (this.ringing) {
                 // I'm the one who started the call, so I should cancel it.
                 const hasOtherParticipants = this.state.remoteParticipants.length > 0;
@@ -9360,7 +9352,7 @@ class Call {
                 // we shouldn't be republishing the streams if we're migrating
                 // as the underlying peer connection will take care of it as part
                 // of the ice-restart process
-                if (localParticipant && !isReactNative() && !migrate) {
+                if (localParticipant && !migrate) {
                     const { audioStream, videoStream, screenShareStream: screenShare, } = localParticipant;
                     // restore previous publishing state
                     if (audioStream)
@@ -9372,7 +9364,6 @@ class Call {
                 }
                 this.logger('info', `[Rejoin]: State restored. Attempt: ${this.reconnectAttempts}`);
             });
-            this.rejoinPromise = rejoin;
             // reconnect if the connection was closed unexpectedly. example:
             // - SFU crash or restart
             // - network change
@@ -9405,9 +9396,6 @@ class Call {
                     if (e.code === KnownCodes.WS_CLOSED_ABRUPTLY &&
                         sfuClient.isMigratingAway)
                         return;
-                    // do nothing for react-native as it is handled by SDK
-                    if (isReactNative())
-                        return;
                     if (this.reconnectAttempts < this.maxReconnectAttempts) {
                         rejoin().catch((err) => {
                             this.logger('error', `[Rejoin]: Rejoin failed for ${this.reconnectAttempts} times. Giving up.`, err);
@@ -9421,28 +9409,34 @@ class Call {
                 });
             });
             // handlers for connection online/offline events
-            // Note: window.addEventListener is not available in React Native, hence the check
-            if (typeof window !== 'undefined' && window.addEventListener) {
-                const handleOnOffline = () => {
-                    window.removeEventListener('offline', handleOnOffline);
-                    this.logger('warn', '[Rejoin]: Going offline...');
-                    this.state.setCallingState(exports.CallingState.OFFLINE);
-                };
-                const handleOnOnline = () => {
-                    window.removeEventListener('online', handleOnOnline);
-                    if (this.state.callingState === exports.CallingState.OFFLINE) {
-                        this.logger('info', '[Rejoin]: Going online...');
-                        rejoin().catch((err) => {
-                            this.logger('error', `[Rejoin]: Rejoin failed for ${this.reconnectAttempts} times. Giving up.`, err);
-                            this.state.setCallingState(exports.CallingState.RECONNECTING_FAILED);
-                        });
-                    }
-                };
-                window.addEventListener('offline', handleOnOffline);
-                window.addEventListener('online', handleOnOnline);
-                // register cleanup hooks
-                this.leaveCallHooks.push(() => window.removeEventListener('offline', handleOnOffline), () => window.removeEventListener('online', handleOnOnline));
-            }
+            const unsubscribeOnlineEvent = this.streamClient.on('connection.changed', (e) => {
+                if (e.type !== 'connection.changed')
+                    return;
+                if (!e.online)
+                    return;
+                unsubscribeOnlineEvent();
+                const currentCallingState = this.state.callingState;
+                if (currentCallingState === exports.CallingState.OFFLINE ||
+                    currentCallingState === exports.CallingState.RECONNECTING_FAILED) {
+                    this.logger('info', '[Rejoin]: Going online...');
+                    rejoin().catch((err) => {
+                        this.logger('error', `[Rejoin]: Rejoin failed for ${this.reconnectAttempts} times. Giving up.`, err);
+                        this.state.setCallingState(exports.CallingState.RECONNECTING_FAILED);
+                    });
+                }
+            });
+            const unsubscribeOfflineEvent = this.streamClient.on('connection.changed', (e) => {
+                if (e.type !== 'connection.changed')
+                    return;
+                if (e.online)
+                    return;
+                unsubscribeOfflineEvent();
+                this.state.setCallingState(exports.CallingState.OFFLINE);
+            });
+            this.leaveCallHooks.push(() => {
+                unsubscribeOnlineEvent();
+                unsubscribeOfflineEvent();
+            });
             if (!this.subscriber) {
                 this.subscriber = new Subscriber({
                     sfuClient,
@@ -10291,6 +10285,9 @@ const isErrorEvent = (res) => res.error !== undefined;
  */
 class StableWSConnection {
     constructor(client) {
+        this._log = (msg, extra = {}, level = 'info') => {
+            this.client.logger(level, 'connection:' + msg, Object.assign({}, extra));
+        };
         this.setClient = (client) => {
             this.client = client;
         };
@@ -10319,7 +10316,8 @@ class StableWSConnection {
             if (event.type === 'offline') {
                 // mark the connection as down
                 this._log('onlineStatusChanged() - Status changing to offline');
-                this._setHealth(false);
+                // we know that the app is offline so dispatch the unhealthy connection event immediately
+                this._setHealth(false, true);
             }
             else if (event.type === 'online') {
                 // retry right now...
@@ -10447,13 +10445,14 @@ class StableWSConnection {
          * Broadcasts an event in case the connection status changed.
          *
          * @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) => {
+        this._setHealth = (healthy, dispatchImmediately = false) => {
             if (healthy === this.isHealthy)
                 return;
             this.isHealthy = healthy;
-            if (this.isHealthy) {
+            if (this.isHealthy || dispatchImmediately) {
                 this.client.dispatchEvent({
                     type: 'connection.changed',
                     online: this.isHealthy,
@@ -10575,9 +10574,6 @@ class StableWSConnection {
         this.connectionCheckTimeout = this.pingInterval + 10 * 1000;
         addConnectionEventListeners(this.onlineStatusChanged);
     }
-    _log(msg, extra = {}, level = 'info') {
-        this.client.logger(level, 'connection:' + msg, Object.assign({}, extra));
-    }
     /**
      * connect - Connect to the WS URL
      * the default 15s timeout allows between 2~3 tries
@@ -11329,6 +11325,18 @@ class StreamClient {
     constructor(key, options) {
         var _a;
         this.nextRequestAbortController = null;
+        this.devToken = (userID) => {
+            return DevToken(userID);
+        };
+        this.getAuthType = () => {
+            return this.anonymous ? 'anonymous' : 'jwt';
+        };
+        this.setBaseURL = (baseURL) => {
+            this.baseURL = baseURL;
+            this.wsBaseURL = this.baseURL
+                .replace('http', 'ws')
+                .replace(':3030', ':8800');
+        };
         this._getConnectionID = () => { var _a, _b; return ((_a = this.wsConnection) === null || _a === void 0 ? void 0 : _a.connectionID) || ((_b = this.wsFallback) === null || _b === void 0 ? void 0 : _b.connectionID); };
         this._hasConnectionID = () => Boolean(this._getConnectionID());
         /**
@@ -11393,6 +11401,16 @@ class StreamClient {
             }
         });
         this._setToken = (user, userTokenOrProvider, isAnonymous) => this.tokenManager.setTokenOrProvider(userTokenOrProvider, user, isAnonymous);
+        this._setUser = (user) => {
+            /**
+             * This one is used by the frontend. This is a copy of the current user object stored on backend.
+             * It contains reserved properties and own user properties which are not present in `this._user`.
+             */
+            this.user = user;
+            this.userID = user.id;
+            // this one is actually used for requests. This is a copy of current user provided to `connectUser` function.
+            this._user = Object.assign({}, user);
+        };
         /**
          * Disconnects the websocket connection, without removing the user set on client.
          * client.closeConnection will not trigger default auto-retry mechanism for reconnection. You need
@@ -11481,6 +11499,66 @@ class StreamClient {
             // resolve the connection_id here.
             this.resolveConnectionId();
         });
+        /**
+         * on - Listen to events on all channels and users your watching
+         *
+         * client.on('message.new', event => {console.log("my new message", event, channel.state.messages)})
+         * or
+         * client.on(event => {console.log(event.type)})
+         *
+         * @param {EventHandler | string} callbackOrEventName  The event type to listen for (optional)
+         * @param {EventHandler} [callbackOrNothing] The callback to call
+         *
+         * @return {Function} Returns a function which, when called, unsubscribes the event handler.
+         */
+        this.on = (callbackOrEventName, callbackOrNothing) => {
+            const key = callbackOrNothing ? callbackOrEventName : 'all';
+            const callback = callbackOrNothing
+                ? callbackOrNothing
+                : callbackOrEventName;
+            if (!(key in this.listeners)) {
+                this.listeners[key] = [];
+            }
+            this.listeners[key].push(callback);
+            return () => {
+                this.off(key, callback);
+            };
+        };
+        /**
+         * off - Remove the event handler
+         *
+         */
+        this.off = (callbackOrEventName, callbackOrNothing) => {
+            const key = callbackOrNothing ? callbackOrEventName : 'all';
+            const callback = callbackOrNothing
+                ? callbackOrNothing
+                : callbackOrEventName;
+            if (!(key in this.listeners)) {
+                this.listeners[key] = [];
+            }
+            this.logger('debug', `Removing listener for ${key} event`);
+            this.listeners[key] = this.listeners[key].filter((value) => value !== callback);
+        };
+        this._logApiRequest = (type, url, data, config) => {
+            this.logger('trace', `client: ${type} - Request - ${url}`, {
+                payload: data,
+                config,
+            });
+        };
+        this._logApiResponse = (type, url, response) => {
+            this.logger('trace', `client:${type} - Response - url: ${url} > status ${response.status}`, {
+                response,
+            });
+            this.logger('trace', `client:${type} - Response payload`, {
+                response,
+            });
+        };
+        this._logApiError = (type, url, error) => {
+            this.logger('error', `client:${type} - Error - url: ${url}`, {
+                url,
+                error,
+            });
+        };
         this.doAxiosRequest = (type, url, data, options = {}) => __awaiter(this, void 0, void 0, function* () {
             var _g;
             if (!options.publicEndpoint || this.user) {
@@ -11545,6 +11623,43 @@ class StreamClient {
                 }
             }
         });
+        this.get = (url, params) => {
+            return this.doAxiosRequest('get', url, null, {
+                params,
+            });
+        };
+        this.put = (url, data) => {
+            return this.doAxiosRequest('put', url, data);
+        };
+        this.post = (url, data) => {
+            return this.doAxiosRequest('post', url, data);
+        };
+        this.patch = (url, data) => {
+            return this.doAxiosRequest('patch', url, data);
+        };
+        this.delete = (url, params) => {
+            return this.doAxiosRequest('delete', url, null, {
+                params,
+            });
+        };
+        this.errorFromResponse = (response) => {
+            let err;
+            err = new ErrorFromResponse(`Stream error HTTP code: ${response.status}`);
+            if (response.data && response.data.code) {
+                err = new Error(`Stream error code ${response.data.code}: ${response.data.message}`);
+                err.code = response.data.code;
+            }
+            err.response = response;
+            err.status = response.status;
+            return err;
+        };
+        this.handleResponse = (response) => {
+            const data = response.data;
+            if (isErrorResponse(response)) {
+                throw this.errorFromResponse(response);
+            }
+            return data;
+        };
         this.dispatchEvent = (event) => {
             if (!event.received_at)
                 event.received_at = new Date();
@@ -11572,10 +11687,119 @@ class StreamClient {
                 listener(event);
             }
         };
+        /**
+         * @private
+         */
+        this.connect = () => __awaiter(this, void 0, void 0, function* () {
+            if (!this.userID || !this._user) {
+                throw Error('Call connectUser or connectAnonymousUser before starting the connection');
+            }
+            if (!this.wsBaseURL) {
+                throw Error('Websocket base url not set');
+            }
+            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 yield 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 yield 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 yield 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.getUserAgent = () => {
+            return (this.userAgent ||
+                `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${"0.0.39"}`);
+        };
+        this.setUserAgent = (userAgent) => {
+            this.userAgent = userAgent;
+        };
         /**
          * _isUsingServerAuth - Returns true if we're using server side auth
          */
         this._isUsingServerAuth = () => !!this.secret;
+        this._enrichAxiosOptions = (options = {
+            params: {},
+            headers: {},
+            config: {},
+        }) => {
+            var _a;
+            const token = options.publicEndpoint && !this.user ? undefined : this._getToken();
+            const authorization = token ? { Authorization: token } : undefined;
+            let signal = null;
+            if (this.nextRequestAbortController !== null) {
+                signal = this.nextRequestAbortController.signal;
+                this.nextRequestAbortController = null;
+            }
+            if (!((_a = options.headers) === null || _a === void 0 ? void 0 : _a['x-client-request-id'])) {
+                options.headers = Object.assign(Object.assign({}, options.headers), { 'x-client-request-id': randomId() });
+            }
+            return Object.assign(Object.assign(Object.assign({ params: Object.assign({ user_id: this.userID, connection_id: this._getConnectionID(), api_key: this.key }, options.params), headers: Object.assign(Object.assign(Object.assign({}, authorization), { 'stream-auth-type': options.publicEndpoint && !this.user
+                        ? 'anonymous'
+                        : this.getAuthType(), 'X-Stream-Client': this.getUserAgent() }), options.headers) }, (signal ? { signal } : {})), options.config), this.options.axiosRequestConfig);
+        };
+        this._getToken = () => {
+            if (!this.tokenManager)
+                return null;
+            return this.tokenManager.getToken();
+        };
         /**
          * encode ws url payload
          * @private
@@ -11588,6 +11812,38 @@ class StreamClient {
                 client_request_id,
             });
         };
+        /**
+         * creates an abort controller that will be used by the next HTTP Request.
+         */
+        this.createAbortControllerForNextRequest = () => {
+            return (this.nextRequestAbortController = new AbortController());
+        };
+        /**
+         * createToken - Creates a token to authenticate this user. This function is used server side.
+         * The resulting token should be passed to the client side when the users registers or logs in.
+         *
+         * @param {string} userID The UserWithId ID
+         * @param {number} [exp] The expiration time for the token expressed in the number of seconds since the epoch
+         * @param call_cids for anonymous tokens you have to provide the call cids the use can join
+         *
+         * @return {string} Returns a token
+         */
+        this.createToken = (userID, exp, iat, call_cids) => {
+            if (this.secret == null) {
+                throw Error(`tokens can only be created server-side using the API Secret`);
+            }
+            const extra = {};
+            if (exp) {
+                extra.exp = exp;
+            }
+            if (iat) {
+                extra.iat = iat;
+            }
+            if (call_cids) {
+                extra.call_cids = call_cids;
+            }
+            return JWTUserToken(this.secret, userID, extra, {});
+        };
         // set the key
         this.key = key;
         this.listeners = {};
@@ -11639,268 +11895,6 @@ class StreamClient {
             ? inputOptions.logger
             : () => null;
     }
-    devToken(userID) {
-        return DevToken(userID);
-    }
-    getAuthType() {
-        return this.anonymous ? 'anonymous' : 'jwt';
-    }
-    setBaseURL(baseURL) {
-        this.baseURL = baseURL;
-        this.wsBaseURL = this.baseURL
-            .replace('http', 'ws')
-            .replace(':3030', ':8800');
-    }
-    _setUser(user) {
-        /**
-         * This one is used by the frontend. This is a copy of the current user object stored on backend.
-         * It contains reserved properties and own user properties which are not present in `this._user`.
-         */
-        this.user = user;
-        this.userID = user.id;
-        // this one is actually used for requests. This is a copy of current user provided to `connectUser` function.
-        this._user = Object.assign({}, user);
-    }
-    /**
-     * on - Listen to events on all channels and users your watching
-     *
-     * client.on('message.new', event => {console.log("my new message", event, channel.state.messages)})
-     * or
-     * client.on(event => {console.log(event.type)})
-     *
-     * @param {EventHandler | string} callbackOrEventName  The event type to listen for (optional)
-     * @param {EventHandler} [callbackOrNothing] The callback to call
-     *
-     * @return {Function} Returns a function which, when called, unsubscribes the event handler.
-     */
-    on(callbackOrEventName, callbackOrNothing) {
-        const key = callbackOrNothing ? callbackOrEventName : 'all';
-        const callback = callbackOrNothing
-            ? callbackOrNothing
-            : callbackOrEventName;
-        if (!(key in this.listeners)) {
-            this.listeners[key] = [];
-        }
-        this.listeners[key].push(callback);
-        return () => {
-            this.off(key, callback);
-        };
-    }
-    /**
-     * off - Remove the event handler
-     *
-     */
-    off(callbackOrEventName, callbackOrNothing) {
-        const key = callbackOrNothing ? callbackOrEventName : 'all';
-        const callback = callbackOrNothing
-            ? callbackOrNothing
-            : callbackOrEventName;
-        if (!(key in this.listeners)) {
-            this.listeners[key] = [];
-        }
-        this.logger('debug', `Removing listener for ${key} event`);
-        this.listeners[key] = this.listeners[key].filter((value) => value !== callback);
-    }
-    _logApiRequest(type, url, data, config) {
-        this.logger('trace', `client: ${type} - Request - ${url}`, {
-            payload: data,
-            config,
-        });
-    }
-    _logApiResponse(type, url, response) {
-        this.logger('trace', `client:${type} - Response - url: ${url} > status ${response.status}`, {
-            response,
-        });
-        this.logger('trace', `client:${type} - Response payload`, {
-            response,
-        });
-    }
-    _logApiError(type, url, error) {
-        this.logger('error', `client:${type} - Error - url: ${url}`, {
-            url,
-            error,
-        });
-    }
-    get(url, params) {
-        return this.doAxiosRequest('get', url, null, {
-            params,
-        });
-    }
-    put(url, data) {
-        return this.doAxiosRequest('put', url, data);
-    }
-    post(url, data) {
-        return this.doAxiosRequest('post', url, data);
-    }
-    patch(url, data) {
-        return this.doAxiosRequest('patch', url, data);
-    }
-    delete(url, params) {
-        return this.doAxiosRequest('delete', url, null, {
-            params,
-        });
-    }
-    errorFromResponse(response) {
-        let err;
-        err = new ErrorFromResponse(`Stream error HTTP code: ${response.status}`);
-        if (response.data && response.data.code) {
-            err = new Error(`Stream error code ${response.data.code}: ${response.data.message}`);
-            err.code = response.data.code;
-        }
-        err.response = response;
-        err.status = response.status;
-        return err;
-    }
-    handleResponse(response) {
-        const data = response.data;
-        if (isErrorResponse(response)) {
-            throw this.errorFromResponse(response);
-        }
-        return data;
-    }
-    /**
-     * @private
-     */
-    connect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.userID || !this._user) {
-                throw Error('Call connectUser or connectAnonymousUser before starting the connection');
-            }
-            if (!this.wsBaseURL) {
-                throw Error('Websocket base url not set');
-            }
-            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 yield 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 yield 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 yield this.wsFallback.connect();
-                }
-                throw err;
-            }
-        });
-    }
-    /**
-     * Check the connectivity with server for warmup purpose.
-     *
-     * @private
-     */
-    _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,
-                });
-            }
-        });
-    }
-    getUserAgent() {
-        return (this.userAgent ||
-            `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${"0.0.38"}`);
-    }
-    setUserAgent(userAgent) {
-        this.userAgent = userAgent;
-    }
-    _enrichAxiosOptions(options = {
-        params: {},
-        headers: {},
-        config: {},
-    }) {
-        var _a;
-        const token = options.publicEndpoint && !this.user ? undefined : this._getToken();
-        const authorization = token ? { Authorization: token } : undefined;
-        let signal = null;
-        if (this.nextRequestAbortController !== null) {
-            signal = this.nextRequestAbortController.signal;
-            this.nextRequestAbortController = null;
-        }
-        if (!((_a = options.headers) === null || _a === void 0 ? void 0 : _a['x-client-request-id'])) {
-            options.headers = Object.assign(Object.assign({}, options.headers), { 'x-client-request-id': randomId() });
-        }
-        return Object.assign(Object.assign(Object.assign({ params: Object.assign({ user_id: this.userID, connection_id: this._getConnectionID(), api_key: this.key }, options.params), headers: Object.assign(Object.assign(Object.assign({}, authorization), { 'stream-auth-type': options.publicEndpoint && !this.user
-                    ? 'anonymous'
-                    : this.getAuthType(), 'X-Stream-Client': this.getUserAgent() }), options.headers) }, (signal ? { signal } : {})), options.config), this.options.axiosRequestConfig);
-    }
-    _getToken() {
-        if (!this.tokenManager)
-            return null;
-        return this.tokenManager.getToken();
-    }
-    /**
-     * creates an abort controller that will be used by the next HTTP Request.
-     */
-    createAbortControllerForNextRequest() {
-        return (this.nextRequestAbortController = new AbortController());
-    }
-    /**
-     * createToken - Creates a token to authenticate this user. This function is used server side.
-     * The resulting token should be passed to the client side when the users registers or logs in.
-     *
-     * @param {string} userID The UserWithId ID
-     * @param {number} [exp] The expiration time for the token expressed in the number of seconds since the epoch
-     * @param call_cids for anonymous tokens you have to provide the call cids the use can join
-     *
-     * @return {string} Returns a token
-     */
-    createToken(userID, exp, iat, call_cids) {
-        if (this.secret == null) {
-            throw Error(`tokens can only be created server-side using the API Secret`);
-        }
-        const extra = {};
-        if (exp) {
-            extra.exp = exp;
-        }
-        if (iat) {
-            extra.iat = iat;
-        }
-        if (call_cids) {
-            extra.call_cids = call_cids;
-        }
-        return JWTUserToken(this.secret, userID, extra, {});
-    }
 }
 
 /**