msw 1.3.2 → 2.0.0

package/lib/core/utils/logging/serializeResponse.js

@@ -0,0 +1,69 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var serializeResponse_exports = {};
+__export(serializeResponse_exports, {
+  serializeResponse: () => serializeResponse
+});
+module.exports = __toCommonJS(serializeResponse_exports);
+var import_statuses = __toESM(require("@bundled-es-modules/statuses"));
+const { message } = import_statuses.default;
+function serializeResponse(response) {
+  return __async(this, null, function* () {
+    const responseClone = response.clone();
+    const responseText = yield responseClone.text();
+    const responseStatus = responseClone.status || 200;
+    const responseStatusText = responseClone.statusText || message[responseStatus] || "OK";
+    return {
+      status: responseStatus,
+      statusText: responseStatusText,
+      headers: Object.fromEntries(responseClone.headers.entries()),
+      body: responseText
+    };
+  });
+}

package/lib/core/utils/logging/serializeResponse.mjs

@@ -0,0 +1,39 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import statuses from "@bundled-es-modules/statuses";
+const { message } = statuses;
+function serializeResponse(response) {
+  return __async(this, null, function* () {
+    const responseClone = response.clone();
+    const responseText = yield responseClone.text();
+    const responseStatus = responseClone.status || 200;
+    const responseStatusText = responseClone.statusText || message[responseStatus] || "OK";
+    return {
+      status: responseStatus,
+      statusText: responseStatusText,
+      headers: Object.fromEntries(responseClone.headers.entries()),
+      body: responseText
+    };
+  });
+}
+export {
+  serializeResponse
+};

package/lib/core/utils/matching/matchRequestUrl.d.ts

@@ -0,0 +1,19 @@
+type Path = string | RegExp;
+type PathParams<KeyType extends keyof any = string> = {
+    [ParamName in KeyType]: string | ReadonlyArray<string>;
+};
+interface Match {
+    matches: boolean;
+    params?: PathParams;
+}
+/**
+ * Coerce a path supported by MSW into a path
+ * supported by "path-to-regexp".
+ */
+declare function coercePath(path: string): string;
+/**
+ * Returns the result of matching given request URL against a mask.
+ */
+declare function matchRequestUrl(url: URL, path: Path, baseUrl?: string): Match;
+
+export { Match, Path, PathParams, coercePath, matchRequestUrl };

package/lib/core/utils/matching/matchRequestUrl.js

@@ -0,0 +1,50 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var matchRequestUrl_exports = {};
+__export(matchRequestUrl_exports, {
+  coercePath: () => coercePath,
+  matchRequestUrl: () => matchRequestUrl
+});
+module.exports = __toCommonJS(matchRequestUrl_exports);
+var import_path_to_regexp = require("path-to-regexp");
+var import_interceptors = require("@mswjs/interceptors");
+var import_normalizePath = require("./normalizePath.js");
+function coercePath(path) {
+  return path.replace(
+    /([:a-zA-Z_-]*)(\*{1,2})+/g,
+    (_, parameterName, wildcard) => {
+      const expression = "(.*)";
+      if (!parameterName) {
+        return expression;
+      }
+      return parameterName.startsWith(":") ? `${parameterName}${wildcard}` : `${parameterName}${expression}`;
+    }
+  ).replace(/([^\/])(:)(?=\d+)/, "$1\\$2").replace(/^([^\/]+)(:)(?=\/\/)/, "$1\\$2");
+}
+function matchRequestUrl(url, path, baseUrl) {
+  const normalizedPath = (0, import_normalizePath.normalizePath)(path, baseUrl);
+  const cleanPath = typeof normalizedPath === "string" ? coercePath(normalizedPath) : normalizedPath;
+  const cleanUrl = (0, import_interceptors.getCleanUrl)(url);
+  const result = (0, import_path_to_regexp.match)(cleanPath, { decode: decodeURIComponent })(cleanUrl);
+  const params = result && result.params || {};
+  return {
+    matches: result !== false,
+    params
+  };
+}

package/lib/core/utils/matching/matchRequestUrl.mjs

