@usertour/helpers 0.0.35 → 0.0.36

package/dist/conditions/time.d.ts

@@ -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 };

package/dist/conditions/time.js

@@ -1,7 +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";
 export {
-  evaluateTimeCondition
+  convertTimeConditionLegacyToV2,
+  evaluateTimeCondition,
+  isTimeConditionDataLegacy,
+  isTimeConditionDataV2,
+  normalizeTimeConditionData
 };

package/dist/index.cjs

@@ -47,6 +47,7 @@ __export(src_exports, {
   cn: () => cn,
   conditionsIsSame: () => conditionsIsSame,
   convertSettings: () => convertSettings,
+  convertTimeConditionLegacyToV2: () => convertTimeConditionLegacyToV2,
   convertToCssVars: () => convertToCssVars,
   cuid: () => cuid,
   deepClone: () => deepClone,
@@ -105,6 +106,8 @@ __export(src_exports, {
   isPublishedAtLeastOneEnvironment: () => isPublishedAtLeastOneEnvironment,
   isPublishedInAllEnvironments: () => isPublishedInAllEnvironments,
   isString: () => isString,
+  isTimeConditionDataLegacy: () => isTimeConditionDataLegacy,
+  isTimeConditionDataV2: () => isTimeConditionDataV2,
   isUint8Array: () => isUint8Array,
   isUndefined: () => isUndefined,
   isUrl: () => isUrl,
@@ -114,6 +117,7 @@ __export(src_exports, {
   nativeForEach: () => nativeForEach,
   nativeIndexOf: () => nativeIndexOf,
   navigator: () => navigator,
+  normalizeTimeConditionData: () => normalizeTimeConditionData,
   parseUrlParams: () => parseUrlParams,
   regenerateConditionIds: () => regenerateConditionIds,
   removeAuthToken: () => removeAuthToken,
@@ -1103,27 +1107,134 @@ var evaluateUrlCondition = (rules, url) => {
 
 // src/conditions/time.ts
 var import_date_fns = require("date-fns");
-var evaluateTimeCondition = (rules) => {
+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);
+    }
+    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;
   }
@@ -1189,8 +1300,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 !== "");
@@ -1510,6 +1621,7 @@ var filterNullAttributes = (attributes) => {
   cn,
   conditionsIsSame,
   convertSettings,
+  convertTimeConditionLegacyToV2,
   convertToCssVars,
   cuid,
   deepClone,
@@ -1568,6 +1680,8 @@ var filterNullAttributes = (attributes) => {
   isPublishedAtLeastOneEnvironment,
   isPublishedInAllEnvironments,
   isString,
+  isTimeConditionDataLegacy,
+  isTimeConditionDataV2,
   isUint8Array,
   isUndefined,
   isUrl,
@@ -1577,6 +1691,7 @@ var filterNullAttributes = (attributes) => {
   nativeForEach,
   nativeIndexOf,
   navigator,
+  normalizeTimeConditionData,
   parseUrlParams,
   regenerateConditionIds,
   removeAuthToken,

package/dist/index.d.cts

@@ -11,7 +11,7 @@ export { generateAutoStateColors, hexToHSLString, hexToRGBStr } from './color.cj
 export { absoluteUrl, cn, cuid, evalCode, formatDate, getRandomColor, hexToRgb, isDark, uuidV4 } from './helper.cjs';
 export { allConditionsHaveIds, assignConditionIds, conditionsIsSame, evaluateRule, evaluateRulesConditions, filterConditionsByType, isConditionsActived, regenerateConditionIds } from './conditions/condition.cjs';
 export { evaluateUrlCondition, isMatchUrlPattern } from './conditions/url.cjs';
-export { evaluateTimeCondition } from './conditions/time.cjs';
+export { convertTimeConditionLegacyToV2, evaluateTimeCondition, isTimeConditionDataLegacy, isTimeConditionDataV2, normalizeTimeConditionData } from './conditions/time.cjs';
 export { evaluateAttributeCondition } from './conditions/attribute.cjs';
 export { capitalizeFirstLetter, filterNullAttributes, getAttributeType } from './attribute.cjs';
 export { default as isEqual } from 'fast-deep-equal';

package/dist/index.d.ts

@@ -11,7 +11,7 @@ export { generateAutoStateColors, hexToHSLString, hexToRGBStr } from './color.js
 export { absoluteUrl, cn, cuid, evalCode, formatDate, getRandomColor, hexToRgb, isDark, uuidV4 } from './helper.js';
 export { allConditionsHaveIds, assignConditionIds, conditionsIsSame, evaluateRule, evaluateRulesConditions, filterConditionsByType, isConditionsActived, regenerateConditionIds } from './conditions/condition.js';
 export { evaluateUrlCondition, isMatchUrlPattern } from './conditions/url.js';
-export { evaluateTimeCondition } from './conditions/time.js';
+export { convertTimeConditionLegacyToV2, evaluateTimeCondition, isTimeConditionDataLegacy, isTimeConditionDataV2, normalizeTimeConditionData } from './conditions/time.js';
 export { evaluateAttributeCondition } from './conditions/attribute.js';
 export { capitalizeFirstLetter, filterNullAttributes, getAttributeType } from './attribute.js';
 export { default as isEqual } from 'fast-deep-equal';

package/dist/index.js

@@ -20,15 +20,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";
@@ -135,6 +139,7 @@ export {
   cn,
   conditionsIsSame,
   convertSettings,
+  convertTimeConditionLegacyToV2,
   convertToCssVars,
   cuid,
   deepClone,
@@ -193,6 +198,8 @@ export {
   isPublishedAtLeastOneEnvironment,
   isPublishedInAllEnvironments,
   isString,
+  isTimeConditionDataLegacy,
+  isTimeConditionDataV2,
   isUint8Array,
   isUndefined,
   isUrl,
@@ -202,6 +209,7 @@ export {
   nativeForEach,
   nativeIndexOf,
   navigator,
+  normalizeTimeConditionData,
   parseUrlParams,
   regenerateConditionIds,
   removeAuthToken,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usertour/helpers",
-  "version": "0.0.35",
+  "version": "0.0.36",
   "type": "module",
   "description": "Utility functions and helpers shared across the UserTour project",
   "homepage": "https://www.usertour.io",
@@ -29,7 +29,7 @@
   },
   "dependencies": {
     "@paralleldrive/cuid2": "^2.2.2",
-    "@usertour/types": "^0.0.19",
+    "@usertour/types": "^0.0.26",
     "chroma-js": "^3.1.2",
     "class-variance-authority": "^0.4.0",
     "clsx": "^1.2.1",

package/dist/chunk-CEK3SCQO.js

@@ -1,31 +0,0 @@
-// src/conditions/time.ts
-import { isAfter, isBefore, isValid, parseISO } from "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 = parseISO(startTimeString);
-    if (!isValid(startTime)) {
-      return false;
-    }
-    const now = /* @__PURE__ */ new Date();
-    if (!endDate || !endDateHour || !endDateMinute) {
-      return isAfter(now, startTime);
-    }
-    const endTimeString = `${endDate}T${endDateHour.padStart(2, "0")}:${endDateMinute.padStart(2, "0")}:00`;
-    const endTime = parseISO(endTimeString);
-    if (!isValid(endTime)) {
-      return false;
-    }
-    return isAfter(now, startTime) && isBefore(now, endTime);
-  } catch {
-    return false;
-  }
-};
-
-export {
-  evaluateTimeCondition
-};