@fishjam-cloud/react-client 0.5.0

package/dist/Client.js

@@ -0,0 +1,589 @@
+import EventEmitter from "events";
+import { FishjamClient } from "@fishjam-cloud/ts-client";
+import { ScreenShareManager } from "./ScreenShareManager";
+import { DeviceManager } from "./DeviceManager";
+import { TrackManager } from "./trackManager";
+import { getAvailableMedia, getCorrectedResult } from "./mediaInitializer";
+export class Client extends EventEmitter {
+    tsClient;
+    screenShareManager;
+    local = null;
+    peers = {};
+    components = {};
+    peersTracks = {};
+    componentsTracks = {};
+    bandwidthEstimation = BigInt(0);
+    status = null;
+    media = null;
+    devices;
+    reconnectionStatus = "idle";
+    currentScreenShareTrackId = null;
+    videoDeviceManager;
+    audioDeviceManager;
+    videoTrackManager;
+    audioTrackManager;
+    constructor(config) {
+        super();
+        this.tsClient = new FishjamClient(config?.clientConfig);
+        this.videoDeviceManager = new DeviceManager("video", config?.deviceManagerDefaultConfig);
+        this.audioDeviceManager = new DeviceManager("audio", config?.deviceManagerDefaultConfig);
+        this.videoTrackManager = new TrackManager(this.tsClient, this.videoDeviceManager);
+        this.audioTrackManager = new TrackManager(this.tsClient, this.audioDeviceManager);
+        this.screenShareManager = new ScreenShareManager(config?.screenShareManagerDefaultConfig);
+        this.devices = {
+            camera: {
+                broadcast: null,
+                status: null,
+                stream: null,
+                track: null,
+                enabled: false,
+                mediaStatus: null,
+                deviceInfo: null,
+                error: null,
+                devices: null,
+            },
+            microphone: {
+                broadcast: null,
+                status: null,
+                stream: null,
+                track: null,
+                enabled: false,
+                mediaStatus: null,
+                deviceInfo: null,
+                error: null,
+                devices: null,
+            },
+            screenShare: {
+                cleanup: async () => { },
+                disableTrack: () => { },
+                enableTrack: () => { },
+                initialize: async () => { },
+                startStreaming: (_trackMetadata, _maxBandwidth) => Promise.reject(),
+                stopStreaming: () => Promise.reject(),
+                broadcast: null,
+                status: null,
+                stream: null,
+                track: null,
+                enabled: false,
+                mediaStatus: null,
+                error: null,
+            },
+        };
+        this.stateToSnapshot();
+        this.tsClient.on("socketOpen", (event) => {
+            this.status = "connected";
+            this.stateToSnapshot();
+            this.emit("socketOpen", event, this);
+        });
+        this.tsClient.on("socketError", (event) => {
+            this.stateToSnapshot();
+            this.emit("socketError", event, this);
+        });
+        this.tsClient.on("socketClose", (event) => {
+            this.stateToSnapshot();
+            this.emit("socketClose", event, this);
+        });
+        this.tsClient.on("authSuccess", () => {
+            this.status = "authenticated";
+            this.stateToSnapshot();
+            this.emit("authSuccess", this);
+        });
+        this.tsClient.on("authError", (reason) => {
+            this.stateToSnapshot();
+            this.status = "error";
+            this.emit("authError", reason, this);
+        });
+        this.tsClient.on("disconnected", () => {
+            this.status = null;
+            this.videoTrackManager.stopStreaming();
+            this.audioTrackManager.stopStreaming();
+            this.currentScreenShareTrackId = null;
+            this.stateToSnapshot();
+            this.emit("disconnected", this);
+        });
+        this.tsClient.on("joined", (peerId, peers, components) => {
+            this.status = "joined";
+            this.stateToSnapshot();
+            this.emit("joined", { peerId, peers, components }, this);
+        });
+        this.tsClient.on("joinError", (metadata) => {
+            this.status = "error";
+            this.stateToSnapshot();
+            this.emit("joinError", metadata, this);
+        });
+        this.tsClient.on("reconnectionStarted", () => {
+            this.reconnectionStatus = "reconnecting";
+            this.stateToSnapshot();
+            this.emit("reconnectionStarted", this);
+        });
+        this.tsClient.on("reconnected", () => {
+            this.reconnectionStatus = "idle";
+            this.stateToSnapshot();
+            this.emit("reconnected", this);
+        });
+        this.tsClient.on("reconnectionRetriesLimitReached", () => {
+            this.reconnectionStatus = "error";
+            this.stateToSnapshot();
+            this.emit("reconnectionRetriesLimitReached", this);
+        });
+        this.tsClient.on("connectionError", (metadata) => {
+            this.status = "error";
+            this.stateToSnapshot();
+            this.emit("connectionError", metadata, this);
+        });
+        this.tsClient.on("peerJoined", (peer) => {
+            this.stateToSnapshot();
+            this.emit("peerJoined", peer, this);
+        });
+        this.tsClient.on("peerUpdated", (peer) => {
+            this.stateToSnapshot();
+            this.emit("peerUpdated", peer, this);
+        });
+        this.tsClient.on("peerLeft", (peer) => {
+            this.stateToSnapshot();
+            this.emit("peerLeft", peer, this);
+        });
+        this.tsClient.on("componentAdded", (component) => {
+            this.stateToSnapshot();
+            this.emit("componentAdded", component, this);
+        });
+        this.tsClient.on("componentUpdated", (component) => {
+            this.stateToSnapshot();
+            this.emit("componentUpdated", component, this);
+        });
+        this.tsClient.on("componentRemoved", (component) => {
+            this.stateToSnapshot();
+            this.emit("componentRemoved", component, this);
+        });
+        this.tsClient.on("trackReady", (ctx) => {
+            this.stateToSnapshot();
+            this.emit("trackReady", ctx, this);
+        });
+        this.tsClient.on("trackAdded", (ctx) => {
+            this.stateToSnapshot();
+            this.emit("trackAdded", ctx, this);
+            ctx.on("encodingChanged", () => {
+                this.stateToSnapshot();
+                this.emit("encodingChanged", ctx, this);
+            });
+            ctx.on("voiceActivityChanged", () => {
+                this.stateToSnapshot();
+                this.emit("voiceActivityChanged", ctx, this);
+            });
+        });
+        this.tsClient.on("trackRemoved", (ctx) => {
+            this.stateToSnapshot();
+            this.emit("trackRemoved", ctx, this);
+            ctx.removeAllListeners();
+        });
+        this.tsClient.on("trackUpdated", (ctx) => {
+            this.stateToSnapshot();
+            this.emit("trackUpdated", ctx, this);
+        });
+        this.tsClient.on("bandwidthEstimationChanged", (estimation) => {
+            this.stateToSnapshot();
+            this.emit("bandwidthEstimationChanged", estimation, this);
+        });
+        this.videoDeviceManager.on("deviceDisabled", (state) => {
+            this.stateToSnapshot();
+            this.emit("deviceDisabled", { ...state, trackType: "video", mediaDeviceType: "userMedia" }, this);
+        });
+        this.videoDeviceManager.on("deviceEnabled", (state) => {
+            this.stateToSnapshot();
+            this.emit("deviceEnabled", { ...state, trackType: "video", mediaDeviceType: "userMedia" }, this);
+        });
+        this.videoDeviceManager.on("managerStarted", (state) => {
+            this.stateToSnapshot();
+            this.emit("managerStarted", { ...state, trackType: "video", mediaDeviceType: "userMedia" }, this);
+        });
+        this.videoDeviceManager.on("deviceStopped", (state) => {
+            this.stateToSnapshot();
+            this.emit("deviceStopped", { ...state, trackType: "video", mediaDeviceType: "userMedia" }, this);
+        });
+        this.videoDeviceManager.on("deviceReady", ({ stream }) => {
+            this.stateToSnapshot();
+            this.emit("deviceReady", { trackType: "video", stream, mediaDeviceType: "userMedia" }, this);
+        });
+        this.videoDeviceManager.on("devicesStarted", (event) => {
+            this.stateToSnapshot();
+            this.emit("devicesStarted", { ...event, trackType: "video", mediaDeviceType: "userMedia" }, this);
+        });
+        this.videoDeviceManager.on("devicesReady", (event) => {
+            this.stateToSnapshot();
+            this.emit("devicesReady", { ...event, trackType: "video", mediaDeviceType: "userMedia" }, this);
+        });
+        this.videoDeviceManager.on("error", (event) => {
+            this.stateToSnapshot();
+            this.emit("error", event, this);
+        });
+        this.audioDeviceManager.on("deviceDisabled", (state) => {
+            this.stateToSnapshot();
+            this.emit("deviceDisabled", { ...state, trackType: "audio", mediaDeviceType: "userMedia" }, this);
+        });
+        this.audioDeviceManager.on("deviceEnabled", (state) => {
+            this.stateToSnapshot();
+            this.emit("deviceEnabled", { ...state, trackType: "audio", mediaDeviceType: "userMedia" }, this);
+        });
+        this.audioDeviceManager.on("managerStarted", (state) => {
+            this.stateToSnapshot();
+            this.emit("managerStarted", { ...state, trackType: "audio", mediaDeviceType: "userMedia" }, this);
+        });
+        this.audioDeviceManager.on("deviceStopped", (state) => {
+            this.stateToSnapshot();
+            this.emit("deviceStopped", { ...state, trackType: "audio", mediaDeviceType: "userMedia" }, this);
+        });
+        this.audioDeviceManager.on("deviceReady", ({ stream }) => {
+            this.stateToSnapshot();
+            this.emit("deviceReady", { trackType: "audio", stream, mediaDeviceType: "userMedia" }, this);
+        });
+        this.audioDeviceManager.on("devicesStarted", (event) => {
+            this.stateToSnapshot();
+            this.emit("devicesStarted", { ...event, trackType: "audio", mediaDeviceType: "userMedia" }, this);
+        });
+        this.audioDeviceManager.on("devicesReady", (event) => {
+            this.stateToSnapshot();
+            this.emit("devicesReady", { ...event, trackType: "audio", mediaDeviceType: "userMedia" }, this);
+        });
+        this.audioDeviceManager.on("error", (event) => {
+            this.stateToSnapshot();
+            this.emit("error", event, this);
+        });
+        this.screenShareManager.on("deviceDisabled", (event) => {
+            this.stateToSnapshot();
+            this.emit("deviceDisabled", { trackType: event.type, mediaDeviceType: "displayMedia" }, this);
+        });
+        this.screenShareManager.on("deviceEnabled", (event) => {
+            this.stateToSnapshot();
+            this.emit("deviceEnabled", { trackType: event.type, mediaDeviceType: "displayMedia" }, this);
+        });
+        this.screenShareManager.on("deviceStopped", async (event) => {
+            this.stateToSnapshot();
+            this.emit("deviceStopped", { trackType: event.type, mediaDeviceType: "displayMedia" }, this);
+        });
+        this.screenShareManager.on("deviceReady", (event, state) => {
+            this.stateToSnapshot();
+            if (!state.videoMedia?.stream)
+                throw Error("Invalid screen share state");
+            this.emit("deviceReady", {
+                trackType: event.type,
+                stream: state.videoMedia.stream,
+                mediaDeviceType: "displayMedia",
+            }, this);
+        });
+        this.screenShareManager.on("error", (a) => {
+            this.stateToSnapshot();
+            this.emit("error", a, this);
+        });
+        this.tsClient?.on("targetTrackEncodingRequested", (event) => {
+            this.stateToSnapshot();
+            this.emit("targetTrackEncodingRequested", event, this);
+        });
+        this.tsClient?.on("localTrackAdded", (event) => {
+            this.stateToSnapshot();
+            this.emit("localTrackAdded", event, this);
+        });
+        this.tsClient?.on("localTrackRemoved", (event) => {
+            this.stateToSnapshot();
+            this.emit("localTrackRemoved", event, this);
+        });
+        this.tsClient?.on("localTrackReplaced", (event) => {
+            this.stateToSnapshot();
+            this.emit("localTrackReplaced", event, this);
+        });
+        this.tsClient?.on("localTrackMuted", (event) => {
+            this.stateToSnapshot();
+            this.emit("localTrackMuted", event, this);
+        });
+        this.tsClient?.on("localTrackUnmuted", (event) => {
+            this.stateToSnapshot();
+            this.emit("localTrackUnmuted", event, this);
+        });
+        this.tsClient?.on("localTrackBandwidthSet", (event) => {
+            this.stateToSnapshot();
+            this.emit("localTrackBandwidthSet", event, this);
+        });
+        this.tsClient?.on("localTrackEncodingBandwidthSet", (event) => {
+            this.stateToSnapshot();
+            this.emit("localTrackEncodingBandwidthSet", event, this);
+        });
+        this.tsClient?.on("localTrackEncodingEnabled", (event) => {
+            this.stateToSnapshot();
+            this.emit("localTrackEncodingEnabled", event, this);
+        });
+        this.tsClient?.on("localTrackEncodingDisabled", (event) => {
+            this.stateToSnapshot();
+            this.emit("localTrackEncodingDisabled", event, this);
+        });
+        this.tsClient?.on("localPeerMetadataChanged", (event) => {
+            this.stateToSnapshot();
+            this.emit("localPeerMetadataChanged", event, this);
+        });
+        this.tsClient?.on("localTrackMetadataChanged", (event) => {
+            this.stateToSnapshot();
+            this.emit("localTrackMetadataChanged", event, this);
+        });
+        this.tsClient?.on("disconnectRequested", (event) => {
+            this.stateToSnapshot();
+            this.emit("disconnectRequested", event, this);
+        });
+    }
+    setScreenManagerConfig(config) {
+        this.screenShareManager?.setConfig(config);
+    }
+    setDeviceManagerConfig(config) {
+        this.videoDeviceManager.setConfig(config.storage, config.trackConstraints);
+        this.audioDeviceManager.setConfig(config.storage, config.trackConstraints);
+    }
+    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,
+        };
+    }
+    connect(config) {
+        this.status = "connecting";
+        this.tsClient.connect(config);
+    }
+    disconnect() {
+        this.status = null;
+        this.tsClient.disconnect();
+    }
+    addTrack(track, trackMetadata, simulcastConfig = { enabled: false, activeEncodings: [], disabledEncodings: [] }, maxBandwidth = 0) {
+        return this.tsClient.addTrack(track, trackMetadata, simulcastConfig, maxBandwidth);
+    }
+    removeTrack(trackId) {
+        return this.tsClient.removeTrack(trackId);
+    }
+    replaceTrack(trackId, newTrack, newTrackMetadata) {
+        return this.tsClient.replaceTrack(trackId, newTrack, newTrackMetadata);
+    }
+    getStatistics(selector) {
+        return this.tsClient.getStatistics(selector);
+    }
+    getBandwidthEstimation() {
+        return this.tsClient.getBandwidthEstimation();
+    }
+    setTrackBandwidth(trackId, bandwidth) {
+        return this.tsClient.setTrackBandwidth(trackId, bandwidth);
+    }
+    setEncodingBandwidth(trackId, rid, bandwidth) {
+        return this.tsClient.setEncodingBandwidth(trackId, rid, bandwidth);
+    }
+    setTargetTrackEncoding(trackId, encoding) {
+        return this.tsClient.setTargetTrackEncoding(trackId, encoding);
+    }
+    enableTrackEncoding(trackId, encoding) {
+        return this.tsClient.enableTrackEncoding(trackId, encoding);
+    }
+    disableTrackEncoding(trackId, encoding) {
+        return this.tsClient.disableTrackEncoding(trackId, encoding);
+    }
+    updatePeerMetadata = (peerMetadata) => {
+        this.tsClient.updatePeerMetadata(peerMetadata);
+    };
+    updateTrackMetadata = (trackId, trackMetadata) => {
+        this.tsClient.updateTrackMetadata(trackId, trackMetadata);
+    };
+    isReconnecting = () => {
+        return this.tsClient.isReconnecting();
+    };
+    initializeDevices = async (config) => {
+        const constraints = {
+            video: this.videoDeviceManager.getConstraints(config?.videoTrackConstraints),
+            audio: this.audioDeviceManager.getConstraints(config?.audioTrackConstraints),
+        };
+        const previousDevices = {
+            video: this.videoDeviceManager.getLastDevice(),
+            audio: this.audioDeviceManager.getLastDevice(),
+        };
+        let [stream, deviceErrors] = await getAvailableMedia(constraints);
+        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);
+        }
+        const state = {
+            video: this.videoDeviceManager.initialize(stream, stream?.getVideoTracks()?.[0] ?? null, videoDevices, !!constraints.video, deviceErrors.video),
+            audio: this.audioDeviceManager.initialize(stream, stream?.getAudioTracks()?.[0] ?? null, audioDevices, !!constraints.audio, deviceErrors.audio),
+        };
+        this.stateToSnapshot();
+        this.emit("managerInitialized", state, this);
+    };
+    startDevices = async (config) => {
+        this.videoDeviceManager.start(config?.videoDeviceId);
+        this.audioDeviceManager.start(config?.audioDeviceId);
+    };
+    // In most cases, the track is identified by its remote track ID.
+    // This ID comes from the ts-client `addTrack` method.
+    // However, we don't have that ID before the `addTrack` method returns it.
+    //
+    // The `addTrack` method emits the `localTrackAdded` event.
+    // This event will refresh the internal state of this object.
+    // However, in that event handler, we don't yet have the remote track ID.
+    // Therefore, for that brief moment, we will use the local track ID from the MediaStreamTrack object to identify the track.
+    getRemoteTrack = (remoteOrLocalTrackId) => {
+        if (!remoteOrLocalTrackId)
+            return null;
+        const tracks = this.tsClient?.getLocalPeer()?.tracks;
+        if (!tracks)
+            return null;
+        const trackByRemoteId = tracks?.get(remoteOrLocalTrackId);
+        if (trackByRemoteId)
+            return this.trackContextToTrack(trackByRemoteId);
+        const trackByLocalId = [...tracks.values()].find((track) => track.track?.id === remoteOrLocalTrackId);
+        return trackByLocalId ? this.trackContextToTrack(trackByLocalId) : null;
+    };
+    stateToSnapshot() {
+        const screenShareManager = this.screenShareManager.getSnapshot();
+        const deviceManagerSnapshot = {
+            audio: this?.audioDeviceManager?.deviceState,
+            video: this?.videoDeviceManager?.deviceState,
+        };
+        const localEndpoint = this.tsClient.getLocalPeer();
+        const localTracks = {};
+        (localEndpoint?.tracks || new Map()).forEach((track) => {
+            localTracks[track.trackId] = this.trackContextToTrack(track);
+        });
+        const broadcastedVideoTrack = this.videoTrackManager.getCurrentTrack();
+        const broadcastedAudioTrack = this.audioTrackManager.getCurrentTrack();
+        const screenShareVideoTrack = this.getRemoteTrack(this.currentScreenShareTrackId);
+        const devices = {
+            camera: {
+                broadcast: broadcastedVideoTrack ?? null,
+                status: deviceManagerSnapshot?.video?.devicesStatus || null,
+                stream: deviceManagerSnapshot?.video.media?.stream || null,
+                track: deviceManagerSnapshot?.video.media?.track || null,
+                enabled: deviceManagerSnapshot?.video.media?.enabled || false,
+                deviceInfo: deviceManagerSnapshot?.video.media?.deviceInfo || null,
+                mediaStatus: deviceManagerSnapshot?.video.mediaStatus || null,
+                error: deviceManagerSnapshot?.video?.error || null,
+                devices: deviceManagerSnapshot?.video?.devices || null,
+            },
+            microphone: {
+                broadcast: broadcastedAudioTrack ?? null,
+                status: deviceManagerSnapshot?.audio?.devicesStatus || null,
+                stream: deviceManagerSnapshot?.audio.media?.stream || null,
+                track: deviceManagerSnapshot?.audio.media?.track || null,
+                enabled: deviceManagerSnapshot?.audio.media?.enabled || false,
+                deviceInfo: deviceManagerSnapshot?.audio.media?.deviceInfo || null,
+                mediaStatus: deviceManagerSnapshot?.video.mediaStatus || null,
+                error: deviceManagerSnapshot?.audio?.error || null,
+                devices: deviceManagerSnapshot?.audio?.devices || null,
+            },
+            screenShare: {
+                cleanup: async () => {
+                    this?.screenShareManager?.stop("video");
+                },
+                disableTrack: () => {
+                    this.screenShareManager?.setEnable("video", false);
+                },
+                enableTrack: () => {
+                    this.screenShareManager?.setEnable("video", true);
+                },
+                initialize: async (config) => {
+                    await this.screenShareManager?.start(config);
+                },
+                startStreaming: async (trackMetadata, maxBandwidth) => {
+                    const media = this.screenShareManager?.getSnapshot().videoMedia;
+                    if (!media || !media.stream || !media.track)
+                        throw Error("Device is unavailable");
+                    if (this.currentScreenShareTrackId)
+                        throw Error("Screen share track already added");
+                    const track = this.getRemoteTrack(media.track.id);
+                    if (track)
+                        return track.trackId;
+                    // see `getRemoteTrack()` explanation
+                    this.currentScreenShareTrackId = media.track.id;
+                    const trackId = await this.tsClient.addTrack(media.track, trackMetadata, undefined, maxBandwidth);
+                    this.currentScreenShareTrackId = trackId;
+                    return trackId;
+                },
+                stopStreaming: () => {
+                    if (!this.currentScreenShareTrackId)
+                        throw Error("There is no screen share track id");
+                    const prevTrack = this.getRemoteTrack(this.currentScreenShareTrackId);
+                    if (!prevTrack)
+                        throw Error("There is no screen share video track");
+                    this.currentScreenShareTrackId = null;
+                    return this.tsClient.removeTrack(prevTrack.trackId);
+                },
+                broadcast: screenShareVideoTrack ?? null,
+                status: screenShareManager?.status || null,
+                mediaStatus: null,
+                stream: screenShareManager?.videoMedia?.stream || null,
+                track: screenShareManager?.videoMedia?.track || null,
+                enabled: screenShareManager?.videoMedia?.enabled || false,
+                error: screenShareManager?.error || null,
+            },
+        };
+        if (!this.tsClient["webrtc"]) {
+            this.media = deviceManagerSnapshot || null;
+            this.peersTracks = {};
+            this.componentsTracks = {};
+            this.devices = devices;
+            this.peers = {};
+            this.components = {};
+            this.local = null;
+            this.bandwidthEstimation = 0n;
+            return;
+        }
+        const peers = {};
+        const components = {};
+        const peersTracks = {};
+        const componentTracks = {};
+        Object.values(this.tsClient.getRemotePeers()).forEach((remotePeer) => {
+            const tracks = {};
+            remotePeer.tracks.forEach((track) => {
+                const mappedTrack = this.trackContextToTrack(track);
+                tracks[track.trackId] = mappedTrack;
+                peersTracks[track.trackId] = { ...mappedTrack, origin: remotePeer };
+            });
+            peers[remotePeer.id] = {
+                rawMetadata: remotePeer.rawMetadata,
+                metadata: remotePeer.metadata,
+                metadataParsingError: remotePeer.metadataParsingError,
+                id: remotePeer.id,
+                tracks,
+            };
+        });
+        Object.values(this.tsClient.getRemoteComponents()).forEach((remotePeer) => {
+            const tracks = {};
+            remotePeer.tracks.forEach((track) => {
+                const mappedTrack = this.trackContextToTrack(track);
+                tracks[track.trackId] = mappedTrack;
+                componentTracks[track.trackId] = { ...mappedTrack, origin: remotePeer };
+            });
+            components[remotePeer.id] = {
+                rawMetadata: remotePeer.rawMetadata,
+                metadata: remotePeer.metadata,
+                metadataParsingError: remotePeer.metadataParsingError,
+                id: remotePeer.id,
+                tracks,
+            };
+        });
+        this.peersTracks = peersTracks;
+        this.componentsTracks = componentTracks;
+        this.media = deviceManagerSnapshot || null;
+        this.local = localEndpoint
+            ? {
+                id: localEndpoint.id,
+                metadata: localEndpoint.metadata,
+                metadataParsingError: localEndpoint.metadataParsingError,
+                rawMetadata: localEndpoint.rawMetadata,
+                tracks: localTracks, // to record
+            }
+            : null;
+        this.peers = peers;
+        this.components = components;
+        this.bandwidthEstimation = this.tsClient.getBandwidthEstimation();
+        this.devices = devices;
+    }
+}

