@marianmeres/stuic 3.181.0 → 3.183.0

package/dist/components/Input/_internal/asset-helpers.js

@@ -0,0 +1,46 @@
+/**
+ * Does a file pass an `accept` attribute value? Shared by `FieldAssets` and
+ * `FieldSingleAsset`.
+ *
+ * Tokens are the HTML `accept` ones, comma separated: a MIME type
+ * (`image/png`), a wildcard MIME (`image/*`, `*`), or an extension (`.pdf`).
+ * MIME tokens are matched as prefixes of the file's `type`; extension tokens
+ * are matched against the end of the file's `name` (the browser's own picker
+ * filters by the same rule, so a drop and a pick agree). An empty `accept`
+ * accepts everything; so does a file with an unknown (empty) `type` when the
+ * token is a MIME one — we cannot tell, and the picker would have let it
+ * through too.
+ */
+export function isAcceptedType(allowedAccept, type, name) {
+    if (!allowedAccept)
+        return true;
+    const tokens = (allowedAccept ?? "")
+        .split(",")
+        .map((v) => `${v || ""}`.trim().toLowerCase())
+        .filter(Boolean);
+    if (!tokens.length)
+        return true;
+    const _type = `${type ?? ""}`.toLowerCase();
+    const _name = `${name ?? ""}`.toLowerCase();
+    return tokens.some((tok) => {
+        if (tok.startsWith("."))
+            return !!_name && _name.endsWith(tok);
+        // unknown type: cannot decide, let it through (legacy behavior)
+        if (!_type)
+            return true;
+        const prefix = tok.includes("*") ? tok.slice(0, tok.indexOf("*")) : tok;
+        return _type.startsWith(prefix);
+    });
+}
+/** `1234567` -> `"1.2 MB"` (1024-based, at most one decimal below 10). */
+export function formatBytes(bytes) {
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let v = Math.max(0, Number(bytes) || 0);
+    let i = 0;
+    while (v >= 1024 && i < units.length - 1) {
+        v /= 1024;
+        i++;
+    }
+    const rounded = i === 0 ? Math.round(v) : parseFloat(v.toFixed(v < 10 ? 1 : 0));
+    return `${rounded} ${units[i]}`;
+}

package/dist/components/Input/_internal/paste-target.d.ts

@@ -0,0 +1,15 @@
+export type PasteTarget = {
+    el: HTMLElement;
+    handle: (e: ClipboardEvent) => void;
+};
+/**
+ * Registers a pasteable field. Returns the unregister function. The document
+ * listener is installed with the first registration and removed with the last.
+ */
+export declare function registerPasteTarget(t: PasteTarget): () => void;
+/**
+ * The file entries of a paste. Prefers `items` (lets us keep only file-kind
+ * entries, e.g. a pasted screenshot); falls back to `.files` for browsers that
+ * only populate that. Empty for a plain-text paste.
+ */
+export declare function extractClipboardFiles(e: ClipboardEvent): File[];

package/dist/components/Input/_internal/paste-target.js