@@ -0,0 +1,30 @@
+import { match } from "path-to-regexp";
+import { getCleanUrl } from "@mswjs/interceptors";
+import { normalizePath } from './normalizePath.mjs';
+function coercePath(path) {
+  return path.replace(
+    /([:a-zA-Z_-]*)(\*{1,2})+/g,
+    (_, parameterName, wildcard) => {
+      const expression = "(.*)";
+      if (!parameterName) {
+        return expression;
+      }
+      return parameterName.startsWith(":") ? `${parameterName}${wildcard}` : `${parameterName}${expression}`;
+    }
+  ).replace(/([^\/])(:)(?=\d+)/, "$1\\$2").replace(/^([^\/]+)(:)(?=\/\/)/, "$1\\$2");
+}
+function matchRequestUrl(url, path, baseUrl) {
+  const normalizedPath = normalizePath(path, baseUrl);
+  const cleanPath = typeof normalizedPath === "string" ? coercePath(normalizedPath) : normalizedPath;
+  const cleanUrl = getCleanUrl(url);
+  const result = match(cleanPath, { decode: decodeURIComponent })(cleanUrl);
+  const params = result && result.params || {};
+  return {
+    matches: result !== false,
+    params
+  };
+}
+export {
+  coercePath,
+  matchRequestUrl
+};

package/lib/core/utils/matching/normalizePath.d.ts

@@ -0,0 +1,12 @@
+import { Path } from './matchRequestUrl.js';
+
+/**
+ * Normalizes a given request handler path:
+ * - Preserves RegExp.
+ * - Removes query parameters and hashes.
+ * - Rebases relative URLs against the "baseUrl" or the current location.
+ * - Preserves relative URLs in Node.js, unless specified otherwise.
+ */
+declare function normalizePath(path: Path, baseUrl?: string): Path;
+
+export { normalizePath };

package/lib/core/utils/matching/normalizePath.js

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var normalizePath_exports = {};
+__export(normalizePath_exports, {
+  normalizePath: () => normalizePath
+});
+module.exports = __toCommonJS(normalizePath_exports);
+var import_cleanUrl = require("../url/cleanUrl.js");
+var import_getAbsoluteUrl = require("../url/getAbsoluteUrl.js");
+function normalizePath(path, baseUrl) {
+  if (path instanceof RegExp) {
+    return path;
+  }
+  const maybeAbsoluteUrl = (0, import_getAbsoluteUrl.getAbsoluteUrl)(path, baseUrl);
+  return (0, import_cleanUrl.cleanUrl)(maybeAbsoluteUrl);
+}

package/lib/core/utils/matching/normalizePath.mjs

@@ -0,0 +1,12 @@
+import { cleanUrl } from '../url/cleanUrl.mjs';
+import { getAbsoluteUrl } from '../url/getAbsoluteUrl.mjs';
+function normalizePath(path, baseUrl) {
+  if (path instanceof RegExp) {
+    return path;
+  }
+  const maybeAbsoluteUrl = getAbsoluteUrl(path, baseUrl);
+  return cleanUrl(maybeAbsoluteUrl);
+}
+export {
+  normalizePath
+};

package/lib/core/utils/request/getPublicUrlFromRequest.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns a relative URL if the given request URL is relative to the current origin.
+ * Otherwise returns an absolute URL.
+ */
+declare function getPublicUrlFromRequest(request: Request): string;
+
+export { getPublicUrlFromRequest };

package/lib/core/utils/request/getPublicUrlFromRequest.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getPublicUrlFromRequest_exports = {};
+__export(getPublicUrlFromRequest_exports, {
+  getPublicUrlFromRequest: () => getPublicUrlFromRequest
+});
+module.exports = __toCommonJS(getPublicUrlFromRequest_exports);
+function getPublicUrlFromRequest(request) {
+  if (typeof location === "undefined") {
+    return request.url;
+  }
+  const url = new URL(request.url);
+  return url.origin === location.origin ? url.pathname : url.origin + url.pathname;
+}

package/lib/core/utils/request/getPublicUrlFromRequest.mjs

@@ -0,0 +1,10 @@
+function getPublicUrlFromRequest(request) {
+  if (typeof location === "undefined") {
+    return request.url;
+  }
+  const url = new URL(request.url);
+  return url.origin === location.origin ? url.pathname : url.origin + url.pathname;
+}
+export {
+  getPublicUrlFromRequest
+};

package/lib/core/utils/request/getRequestCookies.d.ts

@@ -0,0 +1,8 @@
+/** @todo Rename this to "getDocumentCookies" */
+/**
+ * Returns relevant document cookies based on the request `credentials` option.
+ */
+declare function getRequestCookies(request: Request): Record<string, string>;
+declare function getAllRequestCookies(request: Request): Record<string, string>;
+
+export { getAllRequestCookies, getRequestCookies };

package/lib/core/utils/request/getRequestCookies.js

