@fishjam-cloud/react-client 0.5.5 → 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/create.d.ts

@@ -1,10 +0,0 @@
-import type { CreateFishjamClient, DeviceManagerConfig, PeerMetadata, TrackMetadata } from "./types";
-import type { CreateConfig } from "@fishjam-cloud/ts-client";
-/**
- * Create a client that can be used with a context.
- * Returns context provider, and two hooks to interact with the context.
- *
- * @returns ContextProvider, useSelector, useConnect
- */
-export declare function create(config?: CreateConfig<PeerMetadata, TrackMetadata>, deviceManagerDefaultConfig?: DeviceManagerConfig): CreateFishjamClient;
-//# sourceMappingURL=create.d.ts.map

package/dist/create.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../src/create.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,mBAAmB,EACnB,mBAAmB,EAGnB,YAAY,EAIZ,aAAa,EAGd,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAuD7D;;;;;GAKG;AACH,wBAAgB,MAAM,CACpB,MAAM,CAAC,EAAE,YAAY,CAAC,YAAY,EAAE,aAAa,CAAC,EAClD,0BAA0B,CAAC,EAAE,mBAAmB,GAC/C,mBAAmB,CA+KrB"}

package/dist/create.js

@@ -1,195 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useCallback, useContext, useMemo, useRef, useState, useSyncExternalStore } from "react";
-import { Client } from "./Client";
-import { createUseSetupMediaHook } from "./useSetupMedia";
-import { useScreenShare as _useScreenShare } from "./screenShareTrackManager";
-import { useTrackManager } from "./trackManager";
-const eventNames = [
-    "socketOpen",
-    "socketError",
-    "socketClose",
-    "authSuccess",
-    "authError",
-    "disconnected",
-    "joined",
-    "joinError",
-    "peerJoined",
-    "peerUpdated",
-    "peerLeft",
-    "reconnected",
-    "reconnectionRetriesLimitReached",
-    "reconnectionStarted",
-    "componentAdded",
-    "componentUpdated",
-    "componentRemoved",
-    "trackReady",
-    "trackAdded",
-    "trackRemoved",
-    "trackUpdated",
-    "bandwidthEstimationChanged",
-    "encodingChanged",
-    "voiceActivityChanged",
-    "deviceDisabled",
-    "deviceEnabled",
-    "managerInitialized",
-    "managerStarted",
-    "deviceStopped",
-    "deviceReady",
-    "devicesStarted",
-    "devicesReady",
-    "error",
-    "targetTrackEncodingRequested",
-    "localTrackAdded",
-    "localTrackRemoved",
-    "localTrackReplaced",
-    "localTrackMuted",
-    "localTrackUnmuted",
-    "localTrackBandwidthSet",
-    "localTrackEncodingBandwidthSet",
-    "localTrackEncodingEnabled",
-    "localTrackEncodingDisabled",
-    "localPeerMetadataChanged",
-    "localTrackMetadataChanged",
-    "disconnectRequested",
-];
-/**
- * Create a client that can be used with a context.
- * Returns context provider, and two hooks to interact with the context.
- *
- * @returns ContextProvider, useSelector, useConnect
- */
-export function create(config, deviceManagerDefaultConfig) {
-    const FishjamContext = createContext(undefined);
-    function FishjamContextProvider({ children }) {
-        const memoClient = useMemo(() => new Client({ clientConfig: config, deviceManagerDefaultConfig }), []);
-        const clientRef = useRef(memoClient);
-        const mutationRef = useRef(false);
-        const subscribe = useCallback((subscribeCallback) => {
-            const client = clientRef.current;
-            const callback = () => {
-                mutationRef.current = true;
-                subscribeCallback();
-            };
-            eventNames.forEach((eventName) => client.on(eventName, callback));
-            return () => {
-                eventNames.forEach((eventName) => client.removeListener(eventName, callback));
-            };
-        }, []);
-        const lastSnapshotRef = useRef(null);
-        const getSnapshot = useCallback(() => {
-            if (mutationRef.current || lastSnapshotRef.current === null) {
-                lastSnapshotRef.current = {
-                    remote: clientRef.current.peers,
-                    media: clientRef.current.media,
-                    bandwidthEstimation: clientRef.current.bandwidthEstimation,
-                    tracks: clientRef.current.peersTracks,
-                    local: clientRef.current.local,
-                    status: clientRef.current.status,
-                    devices: clientRef.current.devices,
-                    client: clientRef.current,
-                    reconnectionStatus: clientRef.current.reconnectionStatus,
-                };
-                mutationRef.current = false;
-            }
-            return lastSnapshotRef.current;
-        }, []);
-        const state = useSyncExternalStore(subscribe, getSnapshot);
-        const tsClient = state.client.getTsClient();
-        const screenshareState = useState(null);
-        const videoTrackManager = useTrackManager({
-            mediaManager: state.client.videoDeviceManager,
-            tsClient,
-        });
-        const audioTrackManager = useTrackManager({
-            mediaManager: state.client.audioDeviceManager,
-            tsClient,
-        });
-        return (_jsx(FishjamContext.Provider, { value: { state, screenshareState, videoTrackManager, audioTrackManager }, children: children }));
-    }
-    function useFishjamContext() {
-        const context = useContext(FishjamContext);
-        if (!context)
-            throw new Error("useFishjamContext must be used within a FishjamContextProvider");
-        return context;
-    }
-    function useSelector(selector) {
-        const { state } = useFishjamContext();
-        return useMemo(() => selector(state), [selector, state]);
-    }
-    function useConnect() {
-        const { state } = useFishjamContext();
-        return useMemo(() => {
-            return (config) => {
-                state.client.connect(config);
-                return () => {
-                    state.client.disconnect();
-                };
-            };
-        }, [state.client]);
-    }
-    function useDisconnect() {
-        const { state } = useFishjamContext();
-        return useCallback(() => {
-            state.client.disconnect();
-        }, [state.client]);
-    }
-    function useStatus() {
-        return useSelector((s) => s.status);
-    }
-    function useTracks() {
-        return useSelector((s) => s.tracks);
-    }
-    function useClient() {
-        return useSelector((s) => s.client);
-    }
-    function useCamera() {
-        const { state, videoTrackManager } = useFishjamContext();
-        return { ...state.devices.camera, ...videoTrackManager };
-    }
-    function useMicrophone() {
-        const { state, audioTrackManager } = useFishjamContext();
-        return { ...state.devices.microphone, ...audioTrackManager };
-    }
-    function useReconnection() {
-        const { state } = useFishjamContext();
-        return {
-            status: state.reconnectionStatus,
-            isReconnecting: state.reconnectionStatus === "reconnecting",
-            isError: state.reconnectionStatus === "error",
-            isIdle: state.reconnectionStatus === "idle",
-        };
-    }
-    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 };
-    }
-    function useParticipants() {
-        const { state } = useFishjamContext();
-        const localParticipant = state.local
-            ? getPeerWithDistinguishedTracks(state.local)
-            : null;
-        const participants = Object.values(state.remote).map(getPeerWithDistinguishedTracks);
-        return { localParticipant, participants };
-    }
-    function useScreenShare() {
-        const { state, screenshareState } = useFishjamContext();
-        return _useScreenShare(screenshareState, state.client.getTsClient());
-    }
-    return {
-        FishjamContextProvider,
-        useSelector,
-        useConnect,
-        useDisconnect,
-        useStatus,
-        useTracks,
-        useSetupMedia: createUseSetupMediaHook(useFishjamContext),
-        useParticipants,
-        useScreenShare,
-        useCamera,
-        useMicrophone,
-        useClient,
-        useReconnection,
-    };
-}

package/dist/screenShareTrackManager.d.ts

@@ -1,4 +0,0 @@
-import type { FishjamClient } from "@fishjam-cloud/ts-client";
-import type { PeerMetadata, ScreenshareApi, ScreenshareState, TrackMetadata } from "./types";
-export declare const useScreenShare: ([state, setState]: [ScreenshareState, React.Dispatch<React.SetStateAction<ScreenshareState>>], tsClient: FishjamClient<PeerMetadata, TrackMetadata>) => ScreenshareApi;
-//# sourceMappingURL=screenShareTrackManager.d.ts.map

package/dist/screenShareTrackManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"screenShareTrackManager.d.ts","sourceRoot":"","sources":["../src/screenShareTrackManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAG9D,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,gBAAgB,EAAE,aAAa,EAAoB,MAAM,SAAS,CAAC;AAS/G,eAAO,MAAM,cAAc,sBAEN,CAAC,gBAAgB,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,gBAAgB,CAAC,CAAC,CAAC,YACnF,aAAa,CAAC,YAAY,EAAE,aAAa,CAAC,KACnD,cAmGF,CAAC"}