@@ -0,0 +1,114 @@
+// --- Clipboard paste plumbing (see the `pasteable` prop of FieldAssets /
+// FieldSingleAsset) ------------------------------------------------------------
+// All mounted pasteable instances — of EITHER component — coordinate through ONE
+// document-level `paste` listener (installed while at least one is mounted).
+// Document-level (rather than a listener on the field wrapper) because browsers
+// dispatch `paste` at the focused/selection node — with focus on <body> the
+// event never bubbles through the field, which made the feature look dead
+// unless the field was clicked first.
+//
+// Shared on purpose: the "single mounted pasteable field" fallback below must
+// count every pasteable field on the page. Two private registries (one per
+// component) would each believe they own the only field and BOTH would consume
+// a bare Ctrl/Cmd-V.
+const paste_targets = new Set();
+// True only when NOTHING is focused (browsers park focus on <body>/<html>).
+// The fallback below must never fire while the user has deliberately focused
+// some other element — a text input obviously, but also any other widget
+// (e.g. a different, non-pasteable field): pasting "into" the thing they
+// focused must not teleport files to an unrelated field.
+function is_unclaimed_focus(el) {
+    return !el || el === document.body || el === document.documentElement;
+}
+// Text-entry elements own their pastes even when they live INSIDE the field
+// (consumer content via the label/description/below snippets) — an editor's
+// image paste must insert into the editor, not upload into the field.
+function is_text_entry(el) {
+    if (!el)
+        return false;
+    if (el.isContentEditable)
+        return true;
+    return ["INPUT", "TEXTAREA", "SELECT"].includes(el.tagName);
+}
+// A field hidden by CSS (kept-mounted inactive tab panel etc.) must not
+// claim the no-focus fallback — the user would see nothing happen.
+function is_visible(el) {
+    return el.checkVisibility?.() ?? el.offsetParent !== null;
+}
+// A modal/dialog (drawer, modal) takes focus on open, so `active` is the
+// dialog panel — or a control inside it — and NEVER <body>. When the field
+// lives in such a dialog, treat a non-text focus within that SAME dialog as
+// unclaimed too, so a bare Ctrl/Cmd-V attaches with no prior click. Scoped to
+// a shared [aria-modal]/[role=dialog] ancestor on purpose: it must not make
+// the field greedy on ordinary (non-modal) pages, where a deliberately
+// focused control elsewhere still owns its paste.
+function shares_modal(fieldEl, active) {
+    if (!active)
+        return false;
+    const modal = fieldEl.closest?.("[aria-modal='true'],[role='dialog']");
+    return !!modal && modal.contains(active);
+}
+function on_document_paste(e) {
+    // someone (an editor, another paste handler) already claimed it
+    if (e.defaultPrevented)
+        return;
+    const active = document.activeElement;
+    // 1) the field holding focus always wins — unless focus sits in a
+    // text-entry element nested inside it: stand down entirely
+    for (const t of paste_targets) {
+        if (t.el.contains(active)) {
+            if (is_text_entry(active))
+                return;
+            return t.handle(e);
+        }
+    }
+    // 2) fall back to the SINGLE mounted + visible pasteable field for a paste
+    // NOT owned by a focused text-entry element, when focus is EITHER unclaimed
+    // (fresh page, focus on <body>) OR parked on a non-text control inside the
+    // SAME modal/dialog as the field (the drawer/modal case: the panel or the
+    // row that opened it holds focus, so <body> is never active). A bare
+    // Ctrl/Cmd-V then works with no prior click. With several fields mounted the
+    // routing would be ambiguous, so focus (a click on the field) must decide.
+    if (paste_targets.size === 1 && !is_text_entry(active)) {
+        const [t] = paste_targets;
+        if (is_visible(t.el) && (is_unclaimed_focus(active) || shares_modal(t.el, active))) {
+            t.handle(e);
+        }
+    }
+}
+/**
+ * Registers a pasteable field. Returns the unregister function. The document
+ * listener is installed with the first registration and removed with the last.
+ */
+export function registerPasteTarget(t) {
+    if (!paste_targets.size)
+        document.addEventListener("paste", on_document_paste);
+    paste_targets.add(t);
+    return () => {
+        paste_targets.delete(t);
+        if (!paste_targets.size)
+            document.removeEventListener("paste", on_document_paste);
+    };
+}
+/**
+ * The file entries of a paste. Prefers `items` (lets us keep only file-kind
+ * entries, e.g. a pasted screenshot); falls back to `.files` for browsers that
+ * only populate that. Empty for a plain-text paste.
+ */
+export function extractClipboardFiles(e) {
+    const dt = e.clipboardData;
+    if (!dt)
+        return [];
+    const out = [];
+    for (let i = 0; i < (dt.items?.length ?? 0); i++) {
+        const it = dt.items[i];
+        if (it?.kind === "file") {
+            const f = it.getAsFile();
+            if (f)
+                out.push(f);
+        }
+    }
+    if (!out.length && dt.files?.length)
+        out.push(...dt.files);
+    return out;
+}

package/dist/components/Input/field-single-asset-i18n-sk.d.ts

