@usertour/helpers 0.0.17 → 0.0.18

package/dist/__tests__/condition.test.cjs

@@ -0,0 +1,257 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/__tests__/condition.test.ts
+var import_types = require("@usertour/types");
+
+// src/conditions/condition.ts
+var import_fast_deep_equal = __toESM(require("fast-deep-equal"), 1);
+var isConditionsActived = (conditions) => {
+  if (!conditions || conditions.length === 0) {
+    return false;
+  }
+  const operator = conditions[0].operators;
+  const actives = conditions.filter((rule) => {
+    if (!rule.conditions) {
+      return rule.actived;
+    }
+    return isConditionsActived(rule.conditions);
+  });
+  return operator === "and" ? actives.length === conditions.length : actives.length > 0;
+};
+function filterConditionsByType(conditions, allowedTypes) {
+  return conditions.filter((condition) => {
+    if (condition.type === "group" && condition.conditions) {
+      const filteredGroupConditions = filterConditionsByType(condition.conditions, allowedTypes);
+      return filteredGroupConditions.length > 0;
+    }
+    return allowedTypes.includes(condition.type);
+  }).map((condition) => {
+    if (condition.type === "group" && condition.conditions) {
+      return {
+        ...condition,
+        conditions: filterConditionsByType(condition.conditions, allowedTypes)
+      };
+    }
+    return condition;
+  });
+}
+
+// src/__tests__/condition.test.ts
+describe("filterConditionsByType", () => {
+  test("should return empty array when no conditions provided", () => {
+    const result = filterConditionsByType([], [import_types.RulesType.CURRENT_PAGE, import_types.RulesType.TIME]);
+    expect(result).toEqual([]);
+  });
+  test("should filter out non-matching types", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "element",
+        operators: "and",
+        actived: true,
+        data: {}
+      },
+      {
+        id: "2",
+        type: "current-page",
+        operators: "and",
+        actived: true,
+        data: {}
+      }
+    ];
+    const result = filterConditionsByType(conditions, [import_types.RulesType.CURRENT_PAGE, import_types.RulesType.TIME]);
+    expect(result).toHaveLength(1);
+    expect(result[0].type).toBe("current-page");
+  });
+  test("should keep matching types", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "current-page",
+        operators: "and",
+        actived: true,
+        data: {}
+      },
+      {
+        id: "2",
+        type: "time",
+        operators: "and",
+        actived: true,
+        data: {}
+      }
+    ];
+    const result = filterConditionsByType(conditions, [import_types.RulesType.CURRENT_PAGE, import_types.RulesType.TIME]);
+    expect(result).toHaveLength(2);
+    expect(result.map((c) => c.type)).toEqual(["current-page", "time"]);
+  });
+  test("should handle nested group conditions", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "group",
+        operators: "and",
+        data: {},
+        conditions: [
+          {
+            id: "2",
+            type: "current-page",
+            operators: "and",
+            actived: true,
+            data: {}
+          },
+          {
+            id: "3",
+            type: "element",
+            // This should be filtered out
+            operators: "and",
+            actived: true,
+            data: {}
+          }
+        ]
+      }
+    ];
+    const result = filterConditionsByType(conditions, [import_types.RulesType.CURRENT_PAGE, import_types.RulesType.TIME]);
+    expect(result).toHaveLength(1);
+    expect(result[0].type).toBe("group");
+    expect(result[0].conditions).toHaveLength(1);
+    expect(result[0].conditions[0].type).toBe("current-page");
+  });
+  test("should remove groups with no matching conditions", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "group",
+        operators: "and",
+        data: {},
+        conditions: [
+          {
+            id: "2",
+            type: "element",
+            // This should be filtered out
+            operators: "and",
+            actived: true,
+            data: {}
+          }
+        ]
+      }
+    ];
+    const result = filterConditionsByType(conditions, [import_types.RulesType.CURRENT_PAGE, import_types.RulesType.TIME]);
+    expect(result).toHaveLength(0);
+  });
+});
+describe("isConditionsActived", () => {
+  test("should return false when no conditions provided", () => {
+    const result = isConditionsActived([]);
+    expect(result).toBe(false);
+  });
+  test("should return true when all conditions are actived with AND logic", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "current-page",
+        operators: "and",
+        actived: true,
+        data: {}
+      },
+      {
+        id: "2",
+        type: "time",
+        operators: "and",
+        actived: true,
+        data: {}
+      }
+    ];
+    const result = isConditionsActived(conditions);
+    expect(result).toBe(true);
+  });
+  test("should return false when one condition is not actived with AND logic", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "current-page",
+        operators: "and",
+        actived: true,
+        data: {}
+      },
+      {
+        id: "2",
+        type: "time",
+        operators: "and",
+        actived: false,
+        data: {}
+      }
+    ];
+    const result = isConditionsActived(conditions);
+    expect(result).toBe(false);
+  });
+  test("should return true when at least one condition is actived with OR logic", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "current-page",
+        operators: "or",
+        actived: false,
+        data: {}
+      },
+      {
+        id: "2",
+        type: "time",
+        operators: "or",
+        actived: true,
+        data: {}
+      }
+    ];
+    const result = isConditionsActived(conditions);
+    expect(result).toBe(true);
+  });
+  test("should handle nested group conditions", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "group",
+        operators: "and",
+        data: {},
+        conditions: [
+          {
+            id: "2",
+            type: "current-page",
+            operators: "and",
+            actived: true,
+            data: {}
+          },
+          {
+            id: "3",
+            type: "time",
+            operators: "and",
+            actived: true,
+            data: {}
+          }
+        ]
+      }
+    ];
+    const result = isConditionsActived(conditions);
+    expect(result).toBe(true);
+  });
+});

