@eifi1/ui-kit 0.11.0 → 0.13.0

package/dist/lib/format.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Number, money, percentage, date and relative-time formatting — `Intl`, in one place,
+ * for the figures an app prints OUTSIDE a kit component.
+ *
+ * Each app grew its own: kastlan's `utils/formatters.ts` (a Swiss-pinned
+ * `formatNumber`/`formatCurrency`, a date-fns `formatDate`, and a `formatRelativeTime`
+ * whose "5m ago" / "3h ago" / "2d ago" stayed English in every language), its tenancy
+ * `format.ts` (`formatChf`, a `formatPct` gluing a "+" onto `toFixed(2)`), keksdose's
+ * own set. Every one of them is `Intl` with a locale bolted on, so the only thing
+ * worth sharing is the locale — and the kit already has one, the provider's.
+ *
+ * The plain functions take a `locale` (none: the runtime default, as every `Intl` API
+ * reads `undefined`). Inside a component, {@link useKitFormat} hands back the same
+ * functions bound to the `<UiKitProvider locale>`, so a page formats exactly like the
+ * kit components on it.
+ *
+ * A missing value — `null`, `undefined`, `NaN`, an unparseable date — formats as
+ * `empty` (default "—", the dash `StatTile` shows for no value), never as "NaN" or
+ * "Invalid Date".
+ */
+/** What every formatter here prints for a missing value, unless told otherwise. */
+declare const EMPTY_FORMATTED_VALUE = "\u2014";
+/** Fraction digits: a number pins both the minimum and the maximum (`2` → "3.10");
+ *  an object sets them apart (a meter reading, 1–3). */
+type FormatDigits = number | {
+    min?: number;
+    max?: number;
+};
+interface BaseOptions {
+    /** BCP 47 tag. Left out: the runtime default (the hook: the provider's). */
+    locale?: string;
+    /** Printed for a missing value. Default {@link EMPTY_FORMATTED_VALUE}. */
+    empty?: string;
+}
+/** The options every number formatter shares (money and percent carry their own unit). */
+interface FormatNumberBaseOptions extends BaseOptions {
+    digits?: FormatDigits;
+    /** Compact notation: 12 400 → "12K". */
+    compact?: boolean;
+    /** `"exceptZero"` for a change ("+3", "−3", "0"). Default: the minus only. */
+    signDisplay?: Intl.NumberFormatOptions["signDisplay"];
+    /** Any further `Intl.NumberFormat` options, merged over the ones above. */
+    options?: Intl.NumberFormatOptions;
+}
+/** The options {@link formatNumber} takes: the shared ones plus a free-text `unit`. */
+interface FormatNumberOptions extends FormatNumberBaseOptions {
+    /**
+     * A unit printed after the figure, joined by a narrow no-break space (U+202F):
+     * "3.400 N", "12 kg", "4,5 m²". lenkbank (P8) prints forces, masses and lengths in
+     * every table and summary, and each call site glued `${n} N` together with a plain
+     * space — which wraps the "N" onto the next line in a narrow column and reads loose
+     * beside the digit grouping. The narrow no-break space is the SI brochure's and the
+     * Swiss typesetting rule's separator between value and unit, and it never breaks.
+     *
+     * Free text, not `Intl`'s `style: "unit"`: that one only knows the ECMA-402
+     * sanctioned units (no "N", no "kN", no "m³/h"), so an app would still be gluing.
+     * A missing value prints `empty` ALONE — "— N" says there is a newton-shaped
+     * nothing, which is noise in a column that already heads its unit.
+     */
+    unit?: string;
+}
+interface FormatMoneyOptions extends FormatNumberBaseOptions {
+    /** `"symbol"` (default), `"narrowSymbol"`, `"code"` ("CHF 12.00") or `"name"`. */
+    currencyDisplay?: Intl.NumberFormatOptions["currencyDisplay"];
+}
+interface FormatPercentOptions extends FormatNumberBaseOptions {
+    /**
+     * `true` (default): `value` is a RATIO, as `Intl` and `StatTile`'s percent delta read
+     * it — `0.12` is 12 %. `false`: it is already a percentage — `12` is 12 %
+     * (kastlan's rent `change_pct`).
+     */
+    ratio?: boolean;
+}
+/** A number in `locale`: "1,234.5", "1.234,5", "1’234.5" — with `unit`, "3.400 N". */
+declare function formatNumber(value: number | null | undefined, options?: FormatNumberOptions): string;
+/** An amount of `currency` (ISO 4217) in `locale`: "CHF 1’234.50", "1.234,50 €". */
+declare function formatMoney(value: number | null | undefined, currency: string, options?: FormatMoneyOptions): string;
+/** A percentage in `locale` ("12%", "12 %", "+1.25%"). See {@link FormatPercentOptions.ratio}
+ *  for what `value` means. Default digits: at most one. */
+declare function formatPercent(value: number | null | undefined, options?: FormatPercentOptions): string;
+/**
+ * The shapes a date is printed in, each a set of `Intl.DateTimeFormat` options:
+ *  - `short` / `medium` / `long` / `full` — the date alone, at that `dateStyle`
+ *    ("08/07/2026", "8 Jul 2026", "8 July 2026", "Wednesday, 8 July 2026" in en-GB).
+ *  - `dateTime` — medium date and short time: a timestamp ("8 Jul 2026, 14:05").
+ *  - `time` — the short time alone ("14:05").
+ *  - `monthYear` — "July 2026".
+ *
+ * Or pass `Intl.DateTimeFormatOptions` for anything else. A date-fns PATTERN
+ * ("dd.MM.yyyy") is deliberately not accepted: a pattern is one locale's order baked
+ * into a string, which is how an English page ends up with German dates.
+ */
+type FormatDateStyle = "short" | "medium" | "long" | "full" | "dateTime" | "time" | "monthYear";
+interface FormatDateOptions extends BaseOptions {
+    /** An IANA zone ("Europe/Zurich") for a timestamp. Left out: the device's. */
+    timeZone?: string;
+}
+/** What {@link formatDate} and {@link formatRelativeTime} accept. */
+type DateInput = string | number | Date | null | undefined;
+/**
+ * `value` as a Date, or null. A bare "YYYY-MM-DD" is a CALENDAR day and is read on the
+ * local calendar (`parseIsoDate`) — `new Date("2026-07-08")` is UTC midnight, which is
+ * the 7th anywhere west of Greenwich. Anything else (a full ISO timestamp, epoch
+ * milliseconds, a Date) is an instant and goes through `Date` as is.
+ */
+declare function toDate(value: DateInput): Date | null;
+/**
+ * A date or timestamp in `locale`. Takes an ISO date ("2026-07-08", read on the local
+ * calendar), an ISO timestamp ("2026-07-08T14:05:00Z"), epoch milliseconds or a Date.
+ * `style` defaults to `medium`; see {@link FormatDateStyle}.
+ *
+ * `formatIsoDate` (`@eifi1/ui-kit/dates`) remains for a plain "YYYY-MM-DD" with an
+ * explicit locale; this is its superset for timestamps and the named styles.
+ */
+declare function formatDate(value: DateInput, style?: FormatDateStyle | Intl.DateTimeFormatOptions, options?: FormatDateOptions): string;
+interface FormatRelativeTimeOptions extends BaseOptions {
+    /** The moment it is measured from. Default: now. */
+    now?: DateInput;
+    /** `"auto"` (default): "yesterday", "now", "next week". `"always"`: "1 day ago". */
+    numeric?: Intl.RelativeTimeFormatNumeric;
+    /** `"long"` (default) "3 hours ago", `"short"` "3 hr. ago", `"narrow"` "3h ago". */
+    style?: Intl.RelativeTimeFormatStyle;
+    /**
+     * Past this many days either way, print the date instead ({@link formatDate} in
+     * `absoluteStyle`) — kastlan's feed switches to the date after a week, because "5
+     * weeks ago" makes a reader do sums. Default: never.
+     */
+    absoluteAfterDays?: number;
+    /** The style of that date. Default `medium`. */
+    absoluteStyle?: FormatDateStyle | Intl.DateTimeFormatOptions;
+}
+/**
+ * How long ago (or until) `value` is, in `locale`'s words, through
+ * `Intl.RelativeTimeFormat`: "3 hours ago", "vor 3 Stunden", "il y a 3 heures",
+ * "in 2 days", and under 45 seconds "now". The unit is picked by size — seconds,
+ * minutes, hours, days, weeks, months, years — and the count is rounded.
+ */
+declare function formatRelativeTime(value: DateInput, options?: FormatRelativeTimeOptions): string;
+type WithoutLocale<T> = Omit<T, "locale"> & {
+    locale?: string;
+};
+/** What {@link useKitFormat} returns: the formatters above with the provider's locale
+ *  as their default (an explicit `locale` in the options still wins). */
+interface KitFormat {
+    /** The locale they format in — the provider's, or `undefined` (runtime default). */
+    locale: string | undefined;
+    formatNumber: (value: number | null | undefined, options?: WithoutLocale<FormatNumberOptions>) => string;
+    formatMoney: (value: number | null | undefined, currency: string, options?: WithoutLocale<FormatMoneyOptions>) => string;
+    formatPercent: (value: number | null | undefined, options?: WithoutLocale<FormatPercentOptions>) => string;
+    formatDate: (value: DateInput, style?: FormatDateStyle | Intl.DateTimeFormatOptions, options?: WithoutLocale<FormatDateOptions>) => string;
+    formatRelativeTime: (value: DateInput, options?: WithoutLocale<FormatRelativeTimeOptions>) => string;
+}
+/**
+ * The formatters, bound to the `<UiKitProvider locale>` (or to `locale`, which wins
+ * over it — the same precedence as a component's `locale` prop):
+ *
+ *     const { formatMoney, formatRelativeTime } = useKitFormat();
+ *     formatMoney(row.balance, "CHF");
+ */
+declare function useKitFormat(locale?: string): KitFormat;
+
+export { type DateInput, EMPTY_FORMATTED_VALUE, type FormatDateOptions, type FormatDateStyle, type FormatDigits, type FormatMoneyOptions, type FormatNumberBaseOptions, type FormatNumberOptions, type FormatPercentOptions, type FormatRelativeTimeOptions, type KitFormat, formatDate, formatMoney, formatNumber, formatPercent, formatRelativeTime, toDate, useKitFormat };