@@ -0,0 +1,21 @@
+import type { FieldSingleAssetMessages } from "./field-single-asset-i18n.js";
+/**
+ * Slovak message catalog for `FieldSingleAsset`. Opt-in — English stays the built-in
+ * default, and this module is only pulled into a bundle when it is actually imported
+ * (the component itself never references it).
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import {
+ *     FieldSingleAsset,
+ *     createFieldSingleAssetT,
+ *     FIELD_SINGLE_ASSET_MESSAGES_SK,
+ *   } from "@marianmeres/stuic";
+ *   const t = createFieldSingleAssetT(FIELD_SINGLE_ASSET_MESSAGES_SK);
+ * </script>
+ *
+ * <FieldSingleAsset name="avatar" bind:value {processAsset} {t} />
+ * ```
+ */
+export declare const FIELD_SINGLE_ASSET_MESSAGES_SK: FieldSingleAssetMessages;

package/dist/components/Input/field-single-asset-i18n-sk.js

@@ -0,0 +1,49 @@
+/**
+ * Slovak message catalog for `FieldSingleAsset`. Opt-in — English stays the built-in
+ * default, and this module is only pulled into a bundle when it is actually imported
+ * (the component itself never references it).
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import {
+ *     FieldSingleAsset,
+ *     createFieldSingleAssetT,
+ *     FIELD_SINGLE_ASSET_MESSAGES_SK,
+ *   } from "@marianmeres/stuic";
+ *   const t = createFieldSingleAssetT(FIELD_SINGLE_ASSET_MESSAGES_SK);
+ * </script>
+ *
+ * <FieldSingleAsset name="avatar" bind:value {processAsset} {t} />
+ * ```
+ */
+export const FIELD_SINGLE_ASSET_MESSAGES_SK = {
+    field_req_att: "Toto pole vyžaduje pozornosť. Skontrolujte ho a skúste to znova.",
+    pick_file: "Vybrať súbor",
+    replace_file: "Nahradiť {{name}}",
+    empty_hint: "Presuňte sem súbor alebo kliknite a vyberte ho",
+    remove: "Odstrániť",
+    removed: "Súbor {{name}} bol odstránený",
+    undo: "Vrátiť späť",
+    restored: "Súbor {{name}} bol obnovený",
+    preview: "Náhľad",
+    retry: "Skúsiť nahrať znova",
+    discard: "Zahodiť",
+    cancel_upload: "Zrušiť nahrávanie",
+    uploading: "Nahráva sa {{name}}",
+    uploading_short: "Nahráva sa…",
+    uploading_progress: "Nahráva sa… {{percent}} %",
+    uploaded: "Súbor {{name}} bol nahraný",
+    upload_failed: "Nahrávanie zlyhalo",
+    upload_failed_named: "Nahrávanie súboru {{name}} zlyhalo: {{error}}",
+    invalid_type: "Tento typ súboru nie je podporovaný. Povolené: „{{accept}}“.",
+    too_large: "Súbor je príliš veľký ({{size}}). Maximum je {{max}}.",
+    single_only: "Sem je možné umiestniť iba jeden súbor. Presuňte alebo prilepte jeden súbor.",
+    // AssetsPreview
+    unable_to_preview: "Tento súbor nie je možné zobraziť",
+    download: "Stiahnuť originál",
+    close: "Zavrieť náhľad",
+    zoom_in: "Priblížiť",
+    zoom_out: "Oddialiť",
+    delete: "Odstrániť",
+};

package/dist/components/Input/field-single-asset-i18n.d.ts

