@webex/web-client-media-engine 3.11.0 → 3.11.1

package/dist/esm/index.js

@@ -486,6 +486,7 @@ var WebrtcCoreErrorType;
 (function (WebrtcCoreErrorType) {
     WebrtcCoreErrorType["DEVICE_PERMISSION_DENIED"] = "DEVICE_PERMISSION_DENIED";
     WebrtcCoreErrorType["CREATE_STREAM_FAILED"] = "CREATE_STREAM_FAILED";
+    WebrtcCoreErrorType["ADD_EFFECT_FAILED"] = "ADD_EFFECT_FAILED";
 })(WebrtcCoreErrorType || (WebrtcCoreErrorType = {}));
 /**
  * Represents a WebRTC core error, which contains error type and error message.
@@ -1246,11 +1247,12 @@ class _Stream {
 _a$1$1 = StreamEventNames.MuteStateChange, _b$1 = StreamEventNames.Ended;
 const Stream = AddEvents(_Stream);
 
-var _a$6, _b;
+var _a$6, _b, _c;
 var LocalStreamEventNames;
 (function (LocalStreamEventNames) {
     LocalStreamEventNames["ConstraintsChange"] = "constraints-change";
     LocalStreamEventNames["OutputTrackChange"] = "output-track-change";
+    LocalStreamEventNames["EffectAdded"] = "effect-added";
 })(LocalStreamEventNames || (LocalStreamEventNames = {}));
 /**
  * A stream which originates on the local device.
@@ -1265,6 +1267,7 @@ class _LocalStream extends Stream {
         super(stream);
         this[_a$6] = new TypedEvent$1();
         this[_b] = new TypedEvent$1();
+        this[_c] = new TypedEvent$1();
         this.effects = [];
         this.loadingEffects = new Map();
         this.inputStream = stream;
@@ -1356,55 +1359,110 @@ class _LocalStream extends Stream {
     /**
      * Adds an effect to a local stream.
      *
-     * @param name - The name of the effect.
      * @param effect - The effect to add.
      */
