@zimic/interceptor 0.14.0-canary.19 → 0.14.0-canary.21

package/dist/http.mjs

@@ -22,168 +22,62 @@ var UnknownHttpInterceptorTypeError = class extends TypeError {
 };
 var UnknownHttpInterceptorTypeError_default = UnknownHttpInterceptorTypeError;
 
-// src/utils/urls.ts
-var InvalidURLError = class extends TypeError {
-  static {
-    __name(this, "InvalidURLError");
-  }
-  constructor(url) {
-    super(`Invalid URL: '${url}'`);
-    this.name = "InvalidURL";
-  }
-};
-var UnsupportedURLProtocolError = class extends TypeError {
-  static {
-    __name(this, "UnsupportedURLProtocolError");
-  }
-  constructor(protocol, availableProtocols) {
-    super(
-      `Unsupported URL protocol: '${protocol}'. The available options are ${availableProtocols.map((protocol2) => `'${protocol2}'`).join(", ")}`
-    );
-    this.name = "UnsupportedURLProtocolError";
-  }
-};
-function createURLOrThrow(rawURL) {
-  try {
-    const url = new URL(rawURL);
-    Object.defineProperty(url, "raw", {
-      value: rawURL.toString(),
-      writable: false,
-      enumerable: true,
-      configurable: false
-    });
-    return url;
-  } catch {
-    throw new InvalidURLError(rawURL);
-  }
-}
-__name(createURLOrThrow, "createURLOrThrow");
-function excludeNonPathParams(url) {
+// ../zimic-utils/dist/chunk-PAWJFY3S.mjs
+var __defProp2 = Object.defineProperty;
+var __name2 = /* @__PURE__ */ __name((target, value) => __defProp2(target, "name", { value, configurable: true }), "__name");
+
+// ../zimic-utils/dist/url/excludeURLParams.mjs
+function excludeURLParams(url) {
   url.hash = "";
   url.search = "";
   url.username = "";
   url.password = "";
   return url;
 }
-__name(excludeNonPathParams, "excludeNonPathParams");
-var DuplicatedPathParamError = class extends Error {
+__name(excludeURLParams, "excludeURLParams");
+__name2(excludeURLParams, "excludeURLParams");
+var excludeURLParams_default = excludeURLParams;
+
+// ../zimic-utils/dist/url/validateURLProtocol.mjs
+var UnsupportedURLProtocolError = class extends TypeError {
   static {
-    __name(this, "DuplicatedPathParamError");
+    __name(this, "UnsupportedURLProtocolError");
   }
-  constructor(url, paramName) {
+  static {
+    __name2(this, "UnsupportedURLProtocolError");
+  }
+  constructor(protocol, availableProtocols) {
     super(
-      `The path parameter '${paramName}' appears more than once in the URL '${url}'. This is not supported. Please make sure that each parameter is unique.`
+      `Unsupported URL protocol: '${protocol}'. The available options are ${availableProtocols.map((protocol2) => `'${protocol2}'`).join(", ")}`
     );
-    this.name = "DuplicatedPathParamError";
+    this.name = "UnsupportedURLProtocolError";
   }
 };
-var URL_PATH_PARAM_REGEX = /\/:([^/]+)/g;
-function ensureUniquePathParams(url) {
-  const matches = url.matchAll(URL_PATH_PARAM_REGEX);
-  const uniqueParamNames = /* @__PURE__ */ new Set();
-  for (const match of matches) {
-    const paramName = match[1];
-    if (uniqueParamNames.has(paramName)) {
-      throw new DuplicatedPathParamError(url, paramName);
-    }
-    uniqueParamNames.add(paramName);
-  }
-}
-__name(ensureUniquePathParams, "ensureUniquePathParams");
-function createURL(rawURL, options = {}) {
-  const {
-    protocols,
-    excludeNonPathParams: shouldExcludeNonPathParams = false,
-    ensureUniquePathParams: shouldEnsureUniquePathParams = false
-  } = options;
-  const url = createURLOrThrow(rawURL);
+function validateURLProtocol(url, protocols) {
   const protocol = url.protocol.replace(/:$/, "");
-  if (protocols && !protocols.includes(protocol)) {
+  if (!protocols.includes(protocol)) {
     throw new UnsupportedURLProtocolError(protocol, protocols);
   }
-  if (shouldExcludeNonPathParams) {
-    excludeNonPathParams(url);
-  }
-  if (shouldEnsureUniquePathParams) {
-    ensureUniquePathParams(url.toString());
-  }
-  return url;
-}
-__name(createURL, "createURL");
-function prepareURLForRegex(url) {
-  const encodedURL = encodeURI(url);
-  return encodedURL.replace(/([.()*?+$\\])/g, "\\$1");
-}
-__name(prepareURLForRegex, "prepareURLForRegex");
-function createRegexFromURL(url) {
-  const urlWithReplacedPathParams = prepareURLForRegex(url).replace(URL_PATH_PARAM_REGEX, "/(?<$1>[^/]+)").replace(/(\/+)$/, "(?:/+)?");
-  return new RegExp(`^${urlWithReplacedPathParams}$`);
 }
-__name(createRegexFromURL, "createRegexFromURL");
-function joinURL(...parts) {
-  return parts.map((part, index) => {
-    const isFirstPart = index === 0;
-    const isLastPart = index === parts.length - 1;
-    let partAsString = part.toString();
-    if (!isFirstPart) {
-      partAsString = partAsString.replace(/^\//, "");
-    }
-    if (!isLastPart) {
-      partAsString = partAsString.replace(/\/$/, "");
-    }
-    return partAsString;
-  }).filter((part) => part.length > 0).join("/");
-}
-__name(joinURL, "joinURL");
+__name(validateURLProtocol, "validateURLProtocol");
+__name2(validateURLProtocol, "validateURLProtocol");
+var validateURLProtocol_default = validateURLProtocol;
 
-// src/utils/environment.ts
-function isClientSide() {
-  return typeof window !== "undefined";
+// ../zimic-utils/dist/data/blobContains.mjs
+async function blobContains(blob, otherBlob) {
+  return blob.type === otherBlob.type && blob.size >= otherBlob.size && (await blob.text()).includes(await otherBlob.text());
 }
-__name(isClientSide, "isClientSide");
+__name(blobContains, "blobContains");
+__name2(blobContains, "blobContains");
+var blobContains_default = blobContains;
 
-// src/utils/data.ts
+// ../zimic-utils/dist/chunk-HVLEF6VF.mjs
 async function blobEquals(blob, otherBlob) {
   return blob.type === otherBlob.type && blob.size === otherBlob.size && await blob.text() === await otherBlob.text();
 }
 __name(blobEquals, "blobEquals");
-async function blobContains(blob, otherBlob) {
-  return blob.type === otherBlob.type && blob.size >= otherBlob.size && (await blob.text()).includes(await otherBlob.text());
-}
-__name(blobContains, "blobContains");
-function convertArrayBufferToBase64(buffer) {
-  if (isClientSide()) {
-    const bufferBytes = new Uint8Array(buffer);
-    const bufferAsStringArray = [];
-    for (const byte of bufferBytes) {
-      const byteCode = String.fromCharCode(byte);
-      bufferAsStringArray.push(byteCode);
-    }
-    const bufferAsString = bufferAsStringArray.join("");
-    return btoa(bufferAsString);
-  } else {
-    return Buffer.from(buffer).toString("base64");
-  }
-}
-__name(convertArrayBufferToBase64, "convertArrayBufferToBase64");
-function convertBase64ToArrayBuffer(base64Value) {
-  if (isClientSide()) {
-    const bufferAsString = atob(base64Value);
-    const array = Uint8Array.from(bufferAsString, (character) => character.charCodeAt(0));
-    return array.buffer;
-  } else {
-    return Buffer.from(base64Value, "base64");
-  }
-}
-__name(convertBase64ToArrayBuffer, "convertBase64ToArrayBuffer");
-function isDefined(value) {
-  return value !== undefined && value !== null;
-}
-__name(isDefined, "isDefined");
-function isNonEmpty(value) {
-  return isDefined(value) && value !== "";
-}
-__name(isNonEmpty, "isNonEmpty");
+__name2(blobEquals, "blobEquals");
+var blobEquals_default = blobEquals;
 
 // src/utils/json.ts
 function isPrimitiveJSONValue(value) {
@@ -288,17 +182,41 @@ var NoResponseDefinitionError = class extends TypeError {
 };
 var NoResponseDefinitionError_default = NoResponseDefinitionError;
 
-// src/utils/imports.ts
+// ../zimic-utils/dist/chunk-3O5CS47X.mjs
+function isDefined(value) {
+  return value !== undefined && value !== null;
+}
+__name(isDefined, "isDefined");
+__name2(isDefined, "isDefined");
+var isDefined_default = isDefined;
+
+// ../zimic-utils/dist/data/isNonEmpty.mjs
+function isNonEmpty(value) {
+  return isDefined_default(value) && value !== "";
+}
+__name(isNonEmpty, "isNonEmpty");
+__name2(isNonEmpty, "isNonEmpty");
+var isNonEmpty_default = isNonEmpty;
+
+// ../zimic-utils/dist/import/createCachedDynamicImport.mjs
 function createCachedDynamicImport(importModuleDynamically) {
   let cachedImportResult;
-  return /* @__PURE__ */ __name(async function importModuleDynamicallyWithCache() {
+  return /* @__PURE__ */ __name2(/* @__PURE__ */ __name(async function importModuleDynamicallyWithCache() {
     if (cachedImportResult === undefined) {
       cachedImportResult = await importModuleDynamically();
     }
     return cachedImportResult;
-  }, "importModuleDynamicallyWithCache");
+  }, "importModuleDynamicallyWithCache"), "importModuleDynamicallyWithCache");
 }
 __name(createCachedDynamicImport, "createCachedDynamicImport");
+__name2(createCachedDynamicImport, "createCachedDynamicImport");
+var createCachedDynamicImport_default = createCachedDynamicImport;
+
+// src/utils/environment.ts
+function isClientSide() {
+  return typeof window !== "undefined";
+}
+__name(isClientSide, "isClientSide");
 function isGlobalFileAvailable() {
   return globalThis.File !== undefined;
 }
@@ -341,7 +259,7 @@ function stringifyValueToLog(value, options = {}) {
   return fallback(value);
 }
 __name(stringifyValueToLog, "stringifyValueToLog");
-var importUtil = createCachedDynamicImport(() => import('util'));
+var importUtil = createCachedDynamicImport_default(() => import('util'));
 async function formatValueToLog(value, options = {}) {
   if (isClientSide()) {
     return value;
@@ -362,7 +280,7 @@ __name(formatValueToLog, "formatValueToLog");
 function logWithPrefix(messageOrMessages, options = {}) {
   const { method = "log" } = options;
   const messages = Array.isArray(messageOrMessages) ? messageOrMessages : [messageOrMessages];
-  console[method](chalk2.cyan("[zimic]"), ...messages);
+  console[method](chalk2.cyan("[@zimic/interceptor]"), ...messages);
 }
 __name(logWithPrefix, "logWithPrefix");
 
@@ -444,7 +362,7 @@ function createMessage(options) {
   const messageHeader = createMessageHeader(options);
   const messageDiffs = createMessageDiffs(options);
   const messageFooter = createMessageFooter();
-  return [messageHeader, messageDiffs, messageFooter].filter(isNonEmpty).join("\n\n");
+  return [messageHeader, messageDiffs, messageFooter].filter(isNonEmpty_default).join("\n\n");
 }
 __name(createMessage, "createMessage");
 var TimesCheckError = class extends TypeError {
@@ -669,7 +587,7 @@ var HttpRequestHandlerClient = class {
           diff: { expected: restrictionBody, received: body }
         };
       }
-      const matchesRestriction2 = restriction.exact ? await blobEquals(body, restrictionBody) : await blobContains(body, restrictionBody);
+      const matchesRestriction2 = restriction.exact ? await blobEquals_default(body, restrictionBody) : await blobContains_default(body, restrictionBody);
       return matchesRestriction2 ? { value: true } : {
         value: false,
         diff: { expected: restrictionBody, received: body }
@@ -770,6 +688,36 @@ var LocalHttpRequestHandler = class {
 };
 var LocalHttpRequestHandler_default = LocalHttpRequestHandler;
 
+// ../zimic-utils/dist/chunk-7MZYQWWC.mjs
+var URL_PATH_PARAM_REGEX = /\/:([^/]+)/g;
+function createRegExpFromURL(url) {
+  URL_PATH_PARAM_REGEX.lastIndex = 0;
+  const urlWithReplacedPathParams = encodeURI(url).replace(/([.()*?+$\\])/g, "\\$1").replace(URL_PATH_PARAM_REGEX, "/(?<$1>[^/]+)").replace(/(\/+)$/, "(?:/+)?");
+  return new RegExp(`^${urlWithReplacedPathParams}$`);
+}
+__name(createRegExpFromURL, "createRegExpFromURL");
+__name2(createRegExpFromURL, "createRegExpFromURL");
+var createRegExpFromURL_default = createRegExpFromURL;
+
+// ../zimic-utils/dist/url/joinURL.mjs
+function joinURL(...parts) {
+  return parts.map((part, index) => {
+    const isFirstPart = index === 0;
+    const isLastPart = index === parts.length - 1;
+    let partAsString = part.toString();
+    if (!isFirstPart) {
+      partAsString = partAsString.replace(/^\//, "");
+    }
+    if (!isLastPart) {
+      partAsString = partAsString.replace(/\/$/, "");
+    }
+    return partAsString;
+  }).filter((part) => part.length > 0).join("/");
+}
+__name(joinURL, "joinURL");
+__name2(joinURL, "joinURL");
+var joinURL_default = joinURL;
+
 // src/utils/arrays.ts
 function removeArrayIndex(array, index) {
   if (index >= 0 && index < array.length) {
@@ -958,7 +906,7 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
         this.getInterceptorUnhandledRequestStrategy(requestClone, interceptor)
       ]);
       const candidatesOrPromises = [interceptorStrategy, defaultStrategy, globalDefaultStrategy];
-      const candidateStrategies = await Promise.all(candidatesOrPromises.filter(isDefined));
+      const candidateStrategies = await Promise.all(candidatesOrPromises.filter(isDefined_default));
       return candidateStrategies;
     } catch (error) {
       console.error(error);
@@ -974,7 +922,7 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
   }
   findInterceptorByRequestBaseURL(request) {
     const interceptor = this.runningInterceptors.findLast((interceptor2) => {
-      const baseURL = interceptor2.baseURL().toString();
+      const baseURL = interceptor2.baseURL();
       return request.url.startsWith(baseURL);
     });
     return interceptor;
@@ -1021,7 +969,7 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
     const parsedBody = await this.parseRawBody(rawRequest);
     const headers = new HttpHeaders(rawRequest.headers);
     const pathParams = options.urlRegex ? this.parseRawPathParams(options.urlRegex, rawRequest) : {};
-    const parsedURL = createURL(rawRequest.url);
+    const parsedURL = new URL(rawRequest.url);
     const searchParams = new HttpSearchParams(parsedURL.searchParams);
     const parsedRequest = new Proxy(rawRequest, {
       has(target, property) {
@@ -1222,6 +1170,37 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
 };
 var HttpInterceptorWorker_default = HttpInterceptorWorker;
 
+// ../zimic-utils/dist/url/validateURLPathParams.mjs
+var DuplicatedPathParamError = class extends Error {
+  static {
+    __name(this, "DuplicatedPathParamError");
+  }
+  static {
+    __name2(this, "DuplicatedPathParamError");
+  }
+  constructor(url, paramName) {
+    super(
+      `The path parameter '${paramName}' appears more than once in the URL '${url.toString()}'. This is not supported. Please make sure that each parameter is unique.`
+    );
+    this.name = "DuplicatedPathParamError";
+  }
+};
+function validateURLPathParams(url) {
+  URL_PATH_PARAM_REGEX.lastIndex = 0;
+  const matches = url.toString().matchAll(URL_PATH_PARAM_REGEX);
+  const uniqueParamNames = /* @__PURE__ */ new Set();
+  for (const match of matches) {
+    const paramName = match[1];
+    if (uniqueParamNames.has(paramName)) {
+      throw new DuplicatedPathParamError(url, paramName);
+    }
+    uniqueParamNames.add(paramName);
+  }
+}
+__name(validateURLPathParams, "validateURLPathParams");
+__name2(validateURLPathParams, "validateURLPathParams");
+var validateURLPathParams_default = validateURLPathParams;
+
 // src/http/interceptor/errors/NotStartedHttpInterceptorError.ts
 var NotStartedHttpInterceptorError = class extends Error {
   static {
@@ -1373,10 +1352,9 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   use(interceptor, method, rawURL, createResponse) {
     const internalWorker = this.internalWorkerOrThrow();
     const lowercaseMethod = method.toLowerCase();
-    const url = createURL(rawURL, {
-      excludeNonPathParams: true,
-      ensureUniquePathParams: true
-    });
+    const url = new URL(rawURL);
+    excludeURLParams_default(url);
+    validateURLPathParams_default(url);
     const httpHandler = http[lowercaseMethod](url.toString(), async (context) => {
       const request = context.request;
       const requestClone = request.clone();
@@ -1573,7 +1551,11 @@ var HttpInterceptorClient = class {
     this._shouldSaveRequests = options.saveRequests ?? false;
   }
   baseURL() {
-    return this._baseURL;
+    const baseURL = this._baseURL;
+    if (baseURL.href === `${baseURL.origin}/`) {
+      return baseURL.origin;
+    }
+    return baseURL.toString();
   }
   platform() {
     return this.worker.platform();
@@ -1656,8 +1638,8 @@ var HttpInterceptorClient = class {
       return;
     }
     this.handlerClientsByMethod[handler.method()].set(handler.path(), handlerClients);
-    const url = joinURL(this.baseURL(), handler.path());
-    const urlRegex = createRegexFromURL(url);
+    const url = joinURL_default(this.baseURL(), handler.path());
+    const urlRegex = createRegExpFromURL_default(url);
     const registrationResult = this.worker.use(this, handler.method(), url, async (context) => {
       const response = await this.handleInterceptedRequest(
         urlRegex,
@@ -1741,11 +1723,38 @@ var HttpInterceptorClient = class {
 var HttpInterceptorClient_default = HttpInterceptorClient;
 
 // src/utils/crypto.ts
-var importCrypto = createCachedDynamicImport(async () => {
+var importCrypto = createCachedDynamicImport_default(async () => {
   const globalCrypto = globalThis.crypto;
   return globalCrypto ?? await import('crypto');
 });
 
+// src/utils/data.ts
+function convertArrayBufferToBase64(buffer) {
+  if (isClientSide()) {
+    const bufferBytes = new Uint8Array(buffer);
+    const bufferAsStringArray = [];
+    for (const byte of bufferBytes) {
+      const byteCode = String.fromCharCode(byte);
+      bufferAsStringArray.push(byteCode);
+    }
+    const bufferAsString = bufferAsStringArray.join("");
+    return btoa(bufferAsString);
+  } else {
+    return Buffer.from(buffer).toString("base64");
+  }
+}
+__name(convertArrayBufferToBase64, "convertArrayBufferToBase64");
+function convertBase64ToArrayBuffer(base64Value) {
+  if (isClientSide()) {
+    const bufferAsString = atob(base64Value);
+    const array = Uint8Array.from(bufferAsString, (character) => character.charCodeAt(0));
+    return array.buffer;
+  } else {
+    return Buffer.from(base64Value, "base64");
+  }
+}
+__name(convertBase64ToArrayBuffer, "convertBase64ToArrayBuffer");
+
 // src/utils/fetch.ts
 function deserializeRequest(serializedRequest) {
   const deserializedBody = serializedRequest.body ? convertBase64ToArrayBuffer(serializedRequest.body) : null;
@@ -2159,9 +2168,8 @@ var WebSocketClient = class extends WebSocketHandler_default {
       socketTimeout: options.socketTimeout,
       messageTimeout: options.messageTimeout
     });
-    this.url = createURL(options.url, {
-      protocols: SUPPORTED_WEB_SOCKET_PROTOCOLS
-    });
+    this.url = new URL(options.url);
+    validateURLProtocol_default(this.url, SUPPORTED_WEB_SOCKET_PROTOCOLS);
   }
   isRunning() {
     return this.socket !== undefined && this.socket.readyState === this.socket.OPEN;
@@ -2202,7 +2210,7 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
     });
   }
   deriveWebSocketServerURL(serverURL) {
-    const webSocketServerURL = createURL(serverURL);
+    const webSocketServerURL = new URL(serverURL);
     webSocketServerURL.protocol = serverURL.protocol.replace(/^http(s)?:$/, "ws$1:");
     return webSocketServerURL;
   }
@@ -2266,14 +2274,13 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
       throw new NotStartedHttpInterceptorError_default();
     }
     const crypto = await importCrypto();
-    const url = createURL(rawURL, {
-      excludeNonPathParams: true,
-      ensureUniquePathParams: true
-    });
+    const url = new URL(rawURL);
+    excludeURLParams_default(url);
+    validateURLPathParams_default(url);
     const handler = {
       id: crypto.randomUUID(),
       url: {
-        base: interceptor.baseURL().toString(),
+        base: interceptor.baseURL(),
         full: url.toString()
       },
       method,
@@ -2414,10 +2421,9 @@ var LocalHttpInterceptor = class {
   _client;
   constructor(options) {
     this.type = options.type;
-    const baseURL = createURL(options.baseURL, {
-      protocols: SUPPORTED_BASE_URL_PROTOCOLS,
-      excludeNonPathParams: true
-    });
+    const baseURL = new URL(options.baseURL);
+    validateURLProtocol_default(baseURL, SUPPORTED_BASE_URL_PROTOCOLS);
+    excludeURLParams_default(baseURL);
     const worker = this.store.getOrCreateLocalWorker({});
     this._client = new HttpInterceptorClient_default({
       worker,
@@ -2432,7 +2438,7 @@ var LocalHttpInterceptor = class {
     return this._client;
   }
   baseURL() {
-    return this._client.baseURL().raw;
+    return this._client.baseURL();
   }
   platform() {
     return this._client.platform();
@@ -2493,14 +2499,10 @@ var RemoteHttpInterceptor = class {
   _client;
   constructor(options) {
     this.type = options.type;
-    const baseURL = createURL(options.baseURL, {
-      protocols: SUPPORTED_BASE_URL_PROTOCOLS,
-      excludeNonPathParams: true
-    });
-    const serverURL = createURL(baseURL.origin, {
-      protocols: SUPPORTED_BASE_URL_PROTOCOLS,
-      excludeNonPathParams: true
-    });
+    const baseURL = new URL(options.baseURL);
+    validateURLProtocol_default(baseURL, SUPPORTED_BASE_URL_PROTOCOLS);
+    excludeURLParams_default(baseURL);
+    const serverURL = new URL(baseURL.origin);
     const worker = this.store.getOrCreateRemoteWorker({ serverURL });
     this._client = new HttpInterceptorClient_default({
       worker,
@@ -2515,7 +2517,7 @@ var RemoteHttpInterceptor = class {
     return this._client;
   }
   baseURL() {
-    return this._client.baseURL().raw;
+    return this._client.baseURL();
   }
   platform() {
     return this._client.platform();