@usertour/helpers 0.0.20 → 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-TB7JGI2Q.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-TB7JGI2Q.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) {
@@ -93,5 +93,6 @@ export {
   conditionsIsSame,
   isConditionsActived,
   filterConditionsByType,
+  evaluateRule,
   activedRulesConditions
 };

package/dist/conditions/condition.cjs

@@ -32,6 +32,7 @@ var condition_exports = {};
 __export(condition_exports, {
   activedRulesConditions: () => activedRulesConditions,
   conditionsIsSame: () => conditionsIsSame,
+  evaluateRule: () => evaluateRule,
   filterConditionsByType: () => filterConditionsByType,
   isConditionsActived: () => isConditionsActived,
   isEqual: () => import_fast_deep_equal.default
@@ -373,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) {
@@ -410,6 +411,7 @@ var activedRulesConditions = (conditions, options = {}) => {
 0 && (module.exports = {
   activedRulesConditions,
   conditionsIsSame,
+  evaluateRule,
   filterConditionsByType,
   isConditionsActived,
   isEqual

package/dist/conditions/condition.d.cts

@@ -10,6 +10,31 @@ declare const isConditionsActived: (conditions: RulesCondition[]) => boolean;
  * @returns Filtered conditions array
  */
 declare const filterConditionsByType: (conditions: RulesCondition[], allowedTypes: RulesType[]) => RulesCondition[];
+/**
+ * Evaluate and activate rules conditions with enhanced context and type control
+ *
+ * @param conditions - Array of rules conditions to evaluate
+ * @param options - Evaluation options including context, type control, and ID overrides
+ *
+ * @example
+ * const result = await activedRulesConditions(conditions, {
+ *   clientContext: {
+ *     page_url: 'https://example.com',
+ *     viewport_width: 1920,
+ *     viewport_height: 1080
+ *   },
+ *   attributes: userAttributes,
+ *   userAttributes: userData,
+ *   typeControl: {
+ *     [RulesType.CURRENT_PAGE]: true,
+ *     [RulesType.TIME]: false,
+ *     [RulesType.USER_ATTR]: true
+ *   },
+ *   activatedIds: ['rule-1', 'rule-2'],
+ *   deactivatedIds: ['rule-3']
+ * });
+ */
+declare const evaluateRule: (rule: RulesCondition, options: RulesEvaluationOptions) => boolean;
 declare const activedRulesConditions: (conditions: RulesCondition[], options?: RulesEvaluationOptions) => RulesCondition[];
 
-export { activedRulesConditions, conditionsIsSame, filterConditionsByType, isConditionsActived };
+export { activedRulesConditions, conditionsIsSame, evaluateRule, filterConditionsByType, isConditionsActived };

package/dist/conditions/condition.d.ts

@@ -10,6 +10,31 @@ declare const isConditionsActived: (conditions: RulesCondition[]) => boolean;
  * @returns Filtered conditions array
  */
 declare const filterConditionsByType: (conditions: RulesCondition[], allowedTypes: RulesType[]) => RulesCondition[];
+/**
+ * Evaluate and activate rules conditions with enhanced context and type control
+ *
+ * @param conditions - Array of rules conditions to evaluate
+ * @param options - Evaluation options including context, type control, and ID overrides
+ *
+ * @example
+ * const result = await activedRulesConditions(conditions, {
+ *   clientContext: {
+ *     page_url: 'https://example.com',
+ *     viewport_width: 1920,
+ *     viewport_height: 1080
+ *   },
+ *   attributes: userAttributes,
+ *   userAttributes: userData,
+ *   typeControl: {
+ *     [RulesType.CURRENT_PAGE]: true,
+ *     [RulesType.TIME]: false,
+ *     [RulesType.USER_ATTR]: true
+ *   },
+ *   activatedIds: ['rule-1', 'rule-2'],
+ *   deactivatedIds: ['rule-3']
+ * });
+ */
+declare const evaluateRule: (rule: RulesCondition, options: RulesEvaluationOptions) => boolean;
 declare const activedRulesConditions: (conditions: RulesCondition[], options?: RulesEvaluationOptions) => RulesCondition[];
 
-export { activedRulesConditions, conditionsIsSame, filterConditionsByType, isConditionsActived };
+export { activedRulesConditions, conditionsIsSame, evaluateRule, filterConditionsByType, isConditionsActived };

package/dist/conditions/condition.js

@@ -1,10 +1,11 @@
 import {
   activedRulesConditions,
   conditionsIsSame,
+  evaluateRule,
   filterConditionsByType,
   isConditionsActived,
   isEqual
-} from "../chunk-TB7JGI2Q.js";
+} from "../chunk-BJ42SRQ6.js";
 import "../chunk-YYIGUZNZ.js";
 import "../chunk-PAESAL23.js";
 import "../chunk-PBZSPV5R.js";
@@ -13,6 +14,7 @@ import "../chunk-XEO3YXBM.js";
 export {
   activedRulesConditions,
   conditionsIsSame,
+  evaluateRule,
   filterConditionsByType,
   isConditionsActived,
   isEqual

package/dist/conditions/index.cjs

@@ -30,8 +30,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/conditions/index.ts
 var conditions_exports = {};
 __export(conditions_exports, {
+  activedRulesConditions: () => activedRulesConditions,
   conditionsIsSame: () => conditionsIsSame,
   evaluateAttributeCondition: () => evaluateAttributeCondition,
+  evaluateRule: () => evaluateRule,
   evaluateTimeCondition: () => evaluateTimeCondition,
   evaluateUrlCondition: () => evaluateUrlCondition,
   filterConditionsByType: () => filterConditionsByType,
@@ -370,10 +372,53 @@ var filterConditionsByType = (conditions, allowedTypes) => {
     return condition;
   });
 };
+var evaluateRule = (rule, options) => {
+  var _a;
+  const { typeControl = {}, activatedIds, deactivatedIds } = 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] !== true) {
+    return rule.actived || false;
+  }
+  switch (rule.type) {
+    case import_types2.RulesType.CURRENT_PAGE:
+      return evaluateUrlCondition(rule, ((_a = options.clientContext) == null ? void 0 : _a.page_url) || "");
+    case import_types2.RulesType.TIME:
+      return evaluateTimeCondition(rule);
+    case import_types2.RulesType.USER_ATTR:
+    case import_types2.RulesType.COMPANY_ATTR:
+      return evaluateAttributeCondition(
+        rule,
+        options.attributes || [],
+        options.userAttributes || {}
+      );
+    default:
+      return rule.actived || false;
+  }
+};
+var activedRulesConditions = (conditions, options = {}) => {
+  return conditions.map((rule) => {
+    if (rule.type === "group" && rule.conditions) {
+      return {
+        ...rule,
+        conditions: activedRulesConditions(rule.conditions, options)
+      };
+    }
+    return {
+      ...rule,
+      actived: evaluateRule(rule, options)
+    };
+  });
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  activedRulesConditions,
   conditionsIsSame,
   evaluateAttributeCondition,
+  evaluateRule,
   evaluateTimeCondition,
   evaluateUrlCondition,
   filterConditionsByType,

package/dist/conditions/index.d.cts

@@ -1,4 +1,4 @@
-export { conditionsIsSame, filterConditionsByType, isConditionsActived } from './condition.cjs';
+export { activedRulesConditions, conditionsIsSame, evaluateRule, filterConditionsByType, isConditionsActived } from './condition.cjs';
 export { evaluateUrlCondition, isMatchUrlPattern } from './url.cjs';
 export { evaluateTimeCondition } from './time.cjs';
 export { evaluateAttributeCondition } from './attribute.cjs';

package/dist/conditions/index.d.ts

@@ -1,4 +1,4 @@
-export { conditionsIsSame, filterConditionsByType, isConditionsActived } from './condition.js';
+export { activedRulesConditions, conditionsIsSame, evaluateRule, filterConditionsByType, isConditionsActived } from './condition.js';
 export { evaluateUrlCondition, isMatchUrlPattern } from './url.js';
 export { evaluateTimeCondition } from './time.js';
 export { evaluateAttributeCondition } from './attribute.js';

package/dist/conditions/index.js

@@ -1,10 +1,12 @@
 import "../chunk-7ODE2AIC.js";
 import {
+  activedRulesConditions,
   conditionsIsSame,
+  evaluateRule,
   filterConditionsByType,
   isConditionsActived,
   isEqual
-} from "../chunk-TB7JGI2Q.js";
+} from "../chunk-BJ42SRQ6.js";
 import {
   evaluateUrlCondition,
   isMatchUrlPattern
@@ -18,8 +20,10 @@ import {
 } from "../chunk-CEK3SCQO.js";
 import "../chunk-XEO3YXBM.js";
 export {
+  activedRulesConditions,
   conditionsIsSame,
   evaluateAttributeCondition,
+  evaluateRule,
   evaluateTimeCondition,
   evaluateUrlCondition,
   filterConditionsByType,

package/dist/index.cjs

@@ -39,6 +39,7 @@ __export(src_exports, {
   ArrayProto: () => ArrayProto,
   XMLHttpRequest: () => XMLHttpRequest,
   absoluteUrl: () => absoluteUrl,
+  activedRulesConditions: () => activedRulesConditions,
   assignableWindow: () => assignableWindow,
   buildConfig: () => buildConfig,
   cn: () => cn,
@@ -52,6 +53,7 @@ __export(src_exports, {
   document: () => document,
   evalCode: () => evalCode,
   evaluateAttributeCondition: () => evaluateAttributeCondition,
+  evaluateRule: () => evaluateRule,
   evaluateTimeCondition: () => evaluateTimeCondition,
   evaluateUrlCondition: () => evaluateUrlCondition,
   fetch: () => fetch,
@@ -1291,12 +1293,54 @@ var filterConditionsByType = (conditions, allowedTypes) => {
     return condition;
   });
 };
+var evaluateRule = (rule, options) => {
+  var _a;
+  const { typeControl = {}, activatedIds, deactivatedIds } = 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] !== true) {
+    return rule.actived || false;
+  }
+  switch (rule.type) {
+    case import_types5.RulesType.CURRENT_PAGE:
+      return evaluateUrlCondition(rule, ((_a = options.clientContext) == null ? void 0 : _a.page_url) || "");
+    case import_types5.RulesType.TIME:
+      return evaluateTimeCondition(rule);
+    case import_types5.RulesType.USER_ATTR:
+    case import_types5.RulesType.COMPANY_ATTR:
+      return evaluateAttributeCondition(
+        rule,
+        options.attributes || [],
+        options.userAttributes || {}
+      );
+    default:
+      return rule.actived || false;
+  }
+};
+var activedRulesConditions = (conditions, options = {}) => {
+  return conditions.map((rule) => {
+    if (rule.type === "group" && rule.conditions) {
+      return {
+        ...rule,
+        conditions: activedRulesConditions(rule.conditions, options)
+      };
+    }
+    return {
+      ...rule,
+      actived: evaluateRule(rule, options)
+    };
+  });
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AbortController,
   ArrayProto,
   XMLHttpRequest,
   absoluteUrl,
+  activedRulesConditions,
   assignableWindow,
   buildConfig,
   cn,
@@ -1310,6 +1354,7 @@ var filterConditionsByType = (conditions, allowedTypes) => {
   document,
   evalCode,
   evaluateAttributeCondition,
+  evaluateRule,
   evaluateTimeCondition,
   evaluateUrlCondition,
   fetch,

package/dist/index.d.cts

@@ -9,7 +9,7 @@ export { buildConfig, defaultContentConfig, isPublishedAtLeastOneEnvironment, is
 export { deepClone } from './utils.cjs';
 export { generateAutoStateColors, hexToHSLString, hexToRGBStr } from './color.cjs';
 export { absoluteUrl, cn, cuid, evalCode, formatDate, getRandomColor, hexToRgb, isDark, uuidV4 } from './helper.cjs';
-export { conditionsIsSame, filterConditionsByType, isConditionsActived } from './conditions/condition.cjs';
+export { activedRulesConditions, conditionsIsSame, evaluateRule, filterConditionsByType, isConditionsActived } from './conditions/condition.cjs';
 export { evaluateUrlCondition, isMatchUrlPattern } from './conditions/url.cjs';
 export { evaluateTimeCondition } from './conditions/time.cjs';
 export { evaluateAttributeCondition } from './conditions/attribute.cjs';

package/dist/index.d.ts

@@ -9,7 +9,7 @@ export { buildConfig, defaultContentConfig, isPublishedAtLeastOneEnvironment, is
 export { deepClone } from './utils.js';
 export { generateAutoStateColors, hexToHSLString, hexToRGBStr } from './color.js';
 export { absoluteUrl, cn, cuid, evalCode, formatDate, getRandomColor, hexToRgb, isDark, uuidV4 } from './helper.js';
-export { conditionsIsSame, filterConditionsByType, isConditionsActived } from './conditions/condition.js';
+export { activedRulesConditions, conditionsIsSame, evaluateRule, filterConditionsByType, isConditionsActived } from './conditions/condition.js';
 export { evaluateUrlCondition, isMatchUrlPattern } from './conditions/url.js';
 export { evaluateTimeCondition } from './conditions/time.js';
 export { evaluateAttributeCondition } from './conditions/attribute.js';

package/dist/index.js

@@ -9,11 +9,13 @@ import {
   deepClone
 } from "./chunk-2AEGAICC.js";
 import {
+  activedRulesConditions,
   conditionsIsSame,
+  evaluateRule,
   filterConditionsByType,
   isConditionsActived,
   isEqual
-} from "./chunk-TB7JGI2Q.js";
+} from "./chunk-BJ42SRQ6.js";
 import {
   evaluateUrlCondition,
   isMatchUrlPattern
@@ -115,6 +117,7 @@ export {
   ArrayProto,
   XMLHttpRequest,
   absoluteUrl,
+  activedRulesConditions,
   assignableWindow,
   buildConfig,
   cn,
@@ -128,6 +131,7 @@ export {
   document,
   evalCode,
   evaluateAttributeCondition,
+  evaluateRule,
   evaluateTimeCondition,
   evaluateUrlCondition,
   fetch,

package/package.json

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