livekit-client 1.9.2 → 1.9.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "1.9.2",
+  "version": "1.9.4",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -36,11 +36,11 @@
     "deploy": "gh-pages -d example/dist",
     "format": "prettier --write src example/sample.ts",
     "format:check": "prettier --check src",
-    "release": "yarn build && changeset publish",
-    "downlevel-dts": "downlevel-dts ./dist/ ./dist/ts4.2 --to=4.2"
+    "release": "yarn build && yarn compat && changeset publish",
+    "downlevel-dts": "downlevel-dts ./dist/ ./dist/ts4.2 --to=4.2",
+    "compat": "eslint --no-eslintrc --config ./.eslintrc.dist.cjs ./dist/livekit-client.umd.js"
   },
   "dependencies": {
-    "async-await-queue": "^1.2.1",
     "events": "^3.3.0",
     "loglevel": "^1.8.0",
     "protobufjs": "^7.0.0",
@@ -51,8 +51,8 @@
     "webrtc-adapter": "^8.1.1"
   },
   "devDependencies": {
-    "@babel/core": "7.21.4",
-    "@babel/preset-env": "7.21.4",
+    "@babel/core": "7.21.8",
+    "@babel/preset-env": "7.21.5",
     "@changesets/cli": "2.26.1",
     "@livekit/changesets-changelog-github": "^0.0.4",
     "@rollup/plugin-babel": "6.0.3",
@@ -61,44 +61,31 @@
     "@rollup/plugin-node-resolve": "15.0.2",
     "@rollup/plugin-terser": "^0.4.0",
     "@trivago/prettier-plugin-sort-imports": "^4.1.1",
-    "@types/jest": "29.5.0",
+    "@types/events": "^3.0.0",
+    "@types/jest": "29.5.1",
     "@types/sdp-transform": "2.4.6",
     "@types/ua-parser-js": "0.7.36",
-    "@types/ws": "8.5.4",
-    "@typescript-eslint/eslint-plugin": "5.58.0",
-    "@typescript-eslint/parser": "5.58.0",
+    "@typescript-eslint/eslint-plugin": "5.59.2",
+    "@typescript-eslint/parser": "5.59.2",
     "downlevel-dts": "^0.11.0",
-    "eslint": "8.38.0",
+    "eslint": "8.39.0",
     "eslint-config-airbnb-typescript": "17.0.0",
     "eslint-config-prettier": "8.8.0",
+    "eslint-plugin-ecmascript-compat": "^3.0.0",
     "eslint-plugin-import": "2.27.5",
     "gh-pages": "5.0.0",
     "jest": "29.5.0",
     "prettier": "^2.8.8",
-    "rollup": "3.20.2",
+    "rollup": "3.21.3",
     "rollup-plugin-delete": "^2.0.0",
     "rollup-plugin-filesize": "10.0.0",
     "rollup-plugin-re": "1.0.7",
     "rollup-plugin-typescript2": "0.34.1",
     "ts-jest": "29.1.0",
-    "ts-proto": "1.146.0",
-    "typedoc": "0.24.1",
+    "ts-proto": "1.147.1",
+    "typedoc": "0.24.6",
     "typedoc-plugin-no-inherit": "1.4.0",
-    "typescript": "4.9.5",
-    "vite": "4.2.1"
-  },
-  "browserslist": [
-    "safari >= 11",
-    "ios_saf >= 11",
-    "chrome >= 64",
-    "and_chr >= 64",
-    "android >= 64",
-    "firefox >= 53",
-    "and_ff >= 53",
-    "edge >= 79",
-    "Opera >= 52",
-    "Samsung >= 9.2",
-    "not IE 11",
-    "not dead"
-  ]
+    "typescript": "5.0.4",
+    "vite": "4.3.4"
+  }
 }

package/src/AsyncQueue.test.ts

