livekit-client 2.22.3 → 2.23.0

package/dist/ts4.2/room/data-track/LocalDataTrack.d.ts

@@ -1,80 +1,79 @@
-import type { StructuredLogger } from '../../logger';
-import { Future } from '../utils';
-import type { DataTrackFrame } from './frame';
-import type { DataTrackHandle } from './handle';
-import type OutgoingDataTrackManager from './outgoing/OutgoingDataTrackManager';
-import { DataTrackPushFrameError } from './outgoing/errors';
-import type { DataTrackOptions } from './outgoing/types';
-import type { IDataTrack, ILocalTrack } from './track-interfaces';
-import type { DataTrackInfo } from './types';
-export default class LocalDataTrack implements ILocalTrack, IDataTrack {
-    readonly trackSymbol: symbol;
-    readonly isLocal = true;
-    readonly typeSymbol: symbol;
-    protected options: DataTrackOptions;
-    /** Represents the currently active {@link DataTrackHandle} for the publication. */
-    protected handle: DataTrackHandle | null;
-    protected manager: OutgoingDataTrackManager;
-    protected log: StructuredLogger;
-    /** Resolves once the data track has sent all pending packets the rtc data channel buffer. */
-    protected flushedFuture: Future<void, never>;
-    protected isFlushed: boolean;
-    /** @internal */
-    constructor(options: DataTrackOptions, manager: OutgoingDataTrackManager);
-    private handleManagerReset;
-    private handleManagerPacketsFlushedChange;
-    /** @internal */
-    static withExplicitHandle(options: DataTrackOptions, manager: OutgoingDataTrackManager, handle: DataTrackHandle): LocalDataTrack;
-    /** Metrics about the data track publication. */
-    get info(): DataTrackInfo | undefined;
-    /** The raw descriptor from the manager containing the internal state for this local track. */
-    protected get descriptor(): import("./outgoing/OutgoingDataTrackManager").Descriptor | null;
-    /**
-     * Publish the track to the SFU. This must be done before calling {@link tryPush} for the first time.
-     * @internal
-     * */
-    publish(signal?: AbortSignal): Promise<void>;
-    isPublished(): this is {
-        info: DataTrackInfo;
-    };
-    /** Try pushing a frame to subscribers of the track.
-     *
-     * Pushing a frame can fail for several reasons:
-     *
-     * - The track has been unpublished by the local participant or SFU
-     * - The room is no longer connected
-     */
-    tryPush(frame: DataTrackFrame): Promise<import("@livekit/throws-transformer/throws").Throws<void, DataTrackPushFrameError<import("./outgoing/errors").DataTrackPushFrameErrorReason.TrackUnpublished> | DataTrackPushFrameError<import("./outgoing/errors").DataTrackPushFrameErrorReason.Dropped>>>;
-    /**
-     * When called, waits for all in flight packets to be sent before resolving.
-     *
-     * Use this to:
-     *
-     * 1. Send frames exactly in order:
-     * ```ts
-     * await track.tryPush(/* ... *\/);
-     * await track.flush();
-     * await track.tryPush(/* ... *\/);
-     * await track.flush();
-     * // ... etc ...
-     * ```
-     *
-     * 2. Wait for frames to all be delivered before unpublishing a local data track:
-     *
-     * ```ts
-     * await track.tryPush(/* ... *\/);
-     * await track.tryPush(/* ... *\/);
-     * await track.tryPush(/* ... *\/);
-     * // ... etc ...
-     * await track.flush();
-     * await track.unpublish();
-     * ```
-     **/
-    flush(): Promise<void>;
-    /**
-     * Unpublish the track from the SFU. Once this is called, any further calls to {@link tryPush}
-     * will fail.
-     * */
-    unpublish(): Promise<void>;
-}
-//# sourceMappingURL=LocalDataTrack.d.ts.map
+import type { StructuredLogger } from '../../logger';
+import { Future } from '../utils';
+import type { DataTrackFrame } from './frame';
+import type { DataTrackHandle } from './handle';
+import type OutgoingDataTrackManager from './outgoing/OutgoingDataTrackManager';
+import { DataTrackPushFrameError } from './outgoing/errors';
+import type { DataTrackOptions } from './outgoing/types';
+import type { IDataTrack, ILocalTrack } from './track-interfaces';
+import type { DataTrackInfo } from './types';
+export default class LocalDataTrack implements ILocalTrack, IDataTrack {
+    readonly trackSymbol: symbol;
+    readonly isLocal = true;
+    readonly typeSymbol: symbol;
+    protected options: DataTrackOptions;
+    /** Represents the currently active {@link DataTrackHandle} for the publication. */
+    protected handle: DataTrackHandle | null;
+    protected manager: OutgoingDataTrackManager;
+    protected log: StructuredLogger;
+    /** Resolves once the data track has sent all pending packets the rtc data channel buffer. */
+    protected flushedFuture: Future<void, never>;
+    protected isFlushed: boolean;
+    /** @internal */
+    constructor(options: DataTrackOptions, manager: OutgoingDataTrackManager);
+    private handleManagerReset;
+    private handleManagerPacketsFlushedChange;
+    /** @internal */
+    static withExplicitHandle(options: DataTrackOptions, manager: OutgoingDataTrackManager, handle: DataTrackHandle): LocalDataTrack;
+    get info(): (DataTrackInfo | undefined);
+    /** The raw descriptor from the manager containing the internal state for this local track. */
+    protected get descriptor(): (import("./outgoing/OutgoingDataTrackManager").Descriptor | null);
+    /**
+     * Publish the track to the SFU. This must be done before calling {@link tryPush} for the first time.
+     * @internal
+     * */
+    publish(signal?: AbortSignal): Promise<void>;
+    isPublished(): this is {
+        info: DataTrackInfo;
+    };
+    /** Try pushing a frame to subscribers of the track.
+     *
+     * Pushing a frame can fail for several reasons:
+     *
+     * - The track has been unpublished by the local participant or SFU
+     * - The room is no longer connected
+     */
+    tryPush(frame: DataTrackFrame): Promise<import("@livekit/throws-transformer/throws").Throws<void, DataTrackPushFrameError<import("./outgoing/errors").DataTrackPushFrameErrorReason.TrackUnpublished> | DataTrackPushFrameError<import("./outgoing/errors").DataTrackPushFrameErrorReason.Dropped>>>;
+    /**
+     * When called, waits for all in flight packets to be sent before resolving.
+     *
+     * Use this to:
+     *
+     * 1. Send frames exactly in order:
+     * ```ts
+     * await track.tryPush(/* ... *\/);
+     * await track.flush();
+     * await track.tryPush(/* ... *\/);
+     * await track.flush();
+     * // ... etc ...
+     * ```
+     *
+     * 2. Wait for frames to all be delivered before unpublishing a local data track:
+     *
+     * ```ts
+     * await track.tryPush(/* ... *\/);
+     * await track.tryPush(/* ... *\/);
+     * await track.tryPush(/* ... *\/);
+     * // ... etc ...
+     * await track.flush();
+     * await track.unpublish();
+     * ```
+     **/
+    flush(): Promise<void>;
+    /**
+     * Unpublish the track from the SFU. Once this is called, any further calls to {@link tryPush}
+     * will fail.
+     * */
+    unpublish(): Promise<void>;
+}
+//# sourceMappingURL=LocalDataTrack.d.ts.map

