@zimic/interceptor 1.1.2-canary.3 → 1.1.2-canary.4

package/dist/http.mjs

@@ -856,28 +856,31 @@ var LocalHttpRequestHandler = class {
 };
 var LocalHttpRequestHandler_default = LocalHttpRequestHandler;
 
-// ../zimic-utils/dist/chunk-46M3OXFU.mjs
-function getExtraPatternsToEscape() {
+// ../zimic-utils/dist/chunk-TYSDS3LQ.mjs
+function createPathCharactersToEscapeRegex() {
   return /([.(){}+$])/g;
 }
-function getURIEncodedBackSlashPattern() {
-  return /%5C/g;
+function preparePathForRegex(path) {
+  const pathURLPrefix = `data:${path.startsWith("/") ? "" : "/"}`;
+  const pathAsURL = new URL(`${pathURLPrefix}${path}`);
+  const encodedPath = pathAsURL.href.replace(pathURLPrefix, "");
+  return encodedPath.replace(/^\/+/g, "").replace(/\/+$/g, "").replace(createPathCharactersToEscapeRegex(), "\\$1");
 }
-function getPathParamPattern() {
+function createPathParamRegex() {
   return /(?<escape>\\)?:(?<identifier>[$_\p{ID_Start}][$\p{ID_Continue}]+)/gu;
 }
-function getRepeatingPathParamPattern() {
+function createRepeatingPathParamRegex() {
   return /(?<escape>\\)?:(?<identifier>[$_\p{ID_Start}][$\p{ID_Continue}]+)\\+/gu;
 }
-function getOptionalPathParamPattern() {
+function createOptionalPathParamRegex() {
   return /(?<leadingSlash>\/)?(?<escape>\\)?:(?<identifier>[$_\p{ID_Start}][$\p{ID_Continue}]+)\?(?<trailingSlash>\/)?/gu;
 }
-function getOptionalRepeatingPathParamPattern() {
+function createOptionalRepeatingPathParamRegex() {
   return /(?<leadingSlash>\/)?(?<escape>\\)?:(?<identifier>[$_\p{ID_Start}][$\p{ID_Continue}]+)\*(?<trailingSlash>\/)?/gu;
 }
-function createParametrizedPathPattern(path) {
-  const replacedURL = encodeURI(path).replace(/^\/+/g, "").replace(/\/+$/g, "").replace(getExtraPatternsToEscape(), "\\$1").replace(getURIEncodedBackSlashPattern(), "\\").replace(
-    getOptionalRepeatingPathParamPattern(),
+function createRegexFromPath(path) {
+  const pathRegexContent = preparePathForRegex(path).replace(
+    createOptionalRepeatingPathParamRegex(),
     (_match, leadingSlash, escape, identifier, trailingSlash) => {
       if (escape) {
         return `:${identifier}`;
@@ -896,10 +899,10 @@ function createParametrizedPathPattern(path) {
         return `(?<${identifier}>.+?)?`;
       }
     }
-  ).replace(getRepeatingPathParamPattern(), (_match, escape, identifier) => {
+  ).replace(createRepeatingPathParamRegex(), (_match, escape, identifier) => {
     return escape ? `:${identifier}` : `(?<${identifier}>.+)`;
   }).replace(
-    getOptionalPathParamPattern(),
+    createOptionalPathParamRegex(),
     (_match, leadingSlash, escape, identifier, trailingSlash) => {
       if (escape) {
         return `:${identifier}`;
@@ -918,12 +921,12 @@ function createParametrizedPathPattern(path) {
         return `(?<${identifier}>[^\\/]+?)?`;
       }
     }
-  ).replace(getPathParamPattern(), (_match, escape, identifier) => {
+  ).replace(createPathParamRegex(), (_match, escape, identifier) => {
     return escape ? `:${identifier}` : `(?<${identifier}>[^\\/]+?)`;
   });
-  return new RegExp(`^/?${replacedURL}/?$`);
+  return new RegExp(`^/?${pathRegexContent}/?$`);
 }
-var createParametrizedPathPattern_default = createParametrizedPathPattern;
+var createRegexFromPath_default = createRegexFromPath;
 
 // ../zimic-utils/dist/url/excludeURLParams.mjs
 function excludeURLParams(url) {
@@ -1220,7 +1223,7 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
   }
   static parseRawPathParams(request, options) {
     const requestPath = request.url.replace(options?.baseURL ?? "", "");
-    const paramsMatch = options?.pathPattern.exec(requestPath);
+    const paramsMatch = options?.pathRegex.exec(requestPath);
     const params = {};
     for (const [paramName, paramValue] of Object.entries(paramsMatch?.groups ?? {})) {
       params[paramName] = typeof paramValue === "string" ? decodeURIComponent(paramValue) : void 0;
@@ -1572,12 +1575,12 @@ var HttpInterceptorClient = class {
       return;
     }
     this.handlerClientsByMethod[handler.method].set(handler.path, handlerClients);
-    const pathPattern = createParametrizedPathPattern_default(handler.path);
+    const pathRegex = createRegexFromPath_default(handler.path);
     const registrationResult = this.workerOrThrow.use(this, handler.method, handler.path, async (context) => {
       const response = await this.handleInterceptedRequest(
         handler.method,
         handler.path,
-        pathPattern,
+        pathRegex,
         context
       );
       return response;
@@ -1586,10 +1589,10 @@ var HttpInterceptorClient = class {
       handler.registerSyncPromise(registrationResult);
     }
   }
-  async handleInterceptedRequest(method, path, pathPattern, { request }) {
+  async handleInterceptedRequest(method, path, pathRegex, { request }) {
     const parsedRequest = await HttpInterceptorWorker_default.parseRawRequest(request, {
       baseURL: this.baseURLAsString,
-      pathPattern
+      pathRegex
     });
     const matchedHandler = await this.findMatchedHandler(method, path, parsedRequest);
     if (!matchedHandler) {
@@ -1671,7 +1674,7 @@ var DuplicatedPathParamError = class extends Error {
   }
 };
 function validatePathParams(path) {
-  const pathParamMatches = path.toString().matchAll(getPathParamPattern());
+  const pathParamMatches = path.toString().matchAll(createPathParamRegex());
   const uniqueParamNames = /* @__PURE__ */ new Set();
   for (const paramMatch of pathParamMatches) {
     const paramName = paramMatch.groups?.identifier;
@@ -1795,7 +1798,7 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
     const handler = {
       baseURL: interceptor.baseURLAsString,
       method,
-      pathPattern: createParametrizedPathPattern_default(path),
+      pathRegex: createRegexFromPath_default(path),
       interceptor,
       createResponse: async (context) => {
         const request = context.request;
@@ -1832,7 +1835,7 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
         continue;
       }
       const requestPath = requestURLAsString.replace(handler.baseURL, "");
-      const matchesPath = handler.pathPattern.test(requestPath);
+      const matchesPath = handler.pathRegex.test(requestPath);
       if (!matchesPath) {
         continue;
       }