@fishjam-cloud/ts-client 0.25.2 → 0.25.3

package/dist/ts-client/src/auth.d.ts

@@ -1,3 +0,0 @@
-export declare const AUTH_ERROR_REASONS: readonly ["missing token", "invalid token", "expired token", "room not found", "peer not found"];
-export type AuthErrorReason = (typeof AUTH_ERROR_REASONS)[number];
-export declare const isAuthError: (error: string) => error is AuthErrorReason;

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

@@ -1,8 +0,0 @@
-export const AUTH_ERROR_REASONS = [
-    'missing token',
-    'invalid token',
-    'expired token',
-    'room not found',
-    'peer not found',
-];
-export const isAuthError = (error) => AUTH_ERROR_REASONS.includes(error);

package/dist/ts-client/src/connectEventsHandler.d.ts

@@ -1,2 +0,0 @@
-import type { FishjamClient } from './FishjamClient';
-export declare function connectEventsHandler<P, S>(fishjamClient: FishjamClient<P, S>): Promise<void>;

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

@@ -1,22 +0,0 @@
-export function connectEventsHandler(fishjamClient) {
-    return new Promise((resolve, reject) => {
-        const onSuccess = () => {
-            clearCallbacks();
-            resolve();
-        };
-        const onError = () => {
-            clearCallbacks();
-            reject();
-        };
-        fishjamClient.on('joined', onSuccess);
-        fishjamClient.on('joinError', onError);
-        fishjamClient.on('authError', onError);
-        fishjamClient.on('socketError', onError);
-        const clearCallbacks = () => {
-            fishjamClient.removeListener('joined', onSuccess);
-            fishjamClient.removeListener('joinError', onError);
-            fishjamClient.removeListener('authError', onError);
-            fishjamClient.removeListener('socketError', onError);
-        };
-    });
-}

package/dist/ts-client/src/errors.d.ts

@@ -1,3 +0,0 @@
-export declare class TrackTypeError extends Error {
-    constructor();
-}

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

@@ -1,5 +0,0 @@
-export class TrackTypeError extends Error {
-    constructor() {
-        super(`Attempted to add video track to audio-only room. Please refer to the docs at https://docs.fishjam.io/audio-calls`);
-    }
-}

package/dist/ts-client/src/guards.d.ts

@@ -1,7 +0,0 @@
-import type { Endpoint } from '@fishjam-cloud/webrtc-client';
-import type { Component, Peer } from './types';
-export declare const isPeer: <PeerMetadata, TrackMetadata>(endpoint: Endpoint) => endpoint is Peer<PeerMetadata, TrackMetadata>;
-export declare const isComponent: (endpoint: Endpoint) => endpoint is Component;
-export declare const JOIN_ERRORS: readonly ["reached peers limit", "room not found", "node not found", "Invalid SDK version"];
-export type JoinErrorReason = (typeof JOIN_ERRORS)[number];
-export declare const isJoinError: (error: string) => error is JoinErrorReason;

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

@@ -1,8 +0,0 @@
-export const isPeer = (endpoint) => endpoint.type === 'webrtc' || endpoint.type === 'exwebrtc';
-export const isComponent = (endpoint) => endpoint.type === 'recording' ||
-    endpoint.type === 'hls' ||
-    endpoint.type === 'file' ||
-    endpoint.type === 'rtsp' ||
-    endpoint.type === 'sip';
-export const JOIN_ERRORS = ['reached peers limit', 'room not found', 'node not found', 'Invalid SDK version'];
-export const isJoinError = (error) => JOIN_ERRORS.some((knownError) => error.trim().toLowerCase().includes(knownError.trim().toLowerCase()));

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

@@ -1,9 +0,0 @@
-export { AUTH_ERROR_REASONS, type AuthErrorReason, isAuthError } from './auth';
-export { TrackTypeError } from './errors';
-export { FishjamClient } from './FishjamClient';
-export { isJoinError, JOIN_ERRORS, type JoinErrorReason } from './guards';
-export { type LivestreamCallbacks, LivestreamError, publishLivestream, type PublishLivestreamResult, receiveLivestream, type ReceiveLivestreamResult, } from './livestream';
-export type { ReconnectConfig, ReconnectionStatus } from './reconnection';
-export type { ClientType, Component, ConnectConfig, CreateConfig, FishjamTrackContext, GenericMetadata, MessageEvents, Metadata, Peer, TrackContextEvents, TrackMetadata, } from './types';
-export type { BandwidthLimit, DataCallback, DataChannelOptions, EncodingReason, Endpoint, Logger, SimulcastBandwidthLimit, SimulcastConfig, TrackBandwidthLimit, TrackContext, VadStatus, WebRTCEndpointEvents, } from '@fishjam-cloud/webrtc-client';
-export * from '@fishjam-cloud/webrtc-client';

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

