@fishjam-cloud/react-client 0.6.0 → 0.7.0

package/dist/Client.js

@@ -1,461 +0,0 @@
-import EventEmitter from "events";
-import { FishjamClient } from "@fishjam-cloud/ts-client";
-import { DeviceManager } from "./DeviceManager";
-import { getAvailableMedia, getCorrectedResult } from "./mediaInitializer";
-export class Client extends EventEmitter {
-    tsClient;
-    local = null;
-    peers = {};
-    components = {};
-    peersTracks = {};
-    componentsTracks = {};
-    bandwidthEstimation = BigInt(0);
-    status = null;
-    media = null;
-    devices;
-    reconnectionStatus = "idle";
-    videoDeviceManager;
-    audioDeviceManager;
-    initialized = false;
-    constructor(config) {
-        super();
-        this.tsClient = new FishjamClient(config?.clientConfig);
-        this.videoDeviceManager = new DeviceManager("video", config?.deviceManagerDefaultConfig);
-        this.audioDeviceManager = new DeviceManager("audio", config?.deviceManagerDefaultConfig);
-        this.devices = {
-            camera: {
-                status: null,
-                stream: null,
-                track: null,
-                enabled: false,
-                mediaStatus: null,
-                deviceInfo: null,
-                error: null,
-                devices: null,
-            },
-            microphone: {
-                status: null,
-                stream: null,
-                track: null,
-                enabled: false,
-                mediaStatus: null,
-                deviceInfo: null,
-                error: null,
-                devices: null,
-            },
-        };
-        this.stateToSnapshot();
-        this.tsClient.on("disconnected", () => {
-            this.status = null;
-            this.stateToSnapshot();
-            this.emit("disconnected", this);
-        });
-        this.tsClient.on("socketOpen", (event) => {
-            this.status = "connected";
-            this.stateToSnapshot();
-            this.emit("socketOpen", event, this);
-        });
-        this.tsClient.on("socketError", (event) => {
-            this.stateToSnapshot();
-            this.emit("socketError", event, this);
-        });
-        this.tsClient.on("socketClose", (event) => {
-            this.stateToSnapshot();
-            this.emit("socketClose", event, this);
-        });
-        this.tsClient.on("authSuccess", () => {
-            this.status = "authenticated";
-            this.stateToSnapshot();
-            this.emit("authSuccess", this);
-        });
-        this.tsClient.on("authError", (reason) => {
-            this.stateToSnapshot();
-            this.status = "error";
-            this.emit("authError", reason, this);
-        });
-        this.tsClient.on("joined", (peerId, peers, components) => {
-            this.status = "joined";
-            this.stateToSnapshot();
-            this.emit("joined", { peerId, peers, components }, this);
-        });
-        this.tsClient.on("joinError", (metadata) => {
-            this.status = "error";
-            this.stateToSnapshot();
-            this.emit("joinError", metadata, this);
-        });
-        this.tsClient.on("reconnectionStarted", () => {
-            this.reconnectionStatus = "reconnecting";
-            this.stateToSnapshot();
-            this.emit("reconnectionStarted", this);
-        });
-        this.tsClient.on("reconnected", () => {
-            this.reconnectionStatus = "idle";
-            this.stateToSnapshot();
-            this.emit("reconnected", this);
-        });
-        this.tsClient.on("reconnectionRetriesLimitReached", () => {
-            this.reconnectionStatus = "error";
-            this.stateToSnapshot();
-            this.emit("reconnectionRetriesLimitReached", this);
-        });
-        this.tsClient.on("connectionError", (metadata) => {
-            this.status = "error";
-            this.stateToSnapshot();
-            this.emit("connectionError", metadata, this);
-        });
-        this.tsClient.on("peerJoined", (peer) => {
-            this.stateToSnapshot();
-            this.emit("peerJoined", peer, this);
-        });
-        this.tsClient.on("peerUpdated", (peer) => {
-            this.stateToSnapshot();
-            this.emit("peerUpdated", peer, this);
-        });
-        this.tsClient.on("peerLeft", (peer) => {
-            this.stateToSnapshot();
-            this.emit("peerLeft", peer, this);
-        });
-        this.tsClient.on("componentAdded", (component) => {
-            this.stateToSnapshot();
-            this.emit("componentAdded", component, this);
-        });
-        this.tsClient.on("componentUpdated", (component) => {
-            this.stateToSnapshot();
-            this.emit("componentUpdated", component, this);
-        });
-        this.tsClient.on("componentRemoved", (component) => {
-            this.stateToSnapshot();
-            this.emit("componentRemoved", component, this);
-        });
-        this.tsClient.on("trackReady", (ctx) => {
-            this.stateToSnapshot();
-            this.emit("trackReady", ctx, this);
-        });
-        this.tsClient.on("trackAdded", (ctx) => {
-            this.stateToSnapshot();
-            this.emit("trackAdded", ctx, this);
-            ctx.on("encodingChanged", () => {
-                this.stateToSnapshot();
-                this.emit("encodingChanged", ctx, this);
-            });
-            ctx.on("voiceActivityChanged", () => {
-                this.stateToSnapshot();
-                this.emit("voiceActivityChanged", ctx, this);
-            });
-        });
-        this.tsClient.on("trackRemoved", (ctx) => {
-            this.stateToSnapshot();
-            this.emit("trackRemoved", ctx, this);
-            ctx.removeAllListeners();
-        });
-        this.tsClient.on("trackUpdated", (ctx) => {
-            this.stateToSnapshot();
-            this.emit("trackUpdated", ctx, this);
-        });
-        this.tsClient.on("bandwidthEstimationChanged", (estimation) => {
-            this.stateToSnapshot();
-            this.emit("bandwidthEstimationChanged", estimation, this);
-        });
-        this.videoDeviceManager.on("deviceDisabled", (state) => {
-            this.stateToSnapshot();
-            this.emit("deviceDisabled", { ...state, trackType: "video", mediaDeviceType: "userMedia" }, this);
-        });
-        this.videoDeviceManager.on("deviceEnabled", (state) => {
-            this.stateToSnapshot();
-            this.emit("deviceEnabled", { ...state, trackType: "video", mediaDeviceType: "userMedia" }, this);
-        });
-        this.videoDeviceManager.on("managerStarted", (state) => {
-            this.stateToSnapshot();
-            this.emit("managerStarted", { ...state, trackType: "video", mediaDeviceType: "userMedia" }, this);
-        });
-        this.videoDeviceManager.on("deviceStopped", (state) => {
-            this.stateToSnapshot();
-            this.emit("deviceStopped", { ...state, trackType: "video", mediaDeviceType: "userMedia" }, this);
-        });
-        this.videoDeviceManager.on("deviceReady", ({ stream }) => {
-            this.stateToSnapshot();
-            this.emit("deviceReady", { trackType: "video", stream, mediaDeviceType: "userMedia" }, this);
-        });
-        this.videoDeviceManager.on("devicesStarted", (event) => {
-            this.stateToSnapshot();
-            this.emit("devicesStarted", { ...event, trackType: "video", mediaDeviceType: "userMedia" }, this);
-        });
-        this.videoDeviceManager.on("devicesReady", (event) => {
-            this.stateToSnapshot();
-            this.emit("devicesReady", { ...event, trackType: "video", mediaDeviceType: "userMedia" }, this);
-        });
-        this.videoDeviceManager.on("error", (event) => {
-            this.stateToSnapshot();
-            this.emit("error", event, this);
-        });
-        this.audioDeviceManager.on("deviceDisabled", (state) => {
-            this.stateToSnapshot();
-            this.emit("deviceDisabled", { ...state, trackType: "audio", mediaDeviceType: "userMedia" }, this);
-        });
-        this.audioDeviceManager.on("deviceEnabled", (state) => {
-            this.stateToSnapshot();
-            this.emit("deviceEnabled", { ...state, trackType: "audio", mediaDeviceType: "userMedia" }, this);
-        });
-        this.audioDeviceManager.on("managerStarted", (state) => {
-            this.stateToSnapshot();
-            this.emit("managerStarted", { ...state, trackType: "audio", mediaDeviceType: "userMedia" }, this);
-        });
-        this.audioDeviceManager.on("deviceStopped", (state) => {
-            this.stateToSnapshot();
-            this.emit("deviceStopped", { ...state, trackType: "audio", mediaDeviceType: "userMedia" }, this);
-        });
-        this.audioDeviceManager.on("deviceReady", ({ stream }) => {
-            this.stateToSnapshot();
-            this.emit("deviceReady", { trackType: "audio", stream, mediaDeviceType: "userMedia" }, this);
-        });
-        this.audioDeviceManager.on("devicesStarted", (event) => {
-            this.stateToSnapshot();
-            this.emit("devicesStarted", { ...event, trackType: "audio", mediaDeviceType: "userMedia" }, this);
-        });
-        this.audioDeviceManager.on("devicesReady", (event) => {
-            this.stateToSnapshot();
-            this.emit("devicesReady", { ...event, trackType: "audio", mediaDeviceType: "userMedia" }, this);
-        });
-        this.audioDeviceManager.on("error", (event) => {
-            this.stateToSnapshot();
-            this.emit("error", event, this);
-        });
-        this.tsClient?.on("targetTrackEncodingRequested", (event) => {
-            this.stateToSnapshot();
-            this.emit("targetTrackEncodingRequested", event, this);
-        });
-        this.tsClient?.on("localTrackAdded", (event) => {
-            this.stateToSnapshot();
-            this.emit("localTrackAdded", event, this);
-        });
-        this.tsClient?.on("localTrackRemoved", (event) => {
-            this.stateToSnapshot();
-            this.emit("localTrackRemoved", event, this);
-        });
-        this.tsClient?.on("localTrackReplaced", (event) => {
-            this.stateToSnapshot();
-            this.emit("localTrackReplaced", event, this);
-        });
-        this.tsClient?.on("localTrackMuted", (event) => {
-            this.stateToSnapshot();
-            this.emit("localTrackMuted", event, this);
-        });
-        this.tsClient?.on("localTrackUnmuted", (event) => {
-            this.stateToSnapshot();
-            this.emit("localTrackUnmuted", event, this);
-        });
-        this.tsClient?.on("localTrackBandwidthSet", (event) => {
-            this.stateToSnapshot();
-            this.emit("localTrackBandwidthSet", event, this);
-        });
-        this.tsClient?.on("localTrackEncodingBandwidthSet", (event) => {
-            this.stateToSnapshot();
-            this.emit("localTrackEncodingBandwidthSet", event, this);
-        });
-        this.tsClient?.on("localTrackEncodingEnabled", (event) => {
-            this.stateToSnapshot();
-            this.emit("localTrackEncodingEnabled", event, this);
-        });
-        this.tsClient?.on("localTrackEncodingDisabled", (event) => {
-            this.stateToSnapshot();
-            this.emit("localTrackEncodingDisabled", event, this);
-        });
-        this.tsClient?.on("localPeerMetadataChanged", (event) => {
-            this.stateToSnapshot();
-            this.emit("localPeerMetadataChanged", event, this);
-        });
-        this.tsClient?.on("localTrackMetadataChanged", (event) => {
-            this.stateToSnapshot();
-            this.emit("localTrackMetadataChanged", event, this);
-        });
-        this.tsClient?.on("disconnectRequested", (event) => {
-            this.stateToSnapshot();
-            this.emit("disconnectRequested", event, this);
-        });
-    }
-    setDeviceManagerConfig(config) {
-        this.videoDeviceManager.setConfig(config.storage, config.trackConstraints);
-        this.audioDeviceManager.setConfig(config.storage, config.trackConstraints);
-    }
-    trackContextToTrack(track) {
-        return {
-            rawMetadata: track.rawMetadata,
-            metadata: track.metadata,
-            trackId: track.trackId,
-            stream: track.stream,
-            simulcastConfig: track.simulcastConfig || null,
-            encoding: track.encoding || null,
-            vadStatus: track.vadStatus,
-            track: track.track,
-            metadataParsingError: track.metadataParsingError,
-        };
-    }
-    getTsClient = () => this.tsClient;
-    connect(config) {
-        this.status = "connecting";
-        this.tsClient.connect({ ...config, peerMetadata: config?.peerMetadata ?? {} });
-    }
-    disconnect() {
-        this.status = null;
-        this.tsClient.disconnect();
-    }
-    addTrack(track, simulcastConfig = { enabled: false, activeEncodings: [], disabledEncodings: [] }, maxBandwidth = 0) {
-        return this.tsClient.addTrack(track, undefined, simulcastConfig, maxBandwidth);
-    }
-    removeTrack(trackId) {
-        return this.tsClient.removeTrack(trackId);
-    }
-    replaceTrack(trackId, newTrack) {
-        return this.tsClient.replaceTrack(trackId, newTrack);
-    }
-    getStatistics(selector) {
-        return this.tsClient.getStatistics(selector);
-    }
-    getBandwidthEstimation() {
-        return this.tsClient.getBandwidthEstimation();
-    }
-    setTrackBandwidth(trackId, bandwidth) {
-        return this.tsClient.setTrackBandwidth(trackId, bandwidth);
-    }
-    setEncodingBandwidth(trackId, rid, bandwidth) {
-        return this.tsClient.setEncodingBandwidth(trackId, rid, bandwidth);
-    }
-    setTargetTrackEncoding(trackId, encoding) {
-        return this.tsClient.setTargetTrackEncoding(trackId, encoding);
-    }
-    enableTrackEncoding(trackId, encoding) {
-        return this.tsClient.enableTrackEncoding(trackId, encoding);
-    }
-    disableTrackEncoding(trackId, encoding) {
-        return this.tsClient.disableTrackEncoding(trackId, encoding);
-    }
-    isReconnecting = () => {
-        return this.tsClient.isReconnecting();
-    };
-    initializeDevices = async (config) => {
-        // This function should be called only once.
-        // Any subsequent calls to this function will be ignored.
-        if (this.initialized)
-            return;
-        this.initialized = true;
-        const constraints = {
-            video: this.videoDeviceManager.getConstraints(config?.videoTrackConstraints),
-            audio: this.audioDeviceManager.getConstraints(config?.audioTrackConstraints),
-        };
-        const previousDevices = {
-            video: this.videoDeviceManager.getLastDevice(),
-            audio: this.audioDeviceManager.getLastDevice(),
-        };
-        let [stream, deviceErrors] = await getAvailableMedia(constraints);
-        const devices = await navigator.mediaDevices.enumerateDevices();
-        const videoDevices = devices.filter(({ kind }) => kind === "videoinput");
-        const audioDevices = devices.filter(({ kind }) => kind === "audioinput");
-        if (stream) {
-            [stream, deviceErrors] = await getCorrectedResult(stream, deviceErrors, devices, constraints, previousDevices);
-        }
-        const state = {
-            video: this.videoDeviceManager.initialize(stream, stream?.getVideoTracks()?.[0] ?? null, videoDevices, !!constraints.video, deviceErrors.video),
-            audio: this.audioDeviceManager.initialize(stream, stream?.getAudioTracks()?.[0] ?? null, audioDevices, !!constraints.audio, deviceErrors.audio),
-        };
-        this.stateToSnapshot();
-        this.emit("managerInitialized", state, this);
-    };
-    startDevices = async (config) => {
-        this.videoDeviceManager.start(config?.videoDeviceId);
-        this.audioDeviceManager.start(config?.audioDeviceId);
-    };
-    stateToSnapshot() {
-        const deviceManagerSnapshot = {
-            audio: this?.audioDeviceManager?.deviceState,
-            video: this?.videoDeviceManager?.deviceState,
-        };
-        const localEndpoint = this.tsClient.getLocalPeer();
-        const localTracks = {};
-        (localEndpoint?.tracks || new Map()).forEach((track) => {
-            localTracks[track.trackId] = this.trackContextToTrack(track);
-        });
-        const devices = {
-            camera: {
-                status: deviceManagerSnapshot?.video?.devicesStatus || null,
-                stream: deviceManagerSnapshot?.video.media?.stream || null,
-                track: deviceManagerSnapshot?.video.media?.track || null,
-                enabled: deviceManagerSnapshot?.video.media?.enabled || false,
-                deviceInfo: deviceManagerSnapshot?.video.media?.deviceInfo || null,
-                mediaStatus: deviceManagerSnapshot?.video.mediaStatus || null,
-                error: deviceManagerSnapshot?.video?.error || null,
-                devices: deviceManagerSnapshot?.video?.devices || null,
-            },
-            microphone: {
-                status: deviceManagerSnapshot?.audio?.devicesStatus || null,
-                stream: deviceManagerSnapshot?.audio.media?.stream || null,
-                track: deviceManagerSnapshot?.audio.media?.track || null,
-                enabled: deviceManagerSnapshot?.audio.media?.enabled || false,
-                deviceInfo: deviceManagerSnapshot?.audio.media?.deviceInfo || null,
-                mediaStatus: deviceManagerSnapshot?.video.mediaStatus || null,
-                error: deviceManagerSnapshot?.audio?.error || null,
-                devices: deviceManagerSnapshot?.audio?.devices || null,
-            },
-        };
-        if (!this.tsClient["webrtc"]) {
-            this.media = deviceManagerSnapshot || null;
-            this.peersTracks = {};
-            this.componentsTracks = {};
-            this.devices = devices;
-            this.peers = {};
-            this.components = {};
-            this.local = null;
-            this.bandwidthEstimation = 0n;
-            return;
-        }
-        const peers = {};
-        const components = {};
-        const peersTracks = {};
-        const componentTracks = {};
-        Object.values(this.tsClient.getRemotePeers()).forEach((remotePeer) => {
-            const tracks = {};
-            remotePeer.tracks.forEach((track) => {
-                const mappedTrack = this.trackContextToTrack(track);
-                tracks[track.trackId] = mappedTrack;
-                peersTracks[track.trackId] = { ...mappedTrack, origin: remotePeer };
-            });
-            peers[remotePeer.id] = {
-                rawMetadata: remotePeer.rawMetadata,
-                metadata: remotePeer.metadata,
-                metadataParsingError: remotePeer.metadataParsingError,
-                id: remotePeer.id,
-                tracks,
-            };
-        });
-        Object.values(this.tsClient.getRemoteComponents()).forEach((remotePeer) => {
-            const tracks = {};
-            remotePeer.tracks.forEach((track) => {
-                const mappedTrack = this.trackContextToTrack(track);
-                tracks[track.trackId] = mappedTrack;
-                componentTracks[track.trackId] = { ...mappedTrack, origin: remotePeer };
-            });
-            components[remotePeer.id] = {
-                rawMetadata: remotePeer.rawMetadata,
-                metadata: remotePeer.metadata,
-                metadataParsingError: remotePeer.metadataParsingError,
-                id: remotePeer.id,
-                tracks,
-            };
-        });
-        this.peersTracks = peersTracks;
-        this.componentsTracks = componentTracks;
-        this.media = deviceManagerSnapshot || null;
-        this.local = localEndpoint
-            ? {
-                id: localEndpoint.id,
-                metadata: localEndpoint.metadata,
-                metadataParsingError: localEndpoint.metadataParsingError,
-                rawMetadata: localEndpoint.rawMetadata,
-                tracks: localTracks, // to record
-            }
-            : null;
-        this.peers = peers;
-        this.components = components;
-        this.bandwidthEstimation = this.tsClient.getBandwidthEstimation();
-        this.devices = devices;
-    }
-}

