livekit-client 1.4.4 → 1.6.0

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

@@ -0,0 +1,8 @@
+import type { ReconnectContext, ReconnectPolicy } from './ReconnectPolicy';
+declare class DefaultReconnectPolicy implements ReconnectPolicy {
+    private readonly _retryDelays;
+    constructor(retryDelays?: number[]);
+    nextRetryDelayInMs(context: ReconnectContext): number | null;
+}
+export default DefaultReconnectPolicy;
+//# sourceMappingURL=DefaultReconnectPolicy.d.ts.map

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

@@ -0,0 +1,9 @@
+export default class DeviceManager {
+    private static instance?;
+    static mediaDeviceKinds: MediaDeviceKind[];
+    static getInstance(): DeviceManager;
+    static userMediaPromiseMap: Map<MediaDeviceKind, Promise<MediaStream>>;
+    getDevices(kind?: MediaDeviceKind, requestPermissions?: boolean): Promise<MediaDeviceInfo[]>;
+    normalizeDeviceId(kind: MediaDeviceKind, deviceId?: string, groupId?: string): Promise<string | undefined>;
+}
+//# sourceMappingURL=DeviceManager.d.ts.map

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

@@ -0,0 +1,33 @@
+/** @internal */
+interface TrackBitrateInfo {
+    sid: string;
+    codec: string;
+    maxbr: number;
+}
+/** @internal */
+export default class PCTransport {
+    pc: RTCPeerConnection;
+    pendingCandidates: RTCIceCandidateInit[];
+    restartingIce: boolean;
+    renegotiate: boolean;
+    trackBitrates: TrackBitrateInfo[];
+    remoteStereoMids: string[];
+    onOffer?: (offer: RTCSessionDescriptionInit) => void;
+    constructor(config?: RTCConfiguration);
+    get isICEConnected(): boolean;
+    addIceCandidate(candidate: RTCIceCandidateInit): Promise<void>;
+    setRemoteDescription(sd: RTCSessionDescriptionInit): Promise<void>;
+    negotiate: {
+        (this: unknown, ...args: [
+            onError?: ((e: Error) => void) | undefined
+        ] & any[]): Promise<void>;
+        cancel: (reason?: any) => void;
+    };
+    createAndSendOffer(options?: RTCOfferOptions): Promise<void>;
+    createAndSetAnswer(): Promise<RTCSessionDescriptionInit>;
+    setTrackCodecBitrate(sid: string, codec: string, maxbr: number): void;
+    close(): void;
+    private setMungedLocalDescription;
+}
+export {};
+//# sourceMappingURL=PCTransport.d.ts.map

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