package/dist/ts4.2/room/data-track/RemoteDataTrack.d.ts

@@ -1,50 +1,50 @@
-import type Participant from '../participant/Participant';
-import type { DataTrackFrame } from './frame';
-import type IncomingDataTrackManager from './incoming/IncomingDataTrackManager';
-import type { IDataTrack, IRemoteTrack } from './track-interfaces';
-import type { DataTrackInfo, RemoteDataTrackPipelineOptions } from './types';
-type RemoteDataTrackOptions = {
-    publisherIdentity: Participant['identity'];
-};
-export type DataTrackSubscribeOptions = {
-    signal?: AbortSignal;
-    /** The number of {@link DataTrackFrame}s to hold in the ReadableStream before disgarding extra
-     * frames. Defaults to 16, but this may not be good enough for especially high frequency data. */
-    bufferSize?: number;
-};
-export default class RemoteDataTrack implements IRemoteTrack, IDataTrack {
-    readonly trackSymbol: symbol;
-    readonly isLocal = false;
-    readonly typeSymbol: symbol;
-    info: DataTrackInfo;
-    publisherIdentity: Participant['identity'];
-    protected manager: IncomingDataTrackManager;
-    /** @internal */
-    constructor(info: DataTrackInfo, manager: IncomingDataTrackManager, options: RemoteDataTrackOptions);
-    /** Subscribes to the data track to receive frames.
-     *
-     * # Returns
-     *
-     * A stream that yields {@link DataTrackFrame}s as they arrive.
-     *
-     * # Multiple Subscriptions
-     *
-     * An application may call `subscribe` more than once to process frames in
-     * multiple places. For example, one async task might plot values on a graph
-     * while another writes them to a file.
-     *
-     * Internally, only the first call to `subscribe` communicates with the SFU and
-     * allocates the resources required to receive frames. Additional subscriptions
-     * reuse the same underlying pipeline and do not trigger additional signaling.
-     *
-     * Note that newly created subscriptions only receive frames published after
-     * the initial subscription is established.
-     */
-    subscribe(options?: DataTrackSubscribeOptions): ReadableStream<DataTrackFrame>;
-    /** Configure how incoming frames for this track are processed before they are handed out to
-     * subscribers (the "pipeline"). These options apply to all current and future subscriptions
-     * of this track, and may be set at any time. */
-    setPipelineOptions(options: RemoteDataTrackPipelineOptions): void;
-}
-export {};
-//# sourceMappingURL=RemoteDataTrack.d.ts.map
+import type Participant from '../participant/Participant';
+import type { DataTrackFrame } from './frame';
+import type IncomingDataTrackManager from './incoming/IncomingDataTrackManager';
+import type { IDataTrack, IRemoteTrack } from './track-interfaces';
+import type { DataTrackInfo, RemoteDataTrackPipelineOptions } from './types';
+type RemoteDataTrackOptions = {
+    publisherIdentity: Participant['identity'];
+};
+export type DataTrackSubscribeOptions = {
+    signal?: AbortSignal;
+    /** The number of {@link DataTrackFrame}s to hold in the ReadableStream before disgarding extra
+     * frames. Defaults to 16, but this may not be good enough for especially high frequency data. */
+    bufferSize?: number;
+};
+export default class RemoteDataTrack implements IRemoteTrack, IDataTrack {
+    readonly trackSymbol: symbol;
+    readonly isLocal = false;
+    readonly typeSymbol: symbol;
+    info: DataTrackInfo;
+    publisherIdentity: Participant['identity'];
+    protected manager: IncomingDataTrackManager;
+    /** @internal */
+    constructor(info: DataTrackInfo, manager: IncomingDataTrackManager, options: RemoteDataTrackOptions);
+    /** Subscribes to the data track to receive frames.
+     *
+     * # Returns
+     *
+     * A stream that yields {@link DataTrackFrame}s as they arrive.
+     *
+     * # Multiple Subscriptions
+     *
+     * An application may call `subscribe` more than once to process frames in
+     * multiple places. For example, one async task might plot values on a graph
+     * while another writes them to a file.
+     *
+     * Internally, only the first call to `subscribe` communicates with the SFU and
+     * allocates the resources required to receive frames. Additional subscriptions
+     * reuse the same underlying pipeline and do not trigger additional signaling.
+     *
+     * Note that newly created subscriptions only receive frames published after
+     * the initial subscription is established.
+     */
+    subscribe(options?: DataTrackSubscribeOptions): ReadableStream<DataTrackFrame>;
+    /** Configure how incoming frames for this track are processed before they are handed out to
+     * subscribers (the "pipeline"). These options apply to all current and future subscriptions
+     * of this track, and may be set at any time. */
+    setPipelineOptions(options: RemoteDataTrackPipelineOptions): void;
+}
+export {};
+//# sourceMappingURL=RemoteDataTrack.d.ts.map