@@ -0,0 +1,68 @@
+import type { TranslateFn } from "../../types.js";
+/**
+ * The built-in (English) message catalog of `FieldSingleAsset`. Also the fallback of
+ * every other bundled locale, so a locale missing a key still renders text.
+ *
+ * Placeholders are mustache-style (`{{name}}`, `{{max}}`, ...). The last six keys are
+ * the ones the embedded `AssetsPreview` looks up, so one `t` serves both.
+ */
+export declare const FIELD_SINGLE_ASSET_MESSAGES_EN: {
+    field_req_att: string;
+    pick_file: string;
+    replace_file: string;
+    empty_hint: string;
+    remove: string;
+    removed: string;
+    undo: string;
+    restored: string;
+    preview: string;
+    retry: string;
+    discard: string;
+    cancel_upload: string;
+    uploading: string;
+    uploading_short: string;
+    uploading_progress: string;
+    uploaded: string;
+    upload_failed: string;
+    upload_failed_named: string;
+    invalid_type: string;
+    too_large: string;
+    single_only: string;
+    unable_to_preview: string;
+    download: string;
+    close: string;
+    zoom_in: string;
+    zoom_out: string;
+    delete: string;
+};
+/** Every message key `FieldSingleAsset` may look up. */
+export type FieldSingleAssetMessageKey = keyof typeof FIELD_SINGLE_ASSET_MESSAGES_EN;
+/** A (possibly partial) catalog for one locale. */
+export type FieldSingleAssetMessages = Record<FieldSingleAssetMessageKey, string>;
+/**
+ * Builds the `t` prop of `FieldSingleAsset` from a message catalog. Unknown or
+ * untranslated keys fall back to `fallbackMessages` (English by default), so a catalog
+ * may safely be partial and never renders a raw key.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import {
+ *     FieldSingleAsset,
+ *     createFieldSingleAssetT,
+ *     FIELD_SINGLE_ASSET_MESSAGES_SK,
+ *   } from "@marianmeres/stuic";
+ *
+ *   // full locale, plus a field specific tweak
+ *   const t = createFieldSingleAssetT({
+ *     ...FIELD_SINGLE_ASSET_MESSAGES_SK,
+ *     empty_hint: "Sem presuňte fotku",
+ *   });
+ * </script>
+ *
+ * <FieldSingleAsset name="avatar" bind:value {processAsset} {t} />
+ * ```
+ */
+export declare function createFieldSingleAssetT(messages: Partial<FieldSingleAssetMessages> | Record<string, string>, fallbackMessages?: Partial<FieldSingleAssetMessages> | Record<string, string>): TranslateFn;
+/** The component's built-in English `t`. */
+export declare const t_default: TranslateFn;

package/dist/components/Input/field-single-asset-i18n.js

@@ -0,0 +1,75 @@
+import { isPlainObject } from "../../utils/is-plain-object.js";
+import { replaceMap } from "../../utils/replace-map.js";
+/**
+ * The built-in (English) message catalog of `FieldSingleAsset`. Also the fallback of
+ * every other bundled locale, so a locale missing a key still renders text.
+ *
+ * Placeholders are mustache-style (`{{name}}`, `{{max}}`, ...). The last six keys are
+ * the ones the embedded `AssetsPreview` looks up, so one `t` serves both.
+ */
+export const FIELD_SINGLE_ASSET_MESSAGES_EN = {
+    field_req_att: "This field requires attention. Please review and try again.",
+    pick_file: "Choose a file",
+    replace_file: "Replace {{name}}",
+    empty_hint: "Drop a file here or click to browse",
+    remove: "Remove",
+    removed: "{{name}} removed",
+    undo: "Undo",
+    restored: "{{name}} restored",
+    preview: "Preview",
+    retry: "Retry upload",
+    discard: "Discard",
+    cancel_upload: "Cancel upload",
+    uploading: "Uploading {{name}}",
+    uploading_short: "Uploading…",
+    uploading_progress: "Uploading… {{percent}}%",
+    uploaded: "{{name}} uploaded",
+    upload_failed: "Upload failed",
+    upload_failed_named: "Upload of {{name}} failed: {{error}}",
+    invalid_type: 'This file type is not supported. Allowed: "{{accept}}".',
+    too_large: "The file is too large ({{size}}). The maximum is {{max}}.",
+    single_only: "Only one file can be placed here. Drop or paste a single file.",
+    // AssetsPreview
+    unable_to_preview: "This file cannot be previewed",
+    download: "Download original",
+    close: "Close preview window",
+    zoom_in: "Zoom in",
+    zoom_out: "Zoom out",
+    delete: "Delete",
+};
+/**
+ * Builds the `t` prop of `FieldSingleAsset` from a message catalog. Unknown or
+ * untranslated keys fall back to `fallbackMessages` (English by default), so a catalog
+ * may safely be partial and never renders a raw key.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import {
+ *     FieldSingleAsset,
+ *     createFieldSingleAssetT,
+ *     FIELD_SINGLE_ASSET_MESSAGES_SK,
+ *   } from "@marianmeres/stuic";
+ *
+ *   // full locale, plus a field specific tweak
+ *   const t = createFieldSingleAssetT({
+ *     ...FIELD_SINGLE_ASSET_MESSAGES_SK,
+ *     empty_hint: "Sem presuňte fotku",
+ *   });
+ * </script>
+ *
+ * <FieldSingleAsset name="avatar" bind:value {processAsset} {t} />
+ * ```
+ */
+export function createFieldSingleAssetT(messages, fallbackMessages = FIELD_SINGLE_ASSET_MESSAGES_EN) {
+    return (k, values = null, fallback = "") => {
+        const out = messages[k] ??
+            fallbackMessages[k] ??
+            (typeof fallback === "string" ? fallback : k);
+        return isPlainObject(values)
+            ? replaceMap(out, values)
+            : out;
+    };
+}
+/** The component's built-in English `t`. */
+export const t_default = createFieldSingleAssetT(FIELD_SINGLE_ASSET_MESSAGES_EN);