@@ -0,0 +1,99 @@
+import { AsyncQueue } from './AsyncQueue';
+import { sleep } from './room/utils';
+
+describe('asyncQueue', () => {
+  it('runs multiple tasks in order', async () => {
+    const queue = new AsyncQueue();
+    const tasksExecuted: number[] = [];
+
+    for (let i = 0; i < 5; i++) {
+      queue.run(async () => {
+        await sleep(50);
+        tasksExecuted.push(i);
+      });
+    }
+    await queue.flush();
+    expect(tasksExecuted).toMatchObject([0, 1, 2, 3, 4]);
+  });
+  it('runs tasks sequentially and not in parallel', async () => {
+    const queue = new AsyncQueue();
+    const results: number[] = [];
+    for (let i = 0; i < 5; i++) {
+      queue.run(async () => {
+        results.push(i);
+        await sleep(10);
+        results.push(i);
+      });
+    }
+    await queue.flush();
+    expect(results).toMatchObject([0, 0, 1, 1, 2, 2, 3, 3, 4, 4]);
+  });
+  it('continues executing tasks if one task throws an error', async () => {
+    const queue = new AsyncQueue();
+
+    let task1threw = false;
+    let task2Executed = false;
+
+    queue
+      .run(async () => {
+        await sleep(100);
+        throw Error('task 1 throws');
+      })
+      .catch(() => {
+        task1threw = true;
+      });
+
+    await queue
+      .run(async () => {
+        task2Executed = true;
+      })
+      .catch(() => {
+        fail('task 2 should not have thrown');
+      });
+
+    expect(task1threw).toBeTruthy();
+    expect(task2Executed).toBeTruthy();
+  });
+  it('returns the result of the task', async () => {
+    const queue = new AsyncQueue();
+
+    const result = await queue.run(async () => {
+      await sleep(10);
+      return 'result';
+    });
+
+    expect(result).toBe('result');
+  });
+  it('returns only when the enqueued task and all previous tasks have completed', async () => {
+    const queue = new AsyncQueue();
+    const tasksExecuted: number[] = [];
+    for (let i = 0; i < 10; i += 1) {
+      queue.run(async () => {
+        await sleep(10);
+        tasksExecuted.push(i);
+        return i;
+      });
+    }
+
+    const result = await queue.run(async () => {
+      await sleep(10);
+      tasksExecuted.push(999);
+      return 'result';
+    });
+
+    expect(result).toBe('result');
+    expect(tasksExecuted).toMatchObject([...new Array(10).fill(0).map((_, idx) => idx), 999]);
+  });
+  it('can handle queue sizes of up to 10_000 tasks', async () => {
+    const queue = new AsyncQueue();
+    const tasksExecuted: number[] = [];
+
+    for (let i = 0; i < 10_000; i++) {
+      queue.run(async () => {
+        tasksExecuted.push(i);
+      });
+    }
+    await queue.flush();
+    expect(tasksExecuted).toMatchObject(new Array(10_000).fill(0).map((_, idx) => idx));
+  });
+});

package/src/AsyncQueue.ts

@@ -0,0 +1,57 @@
+import { Mutex } from './room/utils';
+
+type QueueTask<T> = () => PromiseLike<T>;
+
+enum QueueTaskStatus {
+  'WAITING',
+  'RUNNING',
+  'COMPLETED',
+}
+
+type QueueTaskInfo = {
+  id: number;
+  enqueuedAt: number;
+  executedAt?: number;
+  status: QueueTaskStatus;
+};
+
+export class AsyncQueue {
+  private pendingTasks: Map<number, QueueTaskInfo>;
+
+  private taskMutex: Mutex;
+
+  private nextTaskIndex: number;
+
+  constructor() {
+    this.pendingTasks = new Map();
+    this.taskMutex = new Mutex();
+    this.nextTaskIndex = 0;
+  }
+
+  async run<T>(task: QueueTask<T>) {
+    const taskInfo: QueueTaskInfo = {
+      id: this.nextTaskIndex++,
+      enqueuedAt: Date.now(),
+      status: QueueTaskStatus.WAITING,
+    };
+    this.pendingTasks.set(taskInfo.id, taskInfo);
+    const unlock = await this.taskMutex.lock();
+    try {
+      taskInfo.executedAt = Date.now();
+      taskInfo.status = QueueTaskStatus.RUNNING;
+      return await task();
+    } finally {
+      taskInfo.status = QueueTaskStatus.COMPLETED;
+      this.pendingTasks.delete(taskInfo.id);
+      unlock();
+    }
+  }
+
+  async flush() {
+    return this.run(async () => {});
+  }
+
+  snapshot() {
+    return Array.from(this.pendingTasks.values());
+  }
+}

package/src/api/SignalClient.ts

@@ -1,5 +1,5 @@
-import Queue from 'async-await-queue';
 import 'webrtc-adapter';
