livekit-client 2.22.2 → 2.22.4

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