@fishjam-cloud/react-client 0.5.5 → 0.7.0

package/dist/DeviceManager.d.ts

@@ -1,4 +1,4 @@
-import type { DeviceManagerConfig, DeviceState, MediaManager, StorageConfig, DeviceError } from "./types";
+import type { DeviceManagerConfig, DeviceState, MediaManager, StorageConfig, DeviceError, DeviceManagerStatus } from "./types";
 import type TypedEmitter from "typed-emitter";
 export type DeviceManagerEvents = {
     managerStarted: (event: DeviceState & {
@@ -7,7 +7,7 @@ export type DeviceManagerEvents = {
     managerInitialized: (state: DeviceState) => void;
     devicesStarted: (event: {
         restarting: boolean;
-        constraints?: string | boolean;
+        constraints?: MediaTrackConstraints | boolean;
     }, state: DeviceState) => void;
     deviceReady: (event: {
         stream: MediaStream;
@@ -20,7 +20,6 @@ export type DeviceManagerEvents = {
     deviceDisabled: (state: DeviceState) => void;
     error: (event: any, state: DeviceState) => void;
 };
-export type DeviceManagerStatus = "uninitialized" | "initializing" | "initialized" | "error";
 declare const DeviceManager_base: new () => TypedEmitter<DeviceManagerEvents>;
 export declare class DeviceManager extends DeviceManager_base implements MediaManager {
     private constraints;
@@ -39,7 +38,7 @@ export declare class DeviceManager extends DeviceManager_base implements MediaMa
     private onTrackEnded;
     getLastDevice(): MediaDeviceInfo | null;
     private saveLastDevice;
-    start(deviceId?: string | boolean): Promise<void>;
+    start(deviceId?: string): Promise<void>;
     stop(): Promise<void>;
     disable(): void;
     enable(): void;

package/dist/DeviceManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DeviceManager.d.ts","sourceRoot":"","sources":["../src/DeviceManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAK1G,OAAO,KAAK,YAAY,MAAM,eAAe,CAAC;AAI9C,MAAM,MAAM,mBAAmB,GAAG;IAChC,cAAc,EAAE,CACd,KAAK,EAAE,WAAW,GAAG;QACnB,WAAW,EAAE,qBAAqB,GAAG,SAAS,CAAC;KAChD,EACD,KAAK,EAAE,WAAW,KACf,IAAI,CAAC;IACV,kBAAkB,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IACjD,cAAc,EAAE,CAAC,KAAK,EAAE;QAAE,UAAU,EAAE,OAAO,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,EAAE,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IAC7G,WAAW,EAAE,CAAC,KAAK,EAAE;QAAE,MAAM,EAAE,WAAW,CAAA;KAAE,EAAE,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IAC1E,YAAY,EAAE,CAAC,KAAK,EAAE,WAAW,GAAG;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,EAAE,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IACxF,aAAa,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IAC5C,aAAa,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IAC5C,cAAc,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IAE7C,KAAK,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;CACjD,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,eAAe,GAAG,cAAc,GAAG,aAAa,GAAG,OAAO,CAAC;4CAGxD,YAAY,CAAC,mBAAmB,CAAC;AADtE,qBAAa,aACX,SAAQ,kBACR,YAAW,YAAY;IAEvB,OAAO,CAAC,WAAW,CAAoC;IACvD,OAAO,CAAC,aAAa,CAAuB;IAE5C,OAAO,CAAC,MAAM,CAAwC;IACtD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;IAExC,WAAW,EAAE,WAAW,CAM7B;gBAEU,UAAU,EAAE,OAAO,GAAG,OAAO,EAAE,aAAa,CAAC,EAAE,mBAAmB;IAS9E,OAAO,CAAC,mBAAmB;IAMpB,SAAS,IAAI,mBAAmB;IAIhC,cAAc,CACnB,kBAAkB,EAAE,OAAO,GAAG,qBAAqB,GAAG,SAAS,GAC9D,qBAAqB,GAAG,SAAS;IAO7B,QAAQ,uCAAgC;IAExC,SAAS,2BAKd;IAEK,UAAU,WACP,WAAW,GAAG,IAAI,SACnB,gBAAgB,GAAG,IAAI,WACrB,eAAe,EAAE,kBACV,OAAO,UAChB,WAAW,GAAG,IAAI,iBAWzB;IAEF,OAAO,CAAC,oBAAoB;IAS5B,OAAO,CAAC,YAAY,CAIlB;IAEK,aAAa,IAAI,eAAe,GAAG,IAAI;IAI9C,OAAO,CAAC,cAAc;IAMT,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO;IA4EjC,IAAI;IAOV,OAAO;IAWP,MAAM;IAWN,aAAa,0BAElB;IAEK,SAAS,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,aAAa,EAAE,WAAW,CAAC,EAAE,OAAO,GAAG,qBAAqB;CAIlG"}
+{"version":3,"file":"DeviceManager.d.ts","sourceRoot":"","sources":["../src/DeviceManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,WAAW,EACX,YAAY,EACZ,aAAa,EACb,WAAW,EACX,mBAAmB,EACpB,MAAM,SAAS,CAAC;AAKjB,OAAO,KAAK,YAAY,MAAM,eAAe,CAAC;AAI9C,MAAM,MAAM,mBAAmB,GAAG;IAChC,cAAc,EAAE,CACd,KAAK,EAAE,WAAW,GAAG;QACnB,WAAW,EAAE,qBAAqB,GAAG,SAAS,CAAC;KAChD,EACD,KAAK,EAAE,WAAW,KACf,IAAI,CAAC;IACV,kBAAkB,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IACjD,cAAc,EAAE,CACd,KAAK,EAAE;QAAE,UAAU,EAAE,OAAO,CAAC;QAAC,WAAW,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAA;KAAE,EAC7E,KAAK,EAAE,WAAW,KACf,IAAI,CAAC;IACV,WAAW,EAAE,CAAC,KAAK,EAAE;QAAE,MAAM,EAAE,WAAW,CAAA;KAAE,EAAE,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IAC1E,YAAY,EAAE,CAAC,KAAK,EAAE,WAAW,GAAG;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,EAAE,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IACxF,aAAa,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IAC5C,aAAa,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IAC5C,cAAc,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IAE7C,KAAK,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;CACjD,CAAC;4CAGmC,YAAY,CAAC,mBAAmB,CAAC;AADtE,qBAAa,aACX,SAAQ,kBACR,YAAW,YAAY;IAEvB,OAAO,CAAC,WAAW,CAAoC;IACvD,OAAO,CAAC,aAAa,CAAuB;IAE5C,OAAO,CAAC,MAAM,CAAwC;IACtD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;IAExC,WAAW,EAAE,WAAW,CAM7B;gBAEU,UAAU,EAAE,OAAO,GAAG,OAAO,EAAE,aAAa,CAAC,EAAE,mBAAmB;IAO9E,OAAO,CAAC,mBAAmB;IAMpB,SAAS,IAAI,mBAAmB;IAIhC,cAAc,CACnB,kBAAkB,EAAE,OAAO,GAAG,qBAAqB,GAAG,SAAS,GAC9D,qBAAqB,GAAG,SAAS;IAO7B,QAAQ,uCAAgC;IAExC,SAAS,2BAMd;IAEK,UAAU,WACP,WAAW,GAAG,IAAI,SACnB,gBAAgB,GAAG,IAAI,WACrB,eAAe,EAAE,kBACV,OAAO,UAChB,WAAW,GAAG,IAAI,iBAazB;IAEF,OAAO,CAAC,oBAAoB;IAS5B,OAAO,CAAC,YAAY,CAIlB;IAEK,aAAa,IAAI,eAAe,GAAG,IAAI;IAI9C,OAAO,CAAC,cAAc;IAKT,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM;IAkFvB,IAAI;IAOV,OAAO;IAWP,MAAM;IAWN,aAAa,0BAElB;IAEK,SAAS,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,aAAa,EAAE,WAAW,CAAC,EAAE,OAAO,GAAG,qBAAqB;CAIlG"}

package/dist/DeviceManager.js

@@ -16,15 +16,15 @@ export class DeviceManager extends EventEmitter {
     };
     constructor(deviceType, defaultConfig) {
         super();
-        this.storageConfig = this.createStorageConfig(defaultConfig?.storage);
+        this.storageConfig = this.createStorageConfig(deviceType, defaultConfig?.storage);
         this.deviceType = deviceType;
         this.constraints = toMediaTrackConstraints(defaultConfig?.trackConstraints ?? true);
     }
-    createStorageConfig(storage) {
+    createStorageConfig(deviceType, storage) {
         if (storage === false)
             return null;
         if (storage === true || storage === undefined)
-            return getLocalStorageConfig(this.deviceType);
+            return getLocalStorageConfig(deviceType);
         return storage;
     }
     getStatus() {
@@ -39,10 +39,11 @@ export class DeviceManager extends EventEmitter {
     }
     getMedia = () => this.deviceState.media;
     getTracks = () => {
+        const stream = this.deviceState.media?.stream;
         if (this.deviceType === "audio") {
-            return this.deviceState.media?.stream?.getAudioTracks() ?? [];
+            return stream?.getAudioTracks() ?? [];
         }
-        return this.deviceState.media?.stream?.getVideoTracks() ?? [];
+        return stream?.getVideoTracks() ?? [];
     };
     initialize = (stream, track, devices, requestedMedia, error = null) => {
         this.deviceState = prepareDeviceState(stream, track, devices, error, requestedMedia);
@@ -51,6 +52,7 @@ export class DeviceManager extends EventEmitter {
             this.saveLastDevice(deviceInfo);
         this.status = "initialized";
         this.setupOnEndedCallback();
+        this.emit("managerInitialized", this.deviceState);
         return this.deviceState;
     };
     setupOnEndedCallback() {
@@ -71,23 +73,26 @@ export class DeviceManager extends EventEmitter {
             console.warn("Device manager storage has been disabled");
         this.storageConfig?.saveLastDevice(info);
     }
-    // todo `audioDeviceId / videoDeviceId === true` means use last device
     async start(deviceId) {
-        const shouldRestart = !!deviceId && deviceId !== this.deviceState.media?.deviceInfo?.deviceId;
-        const newDevice = deviceId === true ? this.getLastDevice()?.deviceId || true : deviceId;
+        const newDeviceId = deviceId ?? this.getLastDevice()?.deviceId;
+        const currentDeviceId = this.deviceState.media?.deviceInfo?.deviceId;
+        const shouldReplaceDevice = Boolean(currentDeviceId && currentDeviceId !== newDeviceId);
+        const isDeviceStopped = currentDeviceId === undefined;
+        const shouldProceed = isDeviceStopped || shouldReplaceDevice;
         const trackConstraints = this.constraints;
-        const exactConstraints = shouldRestart && prepareMediaTrackConstraints(newDevice, trackConstraints);
+        const exactConstraints = shouldProceed && prepareMediaTrackConstraints(newDeviceId, trackConstraints);
         if (!exactConstraints)
             return;
         this.deviceState.mediaStatus = "Requesting";
-        this.emit("devicesStarted", { ...this.deviceState, restarting: shouldRestart, constraints: newDevice }, this.deviceState);
+        this.emit("devicesStarted", { ...this.deviceState, restarting: shouldReplaceDevice, constraints: exactConstraints }, this.deviceState);
         try {
             const stream = await navigator.mediaDevices.getUserMedia({ [this.deviceType]: exactConstraints });
             const getTrack = () => {
                 const tracks = this.deviceType === "audio" ? stream.getAudioTracks() : stream.getVideoTracks();
                 return tracks[0] ?? null;
             };
-            const currentDeviceId = getTrack()?.getSettings()?.deviceId;
+            const track = getTrack();
+            const currentDeviceId = track?.getSettings()?.deviceId;
             const deviceInfo = currentDeviceId ? getDeviceInfo(currentDeviceId, this.deviceState.devices ?? []) : null;
             if (deviceInfo) {
                 this.saveLastDevice?.(deviceInfo);
@@ -104,18 +109,18 @@ export class DeviceManager extends EventEmitter {
             // Manually stopping tracks on its own does not generate the `ended` event.
             // The ended event in Safari has already been emitted and will be handled in the future.
             // Therefore, in the `onTrackEnded` method, events for already stopped tracks are filtered out to prevent the state from being damaged.
-            if (shouldRestart) {
+            if (shouldReplaceDevice) {
                 this.deviceState?.media?.track?.stop();
-                this.deviceState.media = {
-                    stream: stream,
-                    track: getTrack(),
-                    deviceInfo,
-                    enabled: true,
-                };
             }
+            this.deviceState.media = {
+                stream,
+                track,
+                deviceInfo,
+                enabled: true,
+            };
             this.setupOnEndedCallback();
             this.deviceState.mediaStatus = "OK";
-            this.emit("devicesReady", { ...this.deviceState, restarted: shouldRestart }, this.deviceState);
+            this.emit("devicesReady", { ...this.deviceState, restarted: shouldReplaceDevice }, this.deviceState);
         }
         catch (err) {
             const parsedError = parseUserMediaError(err);
@@ -154,7 +159,7 @@ export class DeviceManager extends EventEmitter {
         return this.deviceType;
     };
     setConfig(storage, constraints) {
-        this.storageConfig = this.createStorageConfig(storage);
+        this.storageConfig = this.createStorageConfig(this.deviceType, storage);
         this.constraints = constraints ? toMediaTrackConstraints(constraints) : undefined;
     }
 }

package/dist/constraints.d.ts

@@ -2,25 +2,6 @@ export declare const AUDIO_TRACK_CONSTRAINTS: MediaTrackConstraints;
 export declare const VIDEO_TRACK_CONSTRAINTS: MediaTrackConstraints;
 export declare const SCREEN_SHARING_MEDIA_CONSTRAINTS: MediaStreamConstraints;
 export declare const toMediaTrackConstraints: (constraint?: boolean | MediaTrackConstraints) => MediaTrackConstraints | undefined;
-export declare const prepareMediaTrackConstraints: (deviceId: string | undefined | boolean, constraints: MediaTrackConstraints | undefined) => MediaTrackConstraints | boolean;
-export declare const getExactDeviceConstraint: (constraints: MediaTrackConstraints | undefined, deviceId: string | undefined) => {
-    deviceId: {
-        exact: string | undefined;
-    };
-    advanced?: MediaTrackConstraintSet[];
-    aspectRatio?: ConstrainDouble;
-    autoGainControl?: ConstrainBoolean;
-    channelCount?: ConstrainULong;
-    displaySurface?: ConstrainDOMString;
-    echoCancellation?: ConstrainBoolean;
-    facingMode?: ConstrainDOMString;
-    frameRate?: ConstrainDouble;
-    groupId?: ConstrainDOMString;
-    height?: ConstrainULong;
-    noiseSuppression?: ConstrainBoolean;
-    sampleRate?: ConstrainULong;
-    sampleSize?: ConstrainULong;
-    width?: ConstrainULong;
-};
-export declare const prepareConstraints: (deviceIdToStart: string | undefined, constraints: MediaTrackConstraints | undefined) => MediaTrackConstraints | undefined | boolean;
+export declare const prepareMediaTrackConstraints: (deviceId: string | undefined, constraints: MediaTrackConstraints | undefined) => MediaTrackConstraints | boolean;
+export declare const prepareConstraints: (deviceIdToStart: string | undefined, constraints: MediaTrackConstraints | undefined) => MediaTrackConstraints | undefined;
 //# sourceMappingURL=constraints.d.ts.map

package/dist/constraints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constraints.d.ts","sourceRoot":"","sources":["../src/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,uBAAuB,gBACrB,OAAO,GAAG,qBAAqB,KAC3C,qBAAqB,GAAG,SAK1B,CAAC;AAEF,eAAO,MAAM,4BAA4B,aAC7B,MAAM,GAAG,SAAS,GAAG,OAAO,eACzB,qBAAqB,GAAG,SAAS,KAC7C,qBAAqB,GAAG,OAK1B,CAAC;AAEF,eAAO,MAAM,wBAAwB,gBACtB,qBAAqB,GAAG,SAAS,YACpC,MAAM,GAAG,SAAS;;;;;;;;;;;;;;;;;;CAI5B,CAAC;AAEH,eAAO,MAAM,kBAAkB,oBACZ,MAAM,GAAG,SAAS,eACtB,qBAAqB,GAAG,SAAS,KAC7C,qBAAqB,GAAG,SAAS,GAAG,OAEtC,CAAC"}
+{"version":3,"file":"constraints.d.ts","sourceRoot":"","sources":["../src/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,uBAAuB,gBACrB,OAAO,GAAG,qBAAqB,KAC3C,qBAAqB,GAAG,SAK1B,CAAC;AAEF,eAAO,MAAM,4BAA4B,aAC7B,MAAM,GAAG,SAAS,eACf,qBAAqB,GAAG,SAAS,KAC7C,qBAAqB,GAAG,OAI1B,CAAC;AAEF,eAAO,MAAM,kBAAkB,oBACZ,MAAM,GAAG,SAAS,eACtB,qBAAqB,GAAG,SAAS,KAC7C,qBAAqB,GAAG,SAI1B,CAAC"}

package/dist/constraints.js

@@ -32,16 +32,12 @@ export const toMediaTrackConstraints = (constraint) => {
 };
 export const prepareMediaTrackConstraints = (deviceId, constraints) => {
     if (!deviceId)
-        return false;
-    if (deviceId === true)
         return { ...constraints };
     const exactId = deviceId ? { deviceId: { exact: deviceId } } : {};
     return { ...constraints, ...exactId };
 };
-export const getExactDeviceConstraint = (constraints, deviceId) => ({
-    ...constraints,
-    deviceId: { exact: deviceId },
-});
 export const prepareConstraints = (deviceIdToStart, constraints) => {
-    return deviceIdToStart ? getExactDeviceConstraint(constraints, deviceIdToStart) : constraints;
+    if (!deviceIdToStart)
+        return constraints;
+    return { ...constraints, deviceId: { ideal: deviceIdToStart } };
 };

package/dist/fishjamProvider.d.ts

@@ -0,0 +1,12 @@
+import { type PropsWithChildren } from "react";
+import type { DeviceManagerConfig } from "./types";
+import { type ReconnectConfig } from "@fishjam-cloud/ts-client";
+interface FishjamProviderProps extends PropsWithChildren {
+    config?: {
+        reconnect?: ReconnectConfig | boolean;
+    };
+    deviceManagerDefaultConfig?: DeviceManagerConfig;
+}
+export declare function FishjamProvider({ children, config, deviceManagerDefaultConfig }: FishjamProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=fishjamProvider.d.ts.map

package/dist/fishjamProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fishjamProvider.d.ts","sourceRoot":"","sources":["../src/fishjamProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAEjE,OAAO,KAAK,EAAE,mBAAmB,EAAiD,MAAM,SAAS,CAAC;AAClG,OAAO,EAAiB,KAAK,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAO/E,UAAU,oBAAqB,SAAQ,iBAAiB;IACtD,MAAM,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,eAAe,GAAG,OAAO,CAAA;KAAE,CAAC;IACnD,0BAA0B,CAAC,EAAE,mBAAmB,CAAC;CAClD;AAED,wBAAgB,eAAe,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,0BAA0B,EAAE,EAAE,oBAAoB,2CAqCrG"}

package/dist/fishjamProvider.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef, useState } from "react";
+import { useTrackManager } from "./hooks/useTrackManager";
+import { FishjamClient } from "@fishjam-cloud/ts-client";
+import { FishjamContext } from "./hooks/useFishjamContext";
+import { DeviceManager } from "./DeviceManager";
+import { useParticipantStatus } from "./hooks/useParticipantStatus";
+import { useFishjamClientState } from "./hooks/useFishjamClientState";
+export function FishjamProvider({ children, config, deviceManagerDefaultConfig }) {
+    const fishjamClientRef = useRef(new FishjamClient(config));
+    const hasDevicesBeenInitializedRef = useRef(false);
+    const videoDeviceManagerRef = useRef(new DeviceManager("video", deviceManagerDefaultConfig));
+    const audioDeviceManagerRef = useRef(new DeviceManager("audio", deviceManagerDefaultConfig));
+    const screenShareState = useState({ stream: null, trackIds: null });
+    const { peerStatus, getCurrentParticipantStatus } = useParticipantStatus(fishjamClientRef.current);
+    const videoTrackManager = useTrackManager({
+        mediaManager: videoDeviceManagerRef.current,
+        tsClient: fishjamClientRef.current,
+        getCurrentParticipantStatus,
+    });
+    const audioTrackManager = useTrackManager({
+        mediaManager: audioDeviceManagerRef.current,
+        tsClient: fishjamClientRef.current,
+        getCurrentParticipantStatus,
+    });
+    const clientState = useFishjamClientState(fishjamClientRef.current);
+    const context = {
+        fishjamClientRef,
+        peerStatus,
+        screenShareState,
+        videoTrackManager,
+        audioTrackManager,
+        videoDeviceManagerRef,
+        audioDeviceManagerRef,
+        hasDevicesBeenInitializedRef,
+        clientState,
+    };
+    return _jsx(FishjamContext.Provider, { value: context, children: children });
+}

package/dist/hooks/deviceManagers/useAudioDeviceManager.d.ts

@@ -0,0 +1,2 @@
+export declare const useAudioDeviceManager: () => import("../../types").DeviceManagerState;
+//# sourceMappingURL=useAudioDeviceManager.d.ts.map

package/dist/hooks/deviceManagers/useAudioDeviceManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAudioDeviceManager.d.ts","sourceRoot":"","sources":["../../../src/hooks/deviceManagers/useAudioDeviceManager.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB,gDAKjC,CAAC"}

package/dist/hooks/deviceManagers/useAudioDeviceManager.js

@@ -0,0 +1,7 @@
+import { useFishjamContext } from "../useFishjamContext";
+import { useDeviceManager } from "./useDeviceManager";
+export const useAudioDeviceManager = () => {
+    const { audioDeviceManagerRef } = useFishjamContext();
+    const audioDeviceState = useDeviceManager(audioDeviceManagerRef.current);
+    return audioDeviceState;
+};

package/dist/hooks/deviceManagers/useDeviceManager.d.ts

@@ -0,0 +1,4 @@
+import type { DeviceManagerState } from "../../types";
+import type { DeviceManager } from "../../DeviceManager";
+export declare const useDeviceManager: (deviceManager: DeviceManager) => DeviceManagerState;
+//# sourceMappingURL=useDeviceManager.d.ts.map

package/dist/hooks/deviceManagers/useDeviceManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDeviceManager.d.ts","sourceRoot":"","sources":["../../../src/hooks/deviceManagers/useDeviceManager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAuB,MAAM,qBAAqB,CAAC;AAc9E,eAAO,MAAM,gBAAgB,kBAAmB,aAAa,uBAoC5D,CAAC"}

package/dist/hooks/deviceManagers/useDeviceManager.js

@@ -0,0 +1,39 @@
+import { useCallback, useRef, useSyncExternalStore } from "react";
+const eventNames = [
+    "deviceDisabled",
+    "deviceEnabled",
+    "managerStarted",
+    "deviceStopped",
+    "deviceReady",
+    "devicesStarted",
+    "devicesReady",
+    "managerInitialized",
+    "error",
+];
+export const useDeviceManager = (deviceManager) => {
+    const mutationRef = useRef(false);
+    const subscribe = useCallback((subscribeCallback) => {
+        const callback = () => {
+            mutationRef.current = true;
+            subscribeCallback();
+        };
+        eventNames.forEach((eventName) => deviceManager.on(eventName, callback));
+        return () => {
+            eventNames.forEach((eventName) => deviceManager.removeListener(eventName, callback));
+        };
+    }, [deviceManager]);
+    const lastSnapshotRef = useRef(null);
+    const getSnapshot = useCallback(() => {
+        if (mutationRef.current || lastSnapshotRef.current === null) {
+            lastSnapshotRef.current = {
+                deviceState: deviceManager.deviceState,
+                status: deviceManager.getStatus(),
+                tracks: deviceManager.getTracks(),
+            };
+            mutationRef.current = false;
+        }
+        return lastSnapshotRef.current;
+    }, [deviceManager]);
+    const deviceState = useSyncExternalStore(subscribe, getSnapshot);
+    return deviceState;
+};

package/dist/hooks/deviceManagers/useVideoDeviceManager.d.ts

@@ -0,0 +1,2 @@
+export declare const useVideoDeviceManager: () => import("../../types").DeviceManagerState;
+//# sourceMappingURL=useVideoDeviceManager.d.ts.map

package/dist/hooks/deviceManagers/useVideoDeviceManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useVideoDeviceManager.d.ts","sourceRoot":"","sources":["../../../src/hooks/deviceManagers/useVideoDeviceManager.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB,gDAKjC,CAAC"}

package/dist/hooks/deviceManagers/useVideoDeviceManager.js

@@ -0,0 +1,7 @@
+import { useFishjamContext } from "../useFishjamContext";
+import { useDeviceManager } from "./useDeviceManager";
+export const useVideoDeviceManager = () => {
+    const { videoDeviceManagerRef } = useFishjamContext();
+    const videoDeviceState = useDeviceManager(videoDeviceManagerRef.current);
+    return videoDeviceState;
+};

package/dist/hooks/internal.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../src/hooks/internal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/hooks/internal.js

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

package/dist/hooks/public.d.ts

@@ -0,0 +1,9 @@
+export { useConnect, useDisconnect } from "./useConnection";
+export { useReconnection } from "./useReconnection";
+export { useCamera, useMicrophone, useInitializeDevices } from "./useDevices";
+export { useParticipants } from "./useParticipants";
+export { useScreenShare } from "./useScreenShare";
+export { useStatus } from "./useStatus";
+export { useAudioDeviceManager } from "./deviceManagers/useAudioDeviceManager";
+export { useVideoDeviceManager } from "./deviceManagers/useVideoDeviceManager";
+//# sourceMappingURL=public.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/hooks/public.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAC9E,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC/E,OAAO,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC"}

package/dist/hooks/public.js

@@ -0,0 +1,8 @@
+export { useConnect, useDisconnect } from "./useConnection";
+export { useReconnection } from "./useReconnection";
+export { useCamera, useMicrophone, useInitializeDevices } from "./useDevices";
+export { useParticipants } from "./useParticipants";
+export { useScreenShare } from "./useScreenShare";
+export { useStatus } from "./useStatus";
+export { useAudioDeviceManager } from "./deviceManagers/useAudioDeviceManager";
+export { useVideoDeviceManager } from "./deviceManagers/useVideoDeviceManager";

package/dist/hooks/useConnection.d.ts

@@ -0,0 +1,4 @@
+import type { UseConnect } from "../types";
+export declare function useConnect(): UseConnect;
+export declare function useDisconnect(): () => void;
+//# sourceMappingURL=useConnection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useConnection.d.ts","sourceRoot":"","sources":["../../src/hooks/useConnection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,UAAU,EAAE,MAAM,UAAU,CAAC;AAI1D,wBAAgB,UAAU,IAAI,UAAU,CAOvC;AAED,wBAAgB,aAAa,eAM5B"}

package/dist/hooks/useConnection.js

@@ -0,0 +1,12 @@
+import { useCallback } from "react";
+import { useFishjamContext } from "./useFishjamContext";
+export function useConnect() {
+    const client = useFishjamContext().fishjamClientRef.current;
+    return useCallback((config) => client.connect({ ...config, peerMetadata: config.peerMetadata ?? {} }), [client]);
+}
+export function useDisconnect() {
+    const client = useFishjamContext().fishjamClientRef.current;
+    return useCallback(() => {
+        client.disconnect();
+    }, [client]);
+}

package/dist/hooks/useDevices.d.ts

@@ -0,0 +1,7 @@
+import type { AudioDevice, Device } from "../types";
+export declare function useCamera(): Device;
+export declare function useMicrophone(): AudioDevice;
+export declare const useInitializeDevices: () => {
+    initializeDevices: () => Promise<void>;
+};
+//# sourceMappingURL=useDevices.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDevices.d.ts","sourceRoot":"","sources":["../../src/hooks/useDevices.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAQpD,wBAAgB,SAAS,IAAI,MAAM,CAuBlC;AAED,wBAAgB,aAAa,IAAI,WAAW,CA0B3C;AAED,eAAO,MAAM,oBAAoB;;CAqDhC,CAAC"}

package/dist/hooks/useDevices.js

@@ -0,0 +1,84 @@
+import { useFishjamContext } from "./useFishjamContext";
+import { useVideoDeviceManager } from "./deviceManagers/useVideoDeviceManager";
+import { useAudioDeviceManager } from "./deviceManagers/useAudioDeviceManager";
+import { useCallback } from "react";
+import { getAvailableMedia, getCorrectedResult } from "../mediaInitializer";
+import { useProcessedPreviewStream } from "./useProcessedPreviewStream";
+import { prepareConstraints } from "../constraints";
+export function useCamera() {
+    const { videoTrackManager } = useFishjamContext();
+    const { deviceState } = useVideoDeviceManager();
+    const { currentTrack, ...trackManager } = videoTrackManager;
+    const processedPreviewStream = useProcessedPreviewStream(videoTrackManager, deviceState.media?.track);
+    const stream = currentTrack?.stream ?? processedPreviewStream ?? deviceState.media?.stream ?? null;
+    const isStreaming = Boolean(currentTrack?.stream);
+    const track = stream?.getAudioTracks()[0] ?? null;
+    const trackId = currentTrack?.trackId ?? null;
+    const devices = deviceState.devices ?? [];
+    const activeDevice = deviceState.media?.deviceInfo ?? null;
+    return {
+        ...trackManager,
+        stream,
+        devices,
+        activeDevice,
+        isStreaming,
+        track,
+        trackId,
+    };
+}
+export function useMicrophone() {
+    const { audioTrackManager } = useFishjamContext();
+    const { deviceState } = useAudioDeviceManager();
+    const { currentTrack, ...trackManager } = audioTrackManager;
+    const processedPreviewStream = useProcessedPreviewStream(audioTrackManager, deviceState.media?.track);
+    const stream = currentTrack?.stream ?? processedPreviewStream ?? deviceState.media?.stream ?? null;
+    const isStreaming = Boolean(currentTrack?.stream);
+    const track = stream?.getAudioTracks()[0] ?? null;
+    const trackId = currentTrack?.trackId ?? null;
+    const devices = deviceState.devices ?? [];
+    const activeDevice = deviceState.media?.deviceInfo ?? null;
+    const isAudioPlaying = currentTrack?.vadStatus === "speech";
+    return {
+        ...trackManager,
+        stream,
+        isStreaming,
+        track,
+        trackId,
+        devices,
+        activeDevice,
+        isAudioPlaying,
+    };
+}
+export const useInitializeDevices = () => {
+    const { videoDeviceManagerRef, audioDeviceManagerRef, hasDevicesBeenInitializedRef } = useFishjamContext();
+    const initializeDevices = useCallback(async () => {
+        if (hasDevicesBeenInitializedRef.current)
+            return;
+        hasDevicesBeenInitializedRef.current = true;
+        const videoManager = videoDeviceManagerRef.current;
+        const audioManager = audioDeviceManagerRef.current;
+        const constraints = {
+            video: videoManager.getConstraints(true),
+            audio: audioManager.getConstraints(true),
+        };
+        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: prepareConstraints(previousDevices.video?.deviceId, constraints.video),
+            audio: 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]);
+    return { initializeDevices };
+};

package/dist/hooks/useFishjamClientState.d.ts

@@ -0,0 +1,11 @@
+import type { FishjamClient } from "@fishjam-cloud/ts-client";
+import type { PeerMetadata, TrackMetadata } from "../types";
+import type { PeerState } from "../state.types";
+export interface FishjamClientState {
+    peers: PeerState[];
+    components: PeerState[];
+    localPeer: PeerState | null;
+    isReconnecting: boolean;
+}
+export declare function useFishjamClientState(fishjamClient: FishjamClient<PeerMetadata, TrackMetadata>): FishjamClientState;
+//# sourceMappingURL=useFishjamClientState.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useFishjamClientState.d.ts","sourceRoot":"","sources":["../../src/hooks/useFishjamClientState.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAA0D,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACtH,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,gBAAgB,CAAC;AA0ChE,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;IAC5B,cAAc,EAAE,OAAO,CAAC;CACzB;AAuCD,wBAAgB,qBAAqB,CAAC,aAAa,EAAE,aAAa,CAAC,YAAY,EAAE,aAAa,CAAC,GAAG,kBAAkB,CAyCnH"}

package/dist/hooks/useFishjamClientState.js

@@ -0,0 +1,100 @@
+import { useCallback, useMemo, useRef, useSyncExternalStore } from "react";
+const eventNames = [
+    "socketClose",
+    "socketError",
+    "socketOpen",
+    "authSuccess",
+    "authError",
+    "disconnected",
+    "reconnectionStarted",
+    "reconnected",
+    "reconnectionRetriesLimitReached",
+    "joined",
+    "joinError",
+    "trackReady",
+    "trackAdded",
+    "trackRemoved",
+    "trackUpdated",
+    "peerJoined",
+    "peerLeft",
+    "peerUpdated",
+    "componentAdded",
+    "componentRemoved",
+    "componentUpdated",
+    "connectionError",
+    "tracksPriorityChanged",
+    "bandwidthEstimationChanged",
+    "targetTrackEncodingRequested",
+    "localTrackAdded",
+    "localTrackRemoved",
+    "localTrackReplaced",
+    "localTrackMuted",
+    "localTrackUnmuted",
+    "localTrackBandwidthSet",
+    "localTrackEncodingBandwidthSet",
+    "localTrackEncodingEnabled",
+    "localTrackEncodingDisabled",
+    "localPeerMetadataChanged",
+    "localTrackMetadataChanged",
+    "disconnectRequested",
+];
+function trackContextToTrack(track) {
+    return {
+        rawMetadata: track.rawMetadata,
+        metadata: track.metadata,
+        trackId: track.trackId,
+        stream: track.stream,
+        simulcastConfig: track.simulcastConfig ?? null,
+        encoding: track.encoding ?? null,
+        vadStatus: track.vadStatus,
+        track: track.track,
+        metadataParsingError: track.metadataParsingError,
+    };
+}
+function endpointToPeerState(peer) {
+    const tracks = [...peer.tracks].reduce((acc, [, track]) => ({ ...acc, [track.trackId]: trackContextToTrack(track) }), {});
+    return {
+        rawMetadata: peer.rawMetadata,
+        metadata: peer.metadata,
+        metadataParsingError: peer.metadataParsingError,
+        id: peer.id,
+        tracks,
+    };
+}
+/*
+This is an internally used hook.
+It is not meant to be used by the end user.
+*/
+export function useFishjamClientState(fishjamClient) {
+    const client = useMemo(() => fishjamClient, [fishjamClient]);
+    const mutationRef = useRef(false);
+    const subscribe = useCallback((subscribeCallback) => {
+        const callback = () => {
+            mutationRef.current = true;
+            subscribeCallback();
+        };
+        eventNames.forEach((eventName) => client.on(eventName, callback));
+        return () => {
+            eventNames.forEach((eventName) => client.removeListener(eventName, callback));
+        };
+    }, [client]);
+    const lastSnapshotRef = useRef(null);
+    const getSnapshot = useCallback(() => {
+        if (mutationRef.current || lastSnapshotRef.current === null) {
+            const peers = Object.values(client.getRemotePeers()).map(endpointToPeerState);
+            const components = Object.values(client.getRemoteComponents()).map(endpointToPeerState);
+            const localEndpoint = client.getLocalPeer();
+            const localPeer = localEndpoint ? endpointToPeerState(localEndpoint) : null;
+            const isReconnecting = client.isReconnecting();
+            lastSnapshotRef.current = {
+                peers,
+                components,
+                localPeer,
+                isReconnecting,
+            };
+            mutationRef.current = false;
+        }
+        return lastSnapshotRef.current;
+    }, [client]);
+    return useSyncExternalStore(subscribe, getSnapshot);
+}

package/dist/hooks/useFishjamClient_DO_NOT_USE.d.ts

@@ -0,0 +1,2 @@
+export declare function useFishjamClient_DO_NOT_USE(): import("@fishjam-cloud/ts-client").FishjamClient<import("..").PeerMetadata, import("..").TrackMetadata>;
+//# sourceMappingURL=useFishjamClient_DO_NOT_USE.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useFishjamClient_DO_NOT_USE.d.ts","sourceRoot":"","sources":["../../src/hooks/useFishjamClient_DO_NOT_USE.ts"],"names":[],"mappings":"AAGA,wBAAgB,2BAA2B,4GAI1C"}

package/dist/hooks/useFishjamClient_DO_NOT_USE.js

@@ -0,0 +1,6 @@
+import { useFishjamContext } from "./useFishjamContext";
+import { useMemo } from "react";
+export function useFishjamClient_DO_NOT_USE() {
+    const client = useFishjamContext().fishjamClientRef.current;
+    return useMemo(() => client, [client]);
+}