package/dist/hooks/clientState.d.ts

@@ -1,4 +0,0 @@
-import type { State } from "../state.types";
-import type { Client } from "../Client";
-export declare const useClientState: (client: Client) => State;
-//# sourceMappingURL=clientState.d.ts.map

package/dist/hooks/clientState.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"clientState.d.ts","sourceRoot":"","sources":["../../src/hooks/clientState.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAmDxC,eAAO,MAAM,cAAc,WAAY,MAAM,UAwC5C,CAAC"}

package/dist/hooks/connection.d.ts

@@ -1,6 +0,0 @@
-import type { UseConnect } from "../types";
-import type { UseReconnection } from "../state.types";
-export declare function useConnect(): UseConnect;
-export declare function useDisconnect(): () => void;
-export declare function useReconnection(): UseReconnection;
-//# sourceMappingURL=connection.d.ts.map

package/dist/hooks/connection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../src/hooks/connection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAsB,UAAU,EAAE,MAAM,UAAU,CAAC;AAE/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEtD,wBAAgB,UAAU,IAAI,UAAU,CAWvC;AAED,wBAAgB,aAAa,eAM5B;AAED,wBAAgB,eAAe,IAAI,eAAe,CASjD"}

package/dist/hooks/connection.js

@@ -1,28 +0,0 @@
-import { useFishjamContext } from "./fishjamContext";
-import { useCallback, useMemo } from "react";
-export function useConnect() {
-    const { state } = useFishjamContext();
-    return useMemo(() => {
-        return (config) => {
-            state.client.connect(config);
-            return () => {
-                state.client.disconnect();
-            };
-        };
-    }, [state.client]);
-}
-export function useDisconnect() {
-    const { state } = useFishjamContext();
-    return useCallback(() => {
-        state.client.disconnect();
-    }, [state.client]);
-}
-export function useReconnection() {
-    const { state } = useFishjamContext();
-    return {
-        status: state.reconnectionStatus,
-        isReconnecting: state.reconnectionStatus === "reconnecting",
-        isError: state.reconnectionStatus === "error",
-        isIdle: state.reconnectionStatus === "idle",
-    };
-}

