livekit-client 1.4.4 → 1.5.0

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

@@ -0,0 +1,24 @@
+import LocalAudioTrack from './LocalAudioTrack';
+import type LocalTrack from './LocalTrack';
+import LocalVideoTrack from './LocalVideoTrack';
+import { AudioCaptureOptions, CreateLocalTracksOptions, ScreenShareCaptureOptions, VideoCaptureOptions } from './options';
+/**
+ * Creates a local video and audio track at the same time. When acquiring both
+ * audio and video tracks together, it'll display a single permission prompt to
+ * the user instead of two separate ones.
+ * @param options
+ */
+export declare function createLocalTracks(options?: CreateLocalTracksOptions): Promise<Array<LocalTrack>>;
+/**
+ * Creates a [[LocalVideoTrack]] with getUserMedia()
+ * @param options
+ */
+export declare function createLocalVideoTrack(options?: VideoCaptureOptions): Promise<LocalVideoTrack>;
+export declare function createLocalAudioTrack(options?: AudioCaptureOptions): Promise<LocalAudioTrack>;
+/**
+ * Creates a screen capture tracks with getDisplayMedia().
+ * A LocalVideoTrack is always created and returned.
+ * If { audio: true }, and the browser supports audio capture, a LocalAudioTrack is also created.
+ */
+export declare function createLocalScreenTracks(options?: ScreenShareCaptureOptions): Promise<Array<LocalTrack>>;
+//# sourceMappingURL=create.d.ts.map

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

