@stream-io/video-client 1.18.7 → 1.18.9

package/dist/src/Call.d.ts

@@ -209,7 +209,16 @@ export declare class Call {
      *
      * @returns a promise which resolves once the call join-flow has finished.
      */
-    join: (data?: JoinCallData) => Promise<void>;
+    join: ({ maxJoinRetries, ...data }?: JoinCallData & {
+        maxJoinRetries?: number;
+    }) => Promise<void>;
+    /**
+     * Will make a single attempt to watch for call related WebSocket events
+     * and initiate a call session with the server.
+     *
+     * @returns a promise which resolves once the call join-flow has finished.
+     */
+    doJoin: (data?: JoinCallData) => Promise<void>;
     /**
      * Prepares Reconnect Details object.
      * @internal

package/dist/src/devices/ScreenShareManager.d.ts

@@ -31,8 +31,6 @@ export declare class ScreenShareManager extends InputMediaDeviceManager<ScreenSh
     protected stopPublishStream(): Promise<void>;
     /**
      * Overrides the default `select` method to throw an error.
-     *
-     * @param deviceId ignored.
      */
-    select(deviceId: string | undefined): Promise<void>;
+    select(): Promise<void>;
 }

package/dist/src/gen/video/sfu/event/events.d.ts

@@ -1,24 +1,6 @@
 import { MessageType } from '@protobuf-ts/runtime';
-import { CallEndedReason } from '../models/models';
-import { GoAwayReason } from '../models/models';
-import { CallGrants } from '../models/models';
-import { Codec } from '../models/models';
-import { ConnectionQuality } from '../models/models';
-import { CallState } from '../models/models';
+import { CallEndedReason, CallGrants, CallState, ClientDetails, Codec, ConnectionQuality, Error as Error$, GoAwayReason, ICETrickle as ICETrickle$, Participant, ParticipantCount, PeerType, Pin, PublishOption, SubscribeOption, TrackInfo, TrackType, TrackUnpublishReason, WebsocketReconnectStrategy } from '../models/models';
 import { TrackSubscriptionDetails } from '../signal_rpc/signal';
-import { TrackInfo } from '../models/models';
-import { SubscribeOption } from '../models/models';
-import { ClientDetails } from '../models/models';
-import { TrackUnpublishReason } from '../models/models';
-import { Participant } from '../models/models';
-import { TrackType } from '../models/models';
-import { ParticipantCount } from '../models/models';
-import { PeerType } from '../models/models';
-import { WebsocketReconnectStrategy } from '../models/models';
-import { Error as Error$ } from '../models/models';
-import { Pin } from '../models/models';
-import { PublishOption } from '../models/models';
-import { ICETrickle as ICETrickle$ } from '../models/models';
 /**
  * SFUEvent is a message that is sent from the SFU to the client.
  *

package/dist/src/gen/video/sfu/signal_rpc/signal.client.d.ts

@@ -1,25 +1,6 @@
-import type { RpcTransport } from '@protobuf-ts/runtime-rpc';
-import type { ServiceInfo } from '@protobuf-ts/runtime-rpc';
-import type { StopNoiseCancellationResponse } from './signal';
-import type { StopNoiseCancellationRequest } from './signal';
-import type { StartNoiseCancellationResponse } from './signal';
-import type { StartNoiseCancellationRequest } from './signal';
-import type { SendStatsResponse } from './signal';
-import type { SendStatsRequest } from './signal';
-import type { ICERestartResponse } from './signal';
-import type { ICERestartRequest } from './signal';
-import type { UpdateMuteStatesResponse } from './signal';
-import type { UpdateMuteStatesRequest } from './signal';
-import type { UpdateSubscriptionsResponse } from './signal';
-import type { UpdateSubscriptionsRequest } from './signal';
-import type { ICETrickleResponse } from './signal';
+import type { RpcOptions, RpcTransport, ServiceInfo, UnaryCall } from '@protobuf-ts/runtime-rpc';
+import type { ICERestartRequest, ICERestartResponse, ICETrickleResponse, SendAnswerRequest, SendAnswerResponse, SendStatsRequest, SendStatsResponse, SetPublisherRequest, SetPublisherResponse, StartNoiseCancellationRequest, StartNoiseCancellationResponse, StopNoiseCancellationRequest, StopNoiseCancellationResponse, UpdateMuteStatesRequest, UpdateMuteStatesResponse, UpdateSubscriptionsRequest, UpdateSubscriptionsResponse } from './signal';
 import type { ICETrickle } from '../models/models';
-import type { SendAnswerResponse } from './signal';
-import type { SendAnswerRequest } from './signal';
-import type { SetPublisherResponse } from './signal';
-import type { SetPublisherRequest } from './signal';
-import type { UnaryCall } from '@protobuf-ts/runtime-rpc';
-import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
 /**
  * @generated from protobuf service stream.video.sfu.signal.SignalServer
  */

