msw 2.14.2 → 2.14.4

package/lib/core/utils/internal/isHandlerKind.d.mts

@@ -1,5 +1,5 @@
 import { AnyHandler } from '../../experimental/handlers-controller.mjs';
-import { R as RequestHandler } from '../../HttpResponse-CxHR1nNN.mjs';
+import { R as RequestHandler } from '../../HttpResponse-CQwYpuKo.mjs';
 import { WebSocketHandler } from '../../handlers/WebSocketHandler.mjs';
 import '@mswjs/interceptors';
 import './isIterable.mjs';

package/lib/core/utils/internal/isHandlerKind.d.ts

@@ -1,5 +1,5 @@
 import { AnyHandler } from '../../experimental/handlers-controller.js';
-import { R as RequestHandler } from '../../HttpResponse-aGiIzO91.js';
+import { R as RequestHandler } from '../../HttpResponse-BFS34nkx.js';
 import { WebSocketHandler } from '../../handlers/WebSocketHandler.js';
 import '@mswjs/interceptors';
 import './isIterable.js';

package/lib/core/utils/internal/parseGraphQLRequest.d.mts

@@ -1,5 +1,5 @@
 import 'graphql';
-export { x as GraphQLMultipartRequestBody, w as GraphQLParsedOperationsMap, u as ParsedGraphQLQuery, P as ParsedGraphQLRequest, v as parseDocumentNode, y as parseGraphQLRequest } from '../../HttpResponse-CxHR1nNN.mjs';
+export { x as GraphQLMultipartRequestBody, w as GraphQLParsedOperationsMap, u as ParsedGraphQLQuery, P as ParsedGraphQLRequest, v as parseDocumentNode, y as parseGraphQLRequest } from '../../HttpResponse-CQwYpuKo.mjs';
 import '@mswjs/interceptors';
 import './isIterable.mjs';
 import '../../typeUtils.mjs';

package/lib/core/utils/internal/parseGraphQLRequest.d.ts

@@ -1,5 +1,5 @@
 import 'graphql';
-export { x as GraphQLMultipartRequestBody, w as GraphQLParsedOperationsMap, u as ParsedGraphQLQuery, P as ParsedGraphQLRequest, v as parseDocumentNode, y as parseGraphQLRequest } from '../../HttpResponse-aGiIzO91.js';
+export { x as GraphQLMultipartRequestBody, w as GraphQLParsedOperationsMap, u as ParsedGraphQLQuery, P as ParsedGraphQLRequest, v as parseDocumentNode, y as parseGraphQLRequest } from '../../HttpResponse-BFS34nkx.js';
 import '@mswjs/interceptors';
 import './isIterable.js';
 import '../../typeUtils.js';

package/lib/core/utils/internal/parseMultipartData.d.mts

@@ -1,4 +1,4 @@
-import { d as DefaultRequestMultipartBody } from '../../HttpResponse-CxHR1nNN.mjs';
+import { d as DefaultRequestMultipartBody } from '../../HttpResponse-CQwYpuKo.mjs';
 import '@mswjs/interceptors';
 import './isIterable.mjs';
 import '../../typeUtils.mjs';

package/lib/core/utils/internal/parseMultipartData.d.ts

@@ -1,4 +1,4 @@
-import { d as DefaultRequestMultipartBody } from '../../HttpResponse-aGiIzO91.js';
+import { d as DefaultRequestMultipartBody } from '../../HttpResponse-BFS34nkx.js';
 import '@mswjs/interceptors';
 import './isIterable.js';
 import '../../typeUtils.js';

package/lib/core/ws/handleWebSocketEvent.d.mts

@@ -1,5 +1,5 @@
 import { WebSocketConnectionData } from '@mswjs/interceptors/WebSocket';
-import { R as RequestHandler } from '../HttpResponse-CxHR1nNN.mjs';
+import { R as RequestHandler } from '../HttpResponse-CQwYpuKo.mjs';
 import { WebSocketHandler } from '../handlers/WebSocketHandler.mjs';
 import { UnhandledRequestStrategy } from '../utils/request/onUnhandledRequest.mjs';
 import '@mswjs/interceptors';

