@mswjs/interceptors 0.22.4 → 0.22.5

package/lib/browser/chunk-GL6Y4E24.mjs

@@ -0,0 +1,106 @@
+import {
+  toInteractiveRequest,
+  uuidv4
+} from "./chunk-RT3ATOJH.mjs";
+import {
+  IS_PATCHED_MODULE,
+  Interceptor
+} from "./chunk-2GVXYEMC.mjs";
+
+// src/interceptors/fetch/index.ts
+import { invariant } from "outvariant";
+import { until } from "@open-draft/until";
+var _FetchInterceptor = class extends Interceptor {
+  constructor() {
+    super(_FetchInterceptor.symbol);
+  }
+  checkEnvironment() {
+    return typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined";
+  }
+  setup() {
+    const pureFetch = globalThis.fetch;
+    invariant(
+      !pureFetch[IS_PATCHED_MODULE],
+      'Failed to patch the "fetch" module: already patched.'
+    );
+    globalThis.fetch = async (input, init) => {
+      const requestId = uuidv4();
+      const request = new Request(input, init);
+      this.log("[%s] %s", request.method, request.url);
+      const interactiveRequest = toInteractiveRequest(request);
+      this.log(
+        'emitting the "request" event for %d listener(s)...',
+        this.emitter.listenerCount("request")
+      );
+      this.emitter.emit("request", interactiveRequest, requestId);
+      this.log("awaiting for the mocked response...");
+      const [middlewareException, mockedResponse] = await until(async () => {
+        await this.emitter.untilIdle(
+          "request",
+          ({ args: [, pendingRequestId] }) => {
+            return pendingRequestId === requestId;
+          }
+        );
+        this.log("all request listeners have been resolved!");
+        const [mockedResponse2] = await interactiveRequest.respondWith.invoked();
+        this.log("event.respondWith called with:", mockedResponse2);
+        return mockedResponse2;
+      });
+      if (middlewareException) {
+        console.error(`${request.method} ${request.url} net::ERR_FAILED`);
+        const error = Object.assign(new TypeError("Failed to fetch"), {
+          cause: middlewareException
+        });
+        return Promise.reject(error);
+      }
+      if (mockedResponse) {
+        this.log("received mocked response:", mockedResponse);
+        const responseCloine = mockedResponse.clone();
+        this.emitter.emit(
+          "response",
+          responseCloine,
+          interactiveRequest,
+          requestId
+        );
+        const response = new Response(mockedResponse.body, mockedResponse);
+        Object.defineProperty(response, "url", {
+          writable: false,
+          enumerable: true,
+          configurable: false,
+          value: request.url
+        });
+        return response;
+      }
+      this.log("no mocked response received!");
+      return pureFetch(request).then((response) => {
+        const responseClone = response.clone();
+        this.log("original fetch performed", responseClone);
+        this.emitter.emit(
+          "response",
+          responseClone,
+          interactiveRequest,
+          requestId
+        );
+        return response;
+      });
+    };
+    Object.defineProperty(globalThis.fetch, IS_PATCHED_MODULE, {
+      enumerable: true,
+      configurable: true,
+      value: true
+    });
+    this.subscriptions.push(() => {
+      Object.defineProperty(globalThis.fetch, IS_PATCHED_MODULE, {
+        value: void 0
+      });
+      globalThis.fetch = pureFetch;
+      this.log('restored native "globalThis.fetch"!', globalThis.fetch.name);
+    });
+  }
+};
+var FetchInterceptor = _FetchInterceptor;
+FetchInterceptor.symbol = Symbol("fetch");
+
+export {
+  FetchInterceptor
+};