@fishjam-cloud/webrtc-client 0.25.1 → 0.25.2

package/dist/webrtc-client/src/dataChannels/DataChannel.js

@@ -0,0 +1,144 @@
+/**
+ * Wrapper class for RTCDataChannel.
+ * Handles bidirectional data transmission.
+ * @internal
+ */
+export class DataChannel {
+    type;
+    logger;
+    channel = null;
+    dataCallback = null;
+    openCallback = null;
+    errorCallback = null;
+    _status = 'init';
+    constructor(type, logger) {
+        this.type = type;
+        this.logger = logger;
+    }
+    /**
+     * Get the current status of the data channel
+     */
+    get status() {
+        return this._status;
+    }
+    /**
+     * Set the underlying RTCDataChannel and set up event listeners
+     */
+    setChannel(channel) {
+        this._status = 'creating';
+        this.channel = channel;
+        this.setupListeners();
+    }
+    /**
+     * Set callback to be called when the channel is opened
+     */
+    setOnOpen(callback) {
+        this.openCallback = callback;
+    }
+    /**
+     * Set callback to be called when the channel errors
+     */
+    setOnError(callback) {
+        this.errorCallback = callback;
+    }
+    /**
+     * Send data through the channel
+     * @param data - The data to send as Uint8Array
+     */
+    send(data) {
+        if (!this.channel || this._status !== 'open') {
+            this.logger.warn(`Cannot send data on ${this.type} channel: channel not ready (status: ${this._status})`);
+            return;
+        }
+        try {
+            this.channel.send(data);
+        }
+        catch (error) {
+            this.logger.error(`Error sending data on ${this.type} channel:`, error);
+        }
+    }
+    /**
+     * Set the callback for receiving data
+     * @param callback - Function to call when data is received
+     */
+    setCallback(callback) {
+        this.dataCallback = callback;
+    }
+    /**
+     * Close the data channel
+     */
+    close() {
+        if (this.channel) {
+            this.channel.close();
+        }
+        this._status = 'closed';
+        this.dataCallback = null;
+    }
+    /**
+     * Set up event listeners for the RTCDataChannel
+     * @private
+     */
+    setupListeners() {
+        if (!this.channel)
+            return;
+        this.channel.onopen = () => {
+            this._status = 'open';
+            this.logger.debug(`Data channel ${this.type} opened`);
+            this.openCallback?.();
+        };
+        this.channel.onclose = () => {
+            this._status = 'closed';
+            this.logger.debug(`Data channel ${this.type} closed`);
+        };
+        this.channel.onerror = (event) => {
+            this.logger.error(`Data channel ${this.type} error:`, event);
+            this.errorCallback?.(event);
+        };
+        this.channel.onmessage = (event) => {
+            this.handleMessage(event.data);
+        };
+    }
+    /**
+     * Handle incoming message data
+     * @private
+     */
+    handleMessage(data) {
+        if (!this.dataCallback) {
+            this.logger.warn(`Received data on ${this.type} channel but no callback is set`);
+            return;
+        }
+        try {
+            // Convert data to Uint8Array
+            let uint8Data;
+            if (data instanceof ArrayBuffer) {
+                uint8Data = new Uint8Array(data);
+            }
+            else if (data instanceof Uint8Array) {
+                uint8Data = data;
+            }
+            else if (typeof data === 'string') {
+                // Convert string to Uint8Array using TextEncoder
+                uint8Data = new TextEncoder().encode(data);
+            }
+            else if (data instanceof Blob) {
+                // For Blob, we need to read it asynchronously
+                const reader = new FileReader();
+                reader.onload = () => {
+                    if (reader.result instanceof ArrayBuffer) {
+                        this.dataCallback?.(new Uint8Array(reader.result));
+                    }
+                };
+                reader.readAsArrayBuffer(data);
+                return;
+            }
+            else {
+                this.logger.warn(`Received unsupported data type on ${this.type} channel:`, typeof data);
+                return;
+            }
+            this.dataCallback(uint8Data);
+        }
+        catch (error) {
+            this.logger.error(`Error handling message on ${this.type} channel:`, error);
+        }
+    }
+}

package/dist/webrtc-client/src/dataChannels/DataChannelManager.d.ts