package/dist/lib/format.js

@@ -0,0 +1,151 @@
+"use client";
+import { useMemo } from "react";
+import { useKitLocale } from "../i18n/kit-labels.js";
+import { parseIsoDate } from "./dates.js";
+const EMPTY_FORMATTED_VALUE = "\u2014";
+const UNIT_SEPARATOR = "\u202F";
+const numberFormatters = /* @__PURE__ */ new Map();
+function numberFormatter(locale, options) {
+  const key = `${locale ?? ""}|${JSON.stringify(options)}`;
+  let f = numberFormatters.get(key);
+  if (!f) {
+    f = new Intl.NumberFormat(locale, options);
+    numberFormatters.set(key, f);
+  }
+  return f;
+}
+function digitOptions(digits) {
+  if (digits === void 0) return {};
+  if (typeof digits === "number") return { minimumFractionDigits: digits, maximumFractionDigits: digits };
+  return {
+    ...digits.min !== void 0 ? { minimumFractionDigits: digits.min } : null,
+    ...digits.max !== void 0 ? { maximumFractionDigits: digits.max } : null
+  };
+}
+function numberOptions(o) {
+  return {
+    ...digitOptions(o.digits),
+    ...o.compact ? { notation: "compact" } : null,
+    ...o.signDisplay ? { signDisplay: o.signDisplay } : null,
+    ...o.options
+  };
+}
+function isMissing(value) {
+  return value === null || value === void 0 || Number.isNaN(value);
+}
+function formatNumber(value, options = {}) {
+  if (isMissing(value)) return options.empty ?? EMPTY_FORMATTED_VALUE;
+  const figure = numberFormatter(options.locale, numberOptions(options)).format(value);
+  return options.unit ? `${figure}${UNIT_SEPARATOR}${options.unit}` : figure;
+}
+function formatMoney(value, currency, options = {}) {
+  if (isMissing(value)) return options.empty ?? EMPTY_FORMATTED_VALUE;
+  return numberFormatter(options.locale, {
+    style: "currency",
+    currency,
+    ...options.currencyDisplay ? { currencyDisplay: options.currencyDisplay } : null,
+    ...numberOptions(options)
+  }).format(value);
+}
+function formatPercent(value, options = {}) {
+  if (isMissing(value)) return options.empty ?? EMPTY_FORMATTED_VALUE;
+  const ratio = options.ratio === false ? value / 100 : value;
+  return numberFormatter(options.locale, {
+    style: "percent",
+    ...options.digits === void 0 ? { maximumFractionDigits: 1 } : null,
+    ...numberOptions(options)
+  }).format(ratio);
+}
+const DATE_STYLES = {
+  short: { dateStyle: "short" },
+  medium: { dateStyle: "medium" },
+  long: { dateStyle: "long" },
+  full: { dateStyle: "full" },
+  dateTime: { dateStyle: "medium", timeStyle: "short" },
+  time: { timeStyle: "short" },
+  monthYear: { month: "long", year: "numeric" }
+};
+function toDate(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  if (typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value)) return parseIsoDate(value);
+  const d = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+const dateFormatters = /* @__PURE__ */ new Map();
+function dateFormatter(locale, options) {
+  const key = `${locale ?? ""}|${JSON.stringify(options)}`;
+  let f = dateFormatters.get(key);
+  if (!f) {
+    f = new Intl.DateTimeFormat(locale, options);
+    dateFormatters.set(key, f);
+  }
+  return f;
+}
+function formatDate(value, style = "medium", options = {}) {
+  const d = toDate(value);
+  if (!d) return options.empty ?? EMPTY_FORMATTED_VALUE;
+  const base = typeof style === "string" ? DATE_STYLES[style] : style;
+  return dateFormatter(options.locale, options.timeZone ? { ...base, timeZone: options.timeZone } : base).format(d);
+}
+const SECOND = 1e3;
+const MINUTE = 60 * SECOND;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+const RELATIVE_STEPS = [
+  [45 * SECOND, "second", SECOND],
+  [45 * MINUTE, "minute", MINUTE],
+  [22 * HOUR, "hour", HOUR],
+  [6.5 * DAY, "day", DAY],
+  [26 * DAY, "week", 7 * DAY],
+  [320 * DAY, "month", 30.44 * DAY],
+  [Infinity, "year", 365.25 * DAY]
+];
+const relativeFormatters = /* @__PURE__ */ new Map();
+function relativeFormatter(locale, numeric, style) {
+  const key = `${locale ?? ""}|${numeric}|${style}`;
+  let f = relativeFormatters.get(key);
+  if (!f) {
+    f = new Intl.RelativeTimeFormat(locale, { numeric, style });
+    relativeFormatters.set(key, f);
+  }
+  return f;
+}
+function formatRelativeTime(value, options = {}) {
+  const d = toDate(value);
+  if (!d) return options.empty ?? EMPTY_FORMATTED_VALUE;
+  const now = toDate(options.now ?? /* @__PURE__ */ new Date()) ?? /* @__PURE__ */ new Date();
+  const diff = d.getTime() - now.getTime();
+  const abs = Math.abs(diff);
+  if (options.absoluteAfterDays !== void 0 && abs > options.absoluteAfterDays * DAY) {
+    return formatDate(d, options.absoluteStyle ?? "medium", options);
+  }
+  const rtf = relativeFormatter(options.locale, options.numeric ?? "auto", options.style ?? "long");
+  const [, unit, size] = RELATIVE_STEPS.find(([limit]) => abs < limit);
+  const count = unit === "second" ? 0 : Math.round(diff / size);
+  return rtf.format(count + 0, unit);
+}
+function useKitFormat(locale) {
+  const kitLocale = useKitLocale(locale);
+  return useMemo(
+    () => ({
+      locale: kitLocale,
+      formatNumber: (value, options) => formatNumber(value, { locale: kitLocale, ...options }),
+      formatMoney: (value, currency, options) => formatMoney(value, currency, { locale: kitLocale, ...options }),
+      formatPercent: (value, options) => formatPercent(value, { locale: kitLocale, ...options }),
+      formatDate: (value, style, options) => formatDate(value, style, { locale: kitLocale, ...options }),
+      formatRelativeTime: (value, options) => formatRelativeTime(value, { locale: kitLocale, ...options })
+    }),
+    [kitLocale]
+  );
+}
+export {
+  EMPTY_FORMATTED_VALUE,
+  formatDate,
+  formatMoney,
+  formatNumber,
+  formatPercent,
+  formatRelativeTime,
+  toDate,
+  useKitFormat
+};
+//# sourceMappingURL=format.js.map

