@mswjs/interceptors 0.20.0 → 0.21.1

package/lib/node/chunk-CIN5URNI.mjs

@@ -0,0 +1,29 @@
+import {
+  __require
+} from "./chunk-ZSI7MX3V.mjs";
+
+// src/shims/webEncoding.ts
+var TextEncoder = typeof globalThis.TextEncoder === "undefined" ? __require("util").TextEncoder : globalThis.TextEncoder;
+var TextDecoder = typeof globalThis.TextDecoder === "undefined" ? __require("util").TextDecoder : globalThis.TextDecoder;
+
+// src/utils/bufferUtils.ts
+var encoder = new TextEncoder();
+function encodeBuffer(text) {
+  return encoder.encode(text);
+}
+function decodeBuffer(buffer, encoding) {
+  const decoder = new TextDecoder(encoding);
+  return decoder.decode(buffer);
+}
+function toArrayBuffer(array) {
+  return array.buffer.slice(
+    array.byteOffset,
+    array.byteOffset + array.byteLength
+  );
+}
+
+export {
+  encodeBuffer,
+  decodeBuffer,
+  toArrayBuffer
+};

package/lib/node/chunk-GFH37L5D.mjs

@@ -0,0 +1,6 @@
+// src/glossary.ts
+var IS_PATCHED_MODULE = Symbol("isPatchedModule");
+
+export {
+  IS_PATCHED_MODULE
+};

package/lib/node/chunk-HDUJCCWF.js

