msw 2.14.1 → 2.14.3

package/lib/browser/index.js

@@ -1671,7 +1671,7 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
   return registrationResult;
 };
 
-// node_modules/.pnpm/rettime@0.11.7/node_modules/rettime/build/lens-list.mjs
+// node_modules/.pnpm/rettime@0.11.11/node_modules/rettime/build/lens-list.mjs
 var LensList = class {
   #list;
   #lens;
@@ -1713,15 +1713,17 @@ var LensList = class {
   }
   /**
   * Delete the value belonging to the given key.
+  * Returns `true` if the value was present and removed, `false` otherwise.
   */
   delete(key, value) {
-    if (this.size === 0) return;
-    this.#list = this.#list.filter((item) => item[1] !== value);
+    if (this.size === 0) return false;
     const values = this.#lens.get(key);
-    if (values) {
-      const index = values.indexOf(value);
-      if (index !== -1) values.splice(index, 1);
-    }
+    if (!values) return false;
+    const index = values.indexOf(value);
+    if (index === -1) return false;
+    values.splice(index, 1);
+    this.#list.splice(this.#list.findIndex((item) => item[0] === key && item[1] === value), 1);
+    return true;
   }
   /**
   * Delete all values belogning to the given key.
@@ -1744,7 +1746,7 @@ var LensList = class {
   }
 };
 
-// node_modules/.pnpm/rettime@0.11.7/node_modules/rettime/build/index.mjs
+// node_modules/.pnpm/rettime@0.11.11/node_modules/rettime/build/index.mjs
 var kDefaultPrevented2 = Symbol("kDefaultPrevented");
 var kPropagationStopped = Symbol("kPropagationStopped");
 var kImmediatePropagationStopped = Symbol("kImmediatePropagationStopped");
@@ -1777,37 +1779,66 @@ var TypedEvent = class extends MessageEvent {
 var Emitter2 = class {
   #listeners;
   #listenerOptions;
+  #listenerAbortCleanups;
   #typelessListeners;
   #hookListeners;
   #hookListenerOptions;
+  #hookListenerAbortCleanups;
   hooks;
   constructor() {
     this.#listeners = new LensList();
     this.#listenerOptions = /* @__PURE__ */ new WeakMap();
+    this.#listenerAbortCleanups = /* @__PURE__ */ new WeakMap();
     this.#typelessListeners = /* @__PURE__ */ new WeakSet();
     this.#hookListeners = new LensList();
     this.#hookListenerOptions = /* @__PURE__ */ new WeakMap();
+    this.#hookListenerAbortCleanups = /* @__PURE__ */ new WeakMap();
     this.hooks = {
       on: (hook, callback, options) => {
+        if (options?.signal?.aborted) return;
         if (options?.once) {
           const original = callback;
           const wrapper = ((...args) => {
-            this.#hookListeners.delete(hook, wrapper);
+            this.#deleteHookListener(hook, wrapper);
             return original(...args);
           });
           callback = wrapper;
         }
         this.#hookListeners.append(hook, callback);
         if (options) this.#hookListenerOptions.set(callback, options);
-        if (options?.signal) options.signal.addEventListener("abort", () => {
-          this.#hookListeners.delete(hook, callback);
-        }, { once: true });
+        if (options?.signal) {
+          const { signal } = options;
+          const onAbort = () => {
+            this.#deleteHookListener(hook, callback);
+          };
+          signal.addEventListener("abort", onAbort, { once: true });
+          this.#hookListenerAbortCleanups.set(callback, () => {
+            signal.removeEventListener("abort", onAbort);
+          });
+        }
       },
       removeListener: (hook, callback) => {
-        this.#hookListeners.delete(hook, callback);
+        this.#deleteHookListener(hook, callback);
       }
     };
   }
+  #deleteHookListener(hook, callback) {
+    this.#hookListeners.delete(hook, callback);
+    const cleanup = this.#hookListenerAbortCleanups.get(callback);
+    if (cleanup) {
+      cleanup();
+      this.#hookListenerAbortCleanups.delete(callback);
+    }
+  }
+  #deleteListener(type, listener) {
+    const removed = this.#listeners.delete(type, listener);
+    const cleanup = this.#listenerAbortCleanups.get(listener);
+    if (cleanup) {
+      cleanup();
+      this.#listenerAbortCleanups.delete(listener);
+    }
+    return removed;
+  }
   /**
   * Adds a listener for the given event type.
   */