@@ -0,0 +1,83 @@
+import type TypedEmitter from 'typed-emitter';
+import type { DataChannelManagerEvents, DataChannelOptions, Logger } from '../types';
+declare const DataChannelManager_base: new () => TypedEmitter<Required<DataChannelManagerEvents>>;
+/**
+ * Manages data channels for WebRTC connection.
+ * Handles automatic creation and lifecycle of up to 2 bidirectional channels (reliable and lossy).
+ *
+ * Events:
+ * - `ready` - Emitted when both reliable and lossy data channel publishers are ready to send data.
+ * - `channelOpen` - Emitted when a data channel is opened. Payload includes the channel type.
+ * - `error` - Emitted when a data channel errors. Payload includes the channel type and error.
+ * - `data` - Emitted when data is received on any data channel. Payload includes channel type and binary data.
+ *
+ * @internal
+ */
+export declare class DataChannelManager extends DataChannelManager_base {
+    private readonly createDataChannel;
+    private readonly triggerRenegotiation;
+    private readonly logger;
+    private reliableChannel;
+    private lossyChannel;
+    constructor(createDataChannel: (label: string, init: RTCDataChannelInit) => RTCDataChannel, triggerRenegotiation: () => void, logger: Logger);
+    /**
+     * Initialize channels and trigger renegotiation.
+     * Returns when both channels are open or throws if any channel errors.
+     */
+    connect(): Promise<void>;
+    /**
+     * Wait for both channels to be ready or throw on error.
+     * @private
+     */
+    private waitForChannelsReady;
+    /**
+     * Publish data through a data channel.
+     * Throws an error if the channel doesn't exist or isn't ready.
+     * @param data - The data to send as Uint8Array
+     * @param options - Options specifying which channel to use
+     * @throws Error if the channel doesn't exist or isn't open
+     */
+    publishData(data: Uint8Array, options: DataChannelOptions): void;
+    /**
+     * Close all data channels and remove all event listeners.
+     * Called during cleanup/disconnect.
+     */
+    cleanup(): void;
+    /**
+     * Check if both data channels are open and ready to send data.
+     * @returns true if both channels are open and ready, false otherwise
+     */
+    getChannelsReadiness(): boolean;
+    private createChannels;
+    /**
+     * Create a single data channel.
+     * @private
+     */
+    private createChannel;
+    /**
+     * Called when a data channel opens.
+     * Emits channelOpen event and checks if both channels are open.
+     * @private
+     */
+    private onChannelOpen;
+    /**
+     * Called when a data channel errors.
+     * @private
+     */
+    private onChannelError;
+    /**
+     * Handle data received from a channel and emit the dataReceived event.
+     * @param type - The type of channel the data was received on
+     * @param data - The received binary data
+     * @private
+     */
+    private onDataReceived;
+    /**
+     * Get existing channel wrapper or create a new one (without RTCDataChannel).
+     * @param type - The type of channel
+     * @returns The DataChannel wrapper instance
+     * @private
+     */
+    private getOrCreateChannelWrapper;
+}
+export {};

package/dist/webrtc-client/src/dataChannels/DataChannelManager.js

