@usertour/helpers 0.0.18 → 0.0.21

package/dist/__tests__/condition.test.js

@@ -1,7 +1,12 @@
 import {
+  activedRulesConditions,
   filterConditionsByType,
   isConditionsActived
-} from "../chunk-YOFQHQ7D.js";
+} from "../chunk-UNXDVBM3.js";
+import "../chunk-YYIGUZNZ.js";
+import "../chunk-PAESAL23.js";
+import "../chunk-PBZSPV5R.js";
+import "../chunk-CEK3SCQO.js";
 import "../chunk-XEO3YXBM.js";
 
 // src/__tests__/condition.test.ts
@@ -202,3 +207,339 @@ describe("isConditionsActived", () => {
     expect(result).toBe(true);
   });
 });
+describe("activedRulesConditions", () => {
+  const mockConditions = [
+    {
+      id: "rule-1",
+      type: "current-page",
+      operators: "and",
+      actived: false,
+      data: {
+        includes: ["https://example.com"],
+        excludes: []
+      }
+    },
+    {
+      id: "rule-2",
+      type: "time",
+      operators: "and",
+      actived: false,
+      data: {
+        startDate: "2024-01-01",
+        startDateHour: "00",
+        startDateMinute: "00"
+      }
+    },
+    {
+      id: "rule-3",
+      type: "user-attr",
+      operators: "and",
+      actived: false,
+      data: {
+        attrId: "email",
+        logic: "is",
+        value: "test@example.com"
+      }
+    },
+    {
+      id: "rule-4",
+      type: "element",
+      operators: "and",
+      actived: true,
+      data: {}
+    }
+  ];
+  const mockOptions = {
+    clientContext: {
+      page_url: "https://example.com",
+      viewport_width: 1920,
+      viewport_height: 1080
+    },
+    attributes: [
+      {
+        id: "email",
+        codeName: "email",
+        dataType: 2
+        // String
+      }
+    ],
+    userAttributes: {
+      email: "test@example.com"
+    }
+  };
+  test("should return conditions with default actived state when no options provided", () => {
+    const conditions = [
+      {
+        id: "rule-1",
+        type: "element",
+        operators: "and",
+        actived: true,
+        data: {}
+      },
+      {
+        id: "rule-2",
+        type: "element",
+        operators: "and",
+        actived: false,
+        data: {}
+      }
+    ];
+    const result = activedRulesConditions(conditions);
+    expect(result).toHaveLength(2);
+    expect(result[0].actived).toBe(true);
+    expect(result[1].actived).toBe(false);
+  });
+  test("should force activate rules by ID", () => {
+    const result = activedRulesConditions(mockConditions, {
+      ...mockOptions,
+      activatedIds: ["rule-1", "rule-2"]
+    });
+    expect(result[0].actived).toBe(true);
+    expect(result[1].actived).toBe(true);
+    expect(result[2].actived).toBe(true);
+    expect(result[3].actived).toBe(true);
+  });
+  test("should force deactivate rules by ID", () => {
+    const result = activedRulesConditions(mockConditions, {
+      ...mockOptions,
+      deactivatedIds: ["rule-1", "rule-4"]
+    });
+    expect(result[0].actived).toBe(false);
+    expect(result[1].actived).toBe(true);
+    expect(result[2].actived).toBe(true);
+    expect(result[3].actived).toBe(false);
+  });
+  test("should prioritize activatedIds over deactivatedIds", () => {
+    const result = activedRulesConditions(mockConditions, {
+      ...mockOptions,
+      activatedIds: ["rule-1"],
+      deactivatedIds: ["rule-1"]
+    });
+    expect(result[0].actived).toBe(true);
+  });
+  test("should disable evaluation for specific rule types", () => {
+    const result = activedRulesConditions(mockConditions, {
+      ...mockOptions,
+      typeControl: {
+        [RulesType.CURRENT_PAGE]: false,
+        [RulesType.TIME]: false
+      }
+    });
+    expect(result[0].actived).toBe(false);
+    expect(result[1].actived).toBe(false);
+    expect(result[2].actived).toBe(true);
+    expect(result[3].actived).toBe(true);
+  });
+  test("should evaluate URL conditions correctly", () => {
+    const result = activedRulesConditions(mockConditions, mockOptions);
+    expect(result[0].actived).toBe(false);
+  });
+  test("should evaluate time conditions correctly", () => {
+    const result = activedRulesConditions(mockConditions, mockOptions);
+    expect(typeof result[1].actived).toBe("boolean");
+  });
+  test("should evaluate attribute conditions correctly", () => {
+    const result = activedRulesConditions(mockConditions, mockOptions);
+    expect(result[2].actived).toBe(true);
+  });
+  test("should handle rules without ID", () => {
+    const conditions = [
+      {
+        id: "rule-without-id",
+        type: "element",
+        operators: "and",
+        actived: true,
+        data: {}
+      }
+    ];
+    const result = activedRulesConditions(conditions, {
+      activatedIds: ["non-existent"],
+      deactivatedIds: ["non-existent"]
+    });
+    expect(result[0].actived).toBe(true);
+  });
+  test("should handle nested group conditions", () => {
+    const nestedConditions = [
+      {
+        id: "group-1",
+        type: "group",
+        operators: "and",
+        actived: false,
+        data: {},
+        conditions: [
+          {
+            id: "rule-1",
+            type: "current-page",
+            operators: "and",
+            actived: false,
+            data: {
+              includes: ["https://example.com"],
+              excludes: []
+            }
+          },
+          {
+            id: "rule-2",
+            type: "element",
+            operators: "and",
+            actived: true,
+            data: {}
+          }
+        ]
+      }
+    ];
+    const result = activedRulesConditions(nestedConditions, {
+      ...mockOptions,
+      activatedIds: ["rule-1"]
+    });
+    expect(result[0].type).toBe("group");
+    expect(result[0].conditions).toBeDefined();
+    expect(result[0].conditions[0].actived).toBe(true);
+    expect(result[0].conditions[1].actived).toBe(true);
+  });
+  test("should handle deep nested group conditions", () => {
+    const deepNestedConditions = [
+      {
+        id: "group-1",
+        type: "group",
+        operators: "and",
+        actived: false,
+        data: {},
+        conditions: [
+          {
+            id: "group-2",
+            type: "group",
+            operators: "and",
+            actived: false,
+            data: {},
+            conditions: [
+              {
+                id: "rule-1",
+                type: "current-page",
+                operators: "and",
+                actived: false,
+                data: {
+                  includes: ["https://example.com"],
+                  excludes: []
+                }
+              }
+            ]
+          }
+        ]
+      }
+    ];
+    const result = activedRulesConditions(deepNestedConditions, {
+      ...mockOptions,
+      activatedIds: ["rule-1"]
+    });
+    expect(result[0].conditions[0].conditions[0].actived).toBe(true);
+  });
+  test("should handle empty conditions array", () => {
+    const result = activedRulesConditions([]);
+    expect(result).toEqual([]);
+  });
+  test("should handle conditions with missing data", () => {
+    const conditions = [
+      {
+        id: "rule-1",
+        type: "current-page",
+        operators: "and",
+        actived: false,
+        data: void 0
+      }
+    ];
+    const result = activedRulesConditions(conditions, mockOptions);
+    expect(result[0].actived).toBe(false);
+  });
+  test("should handle mixed rule types with different evaluation results", () => {
+    const mixedConditions = [
+      {
+        id: "url-rule",
+        type: "current-page",
+        operators: "and",
+        actived: false,
+        data: {
+          includes: ["https://wrong-url.com"],
+          excludes: []
+        }
+      },
+      {
+        id: "attr-rule",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "email",
+          logic: "is",
+          value: "test@example.com"
+        }
+      },
+      {
+        id: "element-rule",
+        type: "element",
+        operators: "and",
+        actived: false,
+        data: {}
+      }
+    ];
+    const result = activedRulesConditions(mixedConditions, mockOptions);
+    expect(result[0].actived).toBe(false);
+    expect(result[1].actived).toBe(true);
+    expect(result[2].actived).toBe(false);
+  });
+  test("should handle type control with partial configuration", () => {
+    const result = activedRulesConditions(mockConditions, {
+      ...mockOptions,
+      typeControl: {
+        [RulesType.CURRENT_PAGE]: false
+        // Other types not specified, should evaluate normally
+      }
+    });
+    expect(result[0].actived).toBe(false);
+    expect(result[1].actived).toBe(true);
+    expect(result[2].actived).toBe(true);
+    expect(result[3].actived).toBe(true);
+  });
+  test("should handle missing clientContext gracefully", () => {
+    const result = activedRulesConditions(mockConditions, {
+      attributes: mockOptions.attributes,
+      userAttributes: mockOptions.userAttributes
+    });
+    expect(result).toHaveLength(4);
+    expect(typeof result[0].actived).toBe("boolean");
+  });
+  test("should handle missing attributes gracefully", () => {
+    const result = activedRulesConditions(mockConditions, {
+      clientContext: mockOptions.clientContext,
+      userAttributes: mockOptions.userAttributes
+    });
+    expect(result[2].actived).toBe(false);
+  });
+  test("should handle missing userAttributes gracefully", () => {
+    const result = activedRulesConditions(mockConditions, {
+      clientContext: mockOptions.clientContext,
+      attributes: mockOptions.attributes
+    });
+    expect(result[2].actived).toBe(false);
+  });
+  test("debug: should test URL evaluation directly", () => {
+    const urlCondition = {
+      id: "debug-rule",
+      type: "current-page",
+      operators: "and",
+      actived: false,
+      data: {
+        includes: ["https://example.com"],
+        excludes: []
+      }
+    };
+    const options = {
+      clientContext: {
+        page_url: "https://example.com",
+        viewport_width: 1920,
+        viewport_height: 1080
+      }
+    };
+    const result = activedRulesConditions([urlCondition], options);
+    expect(result[0].actived).toBe(false);
+  });
+});