@@ -1909,8 +1940,8 @@ var Emitter2 = class {
   */
   removeListener(type, listener) {
     const options = this.#listenerOptions.get(listener);
-    this.#listeners.delete(type, listener);
-    for (const hook of this.#hookListeners.get("removeListener")) hook(type, listener, options);
+    if (!this.#deleteListener(type, listener)) return;
+    for (const hook of this.#hookListeners.get("removeListener").slice()) hook(type, listener, options);
   }
   /**
   * Removes all listeners for the given event type.
@@ -1918,11 +1949,12 @@ var Emitter2 = class {
   */
   removeAllListeners(type) {
     if (type == null) {
-      this.#listeners.clear();
-      for (const [hookType, hookListener] of this.#hookListeners) if (!this.#hookListenerOptions.get(hookListener)?.persist) this.#hookListeners.delete(hookType, hookListener);
+      for (const [listenerType, listeners$1] of this.#listeners.entries()) while (listeners$1.length > 0) this.removeListener(listenerType, listeners$1[0]);
+      for (const [hookType, hookListener] of [...this.#hookListeners]) if (!this.#hookListenerOptions.get(hookListener)?.persist) this.#deleteHookListener(hookType, hookListener);
       return;
     }
-    this.#listeners.deleteAll(type);
+    const listeners = this.listeners(type);
+    while (listeners.length > 0) this.removeListener(type, listeners[0]);
   }
   /**
   * Returns the list of listeners for the given event type.
@@ -1941,15 +1973,23 @@ var Emitter2 = class {
     return this.listeners(type).length;
   }
   #addListener(type, listener, options, insertMode = "append") {
-    for (const hook of this.#hookListeners.get("newListener")) hook(type, listener, options);
+    if (options?.signal?.aborted) return;
+    for (const hook of this.#hookListeners.get("newListener").slice()) hook(type, listener, options);
     if (type === "*") this.#typelessListeners.add(listener);
     if (insertMode === "prepend") this.#listeners.prepend(type, listener);
     else this.#listeners.append(type, listener);
     if (options) {
       this.#listenerOptions.set(listener, options);
-      if (options.signal) options.signal.addEventListener("abort", () => {
-        this.removeListener(type, listener);
-      }, { once: true });
+      if (options.signal) {
+        const { signal } = options;
+        const onAbort = () => {
+          this.removeListener(type, listener);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        this.#listenerAbortCleanups.set(listener, () => {
+          signal.removeEventListener("abort", onAbort);
+        });
+      }
     }
   }
   #proxyEvent(event) {
@@ -1966,22 +2006,27 @@ var Emitter2 = class {
     };
   }
   #callListener(event, listener) {
-    for (const hook of this.#hookListeners.get("beforeEmit")) if (hook(event) === false) return;
+    for (const hook of this.#hookListeners.get("beforeEmit").slice()) if (hook(event) === false) return;
     const returnValue = listener.call(this, event);
     const options = this.#listenerOptions.get(listener);
     if (options?.once) {
       const type = this.#isTypelessListener(listener) ? "*" : event.type;
-      this.#listeners.delete(type, listener);
-      for (const hook of this.#hookListeners.get("removeListener")) hook(type, listener, options);
+      if (this.#deleteListener(type, listener)) for (const hook of this.#hookListeners.get("removeListener").slice()) hook(type, listener, options);
     }
     return returnValue;
   }
   /**
   * Return a list of all event listeners relevant for the given event type.
   * This includes the explicit event listeners and also typeless event listeners.
+  *
+  * @note Snapshot the matching listeners before yielding. Listeners can add or
+  * remove other listeners during emission (e.g. `earlyOn` unshifts `#list`),
+  * which would otherwise shift the live iterator and re-yield prior entries.
   */
   *#matchListeners(type) {
-    for (const [key, listener] of this.#listeners) if (key === "*" || key === type) yield listener;
+    const snapshot = [];
+    for (const [key, listener] of this.#listeners) if (key === "*" || key === type) snapshot.push(listener);
+    yield* snapshot;
   }
   #isTypelessListener(listener) {
     return this.#typelessListeners.has(listener);
@@ -2295,11 +2340,12 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
   }
   async #handleResponse(event) {
     const { request, response, isMockedResponse } = event.data;
+    const frame = this.#frames.get(request.id);
     if (response.type?.includes("opaque")) {
       this.#frames.delete(request.id);
+      frame?.events.removeAllListeners();
       return;
     }
-    const frame = this.#frames.get(request.id);
     this.#frames.delete(request.id);
     if (frame == null) {
       return;
@@ -2323,17 +2369,21 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
         url: request.url
       }
     );
-    frame.events.emit(
-      new import_http_frame.ResponseEvent(
-        isMockedResponse ? "response:mocked" : "response:bypass",
-        {
-          requestId: frame.data.id,
-          request: fetchRequest,
-          response: fetchResponse,
-          isMockedResponse
-        }
-      )
-    );
+    try {
+      frame.events.emit(
+        new import_http_frame.ResponseEvent(
+          isMockedResponse ? "response:mocked" : "response:bypass",
+          {
+            requestId: frame.data.id,
+            request: fetchRequest,
+            response: fetchResponse,
+            isMockedResponse
+          }
+        )
+      );
+    } finally {
+      frame.events.removeAllListeners();
+    }
   }
   #defaultFindWorker = (workerUrl, mockServiceWorkerUrl) => {
     return workerUrl === mockServiceWorkerUrl;