@godxjp/ui 13.9.3 → 13.11.0

package/dist/lib/datetime/detect.js

@@ -0,0 +1,16 @@
+import { isValidHhmm } from "./parse";
+const DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
+function detectFormatDateKind(value) {
+  if (value instanceof Date) return "datetime";
+  const trimmed = value.trim();
+  if (isValidHhmm(trimmed)) return "time";
+  if (DATE_ONLY_RE.test(trimmed)) return "date";
+  return "datetime";
+}
+function isDateOnlyString(value) {
+  return DATE_ONLY_RE.test(value.trim());
+}
+export {
+  detectFormatDateKind,
+  isDateOnlyString
+};

package/dist/lib/datetime/format-date.d.ts

@@ -0,0 +1,22 @@
+import { type FormatDatetimeOptions } from "./format";
+import { type FormatDateKind } from "./detect";
+export type FormatDateOptions = FormatDatetimeOptions & {
+    /**
+     * Output preset. Default `auto` detects ISO date / HH:mm / instant.
+     * Locale, timezone, and 12h|24h fall back to AppProvider when omitted.
+     */
+    kind?: FormatDateKind;
+    /** Treat `Date` as calendar pick (react-day-picker) — not an instant. */
+    calendar?: boolean;
+};
+/**
+ * **Single entry point** for all date/time display in GX apps.
+ *
+ * - Defaults: locale, timezone, timeFormat from AppProvider (`syncDatetimeContext`)
+ * - Optional overrides: `{ timezone: "Asia/Tokyo" }` per call
+ * - Auto-detect: `"2026-05-01"` → date, `"14:30"` → time, ISO instant → datetime
+ * - International patterns: ISO 8601 date (`yyyy-MM-dd`) + ISO datetime (`yyyy-MM-dd HH:mm`)
+ */
+export declare function formatDate(value: string | Date | null | undefined, options?: FormatDateOptions): string;
+/** True when value looks like a displayable date/time (string or valid Date). */
+export declare function isFormatDateValue(value: unknown): value is string | Date;

package/dist/lib/datetime/format-date.js

@@ -0,0 +1,73 @@
+import {
+  formatAppDate,
+  formatAppDateLong,
+  formatAppDateTime,
+  formatAppRelative,
+  formatAppTime,
+  formatCalendarDate,
+  formatTimeOfDay
+} from "./format";
+import { detectFormatDateKind } from "./detect";
+import { isValidHhmm, parseDateInput } from "./parse";
+import { canUseLiveRelativeFormatting } from "./sync";
+const EMPTY = "\u2014";
+function resolveKind(value, options) {
+  if (options?.kind && options.kind !== "auto") return options.kind;
+  if (options?.calendar && value instanceof Date) return "calendar";
+  return detectFormatDateKind(value);
+}
+function formatInitialRelative(value, options) {
+  if (canUseLiveRelativeFormatting()) return formatAppRelative(value, options);
+  return formatAppDateTime(value, options);
+}
+function formatDate(value, options) {
+  if (value == null || value === "") return EMPTY;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return EMPTY;
+    const kind2 = resolveKind(trimmed, options);
+    switch (kind2) {
+      case "time":
+        return isValidHhmm(trimmed) ? formatTimeOfDay(trimmed, options) : formatAppTime(trimmed, options);
+      case "date":
+        return formatAppDate(trimmed, options);
+      case "long":
+        return formatAppDateLong(trimmed, options);
+      case "relative":
+        return formatInitialRelative(trimmed, options);
+      case "calendar":
+      case "datetime":
+      default:
+        return formatAppDateTime(trimmed, options);
+    }
+  }
+  if (!(value instanceof Date) || Number.isNaN(value.getTime())) return EMPTY;
+  const kind = resolveKind(value, options);
+  switch (kind) {
+    case "calendar":
+      return formatCalendarDate(value, options);
+    case "date":
+      return formatCalendarDate(value, options);
+    case "time":
+      return formatAppTime(value, options);
+    case "long":
+      return formatAppDateLong(value, options);
+    case "relative":
+      return formatInitialRelative(value, options);
+    case "datetime":
+    default:
+      return formatAppDateTime(value, options);
+  }
+}
+function isFormatDateValue(value) {
+  if (value instanceof Date) return !Number.isNaN(value.getTime());
+  if (typeof value !== "string") return false;
+  const trimmed = value.trim();
+  if (!trimmed) return false;
+  if (isValidHhmm(trimmed)) return true;
+  return parseDateInput(trimmed) != null;
+}
+export {
+  formatDate,
+  isFormatDateValue
+};