package/dist/ts4.2/room/data-track/depacketizer.d.ts

@@ -1,59 +1,59 @@
-import type { Throws } from '@livekit/throws-transformer/throws';
-import { LivekitReasonedError } from '../errors';
-import type { DataTrackFrameInternal } from './frame';
-import { DataTrackPacket } from './packet';
-/** An error indicating a frame was dropped. */
-export declare class DataTrackDepacketizerDropError<Reason extends DataTrackDepacketizerDropReason = DataTrackDepacketizerDropReason> extends LivekitReasonedError<Reason> {
-    readonly name = "DataTrackDepacketizerDropError";
-    reason: Reason;
-    reasonName: string;
-    frameNumber: number;
-    constructor(message: string, reason: Reason, frameNumber: number, options?: {
-        cause?: unknown;
-    });
-    static interrupted(frameNumber: number, newFrameNumber: number): DataTrackDepacketizerDropError<DataTrackDepacketizerDropReason.Interrupted>;
-    static unknownFrame(frameNumber: number): DataTrackDepacketizerDropError<DataTrackDepacketizerDropReason.UnknownFrame>;
-    static bufferFull(frameNumber: number): DataTrackDepacketizerDropError<DataTrackDepacketizerDropReason.BufferFull>;
-    static incomplete(frameNumber: number, receivedPackets: number, expectedPackets: number): DataTrackDepacketizerDropError<DataTrackDepacketizerDropReason.Incomplete>;
-}
-/** Reason why a frame was dropped. */
-export declare enum DataTrackDepacketizerDropReason {
-    Interrupted = 0,
-    UnknownFrame = 1,
-    BufferFull = 2,
-    Incomplete = 3
-}
-type PushOptions = {
-    /** If true, throws `DataTrackDepacketizerDropError.interrupted` instead of logging a warning
-     * when a new frame arrives while the partials map is at capacity. */
-    throwOnInterruption: boolean;
-    /** Maximum number of partial frames the depacketizer will track concurrently. When a new
-     * frame arrives while the partials map is at capacity, the oldest partial is evicted (or
-     * `DataTrackDepacketizerDropError.interrupted` is thrown when `throwOnInterruption` is set).
-     * Defaults to 1. */
-    maxPartialFrames?: number;
-};
-export default class DataTrackDepacketizer {
-    /** Maximum number of packets to buffer per frame before dropping. */
-    static MAX_BUFFER_PACKETS: number;
-    /** Partial frames currently being assembled, keyed by frame number. `Map` preserves insertion
-     * order, so the oldest entry is the first key. */
-    private partials;
-    /** Should be repeatedly called with received {@link DataTrackPacket}s - intermediate calls
-     * aggregate the packet's state internally, and return null.
-     *
-     * Once this method is called with the final packet to form a frame, a new {@link DataTrackFrameInternal}
-     * is returned.*/
-    push(packet: DataTrackPacket, options?: PushOptions): Throws<DataTrackFrameInternal | null, DataTrackDepacketizerDropError>;
-    reset(): void;
-    private peekOldestPartialFrameNumber;
-    private frameFromSingle;
-    /** Begin assembling a new packet. */
-    private beginPartial;
-    /** Push to the existing partial frame. */
-    private pushToPartial;
-    /** Try to reassemble the complete frame. */
-    private finalize;
-}
-export {};
-//# sourceMappingURL=depacketizer.d.ts.map
+import type { Throws } from '@livekit/throws-transformer/throws';
+import { LivekitReasonedError } from '../errors';
+import type { DataTrackFrameInternal } from './frame';
+import { DataTrackPacket } from './packet';
+/** An error indicating a frame was dropped. */
+export declare class DataTrackDepacketizerDropError<Reason extends DataTrackDepacketizerDropReason = DataTrackDepacketizerDropReason> extends LivekitReasonedError<Reason> {
+    readonly name = "DataTrackDepacketizerDropError";
+    reason: Reason;
+    reasonName: string;
+    frameNumber: number;
+    constructor(message: string, reason: Reason, frameNumber: number, options?: {
+        cause?: unknown;
+    });
+    static interrupted(frameNumber: number, newFrameNumber: number): DataTrackDepacketizerDropError<DataTrackDepacketizerDropReason.Interrupted>;
+    static unknownFrame(frameNumber: number): DataTrackDepacketizerDropError<DataTrackDepacketizerDropReason.UnknownFrame>;
+    static bufferFull(frameNumber: number): DataTrackDepacketizerDropError<DataTrackDepacketizerDropReason.BufferFull>;
+    static incomplete(frameNumber: number, receivedPackets: number, expectedPackets: number): DataTrackDepacketizerDropError<DataTrackDepacketizerDropReason.Incomplete>;
+}
+/** Reason why a frame was dropped. */
+export declare enum DataTrackDepacketizerDropReason {
+    Interrupted = 0,
+    UnknownFrame = 1,
+    BufferFull = 2,
+    Incomplete = 3
+}
+type PushOptions = {
+    /** If true, throws `DataTrackDepacketizerDropError.interrupted` instead of logging a warning
+     * when a new frame arrives while the partials map is at capacity. */
+    throwOnInterruption: boolean;
+    /** Maximum number of partial frames the depacketizer will track concurrently. When a new
+     * frame arrives while the partials map is at capacity, the oldest partial is evicted (or
+     * `DataTrackDepacketizerDropError.interrupted` is thrown when `throwOnInterruption` is set).
+     * Defaults to 1. */
+    maxPartialFrames?: number;
+};
+export default class DataTrackDepacketizer {
+    /** Maximum number of packets to buffer per frame before dropping. */
+    static MAX_BUFFER_PACKETS: number;
+    /** Partial frames currently being assembled, keyed by frame number. `Map` preserves insertion
+     * order, so the oldest entry is the first key. */
+    private partials;
+    /** Should be repeatedly called with received {@link DataTrackPacket}s - intermediate calls
+     * aggregate the packet's state internally, and return null.
+     *
+     * Once this method is called with the final packet to form a frame, a new {@link DataTrackFrameInternal}
+     * is returned.*/
+    push(packet: DataTrackPacket, options?: PushOptions): Throws<DataTrackFrameInternal | null, DataTrackDepacketizerDropError>;
+    reset(): void;
+    private peekOldestPartialFrameNumber;
+    private frameFromSingle;
+    /** Begin assembling a new packet. */
+    private beginPartial;
+    /** Push to the existing partial frame. */
+    private pushToPartial;
+    /** Try to reassemble the complete frame. */
+    private finalize;
+}
+export {};
+//# sourceMappingURL=depacketizer.d.ts.map

