@usertour/helpers 0.0.33 → 0.0.34

package/dist/__tests__/attribute.test.cjs

@@ -110,26 +110,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":
@@ -289,6 +290,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 +330,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 +604,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,7 @@
 import {
   evaluateAttributeCondition,
   evaluateFilterConditions
-} from "../chunk-E2APTIR7.js";
+} from "../chunk-7JXEY4A2.js";
 import "../chunk-XEO3YXBM.js";
 
 // src/__tests__/attribute.test.ts
@@ -52,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",
@@ -86,7 +92,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 +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 = [

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":

package/dist/__tests__/condition.test.js

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

package/dist/{chunk-E2APTIR7.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":

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

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

package/dist/conditions/attribute.cjs

@@ -130,26 +130,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":

package/dist/conditions/attribute.js

@@ -1,7 +1,7 @@
 import {
   evaluateAttributeCondition,
   evaluateFilterConditions
-} from "../chunk-E2APTIR7.js";
+} from "../chunk-7JXEY4A2.js";
 import "../chunk-XEO3YXBM.js";
 export {
   evaluateAttributeCondition,

package/dist/conditions/condition.cjs

@@ -225,26 +225,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":

package/dist/conditions/condition.js

@@ -8,10 +8,10 @@ import {
   isConditionsActived,
   isEqual,
   regenerateConditionIds
-} from "../chunk-YZQBWYCU.js";
+} from "../chunk-A4KMGXB3.js";
 import "../chunk-YYIGUZNZ.js";
 import "../chunk-PAESAL23.js";
-import "../chunk-E2APTIR7.js";
+import "../chunk-7JXEY4A2.js";
 import "../chunk-CEK3SCQO.js";
 import "../chunk-3KG2HTZ3.js";
 import "../chunk-XEO3YXBM.js";

package/dist/conditions/index.cjs

@@ -231,26 +231,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":

package/dist/conditions/index.js

@@ -9,7 +9,7 @@ import {
   isConditionsActived,
   isEqual,
   regenerateConditionIds
-} from "../chunk-YZQBWYCU.js";
+} from "../chunk-A4KMGXB3.js";
 import {
   evaluateUrlCondition,
   isMatchUrlPattern
@@ -17,7 +17,7 @@ import {
 import "../chunk-PAESAL23.js";
 import {
   evaluateAttributeCondition
-} from "../chunk-E2APTIR7.js";
+} from "../chunk-7JXEY4A2.js";
 import {
   evaluateTimeCondition
 } from "../chunk-CEK3SCQO.js";

package/dist/index.cjs

@@ -1196,26 +1196,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":

package/dist/index.js

@@ -20,7 +20,7 @@ import {
   isConditionsActived,
   isEqual,
   regenerateConditionIds
-} from "./chunk-YZQBWYCU.js";
+} from "./chunk-A4KMGXB3.js";
 import {
   evaluateUrlCondition,
   isMatchUrlPattern
@@ -28,7 +28,7 @@ import {
 import "./chunk-PAESAL23.js";
 import {
   evaluateAttributeCondition
-} from "./chunk-E2APTIR7.js";
+} from "./chunk-7JXEY4A2.js";
 import {
   evaluateTimeCondition
 } from "./chunk-CEK3SCQO.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usertour/helpers",
-  "version": "0.0.33",
+  "version": "0.0.34",
   "type": "module",
   "description": "Utility functions and helpers shared across the UserTour project",
   "homepage": "https://www.usertour.io",