@stream-io/video-client 0.7.7 → 0.7.9

package/dist/index.cjs.js

@@ -54,6 +54,22 @@ const CreateDeviceRequestPushProviderEnum = {
     HUAWEI: 'huawei',
     XIAOMI: 'xiaomi',
 };
+/**
+ * @export
+ */
+const NoiseCancellationSettingsModeEnum = {
+    AVAILABLE: 'available',
+    DISABLED: 'disabled',
+    AUTO_ON: 'auto-on',
+};
+/**
+ * @export
+ */
+const NoiseCancellationSettingsRequestModeEnum = {
+    AVAILABLE: 'available',
+    DISABLED: 'disabled',
+    AUTO_ON: 'auto-on',
+};
 /**
  * All possibility of string to use
  * @export
@@ -62,6 +78,7 @@ const OwnCapability = {
     BLOCK_USERS: 'block-users',
     CREATE_CALL: 'create-call',
     CREATE_REACTION: 'create-reaction',
+    ENABLE_NOISE_CANCELLATION: 'enable-noise-cancellation',
     END_CALL: 'end-call',
     JOIN_BACKSTAGE: 'join-backstage',
     JOIN_CALL: 'join-call',
@@ -2443,10 +2460,196 @@ var models = /*#__PURE__*/Object.freeze({
 });
 
 /* eslint-disable */
-// @generated by protobuf-ts 2.9.3 with parameter long_type_string,client_generic,server_none,eslint_disable
+// @generated by protobuf-ts 2.9.4 with parameter long_type_string,client_generic,server_none,eslint_disable
 // @generated from protobuf file "video/sfu/signal_rpc/signal.proto" (package "stream.video.sfu.signal", syntax proto3)
 // tslint:disable
 // @generated message type with reflection information, may provide speed optimized methods