-    addEffect(name, effect) {
+    addEffect(effect) {
         return __awaiter$2(this, void 0, void 0, function* () {
-            // Load the effect
-            this.loadingEffects.set(name, effect);
-            const outputTrack = yield effect.load(this.outputTrack);
-            // Check that the loaded effect is the latest one and dispose if not
-            if (effect !== this.loadingEffects.get(name)) {
+            // Check if the effect has already been added.
+            if (this.effects.some((e) => e.id === effect.id)) {
+                return;
+            }
+            // Load the effect. Because loading is asynchronous, keep track of the loading effects.
+            this.loadingEffects.set(effect.kind, effect);
+            yield effect.load(this.outputTrack);
+            // After loading, check whether or not we still want to use this effect. If another effect of
+            // the same kind was added while this effect was loading, we only want to use the latest effect,
+            // so dispose this one. If the effects list was cleared while this effect was loading, also
+            // dispose it.
+            if (effect !== this.loadingEffects.get(effect.kind)) {
                 yield effect.dispose();
-                throw new Error(`Effect "${name}" not required after loading`);
+                throw new WebrtcCoreError(WebrtcCoreErrorType.ADD_EFFECT_FAILED, `Another effect with kind ${effect.kind} was added while effect ${effect.id} was loading, or the effects list was cleared.`);
             }
-            // Use the effect
-            this.loadingEffects.delete(name);
-            this.effects.push({ name, effect });
-            this.changeOutputTrack(outputTrack);
-            // When the effect's track is updated, update the next effect or output stream.
-            // TODO: using EffectEvent.TrackUpdated will cause the entire web-media-effects lib to be built
-            // and makes the size of the webrtc-core build much larger, so we use type assertion here as a
-            // temporary workaround.
-            effect.on('track-updated', (track) => {
-                var _c;
-                const effectIndex = this.effects.findIndex((e) => e.name === name);
+            this.loadingEffects.delete(effect.kind);
+            /**
+             * Handle when the effect's output track has been changed. This will update the input of the
+             * next effect in the effects list of the output of the stream.
+             *
+             * @param track - The new output track of the effect.
+             */
+            const handleEffectTrackUpdated = (track) => {
+                var _d;
+                const effectIndex = this.effects.findIndex((e) => e.id === effect.id);
                 if (effectIndex === this.effects.length - 1) {
                     this.changeOutputTrack(track);
                 }
+                else if (effectIndex >= 0) {
+                    (_d = this.effects[effectIndex + 1]) === null || _d === void 0 ? void 0 : _d.replaceInputTrack(track);
+                }
                 else {
-                    (_c = this.effects[effectIndex + 1]) === null || _c === void 0 ? void 0 : _c.effect.replaceInputTrack(track);
+                    logger$3.error(`Effect with ID ${effect.id} not found in effects list.`);
                 }
-            });
+            };
+            /**
+             * Handle when the effect has been disposed. This will remove all event listeners from the
+             * effect.
+             */
+            const handleEffectDisposed = () => {
+                effect.off('track-updated', handleEffectTrackUpdated);
+                effect.off('disposed', handleEffectDisposed);
+            };
+            // TODO: using EffectEvent.TrackUpdated or EffectEvent.Disposed will cause the entire
+            // web-media-effects lib to be rebuilt and inflates the size of the webrtc-core build, so
+            // we use type assertion here as a temporary workaround.
+            effect.on('track-updated', handleEffectTrackUpdated);
+            effect.on('disposed', handleEffectDisposed);
+            // Add the effect to the effects list. If an effect of the same kind has already been added,
+            // dispose the existing effect and replace it with the new effect. If the existing effect was
+            // enabled, also enable the new effect.
+            const existingEffectIndex = this.effects.findIndex((e) => e.kind === effect.kind);
+            if (existingEffectIndex >= 0) {
+                const [existingEffect] = this.effects.splice(existingEffectIndex, 1, effect);
+                if (existingEffect.isEnabled) {
+                    // If the existing effect is not the first effect in the effects list, then the input of the
+                    // new effect should be the output of the previous effect in the effects list. We know the
+                    // output track of the previous effect must exist because it must have been loaded (and all
+                    // loaded effects have an output track).
+                    const inputTrack = existingEffectIndex === 0
+                        ? this.inputTrack
+                        : this.effects[existingEffectIndex - 1].getOutputTrack();
+                    yield effect.replaceInputTrack(inputTrack);
+                    // Enabling the new effect will trigger the track-updated event, which will handle the new
+                    // effect's updated output track.
+                    yield effect.enable();
+                }
+                yield existingEffect.dispose();
+            }
+            else {
+                this.effects.push(effect);
+            }
+            // Emit an event with the effect so others can listen to the effect events.
+            this[LocalStreamEventNames.EffectAdded].emit(effect);
         });
     }
     /**
-     * Get an effect from the effects list.
+     * Get an effect from the effects list by ID.
+     *
+     * @param id - The id of the effect you want to get.
+     * @returns The effect or undefined.
+     */
+    getEffectById(id) {
+        return this.effects.find((effect) => effect.id === id);
+    }
+    /**
+     * Get an effect from the effects list by kind.
      *
-     * @param name - The name of the effect you want to get.
+     * @param kind - The kind of the effect you want to get.
      * @returns The effect or undefined.
      */
-    getEffect(name) {
-        var _c;
-        return (_c = this.effects.find((e) => e.name === name)) === null || _c === void 0 ? void 0 : _c.effect;
+    getEffectByKind(kind) {
+        return this.effects.find((effect) => effect.kind === kind);
     }
     /**
      * Get all the effects from the effects list.
      *
-     * @returns A list of effect items, each containing the name and the effect itself.
+     * @returns A list of effects.
      */
-    getAllEffects() {
+    getEffects() {
         return this.effects;
     }
     /**
@@ -1416,13 +1474,13 @@ class _LocalStream extends Stream {
             // Dispose of any effects currently in use
             if (this.effects.length > 0) {
                 this.changeOutputTrack(this.inputTrack);
-                yield Promise.all(this.effects.map((item) => item.effect.dispose()));
+                yield Promise.all(this.effects.map((effect) => effect.dispose()));
                 this.effects = [];
             }
         });
     }
 }
-_a$6 = LocalStreamEventNames.ConstraintsChange, _b = LocalStreamEventNames.OutputTrackChange;
+_a$6 = LocalStreamEventNames.ConstraintsChange, _b = LocalStreamEventNames.OutputTrackChange, _c = LocalStreamEventNames.EffectAdded;
 const LocalStream = AddEvents(_LocalStream);
 
 /**