package/dist/src/gen/video/sfu/signal_rpc/signal.d.ts

@@ -1,14 +1,6 @@
+import { AndroidState, AppleState, Error, InputDevices, PeerType, TrackInfo, TrackType, VideoDimension, WebsocketReconnectStrategy } from '../models/models';
 import { ServiceType } from '@protobuf-ts/runtime-rpc';
 import { MessageType } from '@protobuf-ts/runtime';
-import { TrackInfo } from '../models/models';
-import { VideoDimension } from '../models/models';
-import { TrackType } from '../models/models';
-import { PeerType } from '../models/models';
-import { AppleState } from '../models/models';
-import { AndroidState } from '../models/models';
-import { InputDevices } from '../models/models';
-import { WebsocketReconnectStrategy } from '../models/models';
-import { Error } from '../models/models';
 /**
  * @generated from protobuf message stream.video.sfu.signal.StartNoiseCancellationRequest
  */

package/dist/src/helpers/promise.d.ts

@@ -20,8 +20,8 @@ export type PromiseWithResolvers<T> = {
     promise: Promise<T>;
     resolve: (value: T | PromiseLike<T>) => void;
     reject: (reason: any) => void;
-    isResolved: boolean;
-    isRejected: boolean;
+    isResolved: () => boolean;
+    isRejected: () => boolean;
 };
 /**
  * Creates a new promise with resolvers.

package/dist/src/store/CallState.d.ts

@@ -360,6 +360,11 @@ export declare class CallState {
      * The backstage state.
      */
     get backstage(): boolean;
+    /**
+     * Sets the backstage state.
+     * @param backstage the backstage state.
+     */
+    setBackstage: (backstage: Patch<boolean>) => boolean;
     /**
      * Will provide the list of blocked user IDs.
      */

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.18.7",
-  "packageManager": "yarn@3.2.4",
+  "version": "1.18.9",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",
@@ -42,18 +41,18 @@
     "@rollup/plugin-replace": "^6.0.2",
     "@rollup/plugin-typescript": "^12.1.2",
     "@stream-io/audio-filters-web": "^0.2.3",
-    "@stream-io/node-sdk": "^0.4.18",
+    "@stream-io/node-sdk": "^0.4.19",
     "@types/sdp-transform": "^2.4.9",
     "@types/ua-parser-js": "^0.7.39",
-    "@vitest/coverage-v8": "^3.0.5",
+    "@vitest/coverage-v8": "^3.0.9",
     "dotenv": "^16.4.7",
     "happy-dom": "^11.0.2",
-    "prettier": "^3.3.2",
-    "rimraf": "^5.0.7",
-    "rollup": "^4.34.7",
-    "typescript": "^5.5.2",
-    "vite": "^5.4.6",
-    "vitest": "^3.0.5",
-    "vitest-mock-extended": "^2.0.2"
+    "prettier": "^3.5.3",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.36.0",
+    "typescript": "^5.8.2",
+    "vite": "^6.2.2",
+    "vitest": "^3.0.9",
+    "vitest-mock-extended": "^3.0.1"
   }
 }

package/src/Call.ts

@@ -120,7 +120,7 @@ import { DynascaleManager } from './helpers/DynascaleManager';
 import { PermissionsContext } from './permissions';
 import { CallTypes } from './CallType';
 import { StreamClient } from './coordinator/connection/client';