package/lib/core/ws/handleWebSocketEvent.d.ts

@@ -1,5 +1,5 @@
 import { WebSocketConnectionData } from '@mswjs/interceptors/WebSocket';
-import { R as RequestHandler } from '../HttpResponse-aGiIzO91.js';
+import { R as RequestHandler } from '../HttpResponse-BFS34nkx.js';
 import { WebSocketHandler } from '../handlers/WebSocketHandler.js';
 import { UnhandledRequestStrategy } from '../utils/request/onUnhandledRequest.js';
 import '@mswjs/interceptors';

package/lib/iife/index.js

@@ -14335,7 +14335,7 @@ ${operationTypes.join("\n")}
     );
   }
 
-  // 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;
@@ -14377,15 +14377,17 @@ ${operationTypes.join("\n")}
     }
     /**
     * 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.
@@ -14408,7 +14410,7 @@ ${operationTypes.join("\n")}
     }
   };
 
-  // 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 kDefaultPrevented = Symbol("kDefaultPrevented");
   var kPropagationStopped = Symbol("kPropagationStopped");
   var kImmediatePropagationStopped = Symbol("kImmediatePropagationStopped");
@@ -14441,37 +14443,66 @@ ${operationTypes.join("\n")}
   var Emitter = 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.
     */
@@ -14573,8 +14604,8 @@ ${operationTypes.join("\n")}
     */
     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.
@@ -14582,11 +14613,12 @@ ${operationTypes.join("\n")}
     */
     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.
@@ -14605,15 +14637,23 @@ ${operationTypes.join("\n")}
       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) {
@@ -14630,22 +14670,27 @@ ${operationTypes.join("\n")}
       };
     }
     #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);
@@ -16121,7 +16166,9 @@ ${operationTypes.join("\n")}
     resolver;
     resolverIterator;
     resolverIteratorResult;
+    resolverIteratorCleanups;
     options;
+    scheduledCleanups;
     info;
     /**
      * Indicates whether this request handler has been used
@@ -16131,6 +16178,7 @@ ${operationTypes.join("\n")}
     constructor(args) {
       this.resolver = args.resolver;
       this.options = args.options;
+      this.scheduledCleanups = /* @__PURE__ */ new Map();
       const callFrame = getCallFrame(new Error());
       this.info = {
         ...args.info,
@@ -16145,9 +16193,11 @@ ${operationTypes.join("\n")}
      * from a clean state.
      */
     reset() {
+      this.scheduledCleanups.clear();
       const iterator = this.resolverIterator;
       this.resolverIterator = void 0;
       this.resolverIteratorResult = void 0;
+      this.resolverIteratorCleanups = void 0;
       if (typeof iterator?.return === "function") {
         void Promise.resolve(iterator.return());
       }
@@ -16233,8 +16283,20 @@ ${operationTypes.join("\n")}
         request: args.request,
         parsedResult
       });
