msw 2.14.7 → 2.15.0

package/lib/iife/index.js

@@ -19062,6 +19062,18 @@ ${operationTypes.join("\n")}
   function getRawSetCookie(response) {
     return Reflect.get(response, kSetCookie);
   }
+  function copyResponseOwnProperties(source, target) {
+    for (const propertyName of Reflect.ownKeys(source)) {
+      const descriptor = Object.getOwnPropertyDescriptor(source, propertyName);
+      const existingDescriptor = Object.getOwnPropertyDescriptor(
+        target,
+        propertyName
+      );
+      if (descriptor && existingDescriptor == null) {
+        Object.defineProperty(target, propertyName, descriptor);
+      }
+    }
+  }
 
   // src/core/HttpResponse.ts
   var bodyType = /* @__PURE__ */ Symbol("bodyType");
@@ -19213,6 +19225,111 @@ ${operationTypes.join("\n")}
     }
   };
 
+  // node_modules/.pnpm/@open-draft+deferred-promise@3.0.0/node_modules/@open-draft/deferred-promise/build/index.mjs
+  function createDeferredExecutor2() {
+    const executor = ((resolve, reject) => {
+      executor.state = "pending";
+      executor.resolve = (data) => {
+        if (executor.state !== "pending") return;
+        executor.result = data;
+        const onFulfilled = (value) => {
+          executor.state = "fulfilled";
+          return value;
+        };
+        return resolve(data instanceof Promise ? data : Promise.resolve(data).then(onFulfilled));
+      };
+      executor.reject = (reason) => {
+        if (executor.state !== "pending") return;
+        queueMicrotask(() => {
+          executor.state = "rejected";
+        });
+        return reject(executor.rejectionReason = reason);
+      };
+    });
+    return executor;
+  }
+  var DeferredPromise2 = class extends Promise {
+    #executor;
+    resolve;
+    reject;
+    constructor(executor = null) {
+      const deferredExecutor = createDeferredExecutor2();
+      super((originalResolve, originalReject) => {
+        deferredExecutor(originalResolve, originalReject);
+        executor?.(deferredExecutor.resolve, deferredExecutor.reject);
+      });
+      this.#executor = deferredExecutor;
+      this.resolve = this.#executor.resolve;
+      this.reject = this.#executor.reject;
+    }
+    get state() {
+      return this.#executor.state;
+    }
+    get rejectionReason() {
+      return this.#executor.rejectionReason;
+    }
+    then(onFulfilled, onRejected) {
+      return this.#decorate(super.then(onFulfilled, onRejected));
+    }
+    catch(onRejected) {
+      return this.#decorate(super.catch(onRejected));
+    }
+    finally(onfinally) {
+      return this.#decorate(super.finally(onfinally));
+    }
+    #decorate(promise) {
+      return Object.defineProperties(promise, {
+        resolve: {
+          configurable: true,
+          value: this.resolve
+        },
+        reject: {
+          configurable: true,
+          value: this.reject
+        }
+      });
+    }
+  };
+
+  // src/core/utils/internal/observe-response-body-stream.ts
+  function observeResponseBodyStream(response) {
+    if (response.body == null || response.bodyUsed || response.body.locked) {
+      return null;
+    }
+    const settled = new DeferredPromise2();
+    const reader = response.body.getReader();
+    const observedStream = new ReadableStream({
+      async pull(controller) {
+        try {
+          const readResult = await reader.read();
+          if (readResult.done) {
+            settled.resolve();
+            controller.close();
+            return;
+          }
+          controller.enqueue(readResult.value);
+        } catch (error3) {
+          settled.resolve();
+          throw error3;
+        }
+      },
+      async cancel(reason) {
+        settled.resolve();
+        await reader.cancel(reason);
+      }
+    });
+    const observedResponse = new FetchResponse(observedStream, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    copyResponseOwnProperties(response, observedResponse);
+    return {
+      response: observedResponse,
+      settled
+    };
+  }
+
   // src/core/handlers/RequestHandler.ts
   var RequestHandler = class _RequestHandler {
     static cache = /* @__PURE__ */ new WeakMap();
@@ -19338,18 +19455,32 @@ ${operationTypes.join("\n")}
         parsedResult
       });
       const listenerController = new AbortController();
