@usertour/helpers 0.0.17 → 0.0.20

package/dist/conditions/condition.cjs

@@ -30,66 +30,387 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/conditions/condition.ts
 var condition_exports = {};
 __export(condition_exports, {
+  activedRulesConditions: () => activedRulesConditions,
   conditionsIsSame: () => conditionsIsSame,
+  filterConditionsByType: () => filterConditionsByType,
+  isConditionsActived: () => isConditionsActived,
   isEqual: () => import_fast_deep_equal.default
 });
 module.exports = __toCommonJS(condition_exports);
+var import_types2 = require("@usertour/types");
 var import_fast_deep_equal = __toESM(require("fast-deep-equal"), 1);
-var compareConditionsItem = (item1, item2) => {
-  const { data = {}, ...others1 } = item1;
-  const { data: data2 = {}, ...others2 } = item2;
-  if (!(0, import_fast_deep_equal.default)(others2, others1)) {
+
+// 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;
   }
-  for (const key in data) {
-    if (!(0, import_fast_deep_equal.default)(data[key], data2[key])) {
+  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 || {};
+  return isMatchUrlPattern(url, includes, excludes);
+};
+
+// 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;
   }
-  return true;
 };
-var conditionsIsSame = (rr1, rr2) => {
-  const r1 = [...rr1];
-  const r2 = [...rr2];
-  if (r1.length === 0 && r2.length === 0) {
-    return true;
+
+// src/conditions/attribute.ts
+var import_types = require("@usertour/types");
+var import_date_fns2 = require("date-fns");
+function evaluateAttributeCondition(condition, attributes, userAttributes) {
+  const { data } = condition;
+  if (!data) {
+    return false;
   }
-  if (r1.length !== r2.length) {
+  const { logic, value, attrId, value2, listValues = [] } = data;
+  if (!attrId) {
     return false;
   }
-  const group1 = r1.filter((item) => item.type === "group");
-  const group2 = r2.filter((item) => item.type === "group");
-  if (group1.length !== group2.length) {
+  const attr = attributes.find((attr2) => attr2.id === attrId);
+  if (!attr) {
     return false;
   }
-  for (let index = 0; index < r1.length; index++) {
-    const item1 = r1[index];
-    const item2 = r2[index];
-    if (!item1 || !item2) {
-      return false;
+  const actualValue = getAttributeValue(attr.codeName, userAttributes);
+  if (attr.dataType === import_types.BizAttributeTypes.String) {
+    return evaluateStringCondition(logic, actualValue, value);
+  }
+  if (attr.dataType === import_types.BizAttributeTypes.Number) {
+    return evaluateNumberCondition(logic, actualValue, value, value2);
+  }
+  if (attr.dataType === import_types.BizAttributeTypes.Boolean) {
+    return evaluateBooleanCondition(logic, actualValue);
+  }
+  if (attr.dataType === import_types.BizAttributeTypes.List) {
+    return evaluateListCondition(logic, actualValue, listValues);
+  }
+  if (attr.dataType === import_types.BizAttributeTypes.DateTime) {
+    return evaluateDateTimeCondition(logic, actualValue, value);
+  }
+  return false;
+}
+function getAttributeValue(codeName, userAttributes) {
+  return userAttributes == null ? void 0 : userAttributes[codeName];
+}
+function evaluateStringCondition(logic, actualValue, expectedValue) {
+  const stringValue = actualValue === null || actualValue === void 0 ? "" : String(actualValue);
+  switch (logic) {
+    case "is":
+      return stringValue === expectedValue;
+    case "not":
+      return stringValue !== expectedValue;
+    case "contains":
+      return stringValue.includes(expectedValue);
+    case "notContain":
+      return !stringValue.includes(expectedValue);
+    case "startsWith":
+      return stringValue.startsWith(expectedValue);
+    case "endsWith":
+      return stringValue.endsWith(expectedValue);
+    case "empty": {
+      const isEmpty = !stringValue || stringValue === "";
+      return isEmpty;
     }
-    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)) {
+    case "any":
+      return Boolean(stringValue && stringValue !== "");
+    default:
+      return false;
+  }
+}
+function evaluateNumberCondition(logic, actualValue, expectedValue, expectedValue2) {
+  const numValue = Number(actualValue);
+  const numValue2 = Number(expectedValue2);
+  if (Number.isNaN(numValue)) {
+    return false;
+  }
+  switch (logic) {
+    case "is":
+      return numValue === expectedValue;
+    case "not":
+      return numValue !== expectedValue;
+    case "isLessThan":
+      return numValue < expectedValue;
+    case "isLessThanOrEqualTo":
+      return numValue <= expectedValue;
+    case "isGreaterThan":
+      return numValue > expectedValue;
+    case "isGreaterThanOrEqualTo":
+      return numValue >= expectedValue;
+    case "between":
+      return numValue >= expectedValue && numValue <= numValue2;
+    case "empty":
+      return actualValue === null || actualValue === void 0 || actualValue === "";
+    case "any":
+      return actualValue !== null && actualValue !== void 0 && actualValue !== "";
+    default:
+      return false;
+  }
+}
+function evaluateBooleanCondition(logic, actualValue) {
+  switch (logic) {
+    case "true":
+      return actualValue === true;
+    case "false":
+      return actualValue === false;
+    case "empty":
+      return actualValue === null || actualValue === void 0 || actualValue === "";
+    case "any":
+      return actualValue !== null && actualValue !== void 0 && actualValue !== "";
+    default:
+      return false;
+  }
+}
+function evaluateListCondition(logic, actualValue, expectedValues) {
+  const arrayValue = Array.isArray(actualValue) ? actualValue : [];
+  if (logic === "empty" || logic === "any") {
+    switch (logic) {
+      case "empty":
+        return !arrayValue || arrayValue.length === 0;
+      case "any":
+        return arrayValue && arrayValue.length > 0;
+      default:
         return false;
-      }
     }
   }
-  return true;
+  const filteredValues = expectedValues.filter(
+    (value) => value !== null && value !== void 0 && value !== ""
+  );
+  if (!filteredValues.length) {
+    return false;
+  }
+  switch (logic) {
+    case "includesAtLeastOne":
+      return filteredValues.some((value) => arrayValue.includes(value));
+    case "includesAll":
+      return filteredValues.every((value) => arrayValue.includes(value));
+    case "notIncludesAtLeastOne":
+      return !filteredValues.some((value) => arrayValue.includes(value));
+    case "notIncludesAll":
+      return !filteredValues.every((value) => arrayValue.includes(value));
+    default:
+      return false;
+  }
+}
+function evaluateDateTimeCondition(logic, actualValue, expectedValue) {
+  const actualDate = actualValue ? new Date(actualValue) : null;
+  const now = /* @__PURE__ */ new Date();
+  if (!actualDate || Number.isNaN(actualDate.getTime())) {
+    return false;
+  }
+  switch (logic) {
+    case "lessThan": {
+      const targetDate = (0, import_date_fns2.subDays)(now, Number(expectedValue));
+      return actualDate >= targetDate;
+    }
+    case "exactly": {
+      const targetDate = (0, import_date_fns2.subDays)(now, Number(expectedValue));
+      const start = (0, import_date_fns2.startOfDay)(targetDate);
+      const end = (0, import_date_fns2.endOfDay)(targetDate);
+      return actualDate >= start && actualDate <= end;
+    }
+    case "moreThan": {
+      const targetDate = (0, import_date_fns2.subDays)(now, Number(expectedValue));
+      return actualDate <= targetDate;
+    }
+    case "before": {
+      const expectedDate = new Date(expectedValue);
+      return actualDate <= expectedDate;
+    }
+    case "on": {
+      const expectedDateOn = new Date(expectedValue);
+      const start = (0, import_date_fns2.startOfDay)(expectedDateOn);
+      const end = (0, import_date_fns2.endOfDay)(expectedDateOn);
+      return actualDate >= start && actualDate <= end;
+    }
+    case "after": {
+      const expectedDateAfter = new Date(expectedValue);
+      return actualDate >= expectedDateAfter;
+    }
+    case "empty":
+      return !actualValue || actualValue === "";
+    case "any":
+      return actualValue && actualValue !== "";
+    default:
+      return false;
+  }
+}
+
+// src/conditions/condition.ts
+var conditionsIsSame = (rr1, rr2) => {
+  return (0, import_fast_deep_equal.default)(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 import_types2.RulesType.CURRENT_PAGE:
+      return evaluateUrlCondition(rule, ((_a = options.clientContext) == null ? void 0 : _a.page_url) || "");
+    case import_types2.RulesType.TIME:
+      return evaluateTimeCondition(rule);
+    case import_types2.RulesType.USER_ATTR:
+    case import_types2.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)
+    };
+  });
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  activedRulesConditions,
   conditionsIsSame,
+  filterConditionsByType,
+  isConditionsActived,
   isEqual
 });

