@usertour/helpers 0.0.32 → 0.0.34

package/dist/__tests__/attribute.test.js

@@ -1,7 +1,7 @@
 import {
   evaluateAttributeCondition,
   evaluateFilterConditions
-} from "../chunk-P46FJFKP.js";
+} from "../chunk-7JXEY4A2.js";
 import "../chunk-XEO3YXBM.js";
 
 // src/__tests__/attribute.test.ts
@@ -34,6 +34,12 @@ var testAttributes = [
     dataType: BizAttributeTypes.List,
     bizType: AttributeBizTypes.User
   },
+  {
+    id: "tags-attr",
+    codeName: "tags",
+    dataType: BizAttributeTypes.List,
+    bizType: AttributeBizTypes.User
+  },
   {
     id: "signUpDate-attr",
     codeName: "signUpDate",
@@ -46,6 +52,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",
@@ -78,8 +90,10 @@ var testUserAttributes = {
   age: 25,
   isPremium: true,
   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",
@@ -352,6 +366,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 = [
@@ -441,35 +678,234 @@ describe("Attribute Filter - Complete Test Suite", () => {
       ];
       expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
     });
-    test('should evaluate "notIncludesAtLeastOne" condition correctly', () => {
-      const condition = [
-        {
-          id: "condition-24",
-          type: "condition",
-          operators: "and",
-          data: {
-            logic: "notIncludesAtLeastOne",
-            listValues: ["guest"],
-            attrId: "roles-attr"
+    describe("notIncludesAtLeastOne condition", () => {
+      test("should return true when at least one value is not included (single value not included)", () => {
+        const condition = [
+          {
+            id: "condition-24",
+            type: "condition",
+            operators: "and",
+            data: {
+              logic: "notIncludesAtLeastOne",
+              listValues: ["guest"],
+              attrId: "roles-attr"
+            }
           }
-        }
-      ];
-      expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
-    });
-    test('should evaluate "notIncludesAll" condition correctly', () => {
-      const condition = [
-        {
-          id: "condition-25",
-          type: "condition",
-          operators: "and",
-          data: {
-            logic: "notIncludesAll",
-            listValues: ["admin", "guest"],
-            attrId: "roles-attr"
+        ];
+        expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
+      });
+      test("should return true when at least one value is not included (partial values not included)", () => {
+        const condition = [
+          {
+            id: "condition-24-2",
+            type: "condition",
+            operators: "and",
+            data: {
+              logic: "notIncludesAtLeastOne",
+              listValues: ["admin", "guest"],
+              attrId: "roles-attr"
+            }
           }
-        }
-      ];
-      expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
+        ];
+        expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
+      });
+      test("should return true when all values are not included", () => {
+        const condition = [
+          {
+            id: "condition-24-3",
+            type: "condition",
+            operators: "and",
+            data: {
+              logic: "notIncludesAtLeastOne",
+              listValues: ["guest", "visitor"],
+              attrId: "roles-attr"
+            }
+          }
+        ];
+        expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
+      });
+      test("should return false when all values are included", () => {
+        const condition = [
+          {
+            id: "condition-24-4",
+            type: "condition",
+            operators: "and",
+            data: {
+              logic: "notIncludesAtLeastOne",
+              listValues: ["admin", "user"],
+              attrId: "roles-attr"
+            }
+          }
+        ];
+        expect(evaluateFilterConditions(condition, defaultOptions)).toBe(false);
+      });
+      test("should return false when single value is included", () => {
+        const condition = [
+          {
+            id: "condition-24-5",
+            type: "condition",
+            operators: "and",
+            data: {
+              logic: "notIncludesAtLeastOne",
+              listValues: ["admin"],
+              attrId: "roles-attr"
+            }
+          }
+        ];
+        expect(evaluateFilterConditions(condition, defaultOptions)).toBe(false);
+      });
+      test("should return true for numeric list when at least one value is not included", () => {
+        const condition = [
+          {
+            id: "condition-24-6",
+            type: "condition",
+            operators: "and",
+            data: {
+              logic: "notIncludesAtLeastOne",
+              listValues: [123, 444],
+              attrId: "tags-attr"
+            }
+          }
+        ];
+        expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
+      });
+      test("should return false for numeric list when all values are included", () => {
+        const condition = [
+          {
+            id: "condition-24-7",
+            type: "condition",
+            operators: "and",
+            data: {
+              logic: "notIncludesAtLeastOne",
+              listValues: [123, 456],
+              attrId: "tags-attr"
+            }
+          }
+        ];
+        expect(evaluateFilterConditions(condition, defaultOptions)).toBe(false);
+      });
+    });
+    describe("notIncludesAll condition", () => {
+      test("should return true when all values are not included", () => {
+        const condition = [
+          {
+            id: "condition-25",
+            type: "condition",
+            operators: "and",
+            data: {
+              logic: "notIncludesAll",
+              listValues: ["guest", "visitor"],
+              attrId: "roles-attr"
+            }
+          }
+        ];
+        expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
+      });
+      test("should return true when single value is not included", () => {
+        const condition = [
+          {
+            id: "condition-25-2",
+            type: "condition",
+            operators: "and",
+            data: {
+              logic: "notIncludesAll",
+              listValues: ["guest"],
+              attrId: "roles-attr"
+            }
+          }
+        ];
+        expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
+      });
+      test("should return false when at least one value is included", () => {
+        const condition = [
+          {
+            id: "condition-25-3",
+            type: "condition",
+            operators: "and",
+            data: {
+              logic: "notIncludesAll",
+              listValues: ["admin", "guest"],
+              attrId: "roles-attr"
+            }
+          }
+        ];
+        expect(evaluateFilterConditions(condition, defaultOptions)).toBe(false);
+      });
+      test("should return false when all values are included", () => {
+        const condition = [
+          {
+            id: "condition-25-4",
+            type: "condition",
+            operators: "and",
+            data: {
+              logic: "notIncludesAll",
+              listValues: ["admin", "user"],
+              attrId: "roles-attr"
+            }
+          }
+        ];
+        expect(evaluateFilterConditions(condition, defaultOptions)).toBe(false);
+      });
+      test("should return false when single value is included", () => {
+        const condition = [
+          {
+            id: "condition-25-5",
+            type: "condition",
+            operators: "and",
+            data: {
+              logic: "notIncludesAll",
+              listValues: ["admin"],
+              attrId: "roles-attr"
+            }
+          }
+        ];
+        expect(evaluateFilterConditions(condition, defaultOptions)).toBe(false);
+      });
+      test("should return true for numeric list when all values are not included", () => {
+        const condition = [
+          {
+            id: "condition-25-6",
+            type: "condition",
+            operators: "and",
+            data: {
+              logic: "notIncludesAll",
+              listValues: [1234, 789],
+              attrId: "tags-attr"
+            }
+          }
+        ];
+        expect(evaluateFilterConditions(condition, defaultOptions)).toBe(true);
+      });
+      test("should return false for numeric list when at least one value is included", () => {
+        const condition = [
+          {
+            id: "condition-25-7",
+            type: "condition",
+            operators: "and",
+            data: {
+              logic: "notIncludesAll",
+              listValues: [123, 444],
+              attrId: "tags-attr"
+            }
+          }
+        ];
+        expect(evaluateFilterConditions(condition, defaultOptions)).toBe(false);
+      });
+      test("should return false for numeric list when all values are included", () => {
+        const condition = [
+          {
+            id: "condition-25-8",
+            type: "condition",
+            operators: "and",
+            data: {
+              logic: "notIncludesAll",
+              listValues: [123, 456],
+              attrId: "tags-attr"
+            }
+          }
+        ];
+        expect(evaluateFilterConditions(condition, defaultOptions)).toBe(false);
+      });
     });
     test('should evaluate "empty" condition correctly', () => {
       const condition = [

package/dist/__tests__/condition.test.cjs

@@ -210,26 +210,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":
@@ -276,9 +277,9 @@ function evaluateListCondition(logic, actualValue, expectedValues) {
     case "includesAll":
       return filteredValues.every((value) => arrayValue.includes(value));
     case "notIncludesAtLeastOne":
-      return !filteredValues.some((value) => arrayValue.includes(value));
+      return filteredValues.some((value) => !arrayValue.includes(value));
     case "notIncludesAll":
-      return !filteredValues.every((value) => arrayValue.includes(value));
+      return filteredValues.every((value) => !arrayValue.includes(value));
     default:
       return false;
   }

package/dist/__tests__/condition.test.js

@@ -2,10 +2,10 @@ import {
   evaluateRulesConditions,
   filterConditionsByType,
   isConditionsActived
-} from "../chunk-VBHUPKP7.js";
+} from "../chunk-A4KMGXB3.js";
 import "../chunk-YYIGUZNZ.js";
 import "../chunk-PAESAL23.js";
-import "../chunk-P46FJFKP.js";
+import "../chunk-7JXEY4A2.js";
 import "../chunk-CEK3SCQO.js";
 import "../chunk-3KG2HTZ3.js";
 import "../chunk-XEO3YXBM.js";

package/dist/{chunk-P46FJFKP.js → chunk-7JXEY4A2.js}

@@ -108,26 +108,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":
@@ -174,9 +175,9 @@ function evaluateListCondition(logic, actualValue, expectedValues) {
     case "includesAll":
       return filteredValues.every((value) => arrayValue.includes(value));
     case "notIncludesAtLeastOne":
-      return !filteredValues.some((value) => arrayValue.includes(value));
+      return filteredValues.some((value) => !arrayValue.includes(value));
     case "notIncludesAll":
-      return !filteredValues.every((value) => arrayValue.includes(value));
+      return filteredValues.every((value) => !arrayValue.includes(value));
     default:
       return false;
   }

package/dist/{chunk-VBHUPKP7.js → chunk-A4KMGXB3.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-YYIGUZNZ.js";
 import {
   evaluateAttributeCondition
-} from "./chunk-P46FJFKP.js";
+} from "./chunk-7JXEY4A2.js";
 import {
   evaluateTimeCondition
 } from "./chunk-CEK3SCQO.js";