-      args.request.signal.addEventListener(
-        "abort",
-        () => this.runScheduledCleanups(args.requestId),
-        {
-          once: true,
-          signal: listenerController.signal
+      let finalizeFunction;
+      const getFinalize = () => {
+        if (finalizeFunction == null) {
+          if (!args.request.signal.aborted) {
+            args.request.signal.addEventListener(
+              "abort",
+              () => this.runScheduledCleanups(args.requestId),
+              {
+                once: true,
+                signal: listenerController.signal
+              }
+            );
+          }
+          finalizeFunction = (callback) => {
+            this.scheduleCleanup(args.requestId, callback);
+            if (args.request.signal.aborted) {
+              void this.runScheduledCleanups(args.requestId);
+            }
+          };
         }
-      );
+        return finalizeFunction;
+      };
       const mockedResponsePromise = executeResolver({
         ...resolverExtras,
-        finalize: (callback) => {
-          this.scheduleCleanup(args.requestId, callback);
+        get finalize() {
+          return getFinalize();
         },
         requestId: args.requestId,
         request: args.request
@@ -19386,8 +19517,11 @@ ${operationTypes.join("\n")}
             throw error3;
           }
           if (!isIterable(result)) {
-            await this.runScheduledCleanups(info.requestId);
-            return result;
+            return this.complete({
+              request: info.request,
+              requestId: info.requestId,
+              response: result
+            });
           }
           const existingCleanups = this.scheduledCleanups.get(info.requestId);
           if (existingCleanups != null && existingCleanups.length > 0) {
@@ -19404,8 +19538,11 @@ ${operationTypes.join("\n")}
         }
         if (done) {
           this.isUsed = true;
-          await this.runScheduledCleanups(info.requestId);
-          return this.resolverIteratorResult?.clone();
+          return this.complete({
+            request: info.request,
+            requestId: info.requestId,
+            response: this.resolverIteratorResult?.clone()
+          });
         }
         return nextResponse;
       };
@@ -19451,21 +19588,65 @@ ${operationTypes.join("\n")}
         );
       }
     }
-    async runScheduledCleanups(requestId) {
+    /**
+     * Remove and return the cleanups scheduled for the given request
+     * (or the pending iterator cleanups for generator resolvers).
+     */
+    takeScheduledCleanups(requestId) {
       if (this.resolverIterator && this.resolverIteratorCleanups != null && this.resolverIteratorCleanups.length > 0) {
-        try {
-          await this.exhaustCleanups(this.resolverIteratorCleanups);
-        } finally {
-          this.resolverIteratorCleanups = void 0;
-        }
-        return;
+        const cleanups2 = this.resolverIteratorCleanups;
+        this.resolverIteratorCleanups = void 0;
+        return cleanups2;
       }
       const cleanups = this.scheduledCleanups.get(requestId);
-      if (!cleanups || cleanups.length == 0) {
-        return;
+      if (!cleanups || cleanups.length === 0) {
+        return void 0;
       }
-      await this.exhaustCleanups(cleanups);
       this.scheduledCleanups.delete(requestId);
+      return cleanups;
+    }
+    async runScheduledCleanups(requestId) {
+      const cleanups = this.takeScheduledCleanups(requestId);
+      if (cleanups) {
+        await this.exhaustCleanups(cleanups);
+      }
+    }
+    /**
+     * Conclude the response resolution for the given request.
+     * Runs the scheduled cleanups immediately for responses without a
+     * `ReadableStream` body. For streamed responses, returns an observed
+     * copy of the response and defers the cleanups until its body settles
+     * (is read to completion, errored, or canceled) or the request is
+     * aborted, whichever comes first.
+     */
+    async complete(args) {
+      const cleanups = this.takeScheduledCleanups(args.requestId);
+      if (!cleanups) {
+        return args.response;
+      }
+      const observedResponse = args.response ? observeResponseBodyStream(args.response) : null;
+      if (!observedResponse) {
+        await this.exhaustCleanups(cleanups);
+        return args.response;
+      }
+      const listenerController = new AbortController();
+      const runCleanupsOnce = () => {
+        if (listenerController.signal.aborted) {
+          return;
+        }
+        listenerController.abort();
+        void this.exhaustCleanups(cleanups);
+      };
+      void observedResponse.settled.then(runCleanupsOnce);
+      if (args.request.signal.aborted) {
+        runCleanupsOnce();
+      } else {
+        args.request.signal.addEventListener("abort", runCleanupsOnce, {
+          once: true,
+          signal: listenerController.signal
+        });
+      }
+      return observedResponse.response;
     }
   };
   function forwardResponseCookies(response) {
@@ -24181,72 +24362,6 @@ Consider naming this operation or using "graphql.operation()" request handler to
     }
   };
 