package/dist/conditions/condition.d.cts

@@ -1,6 +1,15 @@
-import { RulesCondition } from '@usertour/types';
+import { RulesCondition, RulesType, RulesEvaluationOptions } from '@usertour/types';
 export { default as isEqual } from 'fast-deep-equal';
 
 declare const conditionsIsSame: (rr1: RulesCondition[], rr2: RulesCondition[]) => boolean;
+declare const isConditionsActived: (conditions: RulesCondition[]) => boolean;
+/**
+ * Recursively filter conditions by RulesType
+ * @param conditions - Array of rules conditions
+ * @param allowedTypes - Array of RulesType to filter by
+ * @returns Filtered conditions array
+ */
+declare const filterConditionsByType: (conditions: RulesCondition[], allowedTypes: RulesType[]) => RulesCondition[];
+declare const activedRulesConditions: (conditions: RulesCondition[], options?: RulesEvaluationOptions) => RulesCondition[];
 
-export { conditionsIsSame };
+export { activedRulesConditions, conditionsIsSame, filterConditionsByType, isConditionsActived };

package/dist/conditions/condition.d.ts

@@ -1,6 +1,15 @@
-import { RulesCondition } from '@usertour/types';
+import { RulesCondition, RulesType, RulesEvaluationOptions } from '@usertour/types';
 export { default as isEqual } from 'fast-deep-equal';
 
 declare const conditionsIsSame: (rr1: RulesCondition[], rr2: RulesCondition[]) => boolean;
