cynx-lib 1.3.41 → 1.3.44

package/utils/utils/tz.cjs

@@ -0,0 +1,542 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tz_exports = {};
+__export(tz_exports, {
+  COMMON_TIMEZONES: () => COMMON_TIMEZONES,
+  DEFAULT_OFFSET: () => DEFAULT_OFFSET,
+  DEFAULT_TIMEZONE: () => DEFAULT_TIMEZONE,
+  DEFAULT_TZ_LABEL: () => DEFAULT_TZ_LABEL,
+  addTime: () => addTime,
+  combineToTzIso: () => combineToTzIso,
+  daysBetween: () => daysBetween,
+  default: () => tz_default,
+  formatCustomDateTz: () => formatCustomDateTz,
+  formatDateKeyTz: () => formatDateKeyTz,
+  formatTZ: () => formatTZ,
+  getCurrentMonth: () => getCurrentMonth,
+  getDateRange: () => getDateRange,
+  getEndOfDay: () => getEndOfDay,
+  getEndOfMonth: () => getEndOfMonth,
+  getNow: () => getNow,
+  getPartsInTz: () => getPartsInTz,
+  getStartOfDay: () => getStartOfDay,
+  getStartOfMonth: () => getStartOfMonth,
+  getTimezoneList: () => getTimezoneList,
+  getTimezoneOffset: () => getTimezoneOffset,
+  getTimezoneParts: () => getTimezoneParts,
+  getToday: () => getToday,
+  getUserTimezone: () => getUserTimezone,
+  isSameDay: () => isSameDay,
+  isToday: () => isToday,
+  isValidTimezone: () => isValidTimezone,
+  nextDayStr: () => nextDayStr,
+  pad: () => pad,
+  parseInputDate: () => parseInputDate,
+  prevDayStr: () => prevDayStr,
+  shiftDateStr: () => shiftDateStr,
+  tashkentMonth: () => tashkentMonth,
+  tashkentNow: () => tashkentNow,
+  tashkentTimeStr: () => tashkentTimeStr,
+  tashkentToday: () => tashkentToday,
+  timeAgo: () => timeAgo
+});
+module.exports = __toCommonJS(tz_exports);
+const formatterCache = /* @__PURE__ */ new Map();
+function getCachedFormatter(locale, options) {
+  const key = `${locale}_${JSON.stringify(options)}`;
+  if (!formatterCache.has(key)) {
+    formatterCache.set(key, new Intl.DateTimeFormat(locale, options));
+  }
+  return formatterCache.get(key);
+}
+function parseDate(input) {
+  if (input instanceof Date) return new Date(input.getTime());
+  if (typeof input === "number") return new Date(input);
+  if (typeof input === "string") {
+    const d = new Date(input);
+    if (!isNaN(d.getTime())) return d;
+  }
+  return /* @__PURE__ */ new Date();
+}
+function pad(n, length = 2) {
+  return String(n).padStart(length, "0");
+}
+function getUserTimezone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  } catch {
+    return "UTC";
+  }
+}
+function isValidTimezone(timezone) {
+  if (!timezone || typeof timezone !== "string") return false;
+  try {
+    Intl.DateTimeFormat(void 0, { timeZone: timezone });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getTimezoneParts(date, timezone = getUserTimezone()) {
+  const d = parseDate(date);
+  const formatter = getCachedFormatter("en-US", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "numeric",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    second: "numeric",
+    fractionalSecondDigits: 3,
+    hour12: false,
+    weekday: "short"
+  });
+  const parts = formatter.formatToParts(d);
+  const result = {
+    year: 0,
+    month: 1,
+    day: 1,
+    hour: 0,
+    minute: 0,
+    second: 0,
+    millisecond: d.getMilliseconds(),
+    weekday: d.getDay()
+  };
+  for (const { type, value } of parts) {
+    if (type === "year") result.year = parseInt(value, 10);
+    else if (type === "month") result.month = parseInt(value, 10);
+    else if (type === "day") result.day = parseInt(value, 10);
+    else if (type === "hour") result.hour = parseInt(value, 10) === 24 ? 0 : parseInt(value, 10);
+    else if (type === "minute") result.minute = parseInt(value, 10);
+    else if (type === "second") result.second = parseInt(value, 10);
+    else if (type === "fractionalSecond") result.millisecond = parseInt(value, 10);
+  }
+  return result;
+}
+function getTimezoneOffset(timezone = getUserTimezone(), date = /* @__PURE__ */ new Date()) {
+  const d = parseDate(date);
+  try {
+    const parts = getTimezoneParts(d, timezone);
+    const utcParts = getTimezoneParts(d, "UTC");
+    const tzDate = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
+    const utcDate = Date.UTC(utcParts.year, utcParts.month - 1, utcParts.day, utcParts.hour, utcParts.minute, utcParts.second);
+    const diffMinutes = Math.round((tzDate - utcDate) / (1e3 * 60));
+    const sign = diffMinutes >= 0 ? "+" : "-";
+    const absMin = Math.abs(diffMinutes);
+    const hours = String(Math.floor(absMin / 60)).padStart(2, "0");
+    const mins = String(absMin % 60).padStart(2, "0");
+    const offsetString = `${sign}${hours}:${mins}`;
+    return {
+      offsetMinutes: diffMinutes,
+      offsetString,
+      formatted: `UTC${offsetString}`
+    };
+  } catch {
+    return { offsetMinutes: 0, offsetString: "+00:00", formatted: "UTC+00:00" };
+  }
+}
+const MONTH_NAMES = {
+  en: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
+  ru: ["\u042F\u043D\u0432\u0430\u0440\u044C", "\u0424\u0435\u0432\u0440\u0430\u043B\u044C", "\u041C\u0430\u0440\u0442", "\u0410\u043F\u0440\u0435\u043B\u044C", "\u041C\u0430\u0439", "\u0418\u044E\u043D\u044C", "\u0418\u044E\u043B\u044C", "\u0410\u0432\u0433\u0443\u0441\u0442", "\u0421\u0435\u043D\u0442\u044F\u0431\u0440\u044C", "\u041E\u043A\u0442\u044F\u0431\u0440\u044C", "\u041D\u043E\u044F\u0431\u0440\u044C", "\u0414\u0435\u043A\u0430\u0431\u0440\u044C"]
+};
+const MONTH_SHORT = {
+  en: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
+  ru: ["\u044F\u043D\u0432", "\u0444\u0435\u0432", "\u043C\u0430\u0440", "\u0430\u043F\u0440", "\u043C\u0430\u0439", "\u0438\u044E\u043D", "\u0438\u044E\u043B", "\u0430\u0432\u0433", "\u0441\u0435\u043D", "\u043E\u043A\u0442", "\u043D\u043E\u044F", "\u0434\u0435\u043A"]
+};
+function formatTZ(date, pattern = "YYYY-MM-DD HH:mm:ss", { timezone = getUserTimezone(), locale = "en" } = {}) {
+  const d = parseDate(date);
+  const p = getTimezoneParts(d, timezone);
+  const offset = getTimezoneOffset(timezone, d);
+  const lang = MONTH_NAMES[locale] ? locale : "en";
+  const monthIdx = p.month - 1;
+  const hour12 = p.hour % 12 || 12;
+  const isPM = p.hour >= 12;
+  const tokens = {
+    YYYY: String(p.year),
+    YY: String(p.year).slice(-2),
+    MMMM: MONTH_NAMES[lang][monthIdx],
+    MMM: MONTH_SHORT[lang][monthIdx],
+    MM: String(p.month).padStart(2, "0"),
+    M: String(p.month),
+    DD: String(p.day).padStart(2, "0"),
+    D: String(p.day),
+    HH: String(p.hour).padStart(2, "0"),
+    H: String(p.hour),
+    hh: String(hour12).padStart(2, "0"),
+    h: String(hour12),
+    mm: String(p.minute).padStart(2, "0"),
+    m: String(p.minute),
+    ss: String(p.second).padStart(2, "0"),
+    s: String(p.second),
+    SSS: String(p.millisecond).padStart(3, "0"),
+    A: isPM ? "PM" : "AM",
+    a: isPM ? "pm" : "am",
+    ZZ: offset.offsetString,
+    Z: offset.offsetString.replace(":", ""),
+    z: offset.formatted
+  };
+  return pattern.replace(/YYYY|YY|MMMM|MMM|MM|M|DD|D|HH|H|hh|h|mm|m|ss|s|SSS|A|a|ZZ|Z|z/g, (match) => tokens[match] || match);
+}
+function timeAgo(date, { baseDate = Date.now(), locale = "en" } = {}) {
+  const d = parseDate(date).getTime();
+  const base = parseDate(baseDate).getTime();
+  const diffSec = Math.round((d - base) / 1e3);
+  const rtf = typeof Intl !== "undefined" && Intl.RelativeTimeFormat ? new Intl.RelativeTimeFormat(locale, { numeric: "auto" }) : null;
+  const absSec = Math.abs(diffSec);
+  if (absSec < 10) {
+    return locale.startsWith("ru") ? "\u0442\u043E\u043B\u044C\u043A\u043E \u0447\u0442\u043E" : "just now";
+  }
+  const units = [
+    { name: "year", seconds: 31536e3 },
+    { name: "month", seconds: 2592e3 },
+    { name: "day", seconds: 86400 },
+    { name: "hour", seconds: 3600 },
+    { name: "minute", seconds: 60 },
+    { name: "second", seconds: 1 }
+  ];
+  for (const { name, seconds } of units) {
+    if (absSec >= seconds || name === "second") {
+      const val = Math.round(diffSec / seconds);
+      if (rtf) {
+        return rtf.format(val, name);
+      }
+      return `${Math.abs(val)} ${name}${Math.abs(val) > 1 ? "s" : ""} ${diffSec < 0 ? "ago" : "from now"}`;
+    }
+  }
+  return "";
+}
+function getNow(timezone = getUserTimezone()) {
+  const d = /* @__PURE__ */ new Date();
+  const offset = getTimezoneOffset(timezone, d);
+  return new Date(d.getTime() + offset.offsetMinutes * 60 * 1e3);
+}
+function getToday(timezone = getUserTimezone()) {
+  const p = getTimezoneParts(/* @__PURE__ */ new Date(), timezone);
+  return `${p.year}-${pad(p.month)}-${pad(p.day)}`;
+}
+function getCurrentMonth(timezone = getUserTimezone()) {
+  const p = getTimezoneParts(/* @__PURE__ */ new Date(), timezone);
+  return `${p.year}-${pad(p.month)}`;
+}
+function shiftDateStr(dateInput, amount = 0, unit = "days") {
+  let y, m, d;
+  if (typeof dateInput === "string" && /^\d{4}-\d{2}-\d{2}/.test(dateInput)) {
+    const parts = dateInput.slice(0, 10).split("-").map(Number);
+    y = parts[0];
+    m = parts[1];
+    d = parts[2];
+  } else {
+    const parsed = parseDate(dateInput);
+    y = parsed.getUTCFullYear();
+    m = parsed.getUTCMonth() + 1;
+    d = parsed.getUTCDate();
+  }
+  const dt = new Date(Date.UTC(y, m - 1, d));
+  switch (unit) {
+    case "years":
+      dt.setUTCFullYear(dt.getUTCFullYear() + amount);
+      break;
+    case "months":
+      dt.setUTCMonth(dt.getUTCMonth() + amount);
+      break;
+    case "days":
+    default:
+      dt.setUTCDate(dt.getUTCDate() + amount);
+      break;
+  }
+  return `${dt.getUTCFullYear()}-${pad(dt.getUTCMonth() + 1)}-${pad(dt.getUTCDate())}`;
+}
+function prevDayStr(dateStr, count = 1) {
+  return shiftDateStr(dateStr, -count, "days");
+}
+function nextDayStr(dateStr, count = 1) {
+  return shiftDateStr(dateStr, count, "days");
+}
+function daysBetween(date1, date2) {
+  const parseToUtcMidnight = (val) => {
+    if (typeof val === "string" && /^\d{4}-\d{2}-\d{2}/.test(val)) {
+      const [y, m, d] = val.slice(0, 10).split("-").map(Number);
+      return Date.UTC(y, m - 1, d);
+    }
+    const dt = parseDate(val);
+    return Date.UTC(dt.getUTCFullYear(), dt.getUTCMonth(), dt.getUTCDate());
+  };
+  const ms1 = parseToUtcMidnight(date1);
+  const ms2 = parseToUtcMidnight(date2);
+  return Math.round((ms2 - ms1) / (1e3 * 60 * 60 * 24));
+}
+function getDateRange(startDate, endDate) {
+  const startStr = typeof startDate === "string" && /^\d{4}-\d{2}-\d{2}/.test(startDate) ? startDate.slice(0, 10) : formatTZ(startDate, "YYYY-MM-DD");
+  const endStr = typeof endDate === "string" && /^\d{4}-\d{2}-\d{2}/.test(endDate) ? endDate.slice(0, 10) : formatTZ(endDate, "YYYY-MM-DD");
+  if (startStr > endStr) return [];
+  const range = [];
+  let curr = startStr;
+  while (curr <= endStr) {
+    range.push(curr);
+    curr = nextDayStr(curr);
+  }
+  return range;
+}
+function getStartOfMonth(date = /* @__PURE__ */ new Date(), timezone = getUserTimezone()) {
+  const p = getTimezoneParts(date, timezone);
+  return `${p.year}-${pad(p.month)}-01`;
+}
+function getEndOfMonth(date = /* @__PURE__ */ new Date(), timezone = getUserTimezone()) {
+  const p = getTimezoneParts(date, timezone);
+  const dt = new Date(Date.UTC(p.year, p.month, 0));
+  return `${p.year}-${pad(p.month)}-${pad(dt.getUTCDate())}`;
+}
+function getStartOfDay(date = /* @__PURE__ */ new Date(), timezone = getUserTimezone()) {
+  const p = getTimezoneParts(date, timezone);
+  const offset = getTimezoneOffset(timezone, new Date(Date.UTC(p.year, p.month - 1, p.day, 12, 0, 0)));
+  return new Date(Date.UTC(p.year, p.month - 1, p.day, 0, 0, 0, 0) - offset.offsetMinutes * 60 * 1e3);
+}
+function getEndOfDay(date = /* @__PURE__ */ new Date(), timezone = getUserTimezone()) {
+  const p = getTimezoneParts(date, timezone);
+  const offset = getTimezoneOffset(timezone, new Date(Date.UTC(p.year, p.month - 1, p.day, 12, 0, 0)));
+  return new Date(Date.UTC(p.year, p.month - 1, p.day, 23, 59, 59, 999) - offset.offsetMinutes * 60 * 1e3);
+}
+function addTime(date, amount, unit = "days") {
+  const d = parseDate(date);
+  switch (unit) {
+    case "years":
+      d.setFullYear(d.getFullYear() + amount);
+      break;
+    case "months":
+      d.setMonth(d.getMonth() + amount);
+      break;
+    case "days":
+      d.setDate(d.getDate() + amount);
+      break;
+    case "hours":
+      d.setHours(d.getHours() + amount);
+      break;
+    case "minutes":
+      d.setMinutes(d.getMinutes() + amount);
+      break;
+    case "seconds":
+      d.setSeconds(d.getSeconds() + amount);
+      break;
+  }
+  return d;
+}
+function isSameDay(date1, date2, timezone = getUserTimezone()) {
+  const p1 = getTimezoneParts(date1, timezone);
+  const p2 = getTimezoneParts(date2, timezone);
+  return p1.year === p2.year && p1.month === p2.month && p1.day === p2.day;
+}
+function isToday(date, timezone = getUserTimezone()) {
+  return isSameDay(date, /* @__PURE__ */ new Date(), timezone);
+}
+const COMMON_TIMEZONES = [
+  { value: "Pacific/Midway", label: "(UTC-11:00) Midway Island, Samoa" },
+  { value: "Pacific/Honolulu", label: "(UTC-10:00) Hawaii" },
+  { value: "America/Anchorage", label: "(UTC-09:00) Alaska" },
+  { value: "America/Los_Angeles", label: "(UTC-08:00) Pacific Time (US & Canada)" },
+  { value: "America/Denver", label: "(UTC-07:00) Mountain Time (US & Canada)" },
+  { value: "America/Chicago", label: "(UTC-06:00) Central Time (US & Canada)" },
+  { value: "America/New_York", label: "(UTC-05:00) Eastern Time (US & Canada)" },
+  { value: "America/Sao_Paulo", label: "(UTC-03:00) Brasilia, Sao Paulo" },
+  { value: "UTC", label: "(UTC+00:00) Universal Coordinated Time, London" },
+  { value: "Europe/London", label: "(UTC+00:00) London, Dublin, Edinburgh" },
+  { value: "Europe/Paris", label: "(UTC+01:00) Paris, Berlin, Rome, Madrid" },
+  { value: "Europe/Kyiv", label: "(UTC+02:00) Kyiv, Helsinki, Athens" },
+  { value: "Europe/Moscow", label: "(UTC+03:00) Moscow, St. Petersburg, Istanbul" },
+  { value: "Asia/Dubai", label: "(UTC+04:00) Dubai, Abu Dhabi, Baku" },
+  { value: "Asia/Tashkent", label: "(UTC+05:00) Tashkent, Samarkand, Islamabad" },
+  { value: "Asia/Almaty", label: "(UTC+05:00) Almaty, Astana" },
+  { value: "Asia/Dhaka", label: "(UTC+06:00) Dhaka, Novosibirsk" },
+  { value: "Asia/Bangkok", label: "(UTC+07:00) Bangkok, Hanoi, Jakarta" },
+  { value: "Asia/Singapore", label: "(UTC+08:00) Singapore, Beijing, Hong Kong" },
+  { value: "Asia/Tokyo", label: "(UTC+09:00) Tokyo, Seoul" },
+  { value: "Australia/Sydney", label: "(UTC+10:00) Sydney, Melbourne" },
+  { value: "Pacific/Auckland", label: "(UTC+12:00) Auckland, Wellington" }
+];
+function getTimezoneList() {
+  return COMMON_TIMEZONES.map((tz) => {
+    const off = getTimezoneOffset(tz.value);
+    return {
+      value: tz.value,
+      label: tz.label,
+      offset: off.offsetString,
+      offsetMinutes: off.offsetMinutes
+    };
+  });
+}
+function tashkentNow() {
+  return getNow("Asia/Tashkent");
+}
+function tashkentToday() {
+  return getToday("Asia/Tashkent");
+}
+function tashkentMonth() {
+  return getCurrentMonth("Asia/Tashkent");
+}
+function tashkentTimeStr() {
+  const p = getTimezoneParts(/* @__PURE__ */ new Date(), "Asia/Tashkent");
+  return `${pad(p.hour)}:${pad(p.minute)}`;
+}
+const DEFAULT_TIMEZONE = "Asia/Tashkent";
+const DEFAULT_OFFSET = "+05:00";
+const DEFAULT_TZ_LABEL = "GMT+5";
+function formatCustomDateTz(date, timeZone = DEFAULT_TIMEZONE) {
+  if (!date) return "";
+  const d = new Date(date);
+  if (isNaN(d.getTime())) return "";
+  const dtf = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true
+  });
+  const parts = dtf.formatToParts(d);
+  const partMap = {};
+  for (const p of parts) {
+    partMap[p.type] = p.value;
+  }
+  return `${partMap.month} ${partMap.day}, ${partMap.year}, ${partMap.hour}:${partMap.minute} ${partMap.dayPeriod || ""} ${DEFAULT_TZ_LABEL}`.replace(/\s+/g, " ").trim();
+}
+function formatDateKeyTz(date = /* @__PURE__ */ new Date(), timeZone = DEFAULT_TIMEZONE) {
+  const d = new Date(date);
+  if (isNaN(d.getTime())) return "";
+  const dtf = new Intl.DateTimeFormat("en-CA", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  });
+  return dtf.format(d);
+}
+function getPartsInTz(date, timeZone = DEFAULT_TIMEZONE) {
+  if (!date) return { date: "", time: "" };
+  const d = new Date(date);
+  if (isNaN(d.getTime())) return { date: "", time: "" };
+  const dtf = new Intl.DateTimeFormat("en-GB", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+  const parts = dtf.formatToParts(d);
+  const map = {};
+  for (const p of parts) map[p.type] = p.value;
+  return {
+    date: `${map.year}-${map.month}-${map.day}`,
+    time: `${map.hour}:${map.minute}`
+  };
+}
+function combineToTzIso(dateStr, timeStr = "00:00", offset = DEFAULT_OFFSET) {
+  if (!dateStr || !dateStr.trim()) return null;
+  const t = timeStr && timeStr.trim() ? timeStr.trim() : "00:00";
+  const fullTime = t.length === 5 ? `${t}:00` : t;
+  return `${dateStr.trim()}T${fullTime}${offset}`;
+}
+function parseInputDate(input, defaultOffset = DEFAULT_OFFSET) {
+  if (!input) return null;
+  if (input instanceof Date) return isNaN(input.getTime()) ? null : input;
+  let s = String(input).trim();
+  if (!s) return null;
+  if (!/[zZ]$/.test(s) && !/[+-]\d{2}(:?\d{2})?$/.test(s)) {
+    s = `${s}${defaultOffset}`;
+  }
+  const d = new Date(s);
+  return isNaN(d.getTime()) ? null : d;
+}
+var tz_default = {
+  pad,
+  getUserTimezone,
+  isValidTimezone,
+  getTimezoneParts,
+  getTimezoneOffset,
+  formatTZ,
+  timeAgo,
+  getNow,
+  getToday,
+  getCurrentMonth,
+  shiftDateStr,
+  prevDayStr,
+  nextDayStr,
+  daysBetween,
+  getDateRange,
+  getStartOfMonth,
+  getEndOfMonth,
+  getStartOfDay,
+  getEndOfDay,
+  addTime,
+  isSameDay,
+  isToday,
+  getTimezoneList,
+  COMMON_TIMEZONES,
+  tashkentNow,
+  tashkentToday,
+  tashkentMonth,
+  tashkentTimeStr,
+  DEFAULT_TIMEZONE,
+  DEFAULT_OFFSET,
+  DEFAULT_TZ_LABEL,
+  formatCustomDateTz,
+  formatDateKeyTz,
+  getPartsInTz,
+  combineToTzIso,
+  parseInputDate
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  COMMON_TIMEZONES,
+  DEFAULT_OFFSET,
+  DEFAULT_TIMEZONE,
+  DEFAULT_TZ_LABEL,
+  addTime,
+  combineToTzIso,
+  daysBetween,
+  formatCustomDateTz,
+  formatDateKeyTz,
+  formatTZ,
+  getCurrentMonth,
+  getDateRange,
+  getEndOfDay,
+  getEndOfMonth,
+  getNow,
+  getPartsInTz,
+  getStartOfDay,
+  getStartOfMonth,
+  getTimezoneList,
+  getTimezoneOffset,
+  getTimezoneParts,
+  getToday,
+  getUserTimezone,
+  isSameDay,
+  isToday,
+  isValidTimezone,
+  nextDayStr,
+  pad,
+  parseInputDate,
+  prevDayStr,
+  shiftDateStr,
+  tashkentMonth,
+  tashkentNow,
+  tashkentTimeStr,
+  tashkentToday,
+  timeAgo
+});