@@ -0,0 +1,241 @@
+import type { Track } from './Track';
+export interface TrackPublishDefaults {
+    /**
+     * encoding parameters for camera track
+     */
+    videoEncoding?: VideoEncoding;
+    /**
+     * @experimental
+     */
+    backupCodec?: {
+        codec: BackupVideoCodec;
+        encoding: VideoEncoding;
+    } | false;
+    /**
+     * encoding parameters for screen share track
+     */
+    screenShareEncoding?: VideoEncoding;
+    /**
+     * codec, defaults to vp8; for svc codecs, auto enable vp8
+     * as backup. (TBD)
+     */
+    videoCodec?: VideoCodec;
+    /**
+     * max audio bitrate, defaults to [[AudioPresets.speech]]
+     */
+    audioBitrate?: number;
+    /**
+     * dtx (Discontinuous Transmission of audio), defaults to true
+     */
+    dtx?: boolean;
+    /**
+     * red (Redundant Audio Data), defaults to true
+     */
+    red?: boolean;
+    /**
+     * stereo audio track. defaults determined by capture channel count.
+     */
+    forceStereo?: boolean;
+    /**
+     * use simulcast, defaults to true.
+     * When using simulcast, LiveKit will publish up to three versions of the stream
+     * at various resolutions.
+     */
+    simulcast?: boolean;
+    /**
+     * scalability mode for svc codecs, defaults to 'L3T3'.
+     * for svc codecs, simulcast is disabled.
+     */
+    scalabilityMode?: ScalabilityMode;
+    /**
+     * custom video simulcast layers for camera tracks, defaults to h180, h360, h540
+     * You can specify up to two custom layers that will be used instead of
+     * the LiveKit default layers.
+     * Note: the layers need to be ordered from lowest to highest quality
+     */
+    videoSimulcastLayers?: Array<VideoPreset>;
+    /**
+     * custom video simulcast layers for screen tracks
+     * Note: the layers need to be ordered from lowest to highest quality
+     */
+    screenShareSimulcastLayers?: Array<VideoPreset>;
+    /**
+     * For local tracks, stop the underlying MediaStreamTrack when the track is muted (or paused)
+     * on some platforms, this option is necessary to disable the microphone recording indicator.
+     * Note: when this is enabled, and BT devices are connected, they will transition between
+     * profiles (e.g. HFP to A2DP) and there will be an audible difference in playback.
+     *
+     * defaults to false
+     */
+    stopMicTrackOnMute?: boolean;
+}
+/**
+ * Options when publishing tracks
+ */
+export interface TrackPublishOptions extends TrackPublishDefaults {
+    /**
+     * set a track name
+     */
+    name?: string;
+    /**
+     * Source of track, camera, microphone, or screen
+     */
+    source?: Track.Source;
+}
+export interface CreateLocalTracksOptions {
+    /**
+     * audio track options, true to create with defaults. false if audio shouldn't be created
+     * default true
+     */
+    audio?: boolean | AudioCaptureOptions;
+    /**
+     * video track options, true to create with defaults. false if video shouldn't be created
+     * default true
+     */
+    video?: boolean | VideoCaptureOptions;
+}
+export interface VideoCaptureOptions {
+    /**
+     * A ConstrainDOMString object specifying a device ID or an array of device
+     * IDs which are acceptable and/or required.
+     */
+    deviceId?: ConstrainDOMString;
+    /**
+     * a facing or an array of facings which are acceptable and/or required.
+     */
+    facingMode?: 'user' | 'environment' | 'left' | 'right';
+    resolution?: VideoResolution;
+}
+export interface ScreenShareCaptureOptions {
+    /**
+     * true to capture audio shared. browser support for audio capturing in
+     * screenshare is limited: https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getDisplayMedia#browser_compatibility
+     */
+    audio?: boolean | AudioCaptureOptions;
+    /** capture resolution, defaults to full HD */
+    resolution?: VideoResolution;
+}
+export interface AudioCaptureOptions {
+    /**
+     * specifies whether automatic gain control is preferred and/or required
+     */
+    autoGainControl?: ConstrainBoolean;
+    /**
+     * the channel count or range of channel counts which are acceptable and/or required
+     */
+    channelCount?: ConstrainULong;
+    /**
+     * A ConstrainDOMString object specifying a device ID or an array of device
+     * IDs which are acceptable and/or required.
+     */
+    deviceId?: ConstrainDOMString;
+    /**
+     * whether or not echo cancellation is preferred and/or required
+     */
+    echoCancellation?: ConstrainBoolean;
+    /**
+     * the latency or range of latencies which are acceptable and/or required.
+     */
+    latency?: ConstrainDouble;
+    /**
+     * whether noise suppression is preferred and/or required.
+     */
+    noiseSuppression?: ConstrainBoolean;
+    /**
+     * the sample rate or range of sample rates which are acceptable and/or required.
+     */
+    sampleRate?: ConstrainULong;
+    /**
+     * sample size or range of sample sizes which are acceptable and/or required.
+     */
+    sampleSize?: ConstrainULong;
+}
+export interface AudioOutputOptions {
+    /**
+     * deviceId to output audio
+     *
+     * Only supported on browsers where `setSinkId` is available
+     */
+    deviceId?: string;
+}
+export interface VideoResolution {
+    width: number;
+    height: number;
+    frameRate?: number;
+    aspectRatio?: number;
+}
+export interface VideoEncoding {
+    maxBitrate: number;
+    maxFramerate?: number;
+}
+export declare class VideoPreset {
+    encoding: VideoEncoding;
+    width: number;
+    height: number;
+    constructor(width: number, height: number, maxBitrate: number, maxFramerate?: number);
+    get resolution(): VideoResolution;
+}
+export interface AudioPreset {
+    maxBitrate: number;
+}
+declare const codecs: readonly [
+    "vp8",
+    "h264",
+    "av1"
+];
+declare const backupCodecs: readonly [
+    "vp8",
+    "h264"
+];
+export declare type VideoCodec = typeof codecs[number];
+export declare 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 declare namespace AudioPresets {
+    const telephone: AudioPreset;
+    const speech: AudioPreset;
+    const music: AudioPreset;
+    const musicStereo: AudioPreset;
+    const musicHighQuality: AudioPreset;
+    const musicHighQualityStereo: AudioPreset;
+}
+/**
+ * Sane presets for video resolution/encoding
+ */
+export declare const VideoPresets: {
+    readonly h90: VideoPreset;
+    readonly h180: VideoPreset;
+    readonly h216: VideoPreset;
+    readonly h360: VideoPreset;
+    readonly h540: VideoPreset;
+    readonly h720: VideoPreset;
+    readonly h1080: VideoPreset;
+    readonly h1440: VideoPreset;
+    readonly h2160: VideoPreset;
+};
+/**
+ * Four by three presets
+ */
+export declare const VideoPresets43: {
+    readonly h120: VideoPreset;
+    readonly h180: VideoPreset;
+    readonly h240: VideoPreset;
+    readonly h360: VideoPreset;
+    readonly h480: VideoPreset;
+    readonly h540: VideoPreset;
+    readonly h720: VideoPreset;
+    readonly h1080: VideoPreset;
+    readonly h1440: VideoPreset;
+};
+export declare const ScreenSharePresets: {
+    readonly h360fps3: VideoPreset;
+    readonly h720fps5: VideoPreset;
+    readonly h720fps15: VideoPreset;
+    readonly h1080fps15: VideoPreset;
+    readonly h1080fps30: VideoPreset;
+};
+export {};
+//# sourceMappingURL=options.d.ts.map

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