@@ -1,6 +0,0 @@
-export { AUTH_ERROR_REASONS, isAuthError } from './auth';
-export { TrackTypeError } from './errors';
-export { FishjamClient } from './FishjamClient';
-export { isJoinError, JOIN_ERRORS } from './guards';
-export { LivestreamError, publishLivestream, receiveLivestream, } from './livestream';
-export * from '@fishjam-cloud/webrtc-client';

package/dist/ts-client/src/livestream.d.ts

@@ -1,20 +0,0 @@
-export type ReceiveLivestreamResult = {
-    stream: MediaStream;
-    stop: () => Promise<void>;
-    getStatistics: () => Promise<RTCStatsReport>;
-};
-export type PublishLivestreamResult = {
-    stopPublishing: () => Promise<void>;
-    getStatistics: () => Promise<RTCStatsReport>;
-};
-export declare enum LivestreamError {
-    UNAUTHORIZED = "unauthorized",
-    STREAM_NOT_FOUND = "stream_not_found",
-    UNKNOWN_ERROR = "unknown_error",
-    STREAMER_ALREADY_CONNECTED = "streamer_already_connected"
-}
-export type LivestreamCallbacks = {
-    onConnectionStateChange?: (pc: RTCPeerConnection) => void;
-};
-export declare function receiveLivestream(url: string, token?: string, callbacks?: LivestreamCallbacks): Promise<ReceiveLivestreamResult>;
-export declare function publishLivestream(stream: MediaStream, url: string, token: string, callbacks?: LivestreamCallbacks): Promise<PublishLivestreamResult>;

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

@@ -1,78 +0,0 @@
-export var LivestreamError;
-(function (LivestreamError) {
-    LivestreamError["UNAUTHORIZED"] = "unauthorized";
-    LivestreamError["STREAM_NOT_FOUND"] = "stream_not_found";
-    LivestreamError["UNKNOWN_ERROR"] = "unknown_error";
-    LivestreamError["STREAMER_ALREADY_CONNECTED"] = "streamer_already_connected";
-})(LivestreamError || (LivestreamError = {}));
-export async function receiveLivestream(url, token, callbacks) {
-    const pc = new RTCPeerConnection({ bundlePolicy: 'max-bundle' });
-    pc.addTransceiver('video', { direction: 'recvonly' });
-    pc.addTransceiver('audio', { direction: 'recvonly' });
-    pc.onconnectionstatechange = (_ev) => callbacks?.onConnectionStateChange?.(pc);
-    const { WHEPClient } = await import('@binbat/whip-whep/whep');
-    const whep = new WHEPClient();
-    return new Promise((resolve, reject) => {
-        pc.ontrack = (event) => {
-            const stream = event.streams[0];
-            if (stream) {
-                resolve({
-                    getStatistics: () => pc.getStats(),
-                    stream,
-                    stop: async () => {
-                        await whep.stop();
-                        callbacks?.onConnectionStateChange?.(pc);
-                    },
-                });
-            }
-        };
-        whep.view(pc, url, token).catch((e) => {
-            if (e instanceof Error) {
-                let error = LivestreamError.UNKNOWN_ERROR;
-                if (e.message.includes('401')) {
-                    error = LivestreamError.UNAUTHORIZED;
-                }
-                else if (e.message.includes('404')) {
-                    error = LivestreamError.STREAM_NOT_FOUND;
-                }
-                reject(error);
-            }
-        });
-    });
-}
-export async function publishLivestream(stream, url, token, callbacks) {
-    const pc = new RTCPeerConnection({ bundlePolicy: 'max-bundle' });
-    pc.onconnectionstatechange = (_ev) => callbacks?.onConnectionStateChange?.(pc);
-    const video = stream.getVideoTracks().at(0);
-    const audio = stream.getAudioTracks().at(0);
-    if (!video && !audio) {
-        throw Error('To publish a livestream with WHIP, you need to supply at least one video or audio track.');
-    }
-    if (video)
-        pc.addTransceiver(video, { direction: 'sendonly' });
-    if (audio)
-        pc.addTransceiver(audio, { direction: 'sendonly' });
-    const { WHIPClient } = await import('@binbat/whip-whep/whip');
-    const whip = new WHIPClient();
-    try {
-        await whip.publish(pc, url, token);
-    }
-    catch (e) {
-        if (e instanceof Error) {
-            if (e.message.includes('401'))
-                throw LivestreamError.UNAUTHORIZED;
-            if (e.message.includes('404'))
-                throw LivestreamError.STREAM_NOT_FOUND;
-            if (e.message.includes('409'))
-                throw LivestreamError.STREAMER_ALREADY_CONNECTED;
-        }
-        throw LivestreamError.UNKNOWN_ERROR;
-    }
-    return {
-        getStatistics: () => pc.getStats(),
-        stopPublishing: async () => {
-            await whip.stop();
-            callbacks?.onConnectionStateChange?.(pc);
-        },
-    };
-}

