@cosmicdrift/kumiko-renderer 0.374.0 → 0.378.0

package/dist/headless/form/zod-bridge.js

@@ -0,0 +1,103 @@
+// Translates a ZodError into the same FieldIssue shape the server emits via
+// its own zod-bridge (packages/framework/src/errors/zod-bridge.ts). The two
+// bridges stay in sync on purpose: a field failing zod on the client reads
+// identically to the same field failing zod on the server, so the UI's
+// error-display path doesn't branch on provenance.
+//
+// Duplicated here (not imported) so ui-core remains free of
+// @cosmicdrift/kumiko-framework — this package has to bundle for browsers and Expo,
+// where a server-oriented framework dep would balloon bundle size and drag
+// in Node-only modules (postgres, drizzle, bullmq) even if only types are
+// consumed.
+//
+// Keep this list in sync with the server-side mirror — Zod version bumps
+// tend to introduce new param keys, and the server's classes.test.ts is
+// what catches them. A value added there should be added here too.
+const ISSUE_PARAM_KEYS = [
+    "minimum",
+    "maximum",
+    "expected",
+    "received",
+    "type",
+    "inclusive",
+    "exact",
+    "keys",
+    // Zod 4 additions
+    "format",
+    "divisor",
+    "values",
+    "pattern",
+];
+// Flat FieldIssue list — same shape as server-side ValidationError.fields.
+// The form-controller groups this by `path` for its snapshot's errors map.
+export function zodErrorToFieldIssues(error) {
+    return error.issues.map((issue) => {
+        const params = extractIssueParams(issue);
+        return {
+            // Empty-path issues (top-level object/array failures) use "(root)" so
+            // the form-controller has a stable key to show "form itself is
+            // malformed" errors under — matches what the server does.
+            path: issue.path.map(String).join(".") || "(root)",
+            code: issue.code,
+            i18nKey: resolveI18nKey(issue),
+            ...(params && { params }),
+        };
+    });
+}
+// The issues that count for validity: hidden fields never block, and a
+// scope narrows to the listed paths (an entry matches itself and everything
+// below it, not siblings — #1898). `includeRoot` keeps "(root)" refine issues
+// inside a scope (submit passes it, #1907). Shared by the controller's
+// validate() and RenderEdit's `valid` dry-run so the two cannot drift.
+export function relevantFieldIssues(issues, opts) {
+    const { hiddenFields, scope, includeRoot } = opts;
+    return issues.filter((issue) => {
+        const rootField = issue.path.split(".")[0] ?? "";
+        if (hiddenFields.has(rootField))
+            return false;
+        if (scope === undefined)
+            return true;
+        if (includeRoot === true && issue.path === "(root)")
+            return true;
+        return scope.some((entry) => issue.path === entry || issue.path.startsWith(`${entry}.`));
+    });
+}
+// Same magic key both sides of a superRefine can set to opt out of the
+// generic `errors.validation.custom` message — see form-schema.ts.
+export const I18N_KEY_PARAM = "i18nKey";
+// `code: "custom"` is zod's catch-all for every superRefine/refine check;
+// left mechanical it'd collapse onto one generic key, so a superRefine can
+// set `params[I18N_KEY_PARAM]` to override it. Keep in sync with the server
+// mirror (packages/framework/src/errors/zod-bridge.ts).
+function resolveI18nKey(issue) {
+    if (issue.code === "custom") {
+        const override = issue.params?.[I18N_KEY_PARAM];
+        if (typeof override === "string")
+            return override;
+    }
+    return `errors.validation.${issue.code}`;
+}
+function extractIssueParams(issue) {
+    const out = {};
+    const bag = issue; // @cast-boundary zod-issue
+    for (const key of ISSUE_PARAM_KEYS) {
+        if (bag[key] !== undefined)
+            out[key] = bag[key];
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+// Groups a flat FieldIssue list into the `errors` map carried by a
+// FormSnapshot. A field with multiple issues (e.g. both "required" and
+// "min") keeps both — UIs that only render the first can pick the first
+// element, those that want a full list have it.
+export function groupIssuesByPath(issues) {
+    const out = {};
+    for (const issue of issues) {
+        const bucket = out[issue.path];
+        if (bucket)
+            bucket.push(issue);
+        else
+            out[issue.path] = [issue];
+    }
+    return out;
+}

package/dist/headless/format/document-values.d.ts

@@ -0,0 +1,12 @@
+export declare const DOCUMENT_FALLBACK_CURRENCY = "EUR";
+export declare function formatDocumentMoney(value: unknown, tenantCurrency: string, locale: string): string;
+export type DocumentDateOptions = {
+    /** Append the time of day. Only instants and offset date-times carry one; a
+     *  date-only value prints just the date. */
+    readonly time?: boolean;
+    /** IANA zone an instant is shown in (default UTC). Offset date-times keep
+     *  their own wall clock. */
+    readonly timeZone?: string;
+};
+export declare function formatDocumentDate(value: unknown, locale: string, options?: DocumentDateOptions): string;
+export declare function formatDocumentPercent(value: unknown, locale: string): string;

package/dist/headless/format/document-values.js

@@ -0,0 +1,70 @@
+import { Temporal } from "@cosmicdrift/kumiko-types/temporal";
+import { formatMoney, resolveSafeMoneyLocale } from "./money.js";
+// Used when the tenant has no currency setting.
+export const DOCUMENT_FALLBACK_CURRENCY = "EUR";
+const DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+const DATE_TIME_WITH_OFFSET = /^\d{4}-\d{2}-\d{2}T.*[+-]\d{2}(:?\d{2})?$/;
+function isPlainRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// A bare number is minor units in the tenant currency; a `{ amount, currency }`
+// record brings its own currency.
+export function formatDocumentMoney(value, tenantCurrency, locale) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return formatMoney(value, tenantCurrency, locale);
+    }
+    if (isPlainRecord(value)) {
+        const { amount, currency } = value;
+        if (typeof amount === "number" && Number.isFinite(amount) && typeof currency === "string") {
+            return formatMoney(amount, currency, locale);
+        }
+    }
+    return value === undefined || value === null ? "" : String(value);
+}
+function formatOffsetDateTime(value, locale, withTime) {
+    const wallClock = Temporal.PlainDateTime.from(value);
+    return withTime
+        ? wallClock.toLocaleString(locale, { dateStyle: "long", timeStyle: "short" })
+        : wallClock.toPlainDate().toLocaleString(locale, { dateStyle: "long" });
+}
+function instantFormatOptions(options) {
+    if (options.time !== true)
+        return { dateStyle: "long", timeZone: "UTC" };
+    return { dateStyle: "long", timeStyle: "short", timeZone: options.timeZone ?? "UTC" };
+}
+// The long date a rendered mail or PDF prints for a `date` placeholder; the editor's
+// sample values use it too, so both show the same text.
+export function formatDocumentDate(value, locale, options = {}) {
+    if (typeof value !== "string" && typeof value !== "number") {
+        return value === undefined || value === null ? "" : String(value);
+    }
+    const safeLocale = resolveSafeMoneyLocale(locale);
+    try {
+        // A date-only string has no zone; going through an instant would show the
+        // previous day west of UTC.
+        if (typeof value === "string" && DATE_ONLY.test(value)) {
+            return Temporal.PlainDate.from(value).toLocaleString(safeLocale, { dateStyle: "long" });
+        }
+        // An explicit offset names the sender's zone: the calendar date is the wall-clock
+        // date of the string, not the date at UTC.
+        if (typeof value === "string" && DATE_TIME_WITH_OFFSET.test(value)) {
+            return formatOffsetDateTime(value, safeLocale, options.time === true);
+        }
+        const instant = typeof value === "number"
+            ? Temporal.Instant.fromEpochMilliseconds(value)
+            : Temporal.Instant.from(value);
+        return instant.toLocaleString(safeLocale, instantFormatOptions(options));
+    }
+    catch {
+        return String(value);
+    }
+}
+export function formatDocumentPercent(value, locale) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return new Intl.NumberFormat(resolveSafeMoneyLocale(locale), {
+            style: "percent",
+            maximumFractionDigits: 2,
+        }).format(value / 100);
+    }
+    return value === undefined || value === null ? "" : String(value);
+}

