livekit-client 2.22.3 → 2.23.0

package/dist/ts4.2/room/track/RemoteAudioTrack.d.ts

@@ -1,55 +1,61 @@
-import type { AudioReceiverStats } from '../stats';
-import type { LoggerOptions } from '../types';
-import RemoteTrack from './RemoteTrack';
-import { Track } from './Track';
-import type { AudioOutputOptions } from './options';
-export default class RemoteAudioTrack extends RemoteTrack<Track.Kind.Audio> {
-    private prevStats?;
-    private elementVolume;
-    private audioContext?;
-    private gainNode?;
-    private sourceNode?;
-    private webAudioPluginNodes;
-    private sinkId?;
-    constructor(mediaTrack: MediaStreamTrack, sid: string, receiver: RTCRtpReceiver, audioContext?: AudioContext, audioOutput?: AudioOutputOptions, loggerOptions?: LoggerOptions);
-    /**
-     * sets the volume for all attached audio elements
-     */
-    setVolume(volume: number): void;
-    /**
-     * gets the volume of attached audio elements (loudest)
-     */
-    getVolume(): number;
-    /**
-     * calls setSinkId on all attached elements, if supported
-     * @param deviceId audio output device
-     */
-    setSinkId(deviceId: string): Promise<void>;
-    attach(): HTMLMediaElement;
-    attach(element: HTMLMediaElement): HTMLMediaElement;
-    /**
-     * Detaches from all attached elements
-     */
-    detach(): HTMLMediaElement[];
-    /**
-     * Detach from a single element
-     * @param element
-     */
-    detach(element: HTMLMediaElement): HTMLMediaElement;
-    /**
-     * @internal
-     * @experimental
-     */
-    setAudioContext(audioContext: AudioContext | undefined): void;
-    /**
-     * @internal
-     * @experimental
-     * @param {AudioNode[]} nodes - An array of WebAudio nodes. These nodes should not be connected to each other when passed, as the sdk will take care of connecting them in the order of the array.
-     */
-    setWebAudioPlugins(nodes: AudioNode[]): void;
-    private connectWebAudio;
-    private disconnectWebAudio;
-    protected monitorReceiver: () => Promise<void>;
-    getReceiverStats(): Promise<AudioReceiverStats | undefined>;
-}
-//# sourceMappingURL=RemoteAudioTrack.d.ts.map
+import type { AudioReceiverStats } from '../stats';
+import type { LoggerOptions } from '../types';
+import RemoteTrack from './RemoteTrack';
+import { Track } from './Track';
+import type { AudioOutputOptions } from './options';
+export default class RemoteAudioTrack extends RemoteTrack<Track.Kind.Audio> {
+    private prevStats?;
+    private elementVolume;
+    private audioContext?;
+    private gainNode?;
+    private sourceNode?;
+    private webAudioPluginNodes;
+    /**
+     * the nodes of the graph currently wired up, in order, so teardown can undo exactly the edges
+     * `connectWebAudio` created. Reading `webAudioPluginNodes` instead would miss the old plugins
+     * once `setWebAudioPlugins` has replaced them.
+     */
+    private connectedNodes;
+    private sinkId?;
+    constructor(mediaTrack: MediaStreamTrack, sid: string, receiver: RTCRtpReceiver, audioContext?: AudioContext, audioOutput?: AudioOutputOptions, loggerOptions?: LoggerOptions);
+    /**
+     * sets the volume for all attached audio elements
+     */
+    setVolume(volume: number): void;
+    /**
+     * gets the volume of attached audio elements (loudest)
+     */
+    getVolume(): number;
+    /**
+     * calls setSinkId on all attached elements, if supported
+     * @param deviceId audio output device
+     */
+    setSinkId(deviceId: string): Promise<void>;
+    attach(): HTMLMediaElement;
+    attach(element: HTMLMediaElement): HTMLMediaElement;
+    /**
+     * Detaches from all attached elements
+     */
+    detach(): HTMLMediaElement[];
+    /**
+     * Detach from a single element
+     * @param element
+     */
+    detach(element: HTMLMediaElement): HTMLMediaElement;
+    /**
+     * @internal
+     * @experimental
+     */
+    setAudioContext(audioContext: AudioContext | undefined): void;
+    /**
+     * @internal
+     * @experimental
+     * @param {AudioNode[]} nodes - An array of WebAudio nodes. These nodes should not be connected to each other when passed, as the sdk will take care of connecting them in the order of the array.
+     */
+    setWebAudioPlugins(nodes: AudioNode[]): void;
+    private connectWebAudio;
+    private disconnectWebAudio;
+    protected monitorReceiver: () => Promise<void>;
+    getReceiverStats(): Promise<AudioReceiverStats | undefined>;
+}
+//# sourceMappingURL=RemoteAudioTrack.d.ts.map

