@fishjam-cloud/react-client 0.5.5 → 0.7.0

package/dist/screenShareTrackManager.js

@@ -1,92 +0,0 @@
-import { useCallback, useEffect } from "react";
-import { getRemoteOrLocalTrack } from "./utils/track";
-const getTracks = (stream) => {
-    const video = stream.getVideoTracks()[0];
-    const audio = stream.getAudioTracks()[0] ?? null;
-    return [video, audio];
-};
-export const useScreenShare = (
-// these arguments will be removed after we get rid of create() fn, we will just use the context
-[state, setState], tsClient) => {
-    const startStreaming = async (props) => {
-        const stream = await navigator.mediaDevices.getDisplayMedia({
-            video: props?.videoConstraints ?? true,
-            audio: props?.audioConstraints ?? true,
-        });
-        const [video, audio] = getTracks(stream);
-        const addTrackPromises = [tsClient.addTrack(video)];
-        if (audio)
-            addTrackPromises.push(tsClient.addTrack(audio));
-        const [videoId, audioId] = await Promise.all(addTrackPromises);
-        setState({ stream, trackIds: { videoId, audioId } });
-    };
-    const replaceTracks = async (newVideoTrack, newAudioTrack) => {
-        if (!state?.stream)
-            return;
-        const addTrackPromises = [tsClient.replaceTrack(state.trackIds.videoId, newVideoTrack)];
-        if (newAudioTrack && state.trackIds.audioId) {
-            addTrackPromises.push(tsClient.replaceTrack(state.trackIds.audioId, newAudioTrack));
-        }
-        await Promise.all(addTrackPromises);
-    };
-    const setTracksMiddleware = async (middleware) => {
-        if (!state?.stream)
-            return;
-        const [videoTrack, audioTrack] = getTracks(state.stream);
-        const [newVideoTrack, newAudioTrack] = middleware?.(videoTrack, audioTrack) ?? [videoTrack, audioTrack];
-        await replaceTracks(newVideoTrack, newAudioTrack);
-    };
-    const stopStreaming = useCallback(async () => {
-        if (!state) {
-            console.warn("No stream to stop");
-            return;
-        }
-        const [video, audio] = getTracks(state.stream);
-        video.stop();
-        if (audio)
-            audio.stop();
-        const removeTrackPromises = [tsClient.removeTrack(state.trackIds.videoId)];
-        if (state.trackIds.audioId)
-            removeTrackPromises.push(tsClient.removeTrack(state.trackIds.audioId));
-        await Promise.all(removeTrackPromises);
-        setState(null);
-    }, [state, tsClient, setState]);
-    useEffect(() => {
-        if (!state)
-            return;
-        const [video, audio] = getTracks(state.stream);
-        const trackEndedHandler = () => {
-            stopStreaming();
-        };
-        video.addEventListener("ended", trackEndedHandler);
-        audio?.addEventListener("ended", trackEndedHandler);
-        return () => {
-            video.removeEventListener("ended", trackEndedHandler);
-            audio?.removeEventListener("ended", trackEndedHandler);
-        };
-    }, [state, stopStreaming]);
-    useEffect(() => {
-        const onDisconnected = () => {
-            stopStreaming();
-        };
-        tsClient.on("disconnected", onDisconnected);
-        return () => {
-            tsClient.removeListener("disconnected", onDisconnected);
-        };
-    }, [stopStreaming, tsClient]);
-    const stream = state?.stream ?? null;
-    const [videoTrack, audioTrack] = stream ? getTracks(stream) : [null, null];
-    const videoBroadcast = state ? getRemoteOrLocalTrack(tsClient, state.trackIds.videoId) : null;
-    const audioBroadcast = state?.trackIds.audioId ? getRemoteOrLocalTrack(tsClient, state.trackIds.audioId) : null;
-    return {
-        startStreaming,
-        stopStreaming,
-        stream,
-        videoTrack,
-        audioTrack,
-        videoBroadcast,
-        audioBroadcast,
-        setTracksMiddleware,
-        currentTracksMiddleware: state?.tracksMiddleware ?? null,
-    };
-};

package/dist/trackManager.d.ts

@@ -1,9 +0,0 @@
-import type { FishjamClient } from "@fishjam-cloud/ts-client";
-import type { MediaManager, PeerMetadata, TrackManager, TrackMetadata } from "./types";
-interface TrackManagerConfig {
-    mediaManager: MediaManager;
-    tsClient: FishjamClient<PeerMetadata, TrackMetadata>;
-}
-export declare const useTrackManager: ({ mediaManager, tsClient }: TrackManagerConfig) => TrackManager;
-export {};
-//# sourceMappingURL=trackManager.d.ts.map