@@ -0,0 +1,23 @@
+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 = {
+    /**
+     * Set a custom pixel density, defaults to 1
+     * When streaming videos on a ultra high definition screen this setting
+     * let's you account for the devicePixelRatio of those screens.
+     * Set it to `screen` to use the actual pixel density of the screen
+     * Note: this might significantly increase the bandwidth consumed by people
+     * streaming on high definition screens.
+     */
+    pixelDensity?: number | 'screen';
+    /**
+     * If true, video gets paused when switching to another tab.
+     * Defaults to true.
+     */
+    pauseVideoInBackground?: boolean;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,14 @@
+import type { AudioCaptureOptions, CreateLocalTracksOptions, VideoCaptureOptions } from './options';
+import type { AudioTrack } from './types';
+export declare function mergeDefaultOptions(options?: CreateLocalTracksOptions, audioDefaults?: AudioCaptureOptions, videoDefaults?: VideoCaptureOptions): CreateLocalTracksOptions;
+export declare function constraintsForOptions(options: CreateLocalTracksOptions): MediaStreamConstraints;
+/**
+ * This function detects silence on a given [[Track]] instance.
+ * Returns true if the track seems to be entirely silent.
+ */
+export declare function detectSilence(track: AudioTrack, timeOffset?: number): Promise<boolean>;
+/**
+ * @internal
+ */
+export declare function getNewAudioContext(): AudioContext | void;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1,35 @@
+import { ClientInfo } from '../proto/livekit_models';
+export declare function unpackStreamId(packed: string): string[];
+export declare function sleep(duration: number): Promise<void>;
+/** @internal */
+export declare function supportsTransceiver(): boolean;
+/** @internal */
+export declare function supportsAddTrack(): boolean;
+export declare function supportsAdaptiveStream(): boolean;
+export declare function supportsDynacast(): boolean;
+export declare function supportsAV1(): boolean;
+export declare function supportsSetSinkId(elm?: HTMLMediaElement): boolean;
+export declare function supportsSetCodecPreferences(transceiver: RTCRtpTransceiver): boolean;
+export declare function isBrowserSupported(): boolean;
+export declare function isFireFox(): boolean;
+export declare function isSafari(): boolean;
+export declare function isMobile(): boolean;
+export declare function isWeb(): boolean;
+export declare function compareVersions(v1: string, v2: string): number;
+export declare const getResizeObserver: () => ResizeObserver;
+export declare const getIntersectionObserver: () => IntersectionObserver;
+export interface ObservableMediaElement extends HTMLMediaElement {
+    handleResize: (entry: ResizeObserverEntry) => void;
+    handleVisibilityChanged: (entry: IntersectionObserverEntry) => void;
+}
+export declare function getClientInfo(): ClientInfo;
+export declare function getEmptyVideoStreamTrack(): MediaStreamTrack;
+export declare function getEmptyAudioStreamTrack(): MediaStreamTrack;
+export declare class Future<T> {
+    promise: Promise<T>;
+    resolve?: (arg: T) => void;
+    reject?: (e: any) => void;
+    onFinally?: () => void;
+    constructor(futureBase?: (resolve: (arg: T) => void, reject: (e: any) => void) => void, onFinally?: () => void);
+}
+//# sourceMappingURL=utils.d.ts.map

package/dist/ts4.2/src/test/MockMediaStreamTrack.d.ts

@@ -0,0 +1,26 @@
+export default class MockMediaStreamTrack implements MediaStreamTrack {
+    contentHint: string;
+    enabled: boolean;
+    id: string;
+    kind: string;
+    label: string;
+    muted: boolean;
+    onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
+    onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+    onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+    readyState: MediaStreamTrackState;
+    isolated: boolean;
+    onisolationchange: ((this: MediaStreamTrack, ev: Event) => any) | null;
+    applyConstraints(constraints?: MediaTrackConstraints): Promise<void>;
+    clone(): MediaStreamTrack;
+    getCapabilities(): MediaTrackCapabilities;
+    getConstraints(): MediaTrackConstraints;
+    getSettings(): MediaTrackSettings;
+    stop(): void;
+    addEventListener<K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    dispatchEvent(event: Event): boolean;
+}
+//# sourceMappingURL=MockMediaStreamTrack.d.ts.map

package/dist/ts4.2/src/test/mocks.d.ts

@@ -0,0 +1,11 @@
+import { SignalClient } from '../api/SignalClient';
+import RTCEngine from '../room/RTCEngine';
+declare const mocks: {
+    SignalClient: jest.MockedClass<typeof SignalClient>;
+    RTCEngine: jest.MockedClass<typeof RTCEngine>;
+    MockLocalVideoTrack: {
+        stop: jest.Mock<any, any>;
+    };
+};
+export default mocks;
+//# sourceMappingURL=mocks.d.ts.map

package/dist/ts4.2/src/version.d.ts

@@ -0,0 +1,3 @@
+export declare const version: string;
+export declare const protocolVersion = 8;
+//# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "1.4.4",
+  "version": "1.5.0",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -15,11 +15,18 @@
     "src"
   ],
   "types": "dist/src/index.d.ts",