package/dist/__tests__/condition.test.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/__tests__/condition.test.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/__tests__/condition.test.js

@@ -0,0 +1,204 @@
+import {
+  filterConditionsByType,
+  isConditionsActived
+} from "../chunk-YOFQHQ7D.js";
+import "../chunk-XEO3YXBM.js";
+
+// src/__tests__/condition.test.ts
+import { RulesType } from "@usertour/types";
+describe("filterConditionsByType", () => {
+  test("should return empty array when no conditions provided", () => {
+    const result = filterConditionsByType([], [RulesType.CURRENT_PAGE, RulesType.TIME]);
+    expect(result).toEqual([]);
+  });
+  test("should filter out non-matching types", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "element",
+        operators: "and",
+        actived: true,
+        data: {}
+      },
+      {
+        id: "2",
+        type: "current-page",
+        operators: "and",
+        actived: true,
+        data: {}
+      }
+    ];
+    const result = filterConditionsByType(conditions, [RulesType.CURRENT_PAGE, RulesType.TIME]);
+    expect(result).toHaveLength(1);
+    expect(result[0].type).toBe("current-page");
+  });
+  test("should keep matching types", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "current-page",
+        operators: "and",
+        actived: true,
+        data: {}
+      },
+      {
+        id: "2",
+        type: "time",
+        operators: "and",
+        actived: true,
+        data: {}
+      }
+    ];
+    const result = filterConditionsByType(conditions, [RulesType.CURRENT_PAGE, RulesType.TIME]);
+    expect(result).toHaveLength(2);
+    expect(result.map((c) => c.type)).toEqual(["current-page", "time"]);
+  });
+  test("should handle nested group conditions", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "group",
+        operators: "and",
+        data: {},
+        conditions: [
+          {
+            id: "2",
+            type: "current-page",
+            operators: "and",
+            actived: true,
+            data: {}
+          },
+          {
+            id: "3",
+            type: "element",
+            // This should be filtered out
+            operators: "and",
+            actived: true,
+            data: {}
+          }
+        ]
+      }
+    ];
+    const result = filterConditionsByType(conditions, [RulesType.CURRENT_PAGE, RulesType.TIME]);
+    expect(result).toHaveLength(1);
+    expect(result[0].type).toBe("group");
+    expect(result[0].conditions).toHaveLength(1);
+    expect(result[0].conditions[0].type).toBe("current-page");
+  });
+  test("should remove groups with no matching conditions", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "group",
+        operators: "and",
+        data: {},
+        conditions: [
+          {
+            id: "2",
+            type: "element",
+            // This should be filtered out
+            operators: "and",
+            actived: true,
+            data: {}
+          }
+        ]
+      }
+    ];
+    const result = filterConditionsByType(conditions, [RulesType.CURRENT_PAGE, RulesType.TIME]);
+    expect(result).toHaveLength(0);
+  });
+});
+describe("isConditionsActived", () => {
+  test("should return false when no conditions provided", () => {
+    const result = isConditionsActived([]);
+    expect(result).toBe(false);
+  });
+  test("should return true when all conditions are actived with AND logic", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "current-page",
+        operators: "and",
+        actived: true,
+        data: {}
+      },
+      {
+        id: "2",
+        type: "time",
+        operators: "and",
+        actived: true,
+        data: {}
+      }
+    ];
+    const result = isConditionsActived(conditions);
+    expect(result).toBe(true);
+  });
+  test("should return false when one condition is not actived with AND logic", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "current-page",
+        operators: "and",
+        actived: true,
+        data: {}
+      },
+      {
+        id: "2",
+        type: "time",
+        operators: "and",
+        actived: false,
+        data: {}
+      }
+    ];
+    const result = isConditionsActived(conditions);
+    expect(result).toBe(false);
+  });
+  test("should return true when at least one condition is actived with OR logic", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "current-page",
+        operators: "or",
+        actived: false,
+        data: {}
+      },
+      {
+        id: "2",
+        type: "time",
+        operators: "or",
+        actived: true,
+        data: {}
+      }
+    ];
+    const result = isConditionsActived(conditions);
+    expect(result).toBe(true);
+  });
+  test("should handle nested group conditions", () => {
+    const conditions = [
+      {
+        id: "1",
+        type: "group",
+        operators: "and",
+        data: {},
+        conditions: [
+          {
+            id: "2",
+            type: "current-page",
+            operators: "and",
+            actived: true,
+            data: {}
+          },
+          {
+            id: "3",
+            type: "time",
+            operators: "and",
+            actived: true,
+            data: {}
+          }
+        ]
+      }
+    ];
+    const result = isConditionsActived(conditions);
+    expect(result).toBe(true);
+  });
+});

