msw 1.3.1 → 2.0.0

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

@@ -0,0 +1,193 @@
+"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 onUnhandledRequest_exports = {};
+__export(onUnhandledRequest_exports, {
+  onUnhandledRequest: () => onUnhandledRequest
+});
+module.exports = __toCommonJS(onUnhandledRequest_exports);
+var import_js_levenshtein = __toESM(require("@bundled-es-modules/js-levenshtein"));
+var import__ = require("../../index.js");
+var import_parseGraphQLRequest = require("../internal/parseGraphQLRequest.js");
+var import_getPublicUrlFromRequest = require("./getPublicUrlFromRequest.js");
+var import_isStringEqual = require("../internal/isStringEqual.js");
+var import_devUtils = require("../internal/devUtils.js");
+const getStringMatchScore = import_js_levenshtein.default;
+const MAX_MATCH_SCORE = 3;
+const MAX_SUGGESTION_COUNT = 4;
+const TYPE_MATCH_DELTA = 0.5;
+function groupHandlersByType(handlers) {
+  return handlers.reduce(
+    (groups, handler) => {
+      if (handler instanceof import__.HttpHandler) {
+        groups.http.push(handler);
+      }
+      if (handler instanceof import__.GraphQLHandler) {
+        groups.graphql.push(handler);
+      }
+      return groups;
+    },
+    {
+      http: [],
+      graphql: []
+    }
+  );
+}
+function getHttpHandlerScore() {
+  return (request, handler) => {
+    const { path, method } = handler.info;
+    if (path instanceof RegExp || method instanceof RegExp) {
+      return Infinity;
+    }
+    const hasSameMethod = (0, import_isStringEqual.isStringEqual)(request.method, method);
+    const methodScoreDelta = hasSameMethod ? TYPE_MATCH_DELTA : 0;
+    const requestPublicUrl = (0, import_getPublicUrlFromRequest.getPublicUrlFromRequest)(request);
+    const score = getStringMatchScore(requestPublicUrl, path);
+    return score - methodScoreDelta;
+  };
+}
+function getGraphQLHandlerScore(parsedQuery) {
+  return (_, handler) => {
+    if (typeof parsedQuery.operationName === "undefined") {
+      return Infinity;
+    }
+    const { operationType, operationName } = handler.info;
+    if (typeof operationName !== "string") {
+      return Infinity;
+    }
+    const hasSameOperationType = parsedQuery.operationType === operationType;
+    const operationTypeScoreDelta = hasSameOperationType ? TYPE_MATCH_DELTA : 0;
+    const score = getStringMatchScore(parsedQuery.operationName, operationName);
+    return score - operationTypeScoreDelta;
+  };
+}
+function getSuggestedHandler(request, handlers, getScore) {
+  const suggestedHandlers = handlers.reduce((suggestions, handler) => {
+    const score = getScore(request, handler);
+    return suggestions.concat([[score, handler]]);
+  }, []).sort(([leftScore], [rightScore]) => leftScore - rightScore).filter(([score]) => score <= MAX_MATCH_SCORE).slice(0, MAX_SUGGESTION_COUNT).map(([, handler]) => handler);
+  return suggestedHandlers;
+}
+function getSuggestedHandlersMessage(handlers) {
+  if (handlers.length > 1) {
+    return `Did you mean to request one of the following resources instead?
+
+${handlers.map((handler) => `  \u2022 ${handler.info.header}`).join("\n")}`;
+  }
+  return `Did you mean to request "${handlers[0].info.header}" instead?`;
+}
+function onUnhandledRequest(request, handlers, strategy = "warn") {
+  return __async(this, null, function* () {
+    const parsedGraphQLQuery = yield (0, import_parseGraphQLRequest.parseGraphQLRequest)(request).catch(
+      () => null
+    );
+    const publicUrl = (0, import_getPublicUrlFromRequest.getPublicUrlFromRequest)(request);
+    function generateHandlerSuggestion() {
+      const handlerGroups = groupHandlersByType(handlers);
+      const relevantHandlers = parsedGraphQLQuery ? handlerGroups.graphql : handlerGroups.http;
+      const suggestedHandlers = getSuggestedHandler(
+        request,
+        relevantHandlers,
+        parsedGraphQLQuery ? getGraphQLHandlerScore(parsedGraphQLQuery) : getHttpHandlerScore()
+      );
+      return suggestedHandlers.length > 0 ? getSuggestedHandlersMessage(suggestedHandlers) : "";
+    }
+    function getGraphQLRequestHeader(parsedGraphQLRequest) {
+      if (!(parsedGraphQLRequest == null ? void 0 : parsedGraphQLRequest.operationName)) {
+        return `anonymous ${parsedGraphQLRequest == null ? void 0 : parsedGraphQLRequest.operationType} (${request.method} ${publicUrl})`;
+      }
+      return `${parsedGraphQLRequest.operationType} ${parsedGraphQLRequest.operationName} (${request.method} ${publicUrl})`;
+    }
+    function generateUnhandledRequestMessage() {
+      const requestHeader = parsedGraphQLQuery ? getGraphQLRequestHeader(parsedGraphQLQuery) : `${request.method} ${publicUrl}`;
+      const handlerSuggestion = generateHandlerSuggestion();
+      const messageTemplate = [
+        `intercepted a request without a matching request handler:`,
+        `  \u2022 ${requestHeader}`,
+        handlerSuggestion,
+        `If you still wish to intercept this unhandled request, please create a request handler for it.
+Read more: https://mswjs.io/docs/getting-started/mocks`
+      ].filter(Boolean);
+      return messageTemplate.join("\n\n");
+    }
+    function applyStrategy(strategy2) {
+      const message = generateUnhandledRequestMessage();
+      switch (strategy2) {
+        case "error": {
+          import_devUtils.devUtils.error("Error: %s", message);
+          throw new Error(
+            import_devUtils.devUtils.formatMessage(
+              'Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.'
+            )
+          );
+        }
+        case "warn": {
+          import_devUtils.devUtils.warn("Warning: %s", message);
+          break;
+        }
+        case "bypass":
+          break;
+        default:
+          throw new Error(
+            import_devUtils.devUtils.formatMessage(
+              'Failed to react to an unhandled request: unknown strategy "%s". Please provide one of the supported strategies ("bypass", "warn", "error") or a custom callback function as the value of the "onUnhandledRequest" option.',
+              strategy2
+            )
+          );
+      }
+    }
+    if (typeof strategy === "function") {
+      strategy(request, {
+        warning: applyStrategy.bind(null, "warn"),
+        error: applyStrategy.bind(null, "error")
+      });
+      return;
+    }
+    applyStrategy(strategy);
+  });
+}

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

