@utilix-tech/sdk 0.1.0

package/dist/tools/time.cjs

@@ -0,0 +1,681 @@
+'use strict';
+
+// src/tools/time.ts
+function formatRelative(diffMs) {
+  const absMs = Math.abs(diffMs);
+  const isPast = diffMs >= 0;
+  if (absMs < 1e4) {
+    return "just now";
+  }
+  const seconds = Math.floor(absMs / 1e3);
+  if (seconds < 60) {
+    return isPast ? `${seconds} seconds ago` : `in ${seconds} seconds`;
+  }
+  const minutes = Math.floor(absMs / 6e4);
+  if (minutes < 60) {
+    return isPast ? `${minutes} minutes ago` : `in ${minutes} minutes`;
+  }
+  const hours = Math.floor(absMs / 36e5);
+  if (hours < 24) {
+    return isPast ? `${hours} hours ago` : `in ${hours} hours`;
+  }
+  const days = Math.floor(absMs / 864e5);
+  return isPast ? `${days} days ago` : `in ${days} days`;
+}
+function buildResult(date) {
+  const unixMs = date.getTime();
+  const unix = Math.floor(unixMs / 1e3);
+  const diffMs = Date.now() - unixMs;
+  return {
+    unix,
+    unixMs,
+    iso: date.toISOString(),
+    utc: date.toUTCString(),
+    local: date.toLocaleString(),
+    relative: formatRelative(diffMs)
+  };
+}
+function fromUnix(ts) {
+  const ms = ts > 1e10 ? ts : ts * 1e3;
+  return buildResult(new Date(ms));
+}
+function fromIsoString(iso) {
+  if (!iso || iso.trim() === "") {
+    return { error: "Empty string is not a valid ISO date" };
+  }
+  const date = new Date(iso);
+  if (isNaN(date.getTime())) {
+    return { error: `Invalid ISO string: "${iso}"` };
+  }
+  return buildResult(date);
+}
+function getNow() {
+  return buildResult(/* @__PURE__ */ new Date());
+}
+var CRON_MONTH_NAMES = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var CRON_WEEKDAY_NAMES = [
+  "Sunday",
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday"
+];
+var FIELD_CONFIGS = {
+  minute: { min: 0, max: 59, singularLabel: "minute", pluralLabel: "minutes", unit: "minute" },
+  hour: { min: 0, max: 23, singularLabel: "hour", pluralLabel: "hours", unit: "hour" },
+  day: { min: 1, max: 31, singularLabel: "day", pluralLabel: "days", unit: "day" },
+  month: { min: 1, max: 12, singularLabel: "month", pluralLabel: "months", unit: "month", names: CRON_MONTH_NAMES, nameOffset: 1 },
+  weekday: { min: 0, max: 7, singularLabel: "weekday", pluralLabel: "weekdays", unit: "weekday", names: CRON_WEEKDAY_NAMES, nameOffset: 0 }
+};
+function getCronName(config, value) {
+  if (!config.names) return null;
+  const idx = value - (config.nameOffset ?? 0);
+  const resolvedIdx = config.unit === "weekday" && value === 7 ? 0 : idx;
+  return config.names[resolvedIdx] ?? null;
+}
+function isValidNumber(value, min, max) {
+  return Number.isInteger(value) && value >= min && value <= max;
+}
+function validateValue(value, config) {
+  return isValidNumber(value, config.min, config.max);
+}
+function describeField(raw, fieldType) {
+  const config = FIELD_CONFIGS[fieldType];
+  const everyLabel = `every ${config.unit}`;
+  if (raw === "*") {
+    return { raw, description: everyLabel, valid: true };
+  }
+  const stepMatch = raw.match(/^\*\/(\d+)$/);
+  if (stepMatch) {
+    const step = parseInt(stepMatch[1], 10);
+    if (step < 1) return { raw, description: "", valid: false };
+    return { raw, description: `every ${step} ${config.pluralLabel}`, valid: true };
+  }
+  const rangeMatch = raw.match(/^(\d+)-(\d+)$/);
+  if (rangeMatch) {
+    const from = parseInt(rangeMatch[1], 10);
+    const to = parseInt(rangeMatch[2], 10);
+    if (!validateValue(from, config) || !validateValue(to, config)) {
+      return { raw, description: "", valid: false };
+    }
+    const fromName = getCronName(config, from);
+    const toName = getCronName(config, to);
+    if (fromName && toName) {
+      return { raw, description: `${fromName} through ${toName}`, valid: true };
+    }
+    return { raw, description: `${config.unit} ${from} through ${to}`, valid: true };
+  }
+  if (raw.includes(",")) {
+    const parts = raw.split(",");
+    const values = [];
+    for (const part of parts) {
+      const n2 = parseInt(part.trim(), 10);
+      if (isNaN(n2) || !validateValue(n2, config)) {
+        return { raw, description: "", valid: false };
+      }
+      values.push(n2);
+    }
+    const resolved = values.map((v) => getCronName(config, v) ?? String(v));
+    const label = config.unit === "minute" || config.unit === "hour" || config.unit === "day" ? `${config.pluralLabel} ${resolved.join(", ")}` : resolved.join(", ");
+    return { raw, description: label, valid: true };
+  }
+  const n = parseInt(raw, 10);
+  if (isNaN(n) || !validateValue(n, config)) {
+    return { raw, description: "", valid: false };
+  }
+  const name = getCronName(config, n);
+  if (name) {
+    if (config.unit === "month") {
+      return { raw, description: `in ${name}`, valid: true };
+    }
+    if (config.unit === "weekday") {
+      return { raw, description: `on ${name}`, valid: true };
+    }
+  }
+  const prefix = {
+    minute: "at minute",
+    hour: "at hour",
+    day: "on day",
+    month: "in month",
+    weekday: "on weekday"
+  };
+  return { raw, description: `${prefix[fieldType]} ${n}`, valid: true };
+}
+function parseCron(expr) {
+  const raw = expr;
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5) {
+    return {
+      raw,
+      fields: {
+        minute: { raw: "", description: "", valid: false },
+        hour: { raw: "", description: "", valid: false },
+        day: { raw: "", description: "", valid: false },
+        month: { raw: "", description: "", valid: false },
+        weekday: { raw: "", description: "", valid: false }
+      },
+      summary: "",
+      valid: false,
+      error: `Expected 5 fields but got ${parts.length}`
+    };
+  }
+  const [minuteRaw, hourRaw, dayRaw, monthRaw, weekdayRaw] = parts;
+  const minute = describeField(minuteRaw, "minute");
+  const hour = describeField(hourRaw, "hour");
+  const day = describeField(dayRaw, "day");
+  const month = describeField(monthRaw, "month");
+  const weekday = describeField(weekdayRaw, "weekday");
+  const allValid = minute.valid && hour.valid && day.valid && month.valid && weekday.valid;
+  if (!allValid) {
+    const invalidField = [
+      !minute.valid && "minute",
+      !hour.valid && "hour",
+      !day.valid && "day",
+      !month.valid && "month",
+      !weekday.valid && "weekday"
+    ].filter(Boolean).join(", ");
+    return {
+      raw,
+      fields: { minute, hour, day, month, weekday },
+      summary: "",
+      valid: false,
+      error: `Invalid field(s): ${invalidField}`
+    };
+  }
+  const summary = `At ${minute.description}, ${hour.description}, ${day.description}, ${month.description}, ${weekday.description}`;
+  return {
+    raw,
+    fields: { minute, hour, day, month, weekday },
+    summary,
+    valid: true
+  };
+}
+var COMMON_CRONS = [
+  { expr: "* * * * *", label: "Every minute" },
+  { expr: "0 * * * *", label: "Every hour" },
+  { expr: "0 0 * * *", label: "Every day at midnight" },
+  { expr: "0 9 * * 1-5", label: "Weekdays at 9am" },
+  { expr: "0 0 * * 0", label: "Every Sunday at midnight" },
+  { expr: "0 0 1 * *", label: "First day of every month" },
+  { expr: "0 0 1 1 *", label: "Every year on January 1st" },
+  { expr: "*/15 * * * *", label: "Every 15 minutes" },
+  { expr: "0 0 * * 1", label: "Every Monday at midnight" }
+];
+function parseDate(input) {
+  if (!input || !input.trim()) return null;
+  const trimmed = input.trim();
+  const isoDate = trimmed.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (isoDate) {
+    const d = /* @__PURE__ */ new Date(`${trimmed}T00:00:00.000Z`);
+    return isNaN(d.getTime()) ? null : d;
+  }
+  const mdyMatch = trimmed.match(/^(\d{1,2})\/(\d{1,2})\/(\d{4})$/);
+  if (mdyMatch) {
+    const month = parseInt(mdyMatch[1]);
+    const day = parseInt(mdyMatch[2]);
+    const year = parseInt(mdyMatch[3]);
+    if (month < 1 || month > 12 || day < 1 || day > 31) return null;
+    const d = /* @__PURE__ */ new Date(`${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}T00:00:00.000Z`);
+    return isNaN(d.getTime()) ? null : d;
+  }
+  const dmyMatch = trimmed.match(/^(\d{1,2})-(\d{1,2})-(\d{4})$/);
+  if (dmyMatch) {
+    const day = parseInt(dmyMatch[1]);
+    const month = parseInt(dmyMatch[2]);
+    const year = parseInt(dmyMatch[3]);
+    if (month < 1 || month > 12 || day < 1 || day > 31) return null;
+    const d = /* @__PURE__ */ new Date(`${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}T00:00:00.000Z`);
+    return isNaN(d.getTime()) ? null : d;
+  }
+  const isoFull = new Date(trimmed);
+  if (!isNaN(isoFull.getTime())) return isoFull;
+  return null;
+}
+function humanizeDiff(result) {
+  const parts = [];
+  const units = [
+    { label: "year", value: result.years },
+    { label: "month", value: result.months },
+    { label: "week", value: result.weeks },
+    { label: "day", value: result.days },
+    { label: "hour", value: result.hours },
+    { label: "minute", value: result.minutes },
+    { label: "second", value: result.seconds }
+  ];
+  for (const { label, value } of units) {
+    if (value > 0 && parts.length < 3) {
+      parts.push(`${value} ${label}${value !== 1 ? "s" : ""}`);
+    }
+  }
+  return parts.length > 0 ? parts.join(", ") : "0 seconds";
+}
+function diffDates(from, to) {
+  const fromDate = parseDate(from);
+  const toDate = parseDate(to);
+  if (!fromDate) return { error: `Invalid "from" date: ${from}` };
+  if (!toDate) return { error: `Invalid "to" date: ${to}` };
+  const fromMs = fromDate.getTime();
+  const toMs = toDate.getTime();
+  const isPast = toMs < fromMs;
+  const startMs = Math.min(fromMs, toMs);
+  const endMs = Math.max(fromMs, toMs);
+  const diffMs = endMs - startMs;
+  const totalSeconds = Math.floor(diffMs / 1e3);
+  const totalMinutes = Math.floor(diffMs / (1e3 * 60));
+  const totalHours = Math.floor(diffMs / (1e3 * 60 * 60));
+  const totalDays = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+  const startDate = new Date(startMs);
+  const endDate = new Date(endMs);
+  let years = endDate.getUTCFullYear() - startDate.getUTCFullYear();
+  let months = endDate.getUTCMonth() - startDate.getUTCMonth();
+  let days = endDate.getUTCDate() - startDate.getUTCDate();
+  if (days < 0) {
+    months -= 1;
+    const prevMonth = new Date(Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth(), 0));
+    days += prevMonth.getUTCDate();
+  }
+  if (months < 0) {
+    years -= 1;
+    months += 12;
+  }
+  const weeks = Math.floor(days / 7);
+  const remainingDays = days % 7;
+  const remainingAfterDays = diffMs - (years * 365.25 * 24 * 3600 * 1e3 + months * 30.44 * 24 * 3600 * 1e3 + days * 24 * 3600 * 1e3);
+  const hours = Math.floor(Math.max(0, remainingAfterDays) / (1e3 * 60 * 60));
+  const minutes = Math.floor(Math.max(0, remainingAfterDays) % (1e3 * 60 * 60) / (1e3 * 60));
+  const seconds = Math.floor(Math.max(0, remainingAfterDays) % (1e3 * 60) / 1e3);
+  const result = {
+    years,
+    months,
+    weeks,
+    days: remainingDays,
+    hours,
+    minutes,
+    seconds,
+    totalDays,
+    totalHours,
+    totalMinutes,
+    totalSeconds,
+    isPast,
+    humanReadable: ""
+  };
+  result.humanReadable = humanizeDiff(result);
+  return result;
+}
+var COMMON_DATE_PRESETS = [
+  { label: "Last 7 days", from: () => "2020-01-01", to: () => "2020-01-08" },
+  { label: "Last 30 days", from: () => "2020-01-01", to: () => "2020-01-31" },
+  { label: "Last 90 days", from: () => "2020-01-01", to: () => "2020-04-01" },
+  { label: "Last 6 months", from: () => "2020-01-01", to: () => "2020-07-01" },
+  { label: "Last 1 year", from: () => "2020-01-01", to: () => "2021-01-01" },
+  { label: "Year 2020", from: () => "2020-01-01", to: () => "2020-12-31" },
+  { label: "Year 2021", from: () => "2021-01-01", to: () => "2021-12-31" }
+];
+var TIMEZONES = [
+  { tz: "UTC", label: "UTC (Coordinated Universal Time)", offset: "+00:00" },
+  { tz: "America/New_York", label: "New York (Eastern)", offset: "-05:00" },
+  { tz: "America/Chicago", label: "Chicago (Central)", offset: "-06:00" },
+  { tz: "America/Denver", label: "Denver (Mountain)", offset: "-07:00" },
+  { tz: "America/Los_Angeles", label: "Los Angeles (Pacific)", offset: "-08:00" },
+  { tz: "America/Sao_Paulo", label: "S\xE3o Paulo (BRT)", offset: "-03:00" },
+  { tz: "America/Toronto", label: "Toronto (Eastern)", offset: "-05:00" },
+  { tz: "America/Vancouver", label: "Vancouver (Pacific)", offset: "-08:00" },
+  { tz: "America/Mexico_City", label: "Mexico City (CST)", offset: "-06:00" },
+  { tz: "America/Buenos_Aires", label: "Buenos Aires (ART)", offset: "-03:00" },
+  { tz: "Europe/London", label: "London (GMT/BST)", offset: "+00:00" },
+  { tz: "Europe/Paris", label: "Paris (CET)", offset: "+01:00" },
+  { tz: "Europe/Berlin", label: "Berlin (CET)", offset: "+01:00" },
+  { tz: "Europe/Rome", label: "Rome (CET)", offset: "+01:00" },
+  { tz: "Europe/Amsterdam", label: "Amsterdam (CET)", offset: "+01:00" },
+  { tz: "Europe/Moscow", label: "Moscow (MSK)", offset: "+03:00" },
+  { tz: "Africa/Cairo", label: "Cairo (EET)", offset: "+02:00" },
+  { tz: "Africa/Lagos", label: "Lagos (WAT)", offset: "+01:00" },
+  { tz: "Asia/Dubai", label: "Dubai (GST)", offset: "+04:00" },
+  { tz: "Asia/Karachi", label: "Karachi (PKT)", offset: "+05:00" },
+  { tz: "Asia/Kolkata", label: "Kolkata (IST)", offset: "+05:30" },
+  { tz: "Asia/Bangkok", label: "Bangkok (ICT)", offset: "+07:00" },
+  { tz: "Asia/Jakarta", label: "Jakarta (WIB)", offset: "+07:00" },
+  { tz: "Asia/Singapore", label: "Singapore (SGT)", offset: "+08:00" },
+  { tz: "Asia/Shanghai", label: "Shanghai (CST)", offset: "+08:00" },
+  { tz: "Asia/Seoul", label: "Seoul (KST)", offset: "+09:00" },
+  { tz: "Asia/Tokyo", label: "Tokyo (JST)", offset: "+09:00" },
+  { tz: "Australia/Sydney", label: "Sydney (AEDT)", offset: "+11:00" },
+  { tz: "Pacific/Auckland", label: "Auckland (NZDT)", offset: "+13:00" },
+  { tz: "Pacific/Honolulu", label: "Honolulu (HST)", offset: "-10:00" }
+];
+function getTimezoneOffset(tz, isoString) {
+  try {
+    const date = new Date(isoString);
+    if (isNaN(date.getTime())) {
+      return "+00:00";
+    }
+    const utcFormatter = new Intl.DateTimeFormat("en-US", {
+      timeZone: "UTC",
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: false
+    });
+    const tzFormatter = new Intl.DateTimeFormat("en-US", {
+      timeZone: tz,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: false
+    });
+    const utcParts = utcFormatter.formatToParts(date);
+    const tzParts = tzFormatter.formatToParts(date);
+    const getPart = (parts, type) => {
+      const part = parts.find((p) => p.type === type);
+      return part ? parseInt(part.value, 10) : 0;
+    };
+    const utcYear = getPart(utcParts, "year");
+    const utcMonth = getPart(utcParts, "month") - 1;
+    const utcDay = getPart(utcParts, "day");
+    const utcHour = getPart(utcParts, "hour") % 24;
+    const utcMin = getPart(utcParts, "minute");
+    const tzYear = getPart(tzParts, "year");
+    const tzMonth = getPart(tzParts, "month") - 1;
+    const tzDay = getPart(tzParts, "day");
+    const tzHour = getPart(tzParts, "hour") % 24;
+    const tzMin = getPart(tzParts, "minute");
+    const utcMs = Date.UTC(utcYear, utcMonth, utcDay, utcHour, utcMin);
+    const tzMs = Date.UTC(tzYear, tzMonth, tzDay, tzHour, tzMin);
+    const diffMinutes = Math.round((tzMs - utcMs) / 6e4);
+    const sign = diffMinutes >= 0 ? "+" : "-";
+    const absDiff = Math.abs(diffMinutes);
+    const hours = Math.floor(absDiff / 60);
+    const minutes = absDiff % 60;
+    return `${sign}${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}`;
+  } catch {
+    return "+00:00";
+  }
+}
+function convertTime(isoString, fromTz, toTz) {
+  try {
+    const date = new Date(isoString);
+    if (isNaN(date.getTime())) {
+      return { result: "", error: "Invalid date string" };
+    }
+    try {
+      new Intl.DateTimeFormat("en-US", { timeZone: fromTz });
+    } catch {
+      return { result: "", error: `Invalid source timezone: ${fromTz}` };
+    }
+    try {
+      new Intl.DateTimeFormat("en-US", { timeZone: toTz });
+    } catch {
+      return { result: "", error: `Invalid target timezone: ${toTz}` };
+    }
+    const formatted = formatInTimezone(isoString, toTz);
+    const result = `${formatted.date}T${formatted.time}${formatted.offset}`;
+    return { result };
+  } catch (e) {
+    return { result: "", error: String(e) };
+  }
+}
+function formatInTimezone(isoString, tz) {
+  const date = new Date(isoString);
+  const formatter = new Intl.DateTimeFormat("en-CA", {
+    timeZone: tz,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  });
+  const parts = formatter.formatToParts(date);
+  const getPart = (type) => {
+    const part = parts.find((p) => p.type === type);
+    return part ? part.value : "00";
+  };
+  const year = getPart("year");
+  const month = getPart("month");
+  const day = getPart("day");
+  let hour = getPart("hour");
+  const minute = getPart("minute");
+  const second = getPart("second");
+  if (hour === "24") hour = "00";
+  const dateStr = `${year}-${month}-${day}`;
+  const timeStr = `${hour}:${minute}:${second}`;
+  const offset = getTimezoneOffset(tz, isoString);
+  const entry = TIMEZONES.find((t) => t.tz === tz);
+  const label = entry ? entry.label : tz;
+  return { date: dateStr, time: timeStr, offset, label };
+}
+function getAllZonesForTime(isoString) {
+  return TIMEZONES.map((entry) => {
+    const formatted = formatInTimezone(isoString, entry.tz);
+    const localTime = `${formatted.date}T${formatted.time}${formatted.offset}`;
+    return { ...entry, localTime };
+  });
+}
+var CRON_NEXT_MONTH_NAMES = {
+  JAN: 1,
+  FEB: 2,
+  MAR: 3,
+  APR: 4,
+  MAY: 5,
+  JUN: 6,
+  JUL: 7,
+  AUG: 8,
+  SEP: 9,
+  OCT: 10,
+  NOV: 11,
+  DEC: 12
+};
+var CRON_NEXT_WEEKDAY_NAMES = {
+  SUN: 0,
+  MON: 1,
+  TUE: 2,
+  WED: 3,
+  THU: 4,
+  FRI: 5,
+  SAT: 6
+};
+var DAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+function resolveNamedValue(token, nameMap) {
+  const upper = token.toUpperCase();
+  if (upper in nameMap) return nameMap[upper];
+  const num = parseInt(token, 10);
+  if (!isNaN(num)) return num;
+  return null;
+}
+function parseCronFieldPart(part, min, max, nameMap) {
+  if (part.startsWith("*/")) {
+    const step = parseInt(part.slice(2), 10);
+    if (isNaN(step) || step < 1) return { error: `Invalid step in "${part}"` };
+    const vals = [];
+    for (let i = min; i <= max; i += step) vals.push(i);
+    return vals;
+  }
+  if (part.includes("-")) {
+    const stepSplit = part.split("/");
+    const rangePart = stepSplit[0];
+    const step = stepSplit.length > 1 ? parseInt(stepSplit[1], 10) : 1;
+    if (isNaN(step) || step < 1) return { error: `Invalid step in "${part}"` };
+    const [startStr, endStr] = rangePart.split("-");
+    const start = resolveNamedValue(startStr, nameMap);
+    const end = resolveNamedValue(endStr, nameMap);
+    if (start === null || end === null) return { error: `Invalid range in "${part}"` };
+    if (start < min || end > max || start > end) return { error: `Range out of bounds in "${part}"` };
+    const vals = [];
+    for (let i = start; i <= end; i += step) vals.push(i);
+    return vals;
+  }
+  if (part.includes("/")) {
+    const [startStr, stepStr] = part.split("/");
+    const start = resolveNamedValue(startStr, nameMap);
+    const step = parseInt(stepStr, 10);
+    if (start === null || isNaN(step) || step < 1) return { error: `Invalid expression "${part}"` };
+    if (start < min || start > max) return { error: `Value out of bounds in "${part}"` };
+    const vals = [];
+    for (let i = start; i <= max; i += step) vals.push(i);
+    return vals;
+  }
+  const val = resolveNamedValue(part, nameMap);
+  if (val === null) return { error: `Invalid value "${part}"` };
+  if (val < min || val > max) return { error: `Value ${val} out of bounds [${min}-${max}]` };
+  return [val];
+}
+function parseCronNextField(raw, min, max, nameMap = {}) {
+  if (raw === "*") {
+    const values2 = [];
+    for (let i = min; i <= max; i++) values2.push(i);
+    return { raw, values: values2, min, max };
+  }
+  const parts = raw.split(",");
+  const allValues = /* @__PURE__ */ new Set();
+  for (const part of parts) {
+    const result = parseCronFieldPart(part.trim(), min, max, nameMap);
+    if (typeof result === "object" && "error" in result) return result;
+    for (const v of result) allValues.add(v);
+  }
+  const values = Array.from(allValues).sort((a, b) => a - b);
+  return { raw, values, min, max };
+}
+function parseCronExpression(expr) {
+  const trimmed = expr.trim();
+  const fields = trimmed.split(/\s+/);
+  if (fields.length < 5) return { error: "Cron expression must have exactly 5 fields" };
+  if (fields.length > 5) return { error: "Cron expression must have exactly 5 fields (6+ field expressions not supported)" };
+  const [minRaw, hourRaw, domRaw, monRaw, dowRaw] = fields;
+  const minute = parseCronNextField(minRaw, 0, 59, {});
+  if (typeof minute === "object" && "error" in minute) return { error: `Minute field: ${minute.error}` };
+  const hour = parseCronNextField(hourRaw, 0, 23, {});
+  if (typeof hour === "object" && "error" in hour) return { error: `Hour field: ${hour.error}` };
+  const dayOfMonth = parseCronNextField(domRaw, 1, 31, {});
+  if (typeof dayOfMonth === "object" && "error" in dayOfMonth) return { error: `Day-of-month field: ${dayOfMonth.error}` };
+  const month = parseCronNextField(monRaw, 1, 12, CRON_NEXT_MONTH_NAMES);
+  if (typeof month === "object" && "error" in month) return { error: `Month field: ${month.error}` };
+  const dayOfWeek = parseCronNextField(dowRaw, 0, 6, CRON_NEXT_WEEKDAY_NAMES);
+  if (typeof dayOfWeek === "object" && "error" in dayOfWeek) return { error: `Day-of-week field: ${dayOfWeek.error}` };
+  return {
+    minute,
+    hour,
+    dayOfMonth,
+    month,
+    dayOfWeek
+  };
+}
+function matchesCron(date, parsed) {
+  const min = date.getMinutes();
+  const hour = date.getHours();
+  const dom = date.getDate();
+  const month = date.getMonth() + 1;
+  const dow = date.getDay();
+  if (!parsed.minute.values.includes(min)) return false;
+  if (!parsed.hour.values.includes(hour)) return false;
+  if (!parsed.month.values.includes(month)) return false;
+  const domWild = parsed.dayOfMonth.raw === "*";
+  const dowWild = parsed.dayOfWeek.raw === "*";
+  if (domWild && dowWild) return true;
+  if (domWild) return parsed.dayOfWeek.values.includes(dow);
+  if (dowWild) return parsed.dayOfMonth.values.includes(dom);
+  return parsed.dayOfMonth.values.includes(dom) || parsed.dayOfWeek.values.includes(dow);
+}
+function getNextRuns(expr, count = 10, fromDate) {
+  if (count > 100) return { error: "count must be 100 or less" };
+  const parsed = parseCronExpression(expr);
+  if (typeof parsed === "object" && "error" in parsed) return parsed;
+  const results = [];
+  const start = fromDate ? new Date(fromDate) : /* @__PURE__ */ new Date();
+  const cursor = new Date(start);
+  cursor.setSeconds(0, 0);
+  cursor.setMinutes(cursor.getMinutes() + 1);
+  const maxMinutes = 5 * 365 * 24 * 60;
+  let checked = 0;
+  while (results.length < count && checked < maxMinutes) {
+    if (matchesCron(cursor, parsed)) {
+      results.push(new Date(cursor));
+    }
+    cursor.setMinutes(cursor.getMinutes() + 1);
+    checked++;
+  }
+  if (results.length === 0) {
+    return { error: "No runs found in the next 5 years for this expression" };
+  }
+  return results;
+}
+function formatRunDate(date, timezone) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const seconds = String(date.getSeconds()).padStart(2, "0");
+  const dayName = DAY_NAMES[date.getDay()];
+  const base = `${year}-${month}-${day} ${hours}:${minutes}:${seconds} (${dayName})`;
+  return timezone ? `${base} ${timezone}` : base;
+}
+function getRunInterval(dates) {
+  if (dates.length < 2) return "Unknown interval";
+  const diffMs = dates[1].getTime() - dates[0].getTime();
+  const diffMins = Math.round(diffMs / 6e4);
+  if (diffMins === 1) return "Every minute";
+  if (diffMins < 60) return `Every ${diffMins} minutes`;
+  if (diffMins === 60) {
+    const min = dates[0].getMinutes();
+    return min === 0 ? "Every hour" : `Every hour at :${String(min).padStart(2, "0")}`;
+  }
+  if (diffMins < 1440) {
+    const hours = diffMins / 60;
+    if (Number.isInteger(hours)) {
+      return `Every ${hours} hours`;
+    }
+    return `Every ${diffMins} minutes`;
+  }
+  if (diffMins === 1440) {
+    const h = dates[0].getHours();
+    const m = dates[0].getMinutes();
+    const timeStr = `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}`;
+    return `Every day at ${timeStr}`;
+  }
+  if (diffMins === 7 * 1440) {
+    const dayName = DAY_NAMES[dates[0].getDay()];
+    return `Every ${dayName}`;
+  }
+  const days = Math.round(diffMins / 1440);
+  return `Every ${days} days`;
+}
+
+exports.COMMON_CRONS = COMMON_CRONS;
+exports.COMMON_DATE_PRESETS = COMMON_DATE_PRESETS;
+exports.TIMEZONES = TIMEZONES;
+exports.convertTime = convertTime;
+exports.diffDates = diffDates;
+exports.formatInTimezone = formatInTimezone;
+exports.formatRelative = formatRelative;
+exports.formatRunDate = formatRunDate;
+exports.fromIsoString = fromIsoString;
+exports.fromUnix = fromUnix;
+exports.getAllZonesForTime = getAllZonesForTime;
+exports.getNextRuns = getNextRuns;
+exports.getNow = getNow;
+exports.getRunInterval = getRunInterval;
+exports.getTimezoneOffset = getTimezoneOffset;
+exports.humanizeDiff = humanizeDiff;
+exports.parseCron = parseCron;
+exports.parseCronExpression = parseCronExpression;
+exports.parseDate = parseDate;