package/dist/lib/datetime/format.d.ts

@@ -0,0 +1,23 @@
+import { type Locale } from "date-fns";
+import { type AppTimeFormat } from "../../app/time-formats";
+import type { AppLocale, AppDateFormat } from "../../app/types";
+export type FormatDatetimeOptions = {
+    locale?: Locale | AppLocale;
+    timezone?: string;
+    timeFormat?: AppTimeFormat;
+    dateFormat?: AppDateFormat;
+};
+/** Date-only from calendar picker — uses Y/M/D in app timezone. */
+export declare function formatCalendarDate(value: Date | null | undefined, options?: FormatDatetimeOptions): string;
+/** Date-only from ISO instant or `yyyy-MM-dd` string — date part in app timezone. */
+export declare function formatAppDate(value: string | Date | null | undefined, options?: FormatDatetimeOptions): string;
+/** Date + time in app timezone. */
+export declare function formatAppDateTime(value: string | Date | null | undefined, options?: FormatDatetimeOptions): string;
+/** Time from ISO instant in app timezone. */
+export declare function formatAppTime(value: string | Date | null | undefined, options?: FormatDatetimeOptions): string;
+/** Long date (PPP) in app timezone. */
+export declare function formatAppDateLong(value: string | Date | null | undefined, options?: FormatDatetimeOptions): string;
+/** Relative time — instant-based; locale from context. */
+export declare function formatAppRelative(value: string | Date | null | undefined, options?: Pick<FormatDatetimeOptions, "locale">): string;
+/** Format canonical HH:mm (24h storage) for display per timeFormat + locale. */
+export declare function formatTimeOfDay(hhmm: string | null | undefined, options?: FormatDatetimeOptions): string;

package/dist/lib/datetime/format.js

@@ -0,0 +1,94 @@
+import { TZDate } from "@date-fns/tz";
+import { format, formatDistanceToNow } from "date-fns";
+import { getDateFnsLocale } from "../../app/locales";
+import { getDatePattern, getDateTimePattern } from "../../app/date-formats";
+import { getTimePattern } from "../../app/time-formats";
+import { calendarDateToTZDate, hhmmToTZDate, parseDateInput } from "./parse";
+import { isDateOnlyString } from "./detect";
+import { getDatetimeContext } from "./sync";
+function resolveLocale(locale) {
+  if (!locale) return getDatetimeContext().dateFnsLocale;
+  if (typeof locale === "string") return getDateFnsLocale(locale);
+  return locale;
+}
+function resolveOptions(options) {
+  const ctx = getDatetimeContext();
+  return {
+    locale: resolveLocale(options?.locale),
+    timezone: options?.timezone ?? ctx.timezone,
+    timeFormat: options?.timeFormat ?? ctx.timeFormat,
+    dateFormat: options?.dateFormat ?? ctx.dateFormat
+  };
+}
+function formatTZDate(zoned, pattern, options) {
+  return format(zoned, pattern, { locale: options.locale });
+}
+function instantToTZDate(value, timezone) {
+  return new TZDate(value, timezone);
+}
+const EMPTY = "\u2014";
+function formatCalendarDate(value, options) {
+  if (!value) return EMPTY;
+  const resolved = resolveOptions(options);
+  const zoned = calendarDateToTZDate(value, resolved.timezone);
+  return formatTZDate(zoned, getDatePattern(resolved.dateFormat), resolved);
+}
+function formatAppDate(value, options) {
+  const resolved = resolveOptions(options);
+  if (typeof value === "string" && isDateOnlyString(value)) {
+    const [year, month, day] = value.split("-").map(Number);
+    const zoned2 = new TZDate(year, month - 1, day, resolved.timezone);
+    return formatTZDate(zoned2, getDatePattern(resolved.dateFormat), resolved);
+  }
+  const parsed = parseDateInput(value);
+  if (!parsed) return EMPTY;
+  const zoned = instantToTZDate(parsed, resolved.timezone);
+  return formatTZDate(zoned, getDatePattern(resolved.dateFormat), resolved);
+}
+function formatAppDateTime(value, options) {
+  const parsed = parseDateInput(value);
+  if (!parsed) return EMPTY;
+  const resolved = resolveOptions(options);
+  const zoned = instantToTZDate(parsed, resolved.timezone);
+  return formatTZDate(
+    zoned,
+    getDateTimePattern(resolved.timeFormat, resolved.dateFormat),
+    resolved
+  );
+}
+function formatAppTime(value, options) {
+  const parsed = parseDateInput(value);
+  if (!parsed) return EMPTY;
+  const resolved = resolveOptions(options);
+  const zoned = instantToTZDate(parsed, resolved.timezone);
+  return formatTZDate(zoned, getTimePattern(resolved.timeFormat), resolved);
+}
+function formatAppDateLong(value, options) {
+  const parsed = parseDateInput(value);
+  if (!parsed) return EMPTY;
+  const resolved = resolveOptions(options);
+  const zoned = instantToTZDate(parsed, resolved.timezone);
+  return formatTZDate(zoned, "PPP", resolved);
+}
+function formatAppRelative(value, options) {
+  const parsed = parseDateInput(value);
+  if (!parsed) return EMPTY;
+  const locale = resolveLocale(options?.locale);
+  return formatDistanceToNow(parsed, { addSuffix: true, locale });
+}
+function formatTimeOfDay(hhmm, options) {
+  if (!hhmm) return EMPTY;
+  const resolved = resolveOptions(options);
+  const zoned = hhmmToTZDate(hhmm, resolved.timezone);
+  if (!zoned) return hhmm;
+  return formatTZDate(zoned, getTimePattern(resolved.timeFormat), resolved);
+}
+export {
+  formatAppDate,
+  formatAppDateLong,
+  formatAppDateTime,
+  formatAppRelative,
+  formatAppTime,
+  formatCalendarDate,
+  formatTimeOfDay
+};

