@usertour/helpers 0.0.21 → 0.0.23

package/dist/__tests__/condition.test.cjs

@@ -353,15 +353,19 @@ var filterConditionsByType = (conditions, allowedTypes) => {
 };
 var evaluateRule = (rule, options) => {
   var _a;
-  const { typeControl = {}, activatedIds, deactivatedIds } = options;
+  const { typeControl = {}, activatedIds, deactivatedIds, customEvaluators } = options;
   const ruleId = rule.id;
   if (activatedIds == null ? void 0 : activatedIds.includes(ruleId))
     return true;
   if (deactivatedIds == null ? void 0 : deactivatedIds.includes(ruleId))
     return false;
-  if (typeControl[rule.type] === false) {
+  if (typeControl[rule.type] !== true) {
     return rule.actived || false;
   }
+  const customEvaluator = customEvaluators == null ? void 0 : customEvaluators[rule.type];
+  if (customEvaluator) {
+    return customEvaluator(rule, options);
+  }
   switch (rule.type) {
     case import_types2.RulesType.CURRENT_PAGE:
       return evaluateUrlCondition(rule, ((_a = options.clientContext) == null ? void 0 : _a.page_url) || "");
@@ -672,6 +676,16 @@ describe("activedRulesConditions", () => {
     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, {
+      ...mockOptions,
+      typeControl: {}
+    });
+    expect(result[0].actived).toBe(false);
+    expect(result[1].actived).toBe(false);
+    expect(result[2].actived).toBe(false);
+    expect(result[3].actived).toBe(true);
+  });
   test("should force activate rules by ID", () => {
     const result = activedRulesConditions(mockConditions, {
       ...mockOptions,
@@ -679,7 +693,7 @@ describe("activedRulesConditions", () => {
     });
     expect(result[0].actived).toBe(true);
     expect(result[1].actived).toBe(true);
-    expect(result[2].actived).toBe(true);
+    expect(result[2].actived).toBe(false);
     expect(result[3].actived).toBe(true);
   });
   test("should force deactivate rules by ID", () => {
@@ -688,8 +702,8 @@ describe("activedRulesConditions", () => {
       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[1].actived).toBe(false);
+    expect(result[2].actived).toBe(false);
     expect(result[3].actived).toBe(false);
   });
   test("should prioritize activatedIds over deactivatedIds", () => {
@@ -700,7 +714,7 @@ describe("activedRulesConditions", () => {
     });
     expect(result[0].actived).toBe(true);
   });
-  test("should disable evaluation for specific rule types", () => {
+  test("should disable evaluation for specific rule types by default", () => {
     const result = activedRulesConditions(mockConditions, {
       ...mockOptions,
       typeControl: {
@@ -710,19 +724,34 @@ describe("activedRulesConditions", () => {
     });
     expect(result[0].actived).toBe(false);
     expect(result[1].actived).toBe(false);
-    expect(result[2].actived).toBe(true);
+    expect(result[2].actived).toBe(false);
     expect(result[3].actived).toBe(true);
   });
-  test("should evaluate URL conditions correctly", () => {
-    const result = activedRulesConditions(mockConditions, mockOptions);
+  test("should evaluate URL conditions correctly when enabled", () => {
+    const result = activedRulesConditions(mockConditions, {
+      ...mockOptions,
+      typeControl: {
+        [import_types3.RulesType.CURRENT_PAGE]: true
+      }
+    });
     expect(result[0].actived).toBe(false);
   });
-  test("should evaluate time conditions correctly", () => {
-    const result = activedRulesConditions(mockConditions, mockOptions);
+  test("should evaluate time conditions correctly when enabled", () => {
+    const result = activedRulesConditions(mockConditions, {
+      ...mockOptions,
+      typeControl: {
+        [import_types3.RulesType.TIME]: true
+      }
+    });
     expect(typeof result[1].actived).toBe("boolean");
   });
-  test("should evaluate attribute conditions correctly", () => {
-    const result = activedRulesConditions(mockConditions, mockOptions);
+  test("should evaluate attribute conditions correctly when enabled", () => {
+    const result = activedRulesConditions(mockConditions, {
+      ...mockOptions,
+      typeControl: {
+        [import_types3.RulesType.USER_ATTR]: true
+      }
+    });
     expect(result[2].actived).toBe(true);
   });
   test("should handle rules without ID", () => {
@@ -833,7 +862,7 @@ describe("activedRulesConditions", () => {
     const result = activedRulesConditions(conditions, mockOptions);
     expect(result[0].actived).toBe(false);
   });
-  test("should handle mixed rule types with different evaluation results", () => {
+  test("should handle mixed rule types with different evaluation results when enabled", () => {
     const mixedConditions = [
       {
         id: "url-rule",
@@ -864,7 +893,13 @@ describe("activedRulesConditions", () => {
         data: {}
       }
     ];
-    const result = activedRulesConditions(mixedConditions, mockOptions);
+    const result = activedRulesConditions(mixedConditions, {
+      ...mockOptions,
+      typeControl: {
+        [import_types3.RulesType.CURRENT_PAGE]: true,
+        [import_types3.RulesType.USER_ATTR]: true
+      }
+    });
     expect(result[0].actived).toBe(false);
     expect(result[1].actived).toBe(true);
     expect(result[2].actived).toBe(false);
@@ -874,7 +909,21 @@ describe("activedRulesConditions", () => {
       ...mockOptions,
       typeControl: {
         [import_types3.RulesType.CURRENT_PAGE]: false
-        // Other types not specified, should evaluate normally
+        // Other types not specified, should be disabled by default
+      }
+    });
+    expect(result[0].actived).toBe(false);
+    expect(result[1].actived).toBe(false);
+    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, {
+      ...mockOptions,
+      typeControl: {
+        [import_types3.RulesType.CURRENT_PAGE]: true,
+        [import_types3.RulesType.TIME]: true,
+        [import_types3.RulesType.USER_ATTR]: true
       }
     });
     expect(result[0].actived).toBe(false);
@@ -882,29 +931,40 @@ describe("activedRulesConditions", () => {
     expect(result[2].actived).toBe(true);
     expect(result[3].actived).toBe(true);
   });
-  test("should handle missing clientContext gracefully", () => {
+  test("should handle missing clientContext gracefully when enabled", () => {
     const result = activedRulesConditions(mockConditions, {
       attributes: mockOptions.attributes,
-      userAttributes: mockOptions.userAttributes
+      userAttributes: mockOptions.userAttributes,
+      typeControl: {
+        [import_types3.RulesType.CURRENT_PAGE]: true,
+        [import_types3.RulesType.TIME]: true,
+        [import_types3.RulesType.USER_ATTR]: true
+      }
     });
     expect(result).toHaveLength(4);
     expect(typeof result[0].actived).toBe("boolean");
   });
-  test("should handle missing attributes gracefully", () => {
+  test("should handle missing attributes gracefully when enabled", () => {
     const result = activedRulesConditions(mockConditions, {
       clientContext: mockOptions.clientContext,
-      userAttributes: mockOptions.userAttributes
+      userAttributes: mockOptions.userAttributes,
+      typeControl: {
+        [import_types3.RulesType.USER_ATTR]: true
+      }
     });
     expect(result[2].actived).toBe(false);
   });
-  test("should handle missing userAttributes gracefully", () => {
+  test("should handle missing userAttributes gracefully when enabled", () => {
     const result = activedRulesConditions(mockConditions, {
       clientContext: mockOptions.clientContext,
-      attributes: mockOptions.attributes
+      attributes: mockOptions.attributes,
+      typeControl: {
+        [import_types3.RulesType.USER_ATTR]: true
+      }
     });
     expect(result[2].actived).toBe(false);
   });
-  test("debug: should test URL evaluation directly", () => {
+  test("debug: should test URL evaluation directly when enabled", () => {
     const urlCondition = {
       id: "debug-rule",
       type: "current-page",
@@ -920,6 +980,9 @@ describe("activedRulesConditions", () => {
         page_url: "https://example.com",
         viewport_width: 1920,
         viewport_height: 1080
+      },
+      typeControl: {
+        [import_types3.RulesType.CURRENT_PAGE]: true
       }
     };
     const result = activedRulesConditions([urlCondition], options);

package/dist/__tests__/condition.test.js

@@ -2,7 +2,7 @@ import {
   activedRulesConditions,
   filterConditionsByType,
   isConditionsActived
-} from "../chunk-UNXDVBM3.js";
+} from "../chunk-U3EE75KX.js";
 import "../chunk-YYIGUZNZ.js";
 import "../chunk-PAESAL23.js";
 import "../chunk-PBZSPV5R.js";
@@ -289,6 +289,16 @@ describe("activedRulesConditions", () => {
     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, {
+      ...mockOptions,
+      typeControl: {}
+    });
+    expect(result[0].actived).toBe(false);
+    expect(result[1].actived).toBe(false);
+    expect(result[2].actived).toBe(false);
+    expect(result[3].actived).toBe(true);
+  });
   test("should force activate rules by ID", () => {
     const result = activedRulesConditions(mockConditions, {
       ...mockOptions,
@@ -296,7 +306,7 @@ describe("activedRulesConditions", () => {
     });
     expect(result[0].actived).toBe(true);
     expect(result[1].actived).toBe(true);
-    expect(result[2].actived).toBe(true);
+    expect(result[2].actived).toBe(false);
     expect(result[3].actived).toBe(true);
   });
   test("should force deactivate rules by ID", () => {
@@ -305,8 +315,8 @@ describe("activedRulesConditions", () => {
       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[1].actived).toBe(false);
+    expect(result[2].actived).toBe(false);
     expect(result[3].actived).toBe(false);
   });
   test("should prioritize activatedIds over deactivatedIds", () => {
@@ -317,7 +327,7 @@ describe("activedRulesConditions", () => {
     });
     expect(result[0].actived).toBe(true);
   });
-  test("should disable evaluation for specific rule types", () => {
+  test("should disable evaluation for specific rule types by default", () => {
     const result = activedRulesConditions(mockConditions, {
       ...mockOptions,
       typeControl: {
@@ -327,19 +337,34 @@ describe("activedRulesConditions", () => {
     });
     expect(result[0].actived).toBe(false);
     expect(result[1].actived).toBe(false);
-    expect(result[2].actived).toBe(true);
+    expect(result[2].actived).toBe(false);
     expect(result[3].actived).toBe(true);
   });
-  test("should evaluate URL conditions correctly", () => {
-    const result = activedRulesConditions(mockConditions, mockOptions);
+  test("should evaluate URL conditions correctly when enabled", () => {
+    const result = activedRulesConditions(mockConditions, {
+      ...mockOptions,
+      typeControl: {
+        [RulesType.CURRENT_PAGE]: true
+      }
+    });
     expect(result[0].actived).toBe(false);
   });
-  test("should evaluate time conditions correctly", () => {
-    const result = activedRulesConditions(mockConditions, mockOptions);
+  test("should evaluate time conditions correctly when enabled", () => {
+    const result = activedRulesConditions(mockConditions, {
+      ...mockOptions,
+      typeControl: {
+        [RulesType.TIME]: true
+      }
+    });
     expect(typeof result[1].actived).toBe("boolean");
   });
-  test("should evaluate attribute conditions correctly", () => {
-    const result = activedRulesConditions(mockConditions, mockOptions);
+  test("should evaluate attribute conditions correctly when enabled", () => {
+    const result = activedRulesConditions(mockConditions, {
+      ...mockOptions,
+      typeControl: {
+        [RulesType.USER_ATTR]: true
+      }
+    });
     expect(result[2].actived).toBe(true);
   });
   test("should handle rules without ID", () => {
@@ -450,7 +475,7 @@ describe("activedRulesConditions", () => {
     const result = activedRulesConditions(conditions, mockOptions);
     expect(result[0].actived).toBe(false);
   });
-  test("should handle mixed rule types with different evaluation results", () => {
+  test("should handle mixed rule types with different evaluation results when enabled", () => {
     const mixedConditions = [
       {
         id: "url-rule",
@@ -481,7 +506,13 @@ describe("activedRulesConditions", () => {
         data: {}
       }
     ];
-    const result = activedRulesConditions(mixedConditions, mockOptions);
+    const result = activedRulesConditions(mixedConditions, {
+      ...mockOptions,
+      typeControl: {
+        [RulesType.CURRENT_PAGE]: true,
+        [RulesType.USER_ATTR]: true
+      }
+    });
     expect(result[0].actived).toBe(false);
     expect(result[1].actived).toBe(true);
     expect(result[2].actived).toBe(false);
@@ -491,7 +522,21 @@ describe("activedRulesConditions", () => {
       ...mockOptions,
       typeControl: {
         [RulesType.CURRENT_PAGE]: false
-        // Other types not specified, should evaluate normally
+        // Other types not specified, should be disabled by default
+      }
+    });
+    expect(result[0].actived).toBe(false);
+    expect(result[1].actived).toBe(false);
+    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, {
+      ...mockOptions,
+      typeControl: {
+        [RulesType.CURRENT_PAGE]: true,
+        [RulesType.TIME]: true,
+        [RulesType.USER_ATTR]: true
       }
     });
     expect(result[0].actived).toBe(false);
@@ -499,29 +544,40 @@ describe("activedRulesConditions", () => {
     expect(result[2].actived).toBe(true);
     expect(result[3].actived).toBe(true);
   });
-  test("should handle missing clientContext gracefully", () => {
+  test("should handle missing clientContext gracefully when enabled", () => {
     const result = activedRulesConditions(mockConditions, {
       attributes: mockOptions.attributes,
-      userAttributes: mockOptions.userAttributes
+      userAttributes: mockOptions.userAttributes,
+      typeControl: {
+        [RulesType.CURRENT_PAGE]: true,
+        [RulesType.TIME]: true,
+        [RulesType.USER_ATTR]: true
+      }
     });
     expect(result).toHaveLength(4);
     expect(typeof result[0].actived).toBe("boolean");
   });
-  test("should handle missing attributes gracefully", () => {
+  test("should handle missing attributes gracefully when enabled", () => {
     const result = activedRulesConditions(mockConditions, {
       clientContext: mockOptions.clientContext,
-      userAttributes: mockOptions.userAttributes
+      userAttributes: mockOptions.userAttributes,
+      typeControl: {
+        [RulesType.USER_ATTR]: true
+      }
     });
     expect(result[2].actived).toBe(false);
   });
-  test("should handle missing userAttributes gracefully", () => {
+  test("should handle missing userAttributes gracefully when enabled", () => {
     const result = activedRulesConditions(mockConditions, {
       clientContext: mockOptions.clientContext,
-      attributes: mockOptions.attributes
+      attributes: mockOptions.attributes,
+      typeControl: {
+        [RulesType.USER_ATTR]: true
+      }
     });
     expect(result[2].actived).toBe(false);
   });
-  test("debug: should test URL evaluation directly", () => {
+  test("debug: should test URL evaluation directly when enabled", () => {
     const urlCondition = {
       id: "debug-rule",
       type: "current-page",
@@ -537,6 +593,9 @@ describe("activedRulesConditions", () => {
         page_url: "https://example.com",
         viewport_width: 1920,
         viewport_height: 1080
+      },
+      typeControl: {
+        [RulesType.CURRENT_PAGE]: true
       }
     };
     const result = activedRulesConditions([urlCondition], options);

package/dist/{chunk-UNXDVBM3.js → chunk-U3EE75KX.js}

@@ -48,15 +48,19 @@ var filterConditionsByType = (conditions, allowedTypes) => {
 };
 var evaluateRule = (rule, options) => {
   var _a;
-  const { typeControl = {}, activatedIds, deactivatedIds } = options;
+  const { typeControl = {}, activatedIds, deactivatedIds, customEvaluators } = options;
   const ruleId = rule.id;
   if (activatedIds == null ? void 0 : activatedIds.includes(ruleId))
     return true;
   if (deactivatedIds == null ? void 0 : deactivatedIds.includes(ruleId))
     return false;
-  if (typeControl[rule.type] === false) {
+  if (typeControl[rule.type] !== true) {
     return rule.actived || false;
   }
+  const customEvaluator = customEvaluators == null ? void 0 : customEvaluators[rule.type];
+  if (customEvaluator) {
+    return customEvaluator(rule, options);
+  }
   switch (rule.type) {
     case RulesType.CURRENT_PAGE:
       return evaluateUrlCondition(rule, ((_a = options.clientContext) == null ? void 0 : _a.page_url) || "");

package/dist/conditions/condition.cjs

@@ -368,15 +368,19 @@ var filterConditionsByType = (conditions, allowedTypes) => {
 };
 var evaluateRule = (rule, options) => {
   var _a;
-  const { typeControl = {}, activatedIds, deactivatedIds } = options;
+  const { typeControl = {}, activatedIds, deactivatedIds, customEvaluators } = options;
   const ruleId = rule.id;
   if (activatedIds == null ? void 0 : activatedIds.includes(ruleId))
     return true;
   if (deactivatedIds == null ? void 0 : deactivatedIds.includes(ruleId))
     return false;
-  if (typeControl[rule.type] === false) {
+  if (typeControl[rule.type] !== true) {
     return rule.actived || false;
   }
+  const customEvaluator = customEvaluators == null ? void 0 : customEvaluators[rule.type];
+  if (customEvaluator) {
+    return customEvaluator(rule, options);
+  }
   switch (rule.type) {
     case import_types2.RulesType.CURRENT_PAGE:
       return evaluateUrlCondition(rule, ((_a = options.clientContext) == null ? void 0 : _a.page_url) || "");

package/dist/conditions/condition.js

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

package/dist/conditions/index.cjs

@@ -374,15 +374,19 @@ var filterConditionsByType = (conditions, allowedTypes) => {
 };
 var evaluateRule = (rule, options) => {
   var _a;
-  const { typeControl = {}, activatedIds, deactivatedIds } = options;
+  const { typeControl = {}, activatedIds, deactivatedIds, customEvaluators } = options;
   const ruleId = rule.id;
   if (activatedIds == null ? void 0 : activatedIds.includes(ruleId))
     return true;
   if (deactivatedIds == null ? void 0 : deactivatedIds.includes(ruleId))
     return false;
-  if (typeControl[rule.type] === false) {
+  if (typeControl[rule.type] !== true) {
     return rule.actived || false;
   }
+  const customEvaluator = customEvaluators == null ? void 0 : customEvaluators[rule.type];
+  if (customEvaluator) {
+    return customEvaluator(rule, options);
+  }
   switch (rule.type) {
     case import_types2.RulesType.CURRENT_PAGE:
       return evaluateUrlCondition(rule, ((_a = options.clientContext) == null ? void 0 : _a.page_url) || "");

package/dist/conditions/index.js

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

package/dist/index.cjs

@@ -1295,15 +1295,19 @@ var filterConditionsByType = (conditions, allowedTypes) => {
 };
 var evaluateRule = (rule, options) => {
   var _a;
-  const { typeControl = {}, activatedIds, deactivatedIds } = options;
+  const { typeControl = {}, activatedIds, deactivatedIds, customEvaluators } = options;
   const ruleId = rule.id;
   if (activatedIds == null ? void 0 : activatedIds.includes(ruleId))
     return true;
   if (deactivatedIds == null ? void 0 : deactivatedIds.includes(ruleId))
     return false;
-  if (typeControl[rule.type] === false) {
+  if (typeControl[rule.type] !== true) {
     return rule.actived || false;
   }
+  const customEvaluator = customEvaluators == null ? void 0 : customEvaluators[rule.type];
+  if (customEvaluator) {
+    return customEvaluator(rule, options);
+  }
   switch (rule.type) {
     case import_types5.RulesType.CURRENT_PAGE:
       return evaluateUrlCondition(rule, ((_a = options.clientContext) == null ? void 0 : _a.page_url) || "");

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usertour/helpers",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "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.11",
+    "@usertour/types": "^0.0.13",
     "chroma-js": "^3.1.2",
     "class-variance-authority": "^0.4.0",
     "clsx": "^1.2.1",