package/dist/ts4.2/room/data-track/frame.d.ts

@@ -1,22 +1,22 @@
-import type { NonSharedUint8Array } from '../../type-polyfills/non-shared-typed-arrays';
-import { DataTrackExtensions } from './packet/extensions';
-/** A pair of payload bytes and packet extensions which can be fed into a {@link DataTrackPacketizer}. */
-export type DataTrackFrame = {
-    payload: NonSharedUint8Array;
-    userTimestamp?: bigint;
-};
-/** An internal representation o data track frame which contains all SFU metadata. */
-export type DataTrackFrameInternal = {
-    payload: NonSharedUint8Array;
-    extensions: DataTrackExtensions;
-};
-export declare const DataTrackFrameInternal: {
-    from(frame: DataTrackFrame): {
-        payload: Uint8Array<ArrayBuffer>;
-        extensions: DataTrackExtensions;
-    };
-    /** Converts from a DataTrackFrameInternal -> DataTrackFrame. Some internal information is
-     * discarded like e2ee encrption extension data. */
-    lossyIntoFrame(frame: DataTrackFrameInternal): DataTrackFrame;
-};
-//# sourceMappingURL=frame.d.ts.map
+import type { NonSharedUint8Array } from '../../type-polyfills/non-shared-typed-arrays';
+import { DataTrackExtensions } from './packet/extensions';
+/** A pair of payload bytes and packet extensions which can be fed into a {@link DataTrackPacketizer}. */
+export type DataTrackFrame = {
+    payload: NonSharedUint8Array;
+    userTimestamp?: bigint;
+};
+/** An internal representation o data track frame which contains all SFU metadata. */
+export type DataTrackFrameInternal = {
+    payload: NonSharedUint8Array;
+    extensions: DataTrackExtensions;
+};
+export declare const DataTrackFrameInternal: {
+    from(frame: DataTrackFrame): {
+        payload: Uint8Array;
+        extensions: DataTrackExtensions;
+    };
+    /** Converts from a DataTrackFrameInternal -> DataTrackFrame. Some internal information is
+     * discarded like e2ee encrption extension data. */
+    lossyIntoFrame(frame: DataTrackFrameInternal): DataTrackFrame;
+};
+//# sourceMappingURL=frame.d.ts.map