package/dist/trackManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"trackManager.d.ts","sourceRoot":"","sources":["../src/trackManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAwC,MAAM,0BAA0B,CAAC;AACpG,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,aAAa,EAAmB,MAAM,SAAS,CAAC;AAKxG,UAAU,kBAAkB;IAC1B,YAAY,EAAE,YAAY,CAAC;IAC3B,QAAQ,EAAE,aAAa,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC;CACtD;AAOD,eAAO,MAAM,eAAe,+BAAgC,kBAAkB,KAAG,YA6IhF,CAAC"}

package/dist/trackManager.js

@@ -1,116 +0,0 @@
-import { getRemoteOrLocalTrack } from "./utils/track";
-import { useEffect, useState } from "react";
-const TRACK_TYPE_TO_DEVICE = {
-    video: "camera",
-    audio: "microphone",
-};
-export const useTrackManager = ({ mediaManager, tsClient }) => {
-    const [currentTrackId, setCurrentTrackId] = useState(null);
-    const [paused, setPaused] = useState(false);
-    const [currentTrackMiddleware, setCurrentTrackMiddleware] = useState(null);
-    const type = TRACK_TYPE_TO_DEVICE[mediaManager.getDeviceType()];
-    const getMetadata = () => ({ type, paused });
-    useEffect(() => {
-        const disconnectedHandler = () => {
-            setCurrentTrackId(null);
-        };
-        tsClient.on("disconnected", disconnectedHandler);
-        return () => {
-            tsClient.off("disconnected", disconnectedHandler);
-        };
-    }, [tsClient]);
-    function getPreviousTrack() {
-        if (!currentTrackId)
-            throw Error("There is no current track id");
-        const prevTrack = getRemoteOrLocalTrack(tsClient, currentTrackId);
-        if (!prevTrack)
-            throw Error("There is no previous track");
-        return prevTrack;
-    }
-    async function setTrackMiddleware(middleware) {
-        const currentTrack = getCurrentTrack();
-        const mediaTrack = mediaManager.getTracks()[0];
-        if (!currentTrack || !mediaTrack)
-            return;
-        const trackToSet = middleware ? middleware(mediaTrack) : mediaTrack;
-        await tsClient.replaceTrack(currentTrack.trackId, trackToSet);
-        setCurrentTrackMiddleware(() => middleware);
-    }
-    function getCurrentTrack() {
-        return getRemoteOrLocalTrack(tsClient, currentTrackId);
-    }
-    async function initialize(deviceId) {
-        mediaManager?.start(deviceId ?? true);
-    }
-    async function stop() {
-        mediaManager?.stop();
-    }
-    async function startStreaming(simulcastConfig, maxBandwidth) {
-        if (currentTrackId)
-            throw Error("Track already added");
-        const media = mediaManager.getMedia();
-        if (!media || !media.stream || !media.track)
-            throw Error("Device is unavailable");
-        const track = getRemoteOrLocalTrack(tsClient, currentTrackId);
-        if (track)
-            return track.trackId;
-        // see `getRemoteOrLocalTrackContext()` explanation
-        setCurrentTrackId(media.track.id);
-        const trackMetadata = { ...getMetadata(), paused: false };
-        const remoteTrackId = await tsClient.addTrack(media.track, trackMetadata, simulcastConfig, maxBandwidth);
-        setCurrentTrackId(remoteTrackId);
-        setPaused(false);
-        return remoteTrackId;
-    }
-    async function refreshStreamedTrack() {
-        const prevTrack = getPreviousTrack();
-        const newTrack = mediaManager.getTracks()[0];
-        if (!newTrack)
-            throw Error("New track is empty");
-        return tsClient.replaceTrack(prevTrack.trackId, newTrack);
-    }
-    function stopStreaming() {
-        const prevTrack = getPreviousTrack();
-        setCurrentTrackId(null);
-        setPaused(true);
-        return tsClient.removeTrack(prevTrack.trackId);
-    }
-    async function pauseStreaming() {
-        const prevTrack = getPreviousTrack();
-        setPaused(true);
-        await tsClient.replaceTrack(prevTrack.trackId, null);
-        const trackMetadata = { ...getMetadata(), paused: true };
-        return tsClient.updateTrackMetadata(prevTrack.trackId, trackMetadata);
-    }
-    async function resumeStreaming() {
-        const prevTrack = getPreviousTrack();
-        const media = mediaManager.getMedia();
-        if (!media)
-            throw Error("Device is unavailable");
-        setPaused(false);
-        await tsClient.replaceTrack(prevTrack.trackId, media.track);
-        const trackMetadata = { ...getMetadata(), paused: false };
-        return tsClient.updateTrackMetadata(prevTrack.trackId, trackMetadata);
-    }
-    function disableTrack() {
-        return mediaManager.disable();
-    }
-    function enableTrack() {
-        return mediaManager.enable();
-    }
-    return {
-        getCurrentTrack,
-        setTrackMiddleware,
-        initialize,
-        stop,
-        startStreaming,
-        stopStreaming,
-        pauseStreaming,
-        resumeStreaming,
-        disableTrack,
-        enableTrack,
-        currentTrackMiddleware,
-        refreshStreamedTrack,
-        paused,
-    };
-};