package/dist/ts4.2/room/track/RemoteTrack.d.ts

@@ -1,38 +1,38 @@
-import type { LoggerOptions } from '../types';
-import { Track } from './Track';
-export default abstract class RemoteTrack<TrackKind extends Track.Kind = Track.Kind> extends Track<TrackKind> {
-    /** @internal */
-    receiver: RTCRtpReceiver | undefined;
-    constructor(mediaTrack: MediaStreamTrack, sid: string, kind: TrackKind, receiver: RTCRtpReceiver, loggerOptions?: LoggerOptions);
-    get isLocal(): boolean;
-    /** @internal */
-    setMuted(muted: boolean): void;
-    /** @internal */
-    setMediaStream(stream: MediaStream): void;
-    start(): void;
-    stop(): void;
-    /**
-     * Gets the RTCStatsReport for the RemoteTrack's underlying RTCRtpReceiver
-     * See https://developer.mozilla.org/en-US/docs/Web/API/RTCStatsReport
-     *
-     * @returns Promise<RTCStatsReport> | undefined
-     */
-    getRTCStatsReport(): Promise<RTCStatsReport | undefined>;
-    /**
-     * Allows to set a playout delay (in seconds) for this track.
-     * A higher value allows for more buffering of the track in the browser
-     * and will result in a delay of media being played back of `delayInSeconds`
-     */
-    setPlayoutDelay(delayInSeconds: number): void;
-    /**
-     * Returns the current playout delay (in seconds) of this track.
-     */
-    getPlayoutDelay(): number;
-    startMonitor(): void;
-    stopMonitor(): void;
-    protected abstract monitorReceiver(): void;
-    private timeSyncLoop;
-    private onTimeSyncListenerAdded;
-    registerTimeSyncUpdate(): void;
-}
-//# sourceMappingURL=RemoteTrack.d.ts.map
+import type { LoggerOptions } from '../types';
+import { Track } from './Track';
+export default abstract class RemoteTrack<TrackKind extends Track.Kind = Track.Kind> extends Track<TrackKind> {
+    /** @internal */
+    receiver: RTCRtpReceiver | undefined;
+    constructor(mediaTrack: MediaStreamTrack, sid: string, kind: TrackKind, receiver: RTCRtpReceiver, loggerOptions?: LoggerOptions);
+    get isLocal(): boolean;
+    /** @internal */
+    setMuted(muted: boolean): void;
+    /** @internal */
+    setMediaStream(stream: MediaStream): void;
+    start(): void;
+    stop(): void;
+    /**
+     * Gets the RTCStatsReport for the RemoteTrack's underlying RTCRtpReceiver
+     * See https://developer.mozilla.org/en-US/docs/Web/API/RTCStatsReport
+     *
+     * @returns Promise<RTCStatsReport> | undefined
+     */
+    getRTCStatsReport(): Promise<RTCStatsReport | undefined>;
+    /**
+     * Allows to set a playout delay (in seconds) for this track.
+     * A higher value allows for more buffering of the track in the browser
+     * and will result in a delay of media being played back of `delayInSeconds`
+     */
+    setPlayoutDelay(delayInSeconds: number): void;
+    /**
+     * Returns the current playout delay (in seconds) of this track.
+     */
+    getPlayoutDelay(): number;
+    startMonitor(): void;
+    stopMonitor(): void;
+    protected abstract monitorReceiver(): void;
+    private timeSyncLoop;
+    private onTimeSyncListenerAdded;
+    registerTimeSyncUpdate(): void;
+}
+//# sourceMappingURL=RemoteTrack.d.ts.map

package/dist/ts4.2/room/track/RemoteTrackPublication.d.ts

