@usertour/helpers 0.0.24 → 0.0.25

package/dist/__tests__/condition.test.cjs

@@ -351,7 +351,7 @@ var filterConditionsByType = (conditions, allowedTypes) => {
     return condition;
   });
 };
-var evaluateRule = (rule, options) => {
+var evaluateRule = async (rule, options) => {
   var _a;
   const { typeControl = {}, activatedIds, deactivatedIds, customEvaluators } = options;
   const ruleId = rule.id;
@@ -361,7 +361,8 @@ var evaluateRule = (rule, options) => {
     return false;
   const customEvaluator = customEvaluators == null ? void 0 : customEvaluators[rule.type];
   if (customEvaluator) {
-    return customEvaluator(rule, options);
+    const result = customEvaluator(rule, options);
+    return typeof result === "object" && result !== null && "then" in result ? await result : result;
   }
   if (typeControl[rule.type] !== true) {
     return rule.actived || false;
@@ -382,19 +383,22 @@ var evaluateRule = (rule, options) => {
       return rule.actived || false;
   }
 };
-var activedRulesConditions = (conditions, options = {}) => {
-  return conditions.map((rule) => {
+var activedRulesConditions = async (conditions, options = {}) => {
+  const results = [];
+  for (const rule of conditions) {
     if (rule.type === "group" && rule.conditions) {
-      return {
+      results.push({
         ...rule,
-        conditions: activedRulesConditions(rule.conditions, options)
-      };
+        conditions: await activedRulesConditions(rule.conditions, options)
+      });
+    } else {
+      results.push({
+        ...rule,
+        actived: await evaluateRule(rule, options)
+      });
     }
-    return {
-      ...rule,
-      actived: evaluateRule(rule, options)
-    };
-  });
+  }
+  return results;
 };
 
 // src/__tests__/condition.test.ts
@@ -654,7 +658,7 @@ describe("activedRulesConditions", () => {
       email: "test@example.com"
     }
   };
-  test("should return conditions with default actived state when no options provided", () => {
+  test("should return conditions with default actived state when no options provided", async () => {
     const conditions = [
       {
         id: "rule-1",
@@ -671,13 +675,13 @@ describe("activedRulesConditions", () => {
         data: {}
       }
     ];
-    const result = activedRulesConditions(conditions);
+    const result = await activedRulesConditions(conditions);
     expect(result).toHaveLength(2);
     expect(result[0].actived).toBe(true);
     expect(result[1].actived).toBe(false);
   });
-  test("should disable all rule types by default when typeControl is empty", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should disable all rule types by default when typeControl is empty", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       ...mockOptions,
       typeControl: {}
     });
@@ -686,8 +690,8 @@ describe("activedRulesConditions", () => {
     expect(result[2].actived).toBe(false);
     expect(result[3].actived).toBe(true);
   });
-  test("should force activate rules by ID", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should force activate rules by ID", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       ...mockOptions,
       activatedIds: ["rule-1", "rule-2"]
     });
@@ -696,8 +700,8 @@ describe("activedRulesConditions", () => {
     expect(result[2].actived).toBe(false);
     expect(result[3].actived).toBe(true);
   });
-  test("should force deactivate rules by ID", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should force deactivate rules by ID", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       ...mockOptions,
       deactivatedIds: ["rule-1", "rule-4"]
     });
@@ -706,16 +710,16 @@ describe("activedRulesConditions", () => {
     expect(result[2].actived).toBe(false);
     expect(result[3].actived).toBe(false);
   });
-  test("should prioritize activatedIds over deactivatedIds", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should prioritize activatedIds over deactivatedIds", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       ...mockOptions,
       activatedIds: ["rule-1"],
       deactivatedIds: ["rule-1"]
     });
     expect(result[0].actived).toBe(true);
   });
-  test("should disable evaluation for specific rule types by default", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should disable evaluation for specific rule types by default", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       ...mockOptions,
       typeControl: {
         [import_types3.RulesType.CURRENT_PAGE]: false,
@@ -727,8 +731,8 @@ describe("activedRulesConditions", () => {
     expect(result[2].actived).toBe(false);
     expect(result[3].actived).toBe(true);
   });
-  test("should evaluate URL conditions correctly when enabled", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should evaluate URL conditions correctly when enabled", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       ...mockOptions,
       typeControl: {
         [import_types3.RulesType.CURRENT_PAGE]: true
@@ -736,8 +740,8 @@ describe("activedRulesConditions", () => {
     });
     expect(result[0].actived).toBe(false);
   });
-  test("should evaluate time conditions correctly when enabled", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should evaluate time conditions correctly when enabled", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       ...mockOptions,
       typeControl: {
         [import_types3.RulesType.TIME]: true
@@ -745,8 +749,8 @@ describe("activedRulesConditions", () => {
     });
     expect(typeof result[1].actived).toBe("boolean");
   });
-  test("should evaluate attribute conditions correctly when enabled", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should evaluate attribute conditions correctly when enabled", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       ...mockOptions,
       typeControl: {
         [import_types3.RulesType.USER_ATTR]: true
@@ -754,7 +758,7 @@ describe("activedRulesConditions", () => {
     });
     expect(result[2].actived).toBe(true);
   });
-  test("should handle rules without ID", () => {
+  test("should handle rules without ID", async () => {
     const conditions = [
       {
         id: "rule-without-id",
@@ -764,13 +768,13 @@ describe("activedRulesConditions", () => {
         data: {}
       }
     ];
-    const result = activedRulesConditions(conditions, {
+    const result = await activedRulesConditions(conditions, {
       activatedIds: ["non-existent"],
       deactivatedIds: ["non-existent"]
     });
     expect(result[0].actived).toBe(true);
   });
-  test("should handle nested group conditions", () => {
+  test("should handle nested group conditions", async () => {
     const nestedConditions = [
       {
         id: "group-1",
@@ -799,7 +803,7 @@ describe("activedRulesConditions", () => {
         ]
       }
     ];
-    const result = activedRulesConditions(nestedConditions, {
+    const result = await activedRulesConditions(nestedConditions, {
       ...mockOptions,
       activatedIds: ["rule-1"]
     });
@@ -808,7 +812,7 @@ describe("activedRulesConditions", () => {
     expect(result[0].conditions[0].actived).toBe(true);
     expect(result[0].conditions[1].actived).toBe(true);
   });
-  test("should handle deep nested group conditions", () => {
+  test("should handle deep nested group conditions", async () => {
     const deepNestedConditions = [
       {
         id: "group-1",
@@ -839,17 +843,17 @@ describe("activedRulesConditions", () => {
         ]
       }
     ];
-    const result = activedRulesConditions(deepNestedConditions, {
+    const result = await 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([]);
+  test("should handle empty conditions array", async () => {
+    const result = await activedRulesConditions([]);
     expect(result).toEqual([]);
   });
-  test("should handle conditions with missing data", () => {
+  test("should handle conditions with missing data", async () => {
     const conditions = [
       {
         id: "rule-1",
@@ -859,10 +863,10 @@ describe("activedRulesConditions", () => {
         data: void 0
       }
     ];
-    const result = activedRulesConditions(conditions, mockOptions);
+    const result = await activedRulesConditions(conditions, mockOptions);
     expect(result[0].actived).toBe(false);
   });
-  test("should handle mixed rule types with different evaluation results when enabled", () => {
+  test("should handle mixed rule types with different evaluation results when enabled", async () => {
     const mixedConditions = [
       {
         id: "url-rule",
@@ -893,7 +897,7 @@ describe("activedRulesConditions", () => {
         data: {}
       }
     ];
-    const result = activedRulesConditions(mixedConditions, {
+    const result = await activedRulesConditions(mixedConditions, {
       ...mockOptions,
       typeControl: {
         [import_types3.RulesType.CURRENT_PAGE]: true,
@@ -904,8 +908,8 @@ describe("activedRulesConditions", () => {
     expect(result[1].actived).toBe(true);
     expect(result[2].actived).toBe(false);
   });
-  test("should handle type control with partial configuration", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should handle type control with partial configuration", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       ...mockOptions,
       typeControl: {
         [import_types3.RulesType.CURRENT_PAGE]: false
@@ -917,8 +921,8 @@ describe("activedRulesConditions", () => {
     expect(result[2].actived).toBe(false);
     expect(result[3].actived).toBe(true);
   });
-  test("should enable evaluation for explicitly enabled rule types", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should enable evaluation for explicitly enabled rule types", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       ...mockOptions,
       typeControl: {
         [import_types3.RulesType.CURRENT_PAGE]: true,
@@ -931,8 +935,31 @@ describe("activedRulesConditions", () => {
     expect(result[2].actived).toBe(true);
     expect(result[3].actived).toBe(true);
   });
-  test("should handle missing clientContext gracefully when enabled", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should support custom evaluators with async functions", async () => {
+    const customEvaluators = {
+      [import_types3.RulesType.CURRENT_PAGE]: async (_rule, _options) => {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        return true;
+      },
+      [import_types3.RulesType.USER_ATTR]: (_rule, _options) => {
+        return false;
+      }
+    };
+    const result = await activedRulesConditions(mockConditions, {
+      ...mockOptions,
+      typeControl: {
+        [import_types3.RulesType.CURRENT_PAGE]: true,
+        [import_types3.RulesType.USER_ATTR]: true
+      },
+      customEvaluators
+    });
+    expect(result[0].actived).toBe(true);
+    expect(result[2].actived).toBe(false);
+    expect(result[1].actived).toBe(false);
+    expect(result[3].actived).toBe(true);
+  });
+  test("should handle missing clientContext gracefully when enabled", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       attributes: mockOptions.attributes,
       userAttributes: mockOptions.userAttributes,
       typeControl: {
@@ -944,8 +971,8 @@ describe("activedRulesConditions", () => {
     expect(result).toHaveLength(4);
     expect(typeof result[0].actived).toBe("boolean");
   });
-  test("should handle missing attributes gracefully when enabled", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should handle missing attributes gracefully when enabled", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       clientContext: mockOptions.clientContext,
       userAttributes: mockOptions.userAttributes,
       typeControl: {
@@ -954,8 +981,8 @@ describe("activedRulesConditions", () => {
     });
     expect(result[2].actived).toBe(false);
   });
-  test("should handle missing userAttributes gracefully when enabled", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should handle missing userAttributes gracefully when enabled", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       clientContext: mockOptions.clientContext,
       attributes: mockOptions.attributes,
       typeControl: {
@@ -964,7 +991,7 @@ describe("activedRulesConditions", () => {
     });
     expect(result[2].actived).toBe(false);
   });
-  test("debug: should test URL evaluation directly when enabled", () => {
+  test("debug: should test URL evaluation directly when enabled", async () => {
     const urlCondition = {
       id: "debug-rule",
       type: "current-page",
@@ -985,7 +1012,7 @@ describe("activedRulesConditions", () => {
         [import_types3.RulesType.CURRENT_PAGE]: true
       }
     };
-    const result = activedRulesConditions([urlCondition], options);
+    const result = await activedRulesConditions([urlCondition], options);
     expect(result[0].actived).toBe(false);
   });
 });

package/dist/__tests__/condition.test.js

@@ -2,7 +2,7 @@ import {
   activedRulesConditions,
   filterConditionsByType,
   isConditionsActived
-} from "../chunk-WDSNF52D.js";
+} from "../chunk-4UMEUZN5.js";
 import "../chunk-YYIGUZNZ.js";
 import "../chunk-PAESAL23.js";
 import "../chunk-PBZSPV5R.js";
@@ -267,7 +267,7 @@ describe("activedRulesConditions", () => {
       email: "test@example.com"
     }
   };
-  test("should return conditions with default actived state when no options provided", () => {
+  test("should return conditions with default actived state when no options provided", async () => {
     const conditions = [
       {
         id: "rule-1",
@@ -284,13 +284,13 @@ describe("activedRulesConditions", () => {
         data: {}
       }
     ];
-    const result = activedRulesConditions(conditions);
+    const result = await activedRulesConditions(conditions);
     expect(result).toHaveLength(2);
     expect(result[0].actived).toBe(true);
     expect(result[1].actived).toBe(false);
   });
-  test("should disable all rule types by default when typeControl is empty", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should disable all rule types by default when typeControl is empty", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       ...mockOptions,
       typeControl: {}
     });
@@ -299,8 +299,8 @@ describe("activedRulesConditions", () => {
     expect(result[2].actived).toBe(false);
     expect(result[3].actived).toBe(true);
   });
-  test("should force activate rules by ID", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should force activate rules by ID", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       ...mockOptions,
       activatedIds: ["rule-1", "rule-2"]
     });
@@ -309,8 +309,8 @@ describe("activedRulesConditions", () => {
     expect(result[2].actived).toBe(false);
     expect(result[3].actived).toBe(true);
   });
-  test("should force deactivate rules by ID", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should force deactivate rules by ID", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       ...mockOptions,
       deactivatedIds: ["rule-1", "rule-4"]
     });
@@ -319,16 +319,16 @@ describe("activedRulesConditions", () => {
     expect(result[2].actived).toBe(false);
     expect(result[3].actived).toBe(false);
   });
-  test("should prioritize activatedIds over deactivatedIds", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should prioritize activatedIds over deactivatedIds", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       ...mockOptions,
       activatedIds: ["rule-1"],
       deactivatedIds: ["rule-1"]
     });
     expect(result[0].actived).toBe(true);
   });
-  test("should disable evaluation for specific rule types by default", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should disable evaluation for specific rule types by default", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       ...mockOptions,
       typeControl: {
         [RulesType.CURRENT_PAGE]: false,
@@ -340,8 +340,8 @@ describe("activedRulesConditions", () => {
     expect(result[2].actived).toBe(false);
     expect(result[3].actived).toBe(true);
   });
-  test("should evaluate URL conditions correctly when enabled", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should evaluate URL conditions correctly when enabled", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       ...mockOptions,
       typeControl: {
         [RulesType.CURRENT_PAGE]: true
@@ -349,8 +349,8 @@ describe("activedRulesConditions", () => {
     });
     expect(result[0].actived).toBe(false);
   });
-  test("should evaluate time conditions correctly when enabled", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should evaluate time conditions correctly when enabled", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       ...mockOptions,
       typeControl: {
         [RulesType.TIME]: true
@@ -358,8 +358,8 @@ describe("activedRulesConditions", () => {
     });
     expect(typeof result[1].actived).toBe("boolean");
   });
-  test("should evaluate attribute conditions correctly when enabled", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should evaluate attribute conditions correctly when enabled", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       ...mockOptions,
       typeControl: {
         [RulesType.USER_ATTR]: true
@@ -367,7 +367,7 @@ describe("activedRulesConditions", () => {
     });
     expect(result[2].actived).toBe(true);
   });
-  test("should handle rules without ID", () => {
+  test("should handle rules without ID", async () => {
     const conditions = [
       {
         id: "rule-without-id",
@@ -377,13 +377,13 @@ describe("activedRulesConditions", () => {
         data: {}
       }
     ];
-    const result = activedRulesConditions(conditions, {
+    const result = await activedRulesConditions(conditions, {
       activatedIds: ["non-existent"],
       deactivatedIds: ["non-existent"]
     });
     expect(result[0].actived).toBe(true);
   });
-  test("should handle nested group conditions", () => {
+  test("should handle nested group conditions", async () => {
     const nestedConditions = [
       {
         id: "group-1",
@@ -412,7 +412,7 @@ describe("activedRulesConditions", () => {
         ]
       }
     ];
-    const result = activedRulesConditions(nestedConditions, {
+    const result = await activedRulesConditions(nestedConditions, {
       ...mockOptions,
       activatedIds: ["rule-1"]
     });
@@ -421,7 +421,7 @@ describe("activedRulesConditions", () => {
     expect(result[0].conditions[0].actived).toBe(true);
     expect(result[0].conditions[1].actived).toBe(true);
   });
-  test("should handle deep nested group conditions", () => {
+  test("should handle deep nested group conditions", async () => {
     const deepNestedConditions = [
       {
         id: "group-1",
@@ -452,17 +452,17 @@ describe("activedRulesConditions", () => {
         ]
       }
     ];
-    const result = activedRulesConditions(deepNestedConditions, {
+    const result = await 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([]);
+  test("should handle empty conditions array", async () => {
+    const result = await activedRulesConditions([]);
     expect(result).toEqual([]);
   });
-  test("should handle conditions with missing data", () => {
+  test("should handle conditions with missing data", async () => {
     const conditions = [
       {
         id: "rule-1",
@@ -472,10 +472,10 @@ describe("activedRulesConditions", () => {
         data: void 0
       }
     ];
-    const result = activedRulesConditions(conditions, mockOptions);
+    const result = await activedRulesConditions(conditions, mockOptions);
     expect(result[0].actived).toBe(false);
   });
-  test("should handle mixed rule types with different evaluation results when enabled", () => {
+  test("should handle mixed rule types with different evaluation results when enabled", async () => {
     const mixedConditions = [
       {
         id: "url-rule",
@@ -506,7 +506,7 @@ describe("activedRulesConditions", () => {
         data: {}
       }
     ];
-    const result = activedRulesConditions(mixedConditions, {
+    const result = await activedRulesConditions(mixedConditions, {
       ...mockOptions,
       typeControl: {
         [RulesType.CURRENT_PAGE]: true,
@@ -517,8 +517,8 @@ describe("activedRulesConditions", () => {
     expect(result[1].actived).toBe(true);
     expect(result[2].actived).toBe(false);
   });
-  test("should handle type control with partial configuration", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should handle type control with partial configuration", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       ...mockOptions,
       typeControl: {
         [RulesType.CURRENT_PAGE]: false
@@ -530,8 +530,8 @@ describe("activedRulesConditions", () => {
     expect(result[2].actived).toBe(false);
     expect(result[3].actived).toBe(true);
   });
-  test("should enable evaluation for explicitly enabled rule types", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should enable evaluation for explicitly enabled rule types", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       ...mockOptions,
       typeControl: {
         [RulesType.CURRENT_PAGE]: true,
@@ -544,8 +544,31 @@ describe("activedRulesConditions", () => {
     expect(result[2].actived).toBe(true);
     expect(result[3].actived).toBe(true);
   });
-  test("should handle missing clientContext gracefully when enabled", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should support custom evaluators with async functions", async () => {
+    const customEvaluators = {
+      [RulesType.CURRENT_PAGE]: async (_rule, _options) => {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        return true;
+      },
+      [RulesType.USER_ATTR]: (_rule, _options) => {
+        return false;
+      }
+    };
+    const result = await activedRulesConditions(mockConditions, {
+      ...mockOptions,
+      typeControl: {
+        [RulesType.CURRENT_PAGE]: true,
+        [RulesType.USER_ATTR]: true
+      },
+      customEvaluators
+    });
+    expect(result[0].actived).toBe(true);
+    expect(result[2].actived).toBe(false);
+    expect(result[1].actived).toBe(false);
+    expect(result[3].actived).toBe(true);
+  });
+  test("should handle missing clientContext gracefully when enabled", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       attributes: mockOptions.attributes,
       userAttributes: mockOptions.userAttributes,
       typeControl: {
@@ -557,8 +580,8 @@ describe("activedRulesConditions", () => {
     expect(result).toHaveLength(4);
     expect(typeof result[0].actived).toBe("boolean");
   });
-  test("should handle missing attributes gracefully when enabled", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should handle missing attributes gracefully when enabled", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       clientContext: mockOptions.clientContext,
       userAttributes: mockOptions.userAttributes,
       typeControl: {
@@ -567,8 +590,8 @@ describe("activedRulesConditions", () => {
     });
     expect(result[2].actived).toBe(false);
   });
-  test("should handle missing userAttributes gracefully when enabled", () => {
-    const result = activedRulesConditions(mockConditions, {
+  test("should handle missing userAttributes gracefully when enabled", async () => {
+    const result = await activedRulesConditions(mockConditions, {
       clientContext: mockOptions.clientContext,
       attributes: mockOptions.attributes,
       typeControl: {
@@ -577,7 +600,7 @@ describe("activedRulesConditions", () => {
     });
     expect(result[2].actived).toBe(false);
   });
-  test("debug: should test URL evaluation directly when enabled", () => {
+  test("debug: should test URL evaluation directly when enabled", async () => {
     const urlCondition = {
       id: "debug-rule",
       type: "current-page",
@@ -598,7 +621,7 @@ describe("activedRulesConditions", () => {
         [RulesType.CURRENT_PAGE]: true
       }
     };
-    const result = activedRulesConditions([urlCondition], options);
+    const result = await activedRulesConditions([urlCondition], options);
     expect(result[0].actived).toBe(false);
   });
 });

package/dist/{chunk-WDSNF52D.js → chunk-4UMEUZN5.js}

@@ -44,7 +44,7 @@ var filterConditionsByType = (conditions, allowedTypes) => {
     return condition;
   });
 };
-var evaluateRule = (rule, options) => {
+var evaluateRule = async (rule, options) => {
   var _a;
   const { typeControl = {}, activatedIds, deactivatedIds, customEvaluators } = options;
   const ruleId = rule.id;
@@ -54,7 +54,8 @@ var evaluateRule = (rule, options) => {
     return false;
   const customEvaluator = customEvaluators == null ? void 0 : customEvaluators[rule.type];
   if (customEvaluator) {
-    return customEvaluator(rule, options);
+    const result = customEvaluator(rule, options);
+    return typeof result === "object" && result !== null && "then" in result ? await result : result;
   }
   if (typeControl[rule.type] !== true) {
     return rule.actived || false;
@@ -75,19 +76,22 @@ var evaluateRule = (rule, options) => {
       return rule.actived || false;
   }
 };
-var activedRulesConditions = (conditions, options = {}) => {
-  return conditions.map((rule) => {
+var activedRulesConditions = async (conditions, options = {}) => {
+  const results = [];
+  for (const rule of conditions) {
     if (rule.type === "group" && rule.conditions) {
-      return {
+      results.push({
         ...rule,
-        conditions: activedRulesConditions(rule.conditions, options)
-      };
+        conditions: await activedRulesConditions(rule.conditions, options)
+      });
+    } else {
+      results.push({
+        ...rule,
+        actived: await evaluateRule(rule, options)
+      });
     }
-    return {
-      ...rule,
-      actived: evaluateRule(rule, options)
-    };
-  });
+  }
+  return results;
 };
 
 export {

package/dist/conditions/condition.cjs

@@ -366,7 +366,7 @@ var filterConditionsByType = (conditions, allowedTypes) => {
     return condition;
   });
 };
-var evaluateRule = (rule, options) => {
+var evaluateRule = async (rule, options) => {
   var _a;
   const { typeControl = {}, activatedIds, deactivatedIds, customEvaluators } = options;
   const ruleId = rule.id;
@@ -376,7 +376,8 @@ var evaluateRule = (rule, options) => {
     return false;
   const customEvaluator = customEvaluators == null ? void 0 : customEvaluators[rule.type];
   if (customEvaluator) {
-    return customEvaluator(rule, options);
+    const result = customEvaluator(rule, options);
+    return typeof result === "object" && result !== null && "then" in result ? await result : result;
   }
   if (typeControl[rule.type] !== true) {
     return rule.actived || false;
@@ -397,19 +398,22 @@ var evaluateRule = (rule, options) => {
       return rule.actived || false;
   }
 };
-var activedRulesConditions = (conditions, options = {}) => {
-  return conditions.map((rule) => {
+var activedRulesConditions = async (conditions, options = {}) => {
+  const results = [];
+  for (const rule of conditions) {
     if (rule.type === "group" && rule.conditions) {
-      return {
+      results.push({
         ...rule,
-        conditions: activedRulesConditions(rule.conditions, options)
-      };
+        conditions: await activedRulesConditions(rule.conditions, options)
+      });
+    } else {
+      results.push({
+        ...rule,
+        actived: await evaluateRule(rule, options)
+      });
     }
-    return {
-      ...rule,
-      actived: evaluateRule(rule, options)
-    };
-  });
+  }
+  return results;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/conditions/condition.d.cts

@@ -34,7 +34,7 @@ declare const filterConditionsByType: (conditions: RulesCondition[], allowedType
  *   deactivatedIds: ['rule-3']
  * });
  */
-declare const evaluateRule: (rule: RulesCondition, options: RulesEvaluationOptions) => boolean;
-declare const activedRulesConditions: (conditions: RulesCondition[], options?: RulesEvaluationOptions) => RulesCondition[];
+declare const evaluateRule: (rule: RulesCondition, options: RulesEvaluationOptions) => Promise<boolean>;
+declare const activedRulesConditions: (conditions: RulesCondition[], options?: RulesEvaluationOptions) => Promise<RulesCondition[]>;
 
 export { activedRulesConditions, conditionsIsSame, evaluateRule, filterConditionsByType, isConditionsActived };

package/dist/conditions/condition.d.ts

@@ -34,7 +34,7 @@ declare const filterConditionsByType: (conditions: RulesCondition[], allowedType
  *   deactivatedIds: ['rule-3']
  * });
  */
-declare const evaluateRule: (rule: RulesCondition, options: RulesEvaluationOptions) => boolean;
-declare const activedRulesConditions: (conditions: RulesCondition[], options?: RulesEvaluationOptions) => RulesCondition[];
+declare const evaluateRule: (rule: RulesCondition, options: RulesEvaluationOptions) => Promise<boolean>;
+declare const activedRulesConditions: (conditions: RulesCondition[], options?: RulesEvaluationOptions) => Promise<RulesCondition[]>;
 
 export { activedRulesConditions, conditionsIsSame, evaluateRule, filterConditionsByType, isConditionsActived };

package/dist/conditions/condition.js

@@ -5,7 +5,7 @@ import {
   filterConditionsByType,
   isConditionsActived,
   isEqual
-} from "../chunk-WDSNF52D.js";
+} from "../chunk-4UMEUZN5.js";
 import "../chunk-YYIGUZNZ.js";
 import "../chunk-PAESAL23.js";
 import "../chunk-PBZSPV5R.js";

package/dist/conditions/index.cjs

@@ -372,7 +372,7 @@ var filterConditionsByType = (conditions, allowedTypes) => {
     return condition;
   });
 };
-var evaluateRule = (rule, options) => {
+var evaluateRule = async (rule, options) => {
   var _a;
   const { typeControl = {}, activatedIds, deactivatedIds, customEvaluators } = options;
   const ruleId = rule.id;
@@ -382,7 +382,8 @@ var evaluateRule = (rule, options) => {
     return false;
   const customEvaluator = customEvaluators == null ? void 0 : customEvaluators[rule.type];
   if (customEvaluator) {
-    return customEvaluator(rule, options);
+    const result = customEvaluator(rule, options);
+    return typeof result === "object" && result !== null && "then" in result ? await result : result;
   }
   if (typeControl[rule.type] !== true) {
     return rule.actived || false;
@@ -403,19 +404,22 @@ var evaluateRule = (rule, options) => {
       return rule.actived || false;
   }
 };
-var activedRulesConditions = (conditions, options = {}) => {
-  return conditions.map((rule) => {
+var activedRulesConditions = async (conditions, options = {}) => {
+  const results = [];
+  for (const rule of conditions) {
     if (rule.type === "group" && rule.conditions) {
-      return {
+      results.push({
         ...rule,
-        conditions: activedRulesConditions(rule.conditions, options)
-      };
+        conditions: await activedRulesConditions(rule.conditions, options)
+      });
+    } else {
+      results.push({
+        ...rule,
+        actived: await evaluateRule(rule, options)
+      });
     }
-    return {
-      ...rule,
-      actived: evaluateRule(rule, options)
-    };
-  });
+  }
+  return results;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/conditions/index.js

@@ -6,7 +6,7 @@ import {
   filterConditionsByType,
   isConditionsActived,
   isEqual
-} from "../chunk-WDSNF52D.js";
+} from "../chunk-4UMEUZN5.js";
 import {
   evaluateUrlCondition,
   isMatchUrlPattern

package/dist/index.cjs

@@ -1293,7 +1293,7 @@ var filterConditionsByType = (conditions, allowedTypes) => {
     return condition;
   });
 };
-var evaluateRule = (rule, options) => {
+var evaluateRule = async (rule, options) => {
   var _a;
   const { typeControl = {}, activatedIds, deactivatedIds, customEvaluators } = options;
   const ruleId = rule.id;
@@ -1303,7 +1303,8 @@ var evaluateRule = (rule, options) => {
     return false;
   const customEvaluator = customEvaluators == null ? void 0 : customEvaluators[rule.type];
   if (customEvaluator) {
-    return customEvaluator(rule, options);
+    const result = customEvaluator(rule, options);
+    return typeof result === "object" && result !== null && "then" in result ? await result : result;
   }
   if (typeControl[rule.type] !== true) {
     return rule.actived || false;
@@ -1324,19 +1325,22 @@ var evaluateRule = (rule, options) => {
       return rule.actived || false;
   }
 };
-var activedRulesConditions = (conditions, options = {}) => {
-  return conditions.map((rule) => {
+var activedRulesConditions = async (conditions, options = {}) => {
+  const results = [];
+  for (const rule of conditions) {
     if (rule.type === "group" && rule.conditions) {
-      return {
+      results.push({
         ...rule,
-        conditions: activedRulesConditions(rule.conditions, options)
-      };
+        conditions: await activedRulesConditions(rule.conditions, options)
+      });
+    } else {
+      results.push({
+        ...rule,
+        actived: await evaluateRule(rule, options)
+      });
     }
-    return {
-      ...rule,
-      actived: evaluateRule(rule, options)
-    };
-  });
+  }
+  return results;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/index.js

@@ -15,7 +15,7 @@ import {
   filterConditionsByType,
   isConditionsActived,
   isEqual
-} from "./chunk-WDSNF52D.js";
+} from "./chunk-4UMEUZN5.js";
 import {
   evaluateUrlCondition,
   isMatchUrlPattern

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usertour/helpers",
-  "version": "0.0.24",
+  "version": "0.0.25",
   "type": "module",
   "description": "Utility functions and helpers shared across the UserTour project",
   "homepage": "https://www.usertour.io",
@@ -29,7 +29,7 @@
   },
   "dependencies": {
     "@paralleldrive/cuid2": "^2.2.2",
-    "@usertour/types": "^0.0.13",
+    "@usertour/types": "^0.0.14",
     "chroma-js": "^3.1.2",
     "class-variance-authority": "^0.4.0",
     "clsx": "^1.2.1",