package/dist/ts4.2/room/data-track/handle.d.ts

@@ -1,27 +1,27 @@
-import type { Throws } from '@livekit/throws-transformer/throws';
-import { LivekitReasonedError } from '../errors';
-export declare enum DataTrackHandleErrorReason {
-    Reserved = 0,
-    TooLarge = 1
-}
-export declare class DataTrackHandleError<Reason extends DataTrackHandleErrorReason = DataTrackHandleErrorReason> extends LivekitReasonedError<DataTrackHandleErrorReason> {
-    readonly name = "DataTrackHandleError";
-    reason: Reason;
-    reasonName: string;
-    constructor(message: string, reason: Reason);
-    isReason<R extends DataTrackHandleErrorReason>(reason: R): this is DataTrackHandleError<R>;
-    static tooLarge(): DataTrackHandleError<DataTrackHandleErrorReason.TooLarge>;
-    static reserved(value: number): DataTrackHandleError<DataTrackHandleErrorReason.Reserved>;
-}
-export type DataTrackHandle = number;
-export declare const DataTrackHandle: {
-    fromNumber(raw: number): Throws<DataTrackHandle, DataTrackHandleError>;
-};
-/** Manage allocating new handles which don't conflict over the lifetime of the client. */
-export declare class DataTrackHandleAllocator {
-    value: number;
-    /** Returns a unique track handle for the next publication, if one can be obtained. */
-    get(): DataTrackHandle | null;
-    reset(): void;
-}
-//# sourceMappingURL=handle.d.ts.map
+import type { Throws } from '@livekit/throws-transformer/throws';
+import { LivekitReasonedError } from '../errors';
+export declare enum DataTrackHandleErrorReason {
+    Reserved = 0,
+    TooLarge = 1
+}
+export declare class DataTrackHandleError<Reason extends DataTrackHandleErrorReason = DataTrackHandleErrorReason> extends LivekitReasonedError<DataTrackHandleErrorReason> {
+    readonly name = "DataTrackHandleError";
+    reason: Reason;
+    reasonName: string;
+    constructor(message: string, reason: Reason);
+    isReason<R extends DataTrackHandleErrorReason>(reason: R): this is DataTrackHandleError<R>;
+    static tooLarge(): DataTrackHandleError<DataTrackHandleErrorReason.TooLarge>;
+    static reserved(value: number): DataTrackHandleError<DataTrackHandleErrorReason.Reserved>;
+}
+export type DataTrackHandle = number;
+export declare const DataTrackHandle: {
+    fromNumber(raw: number): Throws<DataTrackHandle, DataTrackHandleError>;
+};
+/** Manage allocating new handles which don't conflict over the lifetime of the client. */
+export declare class DataTrackHandleAllocator {
+    value: number;
+    /** Returns a unique track handle for the next publication, if one can be obtained. */
+    get(): DataTrackHandle | null;
+    reset(): void;
+}
+//# sourceMappingURL=handle.d.ts.map