@@ -1,75 +1,72 @@
-import { SubscriptionError, TrackInfo } from '@livekit/protocol';
-import type { LoggerOptions } from '../types';
-import type RemoteTrack from './RemoteTrack';
-import { Track, VideoQuality } from './Track';
-import { TrackPublication } from './TrackPublication';
-export default class RemoteTrackPublication extends TrackPublication {
-    track?: RemoteTrack;
-    /** @internal */
-    protected allowed: boolean;
-    protected subscribed?: boolean;
-    protected requestedDisabled: boolean | undefined;
-    protected visible: boolean;
-    protected videoDimensionsAdaptiveStream?: Track.Dimensions;
-    protected requestedVideoDimensions?: Track.Dimensions;
-    protected requestedMaxQuality?: VideoQuality;
-    protected fps?: number;
-    protected subscriptionError?: SubscriptionError;
-    constructor(kind: Track.Kind, ti: TrackInfo, autoSubscribe: boolean | undefined, loggerOptions?: LoggerOptions);
-    /**
-     * Subscribe or unsubscribe to this remote track
-     * @param subscribed true to subscribe to a track, false to unsubscribe
-     */
-    setSubscribed(subscribed: boolean): void;
-    get subscriptionStatus(): TrackPublication.SubscriptionStatus;
-    get permissionStatus(): TrackPublication.PermissionStatus;
-    /**
-     * Returns true if track is subscribed, and ready for playback
-     */
-    get isSubscribed(): boolean;
-    get isDesired(): boolean;
-    get isEnabled(): boolean;
-    get isLocal(): boolean;
-    /**
-     * disable server from sending down data for this track. this is useful when
-     * the participant is off screen, you may disable streaming down their video
-     * to reduce bandwidth requirements
-     * @param enabled
-     */
-    setEnabled(enabled: boolean): void;
-    /**
-     * for tracks that support simulcasting, adjust subscribed quality
-     *
-     * This indicates the highest quality the client can accept. if network
-     * bandwidth does not allow, server will automatically reduce quality to
-     * optimize for uninterrupted video
-     */
-    setVideoQuality(quality: VideoQuality): void;
-    /**
-     * Explicitly set the video dimensions for this track.
-     *
-     * This will take precedence over adaptive stream dimensions.
-     *
-     * @param dimensions The video dimensions to set.
-     */
-    setVideoDimensions(dimensions: Track.Dimensions): void;
-    setVideoFPS(fps: number): void;
-    get videoQuality(): VideoQuality | undefined;
-    /** @internal */
-    setTrack(track?: RemoteTrack): void;
-    /** @internal */
-    setAllowed(allowed: boolean): void;
-    /** @internal */
-    setSubscriptionError(error: SubscriptionError): void;
-    /** @internal */
-    updateInfo(info: TrackInfo): void;
-    private emitSubscriptionUpdateIfChanged;
-    private emitPermissionUpdateIfChanged;
-    private isManualOperationAllowed;
-    protected handleEnded: (track: RemoteTrack) => void;
-    protected get isAdaptiveStream(): boolean;
-    protected handleVisibilityChange: (visible: boolean) => void;
-    protected handleVideoDimensionsChange: (dimensions: Track.Dimensions) => void;
-    emitTrackUpdate(): void;
-}
-//# sourceMappingURL=RemoteTrackPublication.d.ts.map
+import { SubscriptionError, TrackInfo } from '@livekit/protocol';
+import type { LoggerOptions } from '../types';
+import type RemoteTrack from './RemoteTrack';
+import { Track, VideoQuality } from './Track';
+import { TrackPublication } from './TrackPublication';
+export default class RemoteTrackPublication extends TrackPublication {
+    track?: RemoteTrack;
+    /** @internal */
+    protected allowed: boolean;
+    protected subscribed?: boolean;
+    protected requestedDisabled: boolean | undefined;
+    protected visible: boolean;
+    protected videoDimensionsAdaptiveStream?: Track.Dimensions;
+    protected requestedVideoDimensions?: Track.Dimensions;
+    protected requestedMaxQuality?: VideoQuality;
+    protected fps?: number;
+    protected subscriptionError?: SubscriptionError;
+    constructor(kind: Track.Kind, ti: TrackInfo, autoSubscribe: boolean | undefined, loggerOptions?: LoggerOptions);
+    /**
+     * Subscribe or unsubscribe to this remote track
+     * @param subscribed true to subscribe to a track, false to unsubscribe
+     */
+    setSubscribed(subscribed: boolean): void;
+    get subscriptionStatus(): TrackPublication.SubscriptionStatus;
+    get permissionStatus(): TrackPublication.PermissionStatus;
+    get isSubscribed(): boolean;
+    get isDesired(): boolean;
+    get isEnabled(): boolean;
+    get isLocal(): boolean;
+    /**
+     * disable server from sending down data for this track. this is useful when
+     * the participant is off screen, you may disable streaming down their video
+     * to reduce bandwidth requirements
+     * @param enabled
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * for tracks that support simulcasting, adjust subscribed quality
+     *
+     * This indicates the highest quality the client can accept. if network
+     * bandwidth does not allow, server will automatically reduce quality to
+     * optimize for uninterrupted video
+     */
+    setVideoQuality(quality: VideoQuality): void;
+    /**
+     * Explicitly set the video dimensions for this track.
+     *
+     * This will take precedence over adaptive stream dimensions.
+     *
+     * @param dimensions The video dimensions to set.
+     */
+    setVideoDimensions(dimensions: Track.Dimensions): void;
+    setVideoFPS(fps: number): void;
+    get videoQuality(): (VideoQuality | undefined);
+    /** @internal */
+    setTrack(track?: RemoteTrack): void;
+    /** @internal */
+    setAllowed(allowed: boolean): void;
+    /** @internal */
+    setSubscriptionError(error: SubscriptionError): void;
+    /** @internal */
+    updateInfo(info: TrackInfo): void;
+    private emitSubscriptionUpdateIfChanged;
+    private emitPermissionUpdateIfChanged;
+    private isManualOperationAllowed;
+    protected handleEnded: (track: RemoteTrack) => void;
+    protected get isAdaptiveStream(): boolean;
+    protected handleVisibilityChange: (visible: boolean) => void;
+    protected handleVideoDimensionsChange: (dimensions: Track.Dimensions) => void;
+    emitTrackUpdate(): void;
+}
+//# sourceMappingURL=RemoteTrackPublication.d.ts.map

