basalt-ui 1.27.0 → 1.29.0

package/dist/format/date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../src/format/date.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAK5C,+FAA+F;AAC/F,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAYlD;AAED;yBACyB;AACzB,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAWpD;AAED,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG;IACxC;8FAC0F;IAC1F,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,uCAAuC;IACvC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,CAAA;AAED;;+EAE+E;AAC/E,wBAAgB,KAAK,CAAC,KAAK,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,MAAM,CAWvF;AAED,MAAM,MAAM,cAAc,GAAG,YAAY,GAAG;IAC1C,+EAA+E;IAC/E,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAA;CACrC,CAAA;AAED;;;yBAGyB;AACzB,wBAAgB,OAAO,CAAC,KAAK,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,EAAE,OAAO,GAAE,cAAmB,GAAG,MAAM,CAW3F;AAED,MAAM,MAAM,mBAAmB,GAAG,YAAY,GAAG;IAC/C,sFAAsF;IACtF,GAAG,CAAC,EAAE,MAAM,CAAA;CACb,CAAA;AAyBD;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,EAC7B,OAAO,GAAE,mBAAwB,GAChC,MAAM,CAUR;AAED,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,SAAS,CAAA;AAEhD,MAAM,MAAM,eAAe,GAAG;IAC5B,oDAAoD;IACpD,IAAI,CAAC,EAAE,YAAY,CAAA;CACpB,CAAA;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,MAAM,CAU7E;AAED;uFACuF;AACvF,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CASrD"}

package/dist/format/date.js

@@ -0,0 +1,106 @@
+import { dateFormat, NON_FINITE, toDate } from "./shared.js";
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+const SHORT_DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+function fmtAxisDate(value) {
+  if (typeof value === "number" && !Number.isFinite(value)) return NON_FINITE;
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) return NON_FINITE;
+    const dd = String(value.getDate()).padStart(2, "0");
+    const mm = String(value.getMonth() + 1).padStart(2, "0");
+    return `${dd}.${mm}`;
+  }
+  const s = String(value ?? "");
+  const match = s.match(/(\d{4})-(\d{2})-(\d{2})/);
+  if (match) return `${match[3]}.${match[2]}`;
+  return s;
+}
+function fmtTooltipDate(date) {
+  if (typeof date === "number" && !Number.isFinite(date)) return NON_FINITE;
+  if (date instanceof Date) {
+    if (Number.isNaN(date.getTime())) return NON_FINITE;
+    return `${SHORT_DAYS[date.getDay()]} ${MONTHS[date.getMonth()]} ${date.getDate()} ${date.getFullYear()}`;
+  }
+  const s = String(date ?? "");
+  const match = s.match(/(\d{4})-(\d{2})-(\d{2})/);
+  if (!match) return s;
+  const d = new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3]));
+  return `${SHORT_DAYS[d.getDay()]} ${MONTHS[d.getMonth()]} ${d.getDate()} ${d.getFullYear()}`;
+}
+function clock(value, options = {}) {
+  const date = toDate(value);
+  if (date === null) return NON_FINITE;
+  const { locale, timeZone, seconds = false } = options;
+  return dateFormat(locale, {
+    hour: "2-digit",
+    minute: "2-digit",
+    ...seconds && { second: "2-digit" },
+    hour12: false,
+    ...timeZone !== void 0 && { timeZone }
+  }).format(date);
+}
+function weekday(value, options = {}) {
+  const date = typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value) ? (() => {
+    const [y, m, d] = value.split("-").map(Number);
+    return new Date(y ?? 1970, (m ?? 1) - 1, d ?? 1);
+  })() : toDate(value);
+  if (date === null) return NON_FINITE;
+  const { locale, format = "short" } = options;
+  return dateFormat(locale, { weekday: format }).format(date);
+}
+const RELATIVE_TIME_UNITS = [
+  { unit: "year", ms: 31536e6 },
+  { unit: "month", ms: 2628e6 },
+  { unit: "week", ms: 6048e5 },
+  { unit: "day", ms: 864e5 },
+  { unit: "hour", ms: 36e5 },
+  { unit: "minute", ms: 6e4 }
+];
+const relativeTimeFormatterCache = /* @__PURE__ */ new Map();
+function relativeTimeFormat(locale) {
+  const key = locale ?? "";
+  const cached = relativeTimeFormatterCache.get(key);
+  if (cached !== void 0) return cached;
+  const created = new Intl.RelativeTimeFormat(locale, { numeric: "auto" });
+  relativeTimeFormatterCache.set(key, created);
+  return created;
+}
+function relativeTime(value, options = {}) {
+  const { locale, now = Date.now() } = options;
+  const timestamp = value instanceof Date ? value.getTime() : typeof value === "number" ? value : Date.parse(value);
+  if (!Number.isFinite(timestamp)) return NON_FINITE;
+  const diffMs = timestamp - now;
+  const absMs = Math.abs(diffMs);
+  if (absMs < 6e4) return "just now";
+  const unit = RELATIVE_TIME_UNITS.find(({ ms }) => absMs >= ms) ?? RELATIVE_TIME_UNITS.at(-1);
+  return relativeTimeFormat(locale).format(Math.round(diffMs / unit.ms), unit.unit);
+}
+function duration(value, options = {}) {
+  if (!Number.isFinite(value)) return NON_FINITE;
+  const { unit = "seconds" } = options;
+  const totalSeconds = Math.max(0, Math.round(unit === "minutes" ? value * 60 : value));
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const totalMinutes = Math.round(totalSeconds / 60);
+  const h = Math.floor(totalMinutes / 60);
+  const m = totalMinutes % 60;
+  if (h === 0) return `${m}m`;
+  return `${h}h ${String(m).padStart(2, "0")}m`;
+}
+function durationClock(seconds) {
+  if (!Number.isFinite(seconds)) return NON_FINITE;
+  const total = Math.max(0, Math.round(seconds));
+  const h = Math.floor(total / 3600);
+  const m = Math.floor(total % 3600 / 60);
+  const s = total % 60;
+  const mm = String(m).padStart(2, "0");
+  const ss = String(s).padStart(2, "0");
+  return h > 0 ? `${h}:${mm}:${ss}` : `${mm}:${ss}`;
+}
+export {
+  clock,
+  duration,
+  durationClock,
+  fmtAxisDate,
+  fmtTooltipDate,
+  relativeTime,
+  weekday
+};