package/dist/ts-client/src/messageQueue.d.ts

@@ -1,13 +0,0 @@
-type MessageQueueParams = {
-    checkIsReconnecting: () => boolean;
-    sendMessage: (message: Uint8Array) => void;
-};
-export declare class MessageQueue {
-    private queuedMessages;
-    private checkIsReconnecting;
-    private sendMessage;
-    constructor({ checkIsReconnecting, sendMessage }: MessageQueueParams);
-    enqueueMessage(mediaEvent: Uint8Array): void;
-    attemptToSendAll(): void;
-}
-export {};

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

@@ -1,23 +0,0 @@
-export class MessageQueue {
-    queuedMessages = [];
-    checkIsReconnecting;
-    sendMessage;
-    constructor({ checkIsReconnecting, sendMessage }) {
-        this.checkIsReconnecting = checkIsReconnecting;
-        this.sendMessage = sendMessage;
-    }
-    enqueueMessage(mediaEvent) {
-        this.queuedMessages.push(mediaEvent);
-        this.attemptToSendAll();
-    }
-    attemptToSendAll() {
-        const isReconnecting = this.checkIsReconnecting();
-        if (isReconnecting)
-            return;
-        while (this.queuedMessages.length > 0) {
-            const oldestMessage = this.queuedMessages.shift();
-            if (oldestMessage)
-                this.sendMessage(oldestMessage);
-        }
-    }
-}

package/dist/ts-client/src/reconnection.d.ts

@@ -1,27 +0,0 @@
-import type { FishjamClient } from './FishjamClient';
-export type ReconnectionStatus = 'reconnecting' | 'idle' | 'error';
-export type ReconnectConfig = {
-    maxAttempts?: number;
-    initialDelay?: number;
-    delay?: number;
-    addTracksOnReconnect?: boolean;
-};
-export declare class ReconnectManager<PeerMetadata, ServerMetadata> {
-    private readonly reconnectConfig;
-    private readonly connect;
-    private readonly client;
-    private initialPeerMetadata;
-    private reconnectAttempt;
-    private reconnectTimeoutId;
-    private status;
-    private lastLocalEndpoint;
-    private removeEventListeners;
-    constructor(client: FishjamClient<PeerMetadata, ServerMetadata>, connect: (metadata: PeerMetadata) => Promise<void>, config?: ReconnectConfig | boolean);
-    isReconnecting(): boolean;
-    reset(initialPeerMetadata: PeerMetadata): void;
-    private getLastPeerMetadata;
-    private reconnect;
-    handleReconnect(): Promise<void>;
-    cleanup(): void;
-}
-export declare const createReconnectConfig: (config?: ReconnectConfig | boolean) => Required<ReconnectConfig>;

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

