@usertour/helpers 0.0.17 → 0.0.20

package/dist/__tests__/condition.test.cjs

@@ -0,0 +1,928 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/__tests__/condition.test.ts
+var import_types3 = require("@usertour/types");
+
+// src/conditions/condition.ts
+var import_types2 = require("@usertour/types");
+var import_fast_deep_equal = __toESM(require("fast-deep-equal"), 1);
+
+// 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;
+}
+
+// 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;
+  }
+};
+
+// 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;
+  }
+  const { logic, value, attrId, value2, listValues = [] } = data;
+  if (!attrId) {
+    return false;
+  }
+  const attr = attributes.find((attr2) => attr2.id === attrId);
+  if (!attr) {
+    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;
+    }
+    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;
+    }
+  }
+  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 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)
+    };
+  });
+};
+
+// src/__tests__/condition.test.ts
+describe("filterConditionsByType", () => {
+  test("should return empty array when no conditions provided", () => {
+    const result = filterConditionsByType([], [import_types3.RulesType.CURRENT_PAGE, import_types3.RulesType.TIME]);
+    expect(result).toEqual([]);
+  });
+  test("should filter out non-matching types", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "element",
+        operators: "and",
+        actived: true,
+        data: {}
+      },
+      {
+        id: "2",
+        type: "current-page",
+        operators: "and",
+        actived: true,
+        data: {}
+      }
+    ];
+    const result = filterConditionsByType(conditions, [import_types3.RulesType.CURRENT_PAGE, import_types3.RulesType.TIME]);
+    expect(result).toHaveLength(1);
+    expect(result[0].type).toBe("current-page");
+  });
+  test("should keep matching types", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "current-page",
+        operators: "and",
+        actived: true,
+        data: {}
+      },
+      {
+        id: "2",
+        type: "time",
+        operators: "and",
+        actived: true,
+        data: {}
+      }
+    ];
+    const result = filterConditionsByType(conditions, [import_types3.RulesType.CURRENT_PAGE, import_types3.RulesType.TIME]);
+    expect(result).toHaveLength(2);
+    expect(result.map((c) => c.type)).toEqual(["current-page", "time"]);
+  });
+  test("should handle nested group conditions", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "group",
+        operators: "and",
+        data: {},
+        conditions: [
+          {
+            id: "2",
+            type: "current-page",
+            operators: "and",
+            actived: true,
+            data: {}
+          },
+          {
+            id: "3",
+            type: "element",
+            // This should be filtered out
+            operators: "and",
+            actived: true,
+            data: {}
+          }
+        ]
+      }
+    ];
+    const result = filterConditionsByType(conditions, [import_types3.RulesType.CURRENT_PAGE, import_types3.RulesType.TIME]);
+    expect(result).toHaveLength(1);
+    expect(result[0].type).toBe("group");
+    expect(result[0].conditions).toHaveLength(1);
+    expect(result[0].conditions[0].type).toBe("current-page");
+  });
+  test("should remove groups with no matching conditions", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "group",
+        operators: "and",
+        data: {},
+        conditions: [
+          {
+            id: "2",
+            type: "element",
+            // This should be filtered out
+            operators: "and",
+            actived: true,
+            data: {}
+          }
+        ]
+      }
+    ];
+    const result = filterConditionsByType(conditions, [import_types3.RulesType.CURRENT_PAGE, import_types3.RulesType.TIME]);
+    expect(result).toHaveLength(0);
+  });
+});
+describe("isConditionsActived", () => {
+  test("should return false when no conditions provided", () => {
+    const result = isConditionsActived([]);
+    expect(result).toBe(false);
+  });
+  test("should return true when all conditions are actived with AND logic", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "current-page",
+        operators: "and",
+        actived: true,
+        data: {}
+      },
+      {
+        id: "2",
+        type: "time",
+        operators: "and",
+        actived: true,
+        data: {}
+      }
+    ];
+    const result = isConditionsActived(conditions);
+    expect(result).toBe(true);
+  });
+  test("should return false when one condition is not actived with AND logic", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "current-page",
+        operators: "and",
+        actived: true,
+        data: {}
+      },
+      {
+        id: "2",
+        type: "time",
+        operators: "and",
+        actived: false,
+        data: {}
+      }
+    ];
+    const result = isConditionsActived(conditions);
+    expect(result).toBe(false);
+  });
+  test("should return true when at least one condition is actived with OR logic", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "current-page",
+        operators: "or",
+        actived: false,
+        data: {}
+      },
+      {
+        id: "2",
+        type: "time",
+        operators: "or",
+        actived: true,
+        data: {}
+      }
+    ];
+    const result = isConditionsActived(conditions);
+    expect(result).toBe(true);
+  });
+  test("should handle nested group conditions", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "group",
+        operators: "and",
+        data: {},
+        conditions: [
+          {
+            id: "2",
+            type: "current-page",
+            operators: "and",
+            actived: true,
+            data: {}
+          },
+          {
+            id: "3",
+            type: "time",
+            operators: "and",
+            actived: true,
+            data: {}
+          }
+        ]
+      }
+    ];
+    const result = isConditionsActived(conditions);
+    expect(result).toBe(true);
+  });
+});
+describe("activedRulesConditions", () => {
+  const mockConditions = [
+    {
+      id: "rule-1",
+      type: "current-page",
+      operators: "and",
+      actived: false,
+      data: {
+        includes: ["https://example.com"],
+        excludes: []
+      }
+    },
+    {
+      id: "rule-2",
+      type: "time",
+      operators: "and",
+      actived: false,
+      data: {
+        startDate: "2024-01-01",
+        startDateHour: "00",
+        startDateMinute: "00"
+      }
+    },
+    {
+      id: "rule-3",
+      type: "user-attr",
+      operators: "and",
+      actived: false,
+      data: {
+        attrId: "email",
+        logic: "is",
+        value: "test@example.com"
+      }
+    },
+    {
+      id: "rule-4",
+      type: "element",
+      operators: "and",
+      actived: true,
+      data: {}
+    }
+  ];
+  const mockOptions = {
+    clientContext: {
+      page_url: "https://example.com",
+      viewport_width: 1920,
+      viewport_height: 1080
+    },
+    attributes: [
+      {
+        id: "email",
+        codeName: "email",
+        dataType: 2
+        // String
+      }
+    ],
+    userAttributes: {
+      email: "test@example.com"
+    }
+  };
+  test("should return conditions with default actived state when no options provided", () => {
+    const conditions = [
+      {
+        id: "rule-1",
+        type: "element",
+        operators: "and",
+        actived: true,
+        data: {}
+      },
+      {
+        id: "rule-2",
+        type: "element",
+        operators: "and",
+        actived: false,
+        data: {}
+      }
+    ];
+    const result = activedRulesConditions(conditions);
+    expect(result).toHaveLength(2);
+    expect(result[0].actived).toBe(true);
+    expect(result[1].actived).toBe(false);
+  });
+  test("should force activate rules by ID", () => {
+    const result = activedRulesConditions(mockConditions, {
+      ...mockOptions,
+      activatedIds: ["rule-1", "rule-2"]
+    });
+    expect(result[0].actived).toBe(true);
+    expect(result[1].actived).toBe(true);
+    expect(result[2].actived).toBe(true);
+    expect(result[3].actived).toBe(true);
+  });
+  test("should force deactivate rules by ID", () => {
+    const result = activedRulesConditions(mockConditions, {
+      ...mockOptions,
+      deactivatedIds: ["rule-1", "rule-4"]
+    });
+    expect(result[0].actived).toBe(false);
+    expect(result[1].actived).toBe(true);
+    expect(result[2].actived).toBe(true);
+    expect(result[3].actived).toBe(false);
+  });
+  test("should prioritize activatedIds over deactivatedIds", () => {
+    const result = activedRulesConditions(mockConditions, {
+      ...mockOptions,
+      activatedIds: ["rule-1"],
+      deactivatedIds: ["rule-1"]
+    });
+    expect(result[0].actived).toBe(true);
+  });
+  test("should disable evaluation for specific rule types", () => {
+    const result = activedRulesConditions(mockConditions, {
+      ...mockOptions,
+      typeControl: {
+        [import_types3.RulesType.CURRENT_PAGE]: false,
+        [import_types3.RulesType.TIME]: false
+      }
+    });
+    expect(result[0].actived).toBe(false);
+    expect(result[1].actived).toBe(false);
+    expect(result[2].actived).toBe(true);
+    expect(result[3].actived).toBe(true);
+  });
+  test("should evaluate URL conditions correctly", () => {
+    const result = activedRulesConditions(mockConditions, mockOptions);
+    expect(result[0].actived).toBe(false);
+  });
+  test("should evaluate time conditions correctly", () => {
+    const result = activedRulesConditions(mockConditions, mockOptions);
+    expect(typeof result[1].actived).toBe("boolean");
+  });
+  test("should evaluate attribute conditions correctly", () => {
+    const result = activedRulesConditions(mockConditions, mockOptions);
+    expect(result[2].actived).toBe(true);
+  });
+  test("should handle rules without ID", () => {
+    const conditions = [
+      {
+        id: "rule-without-id",
+        type: "element",
+        operators: "and",
+        actived: true,
+        data: {}
+      }
+    ];
+    const result = activedRulesConditions(conditions, {
+      activatedIds: ["non-existent"],
+      deactivatedIds: ["non-existent"]
+    });
+    expect(result[0].actived).toBe(true);
+  });
+  test("should handle nested group conditions", () => {
+    const nestedConditions = [
+      {
+        id: "group-1",
+        type: "group",
+        operators: "and",
+        actived: false,
+        data: {},
+        conditions: [
+          {
+            id: "rule-1",
+            type: "current-page",
+            operators: "and",
+            actived: false,
+            data: {
+              includes: ["https://example.com"],
+              excludes: []
+            }
+          },
+          {
+            id: "rule-2",
+            type: "element",
+            operators: "and",
+            actived: true,
+            data: {}
+          }
+        ]
+      }
+    ];
+    const result = activedRulesConditions(nestedConditions, {
+      ...mockOptions,
+      activatedIds: ["rule-1"]
+    });
+    expect(result[0].type).toBe("group");
+    expect(result[0].conditions).toBeDefined();
+    expect(result[0].conditions[0].actived).toBe(true);
+    expect(result[0].conditions[1].actived).toBe(true);
+  });
+  test("should handle deep nested group conditions", () => {
+    const deepNestedConditions = [
+      {
+        id: "group-1",
+        type: "group",
+        operators: "and",
+        actived: false,
+        data: {},
+        conditions: [
+          {
+            id: "group-2",
+            type: "group",
+            operators: "and",
+            actived: false,
+            data: {},
+            conditions: [
+              {
+                id: "rule-1",
+                type: "current-page",
+                operators: "and",
+                actived: false,
+                data: {
+                  includes: ["https://example.com"],
+                  excludes: []
+                }
+              }
+            ]
+          }
+        ]
+      }
+    ];
+    const result = activedRulesConditions(deepNestedConditions, {
+      ...mockOptions,
+      activatedIds: ["rule-1"]
+    });
+    expect(result[0].conditions[0].conditions[0].actived).toBe(true);
+  });
+  test("should handle empty conditions array", () => {
+    const result = activedRulesConditions([]);
+    expect(result).toEqual([]);
+  });
+  test("should handle conditions with missing data", () => {
+    const conditions = [
+      {
+        id: "rule-1",
+        type: "current-page",
+        operators: "and",
+        actived: false,
+        data: void 0
+      }
+    ];
+    const result = activedRulesConditions(conditions, mockOptions);
+    expect(result[0].actived).toBe(false);
+  });
+  test("should handle mixed rule types with different evaluation results", () => {
+    const mixedConditions = [
+      {
+        id: "url-rule",
+        type: "current-page",
+        operators: "and",
+        actived: false,
+        data: {
+          includes: ["https://wrong-url.com"],
+          excludes: []
+        }
+      },
+      {
+        id: "attr-rule",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "email",
+          logic: "is",
+          value: "test@example.com"
+        }
+      },
+      {
+        id: "element-rule",
+        type: "element",
+        operators: "and",
+        actived: false,
+        data: {}
+      }
+    ];
+    const result = activedRulesConditions(mixedConditions, mockOptions);
+    expect(result[0].actived).toBe(false);
+    expect(result[1].actived).toBe(true);
+    expect(result[2].actived).toBe(false);
+  });
+  test("should handle type control with partial configuration", () => {
+    const result = activedRulesConditions(mockConditions, {
+      ...mockOptions,
+      typeControl: {
+        [import_types3.RulesType.CURRENT_PAGE]: false
+        // Other types not specified, should evaluate normally
+      }
+    });
+    expect(result[0].actived).toBe(false);
+    expect(result[1].actived).toBe(true);
+    expect(result[2].actived).toBe(true);
+    expect(result[3].actived).toBe(true);
+  });
+  test("should handle missing clientContext gracefully", () => {
+    const result = activedRulesConditions(mockConditions, {
+      attributes: mockOptions.attributes,
+      userAttributes: mockOptions.userAttributes
+    });
+    expect(result).toHaveLength(4);
+    expect(typeof result[0].actived).toBe("boolean");
+  });
+  test("should handle missing attributes gracefully", () => {
+    const result = activedRulesConditions(mockConditions, {
+      clientContext: mockOptions.clientContext,
+      userAttributes: mockOptions.userAttributes
+    });
+    expect(result[2].actived).toBe(false);
+  });
+  test("should handle missing userAttributes gracefully", () => {
+    const result = activedRulesConditions(mockConditions, {
+      clientContext: mockOptions.clientContext,
+      attributes: mockOptions.attributes
+    });
+    expect(result[2].actived).toBe(false);
+  });
+  test("debug: should test URL evaluation directly", () => {
+    const urlCondition = {
+      id: "debug-rule",
+      type: "current-page",
+      operators: "and",
+      actived: false,
+      data: {
+        includes: ["https://example.com"],
+        excludes: []
+      }
+    };
+    const options = {
+      clientContext: {
+        page_url: "https://example.com",
+        viewport_width: 1920,
+        viewport_height: 1080
+      }
+    };
+    const result = activedRulesConditions([urlCondition], options);
+    expect(result[0].actived).toBe(false);
+  });
+});