@usertour/helpers 0.0.33 → 0.0.35

package/dist/__tests__/attribute.test.cjs

@@ -6,6 +6,15 @@ var import_types2 = require("@usertour/types");
 // src/conditions/attribute.ts
 var import_types = require("@usertour/types");
 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]");
+
+// src/conditions/attribute.ts
 function evaluateFilterConditions(conditions, options) {
   if (!conditions || !conditions.length) {
     return true;
@@ -110,26 +119,27 @@ function evaluateStringCondition(logic, actualValue, expectedValue) {
   }
 }
 function evaluateNumberCondition(logic, actualValue, expectedValue, expectedValue2) {
-  const numValue = Number(actualValue);
-  const numValue2 = Number(expectedValue2);
-  if (Number.isNaN(numValue)) {
+  const numActualValue = Number(actualValue);
+  const numExpectedValue = Number(expectedValue);
+  const numExpectedValue2 = Number(expectedValue2);
+  if (Number.isNaN(numActualValue)) {
     return false;
   }
   switch (logic) {
     case "is":
-      return numValue === expectedValue;
+      return numActualValue === numExpectedValue;
     case "not":
-      return numValue !== expectedValue;
+      return numActualValue !== numExpectedValue;
     case "isLessThan":
-      return numValue < expectedValue;
+      return numActualValue < numExpectedValue;
     case "isLessThanOrEqualTo":
-      return numValue <= expectedValue;
+      return numActualValue <= numExpectedValue;
     case "isGreaterThan":
-      return numValue > expectedValue;
+      return numActualValue > numExpectedValue;
     case "isGreaterThanOrEqualTo":
-      return numValue >= expectedValue;
+      return numActualValue >= numExpectedValue;
     case "between":
-      return numValue >= expectedValue && numValue <= numValue2;
+      return numActualValue >= numExpectedValue && numActualValue <= numExpectedValue2;
     case "empty":
       return actualValue === null || actualValue === void 0 || actualValue === "";
     case "any":
@@ -153,7 +163,7 @@ function evaluateBooleanCondition(logic, actualValue) {
   }
 }
 function evaluateListCondition(logic, actualValue, expectedValues) {
-  const arrayValue = Array.isArray(actualValue) ? actualValue : [];
+  const arrayValue = isArray(actualValue) ? actualValue : [];
   if (logic === "empty" || logic === "any") {
     switch (logic) {
       case "empty":
@@ -289,6 +299,12 @@ var testAttributes = [
     dataType: import_types2.BizAttributeTypes.Number,
     bizType: import_types2.AttributeBizTypes.User
   },
+  {
+    id: "sdsdd-attr",
+    codeName: "sdsdd",
+    dataType: import_types2.BizAttributeTypes.Number,
+    bizType: import_types2.AttributeBizTypes.User
+  },
   // Company attributes
   {
     id: "company-name-attr",
@@ -323,7 +339,8 @@ var testUserAttributes = {
   roles: ["admin", "user"],
   tags: [123, 456],
   signUpDate: "2024-01-15T10:30:00Z",
-  score: 85.5
+  score: 85.5,
+  sdsdd: 101
 };
 var testCompanyAttributes = {
   companyName: "Example Corp",
@@ -596,6 +613,229 @@ describe("Attribute Filter - Complete Test Suite", () => {
       expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
     });
   });
+  describe("Number conditions with string values", () => {
+    test('should evaluate "is" condition when actualValue is number and expectedValue is string', () => {
+      const condition = [
+        {
+          id: "number-string-condition-1",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "is",
+            value: "101",
+            attrId: "sdsdd-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
+    });
+    test('should evaluate "is" condition when actualValue is string and expectedValue is number', () => {
+      const userAttributesWithStringNumber = {
+        ...testUserAttributes,
+        sdsdd: "101"
+      };
+      const condition = [
+        {
+          id: "number-string-condition-2",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "is",
+            value: 101,
+            attrId: "sdsdd-attr"
+          }
+        }
+      ];
+      expect(
+        evaluateFilterConditions(condition, {
+          ...defaultOptions,
+          userAttributes: userAttributesWithStringNumber
+        })
+      ).toBe(true);
+    });
+    test('should evaluate "is" condition when both actualValue and expectedValue are strings', () => {
+      const userAttributesWithStringNumber = {
+        ...testUserAttributes,
+        sdsdd: "101"
+      };
+      const condition = [
+        {
+          id: "number-string-condition-3",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "is",
+            value: "101",
+            attrId: "sdsdd-attr"
+          }
+        }
+      ];
+      expect(
+        evaluateFilterConditions(condition, {
+          ...defaultOptions,
+          userAttributes: userAttributesWithStringNumber
+        })
+      ).toBe(true);
+    });
+    test('should evaluate "not" condition when actualValue is number and expectedValue is string', () => {
+      const condition = [
+        {
+          id: "number-string-condition-4",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "not",
+            value: "102",
+            attrId: "sdsdd-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
+    });
+    test('should evaluate "isLessThan" condition when expectedValue is string', () => {
+      const condition = [
+        {
+          id: "number-string-condition-5",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "isLessThan",
+            value: "102",
+            attrId: "sdsdd-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
+    });
+    test('should evaluate "isGreaterThan" condition when expectedValue is string', () => {
+      const condition = [
+        {
+          id: "number-string-condition-6",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "isGreaterThan",
+            value: "100",
+            attrId: "sdsdd-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
+    });
+    test('should evaluate "between" condition when value and value2 are strings', () => {
+      const condition = [
+        {
+          id: "number-string-condition-7",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "between",
+            value: "100",
+            value2: "103",
+            attrId: "sdsdd-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
+    });
+    test('should evaluate "between" condition when actualValue is string and values are strings', () => {
+      const userAttributesWithStringNumber = {
+        ...testUserAttributes,
+        sdsdd: "101"
+      };
+      const condition = [
+        {
+          id: "number-string-condition-8",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "between",
+            value: "100",
+            value2: "103",
+            attrId: "sdsdd-attr"
+          }
+        }
+      ];
+      expect(
+        evaluateFilterConditions(condition, {
+          ...defaultOptions,
+          userAttributes: userAttributesWithStringNumber
+        })
+      ).toBe(true);
+    });
+    test("should return false when actualValue is NaN", () => {
+      const userAttributesWithNaN = {
+        ...testUserAttributes,
+        sdsdd: "not-a-number"
+      };
+      const condition = [
+        {
+          id: "number-string-condition-9",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "is",
+            value: 101,
+            attrId: "sdsdd-attr"
+          }
+        }
+      ];
+      expect(
+        evaluateFilterConditions(condition, {
+          ...defaultOptions,
+          userAttributes: userAttributesWithNaN
+        })
+      ).toBe(false);
+    });
+    test("should handle decimal string values correctly", () => {
+      const userAttributesWithDecimal = {
+        ...testUserAttributes,
+        score: "85.5"
+      };
+      const condition = [
+        {
+          id: "number-string-condition-10",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "is",
+            value: "85.5",
+            attrId: "score-attr"
+          }
+        }
+      ];
+      expect(
+        evaluateFilterConditions(condition, {
+          ...defaultOptions,
+          userAttributes: userAttributesWithDecimal
+        })
+      ).toBe(true);
+    });
+    test("should handle negative string values correctly", () => {
+      const userAttributesWithNegative = {
+        ...testUserAttributes,
+        sdsdd: "-50"
+      };
+      const condition = [
+        {
+          id: "number-string-condition-11",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "isLessThan",
+            value: "0",
+            attrId: "sdsdd-attr"
+          }
+        }
+      ];
+      expect(
+        evaluateFilterConditions(condition, {
+          ...defaultOptions,
+          userAttributes: userAttributesWithNegative
+        })
+      ).toBe(true);
+    });
+  });
   describe("Boolean conditions (4 cases)", () => {
     test('should evaluate "true" condition correctly', () => {
       const condition = [

package/dist/__tests__/attribute.test.js

@@ -1,7 +1,8 @@
 import {
   evaluateAttributeCondition,
   evaluateFilterConditions
-} from "../chunk-E2APTIR7.js";
+} from "../chunk-KYDXF7SU.js";
+import "../chunk-GFH3VWOC.js";
 import "../chunk-XEO3YXBM.js";
 
 // src/__tests__/attribute.test.ts
@@ -52,6 +53,12 @@ var testAttributes = [
     dataType: BizAttributeTypes.Number,
     bizType: AttributeBizTypes.User
   },
+  {
+    id: "sdsdd-attr",
+    codeName: "sdsdd",
+    dataType: BizAttributeTypes.Number,
+    bizType: AttributeBizTypes.User
+  },
   // Company attributes
   {
     id: "company-name-attr",
@@ -86,7 +93,8 @@ var testUserAttributes = {
   roles: ["admin", "user"],
   tags: [123, 456],
   signUpDate: "2024-01-15T10:30:00Z",
-  score: 85.5
+  score: 85.5,
+  sdsdd: 101
 };
 var testCompanyAttributes = {
   companyName: "Example Corp",
@@ -359,6 +367,229 @@ describe("Attribute Filter - Complete Test Suite", () => {
       expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
     });
   });
+  describe("Number conditions with string values", () => {
+    test('should evaluate "is" condition when actualValue is number and expectedValue is string', () => {
+      const condition = [
+        {
+          id: "number-string-condition-1",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "is",
+            value: "101",
+            attrId: "sdsdd-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
+    });
+    test('should evaluate "is" condition when actualValue is string and expectedValue is number', () => {
+      const userAttributesWithStringNumber = {
+        ...testUserAttributes,
+        sdsdd: "101"
+      };
+      const condition = [
+        {
+          id: "number-string-condition-2",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "is",
+            value: 101,
+            attrId: "sdsdd-attr"
+          }
+        }
+      ];
+      expect(
+        evaluateFilterConditions(condition, {
+          ...defaultOptions,
+          userAttributes: userAttributesWithStringNumber
+        })
+      ).toBe(true);
+    });
+    test('should evaluate "is" condition when both actualValue and expectedValue are strings', () => {
+      const userAttributesWithStringNumber = {
+        ...testUserAttributes,
+        sdsdd: "101"
+      };
+      const condition = [
+        {
+          id: "number-string-condition-3",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "is",
+            value: "101",
+            attrId: "sdsdd-attr"
+          }
+        }
+      ];
+      expect(
+        evaluateFilterConditions(condition, {
+          ...defaultOptions,
+          userAttributes: userAttributesWithStringNumber
+        })
+      ).toBe(true);
+    });
+    test('should evaluate "not" condition when actualValue is number and expectedValue is string', () => {
+      const condition = [
+        {
+          id: "number-string-condition-4",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "not",
+            value: "102",
+            attrId: "sdsdd-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
+    });
+    test('should evaluate "isLessThan" condition when expectedValue is string', () => {
+      const condition = [
+        {
+          id: "number-string-condition-5",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "isLessThan",
+            value: "102",
+            attrId: "sdsdd-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
+    });
+    test('should evaluate "isGreaterThan" condition when expectedValue is string', () => {
+      const condition = [
+        {
+          id: "number-string-condition-6",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "isGreaterThan",
+            value: "100",
+            attrId: "sdsdd-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
+    });
+    test('should evaluate "between" condition when value and value2 are strings', () => {
+      const condition = [
+        {
+          id: "number-string-condition-7",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "between",
+            value: "100",
+            value2: "103",
+            attrId: "sdsdd-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
+    });
+    test('should evaluate "between" condition when actualValue is string and values are strings', () => {
+      const userAttributesWithStringNumber = {
+        ...testUserAttributes,
+        sdsdd: "101"
+      };
+      const condition = [
+        {
+          id: "number-string-condition-8",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "between",
+            value: "100",
+            value2: "103",
+            attrId: "sdsdd-attr"
+          }
+        }
+      ];
+      expect(
+        evaluateFilterConditions(condition, {
+          ...defaultOptions,
+          userAttributes: userAttributesWithStringNumber
+        })
+      ).toBe(true);
+    });
+    test("should return false when actualValue is NaN", () => {
+      const userAttributesWithNaN = {
+        ...testUserAttributes,
+        sdsdd: "not-a-number"
+      };
+      const condition = [
+        {
+          id: "number-string-condition-9",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "is",
+            value: 101,
+            attrId: "sdsdd-attr"
+          }
+        }
+      ];
+      expect(
+        evaluateFilterConditions(condition, {
+          ...defaultOptions,
+          userAttributes: userAttributesWithNaN
+        })
+      ).toBe(false);
+    });
+    test("should handle decimal string values correctly", () => {
+      const userAttributesWithDecimal = {
+        ...testUserAttributes,
+        score: "85.5"
+      };
+      const condition = [
+        {
+          id: "number-string-condition-10",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "is",
+            value: "85.5",
+            attrId: "score-attr"
+          }
+        }
+      ];
+      expect(
+        evaluateFilterConditions(condition, {
+          ...defaultOptions,
+          userAttributes: userAttributesWithDecimal
+        })
+      ).toBe(true);
+    });
+    test("should handle negative string values correctly", () => {
+      const userAttributesWithNegative = {
+        ...testUserAttributes,
+        sdsdd: "-50"
+      };
+      const condition = [
+        {
+          id: "number-string-condition-11",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "isLessThan",
+            value: "0",
+            attrId: "sdsdd-attr"
+          }
+        }
+      ];
+      expect(
+        evaluateFilterConditions(condition, {
+          ...defaultOptions,
+          userAttributes: userAttributesWithNegative
+        })
+      ).toBe(true);
+    });
+  });
   describe("Boolean conditions (4 cases)", () => {
     test('should evaluate "true" condition correctly', () => {
       const condition = [

package/dist/__tests__/condition.test.cjs

@@ -143,6 +143,15 @@ 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) {
@@ -210,26 +219,27 @@ function evaluateStringCondition(logic, actualValue, expectedValue) {
   }
 }
 function evaluateNumberCondition(logic, actualValue, expectedValue, expectedValue2) {
-  const numValue = Number(actualValue);
-  const numValue2 = Number(expectedValue2);
-  if (Number.isNaN(numValue)) {
+  const numActualValue = Number(actualValue);
+  const numExpectedValue = Number(expectedValue);
+  const numExpectedValue2 = Number(expectedValue2);
+  if (Number.isNaN(numActualValue)) {
     return false;
   }
   switch (logic) {
     case "is":
-      return numValue === expectedValue;
+      return numActualValue === numExpectedValue;
     case "not":
-      return numValue !== expectedValue;
+      return numActualValue !== numExpectedValue;
     case "isLessThan":
-      return numValue < expectedValue;
+      return numActualValue < numExpectedValue;
     case "isLessThanOrEqualTo":
-      return numValue <= expectedValue;
+      return numActualValue <= numExpectedValue;
     case "isGreaterThan":
-      return numValue > expectedValue;
+      return numActualValue > numExpectedValue;
     case "isGreaterThanOrEqualTo":
-      return numValue >= expectedValue;
+      return numActualValue >= numExpectedValue;
     case "between":
-      return numValue >= expectedValue && numValue <= numValue2;
+      return numActualValue >= numExpectedValue && numActualValue <= numExpectedValue2;
     case "empty":
       return actualValue === null || actualValue === void 0 || actualValue === "";
     case "any":
@@ -253,7 +263,7 @@ function evaluateBooleanCondition(logic, actualValue) {
   }
 }
 function evaluateListCondition(logic, actualValue, expectedValues) {
-  const arrayValue = Array.isArray(actualValue) ? actualValue : [];
+  const arrayValue = isArray(actualValue) ? actualValue : [];
   if (logic === "empty" || logic === "any") {
     switch (logic) {
       case "empty":

package/dist/__tests__/condition.test.js

@@ -2,11 +2,12 @@ import {
   evaluateRulesConditions,
   filterConditionsByType,
   isConditionsActived
-} from "../chunk-YZQBWYCU.js";
+} from "../chunk-NVSDWUJP.js";
 import "../chunk-YYIGUZNZ.js";
 import "../chunk-PAESAL23.js";
-import "../chunk-E2APTIR7.js";
 import "../chunk-CEK3SCQO.js";
+import "../chunk-KYDXF7SU.js";
+import "../chunk-GFH3VWOC.js";
 import "../chunk-3KG2HTZ3.js";
 import "../chunk-XEO3YXBM.js";