package/dist/components/Input/field-table-i18n-sk.d.ts

@@ -0,0 +1,21 @@
+import type { FieldTableMessages } from "./field-table-i18n.js";
+/**
+ * Slovak message catalog for `FieldTable`. Opt-in — English stays the built-in
+ * default, and this module is only pulled into a bundle when it is actually imported
+ * (the component itself never references it).
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import {
+ *     FieldTable,
+ *     createFieldTableT,
+ *     FIELD_TABLE_MESSAGES_SK,
+ *   } from "@marianmeres/stuic";
+ *   const t = createFieldTableT(FIELD_TABLE_MESSAGES_SK);
+ * </script>
+ *
+ * <FieldTable name="items" bind:value {columns} locale="sk" {t} />
+ * ```
+ */
+export declare const FIELD_TABLE_MESSAGES_SK: FieldTableMessages;

package/dist/components/Input/field-table-i18n-sk.js

@@ -0,0 +1,41 @@
+/**
+ * Slovak message catalog for `FieldTable`. Opt-in — English stays the built-in
+ * default, and this module is only pulled into a bundle when it is actually imported
+ * (the component itself never references it).
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import {
+ *     FieldTable,
+ *     createFieldTableT,
+ *     FIELD_TABLE_MESSAGES_SK,
+ *   } from "@marianmeres/stuic";
+ *   const t = createFieldTableT(FIELD_TABLE_MESSAGES_SK);
+ * </script>
+ *
+ * <FieldTable name="items" bind:value {columns} locale="sk" {t} />
+ * ```
+ */
+export const FIELD_TABLE_MESSAGES_SK = {
+    field_req_att: "Toto pole vyžaduje pozornosť. Skontrolujte ho a skúste to znova.",
+    add_row: "Pridať riadok",
+    empty_message: "Zatiaľ žiadne riadky",
+    row_label: "Riadok {{row}}",
+    actions_label: "Akcie",
+    move_row_up: "Posunúť riadok {{row}} vyššie",
+    move_row_down: "Posunúť riadok {{row}} nižšie",
+    remove_row: "Odstrániť riadok {{row}}",
+    added_row: "Pridaný riadok {{row}}",
+    removed_row: "Odstránený riadok {{row}}",
+    moved_row: "Riadok presunutý na pozíciu {{position}} z {{total}}",
+    unknown_row_warning: "Tento riadok nie je záznam, ktorý vie tento editor zobraziť. Zostáva nezmenený.",
+    err_rows_required: "Vyžaduje sa aspoň jeden riadok",
+    err_max_rows: "Maximálny počet riadkov je {{max}}",
+    err_cell: "Riadok {{row}}, {{column}}: {{message}}",
+    err_number: "nie je číslo",
+    err_url: "musí byť webová adresa začínajúca na http:// alebo https://",
+    err_date: "nie je platný dátum",
+    err_select_unknown: "„{{value}}“ nie je medzi možnosťami",
+    err_maxlength: "príliš dlhé (max. {{max}} znakov)",
+};