@@ -1,124 +0,0 @@
-import { isAuthError } from './auth';
-import { isJoinError } from './guards';
-const DISABLED_RECONNECT_CONFIG = {
-    maxAttempts: 0,
-    initialDelay: 0,
-    delay: 0,
-    addTracksOnReconnect: false,
-};
-const DEFAULT_RECONNECT_CONFIG = {
-    maxAttempts: 3,
-    initialDelay: 500,
-    delay: 500,
-    addTracksOnReconnect: false,
-};
-export class ReconnectManager {
-    reconnectConfig;
-    connect;
-    client;
-    initialPeerMetadata = undefined;
-    reconnectAttempt = 0;
-    reconnectTimeoutId = null;
-    status = 'idle';
-    lastLocalEndpoint = null;
-    removeEventListeners = () => { };
-    constructor(client, connect, config) {
-        this.client = client;
-        this.connect = connect;
-        this.reconnectConfig = createReconnectConfig(config);
-        const onSocketError = () => {
-            this.reconnect();
-        };
-        this.client.on('socketError', onSocketError);
-        const onConnectionError = () => {
-            this.reconnect();
-        };
-        this.client.on('connectionError', onConnectionError);
-        const onSocketClose = (event) => {
-            if (isAuthError(event.reason))
-                return;
-            if (isJoinError(event.reason))
-                return;
-            this.reconnect();
-        };
-        this.client.on('socketClose', onSocketClose);
-        const onAuthSuccess = () => {
-            this.reset(this.initialPeerMetadata);
-        };
-        this.client.on('authSuccess', onAuthSuccess);
-        this.removeEventListeners = () => {
-            this.client.off('socketError', onSocketError);
-            this.client.off('connectionError', onConnectionError);
-            this.client.off('socketClose', onSocketClose);
-            this.client.off('authSuccess', onAuthSuccess);
-        };
-    }
-    isReconnecting() {
-        return this.status === 'reconnecting';
-    }
-    reset(initialPeerMetadata) {
-        this.initialPeerMetadata = initialPeerMetadata;
-        this.reconnectAttempt = 0;
-        if (this.reconnectTimeoutId)
-            clearTimeout(this.reconnectTimeoutId);
-        this.reconnectTimeoutId = null;
-    }
-    getLastPeerMetadata() {
-        const endpointMetadata = this.lastLocalEndpoint?.metadata;
-        return endpointMetadata?.peer;
-    }
-    reconnect() {
-        if (this.reconnectTimeoutId)
-            return;
-        if (this.reconnectAttempt >= this.reconnectConfig.maxAttempts) {
-            if (this.status === 'reconnecting') {
-                this.status = 'error';
-                this.client.emit('reconnectionRetriesLimitReached');
-            }
-            return;
-        }
-        if (this.status !== 'reconnecting') {
-            this.status = 'reconnecting';
-            this.client.emit('reconnectionStarted');
-            this.lastLocalEndpoint = this.client.getLocalPeer() || null;
-        }
-        const timeout = this.reconnectConfig.initialDelay + this.reconnectAttempt * this.reconnectConfig.delay;
-        this.reconnectAttempt += 1;
-        this.reconnectTimeoutId = setTimeout(() => {
-            this.reconnectTimeoutId = null;
-            const peerMetadata = this.getLastPeerMetadata() ?? this.initialPeerMetadata;
-            this.connect(peerMetadata);
-        }, timeout);
-    }
-    async handleReconnect() {
-        if (this.status !== 'reconnecting')
-            return;
-        if (this.lastLocalEndpoint && this.reconnectConfig.addTracksOnReconnect) {
-            for await (const element of this.lastLocalEndpoint.tracks) {
-                const [_, track] = element;
-                if (!track.track || track.track.readyState !== 'live')
-                    return;
-                await this.client.addTrack(track.track, track.metadata, track.simulcastConfig, track.maxBandwidth);
-            }
-        }
-        this.lastLocalEndpoint = null;
-        this.status = 'idle';
-        this.client.emit('reconnected');
-    }
-    cleanup() {
-        this.removeEventListeners();
-        this.removeEventListeners = () => { };
-    }
-}
-export const createReconnectConfig = (config) => {
-    if (!config)
-        return DISABLED_RECONNECT_CONFIG;
-    if (config === true)
-        return DEFAULT_RECONNECT_CONFIG;
-    return {
-        maxAttempts: config?.maxAttempts ?? DEFAULT_RECONNECT_CONFIG.maxAttempts,
-        initialDelay: config?.initialDelay ?? DEFAULT_RECONNECT_CONFIG.initialDelay,
-        delay: config?.delay ?? DEFAULT_RECONNECT_CONFIG.delay,
-        addTracksOnReconnect: config?.addTracksOnReconnect ?? DEFAULT_RECONNECT_CONFIG.addTracksOnReconnect,
-    };
-};

package/dist/ts-client/src/tests/messageQueue.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/ts-client/src/tests/messageQueue.test.js