package/dist/tools/time.d.cts

@@ -0,0 +1 @@
+export { C as COMMON_CRONS, a as COMMON_DATE_PRESETS, b as CronField, c as CronNextField, d as CronResult, D as DateDiffResult, P as ParsedCron, T as TIMEZONES, e as TimestampResult, f as TimezoneEntry, g as convertTime, h as diffDates, i as formatInTimezone, j as formatRelative, k as formatRunDate, l as fromIsoString, m as fromUnix, n as getAllZonesForTime, o as getNextRuns, p as getNow, q as getRunInterval, r as getTimezoneOffset, s as humanizeDiff, u as parseCron, v as parseCronExpression, w as parseDate } from '../time-DbT8fjaF.cjs';

package/dist/tools/time.d.ts

@@ -0,0 +1 @@
+export { C as COMMON_CRONS, a as COMMON_DATE_PRESETS, b as CronField, c as CronNextField, d as CronResult, D as DateDiffResult, P as ParsedCron, T as TIMEZONES, e as TimestampResult, f as TimezoneEntry, g as convertTime, h as diffDates, i as formatInTimezone, j as formatRelative, k as formatRunDate, l as fromIsoString, m as fromUnix, n as getAllZonesForTime, o as getNextRuns, p as getNow, q as getRunInterval, r as getTimezoneOffset, s as humanizeDiff, u as parseCron, v as parseCronExpression, w as parseDate } from '../time-DbT8fjaF.js';

package/dist/tools/time.js

@@ -0,0 +1,2 @@
+export { COMMON_CRONS, COMMON_DATE_PRESETS, TIMEZONES, convertTime, diffDates, formatInTimezone, formatRelative, formatRunDate, fromIsoString, fromUnix, getAllZonesForTime, getNextRuns, getNow, getRunInterval, getTimezoneOffset, humanizeDiff, parseCron, parseCronExpression, parseDate } from '../chunk-ZPQZEIXP.js';
+import '../chunk-MLKGABMK.js';