package/dist/hooks/devices.d.ts

@@ -1,4 +0,0 @@
-import type { UserMediaAPI, TrackManager } from "../types";
-export declare function useCamera(): UserMediaAPI & TrackManager;
-export declare function useMicrophone(): UserMediaAPI & TrackManager;
-//# sourceMappingURL=devices.d.ts.map

package/dist/hooks/devices.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"devices.d.ts","sourceRoot":"","sources":["../../src/hooks/devices.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE3D,wBAAgB,SAAS,IAAI,YAAY,GAAG,YAAY,CAGvD;AAED,wBAAgB,aAAa,IAAI,YAAY,GAAG,YAAY,CAG3D"}

package/dist/hooks/devices.js

@@ -1,9 +0,0 @@
-import { useFishjamContext } from "./fishjamContext";
-export function useCamera() {
-    const { state, videoTrackManager } = useFishjamContext();
-    return { ...state.devices.camera, ...videoTrackManager };
-}
-export function useMicrophone() {
-    const { state, audioTrackManager } = useFishjamContext();
-    return { ...state.devices.microphone, ...audioTrackManager };
-}

package/dist/hooks/fishjamContext.d.ts

@@ -1,4 +0,0 @@
-import type { FishjamContextType } from "../types";
-export declare const FishjamContext: import("react").Context<FishjamContextType | null>;
-export declare function useFishjamContext(): FishjamContextType;
-//# sourceMappingURL=fishjamContext.d.ts.map