@@ -1,54 +0,0 @@
-import { beforeEach, describe, expect, test, vi } from 'vitest';
-import { MessageQueue } from '../messageQueue';
-describe('Message queue tests', () => {
-    let isReconnecting = false;
-    beforeEach(() => {
-        isReconnecting = false;
-    });
-    const getQueueWithUtils = () => {
-        const sendMessage = vi.fn();
-        const queue = new MessageQueue({ sendMessage, checkIsReconnecting: () => isReconnecting });
-        const message1 = new Uint8Array([1, 2, 3]);
-        const message2 = new Uint8Array([4, 5, 6]);
-        return { sendMessage, queue, message1, message2 };
-    };
-    test('Queue dispatches messages while not reconnecting', () => {
-        const { queue, sendMessage, message1, message2 } = getQueueWithUtils();
-        queue.enqueueMessage(message1);
-        queue.enqueueMessage(message2);
-        expect(sendMessage).toHaveBeenCalledWith(message1);
-        expect(sendMessage).toHaveBeenCalledWith(message2);
-    });
-    test('Queue holds messages while reconnecting', () => {
-        const { queue, sendMessage, message1, message2 } = getQueueWithUtils();
-        isReconnecting = true;
-        queue.enqueueMessage(message1);
-        queue.enqueueMessage(message2);
-        expect(sendMessage).not.toHaveBeenCalled();
-    });
-    test('Queue dispatches all messages upon calling attemptToSendOut', async () => {
-        const { queue, sendMessage, message1, message2 } = getQueueWithUtils();
-        isReconnecting = true;
-        queue.enqueueMessage(message1);
-        queue.enqueueMessage(message2);
-        isReconnecting = false;
-        // attemptToSendOut not called yet
-        expect(sendMessage).not.toHaveBeenCalled();
-        queue.attemptToSendAll();
-        // all messages dispatched
-        expect(sendMessage).toHaveBeenCalledTimes(2);
-    });
-    test('Queue dispatches all messages upon enqueuing another event', async () => {
-        const { queue, sendMessage, message1, message2 } = getQueueWithUtils();
-        isReconnecting = true;
-        queue.enqueueMessage(message1);
-        queue.enqueueMessage(message2);
-        isReconnecting = false;
-        // no trigger to send out yet
-        expect(sendMessage).not.toHaveBeenCalled();
-        const anotherMessage = new Uint8Array([7, 8, 9]);
-        queue.enqueueMessage(anotherMessage);
-        // all messages dispatched
-        expect(sendMessage).toHaveBeenCalledTimes(3);
-    });
-});

package/dist/ts-client/src/types.d.ts