@@ -0,0 +1,661 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunk6GWWOJ23js = require('./chunk-6GWWOJ23.js');
+
+
+
+
+var _chunk6V3JXLBFjs = require('./chunk-6V3JXLBF.js');
+
+
+var _chunkVQ4DZOBBjs = require('./chunk-VQ4DZOBB.js');
+
+
+
+var _chunkZJOF5MEZjs = require('./chunk-ZJOF5MEZ.js');
+
+
+var _chunkQMIXLBOUjs = require('./chunk-QMIXLBOU.js');
+
+// src/interceptors/XMLHttpRequest/index.ts
+var _outvariant = require('outvariant');
+
+// src/interceptors/XMLHttpRequest/XMLHttpRequestProxy.ts
+var _until = require('@open-draft/until');
+
+// src/interceptors/XMLHttpRequest/XMLHttpRequestController.ts
+var _headerspolyfill = require('headers-polyfill');
+
+// src/interceptors/XMLHttpRequest/utils/concatArrayBuffer.ts
+function concatArrayBuffer(left, right) {
+  const result = new Uint8Array(left.byteLength + right.byteLength);
+  result.set(left, 0);
+  result.set(right, left.byteLength);
+  return result;
+}
+
+// src/interceptors/XMLHttpRequest/polyfills/EventPolyfill.ts
+var EventPolyfill = class {
+  constructor(type, options) {
+    this.AT_TARGET = 0;
+    this.BUBBLING_PHASE = 0;
+    this.CAPTURING_PHASE = 0;
+    this.NONE = 0;
+    this.type = "";
+    this.srcElement = null;
+    this.currentTarget = null;
+    this.eventPhase = 0;
+    this.isTrusted = true;
+    this.composed = false;
+    this.cancelable = true;
+    this.defaultPrevented = false;
+    this.bubbles = true;
+    this.lengthComputable = true;
+    this.loaded = 0;
+    this.total = 0;
+    this.cancelBubble = false;
+    this.returnValue = true;
+    this.type = type;
+    this.target = (options == null ? void 0 : options.target) || null;
+    this.currentTarget = (options == null ? void 0 : options.currentTarget) || null;
+    this.timeStamp = Date.now();
+  }
+  composedPath() {
+    return [];
+  }
+  initEvent(type, bubbles, cancelable) {
+    this.type = type;
+    this.bubbles = !!bubbles;
+    this.cancelable = !!cancelable;
+  }
+  preventDefault() {
+    this.defaultPrevented = true;
+  }
+  stopPropagation() {
+  }
+  stopImmediatePropagation() {
+  }
+};
+
+// src/interceptors/XMLHttpRequest/polyfills/ProgressEventPolyfill.ts
+var ProgressEventPolyfill = class extends EventPolyfill {
+  constructor(type, init) {
+    super(type);
+    this.lengthComputable = (init == null ? void 0 : init.lengthComputable) || false;
+    this.composed = (init == null ? void 0 : init.composed) || false;
+    this.loaded = (init == null ? void 0 : init.loaded) || 0;
+    this.total = (init == null ? void 0 : init.total) || 0;
+  }
+};
+
+// src/interceptors/XMLHttpRequest/utils/createEvent.ts
+var SUPPORTS_PROGRESS_EVENT = typeof ProgressEvent !== "undefined";
+function createEvent(target, type, init) {
+  const progressEvents = [
+    "error",
+    "progress",
+    "loadstart",
+    "loadend",
+    "load",
+    "timeout",
+    "abort"
+  ];
+  const ProgressEventClass = SUPPORTS_PROGRESS_EVENT ? ProgressEvent : ProgressEventPolyfill;
+  const event = progressEvents.includes(type) ? new ProgressEventClass(type, {
+    lengthComputable: true,
+    loaded: (init == null ? void 0 : init.loaded) || 0,
+    total: (init == null ? void 0 : init.total) || 0
+  }) : new EventPolyfill(type, {
+    target,
+    currentTarget: target
+  });
+  return event;
+}
+
+// src/utils/createProxy.ts
+function createProxy(target, options) {
+  const proxy = new Proxy(target, optionsToProxyHandler(options));
+  return proxy;
+}
+function optionsToProxyHandler(options) {
+  const { constructorCall, methodCall, getProperty, setProperty } = options;
+  const handler = {};
+  if (typeof constructorCall !== "undefined") {
+    handler.construct = function(target, args, newTarget) {
+      const next = Reflect.construct.bind(null, target, args, newTarget);
+      return constructorCall.call(newTarget, args, next);
+    };
+  }
+  if (typeof setProperty !== "undefined") {
+    handler.set = function(target, propertyName, nextValue, receiver) {
+      const next = () => Reflect.set(target, propertyName, nextValue, receiver);
+      return setProperty.call(target, [propertyName, nextValue], next);
+    };
+  }
+  handler.get = function(target, propertyName, receiver) {
+    const next = () => target[propertyName];
+    const value = typeof getProperty !== "undefined" ? getProperty.call(target, [propertyName, receiver], next) : next();
+    if (typeof value === "function") {
+      return (...args) => {
+        const next2 = value.bind(target, ...args);
+        if (typeof methodCall !== "undefined") {
+          return methodCall.call(target, [propertyName, args], next2);
+        }
+        return next2();
+      };
+    }
+    return value;
+  };
+  return handler;
+}
+
+// src/interceptors/XMLHttpRequest/utils/isDomParserSupportedType.ts
+function isDomParserSupportedType(type) {
+  const supportedTypes = [
+    "application/xhtml+xml",
+    "application/xml",
+    "image/svg+xml",
+    "text/html",
+    "text/xml"
+  ];
+  return supportedTypes.some((supportedType) => {
+    return type.startsWith(supportedType);
+  });
+}
+
+// src/utils/parseJson.ts
+function parseJson(data) {
+  try {
+    const json = JSON.parse(data);
+    return json;
+  } catch (_) {
+    return null;
+  }
+}
+
+// src/interceptors/XMLHttpRequest/utils/createResponse.ts
+
+function createResponse(request, responseBody) {
+  return new (0, _chunk6V3JXLBFjs.Response)(responseBody, {
+    status: request.status,
+    statusText: request.statusText,
+    headers: _headerspolyfill.stringToHeaders.call(void 0, request.getAllResponseHeaders())
+  });
+}
+
+// src/interceptors/XMLHttpRequest/XMLHttpRequestController.ts
+
+var XMLHttpRequestController = class {
+  constructor(initialRequest, log) {
+    this.initialRequest = initialRequest;
+    this.log = log;
+    this.method = "GET";
+    this.url = null;
+    this.events = /* @__PURE__ */ new Map();
+    this.requestHeaders = new (0, _chunk6V3JXLBFjs.Headers)();
+    this.responseBuffer = new Uint8Array();
+    this.request = createProxy(initialRequest, {
+      setProperty: ([propertyName, nextValue], invoke) => {
+        if (propertyName === "withCredentials") {
+          define(this.request, "withCredentials", nextValue);
+          return true;
+        }
+        return invoke();
+      },
+      methodCall: ([methodName, args], invoke) => {
+        var _a;
+        switch (methodName) {
+          case "open": {
+            const [method, url] = args;
+            this.requestId = _chunkZJOF5MEZjs.uuidv4.call(void 0, );
+            if (typeof url === "undefined") {
+              this.method = "GET";
+              this.url = toAbsoluteUrl(method);
+            } else {
+              this.method = method;
+              this.url = toAbsoluteUrl(url);
+            }
+            this.log = this.log.extend(`${this.method} ${this.url.href}`);
+            this.log("open", this.method, this.url.href);
+            return invoke();
+          }
+          case "addEventListener": {
+            const [eventName, listener] = args;
+            this.registerEvent(eventName, listener);
+            this.log("addEventListener", eventName, listener.name);
+            return invoke();
+          }
+          case "setRequestHeader": {
+            const [name, value] = args;
+            this.requestHeaders.set(name, value);
+            this.log("setRequestHeader", name, value);
+            return invoke();
+          }
+          case "send": {
+            const [body] = args;
+            if (body != null) {
+              this.requestBody = typeof body === "string" ? _chunk6GWWOJ23js.encodeBuffer.call(void 0, body) : body;
+            }
+            this.request.addEventListener("load", () => {
+              if (typeof this.onResponse !== "undefined") {
+                const fetchResponse = createResponse(
+                  this.request,
+                  this.request.response
+                );
+                this.onResponse.call(
+                  this,
+                  fetchResponse,
+                  fetchRequest,
+                  this.requestId
+                );
+              }
+            });
+            const fetchRequest = this.toFetchApiRequest();
+            const onceRequestSettled = ((_a = this.onRequest) == null ? void 0 : _a.call(this, fetchRequest, this.requestId)) || Promise.resolve();
+            onceRequestSettled.finally(() => {
+              if (this.request.readyState < this.request.LOADING) {
+                this.log(
+                  "request callback settled but request has not been handled (readystate %d), performing as-is...",
+                  this.request.readyState
+                );
+                this.request.setRequestHeader("X-Request-Id", this.requestId);
+                return invoke();
+              }
+            });
+            break;
+          }
+          case "onabort":
+          case "onerror":
+          case "onload":
+          case "onloadend":
+          case "onloadstart":
+          case "onprogress":
+          case "ontimeout":
+          case "onreadystatechange": {
+            const [listener] = args;
+            this.registerEvent(
+              methodName,
+              listener
+            );
+            return invoke();
+          }
+          default: {
+            return invoke();
+          }
+        }
+      }
+    });
+  }
+  registerEvent(eventName, listener) {
+    const prevEvents = this.events.get(eventName) || [];
+    const nextEvents = prevEvents.concat(listener);
+    this.events.set(eventName, nextEvents);
+    this.log('registered event "%s"', eventName, listener.name);
+  }
+  respondWith(response) {
+    this.log(
+      "responding with a mocked response: %d %s",
+      response.status,
+      response.statusText
+    );
+    define(this.request, "status", response.status);
+    define(this.request, "statusText", response.statusText);
+    define(this.request, "responseURL", this.url.href);
+    this.request.getResponseHeader = new Proxy(this.request.getResponseHeader, {
+      apply: (_, __, args) => {
+        this.log("getResponseHeader", args[0]);
+        if (this.request.readyState < this.request.HEADERS_RECEIVED) {
+          this.log("headers not received yet, returning null");
+          return null;
+        }
+        const headerValue = response.headers.get(args[0]);
+        this.log('resolved response header "%s" to', args[0], headerValue);
+        return headerValue;
+      }
+    });
+    this.request.getAllResponseHeaders = new Proxy(
+      this.request.getAllResponseHeaders,
+      {
+        apply: () => {
+          this.log("getAllResponseHeaders");
+          if (this.request.readyState < this.request.HEADERS_RECEIVED) {
+            this.log("headers not received yet, returning empty string");
+            return "";
+          }
+          const allHeaders = _headerspolyfill.headersToString.call(void 0, response.headers);
+          this.log("resolved all response headers to", allHeaders);
+          return allHeaders;
+        }
+      }
+    );
+    Object.defineProperties(this.request, {
+      response: {
+        enumerable: true,
+        get: () => this.response
+      },
+      responseText: {
+        enumerable: true,
+        get: () => this.responseText
+      },
+      responseXML: {
+        enumerable: true,
+        get: () => this.responseXML
+      }
+    });
+    const totalResponseBodyLength = response.headers.has("Content-Length") ? Number(response.headers.get("Content-Length")) : void 0;
+    this.log("calculated response body length", totalResponseBodyLength);
+    this.trigger("loadstart", {
+      loaded: 0,
+      total: totalResponseBodyLength
+    });
+    this.setReadyState(this.request.HEADERS_RECEIVED);
+    this.setReadyState(this.request.LOADING);
+    const finalizeResponse = () => {
+      this.log("finalizing the mocked response...");
+      this.setReadyState(this.request.DONE);
+      this.trigger("load", {
+        loaded: this.responseBuffer.byteLength,
+        total: totalResponseBodyLength
+      });
+      this.trigger("loadend", {
+        loaded: this.responseBuffer.byteLength,
+        total: totalResponseBodyLength
+      });
+    };
+    if (response.body) {
+      this.log("mocked response has body, streaming...");
+      const reader = response.body.getReader();
+      const readNextResponseBodyChunk = async () => {
+        const { value, done } = await reader.read();
+        if (done) {
+          this.log("response body stream done!");
+          finalizeResponse();
+          return;
+        }
+        if (value) {
+          this.log("read response body chunk:", value);
+          this.responseBuffer = concatArrayBuffer(this.responseBuffer, value);
+          this.trigger("progress", {
+            loaded: this.responseBuffer.byteLength,
+            total: totalResponseBodyLength
+          });
+        }
+        readNextResponseBodyChunk();
+      };
+      readNextResponseBodyChunk();
+    } else {
+      finalizeResponse();
+    }
+  }
+  responseBufferToText() {
+    return _chunk6GWWOJ23js.decodeBuffer.call(void 0, this.responseBuffer);
+  }
+  get response() {
+    this.log("getResponse (responseType: %s)", this.request.responseType);
+    if (this.request.readyState !== this.request.DONE) {
+      return null;
+    }
+    switch (this.request.responseType) {
+      case "json": {
+        const responseJson = parseJson(this.responseBufferToText());
+        this.log("resolved response JSON", responseJson);
+        return responseJson;
+      }
+      case "arraybuffer": {
+        const arrayBuffer = _chunk6GWWOJ23js.toArrayBuffer.call(void 0, this.responseBuffer);
+        this.log("resolved response ArrayBuffer", arrayBuffer);
+        return arrayBuffer;
+      }
+      case "blob": {
+        const mimeType = this.request.getResponseHeader("Content-Type") || "text/plain";
+        const responseBlob = new Blob([this.responseBufferToText()], {
+          type: mimeType
+        });
+        this.log(
+          "resolved response Blob (mime type: %s)",
+          responseBlob,
+          mimeType
+        );
+        return responseBlob;
+      }
+      default: {
+        const responseText = this.responseBufferToText();
+        this.log(
+          'resolving "%s" response type as text',
+          this.request.responseType,
+          responseText
+        );
+        return responseText;
+      }
+    }
+  }
+  get responseText() {
+    _outvariant.invariant.call(void 0, 
+      this.request.responseType === "" || this.request.responseType === "text",
+      "InvalidStateError: The object is in invalid state."
+    );
+    if (this.request.readyState !== this.request.LOADING && this.request.readyState !== this.request.DONE) {
+      return "";
+    }
+    const responseText = this.responseBufferToText();
+    this.log('getResponseText: "%s"', responseText);
+    return responseText;
+  }
+  get responseXML() {
+    _outvariant.invariant.call(void 0, 
+      this.request.responseType === "" || this.request.responseType === "document",
+      "InvalidStateError: The object is in invalid state."
+    );
+    if (this.request.readyState !== this.request.DONE) {
+      return null;
+    }
+    const contentType = this.request.getResponseHeader("Content-Type") || "";
+    if (typeof DOMParser === "undefined") {
+      console.warn(
+        "Cannot retrieve XMLHttpRequest response body as XML: DOMParser is not defined. You are likely using an environment that is not browser or does not polyfill browser globals correctly."
+      );
+      return null;
+    }
+    if (isDomParserSupportedType(contentType)) {
+      return new DOMParser().parseFromString(
+        this.responseBufferToText(),
+        contentType
+      );
+    }
+    return null;
+  }
+  errorWith(error) {
+    this.log("responding with an error");
+    this.setReadyState(this.request.DONE);
+    this.trigger("error");
+    this.trigger("loadend");
+  }
+  setReadyState(nextReadyState) {
+    this.log("setReadyState: %d -> %d", this.request.readyState, nextReadyState);
+    if (this.request.readyState === nextReadyState) {
+      this.log("ready state identical, skipping transition...");
+      return;
+    }
+    define(this.request, "readyState", nextReadyState);
+    this.log("set readyState to: %d", nextReadyState);
+    if (nextReadyState !== this.request.UNSENT) {
+      this.log('triggerring "readystatechange" event...');
+      this.trigger("readystatechange");
+    }
+  }
+  trigger(eventName, options) {
+    const callback = this.request[`on${eventName}`];
+    const event = createEvent(this.request, eventName, options);
+    this.log('trigger "%s"', eventName, options || "");
+    if (typeof callback === "function") {
+      this.log('found a direct "%s" callback, calling...', eventName);
+      callback.call(this.request, event);
+    }
+    for (const [registeredEventName, listeners] of this.events) {
+      if (registeredEventName === eventName) {
+        this.log(
+          'found %d listener(s) for "%s" event, calling...',
+          listeners.length,
+          eventName
+        );
+        listeners.forEach((listener) => listener.call(this.request, event));
+      }
+    }
+  }
+  toFetchApiRequest() {
+    this.log("converting request to a Fetch API Request...");
+    const fetchRequest = new (0, _chunk6V3JXLBFjs.Request)(this.url.href, {
+      method: this.method,
+      headers: this.requestHeaders,
+      credentials: this.request.withCredentials ? "include" : "same-origin",
+      body: this.requestBody
+    });
+    const proxyHeaders = createProxy(fetchRequest.headers, {
+      methodCall: ([methodName, args], invoke) => {
+        switch (methodName) {
+          case "append":
+          case "set": {
+            const [headerName, headerValue] = args;
+            this.request.setRequestHeader(headerName, headerValue);
+            break;
+          }
+          case "delete": {
+            const [headerName] = args;
+            console.warn(
+              `XMLHttpRequest: Cannot remove a "${headerName}" header from the Fetch API representation of the "${fetchRequest.method} ${fetchRequest.url}" request. XMLHttpRequest headers cannot be removed.`
+            );
+            break;
+          }
+        }
+        return invoke();
+      }
+    });
+    define(fetchRequest, "headers", proxyHeaders);
+    this.log("converted request to a Fetch API Request!", fetchRequest);
+    return fetchRequest;
+  }
+};
+function toAbsoluteUrl(url) {
+  return new URL(url.toString(), location.href);
+}
+function define(target, property, value) {
+  Reflect.defineProperty(target, property, {
+    writable: true,
+    enumerable: true,
+    value
+  });
+}
+
+// src/interceptors/XMLHttpRequest/XMLHttpRequestProxy.ts
+function createXMLHttpRequestProxy({
+  emitter,
+  log
+}) {
+  const XMLHttpRequestProxy = new Proxy(globalThis.XMLHttpRequest, {
+    construct(target, args) {
+      log("constructed new XMLHttpRequest");
+      const originalRequest = Reflect.construct(target, args);
+      const requestController = new XMLHttpRequestController(
+        originalRequest,
+        log
+      );
+      requestController.onRequest = async function(request, requestId) {
+        const interactiveRequest = _chunkZJOF5MEZjs.toInteractiveRequest.call(void 0, request);
+        this.log(
+          'emitting the "request" event for %s listener(s)...',
+          emitter.listenerCount("request")
+        );
+        emitter.emit("request", interactiveRequest, requestId);
+        this.log("awaiting mocked response...");
+        const [middlewareException, mockedResponse] = await _until.until.call(void 0, async () => {
+          await emitter.untilIdle(
+            "request",
+            ({ args: [, pendingRequestId] }) => {
+              return pendingRequestId === requestId;
+            }
+          );
+          this.log('all "request" listeners settled!');
+          const [mockedResponse2] = await interactiveRequest.respondWith.invoked();
+          this.log("event.respondWith called with:", mockedResponse2);
+          return mockedResponse2;
+        });
+        if (middlewareException) {
+          this.log(
+            "request listener threw an exception, aborting request...",
+            middlewareException
+          );
+          requestController.errorWith(middlewareException);
+          return;
+        }
+        if (typeof mockedResponse !== "undefined") {
+          this.log(
+            "received mocked response: %d %s",
+            mockedResponse.status,
+            mockedResponse.statusText
+          );
+          return requestController.respondWith(mockedResponse);
+        }
+        this.log("no mocked response received, performing request as-is...");
+      };
+      requestController.onResponse = async function(response, request, requestId) {
+        this.log(
+          'emitting the "response" event for %s listener(s)...',
+          emitter.listenerCount("response")
+        );
+        emitter.emit("response", response, request, requestId);
+      };
+      return requestController.request;
+    }
+  });
+  return XMLHttpRequestProxy;
+}
+
+// src/interceptors/XMLHttpRequest/index.ts
+var _XMLHttpRequestInterceptor = class extends _chunkQMIXLBOUjs.Interceptor {
+  constructor() {
+    super(_XMLHttpRequestInterceptor.symbol);
+  }
+  checkEnvironment() {
+    return typeof globalThis.XMLHttpRequest !== "undefined";
+  }
+  setup() {
+    const log = this.log.extend("setup");
+    log('patching "XMLHttpRequest" module...');
+    const PureXMLHttpRequest = globalThis.XMLHttpRequest;
+    _outvariant.invariant.call(void 0, 
+      !PureXMLHttpRequest[_chunkVQ4DZOBBjs.IS_PATCHED_MODULE],
+      'Failed to patch the "XMLHttpRequest" module: already patched.'
+    );
+    globalThis.XMLHttpRequest = createXMLHttpRequestProxy({
+      emitter: this.emitter,
+      log: this.log
+    });
+    log(
+      'native "XMLHttpRequest" module patched!',
+      globalThis.XMLHttpRequest.name
+    );
+    Object.defineProperty(globalThis.XMLHttpRequest, _chunkVQ4DZOBBjs.IS_PATCHED_MODULE, {
+      enumerable: true,
+      configurable: true,
+      value: true
+    });
+    this.subscriptions.push(() => {
+      Object.defineProperty(globalThis.XMLHttpRequest, _chunkVQ4DZOBBjs.IS_PATCHED_MODULE, {
+        value: void 0
+      });
+      globalThis.XMLHttpRequest = PureXMLHttpRequest;
+      log(
+        'native "XMLHttpRequest" module restored!',
+        globalThis.XMLHttpRequest.name
+      );
+    });
+  }
+};
+var XMLHttpRequestInterceptor = _XMLHttpRequestInterceptor;
+XMLHttpRequestInterceptor.symbol = Symbol("xhr");
+
+
+
+exports.XMLHttpRequestInterceptor = XMLHttpRequestInterceptor;