@fishjam-cloud/react-client 0.26.0 → 0.26.1

package/dist/hooks/internal/useCurrentCallback.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns a stable function reference whose body always reads the latest
+ * closure values. Use when a method needs to be called from effects or
+ * captured by consumers without being memoized against changing state
+ * (peerStatus, deviceTrack, etc.) in its dep array.
+ */
+export declare const useCurrentCallback: <Args extends unknown[], R>(handler: (...args: Args) => R) => (...args: Args) => R;
+//# sourceMappingURL=useCurrentCallback.d.ts.map

package/dist/hooks/internal/useCurrentCallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCurrentCallback.d.ts","sourceRoot":"","sources":["../../../src/hooks/internal/useCurrentCallback.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,IAAI,SAAS,OAAO,EAAE,EAAE,CAAC,EAAE,SAAS,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,CAAC,eAK5D,IAAI,MAClC,CAAC"}

package/dist/hooks/internal/useCurrentCallback.js

@@ -0,0 +1,14 @@
+import { useCallback, useLayoutEffect, useRef } from "react";
+/**
+ * Returns a stable function reference whose body always reads the latest
+ * closure values. Use when a method needs to be called from effects or
+ * captured by consumers without being memoized against changing state
+ * (peerStatus, deviceTrack, etc.) in its dep array.
+ */
+export const useCurrentCallback = (handler) => {
+    const ref = useRef(handler);
+    useLayoutEffect(() => {
+        ref.current = handler;
+    });
+    return useCallback((...args) => ref.current(...args), []);
+};

package/dist/hooks/internal/useScreenshareManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useScreenshareManager.d.ts","sourceRoot":"","sources":["../../../src/hooks/internal/useScreenshareManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,MAAM,EAAsC,MAAM,0BAA0B,CAAC;AAI/G,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEvE,MAAM,MAAM,oBAAoB,GAAG;IACjC;;OAEG;IACH,cAAc,EAAE,CAAC,KAAK,CAAC,EAAE;QACvB,gBAAgB,CAAC,EAAE,OAAO,GAAG,qBAAqB,CAAC;QACnD,gBAAgB,CAAC,EAAE,OAAO,GAAG,qBAAqB,CAAC;KACpD,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpB;;OAEG;IACH,aAAa,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC;;OAEG;IACH,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;IAC3B;;OAEG;IACH,UAAU,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACpC;;OAEG;IACH,UAAU,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACpC;;;;OAIG;IACH,uBAAuB,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACjD;;;;OAIG;IACH,mBAAmB,EAAE,CAAC,UAAU,EAAE,gBAAgB,GAAG,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7E,CAAC;AAEF,UAAU,uBAAuB;IAC/B,aAAa,EAAE,aAAa,CAAC;IAC7B,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,qBAAqB,GAAI,wCAInC,uBAAuB,KAAG,oBAiL5B,CAAC"}
+{"version":3,"file":"useScreenshareManager.d.ts","sourceRoot":"","sources":["../../../src/hooks/internal/useScreenshareManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,MAAM,EAAsC,MAAM,0BAA0B,CAAC;AAI/G,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGvE,MAAM,MAAM,oBAAoB,GAAG;IACjC;;OAEG;IACH,cAAc,EAAE,CAAC,KAAK,CAAC,EAAE;QACvB,gBAAgB,CAAC,EAAE,OAAO,GAAG,qBAAqB,CAAC;QACnD,gBAAgB,CAAC,EAAE,OAAO,GAAG,qBAAqB,CAAC;KACpD,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpB;;OAEG;IACH,aAAa,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC;;OAEG;IACH,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;IAC3B;;OAEG;IACH,UAAU,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACpC;;OAEG;IACH,UAAU,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACpC;;;;OAIG;IACH,uBAAuB,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACjD;;;;OAIG;IACH,mBAAmB,EAAE,CAAC,UAAU,EAAE,gBAAgB,GAAG,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7E,CAAC;AAEF,UAAU,uBAAuB;IAC/B,aAAa,EAAE,aAAa,CAAC;IAC7B,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,qBAAqB,GAAI,wCAInC,uBAAuB,KAAG,oBA8K5B,CAAC"}

package/dist/hooks/internal/useScreenshareManager.js

@@ -1,5 +1,6 @@
 import { TrackTypeError } from "@fishjam-cloud/ts-client";
 import { useCallback, useEffect, useRef, useState } from "react";
+import { useCurrentCallback } from "./useCurrentCallback";
 export const useScreenShareManager = ({ fishjamClient, peerStatus, logger, }) => {
     const [state, setState] = useState({ stream: null, trackIds: null });
     const cleanMiddlewareFnRef = useRef(null);
@@ -79,7 +80,9 @@ export const useScreenShareManager = ({ fishjamClient, peerStatus, logger, }) =>
         cleanMiddlewareFnRef.current = onClear;
         await replaceTracks(videoTrack, audioTrack);
     }, [state.stream, cleanMiddleware, replaceTracks]);
