@usertour/helpers 0.0.35 → 0.0.36

package/dist/conditions/condition.cjs

@@ -129,27 +129,117 @@ var evaluateUrlCondition = (rules, url) => {
 
 // src/conditions/time.ts
 var import_date_fns = require("date-fns");
+
+// src/type-utils.ts
+var nativeIsArray = Array.isArray;
+var ObjProto = Object.prototype;
+var objToString = ObjProto.toString;
+var objHasOwn = ObjProto.hasOwnProperty;
+var isArray = nativeIsArray || ((obj) => objToString.call(obj) === "[object Array]");
+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 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 { 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 data = rules.data || {};
+    if (isTimeConditionDataV2(data)) {
+      return evaluateTimeConditionV2(data);
     }
-    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;
+    if (isTimeConditionDataLegacy(data)) {
+      return evaluateTimeConditionLegacy(data);
     }
-    return (0, import_date_fns.isAfter)(now, startTime) && (0, import_date_fns.isBefore)(now, endTime);
+    return false;
   } catch {
     return false;
   }
@@ -158,15 +248,6 @@ var evaluateTimeCondition = (rules) => {
 // src/conditions/attribute.ts
 var import_types = require("@usertour/types");
 var import_date_fns2 = require("date-fns");
-
-// src/type-utils.ts
-var nativeIsArray = Array.isArray;
-var ObjProto = Object.prototype;
-var objToString = ObjProto.toString;
-var objHasOwn = ObjProto.hasOwnProperty;
-var isArray = nativeIsArray || ((obj) => objToString.call(obj) === "[object Array]");
-
-// src/conditions/attribute.ts
 function evaluateAttributeCondition(condition, options) {
   const { data } = condition;
   if (!data) {
@@ -224,8 +305,8 @@ function evaluateStringCondition(logic, actualValue, expectedValue) {
     case "endsWith":
       return stringValue.endsWith(expectedValue);
     case "empty": {
-      const isEmpty = !stringValue || stringValue === "";
-      return isEmpty;
+      const isEmpty2 = !stringValue || stringValue === "";
+      return isEmpty2;
     }
     case "any":
       return Boolean(stringValue && stringValue !== "");

package/dist/conditions/condition.js

@@ -8,10 +8,10 @@ import {
   isConditionsActived,
   isEqual,
   regenerateConditionIds
-} from "../chunk-NVSDWUJP.js";
+} from "../chunk-3UOSPZEP.js";
 import "../chunk-YYIGUZNZ.js";
 import "../chunk-PAESAL23.js";
-import "../chunk-CEK3SCQO.js";
+import "../chunk-JQWKLXW6.js";
 import "../chunk-KYDXF7SU.js";
 import "../chunk-GFH3VWOC.js";
 import "../chunk-3KG2HTZ3.js";

package/dist/conditions/index.cjs

@@ -33,6 +33,7 @@ __export(conditions_exports, {
   allConditionsHaveIds: () => allConditionsHaveIds,
   assignConditionIds: () => assignConditionIds,
   conditionsIsSame: () => conditionsIsSame,
+  convertTimeConditionLegacyToV2: () => convertTimeConditionLegacyToV2,
   evaluateAttributeCondition: () => evaluateAttributeCondition,
   evaluateRule: () => evaluateRule,
   evaluateRulesConditions: () => evaluateRulesConditions,
@@ -42,6 +43,9 @@ __export(conditions_exports, {
   isConditionsActived: () => isConditionsActived,
   isEqual: () => import_fast_deep_equal.default,
   isMatchUrlPattern: () => isMatchUrlPattern,
+  isTimeConditionDataLegacy: () => isTimeConditionDataLegacy,
+  isTimeConditionDataV2: () => isTimeConditionDataV2,
+  normalizeTimeConditionData: () => normalizeTimeConditionData,
   regenerateConditionIds: () => regenerateConditionIds
 });
 module.exports = __toCommonJS(conditions_exports);
@@ -135,27 +139,152 @@ var evaluateUrlCondition = (rules, url) => {
 
 // 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 isArray = nativeIsArray || ((obj) => objToString.call(obj) === "[object Array]");
+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;
   }
@@ -164,15 +293,6 @@ var evaluateTimeCondition = (rules) => {
 // src/conditions/attribute.ts
 var import_types = require("@usertour/types");
 var import_date_fns2 = require("date-fns");
-
-// src/type-utils.ts
-var nativeIsArray = Array.isArray;
-var ObjProto = Object.prototype;
-var objToString = ObjProto.toString;
-var objHasOwn = ObjProto.hasOwnProperty;
-var isArray = nativeIsArray || ((obj) => objToString.call(obj) === "[object Array]");
-
-// src/conditions/attribute.ts
 function evaluateAttributeCondition(condition, options) {
   const { data } = condition;
   if (!data) {
@@ -230,8 +350,8 @@ function evaluateStringCondition(logic, actualValue, expectedValue) {
     case "endsWith":
       return stringValue.endsWith(expectedValue);
     case "empty": {
-      const isEmpty = !stringValue || stringValue === "";
-      return isEmpty;
+      const isEmpty2 = !stringValue || stringValue === "";
+      return isEmpty2;
     }
     case "any":
       return Boolean(stringValue && stringValue !== "");
@@ -541,6 +661,7 @@ var allConditionsHaveIds = (conditions) => {
   allConditionsHaveIds,
   assignConditionIds,
   conditionsIsSame,
+  convertTimeConditionLegacyToV2,
   evaluateAttributeCondition,
   evaluateRule,
   evaluateRulesConditions,
@@ -550,5 +671,8 @@ var allConditionsHaveIds = (conditions) => {
   isConditionsActived,
   isEqual,
   isMatchUrlPattern,
+  isTimeConditionDataLegacy,
+  isTimeConditionDataV2,
+  normalizeTimeConditionData,
   regenerateConditionIds
 });

package/dist/conditions/index.d.cts

@@ -1,6 +1,6 @@
 export { allConditionsHaveIds, assignConditionIds, conditionsIsSame, evaluateRule, evaluateRulesConditions, filterConditionsByType, isConditionsActived, regenerateConditionIds } from './condition.cjs';
 export { evaluateUrlCondition, isMatchUrlPattern } from './url.cjs';
-export { evaluateTimeCondition } from './time.cjs';
+export { convertTimeConditionLegacyToV2, evaluateTimeCondition, isTimeConditionDataLegacy, isTimeConditionDataV2, normalizeTimeConditionData } from './time.cjs';
 export { evaluateAttributeCondition } from './attribute.cjs';
 export { default as isEqual } from 'fast-deep-equal';
 import '@usertour/types';

package/dist/conditions/index.d.ts

@@ -1,6 +1,6 @@
 export { allConditionsHaveIds, assignConditionIds, conditionsIsSame, evaluateRule, evaluateRulesConditions, filterConditionsByType, isConditionsActived, regenerateConditionIds } from './condition.js';
 export { evaluateUrlCondition, isMatchUrlPattern } from './url.js';
-export { evaluateTimeCondition } from './time.js';
+export { convertTimeConditionLegacyToV2, evaluateTimeCondition, isTimeConditionDataLegacy, isTimeConditionDataV2, normalizeTimeConditionData } from './time.js';
 export { evaluateAttributeCondition } from './attribute.js';
 export { default as isEqual } from 'fast-deep-equal';
 import '@usertour/types';

package/dist/conditions/index.js

@@ -9,15 +9,19 @@ import {
   isConditionsActived,
   isEqual,
   regenerateConditionIds
-} from "../chunk-NVSDWUJP.js";
+} from "../chunk-3UOSPZEP.js";
 import {
   evaluateUrlCondition,
   isMatchUrlPattern
 } from "../chunk-YYIGUZNZ.js";
 import "../chunk-PAESAL23.js";
 import {
-  evaluateTimeCondition
-} from "../chunk-CEK3SCQO.js";
+  convertTimeConditionLegacyToV2,
+  evaluateTimeCondition,
+  isTimeConditionDataLegacy,
+  isTimeConditionDataV2,
+  normalizeTimeConditionData
+} from "../chunk-JQWKLXW6.js";
 import {
   evaluateAttributeCondition
 } from "../chunk-KYDXF7SU.js";
@@ -28,6 +32,7 @@ export {
   allConditionsHaveIds,
   assignConditionIds,
   conditionsIsSame,
+  convertTimeConditionLegacyToV2,
   evaluateAttributeCondition,
   evaluateRule,
   evaluateRulesConditions,
@@ -37,5 +42,8 @@ export {
   isConditionsActived,
   isEqual,
   isMatchUrlPattern,
+  isTimeConditionDataLegacy,
+  isTimeConditionDataV2,
+  normalizeTimeConditionData,
   regenerateConditionIds
 };

package/dist/conditions/time.cjs

@@ -20,36 +20,168 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/conditions/time.ts
 var time_exports = {};
 __export(time_exports, {
-  evaluateTimeCondition: () => evaluateTimeCondition
+  convertTimeConditionLegacyToV2: () => convertTimeConditionLegacyToV2,
+  evaluateTimeCondition: () => evaluateTimeCondition,
+  isTimeConditionDataLegacy: () => isTimeConditionDataLegacy,
+  isTimeConditionDataV2: () => isTimeConditionDataV2,
+  normalizeTimeConditionData: () => normalizeTimeConditionData
 });
 module.exports = __toCommonJS(time_exports);
 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;
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  evaluateTimeCondition
+  convertTimeConditionLegacyToV2,
+  evaluateTimeCondition,
+  isTimeConditionDataLegacy,
+  isTimeConditionDataV2,
+  normalizeTimeConditionData
 });

package/dist/conditions/time.d.cts

@@ -1,10 +1,37 @@
-import { RulesCondition } from '@usertour/types';
+import { TimeConditionDataV2, TimeConditionDataLegacy, TimeConditionData, RulesCondition } from '@usertour/types';
 
+/**
+ * Type guard to check if data is in new format (TimeConditionDataV2)
+ * @param data - The data to check
+ * @returns true if data has startTime or endTime fields
+ */
+declare function isTimeConditionDataV2(data: any): data is TimeConditionDataV2;
+/**
+ * Type guard to check if data is in legacy format (TimeConditionDataLegacy)
+ * @param data - The data to check
+ * @returns true if data has startDate or startDateHour fields
+ */
+declare function isTimeConditionDataLegacy(data: any): data is TimeConditionDataLegacy;
+/**
+ * Convert legacy format to new format (ISO 8601)
+ * @param legacyData - Legacy time condition data
+ * @returns New format time condition data, or null if conversion fails
+ */
+declare function convertTimeConditionLegacyToV2(legacyData: TimeConditionDataLegacy): TimeConditionDataV2 | null;
+/**
+ * Normalize time condition data to new format
+ * If data is already in new format, returns it as-is
+ * If data is in legacy format, converts it to new format
+ * @param data - Time condition data (either format)
+ * @returns New format time condition data, or null if conversion fails
+ */
+declare function normalizeTimeConditionData(data: TimeConditionData | null | undefined): TimeConditionDataV2 | null;
 /**
  * Evaluate time condition based on start and end time rules
+ * Supports both new ISO 8601 format and legacy format for backward compatibility
  * @param rules - Time condition rules
  * @returns boolean indicating if current time matches the condition
  */
 declare const evaluateTimeCondition: (rules: RulesCondition) => boolean;
 
-export { evaluateTimeCondition };
+export { convertTimeConditionLegacyToV2, evaluateTimeCondition, isTimeConditionDataLegacy, isTimeConditionDataV2, normalizeTimeConditionData };