package/dist/DeviceManager.d.ts

@@ -0,0 +1,49 @@
+import type { DeviceManagerConfig, DeviceState, GenericMediaManager, StorageConfig, DeviceError } from "./types";
+import type TypedEmitter from "typed-emitter";
+export type DeviceManagerEvents = {
+    managerStarted: (event: DeviceState & {
+        constraints: MediaTrackConstraints | undefined;
+    }, state: DeviceState) => void;
+    managerInitialized: (state: DeviceState) => void;
+    devicesStarted: (event: {
+        restarting: boolean;
+        constraints?: string | boolean;
+    }, state: DeviceState) => void;
+    deviceReady: (event: {
+        stream: MediaStream;
+    }, state: DeviceState) => void;
+    devicesReady: (event: DeviceState & {
+        restarted: boolean;
+    }, state: DeviceState) => void;
+    deviceStopped: (state: DeviceState) => void;
+    deviceEnabled: (state: DeviceState) => void;
+    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 GenericMediaManager {
+    private constraints;
+    private storageConfig;
+    private status;
+    private deviceType;
+    deviceState: DeviceState;
+    constructor(deviceType: "audio" | "video", defaultConfig?: DeviceManagerConfig);
+    private createStorageConfig;
+    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;
+    start(deviceId?: string | boolean): Promise<void>;
+    stop(): Promise<void>;
+    disable(): void;
+    enable(): void;
+    setConfig(storage?: boolean | StorageConfig, constraints?: boolean | MediaTrackConstraints): void;
+}
+export {};
+//# sourceMappingURL=DeviceManager.d.ts.map

package/dist/DeviceManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeviceManager.d.ts","sourceRoot":"","sources":["../src/DeviceManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,WAAW,EAAE,mBAAmB,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAKjH,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,mBAAmB;IAE9B,OAAO,CAAC,WAAW,CAAoC;IACvD,OAAO,CAAC,aAAa,CAAuB;IAE5C,OAAO,CAAC,MAAM,CAAwC;IACtD,OAAO,CAAC,UAAU,CAAoB;IAE/B,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,SAAS,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,aAAa,EAAE,WAAW,CAAC,EAAE,OAAO,GAAG,qBAAqB;CAIlG"}