livekit-client 1.5.0 → 1.6.1

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

@@ -44,9 +44,10 @@ export default class RTCEngine extends RTCEngine_base {
     private joinAttempts;
     /** specifies how often an initial join connection is allowed to retry */
     private maxJoinAttempts;
+    private closingLock;
     constructor(options: InternalRoomOptions);
     join(url: string, token: string, opts: SignalOptions, abortSignal?: AbortSignal): Promise<JoinResponse>;
-    close(): void;
+    close(): Promise<void>;
     addTrack(req: AddTrackRequest): Promise<TrackInfo>;
     removeTrack(sender: RTCRtpSender): void;
     updateMuteStatus(trackSid: string, muted: boolean): void;
@@ -70,23 +71,28 @@ export default class RTCEngine extends RTCEngine_base {
     private resumeConnection;
     waitForPCConnected(): Promise<void>;
     sendDataPacket(packet: DataPacket, kind: DataPacket_Kind): Promise<void>;
+    /**
+     * @internal
+     */
+    ensureDataTransportConnected(kind: DataPacket_Kind, subscriber?: boolean): Promise<void>;
     private ensurePublisherConnected;
     /** @internal */
-    negotiate(): void;
+    negotiate(): Promise<void>;
     dataChannelForKind(kind: DataPacket_Kind, sub?: boolean): RTCDataChannel | undefined;
     private clearPendingReconnect;
     private handleBrowserOnLine;
     private registerOnLineListener;
     private deregisterOnLineListener;
 }
-export declare type EngineEventCallbacks = {
-    connected: () => void;
+export type EngineEventCallbacks = {
+    connected: (joinResp: JoinResponse) => void;
     disconnected: (reason?: DisconnectReason) => void;
     resuming: () => void;
     resumed: () => void;
     restarting: () => void;
     restarted: (joinResp: JoinResponse) => void;
     signalResumed: () => void;
+    closing: () => void;
     mediaTrackAdded: (track: MediaStreamTrack, streams: MediaStream, receiver?: RTCRtpReceiver) => void;
     activeSpeakersUpdate: (speakers: Array<SpeakerInfo>) => void;
     dataPacketReceived: (userPacket: UserPacket, kind: DataPacket_Kind) => void;

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

@@ -6,11 +6,12 @@ import type Participant from './participant/Participant';
 import type { ConnectionQuality } from './participant/Participant';
 import RemoteParticipant from './participant/RemoteParticipant';
 import RTCEngine from './RTCEngine';
-import type LocalTrackPublication from './track/LocalTrackPublication';
+import LocalTrackPublication from './track/LocalTrackPublication';
 import type RemoteTrack from './track/RemoteTrack';
 import RemoteTrackPublication from './track/RemoteTrackPublication';
 import { Track } from './track/Track';
 import type { TrackPublication } from './track/TrackPublication';
+import type { SimulationOptions } from './types';
 export declare enum ConnectionState {
     Disconnected = "disconnected",
     Connecting = "connecting",
@@ -59,6 +60,7 @@ declare class Room extends Room_base {
     private abortController?;
     /** future holding client initiated connection attempt */
     private connectFuture?;
+    private disconnectLock;
     /**
      * Creates a new Room, the primary construct for a LiveKit session.
      * @param options
@@ -102,7 +104,7 @@ declare class Room extends Room_base {
     /**
      * @internal for testing
      */
-    simulateScenario(scenario: string): void;
+    simulateScenario(scenario: string): Promise<void>;
     private onBeforeUnload;
     /**
      * Browsers have different policies regarding audio playback. Most requiring
@@ -117,7 +119,15 @@ declare class Room extends Room_base {
      */
     get canPlaybackAudio(): boolean;
     /**
-     * Switches all active device used in this room to the given device.
+     * Returns the active audio output device used in this room.
+     *
+     * Note: to get the active `audioinput` or `videoinput` use [[LocalTrack.getDeviceId()]]
+     *
+     * @return the previously successfully set audio output device ID or an empty string if the default device is used.
+     */
+    getActiveAudioOutputDevice(): string;
+    /**
+     * Switches all active devices used in this room to the given device.
      *
      * Note: setting AudioOutput is not supported on some browsers. See [setSinkId](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/setSinkId#browser_compatibility)
      *
@@ -127,6 +137,7 @@ declare class Room extends Room_base {
      * @param deviceId
      */
     switchActiveDevice(kind: MediaDeviceKind, deviceId: string): Promise<void>;
+    private setupLocalParticipantEvents;
     private recreateEngine;
     private onTrackAdded;
     private handleRestarting;
@@ -163,10 +174,16 @@ declare class Room extends Room_base {
     private onLocalConnectionQualityChanged;
     private onMediaDevicesError;
     private onLocalParticipantPermissionsChanged;
+    /**
+     * Allows to populate a room with simulated participants.
+     * No actual connection to a server will be established, all state is
+     * @experimental
+     */
+    simulateParticipants(options: SimulationOptions): void;
     emit<E extends keyof RoomEventCallbacks>(event: E, ...args: Parameters<RoomEventCallbacks[E]>): boolean;
 }
 export default Room;
-export declare type RoomEventCallbacks = {
+export type RoomEventCallbacks = {
     connected: () => void;
     reconnecting: () => void;
     reconnected: () => void;

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

@@ -367,6 +367,7 @@ export declare enum EngineEvent {
     Restarting = "restarting",
     Restarted = "restarted",
     SignalResumed = "signalResumed",
+    Closing = "closing",
     MediaTrackAdded = "mediaTrackAdded",
     ActiveSpeakersUpdate = "activeSpeakersUpdate",
     DataPacketReceived = "dataPacketReceived"
@@ -375,6 +376,10 @@ export declare enum TrackEvent {
     Message = "message",
     Muted = "muted",
     Unmuted = "unmuted",
+    /**
+     * Only fires on LocalTracks
+     */
+    Restarted = "restarted",
     Ended = "ended",
     Subscribed = "subscribed",
     Unsubscribed = "unsubscribed",

package/dist/ts4.2/src/room/participant/LocalParticipant.d.ts

@@ -88,8 +88,9 @@ export default class LocalParticipant extends Participant {
      * publish additional codec to existing track
      */
     publishAdditionalCodecForTrack(track: LocalTrack | MediaStreamTrack, videoCodec: BackupVideoCodec, options?: TrackPublishOptions): Promise<void>;
-    unpublishTrack(track: LocalTrack | MediaStreamTrack, stopOnUnpublish?: boolean): LocalTrackPublication | undefined;
-    unpublishTracks(tracks: LocalTrack[] | MediaStreamTrack[]): LocalTrackPublication[];
+    unpublishTrack(track: LocalTrack | MediaStreamTrack, stopOnUnpublish?: boolean): Promise<LocalTrackPublication | undefined>;
+    unpublishTracks(tracks: LocalTrack[] | MediaStreamTrack[]): Promise<LocalTrackPublication[]>;
+    republishAllTracks(options?: TrackPublishOptions): Promise<void>;
     /**
      * Publish a new data payload to the room. Data will be forwarded to each
      * participant in the room if the destination argument is empty

package/dist/ts4.2/src/room/participant/Participant.d.ts

@@ -68,7 +68,7 @@ export default class Participant extends Participant_base {
     setConnectionQuality(q: ProtoQuality): void;
     protected addTrackPublication(publication: TrackPublication): void;
 }
-export declare type ParticipantEventCallbacks = {
+export type ParticipantEventCallbacks = {
     trackPublished: (publication: RemoteTrackPublication) => void;
     trackSubscribed: (track: RemoteTrack, publication: RemoteTrackPublication) => void;
     trackSubscriptionFailed: (trackSid: string) => void;

package/dist/ts4.2/src/room/track/LocalTrack.d.ts

@@ -23,6 +23,7 @@ export default abstract class LocalTrack extends Track {
     private _isUpstreamPaused;
     get isUpstreamPaused(): boolean;
     get isUserProvided(): boolean;
+    waitForDimensions(timeout?: number): Promise<Track.Dimensions>;
     /**
      * @returns DeviceID of the device that is currently being used for this track
      */

package/dist/ts4.2/src/room/track/Track.d.ts

@@ -100,10 +100,11 @@ export declare namespace Track {
     /** @internal */
     function streamStateFromProto(s: ProtoStreamState): StreamState;
 }
-export declare type TrackEventCallbacks = {
+export type TrackEventCallbacks = {
     message: () => void;
     muted: (track?: any) => void;
     unmuted: (track?: any) => void;
+    restarted: (track?: any) => void;
     ended: (track?: any) => void;
     updateSettings: () => void;
     updateSubscription: () => void;

package/dist/ts4.2/src/room/track/TrackPublication.d.ts

@@ -53,7 +53,7 @@ export declare namespace TrackPublication {
         NotAllowed = "not_allowed"
     }
 }
-export declare type PublicationEventCallbacks = {
+export type PublicationEventCallbacks = {
     muted: () => void;
     unmuted: () => void;
     ended: (track?: Track) => void;

package/dist/ts4.2/src/room/track/options.d.ts

@@ -187,13 +187,13 @@ declare const backupCodecs: readonly [
     "vp8",
     "h264"
 ];
-export declare type VideoCodec = typeof codecs[number];
-export declare type BackupVideoCodec = typeof backupCodecs[number];
+export type VideoCodec = typeof codecs[number];
+export type BackupVideoCodec = typeof backupCodecs[number];
 export declare function isBackupCodec(codec: string): codec is BackupVideoCodec;
 /**
  * scalability modes for svc, only supprot l3t3 now.
  */
-export declare type ScalabilityMode = 'L3T3';
+export type ScalabilityMode = 'L3T3';
 export declare namespace AudioPresets {
     const telephone: AudioPreset;
     const speech: AudioPreset;

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

@@ -2,9 +2,9 @@ import type LocalAudioTrack from './LocalAudioTrack';
 import type LocalVideoTrack from './LocalVideoTrack';
 import type RemoteAudioTrack from './RemoteAudioTrack';
 import type RemoteVideoTrack from './RemoteVideoTrack';
-export declare type AudioTrack = RemoteAudioTrack | LocalAudioTrack;
-export declare type VideoTrack = RemoteVideoTrack | LocalVideoTrack;
-export declare type AdaptiveStreamSettings = {
+export type AudioTrack = RemoteAudioTrack | LocalAudioTrack;
+export type VideoTrack = RemoteVideoTrack | LocalVideoTrack;
+export type AdaptiveStreamSettings = {
     /**
      * Set a custom pixel density, defaults to 1
      * When streaming videos on a ultra high definition screen this setting

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.1",
   "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",
-    "@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",
+    "@babel/core": "7.20.7",
+    "@babel/preset-env": "7.20.2",
+    "@changesets/changelog-github": "0.4.8",
+    "@changesets/cli": "2.26.0",
+    "@rollup/plugin-babel": "6.0.3",
+    "@rollup/plugin-commonjs": "24.0.0",
+    "@rollup/plugin-json": "6.0.0",
+    "@rollup/plugin-node-resolve": "15.0.1",
+    "@types/jest": "29.2.5",
     "@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",
+    "@types/ws": "8.5.4",
+    "@typescript-eslint/eslint-plugin": "5.47.1",
+    "@typescript-eslint/parser": "5.47.1",
     "downlevel-dts": "^0.11.0",
-    "eslint": "8.24.0",
+    "eslint": "8.31.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.9.1",
     "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.137.0",
+    "typedoc": "0.23.23",
     "typedoc-plugin-no-inherit": "1.4.0",
-    "typescript": "4.8.4",
-    "vite": "3.1.8"
+    "typescript": "4.9.4",
+    "vite": "4.0.3"
   },
   "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/PCTransport.ts

@@ -1,3 +1,4 @@
+import EventEmitter from 'events';
 import { MediaDescription, parse, write } from 'sdp-transform';
 import { debounce } from 'ts-debounce';
 import log from '../logger';
@@ -10,8 +11,13 @@ interface TrackBitrateInfo {
   maxbr: number;
 }
 
+export const PCEvents = {
+  NegotiationStarted: 'negotiationStarted',
+  NegotiationComplete: 'negotiationComplete',
+} as const;
+
 /** @internal */
-export default class PCTransport {
+export default class PCTransport extends EventEmitter {
   pc: RTCPeerConnection;
 
   pendingCandidates: RTCIceCandidateInit[] = [];
@@ -27,6 +33,7 @@ export default class PCTransport {
   onOffer?: (offer: RTCSessionDescriptionInit) => void;
 
   constructor(config?: RTCConfiguration) {
+    super();
     this.pc = new RTCPeerConnection(config);
   }
 
@@ -56,11 +63,14 @@ export default class PCTransport {
     if (this.renegotiate) {
       this.renegotiate = false;
       this.createAndSendOffer();
+    } else if (sd.type === 'answer') {
+      this.emit(PCEvents.NegotiationComplete);
     }
   }
 
   // debounced negotiate interface
   negotiate = debounce((onError?: (e: Error) => void) => {
+    this.emit(PCEvents.NegotiationStarted);
     try {
       this.createAndSendOffer();
     } catch (e) {