@usertour/helpers 0.0.31 → 0.0.33

package/dist/__tests__/attribute.test.cjs

@@ -176,9 +176,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;
   }
@@ -271,6 +271,12 @@ var testAttributes = [
     dataType: import_types2.BizAttributeTypes.List,
     bizType: import_types2.AttributeBizTypes.User
   },
+  {
+    id: "tags-attr",
+    codeName: "tags",
+    dataType: import_types2.BizAttributeTypes.List,
+    bizType: import_types2.AttributeBizTypes.User
+  },
   {
     id: "signUpDate-attr",
     codeName: "signUpDate",
@@ -315,6 +321,7 @@ var testUserAttributes = {
   age: 25,
   isPremium: true,
   roles: ["admin", "user"],
+  tags: [123, 456],
   signUpDate: "2024-01-15T10:30:00Z",
   score: 85.5
 };
@@ -678,35 +685,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__/attribute.test.js

@@ -1,7 +1,7 @@
 import {
   evaluateAttributeCondition,
   evaluateFilterConditions
-} from "../chunk-P46FJFKP.js";
+} from "../chunk-E2APTIR7.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",
@@ -78,6 +84,7 @@ var testUserAttributes = {
   age: 25,
   isPremium: true,
   roles: ["admin", "user"],
+  tags: [123, 456],
   signUpDate: "2024-01-15T10:30:00Z",
   score: 85.5
 };
@@ -441,35 +448,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

@@ -276,9 +276,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-YZQBWYCU.js";
 import "../chunk-YYIGUZNZ.js";
 import "../chunk-PAESAL23.js";
-import "../chunk-P46FJFKP.js";
+import "../chunk-E2APTIR7.js";
 import "../chunk-CEK3SCQO.js";
 import "../chunk-3KG2HTZ3.js";
 import "../chunk-XEO3YXBM.js";

package/dist/{chunk-P46FJFKP.js → chunk-E2APTIR7.js}

@@ -174,9 +174,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-YZQBWYCU.js}

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

package/dist/conditions/attribute.cjs

@@ -196,9 +196,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/conditions/attribute.js

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

package/dist/conditions/condition.cjs

@@ -291,9 +291,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/conditions/condition.js

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

package/dist/conditions/index.cjs

@@ -297,9 +297,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/conditions/index.js

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

package/dist/index.cjs

@@ -1262,9 +1262,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/index.js

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

package/package.json

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