package/dist/components/Input/field-table-i18n.d.ts

@@ -0,0 +1,60 @@
+import type { TranslateFn } from "../../types.js";
+/**
+ * The built-in (English) message catalog of `FieldTable`. Also the fallback of every
+ * other bundled locale, so a locale missing a key still renders text.
+ *
+ * Placeholders are mustache-style (`{{row}}`, `{{max}}`, ...).
+ */
+export declare const FIELD_TABLE_MESSAGES_EN: {
+    field_req_att: string;
+    add_row: string;
+    empty_message: string;
+    row_label: string;
+    actions_label: string;
+    move_row_up: string;
+    move_row_down: string;
+    remove_row: string;
+    added_row: string;
+    removed_row: string;
+    moved_row: string;
+    unknown_row_warning: string;
+    err_rows_required: string;
+    err_max_rows: string;
+    err_cell: string;
+    err_number: string;
+    err_url: string;
+    err_date: string;
+    err_select_unknown: string;
+    err_maxlength: string;
+};
+/** Every message key `FieldTable` may look up. */
+export type FieldTableMessageKey = keyof typeof FIELD_TABLE_MESSAGES_EN;
+/** A (possibly partial) catalog for one locale. */
+export type FieldTableMessages = Record<FieldTableMessageKey, string>;
+/**
+ * Builds the `t` prop of `FieldTable` from a message catalog. Unknown or untranslated
+ * keys fall back to `fallbackMessages` (English by default), so a catalog may safely be
+ * partial and never renders a raw key.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import {
+ *     FieldTable,
+ *     createFieldTableT,
+ *     FIELD_TABLE_MESSAGES_SK,
+ *   } from "@marianmeres/stuic";
+ *
+ *   // full locale, plus a field specific tweak
+ *   const t = createFieldTableT({
+ *     ...FIELD_TABLE_MESSAGES_SK,
+ *     add_row: "Pridať položku",
+ *   });
+ * </script>
+ *
+ * <FieldTable name="items" bind:value {columns} {t} />
+ * ```
+ */
+export declare function createFieldTableT(messages: Partial<FieldTableMessages> | Record<string, string>, fallbackMessages?: Partial<FieldTableMessages> | Record<string, string>): TranslateFn;
+/** The component's built-in English `t`. */
+export declare const t_default: TranslateFn;

package/dist/components/Input/field-table-i18n.js