+import { AsyncQueue } from '../AsyncQueue';
 import log from '../logger';
 import {
   ClientInfo,
@@ -76,7 +76,7 @@ const passThroughQueueSignals: Array<SignalKind> = [
 ];
 
 function canPassThroughQueue(req: SignalMessage): boolean {
-  const canPass = passThroughQueueSignals.includes(req!.$case);
+  const canPass = passThroughQueueSignals.indexOf(req!.$case) >= 0;
   log.trace('request allowed to bypass queue:', { canPass, req });
   return canPass;
 }
@@ -87,7 +87,7 @@ export class SignalClient {
 
   isReconnecting: boolean;
 
-  requestQueue: Queue;
+  requestQueue: AsyncQueue;
 
   queuedRequests: Array<() => Promise<void>>;
 
@@ -154,7 +154,7 @@ export class SignalClient {
     this.isConnected = false;
     this.isReconnecting = false;
     this.useJSON = useJSON;
-    this.requestQueue = new Queue();
+    this.requestQueue = new AsyncQueue();
     this.queuedRequests = [];
     this.closingLock = new Mutex();
   }
@@ -321,6 +321,7 @@ export class SignalClient {
       };
 
       this.ws.onclose = (ev: CloseEvent) => {
+        log.warn(`websocket closed`, { ev });
         this.handleOnClose(ev.reason);
       };
     });
@@ -344,12 +345,14 @@ export class SignalClient {
           }
         });
 
-        this.ws.close();
-        // 250ms grace period for ws to close gracefully
-        await Promise.race([closePromise, sleep(250)]);
+        if (this.ws.readyState < this.ws.CLOSING) {
+          this.ws.close();
+          // 250ms grace period for ws to close gracefully
+          await Promise.race([closePromise, sleep(250)]);
+        }
+        this.ws = undefined;
+        this.clearPingInterval();
       }
-      this.ws = undefined;
-      this.clearPingInterval();
     } finally {
       unlock();
     }
@@ -611,17 +614,13 @@ export class SignalClient {
     this.isReconnecting = false;
   }
 
-  private handleOnClose(reason: string) {
+  private async handleOnClose(reason: string) {
     if (!this.isConnected) return;
-    this.clearPingInterval();
-    this.clearPingTimeout();
-
+    await this.close();
     log.debug(`websocket connection closed: ${reason}`);
-    this.isConnected = false;
     if (this.onClose) {
       this.onClose(reason);
     }
-    this.ws = undefined;
   }
 
   private handleWSError(ev: Event) {

package/src/connectionHelper/ConnectionCheck.ts

@@ -1,6 +1,7 @@
-import EventEmitter from 'events';
+import { EventEmitter } from 'events';
 import type TypedEmitter from 'typed-emitter';
-import { CheckInfo, CheckStatus, Checker, InstantiableCheck } from './checks/Checker';
+import { CheckStatus, Checker } from './checks/Checker';
+import type { CheckInfo, InstantiableCheck } from './checks/Checker';
 import { PublishAudioCheck } from './checks/publishAudio';
 import { PublishVideoCheck } from './checks/publishVideo';
 import { ReconnectCheck } from './checks/reconnect';

package/src/index.ts

@@ -14,11 +14,12 @@ import LocalVideoTrack from './room/track/LocalVideoTrack';
 import RemoteAudioTrack from './room/track/RemoteAudioTrack';
 import RemoteTrack from './room/track/RemoteTrack';
 import RemoteTrackPublication from './room/track/RemoteTrackPublication';
-import RemoteVideoTrack, { type ElementInfo } from './room/track/RemoteVideoTrack';
+import type { ElementInfo } from './room/track/RemoteVideoTrack';
+import RemoteVideoTrack from './room/track/RemoteVideoTrack';
 import { TrackPublication } from './room/track/TrackPublication';
 import type { LiveKitReactNativeInfo } from './room/types';
+import type { AudioAnalyserOptions } from './room/utils';
 import {
-  type AudioAnalyserOptions,
   createAudioAnalyser,
   getEmptyAudioStreamTrack,
   getEmptyVideoStreamTrack,
@@ -26,18 +27,19 @@ import {
   supportsAV1,
   supportsAdaptiveStream,
   supportsDynacast,
+  supportsVP9,
 } from './room/utils';
 
+export * from './connectionHelper/ConnectionCheck';
 export * from './options';
 export * from './room/errors';
 export * from './room/events';
-export type { DataPublishOptions, SimulationScenario } from './room/types';
+export * from './room/track/Track';
 export * from './room/track/create';
 export * from './room/track/options';
-export * from './room/track/Track';
 export * from './room/track/types';
+export type { DataPublishOptions, SimulationScenario } from './room/types';
 export * from './version';
-export * from './connectionHelper/ConnectionCheck';
 export {
   setLogLevel,
   setLogExtension,
@@ -47,8 +49,8 @@ export {
   supportsAdaptiveStream,
   supportsDynacast,
   supportsAV1,
+  supportsVP9,
   createAudioAnalyser,
-  AudioAnalyserOptions,
   LogLevel,
   Room,
   ConnectionState,
@@ -66,12 +68,15 @@ export {
   RemoteAudioTrack,
   RemoteVideoTrack,
   RemoteTrackPublication,
-  ParticipantTrackPermission,
   TrackPublication,
   VideoQuality,
   ConnectionQuality,
-  ElementInfo,
   DefaultReconnectPolicy,
   CriticalTimers,
+};
+export type {
+  ElementInfo,
+  ParticipantTrackPermission,
+  AudioAnalyserOptions,
   LiveKitReactNativeInfo,
 };

package/src/room/PCTransport.ts

@@ -1,9 +1,10 @@
-import EventEmitter from 'events';
-import { MediaDescription, parse, write } from 'sdp-transform';
+import { EventEmitter } from 'events';
+import { parse, write } from 'sdp-transform';
+import type { MediaDescription } from 'sdp-transform';
 import { debounce } from 'ts-debounce';
 import log from '../logger';
 import { NegotiationError } from './errors';
-import { ddExtensionURI, isSVCCodec } from './utils';
+import { ddExtensionURI, isChromiumBased, isSVCCodec } from './utils';
 
 /** @internal */
 interface TrackBitrateInfo {
@@ -35,9 +36,12 @@ export default class PCTransport extends EventEmitter {
 
   onOffer?: (offer: RTCSessionDescriptionInit) => void;
 
-  constructor(config?: RTCConfiguration) {
+  constructor(config?: RTCConfiguration, mediaConstraints: Record<string, unknown> = {}) {
     super();
-    this.pc = new RTCPeerConnection(config);
+    this.pc = isChromiumBased()
+      ? // @ts-expect-error chrome allows additional media constraints to be passed into the RTCPeerConnection constructor
+        new RTCPeerConnection(config, mediaConstraints)
+      : new RTCPeerConnection(config);
   }
 
   get isICEConnected(): boolean {
@@ -289,7 +293,7 @@ function ensureVideoDDExtensionForSVC(
     payloads?: string | undefined;
   } & MediaDescription,
 ) {
-  const codec = media.rtp.at(0)?.codec?.toLowerCase();
+  const codec = media.rtp[0]?.codec?.toLowerCase();
   if (!isSVCCodec(codec)) {
     return;
   }

package/src/room/RTCEngine.ts

@@ -1,6 +1,7 @@
 import { EventEmitter } from 'events';
 import type TypedEventEmitter from 'typed-emitter';
-import { SignalClient, SignalOptions } from '../api/SignalClient';
+import { SignalClient } from '../api/SignalClient';
+import type { SignalOptions } from '../api/SignalClient';
 import log from '../logger';
 import type { InternalRoomOptions } from '../options';
 import {
@@ -77,6 +78,11 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   fullReconnectOnNext: boolean = false;
 
+  /**
+   * @internal
+   */
+  latestJoinResponse?: JoinResponse;
+
   get isClosed() {
     return this._isClosed;
   }
@@ -171,6 +177,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       this.joinAttempts += 1;
       const joinResponse = await this.client.join(url, token, opts, abortSignal);
       this._isClosed = false;
+      this.latestJoinResponse = joinResponse;
 
       this.subscriberPrimary = joinResponse.subscriberPrimary;
       if (!this.publisher) {
@@ -307,8 +314,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     this.participantSid = joinResponse.participant?.sid;
 
     const rtcConfig = this.makeRTCConfiguration(joinResponse);
-
-    this.publisher = new PCTransport(rtcConfig);
+    const googConstraints = { optional: [{ googDscp: true }] };
+    this.publisher = new PCTransport(rtcConfig, googConstraints);
     this.subscriber = new PCTransport(rtcConfig);
 
     this.emit(EngineEvent.TransportsCreated, this.publisher, this.subscriber);

package/src/room/defaults.ts

@@ -1,16 +1,18 @@
 import type { InternalRoomConnectOptions, InternalRoomOptions } from '../options';
 import DefaultReconnectPolicy from './DefaultReconnectPolicy';
-import {
+import { AudioPresets, ScreenSharePresets, VideoPresets } from './track/options';
+import type {
   AudioCaptureOptions,
-  AudioPresets,
-  ScreenSharePresets,
   TrackPublishDefaults,
   VideoCaptureOptions,
-  VideoPresets,
 } from './track/options';
 
 export const publishDefaults: TrackPublishDefaults = {
+  /**
+   * @deprecated
+   */
   audioBitrate: AudioPresets.music.maxBitrate,
+  audioPreset: AudioPresets.music,
   dtx: true,
   red: true,
   forceStereo: false,

package/src/room/participant/LocalParticipant.ts

@@ -18,22 +18,21 @@ import LocalTrack from '../track/LocalTrack';
 import LocalTrackPublication from '../track/LocalTrackPublication';
 import LocalVideoTrack, { videoLayersFromEncodings } from '../track/LocalVideoTrack';
 import { Track } from '../track/Track';
-import {
+import { ScreenSharePresets, isBackupCodec, isCodecEqual } from '../track/options';
+import type {
   AudioCaptureOptions,
   BackupVideoCodec,
   CreateLocalTracksOptions,
   ScreenShareCaptureOptions,
-  ScreenSharePresets,
   TrackPublishOptions,
   VideoCaptureOptions,
-  isBackupCodec,
-  isCodecEqual,
 } from '../track/options';
 import { constraintsForOptions, mergeDefaultOptions } from '../track/utils';
 import type { DataPublishOptions } from '../types';
 import { Future, isFireFox, isSVCCodec, isSafari, isWeb, supportsAV1, supportsVP9 } from '../utils';
 import Participant from './Participant';
-import { ParticipantTrackPermission, trackPermissionToProto } from './ParticipantTrackPermission';
+import { trackPermissionToProto } from './ParticipantTrackPermission';
+import type { ParticipantTrackPermission } from './ParticipantTrackPermission';
 import RemoteParticipant from './RemoteParticipant';
 import {
   computeTrackBackupEncodings,
@@ -151,7 +150,7 @@ export default class LocalParticipant extends Participant {
 
   /**
    * Sets and updates the metadata of the local participant.
-   * Note: this requires `CanUpdateOwnMetadata` permission encoded in the token.
+   * Note: this requires `canUpdateOwnMetadata` permission encoded in the token.
    * @param metadata
    */
   setMetadata(metadata: string): void {
@@ -161,7 +160,7 @@ export default class LocalParticipant extends Participant {
 
   /**
    * Sets and updates the name of the local participant.
-   * Note: this requires `CanUpdateOwnMetadata` permission encoded in the token.
+   * Note: this requires `canUpdateOwnMetadata` permission encoded in the token.
    * @param metadata
    */
   setName(name: string): void {
@@ -651,10 +650,12 @@ export default class LocalParticipant extends Participant {
         opts,
       );
       req.layers = videoLayersFromEncodings(req.width, req.height, simEncodings ?? encodings);
-    } else if (track.kind === Track.Kind.Audio && opts.audioBitrate) {
+    } else if (track.kind === Track.Kind.Audio) {
       encodings = [
         {
-          maxBitrate: opts.audioBitrate,
+          maxBitrate: opts.audioPreset?.maxBitrate ?? opts.audioBitrate,
+          priority: opts.audioPreset?.priority ?? 'high',
+          networkPriority: opts.audioPreset?.priority ?? 'high',
         },
       ];
     }

package/src/room/participant/RemoteParticipant.ts

@@ -11,7 +11,8 @@ import { Track } from '../track/Track';
 import type { TrackPublication } from '../track/TrackPublication';
 import type { AudioOutputOptions } from '../track/options';
 import type { AdaptiveStreamSettings } from '../track/types';
-import Participant, { ParticipantEventCallbacks } from './Participant';
+import Participant from './Participant';
+import type { ParticipantEventCallbacks } from './Participant';
 
 export default class RemoteParticipant extends Participant {
   audioTracks: Map<string, RemoteTrackPublication>;

package/src/room/participant/publishUtils.ts

@@ -3,15 +3,12 @@ import { TrackInvalidError } from '../errors';
 import LocalAudioTrack from '../track/LocalAudioTrack';
 import LocalVideoTrack from '../track/LocalVideoTrack';
 import { Track } from '../track/Track';
-import {
+import { ScreenSharePresets, VideoPreset, VideoPresets, VideoPresets43 } from '../track/options';
+import type {
   BackupVideoCodec,
-  ScreenSharePresets,
   TrackPublishOptions,
   VideoCodec,
   VideoEncoding,
-  VideoPreset,
-  VideoPresets,
-  VideoPresets43,
 } from '../track/options';
 import { isSVCCodec } from '../utils';
 
@@ -61,6 +58,7 @@ export const computeDefaultScreenShareSimulcastPresets = (fromPreset: VideoPrese
           ),
         ),
         t.fps,
+        fromPreset.encoding.priority,
       ),
   );
 };
@@ -317,6 +315,10 @@ function encodingsFromPresets(
     if (preset.encoding.maxFramerate) {
       encoding.maxFramerate = preset.encoding.maxFramerate;
     }
+    if (preset.encoding.priority) {
+      encoding.priority = preset.encoding.priority;
+      encoding.networkPriority = preset.encoding.priority;
+    }
     encodings.push(encoding);
   });
   return encodings;

package/src/room/track/LocalAudioTrack.ts

@@ -1,6 +1,7 @@
 import log from '../../logger';
 import { TrackEvent } from '../events';
-import { AudioSenderStats, computeBitrate, monitorFrequency } from '../stats';
+import { computeBitrate, monitorFrequency } from '../stats';
+import type { AudioSenderStats } from '../stats';
 import { isWeb } from '../utils';
 import LocalTrack from './LocalTrack';
 import { Track } from './Track';

package/src/room/track/LocalVideoTrack.ts

@@ -2,7 +2,8 @@ import type { SignalClient } from '../../api/SignalClient';
 import log from '../../logger';
 import { VideoLayer, VideoQuality } from '../../proto/livekit_models';
 import type { SubscribedCodec, SubscribedQuality } from '../../proto/livekit_rtc';
-import { VideoSenderStats, computeBitrate, monitorFrequency } from '../stats';
+import { computeBitrate, monitorFrequency } from '../stats';
+import type { VideoSenderStats } from '../stats';
 import { Mutex, isFireFox, isMobile, isWeb } from '../utils';
 import LocalTrack from './LocalTrack';
 import { Track } from './Track';
@@ -153,7 +154,7 @@ export default class LocalVideoTrack extends LocalTrack {
           qualityLimitationResolutionChanges: v.qualityLimitationResolutionChanges,
         };
 
-        // locate the appropriate remote-inbound-rtp item
+        // locate the appropriate remote-inbound-rtp item
         const r = stats.get(v.remoteId);
         if (r) {
           vs.jitter = r.jitter;

package/src/room/track/RemoteAudioTrack.ts

@@ -1,6 +1,7 @@
 import log from '../../logger';
 import { TrackEvent } from '../events';
-import { AudioReceiverStats, computeBitrate } from '../stats';
+import { computeBitrate } from '../stats';
+import type { AudioReceiverStats } from '../stats';
 import { supportsSetSinkId } from '../utils';
 import RemoteTrack from './RemoteTrack';
 import { Track } from './Track';

package/src/room/track/RemoteVideoTrack.ts

@@ -1,15 +1,11 @@
 import { debounce } from 'ts-debounce';
 import log from '../../logger';
 import { TrackEvent } from '../events';
-import { VideoReceiverStats, computeBitrate } from '../stats';
+import { computeBitrate } from '../stats';
+import type { VideoReceiverStats } from '../stats';
 import CriticalTimers from '../timers';
-import {
-  ObservableMediaElement,
-  getDevicePixelRatio,
-  getIntersectionObserver,
-  getResizeObserver,
-  isWeb,
-} from '../utils';
+import { getDevicePixelRatio, getIntersectionObserver, getResizeObserver, isWeb } from '../utils';
+import type { ObservableMediaElement } from '../utils';
 import RemoteTrack from './RemoteTrack';
 import { Track, attachToElement, detachTrack } from './Track';
 import type { AdaptiveStreamSettings } from './types';