@@ -0,0 +1,184 @@
+import { EventEmitter } from 'events';
+import { DataChannel } from './DataChannel';
+/**
+ * Manages data channels for WebRTC connection.
+ * Handles automatic creation and lifecycle of up to 2 bidirectional channels (reliable and lossy).
+ *
+ * Events:
+ * - `ready` - Emitted when both reliable and lossy data channel publishers are ready to send data.
+ * - `channelOpen` - Emitted when a data channel is opened. Payload includes the channel type.
+ * - `error` - Emitted when a data channel errors. Payload includes the channel type and error.
+ * - `data` - Emitted when data is received on any data channel. Payload includes channel type and binary data.
+ *
+ * @internal
+ */
+export class DataChannelManager extends EventEmitter {
+    createDataChannel;
+    triggerRenegotiation;
+    logger;
+    reliableChannel = null;
+    lossyChannel = null;
+    constructor(createDataChannel, triggerRenegotiation, logger) {
+        super();
+        this.createDataChannel = createDataChannel;
+        this.triggerRenegotiation = triggerRenegotiation;
+        this.logger = logger;
+    }
+    /**
+     * Initialize channels and trigger renegotiation.
+     * Returns when both channels are open or throws if any channel errors.
+     */
+    async connect() {
+        if (this.getChannelsReadiness())
+            return;
+        this.createChannels();
+        this.triggerRenegotiation();
+        await this.waitForChannelsReady();
+    }
+    /**
+     * Wait for both channels to be ready or throw on error.
+     * @private
+     */
+    waitForChannelsReady() {
+        if (this.getChannelsReadiness())
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            const onReady = () => {
+                cleanup();
+                resolve();
+            };
+            const onError = (type, error) => {
+                cleanup();
+                reject(new Error(`Data channel ${type} error: ${error}`));
+            };
+            const cleanup = () => {
+                this.removeListener('ready', onReady);
+                this.removeListener('error', onError);
+            };
+            this.on('ready', onReady);
+            this.on('error', onError);
+        });
+    }
+    /**
+     * Publish data through a data channel.
+     * Throws an error if the channel doesn't exist or isn't ready.
+     * @param data - The data to send as Uint8Array
+     * @param options - Options specifying which channel to use
+     * @throws Error if the channel doesn't exist or isn't open
+     */
+    publishData(data, options) {
+        const type = options.reliable ? 'reliable' : 'lossy';
+        const channel = type === 'reliable' ? this.reliableChannel : this.lossyChannel;
+        if (!channel) {
+            throw new Error(`Cannot publish data: ${type} channel not created. Call connectDataPublishers() first or enable negotiateOnConnect.`);
+        }
+        if (channel.status !== 'open') {
+            throw new Error(`Cannot publish data: ${type} channel not ready (status: ${channel.status}). Wait for dataChannelsReady event.`);
+        }
+        channel.send(data);
+    }
+    /**
+     * Close all data channels and remove all event listeners.
+     * Called during cleanup/disconnect.
+     */
+    cleanup() {
+        this.logger.warn('Cleaning up data channels');
+        if (this.reliableChannel) {
+            this.reliableChannel.close();
+            this.reliableChannel = null;
+        }
+        if (this.lossyChannel) {
+            this.lossyChannel.close();
+            this.lossyChannel = null;
+        }
+        this.removeAllListeners();
+    }
+    /**
+     * Check if both data channels are open and ready to send data.
+     * @returns true if both channels are open and ready, false otherwise
+     */
+    getChannelsReadiness() {
+        return this.reliableChannel?.status === 'open' && this.lossyChannel?.status === 'open';
+    }
+    createChannels() {
+        this.createChannel('reliable');
+        this.createChannel('lossy');
+    }
+    /**
+     * Create a single data channel.
+     * @private
+     */
+    createChannel(type) {
+        const channel = this.getOrCreateChannelWrapper(type);
+        if (channel.status !== 'init')
+            return;
+        const label = type;
+        const config = type === 'reliable' ? { ordered: true } : { ordered: false, maxRetransmits: 0 };
+        const rtcChannel = this.createDataChannel(label, config);
+        channel.setOnOpen(() => this.onChannelOpen(type));
+        channel.setOnError((error) => this.onChannelError(type, error));
+        channel.setChannel(rtcChannel);
+        this.logger.warn(`Created ${type} data channel`);
+    }
+    /**
+     * Called when a data channel opens.
+     * Emits channelOpen event and checks if both channels are open.
+     * @private
+     */
+    onChannelOpen(type) {
+        this.logger.warn(`Data channel ${type} opened`);
+        this.emit('channelOpen', type);
+        // Check if both channels are now open
+        const bothReady = this.reliableChannel &&
+            this.reliableChannel.status === 'open' &&
+            this.lossyChannel &&
+            this.lossyChannel.status === 'open';
+        if (bothReady) {
+            this.logger.warn('All data publishers ready');
+            this.emit('ready');
+        }
+    }
+    /**
+     * Called when a data channel errors.
+     * @private
+     */
+    onChannelError(type, error) {
+        this.logger.error(`Data channel ${type} error:`, error);
+        this.emit('error', type, error);
+    }
+    /**
+     * Handle data received from a channel and emit the dataReceived event.
+     * @param type - The type of channel the data was received on
+     * @param data - The received binary data
+     * @private
+     */
+    onDataReceived(type, data) {
+        const payload = {
+            channelType: type,
+            data,
+        };
+        this.emit('data', payload);
+    }
+    /**
+     * Get existing channel wrapper or create a new one (without RTCDataChannel).
+     * @param type - The type of channel
+     * @returns The DataChannel wrapper instance
+     * @private
+     */
+    getOrCreateChannelWrapper(type) {
+        if (type === 'reliable') {
+            if (!this.reliableChannel) {
+                this.reliableChannel = new DataChannel(type, this.logger);
+                this.reliableChannel.setCallback((data) => this.onDataReceived(type, data));
+            }
+            return this.reliableChannel;
+        }
+        else {
+            if (!this.lossyChannel) {
+                this.lossyChannel = new DataChannel(type, this.logger);
+                this.lossyChannel.setCallback((data) => this.onDataReceived(type, data));
+            }
+            return this.lossyChannel;
+        }
+    }
+}

