@usertour/helpers 0.0.35 → 0.0.36

package/dist/__tests__/condition.test.cjs

@@ -114,27 +114,117 @@ var evaluateUrlCondition = (rules, url) => {
 
 // src/conditions/time.ts
 var import_date_fns = require("date-fns");
+
+// src/type-utils.ts
+var nativeIsArray = Array.isArray;
+var ObjProto = Object.prototype;
+var objToString = ObjProto.toString;
+var objHasOwn = ObjProto.hasOwnProperty;
+var isArray = nativeIsArray || ((obj) => objToString.call(obj) === "[object Array]");
+var isUndefined = (x) => x === void 0;
+var isString = (x) => {
+  return objToString.call(x) === "[object String]";
+};
+var isEmptyString = (x) => isString(x) && x.trim().length === 0;
+var isNull = (x) => {
+  return x === null;
+};
+var isNullish = (x) => isUndefined(x) || isNull(x);
+
+// src/conditions/time.ts
+function isEmpty(value) {
+  return isNullish(value) || isEmptyString(value);
+}
+function hasRequiredFields(data, type) {
+  if (type === "start") {
+    return !isEmpty(data.startDate) && !isEmpty(data.startDateHour) && !isEmpty(data.startDateMinute);
+  }
+  return !isEmpty(data.endDate) && !isEmpty(data.endDateHour) && !isEmpty(data.endDateMinute);
+}
+function parseLegacyDate(dateStr) {
+  const [month, day, year] = dateStr.split("/");
+  if (!month || !day || !year) {
+    return null;
+  }
+  return {
+    month: Number.parseInt(month),
+    day: Number.parseInt(day),
+    year: Number.parseInt(year)
+  };
+}
+function createLegacyDateTime(data, type) {
+  const dateStr = type === "start" ? data.startDate : data.endDate;
+  const hourStr = type === "start" ? data.startDateHour : data.endDateHour;
+  const minuteStr = type === "start" ? data.startDateMinute : data.endDateMinute;
+  if (!dateStr || !hourStr || !minuteStr) {
+    return null;
+  }
+  const dateParts = parseLegacyDate(dateStr);
+  if (!dateParts) {
+    return null;
+  }
+  const dateTime = new Date(
+    dateParts.year,
+    dateParts.month - 1,
+    dateParts.day,
+    Number.parseInt(hourStr),
+    Number.parseInt(minuteStr),
+    0
+  );
+  return (0, import_date_fns.isValid)(dateTime) ? dateTime : null;
+}
+function isTimeConditionDataV2(data) {
+  return data && ("startTime" in data || "endTime" in data);
+}
+function isTimeConditionDataLegacy(data) {
+  return data && ("startDate" in data || "startDateHour" in data);
+}
+function evaluateTimeConditionV2(data) {
+  if (!data.startTime) {
+    return false;
+  }
+  const startTime = (0, import_date_fns.parseISO)(data.startTime);
+  if (!(0, import_date_fns.isValid)(startTime)) {
+    return false;
+  }
+  const now = /* @__PURE__ */ new Date();
+  if (!data.endTime) {
+    return (0, import_date_fns.isAfter)(now, startTime);
+  }
+  const endTime = (0, import_date_fns.parseISO)(data.endTime);
+  if (!(0, import_date_fns.isValid)(endTime)) {
+    return false;
+  }
+  return (0, import_date_fns.isAfter)(now, startTime) && (0, import_date_fns.isBefore)(now, endTime);
+}
+function evaluateTimeConditionLegacy(data) {
+  if (!hasRequiredFields(data, "start")) {
+    return false;
+  }
+  const startDateTime = createLegacyDateTime(data, "start");
+  if (!startDateTime) {
+    return false;
+  }
+  const now = /* @__PURE__ */ new Date();
+  if (!hasRequiredFields(data, "end")) {
+    return (0, import_date_fns.isAfter)(now, startDateTime);
+  }
+  const endDateTime = createLegacyDateTime(data, "end");
+  if (!endDateTime) {
+    return false;
+  }
+  return (0, import_date_fns.isAfter)(now, startDateTime) && (0, import_date_fns.isBefore)(now, endDateTime);
+}
 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 data = rules.data || {};
+    if (isTimeConditionDataV2(data)) {
+      return evaluateTimeConditionV2(data);
     }
-    const now = /* @__PURE__ */ new Date();
-    if (!endDate || !endDateHour || !endDateMinute) {
-      return (0, import_date_fns.isAfter)(now, startTime);
+    if (isTimeConditionDataLegacy(data)) {
+      return evaluateTimeConditionLegacy(data);
     }
-    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);
+    return false;
   } catch {
     return false;
   }