-import { sleep } from './coordinator/connection/utils';
+import { retryInterval, sleep } from './coordinator/connection/utils';
 import {
   AllCallEvents,
   CallEventListener,
@@ -813,14 +813,49 @@ export class Call {
    *
    * @returns a promise which resolves once the call join-flow has finished.
    */
-  join = async (data?: JoinCallData): Promise<void> => {
-    const connectStartTime = Date.now();
+  join = async ({
+    maxJoinRetries = 3,
+    ...data
+  }: JoinCallData & {
+    maxJoinRetries?: number;
+  } = {}): Promise<void> => {
     await this.setup();
     const callingState = this.state.callingState;
+
     if ([CallingState.JOINED, CallingState.JOINING].includes(callingState)) {
       throw new Error(`Illegal State: call.join() shall be called only once`);
     }
 
+    this.state.setCallingState(CallingState.JOINING);
+
+    maxJoinRetries = Math.max(maxJoinRetries, 1);
+    for (let attempt = 0; attempt < maxJoinRetries; attempt++) {
+      try {
+        this.logger('trace', `Joining call (${attempt})`, this.cid);
+        return await this.doJoin(data);
+      } catch (err) {
+        this.logger('warn', `Failed to join call (${attempt})`, this.cid);
+        if (attempt === maxJoinRetries - 1) {
+          // restore the previous call state if the join-flow fails
+          this.state.setCallingState(callingState);
+          throw err;
+        }
+      }
+
+      await sleep(retryInterval(attempt));
+    }
+  };
+
+  /**
+   * Will make a single attempt to watch for call related WebSocket events
+   * and initiate a call session with the server.
+   *
+   * @returns a promise which resolves once the call join-flow has finished.
+   */
+  doJoin = async (data?: JoinCallData): Promise<void> => {
+    const connectStartTime = Date.now();
+    const callingState = this.state.callingState;
+
     this.joinCallData = data;
 
     this.logger('debug', 'Starting join flow');
@@ -920,6 +955,11 @@ export class Call {
           );
         }
       } catch (error) {
+        this.logger('warn', 'Join SFU request failed', error);
+        sfuClient.close(
+          StreamSfuClient.ERROR_CONNECTION_UNHEALTHY,
+          'Join request failed, connection considered unhealthy',
+        );
         // restore the previous call state if the join-flow fails
         this.state.setCallingState(callingState);
         throw error;
@@ -1230,9 +1270,20 @@ export class Call {
    */
   private handleSfuSignalClose = (sfuClient: StreamSfuClient) => {
     this.logger('debug', '[Reconnect] SFU signal connection closed');
-    // SFU WS closed before we finished current join, no need to schedule reconnect
-    // because join operation will fail
-    if (this.state.callingState === CallingState.JOINING) return;
+    const { callingState } = this.state;
+    if (
+      // SFU WS closed before we finished current join,
+      // no need to schedule reconnecting
+      callingState === CallingState.JOINING ||
+      // we are already in the process of reconnecting,
+      // no need to schedule another one
+      callingState === CallingState.RECONNECTING ||
+      // SFU WS closed as a result of unsuccessful join,
+      // and no further retries need to be made
+      callingState === CallingState.IDLE ||
+      callingState === CallingState.LEFT
+    )
+      return;
     // normal close, no need to reconnect
     if (sfuClient.isLeaving) return;
     this.reconnect(WebsocketReconnectStrategy.REJOIN).catch((err) => {
@@ -1262,7 +1313,7 @@ export class Call {
         `[Reconnect] Reconnecting with strategy ${WebsocketReconnectStrategy[strategy]}`,
       );
 
-      let reconnectStartTime = Date.now();
+      const reconnectStartTime = Date.now();
       this.reconnectStrategy = strategy;
 
       do {
@@ -1352,7 +1403,7 @@ export class Call {
     const reconnectStartTime = Date.now();
     this.reconnectStrategy = WebsocketReconnectStrategy.FAST;
     this.state.setCallingState(CallingState.RECONNECTING);
-    await this.join(this.joinCallData);
+    await this.doJoin(this.joinCallData);
     this.sfuStatsReporter?.sendReconnectionTime(
       WebsocketReconnectStrategy.FAST,
       (Date.now() - reconnectStartTime) / 1000,
@@ -1367,7 +1418,7 @@ export class Call {
     const reconnectStartTime = Date.now();
     this.reconnectStrategy = WebsocketReconnectStrategy.REJOIN;
     this.state.setCallingState(CallingState.RECONNECTING);
-    await this.join(this.joinCallData);
+    await this.doJoin(this.joinCallData);
     await this.restorePublishedTracks();
     this.restoreSubscribedTracks();
     this.sfuStatsReporter?.sendReconnectionTime(
@@ -1399,7 +1450,7 @@ export class Call {
 
     try {
       const currentSfu = currentSfuClient.edgeName;
-      await this.join({ ...this.joinCallData, migrating_from: currentSfu });
+      await this.doJoin({ ...this.joinCallData, migrating_from: currentSfu });
     } finally {
       // cleanup the migration_from field after the migration is complete or failed
       // as we don't want to keep dirty data in the join call data

package/src/StreamSfuClient.ts

@@ -261,7 +261,10 @@ export class StreamSfuClient {
   };
 
   get isHealthy() {
-    return this.signalWs.readyState === WebSocket.OPEN;
+    return (
+      this.signalWs.readyState === WebSocket.OPEN &&
+      this.joinResponseTask.isResolved()
+    );
   }
 
   get joinTask() {
@@ -412,7 +415,10 @@ export class StreamSfuClient {
   ): Promise<JoinResponse> => {
     // wait for the signal web socket to be ready before sending "joinRequest"
     await this.signalReady();
-    if (this.joinResponseTask.isResolved || this.joinResponseTask.isRejected) {
+    if (
+      this.joinResponseTask.isResolved() ||
+      this.joinResponseTask.isRejected()
+    ) {
       // we need to lock the RPC requests until we receive a JoinResponse.
       // that's why we have this primitive lock mechanism.
       // the client starts with already initialized joinResponseTask,
@@ -424,7 +430,7 @@ export class StreamSfuClient {
     // be replaced with a new one in case a second join request is made
     const current = this.joinResponseTask;
 
-    let timeoutId: NodeJS.Timeout;
+    let timeoutId: NodeJS.Timeout | undefined = undefined;
     const unsubscribe = this.dispatcher.on('joinResponse', (joinResponse) => {
       this.logger('debug', 'Received joinResponse', joinResponse);
       clearTimeout(timeoutId);

package/src/StreamVideoClient.ts

@@ -259,11 +259,10 @@ export class StreamVideoClient {
       this.connectionConcurrencyTag,
       async () => {
         const client = this.streamClient;
-        const {
-          maxConnectUserRetries = 5,
-          onConnectUserError,
-          persistUserOnConnectionFailure,
-        } = client.options;
+        const { onConnectUserError, persistUserOnConnectionFailure } =
+          client.options;
+        let { maxConnectUserRetries = 5 } = client.options;
+        maxConnectUserRetries = Math.max(maxConnectUserRetries, 1);
 
         const errorQueue: Error[] = [];
         for (let attempt = 0; attempt < maxConnectUserRetries; attempt++) {

package/src/__tests__/Call.test.ts

@@ -105,7 +105,7 @@ it('keeps user handlers for SFU and coordinator events', async () => {
 
 it("doesn't break when joining and leaving the same instance in quick succession", async () => {
   const call = client.call('default', generateUUIDv4());
-  let states: CallingState[] = [];
+  const states: CallingState[] = [];
   call.state.callingState$.subscribe((state) => states.push(state));
   call.getOrCreate();
   call.leave();

package/src/coordinator/connection/client.ts

@@ -492,7 +492,7 @@ export class StreamClient {
       // we need to wait for presence of connection id before making requests
       try {
         await this.connectionIdPromise;
-      } catch (e) {
+      } catch {
         // in case connection id was rejected
         // reconnection maybe in progress
         // we can wait for healthy connection to resolve, which rejects when 15s timeout is reached
@@ -529,7 +529,6 @@ export class StreamClient {
       this._logApiResponse<T>(type, url, response);
       this.consecutiveFailures = 0;
       return this.handleResponse(response);
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
     } catch (e: any /**TODO: generalize error types  */) {
       e.client_request_id = requestConfig.headers?.['x-client-request-id'];
       this.consecutiveFailures += 1;
@@ -549,7 +548,7 @@ export class StreamClient {
         return this.handleResponse(e.response);
       } else {
         this._logApiError(type, url, e);
-        // eslint-disable-next-line no-throw-literal
+
         throw e as AxiosError<APIErrorResponse>;
       }
     }

package/src/coordinator/connection/connection.ts

@@ -120,7 +120,7 @@ export class StableWSConnection {
       this.consecutiveFailures += 1;
 
       if (
-        // @ts-ignore
+        // @ts-expect-error type issue
         error.code === KnownCodes.TOKEN_EXPIRED &&
         !this.client.tokenManager.isStatic()
       ) {
@@ -129,18 +129,18 @@ export class StableWSConnection {
         );
         this._reconnect({ refreshToken: true });
       } else {
-        // @ts-ignore
+        // @ts-expect-error type issue
         if (!error.isWSFailure) {
           // API rejected the connection and we should not retry
           throw new Error(
             JSON.stringify({
-              // @ts-ignore
+              // @ts-expect-error type issue
               code: error.code,
-              // @ts-ignore
+              // @ts-expect-error type issue
               StatusCode: error.StatusCode,
-              // @ts-ignore
+              // @ts-expect-error type issue
               message: error.message,
-              // @ts-ignore
+              // @ts-expect-error type issue
               isWSFailure: error.isWSFailure,
             }),
           );
@@ -288,7 +288,7 @@ export class StableWSConnection {
       this._log(`_connect() - waiting for token`);
       await this.client.tokenManager.tokenReady();
       isTokenReady = true;
-    } catch (e) {
+    } catch {
       // token provider has failed before, so try again
     }
 
@@ -323,7 +323,7 @@ export class StableWSConnection {
     } catch (err) {
       this.client._setupConnectionIdPromise();
       this.isConnecting = false;
-      // @ts-ignore
+      // @ts-expect-error type issue
       this._log(`_connect() - Error - `, err);
       this.client.rejectConnectionId?.(err);
       throw err;
@@ -543,13 +543,13 @@ export class StableWSConnection {
         `WS connection reject with error ${event.reason}`,
       );
 
-      // @ts-expect-error
+      // @ts-expect-error type issue
       error.reason = event.reason;
-      // @ts-expect-error
+      // @ts-expect-error type issue
       error.code = event.code;
-      // @ts-expect-error
+      // @ts-expect-error type issue
       error.wasClean = event.wasClean;
-      // @ts-expect-error
+      // @ts-expect-error type issue
       error.target = event.target;
 
       this.rejectConnectionOpen?.(error);
@@ -665,7 +665,7 @@ export class StableWSConnection {
 
     try {
       this?.ws?.close();
-    } catch (e) {
+    } catch {
       // we don't care
     }
   }
@@ -704,7 +704,7 @@ export class StableWSConnection {
       // try to send on the connection
       try {
         this.ws?.send(JSON.stringify(data));
-      } catch (e) {
+      } catch {
         // error will already be detected elsewhere
       }
     }, this.pingInterval);

package/src/coordinator/connection/signing.ts

@@ -32,7 +32,7 @@ const decodeBase64 = (s: string): string => {
     b = (b << 6) + c;
     l += 6;
     while (l >= 8) {
-      ((a = (b >>> (l -= 8)) & 0xff) || x < L - 2) && (r += w(a));
+      if ((a = (b >>> (l -= 8)) & 0xff) || x < L - 2) r += w(a);
     }
   }
   return r;

package/src/devices/BrowserPermission.ts

@@ -23,7 +23,7 @@ export class BrowserPermission {
     const signal = this.disposeController.signal;
 
     this.ready = (async () => {
-      const assumeGranted = (error?: unknown) => {
+      const assumeGranted = () => {
         this.setState('prompt');
       };
 
@@ -43,7 +43,8 @@ export class BrowserPermission {
           });
         }
       } catch (err) {
-        assumeGranted(err);
+        this.logger('debug', 'Failed to query permission status', err);
+        assumeGranted();
       }
     })();
   }

package/src/devices/MicrophoneManager.ts

@@ -250,7 +250,7 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
       } else {
         // Need to start a new stream that's not connected to publisher
         const stream = await this.getStream({
-          deviceId,
+          deviceId: { exact: deviceId },
         });
         this.soundDetectorCleanup = createSoundDetector(stream, (event) => {
           this.state.setSpeakingWhileMuted(event.isSoundDetected);

package/src/devices/ScreenShareManager.ts

@@ -88,10 +88,8 @@ export class ScreenShareManager extends InputMediaDeviceManager<
 
   /**
    * Overrides the default `select` method to throw an error.
-   *
-   * @param deviceId ignored.
    */
-  async select(deviceId: string | undefined): Promise<void> {
+  async select(): Promise<void> {
     throw new Error('This method is not supported in for Screen Share');
   }
 }

package/src/devices/__tests__/InputMediaDeviceManager.test.ts

@@ -309,7 +309,7 @@ describe('InputMediaDeviceManager.test', () => {
     const device = mockVideoDevices[0];
     await manager.select(device.deviceId);
 
-    //@ts-expect-error
+    // @ts-expect-error - private method
     vi.spyOn(manager, 'applySettingsToStream');
 
     emitDeviceIds([

package/src/devices/__tests__/MicrophoneManager.test.ts

@@ -152,7 +152,7 @@ describe('MicrophoneManager', () => {
   describe('Speaking While Muted', () => {
     it(`should start sound detection if mic is disabled`, async () => {
       await manager.enable();
-      // @ts-expect-error
+      // @ts-expect-error private api
       vi.spyOn(manager, 'startSpeakingWhileMutedDetection');
       await manager.disable();
 
@@ -171,7 +171,7 @@ describe('MicrophoneManager', () => {
     it('should update speaking while muted state', async () => {
       const mock = createSoundDetector as Mock;
       let handler: SoundStateChangeHandler;
-      let prevMockImplementation = mock.getMockImplementation();
+      const prevMockImplementation = mock.getMockImplementation();
       mock.mockImplementation((_: MediaStream, h: SoundStateChangeHandler) => {
         handler = h;
       });
@@ -197,7 +197,7 @@ describe('MicrophoneManager', () => {
       await manager.enable();
       await manager.disable();
 
-      // @ts-expect-error
+      // @ts-expect-error private api
       vi.spyOn(manager, 'stopSpeakingWhileMutedDetection');
       manager['call'].state.setOwnCapabilities([]);
 
@@ -211,7 +211,7 @@ describe('MicrophoneManager', () => {
 
       manager['call'].state.setOwnCapabilities([]);
 
-      // @ts-expect-error
+      // @ts-expect-error private api
       vi.spyOn(manager, 'startSpeakingWhileMutedDetection');
       manager['call'].state.setOwnCapabilities([OwnCapability.SEND_AUDIO]);
 

package/src/devices/__tests__/MicrophoneManagerRN.test.ts

@@ -73,7 +73,7 @@ describe('MicrophoneManager React Native', () => {
 
   it(`should start sound detection if mic is disabled`, async () => {
     await manager.enable();
-    // @ts-expect-error
+    // @ts-expect-error - private method
     vi.spyOn(manager, 'startSpeakingWhileMutedDetection');
     await manager.disable();
 
@@ -109,7 +109,7 @@ describe('MicrophoneManager React Native', () => {
     await manager.enable();
     await manager.disable();
 
-    // @ts-expect-error
+    // @ts-expect-error private method
     vi.spyOn(manager, 'stopSpeakingWhileMutedDetection');
     manager['call'].state.setOwnCapabilities([]);
 
@@ -122,7 +122,7 @@ describe('MicrophoneManager React Native', () => {
 
     manager['call'].state.setOwnCapabilities([]);
 
-    // @ts-expect-error
+    // @ts-expect-error - private method
     vi.spyOn(manager, 'startSpeakingWhileMutedDetection');
     manager['call'].state.setOwnCapabilities([OwnCapability.SEND_AUDIO]);
 
@@ -139,7 +139,7 @@ describe('MicrophoneManager React Native', () => {
             enable = () => {};
             disable = () => {};
             dispose = () => Promise.resolve(undefined);
-            toFilter = () => async (ms: MediaStream) => ms;
+            toFilter = () => (ms: MediaStream) => ({ output: ms });
             on = () => () => {};
             off = () => {};
           })(),

package/src/devices/devices.ts

@@ -217,6 +217,7 @@ export const getAudioStream = async (
     return await getStream(constraints);
   } catch (error) {
     if (isNotFoundOrOverconstrainedError(error) && trackConstraints?.deviceId) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
       const { deviceId, ...relaxedConstraints } = trackConstraints;
       getLogger(['devices'])(
         'warn',
@@ -259,6 +260,7 @@ export const getVideoStream = async (
     return await getStream(constraints);
   } catch (error) {
     if (isNotFoundOrOverconstrainedError(error) && trackConstraints?.deviceId) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
       const { deviceId, ...relaxedConstraints } = trackConstraints;
       getLogger(['devices'])(
         'warn',
@@ -333,7 +335,7 @@ export const disposeOfMediaStream = (stream: MediaStream) => {
   });
   // @ts-expect-error release() is present in react-native-webrtc and must be called to dispose the stream
   if (typeof stream.release === 'function') {
-    // @ts-expect-error
+    // @ts-expect-error - release() is present in react-native-webrtc
     stream.release();
   }
 };