-  // node_modules/.pnpm/@open-draft+deferred-promise@3.0.0/node_modules/@open-draft/deferred-promise/build/index.mjs
-  function createDeferredExecutor2() {
-    const executor = ((resolve, reject) => {
-      executor.state = "pending";
-      executor.resolve = (data) => {
-        if (executor.state !== "pending") return;
-        executor.result = data;
-        const onFulfilled = (value) => {
-          executor.state = "fulfilled";
-          return value;
-        };
-        return resolve(data instanceof Promise ? data : Promise.resolve(data).then(onFulfilled));
-      };
-      executor.reject = (reason) => {
-        if (executor.state !== "pending") return;
-        queueMicrotask(() => {
-          executor.state = "rejected";
-        });
-        return reject(executor.rejectionReason = reason);
-      };
-    });
-    return executor;
-  }
-  var DeferredPromise2 = class extends Promise {
-    #executor;
-    resolve;
-    reject;
-    constructor(executor = null) {
-      const deferredExecutor = createDeferredExecutor2();
-      super((originalResolve, originalReject) => {
-        deferredExecutor(originalResolve, originalReject);
-        executor?.(deferredExecutor.resolve, deferredExecutor.reject);
-      });
-      this.#executor = deferredExecutor;
-      this.resolve = this.#executor.resolve;
-      this.reject = this.#executor.reject;
-    }
-    get state() {
-      return this.#executor.state;
-    }
-    get rejectionReason() {
-      return this.#executor.rejectionReason;
-    }
-    then(onFulfilled, onRejected) {
-      return this.#decorate(super.then(onFulfilled, onRejected));
-    }
-    catch(onRejected) {
-      return this.#decorate(super.catch(onRejected));
-    }
-    finally(onfinally) {
-      return this.#decorate(super.finally(onfinally));
-    }
-    #decorate(promise) {
-      return Object.defineProperties(promise, {
-        resolve: {
-          configurable: true,
-          value: this.resolve
-        },
-        reject: {
-          configurable: true,
-          value: this.reject
-        }
-      });
-    }
-  };
-
   // src/core/ws/WebSocketIndexedDBClientStore.ts
   var DB_NAME = "msw-websocket-clients";
   var DB_STORE_NAME = "clients";
@@ -24628,16 +24743,17 @@ Consider naming this operation or using "graphql.operation()" request handler to
         const { client, server, response } = createEventStream(
           info.request
         );
-        const emitter = new Emitter2();
+        const emitter = new Emitter();
         client[kClientEmitter] = emitter;
         if (this.#loggableRequests.has(info.request)) {
           this.#attachClientLogger(info.request, emitter);
         }
-        await resolver({
-          ...info,
-          client,
-          server
-        });
+        await resolver(
+          Object.assign(info, {
+            client,
+            server
+          })
+        );
         return response;
       });
       this.#loggableRequests = /* @__PURE__ */ new WeakSet();
@@ -24660,21 +24776,20 @@ Consider naming this operation or using "graphql.operation()" request handler to
       }
       return matches;
     }