@@ -0,0 +1,165 @@
+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 jsLevenshtein from "@bundled-es-modules/js-levenshtein";
+import { HttpHandler, GraphQLHandler } from '../../index.mjs';
+import {
+  parseGraphQLRequest
+} from '../internal/parseGraphQLRequest.mjs';
+import { getPublicUrlFromRequest } from './getPublicUrlFromRequest.mjs';
+import { isStringEqual } from '../internal/isStringEqual.mjs';
+import { devUtils } from '../internal/devUtils.mjs';
+const getStringMatchScore = jsLevenshtein;
+const MAX_MATCH_SCORE = 3;
+const MAX_SUGGESTION_COUNT = 4;
+const TYPE_MATCH_DELTA = 0.5;
+function groupHandlersByType(handlers) {
+  return handlers.reduce(
+    (groups, handler) => {
+      if (handler instanceof HttpHandler) {
+        groups.http.push(handler);
+      }
+      if (handler instanceof GraphQLHandler) {
+        groups.graphql.push(handler);
+      }
+      return groups;
+    },
+    {
+      http: [],
+      graphql: []
+    }
+  );
+}
+function getHttpHandlerScore() {
+  return (request, handler) => {
+    const { path, method } = handler.info;
+    if (path instanceof RegExp || method instanceof RegExp) {
+      return Infinity;
+    }
+    const hasSameMethod = isStringEqual(request.method, method);
+    const methodScoreDelta = hasSameMethod ? TYPE_MATCH_DELTA : 0;
+    const requestPublicUrl = getPublicUrlFromRequest(request);
+    const score = getStringMatchScore(requestPublicUrl, path);
+    return score - methodScoreDelta;
+  };
+}
+function getGraphQLHandlerScore(parsedQuery) {
+  return (_, handler) => {
+    if (typeof parsedQuery.operationName === "undefined") {
+      return Infinity;
+    }
+    const { operationType, operationName } = handler.info;
+    if (typeof operationName !== "string") {
+      return Infinity;
+    }
+    const hasSameOperationType = parsedQuery.operationType === operationType;
+    const operationTypeScoreDelta = hasSameOperationType ? TYPE_MATCH_DELTA : 0;
+    const score = getStringMatchScore(parsedQuery.operationName, operationName);
+    return score - operationTypeScoreDelta;
+  };
+}
+function getSuggestedHandler(request, handlers, getScore) {
+  const suggestedHandlers = handlers.reduce((suggestions, handler) => {
+    const score = getScore(request, handler);
+    return suggestions.concat([[score, handler]]);
+  }, []).sort(([leftScore], [rightScore]) => leftScore - rightScore).filter(([score]) => score <= MAX_MATCH_SCORE).slice(0, MAX_SUGGESTION_COUNT).map(([, handler]) => handler);
+  return suggestedHandlers;
+}
+function getSuggestedHandlersMessage(handlers) {
+  if (handlers.length > 1) {
+    return `Did you mean to request one of the following resources instead?
+
+${handlers.map((handler) => `  \u2022 ${handler.info.header}`).join("\n")}`;
+  }
+  return `Did you mean to request "${handlers[0].info.header}" instead?`;
+}
+function onUnhandledRequest(request, handlers, strategy = "warn") {
+  return __async(this, null, function* () {
+    const parsedGraphQLQuery = yield parseGraphQLRequest(request).catch(
+      () => null
+    );
+    const publicUrl = getPublicUrlFromRequest(request);
+    function generateHandlerSuggestion() {
+      const handlerGroups = groupHandlersByType(handlers);
+      const relevantHandlers = parsedGraphQLQuery ? handlerGroups.graphql : handlerGroups.http;
+      const suggestedHandlers = getSuggestedHandler(
+        request,
+        relevantHandlers,
+        parsedGraphQLQuery ? getGraphQLHandlerScore(parsedGraphQLQuery) : getHttpHandlerScore()
+      );
+      return suggestedHandlers.length > 0 ? getSuggestedHandlersMessage(suggestedHandlers) : "";
+    }
+    function getGraphQLRequestHeader(parsedGraphQLRequest) {
+      if (!(parsedGraphQLRequest == null ? void 0 : parsedGraphQLRequest.operationName)) {
+        return `anonymous ${parsedGraphQLRequest == null ? void 0 : parsedGraphQLRequest.operationType} (${request.method} ${publicUrl})`;
+      }
+      return `${parsedGraphQLRequest.operationType} ${parsedGraphQLRequest.operationName} (${request.method} ${publicUrl})`;
+    }
+    function generateUnhandledRequestMessage() {
+      const requestHeader = parsedGraphQLQuery ? getGraphQLRequestHeader(parsedGraphQLQuery) : `${request.method} ${publicUrl}`;
+      const handlerSuggestion = generateHandlerSuggestion();
+      const messageTemplate = [
+        `intercepted a request without a matching request handler:`,
+        `  \u2022 ${requestHeader}`,
+        handlerSuggestion,
+        `If you still wish to intercept this unhandled request, please create a request handler for it.
+Read more: https://mswjs.io/docs/getting-started/mocks`
+      ].filter(Boolean);
+      return messageTemplate.join("\n\n");
+    }
+    function applyStrategy(strategy2) {
+      const message = generateUnhandledRequestMessage();
+      switch (strategy2) {
+        case "error": {
+          devUtils.error("Error: %s", message);
+          throw new Error(
+            devUtils.formatMessage(
+              'Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.'
+            )
+          );
+        }
+        case "warn": {
+          devUtils.warn("Warning: %s", message);
+          break;
+        }
+        case "bypass":
+          break;
+        default:
+          throw new Error(
+            devUtils.formatMessage(
+              'Failed to react to an unhandled request: unknown strategy "%s". Please provide one of the supported strategies ("bypass", "warn", "error") or a custom callback function as the value of the "onUnhandledRequest" option.',
+              strategy2
+            )
+          );
+      }
+    }
+    if (typeof strategy === "function") {
+      strategy(request, {
+        warning: applyStrategy.bind(null, "warn"),
+        error: applyStrategy.bind(null, "error")
+      });
+      return;
+    }
+    applyStrategy(strategy);
+  });
+}
+export {
+  onUnhandledRequest
+};

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