+  "typesVersions": {
+    "<4.8": {
+      "./dist/src/index.d.ts": [
+        "./dist/src/ts4.2/index.d.ts"
+      ]
+    }
+  },
   "repository": "git@github.com:livekit/client-sdk-js.git",
   "author": "David Zhao <david@davidzhao.com>",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "rollup --config",
+    "build": "rollup --config && 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",
@@ -29,7 +36,8 @@
     "deploy": "gh-pages -d example/dist",
     "format": "prettier --write src example/sample.ts",
     "format:check": "prettier --check src",
-    "release": "yarn build && changeset publish"
+    "release": "yarn build && changeset publish",
+    "downlevel-dts": "downlevel-dts ./dist/ ./dist/ts4.2 --to=4.2"
   },
   "dependencies": {
     "async-await-queue": "^1.2.1",
@@ -57,6 +65,7 @@
     "@types/ws": "8.5.3",
     "@typescript-eslint/eslint-plugin": "5.38.1",
     "@typescript-eslint/parser": "5.38.1",
+    "downlevel-dts": "^0.11.0",
     "eslint": "8.24.0",
     "eslint-config-airbnb-typescript": "17.0.0",
     "eslint-config-prettier": "8.5.0",
@@ -65,6 +74,7 @@
     "jest": "29.1.2",
     "prettier": "2.7.1",
     "rollup": "2.79.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",

package/src/api/SignalClient.ts

@@ -441,8 +441,8 @@ export class SignalClient {
     if (this.signalLatency) {
       await sleep(this.signalLatency);
     }
-    if (!this.ws) {
-      log.error('cannot send signal request before connected');
+    if (!this.ws || this.ws.readyState < this.ws.OPEN) {
+      log.error(`cannot send signal request before connected, type: ${message?.$case}`);
       return;
     }
 

package/src/connectionHelper/ConnectionCheck.ts

@@ -0,0 +1,90 @@
+import EventEmitter from 'events';
+import type TypedEmitter from 'typed-emitter';
+
+import { Checker, CheckInfo, CheckStatus, InstantiableCheck } from './checks/Checker';
+import { PublishAudioCheck } from './checks/publishAudio';
+import { PublishVideoCheck } from './checks/publishVideo';
+import { ReconnectCheck } from './checks/reconnect';
+import { TURNCheck } from './checks/turn';
+import { WebRTCCheck } from './checks/webrtc';
+import { WebSocketCheck } from './checks/websocket';
+
+export type { CheckInfo };
+
+export class ConnectionCheck extends (EventEmitter as new () => TypedEmitter<ConnectionCheckCallbacks>) {
+  token: string;
+
+  url: string;
+
+  private checkResults: Map<number, CheckInfo> = new Map();
+
+  constructor(url: string, token: string) {
+    super();
+    this.url = url;
+    this.token = token;
+  }
+
+  private getNextCheckId() {
+    const nextId = this.checkResults.size;
+    this.checkResults.set(nextId, {
+      logs: [],
+      status: CheckStatus.IDLE,
+      name: '',
+      description: '',
+    });
+    return nextId;
+  }
+
+  private updateCheck(checkId: number, info: CheckInfo) {
+    this.checkResults.set(checkId, info);
+    this.emit('checkUpdate', checkId, info);
+  }
+
+  isSuccess() {
+    return Array.from(this.checkResults.values()).every((r) => r.status !== CheckStatus.FAILED);
+  }
+
+  getResults() {
+    return Array.from(this.checkResults.values());
+  }
+
+  async createAndRunCheck<T extends Checker>(check: InstantiableCheck<T>) {
+    const checkId = this.getNextCheckId();
+    const test = new check(this.url, this.token);
+    const handleUpdate = (info: CheckInfo) => {
+      this.updateCheck(checkId, info);
+    };
+    test.on('update', handleUpdate);
+    const result = await test.run();
+    test.off('update', handleUpdate);
+    return result;
+  }
+
+  async checkWebsocket() {
+    return this.createAndRunCheck(WebSocketCheck);
+  }
+
+  async checkWebRTC() {
+    return this.createAndRunCheck(WebRTCCheck);
+  }
+
+  async checkTURN() {
+    return this.createAndRunCheck(TURNCheck);
+  }
+
+  async checkReconnect() {
+    return this.createAndRunCheck(ReconnectCheck);
+  }
+
+  async checkPublishAudio() {
+    return this.createAndRunCheck(PublishAudioCheck);
+  }
+
+  async checkPublishVideo() {
+    return this.createAndRunCheck(PublishVideoCheck);
+  }
+}
+
+type ConnectionCheckCallbacks = {
+  checkUpdate: (id: number, info: CheckInfo) => void;
+};