livekit-client 2.22.3 → 2.23.0

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

@@ -1,31 +1,42 @@
-import type Room from '../../Room';
-import type LocalTrack from '../LocalTrack';
-import type { Track } from '../Track';
-/**
- * @experimental
- */
-export type ProcessorOptions<T extends Track.Kind> = {
-    kind: T;
-    track: MediaStreamTrack;
-    element?: HTMLMediaElement;
-    audioContext?: AudioContext;
-    localTrack?: LocalTrack;
-};
-export interface AudioProcessorOptions extends ProcessorOptions<Track.Kind.Audio> {
-    audioContext: AudioContext;
-}
-/**
- * @experimental
- */
-export interface VideoProcessorOptions extends ProcessorOptions<Track.Kind.Video> {
-}
-export interface TrackProcessor<T extends Track.Kind, U extends ProcessorOptions<T> = ProcessorOptions<T>> {
-    name: string;
-    init: (opts: U) => Promise<void>;
-    restart: (opts: U) => Promise<void>;
-    destroy: () => Promise<void>;
-    processedTrack?: MediaStreamTrack;
-    onPublish?: (room: Room) => Promise<void>;
-    onUnpublish?: () => Promise<void>;
-}
-//# sourceMappingURL=types.d.ts.map
+import type Room from '../../Room';
+import type LocalTrack from '../LocalTrack';
+import type { Track } from '../Track';
+/**
+ * @experimental
+ */
+export type ProcessorOptions<T extends Track.Kind> = {
+    kind: T;
+    track: MediaStreamTrack;
+    element?: HTMLMediaElement;
+    audioContext?: AudioContext;
+    localTrack?: LocalTrack;
+};
+export interface AudioProcessorOptions extends ProcessorOptions<Track.Kind.Audio> {
+    audioContext: AudioContext;
+}
+/**
+ * @experimental
+ */
+export interface VideoProcessorOptions extends ProcessorOptions<Track.Kind.Video> {
+}
+/**
+ * A processor is bound to the track it was set on, not to the room, and it does not survive the
+ * track being stopped: unpublishing a track or disconnecting from a room destroys its processor.
+ * Both paths stop the track by default, so after reconnecting or republishing, call
+ * `setProcessor` again on the new track to put the processor back.
+ *
+ * The exception is `stopLocalTrackOnUnpublish: false`, which keeps the track alive across an
+ * unpublish or disconnect. A video processor then survives with it. An audio processor only
+ * survives if the audio context came from the application, because a context the SDK created is
+ * closed on disconnect and the processor goes with it.
+ */
+export interface TrackProcessor<T extends Track.Kind, U extends ProcessorOptions<T> = ProcessorOptions<T>> {
+    name: string;
+    init: (opts: U) => Promise<void>;
+    restart: (opts: U) => Promise<void>;
+    destroy: () => Promise<void>;
+    processedTrack?: MediaStreamTrack;
+    onPublish?: (room: Room) => Promise<void>;
+    onUnpublish?: () => Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -1,13 +1,13 @@
-import type LocalTrack from './LocalTrack';
-declare const RecorderBase: {
-    new (stream: MediaStream, options?: MediaRecorderOptions): MediaRecorder;
-    prototype: MediaRecorder;
-    isTypeSupported(type: string): boolean;
-};
-export declare class LocalTrackRecorder<T extends LocalTrack> extends RecorderBase {
-    byteStream: ReadableStream<Uint8Array>;
-    constructor(track: T, options?: MediaRecorderOptions);
-}
-export declare function isRecordingSupported(): boolean;
-export {};
-//# sourceMappingURL=record.d.ts.map
+import type LocalTrack from './LocalTrack';
+declare const RecorderBase: {
+    new (stream: MediaStream, options?: MediaRecorderOptions): MediaRecorder;
+    prototype: MediaRecorder;
+    isTypeSupported(type: string): boolean;
+};
+export declare class LocalTrackRecorder<T extends LocalTrack> extends RecorderBase {
+    byteStream: ReadableStream<Uint8Array>;
+    constructor(track: T, options?: MediaRecorderOptions);
+}
+export declare function isRecordingSupported(): boolean;
+export {};
+//# sourceMappingURL=record.d.ts.map

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

@@ -1,28 +1,28 @@
-import type LocalAudioTrack from './LocalAudioTrack';
-import type LocalVideoTrack from './LocalVideoTrack';
-import type RemoteAudioTrack from './RemoteAudioTrack';
-import type RemoteVideoTrack from './RemoteVideoTrack';
-export type AudioTrack = RemoteAudioTrack | LocalAudioTrack;
-export type VideoTrack = RemoteVideoTrack | LocalVideoTrack;
-export type AdaptiveStreamSettings = {
-    /**
-     * Set a custom pixel density. Defaults to 2 for high density screens (3+) or
-     * 1 otherwise.
-     * 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;
-};
-export interface ReplaceTrackOptions {
-    userProvidedTrack?: boolean;
-    stopProcessor?: boolean;
-}
-//# sourceMappingURL=types.d.ts.map
+import type LocalAudioTrack from './LocalAudioTrack';
+import type LocalVideoTrack from './LocalVideoTrack';
+import type RemoteAudioTrack from './RemoteAudioTrack';
+import type RemoteVideoTrack from './RemoteVideoTrack';
+export type AudioTrack = RemoteAudioTrack | LocalAudioTrack;
+export type VideoTrack = RemoteVideoTrack | LocalVideoTrack;
+export type AdaptiveStreamSettings = {
+    /**
+     * Set a custom pixel density. Defaults to 2 for high density screens (3+) or
+     * 1 otherwise.
+     * 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;
+};
+export interface ReplaceTrackOptions {
+    userProvidedTrack?: boolean;
+    stopProcessor?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -1,47 +1,60 @@
-import { TrackInfo, TrackPublishedResponse, TrackSource, VideoQuality } from '@livekit/protocol';
-import type { AudioProcessorOptions, TrackProcessor, VideoProcessorOptions } from '../..';
-import { Track } from './Track';
-import type { TrackPublication } from './TrackPublication';
-import type { AudioCaptureOptions, CreateLocalTracksOptions, ScreenShareCaptureOptions, VideoCaptureOptions, VideoCodec } 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;
-/**
- * @internal
- */
-export declare function kindToSource(kind: MediaDeviceKind): Track.Source.Camera | Track.Source.Microphone | Track.Source.Unknown;
-/**
- * @internal
- */
-export declare function sourceToKind(source: Track.Source): MediaDeviceKind | undefined;
-/**
- * @internal
- */
-export declare function screenCaptureToDisplayMediaStreamOptions(options: ScreenShareCaptureOptions): DisplayMediaStreamOptions;
-export declare function mimeTypeToVideoCodecString(mimeType: string): VideoCodec;
-export declare function getTrackPublicationInfo<T extends TrackPublication>(tracks: T[]): TrackPublishedResponse[];
-export declare function getLogContextFromTrack(track: Track | TrackPublication): Record<string, unknown>;
-export declare function supportsSynchronizationSources(): boolean;
-export declare function diffAttributes(oldValues: Record<string, string> | undefined, newValues: Record<string, string> | undefined): Record<string, string>;
-/** @internal */
-export declare function extractProcessorsFromOptions(options: CreateLocalTracksOptions): {
-    audioProcessor: TrackProcessor<Track.Kind.Audio, AudioProcessorOptions> | undefined;
-    videoProcessor: TrackProcessor<Track.Kind.Video, VideoProcessorOptions> | undefined;
-    optionsWithoutProcessor: {
-        audio?: boolean | AudioCaptureOptions;
-        video?: boolean | VideoCaptureOptions;
-    };
-};
-export declare function getTrackSourceFromProto(source: TrackSource): Track.Source;
-export declare function areDimensionsSmaller(a: Track.Dimensions, b: Track.Dimensions): boolean;
-export declare function layerDimensionsFor(trackInfo: TrackInfo, quality: VideoQuality): Track.Dimensions | undefined;
-//# sourceMappingURL=utils.d.ts.map
+import { TrackInfo, TrackPublishedResponse, TrackSource, VideoQuality } from '@livekit/protocol';
+import type { AudioProcessorOptions, TrackProcessor, VideoProcessorOptions } from '../..';
+import { Track } from './Track';
+import type { TrackPublication } from './TrackPublication';
+import type { AudioCaptureOptions, CreateLocalTracksOptions, ScreenShareCaptureOptions, VideoCaptureOptions, VideoCodec } 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;
+/**
+ * @internal
+ */
+export declare function kindToSource(kind: MediaDeviceKind): Track.Source.Camera | Track.Source.Microphone | Track.Source.Unknown;
+/**
+ * @internal
+ */
+export declare function sourceToKind(source: Track.Source): MediaDeviceKind | undefined;
+/**
+ * @internal
+ */
+export declare function screenCaptureToDisplayMediaStreamOptions(options: ScreenShareCaptureOptions): DisplayMediaStreamOptions;
+export declare function mimeTypeToVideoCodecString(mimeType: string): VideoCodec;
+export declare function getTrackPublicationInfo<T extends TrackPublication>(tracks: T[]): TrackPublishedResponse[];
+export declare function getLogContextFromTrack(track: Track | TrackPublication): Record<string, unknown>;
+export declare function supportsSynchronizationSources(): boolean;
+export declare function diffAttributes(oldValues: Record<string, string> | undefined, newValues: Record<string, string> | undefined): Record<string, string>;
+/** @internal */
+export declare function extractProcessorsFromOptions(options: CreateLocalTracksOptions): {
+    audioProcessor: TrackProcessor<Track.Kind.Audio, AudioProcessorOptions> | undefined;
+    videoProcessor: TrackProcessor<Track.Kind.Video, VideoProcessorOptions> | undefined;
+    optionsWithoutProcessor: {
+        audio?: boolean | AudioCaptureOptions;
+        video?: boolean | VideoCaptureOptions;
+    };
+};
+export declare function getTrackSourceFromProto(source: TrackSource): Track.Source;
+export declare function areDimensionsSmaller(a: Track.Dimensions, b: Track.Dimensions): boolean;
+export declare function layerDimensionsFor(trackInfo: TrackInfo, quality: VideoQuality): Track.Dimensions | undefined;
+/**
+ * Waits until `track` has actually produced a video frame.
+ *
+ * iOS keeps reporting the camera's sensor frame from `getSettings()` until the camera has
+ * delivered its first picture, so a portrait capture initially reads as landscape. The arrival
+ * of that first frame is the only reliable signal that the reported settings describe reality.
+ *
+ * Best effort, never throws. Resolves `true` when a frame was observed, `false` when no frame
+ * can be observed (the track is already ended, muted or disabled) or `timeoutMs` elapsed first.
+ *
+ * @internal
+ */
+export declare function waitForFirstVideoFrame(track: MediaStreamTrack, timeoutMs: number, candidateElements?: HTMLMediaElement[]): Promise<boolean>;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -1,127 +1,127 @@
-import type { DataStream_Chunk, Encryption_Type } from '@livekit/protocol';
-export type SimulationOptions = {
-    publish?: {
-        audio?: boolean;
-        video?: boolean;
-        useRealTracks?: boolean;
-    };
-    participants?: {
-        count?: number;
-        aspectRatios?: Array<number>;
-        audio?: boolean;
-        video?: boolean;
-    };
-};
-export interface SendTextOptions {
-    topic?: string;
-    destinationIdentities?: Array<string>;
-    attachments?: Array<File>;
-    onProgress?: (progress: number) => void;
-    attributes?: Record<string, string>;
-    /** Whether to compress the payload (deflate-raw). Defaults to true. Compression is only applied
-     * when every recipient supports data streams v2 and the runtime can compress. */
-    compress?: boolean;
-}
-export interface SendBytesOptions {
-    topic?: string;
-    destinationIdentities?: Array<string>;
-    attributes?: Record<string, string>;
-    onProgress?: (progress: number) => void;
-    /** Whether to compress the payload (deflate-raw). Defaults to true. Compression is only applied
-     * when every recipient supports data streams v2 and the runtime can compress. */
-    compress?: boolean;
-    name?: string;
-    mimeType?: string;
-}
-export interface StreamTextOptions {
-    topic?: string;
-    destinationIdentities?: Array<string>;
-    type?: 'create' | 'update';
-    streamId?: string;
-    version?: number;
-    attachedStreamIds?: Array<string>;
-    replyToStreamId?: string;
-    totalSize?: number;
-    attributes?: Record<string, string>;
-}
-export type StreamBytesOptions = {
-    name?: string;
-    topic?: string;
-    attributes?: Record<string, string>;
-    destinationIdentities?: Array<string>;
-    streamId?: string;
-    mimeType?: string;
-    totalSize?: number;
-};
-export type SendFileOptions = Pick<StreamBytesOptions, 'topic' | 'mimeType' | 'destinationIdentities'> & {
-    onProgress?: (progress: number) => void;
-    encryptionType?: Encryption_Type.NONE;
-    /** Whether to compress the payload (deflate-raw). Defaults to true. Compression is only applied
-     * when every recipient supports data streams v2 and the runtime can compress. */
-    compress?: boolean;
-};
-export type DataPublishOptions = {
-    /**
-     * whether to send this as reliable or lossy.
-     * For data that you need delivery guarantee (such as chat messages), use Reliable.
-     * For data that should arrive as quickly as possible, but you are ok with dropped
-     * packets, use Lossy.
-     */
-    reliable?: boolean;
-    /**
-     * the identities of participants who will receive the message, will be sent to every one if empty
-     */
-    destinationIdentities?: string[];
-    /** the topic under which the message gets published */
-    topic?: string;
-};
-export type LiveKitReactNativeInfo = {
-    platform: 'ios' | 'android' | 'windows' | 'macos' | 'web' | 'native';
-    devicePixelRatio: number;
-};
-export type SimulationScenario = 'signal-reconnect' | 'speaker' | 'node-failure' | 'server-leave' | 'migration' | 'resume-reconnect' | 'force-tcp' | 'force-tls' | 'full-reconnect' | 'subscriber-bandwidth' | 'disconnect-signal-on-resume' | 'disconnect-signal-on-resume-no-messages' | 'leave-full-reconnect' | 'fail-on-v1-path';
-export type LoggerOptions = {
-    loggerName?: string;
-    loggerContextCb?: () => Record<string, unknown>;
-};
-export interface TranscriptionSegment {
-    id: string;
-    text: string;
-    language: string;
-    startTime: number;
-    endTime: number;
-    final: boolean;
-    firstReceivedTime: number;
-    lastReceivedTime: number;
-}
-export interface ChatMessage {
-    id: string;
-    timestamp: number;
-    message: string;
-    editTimestamp?: number;
-    attachedFiles?: Array<File>;
-}
-export interface StreamController<T extends DataStream_Chunk> {
-    info: BaseStreamInfo;
-    controller: ReadableStreamDefaultController<T>;
-    startTime: number;
-    endTime?: number;
-    sendingParticipantIdentity: string;
-}
-export interface BaseStreamInfo {
-    id: string;
-    mimeType: string;
-    topic: string;
-    timestamp: number;
-    /** total size in bytes for finite streams and undefined for streams of unknown size */
-    size?: number;
-    attributes?: Record<string, string>;
-    encryptionType: Encryption_Type;
-}
-export interface ByteStreamInfo extends BaseStreamInfo {
-    name: string;
-}
-export interface TextStreamInfo extends BaseStreamInfo {
-    attachedStreamIds?: Array<string>;
-}
-//# sourceMappingURL=types.d.ts.map
+import type { DataStream_Chunk, Encryption_Type } from '@livekit/protocol';
+export type SimulationOptions = {
+    publish?: {
+        audio?: boolean;
+        video?: boolean;
+        useRealTracks?: boolean;
+    };
+    participants?: {
+        count?: number;
+        aspectRatios?: Array<number>;
+        audio?: boolean;
+        video?: boolean;
+    };
+};
+export interface SendTextOptions {
+    topic?: string;
+    destinationIdentities?: Array<string>;
+    attachments?: Array<File>;
+    onProgress?: (progress: number) => void;
+    attributes?: Record<string, string>;
+    /** Whether to compress the payload (deflate-raw). Defaults to true. Compression is only applied
+     * when every recipient supports data streams v2 and the runtime can compress. */
+    compress?: boolean;
+}
+export interface SendBytesOptions {
+    topic?: string;
+    destinationIdentities?: Array<string>;
+    attributes?: Record<string, string>;
+    onProgress?: (progress: number) => void;
+    /** Whether to compress the payload (deflate-raw). Defaults to true. Compression is only applied
+     * when every recipient supports data streams v2 and the runtime can compress. */
+    compress?: boolean;
+    name?: string;
+    mimeType?: string;
+}
+export interface StreamTextOptions {
+    topic?: string;
+    destinationIdentities?: Array<string>;
+    type?: 'create' | 'update';
+    streamId?: string;
+    version?: number;
+    attachedStreamIds?: Array<string>;
+    replyToStreamId?: string;
+    totalSize?: number;
+    attributes?: Record<string, string>;
+}
+export type StreamBytesOptions = {
+    name?: string;
+    topic?: string;
+    attributes?: Record<string, string>;
+    destinationIdentities?: Array<string>;
+    streamId?: string;
+    mimeType?: string;
+    totalSize?: number;
+};
+export type SendFileOptions = Pick<StreamBytesOptions, 'topic' | 'mimeType' | 'destinationIdentities'> & {
+    onProgress?: (progress: number) => void;
+    encryptionType?: Encryption_Type.NONE;
+    /** Whether to compress the payload (deflate-raw). Defaults to true. Compression is only applied
+     * when every recipient supports data streams v2 and the runtime can compress. */
+    compress?: boolean;
+};
+export type DataPublishOptions = {
+    /**
+     * whether to send this as reliable or lossy.
+     * For data that you need delivery guarantee (such as chat messages), use Reliable.
+     * For data that should arrive as quickly as possible, but you are ok with dropped
+     * packets, use Lossy.
+     */
+    reliable?: boolean;
+    /**
+     * the identities of participants who will receive the message, will be sent to every one if empty
+     */
+    destinationIdentities?: string[];
+    /** the topic under which the message gets published */
+    topic?: string;
+};
+export type LiveKitReactNativeInfo = {
+    platform: 'ios' | 'android' | 'windows' | 'macos' | 'web' | 'native';
+    devicePixelRatio: number;
+};
+export type SimulationScenario = 'signal-reconnect' | 'speaker' | 'node-failure' | 'server-leave' | 'migration' | 'resume-reconnect' | 'force-tcp' | 'force-tls' | 'full-reconnect' | 'subscriber-bandwidth' | 'disconnect-signal-on-resume' | 'disconnect-signal-on-resume-no-messages' | 'leave-full-reconnect' | 'fail-on-v1-path';
+export type LoggerOptions = {
+    loggerName?: string;
+    loggerContextCb?: () => Record<string, unknown>;
+};
+export interface TranscriptionSegment {
+    id: string;
+    text: string;
+    language: string;
+    startTime: number;
+    endTime: number;
+    final: boolean;
+    firstReceivedTime: number;
+    lastReceivedTime: number;
+}
+export interface ChatMessage {
+    id: string;
+    timestamp: number;
+    message: string;
+    editTimestamp?: number;
+    attachedFiles?: Array<File>;
+}
+export interface StreamController<T extends DataStream_Chunk> {
+    info: BaseStreamInfo;
+    controller: ReadableStreamDefaultController<T>;
+    startTime: number;
+    endTime?: number;
+    sendingParticipantIdentity: string;
+}
+export interface BaseStreamInfo {
+    id: string;
+    mimeType: string;
+    topic: string;
+    timestamp: number;
+    /** total size in bytes for finite streams and undefined for streams of unknown size */
+    size?: number;
+    attributes?: Record<string, string>;
+    encryptionType: Encryption_Type;
+}
+export interface ByteStreamInfo extends BaseStreamInfo {
+    name: string;
+}
+export interface TextStreamInfo extends BaseStreamInfo {
+    attachedStreamIds?: Array<string>;
+}
+//# sourceMappingURL=types.d.ts.map