-    const stopStreaming = useCallback(async () => {
+    // Stable identity with a live closure: peerStatus must be observed at call
+    // time so a captured reference doesn't skip the SFU removeTrack calls.
+    const stopStreaming = useCurrentCallback(async () => {
         if (!state.stream) {
             logger.warn("No stream to stop");
             return;
@@ -98,21 +101,15 @@ export const useScreenShareManager = ({ fishjamClient, peerStatus, logger, }) =>
         }
         cleanMiddleware();
         setState((prev) => ({ stream: null, trackIds: null, tracksMiddleware: prev.tracksMiddleware }));
-    }, [
-        state.stream,
-        state.trackIds?.videoId,
-        state.trackIds?.audioId,
-        peerStatus,
-        cleanMiddleware,
-        logger,
-        fishjamClient,
-    ]);
+    });
     useEffect(() => {
         if (!state.stream)
             return;
         const [video, audio] = getTracksFromStream(state.stream);
         const trackEndedHandler = () => {
-            stopStreaming();
+            void stopStreaming().catch((err) => {
+                logger.error(err);
+            });
         };
         video.addEventListener("ended", trackEndedHandler);
         audio?.addEventListener("ended", trackEndedHandler);
@@ -120,18 +117,20 @@ export const useScreenShareManager = ({ fishjamClient, peerStatus, logger, }) =>
             video.removeEventListener("ended", trackEndedHandler);
             audio?.removeEventListener("ended", trackEndedHandler);
         };
-    }, [state, stopStreaming]);
+    }, [state, stopStreaming, logger]);
     useEffect(() => {
         const onDisconnected = () => {
-            if (stream) {
-                stopStreaming();
-            }
+            if (!stream)
+                return;
+            void stopStreaming().catch((err) => {
+                logger.error(err);
+            });
         };
         fishjamClient.on("disconnected", onDisconnected);
         return () => {
             fishjamClient.removeListener("disconnected", onDisconnected);
         };
-    }, [stopStreaming, fishjamClient, stream]);
+    }, [stopStreaming, fishjamClient, stream, logger]);
     return {
         startStreaming,
         stopStreaming,

package/dist/hooks/internal/useTrackManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useTrackManager.d.ts","sourceRoot":"","sources":["../../../src/hooks/internal/useTrackManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,MAAM,EAA+C,MAAM,0BAA0B,CAAC;AAGxH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,YAAY,EAAmB,MAAM,oBAAoB,CAAC;AAErG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAEhE,UAAU,kBAAkB;IAC1B,aAAa,EAAE,aAAa,CAAC;IAC7B,QAAQ,EAAE,aAAa,CAAC;IACxB,UAAU,EAAE,UAAU,CAAC;IACvB,eAAe,EAAE,eAAe,CAAC;IACjC,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,IAAI,EAAE,QAAQ,GAAG,YAAY,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,eAAe,GAAI,uFAQ7B,kBAAkB,KAAG,YAoLvB,CAAC"}
+{"version":3,"file":"useTrackManager.d.ts","sourceRoot":"","sources":["../../../src/hooks/internal/useTrackManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,MAAM,EAA+C,MAAM,0BAA0B,CAAC;AAGxH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,YAAY,EAAmB,MAAM,oBAAoB,CAAC;AAErG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAGhE,UAAU,kBAAkB;IAC1B,aAAa,EAAE,aAAa,CAAC;IAC7B,QAAQ,EAAE,aAAa,CAAC;IACxB,UAAU,EAAE,UAAU,CAAC;IACvB,eAAe,EAAE,eAAe,CAAC;IACjC,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,IAAI,EAAE,QAAQ,GAAG,YAAY,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,eAAe,GAAI,uFAQ7B,kBAAkB,KAAG,YA2KvB,CAAC"}

package/dist/hooks/internal/useTrackManager.js

@@ -1,36 +1,44 @@
 import { TrackTypeError, Variant } from "@fishjam-cloud/ts-client";
-import { useCallback, useEffect, useRef } from "react";
+import { useEffect, useRef } from "react";
 import { getConfigAndBandwidthFromProps, getRemoteOrLocalTrack } from "../../utils/track";
+import { useCurrentCallback } from "./useCurrentCallback";
 export const useTrackManager = ({ deviceManager, tsClient, peerStatus, bandwidthLimits, streamConfig, type, logger, }) => {
     const currentTrackIdRef = useRef(null);
+    const connectionPromiseRef = useRef(null);
     const { startDevice, stopDevice, enableDevice, disableDevice, deviceTrack, applyMiddleware, currentMiddleware, selectDevice: _selectDevice, } = deviceManager;
-    const getCurrentTrackId = useCallback(() => {
+    // Read live deviceTrack from the `joined` listener without re-subscribing
+    // every time it changes.
+    const getDeviceTrack = useCurrentCallback(() => deviceTrack);
+    const getCurrentTrackId = async () => {
+        if (connectionPromiseRef.current) {
+            await connectionPromiseRef.current;
+        }
         const refTrackId = currentTrackIdRef.current;
         if (!refTrackId)
             return null;
         const currentTrack = getRemoteOrLocalTrack(tsClient, refTrackId);
         return currentTrack?.trackId ?? null;
-    }, [tsClient]);
-    const selectDevice = useCallback(async (deviceId) => {
+    };
+    const selectDevice = useCurrentCallback(async (deviceId) => {
         const result = await _selectDevice(deviceId);
         if (!result)
             return;
         const [newTrack, error] = result;
         if (error)
             return error;
-        const currentTrackId = getCurrentTrackId();
+        const currentTrackId = await getCurrentTrackId();
         if (!currentTrackId)
             return;
         await tsClient.replaceTrack(currentTrackId, newTrack);
-    }, [getCurrentTrackId, _selectDevice, tsClient]);
-    const setTrackMiddleware = useCallback(async (middleware) => {
+    });
+    const setTrackMiddleware = useCurrentCallback(async (middleware) => {
         const processedTrack = await applyMiddleware(middleware);
-        const currentTrackId = getCurrentTrackId();
+        const currentTrackId = await getCurrentTrackId();
         if (!currentTrackId)
             return;
         await tsClient.replaceTrack(currentTrackId, processedTrack);
-    }, [applyMiddleware, getCurrentTrackId, tsClient]);
-    const startStreaming = useCallback(async (track, props = { sentQualities: [Variant.VARIANT_LOW, Variant.VARIANT_MEDIUM, Variant.VARIANT_HIGH] }) => {
+    });
+    const startStreaming = useCurrentCallback(async (track, props = { sentQualities: [Variant.VARIANT_LOW, Variant.VARIANT_MEDIUM, Variant.VARIANT_HIGH] }) => {
         // temporarily setting the local trackId until we have the remoteTrackId
         currentTrackIdRef.current = track.id;
         const trackMetadata = { type, paused: false };
@@ -40,7 +48,9 @@ export const useTrackManager = ({ deviceManager, tsClient, peerStatus, bandwidth
         }
         const [maxBandwidth, simulcastConfig] = getConfigAndBandwidthFromProps(props.sentQualities, bandwidthLimits);
         try {
-            const remoteTrackId = await tsClient.addTrack(track, trackMetadata, simulcastConfig, maxBandwidth);
+            const addTrackJob = tsClient.addTrack(track, trackMetadata, simulcastConfig, maxBandwidth);
+            connectionPromiseRef.current = addTrackJob;
+            const remoteTrackId = await addTrackJob;
             currentTrackIdRef.current = remoteTrackId;
         }
         catch (err) {
@@ -50,24 +60,24 @@ export const useTrackManager = ({ deviceManager, tsClient, peerStatus, bandwidth
             }
             throw err;
         }
-    }, [type, tsClient, bandwidthLimits, logger]);
-    const pauseStreaming = useCallback(async (trackId) => {
+    });
+    const pauseStreaming = useCurrentCallback(async (trackId) => {
         if (peerStatus !== "connected")
             return;
         await tsClient.replaceTrack(trackId, null);
         return tsClient.updateTrackMetadata(trackId, { type, paused: true });
-    }, [tsClient, type, peerStatus]);
-    const resumeStreaming = useCallback(async (trackId, track) => {
+    });
+    const resumeStreaming = useCurrentCallback(async (trackId, track) => {
         if (peerStatus !== "connected")
             return;
         await tsClient.replaceTrack(trackId, track);
         return tsClient.updateTrackMetadata(trackId, { type, paused: false });
-    }, [peerStatus, tsClient, type]);
+    });
     /**
      * @see {@link TrackManager#toggleMute} for more details.
      */
-    const toggleMute = useCallback(async () => {
-        const currentTrackId = getCurrentTrackId();
+    const toggleMute = useCurrentCallback(async () => {
+        const currentTrackId = await getCurrentTrackId();
         const isTrackCurrentlyEnabled = Boolean(deviceTrack?.enabled);
         if (!currentTrackId) {
             logger.warn("Toggling mute is only possible while connected to a room.");
@@ -81,16 +91,16 @@ export const useTrackManager = ({ deviceManager, tsClient, peerStatus, bandwidth
             enableDevice();
             await resumeStreaming(currentTrackId, deviceTrack);
         }
-    }, [deviceTrack, getCurrentTrackId, logger, disableDevice, pauseStreaming, enableDevice, resumeStreaming]);
+    });
     /**
      * @see {@link TrackManager#toggleDevice} for more details.
      */
-    const toggleDevice = useCallback(async () => {
-        const currentTrackId = getCurrentTrackId();
+    const toggleDevice = useCurrentCallback(async () => {
+        const currentTrackId = await getCurrentTrackId();
         if (deviceTrack) {
             stopDevice();
             if (currentTrackId) {
-                pauseStreaming(currentTrackId);
+                await pauseStreaming(currentTrackId);
             }
         }
         else {
@@ -104,22 +114,19 @@ export const useTrackManager = ({ deviceManager, tsClient, peerStatus, bandwidth
                 await startStreaming(newTrack, streamConfig);
             }
         }
-    }, [
-        getCurrentTrackId,
-        deviceTrack,
-        stopDevice,
-        pauseStreaming,
-        startDevice,
-        peerStatus,
-        resumeStreaming,
-        startStreaming,
-        streamConfig,
-    ]);
+    });
     useEffect(() => {
         const onJoinedRoom = () => {
-            if (deviceTrack) {
-                startStreaming(deviceTrack, streamConfig);
-            }
+            const currentDeviceTrack = getDeviceTrack();
+            if (!currentDeviceTrack)
+                return;
+            // The handler is sync; observe rejections so non-TrackTypeError failures
+            // from addTrack don't surface as unhandledrejection.
+            void startStreaming(currentDeviceTrack, streamConfig).catch((err) => {
+                if (err instanceof TrackTypeError)
+                    return;
+                logger.error(err);
+            });
         };
         const onLeftRoom = () => {
             currentTrackIdRef.current = null;
@@ -130,7 +137,7 @@ export const useTrackManager = ({ deviceManager, tsClient, peerStatus, bandwidth
             tsClient.off("joined", onJoinedRoom);
             tsClient.off("disconnected", onLeftRoom);
         };
-    }, [deviceTrack, startStreaming, tsClient, streamConfig]);
+    }, [startStreaming, tsClient, streamConfig, getDeviceTrack, logger]);
     return {
         deviceTrack,
         currentMiddleware,

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

@@ -1 +1 @@
-{"version":3,"file":"useDataChannel.d.ts","sourceRoot":"","sources":["../../src/hooks/useDataChannel.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAE5D;;;;;GAKG;AACH,wBAAgB,cAAc,IAAI,oBAAoB,CAsFrD"}
+{"version":3,"file":"useDataChannel.d.ts","sourceRoot":"","sources":["../../src/hooks/useDataChannel.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAG5D;;;;;GAKG;AACH,wBAAgB,cAAc,IAAI,oBAAoB,CAyFrD"}

package/dist/hooks/useDataChannel.js

@@ -1,6 +1,7 @@
 import { useCallback, useContext, useEffect, useState } from "react";
 import { FishjamClientContext } from "../contexts/fishjamClient";
 import { PeerStatusContext } from "../contexts/peerStatus";
+import { useCurrentCallback } from "./internal/useCurrentCallback";
 /**
  * Hook for data channel operations - publish and subscribe to data.
  *
@@ -39,7 +40,10 @@ export function useDataChannel() {
             client.removeListener("disconnected", handleDisconnect);
         };
     }, [client]);
-    const initialize = useCallback(async () => {
+    // Stable identity with a live closure: peerStatus / loading / ready must be
+    // observed at call time so a captured reference doesn't reject with a stale
+    // "Peer is not connected" right after the connect promise settles.
+    const initialize = useCurrentCallback(async () => {
         if (loading || ready)
             return;
         if (peerStatus !== "connected") {
@@ -58,7 +62,7 @@ export function useDataChannel() {
         finally {
             setLoading(false);
         }
-    }, [client, peerStatus, loading, ready]);
+    });
     const publishData = useCallback((data, options) => {
         try {
             client.publishData(data, options);

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

@@ -1 +1 @@
-{"version":3,"file":"useLocalVAD.d.ts","sourceRoot":"","sources":["../../src/hooks/useLocalVAD.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAW9C;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS;IAAE,QAAQ,EAAE,OAAO,CAAA;CAAE,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAsClF,CAAC"}
+{"version":3,"file":"useLocalVAD.d.ts","sourceRoot":"","sources":["../../src/hooks/useLocalVAD.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAW9C;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS;IAAE,QAAQ,EAAE,OAAO,CAAA;CAAE,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CA8ClF,CAAC"}

package/dist/hooks/useLocalVAD.js

@@ -33,8 +33,14 @@ export const useLocalVAD = (options) => {
             return;
         let silenceTicks = 0;
         let timeoutId;
+        const controller = new AbortController();
+        const { signal } = controller;
         const poll = async () => {
+            if (signal.aborted)
+                return;
             const trackAudio = await fishjamClient?.current?.getLocalTrackAudioLevel(microphoneTrackId);
+            if (signal.aborted)
+                return;
             if (trackAudio != null && trackAudio.level > THRESHOLD) {
                 silenceTicks = 0;
                 setIsSpeaking(true);
@@ -45,10 +51,13 @@ export const useLocalVAD = (options) => {
                     setIsSpeaking(false);
                 }
             }
+            if (signal.aborted)
+                return;
             timeoutId = setTimeout(poll, 100);
         };
         timeoutId = setTimeout(poll, 0);
         return () => {
+            controller.abort();
             clearTimeout(timeoutId);
             setIsSpeaking(false);
         };

package/dist/hooks/usePeers.d.ts

@@ -1,4 +1,4 @@
-import type { Metadata } from "@fishjam-cloud/ts-client";
+import type { Metadata, Variant } from "@fishjam-cloud/ts-client";
 import type { PeerId, RemoteTrack, Track } from "../types/public";
 /**
  *
@@ -38,5 +38,11 @@ export declare function usePeers<PeerMetadata = Record<string, unknown>, ServerM
      * This property will be removed in future versions.
      */
     peers: PeerWithTracks<PeerMetadata, ServerMetadata, RemoteTrack>[];
+    /**
+     * This function allows to set the quality of tracks received from remote peers.
+     * @param trackIds The array of the track ids to set the quality for.
+     * @param quality The quality to set for the track.
+     */
+    setReceivedTracksQuality: (trackIds: string[], quality: Variant) => void;
 };
 //# sourceMappingURL=usePeers.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"usePeers.d.ts","sourceRoot":"","sources":["../../src/hooks/usePeers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,QAAQ,EAAiD,MAAM,0BAA0B,CAAC;AAMvH,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,KAAK,EAAW,MAAM,iBAAiB,CAAC;AAE3E;;;;GAIG;AACH,MAAM,MAAM,cAAc,CAAC,YAAY,EAAE,cAAc,EAAE,CAAC,SAAS,KAAK,GAAG,KAAK,IAAI;IAClF,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,CAAC,EAAE,QAAQ,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC;IAClD,MAAM,EAAE,CAAC,EAAE,CAAC;IACZ,WAAW,CAAC,EAAE,CAAC,CAAC;IAChB,eAAe,CAAC,EAAE,CAAC,CAAC;IACpB,qBAAqB,CAAC,EAAE,CAAC,CAAC;IAC1B,qBAAqB,CAAC,EAAE,CAAC,CAAC;IAC1B,iBAAiB,EAAE,CAAC,EAAE,CAAC;IACvB,iBAAiB,EAAE,CAAC,EAAE,CAAC;CACxB,CAAC;AAuEF;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAoBrG;;;OAGG;IACH;;OAEG;IACH;;;;OAIG;;EAGN"}
+{"version":3,"file":"usePeers.d.ts","sourceRoot":"","sources":["../../src/hooks/usePeers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,QAAQ,EAAwC,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAMvH,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,KAAK,EAAW,MAAM,iBAAiB,CAAC;AAE3E;;;;GAIG;AACH,MAAM,MAAM,cAAc,CAAC,YAAY,EAAE,cAAc,EAAE,CAAC,SAAS,KAAK,GAAG,KAAK,IAAI;IAClF,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,CAAC,EAAE,QAAQ,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC;IAClD,MAAM,EAAE,CAAC,EAAE,CAAC;IACZ,WAAW,CAAC,EAAE,CAAC,CAAC;IAChB,eAAe,CAAC,EAAE,CAAC,CAAC;IACpB,qBAAqB,CAAC,EAAE,CAAC,CAAC;IAC1B,qBAAqB,CAAC,EAAE,CAAC,CAAC;IAC1B,iBAAiB,EAAE,CAAC,EAAE,CAAC;IACvB,iBAAiB,EAAE,CAAC,EAAE,CAAC;CACxB,CAAC;AAuEF;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IA0BrG;;;OAGG;IACH;;OAEG;IACH;;;;OAIG;;IAEH;;;;OAIG;yCAvBQ,MAAM,EAAE,WAAW,OAAO;EA0BxC"}

package/dist/hooks/usePeers.js

@@ -1,4 +1,4 @@
-import { useContext } from "react";
+import { useCallback, useContext } from "react";
 import { FishjamClientContext } from "../contexts/fishjamClient";
 import { FishjamClientStateContext } from "../contexts/fishjamState";
 function trackContextToTrack(track) {
@@ -63,6 +63,7 @@ export function usePeers() {
         ? getLocalPeerWithTracks(clientState.localPeer)
         : null;
     const remotePeers = Object.values(clientState.peers).map((peer) => getRemotePeerWithTracks(peer, fishjamClient.current));
+    const setReceivedTracksQuality = useCallback((trackIds, quality) => trackIds.forEach((trackId) => fishjamClient.current.setTargetTrackEncoding(trackId, quality)), [fishjamClient]);
     return {
         /**
          * The local peer with distinguished tracks (camera, microphone, screen share).
@@ -77,5 +78,11 @@ export function usePeers() {
          * This property will be removed in future versions.
          */
         peers: remotePeers,
+        /**
+         * This function allows to set the quality of tracks received from remote peers.
+         * @param trackIds The array of the track ids to set the quality for.
+         * @param quality The quality to set for the track.
+         */
+        setReceivedTracksQuality,
     };
 }

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

@@ -1 +1 @@
-{"version":3,"file":"useScreenShare.d.ts","sourceRoot":"","sources":["../../src/hooks/useScreenShare.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,eAAO,MAAM,cAAc;IAKvB;;OAEG;;wBADiE,CAAC;wBAEpD,CAAC;;IAClB;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;;;OAIG;;IAEH;;;;OAIG;;CAGN,CAAC"}
+{"version":3,"file":"useScreenShare.d.ts","sourceRoot":"","sources":["../../src/hooks/useScreenShare.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,eAAO,MAAM,cAAc;IAKvB;;OAEG;;wBACiB,CAAC;wBAER,CAAC;;IADd;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;;;OAIG;;IAEH;;;;OAIG;;CAGN,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"useVAD.d.ts","sourceRoot":"","sources":["../../src/hooks/useVAD.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAW,MAAM,iBAAiB,CAAC;AAGvD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,MAAM,GAAI,SAAS;IAAE,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAAE,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAuE1F,CAAC"}
+{"version":3,"file":"useVAD.d.ts","sourceRoot":"","sources":["../../src/hooks/useVAD.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAG9C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,MAAM,GAAI,SAAS;IAAE,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAAE,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAyD1F,CAAC"}

package/dist/hooks/useVAD.js

@@ -1,4 +1,4 @@
-import { useContext, useEffect, useMemo, useState } from "react";
+import { useContext, useEffect, useMemo, useReducer } from "react";
 import { FishjamClientStateContext } from "../contexts/fishjamState";
 import { useLocalVAD } from "./useLocalVAD";
 /**
@@ -40,37 +40,33 @@ export const useVAD = (options) => {
         peerId: peer.id,
         microphoneTrack: Array.from(peer.tracks.values()).find(({ metadata }) => metadata?.type === "microphone"),
     })), [clientState.peers, peerIds]);
-    const getDefaultVadStatuses = () => micTracksWithSelectedPeerIds.reduce((mappedTracks, { peerId, microphoneTrack }) => ({
-        ...mappedTracks,
-        [peerId]: microphoneTrack ? { [microphoneTrack.trackId]: microphoneTrack.vadStatus } : {},
-    }), {});
-    const [_vadStatuses, setVadStatuses] = useState(getDefaultVadStatuses);
+    // `voiceActivityChanged` mutates the track context in place and does not flow through
+    // `useFishjamClientState`, so we need an explicit re-render trigger to re-read the
+    // current `vadStatus` off each mic track.
+    const [version, bumpVersion] = useReducer((n) => n + 1, 0);
     useEffect(() => {
-        const unsubs = micTracksWithSelectedPeerIds.map(({ peerId, microphoneTrack }) => {
-            const updateVadStatus = (track) => {
-                setVadStatuses((prev) => ({
-                    ...prev,
-                    [peerId]: { ...prev[peerId], [track.trackId]: track.vadStatus },
-                }));
-            };
-            if (microphoneTrack) {
-                microphoneTrack.on("voiceActivityChanged", updateVadStatus);
-            }
+        const unsubs = micTracksWithSelectedPeerIds.map(({ microphoneTrack }) => {
+            if (!microphoneTrack)
+                return () => { };
+            microphoneTrack.on("voiceActivityChanged", bumpVersion);
             return () => {
-                if (microphoneTrack) {
-                    microphoneTrack.off("voiceActivityChanged", updateVadStatus);
-                }
+                microphoneTrack.off("voiceActivityChanged", bumpVersion);
             };
         });
         return () => unsubs.forEach((unsub) => unsub());
     }, [micTracksWithSelectedPeerIds]);
     const localVAD = useLocalVAD({ disabled: !showLocalPeerVAD });
-    const vadStatuses = useMemo(() => ({
-        ...Object.fromEntries(Object.entries(_vadStatuses).map(([peerId, tracks]) => [
-            peerId,
-            Object.values(tracks).some((vad) => vad === "speech"),
-        ])),
-        ...localVAD,
-    }), [_vadStatuses, localVAD]);
+    const vadStatuses = useMemo(() => {
+        // Referencing `version` makes the memo recompute on every `voiceActivityChanged`
+        // event, so we re-read each current mic track's mutable `vadStatus`.
+        void version;
+        return {
+            ...Object.fromEntries(micTracksWithSelectedPeerIds.map(({ peerId, microphoneTrack }) => [
+                peerId,
+                microphoneTrack?.vadStatus === "speech",
+            ])),
+            ...localVAD,
+        };
+    }, [micTracksWithSelectedPeerIds, localVAD, version]);
     return vadStatuses;
 };

package/dist/tests/useCurrentCallback.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=useCurrentCallback.spec.d.ts.map

package/dist/tests/useCurrentCallback.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCurrentCallback.spec.d.ts","sourceRoot":"","sources":["../../src/tests/useCurrentCallback.spec.ts"],"names":[],"mappings":""}

package/dist/tests/useCurrentCallback.spec.js

@@ -0,0 +1,49 @@
+import { renderHook } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { useCurrentCallback } from "../hooks/internal/useCurrentCallback";
+describe("useCurrentCallback", () => {
+    it("returns a stable function reference across re-renders", () => {
+        const { result, rerender } = renderHook((handler) => useCurrentCallback(handler), {
+            initialProps: () => undefined,
+        });
+        const firstRef = result.current;
+        rerender(() => undefined);
+        rerender(() => undefined);
+        expect(result.current).toBe(firstRef);
+    });
+    it("invokes the latest handler when called after a re-render", () => {
+        const first = vi.fn();
+        const second = vi.fn();
+        const { result, rerender } = renderHook((handler) => useCurrentCallback(handler), {
+            initialProps: first,
+        });
+        result.current();
+        expect(first).toHaveBeenCalledTimes(1);
+        expect(second).not.toHaveBeenCalled();
+        rerender(second);
+        result.current();
+        expect(first).toHaveBeenCalledTimes(1);
+        expect(second).toHaveBeenCalledTimes(1);
+    });
+    it("forwards arguments and returns the handler's value", () => {
+        const handler = vi.fn((a, b) => a + b);
+        const { result } = renderHook(() => useCurrentCallback(handler));
+        const sum = result.current(2, 3);
+        expect(handler).toHaveBeenCalledWith(2, 3);
+        expect(sum).toBe(5);
+    });
+    it("the wrapper captured before a re-render still calls the latest handler", () => {
+        const first = vi.fn(() => "first");
+        const second = vi.fn(() => "second");
+        const { result, rerender } = renderHook((handler) => useCurrentCallback(handler), {
+            initialProps: first,
+        });
+        // Simulates a consumer capturing the reference (e.g. inside a useEffect
+        // closure) before the handler closure has changed.
+        const captured = result.current;
+        rerender(second);
+        expect(captured()).toBe("second");
+        expect(second).toHaveBeenCalledTimes(1);
+        expect(first).not.toHaveBeenCalled();
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fishjam-cloud/react-client",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "React client library for Fishjam",
   "license": "Apache-2.0",
   "author": "Fishjam Team",
@@ -62,7 +62,7 @@
     "vitest": "^3.1.1"
   },
   "dependencies": {
-    "@fishjam-cloud/ts-client": "0.26.0",
+    "@fishjam-cloud/ts-client": "0.26.1",
     "events": "3.3.0",
     "lodash.isequal": "4.5.0"
   },