+declare const isConditionsActived: (conditions: RulesCondition[]) => boolean;
+/**
+ * Recursively filter conditions by RulesType
+ * @param conditions - Array of rules conditions
+ * @param allowedTypes - Array of RulesType to filter by
+ * @returns Filtered conditions array
+ */
+declare const filterConditionsByType: (conditions: RulesCondition[], allowedTypes: RulesType[]) => RulesCondition[];
+declare const activedRulesConditions: (conditions: RulesCondition[], options?: RulesEvaluationOptions) => RulesCondition[];
 
-export { conditionsIsSame };
+export { activedRulesConditions, conditionsIsSame, filterConditionsByType, isConditionsActived };

package/dist/conditions/condition.js

@@ -1,9 +1,19 @@
 import {
+  activedRulesConditions,
   conditionsIsSame,
+  filterConditionsByType,
+  isConditionsActived,
   isEqual
-} from "../chunk-7CC4WXB3.js";
+} from "../chunk-TB7JGI2Q.js";
+import "../chunk-YYIGUZNZ.js";
+import "../chunk-PAESAL23.js";
+import "../chunk-PBZSPV5R.js";
+import "../chunk-CEK3SCQO.js";
 import "../chunk-XEO3YXBM.js";
 export {
+  activedRulesConditions,
   conditionsIsSame,
+  filterConditionsByType,
+  isConditionsActived,
   isEqual
 };