+      const listenerController = new AbortController();
+      args.request.signal.addEventListener(
+        "abort",
+        () => this.runScheduledCleanups(args.requestId),
+        {
+          once: true,
+          signal: listenerController.signal
+        }
+      );
       const mockedResponsePromise = executeResolver({
         ...resolverExtras,
+        finalize: (callback) => {
+          this.scheduleCleanup(args.requestId, callback);
+        },
         requestId: args.requestId,
         request: args.request
       }).catch((errorOrResponse) => {
@@ -16242,6 +16304,8 @@ ${operationTypes.join("\n")}
           return errorOrResponse;
         }
         throw errorOrResponse;
+      }).finally(() => {
+        listenerController.abort();
       });
       const mockedResponse = await mockedResponsePromise;
       if (mockedResponse) {
@@ -16260,10 +16324,22 @@ ${operationTypes.join("\n")}
     wrapResolver(resolver) {
       return async (info) => {
         if (!this.resolverIterator) {
-          const result = await resolver(info);
+          let result;
+          try {
+            result = await resolver(info);
+          } catch (error3) {
+            await this.runScheduledCleanups(info.requestId);
+            throw error3;
+          }
           if (!isIterable(result)) {
+            await this.runScheduledCleanups(info.requestId);
             return result;
           }
+          const existingCleanups = this.scheduledCleanups.get(info.requestId);
+          if (existingCleanups != null && existingCleanups.length > 0) {
+            this.resolverIteratorCleanups = existingCleanups;
+            this.scheduledCleanups.delete(info.requestId);
+          }
           this.resolverIterator = Symbol.iterator in result ? result[Symbol.iterator]() : result[Symbol.asyncIterator]();
         }
         this.isUsed = false;
@@ -16274,6 +16350,7 @@ ${operationTypes.join("\n")}
         }
         if (done) {
           this.isUsed = true;
+          await this.runScheduledCleanups(info.requestId);
           return this.resolverIteratorResult?.clone();
         }
         return nextResponse;
@@ -16288,6 +16365,54 @@ ${operationTypes.join("\n")}
         parsedResult: args.parsedResult
       };
     }
+    scheduleCleanup(requestId, callback) {
+      if (this.resolverIterator) {
+        ;
+        (this.resolverIteratorCleanups ||= []).unshift(callback);
+        return;
+      }
+      const cleanups = this.scheduledCleanups.get(requestId) || [];
+      cleanups.unshift(callback);
+      this.scheduledCleanups.set(requestId, cleanups);
+    }
+    async exhaustCleanups(cleanups) {
+      const errors = [];
+      for (const cleanup of cleanups) {
+        try {
+          await cleanup();
+        } catch (error3) {
+          if (error3 instanceof Error) {
+            errors.push(error3);
+          }
+        }
+      }
+      if (errors.length > 0) {
+        devUtils.error(
+          'Failed to execute cleanup for request handler "%s"',
+          this.info.header,
+          new AggregateError(
+            errors,
+            `Failed to execute cleanup for request handler "${this.info.header}"`
+          )
+        );
+      }
+    }
+    async runScheduledCleanups(requestId) {
+      if (this.resolverIterator && this.resolverIteratorCleanups != null && this.resolverIteratorCleanups.length > 0) {
+        try {
+          await this.exhaustCleanups(this.resolverIteratorCleanups);
+        } finally {
+          this.resolverIteratorCleanups = void 0;
+        }
+        return;
+      }
+      const cleanups = this.scheduledCleanups.get(requestId);
+      if (!cleanups || cleanups.length == 0) {
+        return;
+      }
+      await this.exhaustCleanups(cleanups);
+      this.scheduledCleanups.delete(requestId);
+    }
   };
   function forwardResponseCookies(response) {
     if (typeof document === "undefined") {
@@ -22937,16 +23062,20 @@ Read more: https://mswjs.io/docs/websocket`;
         return;
       }
       queueMicrotask(() => {
-        httpFrame.events.emit(
-          new ResponseEvent(
-            isMockedResponse ? "response:mocked" : "response:bypass",
-            {
-              requestId,
-              request,
-              response
-            }
-          )
-        );
+        try {
+          httpFrame.events.emit(
+            new ResponseEvent(
+              isMockedResponse ? "response:mocked" : "response:bypass",
+              {
+                requestId,
+                request,
+                response
+              }
+            )
+          );
+        } finally {
+          httpFrame.events.removeAllListeners();
+        }
       });
     }
     async #handleWebSocketConnection(connection) {
@@ -23439,11 +23568,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;
@@ -23467,17 +23597,21 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
           url: request.url
         }
       );
-      frame.events.emit(
-        new ResponseEvent(
-          isMockedResponse ? "response:mocked" : "response:bypass",
-          {
-            requestId: frame.data.id,
-            request: fetchRequest,
-            response: fetchResponse,
-            isMockedResponse
-          }
-        )
-      );
+      try {
+        frame.events.emit(
+          new 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;