package/dist/webrtc-client/src/deferred.d.ts

@@ -0,0 +1,8 @@
+export declare class Deferred<T, E = unknown> {
+    promise: Promise<T>;
+    private resolveFn;
+    private rejectFn;
+    constructor();
+    resolve(value: T): void;
+    reject(reason?: E): void;
+}

package/dist/webrtc-client/src/deferred.js

@@ -0,0 +1,17 @@
+export class Deferred {
+    promise;
+    resolveFn = () => null;
+    rejectFn = () => null;
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this.resolveFn = resolve;
+            this.rejectFn = reject;
+        });
+    }
+    resolve(value) {
+        this.resolveFn(value);
+    }
+    reject(reason) {
+        this.rejectFn(reason);
+    }
+}

package/dist/webrtc-client/src/index.d.ts

@@ -0,0 +1,6 @@
+export { getLogger } from './logger';
+export type { MediaEvent, SerializedMediaEvent } from './mediaEvent';
+export type { BandwidthLimit, DataCallback, DataChannelMessagePayload, DataChannelOptions, DataChannelType, EncodingReason, Endpoint, Logger, SimulcastBandwidthLimit, TrackBandwidthLimit, TrackContext, TrackContextEvents, TrackKind, VadStatus, WebRTCEndpointEvents, } from './types';
+export { WebRTCEndpoint } from './webRTCEndpoint';
+export { MediaEvent_Track_SimulcastConfig as SimulcastConfig } from '@fishjam-cloud/protobufs/server';
+export { Variant } from '@fishjam-cloud/protobufs/shared';

package/dist/webrtc-client/src/index.js

@@ -0,0 +1,4 @@
+export { getLogger } from './logger';
+export { WebRTCEndpoint } from './webRTCEndpoint';
+export { MediaEvent_Track_SimulcastConfig as SimulcastConfig } from '@fishjam-cloud/protobufs/server';
+export { Variant } from '@fishjam-cloud/protobufs/shared';

package/dist/webrtc-client/src/internal.d.ts

@@ -0,0 +1,27 @@
+import type { MediaEvent_Track_SimulcastConfig } from '@fishjam-cloud/protobufs/server';
+import type { Variant } from '@fishjam-cloud/protobufs/shared';
+import type TypedEmitter from 'typed-emitter';
+import type { EncodingReason, Endpoint, TrackBandwidthLimit, TrackContext, TrackContextEvents, TrackKind, TrackNegotiationStatus, VadStatus } from './types';
+export declare const isTrackKind: (kind: string) => kind is TrackKind;
+declare const TrackContextImpl_base: new () => TypedEmitter<Required<TrackContextEvents>>;
+export declare class TrackContextImpl extends TrackContextImpl_base implements TrackContext {
+    endpoint: Endpoint;
+    trackId: string;
+    track: MediaStreamTrack | null;
+    trackKind: TrackKind | null;
+    stream: MediaStream | null;
+    metadata?: unknown;
+    metadataParsingError?: any;
+    simulcastConfig?: MediaEvent_Track_SimulcastConfig;
+    maxBandwidth: TrackBandwidthLimit;
+    encoding?: Variant;
+    encodingReason?: EncodingReason;
+    vadStatus: VadStatus;
+    negotiationStatus: TrackNegotiationStatus;
+    pendingMetadataUpdate: boolean;
+    constructor(endpoint: Endpoint, trackId: string, metadata: any, simulcastConfig?: MediaEvent_Track_SimulcastConfig);
+}
+export type EndpointWithTrackContext = Omit<Endpoint, 'tracks'> & {
+    tracks: Map<string, TrackContextImpl>;
+};
+export {};

