@usertour/helpers 0.0.35 → 0.0.37

package/dist/__tests__/time.test.js

@@ -1,11 +1,16 @@
 import {
-  evaluateTimeCondition
-} from "../chunk-CEK3SCQO.js";
+  convertTimeConditionLegacyToV2,
+  evaluateTimeCondition,
+  isTimeConditionDataLegacy,
+  isTimeConditionDataV2,
+  normalizeTimeConditionData
+} from "../chunk-JQWKLXW6.js";
+import "../chunk-GFH3VWOC.js";
 import "../chunk-XEO3YXBM.js";
 
 // src/__tests__/time.test.ts
 describe("Time Condition Evaluation", () => {
-  const mockNow = /* @__PURE__ */ new Date("2024-01-15T12:00:00Z");
+  const mockNow = new Date(2024, 0, 15, 12, 0, 0);
   beforeAll(() => {
     jest.useFakeTimers();
     jest.setSystemTime(mockNow);
@@ -13,36 +18,352 @@ describe("Time Condition Evaluation", () => {
   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",
+  describe("Type Guards", () => {
+    test("isTimeConditionDataV2 should return true for new format", () => {
+      expect(isTimeConditionDataV2({ startTime: "2024-01-15T10:00:00Z" })).toBe(true);
+      expect(isTimeConditionDataV2({ endTime: "2024-01-15T14:00:00Z" })).toBe(true);
+      expect(
+        isTimeConditionDataV2({
+          startTime: "2024-01-15T10:00:00Z",
+          endTime: "2024-01-15T14:00:00Z"
+        })
+      ).toBe(true);
+    });
+    test("isTimeConditionDataV2 should return false for legacy format", () => {
+      expect(isTimeConditionDataV2({ startDate: "01/15/2024" })).toBe(false);
+      expect(isTimeConditionDataV2({})).toBe(false);
+    });
+    test("isTimeConditionDataLegacy should return true for legacy format", () => {
+      expect(isTimeConditionDataLegacy({ startDate: "01/15/2024" })).toBe(true);
+      expect(isTimeConditionDataLegacy({ startDateHour: "10" })).toBe(true);
+      expect(
+        isTimeConditionDataLegacy({
+          startDate: "01/15/2024",
+          startDateHour: "10",
+          startDateMinute: "00"
+        })
+      ).toBe(true);
+    });
+    test("isTimeConditionDataLegacy should return false for new format", () => {
+      expect(isTimeConditionDataLegacy({ startTime: "2024-01-15T10:00:00Z" })).toBe(false);
+      expect(isTimeConditionDataLegacy({})).toBe(false);
+    });
+  });
+  describe("Format Conversion", () => {
+    test("convertTimeConditionLegacyToV2 should convert valid legacy data", () => {
+      const legacyData = {
+        startDate: "01/15/2024",
+        startDateHour: "10",
+        startDateMinute: "00",
+        endDate: "01/15/2024",
+        endDateHour: "14",
+        endDateMinute: "00"
+      };
+      const result = convertTimeConditionLegacyToV2(legacyData);
+      expect(result).not.toBeNull();
+      expect(result == null ? void 0 : result.startTime).toBeDefined();
+      expect(result == null ? void 0 : result.endTime).toBeDefined();
+      expect(result == null ? void 0 : result.startTime).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
+    });
+    test("convertTimeConditionLegacyToV2 should convert legacy data without end time", () => {
+      const legacyData = {
+        startDate: "01/15/2024",
         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",
+      };
+      const result = convertTimeConditionLegacyToV2(legacyData);
+      expect(result).not.toBeNull();
+      expect(result == null ? void 0 : result.startTime).toBeDefined();
+      expect(result == null ? void 0 : result.endTime).toBeUndefined();
+    });
+    test("convertTimeConditionLegacyToV2 should return null for invalid data", () => {
+      expect(
+        convertTimeConditionLegacyToV2({
+          startDate: "",
+          startDateHour: "10",
+          startDateMinute: "00"
+        })
+      ).toBeNull();
+      expect(
+        convertTimeConditionLegacyToV2({
+          startDate: "01/15/2024",
+          startDateHour: "",
+          startDateMinute: "00"
+        })
+      ).toBeNull();
+      expect(
+        convertTimeConditionLegacyToV2({
+          startDate: "01/15/2024",
+          startDateHour: "10",
+          startDateMinute: ""
+        })
+      ).toBeNull();
+    });
+    test("normalizeTimeConditionData should return new format as-is", () => {
+      const newFormat = { startTime: "2024-01-15T10:00:00Z", endTime: "2024-01-15T14:00:00Z" };
+      expect(normalizeTimeConditionData(newFormat)).toEqual(newFormat);
+    });
+    test("normalizeTimeConditionData should convert legacy format", () => {
+      const legacyData = {
+        startDate: "01/15/2024",
         startDateHour: "10",
-        startDateMinute: "00",
-        endDate: "2024-01-15",
-        endDateHour: "14",
-        endDateMinute: "00"
-      }
-    };
-    expect(evaluateTimeCondition(rules)).toBe(false);
+        startDateMinute: "00"
+      };
+      const result = normalizeTimeConditionData(legacyData);
+      expect(result).not.toBeNull();
+      expect(result == null ? void 0 : result.startTime).toBeDefined();
+    });
+    test("normalizeTimeConditionData should return null for invalid data", () => {
+      expect(normalizeTimeConditionData(null)).toBeNull();
+      expect(normalizeTimeConditionData(void 0)).toBeNull();
+      expect(normalizeTimeConditionData({})).toBeNull();
+    });
+  });
+  describe("Legacy Format Evaluation", () => {
+    test("should return true when current time is after start time and no end time", () => {
+      const rules = {
+        id: "condition-1",
+        type: "time",
+        data: {
+          startDate: "01/15/2024",
+          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: "time",
+        data: {
+          startDate: "01/15/2024",
+          startDateHour: "10",
+          startDateMinute: "00",
+          endDate: "01/15/2024",
+          endDateHour: "14",
+          endDateMinute: "00"
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(true);
+    });
+    test("should return false when current time is before start time", () => {
+      const rules = {
+        id: "condition-3",
+        type: "time",
+        data: {
+          startDate: "01/15/2024",
+          startDateHour: "15",
+          startDateMinute: "00",
+          endDate: "",
+          endDateHour: "",
+          endDateMinute: ""
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should return false when current time is after end time", () => {
+      const rules = {
+        id: "condition-4",
+        type: "time",
+        data: {
+          startDate: "01/15/2024",
+          startDateHour: "10",
+          startDateMinute: "00",
+          endDate: "01/15/2024",
+          endDateHour: "11",
+          endDateMinute: "00"
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should return false when start date is missing", () => {
+      const rules = {
+        id: "condition-5",
+        type: "time",
+        data: {
+          startDate: "",
+          startDateHour: "10",
+          startDateMinute: "00"
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should return false when start hour is missing", () => {
+      const rules = {
+        id: "condition-6",
+        type: "time",
+        data: {
+          startDate: "01/15/2024",
+          startDateHour: "",
+          startDateMinute: "00"
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should handle empty endDate string", () => {
+      const rules = {
+        id: "condition-7",
+        type: "time",
+        data: {
+          startDate: "01/15/2024",
+          startDateHour: "10",
+          startDateMinute: "00",
+          endDate: "",
+          endDateHour: "00",
+          endDateMinute: "00"
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(true);
+    });
+    test("should handle cross-day time range", () => {
+      const crossDayTime = new Date(2024, 0, 15, 23, 0, 0);
+      jest.setSystemTime(crossDayTime);
+      const rules = {
+        id: "condition-8",
+        type: "time",
+        data: {
+          startDate: "01/15/2024",
+          startDateHour: "22",
+          startDateMinute: "00",
+          endDate: "01/16/2024",
+          endDateHour: "02",
+          endDateMinute: "00"
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(true);
+      jest.setSystemTime(mockNow);
+    });
+  });
+  describe("New Format (ISO 8601) Evaluation", () => {
+    test("should return true when current time is after start time and no end time", () => {
+      const startTime = new Date(2024, 0, 15, 10, 0, 0).toISOString();
+      const rules = {
+        id: "condition-v2-1",
+        type: "time",
+        data: {
+          startTime
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(true);
+    });
+    test("should return true when current time is within start and end time range", () => {
+      const startTime = new Date(2024, 0, 15, 10, 0, 0).toISOString();
+      const endTime = new Date(2024, 0, 15, 14, 0, 0).toISOString();
+      const rules = {
+        id: "condition-v2-2",
+        type: "time",
+        data: {
+          startTime,
+          endTime
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(true);
+    });
+    test("should return false when current time is before start time", () => {
+      const startTime = new Date(2024, 0, 15, 15, 0, 0).toISOString();
+      const rules = {
+        id: "condition-v2-3",
+        type: "time",
+        data: {
+          startTime
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should return false when current time is after end time", () => {
+      const startTime = new Date(2024, 0, 15, 10, 0, 0).toISOString();
+      const endTime = new Date(2024, 0, 15, 11, 0, 0).toISOString();
+      const rules = {
+        id: "condition-v2-4",
+        type: "time",
+        data: {
+          startTime,
+          endTime
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should return false when startTime is missing", () => {
+      const endTime = new Date(2024, 0, 15, 14, 0, 0).toISOString();
+      const rules = {
+        id: "condition-v2-5",
+        type: "time",
+        data: {
+          endTime
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should return false when startTime is invalid", () => {
+      const rules = {
+        id: "condition-v2-6",
+        type: "time",
+        data: {
+          startTime: "invalid-date"
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should handle timezone in ISO format", () => {
+      const rules = {
+        id: "condition-v2-7",
+        type: "time",
+        data: {
+          startTime: "2024-01-15T10:00:00+08:00",
+          endTime: "2024-01-15T14:00:00+08:00"
+        }
+      };
+      expect(typeof evaluateTimeCondition(rules)).toBe("boolean");
+    });
+  });
+  describe("Edge Cases", () => {
+    test("should return false for empty data", () => {
+      const rules = {
+        id: "condition-edge-1",
+        type: "time",
+        data: {}
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should return false for null data", () => {
+      const rules = {
+        id: "condition-edge-2",
+        type: "time",
+        data: null
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should return false for invalid date format in legacy", () => {
+      const rules = {
+        id: "condition-edge-3",
+        type: "time",
+        data: {
+          startDate: "invalid-date",
+          startDateHour: "10",
+          startDateMinute: "00"
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should handle invalid month/day in legacy format", () => {
+      const rules = {
+        id: "condition-edge-4",
+        type: "time",
+        data: {
+          startDate: "13/32/2024",
+          // Invalid month and day
+          startDateHour: "10",
+          startDateMinute: "00"
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
   });
 });

package/dist/{chunk-NVSDWUJP.js → chunk-E3B3AWMJ.js}

@@ -1,12 +1,12 @@
 import {
   evaluateUrlCondition
 } from "./chunk-YYIGUZNZ.js";
-import {
-  evaluateTimeCondition
-} from "./chunk-CEK3SCQO.js";
 import {
   evaluateAttributeCondition
 } from "./chunk-KYDXF7SU.js";
+import {
+  evaluateTimeCondition
+} from "./chunk-JQWKLXW6.js";
 import {
   cuid
 } from "./chunk-3KG2HTZ3.js";

package/dist/chunk-JQWKLXW6.js

@@ -0,0 +1,147 @@
+import {
+  isEmptyString,
+  isNullish
+} from "./chunk-GFH3VWOC.js";
+
+// src/conditions/time.ts
+import { isAfter, isBefore, isValid, parseISO } from "date-fns";
+function isEmpty(value) {
+  return isNullish(value) || isEmptyString(value);
+}
+function hasRequiredFields(data, type) {
+  if (type === "start") {
+    return !isEmpty(data.startDate) && !isEmpty(data.startDateHour) && !isEmpty(data.startDateMinute);
+  }
+  return !isEmpty(data.endDate) && !isEmpty(data.endDateHour) && !isEmpty(data.endDateMinute);
+}
+function parseLegacyDate(dateStr) {
+  const [month, day, year] = dateStr.split("/");
+  if (!month || !day || !year) {
+    return null;
+  }
+  return {
+    month: Number.parseInt(month),
+    day: Number.parseInt(day),
+    year: Number.parseInt(year)
+  };
+}
+function createLegacyDateTime(data, type) {
+  const dateStr = type === "start" ? data.startDate : data.endDate;
+  const hourStr = type === "start" ? data.startDateHour : data.endDateHour;
+  const minuteStr = type === "start" ? data.startDateMinute : data.endDateMinute;
+  if (!dateStr || !hourStr || !minuteStr) {
+    return null;
+  }
+  const dateParts = parseLegacyDate(dateStr);
+  if (!dateParts) {
+    return null;
+  }
+  const dateTime = new Date(
+    dateParts.year,
+    dateParts.month - 1,
+    dateParts.day,
+    Number.parseInt(hourStr),
+    Number.parseInt(minuteStr),
+    0
+  );
+  return isValid(dateTime) ? dateTime : null;
+}
+function isTimeConditionDataV2(data) {
+  return data && ("startTime" in data || "endTime" in data);
+}
+function isTimeConditionDataLegacy(data) {
+  return data && ("startDate" in data || "startDateHour" in data);
+}
+function convertTimeConditionLegacyToV2(legacyData) {
+  try {
+    if (!hasRequiredFields(legacyData, "start")) {
+      return null;
+    }
+    const startDateTime = createLegacyDateTime(legacyData, "start");
+    if (!startDateTime) {
+      return null;
+    }
+    const result = {
+      startTime: startDateTime.toISOString()
+    };
+    if (hasRequiredFields(legacyData, "end")) {
+      const endDateTime = createLegacyDateTime(legacyData, "end");
+      if (endDateTime) {
+        result.endTime = endDateTime.toISOString();
+      }
+    }
+    return result;
+  } catch {
+    return null;
+  }
+}
+function normalizeTimeConditionData(data) {
+  if (!data) {
+    return null;
+  }
+  if (isTimeConditionDataV2(data)) {
+    return data;
+  }
+  if (isTimeConditionDataLegacy(data)) {
+    return convertTimeConditionLegacyToV2(data);
+  }
+  return null;
+}
+function evaluateTimeConditionV2(data) {
+  if (!data.startTime) {
+    return false;
+  }
+  const startTime = parseISO(data.startTime);
+  if (!isValid(startTime)) {
+    return false;
+  }
+  const now = /* @__PURE__ */ new Date();
+  if (!data.endTime) {
+    return isAfter(now, startTime);
+  }
+  const endTime = parseISO(data.endTime);
+  if (!isValid(endTime)) {
+    return false;
+  }
+  return isAfter(now, startTime) && isBefore(now, endTime);
+}
+function evaluateTimeConditionLegacy(data) {
+  if (!hasRequiredFields(data, "start")) {
+    return false;
+  }
+  const startDateTime = createLegacyDateTime(data, "start");
+  if (!startDateTime) {
+    return false;
+  }
+  const now = /* @__PURE__ */ new Date();
+  if (!hasRequiredFields(data, "end")) {
+    return isAfter(now, startDateTime);
+  }
+  const endDateTime = createLegacyDateTime(data, "end");
+  if (!endDateTime) {
+    return false;
+  }
+  return isAfter(now, startDateTime) && isBefore(now, endDateTime);
+}
+var evaluateTimeCondition = (rules) => {
+  try {
+    const data = rules.data || {};
+    if (isTimeConditionDataV2(data)) {
+      return evaluateTimeConditionV2(data);
+    }
+    if (isTimeConditionDataLegacy(data)) {
+      return evaluateTimeConditionLegacy(data);
+    }
+    return false;
+  } catch {
+    return false;
+  }
+};
+
+export {
+  isTimeConditionDataV2,
+  isTimeConditionDataLegacy,
+  convertTimeConditionLegacyToV2,
+  normalizeTimeConditionData,
+  evaluateTimeCondition
+};

package/dist/{chunk-G5P7KULU.js → chunk-QWYOGIRR.js}

@@ -1,3 +1,8 @@
+import {
+  isTimeConditionDataLegacy,
+  isTimeConditionDataV2
+} from "./chunk-JQWKLXW6.js";
+
 // src/error.ts
 import {
   AttributeDataType,
@@ -53,7 +58,21 @@ var getUrlPatternError = (data) => {
 };
 var getCurrentTimeError = (data) => {
   const ret = { showError: false, errorInfo: "" };
-  if (!data.startDate && !data.endDate) {
+  if (isTimeConditionDataV2(data)) {
+    if (!data.startTime && !data.endTime) {
+      ret.showError = true;
+      ret.errorInfo = "Either start or end time be filled in";
+    }
+    return ret;
+  }
+  if (isTimeConditionDataLegacy(data)) {
+    if (!data.startDate && !data.endDate) {
+      ret.showError = true;
+      ret.errorInfo = "Either start or end time be filled in";
+    }
+    return ret;
+  }
+  if (!data || typeof data === "object" && Object.keys(data).length === 0) {
     ret.showError = true;
     ret.errorInfo = "Either start or end time be filled in";
   }