package/dist/{chunk-7CC4WXB3.js → chunk-YOFQHQ7D.js}

@@ -53,8 +53,40 @@ var conditionsIsSame = (rr1, rr2) => {
   }
   return true;
 };
+var isConditionsActived = (conditions) => {
+  if (!conditions || conditions.length === 0) {
+    return false;
+  }
+  const operator = conditions[0].operators;
+  const actives = conditions.filter((rule) => {
+    if (!rule.conditions) {
+      return rule.actived;
+    }
+    return isConditionsActived(rule.conditions);
+  });
+  return operator === "and" ? actives.length === conditions.length : actives.length > 0;
+};
+function filterConditionsByType(conditions, allowedTypes) {
+  return conditions.filter((condition) => {
+    if (condition.type === "group" && condition.conditions) {
+      const filteredGroupConditions = filterConditionsByType(condition.conditions, allowedTypes);
+      return filteredGroupConditions.length > 0;
+    }
+    return allowedTypes.includes(condition.type);
+  }).map((condition) => {
+    if (condition.type === "group" && condition.conditions) {
+      return {
+        ...condition,
+        conditions: filterConditionsByType(condition.conditions, allowedTypes)
+      };
+    }
+    return condition;
+  });
+}
 
 export {
   isEqual,
-  conditionsIsSame
+  conditionsIsSame,
+  isConditionsActived,
+  filterConditionsByType
 };

package/dist/conditions/condition.cjs

@@ -31,6 +31,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var condition_exports = {};
 __export(condition_exports, {
   conditionsIsSame: () => conditionsIsSame,
+  filterConditionsByType: () => filterConditionsByType,
+  isConditionsActived: () => isConditionsActived,
   isEqual: () => import_fast_deep_equal.default
 });
 module.exports = __toCommonJS(condition_exports);
@@ -88,8 +90,40 @@ var conditionsIsSame = (rr1, rr2) => {
   }
   return true;
 };
+var isConditionsActived = (conditions) => {
+  if (!conditions || conditions.length === 0) {
+    return false;
+  }
+  const operator = conditions[0].operators;
+  const actives = conditions.filter((rule) => {
+    if (!rule.conditions) {
+      return rule.actived;
+    }
+    return isConditionsActived(rule.conditions);
+  });
+  return operator === "and" ? actives.length === conditions.length : actives.length > 0;
+};
+function filterConditionsByType(conditions, allowedTypes) {
+  return conditions.filter((condition) => {
+    if (condition.type === "group" && condition.conditions) {
+      const filteredGroupConditions = filterConditionsByType(condition.conditions, allowedTypes);
+      return filteredGroupConditions.length > 0;
+    }
+    return allowedTypes.includes(condition.type);
+  }).map((condition) => {
+    if (condition.type === "group" && condition.conditions) {
+      return {
+        ...condition,
+        conditions: filterConditionsByType(condition.conditions, allowedTypes)
+      };
+    }
+    return condition;
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   conditionsIsSame,
+  filterConditionsByType,
+  isConditionsActived,
   isEqual
 });

package/dist/conditions/condition.d.cts

@@ -1,6 +1,14 @@
-import { RulesCondition } from '@usertour/types';
+import { RulesCondition, RulesType } from '@usertour/types';
 export { default as isEqual } from 'fast-deep-equal';
 
 declare const conditionsIsSame: (rr1: RulesCondition[], rr2: RulesCondition[]) => boolean;
+declare const isConditionsActived: (conditions: RulesCondition[]) => boolean;
+/**
+ * Recursively filter conditions by RulesType
+ * @param conditions - Array of rules conditions
+ * @param allowedTypes - Array of RulesType to filter by
+ * @returns Filtered conditions array
+ */
+declare function filterConditionsByType(conditions: RulesCondition[], allowedTypes: RulesType[]): RulesCondition[];
 
-export { conditionsIsSame };
+export { conditionsIsSame, filterConditionsByType, isConditionsActived };

package/dist/conditions/condition.d.ts

@@ -1,6 +1,14 @@
-import { RulesCondition } from '@usertour/types';
+import { RulesCondition, RulesType } from '@usertour/types';
 export { default as isEqual } from 'fast-deep-equal';
 
 declare const conditionsIsSame: (rr1: RulesCondition[], rr2: RulesCondition[]) => boolean;
+declare const isConditionsActived: (conditions: RulesCondition[]) => boolean;
+/**
+ * Recursively filter conditions by RulesType
+ * @param conditions - Array of rules conditions
+ * @param allowedTypes - Array of RulesType to filter by
+ * @returns Filtered conditions array
+ */
+declare function filterConditionsByType(conditions: RulesCondition[], allowedTypes: RulesType[]): RulesCondition[];
 
-export { conditionsIsSame };
+export { conditionsIsSame, filterConditionsByType, isConditionsActived };

package/dist/conditions/condition.js

@@ -1,9 +1,13 @@
 import {
   conditionsIsSame,
+  filterConditionsByType,
+  isConditionsActived,
   isEqual
-} from "../chunk-7CC4WXB3.js";
+} from "../chunk-YOFQHQ7D.js";
 import "../chunk-XEO3YXBM.js";
 export {
   conditionsIsSame,
+  filterConditionsByType,
+  isConditionsActived,
   isEqual
 };

package/dist/conditions/index.js

@@ -1,18 +1,18 @@
 import "../chunk-7ODE2AIC.js";
 import {
-  conditionsIsSame,
-  isEqual
-} from "../chunk-7CC4WXB3.js";
+  evaluateUrlCondition,
+  isMatchUrlPattern
+} from "../chunk-BC7KXBMF.js";
 import {
   evaluateAttributeCondition
 } from "../chunk-PBZSPV5R.js";
+import {
+  conditionsIsSame,
+  isEqual
+} from "../chunk-YOFQHQ7D.js";
 import {
   evaluateTimeCondition
 } from "../chunk-CEK3SCQO.js";
-import {
-  evaluateUrlCondition,
-  isMatchUrlPattern
-} from "../chunk-BC7KXBMF.js";
 import "../chunk-XEO3YXBM.js";
 export {
   conditionsIsSame,

package/dist/index.js

@@ -1,8 +1,8 @@
 import "./chunk-7ODE2AIC.js";
 import {
-  conditionsIsSame,
-  isEqual
-} from "./chunk-7CC4WXB3.js";
+  evaluateUrlCondition,
+  isMatchUrlPattern
+} from "./chunk-BC7KXBMF.js";
 import {
   isUrl
 } from "./chunk-ZNFXGN3M.js";
@@ -15,13 +15,13 @@ import {
 import {
   evaluateAttributeCondition
 } from "./chunk-PBZSPV5R.js";
+import {
+  conditionsIsSame,
+  isEqual
+} from "./chunk-YOFQHQ7D.js";
 import {
   evaluateTimeCondition
 } from "./chunk-CEK3SCQO.js";
-import {
-  evaluateUrlCondition,
-  isMatchUrlPattern
-} from "./chunk-BC7KXBMF.js";
 import {
   getAuthToken,
   removeAuthToken,

package/package.json

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