@@ -0,0 +1,97 @@
+import type TypedEventEmitter from 'typed-emitter';
+import { SignalClient, SignalOptions } from '../api/SignalClient';
+import type { InternalRoomOptions } from '../options';
+import { DataPacket, DataPacket_Kind, DisconnectReason, SpeakerInfo, TrackInfo, UserPacket } from '../proto/livekit_models';
+import { AddTrackRequest, JoinResponse } from '../proto/livekit_rtc';
+import PCTransport from './PCTransport';
+import type LocalTrack from './track/LocalTrack';
+import type LocalVideoTrack from './track/LocalVideoTrack';
+import type { SimulcastTrackInfo } from './track/LocalVideoTrack';
+import type { TrackPublishOptions } from './track/options';
+declare const RTCEngine_base: new () => TypedEventEmitter<EngineEventCallbacks>;
+/** @internal */
+export default class RTCEngine extends RTCEngine_base {
+    private options;
+    publisher?: PCTransport;
+    subscriber?: PCTransport;
+    client: SignalClient;
+    rtcConfig: RTCConfiguration;
+    peerConnectionTimeout: number;
+    get isClosed(): boolean;
+    private lossyDC?;
+    private lossyDCSub?;
+    private reliableDC?;
+    private reliableDCSub?;
+    private subscriberPrimary;
+    private primaryPC?;
+    private pcState;
+    private _isClosed;
+    private pendingTrackResolvers;
+    private hasPublished;
+    private url?;
+    private token?;
+    private signalOpts?;
+    private reconnectAttempts;
+    private reconnectStart;
+    private fullReconnectOnNext;
+    private clientConfiguration?;
+    private connectedServerAddr?;
+    private attemptingReconnect;
+    private reconnectPolicy;
+    private reconnectTimeout?;
+    private participantSid?;
+    /** keeps track of how often an initial join connection has been tried */
+    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(): Promise<void>;
+    addTrack(req: AddTrackRequest): Promise<TrackInfo>;
+    removeTrack(sender: RTCRtpSender): void;
+    updateMuteStatus(trackSid: string, muted: boolean): void;
+    get dataSubscriberReadyState(): string | undefined;
+    get connectedServerAddress(): string | undefined;
+    private configure;
+    private createDataChannels;
+    private handleDataChannel;
+    private handleDataMessage;
+    private handleDataError;
+    private setPreferredCodec;
+    createSender(track: LocalTrack, opts: TrackPublishOptions, encodings?: RTCRtpEncodingParameters[]): Promise<RTCRtpSender>;
+    createSimulcastSender(track: LocalVideoTrack, simulcastTrack: SimulcastTrackInfo, opts: TrackPublishOptions, encodings?: RTCRtpEncodingParameters[]): Promise<RTCRtpSender | undefined>;
+    private createTransceiverRTCRtpSender;
+    private createSimulcastTransceiverSender;
+    private createRTCRtpSender;
+    private handleDisconnect;
+    private attemptReconnect;
+    private getNextRetryDelay;
+    private restartConnection;
+    private resumeConnection;
+    waitForPCConnected(): Promise<void>;
+    sendDataPacket(packet: DataPacket, kind: DataPacket_Kind): Promise<void>;
+    private ensurePublisherConnected;
+    /** @internal */
+    negotiate(): void;
+    dataChannelForKind(kind: DataPacket_Kind, sub?: boolean): RTCDataChannel | undefined;
+    private clearPendingReconnect;
+    private handleBrowserOnLine;
+    private registerOnLineListener;
+    private deregisterOnLineListener;
+}
+export type EngineEventCallbacks = {
+    connected: (joinResp: JoinResponse) => void;
+    disconnected: (reason?: DisconnectReason) => void;
+    resuming: () => void;
+    resumed: () => void;
+    restarting: () => void;
+    restarted: (joinResp: JoinResponse) => void;
+    signalResumed: () => void;
+    mediaTrackAdded: (track: MediaStreamTrack, streams: MediaStream, receiver?: RTCRtpReceiver) => void;
+    activeSpeakersUpdate: (speakers: Array<SpeakerInfo>) => void;
+    dataPacketReceived: (userPacket: UserPacket, kind: DataPacket_Kind) => void;
+    transportsCreated: (publisher: PCTransport, subscriber: PCTransport) => void;
+};
+export {};
+//# sourceMappingURL=RTCEngine.d.ts.map

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

@@ -0,0 +1,23 @@
+/** Controls reconnecting of the client */
+export interface ReconnectPolicy {
+    /** Called after disconnect was detected
+     *
+     * @returns {number | null} Amount of time in milliseconds to delay the next reconnect attempt, `null` signals to stop retrying.
+     */
+    nextRetryDelayInMs(context: ReconnectContext): number | null;
+}
+export interface ReconnectContext {
+    /**
+     * Number of failed reconnect attempts
+     */
+    readonly retryCount: number;
+    /**
+     * Elapsed amount of time in milliseconds since the disconnect.
+     */
+    readonly elapsedMs: number;
+    /**
+     * Reason for retrying
+     */
+    readonly retryReason?: Error;
+}
+//# sourceMappingURL=ReconnectPolicy.d.ts.map

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