@@ -143,15 +233,6 @@ var evaluateTimeCondition = (rules) => {
 // src/conditions/attribute.ts
 var import_types = require("@usertour/types");
 var import_date_fns2 = require("date-fns");
-
-// src/type-utils.ts
-var nativeIsArray = Array.isArray;
-var ObjProto = Object.prototype;
-var objToString = ObjProto.toString;
-var objHasOwn = ObjProto.hasOwnProperty;
-var isArray = nativeIsArray || ((obj) => objToString.call(obj) === "[object Array]");
-
-// src/conditions/attribute.ts
 function evaluateAttributeCondition(condition, options) {
   const { data } = condition;
   if (!data) {
@@ -209,8 +290,8 @@ function evaluateStringCondition(logic, actualValue, expectedValue) {
     case "endsWith":
       return stringValue.endsWith(expectedValue);
     case "empty": {
-      const isEmpty = !stringValue || stringValue === "";
-      return isEmpty;
+      const isEmpty2 = !stringValue || stringValue === "";
+      return isEmpty2;
     }
     case "any":
       return Boolean(stringValue && stringValue !== "");
@@ -696,7 +777,8 @@ describe("evaluateRulesConditions", () => {
       operators: "and",
       actived: false,
       data: {
-        startDate: "2024-01-01",
+        startDate: "01/01/2024",
+        // MM/dd/yyyy format
         startDateHour: "00",
         startDateMinute: "00"
       }
@@ -838,6 +920,902 @@ describe("evaluateRulesConditions", () => {
     });
     expect(result[2].actived).toBe(true);
   });
+  test("should evaluate String type attribute conditions with all logic operators", async () => {
+    const conditions = [
+      {
+        id: "string-is",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "email",
+          logic: "is",
+          value: "user@example.com"
+        }
+      },
+      {
+        id: "string-not",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "name",
+          logic: "not",
+          value: "admin"
+        }
+      },
+      {
+        id: "string-contains",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "description",
+          logic: "contains",
+          value: "premium"
+        }
+      },
+      {
+        id: "string-notContain",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "title",
+          logic: "notContain",
+          value: "test"
+        }
+      },
+      {
+        id: "string-startsWith",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "path",
+          logic: "startsWith",
+          value: "/api"
+        }
+      },
+      {
+        id: "string-endsWith",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "filename",
+          logic: "endsWith",
+          value: ".pdf"
+        }
+      },
+      {
+        id: "string-empty",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "emptyString",
+          logic: "empty"
+        }
+      },
+      {
+        id: "string-any",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "hasString",
+          logic: "any"
+        }
+      }
+    ];
+    const options = {
+      clientContext: mockOptions.clientContext,
+      attributes: [
+        {
+          id: "email",
+          codeName: "email",
+          dataType: import_types3.BizAttributeTypes.String,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "name",
+          codeName: "name",
+          dataType: import_types3.BizAttributeTypes.String,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "description",
+          codeName: "description",
+          dataType: import_types3.BizAttributeTypes.String,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "title",
+          codeName: "title",
+          dataType: import_types3.BizAttributeTypes.String,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "path",
+          codeName: "path",
+          dataType: import_types3.BizAttributeTypes.String,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "filename",
+          codeName: "filename",
+          dataType: import_types3.BizAttributeTypes.String,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "emptyString",
+          codeName: "emptyString",
+          dataType: import_types3.BizAttributeTypes.String,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "hasString",
+          codeName: "hasString",
+          dataType: import_types3.BizAttributeTypes.String,
+          bizType: import_types3.AttributeBizTypes.User
+        }
+      ],
+      userAttributes: {
+        email: "user@example.com",
+        name: "john",
+        description: "premium user account",
+        title: "Manager",
+        path: "/api/users",
+        filename: "document.pdf",
+        emptyString: "",
+        hasString: "some value"
+      },
+      typeControl: {
+        [import_types3.RulesType.USER_ATTR]: true
+      }
+    };
+    const result = await evaluateRulesConditions(conditions, options);
+    expect(result[0].actived).toBe(true);
+    expect(result[1].actived).toBe(true);
+    expect(result[2].actived).toBe(true);
+    expect(result[3].actived).toBe(true);
+    expect(result[4].actived).toBe(true);
+    expect(result[5].actived).toBe(true);
+    expect(result[6].actived).toBe(true);
+    expect(result[7].actived).toBe(true);
+  });
+  test("should evaluate Number type attribute conditions with all logic operators", async () => {
+    const conditions = [
+      {
+        id: "number-is",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "age",
+          logic: "is",
+          value: 25
+        }
+      },
+      {
+        id: "number-not",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "age2",
+          logic: "not",
+          value: 30
+        }
+      },
+      {
+        id: "number-isLessThan",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "score",
+          logic: "isLessThan",
+          value: 100
+        }
+      },
+      {
+        id: "number-isLessThanOrEqualTo",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "score2",
+          logic: "isLessThanOrEqualTo",
+          value: 80
+        }
+      },
+      {
+        id: "number-isGreaterThan",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "score3",
+          logic: "isGreaterThan",
+          value: 50
+        }
+      },
+      {
+        id: "number-isGreaterThanOrEqualTo",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "score4",
+          logic: "isGreaterThanOrEqualTo",
+          value: 60
+        }
+      },
+      {
+        id: "number-between",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "price",
+          logic: "between",
+          value: 10,
+          value2: 100
+        }
+      },
+      {
+        id: "number-empty",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "emptyValue",
+          logic: "empty"
+        }
+      },
+      {
+        id: "number-any",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "hasValue",
+          logic: "any"
+        }
+      }
+    ];
+    const options = {
+      clientContext: mockOptions.clientContext,
+      attributes: [
+        {
+          id: "age",
+          codeName: "age",
+          dataType: import_types3.BizAttributeTypes.Number,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "age2",
+          codeName: "age2",
+          dataType: import_types3.BizAttributeTypes.Number,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "score",
+          codeName: "score",
+          dataType: import_types3.BizAttributeTypes.Number,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "score2",
+          codeName: "score2",
+          dataType: import_types3.BizAttributeTypes.Number,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "score3",
+          codeName: "score3",
+          dataType: import_types3.BizAttributeTypes.Number,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "score4",
+          codeName: "score4",
+          dataType: import_types3.BizAttributeTypes.Number,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "price",
+          codeName: "price",
+          dataType: import_types3.BizAttributeTypes.Number,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "emptyValue",
+          codeName: "emptyValue",
+          dataType: import_types3.BizAttributeTypes.Number,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "hasValue",
+          codeName: "hasValue",
+          dataType: import_types3.BizAttributeTypes.Number,
+          bizType: import_types3.AttributeBizTypes.User
+        }
+      ],
+      userAttributes: {
+        age: 25,
+        age2: 25,
+        score: 90,
+        score2: 80,
+        score3: 70,
+        score4: 60,
+        price: 50,
+        emptyValue: null,
+        hasValue: 42
+      },
+      typeControl: {
+        [import_types3.RulesType.USER_ATTR]: true
+      }
+    };
+    const result = await evaluateRulesConditions(conditions, options);
+    expect(result[0].actived).toBe(true);
+    expect(result[1].actived).toBe(true);
+    expect(result[2].actived).toBe(true);
+    expect(result[3].actived).toBe(true);
+    expect(result[4].actived).toBe(true);
+    expect(result[5].actived).toBe(true);
+    expect(result[6].actived).toBe(true);
+    expect(result[7].actived).toBe(true);
+    expect(result[8].actived).toBe(true);
+  });
+  test("should evaluate Boolean type attribute conditions with all logic operators", async () => {
+    const conditions = [
+      {
+        id: "bool-true",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "isVip",
+          logic: "true"
+        }
+      },
+      {
+        id: "bool-false",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "isActive",
+          logic: "false"
+        }
+      },
+      {
+        id: "bool-empty",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "emptyBool",
+          logic: "empty"
+        }
+      },
+      {
+        id: "bool-any",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "hasBool",
+          logic: "any"
+        }
+      }
+    ];
+    const options = {
+      clientContext: mockOptions.clientContext,
+      attributes: [
+        {
+          id: "isVip",
+          codeName: "isVip",
+          dataType: import_types3.BizAttributeTypes.Boolean,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "isActive",
+          codeName: "isActive",
+          dataType: import_types3.BizAttributeTypes.Boolean,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "emptyBool",
+          codeName: "emptyBool",
+          dataType: import_types3.BizAttributeTypes.Boolean,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "hasBool",
+          codeName: "hasBool",
+          dataType: import_types3.BizAttributeTypes.Boolean,
+          bizType: import_types3.AttributeBizTypes.User
+        }
+      ],
+      userAttributes: {
+        isVip: true,
+        isActive: false,
+        emptyBool: null,
+        hasBool: true
+      },
+      typeControl: {
+        [import_types3.RulesType.USER_ATTR]: true
+      }
+    };
+    const result = await evaluateRulesConditions(conditions, options);
+    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 evaluate List type attribute conditions with all logic operators", async () => {
+    const conditions = [
+      {
+        id: "list-includesAtLeastOne",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "tags",
+          logic: "includesAtLeastOne",
+          listValues: ["premium", "vip"]
+        }
+      },
+      {
+        id: "list-includesAll",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "roles",
+          logic: "includesAll",
+          listValues: ["admin", "editor"]
+        }
+      },
+      {
+        id: "list-notIncludesAtLeastOne",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "permissions",
+          logic: "notIncludesAtLeastOne",
+          listValues: ["delete", "modify"]
+        }
+      },
+      {
+        id: "list-notIncludesAll",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "categories",
+          logic: "notIncludesAll",
+          listValues: ["tech", "finance"]
+        }
+      },
+      {
+        id: "list-empty",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "emptyList",
+          logic: "empty"
+        }
+      },
+      {
+        id: "list-any",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "hasList",
+          logic: "any"
+        }
+      }
+    ];
+    const options = {
+      clientContext: mockOptions.clientContext,
+      attributes: [
+        {
+          id: "tags",
+          codeName: "tags",
+          dataType: import_types3.BizAttributeTypes.List,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "roles",
+          codeName: "roles",
+          dataType: import_types3.BizAttributeTypes.List,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "permissions",
+          codeName: "permissions",
+          dataType: import_types3.BizAttributeTypes.List,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "categories",
+          codeName: "categories",
+          dataType: import_types3.BizAttributeTypes.List,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "emptyList",
+          codeName: "emptyList",
+          dataType: import_types3.BizAttributeTypes.List,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "hasList",
+          codeName: "hasList",
+          dataType: import_types3.BizAttributeTypes.List,
+          bizType: import_types3.AttributeBizTypes.User
+        }
+      ],
+      userAttributes: {
+        tags: ["premium", "basic"],
+        roles: ["admin", "editor", "viewer"],
+        permissions: ["read", "write"],
+        categories: ["other"],
+        emptyList: [],
+        hasList: ["item1", "item2"]
+      },
+      typeControl: {
+        [import_types3.RulesType.USER_ATTR]: true
+      }
+    };
+    const result = await evaluateRulesConditions(conditions, options);
+    expect(result[0].actived).toBe(true);
+    expect(result[1].actived).toBe(true);
+    expect(result[2].actived).toBe(true);
+    expect(result[3].actived).toBe(true);
+    expect(result[4].actived).toBe(true);
+    expect(result[5].actived).toBe(true);
+  });
+  test("should evaluate DateTime type attribute conditions with all logic operators", async () => {
+    const now = /* @__PURE__ */ new Date();
+    const fiveDaysAgo = new Date(now.getTime() - 5 * 24 * 60 * 60 * 1e3);
+    const tenDaysAgo = new Date(now.getTime() - 10 * 24 * 60 * 60 * 1e3);
+    const threeDaysAgo = new Date(now.getTime() - 3 * 24 * 60 * 60 * 1e3);
+    const fifteenDaysAgo = new Date(now.getTime() - 15 * 24 * 60 * 60 * 1e3);
+    const futureDate = new Date(now.getTime() + 5 * 24 * 60 * 60 * 1e3);
+    const conditions = [
+      {
+        id: "datetime-lessThan",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "lastLogin",
+          logic: "lessThan",
+          value: 7
+        }
+      },
+      {
+        id: "datetime-exactly",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "exactDate",
+          logic: "exactly",
+          value: 3
+        }
+      },
+      {
+        id: "datetime-moreThan",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "oldDate",
+          logic: "moreThan",
+          value: 7
+        }
+      },
+      {
+        id: "datetime-before",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "createdAt",
+          logic: "before",
+          value: now.toISOString()
+        }
+      },
+      {
+        id: "datetime-on",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "onDate",
+          logic: "on",
+          value: threeDaysAgo.toISOString()
+        }
+      },
+      {
+        id: "datetime-after",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "futureDate",
+          logic: "after",
+          value: now.toISOString()
+        }
+      },
+      {
+        id: "datetime-empty",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "emptyDate",
+          logic: "empty"
+        }
+      },
+      {
+        id: "datetime-any",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "hasDate",
+          logic: "any"
+        }
+      }
+    ];
+    const options = {
+      clientContext: mockOptions.clientContext,
+      attributes: [
+        {
+          id: "lastLogin",
+          codeName: "lastLogin",
+          dataType: import_types3.BizAttributeTypes.DateTime,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "exactDate",
+          codeName: "exactDate",
+          dataType: import_types3.BizAttributeTypes.DateTime,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "oldDate",
+          codeName: "oldDate",
+          dataType: import_types3.BizAttributeTypes.DateTime,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "createdAt",
+          codeName: "createdAt",
+          dataType: import_types3.BizAttributeTypes.DateTime,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "onDate",
+          codeName: "onDate",
+          dataType: import_types3.BizAttributeTypes.DateTime,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "futureDate",
+          codeName: "futureDate",
+          dataType: import_types3.BizAttributeTypes.DateTime,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "emptyDate",
+          codeName: "emptyDate",
+          dataType: import_types3.BizAttributeTypes.DateTime,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "hasDate",
+          codeName: "hasDate",
+          dataType: import_types3.BizAttributeTypes.DateTime,
+          bizType: import_types3.AttributeBizTypes.User
+        }
+      ],
+      userAttributes: {
+        lastLogin: fiveDaysAgo.toISOString(),
+        exactDate: threeDaysAgo.toISOString(),
+        oldDate: fifteenDaysAgo.toISOString(),
+        createdAt: tenDaysAgo.toISOString(),
+        onDate: threeDaysAgo.toISOString(),
+        futureDate: futureDate.toISOString(),
+        emptyDate: "",
+        hasDate: fiveDaysAgo.toISOString()
+      },
+      typeControl: {
+        [import_types3.RulesType.USER_ATTR]: true
+      }
+    };
+    const result = await evaluateRulesConditions(conditions, options);
+    expect(result[0].actived).toBe(true);
+    expect(result[1].actived).toBe(true);
+    expect(result[2].actived).toBe(true);
+    expect(result[3].actived).toBe(true);
+    expect(result[4].actived).toBe(true);
+    expect(result[5].actived).toBe(true);
+    expect(result[6].actived).toBe(false);
+    expect(result[7].actived).toBe(true);
+  });
+  test("should evaluate mixed attribute type conditions correctly", async () => {
+    const conditions = [
+      {
+        id: "mixed-1",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "email",
+          logic: "is",
+          value: "user@example.com"
+        }
+      },
+      {
+        id: "mixed-2",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "age",
+          logic: "isGreaterThan",
+          value: 18
+        }
+      },
+      {
+        id: "mixed-3",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "isVip",
+          logic: "true"
+        }
+      },
+      {
+        id: "mixed-4",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "tags",
+          logic: "includesAtLeastOne",
+          listValues: ["premium"]
+        }
+      }
+    ];
+    const options = {
+      clientContext: mockOptions.clientContext,
+      attributes: [
+        {
+          id: "email",
+          codeName: "email",
+          dataType: import_types3.BizAttributeTypes.String,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "age",
+          codeName: "age",
+          dataType: import_types3.BizAttributeTypes.Number,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "isVip",
+          codeName: "isVip",
+          dataType: import_types3.BizAttributeTypes.Boolean,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "tags",
+          codeName: "tags",
+          dataType: import_types3.BizAttributeTypes.List,
+          bizType: import_types3.AttributeBizTypes.User
+        }
+      ],
+      userAttributes: {
+        email: "user@example.com",
+        age: 25,
+        isVip: true,
+        tags: ["premium", "basic"]
+      },
+      typeControl: {
+        [import_types3.RulesType.USER_ATTR]: true
+      }
+    };
+    const result = await evaluateRulesConditions(conditions, options);
+    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 evaluate mixed attribute types with OR logic correctly", async () => {
+    const conditions = [
+      {
+        id: "or-1",
+        type: "user-attr",
+        operators: "or",
+        actived: false,
+        data: {
+          attrId: "email",
+          logic: "is",
+          value: "wrong@example.com"
+        }
+      },
+      {
+        id: "or-2",
+        type: "user-attr",
+        operators: "or",
+        actived: false,
+        data: {
+          attrId: "age",
+          logic: "isGreaterThan",
+          value: 18
+        }
+      },
+      {
+        id: "or-3",
+        type: "user-attr",
+        operators: "or",
+        actived: false,
+        data: {
+          attrId: "isVip",
+          logic: "false"
+        }
+      }
+    ];
+    const options = {
+      clientContext: mockOptions.clientContext,
+      attributes: [
+        {
+          id: "email",
+          codeName: "email",
+          dataType: import_types3.BizAttributeTypes.String,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "age",
+          codeName: "age",
+          dataType: import_types3.BizAttributeTypes.Number,
+          bizType: import_types3.AttributeBizTypes.User
+        },
+        {
+          id: "isVip",
+          codeName: "isVip",
+          dataType: import_types3.BizAttributeTypes.Boolean,
+          bizType: import_types3.AttributeBizTypes.User
+        }
+      ],
+      userAttributes: {
+        email: "user@example.com",
+        age: 25,
+        isVip: true
+      },
+      typeControl: {
+        [import_types3.RulesType.USER_ATTR]: true
+      }
+    };
+    const result = await evaluateRulesConditions(conditions, options);
+    expect(result[0].actived).toBe(false);
+    expect(result[1].actived).toBe(true);
+    expect(result[2].actived).toBe(false);
+  });
   test("should handle rules without ID", async () => {
     const conditions = [
       {