@@ -0,0 +1,3 @@
+declare function readResponseCookies(request: Request, response: Response): void;
+
+export { readResponseCookies };

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

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 readResponseCookies_exports = {};
+__export(readResponseCookies_exports, {
+  readResponseCookies: () => readResponseCookies
+});
+module.exports = __toCommonJS(readResponseCookies_exports);
+var import_cookies = require("@mswjs/cookies");
+function readResponseCookies(request, response) {
+  import_cookies.store.add(__spreadProps(__spreadValues({}, request), { url: request.url.toString() }), response);
+  import_cookies.store.persist();
+}

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

@@ -0,0 +1,27 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { store } from "@mswjs/cookies";
+function readResponseCookies(request, response) {
+  store.add(__spreadProps(__spreadValues({}, request), { url: request.url.toString() }), response);
+  store.persist();
+}
+export {
+  readResponseCookies
+};

package/lib/core/utils/toResponseInit.d.ts

@@ -0,0 +1,3 @@
+declare function toResponseInit(response: Response): ResponseInit;
+
+export { toResponseInit };

package/lib/core/utils/toResponseInit.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 toResponseInit_exports = {};
+__export(toResponseInit_exports, {
+  toResponseInit: () => toResponseInit
+});
+module.exports = __toCommonJS(toResponseInit_exports);
+function toResponseInit(response) {
+  return {
+    status: response.status,
+    statusText: response.statusText,
+    headers: Object.fromEntries(response.headers.entries())
+  };
+}