package/dist/lib/format.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/format.ts"],"sourcesContent":["import { useMemo } from \"react\";\nimport { useKitLocale } from \"../i18n/kit-labels\";\nimport { parseIsoDate } from \"./dates\";\n\n/**\n * Number, money, percentage, date and relative-time formatting — `Intl`, in one place,\n * for the figures an app prints OUTSIDE a kit component.\n *\n * Each app grew its own: kastlan's `utils/formatters.ts` (a Swiss-pinned\n * `formatNumber`/`formatCurrency`, a date-fns `formatDate`, and a `formatRelativeTime`\n * whose \"5m ago\" / \"3h ago\" / \"2d ago\" stayed English in every language), its tenancy\n * `format.ts` (`formatChf`, a `formatPct` gluing a \"+\" onto `toFixed(2)`), keksdose's\n * own set. Every one of them is `Intl` with a locale bolted on, so the only thing\n * worth sharing is the locale — and the kit already has one, the provider's.\n *\n * The plain functions take a `locale` (none: the runtime default, as every `Intl` API\n * reads `undefined`). Inside a component, {@link useKitFormat} hands back the same\n * functions bound to the `<UiKitProvider locale>`, so a page formats exactly like the\n * kit components on it.\n *\n * A missing value — `null`, `undefined`, `NaN`, an unparseable date — formats as\n * `empty` (default \"—\", the dash `StatTile` shows for no value), never as \"NaN\" or\n * \"Invalid Date\".\n */\n\n/** What every formatter here prints for a missing value, unless told otherwise. */\nexport const EMPTY_FORMATTED_VALUE = \"—\";\n\n/** Fraction digits: a number pins both the minimum and the maximum (`2` → \"3.10\");\n *  an object sets them apart (a meter reading, 1–3). */\nexport type FormatDigits = number | { min?: number; max?: number };\n\ninterface BaseOptions {\n  /** BCP 47 tag. Left out: the runtime default (the hook: the provider's). */\n  locale?: string;\n  /** Printed for a missing value. Default {@link EMPTY_FORMATTED_VALUE}. */\n  empty?: string;\n}\n\n/** The options every number formatter shares (money and percent carry their own unit). */\nexport interface FormatNumberBaseOptions extends BaseOptions {\n  digits?: FormatDigits;\n  /** Compact notation: 12 400 → \"12K\". */\n  compact?: boolean;\n  /** `\"exceptZero\"` for a change (\"+3\", \"−3\", \"0\"). Default: the minus only. */\n  signDisplay?: Intl.NumberFormatOptions[\"signDisplay\"];\n  /** Any further `Intl.NumberFormat` options, merged over the ones above. */\n  options?: Intl.NumberFormatOptions;\n}\n\n/** The options {@link formatNumber} takes: the shared ones plus a free-text `unit`. */\nexport interface FormatNumberOptions extends FormatNumberBaseOptions {\n  /**\n   * A unit printed after the figure, joined by a narrow no-break space (U+202F):\n   * \"3.400 N\", \"12 kg\", \"4,5 m²\". lenkbank (P8) prints forces, masses and lengths in\n   * every table and summary, and each call site glued `${n} N` together with a plain\n   * space — which wraps the \"N\" onto the next line in a narrow column and reads loose\n   * beside the digit grouping. The narrow no-break space is the SI brochure's and the\n   * Swiss typesetting rule's separator between value and unit, and it never breaks.\n   *\n   * Free text, not `Intl`'s `style: \"unit\"`: that one only knows the ECMA-402\n   * sanctioned units (no \"N\", no \"kN\", no \"m³/h\"), so an app would still be gluing.\n   * A missing value prints `empty` ALONE — \"— N\" says there is a newton-shaped\n   * nothing, which is noise in a column that already heads its unit.\n   */\n  unit?: string;\n}\n\n/** Narrow no-break space (U+202F): between a figure and its {@link FormatNumberOptions.unit}. */\nconst UNIT_SEPARATOR = \"\\u202F\";\n\nexport interface FormatMoneyOptions extends FormatNumberBaseOptions {\n  /** `\"symbol\"` (default), `\"narrowSymbol\"`, `\"code\"` (\"CHF 12.00\") or `\"name\"`. */\n  currencyDisplay?: Intl.NumberFormatOptions[\"currencyDisplay\"];\n}\n\nexport interface FormatPercentOptions extends FormatNumberBaseOptions {\n  /**\n   * `true` (default): `value` is a RATIO, as `Intl` and `StatTile`'s percent delta read\n   * it — `0.12` is 12 %. `false`: it is already a percentage — `12` is 12 %\n   * (kastlan's rent `change_pct`).\n   */\n  ratio?: boolean;\n}\n\n// One formatter per option set: a table formats the same way thousands of times, and\n// constructing an Intl formatter is the expensive part.\nconst numberFormatters = new Map<string, Intl.NumberFormat>();\nfunction numberFormatter(locale: string | undefined, options: Intl.NumberFormatOptions): Intl.NumberFormat {\n  const key = `${locale ?? \"\"}|${JSON.stringify(options)}`;\n  let f = numberFormatters.get(key);\n  if (!f) {\n    f = new Intl.NumberFormat(locale, options);\n    numberFormatters.set(key, f);\n  }\n  return f;\n}\n\nfunction digitOptions(digits: FormatDigits | undefined): Intl.NumberFormatOptions {\n  if (digits === undefined) return {};\n  if (typeof digits === \"number\") return { minimumFractionDigits: digits, maximumFractionDigits: digits };\n  return {\n    ...(digits.min !== undefined ? { minimumFractionDigits: digits.min } : null),\n    ...(digits.max !== undefined ? { maximumFractionDigits: digits.max } : null),\n  };\n}\n\nfunction numberOptions(o: FormatNumberBaseOptions): Intl.NumberFormatOptions {\n  return {\n    ...digitOptions(o.digits),\n    ...(o.compact ? { notation: \"compact\" } : null),\n    ...(o.signDisplay ? { signDisplay: o.signDisplay } : null),\n    ...o.options,\n  };\n}\n\nfunction isMissing(value: number | null | undefined): value is null | undefined {\n  return value === null || value === undefined || Number.isNaN(value);\n}\n\n/** A number in `locale`: \"1,234.5\", \"1.234,5\", \"1’234.5\" — with `unit`, \"3.400 N\". */\nexport function formatNumber(value: number | null | undefined, options: FormatNumberOptions = {}): string {\n  if (isMissing(value)) return options.empty ?? EMPTY_FORMATTED_VALUE;\n  const figure = numberFormatter(options.locale, numberOptions(options)).format(value);\n  return options.unit ? `${figure}${UNIT_SEPARATOR}${options.unit}` : figure;\n}\n\n/** An amount of `currency` (ISO 4217) in `locale`: \"CHF 1’234.50\", \"1.234,50 €\". */\nexport function formatMoney(\n  value: number | null | undefined,\n  currency: string,\n  options: FormatMoneyOptions = {},\n): string {\n  if (isMissing(value)) return options.empty ?? EMPTY_FORMATTED_VALUE;\n  return numberFormatter(options.locale, {\n    style: \"currency\",\n    currency,\n    ...(options.currencyDisplay ? { currencyDisplay: options.currencyDisplay } : null),\n    ...numberOptions(options),\n  }).format(value);\n}\n\n/** A percentage in `locale` (\"12%\", \"12 %\", \"+1.25%\"). See {@link FormatPercentOptions.ratio}\n *  for what `value` means. Default digits: at most one. */\nexport function formatPercent(value: number | null | undefined, options: FormatPercentOptions = {}): string {\n  if (isMissing(value)) return options.empty ?? EMPTY_FORMATTED_VALUE;\n  const ratio = options.ratio === false ? value / 100 : value;\n  return numberFormatter(options.locale, {\n    style: \"percent\",\n    ...(options.digits === undefined ? { maximumFractionDigits: 1 } : null),\n    ...numberOptions(options),\n  }).format(ratio);\n}\n\n/* ── Dates ─────────────────────────────────────────────────────────────────── */\n\n/**\n * The shapes a date is printed in, each a set of `Intl.DateTimeFormat` options:\n *  - `short` / `medium` / `long` / `full` — the date alone, at that `dateStyle`\n *    (\"08/07/2026\", \"8 Jul 2026\", \"8 July 2026\", \"Wednesday, 8 July 2026\" in en-GB).\n *  - `dateTime` — medium date and short time: a timestamp (\"8 Jul 2026, 14:05\").\n *  - `time` — the short time alone (\"14:05\").\n *  - `monthYear` — \"July 2026\".\n *\n * Or pass `Intl.DateTimeFormatOptions` for anything else. A date-fns PATTERN\n * (\"dd.MM.yyyy\") is deliberately not accepted: a pattern is one locale's order baked\n * into a string, which is how an English page ends up with German dates.\n */\nexport type FormatDateStyle = \"short\" | \"medium\" | \"long\" | \"full\" | \"dateTime\" | \"time\" | \"monthYear\";\n\nconst DATE_STYLES: Record<FormatDateStyle, Intl.DateTimeFormatOptions> = {\n  short: { dateStyle: \"short\" },\n  medium: { dateStyle: \"medium\" },\n  long: { dateStyle: \"long\" },\n  full: { dateStyle: \"full\" },\n  dateTime: { dateStyle: \"medium\", timeStyle: \"short\" },\n  time: { timeStyle: \"short\" },\n  monthYear: { month: \"long\", year: \"numeric\" },\n};\n\nexport interface FormatDateOptions extends BaseOptions {\n  /** An IANA zone (\"Europe/Zurich\") for a timestamp. Left out: the device's. */\n  timeZone?: string;\n}\n\n/** What {@link formatDate} and {@link formatRelativeTime} accept. */\nexport type DateInput = string | number | Date | null | undefined;\n\n/**\n * `value` as a Date, or null. A bare \"YYYY-MM-DD\" is a CALENDAR day and is read on the\n * local calendar (`parseIsoDate`) — `new Date(\"2026-07-08\")` is UTC midnight, which is\n * the 7th anywhere west of Greenwich. Anything else (a full ISO timestamp, epoch\n * milliseconds, a Date) is an instant and goes through `Date` as is.\n */\nexport function toDate(value: DateInput): Date | null {\n  if (value === null || value === undefined || value === \"\") return null;\n  if (typeof value === \"string\" && /^\\d{4}-\\d{2}-\\d{2}$/.test(value)) return parseIsoDate(value);\n  const d = value instanceof Date ? value : new Date(value);\n  return Number.isNaN(d.getTime()) ? null : d;\n}\n\nconst dateFormatters = new Map<string, Intl.DateTimeFormat>();\nfunction dateFormatter(locale: string | undefined, options: Intl.DateTimeFormatOptions): Intl.DateTimeFormat {\n  const key = `${locale ?? \"\"}|${JSON.stringify(options)}`;\n  let f = dateFormatters.get(key);\n  if (!f) {\n    f = new Intl.DateTimeFormat(locale, options);\n    dateFormatters.set(key, f);\n  }\n  return f;\n}\n\n/**\n * A date or timestamp in `locale`. Takes an ISO date (\"2026-07-08\", read on the local\n * calendar), an ISO timestamp (\"2026-07-08T14:05:00Z\"), epoch milliseconds or a Date.\n * `style` defaults to `medium`; see {@link FormatDateStyle}.\n *\n * `formatIsoDate` (`@eifi1/ui-kit/dates`) remains for a plain \"YYYY-MM-DD\" with an\n * explicit locale; this is its superset for timestamps and the named styles.\n */\nexport function formatDate(\n  value: DateInput,\n  style: FormatDateStyle | Intl.DateTimeFormatOptions = \"medium\",\n  options: FormatDateOptions = {},\n): string {\n  const d = toDate(value);\n  if (!d) return options.empty ?? EMPTY_FORMATTED_VALUE;\n  const base = typeof style === \"string\" ? DATE_STYLES[style] : style;\n  return dateFormatter(options.locale, options.timeZone ? { ...base, timeZone: options.timeZone } : base).format(d);\n}\n\nexport interface FormatRelativeTimeOptions extends BaseOptions {\n  /** The moment it is measured from. Default: now. */\n  now?: DateInput;\n  /** `\"auto\"` (default): \"yesterday\", \"now\", \"next week\". `\"always\"`: \"1 day ago\". */\n  numeric?: Intl.RelativeTimeFormatNumeric;\n  /** `\"long\"` (default) \"3 hours ago\", `\"short\"` \"3 hr. ago\", `\"narrow\"` \"3h ago\". */\n  style?: Intl.RelativeTimeFormatStyle;\n  /**\n   * Past this many days either way, print the date instead ({@link formatDate} in\n   * `absoluteStyle`) — kastlan's feed switches to the date after a week, because \"5\n   * weeks ago\" makes a reader do sums. Default: never.\n   */\n  absoluteAfterDays?: number;\n  /** The style of that date. Default `medium`. */\n  absoluteStyle?: FormatDateStyle | Intl.DateTimeFormatOptions;\n}\n\nconst SECOND = 1000;\nconst MINUTE = 60 * SECOND;\nconst HOUR = 60 * MINUTE;\nconst DAY = 24 * HOUR;\n\n/** [the largest |difference| a unit is used for, the unit, its length]. */\nconst RELATIVE_STEPS: Array<[number, Intl.RelativeTimeFormatUnit, number]> = [\n  [45 * SECOND, \"second\", SECOND],\n  [45 * MINUTE, \"minute\", MINUTE],\n  [22 * HOUR, \"hour\", HOUR],\n  [6.5 * DAY, \"day\", DAY],\n  [26 * DAY, \"week\", 7 * DAY],\n  [320 * DAY, \"month\", 30.44 * DAY],\n  [Infinity, \"year\", 365.25 * DAY],\n];\n\nconst relativeFormatters = new Map<string, Intl.RelativeTimeFormat>();\nfunction relativeFormatter(\n  locale: string | undefined,\n  numeric: Intl.RelativeTimeFormatNumeric,\n  style: Intl.RelativeTimeFormatStyle,\n): Intl.RelativeTimeFormat {\n  const key = `${locale ?? \"\"}|${numeric}|${style}`;\n  let f = relativeFormatters.get(key);\n  if (!f) {\n    f = new Intl.RelativeTimeFormat(locale, { numeric, style });\n    relativeFormatters.set(key, f);\n  }\n  return f;\n}\n\n/**\n * How long ago (or until) `value` is, in `locale`'s words, through\n * `Intl.RelativeTimeFormat`: \"3 hours ago\", \"vor 3 Stunden\", \"il y a 3 heures\",\n * \"in 2 days\", and under 45 seconds \"now\". The unit is picked by size — seconds,\n * minutes, hours, days, weeks, months, years — and the count is rounded.\n */\nexport function formatRelativeTime(value: DateInput, options: FormatRelativeTimeOptions = {}): string {\n  const d = toDate(value);\n  if (!d) return options.empty ?? EMPTY_FORMATTED_VALUE;\n  const now = toDate(options.now ?? new Date()) ?? new Date();\n  const diff = d.getTime() - now.getTime();\n  const abs = Math.abs(diff);\n  if (options.absoluteAfterDays !== undefined && abs > options.absoluteAfterDays * DAY) {\n    return formatDate(d, options.absoluteStyle ?? \"medium\", options);\n  }\n  const rtf = relativeFormatter(options.locale, options.numeric ?? \"auto\", options.style ?? \"long\");\n  const [, unit, size] = RELATIVE_STEPS.find(([limit]) => abs < limit)!;\n  // Under 45 seconds is \"now\" rather than \"12 seconds ago\": a feed that ticks through\n  // the seconds is noise, and nothing reads a timestamp to the second.\n  const count = unit === \"second\" ? 0 : Math.round(diff / size);\n  // `+ 0` folds -0 into 0: `format(-0, …)` says \"0 seconds ago\" instead of \"now\".\n  return rtf.format(count + 0, unit);\n}\n\n/* ── Bound to the provider ─────────────────────────────────────────────────── */\n\ntype WithoutLocale<T> = Omit<T, \"locale\"> & { locale?: string };\n\n/** What {@link useKitFormat} returns: the formatters above with the provider's locale\n *  as their default (an explicit `locale` in the options still wins). */\nexport interface KitFormat {\n  /** The locale they format in — the provider's, or `undefined` (runtime default). */\n  locale: string | undefined;\n  formatNumber: (value: number | null | undefined, options?: WithoutLocale<FormatNumberOptions>) => string;\n  formatMoney: (\n    value: number | null | undefined,\n    currency: string,\n    options?: WithoutLocale<FormatMoneyOptions>,\n  ) => string;\n  formatPercent: (value: number | null | undefined, options?: WithoutLocale<FormatPercentOptions>) => string;\n  formatDate: (\n    value: DateInput,\n    style?: FormatDateStyle | Intl.DateTimeFormatOptions,\n    options?: WithoutLocale<FormatDateOptions>,\n  ) => string;\n  formatRelativeTime: (value: DateInput, options?: WithoutLocale<FormatRelativeTimeOptions>) => string;\n}\n\n/**\n * The formatters, bound to the `<UiKitProvider locale>` (or to `locale`, which wins\n * over it — the same precedence as a component's `locale` prop):\n *\n *     const { formatMoney, formatRelativeTime } = useKitFormat();\n *     formatMoney(row.balance, \"CHF\");\n */\nexport function useKitFormat(locale?: string): KitFormat {\n  const kitLocale = useKitLocale(locale);\n  return useMemo<KitFormat>(\n    () => ({\n      locale: kitLocale,\n      formatNumber: (value, options) => formatNumber(value, { locale: kitLocale, ...options }),\n      formatMoney: (value, currency, options) => formatMoney(value, currency, { locale: kitLocale, ...options }),\n      formatPercent: (value, options) => formatPercent(value, { locale: kitLocale, ...options }),\n      formatDate: (value, style, options) => formatDate(value, style, { locale: kitLocale, ...options }),\n      formatRelativeTime: (value, options) => formatRelativeTime(value, { locale: kitLocale, ...options }),\n    }),\n    [kitLocale],\n  );\n}\n"],"mappings":"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","names":[]}

