@fishjam-cloud/react-client 0.13.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,2CA8D1D"}
+{"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,63 +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 }));
-    const hasDevicesBeenInitializedRef = useRef(false);
-    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,
+        type: "camera",
     });
     const audioTrackManager = useTrackManager({
-        mediaManager: audioDeviceManagerRef.current,
         tsClient: fishjamClientRef.current,
-        getCurrentPeerStatus,
+        peerStatus,
+        deviceManager: microphoneManager,
         bandwidthLimits: mergedBandwidthLimits,
         streamConfig: props.audioConfig,
+        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,
-        hasDevicesBeenInitializedRef,
-        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 getCorrectedResult: (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;AAEhF,KAAK,eAAe,GAAG,UAAU,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;AAsB1D,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,CAuB9D,CAAC;AAIF,eAAO,MAAM,kBAAkB,WACrB,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

@@ -1,49 +1,67 @@
 import { NOT_FOUND_ERROR, OVERCONSTRAINED_ERROR, PERMISSION_DENIED, UNHANDLED_ERROR } from "../utils/errors";
 import { prepareConstraints } from "./constraints";
 const defaultErrors = { audio: null, video: null };
-const tryToGetAudioOnlyThenVideoOnly = async (constraints, deviceErrors = defaultErrors, transformConstraint = () => false) => {
-    const audioOnly = await getAvailableMedia({ ...constraints, video: transformConstraint(constraints.video) }, { ...deviceErrors, audio: null });
-    if (audioOnly[0])
-        return audioOnly;
-    return getAvailableMedia({ ...constraints, audio: transformConstraint(constraints.audio) }, { ...deviceErrors, video: null });
+const errorMap = {
+    NotFoundError: NOT_FOUND_ERROR,
+    OverconstrainedError: OVERCONSTRAINED_ERROR,
+    NotAllowedError: PERMISSION_DENIED,
 };
-export const getAvailableMedia = async (constraints, deviceErrors = defaultErrors) => {
+const getSingleMedia = async (type, constraints) => {
+    const baseConstraints = { audio: undefined, video: undefined };
     try {
-        return [await navigator.mediaDevices.getUserMedia(constraints), deviceErrors];
+        const stream = await navigator.mediaDevices.getUserMedia({ ...baseConstraints, [type]: constraints });
+        return [stream, null];
     }
     catch (err) {
         if (!(err instanceof DOMException))
-            return [null, { audio: UNHANDLED_ERROR, video: UNHANDLED_ERROR }];
-        if (err.name === deviceErrors.audio?.name || err.name === deviceErrors.video?.name)
-            return [null, deviceErrors];
-        switch (err.name) {
-            case "NotFoundError":
-                return tryToGetAudioOnlyThenVideoOnly(constraints, { audio: NOT_FOUND_ERROR, video: NOT_FOUND_ERROR });
-            case "OverconstrainedError":
-                return tryToGetAudioOnlyThenVideoOnly(constraints, { audio: OVERCONSTRAINED_ERROR, video: OVERCONSTRAINED_ERROR }, removeSpecifiedDeviceFromConstraints);
-            case "NotAllowedError":
-                return tryToGetAudioOnlyThenVideoOnly(constraints, { audio: PERMISSION_DENIED, video: PERMISSION_DENIED });
-            default:
-                return [null, { audio: UNHANDLED_ERROR, video: UNHANDLED_ERROR }];
+            return [null, UNHANDLED_ERROR];
+        return [null, errorMap[err.name] ?? UNHANDLED_ERROR];
+    }
+};
+const tryToGetAudioOnlyThenVideoOnly = async (constraints, initialError) => {
+    const [audioStream, audioErr] = await getSingleMedia("audio", constraints.audio);
+    if (audioStream)
+        return { stream: audioStream, errors: { video: initialError, audio: null } };
+    const [videoStream, videoErr] = await getSingleMedia("video", constraints.video);
+    return { stream: videoStream, errors: { audio: audioErr, video: videoErr } };
+};
+export const getAvailableMedia = async (constraints, errors = defaultErrors) => {
+    try {
+        return { stream: await navigator.mediaDevices.getUserMedia(constraints), errors };
+    }
+    catch (err) {
+        if (err instanceof DOMException) {
+            switch (err.name) {
+                case errors.audio?.name:
+                case errors.video?.name:
+                    return { stream: null, errors };
+                case "NotFoundError":
+                    return tryToGetAudioOnlyThenVideoOnly(constraints, PERMISSION_DENIED);
+                case "OverconstrainedError":
+                    return getAvailableMedia({ audio: unspecifyDevice(constraints.audio), video: unspecifyDevice(constraints.video) }, { audio: OVERCONSTRAINED_ERROR, video: OVERCONSTRAINED_ERROR });
+                case "NotAllowedError":
+                    return tryToGetAudioOnlyThenVideoOnly(constraints, PERMISSION_DENIED);
+            }
         }
+        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 getCorrectedResult = 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 };
@@ -69,7 +87,7 @@ const stopTracks = (requestedDevices) => {
         track.stop();
     }
 };
-const removeSpecifiedDeviceFromConstraints = (trackConstraints) => {
+const unspecifyDevice = (trackConstraints) => {
     if (typeof trackConstraints === "object") {
         return { ...trackConstraints, deviceId: undefined };
     }

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

@@ -10,6 +10,6 @@ export declare const useInitializeDevices: () => {
     /**
      * Initialize access to the devices before joining the room
      */
-    initializeDevices: (params?: UseInitializeDevicesParams) => Promise<void>;
+    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":"AAMA,MAAM,MAAM,0BAA0B,GAAG;IACvC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB;IAwD7B;;OAEG;iCAvD8B,0BAA0B,KAAK,OAAO,CAAC,IAAI,CAAC;CA0DhF,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,42 +1,13 @@
-import { useCallback } from "react";
-import { prepareConstraints } from "../../devices/constraints";
-import { getAvailableMedia, getCorrectedResult } from "../../devices/mediaInitializer";
-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, hasDevicesBeenInitializedRef } = useFishjamContext();
-    const initializeDevices = useCallback(async ({ enableVideo = true, enableAudio = true } = {}) => {
-        if (hasDevicesBeenInitializedRef.current)
-            return;
-        hasDevicesBeenInitializedRef.current = true;
-        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 `getCorrectedResult` 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 getCorrectedResult(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);
-    }, [videoDeviceManagerRef, audioDeviceManagerRef, hasDevicesBeenInitializedRef]);
+    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,
     };
 }