@usertour/helpers 0.0.34 → 0.0.36

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

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

@@ -43,9 +43,11 @@ __export(src_exports, {
   assignConditionIds: () => assignConditionIds,
   assignableWindow: () => assignableWindow,
   buildConfig: () => buildConfig,
+  capitalizeFirstLetter: () => capitalizeFirstLetter,
   cn: () => cn,
   conditionsIsSame: () => conditionsIsSame,
   convertSettings: () => convertSettings,
+  convertTimeConditionLegacyToV2: () => convertTimeConditionLegacyToV2,
   convertToCssVars: () => convertToCssVars,
   cuid: () => cuid,
   deepClone: () => deepClone,
@@ -60,8 +62,10 @@ __export(src_exports, {
   evaluateUrlCondition: () => evaluateUrlCondition,
   fetch: () => fetch,
   filterConditionsByType: () => filterConditionsByType,
+  filterNullAttributes: () => filterNullAttributes,
   formatDate: () => formatDate,
   generateAutoStateColors: () => generateAutoStateColors,
+  getAttributeType: () => getAttributeType,
   getAuthToken: () => getAuthToken,
   getCodeError: () => getCodeError,
   getContentError: () => getContentError,
@@ -102,6 +106,8 @@ __export(src_exports, {
   isPublishedAtLeastOneEnvironment: () => isPublishedAtLeastOneEnvironment,
   isPublishedInAllEnvironments: () => isPublishedInAllEnvironments,
   isString: () => isString,
+  isTimeConditionDataLegacy: () => isTimeConditionDataLegacy,
+  isTimeConditionDataV2: () => isTimeConditionDataV2,
   isUint8Array: () => isUint8Array,
   isUndefined: () => isUndefined,
   isUrl: () => isUrl,
@@ -111,6 +117,7 @@ __export(src_exports, {
   nativeForEach: () => nativeForEach,
   nativeIndexOf: () => nativeIndexOf,
   navigator: () => navigator,
+  normalizeTimeConditionData: () => normalizeTimeConditionData,
   parseUrlParams: () => parseUrlParams,
   regenerateConditionIds: () => regenerateConditionIds,
   removeAuthToken: () => removeAuthToken,
@@ -1100,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;
   }
@@ -1186,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 !== "");
@@ -1240,7 +1354,7 @@ function evaluateBooleanCondition(logic, actualValue) {
   }
 }
 function evaluateListCondition(logic, actualValue, expectedValues) {
-  const arrayValue = Array.isArray(actualValue) ? actualValue : [];
+  const arrayValue = isArray(actualValue) ? actualValue : [];
   if (logic === "empty" || logic === "any") {
     switch (logic) {
       case "empty":
@@ -1424,6 +1538,75 @@ var allConditionsHaveIds = (conditions) => {
   }
   return true;
 };
+
+// src/attribute.ts
+var import_types6 = require("@usertour/types");
+var import_date_fns3 = require("date-fns");
+var isValidYear = (date) => {
+  const year = date.getFullYear();
+  return year >= 1900 && year <= 2100;
+};
+var tryParseDate = (parser) => {
+  try {
+    const date = parser();
+    return (0, import_date_fns3.isValid)(date) && isValidYear(date);
+  } catch {
+    return false;
+  }
+};
+function isDateString(dateStr) {
+  if (!Number.isNaN(Number(dateStr)) || dateStr.length < 10) {
+    return false;
+  }
+  const dateFormats = [
+    "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'",
+    "yyyy-MM-dd'T'HH:mm:ss'Z'",
+    "yyyy-MM-dd'T'HH:mm:ss.SSS",
+    "yyyy-MM-dd'T'HH:mm:ss",
+    "yyyy-MM-dd",
+    "MM/dd/yyyy",
+    "dd/MM/yyyy",
+    "yyyy/MM/dd",
+    "MM-dd-yyyy",
+    "dd-MM-yyyy"
+  ];
+  if (tryParseDate(() => (0, import_date_fns3.parseISO)(dateStr))) {
+    return true;
+  }
+  return dateFormats.some((format) => tryParseDate(() => (0, import_date_fns3.parse)(dateStr, format, /* @__PURE__ */ new Date())));
+}
+var getAttributeType = (attribute) => {
+  const t = typeof attribute;
+  if (t === "number") {
+    return import_types6.BizAttributeTypes.Number;
+  }
+  if (t === "string") {
+    if (isDateString(attribute)) {
+      return import_types6.BizAttributeTypes.DateTime;
+    }
+    return import_types6.BizAttributeTypes.String;
+  }
+  if (t === "boolean") {
+    return import_types6.BizAttributeTypes.Boolean;
+  }
+  if (t === "object" && Array.isArray(attribute)) {
+    return import_types6.BizAttributeTypes.List;
+  }
+  return import_types6.BizAttributeTypes.Nil;
+};
+var capitalizeFirstLetter = (string) => {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+};
+var filterNullAttributes = (attributes) => {
+  const attrs = {};
+  for (const key in attributes) {
+    const v = attributes[key];
+    if (!isNull(v)) {
+      attrs[key] = v;
+    }
+  }
+  return attrs;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AbortController,
@@ -1434,9 +1617,11 @@ var allConditionsHaveIds = (conditions) => {
   assignConditionIds,
   assignableWindow,
   buildConfig,
+  capitalizeFirstLetter,
   cn,
   conditionsIsSame,
   convertSettings,
+  convertTimeConditionLegacyToV2,
   convertToCssVars,
   cuid,
   deepClone,
@@ -1451,8 +1636,10 @@ var allConditionsHaveIds = (conditions) => {
   evaluateUrlCondition,
   fetch,
   filterConditionsByType,
+  filterNullAttributes,
   formatDate,
   generateAutoStateColors,
+  getAttributeType,
   getAuthToken,
   getCodeError,
   getContentError,
@@ -1493,6 +1680,8 @@ var allConditionsHaveIds = (conditions) => {
   isPublishedAtLeastOneEnvironment,
   isPublishedInAllEnvironments,
   isString,
+  isTimeConditionDataLegacy,
+  isTimeConditionDataV2,
   isUint8Array,
   isUndefined,
   isUrl,
@@ -1502,6 +1691,7 @@ var allConditionsHaveIds = (conditions) => {
   nativeForEach,
   nativeIndexOf,
   navigator,
+  normalizeTimeConditionData,
   parseUrlParams,
   regenerateConditionIds,
   removeAuthToken,

package/dist/index.d.cts

@@ -11,8 +11,9 @@ 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';
 import '@usertour/types';
 import './storage.cjs';

package/dist/index.d.ts

@@ -11,8 +11,9 @@ 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';
 import '@usertour/types';
 import './storage.js';