@usertour/helpers 0.0.35 → 0.0.36

package/dist/__tests__/time.test.cjs

@@ -2,27 +2,151 @@
 
 // src/conditions/time.ts
 var import_date_fns = require("date-fns");
-var evaluateTimeCondition = (rules) => {
+
+// src/type-utils.ts
+var nativeIsArray = Array.isArray;
+var ObjProto = Object.prototype;
+var objToString = ObjProto.toString;
+var objHasOwn = ObjProto.hasOwnProperty;
+var isUndefined = (x) => x === void 0;
+var isString = (x) => {
+  return objToString.call(x) === "[object String]";
+};
+var isEmptyString = (x) => isString(x) && x.trim().length === 0;
+var isNull = (x) => {
+  return x === null;
+};
+var isNullish = (x) => isUndefined(x) || isNull(x);
+
+// src/conditions/time.ts
+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 (0, import_date_fns.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 {
-    const { endDate, endDateHour, endDateMinute, startDate, startDateHour, startDateMinute } = rules.data || {};
-    if (!startDate || !startDateHour || !startDateMinute) {
-      return false;
+    if (!hasRequiredFields(legacyData, "start")) {
+      return null;
     }
-    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 startDateTime = createLegacyDateTime(legacyData, "start");
+    if (!startDateTime) {
+      return null;
     }
-    const now = /* @__PURE__ */ new Date();
-    if (!endDate || !endDateHour || !endDateMinute) {
-      return (0, import_date_fns.isAfter)(now, startTime);
+    const result = {
+      startTime: startDateTime.toISOString()
+    };
+    if (hasRequiredFields(legacyData, "end")) {
+      const endDateTime = createLegacyDateTime(legacyData, "end");
+      if (endDateTime) {
+        result.endTime = endDateTime.toISOString();
+      }
     }
-    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 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 = (0, import_date_fns.parseISO)(data.startTime);
+  if (!(0, import_date_fns.isValid)(startTime)) {
+    return false;
+  }
+  const now = /* @__PURE__ */ new Date();
+  if (!data.endTime) {
+    return (0, import_date_fns.isAfter)(now, startTime);
+  }
+  const endTime = (0, import_date_fns.parseISO)(data.endTime);
+  if (!(0, import_date_fns.isValid)(endTime)) {
+    return false;
+  }
+  return (0, import_date_fns.isAfter)(now, startTime) && (0, import_date_fns.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 (0, import_date_fns.isAfter)(now, startDateTime);
+  }
+  const endDateTime = createLegacyDateTime(data, "end");
+  if (!endDateTime) {
+    return false;
+  }
+  return (0, import_date_fns.isAfter)(now, startDateTime) && (0, import_date_fns.isBefore)(now, endDateTime);
+}
+var evaluateTimeCondition = (rules) => {
+  try {
+    const data = rules.data || {};
+    if (isTimeConditionDataV2(data)) {
+      return evaluateTimeConditionV2(data);
     }
-    return (0, import_date_fns.isAfter)(now, startTime) && (0, import_date_fns.isBefore)(now, endTime);
+    if (isTimeConditionDataLegacy(data)) {
+      return evaluateTimeConditionLegacy(data);
+    }
+    return false;
   } catch {
     return false;
   }
@@ -30,7 +154,7 @@ var evaluateTimeCondition = (rules) => {
 
 // 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);
@@ -38,36 +162,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);
+    });
   });
 });