@stream-io/video-client 1.0.0 → 1.0.2

package/dist/index.cjs.js

@@ -954,6 +954,9 @@ var TrackUnpublishReason;
     TrackUnpublishReason[TrackUnpublishReason["MODERATION"] = 3] = "MODERATION";
 })(TrackUnpublishReason || (TrackUnpublishReason = {}));
 /**
+ * GoAwayReason represents the reason for the SFU to
+ * disconnect the client.
+ *
  * @generated from protobuf enum stream.video.sfu.models.GoAwayReason
  */
 var GoAwayReason;
@@ -971,6 +974,75 @@ var GoAwayReason;
      */
     GoAwayReason[GoAwayReason["REBALANCE"] = 2] = "REBALANCE";
 })(GoAwayReason || (GoAwayReason = {}));
+/**
+ * CallEndedReason represents the reason for the call to end.
+ *
+ * @generated from protobuf enum stream.video.sfu.models.CallEndedReason
+ */
+var CallEndedReason;
+(function (CallEndedReason) {
+    /**
+     * @generated from protobuf enum value: CALL_ENDED_REASON_UNSPECIFIED = 0;
+     */
+    CallEndedReason[CallEndedReason["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: CALL_ENDED_REASON_ENDED = 1;
+     */
+    CallEndedReason[CallEndedReason["ENDED"] = 1] = "ENDED";
+    /**
+     * @generated from protobuf enum value: CALL_ENDED_REASON_LIVE_ENDED = 2;
+     */
+    CallEndedReason[CallEndedReason["LIVE_ENDED"] = 2] = "LIVE_ENDED";
+    /**
+     * @generated from protobuf enum value: CALL_ENDED_REASON_KICKED = 3;
+     */
+    CallEndedReason[CallEndedReason["KICKED"] = 3] = "KICKED";
+})(CallEndedReason || (CallEndedReason = {}));
+/**
+ * WebsocketReconnectStrategy defines the ws strategies available for handling reconnections.
+ *
+ * @generated from protobuf enum stream.video.sfu.models.WebsocketReconnectStrategy
+ */
+var WebsocketReconnectStrategy;
+(function (WebsocketReconnectStrategy) {
+    /**
+     * @generated from protobuf enum value: WEBSOCKET_RECONNECT_STRATEGY_UNSPECIFIED = 0;
+     */
+    WebsocketReconnectStrategy[WebsocketReconnectStrategy["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * Sent after reaching the maximum reconnection attempts, leading to permanent disconnect.
+     *
+     * @generated from protobuf enum value: WEBSOCKET_RECONNECT_STRATEGY_DISCONNECT = 1;
+     */
+    WebsocketReconnectStrategy[WebsocketReconnectStrategy["DISCONNECT"] = 1] = "DISCONNECT";
+    /**
+     * SDK should maintaining existing publisher/subscriber pc instances
+     * and establish a new WebSocket connection.
+     *
+     * @generated from protobuf enum value: WEBSOCKET_RECONNECT_STRATEGY_FAST = 2;
+     */
+    WebsocketReconnectStrategy[WebsocketReconnectStrategy["FAST"] = 2] = "FAST";
+    /**
+     * SDK should drop existing pc instances and creates a fresh WebSocket connection,
+     * ensuring a clean state for the reconnection.
+     *
+     * @generated from protobuf enum value: WEBSOCKET_RECONNECT_STRATEGY_CLEAN = 3;
+     */
+    WebsocketReconnectStrategy[WebsocketReconnectStrategy["CLEAN"] = 3] = "CLEAN";
+    /**
+     * SDK should obtain new credentials from the coordinator, drops existing pc instances, and initializes
+     * a completely new WebSocket connection, ensuring a comprehensive reset.
+     *
+     * @generated from protobuf enum value: WEBSOCKET_RECONNECT_STRATEGY_FULL = 4;
+     */
+    WebsocketReconnectStrategy[WebsocketReconnectStrategy["FULL"] = 4] = "FULL";
+    /**
+     * SDK should migrate to a new SFU instance
+     *
+     * @generated from protobuf enum value: WEBSOCKET_RECONNECT_STRATEGY_MIGRATE = 5;
+     */
+    WebsocketReconnectStrategy[WebsocketReconnectStrategy["MIGRATE"] = 5] = "MIGRATE";
+})(WebsocketReconnectStrategy || (WebsocketReconnectStrategy = {}));
 // @generated message type with reflection information, may provide speed optimized methods
 class CallState$Type extends runtime.MessageType {
     constructor() {
@@ -2433,6 +2505,7 @@ var models = /*#__PURE__*/Object.freeze({
     __proto__: null,
     Browser: Browser,
     Call: Call$1,
+    get CallEndedReason () { return CallEndedReason; },
     CallGrants: CallGrants,
     CallState: CallState$1,
     ClientDetails: ClientDetails,
@@ -2456,7 +2529,8 @@ var models = /*#__PURE__*/Object.freeze({
     get TrackUnpublishReason () { return TrackUnpublishReason; },
     VideoDimension: VideoDimension,
     VideoLayer: VideoLayer,
-    get VideoQuality () { return VideoQuality; }
+    get VideoQuality () { return VideoQuality; },
+    get WebsocketReconnectStrategy () { return WebsocketReconnectStrategy; }
 });
 
 /* eslint-disable */
@@ -3865,6 +3939,20 @@ class SfuEvent$Type extends runtime.MessageType {
                 oneof: 'eventPayload',
                 T: () => PinsChanged,
             },
+            {
+                no: 23,
+                name: 'call_ended',
+                kind: 'message',
+                oneof: 'eventPayload',
+                T: () => CallEnded,
+            },
+            {
+                no: 24,
+                name: 'participant_updated',
+                kind: 'message',
+                oneof: 'eventPayload',
+                T: () => ParticipantUpdated,
+            },
         ]);
     }
     create(value) {
@@ -3987,6 +4075,18 @@ class SfuEvent$Type extends runtime.MessageType {
                         pinsUpdated: PinsChanged.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.pinsUpdated),
                     };
                     break;
+                case /* stream.video.sfu.event.CallEnded call_ended */ 23:
+                    message.eventPayload = {
+                        oneofKind: 'callEnded',
+                        callEnded: CallEnded.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.callEnded),
+                    };
+                    break;
+                case /* stream.video.sfu.event.ParticipantUpdated participant_updated */ 24:
+                    message.eventPayload = {
+                        oneofKind: 'participantUpdated',
+                        participantUpdated: ParticipantUpdated.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.participantUpdated),
+                    };
+                    break;
                 default:
                     let u = options.readUnknownField;
                     if (u === 'throw')
@@ -4053,6 +4153,12 @@ class SfuEvent$Type extends runtime.MessageType {
         /* stream.video.sfu.event.PinsChanged pins_updated = 22; */
         if (message.eventPayload.oneofKind === 'pinsUpdated')
             PinsChanged.internalBinaryWrite(message.eventPayload.pinsUpdated, writer.tag(22, runtime.WireType.LengthDelimited).fork(), options).join();
+        /* stream.video.sfu.event.CallEnded call_ended = 23; */
+        if (message.eventPayload.oneofKind === 'callEnded')
+            CallEnded.internalBinaryWrite(message.eventPayload.callEnded, writer.tag(23, runtime.WireType.LengthDelimited).fork(), options).join();
+        /* stream.video.sfu.event.ParticipantUpdated participant_updated = 24; */
+        if (message.eventPayload.oneofKind === 'participantUpdated')
+            ParticipantUpdated.internalBinaryWrite(message.eventPayload.participantUpdated, writer.tag(24, runtime.WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -4121,10 +4227,21 @@ class Error$Type extends runtime.MessageType {
     constructor() {
         super('stream.video.sfu.event.Error', [
             { no: 4, name: 'error', kind: 'message', T: () => Error$2 },
+            {
+                no: 5,
+                name: 'reconnect_strategy',
+                kind: 'enum',
+                T: () => [
+                    'stream.video.sfu.models.WebsocketReconnectStrategy',
+                    WebsocketReconnectStrategy,
+                    'WEBSOCKET_RECONNECT_STRATEGY_',
+                ],
+            },
         ]);
     }
     create(value) {
         const message = globalThis.Object.create(this.messagePrototype);
+        message.reconnectStrategy = 0;
         if (value !== undefined)
             runtime.reflectionMergePartial(this, message, value);
         return message;
@@ -4137,6 +4254,9 @@ class Error$Type extends runtime.MessageType {
                 case /* stream.video.sfu.models.Error error */ 4:
                     message.error = Error$2.internalBinaryRead(reader, reader.uint32(), options, message.error);
                     break;
+                case /* stream.video.sfu.models.WebsocketReconnectStrategy reconnect_strategy */ 5:
+                    message.reconnectStrategy = reader.int32();
+                    break;
                 default:
                     let u = options.readUnknownField;
                     if (u === 'throw')
@@ -4152,6 +4272,9 @@ class Error$Type extends runtime.MessageType {
         /* stream.video.sfu.models.Error error = 4; */
         if (message.error)
             Error$2.internalBinaryWrite(message.error, writer.tag(4, runtime.WireType.LengthDelimited).fork(), options).join();
+        /* stream.video.sfu.models.WebsocketReconnectStrategy reconnect_strategy = 5; */
+        if (message.reconnectStrategy !== 0)
+            writer.tag(5, runtime.WireType.Varint).int32(message.reconnectStrategy);
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -4945,6 +5068,60 @@ class ParticipantLeft$Type extends runtime.MessageType {
  */
 const ParticipantLeft = new ParticipantLeft$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class ParticipantUpdated$Type extends runtime.MessageType {
+    constructor() {
+        super('stream.video.sfu.event.ParticipantUpdated', [
+            { no: 1, name: 'call_cid', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: 'participant', kind: 'message', T: () => Participant },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.callCid = '';
+        if (value !== undefined)
+            runtime.reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string call_cid */ 1:
+                    message.callCid = reader.string();
+                    break;
+                case /* stream.video.sfu.models.Participant participant */ 2:
+                    message.participant = Participant.internalBinaryRead(reader, reader.uint32(), options, message.participant);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string call_cid = 1; */
+        if (message.callCid !== '')
+            writer.tag(1, runtime.WireType.LengthDelimited).string(message.callCid);
+        /* stream.video.sfu.models.Participant participant = 2; */
+        if (message.participant)
+            Participant.internalBinaryWrite(message.participant, writer.tag(2, runtime.WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.event.ParticipantUpdated
+ */
+const ParticipantUpdated = new ParticipantUpdated$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class SubscriberOffer$Type extends runtime.MessageType {
     constructor() {
         super('stream.video.sfu.event.SubscriberOffer', [
@@ -5895,6 +6072,62 @@ class GoAway$Type extends runtime.MessageType {
  * @generated MessageType for protobuf message stream.video.sfu.event.GoAway
  */
 const GoAway = new GoAway$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CallEnded$Type extends runtime.MessageType {
+    constructor() {
+        super('stream.video.sfu.event.CallEnded', [
+            {
+                no: 1,
+                name: 'reason',
+                kind: 'enum',
+                T: () => [
+                    'stream.video.sfu.models.CallEndedReason',
+                    CallEndedReason,
+                    'CALL_ENDED_REASON_',
+                ],
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.reason = 0;
+        if (value !== undefined)
+            runtime.reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* stream.video.sfu.models.CallEndedReason reason */ 1:
+                    message.reason = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* stream.video.sfu.models.CallEndedReason reason = 1; */
+        if (message.reason !== 0)
+            writer.tag(1, runtime.WireType.Varint).int32(message.reason);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.event.CallEnded
+ */
+const CallEnded = new CallEnded$Type();
 
 var events = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -5902,6 +6135,7 @@ var events = /*#__PURE__*/Object.freeze({
     AudioLevelChanged: AudioLevelChanged,
     AudioMediaRequest: AudioMediaRequest,
     AudioSender: AudioSender,
+    CallEnded: CallEnded,
     CallGrantsUpdated: CallGrantsUpdated,
     ChangePublishQuality: ChangePublishQuality,
     ConnectionQualityChanged: ConnectionQualityChanged,
@@ -5918,6 +6152,7 @@ var events = /*#__PURE__*/Object.freeze({
     Migration: Migration,
     ParticipantJoined: ParticipantJoined,
     ParticipantLeft: ParticipantLeft,
+    ParticipantUpdated: ParticipantUpdated,
     PinsChanged: PinsChanged,
     PublisherAnswer: PublisherAnswer,
     SfuEvent: SfuEvent,
@@ -6198,6 +6433,8 @@ const sfuEventKinds = {
     goAway: undefined,
     iceRestart: undefined,
     pinsUpdated: undefined,
+    callEnded: undefined,
+    participantUpdated: undefined,
 };
 const isSfuEvent = (eventName) => {
     return Object.prototype.hasOwnProperty.call(sfuEventKinds, eventName);
@@ -7137,9 +7374,11 @@ class CallState {
             this.setCurrentValue(this.thumbnailsSubject, call.thumbnails);
         };
         this.updateFromMemberRemoved = (event) => {
+            this.updateFromCallResponse(event.call);
             this.setCurrentValue(this.membersSubject, (members) => members.filter((m) => event.members.indexOf(m.user_id) === -1));
         };
         this.updateFromMemberAdded = (event) => {
+            this.updateFromCallResponse(event.call);
             this.setCurrentValue(this.membersSubject, (members) => [
                 ...members,
                 ...event.members,
@@ -7223,6 +7462,7 @@ class CallState {
             });
         };
         this.updateMembers = (event) => {
+            this.updateFromCallResponse(event.call);
             this.setCurrentValue(this.membersSubject, (members) => members.map((member) => {
                 const memberUpdate = event.members.find((m) => m.user_id === member.user_id);
                 return memberUpdate ? memberUpdate : member;
@@ -9351,6 +9591,17 @@ const watchParticipantLeft = (state) => {
         state.setParticipants((participants) => participants.filter((p) => p.sessionId !== participant.sessionId));
     };
 };
+/**
+ * An event responder which handles the `participantUpdated` event.
+ */
+const watchParticipantUpdated = (state) => {
+    return function onParticipantUpdated(e) {
+        const { participant } = e;
+        if (!participant)
+            return;
+        state.updateParticipant(participant.sessionId, participant);
+    };
+};
 /**
  * An event responder which handles the `trackPublished` event.
  * The SFU will send this event when a participant publishes a track.
@@ -9452,6 +9703,7 @@ const registerEventHandlers = (call, state, dispatcher) => {
         watchParticipantCountChanged(dispatcher, state),
         call.on('participantJoined', watchParticipantJoined(state)),
         call.on('participantLeft', watchParticipantLeft(state)),
+        call.on('participantUpdated', watchParticipantUpdated(state)),
         call.on('trackPublished', watchTrackPublished(state)),
         call.on('trackUnpublished', watchTrackUnpublished(state)),
         watchAudioLevelChanged(dispatcher, state),
@@ -10638,18 +10890,27 @@ class InputMediaDeviceManager {
      * Starts stream.
      */
     async enable() {
-        if (this.state.status === 'enabled')
+        if (this.state.optimisticStatus === 'enabled') {
+            await this.statusChangePromise;
             return;
-        this.enablePromise = this.unmuteStream();
-        try {
-            await this.enablePromise;
-            this.state.setStatus('enabled');
-            this.enablePromise = undefined;
-        }
-        catch (error) {
-            this.enablePromise = undefined;
-            throw error;
         }
+        const signal = this.nextAbortableStatusChangeRequest('enabled');
+        const doEnable = async () => {
+            if (signal.aborted)
+                return;
+            try {
+                await this.unmuteStream();
+                this.state.setStatus('enabled');
+            }
+            finally {
+                if (!signal.aborted)
+                    this.resetStatusChangeRequest();
+            }
+        };
+        this.statusChangePromise = this.statusChangePromise
+            ? this.statusChangePromise.then(doEnable)
+            : doEnable();
+        await this.statusChangePromise;
     }
     /**
      * Stops or pauses the stream based on state.disableMode
@@ -10657,19 +10918,28 @@ class InputMediaDeviceManager {
      */
     async disable(forceStop = false) {
         this.state.prevStatus = this.state.status;
-        if (!forceStop && this.state.status === 'disabled')
+        if (!forceStop && this.state.optimisticStatus === 'disabled') {
+            await this.statusChangePromise;
             return;
-        const stopTracks = forceStop || this.state.disableMode === 'stop-tracks';
-        this.disablePromise = this.muteStream(stopTracks);
-        try {
-            await this.disablePromise;
-            this.state.setStatus('disabled');
-            this.disablePromise = undefined;
-        }
-        catch (error) {
-            this.disablePromise = undefined;
-            throw error;
         }
+        const stopTracks = forceStop || this.state.disableMode === 'stop-tracks';
+        const signal = this.nextAbortableStatusChangeRequest('disabled');
+        const doDisable = async () => {
+            if (signal.aborted)
+                return;
+            try {
+                await this.muteStream(stopTracks);
+                this.state.setStatus('disabled');
+            }
+            finally {
+                if (!signal.aborted)
+                    this.resetStatusChangeRequest();
+            }
+        };
+        this.statusChangePromise = this.statusChangePromise
+            ? this.statusChangePromise.then(doDisable)
+            : doDisable();
+        await this.statusChangePromise;
     }
     /**
      * If status was previously enabled, it will re-enable the device.
@@ -10685,7 +10955,7 @@ class InputMediaDeviceManager {
      * else it will disable it.
      */
     async toggle() {
-        if (this.state.status === 'enabled') {
+        if (this.state.optimisticStatus === 'enabled') {
             return this.disable();
         }
         else {
@@ -10872,11 +11142,8 @@ class InputMediaDeviceManager {
             this.state.setMediaStream(stream, await rootStream);
             this.getTracks().forEach((track) => {
                 track.addEventListener('ended', async () => {
-                    if (this.enablePromise) {
-                        await this.enablePromise;
-                    }
-                    if (this.disablePromise) {
-                        await this.disablePromise;
+                    if (this.statusChangePromise) {
+                        await this.statusChangePromise;
                     }
                     if (this.state.status === 'enabled') {
                         this.isTrackStoppedDueToTrackEnd = true;
@@ -10906,11 +11173,8 @@ class InputMediaDeviceManager {
             if (!deviceId) {
                 return;
             }
-            if (this.enablePromise) {
-                await this.enablePromise;
-            }
-            if (this.disablePromise) {
-                await this.disablePromise;
+            if (this.statusChangePromise) {
+                await this.statusChangePromise;
             }
             let isDeviceDisconnected = false;
             let isDeviceReplaced = false;
@@ -10944,6 +11208,16 @@ class InputMediaDeviceManager {
     findDeviceInList(devices, deviceId) {
         return devices.find((d) => d.deviceId === deviceId && d.kind === this.mediaDeviceKind);
     }
+    nextAbortableStatusChangeRequest(status) {
+        this.statusChangeAbortController?.abort();
+        this.statusChangeAbortController = new AbortController();
+        this.state.setPendingStatus(status);
+        return this.statusChangeAbortController.signal;
+    }
+    resetStatusChangeRequest() {
+        this.statusChangePromise = undefined;
+        this.statusChangeAbortController = undefined;
+    }
 }
 
 class InputMediaDeviceManagerState {
@@ -10958,6 +11232,7 @@ class InputMediaDeviceManagerState {
         this.disableMode = disableMode;
         this.permissionName = permissionName;
         this.statusSubject = new rxjs.BehaviorSubject(undefined);
+        this.optimisticStatusSubject = new rxjs.BehaviorSubject(undefined);
         this.mediaStreamSubject = new rxjs.BehaviorSubject(undefined);
         this.selectedDeviceSubject = new rxjs.BehaviorSubject(undefined);
         this.defaultConstraintsSubject = new rxjs.BehaviorSubject(undefined);
@@ -10976,6 +11251,12 @@ class InputMediaDeviceManagerState {
          * An Observable that emits the device status
          */
         this.status$ = this.statusSubject.asObservable().pipe(rxjs.distinctUntilChanged());
+        /**
+         * An Observable the reflects the requested device status. Useful for optimistic UIs
+         */
+        this.optimisticStatus$ = this.optimisticStatusSubject
+            .asObservable()
+            .pipe(rxjs.distinctUntilChanged());
         /**
          * The default constraints for the device.
          */
@@ -11043,6 +11324,12 @@ class InputMediaDeviceManagerState {
     get status() {
         return this.getCurrentValue(this.status$);
     }
+    /**
+     * The requested device status. Useful for optimistic UIs
+     */
+    get optimisticStatus() {
+        return this.getCurrentValue(this.optimisticStatus$);
+    }
     /**
      * The currently selected device
      */
@@ -11062,6 +11349,13 @@ class InputMediaDeviceManagerState {
     setStatus(status) {
         this.setCurrentValue(this.statusSubject, status);
     }
+    /**
+     * @internal
+     * @param pendingStatus
+     */
+    setPendingStatus(pendingStatus) {
+        this.setCurrentValue(this.optimisticStatusSubject, pendingStatus);
+    }
     /**
      * Updates the `mediaStream` state variable.
      *
@@ -11181,9 +11475,9 @@ class CameraManager extends InputMediaDeviceManager {
     async selectTargetResolution(resolution) {
         this.targetResolution.height = resolution.height;
         this.targetResolution.width = resolution.width;
-        if (this.enablePromise) {
+        if (this.statusChangePromise && this.state.optimisticStatus === 'enabled') {
             try {
-                await this.enablePromise;
+                await this.statusChangePromise;
             }
             catch (error) {
                 // couldn't enable device, target resolution will be applied the next time user attempts to start the device
@@ -13324,12 +13618,7 @@ class Call {
     }
     async initCamera(options) {
         // Wait for any in progress camera operation
-        if (this.camera.enablePromise) {
-            await this.camera.enablePromise;
-        }
-        if (this.camera.disablePromise) {
-            await this.camera.disablePromise;
-        }
+        await this.camera.statusChangePromise;
         if (this.state.localParticipant?.videoStream ||
             !this.permissionsContext.hasPermission('send-video')) {
             return;
@@ -13366,12 +13655,7 @@ class Call {
     }
     async initMic(options) {
         // Wait for any in progress mic operation
-        if (this.microphone.enablePromise) {
-            await this.microphone.enablePromise;
-        }
-        if (this.microphone.disablePromise) {
-            await this.microphone.disablePromise;
-        }
+        await this.microphone.statusChangePromise;
         if (this.state.localParticipant?.audioStream ||
             !this.permissionsContext.hasPermission('send-audio')) {
             return;
@@ -14912,7 +15196,7 @@ class StreamClient {
             });
         };
         this.getUserAgent = () => {
-            const version = "1.0.0" ;
+            const version = "1.0.2" ;
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };