@usertour/helpers 0.0.15 → 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/__tests__/time.test.cjs

@@ -0,0 +1,73 @@
+"use strict";
+
+// src/conditions/time.ts
+var import_date_fns = require("date-fns");
+var evaluateTimeCondition = (rules) => {
+  try {
+    const { endDate, endDateHour, endDateMinute, startDate, startDateHour, startDateMinute } = rules.data || {};
+    if (!startDate || !startDateHour || !startDateMinute) {
+      return false;
+    }
+    const startTimeString = `${startDate}T${startDateHour.padStart(2, "0")}:${startDateMinute.padStart(2, "0")}:00`;
+    const startTime = (0, import_date_fns.parseISO)(startTimeString);
+    if (!(0, import_date_fns.isValid)(startTime)) {
+      return false;
+    }
+    const now = /* @__PURE__ */ new Date();
+    if (!endDate || !endDateHour || !endDateMinute) {
+      return (0, import_date_fns.isAfter)(now, startTime);
+    }
+    const endTimeString = `${endDate}T${endDateHour.padStart(2, "0")}:${endDateMinute.padStart(2, "0")}:00`;
+    const endTime = (0, import_date_fns.parseISO)(endTimeString);
+    if (!(0, import_date_fns.isValid)(endTime)) {
+      return false;
+    }
+    return (0, import_date_fns.isAfter)(now, startTime) && (0, import_date_fns.isBefore)(now, endTime);
+  } catch {
+    return false;
+  }
+};
+
+// src/__tests__/time.test.ts
+describe("Time Condition Evaluation", () => {
+  const mockNow = /* @__PURE__ */ new Date("2024-01-15T12:00:00Z");
+  beforeAll(() => {
+    jest.useFakeTimers();
+    jest.setSystemTime(mockNow);
+  });
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+  test("should return true when current time is after start time and no end time", () => {
+    const rules = {
+      id: "condition-1",
+      type: "condition",
+      operators: "and",
+      data: {
+        startDate: "2024-01-15",
+        startDateHour: "10",
+        startDateMinute: "00",
+        endDate: "",
+        endDateHour: "",
+        endDateMinute: ""
+      }
+    };
+    expect(evaluateTimeCondition(rules)).toBe(true);
+  });
+  test("should return true when current time is within start and end time range", () => {
+    const rules = {
+      id: "condition-2",
+      type: "condition",
+      operators: "and",
+      data: {
+        startDate: "2024-01-15",
+        startDateHour: "10",
+        startDateMinute: "00",
+        endDate: "2024-01-15",
+        endDateHour: "14",
+        endDateMinute: "00"
+      }
+    };
+    expect(evaluateTimeCondition(rules)).toBe(false);
+  });
+});

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

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

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

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

package/dist/__tests__/time.test.js

@@ -0,0 +1,48 @@
+import {
+  evaluateTimeCondition
+} from "../chunk-CEK3SCQO.js";
+import "../chunk-XEO3YXBM.js";
+
+// src/__tests__/time.test.ts
+describe("Time Condition Evaluation", () => {
+  const mockNow = /* @__PURE__ */ new Date("2024-01-15T12:00:00Z");
+  beforeAll(() => {
+    jest.useFakeTimers();
+    jest.setSystemTime(mockNow);
+  });
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+  test("should return true when current time is after start time and no end time", () => {
+    const rules = {
+      id: "condition-1",
+      type: "condition",
+      operators: "and",
+      data: {
+        startDate: "2024-01-15",
+        startDateHour: "10",
+        startDateMinute: "00",
+        endDate: "",
+        endDateHour: "",
+        endDateMinute: ""
+      }
+    };
+    expect(evaluateTimeCondition(rules)).toBe(true);
+  });
+  test("should return true when current time is within start and end time range", () => {
+    const rules = {
+      id: "condition-2",
+      type: "condition",
+      operators: "and",
+      data: {
+        startDate: "2024-01-15",
+        startDateHour: "10",
+        startDateMinute: "00",
+        endDate: "2024-01-15",
+        endDateHour: "14",
+        endDateMinute: "00"
+      }
+    };
+    expect(evaluateTimeCondition(rules)).toBe(false);
+  });
+});