package/dist/webrtc-client/src/internal.js

@@ -0,0 +1,18 @@
+import EventEmitter from 'events';
+export const isTrackKind = (kind) => kind === 'audio' || kind === 'video';
+export class TrackContextImpl extends EventEmitter {
+    constructor(endpoint, trackId, metadata, simulcastConfig = { enabled: false, enabledVariants: [], disabledVariants: [] }) {
+        super();
+        this.endpoint = endpoint;
+        this.trackId = trackId;
+        this.track = null;
+        this.trackKind = null;
+        this.stream = null;
+        this.metadata = metadata;
+        this.simulcastConfig = simulcastConfig;
+        this.maxBandwidth = 0;
+        this.vadStatus = 'silence';
+        this.negotiationStatus = 'awaiting';
+        this.pendingMetadataUpdate = false;
+    }
+}

package/dist/webrtc-client/src/logger.d.ts

@@ -0,0 +1,5 @@
+export declare const getLogger: (enableLogging: boolean) => {
+    readonly debug: (arg: unknown, ...args: unknown[]) => void;
+    readonly warn: (arg: unknown, ...args: unknown[]) => void;
+    readonly error: (arg: unknown, ...args: unknown[]) => void;
+};

package/dist/webrtc-client/src/logger.js

@@ -0,0 +1,15 @@
+const FISHJAM_PREFIX = '[FISHJAM]';
+export const getLogger = (enableLogging) => ({
+    debug: (arg, ...args) => {
+        if (enableLogging)
+            console.debug(FISHJAM_PREFIX, arg, ...args);
+    },
+    warn: (arg, ...args) => {
+        if (enableLogging)
+            console.warn(FISHJAM_PREFIX, arg, ...args);
+    },
+    error: (arg, ...args) => {
+        if (enableLogging)
+            console.error(FISHJAM_PREFIX, arg, ...args);
+    },
+});

package/dist/webrtc-client/src/mediaEvent.d.ts

@@ -0,0 +1,13 @@
+import { MediaEvent as PeerMediaEvent } from '@fishjam-cloud/protobufs/peer';
+import { MediaEvent as ServerMediaEvent } from '@fishjam-cloud/protobufs/server';
+export type SerializedMediaEvent = Uint8Array;
+export interface MediaEvent {
+    type: keyof PeerMediaEvent;
+    key?: string;
+    data?: any;
+}
+export declare function serializePeerMediaEvent(mediaEvent: PeerMediaEvent): Uint8Array;
+export declare function serializeServerMediaEvent(mediaEvent: ServerMediaEvent): Uint8Array;
+export declare function deserializeServerMediaEvent(serializedMediaEvent: SerializedMediaEvent): ServerMediaEvent;
+export declare function deserializePeerMediaEvent(serializedMediaEvent: SerializedMediaEvent): PeerMediaEvent;
+export declare function generateMediaEvent<T extends keyof PeerMediaEvent>(type: T, data?: PeerMediaEvent[T]): MediaEvent;

package/dist/webrtc-client/src/mediaEvent.js

@@ -0,0 +1,20 @@
+import { MediaEvent as PeerMediaEvent } from '@fishjam-cloud/protobufs/peer';
+import { MediaEvent as ServerMediaEvent } from '@fishjam-cloud/protobufs/server';
+export function serializePeerMediaEvent(mediaEvent) {
+    const encodedEvent = PeerMediaEvent.encode(mediaEvent).finish();
+    return encodedEvent;
+}
+export function serializeServerMediaEvent(mediaEvent) {
+    const encodedEvent = ServerMediaEvent.encode(mediaEvent).finish();
+    return encodedEvent;
+}
+export function deserializeServerMediaEvent(serializedMediaEvent) {
+    return ServerMediaEvent.decode(serializedMediaEvent);
+}
+export function deserializePeerMediaEvent(serializedMediaEvent) {
+    return PeerMediaEvent.decode(serializedMediaEvent);
+}
+export function generateMediaEvent(type, data) {
+    const mediaEvent = { type, data };
+    return mediaEvent;
+}

