@usertour/helpers 0.0.18 → 0.0.21

package/dist/__tests__/url.test.cjs

@@ -1,68 +1,85 @@
 "use strict";
 
-// src/conditions/url.ts
-var parseUrl = (url) => {
-  const urlPatterns = url.match(/^(([a-z\d]+):\/\/)?([^/?#]+)?(\/[^?#]*)?(\?([^#]*))?(#.*)?$/i);
-  if (!urlPatterns) {
+// src/conditions/url-v2.ts
+function parseUrl(url) {
+  const match = url.match(/^(([a-z\d]+):\/\/)?([^/?#]+)?(\/[^?#]*)?(\?([^#]*))?(#.*)?$/i);
+  if (!match)
     return null;
-  }
-  const [, , scheme = "", domain = "", path = "", , query = "", fragment = ""] = urlPatterns;
-  return { scheme, domain, path, query, fragment };
-};
-var replaceWildcard = (input, s1, s2) => {
-  const withSpecialWords = replaceSpecialWords(input);
-  const withWildcard = withSpecialWords.replace(/\\\*/g, `${s1}*`);
-  if (!s2) {
-    return withWildcard;
-  }
-  return withWildcard.replace(/:[a-z0-9_]+/g, `[^${s2}]+`);
-};
-var replaceSpecialWords = (str) => {
+  const [, , scheme, domain, path, , query, fragment] = match;
+  return {
+    scheme: scheme || "",
+    domain: domain || "",
+    path: path || "",
+    query: query || "",
+    fragment: fragment || ""
+  };
+}
+function escapeRegex(str) {
   return str.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
-};
-var parsePattern = (pattern) => {
-  if (!pattern || !pattern.trim()) {
-    return null;
+}
+function processUrlPattern(pattern, wildcardReplacement, paramReplacement) {
+  let processed = escapeRegex(pattern);
+  processed = processed.replace(/\\\*/g, `${wildcardReplacement}*`);
+  if (paramReplacement) {
+    processed = processed.replace(/:[a-zA-Z0-9_]+/g, `[^${paramReplacement}]+`);
   }
-  const _pattern = parseUrl(pattern);
-  if (!_pattern) {
-    console.error("Invalid URL pattern:", pattern);
+  return processed;
+}
+function urlPatternToRegex(pattern) {
+  const parsed = parseUrl(pattern);
+  if (!parsed) {
     return null;
   }
-  const { scheme, domain, path, query, fragment } = _pattern;
-  const _scheme = scheme ? replaceSpecialWords(scheme) : "[a-z\\d]+";
-  const _domain = domain ? replaceWildcard(domain, "[^/]", ".") : "[^/]*";
-  const _fragment = fragment ? replaceWildcard(fragment, ".", "/") : "(#.*)?";
-  const _path = path ? replaceWildcard(path, "[^?#]", "/") : "/[^?#]*";
-  let _query = "(\\?[^#]*)?";
+  const { scheme, domain, path, query, fragment } = parsed;
+  const schemePattern = scheme ? escapeRegex(scheme) : "[a-z\\d]+";
+  const domainPattern = domain ? processUrlPattern(domain, "[^/]", ".") : "[^/]*";
+  const portPattern = "(:\\d+)?";
+  const pathPattern = path ? processUrlPattern(path, "[^?#]", "/") : "/[^?#]*";
+  let queryPattern;
   if (query) {
+    queryPattern = "";
     new URLSearchParams(query).forEach((value, key) => {
-      const _str = value === "" ? "=?" : value === "*" ? "(=[^&#]*)?" : `=${replaceWildcard(value, "[^#]")}`;
-      _query += `(?=.*[?&]${replaceSpecialWords(key)}${_str}([&#]|$))`;
+      let valuePattern;
+      if (value === "") {
+        valuePattern = "=?";
+      } else if (value === "*") {
+        valuePattern = "(=[^&#]*)?";
+      } else {
+        const encodedValue = value.split(/\*/g).map((part) => encodeURI(part)).join("*");
+        valuePattern = `=${processUrlPattern(encodedValue, "[^#]")}`;
+      }
+      queryPattern += `(?=.*[?&]${escapeRegex(key)}${valuePattern}([&#]|$))`;
     });
-    _query += "\\?[^#]*";
+    queryPattern += "\\?[^#]*";
+  } else {
+    queryPattern = "(\\?[^#]*)?";
   }
-  return new RegExp(`^${_scheme}://${_domain}(:\\d+)?${_path}${_query}${_fragment}$`);
-};
-var isMatchUrlPattern = (_url, includes, excludes) => {
-  const isMatchIncludesConditions = includes.length > 0 ? includes.some((_include) => {
-    const reg = parsePattern(_include);
-    if (reg) {
-      return reg.test(_url);
-    }
+  const fragmentPattern = fragment ? processUrlPattern(fragment, ".", "/") : "(#.*)?";
+  return new RegExp(
+    `^${schemePattern}://${domainPattern}${portPattern}${pathPattern}${queryPattern}${fragmentPattern}$`
+  );
+}
+function matchUrlPattern(urlPattern, url) {
+  if (urlPattern.includes.length === 0 && urlPattern.excludes.length === 0) {
     return false;
-  }) : true;
-  const isMatchExcludesConditions = excludes.length > 0 ? excludes.some((_exclude) => {
-    const reg = parsePattern(_exclude);
-    if (reg) {
-      return reg.test(_url);
-    }
-    return false;
-  }) : false;
-  return isMatchIncludesConditions && !isMatchExcludesConditions;
+  }
+  const matchesInclude = urlPattern.includes.length === 0 || urlPattern.includes.some((includePattern) => {
+    const regex = urlPatternToRegex(includePattern);
+    return regex && url.match(regex);
+  });
+  const matchesExclude = urlPattern.excludes.some((excludePattern) => {
+    const regex = urlPatternToRegex(excludePattern);
+    return regex && url.match(regex);
+  });
+  return matchesInclude && !matchesExclude;
+}
+
+// src/conditions/url.ts
+var isMatchUrlPattern = (_url, includes, excludes) => {
+  return matchUrlPattern({ includes, excludes }, _url);
 };
 var evaluateUrlCondition = (rules, url) => {
-  const { excludes, includes } = rules.data;
+  const { excludes = [], includes = [] } = rules.data || {};
   return isMatchUrlPattern(url, includes, excludes);
 };
 
@@ -121,7 +138,7 @@ describe("URL Condition Evaluation", () => {
       const url = "https://example.com/dashboard";
       expect(evaluateUrlCondition(rules, url)).toBe(true);
     });
-    test("should return true when no includes specified (matches all)", () => {
+    test("should return false when no includes and no excludes specified", () => {
       const rules = {
         id: "condition-5",
         type: "condition",
@@ -132,7 +149,7 @@ describe("URL Condition Evaluation", () => {
         }
       };
       const url = "https://example.com/dashboard";
-      expect(evaluateUrlCondition(rules, url)).toBe(true);
+      expect(evaluateUrlCondition(rules, url)).toBe(false);
     });
     test("should return false when URL matches exclude even with no includes", () => {
       const rules = {
@@ -147,6 +164,97 @@ describe("URL Condition Evaluation", () => {
       const url = "https://example.com/admin";
       expect(evaluateUrlCondition(rules, url)).toBe(false);
     });
+    test("should handle URLs with ports", () => {
+      const rules = {
+        id: "condition-7",
+        type: "condition",
+        operators: "and",
+        data: {
+          includes: ["https://example.com:8080/dashboard"],
+          excludes: []
+        }
+      };
+      const url = "https://example.com:8080/dashboard";
+      expect(evaluateUrlCondition(rules, url)).toBe(true);
+    });
+    test("should handle URLs with complex query parameters", () => {
+      const rules = {
+        id: "condition-8",
+        type: "condition",
+        operators: "and",
+        data: {
+          includes: ["https://example.com/dashboard?tab=overview&user=123"],
+          excludes: []
+        }
+      };
+      const url = "https://example.com/dashboard?tab=overview&user=123";
+      expect(evaluateUrlCondition(rules, url)).toBe(true);
+    });
+    test("should handle URLs with special characters in query parameters", () => {
+      const rules = {
+        id: "condition-9",
+        type: "condition",
+        operators: "and",
+        data: {
+          includes: ["https://example.com/search?q=hello+world"],
+          excludes: []
+        }
+      };
+      const url = "https://example.com/search?q=hello+world";
+      expect(evaluateUrlCondition(rules, url)).toBe(false);
+    });
+    test("should handle URLs with fragments", () => {
+      const rules = {
+        id: "condition-10",
+        type: "condition",
+        operators: "and",
+        data: {
+          includes: ["https://example.com/dashboard#overview"],
+          excludes: []
+        }
+      };
+      const url = "https://example.com/dashboard#overview";
+      expect(evaluateUrlCondition(rules, url)).toBe(true);
+    });
+    test("should handle wildcard patterns in query parameters", () => {
+      const rules = {
+        id: "condition-11",
+        type: "condition",
+        operators: "and",
+        data: {
+          includes: ["https://example.com/dashboard?tab=*"],
+          excludes: []
+        }
+      };
+      const url = "https://example.com/dashboard?tab=overview";
+      expect(evaluateUrlCondition(rules, url)).toBe(true);
+    });
+    test("should handle empty query parameter values", () => {
+      const rules = {
+        id: "condition-12",
+        type: "condition",
+        operators: "and",
+        data: {
+          includes: ["https://example.com/dashboard?tab="],
+          excludes: []
+        }
+      };
+      const url = "https://example.com/dashboard?tab=";
+      expect(evaluateUrlCondition(rules, url)).toBe(true);
+    });
+    test("should handle multiple query parameters with wildcards", () => {
+      const rules = {
+        id: "condition-13",
+        type: "condition",
+        operators: "and",
+        data: {
+          includes: ["https://example.com/dashboard?tab=*&user=*"],
+          excludes: []
+        }
+      };
+      const url = "https://example.com/dashboard?tab=overview&user=123";
+      expect(evaluateUrlCondition(rules, url)).toBe(true);
+    });
   });
   describe("isMatchUrlPattern", () => {
     test("should match exact URL", () => {
@@ -193,7 +301,7 @@ describe("URL Condition Evaluation", () => {
       const url = "https://example.com/dashboard";
       const includes = [];
       const excludes = [];
-      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(false);
     });
     test("should handle empty excludes", () => {
       const url = "https://example.com/dashboard";
@@ -255,5 +363,157 @@ describe("URL Condition Evaluation", () => {
       const excludes = ["https://example.com/admin", "https://example.com/settings"];
       expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
     });
+    test("should handle URLs with special regex characters", () => {
+      const url = "https://example.com/dashboard?param=value+with+spaces";
+      const includes = ["https://example.com/dashboard?param=value+with+spaces"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(false);
+    });
+    test("should handle URLs with encoded characters", () => {
+      const url = "https://example.com/search?q=hello%20world";
+      const includes = ["https://example.com/search?q=hello%20world"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URLs with multiple query parameters in different order", () => {
+      const url = "https://example.com/dashboard?tab=overview&user=123&theme=dark";
+      const includes = ["https://example.com/dashboard?user=123&tab=overview"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URLs with empty path", () => {
+      const url = "https://example.com/";
+      const includes = ["https://example.com/"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URLs with root path wildcard", () => {
+      const url = "https://example.com/";
+      const includes = ["https://example.com/*"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URLs with subdomain wildcards", () => {
+      const url = "https://app.example.com/dashboard";
+      const includes = ["https://*.example.com/dashboard"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URLs with port numbers", () => {
+      const url = "https://example.com:3000/dashboard";
+      const includes = ["https://example.com:3000/dashboard"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URLs with port wildcards", () => {
+      const url = "https://example.com:8080/dashboard";
+      const includes = ["https://example.com:*/dashboard"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle complex fragment patterns", () => {
+      const url = "https://example.com/dashboard#section-1";
+      const includes = ["https://example.com/dashboard#section-*"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URLs with special characters in path", () => {
+      const url = "https://example.com/user/123/profile";
+      const includes = ["https://example.com/user/*/profile"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URLs with query parameters containing special characters", () => {
+      const url = "https://example.com/search?q=hello&filter=active";
+      const includes = ["https://example.com/search?q=*&filter=active"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URLs with empty query parameter values", () => {
+      const url = "https://example.com/dashboard?tab=";
+      const includes = ["https://example.com/dashboard?tab="];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URLs with query parameters that have no value", () => {
+      const url = "https://example.com/dashboard?tab";
+      const includes = ["https://example.com/dashboard?tab"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URLs with multiple fragments", () => {
+      const url = "https://example.com/dashboard#section-1#subsection-a";
+      const includes = ["https://example.com/dashboard#section-1#*"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URLs with IPv4 addresses", () => {
+      const url = "https://192.168.1.1/dashboard";
+      const includes = ["https://192.168.1.1/dashboard"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URLs with IPv6 addresses", () => {
+      const url = "https://[2001:db8::1]/dashboard";
+      const includes = ["https://[2001:db8::1]/dashboard"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URLs with mixed case in domain", () => {
+      const url = "https://Example.COM/dashboard";
+      const includes = ["https://example.com/dashboard"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(false);
+    });
+    test("should handle URLs with mixed case in path", () => {
+      const url = "https://example.com/Dashboard";
+      const includes = ["https://example.com/dashboard"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(false);
+    });
+  });
+  describe("Implementation Compatibility Tests", () => {
+    test("should handle query parameters with special characters consistently", () => {
+      const url = "https://example.com/search?q=hello+world&filter=active";
+      const includes = ["https://example.com/search?q=hello+world"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(false);
+    });
+    test("should handle query parameters with encoded characters consistently", () => {
+      const url = "https://example.com/search?q=hello%20world";
+      const includes = ["https://example.com/search?q=hello%20world"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle query parameters with wildcards consistently", () => {
+      const url = "https://example.com/search?q=hello&filter=*";
+      const includes = ["https://example.com/search?q=*&filter=active"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(false);
+    });
+    test("should handle empty includes and excludes consistently", () => {
+      const url = "https://example.com/dashboard";
+      const includes = [];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(false);
+    });
+    test("should handle only excludes consistently", () => {
+      const url = "https://example.com/dashboard";
+      const includes = [];
+      const excludes = ["https://example.com/admin"];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle complex nested paths consistently", () => {
+      const url = "https://example.com/app/dashboard/user/123/settings";
+      const includes = ["https://example.com/app/*/user/*/settings"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URLs with multiple query parameters consistently", () => {
+      const url = "https://example.com/dashboard?tab=overview&user=123&theme=dark&lang=en";
+      const includes = ["https://example.com/dashboard?tab=overview&user=*&theme=dark"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
   });
 });