@fishjam-cloud/ts-client 0.25.1 → 0.25.2

package/dist/ts-client/src/FishjamClient.js

@@ -0,0 +1,821 @@
+import { PeerMessage, PeerMessage_RoomType, PeerMessage_SdkDeprecation_Status, } from '@fishjam-cloud/protobufs/fishjamPeer';
+import { MediaEvent as PeerMediaEvent } from '@fishjam-cloud/protobufs/peer';
+import { MediaEvent as ServerMediaEvent } from '@fishjam-cloud/protobufs/server';
+import { ChannelMessage } from '@fishjam-cloud/protobufs/shared';
+import { getLogger, WebRTCEndpoint } from '@fishjam-cloud/webrtc-client';
+import { EventEmitter } from 'events';
+import { isAuthError } from './auth';
+import { connectEventsHandler } from './connectEventsHandler';
+import { TrackTypeError } from './errors';
+import { isComponent, isJoinError, isPeer } from './guards';
+import { MessageQueue } from './messageQueue';
+import { ReconnectManager } from './reconnection';
+import { packageVersion } from './version';
+const STATISTICS_INTERVAL = 10_000;
+const WEBSOCKET_PATH = 'socket/peer/websocket';
+/**
+ * FishjamClient is the main class to interact with Fishjam.
+ *
+ * @example
+ * ```typescript
+ * const client = new FishjamClient<PeerMetadata>();
+ * const peerToken = "YOUR_PEER_TOKEN";
+ *
+ * // You can listen to events emitted by the client
+ * client.on("joined", (peerId, peersInRoom) => {
+ *  console.log("join success");
+ * });
+ *
+ * // Start the peer connection
+ * client.connect({
+ *  peerMetadata: {},
+ *  isSimulcastOn: false,
+ *  token: peerToken
+ * });
+ *
+ * // Close the peer connection
+ * client.disconnect();
+ * ```
+ *
+ * You can register callbacks to handle the events emitted by the Client.
+ *
+ * @example
+ * ```typescript
+ *
+ * client.on("trackReady", (ctx) => {
+ *  console.log("On track ready");
+ * });
+ * ```
+ */
+export class FishjamClient extends EventEmitter {
+    websocket = null;
+    webrtc = null;
+    removeEventListeners = null;
+    debug;
+    logger;
+    clientType;
+    status = 'new';
+    connectConfig = null;
+    isAudioOnlyConnection = false;
+    reconnectManager;
+    peerMessageQueue;
+    sendStatisticsInterval = undefined;
+    constructor(config) {
+        super();
+        this.debug = !!config?.debug;
+        this.logger = getLogger(this.debug);
+        this.clientType = config?.clientType ?? 'web';
+        this.reconnectManager = new ReconnectManager(this, (peerMetadata) => this.initConnection(peerMetadata), config?.reconnect ?? true);
+        this.peerMessageQueue = new MessageQueue({
+            sendMessage: (event) => this.websocket?.send(event),
+            checkIsReconnecting: () => this.reconnectManager.isReconnecting(),
+        });
+        this.on('reconnected', () => this.peerMessageQueue.attemptToSendAll());
+    }
+    /**
+     * Uses the WebSocket connection and {@link !WebRTCEndpoint | WebRTCEndpoint} to join to the room. Registers the callbacks to
+     * handle the events emitted by the {@link !WebRTCEndpoint | WebRTCEndpoint}. Make sure that peer metadata is serializable.
+     *
+     * @example
+     * ```typescript
+     * const client = new FishjamClient<PeerMetadata>();
+     *
+     * client.connect({
+     *  peerMetadata: {},
+     *  token: peerToken
+     * });
+     * ```
+     *
+     * @param {ConnectConfig} config - Configuration object for the client
+     */
+    async connect(config) {
+        this.emit('connectionStarted');
+        const result = connectEventsHandler(this);
+        this.reconnectManager.reset(config.peerMetadata);
+        this.connectConfig = config;
+        this.initConnection(config.peerMetadata);
+        return result;
+    }
+    async initConnection(peerMetadata) {
+        if (this.status === 'initialized') {
+            this.disconnect();
+        }
+        this.webrtc = new WebRTCEndpoint({
+            debug: this.debug,
+        });
+        this.initWebsocket(peerMetadata);
+        this.setupCallbacks();
+        this.status = 'initialized';
+    }
+    getUrl(url) {
+        if (url.endsWith('/'))
+            return `${url}${WEBSOCKET_PATH}`;
+        return `${url}/${WEBSOCKET_PATH}`;
+    }
+    initWebsocket(peerMetadata) {
+        if (!this.connectConfig)
+            throw Error('ConnectConfig is null');
+        const { token, url } = this.connectConfig;
+        const websocketUrl = this.getUrl(url);
+        this.websocket = new WebSocket(websocketUrl);
+        this.websocket.binaryType = 'arraybuffer';
+        const socketOpenHandler = (event) => {
+            this.emit('socketOpen', event);
+            const sdkVersion = `${this.clientType}-${packageVersion}`;
+            const message = PeerMessage.encode({ authRequest: { token, sdkVersion } }).finish();
+            this.websocket?.send(message);
+        };
+        const socketErrorHandler = (event) => {
+            this.emit('socketError', event);
+        };
+        const socketCloseHandler = (event) => {
+            if (isAuthError(event.reason)) {
+                this.emit('authError', event.reason);
+            }
+            if (isJoinError(event.reason)) {
+                this.emit('joinError', event.reason);
+            }
+            this.logger.warn(`Socket closed with reason: ${event.reason}`);
+            this.emit('socketClose', event);
+        };
+        this.websocket.addEventListener('open', socketOpenHandler);
+        this.websocket.addEventListener('error', socketErrorHandler);
+        this.websocket.addEventListener('close', socketCloseHandler);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const messageHandler = (event) => {
+            const uint8Array = new Uint8Array(event.data);
+            try {
+                const data = PeerMessage.decode(uint8Array);
+                const serverMediaEvent = data.serverMediaEvent;
+                if (data.authenticated) {
+                    this.isAudioOnlyConnection = data.authenticated.roomType === PeerMessage_RoomType.ROOM_TYPE_AUDIO_ONLY;
+                    if (data.authenticated.sdkDeprecation) {
+                        this.handleSdkDeprecation(data.authenticated.sdkDeprecation);
+                    }
+                    this.emit('authSuccess');
+                    this.webrtc?.connect(peerMetadata);
+                }
+                else if (data.authRequest) {
+                    this.logger.warn('Received unexpected control message: authRequest');
+                }
+                else if (serverMediaEvent) {
+                    this.webrtc?.receiveMediaEvent(ServerMediaEvent.encode(serverMediaEvent).finish());
+                }
+            }
+            catch (e) {
+                this.logger.warn(`Received invalid control message, error: ${e}`);
+            }
+        };
+        this.websocket.addEventListener('message', messageHandler);
+        this.removeEventListeners = () => {
+            this.websocket?.removeEventListener('open', socketOpenHandler);
+            this.websocket?.removeEventListener('error', socketErrorHandler);
+            this.websocket?.removeEventListener('close', socketCloseHandler);
+            this.websocket?.removeEventListener('message', messageHandler);
+        };
+    }
+    handleSdkDeprecation(sdkDeprecation) {
+        switch (sdkDeprecation.status) {
+            case PeerMessage_SdkDeprecation_Status.STATUS_UNSUPPORTED:
+                this.logger.error(sdkDeprecation.message);
+                break;
+            case PeerMessage_SdkDeprecation_Status.STATUS_DEPRECATED:
+                this.logger.warn(sdkDeprecation.message);
+                break;
+            default:
+                break;
+        }
+    }
+    /**
+     * Retrieves statistics related to the RTCPeerConnection.
+     * These statistics provide insights into the performance and status of the connection.
+     *
+     * @return {Promise<RTCStatsReport>}
+     *
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/getStats | MDN Web Docs: RTCPeerConnection.getStats()}
+     */
+    async getStatistics(selector) {
+        return (await this.webrtc?.getStatistics(selector)) ?? new Map();
+    }
+    /**
+     * Returns a snapshot of currently received remote tracks.
+     *
+     * @example
+     * if (client.getRemoteTracks()[trackId]?.simulcastConfig?.enabled) {
+     *   client.setTargetTrackEncoding(trackId, encoding);
+     * }
+     */
+    getRemoteTracks() {
+        return this.webrtc?.getRemoteTracks() ?? {};
+    }
+    /**
+     * Returns a snapshot of currently received remote peers.
+     */
+    getRemotePeers() {
+        return Object.entries(this.webrtc?.getRemoteEndpoints() ?? {}).reduce((acc, [id, peer]) => (isPeer(peer) ? { ...acc, [id]: peer } : acc), {});
+    }
+    getRemoteComponents() {
+        return Object.entries(this.webrtc?.getRemoteEndpoints() ?? {}).reduce((acc, [id, component]) => (isComponent(component) ? { ...acc, [id]: component } : acc), {});
+    }
+    getLocalPeer() {
+        return this.webrtc?.getLocalEndpoint() || null;
+    }
+    getBandwidthEstimation() {
+        if (!this.webrtc)
+            throw Error('Webrtc not initialized');
+        return this.webrtc?.getBandwidthEstimation();
+    }
+    isConnectingRelatedEvent(mediaEvent) {
+        return Boolean(mediaEvent.connect || mediaEvent.renegotiateTracks || mediaEvent.sdpOffer || mediaEvent.candidate);
+    }
+    setupCallbacks() {
+        this.webrtc?.on('sendMediaEvent', (mediaEvent) => {
+            const peerMediaEvent = PeerMediaEvent.decode(mediaEvent);
+            const serializedMessage = PeerMessage.encode({ peerMediaEvent }).finish();
+            if (this.isConnectingRelatedEvent(peerMediaEvent)) {
+                this.websocket?.send(serializedMessage);
+            }
+            else {
+                this.peerMessageQueue.enqueueMessage(serializedMessage);
+            }
+        });
+        this.webrtc?.on('connected', async (peerId, endpointsInRoom) => {
+            const peers = endpointsInRoom
+                .filter((endpoint) => isPeer(endpoint))
+                .map((peer) => peer);
+            const components = endpointsInRoom
+                .filter((endpoint) => isComponent(endpoint))
+                .map((component) => component);
+            await this.reconnectManager.handleReconnect();
+            this.sendStatisticsInterval = setInterval(() => this.sendStatistics(), STATISTICS_INTERVAL);
+            this.emit('joined', peerId, peers, components);
+        });
+        this.webrtc?.on('disconnected', () => {
+            this.emit('disconnected');
+            clearInterval(this.sendStatisticsInterval);
+        });
+        this.webrtc?.on('endpointAdded', (endpoint) => {
+            if (isPeer(endpoint)) {
+                this.emit('peerJoined', endpoint);
+            }
+            if (isComponent(endpoint)) {
+                this.emit('componentAdded', endpoint);
+            }
+        });
+        this.webrtc?.on('endpointRemoved', (endpoint) => {
+            if (isPeer(endpoint)) {
+                this.emit('peerLeft', endpoint);
+            }
+            if (isComponent(endpoint)) {
+                this.emit('componentRemoved', endpoint);
+            }
+        });
+        this.webrtc?.on('endpointUpdated', (endpoint) => {
+            if (isPeer(endpoint)) {
+                this.emit('peerUpdated', endpoint);
+            }
+            if (isComponent(endpoint)) {
+                this.emit('componentUpdated', endpoint);
+            }
+        });
+        this.webrtc?.on('trackReady', (ctx) => {
+            if (!isPeer(ctx.endpoint))
+                return;
+            this.emit('trackReady', ctx);
+        });
+        this.webrtc?.on('trackAdded', (ctx) => {
+            if (!isPeer(ctx.endpoint))
+                return;
+            this.emit('trackAdded', ctx);
+        });
+        this.webrtc?.on('trackRemoved', (ctx) => {
+            if (!isPeer(ctx.endpoint))
+                return;
+            this.emit('trackRemoved', ctx);
+            ctx.removeAllListeners();
+        });
+        this.webrtc?.on('trackUpdated', (ctx) => {
+            if (!isPeer(ctx.endpoint))
+                return;
+            this.emit('trackUpdated', ctx);
+        });
+        this.webrtc?.on('tracksPriorityChanged', (enabledTracks, disabledTracks) => {
+            this.emit('tracksPriorityChanged', enabledTracks, disabledTracks);
+        });
+        this.webrtc?.on('signalingError', (error) => {
+            this.emit('joinError', error);
+        });
+        this.webrtc?.on('connectionError', (error) => {
+            this.emit('connectionError', error);
+        });
+        this.webrtc?.on('bandwidthEstimationChanged', (estimation) => {
+            this.emit('bandwidthEstimationChanged', estimation);
+        });
+        this.webrtc?.on('targetTrackEncodingRequested', (event) => {
+            this.emit('targetTrackEncodingRequested', event);
+        });
+        this.webrtc?.on('localTrackAdded', (event) => {
+            this.emit('localTrackAdded', event);
+        });
+        this.webrtc?.on('localTrackRemoved', (event) => {
+            this.emit('localTrackRemoved', event);
+        });
+        this.webrtc?.on('localTrackReplaced', (event) => {
+            this.emit('localTrackReplaced', event);
+        });
+        this.webrtc?.on('localTrackBandwidthSet', (event) => {
+            this.emit('localTrackBandwidthSet', event);
+        });
+        this.webrtc?.on('localTrackMuted', (event) => {
+            this.emit('localTrackMuted', event);
+        });
+        this.webrtc?.on('localTrackUnmuted', (event) => {
+            this.emit('localTrackUnmuted', event);
+        });
+        this.webrtc?.on('localTrackBandwidthSet', (event) => {
+            this.emit('localTrackBandwidthSet', event);
+        });
+        this.webrtc?.on('localTrackEncodingEnabled', (event) => {
+            this.emit('localTrackEncodingEnabled', event);
+        });
+        this.webrtc?.on('localTrackEncodingDisabled', (event) => {
+            this.emit('localTrackEncodingDisabled', event);
+        });
+        this.webrtc?.on('localEndpointMetadataChanged', (event) => {
+            this.emit('localPeerMetadataChanged', event);
+        });
+        this.webrtc?.on('localTrackMetadataChanged', (event) => {
+            this.emit('localTrackMetadataChanged', event);
+        });
+        this.webrtc?.on('disconnectRequested', (event) => {
+            this.emit('disconnectRequested', event);
+        });
+        this.webrtc?.on('dataChannelsReady', () => {
+            this.emit('dataChannelsReady');
+        });
+        this.webrtc?.on('dataChannelsError', (error) => {
+            this.emit('dataChannelsError', error);
+        });
+    }
+    async sendStatistics() {
+        const statistics = await this.getStatistics();
+        const tracksStatistics = {};
+        statistics.forEach((report, key) => {
+            if (report.type === 'inbound-rtp' || report.type === 'outbound-rtp')
+                tracksStatistics[key] = report;
+        });
+        const message = PeerMessage.encode({
+            rtcStatsReport: { data: JSON.stringify(tracksStatistics) },
+        }).finish();
+        this.peerMessageQueue.enqueueMessage(message);
+    }
+    /**
+     * Register a callback to be called when the event is emitted.
+     * Full list of callbacks can be found here {@link MessageEvents}.
+     *
+     * @example
+     * ```ts
+     * const callback = ()=>{  };
+     *
+     * client.on("onJoinSuccess", callback);
+     * ```
+     *
+     * @param event - Event name from {@link MessageEvents}
+     * @param listener - Callback function to be called when the event is emitted
+     * @returns This
+     */
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    /**
+     * Remove a callback from the list of callbacks to be called when the event is emitted.
+     *
+     * @example
+     * ```ts
+     * const callback = ()=>{  };
+     *
+     * client.on("onJoinSuccess", callback);
+     *
+     * client.off("onJoinSuccess", callback);
+     * ```
+     *
+     * @param event - Event name from {@link MessageEvents}
+     * @param listener - Reference to function to be removed from called callbacks
+     * @returns This
+     */
+    off(event, listener) {
+        return super.off(event, listener);
+    }
+    handleWebRTCNotInitialized() {
+        return new Error('WebRTC is not initialized');
+    }
+    /**
+     * Adds track that will be sent to the RTC Engine.
+     *
+     * @example
+     * ```ts
+     * const localStream: MediaStream = new MediaStream();
+     * try {
+     *   const localAudioStream = await navigator.mediaDevices.getUserMedia(
+     *     { audio: true }
+     *   );
+     *   localAudioStream
+     *     .getTracks()
+     *     .forEach((track) => localStream.addTrack(track));
+     * } catch (error) {
+     *   console.error("Couldn't get microphone permission:", error);
+     * }
+     *
+     * try {
+     *   const localVideoStream = await navigator.mediaDevices.getUserMedia(
+     *     { video: true }
+     *   );
+     *   localVideoStream
+     *     .getTracks()
+     *     .forEach((track) => localStream.addTrack(track));
+     * } catch (error) {
+     *  console.error("Couldn't get camera permission:", error);
+     * }
+     *
+     * localStream
+     *  .getTracks()
+     *  .forEach((track) => client.addTrack(track, localStream));
+     * ```
+     *
+     * @param track - Audio or video track e.g. from your microphone or camera.
+     * @param trackMetadata - Any information about this track that other peers will receive in
+     * {@link MessageEvents.peerJoined}. E.g. this can source of the track - wheather it's screensharing, webcam or some
+     * other media device.
+     * @param simulcastConfig - Simulcast configuration. By default, simulcast is disabled. For more information refer to
+     * {@link !SimulcastConfig | SimulcastConfig}.
+     * @param maxBandwidth - Maximal bandwidth this track can use. Defaults to 0 which is unlimited. This option has no
+     * effect for simulcast and audio tracks. For simulcast tracks use {@link FishjamClient.setTrackBandwidth}.
+     * @returns {string} Returns id of added track
+     */
+    addTrack(track, trackMetadata, simulcastConfig = {
+        enabled: false,
+        enabledVariants: [],
+        disabledVariants: [],
+    }, maxBandwidth = 0) {
+        if (!this.webrtc)
+            throw this.handleWebRTCNotInitialized();
+        if (this.isAudioOnlyConnection && track.kind !== 'audio')
+            throw new TrackTypeError();
+        return this.webrtc.addTrack(track, trackMetadata, simulcastConfig, maxBandwidth);
+    }
+    /**
+     * Replaces a track that is being sent to the RTC Engine.
+     *
+     * @example
+     * ```ts
+     * // setup camera
+     * let localStream: MediaStream = new MediaStream();
+     * try {
+     *   localVideoStream = await navigator.mediaDevices.getUserMedia(
+     *     VIDEO_CONSTRAINTS
+     *   );
+     *   localVideoStream
+     *     .getTracks()
+     *     .forEach((track) => localStream.addTrack(track));
+     * } catch (error) {
+     *   console.error("Couldn't get camera permission:", error);
+     * }
+     * let oldTrackId;
+     * localStream
+     *  .getTracks()
+     *  .forEach((track) => trackId = webrtc.addTrack(track, localStream));
+     *
+     * // change camera
+     * const oldTrack = localStream.getVideoTracks()[0];
+     * let videoDeviceId = "abcd-1234";
+     * navigator.mediaDevices.getUserMedia({
+     *      video: {
+     *        ...(VIDEO_CONSTRAINTS as {}),
+     *        deviceId: {
+     *          exact: videoDeviceId,
+     *        },
+     *      }
+     *   })
+     *   .then((stream) => {
+     *     let videoTrack = stream.getVideoTracks()[0];
+     *     webrtc.replaceTrack(oldTrackId, videoTrack);
+     *   })
+     *   .catch((error) => {
+     *     console.error('Error switching camera', error);
+     *   })
+     * ```
+     *
+     * @param {string} trackId - Id of audio or video track to replace.
+     * @param {MediaStreamTrack} newTrack - New audio or video track.
+     * @returns {Promise<boolean>} Success
+     */
+    async replaceTrack(trackId, newTrack) {
+        if (!this.webrtc)
+            throw this.handleWebRTCNotInitialized();
+        return this.webrtc.replaceTrack(trackId, newTrack);
+    }
+    /**
+     * Updates maximum bandwidth for the track identified by trackId. This value directly translates to quality of the
+     * stream and, in case of video, to the amount of RTP packets being sent. In case trackId points at the simulcast
+     * track bandwidth is split between all of the variant streams proportionally to their resolution.
+     *
+     * @param {string} trackId
+     * @param {BandwidthLimit} bandwidth In kbps
+     * @returns {Promise<boolean>} Success
+     */
+    async setTrackBandwidth(trackId, bandwidth) {
+        if (!this.webrtc)
+            throw this.handleWebRTCNotInitialized();
+        await this.webrtc.setTrackBandwidth(trackId, bandwidth);
+        return true;
+    }
+    /**
+     * Updates maximum bandwidth for the given simulcast encoding of the given track.
+     *
+     * @param {string} trackId - Id of the track
+     * @param {string} rid - Rid of the encoding
+     * @param {BandwidthLimit} bandwidth - Desired max bandwidth used by the encoding (in kbps)
+     * @returns
+     */
+    async setEncodingBandwidth(trackId, rid, bandwidth) {
+        if (!this.webrtc)
+            throw this.handleWebRTCNotInitialized();
+        await this.webrtc.setEncodingBandwidth(trackId, rid, bandwidth);
+        return true;
+    }
+    /**
+     * Removes a track from connection that was being sent to the RTC Engine.
+     *
+     * @example
+     * ```ts
+     * // setup camera
+     * let localStream: MediaStream = new MediaStream();
+     * try {
+     *   localVideoStream = await navigator.mediaDevices.getUserMedia(
+     *     VIDEO_CONSTRAINTS
+     *   );
+     *   localVideoStream
+     *     .getTracks()
+     *     .forEach((track) => localStream.addTrack(track));
+     * } catch (error) {
+     *   console.error("Couldn't get camera permission:", error);
+     * }
+     *
+     * let trackId
+     * localStream
+     *  .getTracks()
+     *  .forEach((track) => trackId = webrtc.addTrack(track, localStream));
+     *
+     * // remove track
+     * webrtc.removeTrack(trackId)
+     * ```
+     *
+     * @param {string} trackId - Id of audio or video track to remove.
+     */
+    removeTrack(trackId) {
+        if (!this.webrtc)
+            throw this.handleWebRTCNotInitialized();
+        return this.webrtc.removeTrack(trackId);
+    }
+    /**
+     * Sets track encoding that server should send to the client library.
+     *
+     * The encoding will be sent whenever it is available. If chosen encoding is temporarily unavailable, some other
+     * encoding will be sent until chosen encoding becomes active again.
+     *
+     * @example
+     * ```ts
+     * webrtc.setTargetTrackEncoding(incomingTrackCtx.trackId, "l")
+     * ```
+     *
+     * @param {string} trackId - Id of track
+     * @param {Encoding} encoding - Encoding to receive
+     */
+    setTargetTrackEncoding(trackId, encoding) {
+        if (!this.webrtc)
+            throw this.handleWebRTCNotInitialized();
+        return this.webrtc.setTargetTrackEncoding(trackId, encoding);
+    }
+    /**
+     * Enables track encoding so that it will be sent to the server.
+     *
+     * @example
+     * ```ts
+     * const trackId = webrtc.addTrack(track, stream, {}, {enabled: true, active_encodings: ["l", "m", "h"]});
+     * webrtc.disableTrackEncoding(trackId, "l");
+     * // wait some time
+     * webrtc.enableTrackEncoding(trackId, "l");
+     * ```
+     *
+     * @param {string} trackId - Id of track
+     * @param {Encoding} encoding - Encoding that will be enabled
+     */
+    enableTrackEncoding(trackId, encoding) {
+        if (!this.webrtc)
+            throw this.handleWebRTCNotInitialized();
+        return this.webrtc.enableTrackEncoding(trackId, encoding);
+    }
+    /**
+     * Disables track encoding so that it will be no longer sent to the server.
+     *
+     * @example
+     * ```ts
+     * const trackId = webrtc.addTrack(track, stream, {}, {enabled: true, active_encodings: ["l", "m", "h"]});
+     * webrtc.disableTrackEncoding(trackId, "l");
+     * ```
+     *
+     * @param {string} trackId - Id of track
+     * @param {Encoding} encoding - Encoding that will be disabled
+     */
+    disableTrackEncoding(trackId, encoding) {
+        if (!this.webrtc)
+            throw this.handleWebRTCNotInitialized();
+        return this.webrtc.disableTrackEncoding(trackId, encoding);
+    }
+    /**
+     * Updates the metadata for the current peer.
+     *
+     * @param peerMetadata - Data about this peer that other peers will receive upon joining.
+     *
+     * If the metadata is different from what is already tracked in the room, the event {@link MessageEvents.peerUpdated} will
+     * be emitted for other peers in the room.
+     */
+    updatePeerMetadata = (peerMetadata) => {
+        if (!this.webrtc)
+            throw this.handleWebRTCNotInitialized();
+        this.webrtc.updateEndpointMetadata(peerMetadata);
+    };
+    /**
+     * Updates the metadata for a specific track.
+     *
+     * @param trackId - TrackId (generated in addTrack) of audio or video track.
+     * @param trackMetadata - Data about this track that other peers will receive upon joining.
+     *
+     * If the metadata is different from what is already tracked in the room, the event {@link MessageEvents.trackUpdated} will
+     * be emitted for other peers in the room.
+     */
+    updateTrackMetadata = (trackId, trackMetadata) => {
+        if (!this.webrtc)
+            throw this.handleWebRTCNotInitialized();
+        this.webrtc.updateTrackMetadata(trackId, trackMetadata);
+    };
+    isReconnecting() {
+        return this.reconnectManager.isReconnecting();
+    }
+    getDataChannelsReadiness() {
+        return this.webrtc?.getDataChannelsReadiness() ?? false;
+    }
+    /**
+     * Leaves the room. This function should be called when user leaves the room in a clean way e.g. by clicking a
+     * dedicated, custom button `disconnect`. As a result there will be generated one more media event that should be sent
+     * to the RTC Engine. Thanks to it each other peer will be notified that peer left in {@link MessageEvents.peerLeft},
+     */
+    leave = () => {
+        if (!this.webrtc)
+            throw this.handleWebRTCNotInitialized();
+        this.webrtc.disconnect();
+    };
+    // https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/readyState
+    isOpen(websocket) {
+        return websocket?.readyState === 1;
+    }
+    /**
+     * Create both reliable and lossy data channel publishers.
+     * This method must be called before publishData() can be used (unless negotiateOnConnect is enabled).
+     * Emits the 'dataChannelsReady' event when both channels are open and ready.
+     *
+     * @throws Error if data channels are not enabled in the constructor config
+     *
+     * @example
+     * ```typescript
+     * const client = new FishjamClient({ dataChannels: {} });
+     *
+     * client.on('dataChannelsReady', () => {
+     *   console.log('Data channels ready, can now send data');
+     *   client.publishData(new TextEncoder().encode('Hello'), { reliable: true });
+     * });
+     *
+     * client.createDataChannels();
+     * ```
+     */
+    createDataChannels() {
+        if (!this.webrtc)
+            throw this.handleWebRTCNotInitialized();
+        return this.webrtc.connectDataChannels();
+    }
+    /**
+     * Publish data through a data channel.
+     * The data channels must be created first by calling createDataChannels() or enabling negotiateOnConnect.
+     * Throws an error if the channel doesn't exist or isn't ready yet.
+     *
+     * @param data - The data to send as Uint8Array
+     * @param options - Options specifying which channel to use (reliable or lossy)
+     * @throws Error if the channel doesn't exist or isn't ready, or if webrtc is not initialized
+     *
+     * @example
+     * ```typescript
+     * client.on('dataChannelsReady', () => {
+     *   // Send reliable data
+     *   const data = new TextEncoder().encode('Hello World');
+     *   client.publishData(data, { reliable: true });
+     *
+     *   // Send lossy data for low-latency updates
+     *   const gameState = new Uint8Array([1, 2, 3, 4, 5]);
+     *   client.publishData(gameState, { reliable: false });
+     * });
+     *
+     * client.createDataChannels();
+     * ```
+     */
+    publishData(data, options) {
+        if (!this.webrtc)
+            throw this.handleWebRTCNotInitialized();
+        const message = ChannelMessage.encode({
+            source: 'mock',
+            destinations: ['*'],
+            binary: { data },
+        }).finish();
+        this.webrtc.publishData(message, options);
+    }
+    /**
+     * Subscribe to data from a specific channel type.
+     * Can be called before or after creating the data channels.
+     * If called before, the callback will be applied when the channel is created.
+     *
+     * @param callback - Function to call when data is received
+     * @param options - Options specifying which channel to subscribe to (reliable or lossy)
+     * @throws Error if webrtc is not initialized
+     *
+     * @example
+     * ```typescript
+     * // Subscribe to reliable channel
+     * client.subscribeData((data) => {
+     *   const message = new TextDecoder().decode(data);
+     *   console.log('Received:', message);
+     * }, { reliable: true });
+     *
+     * // Subscribe to lossy channel
+     * client.subscribeData((data) => {
+     *   console.log('Received game state:', data);
+     * }, { reliable: false });
+     *
+     * // Then create publishers
+     * client.createDataChannels();
+     * ```
+     */
+    subscribeData(callback, options) {
+        if (!this.webrtc)
+            throw this.handleWebRTCNotInitialized();
+        const publisherCb = ({ channelType, data }) => {
+            if (options.reliable && channelType !== 'reliable')
+                return;
+            if (!options.reliable && channelType !== 'lossy')
+                return;
+            try {
+                const { binary } = ChannelMessage.decode(data);
+                if (binary) {
+                    callback(binary.data);
+                }
+            }
+            catch (e) {
+                this.logger.warn(`Received invalid channel message, error: ${e}`);
+            }
+        };
+        this.webrtc.on('dataChannelPayload', publisherCb);
+        return () => this.webrtc?.off('dataChannelPayload', publisherCb);
+    }
+    /**
+     * Disconnect from the room, and close the websocket connection. Tries to leave the room gracefully, but if it fails,
+     * it will close the websocket anyway.
+     *
+     * @example
+     * ```typescript
+     * const client = new FishjamClient<PeerMetadata>();
+     *
+     * client.connect({ ... });
+     *
+     * client.disconnect();
+     * ```
+     */
+    disconnect() {
+        try {
+            this.webrtc?.removeAllListeners();
+            this.webrtc?.disconnect();
+            this.webrtc?.cleanUp();
+        }
+        catch (e) {
+            this.logger.warn(e);
+        }
+        this.removeEventListeners?.();
+        this.removeEventListeners = null;
+        if (this.isOpen(this.websocket || null)) {
+            this.websocket?.close();
+        }
+        this.websocket = null;
+        this.webrtc = null;
+        this.emit('disconnected');
+    }
+    cleanup() {
+        this.reconnectManager.cleanup();
+    }
+}