package/dist/lib/datetime/index.d.ts

@@ -1,35 +1,5 @@
-import { Locale } from 'date-fns';
-import { h as AppLocale, j as AppTimeFormat, g as AppDateFormat } from '../../types-mvzYGrma.js';
-import { TZDate } from '@date-fns/tz';
-export { F as FormatDateKind, a as FormatDateOptions, b as FormatDatetimeOptions, d as detectFormatDateKind, f as formatAppDate, c as formatAppDateLong, e as formatAppDateTime, g as formatAppRelative, h as formatAppTime, i as formatCalendarDate, j as formatDate, k as formatTimeOfDay, l as isDateOnlyString, m as isFormatDateValue } from '../../format-date-ByyZoqI5.js';
-
-type DatetimeContext = {
-    locale: AppLocale;
-    dateFnsLocale: Locale;
-    timezone: string;
-    timeFormat: AppTimeFormat;
-    dateFormat: AppDateFormat;
-};
-/** Sync module-level datetime prefs from AppProvider (mirrors syncI18nLocale). */
-declare function syncDatetimeContext(partial: Pick<DatetimeContext, "locale" | "timezone" | "timeFormat" | "dateFormat"> & {
-    dateFnsLocale?: Locale;
-}): void;
-declare function getDatetimeContext(): Readonly<DatetimeContext>;
-declare function enableLiveRelativeFormatting(): void;
-declare function disableLiveRelativeFormatting(): void;
-/** Vitest only — reset to defaults between cases. */
-declare function resetDatetimeContextForTests(): void;
-
-/** Format a calendar Date to an ISO-8601 date-only string (`yyyy-MM-dd`) from its local Y/M/D. */
-declare function toIsoDate(value: Date | null | undefined): string;
-/** Parse ISO string or Date — returns null for invalid values. */
-declare function parseDateInput(value: string | Date | null | undefined): Date | null;
-/** Calendar date from react-day-picker — interpret Y/M/D in app timezone, not browser local. */
-declare function calendarDateToTZDate(date: Date, timezone: string): TZDate;
-declare function isValidHhmm(value: string): boolean;
-/** Normalize loose input ("9:30") to canonical 24h "09:30". */
-declare function normalizeHhmm(value: string): string | null;
-/** Map canonical HH:mm to a TZDate on today's calendar date in the given timezone. */
-declare function hhmmToTZDate(hhmm: string, timezone: string): TZDate | null;
-
-export { type DatetimeContext, calendarDateToTZDate, disableLiveRelativeFormatting, enableLiveRelativeFormatting, getDatetimeContext, hhmmToTZDate, isValidHhmm, normalizeHhmm, parseDateInput, resetDatetimeContextForTests, syncDatetimeContext, toIsoDate };
+export { syncDatetimeContext, getDatetimeContext, enableLiveRelativeFormatting, disableLiveRelativeFormatting, resetDatetimeContextForTests, type DatetimeContext, } from "./sync";
+export { parseDateInput, toIsoDate, calendarDateToTZDate, isValidHhmm, normalizeHhmm, hhmmToTZDate, } from "./parse";
+export { formatCalendarDate, formatAppDate, formatAppDateTime, formatAppTime, formatAppDateLong, formatAppRelative, formatTimeOfDay, type FormatDatetimeOptions, } from "./format";
+export { formatDate, isFormatDateValue, type FormatDateOptions } from "./format-date";
+export { detectFormatDateKind, isDateOnlyString, type FormatDateKind } from "./detect";

