@usertour/helpers 0.0.17 → 0.0.20

package/dist/__tests__/url.test.js

@@ -1,7 +1,8 @@
 import {
   evaluateUrlCondition,
   isMatchUrlPattern
-} from "../chunk-BC7KXBMF.js";
+} from "../chunk-YYIGUZNZ.js";
+import "../chunk-PAESAL23.js";
 import "../chunk-XEO3YXBM.js";
 
 // src/__tests__/url.test.ts
@@ -59,7 +60,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",
@@ -70,7 +71,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 = {
@@ -85,6 +86,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", () => {
@@ -131,7 +223,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";
@@ -193,5 +285,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);
+    });
   });
 });

package/dist/chunk-PAESAL23.js

@@ -0,0 +1,77 @@
+// 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] = match;
+  return {
+    scheme: scheme || "",
+    domain: domain || "",
+    path: path || "",
+    query: query || "",
+    fragment: fragment || ""
+  };
+}
+function escapeRegex(str) {
+  return str.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+}
+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}]+`);
+  }
+  return processed;
+}
+function urlPatternToRegex(pattern) {
+  const parsed = parseUrl(pattern);
+  if (!parsed) {
+    return null;
+  }
+  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) => {
+      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}([&#]|$))`;
+    });
+    queryPattern += "\\?[^#]*";
+  } else {
+    queryPattern = "(\\?[^#]*)?";
+  }
+  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;
+  }
+  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;
+}
+
+export {
+  matchUrlPattern
+};

package/dist/chunk-TB7JGI2Q.js

@@ -0,0 +1,97 @@
+import {
+  evaluateUrlCondition
+} from "./chunk-YYIGUZNZ.js";
+import {
+  evaluateAttributeCondition
+} from "./chunk-PBZSPV5R.js";
+import {
+  evaluateTimeCondition
+} from "./chunk-CEK3SCQO.js";
+
+// src/conditions/condition.ts
+import {
+  RulesType
+} from "@usertour/types";
+import isEqual from "fast-deep-equal";
+var conditionsIsSame = (rr1, rr2) => {
+  return isEqual(rr1, rr2);
+};
+var isConditionsActived = (conditions) => {
+  if (!conditions || conditions.length === 0) {
+    return false;
+  }
+  const operator = conditions[0].operators;
+  const actives = conditions.filter((rule) => {
+    if (!rule.conditions) {
+      return rule.actived;
+    }
+    return isConditionsActived(rule.conditions);
+  });
+  return operator === "and" ? actives.length === conditions.length : actives.length > 0;
+};
+var filterConditionsByType = (conditions, allowedTypes) => {
+  return conditions.filter((condition) => {
+    if (condition.type === "group" && condition.conditions) {
+      const filteredGroupConditions = filterConditionsByType(condition.conditions, allowedTypes);
+      return filteredGroupConditions.length > 0;
+    }
+    return allowedTypes.includes(condition.type);
+  }).map((condition) => {
+    if (condition.type === "group" && condition.conditions) {
+      return {
+        ...condition,
+        conditions: filterConditionsByType(condition.conditions, allowedTypes)
+      };
+    }
+    return condition;
+  });
+};
+var evaluateRule = (rule, options) => {
+  var _a;
+  const { typeControl = {}, activatedIds, deactivatedIds } = options;
+  const ruleId = rule.id;
+  if (activatedIds == null ? void 0 : activatedIds.includes(ruleId))
+    return true;
+  if (deactivatedIds == null ? void 0 : deactivatedIds.includes(ruleId))
+    return false;
+  if (typeControl[rule.type] === false) {
+    return rule.actived || false;
+  }
+  switch (rule.type) {
+    case RulesType.CURRENT_PAGE:
+      return evaluateUrlCondition(rule, ((_a = options.clientContext) == null ? void 0 : _a.page_url) || "");
+    case RulesType.TIME:
+      return evaluateTimeCondition(rule);
+    case RulesType.USER_ATTR:
+    case RulesType.COMPANY_ATTR:
+      return evaluateAttributeCondition(
+        rule,
+        options.attributes || [],
+        options.userAttributes || {}
+      );
+    default:
+      return rule.actived || false;
+  }
+};
+var activedRulesConditions = (conditions, options = {}) => {
+  return conditions.map((rule) => {
+    if (rule.type === "group" && rule.conditions) {
+      return {
+        ...rule,
+        conditions: activedRulesConditions(rule.conditions, options)
+      };
+    }
+    return {
+      ...rule,
+      actived: evaluateRule(rule, options)
+    };
+  });
+};
+
+export {
+  isEqual,
+  conditionsIsSame,
+  isConditionsActived,
+  filterConditionsByType,
+  activedRulesConditions
+};

package/dist/chunk-YYIGUZNZ.js

@@ -0,0 +1,17 @@
+import {
+  matchUrlPattern
+} from "./chunk-PAESAL23.js";
+
+// src/conditions/url.ts
+var isMatchUrlPattern = (_url, includes, excludes) => {
+  return matchUrlPattern({ includes, excludes }, _url);
+};
+var evaluateUrlCondition = (rules, url) => {
+  const { excludes = [], includes = [] } = rules.data || {};
+  return isMatchUrlPattern(url, includes, excludes);
+};
+
+export {
+  isMatchUrlPattern,
+  evaluateUrlCondition
+};

package/dist/conditions/attribute.d.cts

@@ -1,13 +1,5 @@
-import { RulesCondition, UserTourTypes } from '@usertour/types';
+import { RulesCondition, SimpleAttribute, UserTourTypes } from '@usertour/types';
 
-/**
- * Simplified attribute type with only required fields
- */
-interface SimpleAttribute {
-    id: string;
-    codeName: string;
-    dataType: number;
-}
 /**
  * Evaluate filter conditions and return boolean result
  * @param conditions - Filter conditions to evaluate
@@ -25,4 +17,4 @@ declare function evaluateFilterConditions(conditions: RulesCondition[], attribut
  */
 declare function evaluateAttributeCondition(condition: RulesCondition, attributes: SimpleAttribute[], userAttributes: UserTourTypes.Attributes): any;
 
-export { type SimpleAttribute, evaluateAttributeCondition, evaluateFilterConditions };
+export { evaluateAttributeCondition, evaluateFilterConditions };

package/dist/conditions/attribute.d.ts

@@ -1,13 +1,5 @@
-import { RulesCondition, UserTourTypes } from '@usertour/types';
+import { RulesCondition, SimpleAttribute, UserTourTypes } from '@usertour/types';
 
-/**
- * Simplified attribute type with only required fields
- */
-interface SimpleAttribute {
-    id: string;
-    codeName: string;
-    dataType: number;
-}
 /**
  * Evaluate filter conditions and return boolean result
  * @param conditions - Filter conditions to evaluate
@@ -25,4 +17,4 @@ declare function evaluateFilterConditions(conditions: RulesCondition[], attribut
  */
 declare function evaluateAttributeCondition(condition: RulesCondition, attributes: SimpleAttribute[], userAttributes: UserTourTypes.Attributes): any;
 
-export { type SimpleAttribute, evaluateAttributeCondition, evaluateFilterConditions };
+export { evaluateAttributeCondition, evaluateFilterConditions };