@fishjam-cloud/react-client 0.7.0 → 0.7.2

package/dist/DeviceManager.d.ts

@@ -1,5 +1,7 @@
-import type { DeviceManagerConfig, DeviceState, MediaManager, StorageConfig, DeviceError, DeviceManagerStatus } from "./types";
+import type { DeviceError, DeviceManagerStatus, DeviceState, Media, MediaManager } from "./types/internal";
 import type TypedEmitter from "typed-emitter";
+import type { PersistLastDeviceHandlers, TrackMiddleware } from "./types/public";
+export type DeviceType = "audio" | "video";
 export type DeviceManagerEvents = {
     managerStarted: (event: DeviceState & {
         constraints: MediaTrackConstraints | undefined;
@@ -18,32 +20,46 @@ export type DeviceManagerEvents = {
     deviceStopped: (state: DeviceState) => void;
     deviceEnabled: (state: DeviceState) => void;
     deviceDisabled: (state: DeviceState) => void;
+    middlewareSet: (state: DeviceState) => void;
     error: (event: any, state: DeviceState) => void;
 };
+export type DeviceManagerConfig = {
+    deviceType: DeviceType;
+    defaultConstraints: MediaTrackConstraints;
+    userConstraints?: boolean | MediaTrackConstraints;
+    storage?: boolean | PersistLastDeviceHandlers;
+};
 declare const DeviceManager_base: new () => TypedEmitter<DeviceManagerEvents>;
 export declare class DeviceManager extends DeviceManager_base implements MediaManager {
-    private constraints;
-    private storageConfig;
+    private readonly constraints;
     private status;
     private readonly deviceType;
-    deviceState: DeviceState;
-    constructor(deviceType: "audio" | "video", defaultConfig?: DeviceManagerConfig);
-    private createStorageConfig;
+    private readonly middlewareManager;
+    readonly getLastDevice: () => MediaDeviceInfo | null;
+    private readonly saveLastDevice;
+    private rawMedia;
+    private processedMediaTrack;
+    private media;
+    private mediaStatus;
+    private devices;
+    private devicesStatus;
+    private error;
+    constructor({ deviceType, storage, userConstraints, defaultConstraints }: DeviceManagerConfig);
+    getState(): DeviceState;
     getStatus(): DeviceManagerStatus;
-    getConstraints(currentConstraints: boolean | MediaTrackConstraints | undefined): MediaTrackConstraints | undefined;
-    getMedia: () => import("./types").Media | null;
-    getTracks: () => MediaStreamTrack[];
-    initialize: (stream: MediaStream | null, track: MediaStreamTrack | null, devices: MediaDeviceInfo[], requestedMedia: boolean, error?: DeviceError | null) => DeviceState;
-    private setupOnEndedCallback;
-    private onTrackEnded;
-    getLastDevice(): MediaDeviceInfo | null;
-    private saveLastDevice;
+    getConstraints(): MediaTrackConstraints | boolean;
+    getDeviceType: () => DeviceType;
+    getMedia: () => Media | null;
+    initialize: (stream: MediaStream | null, track: MediaStreamTrack | null, devices: MediaDeviceInfo[], requestedMedia: boolean, error?: DeviceError | null) => void;
     start(deviceId?: string): Promise<void>;
-    stop(): Promise<void>;
+    setTrackMiddleware(middleware: TrackMiddleware | null): Promise<void>;
+    getMiddleware(): TrackMiddleware | null;
+    stop(): void;
     disable(): void;
     enable(): void;
-    getDeviceType: () => "audio" | "video";
-    setConfig(storage?: boolean | StorageConfig, constraints?: boolean | MediaTrackConstraints): void;
+    private setEnable;
+    private updateMedia;
+    private setCurrentMedia;
 }
 export {};
 //# sourceMappingURL=DeviceManager.d.ts.map

package/dist/DeviceManager.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"DeviceManager.d.ts","sourceRoot":"","sources":["../src/DeviceManager.ts"],"names":[],"mappings":"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"}

package/dist/DeviceManager.js

@@ -1,99 +1,93 @@
-import { prepareMediaTrackConstraints, toMediaTrackConstraints } from "./constraints";
+import { prepareMediaTrackConstraints } from "./constraints";
 import EventEmitter from "events";
-import { getDeviceInfo, getLocalStorageConfig, prepareDeviceState } from "./utils/media";
+import { MiddlewareManager } from "./devices/MiddlewareManager";
+import { createStorageConfig } from "./utils/localStorage";
+import { setupOnEndedCallback } from "./utils/track";
 import { parseUserMediaError } from "./utils/errors";
+const NOOP = () => { };
 export class DeviceManager extends EventEmitter {
     constraints;
-    storageConfig;
     status = "uninitialized";
     deviceType;
-    deviceState = {
-        media: null,
-        mediaStatus: "Not requested",
-        devices: null,
-        devicesStatus: "Not requested",
-        error: null,
-    };
-    constructor(deviceType, defaultConfig) {
+    middlewareManager = new MiddlewareManager();
+    getLastDevice = () => null;
+    saveLastDevice = NOOP;
+    rawMedia = null;
+    processedMediaTrack = null;
+    media = null;
+    mediaStatus = "Not requested";
+    devices = null;
+    devicesStatus = "Not requested";
+    error = null;
+    constructor({ deviceType, storage, userConstraints, defaultConstraints }) {
         super();
-        this.storageConfig = this.createStorageConfig(deviceType, defaultConfig?.storage);
+        const storageConfig = createStorageConfig(deviceType, storage);
+        if (storageConfig) {
+            this.getLastDevice = storageConfig.getLastDevice;
+            this.saveLastDevice = storageConfig.saveLastDevice;
+        }
         this.deviceType = deviceType;
-        this.constraints = toMediaTrackConstraints(defaultConfig?.trackConstraints ?? true);
+        this.constraints = userConstraints ?? defaultConstraints;
     }
-    createStorageConfig(deviceType, storage) {
-        if (storage === false)
-            return null;
-        if (storage === true || storage === undefined)
-            return getLocalStorageConfig(deviceType);
-        return storage;
+    getState() {
+        return {
+            mediaStatus: this.mediaStatus,
+            devices: this.devices,
+            devicesStatus: this.devicesStatus,
+            error: this.error,
+            media: this.media,
+            currentMiddleware: this.middlewareManager.getMiddleware(),
+        };
     }
     getStatus() {
         return this.status;
     }
-    getConstraints(currentConstraints) {
-        if (currentConstraints === false)
-            return undefined;
-        if (currentConstraints === undefined || currentConstraints === true)
-            return this.constraints;
-        return currentConstraints ?? this.constraints;
+    getConstraints() {
+        return this.constraints;
     }
-    getMedia = () => this.deviceState.media;
-    getTracks = () => {
-        const stream = this.deviceState.media?.stream;
-        if (this.deviceType === "audio") {
-            return stream?.getAudioTracks() ?? [];
-        }
-        return stream?.getVideoTracks() ?? [];
+    getDeviceType = () => {
+        return this.deviceType;
+    };
+    getMedia = () => {
+        return this.media;
     };
     initialize = (stream, track, devices, requestedMedia, error = null) => {
-        this.deviceState = prepareDeviceState(stream, track, devices, error, requestedMedia);
-        const deviceInfo = this.deviceState.media?.deviceInfo;
+        const deviceInfo = getDeviceInfo(track?.getSettings()?.deviceId || null, devices);
+        const [devicesStatus, newError] = prepareStatus(requestedMedia, track);
+        this.devices = devices;
+        this.devicesStatus = devicesStatus;
+        this.mediaStatus = devicesStatus;
+        this.error = newError ?? error;
+        this.updateMedia({
+            stream: track ? stream : null,
+            track,
+            deviceInfo,
+            enabled: Boolean(track?.enabled),
+        });
         if (deviceInfo)
-            this.saveLastDevice(deviceInfo);
+            this.saveLastDevice?.(deviceInfo);
         this.status = "initialized";
-        this.setupOnEndedCallback();
-        this.emit("managerInitialized", this.deviceState);
-        return this.deviceState;
-    };
-    setupOnEndedCallback() {
-        if (this.deviceState?.media?.track) {
-            this.deviceState.media.track.addEventListener("ended", async (event) => await this.onTrackEnded(event.target.id));
-        }
-    }
-    onTrackEnded = async (trackId) => {
-        if (trackId === this?.deviceState.media?.track?.id) {
-            await this.stop();
+        if (track) {
+            setupOnEndedCallback(track, () => this?.rawMedia?.track?.id, async () => this.stop());
         }
+        this.emit("managerInitialized", this.getState());
     };
-    getLastDevice() {
-        return this.storageConfig?.getLastDevice?.() ?? null;
-    }
-    saveLastDevice(info) {
-        if (!this.storageConfig)
-            console.warn("Device manager storage has been disabled");
-        this.storageConfig?.saveLastDevice(info);
-    }
     async start(deviceId) {
-        const newDeviceId = deviceId ?? this.getLastDevice()?.deviceId;
-        const currentDeviceId = this.deviceState.media?.deviceInfo?.deviceId;
+        const newDeviceId = deviceId ?? this.getLastDevice?.()?.deviceId;
+        const currentDeviceId = this.rawMedia?.deviceInfo?.deviceId;
         const shouldReplaceDevice = Boolean(currentDeviceId && currentDeviceId !== newDeviceId);
         const isDeviceStopped = currentDeviceId === undefined;
         const shouldProceed = isDeviceStopped || shouldReplaceDevice;
-        const trackConstraints = this.constraints;
-        const exactConstraints = shouldProceed && prepareMediaTrackConstraints(newDeviceId, trackConstraints);
+        const exactConstraints = shouldProceed && prepareMediaTrackConstraints(newDeviceId, this.constraints);
         if (!exactConstraints)
             return;
-        this.deviceState.mediaStatus = "Requesting";
-        this.emit("devicesStarted", { ...this.deviceState, restarting: shouldReplaceDevice, constraints: exactConstraints }, this.deviceState);
+        this.mediaStatus = "Requesting";
+        this.emit("devicesStarted", { restarting: shouldReplaceDevice, constraints: exactConstraints }, this.getState());
         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 track = getTrack();
+            const track = getTrack(stream, this.deviceType);
             const currentDeviceId = track?.getSettings()?.deviceId;
-            const deviceInfo = currentDeviceId ? getDeviceInfo(currentDeviceId, this.deviceState.devices ?? []) : null;
+            const deviceInfo = currentDeviceId ? getDeviceInfo(currentDeviceId, this.devices ?? []) : null;
             if (deviceInfo) {
                 this.saveLastDevice?.(deviceInfo);
             }
@@ -110,17 +104,20 @@ export class DeviceManager extends EventEmitter {
             // 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 (shouldReplaceDevice) {
-                this.deviceState?.media?.track?.stop();
+                this.rawMedia?.track?.stop();
+                this.processedMediaTrack?.stop();
             }
-            this.deviceState.media = {
+            this.updateMedia({
                 stream,
                 track,
                 deviceInfo,
-                enabled: true,
-            };
-            this.setupOnEndedCallback();
-            this.deviceState.mediaStatus = "OK";
-            this.emit("devicesReady", { ...this.deviceState, restarted: shouldReplaceDevice }, this.deviceState);
+                enabled: Boolean(track?.enabled),
+            });
+            if (track) {
+                setupOnEndedCallback(track, () => this?.rawMedia?.track?.id, async () => this.stop());
+            }
+            this.mediaStatus = "OK";
+            this.emit("devicesReady", { ...this.getState(), restarted: shouldReplaceDevice }, this.getState());
         }
         catch (err) {
             const parsedError = parseUserMediaError(err);
@@ -129,37 +126,69 @@ export class DeviceManager extends EventEmitter {
                 constraints: exactConstraints,
             };
             if (exactConstraints) {
-                this.deviceState.error = parsedError;
+                this.error = parsedError;
             }
-            this.emit("error", event, this.deviceState);
+            this.emit("error", event, this.getState());
         }
     }
-    async stop() {
-        this.deviceState.media?.track?.stop();
-        this.deviceState.media = null;
-        this.emit("deviceStopped", this.deviceState);
+    async setTrackMiddleware(middleware) {
+        const rawTrack = this.rawMedia?.track ?? null;
+        const processedMedia = this.middlewareManager.applyMiddleware(rawTrack, middleware);
+        this.setCurrentMedia(this.rawMedia, processedMedia);
+        this.emit("middlewareSet", this.getState());
+    }
+    getMiddleware() {
+        return this.middlewareManager.getMiddleware();
+    }
+    stop() {
+        this.middlewareManager.clearMiddleware();
+        this.processedMediaTrack?.stop();
+        this.rawMedia?.track?.stop();
+        this.updateMedia(null);
+        this.emit("deviceStopped", this.getState());
     }
     disable() {
-        if (!this.deviceState.media || !this.deviceState.media?.track) {
-            return;
-        }
-        this.deviceState.media.track.enabled = false;
-        this.deviceState.media.enabled = false;
-        this.emit("deviceDisabled", this.deviceState);
+        this.setEnable(this.rawMedia?.track ?? null, false);
+        this.setEnable(this.processedMediaTrack, false);
+        this.emit("deviceDisabled", this.getState());
     }
     enable() {
-        if (!this.deviceState.media || !this.deviceState.media?.track) {
-            return;
-        }
-        this.deviceState.media.track.enabled = true;
-        this.deviceState.media.enabled = true;
-        this.emit("deviceEnabled", this.deviceState);
+        this.setEnable(this.rawMedia?.track ?? null, true);
+        this.setEnable(this.processedMediaTrack, true);
+        this.emit("deviceEnabled", this.getState());
     }
-    getDeviceType = () => {
-        return this.deviceType;
+    setEnable = (track, value) => {
+        if (!track)
+            return;
+        track.enabled = value;
     };
-    setConfig(storage, constraints) {
-        this.storageConfig = this.createStorageConfig(this.deviceType, storage);
-        this.constraints = constraints ? toMediaTrackConstraints(constraints) : undefined;
+    updateMedia(media) {
+        this.rawMedia = !media ? null : { ...media };
+        const processedMedia = this.middlewareManager.applyMiddleware(media?.track ?? null);
+        this.setCurrentMedia(this.rawMedia, processedMedia);
+    }
+    setCurrentMedia(media, processedTrack) {
+        this.processedMediaTrack = processedTrack;
+        const streamTrack = processedTrack ? { track: processedTrack, stream: new MediaStream([processedTrack]) } : media;
+        this.media = streamTrack
+            ? {
+                ...streamTrack,
+                enabled: Boolean(streamTrack.track?.enabled),
+                deviceInfo: this.rawMedia?.deviceInfo ?? null,
+            }
+            : null;
     }
 }
+function getDeviceInfo(trackDeviceId, devices) {
+    return (trackDeviceId && devices.find(({ deviceId }) => trackDeviceId === deviceId)) || null;
+}
+function getTrack(stream, deviceType) {
+    return (deviceType === "audio" ? stream?.getAudioTracks()?.[0] : stream?.getVideoTracks()?.[0]) ?? null;
+}
+function prepareStatus(requested, track) {
+    if (!requested)
+        return ["Not requested", null];
+    if (track)
+        return ["OK", null];
+    return ["Error", null];
+}

package/dist/constraints.d.ts

@@ -1,7 +1,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, constraints: MediaTrackConstraints | undefined) => MediaTrackConstraints | boolean;
-export declare const prepareConstraints: (deviceIdToStart: string | undefined, constraints: MediaTrackConstraints | undefined) => MediaTrackConstraints | undefined;
+export declare const prepareMediaTrackConstraints: (deviceId: string | undefined, constraints: MediaTrackConstraints | undefined | boolean) => MediaTrackConstraints | boolean;
+export declare const prepareConstraints: (deviceIdToStart: string | undefined, constraints: MediaTrackConstraints | undefined | boolean) => MediaTrackConstraints | undefined | boolean;
 //# 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,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"}
+{"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,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"}

package/dist/constraints.js

@@ -24,20 +24,19 @@ export const SCREEN_SHARING_MEDIA_CONSTRAINTS = {
         height: { max: 1080, ideal: 1080 },
     },
 };
-export const toMediaTrackConstraints = (constraint) => {
-    if (typeof constraint === "boolean") {
-        return constraint ? {} : undefined;
-    }
-    return constraint;
-};
 export const prepareMediaTrackConstraints = (deviceId, constraints) => {
+    const trackConstraints = typeof constraints === "boolean" ? {} : constraints;
     if (!deviceId)
-        return { ...constraints };
-    const exactId = deviceId ? { deviceId: { exact: deviceId } } : {};
-    return { ...constraints, ...exactId };
+        return { ...trackConstraints };
+    return { ...trackConstraints, deviceId: { exact: deviceId } };
 };
 export const prepareConstraints = (deviceIdToStart, constraints) => {
     if (!deviceIdToStart)
         return constraints;
-    return { ...constraints, deviceId: { ideal: deviceIdToStart } };
+    // The resulting stream will not contain a track of this type,
+    // which means that the device will not be activated.
+    if (constraints === false)
+        return false;
+    const constraintsObj = constraints === true ? {} : constraints;
+    return { ...constraintsObj, deviceId: { ideal: deviceIdToStart } };
 };

package/dist/devices/MiddlewareManager.d.ts

@@ -0,0 +1,9 @@
+import type { TrackMiddleware } from "../types/public";
+export declare class MiddlewareManager {
+    private middleware;
+    private clearMiddlewareFn;
+    getMiddleware(): TrackMiddleware | null;
+    clearMiddleware(): void;
+    applyMiddleware(rawTrack: MediaStreamTrack | null, middleware?: TrackMiddleware | null): MediaStreamTrack | null;
+}
+//# sourceMappingURL=MiddlewareManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MiddlewareManager.d.ts","sourceRoot":"","sources":["../../src/devices/MiddlewareManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGvD,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,UAAU,CAAgC;IAClD,OAAO,CAAC,iBAAiB,CAA6B;IAE/C,aAAa,IAAI,eAAe,GAAG,IAAI;IAIvC,eAAe;IAKf,eAAe,CACpB,QAAQ,EAAE,gBAAgB,GAAG,IAAI,EACjC,UAAU,GAAE,eAAe,GAAG,IAAsB,GACnD,gBAAgB,GAAG,IAAI;CAmB3B"}

package/dist/devices/MiddlewareManager.js

@@ -0,0 +1,26 @@
+import { setupOnEndedCallback } from "../utils/track";
+export class MiddlewareManager {
+    middleware = null;
+    clearMiddlewareFn = null;
+    getMiddleware() {
+        return this.middleware;
+    }
+    clearMiddleware() {
+        this.clearMiddlewareFn?.();
+        this.clearMiddlewareFn = null;
+    }
+    applyMiddleware(rawTrack, middleware = this.middleware) {
+        this.middleware = middleware;
+        this.clearMiddleware();
+        if (!rawTrack || !middleware)
+            return null;
+        const { onClear, track } = middleware(rawTrack);
+        if (onClear)
+            this.clearMiddlewareFn = onClear;
+        setupOnEndedCallback(track, () => track.id, async () => {
+            this.clearMiddleware();
+            track.stop();
+        });
+        return track;
+    }
+}

package/dist/fishjamProvider.d.ts

@@ -1,12 +1,14 @@
 import { type PropsWithChildren } from "react";
-import type { DeviceManagerConfig } from "./types";
 import { type ReconnectConfig } from "@fishjam-cloud/ts-client";
+import type { PersistLastDeviceHandlers } from "./types/public";
 interface FishjamProviderProps extends PropsWithChildren {
-    config?: {
-        reconnect?: ReconnectConfig | boolean;
-    };
-    deviceManagerDefaultConfig?: DeviceManagerConfig;
+    reconnect?: ReconnectConfig | boolean;
+    constraints?: Pick<MediaStreamConstraints, "audio" | "video">;
+    persistLastDevice?: boolean | PersistLastDeviceHandlers;
 }
-export declare function FishjamProvider({ children, config, deviceManagerDefaultConfig }: FishjamProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * @category Components
+ */
+export declare function FishjamProvider({ children, reconnect, constraints, persistLastDevice }: FishjamProviderProps): import("react/jsx-runtime").JSX.Element;
 export {};
 //# sourceMappingURL=fishjamProvider.d.ts.map

package/dist/fishjamProvider.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"fishjamProvider.d.ts","sourceRoot":"","sources":["../src/fishjamProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAGvD,OAAO,EAAiB,KAAK,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAO/E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAGhE,UAAU,oBAAqB,SAAQ,iBAAiB;IACtD,SAAS,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC;IACtC,WAAW,CAAC,EAAE,IAAI,CAAC,sBAAsB,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC;IAC9D,iBAAiB,CAAC,EAAE,OAAO,GAAG,yBAAyB,CAAC;CACzD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,iBAAiB,EAAE,EAAE,oBAAoB,2CAuD5G"}

package/dist/fishjamProvider.js

@@ -1,33 +1,49 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useRef, useState } from "react";
+import { useRef } 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 { usePeerStatus } from "./hooks/usePeerStatus";
 import { useFishjamClientState } from "./hooks/useFishjamClientState";
-export function FishjamProvider({ children, config, deviceManagerDefaultConfig }) {
-    const fishjamClientRef = useRef(new FishjamClient(config));
+import { AUDIO_TRACK_CONSTRAINTS, VIDEO_TRACK_CONSTRAINTS } from "./constraints";
+import { useScreenShareManager } from "./hooks/useScreenShare";
+/**
+ * @category Components
+ */
+export function FishjamProvider({ children, reconnect, constraints, persistLastDevice }) {
+    const fishjamClientRef = useRef(new FishjamClient({ reconnect }));
     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 storage = persistLastDevice;
+    const videoDeviceManagerRef = useRef(new DeviceManager({
+        deviceType: "video",
+        defaultConstraints: VIDEO_TRACK_CONSTRAINTS,
+        userConstraints: constraints?.video,
+        storage,
+    }));
+    const audioDeviceManagerRef = useRef(new DeviceManager({
+        deviceType: "audio",
+        defaultConstraints: AUDIO_TRACK_CONSTRAINTS,
+        userConstraints: constraints?.audio,
+        storage,
+    }));
+    const { peerStatus, getCurrentPeerStatus } = usePeerStatus(fishjamClientRef.current);
     const videoTrackManager = useTrackManager({
         mediaManager: videoDeviceManagerRef.current,
         tsClient: fishjamClientRef.current,
-        getCurrentParticipantStatus,
+        getCurrentPeerStatus,
     });
     const audioTrackManager = useTrackManager({
         mediaManager: audioDeviceManagerRef.current,
         tsClient: fishjamClientRef.current,
-        getCurrentParticipantStatus,
+        getCurrentPeerStatus,
     });
+    const screenShareManager = useScreenShareManager({ fishjamClient: fishjamClientRef.current });
     const clientState = useFishjamClientState(fishjamClientRef.current);
     const context = {
         fishjamClientRef,
         peerStatus,
-        screenShareState,
+        screenShareManager,
         videoTrackManager,
         audioTrackManager,
         videoDeviceManagerRef,

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

@@ -1,4 +1,4 @@
-import type { DeviceManagerState } from "../../types";
+import type { DeviceManagerState } from "../../types/internal";
 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

@@ -1 +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"}
+{"version":3,"file":"useDeviceManager.d.ts","sourceRoot":"","sources":["../../../src/hooks/deviceManagers/useDeviceManager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAuB,MAAM,qBAAqB,CAAC;AAe9E,eAAO,MAAM,gBAAgB,kBAAmB,aAAa,uBAmC5D,CAAC"}

package/dist/hooks/deviceManagers/useDeviceManager.js

@@ -9,6 +9,7 @@ const eventNames = [
     "devicesReady",
     "managerInitialized",
     "error",
+    "middlewareSet",
 ];
 export const useDeviceManager = (deviceManager) => {
     const mutationRef = useRef(false);
@@ -26,9 +27,8 @@ export const useDeviceManager = (deviceManager) => {
     const getSnapshot = useCallback(() => {
         if (mutationRef.current || lastSnapshotRef.current === null) {
             lastSnapshotRef.current = {
-                deviceState: deviceManager.deviceState,
+                deviceState: deviceManager.getState(),
                 status: deviceManager.getStatus(),
-                tracks: deviceManager.getTracks(),
             };
             mutationRef.current = false;
         }

package/dist/hooks/{useDevices.d.ts → devices.d.ts}

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"devices.d.ts","sourceRoot":"","sources":["../../src/hooks/devices.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAK3D;;;GAGG;AACH,wBAAgB,SAAS,IAAI,MAAM,CAyBlC;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,WAAW,CA2B3C;AAED;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;CAqDhC,CAAC"}