package/lib/core/utils/toResponseInit.mjs

@@ -0,0 +1,10 @@
+function toResponseInit(response) {
+  return {
+    status: response.status,
+    statusText: response.statusText,
+    headers: Object.fromEntries(response.headers.entries())
+  };
+}
+export {
+  toResponseInit
+};

package/lib/core/utils/url/cleanUrl.d.ts

@@ -0,0 +1,7 @@
+declare function getSearchParams(path: string): URLSearchParams;
+/**
+ * Removes query parameters and hashes from a given URL string.
+ */
+declare function cleanUrl(path: string): string;
+
+export { cleanUrl, getSearchParams };

package/lib/core/utils/url/cleanUrl.js

@@ -0,0 +1,31 @@
+"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 cleanUrl_exports = {};
+__export(cleanUrl_exports, {
+  cleanUrl: () => cleanUrl,
+  getSearchParams: () => getSearchParams
+});
+module.exports = __toCommonJS(cleanUrl_exports);
+const REDUNDANT_CHARACTERS_EXP = /[\?|#].*$/g;
+function getSearchParams(path) {
+  return new URL(`/${path}`, "http://localhost").searchParams;
+}
+function cleanUrl(path) {
+  return path.replace(REDUNDANT_CHARACTERS_EXP, "");
+}

package/lib/core/utils/url/cleanUrl.mjs

@@ -0,0 +1,11 @@
+const REDUNDANT_CHARACTERS_EXP = /[\?|#].*$/g;
+function getSearchParams(path) {
+  return new URL(`/${path}`, "http://localhost").searchParams;
+}
+function cleanUrl(path) {
+  return path.replace(REDUNDANT_CHARACTERS_EXP, "");
+}
+export {
+  cleanUrl,
+  getSearchParams
+};

package/lib/core/utils/url/getAbsoluteUrl.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns an absolute URL based on the given path.
+ */
+declare function getAbsoluteUrl(path: string, baseUrl?: string): string;
+
+export { getAbsoluteUrl };

package/lib/core/utils/url/getAbsoluteUrl.js

@@ -0,0 +1,37 @@
+"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 getAbsoluteUrl_exports = {};
+__export(getAbsoluteUrl_exports, {
+  getAbsoluteUrl: () => getAbsoluteUrl
+});
+module.exports = __toCommonJS(getAbsoluteUrl_exports);
+var import_isAbsoluteUrl = require("./isAbsoluteUrl.js");
+function getAbsoluteUrl(path, baseUrl) {
+  if ((0, import_isAbsoluteUrl.isAbsoluteUrl)(path)) {
+    return path;
+  }
+  if (path.startsWith("*")) {
+    return path;
+  }
+  const origin = baseUrl || typeof document !== "undefined" && document.baseURI;
+  return origin ? (
+    // Encode and decode the path to preserve escaped characters.
+    decodeURI(new URL(encodeURI(path), origin).href)
+  ) : path;
+}

package/lib/core/utils/url/getAbsoluteUrl.mjs

@@ -0,0 +1,17 @@
+import { isAbsoluteUrl } from './isAbsoluteUrl.mjs';
+function getAbsoluteUrl(path, baseUrl) {
+  if (isAbsoluteUrl(path)) {
+    return path;
+  }
+  if (path.startsWith("*")) {
+    return path;
+  }
+  const origin = baseUrl || typeof document !== "undefined" && document.baseURI;
+  return origin ? (
+    // Encode and decode the path to preserve escaped characters.
+    decodeURI(new URL(encodeURI(path), origin).href)
+  ) : path;
+}
+export {
+  getAbsoluteUrl
+};

package/lib/core/utils/url/isAbsoluteUrl.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Determines if the given URL string is an absolute URL.
+ */
+declare function isAbsoluteUrl(url: string): boolean;
+
+export { isAbsoluteUrl };

package/lib/core/utils/url/isAbsoluteUrl.js

@@ -0,0 +1,26 @@
+"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 isAbsoluteUrl_exports = {};
+__export(isAbsoluteUrl_exports, {
+  isAbsoluteUrl: () => isAbsoluteUrl
+});
+module.exports = __toCommonJS(isAbsoluteUrl_exports);
+function isAbsoluteUrl(url) {
+  return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
+}

package/lib/core/utils/url/isAbsoluteUrl.mjs

@@ -0,0 +1,6 @@
+function isAbsoluteUrl(url) {
+  return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
+}
+export {
+  isAbsoluteUrl
+};