@usertour/helpers 0.0.15 → 0.0.17

package/dist/__tests__/time.test.cjs

@@ -0,0 +1,73 @@
+"use strict";
+
+// src/conditions/time.ts
+var import_date_fns = require("date-fns");
+var evaluateTimeCondition = (rules) => {
+  try {
+    const { endDate, endDateHour, endDateMinute, startDate, startDateHour, startDateMinute } = rules.data || {};
+    if (!startDate || !startDateHour || !startDateMinute) {
+      return false;
+    }
+    const startTimeString = `${startDate}T${startDateHour.padStart(2, "0")}:${startDateMinute.padStart(2, "0")}:00`;
+    const startTime = (0, import_date_fns.parseISO)(startTimeString);
+    if (!(0, import_date_fns.isValid)(startTime)) {
+      return false;
+    }
+    const now = /* @__PURE__ */ new Date();
+    if (!endDate || !endDateHour || !endDateMinute) {
+      return (0, import_date_fns.isAfter)(now, startTime);
+    }
+    const endTimeString = `${endDate}T${endDateHour.padStart(2, "0")}:${endDateMinute.padStart(2, "0")}:00`;
+    const endTime = (0, import_date_fns.parseISO)(endTimeString);
+    if (!(0, import_date_fns.isValid)(endTime)) {
+      return false;
+    }
+    return (0, import_date_fns.isAfter)(now, startTime) && (0, import_date_fns.isBefore)(now, endTime);
+  } catch {
+    return false;
+  }
+};
+
+// src/__tests__/time.test.ts
+describe("Time Condition Evaluation", () => {
+  const mockNow = /* @__PURE__ */ new Date("2024-01-15T12:00:00Z");
+  beforeAll(() => {
+    jest.useFakeTimers();
+    jest.setSystemTime(mockNow);
+  });
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+  test("should return true when current time is after start time and no end time", () => {
+    const rules = {
+      id: "condition-1",
+      type: "condition",
+      operators: "and",
+      data: {
+        startDate: "2024-01-15",
+        startDateHour: "10",
+        startDateMinute: "00",
+        endDate: "",
+        endDateHour: "",
+        endDateMinute: ""
+      }
+    };
+    expect(evaluateTimeCondition(rules)).toBe(true);
+  });
+  test("should return true when current time is within start and end time range", () => {
+    const rules = {
+      id: "condition-2",
+      type: "condition",
+      operators: "and",
+      data: {
+        startDate: "2024-01-15",
+        startDateHour: "10",
+        startDateMinute: "00",
+        endDate: "2024-01-15",
+        endDateHour: "14",
+        endDateMinute: "00"
+      }
+    };
+    expect(evaluateTimeCondition(rules)).toBe(false);
+  });
+});

package/dist/__tests__/time.test.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/__tests__/time.test.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/__tests__/time.test.js

@@ -0,0 +1,48 @@
+import {
+  evaluateTimeCondition
+} from "../chunk-CEK3SCQO.js";
+import "../chunk-XEO3YXBM.js";
+
+// src/__tests__/time.test.ts
+describe("Time Condition Evaluation", () => {
+  const mockNow = /* @__PURE__ */ new Date("2024-01-15T12:00:00Z");
+  beforeAll(() => {
+    jest.useFakeTimers();
+    jest.setSystemTime(mockNow);
+  });
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+  test("should return true when current time is after start time and no end time", () => {
+    const rules = {
+      id: "condition-1",
+      type: "condition",
+      operators: "and",
+      data: {
+        startDate: "2024-01-15",
+        startDateHour: "10",
+        startDateMinute: "00",
+        endDate: "",
+        endDateHour: "",
+        endDateMinute: ""
+      }
+    };
+    expect(evaluateTimeCondition(rules)).toBe(true);
+  });
+  test("should return true when current time is within start and end time range", () => {
+    const rules = {
+      id: "condition-2",
+      type: "condition",
+      operators: "and",
+      data: {
+        startDate: "2024-01-15",
+        startDateHour: "10",
+        startDateMinute: "00",
+        endDate: "2024-01-15",
+        endDateHour: "14",
+        endDateMinute: "00"
+      }
+    };
+    expect(evaluateTimeCondition(rules)).toBe(false);
+  });
+});

package/dist/__tests__/url.test.cjs