package/utils/utils/ui.cjs

@@ -0,0 +1,105 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ui_exports = {};
+__export(ui_exports, {
+  cn: () => cn,
+  copyToClipboard: () => copyToClipboard,
+  default: () => ui_default,
+  fmtAgo: () => fmtAgo,
+  fmtDate: () => fmtDate
+});
+module.exports = __toCommonJS(ui_exports);
+function cn(...inputs) {
+  const classes = [];
+  for (let i = 0; i < inputs.length; i++) {
+    const arg = inputs[i];
+    if (!arg) continue;
+    const argType = typeof arg;
+    if (argType === "string" || argType === "number") {
+      classes.push(arg);
+    } else if (Array.isArray(arg)) {
+      if (arg.length) {
+        const inner = cn(...arg);
+        if (inner) classes.push(inner);
+      }
+    } else if (argType === "object") {
+      for (const key in arg) {
+        if (Object.prototype.hasOwnProperty.call(arg, key) && arg[key]) {
+          classes.push(key);
+        }
+      }
+    }
+  }
+  return classes.join(" ");
+}
+async function copyToClipboard(text) {
+  if (typeof navigator !== "undefined" && navigator.clipboard?.writeText) {
+    try {
+      await navigator.clipboard.writeText(text);
+      return true;
+    } catch {
+    }
+  }
+  if (typeof document !== "undefined") {
+    try {
+      const el = document.createElement("textarea");
+      el.value = text;
+      el.setAttribute("readonly", "");
+      el.style.position = "absolute";
+      el.style.left = "-9999px";
+      document.body.appendChild(el);
+      el.select();
+      const successful = document.execCommand("copy");
+      document.body.removeChild(el);
+      return successful;
+    } catch {
+    }
+  }
+  return false;
+}
+function fmtAgo(d) {
+  if (!d) return "\u2014";
+  const s = Math.floor((Date.now() - new Date(d).getTime()) / 1e3);
+  if (isNaN(s)) return "\u2014";
+  if (s < 60) return `${Math.max(0, s)}s ago`;
+  if (s < 3600) return `${Math.floor(s / 60)}m ago`;
+  if (s < 86400) return `${Math.floor(s / 3600)}h ago`;
+  return `${Math.floor(s / 86400)}d ago`;
+}
+function fmtDate(d, locale = "ru-RU") {
+  if (!d) return "\u2014";
+  try {
+    const date = new Date(d);
+    return isNaN(date.getTime()) ? "\u2014" : date.toLocaleString(locale);
+  } catch {
+    return "\u2014";
+  }
+}
+var ui_default = {
+  cn,
+  copyToClipboard,
+  fmtAgo,
+  fmtDate
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cn,
+  copyToClipboard,
+  fmtAgo,
+  fmtDate
+});