package/dist/format/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * `basalt-ui/format` — Mantine-free, React-free `Intl`-backed formatting. One implementation for
+ * numbers/percentages/money, dates/times/durations and the two measurement units argo needed
+ * (`km`/`kcal`) — replacing argo's `features/*\/{formatters,formulas,format}.ts` (~350 of 643
+ * lines across four duration spellings) and the chart layer's own `charts/utils/format.ts`, which
+ * now re-exports from here.
+ *
+ * Every formatter takes `(value, opts?)`; `locale` on every `opts` defaults to `undefined` —
+ * `Intl`'s own "use the runtime's locale". Every non-finite/unparseable input prints the same
+ * {@link NON_FINITE} em dash rather than `"NaN"` or throwing.
+ *
+ * @example
+ * import { money, percent, duration, weekday, relativeTime } from 'basalt-ui/format'
+ *
+ * money(1234, { currency: 'USD' })        // "$1,234"
+ * percent(0.42)                            // "42%"
+ * duration(3_723)                          // "1h 02m"
+ * weekday('2026-09-02')                    // "Wed"
+ * relativeTime(Date.now() - 3_600_000)     // "1 hour ago"
+ */
+export { compact, deltaPct, type DeltaPctOptions, fmtCompact, type FmtCompactOptions, fmtCurrency, type FmtCurrencyOptions, fmtInt, fmtPercent, type FmtPercentOptions, integer, type LocaleOption, money, NON_FINITE, percent, } from './number.js';
+export { clock, type ClockOptions, duration, durationClock, type DurationOptions, type DurationUnit, fmtAxisDate, fmtTooltipDate, relativeTime, type RelativeTimeOptions, weekday, type WeekdayOptions, } from './date.js';
+export { kcal, type KcalOptions, km, type KmOptions } from './measure.js';
+import { fmtCompact, fmtCurrency, fmtInt, fmtPercent } from './number.js';
+import { fmtAxisDate, fmtTooltipDate } from './date.js';
+/**
+ * Every shipped chart-facing formatter under one name, so a chart can be handed the whole set
+ * (`format={formatters.compact}`). Unchanged shape from `charts/utils/format.ts` — this is the
+ * SAME object, not a second one, so an existing `formatters.x` call site keeps working verbatim.
+ */
+export declare const formatters: {
+    readonly compact: typeof fmtCompact;
+    readonly percent: typeof fmtPercent;
+    readonly currency: typeof fmtCurrency;
+    readonly int: typeof fmtInt;
+    readonly axisDate: typeof fmtAxisDate;
+    readonly tooltipDate: typeof fmtTooltipDate;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/format/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/format/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EACL,OAAO,EACP,QAAQ,EACR,KAAK,eAAe,EACpB,UAAU,EACV,KAAK,iBAAiB,EACtB,WAAW,EACX,KAAK,kBAAkB,EACvB,MAAM,EACN,UAAU,EACV,KAAK,iBAAiB,EACtB,OAAO,EACP,KAAK,YAAY,EACjB,KAAK,EACL,UAAU,EACV,OAAO,GACR,MAAM,UAAU,CAAA;AACjB,OAAO,EACL,KAAK,EACL,KAAK,YAAY,EACjB,QAAQ,EACR,aAAa,EACb,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,WAAW,EACX,cAAc,EACd,YAAY,EACZ,KAAK,mBAAmB,EACxB,OAAO,EACP,KAAK,cAAc,GACpB,MAAM,QAAQ,CAAA;AACf,OAAO,EAAE,IAAI,EAAE,KAAK,WAAW,EAAE,EAAE,EAAE,KAAK,SAAS,EAAE,MAAM,WAAW,CAAA;AAEtE,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AACtE,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAEpD;;;;GAIG;AACH,eAAO,MAAM,UAAU;;;;;;;CAOb,CAAA"}

package/dist/format/index.js

@@ -0,0 +1,54 @@
+import {
+  compact,
+  deltaPct,
+  fmtCompact,
+  fmtCurrency,
+  fmtInt,
+  fmtPercent,
+  integer,
+  money,
+  NON_FINITE,
+  percent
+} from "./number.js";
+import {
+  clock,
+  duration,
+  durationClock,
+  fmtAxisDate,
+  fmtTooltipDate,
+  relativeTime,
+  weekday
+} from "./date.js";
+import { kcal, km } from "./measure.js";
+import { fmtCompact as fmtCompact2, fmtCurrency as fmtCurrency2, fmtInt as fmtInt2, fmtPercent as fmtPercent2 } from "./number.js";
+import { fmtAxisDate as fmtAxisDate2, fmtTooltipDate as fmtTooltipDate2 } from "./date.js";
+const formatters = {
+  compact: fmtCompact2,
+  percent: fmtPercent2,
+  currency: fmtCurrency2,
+  int: fmtInt2,
+  axisDate: fmtAxisDate2,
+  tooltipDate: fmtTooltipDate2
+};
+export {
+  NON_FINITE,
+  clock,
+  compact,
+  deltaPct,
+  duration,
+  durationClock,
+  fmtAxisDate,
+  fmtCompact,
+  fmtCurrency,
+  fmtInt,
+  fmtPercent,
+  fmtTooltipDate,
+  formatters,
+  integer,
+  kcal,
+  km,
+  money,
+  percent,
+  relativeTime,
+  weekday
+};

package/dist/format/measure.d.ts

@@ -0,0 +1,15 @@
+export type KmOptions = {
+    /** Fraction digits. Default 2 (`"5.30 km"`). */
+    digits?: number;
+};
+/** Meters as kilometers — `"5.30 km"`. A non-finite value prints {@link NON_FINITE}. */
+export declare function km(meters: number, options?: KmOptions): string;
+export type KcalOptions = {
+    /** Fraction digits once compacted to `k cal`. Default 2. Below 1000 kcal always rounds to a
+     * whole number, matching the seed (`formatKcal`). */
+    digits?: number;
+};
+/** Kilocalories, compacting to `"k cal"` above 1000 — `"842 kcal"`, `"1.24 k cal"`. A non-finite
+ * value prints {@link NON_FINITE}. */
+export declare function kcal(value: number, options?: KcalOptions): string;
+//# sourceMappingURL=measure.d.ts.map

package/dist/format/measure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"measure.d.ts","sourceRoot":"","sources":["../../src/format/measure.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,SAAS,GAAG;IACtB,gDAAgD;IAChD,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,wFAAwF;AACxF,wBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,SAAc,GAAG,MAAM,CAIlE;AAED,MAAM,MAAM,WAAW,GAAG;IACxB;yDACqD;IACrD,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED;sCACsC;AACtC,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,MAAM,CAKrE"}

package/dist/format/measure.js

@@ -0,0 +1,16 @@
+import { NON_FINITE } from "./shared.js";
+function km(meters, options = {}) {
+  if (!Number.isFinite(meters)) return NON_FINITE;
+  const { digits = 2 } = options;
+  return `${(meters / 1e3).toFixed(digits)} km`;
+}
+function kcal(value, options = {}) {
+  if (!Number.isFinite(value)) return NON_FINITE;
+  const { digits = 2 } = options;
+  if (value >= 1e3) return `${(value / 1e3).toFixed(digits)} k cal`;
+  return `${Math.round(value)} kcal`;
+}
+export {
+  kcal,
+  km
+};

package/dist/format/number.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Number formatting — `Intl.NumberFormat` with the arguments already decided, so a caller states
+ * WHAT a number is rather than how to punctuate it. Moved here from `src/charts/utils/format.ts`
+ * (C5 consolidation) — that file now re-exports from this module so charts keep working through
+ * one implementation.
+ *
+ * `money`/`percent`/`integer`/`compact`/`deltaPct` are the argo-facing names (seeded from
+ * `features/*\/{formatters,formulas}.ts`); `fmtCurrency`/`fmtPercent`/`fmtInt`/`fmtCompact` are the
+ * original chart-formatter names, kept for source compatibility and delegated to by the new names.
+ */
+import { NON_FINITE } from './shared.js';
+import type { LocaleOption } from './shared.js';
+export type { LocaleOption };
+export { NON_FINITE };
+export type FmtCompactOptions = LocaleOption & {
+    /** Significant-ish fraction digits on the compacted number. Default 1 (`1.2k`, `3.4M`). */
+    digits?: number;
+};
+/**
+ * Compact notation: `1.2k`, `3.4M`, `-820`. The axis formatter for any count whose range spans
+ * more than three digits. A non-finite value prints {@link NON_FINITE}.
+ *
+ * Note `Intl`'s compact notation is LOCALE text, not a suffix table: `en` gives `1.2K`, and this
+ * lowercases the `K` to match the package's own numeral style while leaving every other locale's
+ * word (`1,2 Mio.`) untouched.
+ */
+export declare function fmtCompact(value: number, options?: FmtCompactOptions): string;
+/** `compact` — the `basalt-ui/format` name for {@link fmtCompact}. */
+export declare const compact: typeof fmtCompact;
+export type FmtPercentOptions = LocaleOption & {
+    /** Fraction digits. Default 0 (`42%`). */
+    digits?: number;
+    /**
+     * What the incoming number MEANS. `'ratio'` (default) is `0.42 → 42%`; `'percent'` is
+     * `42 → 42%`. Required as an explicit option rather than guessed from magnitude.
+     */
+    input?: 'ratio' | 'percent';
+};
+/** Percentages, from either a ratio or an already-scaled percentage. A non-finite value prints
+ * {@link NON_FINITE}. */
+export declare function fmtPercent(value: number, options?: FmtPercentOptions): string;
+/** `percent` — the `basalt-ui/format` name for {@link fmtPercent}. */
+export declare const percent: typeof fmtPercent;
+export type DeltaPctOptions = FmtPercentOptions;
+/**
+ * A signed percentage delta: `+4%`, `-12%`, `0%` — argo's `walking-pad/formatters.ts#formatPct`
+ * (a `+`-prefixed ratio) generalized onto `Intl`'s own `signDisplay: 'exceptZero'`, which adds the
+ * `+`/`-` sign the same way `Intl`'s own minus sign already does, and adds nothing for zero. A
+ * non-finite value prints {@link NON_FINITE}.
+ */
+export declare function deltaPct(value: number, options?: DeltaPctOptions): string;
+export type FmtCurrencyOptions = LocaleOption & {
+    /** ISO 4217 code — required. There is no default currency. */
+    currency: string;
+    /** Compact notation for the amount (`$1.2k`). Default false. */
+    compact?: boolean;
+    /** Fraction digits. Default 0 compacted, else the currency's own default (`undefined`). */
+    digits?: number;
+};
+/** Money. `fmtCurrency(1234, { currency: 'USD' })` → `$1,234`. A non-finite amount prints
+ * {@link NON_FINITE}. */
+export declare function fmtCurrency(value: number, options: FmtCurrencyOptions): string;
+/** `money` — the `basalt-ui/format` name for {@link fmtCurrency}. */
+export declare const money: typeof fmtCurrency;
+/** Grouped integer: `12,480`. Rounds. A non-finite value prints {@link NON_FINITE}. */
+export declare function fmtInt(value: number, options?: LocaleOption): string;
+/** `integer` — the `basalt-ui/format` name for {@link fmtInt}. */
+export declare const integer: typeof fmtInt;
+//# sourceMappingURL=number.d.ts.map

package/dist/format/number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../src/format/number.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,UAAU,EAAgB,MAAM,UAAU,CAAA;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAE5C,YAAY,EAAE,YAAY,EAAE,CAAA;AAC5B,OAAO,EAAE,UAAU,EAAE,CAAA;AAMrB,MAAM,MAAM,iBAAiB,GAAG,YAAY,GAAG;IAC7C,2FAA2F;IAC3F,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB,GAAG,MAAM,CAUjF;AAED,sEAAsE;AACtE,eAAO,MAAM,OAAO,mBAAa,CAAA;AAEjC,MAAM,MAAM,iBAAiB,GAAG,YAAY,GAAG;IAC7C,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAC5B,CAAA;AAED;yBACyB;AACzB,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB,GAAG,MAAM,CAQjF;AAED,sEAAsE;AACtE,eAAO,MAAM,OAAO,mBAAa,CAAA;AAEjC,MAAM,MAAM,eAAe,GAAG,iBAAiB,CAAA;AAE/C;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,MAAM,CAS7E;AAED,MAAM,MAAM,kBAAkB,GAAG,YAAY,GAAG;IAC9C,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAA;IAChB,gEAAgE;IAChE,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,2FAA2F;IAC3F,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED;yBACyB;AACzB,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,GAAG,MAAM,CAa9E;AAED,qEAAqE;AACrE,eAAO,MAAM,KAAK,oBAAc,CAAA;AAEhC,uFAAuF;AACvF,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,MAAM,CAGxE;AAED,kEAAkE;AAClE,eAAO,MAAM,OAAO,eAAS,CAAA"}

package/dist/format/number.js

@@ -0,0 +1,62 @@
+import { NON_FINITE, numberFormat } from "./shared.js";
+const COMPACT_K = /(\d\s?)K/;
+function fmtCompact(value, options = {}) {
+  if (!Number.isFinite(value)) return NON_FINITE;
+  const { digits = 1, locale } = options;
+  return numberFormat(locale, {
+    notation: "compact",
+    compactDisplay: "short",
+    maximumFractionDigits: digits
+  }).format(value).replace(COMPACT_K, "$1k");
+}
+const compact = fmtCompact;
+function fmtPercent(value, options = {}) {
+  if (!Number.isFinite(value)) return NON_FINITE;
+  const { digits = 0, input = "ratio", locale } = options;
+  return numberFormat(locale, {
+    style: "percent",
+    minimumFractionDigits: digits,
+    maximumFractionDigits: digits
+  }).format(input === "percent" ? value / 100 : value);
+}
+const percent = fmtPercent;
+function deltaPct(value, options = {}) {
+  if (!Number.isFinite(value)) return NON_FINITE;
+  const { digits = 0, input = "ratio", locale } = options;
+  return numberFormat(locale, {
+    style: "percent",
+    signDisplay: "exceptZero",
+    minimumFractionDigits: digits,
+    maximumFractionDigits: digits
+  }).format(input === "percent" ? value / 100 : value);
+}
+function fmtCurrency(value, options) {
+  if (!Number.isFinite(value)) return NON_FINITE;
+  const { currency, compact: isCompact = false, digits, locale } = options;
+  const fractionDigits = digits ?? (isCompact ? 1 : 0);
+  return numberFormat(locale, {
+    style: "currency",
+    currency,
+    ...isCompact && { notation: "compact", compactDisplay: "short" },
+    minimumFractionDigits: isCompact ? 0 : fractionDigits,
+    maximumFractionDigits: fractionDigits
+  }).format(value).replace(COMPACT_K, "$1k");
+}
+const money = fmtCurrency;
+function fmtInt(value, options = {}) {
+  if (!Number.isFinite(value)) return NON_FINITE;
+  return numberFormat(options.locale, { maximumFractionDigits: 0 }).format(value);
+}
+const integer = fmtInt;
+export {
+  NON_FINITE,
+  compact,
+  deltaPct,
+  fmtCompact,
+  fmtCurrency,
+  fmtInt,
+  fmtPercent,
+  integer,
+  money,
+  percent
+};

package/dist/format/shared.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared low-level pieces of `basalt-ui/format` — the em-dash sentinel and the memoized
+ * `Intl.NumberFormat` cache every number formatter in this module reuses. Moved here (out of
+ * `src/charts/utils/format.ts`, C5 consolidation) so the subpath is the single implementation and
+ * `charts/utils/format.ts` becomes a thin re-export (`docs/CHARTS-SPEC.md` still calls it home for
+ * chart callers, but the code lives here now).
+ */
+/**
+ * What EVERY formatter in this module prints for input it cannot represent — `NaN`, `±Infinity`,
+ * an `Invalid Date`. An em dash (U+2014). A formatter may say it does not know; it may not print a
+ * number that is not one.
+ */
+export declare const NON_FINITE = "\u2014";
+/** Options every number formatter here accepts. */
+export type LocaleOption = {
+    /** BCP-47 tag. Default `undefined` — the runtime's own locale. */
+    locale?: string;
+};
+export declare function numberFormat(locale: string | undefined, options: Intl.NumberFormatOptions): Intl.NumberFormat;
+export declare function dateFormat(locale: string | undefined, options: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;
+/** Coerces the flexible `Date | number | string` inputs this module's date formatters accept into
+ * a `Date`. A `number` is treated as epoch milliseconds (matching `Date`'s own constructor and
+ * `agent-chat/relative-time.ts`'s prior contract) — a caller with epoch seconds multiplies by
+ * 1000 first. Returns `null` for a non-finite/unparseable input so every caller can share one
+ * {@link NON_FINITE} guard instead of re-deriving one. */
+export declare function toDate(value: Date | number | string): Date | null;
+//# sourceMappingURL=shared.d.ts.map

package/dist/format/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/format/shared.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;GAIG;AACH,eAAO,MAAM,UAAU,WAAM,CAAA;AAE7B,mDAAmD;AACnD,MAAM,MAAM,YAAY,GAAG;IACzB,kEAAkE;IAClE,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AASD,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,EAAE,IAAI,CAAC,mBAAmB,GAChC,IAAI,CAAC,YAAY,CAOnB;AAID,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,EAAE,IAAI,CAAC,qBAAqB,GAClC,IAAI,CAAC,cAAc,CAOrB;AAED;;;;0DAI0D;AAC1D,wBAAgB,MAAM,CAAC,KAAK,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,IAAI,CAGjE"}

package/dist/format/shared.js

@@ -0,0 +1,29 @@
+const NON_FINITE = "\u2014";
+const formatterCache = /* @__PURE__ */ new Map();
+function numberFormat(locale, options) {
+  const key = `${locale ?? ""}|${JSON.stringify(options)}`;
+  const cached = formatterCache.get(key);
+  if (cached !== void 0) return cached;
+  const created = new Intl.NumberFormat(locale, options);
+  formatterCache.set(key, created);
+  return created;
+}
+const dateFormatterCache = /* @__PURE__ */ new Map();
+function dateFormat(locale, options) {
+  const key = `${locale ?? ""}|${JSON.stringify(options)}`;
+  const cached = dateFormatterCache.get(key);
+  if (cached !== void 0) return cached;
+  const created = new Intl.DateTimeFormat(locale, options);
+  dateFormatterCache.set(key, created);
+  return created;
+}
+function toDate(value) {
+  const date = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+export {
+  NON_FINITE,
+  dateFormat,
+  numberFormat,
+  toDate
+};

package/dist/forms/FormErrorSummary.d.ts

@@ -1,6 +1,7 @@
 import type { UseFormReturnType } from '@mantine/form';
+import type { BasaltProps } from '../common/props.js';
 /** Props for FormErrorSummary. */
-export type FormErrorSummaryProps<Values extends Record<string, unknown>> = {
+export type FormErrorSummaryProps<Values extends Record<string, unknown>> = BasaltProps & {
     form: UseFormReturnType<Values>;
     /** Accessible heading shown above the error list. Defaults to "Please fix the following errors". */
     title?: string;
@@ -20,10 +21,10 @@ export type FormErrorSummaryProps<Values extends Record<string, unknown>> = {
  *   return (
  *     <form onSubmit={form.onSubmit(console.log)}>
  *       <FormErrorSummary form={form} title="Fix these before submitting" />
- *       <TextInput {...field(form, 'email')} label="Email" />
+ *       <TextInput key={fieldKey(form, 'email')} {...inputProps(form, 'email')} label="Email" />
  *     </form>
  *   )
  * }
  */
-export declare function FormErrorSummary<Values extends Record<string, unknown>>({ form, title, }: FormErrorSummaryProps<Values>): import("react").JSX.Element | null;
+export declare function FormErrorSummary<Values extends Record<string, unknown>>(props: FormErrorSummaryProps<Values>): import("react").JSX.Element | null;
 //# sourceMappingURL=FormErrorSummary.d.ts.map

package/dist/forms/FormErrorSummary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FormErrorSummary.d.ts","sourceRoot":"","sources":["../../src/forms/FormErrorSummary.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAKtD,kCAAkC;AAClC,MAAM,MAAM,qBAAqB,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI;IAC1E,IAAI,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAA;IAC/B,oGAAoG;IACpG,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EACvE,IAAI,EACJ,KAAyC,GAC1C,EAAE,qBAAqB,CAAC,MAAM,CAAC,sCAuB/B"}
+{"version":3,"file":"FormErrorSummary.d.ts","sourceRoot":"","sources":["../../src/forms/FormErrorSummary.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAMlD,kCAAkC;AAClC,MAAM,MAAM,qBAAqB,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,WAAW,GAAG;IACxF,IAAI,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAA;IAC/B,oGAAoG;IACpG,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACrE,KAAK,EAAE,qBAAqB,CAAC,MAAM,CAAC,sCA8BrC"}

package/dist/forms/FormErrorSummary.js

@@ -1,10 +1,10 @@
 import { jsx } from "react/jsx-runtime";
 import { Alert, List, Text } from "@mantine/core";
+import { assertRequiredProps } from "../common/validate.js";
 import { alpha, VX } from "../tokens/index.js";
-function FormErrorSummary({
-  form,
-  title = "Please fix the following errors"
-}) {
+function FormErrorSummary(props) {
+  assertRequiredProps("FormErrorSummary", props, ["form"]);
+  const { form, title = "Please fix the following errors", className, style } = props;
   const errorEntries = Object.entries(form.errors);
   if (errorEntries.length === 0) return null;
   return /* @__PURE__ */ jsx(
@@ -12,6 +12,8 @@ function FormErrorSummary({
     {
       role: "alert",
       title: /* @__PURE__ */ jsx(Text, { fw: 600, children: title }),
+      ...className !== void 0 && { className },
+      ...style !== void 0 && { style },
       styles: {
         root: {
           backgroundColor: alpha(VX.status.bad, 0.13),

package/dist/forms/create-form.d.ts

@@ -17,14 +17,14 @@ export type UseBasaltFormOptions<Values extends Record<string, unknown>> = Omit<
  *
  * @example
  * import * as v from 'valibot'
- * import { useBasaltForm, field } from 'basalt-ui/forms'
+ * import { useBasaltForm, inputProps, fieldKey } from 'basalt-ui/forms'
  *
  * const Schema = v.object({ name: v.pipe(v.string(), v.minLength(2)), email: v.string() })
  * type Values = v.InferOutput<typeof Schema>
  *
  * function MyForm() {
  *   const form = useBasaltForm({ initialValues: { name: '', email: '' }, schema: Schema })
- *   return <TextInput {...field(form, 'name')} label="Name" />
+ *   return <TextInput key={fieldKey(form, 'name')} {...inputProps(form, 'name')} label="Name" />
  * }
  */
 export declare function useBasaltForm<Values extends Record<string, unknown>>(opts: UseBasaltFormOptions<Values>): UseFormReturnType<Values>;

package/dist/forms/field.d.ts

@@ -1,22 +1,46 @@
 /**
- * ./forms — field: DX helper for Mantine v9 uncontrolled fields.
+ * ./forms — inputProps + fieldKey: the two-call idiom every Mantine v9 uncontrolled field needs.
  * Mantine-coupled. Optional peer: @mantine/form.
+ *
+ * **`key` is NOT in `inputProps`' return, and that is the whole point of this file's shape.**
+ * It used to be — one object holding `getInputProps(path)` and `form.key(path)` together, so a
+ * single spread covered both. React 19 logs
+ * `A props object containing a "key" prop is being spread into JSX` on every such render: a spread
+ * `key` is read as the element key but the warning says it is deprecated, and three fields meant
+ * three warnings per page. The bundle was basalt's own invention; Mantine's documented idiom is
+ * `key={form.key(path)} {...form.getInputProps(path)}`, and this is that idiom with basalt's names.
+ *
+ * The `@deprecated` `field` alias that used to live here is removed (1.29.0, C1 consolidation) —
+ * `basalt-ui/forms`' `field` collided in name with the `field` store builder on `basalt-ui/state`,
+ * which was the whole reason for the rename in the first place. Write
+ * `key={fieldKey(form, path)} {...inputProps(form, path)}`.
  */
 import type { LooseKeys, UseFormReturnType } from '@mantine/form';
 /**
- * Bundles the two props every Mantine v9 uncontrolled field needs — `getInputProps` spread
- * plus the reconciler `key` — into a single object. Eliminates the two-call boilerplate at
- * every field site.
+ * The spread half: `form.getInputProps(path)`, and nothing else.
+ *
+ * Pair it with {@link fieldKey} — an uncontrolled field renders from a `defaultValue`, so without
+ * the reconciler key React reuses the DOM node and `form.reset()` / `setValues()` / a removed list
+ * row leave the old text on screen.
  *
  * @example
- * import { useBasaltForm, field } from 'basalt-ui/forms'
+ * import { useBasaltForm, inputProps, fieldKey } from 'basalt-ui/forms'
  *
  * function MyForm() {
  *   const form = useBasaltForm({ initialValues: { email: '' } })
- *   return <TextInput {...field(form, 'email')} label="Email" />
+ *   return <TextInput key={fieldKey(form, 'email')} {...inputProps(form, 'email')} label="Email" />
  * }
  */
-export declare function field<Values extends Record<string, unknown>, Path extends LooseKeys<Values>>(form: UseFormReturnType<Values>, path: Path): ReturnType<UseFormReturnType<Values>['getInputProps']> & {
-    key: string;
-};
+export declare function inputProps<Values extends Record<string, unknown>, Path extends LooseKeys<Values>>(form: UseFormReturnType<Values>, path: Path): ReturnType<UseFormReturnType<Values>['getInputProps']>;
+/**
+ * The key half: `form.key(path)`, as a JSX `key` attribute — never spread.
+ *
+ * A separate call rather than a second member of {@link inputProps}' object, because an object
+ * carrying `key` cannot be spread without React 19 warning about it. Two calls on one line is the
+ * cost; a clean console and a reconciler that actually resets its inputs is what it buys.
+ *
+ * @example
+ * <TextInput key={fieldKey(form, 'email')} {...inputProps(form, 'email')} />
+ */
+export declare function fieldKey<Values extends Record<string, unknown>, Path extends LooseKeys<Values>>(form: UseFormReturnType<Values>, path: Path): string;
 //# sourceMappingURL=field.d.ts.map

package/dist/forms/field.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"field.d.ts","sourceRoot":"","sources":["../../src/forms/field.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAIjE;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,SAAS,SAAS,CAAC,MAAM,CAAC,EAC1F,IAAI,EAAE,iBAAiB,CAAC,MAAM,CAAC,EAC/B,IAAI,EAAE,IAAI,GACT,UAAU,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,eAAe,CAAC,CAAC,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAK1E"}
+{"version":3,"file":"field.d.ts","sourceRoot":"","sources":["../../src/forms/field.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAIjE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,SAAS,SAAS,CAAC,MAAM,CAAC,EAC/F,IAAI,EAAE,iBAAiB,CAAC,MAAM,CAAC,EAC/B,IAAI,EAAE,IAAI,GACT,UAAU,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,eAAe,CAAC,CAAC,CAExD;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,SAAS,SAAS,CAAC,MAAM,CAAC,EAC7F,IAAI,EAAE,iBAAiB,CAAC,MAAM,CAAC,EAC/B,IAAI,EAAE,IAAI,GACT,MAAM,CAER"}

package/dist/forms/field.js

@@ -1,9 +1,10 @@
-function field(form, path) {
-  return {
-    ...form.getInputProps(path),
-    key: form.key(path)
-  };
+function inputProps(form, path) {
+  return form.getInputProps(path);
+}
+function fieldKey(form, path) {
+  return form.key(path);
 }
 export {
-  field
+  fieldKey,
+  inputProps
 };