@@ -0,0 +1,259 @@
+"use strict";
+
+// src/conditions/url.ts
+var parseUrl = (url) => {
+  const urlPatterns = url.match(/^(([a-z\d]+):\/\/)?([^/?#]+)?(\/[^?#]*)?(\?([^#]*))?(#.*)?$/i);
+  if (!urlPatterns) {
+    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) => {
+  return str.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+};
+var parsePattern = (pattern) => {
+  if (!pattern || !pattern.trim()) {
+    return null;
+  }
+  const _pattern = parseUrl(pattern);
+  if (!_pattern) {
+    console.error("Invalid URL pattern:", pattern);
+    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 = "(\\?[^#]*)?";
+  if (query) {
+    new URLSearchParams(query).forEach((value, key) => {
+      const _str = value === "" ? "=?" : value === "*" ? "(=[^&#]*)?" : `=${replaceWildcard(value, "[^#]")}`;
+      _query += `(?=.*[?&]${replaceSpecialWords(key)}${_str}([&#]|$))`;
+    });
+    _query += "\\?[^#]*";
+  }
+  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);
+    }
+    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;
+};
+var evaluateUrlCondition = (rules, url) => {
+  const { excludes, includes } = rules.data;
+  return isMatchUrlPattern(url, includes, excludes);
+};
+
+// src/__tests__/url.test.ts
+describe("URL Condition Evaluation", () => {
+  describe("evaluateUrlCondition", () => {
+    test("should return true when URL matches include pattern and no excludes", () => {
+      const rules = {
+        id: "condition-1",
+        type: "condition",
+        operators: "and",
+        data: {
+          includes: ["https://example.com/dashboard"],
+          excludes: []
+        }
+      };
+      const url = "https://example.com/dashboard";
+      expect(evaluateUrlCondition(rules, url)).toBe(true);
+    });
+    test("should return false when URL does not match include pattern", () => {
+      const rules = {
+        id: "condition-2",
+        type: "condition",
+        operators: "and",
+        data: {
+          includes: ["https://example.com/dashboard"],
+          excludes: []
+        }
+      };
+      const url = "https://example.com/profile";
+      expect(evaluateUrlCondition(rules, url)).toBe(false);
+    });
+    test("should return false when URL matches exclude pattern", () => {
+      const rules = {
+        id: "condition-3",
+        type: "condition",
+        operators: "and",
+        data: {
+          includes: ["https://example.com/*"],
+          excludes: ["https://example.com/admin"]
+        }
+      };
+      const url = "https://example.com/admin";
+      expect(evaluateUrlCondition(rules, url)).toBe(false);
+    });
+    test("should return true when URL matches include but not exclude", () => {
+      const rules = {
+        id: "condition-4",
+        type: "condition",
+        operators: "and",
+        data: {
+          includes: ["https://example.com/*"],
+          excludes: ["https://example.com/admin"]
+        }
+      };
+      const url = "https://example.com/dashboard";
+      expect(evaluateUrlCondition(rules, url)).toBe(true);
+    });
+    test("should return true when no includes specified (matches all)", () => {
+      const rules = {
+        id: "condition-5",
+        type: "condition",
+        operators: "and",
+        data: {
+          includes: [],
+          excludes: []
+        }
+      };
+      const url = "https://example.com/dashboard";
+      expect(evaluateUrlCondition(rules, url)).toBe(true);
+    });
+    test("should return false when URL matches exclude even with no includes", () => {
+      const rules = {
+        id: "condition-6",
+        type: "condition",
+        operators: "and",
+        data: {
+          includes: [],
+          excludes: ["https://example.com/admin"]
+        }
+      };
+      const url = "https://example.com/admin";
+      expect(evaluateUrlCondition(rules, url)).toBe(false);
+    });
+  });
+  describe("isMatchUrlPattern", () => {
+    test("should match exact URL", () => {
+      const url = "https://example.com/dashboard";
+      const includes = ["https://example.com/dashboard"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should match wildcard pattern", () => {
+      const url = "https://example.com/dashboard";
+      const includes = ["https://example.com/*"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should match multiple include patterns", () => {
+      const url = "https://example.com/dashboard";
+      const includes = [
+        "https://example.com/profile",
+        "https://example.com/dashboard",
+        "https://example.com/settings"
+      ];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should not match when no includes match", () => {
+      const url = "https://example.com/dashboard";
+      const includes = ["https://example.com/profile", "https://example.com/settings"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(false);
+    });
+    test("should not match when URL is excluded", () => {
+      const url = "https://example.com/admin";
+      const includes = ["https://example.com/*"];
+      const excludes = ["https://example.com/admin"];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(false);
+    });
+    test("should match when URL matches include but not exclude", () => {
+      const url = "https://example.com/dashboard";
+      const includes = ["https://example.com/*"];
+      const excludes = ["https://example.com/admin"];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle empty includes (matches all)", () => {
+      const url = "https://example.com/dashboard";
+      const includes = [];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle empty excludes", () => {
+      const url = "https://example.com/dashboard";
+      const includes = ["https://example.com/*"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle complex URL patterns with query parameters", () => {
+      const url = "https://example.com/dashboard?tab=overview&user=123";
+      const includes = ["https://example.com/dashboard?tab=*"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URL patterns with path parameters", () => {
+      const url = "https://example.com/users/123/profile";
+      const includes = ["https://example.com/users/*/profile"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URL patterns with fragments", () => {
+      const url = "https://example.com/dashboard#overview";
+      const includes = ["https://example.com/dashboard#*"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URLs without protocol", () => {
+      const url = "https://example.com/dashboard";
+      const includes = ["example.com/dashboard"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URLs with different protocols", () => {
+      const url = "http://example.com/dashboard";
+      const includes = ["https://example.com/dashboard"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(false);
+    });
+    test("should handle invalid URL patterns gracefully", () => {
+      const url = "https://example.com/dashboard";
+      const includes = ["invalid-url-pattern"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(false);
+    });
+    test("should handle empty URL", () => {
+      const url = "";
+      const includes = ["https://example.com/*"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(false);
+    });
+    test("should handle multiple exclude patterns", () => {
+      const url = "https://example.com/admin";
+      const includes = ["https://example.com/*"];
+      const excludes = ["https://example.com/admin", "https://example.com/settings"];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(false);
+    });
+    test("should match when URL matches include but not any exclude", () => {
+      const url = "https://example.com/dashboard";
+      const includes = ["https://example.com/*"];
+      const excludes = ["https://example.com/admin", "https://example.com/settings"];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+  });
+});

package/dist/__tests__/url.test.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/__tests__/url.test.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/__tests__/url.test.js

@@ -0,0 +1,197 @@
+import {
+  evaluateUrlCondition,
+  isMatchUrlPattern
+} from "../chunk-BC7KXBMF.js";
+import "../chunk-XEO3YXBM.js";
+
+// src/__tests__/url.test.ts
+describe("URL Condition Evaluation", () => {
+  describe("evaluateUrlCondition", () => {
+    test("should return true when URL matches include pattern and no excludes", () => {
+      const rules = {
+        id: "condition-1",
+        type: "condition",
+        operators: "and",
+        data: {
+          includes: ["https://example.com/dashboard"],
+          excludes: []
+        }
+      };
+      const url = "https://example.com/dashboard";
+      expect(evaluateUrlCondition(rules, url)).toBe(true);
+    });
+    test("should return false when URL does not match include pattern", () => {
+      const rules = {
+        id: "condition-2",
+        type: "condition",
+        operators: "and",
+        data: {
+          includes: ["https://example.com/dashboard"],
+          excludes: []
+        }
+      };
+      const url = "https://example.com/profile";
+      expect(evaluateUrlCondition(rules, url)).toBe(false);
+    });
+    test("should return false when URL matches exclude pattern", () => {
+      const rules = {
+        id: "condition-3",
+        type: "condition",
+        operators: "and",
+        data: {
+          includes: ["https://example.com/*"],
+          excludes: ["https://example.com/admin"]
+        }
+      };
+      const url = "https://example.com/admin";
+      expect(evaluateUrlCondition(rules, url)).toBe(false);
+    });
+    test("should return true when URL matches include but not exclude", () => {
+      const rules = {
+        id: "condition-4",
+        type: "condition",
+        operators: "and",
+        data: {
+          includes: ["https://example.com/*"],
+          excludes: ["https://example.com/admin"]
+        }
+      };
+      const url = "https://example.com/dashboard";
+      expect(evaluateUrlCondition(rules, url)).toBe(true);
+    });
+    test("should return true when no includes specified (matches all)", () => {
+      const rules = {
+        id: "condition-5",
+        type: "condition",
+        operators: "and",
+        data: {
+          includes: [],
+          excludes: []
+        }
+      };
+      const url = "https://example.com/dashboard";
+      expect(evaluateUrlCondition(rules, url)).toBe(true);
+    });
+    test("should return false when URL matches exclude even with no includes", () => {
+      const rules = {
+        id: "condition-6",
+        type: "condition",
+        operators: "and",
+        data: {
+          includes: [],
+          excludes: ["https://example.com/admin"]
+        }
+      };
+      const url = "https://example.com/admin";
+      expect(evaluateUrlCondition(rules, url)).toBe(false);
+    });
+  });
+  describe("isMatchUrlPattern", () => {
+    test("should match exact URL", () => {
+      const url = "https://example.com/dashboard";
+      const includes = ["https://example.com/dashboard"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should match wildcard pattern", () => {
+      const url = "https://example.com/dashboard";
+      const includes = ["https://example.com/*"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should match multiple include patterns", () => {
+      const url = "https://example.com/dashboard";
+      const includes = [
+        "https://example.com/profile",
+        "https://example.com/dashboard",
+        "https://example.com/settings"
+      ];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should not match when no includes match", () => {
+      const url = "https://example.com/dashboard";
+      const includes = ["https://example.com/profile", "https://example.com/settings"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(false);
+    });
+    test("should not match when URL is excluded", () => {
+      const url = "https://example.com/admin";
+      const includes = ["https://example.com/*"];
+      const excludes = ["https://example.com/admin"];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(false);
+    });
+    test("should match when URL matches include but not exclude", () => {
+      const url = "https://example.com/dashboard";
+      const includes = ["https://example.com/*"];
+      const excludes = ["https://example.com/admin"];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle empty includes (matches all)", () => {
+      const url = "https://example.com/dashboard";
+      const includes = [];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle empty excludes", () => {
+      const url = "https://example.com/dashboard";
+      const includes = ["https://example.com/*"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle complex URL patterns with query parameters", () => {
+      const url = "https://example.com/dashboard?tab=overview&user=123";
+      const includes = ["https://example.com/dashboard?tab=*"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URL patterns with path parameters", () => {
+      const url = "https://example.com/users/123/profile";
+      const includes = ["https://example.com/users/*/profile"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URL patterns with fragments", () => {
+      const url = "https://example.com/dashboard#overview";
+      const includes = ["https://example.com/dashboard#*"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URLs without protocol", () => {
+      const url = "https://example.com/dashboard";
+      const includes = ["example.com/dashboard"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+    test("should handle URLs with different protocols", () => {
+      const url = "http://example.com/dashboard";
+      const includes = ["https://example.com/dashboard"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(false);
+    });
+    test("should handle invalid URL patterns gracefully", () => {
+      const url = "https://example.com/dashboard";
+      const includes = ["invalid-url-pattern"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(false);
+    });
+    test("should handle empty URL", () => {
+      const url = "";
+      const includes = ["https://example.com/*"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(false);
+    });
+    test("should handle multiple exclude patterns", () => {
+      const url = "https://example.com/admin";
+      const includes = ["https://example.com/*"];
+      const excludes = ["https://example.com/admin", "https://example.com/settings"];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(false);
+    });
+    test("should match when URL matches include but not any exclude", () => {
+      const url = "https://example.com/dashboard";
+      const includes = ["https://example.com/*"];
+      const excludes = ["https://example.com/admin", "https://example.com/settings"];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
+  });
+});

package/dist/{chunk-B4DTY6GN.js → chunk-4LLDSAHJ.js}

@@ -44,17 +44,6 @@ var defaultContentConfig = {
   autoStartRulesSetting: rulesSetting,
   hideRulesSetting
 };
-var autoStartConditions = {
-  ...defaultContentConfig,
-  enabledAutoStartRules: true,
-  autoStartRules: [
-    {
-      data: { excludes: [], includes: ["/*"] },
-      type: "current-page",
-      operators: "and"
-    }
-  ]
-};
 var buildConfig = (config) => {
   return {
     ...defaultContentConfig,
@@ -71,6 +60,5 @@ export {
   isPublishedInAllEnvironments,
   isPublishedAtLeastOneEnvironment,
   defaultContentConfig,
-  autoStartConditions,
   buildConfig
 };

package/dist/chunk-7CC4WXB3.js

@@ -0,0 +1,60 @@
+// src/conditions/condition.ts
+import isEqual from "fast-deep-equal";
+var compareConditionsItem = (item1, item2) => {
+  const { data = {}, ...others1 } = item1;
+  const { data: data2 = {}, ...others2 } = item2;
+  if (!isEqual(others2, others1)) {
+    return false;
+  }
+  for (const key in data) {
+    if (!isEqual(data[key], data2[key])) {
+      return false;
+    }
+  }
+  return true;
+};
+var conditionsIsSame = (rr1, rr2) => {
+  const r1 = [...rr1];
+  const r2 = [...rr2];
+  if (r1.length === 0 && r2.length === 0) {
+    return true;
+  }
+  if (r1.length !== r2.length) {
+    return false;
+  }
+  const group1 = r1.filter((item) => item.type === "group");
+  const group2 = r2.filter((item) => item.type === "group");
+  if (group1.length !== group2.length) {
+    return false;
+  }
+  for (let index = 0; index < r1.length; index++) {
+    const item1 = r1[index];
+    const item2 = r2[index];
+    if (!item1 || !item2) {
+      return false;
+    }
+    if (item1.type === "group") {
+      if (!item2.conditions) {
+        return false;
+      }
+      const c1 = item1.conditions;
+      const c2 = item2.conditions;
+      if (item1.operators !== item2.operators) {
+        return false;
+      }
+      if (!conditionsIsSame(c1, c2)) {
+        return false;
+      }
+    } else {
+      if (!compareConditionsItem(item1, item2)) {
+        return false;
+      }
+    }
+  }
+  return true;
+};
+
+export {
+  isEqual,
+  conditionsIsSame
+};