package/dist/webrtc-client/src/tracks/Local.d.ts

@@ -0,0 +1,49 @@
+import { MediaEvent as PeerMediaEvent, MediaEvent_SdpOffer } from '@fishjam-cloud/protobufs/peer';
+import { type MediaEvent_Track_SimulcastConfig } from '@fishjam-cloud/protobufs/server';
+import { Variant } from '@fishjam-cloud/protobufs/shared';
+import type { ConnectionManager } from '../ConnectionManager';
+import type { EndpointWithTrackContext } from '../internal';
+import { TrackContextImpl } from '../internal';
+import type { BandwidthLimit, RemoteTrackId, TrackBandwidthLimit, WebRTCEndpointEvents } from '../types';
+import type { WebRTCEndpoint } from '../webRTCEndpoint';
+import { LocalTrack } from './LocalTrack';
+import type { EndpointId, TrackId } from './TrackCommon';
+/**
+ * This class encapsulates methods related to handling the list of local tracks and local endpoint.
+ * It stores and mutates part of the client state for this local peer.
+ * It emits local events for local tracks and endpoints,
+ * and delegates mutation logic to the appropriate `LocalTrack` objects.
+ * It's responsible for creating `MidToTrackId` record which is required in `sdpOffer`
+ */
+export declare class Local {
+    private readonly localTracks;
+    private readonly localEndpoint;
+    private readonly emit;
+    private readonly sendMediaEvent;
+    private connection;
+    constructor(emit: <E extends keyof Required<WebRTCEndpointEvents>>(event: E, ...args: Parameters<Required<WebRTCEndpointEvents>[E]>) => void, sendMediaEvent: (mediaEvent: PeerMediaEvent) => void);
+    updateSenders: () => void;
+    updateMLineIds: (midToTrackIds: Record<string, string>) => void;
+    updateConnection: (connection: ConnectionManager) => void;
+    createSdpOfferEvent: (sdpOffer: RTCSessionDescriptionInit) => MediaEvent_SdpOffer;
+    addTrack: (connection: ConnectionManager | undefined, trackId: string, track: MediaStreamTrack, stream: MediaStream, trackMetadata: unknown | undefined, simulcastConfig: MediaEvent_Track_SimulcastConfig, maxBandwidth: TrackBandwidthLimit) => LocalTrack;
+    getTrackByMidOrNull: (mid: string) => LocalTrack | null;
+    removeTrack: (trackId: TrackId) => void;
+    replaceTrack: (webrtc: WebRTCEndpoint, trackId: TrackId, newTrack: MediaStreamTrack | null) => Promise<void>;
+    setEndpointMetadata: (metadata: unknown) => void;
+    getEndpoint: () => EndpointWithTrackContext;
+    setTrackBandwidth: (trackId: string, bandwidth: BandwidthLimit) => Promise<void>;
+    getTrackIdToTrack: () => Map<RemoteTrackId, TrackContextImpl>;
+    setLocalEndpointId: (endpointId: EndpointId) => void;
+    setEncodingBandwidth: (trackId: TrackId, rid: Variant, bandwidth: BandwidthLimit) => Promise<void>;
+    updateEndpointMetadata: (metadata: unknown) => void;
+    updateLocalTrackMetadata: (trackId: TrackId, metadata: unknown) => void;
+    disableLocalTrackEncoding: (trackId: string, encoding: Variant) => Promise<void>;
+    enableLocalTrackEncoding: (trackId: TrackId, variant: Variant) => Promise<void>;
+    private getTrackIdToMetadataJson;
+    private getTrackIdToTrackBitrates;
+    private getMidToTrackId;
+    private getTransceiverMapping;
+    setLocalTrackStatusToOffered: () => void;
+    addAllTracksToConnection: () => void;
+}