package/dist/hooks/fishjamContext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fishjamContext.d.ts","sourceRoot":"","sources":["../../src/hooks/fishjamContext.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAEnD,eAAO,MAAM,cAAc,oDAAiD,CAAC;AAE7E,wBAAgB,iBAAiB,IAGb,kBAAkB,CACrC"}

package/dist/hooks/participants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"participants.d.ts","sourceRoot":"","sources":["../../src/hooks/participants.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAWpD,wBAAgB,eAAe;;;EAQ9B"}

package/dist/hooks/participants.js

@@ -1,13 +0,0 @@
-import { useFishjamContext } from "./fishjamContext";
-function getPeerWithDistinguishedTracks(peerState) {
-    const localTracks = Object.values(peerState.tracks ?? {});
-    const videoTracks = localTracks.filter(({ track }) => track?.kind === "video");
-    const audioTracks = localTracks.filter(({ track }) => track?.kind === "audio");
-    return { ...peerState, videoTracks, audioTracks };
-}
-export function useParticipants() {
-    const { state } = useFishjamContext();
-    const localParticipant = state.local ? getPeerWithDistinguishedTracks(state.local) : null;
-    const participants = Object.values(state.remote).map(getPeerWithDistinguishedTracks);
-    return { localParticipant, participants };
-}

package/dist/hooks/screenShare.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"screenShare.d.ts","sourceRoot":"","sources":["../../src/hooks/screenShare.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAoB,MAAM,UAAU,CAAC;AAUjE,eAAO,MAAM,cAAc,QAAO,cAwGjC,CAAC"}

package/dist/hooks/setupMedia.d.ts

@@ -1,3 +0,0 @@
-import type { UseSetupMediaConfig, UseSetupMediaResult } from "../types";
-export declare const useSetupMedia: (config: UseSetupMediaConfig) => UseSetupMediaResult;
-//# sourceMappingURL=setupMedia.d.ts.map

package/dist/hooks/setupMedia.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setupMedia.d.ts","sourceRoot":"","sources":["../../src/hooks/setupMedia.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAYzE,eAAO,MAAM,aAAa,WAAY,mBAAmB,KAAG,mBA6O3D,CAAC"}