-    async log(_args) {
+    async log(args) {
+      args.response.body?.cancel();
       return;
     }
     #attachClientLogger(request, emitter) {
       const publicUrl = toPublicUrl(request.url);
-      emitter.on("message", (payload) => {
+      emitter.on("message", ({ data }) => {
         console.groupCollapsed(
-          devUtils.formatMessage(
-            `${getTimestamp()} SSE %s %c\u21E3%c ${payload.event}`
-          ),
+          devUtils.formatMessage(`${getTimestamp()} SSE %s %c\u21E3%c ${data.event}`),
           publicUrl,
           `color:${colors.mocked}`,
           "color:inherit"
         );
-        console.log(payload.frames);
+        console.log(data.frames);
         console.groupEnd();
       });
       emitter.on("error", () => {
@@ -24703,10 +24818,12 @@ Consider naming this operation or using "graphql.operation()" request handler to
   var ServerSentEventClient = class {
     [kClientEmitter];
     #encoder;
-    #writer;
-    constructor(writable) {
+    #controller;
+    #closed;
+    constructor(controller) {
       this.#encoder = new TextEncoder();
-      this.#writer = writable.getWriter();
+      this.#controller = controller;
+      this.#closed = new DeferredPromise2();
     }
     /**
      * Sends the given payload to the intercepted `EventSource`.
@@ -24749,35 +24866,44 @@ Consider naming this operation or using "graphql.operation()" request handler to
      * error.
      */
     error() {
-      this.#writer.abort().catch((error3) => {
-        console.error(error3);
-        devUtils.error(
-          "Failed to abort server-side EventSource. Please see the original error above."
-        );
-      });
-      this[kClientEmitter]?.emit("error");
+      if (this.#closed.state !== "pending") {
+        return;
+      }
+      this.#controller.error();
+      this.#closed.resolve();
+      this[kClientEmitter]?.emit(new TypedEvent("error"));
     }
     /**
      * Closes the underlying `EventSource`, closing the connection.
      */
     close() {
-      this.#writer.close().catch((error3) => {
+      if (this.#closed.state !== "pending") {
+        return;
+      }
+      try {
+        this.#controller.close();
+        this.#closed.resolve();
+      } catch {
+      }
+      this[kClientEmitter]?.emit(new TypedEvent("close"));
+    }
+    #enqueue(chunk) {
+      if (this.#closed.state !== "pending") {
+        return;
+      }
+      try {
+        this.#controller.enqueue(chunk);
+      } catch (error3) {
         console.error(error3);
         devUtils.error(
-          "Failed to close server-side EventSource. Please see the original error above."
+          "Failed to write to server-side EventSource. Please see the original error above."
         );
-      });
-      this[kClientEmitter]?.emit("close");
+      }
     }
     #sendRetry(retry) {
-      this.#writer.write(this.#encoder.encode(`retry:${retry}
+      this.#enqueue(this.#encoder.encode(`retry:${retry}
 
-`)).catch((error3) => {
-        console.error(error3);
-        devUtils.error(
-          "Failed to send a retry packet to server-side EventSource. Please see the original error above."
-        );
-      });
+`));
     }
     #sendMessage(message4) {
       const frames = [];
@@ -24793,18 +24919,17 @@ Consider naming this operation or using "graphql.operation()" request handler to
         }
       }
       frames.push("", "");
-      this.#writer.write(this.#encoder.encode(frames.join("\n"))).catch((error3) => {
-        console.error(error3);
-        devUtils.error(
-          "Failed to send a message to server-side EventSource. Please see the original error above."
-        );
-      });
-      this[kClientEmitter]?.emit("message", {
-        id: message4.id,
-        event: message4.event?.toString() || "message",
-        data: message4.data,
-        frames
-      });
+      this.#enqueue(this.#encoder.encode(frames.join("\n")));
+      this[kClientEmitter]?.emit(
+        new TypedEvent("message", {
+          data: {
+            id: message4.id,
+            event: message4.event?.toString() || "message",
+            data: message4.data,
+            frames
+          }
+        })
+      );
     }
   };
   var ServerSentEventServer = class {
@@ -25218,8 +25343,16 @@ Consider naming this operation or using "graphql.operation()" request handler to
       request.method,
       request.url
     );
-    const { readable, writable } = new TransformStream();
-    const client = new ServerSentEventClient(writable);
+    let controller;
+    const readable = new ReadableStream({
+      start(defaultController) {
+        controller = defaultController;
+      },
+      cancel() {
+        client.close();
+      }
+    });
+    const client = new ServerSentEventClient(controller);
     const server = new ServerSentEventServer({
       request,
       client
@@ -27098,7 +27231,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       this.#channel.postMessage("INTEGRITY_CHECK_REQUEST");
       this.#channel.once("INTEGRITY_CHECK_RESPONSE", (event) => {
         const { checksum, packageVersion } = event.data;
-        if (checksum !== "4db4a41e972cec1b64cc569c66952d82") {
+        if (checksum !== "03cb67ac84128e63d7cd722a6e5b7f1e") {
           devUtils.warn(
             `The currently registered Service Worker has been generated by a different version of MSW (${packageVersion}) and may not be fully compatible with the installed version.