package/dist/lib/datetime/index.js

@@ -1 +1,50 @@
-export { calendarDateToTZDate, detectFormatDateKind, disableLiveRelativeFormatting, enableLiveRelativeFormatting, formatAppDate, formatAppDateLong, formatAppDateTime, formatAppRelative, formatAppTime, formatCalendarDate, formatDate, formatTimeOfDay, getDatetimeContext, hhmmToTZDate, isDateOnlyString, isFormatDateValue, isValidHhmm, normalizeHhmm, parseDateInput, resetDatetimeContextForTests, syncDatetimeContext, toIsoDate } from '../../chunk-5732TWQF.js';
+import {
+  syncDatetimeContext,
+  getDatetimeContext,
+  enableLiveRelativeFormatting,
+  disableLiveRelativeFormatting,
+  resetDatetimeContextForTests
+} from "./sync";
+import {
+  parseDateInput,
+  toIsoDate,
+  calendarDateToTZDate,
+  isValidHhmm,
+  normalizeHhmm,
+  hhmmToTZDate
+} from "./parse";
+import {
+  formatCalendarDate,
+  formatAppDate,
+  formatAppDateTime,
+  formatAppTime,
+  formatAppDateLong,
+  formatAppRelative,
+  formatTimeOfDay
+} from "./format";
+import { formatDate, isFormatDateValue } from "./format-date";
+import { detectFormatDateKind, isDateOnlyString } from "./detect";
+export {
+  calendarDateToTZDate,
+  detectFormatDateKind,
+  disableLiveRelativeFormatting,
+  enableLiveRelativeFormatting,
+  formatAppDate,
+  formatAppDateLong,
+  formatAppDateTime,
+  formatAppRelative,
+  formatAppTime,
+  formatCalendarDate,
+  formatDate,
+  formatTimeOfDay,
+  getDatetimeContext,
+  hhmmToTZDate,
+  isDateOnlyString,
+  isFormatDateValue,
+  isValidHhmm,
+  normalizeHhmm,
+  parseDateInput,
+  resetDatetimeContextForTests,
+  syncDatetimeContext,
+  toIsoDate
+};

package/dist/lib/datetime/parse.d.ts

@@ -0,0 +1,12 @@
+import { TZDate } from "@date-fns/tz";
+/** Format a calendar Date to an ISO-8601 date-only string (`yyyy-MM-dd`) from its local Y/M/D. */
+export declare function toIsoDate(value: Date | null | undefined): string;
+/** Parse ISO string or Date — returns null for invalid values. */
+export declare function parseDateInput(value: string | Date | null | undefined): Date | null;
+/** Calendar date from react-day-picker — interpret Y/M/D in app timezone, not browser local. */
+export declare function calendarDateToTZDate(date: Date, timezone: string): TZDate;
+export declare function isValidHhmm(value: string): boolean;
+/** Normalize loose input ("9:30") to canonical 24h "09:30". */
+export declare function normalizeHhmm(value: string): string | null;
+/** Map canonical HH:mm to a TZDate on today's calendar date in the given timezone. */
+export declare function hhmmToTZDate(hhmm: string, timezone: string): TZDate | null;

package/dist/lib/datetime/parse.js

