@usertour/helpers 0.0.21 → 0.0.22

package/dist/__tests__/condition.test.cjs

@@ -359,7 +359,7 @@ var evaluateRule = (rule, options) => {
     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;
   }
   switch (rule.type) {
@@ -672,6 +672,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 +689,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 +698,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 +710,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 +720,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 +858,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 +889,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 +905,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 +927,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 +976,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-BJ42SRQ6.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-BJ42SRQ6.js}

@@ -54,7 +54,7 @@ var evaluateRule = (rule, options) => {
     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;
   }
   switch (rule.type) {

package/dist/conditions/condition.cjs

@@ -374,7 +374,7 @@ var evaluateRule = (rule, options) => {
     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;
   }
   switch (rule.type) {

package/dist/conditions/condition.js

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

package/dist/conditions/index.cjs

@@ -380,7 +380,7 @@ var evaluateRule = (rule, options) => {
     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;
   }
   switch (rule.type) {

package/dist/conditions/index.js

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

package/dist/index.cjs

@@ -1301,7 +1301,7 @@ var evaluateRule = (rule, options) => {
     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;
   }
   switch (rule.type) {

package/dist/index.js

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

package/package.json

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