@@ -0,0 +1,66 @@
+import { isPlainObject } from "../../utils/is-plain-object.js";
+import { replaceMap } from "../../utils/replace-map.js";
+/**
+ * The built-in (English) message catalog of `FieldTable`. Also the fallback of every
+ * other bundled locale, so a locale missing a key still renders text.
+ *
+ * Placeholders are mustache-style (`{{row}}`, `{{max}}`, ...).
+ */
+export const FIELD_TABLE_MESSAGES_EN = {
+    field_req_att: "This field requires attention. Please review and try again.",
+    add_row: "Add row",
+    empty_message: "No rows yet",
+    row_label: "Row {{row}}",
+    actions_label: "Actions",
+    move_row_up: "Move row {{row}} up",
+    move_row_down: "Move row {{row}} down",
+    remove_row: "Remove row {{row}}",
+    added_row: "Row {{row}} added",
+    removed_row: "Row {{row}} removed",
+    moved_row: "Row moved to position {{position}} of {{total}}",
+    unknown_row_warning: "This row is not a record this editor can show. It is kept unchanged.",
+    err_rows_required: "At least one row is required",
+    err_max_rows: "Maximum number of rows is {{max}}",
+    err_cell: "Row {{row}}, {{column}}: {{message}}",
+    err_number: "not a number",
+    err_url: "must be a web address starting with http:// or https://",
+    err_date: "not a valid date",
+    err_select_unknown: "“{{value}}” is not one of the choices",
+    err_maxlength: "too long (max {{max}} characters)",
+};
+/**
+ * Builds the `t` prop of `FieldTable` from a message catalog. Unknown or untranslated
+ * keys fall back to `fallbackMessages` (English by default), so a catalog may safely be
+ * partial and never renders a raw key.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import {
+ *     FieldTable,
+ *     createFieldTableT,
+ *     FIELD_TABLE_MESSAGES_SK,
+ *   } from "@marianmeres/stuic";
+ *
+ *   // full locale, plus a field specific tweak
+ *   const t = createFieldTableT({
+ *     ...FIELD_TABLE_MESSAGES_SK,
+ *     add_row: "Pridať položku",
+ *   });
+ * </script>
+ *
+ * <FieldTable name="items" bind:value {columns} {t} />
+ * ```
+ */
+export function createFieldTableT(messages, fallbackMessages = FIELD_TABLE_MESSAGES_EN) {
+    return (k, values = null, fallback = "") => {
+        const out = messages[k] ??
+            fallbackMessages[k] ??
+            (typeof fallback === "string" ? fallback : k);
+        return isPlainObject(values)
+            ? replaceMap(out, values)
+            : out;
+    };
+}
+/** The component's built-in English `t`. */
+export const t_default = createFieldTableT(FIELD_TABLE_MESSAGES_EN);

package/dist/components/Input/field-table-number.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Locale-aware number parsing and formatting for `FieldTable`'s `number` cells.
+ *
+ * Pure functions (no DOM), so they can be unit-tested in the fast node project.
+ * The rule they implement is "never guess": a typed value is either read as one
+ * unambiguous number, or rejected.
+ */
+/** A parse outcome — `null` is "blank" (an empty cell), never an error. */
+export type ParsedCellNumber = {
+    ok: true;
+    value: number | null;
+} | {
+    ok: false;
+};
+/**
+ * The decimal separator `Intl` uses for `locale` (`"."` for `en`, `","` for `sk`).
+ * `undefined` means the runtime's default locale. An unknown locale falls back to `"."`.
+ */
+export declare function decimalSeparator(locale?: string): string;
+/**
+ * Parses what a user typed into a number cell.
+ *
+ * - Whitespace anywhere (including NBSP / narrow NBSP) is stripped: `"1 000"` → `1000`.
+ * - `"."` is always accepted as the decimal separator.
+ * - `","` is accepted as the decimal separator **only** when `locale` uses it. Under an
+ *   English locale `"1,000"` is rejected — it is never silently read as a thousands group.
+ * - Two separators (`"1.2.3"`, `"1,2,3"`, `"1,000.5"`) are rejected.
+ * - A Unicode minus (`"−5"`, what `Intl` formats in some locales) reads as a minus sign.
+ * - Blank is `{ ok: true, value: null }`.
+ *
+ * @example
+ * ```ts
+ * parseCellNumber("4.2", "sk");  // { ok: true, value: 4.2 }
+ * parseCellNumber("4,2", "sk");  // { ok: true, value: 4.2 }
+ * parseCellNumber("4,2", "en");  // { ok: false }
+ * parseCellNumber("1 000", "en"); // { ok: true, value: 1000 }
+ * parseCellNumber("", "en");     // { ok: true, value: null }
+ * ```
+ */
+export declare function parseCellNumber(raw: string, locale?: string): ParsedCellNumber;
+/**
+ * Formats a number for display in a number cell: no grouping, up to 20 fraction
+ * digits (so `4.2` is never rounded away), Latin digits, the locale's decimal
+ * separator. A Slovak user sees `4,2` for `4.2`; an English one `4.2`.
+ *
+ * A non-finite input yields `""`.
+ */
+export declare function formatCellNumber(n: number, locale?: string): string;