package/dist/useSetupMedia.d.ts

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

package/dist/useSetupMedia.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useSetupMedia.d.ts","sourceRoot":"","sources":["../src/useSetupMedia.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAK5F,eAAO,MAAM,uBAAuB,sBAAuB,MAAM,kBAAkB,cAOjE,mBAAmB,KAAG,mBA+OvC,CAAC"}

package/dist/useSetupMedia.js

@@ -1,201 +0,0 @@
-import { useEffect, useMemo, useRef } from "react";
-export const createUseSetupMediaHook = (useFishjamContext) => {
-    const isBroadcastedTrackChanged = (client, pending) => client.status === "joined" && !pending && !client.isReconnecting();
-    const isBroadcastedTrackStopped = (status, stream) => status === "joined" && stream;
-    return (config) => {
-        const { state, videoTrackManager, audioTrackManager } = useFishjamContext();
-        const configRef = useRef(config);
-        useEffect(() => {
-            configRef.current = config;
-            state.client.setDeviceManagerConfig({
-                storage: config.storage,
-            });
-        }, [config, state.client]);
-        useEffect(() => {
-            if (!configRef.current.startOnMount)
-                return;
-            state.client.initializeDevices({
-                audioTrackConstraints: configRef?.current.microphone.trackConstraints,
-                videoTrackConstraints: configRef?.current.camera.trackConstraints,
-            });
-            // eslint-disable-next-line
-        }, []);
-        useEffect(() => {
-            let pending = false;
-            const broadcastOnCameraStart = async (client) => {
-                const config = configRef.current.camera;
-                const onDeviceChange = config.onDeviceChange ?? "replace";
-                const stream = videoTrackManager.getCurrentTrack()?.stream;
-                if (isBroadcastedTrackChanged(client, pending)) {
-                    if (!stream && config.broadcastOnDeviceStart) {
-                        pending = true;
-                        await videoTrackManager
-                            .startStreaming(config.defaultSimulcastConfig, config.defaultMaxBandwidth)
-                            .finally(() => {
-                            pending = false;
-                        });
-                    }
-                    else if (stream && onDeviceChange === "replace") {
-                        pending = true;
-                        await videoTrackManager.refreshStreamedTrack().finally(() => {
-                            pending = false;
-                        });
-                    }
-                    else if (stream && onDeviceChange === "remove") {
-                        pending = true;
-                        await videoTrackManager.stopStreaming().finally(() => {
-                            pending = false;
-                        });
-                    }
-                }
-            };
-            const managerInitialized = async (event, client) => {
-                if (event.video?.media?.stream) {
-                    await broadcastOnCameraStart(client);
-                }
-            };
-            const devicesReady = async (event, client) => {
-                if (event.trackType === "video" && event.restarted && event?.media?.stream) {
-                    await broadcastOnCameraStart(client);
-                }
-            };
-            const deviceReady = async (event, client) => {
-                if (event.trackType === "video") {
-                    await broadcastOnCameraStart(client);
-                }
-            };
-            state.client.on("managerInitialized", managerInitialized);
-            state.client.on("devicesReady", devicesReady);
-            state.client.on("deviceReady", deviceReady);
-            return () => {
-                state.client.removeListener("managerInitialized", managerInitialized);
-                state.client.removeListener("devicesReady", devicesReady);
-                state.client.removeListener("deviceReady", deviceReady);
-            };
-        }, [state.client, videoTrackManager]);
-        useEffect(() => {
-            const removeOnCameraStopped = async (event, client) => {
-                const stream = videoTrackManager.getCurrentTrack()?.stream;
-                const onDeviceStop = configRef.current.camera.onDeviceStop ?? "mute";
-                if (event.mediaDeviceType === "userMedia" &&
-                    event.trackType === "video" &&
-                    isBroadcastedTrackStopped(client.status, stream)) {
-                    if (onDeviceStop === "mute") {
-                        await videoTrackManager.pauseStreaming();
-                    }
-                    else {
-                        await videoTrackManager.stopStreaming();
-                    }
-                }
-            };
-            state.client.on("deviceStopped", removeOnCameraStopped);
-            return () => {
-                state.client.removeListener("deviceStopped", removeOnCameraStopped);
-            };
-        }, [state.client, videoTrackManager]);
-        useEffect(() => {
-            const broadcastCameraOnConnect = async (_, client) => {
-                const camera = client.devices.camera;
-                const stream = camera.stream;
-                const config = configRef.current.camera;
-                if (stream && config.broadcastOnConnect) {
-                    await videoTrackManager.startStreaming(config.defaultSimulcastConfig, config.defaultMaxBandwidth);
-                }
-            };
-            state.client.on("joined", broadcastCameraOnConnect);
-            return () => {
-                state.client.removeListener("joined", broadcastCameraOnConnect);
-            };
-        }, [state.client, videoTrackManager]);
-        useEffect(() => {
-            let pending = false;
-            const broadcastOnMicrophoneStart = async (client) => {
-                const stream = audioTrackManager.getCurrentTrack()?.stream;
-                const config = configRef.current.microphone;
-                const onDeviceChange = config.onDeviceChange ?? "replace";
-                if (isBroadcastedTrackChanged(client, pending)) {
-                    if (!stream && config.broadcastOnDeviceStart) {
-                        pending = true;
-                        await audioTrackManager.startStreaming(undefined, config.defaultMaxBandwidth).finally(() => {
-                            pending = false;
-                        });
-                    }
-                    else if (stream && onDeviceChange === "replace") {
-                        pending = true;
-                        await audioTrackManager.refreshStreamedTrack().finally(() => {
-                            pending = false;
-                        });
-                    }
-                    else if (stream && onDeviceChange === "remove") {
-                        pending = true;
-                        await audioTrackManager.stopStreaming().finally(() => {
-                            pending = false;
-                        });
-                    }
-                }
-            };
-            const managerInitialized = async (event, client) => {
-                if (event.audio?.media?.stream) {
-                    await broadcastOnMicrophoneStart(client);
-                }
-            };
-            const devicesReady = async (event, client) => {
-                if (event.trackType === "audio" && event.restarted && event?.media?.stream) {
-                    await broadcastOnMicrophoneStart(client);
-                }
-            };
-            const deviceReady = async (event, client) => {
-                if (event.trackType === "audio") {
-                    await broadcastOnMicrophoneStart(client);
-                }
-            };
-            state.client.on("managerInitialized", managerInitialized);
-            state.client.on("deviceReady", deviceReady);
-            state.client.on("devicesReady", devicesReady);
-            return () => {
-                state.client.removeListener("managerInitialized", managerInitialized);
-                state.client.removeListener("deviceReady", deviceReady);
-                state.client.removeListener("devicesReady", devicesReady);
-            };
-        }, [state.client, audioTrackManager]);
-        useEffect(() => {
-            const onMicrophoneStopped = async (event, client) => {
-                const stream = audioTrackManager.getCurrentTrack()?.stream;
-                const onDeviceStop = configRef.current.microphone.onDeviceStop ?? "mute";
-                const isRightDeviceType = event.mediaDeviceType === "userMedia";
-                const isRightTrackType = event.trackType === "audio";
-                if (isRightDeviceType && isRightTrackType && isBroadcastedTrackStopped(client.status, stream)) {
-                    if (onDeviceStop === "mute") {
-                        await audioTrackManager.pauseStreaming();
-                    }
-                    else {
-                        await audioTrackManager.stopStreaming();
-                    }
-                }
-            };
-            state.client.on("deviceStopped", onMicrophoneStopped);
-            return () => {
-                state.client.removeListener("deviceStopped", onMicrophoneStopped);
-            };
-        }, [state.client, audioTrackManager]);
-        useEffect(() => {
-            const broadcastMicrophoneOnConnect = async (_, client) => {
-                const config = configRef.current.microphone;
-                const microphone = client.devices.microphone;
-                if (microphone.stream && config.broadcastOnConnect) {
-                    await audioTrackManager.startStreaming(undefined, config.defaultMaxBandwidth);
-                }
-            };
-            state.client.on("joined", broadcastMicrophoneOnConnect);
-            return () => {
-                state.client.removeListener("joined", broadcastMicrophoneOnConnect);
-            };
-        }, [state.client, audioTrackManager]);
-        return useMemo(() => ({
-            init: () => state.client.initializeDevices({
-                audioTrackConstraints: configRef.current?.microphone?.trackConstraints,
-                videoTrackConstraints: configRef.current?.camera?.trackConstraints,
-            }),
-        }), [state.client]);
-    };
-};