@@ -0,0 +1,56 @@
+import { TZDate } from "@date-fns/tz";
+import { parseISO } from "date-fns";
+import { isDateOnlyString } from "./detect";
+function toIsoDate(value) {
+  if (value == null || Number.isNaN(value.getTime())) return "";
+  const year = String(value.getFullYear()).padStart(4, "0");
+  const month = String(value.getMonth() + 1).padStart(2, "0");
+  const day = String(value.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function parseDateInput(value) {
+  if (value == null) return null;
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value;
+  const trimmed = value.trim();
+  if (isDateOnlyString(trimmed)) {
+    const [year, month, day] = trimmed.split("-").map(Number);
+    return new Date(year, month - 1, day);
+  }
+  const parsed = parseISO(trimmed);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function calendarDateToTZDate(date, timezone) {
+  return new TZDate(date.getFullYear(), date.getMonth(), date.getDate(), timezone);
+}
+const HHMM_RE = /^([01]?\d|2[0-3]):([0-5]\d)$/;
+function isValidHhmm(value) {
+  return HHMM_RE.test(value.trim());
+}
+function normalizeHhmm(value) {
+  const trimmed = value.trim();
+  if (isValidHhmm(trimmed)) {
+    const [h, m] = trimmed.split(":");
+    return `${h.padStart(2, "0")}:${m}`;
+  }
+  const loose = /^(\d{1,2}):(\d{2})$/.exec(trimmed);
+  if (!loose) return null;
+  const hours = Number(loose[1]);
+  const minutes = Number(loose[2]);
+  if (hours > 23 || minutes > 59) return null;
+  return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}`;
+}
+function hhmmToTZDate(hhmm, timezone) {
+  const normalized = normalizeHhmm(hhmm);
+  if (!normalized) return null;
+  const [h, m] = normalized.split(":").map(Number);
+  const today = TZDate.tz(timezone);
+  return new TZDate(today.getFullYear(), today.getMonth(), today.getDate(), h, m, 0, 0, timezone);
+}
+export {
+  calendarDateToTZDate,
+  hhmmToTZDate,
+  isValidHhmm,
+  normalizeHhmm,
+  parseDateInput,
+  toIsoDate
+};

package/dist/lib/datetime/sync.d.ts

@@ -0,0 +1,19 @@
+import type { Locale } from "date-fns";
+import type { AppLocale, AppTimeFormat, AppDateFormat } from "../../app/types";
+export type DatetimeContext = {
+    locale: AppLocale;
+    dateFnsLocale: Locale;
+    timezone: string;
+    timeFormat: AppTimeFormat;
+    dateFormat: AppDateFormat;
+};
+/** Sync module-level datetime prefs from AppProvider (mirrors syncI18nLocale). */
+export declare function syncDatetimeContext(partial: Pick<DatetimeContext, "locale" | "timezone" | "timeFormat" | "dateFormat"> & {
+    dateFnsLocale?: Locale;
+}): void;
+export declare function getDatetimeContext(): Readonly<DatetimeContext>;
+export declare function enableLiveRelativeFormatting(): void;
+export declare function disableLiveRelativeFormatting(): void;
+export declare function canUseLiveRelativeFormatting(): boolean;
+/** Vitest only — reset to defaults between cases. */
+export declare function resetDatetimeContextForTests(): void;

package/dist/lib/datetime/sync.js

@@ -0,0 +1,45 @@
+import { getDateFnsLocale } from "../../app/locales";
+import { resolveDefaultDateFormat } from "../../app/date-format-labels";
+const DEFAULT_LOCALE = "vi";
+const defaultContext = () => ({
+  locale: DEFAULT_LOCALE,
+  dateFnsLocale: getDateFnsLocale(DEFAULT_LOCALE),
+  timezone: "Asia/Ho_Chi_Minh",
+  timeFormat: "24h",
+  dateFormat: resolveDefaultDateFormat(DEFAULT_LOCALE)
+});
+let syncedContext = defaultContext();
+let liveRelativeFormattingEnabled = true;
+function syncDatetimeContext(partial) {
+  syncedContext = {
+    locale: partial.locale,
+    timezone: partial.timezone,
+    timeFormat: partial.timeFormat,
+    dateFormat: partial.dateFormat,
+    dateFnsLocale: partial.dateFnsLocale ?? getDateFnsLocale(partial.locale)
+  };
+}
+function getDatetimeContext() {
+  return syncedContext;
+}
+function enableLiveRelativeFormatting() {
+  liveRelativeFormattingEnabled = true;
+}
+function disableLiveRelativeFormatting() {
+  liveRelativeFormattingEnabled = false;
+}
+function canUseLiveRelativeFormatting() {
+  return liveRelativeFormattingEnabled;
+}
+function resetDatetimeContextForTests() {
+  syncedContext = defaultContext();
+  liveRelativeFormattingEnabled = true;
+}
+export {
+  canUseLiveRelativeFormatting,
+  disableLiveRelativeFormatting,
+  enableLiveRelativeFormatting,
+  getDatetimeContext,
+  resetDatetimeContextForTests,
+  syncDatetimeContext
+};

package/dist/lib/format.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Bytes → size with conventional binary units (B/KB/MB/GB) and a locale-correct number,
+ * e.g. "2.0 KB" (en) / "2,0 KB" (vi). The numeric part is formatted via `Intl.NumberFormat`
+ * (locale decimal/grouping separators — no hardcoded "."); an optional `locale` overrides the
+ * module-synced active locale.
+ */
+export declare function formatBytes(n: number | null | undefined, locale?: string): string;
+/**
+ * ISO 4217 minor units → locale-formatted currency, e.g. (1995, "USD") → "$19.95" (en) /
+ * "19,95 $" (vi). The active locale (or an explicit `locale`) drives grouping/symbol placement;
+ * the currency's minor-unit scale comes from CLDR via `resolvedOptions().maximumFractionDigits`
+ * — no hand-maintained zero-decimal list.
+ */
+export declare function formatCurrency(amountMinor: number | null | undefined, currency: string, locale?: string): string;
+/** UUIDv7 / UUIDv4 → first 8 chars + ellipsis. Pair with a Tooltip showing full. */
+export declare function shortId(id: string | null | undefined): string;
+/** Translate any backend error into something a user can act on. Falls back
+ * to a generic message for non-Error objects (avoids dumping stack traces). */
+export declare function humanError(err: unknown): string;
+export { formatDate, isFormatDateValue, formatCalendarDate, formatAppDate, formatAppDateTime, formatAppTime, formatAppDateLong, formatAppRelative, formatTimeOfDay, parseDateInput, normalizeHhmm, isValidHhmm, detectFormatDateKind, } from "./datetime";
+export type { FormatDateOptions, FormatDatetimeOptions, FormatDateKind } from "./datetime";

package/dist/{chunk-X6AJ5HEI.js → lib/format.js}

@@ -1,6 +1,4 @@
-import { getSyncedLocale, translateCurrent } from './chunk-5732TWQF.js';
-
-// src/lib/format.ts
+import { getSyncedLocale, translateCurrent } from "../i18n/translate";
 function formatBytes(n, locale = getSyncedLocale()) {
   if (n == null) return "\u2014";
   const num = (digits, scaled) => new Intl.NumberFormat(locale, {
@@ -33,5 +31,37 @@ function humanError(err) {
   }
   return translateCurrent("feedback.genericError");
 }
-
-export { formatBytes, formatCurrency, humanError, shortId };
+import {
+  formatDate,
+  isFormatDateValue,
+  formatCalendarDate,
+  formatAppDate,
+  formatAppDateTime,
+  formatAppTime,
+  formatAppDateLong,
+  formatAppRelative,
+  formatTimeOfDay,
+  parseDateInput,
+  normalizeHhmm,
+  isValidHhmm,
+  detectFormatDateKind
+} from "./datetime";
+export {
+  detectFormatDateKind,
+  formatAppDate,
+  formatAppDateLong,
+  formatAppDateTime,
+  formatAppRelative,
+  formatAppTime,
+  formatBytes,
+  formatCalendarDate,
+  formatCurrency,
+  formatDate,
+  formatTimeOfDay,
+  humanError,
+  isFormatDateValue,
+  isValidHhmm,
+  normalizeHhmm,
+  parseDateInput,
+  shortId
+};

package/dist/lib/hooks.d.ts

@@ -5,13 +5,11 @@
  * setState runs only inside setTimeout (async) — compliant with
  * react-hooks/set-state-in-effect.
  */
-declare function useDebouncedValue<T>(value: T, delay?: number): T;
+export declare function useDebouncedValue<T>(value: T, delay?: number): T;
 /**
  * Returns true while `ms` haven't elapsed since `signal` last flipped truthy.
  * setState is scheduled asynchronously (setTimeout 0 / ms) — Rules of React safe.
  */
-declare function useTimeoutFlag(signal: unknown, ms?: number): boolean;
-declare function useMediaQuery(query: string): boolean;
-declare function useIsMobile(): boolean;
-
-export { useDebouncedValue, useIsMobile, useMediaQuery, useTimeoutFlag };
+export declare function useTimeoutFlag(signal: unknown, ms?: number): boolean;
+export declare function useMediaQuery(query: string): boolean;
+export declare function useIsMobile(): boolean;

package/dist/lib/hooks.js

@@ -1 +1,70 @@
-export { useDebouncedValue, useIsMobile, useMediaQuery, useTimeoutFlag } from '../chunk-LFW37FGG.js';
+import { useEffect, useState } from "react";
+function useDebouncedValue(value, delay = 250) {
+  const [debounced, setDebounced] = useState(value);
+  useEffect(() => {
+    const t = setTimeout(() => {
+      setDebounced(value);
+    }, delay);
+    return () => {
+      clearTimeout(t);
+    };
+  }, [value, delay]);
+  return debounced;
+}
+function useTimeoutFlag(signal, ms = 2e3) {
+  const [active, setActive] = useState(false);
+  useEffect(() => {
+    if (!signal) {
+      const id = window.setTimeout(() => {
+        setActive(false);
+      }, 0);
+      return () => {
+        clearTimeout(id);
+      };
+    }
+    const showId = window.setTimeout(() => {
+      setActive(true);
+    }, 0);
+    const hideId = window.setTimeout(() => {
+      setActive(false);
+    }, ms);
+    return () => {
+      clearTimeout(showId);
+      clearTimeout(hideId);
+    };
+  }, [signal, ms]);
+  return Boolean(signal) && active;
+}
+function useMediaQuery(query) {
+  const isBrowser = typeof window !== "undefined";
+  const getMatch = () => isBrowser ? window.matchMedia(query).matches : false;
+  const [matches, setMatches] = useState(getMatch());
+  useEffect(() => {
+    if (!isBrowser) return void 0;
+    const mediaQuery = window.matchMedia(query);
+    const updateMatch = () => {
+      setMatches(mediaQuery.matches);
+    };
+    updateMatch();
+    if (typeof mediaQuery.addEventListener === "function") {
+      mediaQuery.addEventListener("change", updateMatch);
+      return () => {
+        mediaQuery.removeEventListener("change", updateMatch);
+      };
+    }
+    mediaQuery.addListener(updateMatch);
+    return () => {
+      mediaQuery.removeListener(updateMatch);
+    };
+  }, [isBrowser, query]);
+  return matches;
+}
+function useIsMobile() {
+  return useMediaQuery("(max-width: 767px)");
+}
+export {
+  useDebouncedValue,
+  useIsMobile,
+  useMediaQuery,
+  useTimeoutFlag
+};

package/dist/lib/utils.d.ts

@@ -1,5 +1,2 @@
-import { ClassValue } from 'clsx';
-
-declare function cn(...inputs: ClassValue[]): string;
-
-export { cn };
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/lib/utils.js

@@ -1 +1,8 @@
-export { cn } from '../chunk-U7N2A7A3.js';
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+export {
+  cn
+};

package/dist/lib/variants.d.ts

@@ -0,0 +1,12 @@
+/** Prop → internal class maps. Apps use component props, never these classes directly. */
+import type { GapProp, PageContainerVariantProp, PageDensityProp } from "../props/vocabulary";
+export type Density = PageDensityProp;
+export type StackGap = GapProp;
+export type FlexGap = GapProp;
+export type InlineGap = Exclude<GapProp, "xl">;
+export type PageContainerVariant = PageContainerVariantProp;
+export declare const densityClass: Record<PageDensityProp, string>;
+export declare const pageContainerVariantClass: Record<PageContainerVariantProp, string | undefined>;
+export declare const stackGapClass: Record<GapProp, string>;
+export declare const inlineGapClass: Record<Exclude<GapProp, "xl">, string>;
+export declare const flexGapClass: Record<GapProp, string>;