@fishjam-cloud/ts-client 0.8.1 → 0.10.0

package/dist/src/FishjamClient.d.ts

@@ -1,511 +0,0 @@
-import type { BandwidthLimit, Encoding, Endpoint, MetadataParser, SimulcastConfig, TrackBandwidthLimit, TrackContext, WebRTCEndpointEvents } from './webrtc';
-import type TypedEmitter from 'typed-emitter';
-import type { ReconnectConfig } from './reconnection';
-import type { AuthErrorReason } from './auth';
-export type Peer<PeerMetadata, TrackMetadata> = Endpoint<PeerMetadata, TrackMetadata> & {
-    type: 'webrtc';
-};
-export type Component<PeerMetadata, TrackMetadata> = Omit<Endpoint<PeerMetadata, TrackMetadata>, 'type'> & {
-    type: 'recording' | 'hls' | 'file' | 'rtsp' | 'sip';
-};
-/**
- * Events emitted by the client with their arguments.
- */
-export interface MessageEvents<PeerMetadata, TrackMetadata> {
-    /**
-     * Emitted when connect method invoked
-     *
-     */
-    connectionStarted: () => void;
-    /**
-     * Emitted when the websocket connection is closed
-     *
-     * @param {CloseEvent} event - Close event object from the websocket
-     */
-    socketClose: (event: CloseEvent) => void;
-    /**
-     * Emitted when occurs an error in the websocket connection
-     *
-     * @param {Event} event - Event object from the websocket
-     */
-    socketError: (event: Event) => void;
-    /**
-     * Emitted when the websocket connection is opened
-     *
-     * @param {Event} event - Event object from the websocket
-     */
-    socketOpen: (event: Event) => void;
-    /** Emitted when authentication is successful */
-    authSuccess: () => void;
-    /** Emitted when authentication fails */
-    authError: (reason: AuthErrorReason) => void;
-    /** Emitted when the connection is closed */
-    disconnected: () => void;
-    /** Emitted when the process of reconnection starts */
-    reconnectionStarted: () => void;
-    /** Emitted on successful reconnection */
-    reconnected: () => void;
-    /** Emitted when the maximum number of reconnection retries is reached */
-    reconnectionRetriesLimitReached: () => void;
-    /**
-     * Called when peer was accepted.
-     */
-    joined: (peerId: string, peers: Peer<PeerMetadata, TrackMetadata>[], components: Component<PeerMetadata, TrackMetadata>[]) => void;
-    /**
-     * Called when peer was not accepted
-     * @param metadata - Pass through for client application to communicate further actions to frontend
-     */
-    joinError: (metadata: any) => void;
-    /**
-     * Called when data in a new track arrives.
-     *
-     * This callback is always called after {@link MessageEvents.trackAdded}.
-     * It informs user that data related to the given track arrives and can be played or displayed.
-     */
-    trackReady: (ctx: TrackContext<PeerMetadata, TrackMetadata>) => void;
-    /**
-     * Called each time the peer which was already in the room, adds new track. Fields track and stream will be set to null.
-     * These fields will be set to non-null value in {@link MessageEvents.trackReady}
-     */
-    trackAdded: (ctx: TrackContext<PeerMetadata, TrackMetadata>) => void;
-    /**
-     * Called when some track will no longer be sent.
-     *
-     * It will also be called before {@link MessageEvents.peerLeft} for each track of this peer.
-     */
-    trackRemoved: (ctx: TrackContext<PeerMetadata, TrackMetadata>) => void;
-    /**
-     * Called each time peer has its track metadata updated.
-     */
-    trackUpdated: (ctx: TrackContext<PeerMetadata, TrackMetadata>) => void;
-    /**
-     * Called each time new peer joins the room.
-     */
-    peerJoined: (peer: Peer<PeerMetadata, TrackMetadata>) => void;
-    /**
-     * Called each time peer leaves the room.
-     */
-    peerLeft: (peer: Peer<PeerMetadata, TrackMetadata>) => void;
-    /**
-     * Called each time peer has its metadata updated.
-     */
-    peerUpdated: (peer: Peer<PeerMetadata, TrackMetadata>) => void;
-    /**
-     * Called each time new peer joins the room.
-     */
-    componentAdded: (peer: Component<PeerMetadata, TrackMetadata>) => void;
-    /**
-     * Called each time peer leaves the room.
-     */
-    componentRemoved: (peer: Component<PeerMetadata, TrackMetadata>) => void;
-    /**
-     * Called each time peer has its metadata updated.
-     */
-    componentUpdated: (peer: Component<PeerMetadata, TrackMetadata>) => void;
-    /**
-     * Called in case of errors related to multimedia session e.g. ICE connection.
-     */
-    connectionError: (error: {
-        message: string;
-        event?: Event;
-    }) => void;
-    /**
-     * Currently, this callback is only invoked when DisplayManager in RTC Engine is
-     * enabled and simulcast is disabled.
-     *
-     * Called when priority of video tracks have changed.
-     * @param enabledTracks - list of tracks which will be sent to client from SFU
-     * @param disabledTracks - list of tracks which will not be sent to client from SFU
-     */
-    tracksPriorityChanged: (enabledTracks: TrackContext<PeerMetadata, TrackMetadata>[], disabledTracks: TrackContext<PeerMetadata, TrackMetadata>[]) => void;
-    /**
-     * Called every time the server estimates client's bandiwdth.
-     *
-     * @param {bigint} estimation - client's available incoming bitrate estimated
-     * by the server. It's measured in bits per second.
-     */
-    bandwidthEstimationChanged: (estimation: bigint) => void;
-    targetTrackEncodingRequested: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['targetTrackEncodingRequested']>[0]) => void;
-    localTrackAdded: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localTrackAdded']>[0]) => void;
-    localTrackRemoved: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localTrackRemoved']>[0]) => void;
-    localTrackReplaced: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localTrackReplaced']>[0]) => void;
-    localTrackMuted: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localTrackMuted']>[0]) => void;
-    localTrackUnmuted: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localTrackUnmuted']>[0]) => void;
-    localTrackBandwidthSet: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localTrackBandwidthSet']>[0]) => void;
-    localTrackEncodingBandwidthSet: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localTrackEncodingBandwidthSet']>[0]) => void;
-    localTrackEncodingEnabled: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localTrackEncodingEnabled']>[0]) => void;
-    localTrackEncodingDisabled: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localTrackEncodingDisabled']>[0]) => void;
-    localPeerMetadataChanged: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localEndpointMetadataChanged']>[0]) => void;
-    localTrackMetadataChanged: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localTrackMetadataChanged']>[0]) => void;
-    disconnectRequested: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['disconnectRequested']>[0]) => void;
-}
-/** Configuration object for the client */
-export interface ConnectConfig<PeerMetadata> {
-    /** Metadata for the peer */
-    peerMetadata: PeerMetadata;
-    /** Token for authentication */
-    token: string;
-    /** Fishjam url */
-    url: string;
-}
-export type CreateConfig<PeerMetadata, TrackMetadata> = {
-    peerMetadataParser?: MetadataParser<PeerMetadata>;
-    trackMetadataParser?: MetadataParser<TrackMetadata>;
-    reconnect?: ReconnectConfig | boolean;
-};
-declare const FishjamClient_base: new <PeerMetadata_1, TrackMetadata_1>() => TypedEmitter<Required<MessageEvents<PeerMetadata_1, TrackMetadata_1>>>;
-/**
- * FishjamClient is the main class to interact with Fishjam.
- *
- * @example
- * ```typescript
- * const client = new FishjamClient<PeerMetadata, TrackMetadata>();
- * 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 declare class FishjamClient<PeerMetadata, TrackMetadata> extends FishjamClient_base<PeerMetadata, TrackMetadata> {
-    private websocket;
-    private webrtc;
-    private removeEventListeners;
-    status: 'new' | 'initialized';
-    private connectConfig;
-    private reconnectManager;
-    private sendStatisticsInterval;
-    private readonly peerMetadataParser;
-    private readonly trackMetadataParser;
-    constructor(config?: CreateConfig<PeerMetadata, TrackMetadata>);
-    /**
-     * Uses the {@link !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, TrackMetadata>();
-     *
-     * client.connect({
-     *  peerMetadata: {},
-     *  token: peerToken
-     * });
-     * ```
-     *
-     * @param {ConnectConfig} config - Configuration object for the client
-     */
-    connect(config: ConnectConfig<PeerMetadata>): Promise<void>;
-    private initConnection;
-    private getUrl;
-    private initWebsocket;
-    /**
-     * Retrieves statistics related to the RTCPeerConnection.
-     * These statistics provide insights into the performance and status of the connection.
-     *
-     * @return {Promise<RTCStatsReport>}
-     *
-     * @external RTCPeerConnection#getStats()
-     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/getStats | MDN Web Docs: RTCPeerConnection.getStats()}
-     */
-    getStatistics(selector?: MediaStreamTrack | null): Promise<RTCStatsReport>;
-    /**
-     * Returns a snapshot of currently received remote tracks.
-     *
-     * @example
-     * if (client.getRemoteTracks()[trackId]?.simulcastConfig?.enabled) {
-     *   client.setTargetTrackEncoding(trackId, encoding);
-     * }
-     */
-    getRemoteTracks(): Readonly<Record<string, TrackContext<PeerMetadata, TrackMetadata>>>;
-    /**
-     * Returns a snapshot of currently received remote peers.
-     */
-    getRemotePeers(): Record<string, Peer<PeerMetadata, TrackMetadata>>;
-    getRemoteComponents(): Record<string, Component<PeerMetadata, TrackMetadata>>;
-    getLocalPeer(): Endpoint<PeerMetadata, TrackMetadata> | null;
-    getBandwidthEstimation(): bigint;
-    private setupCallbacks;
-    private sendStatistics;
-    /**
-     * 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<E extends keyof MessageEvents<PeerMetadata, TrackMetadata>>(event: E, listener: Required<MessageEvents<PeerMetadata, TrackMetadata>>[E]): this;
-    /**
-     * 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<E extends keyof MessageEvents<PeerMetadata, TrackMetadata>>(event: E, listener: Required<MessageEvents<PeerMetadata, TrackMetadata>>[E]): this;
-    private handleWebRTCNotInitialized;
-    /**
-     * 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 stream - Stream that this track belongs to.
-     * @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: MediaStreamTrack, trackMetadata?: TrackMetadata, simulcastConfig?: SimulcastConfig, maxBandwidth?: TrackBandwidthLimit): Promise<string>;
-    /**
-     * 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
-     */
-    replaceTrack(trackId: string, newTrack: MediaStreamTrack | null): Promise<void>;
-    /**
-     * 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
-     */
-    setTrackBandwidth(trackId: string, bandwidth: BandwidthLimit): Promise<boolean>;
-    /**
-     * 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
-     */
-    setEncodingBandwidth(trackId: string, rid: string, bandwidth: BandwidthLimit): Promise<boolean>;
-    /**
-     * 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: string): Promise<void>;
-    /**
-     * 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: string, encoding: Encoding): void;
-    /**
-     * 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: string, encoding: Encoding): Promise<void>;
-    /**
-     * 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 {rackEncoding} encoding - Encoding that will be disabled
-     */
-    disableTrackEncoding(trackId: string, encoding: Encoding): Promise<void>;
-    /**
-     * 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: PeerMetadata) => void;
-    /**
-     * 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: string, trackMetadata: TrackMetadata) => void;
-    isReconnecting(): boolean;
-    /**
-     * 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: () => void;
-    private isOpen;
-    /**
-     * 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, TrackMetadata>();
-     *
-     * client.connect({ ... });
-     *
-     * client.disconnect();
-     * ```
-     */
-    disconnect(): void;
-    cleanup(): void;
-}
-export {};