@@ -0,0 +1,88 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getRequestCookies_exports = {};
+__export(getRequestCookies_exports, {
+  getAllRequestCookies: () => getAllRequestCookies,
+  getRequestCookies: () => getRequestCookies
+});
+module.exports = __toCommonJS(getRequestCookies_exports);
+var import_cookie = __toESM(require("@bundled-es-modules/cookie"));
+var import_cookies = require("@mswjs/cookies");
+function getAllDocumentCookies() {
+  return import_cookie.default.parse(document.cookie);
+}
+function getRequestCookies(request) {
+  if (typeof document === "undefined" || typeof location === "undefined") {
+    return {};
+  }
+  switch (request.credentials) {
+    case "same-origin": {
+      const url = new URL(request.url);
+      return location.origin === url.origin ? getAllDocumentCookies() : {};
+    }
+    case "include": {
+      return getAllDocumentCookies();
+    }
+    default: {
+      return {};
+    }
+  }
+}
+function getAllRequestCookies(request) {
+  var _a;
+  const requestCookiesString = request.headers.get("cookie");
+  const cookiesFromHeaders = requestCookiesString ? import_cookie.default.parse(requestCookiesString) : {};
+  import_cookies.store.hydrate();
+  const cookiesFromStore = Array.from((_a = import_cookies.store.get(request)) == null ? void 0 : _a.entries()).reduce(
+    (cookies, [name, { value }]) => {
+      return Object.assign(cookies, { [name.trim()]: value });
+    },
+    {}
+  );
+  const cookiesFromDocument = getRequestCookies(request);
+  const forwardedCookies = __spreadValues(__spreadValues({}, cookiesFromDocument), cookiesFromStore);
+  for (const [name, value] of Object.entries(forwardedCookies)) {
+    request.headers.append("cookie", `${name}=${value}`);
+  }
+  return __spreadValues(__spreadValues({}, forwardedCookies), cookiesFromHeaders);
+}

package/lib/core/utils/request/getRequestCookies.mjs

@@ -0,0 +1,60 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+import cookieUtils from "@bundled-es-modules/cookie";
+import { store } from "@mswjs/cookies";
+function getAllDocumentCookies() {
+  return cookieUtils.parse(document.cookie);
+}
+function getRequestCookies(request) {
+  if (typeof document === "undefined" || typeof location === "undefined") {
+    return {};
+  }
+  switch (request.credentials) {
+    case "same-origin": {
+      const url = new URL(request.url);
+      return location.origin === url.origin ? getAllDocumentCookies() : {};
+    }
+    case "include": {
+      return getAllDocumentCookies();
+    }
+    default: {
+      return {};
+    }
+  }
+}
+function getAllRequestCookies(request) {
+  var _a;
+  const requestCookiesString = request.headers.get("cookie");
+  const cookiesFromHeaders = requestCookiesString ? cookieUtils.parse(requestCookiesString) : {};
+  store.hydrate();
+  const cookiesFromStore = Array.from((_a = store.get(request)) == null ? void 0 : _a.entries()).reduce(
+    (cookies, [name, { value }]) => {
+      return Object.assign(cookies, { [name.trim()]: value });
+    },
+    {}
+  );
+  const cookiesFromDocument = getRequestCookies(request);
+  const forwardedCookies = __spreadValues(__spreadValues({}, cookiesFromDocument), cookiesFromStore);
+  for (const [name, value] of Object.entries(forwardedCookies)) {
+    request.headers.append("cookie", `${name}=${value}`);
+  }
+  return __spreadValues(__spreadValues({}, forwardedCookies), cookiesFromHeaders);
+}
+export {
+  getAllRequestCookies,
+  getRequestCookies
+};

package/lib/core/utils/request/onUnhandledRequest.d.ts

@@ -0,0 +1,12 @@
+import { R as RequestHandler } from '../../RequestHandler-1a5dbdc7.js';
+import '../../typeUtils.js';
+
+interface UnhandledRequestPrint {
+    warning(): void;
+    error(): void;
+}
+type UnhandledRequestCallback = (request: Request, print: UnhandledRequestPrint) => void;
+type UnhandledRequestStrategy = 'bypass' | 'warn' | 'error' | UnhandledRequestCallback;
+declare function onUnhandledRequest(request: Request, handlers: Array<RequestHandler>, strategy?: UnhandledRequestStrategy): Promise<void>;
+
+export { UnhandledRequestCallback, UnhandledRequestPrint, UnhandledRequestStrategy, onUnhandledRequest };