@@ -0,0 +1,220 @@
+import type TypedEmitter from 'typed-emitter';
+import type { InternalRoomOptions, RoomConnectOptions, RoomOptions } from '../options';
+import { DataPacket_Kind, DisconnectReason, ParticipantPermission } from '../proto/livekit_models';
+import LocalParticipant from './participant/LocalParticipant';
+import type Participant from './participant/Participant';
+import type { ConnectionQuality } from './participant/Participant';
+import RemoteParticipant from './participant/RemoteParticipant';
+import RTCEngine from './RTCEngine';
+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",
+    Connected = "connected",
+    Reconnecting = "reconnecting"
+}
+/** @deprecated RoomState has been renamed to [[ConnectionState]] */
+export declare const RoomState: typeof ConnectionState;
+declare const Room_base: new () => TypedEmitter<RoomEventCallbacks>;
+/**
+ * In LiveKit, a room is the logical grouping for a list of participants.
+ * Participants in a room can publish tracks, and subscribe to others' tracks.
+ *
+ * a Room fires [[RoomEvent | RoomEvents]].
+ *
+ * @noInheritDoc
+ */
+declare class Room extends Room_base {
+    state: ConnectionState;
+    /** map of sid: [[RemoteParticipant]] */
+    participants: Map<string, RemoteParticipant>;
+    /**
+     * list of participants that are actively speaking. when this changes
+     * a [[RoomEvent.ActiveSpeakersChanged]] event is fired
+     */
+    activeSpeakers: Participant[];
+    /** @internal */
+    engine: RTCEngine;
+    /** server assigned unique room id */
+    sid: string;
+    /** user assigned name, derived from JWT token */
+    name: string;
+    /** the current participant */
+    localParticipant: LocalParticipant;
+    /** room metadata */
+    metadata: string | undefined;
+    /** options of room */
+    options: InternalRoomOptions;
+    private _isRecording;
+    private identityToSid;
+    /** connect options of room */
+    private connOptions?;
+    private audioEnabled;
+    private audioContext?;
+    /** used for aborting pending connections to a LiveKit server */
+    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
+     */
+    constructor(options?: RoomOptions);
+    private maybeCreateEngine;
+    /**
+     * getLocalDevices abstracts navigator.mediaDevices.enumerateDevices.
+     * In particular, it handles Chrome's unique behavior of creating `default`
+     * devices. When encountered, it'll be removed from the list of devices.
+     * The actual default device will be placed at top.
+     * @param kind
+     * @returns a list of available local devices
+     */
+    static getLocalDevices(kind?: MediaDeviceKind, requestPermissions?: boolean): Promise<MediaDeviceInfo[]>;
+    /**
+     * prepares the connection to the livekit server by sending a HEAD request in order to
+     * 1. speed up DNS resolution
+     * 2. speed up TLS setup
+     * on the actual connection request
+     * throws an error if server is not reachable after the request timeout
+     * @experimental
+     */
+    prepareConnection(url: string): Promise<void>;
+    connect: (url: string, token: string, opts?: RoomConnectOptions) => Promise<void>;
+    /**
+     * disconnects the room, emits [[RoomEvent.Disconnected]]
+     */
+    disconnect: (stopTracks?: boolean) => Promise<void>;
+    /**
+     * retrieves a participant by identity
+     * @param identity
+     * @returns
+     */
+    getParticipantByIdentity(identity: string): Participant | undefined;
+    private clearConnectionFutures;
+    /**
+     * if the current room has a participant with `recorder: true` in its JWT grant
+     **/
+    get isRecording(): boolean;
+    /**
+     * @internal for testing
+     */
+    simulateScenario(scenario: string): Promise<void>;
+    private onBeforeUnload;
+    /**
+     * Browsers have different policies regarding audio playback. Most requiring
+     * some form of user interaction (click/tap/etc).
+     * In those cases, audio will be silent until a click/tap triggering one of the following
+     * - `startAudio`
+     * - `getUserMedia`
+     */
+    startAudio(): Promise<void>;
+    /**
+     * Returns true if audio playback is enabled
+     */
+    get canPlaybackAudio(): boolean;
+    /**
+     * 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)
+     *
+     * @param kind use `videoinput` for camera track,
+     *  `audioinput` for microphone track,
+     *  `audiooutput` to set speaker for all incoming audio tracks
+     * @param deviceId
+     */
+    switchActiveDevice(kind: MediaDeviceKind, deviceId: string): Promise<void>;
+    private setupLocalParticipantEvents;
+    private recreateEngine;
+    private onTrackAdded;
+    private handleRestarting;
+    private handleRestarted;
+    private handleDisconnect;
+    private handleParticipantUpdates;
+    private handleParticipantDisconnected;
+    private handleActiveSpeakersUpdate;
+    private handleSpeakersChanged;
+    private handleStreamStateUpdate;
+    private handleSubscriptionPermissionUpdate;
+    private handleDataPacket;
+    private handleAudioPlaybackStarted;
+    private handleAudioPlaybackFailed;
+    private handleDeviceChange;
+    private handleRoomUpdate;
+    private handleConnectionQualityUpdate;
+    private acquireAudioContext;
+    private createParticipant;
+    private getOrCreateParticipant;
+    private sendSyncState;
+    /**
+     * After resuming, we'll need to notify the server of the current
+     * subscription settings.
+     */
+    private updateSubscriptions;
+    private setAndEmitConnectionState;
+    private emitWhenConnected;
+    private onLocalParticipantMetadataChanged;
+    private onLocalTrackMuted;
+    private onLocalTrackUnmuted;
+    private onLocalTrackPublished;
+    private onLocalTrackUnpublished;
+    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 type RoomEventCallbacks = {
+    connected: () => void;
+    reconnecting: () => void;
+    reconnected: () => void;
+    disconnected: (reason?: DisconnectReason) => void;
+    /** @deprecated stateChanged has been renamed to connectionStateChanged */
+    stateChanged: (state: ConnectionState) => void;
+    connectionStateChanged: (state: ConnectionState) => void;
+    mediaDevicesChanged: () => void;
+    participantConnected: (participant: RemoteParticipant) => void;
+    participantDisconnected: (participant: RemoteParticipant) => void;
+    trackPublished: (publication: RemoteTrackPublication, participant: RemoteParticipant) => void;
+    trackSubscribed: (track: RemoteTrack, publication: RemoteTrackPublication, participant: RemoteParticipant) => void;
+    trackSubscriptionFailed: (trackSid: string, participant: RemoteParticipant) => void;
+    trackUnpublished: (publication: RemoteTrackPublication, participant: RemoteParticipant) => void;
+    trackUnsubscribed: (track: RemoteTrack, publication: RemoteTrackPublication, participant: RemoteParticipant) => void;
+    trackMuted: (publication: TrackPublication, participant: Participant) => void;
+    trackUnmuted: (publication: TrackPublication, participant: Participant) => void;
+    localTrackPublished: (publication: LocalTrackPublication, participant: LocalParticipant) => void;
+    localTrackUnpublished: (publication: LocalTrackPublication, participant: LocalParticipant) => void;
+    participantMetadataChanged: (metadata: string | undefined, participant: RemoteParticipant | LocalParticipant) => void;
+    participantPermissionsChanged: (prevPermissions: ParticipantPermission, participant: RemoteParticipant | LocalParticipant) => void;
+    activeSpeakersChanged: (speakers: Array<Participant>) => void;
+    roomMetadataChanged: (metadata: string) => void;
+    dataReceived: (payload: Uint8Array, participant?: RemoteParticipant, kind?: DataPacket_Kind) => void;
+    connectionQualityChanged: (quality: ConnectionQuality, participant: Participant) => void;
+    mediaDevicesError: (error: Error) => void;
+    trackStreamStateChanged: (publication: RemoteTrackPublication, streamState: Track.StreamState, participant: RemoteParticipant) => void;
+    trackSubscriptionPermissionChanged: (publication: RemoteTrackPublication, status: TrackPublication.PermissionStatus, participant: RemoteParticipant) => void;
+    trackSubscriptionStatusChanged: (publication: RemoteTrackPublication, status: TrackPublication.SubscriptionStatus, participant: RemoteParticipant) => void;
+    audioPlaybackChanged: (playing: boolean) => void;
+    signalConnected: () => void;
+    recordingStatusChanged: (recording: boolean) => void;
+};
+//# sourceMappingURL=Room.d.ts.map

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

@@ -0,0 +1,8 @@
+import type { InternalRoomConnectOptions, InternalRoomOptions } from '../options';
+import { AudioCaptureOptions, TrackPublishDefaults, VideoCaptureOptions } from './track/options';
+export declare const publishDefaults: TrackPublishDefaults;
+export declare const audioDefaults: AudioCaptureOptions;
+export declare const videoDefaults: VideoCaptureOptions;
+export declare const roomOptionDefaults: InternalRoomOptions;
+export declare const roomConnectOptionDefaults: InternalRoomConnectOptions;
+//# sourceMappingURL=defaults.d.ts.map

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

@@ -0,0 +1,39 @@
+export declare class LivekitError extends Error {
+    code: number;
+    constructor(code: number, message?: string);
+}
+export declare const enum ConnectionErrorReason {
+    NotAllowed = 0,
+    ServerUnreachable = 1,
+    InternalError = 2
+}
+export declare class ConnectionError extends LivekitError {
+    status?: number;
+    reason?: ConnectionErrorReason;
+    constructor(message?: string, reason?: ConnectionErrorReason, status?: number);
+}
+export declare class TrackInvalidError extends LivekitError {
+    constructor(message?: string);
+}
+export declare class UnsupportedServer extends LivekitError {
+    constructor(message?: string);
+}
+export declare class UnexpectedConnectionState extends LivekitError {
+    constructor(message?: string);
+}
+export declare class NegotiationError extends LivekitError {
+    constructor(message?: string);
+}
+export declare class PublishDataError extends LivekitError {
+    constructor(message?: string);
+}
+export declare enum MediaDeviceFailure {
+    PermissionDenied = "PermissionDenied",
+    NotFound = "NotFound",
+    DeviceInUse = "DeviceInUse",
+    Other = "Other"
+}
+export declare namespace MediaDeviceFailure {
+    function getFailure(error: any): MediaDeviceFailure | undefined;
+}
+//# sourceMappingURL=errors.d.ts.map