package/dist/ts4.2/room/track/RemoteVideoTrack.d.ts

@@ -1,76 +1,73 @@
-import type { FrameMetadata } from '../../frameMetadata/types';
-import type { VideoReceiverStats } from '../stats';
-import type { LoggerOptions } from '../types';
-import type { FrameMetadataExtractor } from './FrameMetadataExtractor';
-import RemoteTrack from './RemoteTrack';
-import { Track } from './Track';
-import type { AdaptiveStreamSettings } from './types';
-export default class RemoteVideoTrack extends RemoteTrack<Track.Kind.Video> {
-    private prevStats?;
-    private elementInfos;
-    private adaptiveStreamSettings?;
-    private lastVisible?;
-    private lastDimensions?;
-    /** @internal */
-    frameMetadataExtractor?: FrameMetadataExtractor;
-    constructor(mediaTrack: MediaStreamTrack, sid: string, receiver: RTCRtpReceiver, adaptiveStreamSettings?: AdaptiveStreamSettings, loggerOptions?: LoggerOptions);
-    get isAdaptiveStream(): boolean;
-    /**
-     * Look up frame-level metadata for a given RTP timestamp.
-     * Use with the `TrackEvent.TimeSyncUpdate` event to correlate displayed frames
-     * with their capture-time metadata.
-     *
-     * Requires the room to be configured with the `frameMetadata` worker option
-     * and the publishing track to have frame metadata features enabled.
-     *
-     */
-    lookupFrameMetadata({ rtpTimestamp }: {
-        rtpTimestamp: number;
-    }): FrameMetadata | undefined;
-    setStreamState(value: Track.StreamState): void;
-    /**
-     * Note: When using adaptiveStream, you need to use remoteVideoTrack.attach() to add the track to a HTMLVideoElement, otherwise your video tracks might never start
-     */
-    get mediaStreamTrack(): MediaStreamTrack;
-    /** @internal */
-    setMuted(muted: boolean): void;
-    attach(): HTMLMediaElement;
-    attach(element: HTMLMediaElement): HTMLMediaElement;
-    /**
-     * Observe an ElementInfo for changes when adaptive streaming.
-     * @param elementInfo
-     * @internal
-     */
-    observeElementInfo(elementInfo: ElementInfo): void;
-    /**
-     * Stop observing an ElementInfo for changes.
-     * @param elementInfo
-     * @internal
-     */
-    stopObservingElementInfo(elementInfo: ElementInfo): void;
-    detach(): HTMLMediaElement[];
-    detach(element: HTMLMediaElement): HTMLMediaElement;
-    /** @internal */
-    getDecoderImplementation(): string | undefined;
-    protected monitorReceiver: () => Promise<void>;
-    getReceiverStats(): Promise<VideoReceiverStats | undefined>;
-    private stopObservingElement;
-    protected handleAppVisibilityChanged(): Promise<void>;
-    private readonly debouncedHandleResize;
-    private updateVisibility;
-    private updateDimensions;
-    private getPixelDensity;
-}
-export interface ElementInfo {
-    element: object;
-    width(): number;
-    height(): number;
-    visible: boolean;
-    pictureInPicture: boolean;
-    visibilityChangedAt: number | undefined;
-    handleResize?: () => void;
-    handleVisibilityChanged?: () => void;
-    observe(): void;
-    stopObserving(): void;
-}
-//# sourceMappingURL=RemoteVideoTrack.d.ts.map
+import type { FrameMetadata } from '../../frameMetadata/types';
+import type { VideoReceiverStats } from '../stats';
+import type { LoggerOptions } from '../types';
+import type { FrameMetadataExtractor } from './FrameMetadataExtractor';
+import RemoteTrack from './RemoteTrack';
+import { Track } from './Track';
+import type { AdaptiveStreamSettings } from './types';
+export default class RemoteVideoTrack extends RemoteTrack<Track.Kind.Video> {
+    private prevStats?;
+    private elementInfos;
+    private adaptiveStreamSettings?;
+    private lastVisible?;
+    private lastDimensions?;
+    /** @internal */
+    frameMetadataExtractor?: FrameMetadataExtractor;
+    constructor(mediaTrack: MediaStreamTrack, sid: string, receiver: RTCRtpReceiver, adaptiveStreamSettings?: AdaptiveStreamSettings, loggerOptions?: LoggerOptions);
+    get isAdaptiveStream(): boolean;
+    /**
+     * Look up frame-level metadata for a given RTP timestamp.
+     * Use with the `TrackEvent.TimeSyncUpdate` event to correlate displayed frames
+     * with their capture-time metadata.
+     *
+     * Requires the room to be configured with the `frameMetadata` worker option
+     * and the publishing track to have frame metadata features enabled.
+     *
+     */
+    lookupFrameMetadata({ rtpTimestamp }: {
+        rtpTimestamp: number;
+    }): FrameMetadata | undefined;
+    setStreamState(value: Track.StreamState): void;
+    get mediaStreamTrack(): MediaStreamTrack;
+    /** @internal */
+    setMuted(muted: boolean): void;
+    attach(): HTMLMediaElement;
+    attach(element: HTMLMediaElement): HTMLMediaElement;
+    /**
+     * Observe an ElementInfo for changes when adaptive streaming.
+     * @param elementInfo
+     * @internal
+     */
+    observeElementInfo(elementInfo: ElementInfo): void;
+    /**
+     * Stop observing an ElementInfo for changes.
+     * @param elementInfo
+     * @internal
+     */
+    stopObservingElementInfo(elementInfo: ElementInfo): void;
+    detach(): HTMLMediaElement[];
+    detach(element: HTMLMediaElement): HTMLMediaElement;
+    /** @internal */
+    getDecoderImplementation(): string | undefined;
+    protected monitorReceiver: () => Promise<void>;
+    getReceiverStats(): Promise<VideoReceiverStats | undefined>;
+    private stopObservingElement;
+    protected handleAppVisibilityChanged(): Promise<void>;
+    private readonly debouncedHandleResize;
+    private updateVisibility;
+    private updateDimensions;
+    private getPixelDensity;
+}
+export interface ElementInfo {
+    element: object;
+    width(): number;
+    height(): number;
+    visible: boolean;
+    pictureInPicture: boolean;
+    visibilityChangedAt: number | undefined;
+    handleResize?: () => void;
+    handleVisibilityChanged?: () => void;
+    observe(): void;
+    stopObserving(): void;
+}
+//# sourceMappingURL=RemoteVideoTrack.d.ts.map