+class StartNoiseCancellationRequest$Type extends runtime.MessageType {
+    constructor() {
+        super('stream.video.sfu.signal.StartNoiseCancellationRequest', [
+            { no: 1, name: 'session_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.sessionId = '';
+        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 session_id */ 1:
+                    message.sessionId = reader.string();
+                    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 session_id = 1; */
+        if (message.sessionId !== '')
+            writer.tag(1, runtime.WireType.LengthDelimited).string(message.sessionId);
+        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.signal.StartNoiseCancellationRequest
+ */
+const StartNoiseCancellationRequest = new StartNoiseCancellationRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StartNoiseCancellationResponse$Type extends runtime.MessageType {
+    constructor() {
+        super('stream.video.sfu.signal.StartNoiseCancellationResponse', [
+            { no: 1, name: 'error', kind: 'message', T: () => Error$2 },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        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.Error error */ 1:
+                    message.error = Error$2.internalBinaryRead(reader, reader.uint32(), options, message.error);
+                    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.Error error = 1; */
+        if (message.error)
+            Error$2.internalBinaryWrite(message.error, writer.tag(1, 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.signal.StartNoiseCancellationResponse
+ */
+const StartNoiseCancellationResponse = new StartNoiseCancellationResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StopNoiseCancellationRequest$Type extends runtime.MessageType {
+    constructor() {
+        super('stream.video.sfu.signal.StopNoiseCancellationRequest', [
+            { no: 1, name: 'session_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.sessionId = '';
+        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 session_id */ 1:
+                    message.sessionId = reader.string();
+                    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 session_id = 1; */
+        if (message.sessionId !== '')
+            writer.tag(1, runtime.WireType.LengthDelimited).string(message.sessionId);
+        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.signal.StopNoiseCancellationRequest
+ */
+const StopNoiseCancellationRequest = new StopNoiseCancellationRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StopNoiseCancellationResponse$Type extends runtime.MessageType {
+    constructor() {
+        super('stream.video.sfu.signal.StopNoiseCancellationResponse', [
+            { no: 1, name: 'error', kind: 'message', T: () => Error$2 },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        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.Error error */ 1:
+                    message.error = Error$2.internalBinaryRead(reader, reader.uint32(), options, message.error);
+                    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.Error error = 1; */
+        if (message.error)
+            Error$2.internalBinaryWrite(message.error, writer.tag(1, 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.signal.StopNoiseCancellationResponse
+ */
+const StopNoiseCancellationResponse = new StopNoiseCancellationResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class SendStatsRequest$Type extends runtime.MessageType {
     constructor() {
         super('stream.video.sfu.signal.SendStatsRequest', [
@@ -3496,6 +3699,18 @@ const SignalServer = new runtimeRpc.ServiceType('stream.video.sfu.signal.SignalS
         I: SendStatsRequest,
         O: SendStatsResponse,
     },
+    {
+        name: 'StartNoiseCancellation',
+        options: {},
+        I: StartNoiseCancellationRequest,
+        O: StartNoiseCancellationResponse,
+    },
+    {
+        name: 'StopNoiseCancellation',
+        options: {},
+        I: StopNoiseCancellationRequest,
+        O: StopNoiseCancellationResponse,
+    },
 ]);
 
 /**
@@ -5798,6 +6013,20 @@ class SignalServerClient {
         const method = this.methods[6], opt = this._transport.mergeOptions(options);
         return runtimeRpc.stackIntercept('unary', this._transport, method, opt, input);
     }
+    /**
+     * @generated from protobuf rpc: StartNoiseCancellation(stream.video.sfu.signal.StartNoiseCancellationRequest) returns (stream.video.sfu.signal.StartNoiseCancellationResponse);
+     */
+    startNoiseCancellation(input, options) {
+        const method = this.methods[7], opt = this._transport.mergeOptions(options);
+        return runtimeRpc.stackIntercept('unary', this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: StopNoiseCancellation(stream.video.sfu.signal.StopNoiseCancellationRequest) returns (stream.video.sfu.signal.StopNoiseCancellationResponse);
+     */
+    stopNoiseCancellation(input, options) {
+        const method = this.methods[8], opt = this._transport.mergeOptions(options);
+        return runtimeRpc.stackIntercept('unary', this._transport, method, opt, input);
+    }
 }
 
 const defaultOptions = {
@@ -7071,13 +7300,11 @@ class CallState {
         this.eventHandlers = {
             // these events are not updating the call state:
             'call.closed_caption': undefined,
+            'call.deleted': undefined,
             'call.permission_request': undefined,
             'call.recording_failed': undefined,
             'call.recording_ready': undefined,
-            'call.transcription_started': undefined,
-            'call.transcription_stopped': undefined,
             'call.transcription_ready': undefined,
-            'call.transcription_failed': undefined,
             'call.user_muted': undefined,
             'connection.error': undefined,
             'connection.ok': undefined,
@@ -7113,9 +7340,17 @@ class CallState {
             'call.session_participant_joined': this.updateFromSessionParticipantJoined,
             'call.session_participant_left': this.updateFromSessionParticipantLeft,
             'call.session_started': (e) => this.updateFromCallResponse(e.call),
+            'call.transcription_started': () => {
+                this.setCurrentValue(this.transcribingSubject, true);
+            },
+            'call.transcription_stopped': () => {
+                this.setCurrentValue(this.transcribingSubject, false);
+            },
+            'call.transcription_failed': () => {
+                this.setCurrentValue(this.transcribingSubject, false);
+            },
             'call.unblocked_user': this.unblockUser,
             'call.updated': (e) => this.updateFromCallResponse(e.call),
-            'call.deleted': undefined,
         };
     }
     /**
@@ -8695,6 +8930,16 @@ class StreamSfuClient {
                 sessionId: this.sessionId,
             }), this.logger);
         };
+        this.startNoiseCancellation = async () => {
+            return retryable(() => this.rpc.startNoiseCancellation({
+                sessionId: this.sessionId,
+            }), this.logger);
+        };
+        this.stopNoiseCancellation = async () => {
+            return retryable(() => this.rpc.stopNoiseCancellation({
+                sessionId: this.sessionId,
+            }), this.logger);
+        };
         this.join = async (data) => {
             const joinRequest = JoinRequest.create({
                 ...data,
@@ -11027,7 +11272,9 @@ const createSoundDetector = (audioStream, onSoundDetectedStateChanged, options =
         // clean-up the AudioContext elements
         microphone.disconnect();
         analyser.disconnect();
-        await audioContext.close();
+        if (audioContext.state !== 'closed') {
+            await audioContext.close();
+        }
         // stop the stream
         if (destroyStreamOnStop) {
             audioStream.getTracks().forEach((track) => {
@@ -11158,6 +11405,99 @@ class MicrophoneManager extends InputMediaDeviceManager {
                 await this.stopSpeakingWhileMutedDetection();
             }
         });
+        this.subscriptions.push(createSubscription(this.call.state.callingState$, (callingState) => {
+            // do nothing when noise filtering isn't turned on
+            if (!this.noiseCancellationRegistration || !this.noiseCancellation)
+                return;
+            const autoOn = this.call.state.settings?.audio.noise_cancellation?.mode ===
+                NoiseCancellationSettingsModeEnum.AUTO_ON;
+            if (autoOn && callingState === exports.CallingState.JOINED) {
+                this.noiseCancellationRegistration
+                    .then(() => this.noiseCancellation?.enable())
+                    .catch((err) => {
+                    this.logger('warn', `Failed to enable noise cancellation`, err);
+                    return this.call.notifyNoiseCancellationStopped();
+                });
+            }
+            else if (callingState === exports.CallingState.LEFT) {
+                this.noiseCancellationRegistration
+                    .then(() => this.noiseCancellation?.disable())
+                    .catch((err) => {
+                    this.logger('warn', `Failed to disable noise cancellation`, err);
+                });
+            }
+        }));
+    }
+    /**
+     * Enables noise cancellation for the microphone.
+     *
+     * Note: not supported in React Native.
+     * @param noiseCancellation - a noise cancellation instance to use.
+     */
+    async enableNoiseCancellation(noiseCancellation) {
+        if (isReactNative()) {
+            throw new Error('Noise cancellation is not supported in React Native');
+        }
+        const { ownCapabilities, settings } = this.call.state;
+        const hasNoiseCancellationCapability = ownCapabilities.includes(OwnCapability.ENABLE_NOISE_CANCELLATION);
+        if (!hasNoiseCancellationCapability) {
+            throw new Error('Noise cancellation is not available.');
+        }
+        const noiseCancellationSettings = settings?.audio.noise_cancellation;
+        if (!noiseCancellationSettings ||
+            noiseCancellationSettings.mode ===
+                NoiseCancellationSettingsModeEnum.DISABLED) {
+            throw new Error('Noise cancellation is disabled for this call type.');
+        }
+        try {
+            this.noiseCancellation = noiseCancellation;
+            // listen for change events and notify the SFU
+            this.noiseCancellationChangeUnsubscribe = this.noiseCancellation.on('change', (enabled) => {
+                if (enabled) {
+                    this.call.notifyNoiseCancellationStarting().catch((err) => {
+                        this.logger('warn', `notifyNoiseCancellationStart failed`, err);
+                    });
+                }
+                else {
+                    this.call.notifyNoiseCancellationStopped().catch((err) => {
+                        this.logger('warn', `notifyNoiseCancellationStop failed`, err);
+                    });
+                }
+            });
+            this.noiseCancellationRegistration = this.registerFilter(noiseCancellation.toFilter());
+            await this.noiseCancellationRegistration;
+            // handles an edge case where a noise cancellation is enabled after
+            // the participant as joined the call -> we immediately enable NC
+            if (noiseCancellationSettings.mode ===
+                NoiseCancellationSettingsModeEnum.AUTO_ON &&
+                this.call.state.callingState === exports.CallingState.JOINED) {
+                noiseCancellation.enable();
+            }
+        }
+        catch (e) {
+            this.logger('warn', 'Failed to enable noise cancellation', e);
+            await this.disableNoiseCancellation().catch((err) => {
+                this.logger('warn', 'Failed to disable noise cancellation', err);
+            });
+        }
+    }
+    /**
+     * Disables noise cancellation for the microphone.
+     *
+     * Note: not supported in React Native.
+     */
+    async disableNoiseCancellation() {
+        if (isReactNative()) {
+            throw new Error('Noise cancellation is not supported in React Native');
+        }
+        await this.noiseCancellationRegistration
+            ?.then((unregister) => unregister())
+            .then(() => this.noiseCancellation?.disable())
+            .then(() => this.noiseCancellationChangeUnsubscribe?.())
+            .catch((err) => {
+            this.logger('warn', 'Failed to unregister noise cancellation', err);
+        });
+        await this.call.notifyNoiseCancellationStopped();
     }
     getDevices() {
         return getAudioDevices();
@@ -12184,6 +12524,26 @@ class Call {
             this.logger('info', `stopPublish ${TrackType[trackType]}, stop tracks: ${stopTrack}`);
             await this.publisher?.unpublishStream(trackType, stopTrack);
         };
+        /**
+         * Notifies the SFU that a noise cancellation process has started.
+         *
+         * @internal
+         */
+        this.notifyNoiseCancellationStarting = async () => {
+            return this.sfuClient?.startNoiseCancellation().catch((err) => {
+                this.logger('warn', 'Failed to notify start of noise cancellation', err);
+            });
+        };
+        /**
+         * Notifies the SFU that a noise cancellation process has stopped.
+         *
+         * @internal
+         */
+        this.notifyNoiseCancellationStopped = async () => {
+            return this.sfuClient?.stopNoiseCancellation().catch((err) => {
+                this.logger('warn', 'Failed to notify stop of noise cancellation', err);
+            });
+        };
         /**
          * Update track subscription configuration for one or more participants.
          * You have to create a subscription for each participant for all the different kinds of tracks you want to receive.
@@ -14501,7 +14861,7 @@ class StreamClient {
             });
         };
         this.getUserAgent = () => {
-            const version = "0.7.7" ;
+            const version = "0.7.9" ;
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };
@@ -14997,6 +15357,8 @@ exports.InputMediaDeviceManager = InputMediaDeviceManager;
 exports.InputMediaDeviceManagerState = InputMediaDeviceManagerState;
 exports.MicrophoneManager = MicrophoneManager;
 exports.MicrophoneManagerState = MicrophoneManagerState;
+exports.NoiseCancellationSettingsModeEnum = NoiseCancellationSettingsModeEnum;
+exports.NoiseCancellationSettingsRequestModeEnum = NoiseCancellationSettingsRequestModeEnum;
 exports.OwnCapability = OwnCapability;
 exports.RecordSettingsRequestModeEnum = RecordSettingsRequestModeEnum;
 exports.RecordSettingsRequestQualityEnum = RecordSettingsRequestQualityEnum;