livekit-client 1.5.0 → 1.6.0

package/dist/ts4.2/src/room/types.d.ts

@@ -0,0 +1,13 @@
+export type SimulationOptions = {
+    publish?: {
+        audio?: boolean;
+        video?: boolean;
+    };
+    participants?: {
+        count?: number;
+        aspectRatios?: Array<number>;
+        audio?: boolean;
+        video?: boolean;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/ts4.2/src/room/utils.d.ts

@@ -1,4 +1,6 @@
 import { ClientInfo } from '../proto/livekit_models';
+import type LocalAudioTrack from './track/LocalAudioTrack';
+import type RemoteAudioTrack from './track/RemoteAudioTrack';
 export declare function unpackStreamId(packed: string): string[];
 export declare function sleep(duration: number): Promise<void>;
 /** @internal */
@@ -24,6 +26,7 @@ export interface ObservableMediaElement extends HTMLMediaElement {
 }
 export declare function getClientInfo(): ClientInfo;
 export declare function getEmptyVideoStreamTrack(): MediaStreamTrack;
+export declare function createDummyVideoStreamTrack(width?: number, height?: number, enabled?: boolean, paintContent?: boolean): MediaStreamTrack;
 export declare function getEmptyAudioStreamTrack(): MediaStreamTrack;
 export declare class Future<T> {
     promise: Promise<T>;
@@ -32,4 +35,45 @@ export declare class Future<T> {
     onFinally?: () => void;
     constructor(futureBase?: (resolve: (arg: T) => void, reject: (e: any) => void) => void, onFinally?: () => void);
 }
+export type AudioAnalyserOptions = {
+    /**
+     * If set to true, the analyser will use a cloned version of the underlying mediastreamtrack, which won't be impacted by muting the track.
+     * Useful for local tracks when implementing things like "seems like you're muted, but trying to speak".
+     * Defaults to false
+     */
+    cloneTrack?: boolean;
+    /**
+     * see https://developer.mozilla.org/en-US/docs/Web/API/AnalyserNode/fftSize
+     */
+    fftSize?: number;
+    /**
+     * see https://developer.mozilla.org/en-US/docs/Web/API/AnalyserNode/smoothingTimeConstant
+     */
+    smoothingTimeConstant?: number;
+    /**
+     * see https://developer.mozilla.org/en-US/docs/Web/API/AnalyserNode/minDecibels
+     */
+    minDecibels?: number;
+    /**
+     * see https://developer.mozilla.org/en-US/docs/Web/API/AnalyserNode/maxDecibels
+     */
+    maxDecibels?: number;
+};
+/**
+ * Creates and returns an analyser web audio node that is attached to the provided track.
+ * Additionally returns a convenience method `calculateVolume` to perform instant volume readings on that track.
+ * Call the returned `cleanup` function to close the audioContext that has been created for the instance of this helper
+ */
+export declare function createAudioAnalyser(track: LocalAudioTrack | RemoteAudioTrack, options?: AudioAnalyserOptions): {
+    calculateVolume: () => number;
+    analyser: AnalyserNode;
+    cleanup: () => void;
+};
+export declare class Mutex {
+    private _locking;
+    private _locks;
+    constructor();
+    isLocked(): boolean;
+    lock(): Promise<() => void>;
+}
 //# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -26,7 +26,7 @@
   "author": "David Zhao <david@davidzhao.com>",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "rollup --config && yarn downlevel-dts",
+    "build": "rollup --config --bundleConfigAsCjs && yarn downlevel-dts",
     "build:watch": "rollup --watch --config rollup.config.js",
     "build-docs": "typedoc",
     "proto": "protoc --plugin=node_modules/ts-proto/protoc-gen-ts_proto --ts_proto_opt=esModuleInterop=true --ts_proto_out=./src/proto --ts_proto_opt=outputClientImpl=false,useOptionals=messages,oneof=unions -I./protocol ./protocol/livekit_rtc.proto ./protocol/livekit_models.proto",
@@ -51,40 +51,40 @@
     "webrtc-adapter": "^8.1.1"
   },
   "devDependencies": {
-    "@babel/core": "7.19.3",
-    "@babel/preset-env": "7.19.3",
+    "@babel/core": "7.20.5",
+    "@babel/preset-env": "7.20.2",
     "@changesets/changelog-github": "0.4.7",
-    "@changesets/cli": "2.25.0",
-    "@rollup/plugin-babel": "5.3.1",
-    "@rollup/plugin-commonjs": "22.0.2",
-    "@rollup/plugin-json": "4.1.0",
-    "@rollup/plugin-node-resolve": "14.1.0",
-    "@types/jest": "29.1.1",
+    "@changesets/cli": "2.25.2",
+    "@rollup/plugin-babel": "6.0.3",
+    "@rollup/plugin-commonjs": "23.0.4",
+    "@rollup/plugin-json": "5.0.2",
+    "@rollup/plugin-node-resolve": "15.0.1",
+    "@types/jest": "29.2.4",
     "@types/sdp-transform": "2.4.5",
     "@types/ua-parser-js": "0.7.36",
     "@types/ws": "8.5.3",
-    "@typescript-eslint/eslint-plugin": "5.38.1",
-    "@typescript-eslint/parser": "5.38.1",
+    "@typescript-eslint/eslint-plugin": "5.46.0",
+    "@typescript-eslint/parser": "5.46.0",
     "downlevel-dts": "^0.11.0",
-    "eslint": "8.24.0",
+    "eslint": "8.29.0",
     "eslint-config-airbnb-typescript": "17.0.0",
     "eslint-config-prettier": "8.5.0",
     "eslint-plugin-import": "2.26.0",
     "gh-pages": "4.0.0",
-    "jest": "29.1.2",
-    "prettier": "2.7.1",
-    "rollup": "2.79.1",
+    "jest": "29.3.1",
+    "prettier": "2.8.1",
+    "rollup": "3.7.0",
     "rollup-plugin-delete": "^2.0.0",
     "rollup-plugin-filesize": "9.1.2",
     "rollup-plugin-re": "1.0.7",
     "rollup-plugin-terser": "7.0.2",
-    "rollup-plugin-typescript2": "0.34.0",
+    "rollup-plugin-typescript2": "0.34.1",
     "ts-jest": "29.0.3",
-    "ts-proto": "1.126.1",
-    "typedoc": "0.23.15",
+    "ts-proto": "1.135.0",
+    "typedoc": "0.23.21",
     "typedoc-plugin-no-inherit": "1.4.0",
-    "typescript": "4.8.4",
-    "vite": "3.1.8"
+    "typescript": "4.9.4",
+    "vite": "3.2.5"
   },
   "browserslist": [
     "safari >= 11",

package/src/api/SignalClient.ts

@@ -30,7 +30,7 @@ import {
   UpdateTrackSettings,
 } from '../proto/livekit_rtc';
 import { ConnectionError, ConnectionErrorReason } from '../room/errors';
-import { getClientInfo, sleep } from '../room/utils';
+import { getClientInfo, Mutex, sleep } from '../room/utils';
 
 // internal options
 interface ConnectOpts {
@@ -139,12 +139,15 @@ export class SignalClient {
 
   private pingInterval: ReturnType<typeof setInterval> | undefined;
 
+  private closingLock: Mutex;
+
   constructor(useJSON: boolean = false) {
     this.isConnected = false;
     this.isReconnecting = false;
     this.useJSON = useJSON;
     this.requestQueue = new Queue();
     this.queuedRequests = [];
+    this.closingLock = new Mutex();
   }
 
   async join(
@@ -190,9 +193,9 @@ export class SignalClient {
     const clientInfo = getClientInfo();
     const params = createConnectionParams(token, clientInfo, opts);
 
-    return new Promise<JoinResponse | void>((resolve, reject) => {
-      const abortHandler = () => {
-        this.close();
+    return new Promise<JoinResponse | void>(async (resolve, reject) => {
+      const abortHandler = async () => {
+        await this.close();
         reject(new ConnectionError('room connection has been cancelled'));
       };
 
@@ -202,7 +205,7 @@ export class SignalClient {
       abortSignal?.addEventListener('abort', abortHandler);
       log.debug(`connecting to ${url + params}`);
       if (this.ws) {
-        this.close();
+        await this.close();
       }
       this.ws = new WebSocket(url + params);
       this.ws.binaryType = 'arraybuffer';
@@ -277,7 +280,11 @@ export class SignalClient {
             }
             resolve(resp.message.join);
           } else {
-            reject(new ConnectionError('did not receive join response'));
+            reject(
+              new ConnectionError(
+                `did not receive join response, got ${resp.message?.$case} instead`,
+              ),
+            );
           }
           return;
         }
@@ -301,16 +308,33 @@ export class SignalClient {
     });
   }
 
-  close() {
-    this.isConnected = false;
-    if (this.ws) {
-      this.ws.onclose = null;
-      this.ws.onmessage = null;
-      this.ws.onopen = null;
-      this.ws.close();
+  async close() {
+    const unlock = await this.closingLock.lock();
+    try {
+      this.isConnected = false;
+      if (this.ws) {
+        this.ws.onclose = null;
+        this.ws.onmessage = null;
+        this.ws.onopen = null;
+
+        // calling `ws.close()` only starts the closing handshake (CLOSING state), prefer to wait until state is actually CLOSED
+        const closePromise = new Promise((resolve) => {
+          if (this.ws) {
+            this.ws.onclose = resolve;
+          } else {
+            resolve(true);
+          }
+        });
+
+        this.ws.close();
+        // 250ms grace period for ws to close gracefully
+        await Promise.race([closePromise, sleep(250)]);
+      }
+      this.ws = undefined;
+      this.clearPingInterval();
+    } finally {
+      unlock();
     }
-    this.ws = undefined;
-    this.clearPingInterval();
   }
 
   // initial offer after joining
@@ -441,7 +465,7 @@ export class SignalClient {
     if (this.signalLatency) {
       await sleep(this.signalLatency);
     }
-    if (!this.ws || this.ws.readyState < this.ws.OPEN) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN) {
       log.error(`cannot send signal request before connected, type: ${message?.$case}`);
       return;
     }

package/src/connectionHelper/checks/turn.ts

@@ -37,7 +37,7 @@ export class TURNCheck extends Checker {
     } else if (hasTURN && !hasTLS) {
       this.appendWarning('TURN is configured server side, but TURN/TLS is unavailable.');
     }
-    signalClient.close();
+    await signalClient.close();
     if (this.connectOptions?.rtcConfig?.iceServers || hasTURN) {
       await this.room!.connect(this.url, this.token, {
         rtcConfig: {

package/src/connectionHelper/checks/websocket.ts

@@ -17,6 +17,6 @@ export class WebSocketCheck extends Checker {
       maxRetries: 0,
     });
     this.appendMessage(`Connected to server, version ${joinRes.serverVersion}.`);
-    signalClient.close();
+    await signalClient.close();
   }
 }

package/src/index.ts

@@ -23,8 +23,11 @@ import {
   supportsAdaptiveStream,
   supportsAV1,
   supportsDynacast,
+  createAudioAnalyser,
 } from './room/utils';
 
+import type { AudioAnalyserOptions } from './room/utils';
+
 export * from './options';
 export * from './room/errors';
 export * from './room/events';
@@ -43,6 +46,8 @@ export {
   supportsAdaptiveStream,
   supportsDynacast,
   supportsAV1,
+  createAudioAnalyser,
+  AudioAnalyserOptions,
   LogLevel,
   Room,
   ConnectionState,

package/src/options.ts

@@ -7,6 +7,10 @@ import type {
 } from './room/track/options';
 import type { AdaptiveStreamSettings } from './room/track/types';
 
+export interface WebAudioSettings {
+  audioContext: AudioContext;
+}
+
 /**
  * @internal
  */
@@ -72,7 +76,7 @@ export interface InternalRoomOptions {
    * experimental flag, mix all audio tracks in web audio
    */
 
-  expWebAudioMix: boolean;
+  expWebAudioMix: boolean | WebAudioSettings;
 }
 
 /**

package/src/room/RTCEngine.ts

@@ -38,6 +38,7 @@ import type { TrackPublishOptions, VideoCodec } from './track/options';
 import { Track } from './track/Track';
 import {
   isWeb,
+  Mutex,
   sleep,
   supportsAddTrack,
   supportsSetCodecPreferences,
@@ -130,12 +131,15 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   /** specifies how often an initial join connection is allowed to retry */
   private maxJoinAttempts: number = 1;
 
+  private closingLock: Mutex;
+
   constructor(private options: InternalRoomOptions) {
     super();
     this.client = new SignalClient();
     this.client.signalLatency = this.options.expSignalLatency;
     this.reconnectPolicy = this.options.reconnectPolicy;
     this.registerOnLineListener();
+    this.closingLock = new Mutex();
   }
 
   async join(
@@ -179,30 +183,35 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     }
   }
 
-  close() {
-    this._isClosed = true;
-    this.removeAllListeners();
-    this.deregisterOnLineListener();
-    this.clearPendingReconnect();
-    if (this.publisher && this.publisher.pc.signalingState !== 'closed') {
-      this.publisher.pc.getSenders().forEach((sender) => {
-        try {
-          // TODO: react-native-webrtc doesn't have removeTrack yet.
-          if (this.publisher?.pc.removeTrack) {
-            this.publisher?.pc.removeTrack(sender);
+  async close() {
+    const unlock = await this.closingLock.lock();
+    try {
+      this._isClosed = true;
+      this.removeAllListeners();
+      this.deregisterOnLineListener();
+      this.clearPendingReconnect();
+      if (this.publisher && this.publisher.pc.signalingState !== 'closed') {
+        this.publisher.pc.getSenders().forEach((sender) => {
+          try {
+            // TODO: react-native-webrtc doesn't have removeTrack yet.
+            if (this.publisher?.pc.removeTrack) {
+              this.publisher?.pc.removeTrack(sender);
+            }
+          } catch (e) {
+            log.warn('could not removeTrack', { error: e });
           }
-        } catch (e) {
-          log.warn('could not removeTrack', { error: e });
-        }
-      });
-      this.publisher.close();
-      this.publisher = undefined;
-    }
-    if (this.subscriber) {
-      this.subscriber.close();
-      this.subscriber = undefined;
+        });
+        this.publisher.close();
+        this.publisher = undefined;
+      }
+      if (this.subscriber) {
+        this.subscriber.close();
+        this.subscriber = undefined;
+      }
+      await this.client.close();
+    } finally {
+      unlock();
     }
-    this.client.close();
   }
 
   addTrack(req: AddTrackRequest): Promise<TrackInfo> {
@@ -335,7 +344,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         const shouldEmit = this.pcState === PCState.New;
         this.pcState = PCState.Connected;
         if (shouldEmit) {
-          this.emit(EngineEvent.Connected);
+          this.emit(EngineEvent.Connected, joinResponse);
         }
       } else if (primaryPC.connectionState === 'failed') {
         // on Safari, PeerConnection will switch to 'disconnected' during renegotiation
@@ -784,9 +793,9 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     }
 
     if (this.client.isConnected) {
-      this.client.sendLeave();
+      await this.client.sendLeave();
     }
-    this.client.close();
+    await this.client.close();
     this.primaryPC = undefined;
     this.publisher?.close();
     this.publisher = undefined;
@@ -1040,7 +1049,7 @@ async function getConnectedAddress(pc: RTCPeerConnection): Promise<string | unde
 class SignalReconnectError extends Error {}
 
 export type EngineEventCallbacks = {
-  connected: () => void;
+  connected: (joinResp: JoinResponse) => void;
   disconnected: (reason?: DisconnectReason) => void;
   resuming: () => void;
   resumed: () => void;