package/dist/headless/format/escape.d.ts

@@ -0,0 +1,5 @@
+export declare function escapeHtml(s: string): string;
+export declare function escapeHtmlAttr(s: string): string;
+export declare function escapeXml(s: string): string;
+export declare function stripControlChars(value: string): string;
+export declare function isSafeHref(href: string): boolean;

package/dist/headless/format/escape.js

@@ -0,0 +1,75 @@
+export function escapeHtml(s) {
+    return s
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+// Superset of escapeHtml for attribute contexts: additionally escapes ' so
+// single-quoted attributes cannot be broken out of.
+export function escapeHtmlAttr(s) {
+    return escapeHtml(s).replace(/'/g, "&#39;");
+}
+// Shared API for app repos (publicstatus badge-SVG renders XML by hand) —
+// no in-repo consumer yet, deliberately exported for cross-repo dedup.
+export function escapeXml(s) {
+    return s
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+// Strips ASCII control chars + space (codepoints 0x00-0x20 and 0x7f) — the
+// same characters browsers strip before scheme detection. `.trim()` alone
+// only removes leading/trailing whitespace, so a scheme like
+// "java\tscript:" (tab embedded mid-scheme) survives to isSafeHref's regex
+// check below, breaks its character class before the ":", falls through to
+// `return true`, and the browser then normalizes it back to "javascript:"
+// and executes it. Written as a char-code filter rather than a regex range
+// to avoid embedding literal control characters in source.
+export function stripControlChars(value) {
+    let result = "";
+    for (const ch of value) {
+        const code = ch.codePointAt(0) ?? 0;
+        if (code > 0x20 && code !== 0x7f)
+            result += ch;
+    }
+    return result;
+}
+// http(s)/mailto or scheme-less (relative/anchor) allowed; javascript:,
+// data:, vbscript:, etc. rejected. Shared between renderer/web's Link
+// primitive and page-render's server-side markdown renderer (both take
+// untrusted tenant-authored hrefs) — no sanitizer dependency needed for a
+// four-line regex check.
+// Browsers decode HTML character references (&colon;, &#58;, &#x3a;, &Tab;,
+// &#9;, ...) while parsing the href attribute, before the URL parser ever
+// sees the value — so "javascript&colon;alert(1)" and "java&Tab;script:"
+// both normalize to an executable javascript: URL at click time even though
+// neither contains a literal ":" for the regex below to catch. Decode
+// (not delete) so the scheme check sees what the browser will execute —
+// deleting "&colon;" would leave no colon at all, which reads as a safe
+// scheme-less href, exactly backwards.
+const NAMED_HTML_ENTITY_CHARS = {
+    colon: ":",
+    tab: "\t",
+    newline: "\n",
+    semi: ";",
+    amp: "&",
+};
+function decodeHtmlEntities(value) {
+    return value.replace(/&(#x[0-9a-f]+|#[0-9]+|[a-z][a-z0-9]*);/gi, (match, entity) => {
+        if (entity[0] === "#") {
+            const isHex = entity[1]?.toLowerCase() === "x";
+            const code = Number.parseInt(isHex ? entity.slice(2) : entity.slice(1), isHex ? 16 : 10);
+            return Number.isFinite(code) ? String.fromCodePoint(code) : match;
+        }
+        return NAMED_HTML_ENTITY_CHARS[entity.toLowerCase()] ?? match;
+    });
+}
+export function isSafeHref(href) {
+    const trimmed = stripControlChars(decodeHtmlEntities(href)).toLowerCase();
+    if (!/^[a-z][a-z0-9+.-]*:/.test(trimmed))
+        return true;
+    return /^(?:https?|mailto):/.test(trimmed);
+}

package/dist/headless/format/html-template.d.ts

@@ -0,0 +1,9 @@
+export declare class RawHtml {
+    readonly html: string;
+    constructor(html: string);
+    toString(): string;
+}
+/** Marks already escaped or trusted markup for html`...`. */
+export declare function raw(html: string): RawHtml;
+export type HtmlValue = string | number | boolean | null | undefined | RawHtml | ReadonlyArray<HtmlValue>;
+export declare function html(strings: TemplateStringsArray, ...values: ReadonlyArray<HtmlValue>): RawHtml;

package/dist/headless/format/html-template.js

@@ -0,0 +1,39 @@
+// html`...` — tagged template that HTML-escapes every interpolation automatically.
+// Makes escaping structural instead of a per-call-site convention: forgetting
+// it is impossible, deliberately raw HTML needs an explicit raw(). The
+// HTML-escape guard (kumiko-guards) accepts html`...` as safe.
+import { escapeHtml } from "./escape.js";
+export class RawHtml {
+    html;
+    constructor(html) {
+        this.html = html;
+    }
+    toString() {
+        return this.html;
+    }
+}
+/** Marks already escaped or trusted markup for html`...`. */
+export function raw(html) {
+    return new RawHtml(html);
+}
+function renderValue(value) {
+    if (value === null || value === undefined)
+        return "";
+    if (value instanceof RawHtml)
+        return value.html;
+    if (Array.isArray(value))
+        return value.map(renderValue).join("");
+    if (typeof value === "string")
+        return escapeHtml(value);
+    return String(value);
+}
+// Returns RawHtml so fragments can be nested without double escaping:
+// `html`<div>${item}</div>`` inside an outer html`...` passes through
+// unchanged. toString() yields the finished markup.
+export function html(strings, ...values) {
+    let out = strings[0] ?? "";
+    values.forEach((value, i) => {
+        out += renderValue(value) + (strings[i + 1] ?? "");
+    });
+    return new RawHtml(out);
+}

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

@@ -0,0 +1,12 @@
+import { Temporal } from "@cosmicdrift/kumiko-types/temporal";
+export declare const EMPTY_VALUE_PLACEHOLDER = "\u2014";
+export declare function toInstant(raw: string): Temporal.Instant;
+/** Exported for UnitKey parity tests against @cosmicdrift/kumiko-types/screen. */
+export declare const UNIT_FORMAT_KEYS: readonly string[];
+export { DOCUMENT_FALLBACK_CURRENCY, type DocumentDateOptions, formatDocumentDate, formatDocumentMoney, formatDocumentPercent, } from "./document-values.ts";
+export { escapeHtml, escapeHtmlAttr, escapeXml, isSafeHref, stripControlChars } from "./escape.ts";
+export { type HtmlValue, html, RawHtml, raw } from "./html-template.ts";
+export { currencyDecimals, formatMoney, resolveSafeMoneyLocale } from "./money.ts";
+export declare function applyFormatSpec(spec: {
+    format: string;
+} & Record<string, unknown>, value: unknown, translate?: (key: string) => string): string;

package/dist/headless/format/index.js

@@ -0,0 +1,237 @@
+// Pure format utilities — no web or platform dependencies.
+// Shared between renderer/web, renderer-native, and server-side tests.
+import { Temporal } from "@cosmicdrift/kumiko-types/temporal";
+import { isOneOf } from "@cosmicdrift/kumiko-types/type-guards";
+export const EMPTY_VALUE_PLACEHOLDER = "—";
+function toPlainDate(raw) {
+    try {
+        return Temporal.PlainDate.from(raw);
+    }
+    catch {
+        // "date"-typed field stored as a full instant (day-boundary timestamp) —
+        // take the calendar date in the local zone rather than fail.
+        return toInstant(raw).toZonedDateTimeISO(Temporal.Now.timeZoneId()).toPlainDate();
+    }
+}
+// Temporal.Instant.from is stricter than the `new Date(raw)` this replaced:
+// it requires a UTC designator/offset (Z/+hh:mm). Timestamps without one
+// (e.g. "2026-07-18T12:00:00", still valid input to `new Date`) throw here
+// instead of parsing — fall back to reading them as a local wall-clock time,
+// same posture as toPlainDate's own fallback above.
+export function toInstant(raw) {
+    try {
+        return Temporal.Instant.from(raw);
+    }
+    catch {
+        return Temporal.PlainDateTime.from(raw).toZonedDateTime(Temporal.Now.timeZoneId()).toInstant();
+    }
+}
+function formatDateCell(value, type, opts) {
+    try {
+        const raw = typeof value === "string" ? value : String(value);
+        const locale = opts?.locale;
+        if (opts?.dateStyle || opts?.timeStyle) {
+            if (type === "date") {
+                // ponytail: timeStyle is ignored here on purpose — a PlainDate has no
+                // time component to format, so a timeStyle-only "date" field falls
+                // back to PlainDate's default dateStyle instead of rendering a time.
+                return toPlainDate(raw).toLocaleString(locale, {
+                    dateStyle: opts.dateStyle,
+                });
+            }
+            return toInstant(raw).toLocaleString(locale, {
+                dateStyle: opts.dateStyle,
+                timeStyle: opts.timeStyle,
+                timeZone: opts.timeZone,
+            });
+        }
+        if (type === "date") {
+            return toPlainDate(raw).toLocaleString(locale, {
+                year: "numeric",
+                month: "2-digit",
+                day: "2-digit",
+            });
+        }
+        return toInstant(raw).toLocaleString(locale, {
+            year: "numeric",
+            month: "short",
+            day: "numeric",
+            hour: "2-digit",
+            minute: "2-digit",
+            timeZone: opts?.timeZone,
+        });
+    }
+    catch {
+        return String(value);
+    }
+}
+// No `locale` fallback to a browser API here (headless has none) — passing
+// `undefined` to Intl.NumberFormat resolves the runtime's default locale,
+// the same value a browser's navigator.language-based guess would produce.
+function formatNumberCell(value, locale, grouping = true) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return String(value);
+    try {
+        return new Intl.NumberFormat(locale, { useGrouping: grouping }).format(value);
+    }
+    catch {
+        // Malformed BCP-47 locale tag — mirrors formatDateCell's fallback above.
+        return String(value);
+    }
+}
+// Two-tier unit table for `{ format: "unit" }`. Keys mirror
+// @cosmicdrift/kumiko-types' UnitKey (kept as a local literal union instead
+// of an import — headless has no build-time dependency on kumiko-types
+// today, and applyFormatSpec's spec param is already an untyped
+// Record<string, unknown>, cast per-case like every other format below).
+const UNIT_INTL_IDS = {
+    km: "kilometer",
+    m: "meter",
+    kg: "kilogram",
+    percent: "percent",
+    mi: "mile",
+};
+// "m2" (square meter) has no ECMA-402 sanctioned unit — Intl.NumberFormat
+// throws RangeError for "square-meter". Locale-format the number and append
+// the literal suffix instead of going through `style: "unit"`.
+const UNIT_SUFFIXES = { m2: "m²" };
+function isIntlUnit(unit) {
+    return Object.hasOwn(UNIT_INTL_IDS, unit);
+}
+function isSuffixUnit(unit) {
+    return Object.hasOwn(UNIT_SUFFIXES, unit);
+}
+function formatUnitCell(value, unit, locale, unitDisplay) {
+    const n = typeof value === "number" ? value : Number(value);
+    if (unit === undefined || !Number.isFinite(n))
+        return String(value);
+    if (isIntlUnit(unit)) {
+        try {
+            return new Intl.NumberFormat(locale, {
+                style: "unit",
+                unit: UNIT_INTL_IDS[unit],
+                unitDisplay,
+            }).format(n);
+        }
+        catch {
+            // Malformed BCP-47 locale tag — mirrors formatNumberCell's fallback below.
+            return formatNumberCell(n, locale);
+        }
+    }
+    if (isSuffixUnit(unit)) {
+        return `${formatNumberCell(n, locale)} ${UNIT_SUFFIXES[unit]}`;
+    }
+    return String(value);
+}
+/** Exported for UnitKey parity tests against @cosmicdrift/kumiko-types/screen. */
+export const UNIT_FORMAT_KEYS = [
+    ...Object.keys(UNIT_INTL_IDS),
+    ...Object.keys(UNIT_SUFFIXES),
+];
+export { DOCUMENT_FALLBACK_CURRENCY, formatDocumentDate, formatDocumentMoney, formatDocumentPercent, } from "./document-values.js";
+export { escapeHtml, escapeHtmlAttr, escapeXml, isSafeHref, stripControlChars } from "./escape.js";
+export { html, RawHtml, raw } from "./html-template.js";
+export { currencyDecimals, formatMoney, resolveSafeMoneyLocale } from "./money.js";
+// JSON.stringify throws on BigInt and circular values; a cell must degrade to text instead of crashing the screen.
+function stringifyJsonOrString(value, indent) {
+    try {
+        return JSON.stringify(value, null, indent) ?? String(value);
+    }
+    catch {
+        try {
+            return String(value);
+        }
+        catch {
+            return "[unserializable value]";
+        }
+    }
+}
+const INTL_DATE_STYLES = ["full", "long", "medium", "short"];
+const INTL_UNIT_DISPLAYS = ["short", "long", "narrow"];
+function stringSpec(spec, key) {
+    const v = spec[key];
+    return typeof v === "string" ? v : undefined;
+}
+function booleanSpec(spec, key) {
+    const v = spec[key];
+    return typeof v === "boolean" ? v : undefined;
+}
+function dateStyleSpec(spec, key) {
+    const v = spec[key];
+    return isOneOf(INTL_DATE_STYLES, v) ? v : undefined;
+}
+function unitDisplaySpec(spec) {
+    const v = spec["unitDisplay"];
+    return isOneOf(INTL_UNIT_DISPLAYS, v) ? v : "short";
+}
+export function applyFormatSpec(spec, value, translate) {
+    const isEmpty = value === null || value === undefined || value === "";
+    // priority renders its emptyLabel for empty values — every other format
+    // collapses empty to "".
+    if (isEmpty && spec.format !== "priority")
+        return "";
+    switch (spec.format) {
+        case "timestamp":
+        case "date":
+            return formatDateCell(value, spec.format, {
+                locale: stringSpec(spec, "locale"),
+                dateStyle: dateStyleSpec(spec, "dateStyle"),
+                timeStyle: spec.format === "timestamp" ? dateStyleSpec(spec, "timeStyle") : undefined,
+                timeZone: spec.format === "timestamp" ? stringSpec(spec, "timeZone") : undefined,
+            });
+        case "boolean": {
+            if (value === true) {
+                const trueLabel = stringSpec(spec, "trueLabel");
+                return trueLabel === undefined ? "✓" : (translate?.(trueLabel) ?? trueLabel);
+            }
+            if (value === false) {
+                const falseLabel = stringSpec(spec, "falseLabel");
+                return falseLabel === undefined ? "" : (translate?.(falseLabel) ?? falseLabel);
+            }
+            return "";
+        }
+        case "currency": {
+            const sym = stringSpec(spec, "symbol") ?? "";
+            return sym.length > 0 ? `${value} ${sym}` : String(value);
+        }
+        case "number":
+        case "decimal":
+        case "bigInt":
+            return formatNumberCell(value, stringSpec(spec, "locale"), booleanSpec(spec, "grouping") ?? true);
+        case "unit":
+            return formatUnitCell(value, stringSpec(spec, "unit"), stringSpec(spec, "locale"), unitDisplaySpec(spec));
+        case "priority": {
+            const emptyLabel = stringSpec(spec, "emptyLabel") ?? EMPTY_VALUE_PLACEHOLDER;
+            const prefix = stringSpec(spec, "prefix") ?? "";
+            if (isEmpty || value === 0)
+                return emptyLabel;
+            return `${prefix}${value}`;
+        }
+        case "enumOption": {
+            const keyPrefix = stringSpec(spec, "keyPrefix");
+            const labelFor = (item) => {
+                const raw = typeof item === "string" ? item : String(item);
+                if (keyPrefix === undefined || translate === undefined)
+                    return raw;
+                const key = `${keyPrefix}${raw}`;
+                const translated = translate(key);
+                return translated === key ? raw : translated;
+            };
+            // multiSelect-style columns hold an array of option values
+            return Array.isArray(value) ? value.map(labelFor).join(", ") : labelFor(value);
+        }
+        // Thumbnails and file links are drawn by the web list cell; this is the
+        // text fallback for every other surface.
+        case "image":
+        case "file":
+            return Array.isArray(value) ? value.join(", ") : String(value);
+        case "json":
+            return stringifyJsonOrString(value, typeof spec["indent"] === "number" ? spec["indent"] : 2);
+        default:
+            if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+                // biome-ignore lint/suspicious/noConsole: dev-only warning
+                console.warn(`[kumiko] applyFormatSpec: unknown format key "${spec.format}" — registered via FieldFormatRegistry module augmentation?`);
+            }
+            return typeof value === "string" ? value : String(value);
+    }
+}

package/dist/headless/format/money.d.ts

@@ -0,0 +1,3 @@
+export declare function currencyDecimals(code: string): number;
+export declare function resolveSafeMoneyLocale(locale: string | undefined): string;
+export declare function formatMoney(amountMinor: number, currency: string, locale?: string, fractionDigits?: number): string;

package/dist/headless/format/money.js

@@ -0,0 +1,39 @@
+// Currency decimal places — covers the world's zero- and three-decimal
+// outliers, defaults to 2 for everything else. Shared between renderer/web's
+// MoneyInput (minor-unit display factor) and RenderField's minor/major-unit
+// conversion (kumiko-framework#1923) — a single source keeps both sides
+// scaling the same currency the same way.
+export function currencyDecimals(code) {
+    if (code === "JPY" || code === "KRW" || code === "VND" || code === "ISK")
+        return 0;
+    if (code === "BHD" || code === "JOD" || code === "KWD" || code === "OMR" || code === "TND")
+        return 3;
+    return 2;
+}
+const FALLBACK_MONEY_LOCALE = "en-US";
+// An invalid tag makes Intl constructors throw a RangeError; canonicalizing up
+// front keeps server renders and client cells safe. No navigator lookup, so it
+// behaves the same on the server.
+export function resolveSafeMoneyLocale(locale) {
+    try {
+        return Intl.getCanonicalLocales(locale ?? FALLBACK_MONEY_LOCALE)[0] ?? FALLBACK_MONEY_LOCALE;
+    }
+    catch {
+        return FALLBACK_MONEY_LOCALE;
+    }
+}
+// currency is validated against the 3-letter-alpha shape Intl.NumberFormat
+// requires: a non-conforming value (e.g. from a JSONB custom field) would throw
+// a RangeError and take down the whole render instead of just this value.
+export function formatMoney(amountMinor, currency, locale, fractionDigits) {
+    if (!/^[A-Za-z]{3}$/.test(currency))
+        return String(amountMinor);
+    const decimals = currencyDecimals(currency);
+    const displayDigits = fractionDigits ?? decimals;
+    return new Intl.NumberFormat(resolveSafeMoneyLocale(locale), {
+        style: "currency",
+        currency,
+        minimumFractionDigits: displayDigits,
+        maximumFractionDigits: displayDigits,
+    }).format(amountMinor / 10 ** decimals);
+}

package/dist/headless/index.d.ts

@@ -0,0 +1,14 @@
+export type { ParsedRefTarget } from "@cosmicdrift/kumiko-framework/ui-types";
+export { parseRefTarget } from "@cosmicdrift/kumiko-framework/ui-types";
+export type { AssetResolution, AssetResolveContext, AssetResolver, BadgeProps, ButtonProps, CardProps, DatePickerProps, IconProps, LocaleResolver, ModalProps, NumberInputProps, PrimitiveCommonProps, PrimitivesContract, SelectOption, SelectProps, TextInputProps, ToastIntent, ToastProps, ToggleProps, } from "./contracts/index.ts";
+export type { BatchResult, Command, Dispatcher, DispatcherError, DispatcherStatus, FieldIssue, PendingFile, PendingWrite, QueryOpts, QueryResult, StreamOpts, WriteOpts, WriteResult, } from "./dispatcher/index.ts";
+export { StreamFrame, type StreamFrameEvent } from "./dispatcher/index.ts";
+export type { FieldConditionPredicate, FieldConditions, FieldConditionValue, FieldState, FormController, FormControllerOptions, FormSnapshot, FormValues, SubmitConfig, SubmitPayloadMode, SubmitResult, } from "./form/index.ts";
+export { createFormController, groupIssuesByPath, I18N_KEY_PARAM, relevantFieldIssues, zodErrorToFieldIssues, } from "./form/index.ts";
+export { applyFormatSpec, currencyDecimals, DOCUMENT_FALLBACK_CURRENCY, EMPTY_VALUE_PLACEHOLDER, escapeHtml, escapeHtmlAttr, escapeXml, formatDocumentDate, formatDocumentMoney, formatDocumentPercent, formatMoney, type HtmlValue, html, isSafeHref, RawHtml, raw, resolveSafeMoneyLocale, stripControlChars, toInstant, } from "./format/index.ts";
+export type { NavDefinition, NavNode, NavRegistrySlice, NavTree, ResolveNavigationOptions, } from "./nav/index.ts";
+export { resolveNavigation } from "./nav/index.ts";
+export type { Store, WritableStore } from "./store/index.ts";
+export { createStore, shallowEqual } from "./store/index.ts";
+export type { CellLink, CellLinkItem, ComputeEditViewModelInput, ComputeListViewModelInput, DerivedCellRoundingTarget, EditExtensionSectionViewModel, EditFieldSpec, EditFieldsSectionViewModel, EditFieldViewModel, EditFormMode, EditRelatedListSectionViewModel, EditSectionSpec, EditSectionViewModel, EditViewModel, EditWriteFormSectionViewModel, EmbeddedDerivedOp, EmbeddedListCellViewModel, EmbeddedListIssueGroups, FieldConditionCtx, FieldRenderer, ListColumnFileDisplay, ListColumnSpec, ListColumnViewModel, ListRowViewModel, ListViewModel, RuntimeCellLink, RuntimeCellLinkItems, RuntimeRenderer, ScreenSlots, Translate, } from "./view-model/index.ts";
+export { buildOptionLabels, computeDerivedCellValue, computeEditViewModel, computeListViewModel, computeRelatedListSectionViewModel, embeddedCellLabelKey, embeddedCellOptionLabelKey, fieldLabelKey, fieldOptionLabelKey, fieldOptionLabelKeyPrefix, groupEmbeddedListIssues, roundDerivedCellValue, sumEmbeddedListColumn, } from "./view-model/index.ts";

package/dist/headless/index.js

@@ -0,0 +1,9 @@
+// Re-Export aus framework/ui-types damit Renderer-Code denselben
+// Parser nutzt wie der Server-Boot-Validator (Cross-Feature-Refs).
+export { parseRefTarget } from "@cosmicdrift/kumiko-framework/ui-types";
+export { StreamFrame } from "./dispatcher/index.js";
+export { createFormController, groupIssuesByPath, I18N_KEY_PARAM, relevantFieldIssues, zodErrorToFieldIssues, } from "./form/index.js";
+export { applyFormatSpec, currencyDecimals, DOCUMENT_FALLBACK_CURRENCY, EMPTY_VALUE_PLACEHOLDER, escapeHtml, escapeHtmlAttr, escapeXml, formatDocumentDate, formatDocumentMoney, formatDocumentPercent, formatMoney, html, isSafeHref, RawHtml, raw, resolveSafeMoneyLocale, stripControlChars, toInstant, } from "./format/index.js";
+export { resolveNavigation } from "./nav/index.js";
+export { createStore, shallowEqual } from "./store/index.js";
+export { buildOptionLabels, computeDerivedCellValue, computeEditViewModel, computeListViewModel, computeRelatedListSectionViewModel, embeddedCellLabelKey, embeddedCellOptionLabelKey, fieldLabelKey, fieldOptionLabelKey, fieldOptionLabelKeyPrefix, groupEmbeddedListIssues, roundDerivedCellValue, sumEmbeddedListColumn, } from "./view-model/index.js";