package/dist/lib/qr-encode.d.ts

@@ -0,0 +1,44 @@
+/**
+ * A QR code encoder: text in, a square of dark / light modules out (ISO/IEC 18004).
+ *
+ * WHY IT IS IN THE KIT rather than a dependency. `TwoFactorSetting` needs one QR code —
+ * an `otpauth://` URI, around 100–200 bytes — and every app that shows it was pulling
+ * in `qrcode.react` plus `react-dom/server` to render that one code to a static SVG
+ * string, then base64-encoding it so the kit could draw it back as an `<img>`.
+ * A dependency here would land in all three apps whether they show 2FA or not; an
+ * optional peer would mean a lazy import and a loading state for something that is
+ * a few hundred lines of arithmetic. So it is those lines: pure, no imports, no module
+ * state beyond two constant tables, safe under `sideEffects: false`, and
+ * tree-shaken out of every app that never renders a {@link QrCode}.
+ *
+ * Scope, chosen for what the kit renders: BYTE mode only (UTF-8), all 40 versions,
+ * all four error-correction levels, automatic version and mask selection. Numeric,
+ * alphanumeric and Kanji modes are denser for their alphabets but would not shrink an
+ * otpauth URI (lower-case letters are not in the alphanumeric set). The algorithm and
+ * its penalty rules follow the reference implementation by Project Nayuki (MIT),
+ * which is also what `qrcode.react` wraps — so for the same input, level and boost
+ * the modules match that library's output exactly (the test suite pins a matrix).
+ */
+type QrErrorCorrection = "L" | "M" | "Q" | "H";
+interface QrEncodeOptions {
+    /** How much of the code may be damaged and still read. Default `"M"` (~15 %). */
+    errorCorrection?: QrErrorCorrection;
+    /** Raise the level as far as the chosen version still fits, for free. Default true. */
+    boostErrorCorrection?: boolean;
+}
+interface QrMatrix {
+    /** 1–40. */
+    version: number;
+    /** Modules per side: `version * 4 + 17`. */
+    size: number;
+    /** The level actually used — higher than asked when boosted. */
+    errorCorrection: QrErrorCorrection;
+    /** 0–7. */
+    mask: number;
+    /** `modules[y][x]`, true = dark. No quiet zone: the renderer adds its own. */
+    modules: boolean[][];
+}
+/** Encode `text` (as UTF-8 bytes). Throws a `RangeError` past version 40's capacity. */
+declare function encodeQr(text: string, options?: QrEncodeOptions): QrMatrix;
+
+export { type QrEncodeOptions, type QrErrorCorrection, type QrMatrix, encodeQr };