@@ -1,216 +0,0 @@
-import type { EncodingReason, Endpoint, SimulcastConfig, TrackBandwidthLimit, VadStatus, Variant, WebRTCEndpointEvents } from '@fishjam-cloud/webrtc-client';
-import type TypedEmitter from 'typed-emitter';
-import type { AuthErrorReason } from './auth';
-import type { JoinErrorReason } from './guards';
-import type { ReconnectConfig } from './reconnection';
-/**
- * Metadata attached to a track published by a peer.
- * Sent over the signaling channel so other peers know what kind of track they're receiving.
- * @category Tracks
- */
-export type TrackMetadata = {
-    /** The kind of media this track carries. */
-    type: 'camera' | 'microphone' | 'screenShareVideo' | 'screenShareAudio' | 'customVideo' | 'customAudio';
-    /** Whether the track is currently muted/disabled. */
-    paused: boolean;
-    /** The peer's display name, used in recordings. */
-    displayName?: string;
-};
-export type GenericMetadata = Record<string, unknown> | undefined;
-/**
- *
- * @category Connection
- * @typeParam PeerMetadata Type of metadata set by peer while connecting to a room.
- * @typeParam ServerMetadata Type of metadata set by the server while creating a peer.
- */
-export type Metadata<PeerMetadata = GenericMetadata, ServerMetadata = GenericMetadata> = {
-    peer: PeerMetadata;
-    server: ServerMetadata;
-};
-export type TrackContextEvents = {
-    encodingChanged: (context: FishjamTrackContext) => void;
-    voiceActivityChanged: (context: FishjamTrackContext) => void;
-};
-export interface FishjamTrackContext extends TypedEmitter<TrackContextEvents> {
-    readonly track: MediaStreamTrack | null;
-    readonly stream: MediaStream | null;
-    readonly endpoint: Endpoint;
-    readonly trackId: string;
-    readonly simulcastConfig?: SimulcastConfig;
-    readonly metadata?: TrackMetadata;
-    readonly maxBandwidth?: TrackBandwidthLimit;
-    readonly vadStatus: VadStatus;
-    readonly encoding?: Variant;
-    readonly encodingReason?: EncodingReason;
-}
-export type Peer<PeerMetadata = GenericMetadata, ServerMetadata = GenericMetadata> = {
-    id: string;
-    type: string;
-    metadata?: Metadata<PeerMetadata, ServerMetadata>;
-    tracks: Map<string, FishjamTrackContext>;
-};
-export type Component = Omit<Endpoint, 'type'> & {
-    type: 'recording' | 'hls' | 'file' | 'rtsp' | 'sip';
-};
-/**
- * Events emitted by the client with their arguments.
- */
-export type MessageEvents<P, S> = {
-    /**
-     * 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<P, S>[], components: Component[]) => void;
-    /**
-     * Called when peer was not accepted
-     * @param metadata - Pass through for client application to communicate further actions to frontend
-     */
-    joinError: (metadata: JoinErrorReason | unknown) => 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: FishjamTrackContext) => 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: FishjamTrackContext) => 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: FishjamTrackContext) => void;
-    /**
-     * Called each time peer has its track metadata updated.
-     */
-    trackUpdated: (ctx: FishjamTrackContext) => void;
-    /**
-     * Called each time new peer joins the room.
-     */
-    peerJoined: (peer: Peer<P, S>) => void;
-    /**
-     * Called each time peer leaves the room.
-     */
-    peerLeft: (peer: Peer<P, S>) => void;
-    /**
-     * Called each time peer has its metadata updated.
-     */
-    peerUpdated: (peer: Peer<P, S>) => void;
-    /**
-     * Called each time new peer joins the room.
-     */
-    componentAdded: (peer: Component) => void;
-    /**
-     * Called each time peer leaves the room.
-     */
-    componentRemoved: (peer: Component) => void;
-    /**
-     * Called each time peer has its metadata updated.
-     */
-    componentUpdated: (peer: Component) => 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: FishjamTrackContext[], disabledTracks: FishjamTrackContext[]) => void;
-    /**
-     * Called every time the server estimates client's bandwidth.
-     *
-     * @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['targetTrackEncodingRequested']>[0]) => void;
-    localTrackAdded: (event: Parameters<WebRTCEndpointEvents['localTrackAdded']>[0]) => void;
-    localTrackRemoved: (event: Parameters<WebRTCEndpointEvents['localTrackRemoved']>[0]) => void;
-    localTrackReplaced: (event: Parameters<WebRTCEndpointEvents['localTrackReplaced']>[0]) => void;
-    localTrackMuted: (event: Parameters<WebRTCEndpointEvents['localTrackMuted']>[0]) => void;
-    localTrackUnmuted: (event: Parameters<WebRTCEndpointEvents['localTrackUnmuted']>[0]) => void;
-    localTrackBandwidthSet: (event: Parameters<WebRTCEndpointEvents['localTrackBandwidthSet']>[0]) => void;
-    localTrackEncodingBandwidthSet: (event: Parameters<WebRTCEndpointEvents['localTrackEncodingBandwidthSet']>[0]) => void;
-    localTrackEncodingEnabled: (event: Parameters<WebRTCEndpointEvents['localTrackEncodingEnabled']>[0]) => void;
-    localTrackEncodingDisabled: (event: Parameters<WebRTCEndpointEvents['localTrackEncodingDisabled']>[0]) => void;
-    localPeerMetadataChanged: (event: Parameters<WebRTCEndpointEvents['localEndpointMetadataChanged']>[0]) => void;
-    localTrackMetadataChanged: (event: Parameters<WebRTCEndpointEvents['localTrackMetadataChanged']>[0]) => void;
-    disconnectRequested: (event: Parameters<WebRTCEndpointEvents['disconnectRequested']>[0]) => void;
-    /**
-     * Emitted when data channel publishers (both reliable and lossy) are created and ready to send data.
-     */
-    dataChannelsReady: () => void;
-    /**
-     * Emitted when data channel publishers (both reliable or lossy) fail.
-     */
-    dataChannelsError: (error: Error) => void;
-};
-/**
- * Represents the type of client used.
- * @category Connection
- */
-export type ClientType = 'web' | 'mobile';
-/** 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 = {
-    reconnect?: ReconnectConfig | boolean;
-    /**
-     * Enables Fishjam SDK's debug logs in the console.
-     */
-    debug?: boolean;
-    /** Type of client used */
-    clientType?: ClientType;
-};

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

@@ -1 +0,0 @@
-export {};

package/dist/ts-client/src/version.d.ts

@@ -1 +0,0 @@
-export declare const packageVersion: string;

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

@@ -1,2 +0,0 @@
-import { version } from '../package.json';
-export const packageVersion = version;