@fishjam-cloud/react-client 0.14.0 → 0.14.1

package/dist/FishjamProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FishjamProvider.d.ts","sourceRoot":"","sources":["../src/FishjamProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC/E,OAAO,EAAE,KAAK,iBAAiB,EAAU,MAAM,OAAO,CAAC;AAUvD,OAAO,KAAK,EAAE,eAAe,EAAE,yBAAyB,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG/F;;GAEG;AACH,MAAM,WAAW,oBAAqB,SAAQ,iBAAiB;IAC7D;;;OAGG;IACH,SAAS,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC;IACtC;;;;OAIG;IACH,WAAW,CAAC,EAAE,IAAI,CAAC,sBAAsB,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC;IAC9D;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,GAAG,yBAAyB,CAAC;IACxD;;OAEG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;IAC3C;;OAEG;IACH,WAAW,CAAC,EAAE,YAAY,CAAC;IAC3B;;OAEG;IACH,WAAW,CAAC,EAAE,YAAY,CAAC;CAC5B;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,2CAmE1D"}
+{"version":3,"file":"FishjamProvider.d.ts","sourceRoot":"","sources":["../src/FishjamProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC/E,OAAO,EAAE,KAAK,iBAAiB,EAAmB,MAAM,OAAO,CAAC;AAehE,OAAO,KAAK,EAAE,eAAe,EAAE,yBAAyB,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAI/F;;GAEG;AACH,MAAM,WAAW,oBAAqB,SAAQ,iBAAiB;IAC7D;;;OAGG;IACH,SAAS,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC;IACtC;;;;OAIG;IACH,WAAW,CAAC,EAAE,IAAI,CAAC,sBAAsB,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC;IAC9D;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,GAAG,yBAAyB,CAAC;IACxD;;OAEG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;IAC3C;;OAEG;IACH,WAAW,CAAC,EAAE,YAAY,CAAC;IAC3B;;OAEG;IACH,WAAW,CAAC,EAAE,YAAY,CAAC;CAC5B;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,2CAsE1D"}

package/dist/FishjamProvider.js

@@ -1,67 +1,63 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { FishjamClient } from "@fishjam-cloud/ts-client";
-import { useRef } from "react";
+import { useMemo, useRef } from "react";
+import { CameraContext } from "./contexts/camera";
+import { FishjamClientContext } from "./contexts/fishjamClient";
+import { FishjamClientStateContext } from "./contexts/fishjamState";
+import { InitDevicesContext } from "./contexts/initDevices";
+import { MicrophoneContext } from "./contexts/microphone";
+import { PeerStatusContext } from "./contexts/peerStatus";
+import { ScreenshareContext } from "./contexts/screenshare";
 import { AUDIO_TRACK_CONSTRAINTS, VIDEO_TRACK_CONSTRAINTS } from "./devices/constraints";
-import { DeviceManager } from "./devices/DeviceManager";
+import { useMediaDevices } from "./hooks/internal/devices/useMediaDevices";
 import { useFishjamClientState } from "./hooks/internal/useFishjamClientState";
-import { FishjamContext } from "./hooks/internal/useFishjamContext";
 import { usePeerStatus } from "./hooks/internal/usePeerStatus";
 import { useScreenShareManager } from "./hooks/internal/useScreenshareManager";
 import { useTrackManager } from "./hooks/internal/useTrackManager";
 import { mergeWithDefaultBandwitdthLimits } from "./utils/bandwidth";
+import { getLastDevice, saveLastDevice } from "./utils/localStorage";
 /**
  * Provides the Fishjam Context
  * @category Components
  */
 export function FishjamProvider(props) {
     const fishjamClientRef = useRef(new FishjamClient({ reconnect: props.reconnect }));
-    // HACK: This is a workaround to prevent multiple device initialization calls.
-    // TODO to be removed in FCE-1278
-    const devicesInitializationRef = useRef(null);
-    const storage = props.persistLastDevice;
-    const videoDeviceManagerRef = useRef(new DeviceManager({
-        deviceType: "video",
-        defaultConstraints: VIDEO_TRACK_CONSTRAINTS,
-        userConstraints: props.constraints?.video,
-        storage,
-    }));
-    const audioDeviceManagerRef = useRef(new DeviceManager({
-        deviceType: "audio",
-        defaultConstraints: AUDIO_TRACK_CONSTRAINTS,
-        userConstraints: props.constraints?.audio,
-        storage,
-    }));
-    const { peerStatus, getCurrentPeerStatus } = usePeerStatus(fishjamClientRef.current);
-    const mergedBandwidthLimits = mergeWithDefaultBandwitdthLimits(props.bandwidthLimits);
+    const persistHandlers = useMemo(() => {
+        if (props.persistLastDevice === false)
+            return undefined;
+        if (typeof props.persistLastDevice === "object")
+            return props.persistLastDevice;
+        return { getLastDevice, saveLastDevice };
+    }, [props.persistLastDevice]);
+    const { cameraManager, microphoneManager, initializeDevices } = useMediaDevices({
+        videoConstraints: props.constraints?.video ?? VIDEO_TRACK_CONSTRAINTS,
+        audioConstraints: props.constraints?.audio ?? AUDIO_TRACK_CONSTRAINTS,
+        persistHandlers,
+    });
+    const peerStatus = usePeerStatus(fishjamClientRef.current);
+    const mergedBandwidthLimits = useMemo(() => mergeWithDefaultBandwitdthLimits(props.bandwidthLimits), [props.bandwidthLimits]);
     const videoTrackManager = useTrackManager({
-        mediaManager: videoDeviceManagerRef.current,
         tsClient: fishjamClientRef.current,
-        getCurrentPeerStatus,
+        peerStatus,
+        deviceManager: cameraManager,
         bandwidthLimits: mergedBandwidthLimits,
         streamConfig: props.videoConfig,
-        devicesInitializationRef,
+        type: "camera",
     });
     const audioTrackManager = useTrackManager({
-        mediaManager: audioDeviceManagerRef.current,
         tsClient: fishjamClientRef.current,
-        getCurrentPeerStatus,
+        peerStatus,
+        deviceManager: microphoneManager,
         bandwidthLimits: mergedBandwidthLimits,
         streamConfig: props.audioConfig,
-        devicesInitializationRef,
+        type: "microphone",
     });
-    const screenShareManager = useScreenShareManager({ fishjamClient: fishjamClientRef.current, getCurrentPeerStatus });
-    const clientState = useFishjamClientState(fishjamClientRef.current);
-    const context = {
-        fishjamClientRef,
+    const screenShareManager = useScreenShareManager({
+        fishjamClient: fishjamClientRef.current,
         peerStatus,
-        screenShareManager,
-        videoTrackManager,
-        audioTrackManager,
-        videoDeviceManagerRef,
-        audioDeviceManagerRef,
-        devicesInitializationRef,
-        clientState,
-        bandwidthLimits: mergedBandwidthLimits,
-    };
-    return _jsx(FishjamContext.Provider, { value: context, children: props.children });
+    });
+    const cameraContext = useMemo(() => ({ videoTrackManager, cameraManager }), [videoTrackManager, cameraManager]);
+    const microphoneContext = useMemo(() => ({ audioTrackManager, microphoneManager }), [audioTrackManager, microphoneManager]);
+    const fishjamClientState = useFishjamClientState(fishjamClientRef.current);
+    return (_jsx(FishjamClientContext.Provider, { value: fishjamClientRef, children: _jsx(FishjamClientStateContext.Provider, { value: fishjamClientState, children: _jsx(InitDevicesContext.Provider, { value: initializeDevices, children: _jsx(PeerStatusContext.Provider, { value: peerStatus, children: _jsx(CameraContext.Provider, { value: cameraContext, children: _jsx(MicrophoneContext.Provider, { value: microphoneContext, children: _jsx(ScreenshareContext.Provider, { value: screenShareManager, children: props.children }) }) }) }) }) }) }));
 }

package/dist/contexts/camera.d.ts

@@ -0,0 +1,8 @@
+import type { DeviceManager } from "../hooks/internal/devices/useDeviceManager";
+import type { TrackManager } from "../types/internal";
+export type CameraContextType = {
+    videoTrackManager: TrackManager;
+    cameraManager: DeviceManager;
+};
+export declare const CameraContext: import("react").Context<CameraContextType | null>;
+//# sourceMappingURL=camera.d.ts.map

package/dist/contexts/camera.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera.d.ts","sourceRoot":"","sources":["../../src/contexts/camera.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4CAA4C,CAAC;AAChF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,iBAAiB,EAAE,YAAY,CAAC;IAChC,aAAa,EAAE,aAAa,CAAC;CAC9B,CAAC;AAEF,eAAO,MAAM,aAAa,mDAAgD,CAAC"}

package/dist/contexts/camera.js

@@ -0,0 +1,2 @@
+import { createContext } from "react";
+export const CameraContext = createContext(null);

package/dist/contexts/fishjamClient.d.ts

@@ -0,0 +1,4 @@
+import type { FishjamClient } from "@fishjam-cloud/ts-client";
+import { type RefObject } from "react";
+export declare const FishjamClientContext: import("react").Context<RefObject<FishjamClient<import("@fishjam-cloud/ts-client").GenericMetadata, import("@fishjam-cloud/ts-client").GenericMetadata>> | null>;
+//# sourceMappingURL=fishjamClient.d.ts.map

package/dist/contexts/fishjamClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fishjamClient.d.ts","sourceRoot":"","sources":["../../src/contexts/fishjamClient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAEtD,eAAO,MAAM,oBAAoB,kKAAuD,CAAC"}

package/dist/contexts/fishjamClient.js

@@ -0,0 +1,2 @@
+import { createContext } from "react";
+export const FishjamClientContext = createContext(null);

package/dist/contexts/fishjamState.d.ts

@@ -0,0 +1,3 @@
+import type { FishjamClientState } from "../hooks/internal/useFishjamClientState";
+export declare const FishjamClientStateContext: import("react").Context<FishjamClientState<import("@fishjam-cloud/ts-client").GenericMetadata, import("@fishjam-cloud/ts-client").GenericMetadata> | null>;
+//# sourceMappingURL=fishjamState.d.ts.map

package/dist/contexts/fishjamState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fishjamState.d.ts","sourceRoot":"","sources":["../../src/contexts/fishjamState.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAElF,eAAO,MAAM,yBAAyB,4JAAiD,CAAC"}

package/dist/contexts/fishjamState.js

@@ -0,0 +1,2 @@
+import { createContext } from "react";
+export const FishjamClientStateContext = createContext(null);

package/dist/contexts/initDevices.d.ts

@@ -0,0 +1,3 @@
+import type { InitializeDevicesResult } from "../types/public";
+export declare const InitDevicesContext: import("react").Context<(() => Promise<InitializeDevicesResult>) | null>;
+//# sourceMappingURL=initDevices.d.ts.map

package/dist/contexts/initDevices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initDevices.d.ts","sourceRoot":"","sources":["../../src/contexts/initDevices.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAE/D,eAAO,MAAM,kBAAkB,iCAAwB,OAAO,CAAC,uBAAuB,CAAC,SAAe,CAAC"}

package/dist/contexts/initDevices.js

@@ -0,0 +1,2 @@
+import { createContext } from "react";
+export const InitDevicesContext = createContext(null);

package/dist/contexts/microphone.d.ts

@@ -0,0 +1,8 @@
+import type { DeviceManager } from "../hooks/internal/devices/useDeviceManager";
+import type { TrackManager } from "../types/internal";
+export type MicrophoneContextType = {
+    audioTrackManager: TrackManager;
+    microphoneManager: DeviceManager;
+};
+export declare const MicrophoneContext: import("react").Context<MicrophoneContextType | null>;
+//# sourceMappingURL=microphone.d.ts.map

package/dist/contexts/microphone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"microphone.d.ts","sourceRoot":"","sources":["../../src/contexts/microphone.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4CAA4C,CAAC;AAChF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,MAAM,MAAM,qBAAqB,GAAG;IAClC,iBAAiB,EAAE,YAAY,CAAC;IAChC,iBAAiB,EAAE,aAAa,CAAC;CAClC,CAAC;AAEF,eAAO,MAAM,iBAAiB,uDAAoD,CAAC"}

package/dist/contexts/microphone.js

@@ -0,0 +1,2 @@
+import { createContext } from "react";
+export const MicrophoneContext = createContext(null);

package/dist/contexts/peerStatus.d.ts

@@ -0,0 +1,3 @@
+import type { PeerStatus } from "../types/public";
+export declare const PeerStatusContext: import("react").Context<PeerStatus>;
+//# sourceMappingURL=peerStatus.d.ts.map

package/dist/contexts/peerStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peerStatus.d.ts","sourceRoot":"","sources":["../../src/contexts/peerStatus.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD,eAAO,MAAM,iBAAiB,qCAAoC,CAAC"}

package/dist/contexts/peerStatus.js

@@ -0,0 +1,2 @@
+import { createContext } from "react";
+export const PeerStatusContext = createContext("idle");

package/dist/contexts/screenshare.d.ts

@@ -0,0 +1,3 @@
+import type { UseScreenshareResult } from "../hooks/internal/useScreenshareManager";
+export declare const ScreenshareContext: import("react").Context<UseScreenshareResult | null>;
+//# sourceMappingURL=screenshare.d.ts.map

package/dist/contexts/screenshare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screenshare.d.ts","sourceRoot":"","sources":["../../src/contexts/screenshare.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yCAAyC,CAAC;AAEpF,eAAO,MAAM,kBAAkB,sDAAmD,CAAC"}

package/dist/contexts/screenshare.js

@@ -0,0 +1,2 @@
+import { createContext } from "react";
+export const ScreenshareContext = createContext(null);

package/dist/debug.d.ts

@@ -0,0 +1,2 @@
+export { useStatistics } from "./hooks/useStatistics";
+//# sourceMappingURL=debug.d.ts.map

package/dist/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../src/debug.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/debug.js

@@ -0,0 +1 @@
+export { useStatistics } from "./hooks/useStatistics";

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

@@ -1 +1 @@
-{"version":3,"file":"constraints.d.ts","sourceRoot":"","sources":["../../src/devices/constraints.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,uBAAuB,EAAE,qBAErC,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,qBAerC,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,sBAM9C,CAAC;AAEF,eAAO,MAAM,4BAA4B,aAC7B,MAAM,GAAG,SAAS,eACf,qBAAqB,GAAG,SAAS,GAAG,OAAO,KACvD,qBAAqB,GAAG,OAM1B,CAAC;AAEF,eAAO,MAAM,kBAAkB,oBACZ,MAAM,GAAG,SAAS,eACtB,qBAAqB,GAAG,SAAS,GAAG,OAAO,KACvD,qBAAqB,GAAG,SAAS,GAAG,OAUtC,CAAC"}
+{"version":3,"file":"constraints.d.ts","sourceRoot":"","sources":["../../src/devices/constraints.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,uBAAuB,EAAE,qBAErC,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,qBAerC,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,sBAM9C,CAAC;AAEF,eAAO,MAAM,4BAA4B,GACvC,UAAU,MAAM,GAAG,SAAS,EAC5B,aAAa,qBAAqB,GAAG,SAAS,GAAG,OAAO,KACvD,qBAAqB,GAAG,OAM1B,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,iBAAiB,MAAM,GAAG,SAAS,EACnC,aAAa,qBAAqB,GAAG,SAAS,GAAG,OAAO,KACvD,qBAAqB,GAAG,SAAS,GAAG,OAUtC,CAAC"}

package/dist/devices/mediaInitializer.d.ts

@@ -1,11 +1,12 @@
+import type { AudioVideo } from "../types/internal";
 import type { DeviceError } from "../types/public";
-type AudioVideo<T> = {
-    audio: T;
-    video: T;
-};
 type MediaConstraints = AudioVideo<MediaTrackConstraints | undefined | boolean>;
 type PreviousDevices = AudioVideo<MediaDeviceInfo | null>;
-export declare const getAvailableMedia: (constraints: MediaStreamConstraints, deviceErrors?: AudioVideo<DeviceError | null>) => Promise<[MediaStream | null, AudioVideo<DeviceError | null>]>;
-export declare const correctDevicesOnSafari: (stream: MediaStream, deviceErrors: AudioVideo<DeviceError | null>, devices: MediaDeviceInfo[], constraints: MediaConstraints, previousDevices: PreviousDevices) => Promise<[MediaStream | null, AudioVideo<DeviceError | null>]>;
+type GetMediaResult = {
+    stream: MediaStream | null;
+    errors: AudioVideo<DeviceError | null>;
+};
+export declare const getAvailableMedia: (constraints: MediaStreamConstraints, errors?: AudioVideo<DeviceError | null>) => Promise<GetMediaResult>;
+export declare const correctDevicesOnSafari: (stream: MediaStream, errors: AudioVideo<DeviceError | null>, devices: MediaDeviceInfo[], constraints: MediaConstraints, previousDevices: PreviousDevices) => Promise<GetMediaResult>;
 export {};
 //# sourceMappingURL=mediaInitializer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"mediaInitializer.d.ts","sourceRoot":"","sources":["../../src/devices/mediaInitializer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAInD,KAAK,UAAU,CAAC,CAAC,IAAI;IAAE,KAAK,EAAE,CAAC,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,CAAC;AAE5C,KAAK,gBAAgB,GAAG,UAAU,CAAC,qBAAqB,GAAG,SAAS,GAAG,OAAO,CAAC,CAAC;AAChF,KAAK,eAAe,GAAG,UAAU,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;AAqC1D,eAAO,MAAM,iBAAiB,gBACf,sBAAsB,iBACrB,UAAU,CAAC,WAAW,GAAG,IAAI,CAAC,KAC3C,OAAO,CAAC,CAAC,WAAW,GAAG,IAAI,EAAE,UAAU,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC,CAwB9D,CAAC;AAIF,eAAO,MAAM,sBAAsB,WACzB,WAAW,gBACL,UAAU,CAAC,WAAW,GAAG,IAAI,CAAC,WACnC,eAAe,EAAE,eACb,gBAAgB,mBACZ,eAAe,KAC/B,OAAO,CAAC,CAAC,WAAW,GAAG,IAAI,EAAE,UAAU,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC,CAsB9D,CAAC"}
+{"version":3,"file":"mediaInitializer.d.ts","sourceRoot":"","sources":["../../src/devices/mediaInitializer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAkB,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAInD,KAAK,gBAAgB,GAAG,UAAU,CAAC,qBAAqB,GAAG,SAAS,GAAG,OAAO,CAAC,CAAC;AAChF,KAAK,eAAe,GAAG,UAAU,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;AAE1D,KAAK,cAAc,GAAG;IAAE,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;IAAC,MAAM,EAAE,UAAU,CAAC,WAAW,GAAG,IAAI,CAAC,CAAA;CAAE,CAAC;AAqC7F,eAAO,MAAM,iBAAiB,GAC5B,aAAa,sBAAsB,EACnC,SAAQ,UAAU,CAAC,WAAW,GAAG,IAAI,CAAiB,KACrD,OAAO,CAAC,cAAc,CAsBxB,CAAC;AAIF,eAAO,MAAM,sBAAsB,GACjC,QAAQ,WAAW,EACnB,QAAQ,UAAU,CAAC,WAAW,GAAG,IAAI,CAAC,EACtC,SAAS,eAAe,EAAE,EAC1B,aAAa,gBAAgB,EAC7B,iBAAiB,eAAe,KAC/B,OAAO,CAAC,cAAc,CAsBxB,CAAC"}

package/dist/devices/mediaInitializer.js

@@ -21,21 +21,20 @@ const getSingleMedia = async (type, constraints) => {
 const tryToGetAudioOnlyThenVideoOnly = async (constraints, initialError) => {
     const [audioStream, audioErr] = await getSingleMedia("audio", constraints.audio);
     if (audioStream)
-        return [audioStream, { video: initialError, audio: null }];
+        return { stream: audioStream, errors: { video: initialError, audio: null } };
     const [videoStream, videoErr] = await getSingleMedia("video", constraints.video);
-    return [videoStream, { audio: audioErr, video: videoErr }];
+    return { stream: videoStream, errors: { audio: audioErr, video: videoErr } };
 };
-export const getAvailableMedia = async (constraints, deviceErrors = defaultErrors) => {
+export const getAvailableMedia = async (constraints, errors = defaultErrors) => {
     try {
-        return [await navigator.mediaDevices.getUserMedia(constraints), deviceErrors];
+        return { stream: await navigator.mediaDevices.getUserMedia(constraints), errors };
     }
     catch (err) {
-        const unhandledErr = { audio: UNHANDLED_ERROR, video: UNHANDLED_ERROR };
         if (err instanceof DOMException) {
             switch (err.name) {
-                case deviceErrors.audio?.name:
-                case deviceErrors.video?.name:
-                    return [null, deviceErrors];
+                case errors.audio?.name:
+                case errors.video?.name:
+                    return { stream: null, errors };
                 case "NotFoundError":
                     return tryToGetAudioOnlyThenVideoOnly(constraints, PERMISSION_DENIED);
                 case "OverconstrainedError":
@@ -44,25 +43,25 @@ export const getAvailableMedia = async (constraints, deviceErrors = defaultError
                     return tryToGetAudioOnlyThenVideoOnly(constraints, PERMISSION_DENIED);
             }
         }
-        return [null, unhandledErr];
+        return { stream: null, errors: { audio: UNHANDLED_ERROR, video: UNHANDLED_ERROR } };
     }
 };
 // Safari changes deviceId between sessions, therefore we cannot rely on deviceId for identification purposes.
 // We can switch a random device that comes from safari to one that has the same label as the one used in the previous session.
-export const correctDevicesOnSafari = async (stream, deviceErrors, devices, constraints, previousDevices) => {
+export const correctDevicesOnSafari = async (stream, errors, devices, constraints, previousDevices) => {
     const shouldCorrectDevices = isAnyDeviceDifferentFromLastSession(previousDevices.video, previousDevices.audio, getCurrentDevicesSettings(stream, devices));
     if (!shouldCorrectDevices)
-        return [stream, deviceErrors];
+        return { stream, errors };
     const videoIdToStart = devices.find((info) => info.label === previousDevices.video?.label)?.deviceId;
     const audioIdToStart = devices.find((info) => info.label === previousDevices.audio?.label)?.deviceId;
     if (!videoIdToStart && !audioIdToStart)
-        return [stream, deviceErrors];
+        return { stream, errors };
     stopTracks(stream);
     const exactConstraints = {
-        video: !deviceErrors.video && prepareConstraints(videoIdToStart, constraints.video),
-        audio: !deviceErrors.audio && prepareConstraints(audioIdToStart, constraints.audio),
+        video: !errors.video && prepareConstraints(videoIdToStart, constraints.video),
+        audio: !errors.audio && prepareConstraints(audioIdToStart, constraints.audio),
     };
-    return await getAvailableMedia(exactConstraints, deviceErrors);
+    return await getAvailableMedia(exactConstraints, errors);
 };
 const getCurrentDevicesSettings = (requestedDevices, mediaDeviceInfos) => {
     const currentDevices = { videoinput: null, audioinput: null };

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

@@ -6,11 +6,11 @@ export declare function useCamera(): {
     /**
      * Toggles current camera on/off
      */
-    toggleCamera: () => Promise<void>;
+    toggleCamera: () => Promise<undefined | import("../..").DeviceError>;
     /**
      * Selects the camera device
      */
-    selectCamera: (deviceId?: string) => Promise<void>;
+    selectCamera: (deviceId?: string) => Promise<undefined | import("../..").DeviceError>;
     /**
      * Indicates which camera is now turned on and streaming
      */

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

@@ -1 +1 @@
-{"version":3,"file":"useCamera.d.ts","sourceRoot":"","sources":["../../../src/hooks/devices/useCamera.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wBAAgB,SAAS;IAKrB;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;EAGN"}
+{"version":3,"file":"useCamera.d.ts","sourceRoot":"","sources":["../../../src/hooks/devices/useCamera.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,wBAAgB,SAAS;IAarB;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;EAGN"}

package/dist/hooks/devices/useCamera.js

@@ -1,12 +1,20 @@
-import { useDeviceApi } from "../internal/device/useDeviceApi";
-import { useFishjamContext } from "../internal/useFishjamContext";
+import { useContext, useMemo } from "react";
+import { CameraContext } from "../../contexts/camera";
 /**
  * This hook can toggle camera on/off, change camera, provides current camera and other.
  * @category Devices
  */
 export function useCamera() {
-    const { videoTrackManager, videoDeviceManagerRef } = useFishjamContext();
-    const deviceApi = useDeviceApi({ deviceManager: videoDeviceManagerRef.current });
+    const cameraCtx = useContext(CameraContext);
+    if (!cameraCtx)
+        throw Error("useCamera must be used within CameraProvider");
+    const { videoTrackManager, cameraManager } = cameraCtx;
+    const cameraStream = useMemo(() => {
+        const track = videoTrackManager.deviceTrack;
+        if (!track)
+            return null;
+        return new MediaStream([track]);
+    }, [videoTrackManager.deviceTrack]);
     return {
         /**
          * Toggles current camera on/off
@@ -19,19 +27,19 @@ export function useCamera() {
         /**
          * Indicates which camera is now turned on and streaming
          */
-        activeCamera: deviceApi.activeDevice,
+        activeCamera: cameraManager.activeDevice,
         /**
          * Indicates whether the microphone is streaming video
          */
-        isCameraOn: !!deviceApi.mediaStream,
+        isCameraOn: !!cameraStream,
         /**
          * The MediaStream object containing the current stream
          */
-        cameraStream: deviceApi.mediaStream,
+        cameraStream,
         /**
          * The currently set camera middleware function
          */
-        currentCameraMiddleware: deviceApi.currentMiddleware,
+        currentCameraMiddleware: videoTrackManager.currentMiddleware,
         /**
          * Sets the camera middleware
          */
@@ -39,10 +47,10 @@ export function useCamera() {
         /**
          * List of available camera devices
          */
-        cameraDevices: deviceApi.devices,
+        cameraDevices: cameraManager.deviceList,
         /**
          * Possible error thrown while setting up the camera
          */
-        cameraDeviceError: deviceApi.deviceError,
+        cameraDeviceError: cameraManager.deviceError,
     };
 }

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

@@ -1,12 +1,7 @@
-import { type DeviceError } from "../../types/public";
 export type UseInitializeDevicesParams = {
     enableVideo?: boolean;
     enableAudio?: boolean;
 };
-export type InitializeDevicesErrors = {
-    audio: DeviceError | null;
-    video: DeviceError | null;
-};
 /**
  * Hook allows you to initialize access to the devices before joining the room.
  * @category Devices
@@ -15,6 +10,6 @@ export declare const useInitializeDevices: () => {
     /**
      * Initialize access to the devices before joining the room
      */
-    initializeDevices: (params?: UseInitializeDevicesParams) => Promise<null | InitializeDevicesErrors>;
+    initializeDevices: () => Promise<import("../..").InitializeDevicesResult>;
 };
 //# sourceMappingURL=useInitializeDevices.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useInitializeDevices.d.ts","sourceRoot":"","sources":["../../../src/hooks/devices/useInitializeDevices.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAItD,MAAM,MAAM,0BAA0B,GAAG;IACvC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IAAE,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;IAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAAA;CAAE,CAAC;AAE/F;;;GAGG;AACH,eAAO,MAAM,oBAAoB;IA4E7B;;OAEG;iCA3E8B,0BAA0B,KAAK,OAAO,CAAC,IAAI,GAAG,uBAAuB,CAAC;CA8E1G,CAAC"}
+{"version":3,"file":"useInitializeDevices.d.ts","sourceRoot":"","sources":["../../../src/hooks/devices/useInitializeDevices.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,0BAA0B,GAAG;IACvC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB;IAK7B;;OAEG;;CAGN,CAAC"}

package/dist/hooks/devices/useInitializeDevices.js

@@ -1,53 +1,13 @@
-import { useCallback } from "react";
-import { prepareConstraints } from "../../devices/constraints";
-import { correctDevicesOnSafari, getAvailableMedia } from "../../devices/mediaInitializer";
-import { Deferred } from "../../utils/deferred";
-import { useFishjamContext } from "../internal/useFishjamContext";
+import { useContext } from "react";
+import { InitDevicesContext } from "../../contexts/initDevices";
 /**
  * Hook allows you to initialize access to the devices before joining the room.
  * @category Devices
  */
 export const useInitializeDevices = () => {
-    const { videoDeviceManagerRef, audioDeviceManagerRef, devicesInitializationRef } = useFishjamContext();
-    const initializeDevices = useCallback(async ({ enableVideo = true, enableAudio = true } = {}) => {
-        if (devicesInitializationRef.current)
-            return null;
-        const deferred = new Deferred();
-        devicesInitializationRef.current = deferred.promise;
-        try {
-            const videoManager = videoDeviceManagerRef.current;
-            const audioManager = audioDeviceManagerRef.current;
-            const constraints = {
-                video: enableVideo && videoManager.getConstraints(),
-                audio: enableAudio && audioManager.getConstraints(),
-            };
-            const previousDevices = {
-                video: videoManager.getLastDevice(),
-                audio: audioManager.getLastDevice(),
-            };
-            // Attempt to start the last selected device to avoid an unnecessary restart.
-            // Without this, the first device will start, and `correctDevicesOnSafari` will attempt to fix it.
-            let [stream, deviceErrors] = await getAvailableMedia({
-                video: enableVideo && prepareConstraints(previousDevices.video?.deviceId, constraints.video),
-                audio: enableAudio && prepareConstraints(previousDevices.audio?.deviceId, constraints.audio),
-            });
-            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 correctDevicesOnSafari(stream, deviceErrors, devices, constraints, previousDevices);
-            }
-            videoManager.initialize(stream, stream?.getVideoTracks()?.[0] ?? null, videoDevices, !!constraints.video, deviceErrors.video);
-            audioManager.initialize(stream, stream?.getAudioTracks()?.[0] ?? null, audioDevices, !!constraints.audio, deviceErrors.audio);
-            deferred.resolve();
-            if (deviceErrors.video || deviceErrors.audio)
-                return deviceErrors;
-        }
-        catch {
-            deferred.reject();
-        }
-        return null;
-    }, [videoDeviceManagerRef, audioDeviceManagerRef, devicesInitializationRef]);
+    const initializeDevices = useContext(InitDevicesContext);
+    if (!initializeDevices)
+        throw Error("useInitializeDevices must be used within FishjamProvider");
     return {
         /**
          * Initialize access to the devices before joining the room

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

@@ -4,11 +4,11 @@
  */
 export declare function useMicrophone(): {
     /** Toggles current microphone on/off */
-    toggleMicrophone: () => Promise<void>;
+    toggleMicrophone: () => Promise<undefined | import("../..").DeviceError>;
     /** Mutes/unmutes the microphone */
     toggleMicrophoneMute: () => Promise<void>;
     /** Selects the microphone device */
-    selectMicrophone: (deviceId?: string) => Promise<void>;
+    selectMicrophone: (deviceId?: string) => Promise<undefined | import("../..").DeviceError>;
     /**
      * Indicates which microphone is now turned on and streaming audio
      */

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

@@ -1 +1 @@
-{"version":3,"file":"useMicrophone.d.ts","sourceRoot":"","sources":["../../../src/hooks/devices/useMicrophone.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wBAAgB,aAAa;IAKzB,wCAAwC;;IAExC,mCAAmC;;IAEnC,oCAAoC;;IAEpC;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;EAGN"}
+{"version":3,"file":"useMicrophone.d.ts","sourceRoot":"","sources":["../../../src/hooks/devices/useMicrophone.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,wBAAgB,aAAa;IAazB,wCAAwC;;IAExC,mCAAmC;;IAEnC,oCAAoC;;IAEpC;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;EAGN"}

package/dist/hooks/devices/useMicrophone.js

@@ -1,12 +1,20 @@
-import { useDeviceApi } from "../internal/device/useDeviceApi";
-import { useFishjamContext } from "../internal/useFishjamContext";
+import { useContext, useMemo } from "react";
+import { MicrophoneContext } from "../../contexts/microphone";
 /**
  * Manage microphone
  * @category Devices
  */
 export function useMicrophone() {
-    const { audioTrackManager, audioDeviceManagerRef } = useFishjamContext();
-    const deviceApi = useDeviceApi({ deviceManager: audioDeviceManagerRef.current });
+    const microphoneCtx = useContext(MicrophoneContext);
+    if (!microphoneCtx)
+        throw Error("useMicrophone must be used within FishjamProvider");
+    const { audioTrackManager, microphoneManager } = microphoneCtx;
+    const microphoneStream = useMemo(() => {
+        const track = audioTrackManager.deviceTrack;
+        if (!track)
+            return null;
+        return new MediaStream([track]);
+    }, [audioTrackManager.deviceTrack]);
     return {
         /** Toggles current microphone on/off */
         toggleMicrophone: audioTrackManager.toggleDevice,
@@ -17,23 +25,23 @@ export function useMicrophone() {
         /**
          * Indicates which microphone is now turned on and streaming audio
          */
-        activeMicrophone: deviceApi.activeDevice,
+        activeMicrophone: microphoneManager.activeDevice,
         /**
          * Indicates whether the microphone is streaming audio
          */
-        isMicrophoneOn: !!deviceApi.mediaStream,
+        isMicrophoneOn: !!microphoneStream,
         /**
          * Indicates whether the microphone is muted
          */
-        isMicrophoneMuted: audioTrackManager.paused,
+        isMicrophoneMuted: !microphoneManager.deviceEnabled,
         /**
          * The MediaStream object containing the current audio stream
          */
-        microphoneStream: deviceApi.mediaStream,
+        microphoneStream,
         /**
          * The currently set microphone middleware function
          */
-        currentMicrophoneMiddleware: deviceApi.currentMiddleware,
+        currentMicrophoneMiddleware: audioTrackManager.currentMiddleware,
         /**
          * Sets the microphone middleware
          */
@@ -41,10 +49,10 @@ export function useMicrophone() {
         /**
          * List of available microphone devices
          */
-        microphoneDevices: deviceApi.devices,
+        microphoneDevices: microphoneManager.deviceList,
         /**
          * Possible error thrown while setting up the microphone
          */
-        microphoneDeviceError: deviceApi.deviceError,
+        microphoneDeviceError: microphoneManager.deviceError,
     };
 }

package/dist/hooks/internal/devices/useDeviceManager.d.ts

@@ -0,0 +1,29 @@
+import type { SetStateAction } from "react";
+import type { DeviceError, DeviceItem, TrackMiddleware } from "../../../types/public";
+type DeviceManagerProps = {
+    mediaStream: MediaStream | null;
+    setMediaStream: (action: SetStateAction<MediaStream | null>) => void;
+    deviceError: DeviceError | null;
+    setDeviceError: (action: SetStateAction<DeviceError | null>) => void;
+    getInitialStream: () => Promise<MediaStream | null>;
+    deviceType: "audio" | "video";
+    allDevicesList: MediaDeviceInfo[];
+    constraints?: MediaTrackConstraints | boolean;
+    saveUsedDevice: (device: MediaDeviceInfo) => void;
+};
+export type DeviceManager = {
+    startDevice: (deviceId?: string) => Promise<[MediaStreamTrack, null] | [null, DeviceError]>;
+    stopDevice: () => void;
+    activeDevice: DeviceItem | null;
+    deviceTrack: MediaStreamTrack | null;
+    deviceList: DeviceItem[];
+    deviceEnabled: boolean;
+    enableDevice: () => void;
+    disableDevice: () => void;
+    currentMiddleware: TrackMiddleware;
+    applyMiddleware: (middleware: TrackMiddleware) => MediaStreamTrack | null;
+    deviceError: DeviceError | null;
+};
+export declare const useDeviceManager: ({ mediaStream, getInitialStream, deviceType, allDevicesList, setMediaStream, constraints, saveUsedDevice, deviceError, setDeviceError, }: DeviceManagerProps) => DeviceManager;
+export {};
+//# sourceMappingURL=useDeviceManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDeviceManager.d.ts","sourceRoot":"","sources":["../../../../src/hooks/internal/devices/useDeviceManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAG5C,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAKtF,KAAK,kBAAkB,GAAG;IACxB,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAChC,cAAc,EAAE,CAAC,MAAM,EAAE,cAAc,CAAC,WAAW,GAAG,IAAI,CAAC,KAAK,IAAI,CAAC;IACrE,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAChC,cAAc,EAAE,CAAC,MAAM,EAAE,cAAc,CAAC,WAAW,GAAG,IAAI,CAAC,KAAK,IAAI,CAAC;IACrE,gBAAgB,EAAE,MAAM,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IACpD,UAAU,EAAE,OAAO,GAAG,OAAO,CAAC;IAC9B,cAAc,EAAE,eAAe,EAAE,CAAC;IAClC,WAAW,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC;IAC9C,cAAc,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;CACnD,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,WAAW,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,gBAAgB,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC;IAC5F,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,YAAY,EAAE,UAAU,GAAG,IAAI,CAAC;IAChC,WAAW,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACrC,UAAU,EAAE,UAAU,EAAE,CAAC;IACzB,aAAa,EAAE,OAAO,CAAC;IACvB,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,iBAAiB,EAAE,eAAe,CAAC;IACnC,eAAe,EAAE,CAAC,UAAU,EAAE,eAAe,KAAK,gBAAgB,GAAG,IAAI,CAAC;IAC1E,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;CACjC,CAAC;AAsCF,eAAO,MAAM,gBAAgB,GAAI,0IAU9B,kBAAkB,KAAG,aAuFvB,CAAC"}