@zimic/interceptor 0.14.0-canary.17 → 0.14.0-canary.20

package/dist/{chunk-3XWHITKR.mjs → chunk-5ESJW32X.mjs}

@@ -5,6 +5,41 @@ import { HttpHeaders, HttpSearchParams, HttpFormData, HTTP_METHODS, HTTP_METHODS
 import chalk2 from 'chalk';
 import ClientSocket from 'isomorphic-ws';
 
+// ../zimic-utils/dist/chunk-PAWJFY3S.mjs
+var __defProp = Object.defineProperty;
+var __name2 = /* @__PURE__ */ __name((target, value) => __defProp(target, "name", { value, configurable: true }), "__name");
+
+// ../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/excludeURLParams.mjs
+function excludeURLParams(url) {
+  url.hash = "";
+  url.search = "";
+  url.username = "";
+  url.password = "";
+  return url;
+}
+__name(excludeURLParams, "excludeURLParams");
+__name2(excludeURLParams, "excludeURLParams");
+var excludeURLParams_default = excludeURLParams;
+
+// ../zimic-utils/dist/chunk-3O5CS47X.mjs
+function isDefined(value) {
+  return value !== undefined && value !== null;
+}
+__name(isDefined, "isDefined");
+__name2(isDefined, "isDefined");
+var isDefined_default = isDefined;
+
 // src/utils/arrays.ts
 function removeArrayIndex(array, index) {
   if (index >= 0 && index < array.length) {
@@ -19,42 +54,36 @@ function removeArrayElement(array, element) {
 }
 __name(removeArrayElement, "removeArrayElement");
 
-// src/utils/environment.ts
-function isClientSide() {
-  return typeof window !== "undefined";
-}
-__name(isClientSide, "isClientSide");
-
-// src/utils/imports.ts
+// ../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");
 
 // src/utils/files.ts
-var importBuffer = createCachedDynamicImport(
+var importFile = createCachedDynamicImport_default(
   /* istanbul ignore next -- @preserve
-   * Ignoring as Node.js >=20 provides a global file and the buffer import won't run. */
-  () => import('buffer')
+   * Ignoring as Node.js >=20 provides a global File and the import fallback won't run. */
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  async () => globalThis.File ?? (await import('buffer')).File
 );
-var FileSingleton;
-async function importFile() {
-  if (FileSingleton) {
-    return FileSingleton;
-  }
-  FileSingleton = globalThis.File ?? (await importBuffer()).File;
-  return FileSingleton;
-}
-__name(importFile, "importFile");
 
 // src/utils/console.ts
-var importUtil = createCachedDynamicImport(() => import('util'));
+var importUtil = createCachedDynamicImport_default(() => import('util'));
 async function formatValueToLog(value, options = {}) {
   if (isClientSide()) {
     return value;
@@ -75,40 +104,9 @@ __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");
-
-// 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");
-function isDefined(value) {
-  return value !== undefined && value !== null;
-}
-__name(isDefined, "isDefined");
 var HttpServerTimeoutError = class extends Error {
   static {
     __name(this, "HttpServerTimeoutError");
@@ -193,105 +191,6 @@ function methodCanHaveResponseBody(method) {
 }
 __name(methodCanHaveResponseBody, "methodCanHaveResponseBody");
 
-// 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) {
-  url.hash = "";
-  url.search = "";
-  url.username = "";
-  url.password = "";
-  return url;
-}
-__name(excludeNonPathParams, "excludeNonPathParams");
-var DuplicatedPathParamError = class extends Error {
-  static {
-    __name(this, "DuplicatedPathParamError");
-  }
-  constructor(url, paramName) {
-    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.`
-    );
-    this.name = "DuplicatedPathParamError";
-  }
-};
-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);
-  const protocol = url.protocol.replace(/:$/, "");
-  if (protocols && !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");
-
 // src/http/requestHandler/types/requests.ts
 var HTTP_INTERCEPTOR_REQUEST_HIDDEN_PROPERTIES = Object.freeze(
   /* @__PURE__ */ new Set([
@@ -461,7 +360,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);
@@ -477,7 +376,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;
@@ -524,7 +423,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) {
@@ -725,6 +624,33 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
 };
 var HttpInterceptorWorker_default = HttpInterceptorWorker;
 
+// 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
 async function serializeRequest(request) {
   const requestClone = request.clone();
@@ -877,7 +803,7 @@ async function closeServerSocket(socket, options = {}) {
 __name(closeServerSocket, "closeServerSocket");
 
 // src/utils/crypto.ts
-var importCrypto = createCachedDynamicImport(async () => {
+var importCrypto = createCachedDynamicImport_default(async () => {
   const globalCrypto = globalThis.crypto;
   return globalCrypto ?? await import('crypto');
 });
@@ -1357,12 +1283,13 @@ var InterceptorServer = class {
   }, "resetWorker");
   registerHttpHandler({ id, url, method }, socket) {
     const handlerGroups = this.httpHandlerGroups[method];
-    const fullURL = createURL(url.full, { excludeNonPathParams: true });
+    const fullURL = new URL(url.full);
+    excludeURLParams_default(fullURL);
     handlerGroups.push({
       id,
       url: {
         base: url.base,
-        fullRegex: createRegexFromURL(fullURL.toString())
+        fullRegex: createRegExpFromURL_default(fullURL.toString())
       },
       socket
     });
@@ -1436,7 +1363,7 @@ var InterceptorServer = class {
   async createResponseForRequest(request) {
     const webSocketServer = this.webSocketServer();
     const methodHandlers = this.httpHandlerGroups[request.method];
-    const requestURL = createURL(request.url, { excludeNonPathParams: true }).toString();
+    const requestURL = excludeURLParams_default(new URL(request.url)).toString();
     let matchedSomeInterceptor = false;
     for (let index = methodHandlers.length - 1; index >= 0; index--) {
       const handler = methodHandlers[index];
@@ -1528,8 +1455,6 @@ var InterceptorServerNamespace_default = InterceptorServerNamespace;
 
 // src/server/index.ts
 var interceptorServer = Object.freeze(new InterceptorServerNamespace_default());
-/* istanbul ignore next -- @preserve
- * Ignoring as Node.js >=20 provides a global File and the import fallback won't run. */
 /* istanbul ignore if -- @preserve
  * This is expected not to happen since the servers are not stopped unless they are running. */
 /* istanbul ignore if -- @preserve
@@ -1556,6 +1481,6 @@ var interceptorServer = Object.freeze(new InterceptorServerNamespace_default());
  * This try..catch is for the case when the remote interceptor web socket client is closed before responding.
  * Since simulating this scenario is difficult, we are ignoring this branch fow now. */
 
-export { DEFAULT_ACCESS_CONTROL_HEADERS, DEFAULT_PREFLIGHT_STATUS_CODE, NotStartedInterceptorServerError_default, createCachedDynamicImport, interceptorServer, logWithPrefix };
-//# sourceMappingURL=chunk-3XWHITKR.mjs.map
-//# sourceMappingURL=chunk-3XWHITKR.mjs.map
+export { DEFAULT_ACCESS_CONTROL_HEADERS, DEFAULT_PREFLIGHT_STATUS_CODE, NotStartedInterceptorServerError_default, createCachedDynamicImport_default, interceptorServer, logWithPrefix };
+//# sourceMappingURL=chunk-5ESJW32X.mjs.map
+//# sourceMappingURL=chunk-5ESJW32X.mjs.map