@nanahoshi/mona-ui 0.23.3 → 0.24.1

package/fesm2022/nanahoshi-mona-ui-i18n.mjs

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, signal, computed, Injectable, isDevMode, ElementRef, DestroyRef, makeEnvironmentProviders } from '@angular/core';
+import { InjectionToken, inject, signal, computed, Injectable, isDevMode, ElementRef, DestroyRef, afterNextRender, Injector, makeEnvironmentProviders, provideAppInitializer } from '@angular/core';
 import { Directionality } from '@angular/cdk/bidi';
 import { DateTime } from 'luxon';
 
@@ -83,19 +83,36 @@ function mergeMessages(fallback, localeMessages, overrideMessages) {
 
 class MonaI18nService {
     #config;
+    #loadError;
+    #loadedLocales;
+    #loadingLocaleId;
     #locale;
     #localeOverrides;
     #overrides;
+    /** Incremented by every `load()` and `use()`, so only the latest request changes the locale. */
+    #localeRequest;
     constructor() {
         this.#config = inject(MONA_I18N_CONFIG);
+        this.#loadError = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#loadError" }] : /* istanbul ignore next */ []));
+        this.#loadedLocales = new Map();
+        this.#loadingLocaleId = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#loadingLocaleId" }] : /* istanbul ignore next */ []));
         this.#locale = signal(this.#config.locale ?? MONA_DEFAULT_LOCALE, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "#locale" }] : /* istanbul ignore next */ []));
         this.#localeOverrides = signal(createLocaleOverrides(this.#config.localeMessages), /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "#localeOverrides" }] : /* istanbul ignore next */ []));
         this.#overrides = signal(this.#config.messages ?? {}, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "#overrides" }] : /* istanbul ignore next */ []));
+        /** Incremented by every `load()` and `use()`, so only the latest request changes the locale. */
+        this.#localeRequest = 0;
         this.direction = computed(() => this.#locale().direction, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "direction" }] : /* istanbul ignore next */ []));
+        /** The error of the latest `load()` when it failed, otherwise `null`. */
+        this.loadError = this.#loadError.asReadonly();
+        /** Whether a `load()` is in progress and has not been superseded. */
+        this.loading = computed(() => this.#loadingLocaleId() != null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "loading" }] : /* istanbul ignore next */ []));
         this.locale = this.#locale.asReadonly();
         /**
          * Canonical BCP 47 id of the active locale. POSIX ids such as `en_US` are converted to `en-US`,
@@ -131,6 +148,51 @@ class MonaI18nService {
             return mergeTwo(merged, localeOverrideMessages);
         });
     }
+    /**
+     * Loads a locale with the `loadLocale` function configured in `provideMonaI18n` and switches to it.
+     *
+     * - Ids are canonicalized, and each locale is loaded once: later calls reuse it, and concurrent calls for the
+     *   same id share one request.
+     * - The latest `load()` or `use()` wins. When a newer one starts before this one finishes, this one resolves
+     *   without switching.
+     * - When loading fails, the current locale stays, `loadError` is set and the promise rejects. The failed
+     *   locale is not cached, so a later call retries it.
+     */
+    async load(localeId) {
+        const loadLocale = this.#config.loadLocale;
+        if (loadLocale == null) {
+            throw new Error("[mona-ui] MonaI18nService.load() needs a loader: provideMonaI18n({ loadLocale: loadMonaLocale }).");
+        }
+        const canonicalId = canonicalizeLocaleId(localeId);
+        const request = ++this.#localeRequest;
+        this.#loadingLocaleId.set(canonicalId);
+        this.#loadError.set(null);
+        let pending = this.#loadedLocales.get(canonicalId);
+        if (pending == null) {
+            pending = Promise.resolve().then(() => loadLocale(canonicalId));
+            this.#loadedLocales.set(canonicalId, pending);
+        }
+        try {
+            const locale = await pending;
+            if (request === this.#localeRequest) {
+                this.#applyLocale(locale);
+            }
+        }
+        catch (error) {
+            if (this.#loadedLocales.get(canonicalId) === pending) {
+                this.#loadedLocales.delete(canonicalId);
+            }
+            if (request === this.#localeRequest) {
+                this.#loadError.set(error);
+            }
+            throw error;
+        }
+        finally {
+            if (request === this.#localeRequest) {
+                this.#loadingLocaleId.set(null);
+            }
+        }
+    }
     /**
      * Merges overrides into the existing ones. With `options.locale`, they apply only while that locale is
      * active, so overrides patched for German do not show after switching to English.
@@ -154,7 +216,14 @@ class MonaI18nService {
         const localeId = canonicalizeLocaleId(options.locale);
         this.#localeOverrides.update(current => new Map(current).set(localeId, messages));
     }
+    /** Switches to a locale that is already loaded. It supersedes a `load()` still in progress. */
     use(locale) {
+        this.#localeRequest++;
+        this.#loadingLocaleId.set(null);
+        this.#loadError.set(null);
+        this.#applyLocale(locale);
+    }
+    #applyLocale(locale) {
         warnOnInvalidLocaleId(locale.id);
         this.#locale.set(locale);
     }
@@ -241,39 +310,94 @@ function resolveComponentDirection(hostElement, directionality) {
     }
     return "ltr";
 }
-const documentObservers = new WeakMap();
-function observeDocumentDirChanges(doc, callback) {
-    let entry = documentObservers.get(doc);
-    if (!entry) {
-        const callbacks = new Set();
-        const observer = new MutationObserver(() => {
-            for (const cb of Array.from(callbacks)) {
-                cb();
+/**
+ * One `dir` attribute observer per observed root (the document element, a shadow root, or the top of a detached
+ * tree), shared by every direction-aware instance under it. A mutation only invalidates the instances it can affect,
+ * so a `dir` written on an overlay pane does not re-resolve every component on the page.
+ */
+const directionRegistries = new WeakMap();
+function isShadowRoot(node) {
+    return node.nodeType === 11 && "host" in node;
+}
+function getComposedParent(node) {
+    if (node.parentNode) {
+        return node.parentNode;
+    }
+    return isShadowRoot(node) ? node.host : null;
+}
+function composedContains(ancestor, node) {
+    for (let current = node; current; current = getComposedParent(current)) {
+        if (current === ancestor) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * A `dir` change affects an instance when it lands on the instance's element or one of its ancestors, or anywhere
+ * inside the `dir="auto"` root it resolves against (a nested explicit direction changes which text counts).
+ */
+function isAffectedByDirChange(subscriber, targets) {
+    for (let current = subscriber.element; current; current = getComposedParent(current)) {
+        if (targets.has(current)) {
+            return true;
+        }
+    }
+    const autoRoot = subscriber.autoRoot;
+    if (autoRoot) {
+        for (const target of targets) {
+            if (composedContains(autoRoot, target)) {
+                return true;
             }
-        });
-        if (doc.documentElement) {
-            observer.observe(doc.documentElement, {
-                attributes: true,
-                attributeFilter: ["dir"],
-                subtree: true
-            });
         }
-        entry = { refCount: 0, observer, callbacks };
-        documentObservers.set(doc, entry);
     }
-    entry.refCount++;
-    entry.callbacks.add(callback);
-    let cleanedUp = false;
+    return false;
+}
+function getObservedRoots(element) {
+    const roots = [];
+    let root = element.getRootNode?.() ?? null;
+    while (root && isShadowRoot(root)) {
+        roots.push(root);
+        root = root.host.getRootNode?.() ?? null;
+    }
+    // The top of a detached tree, so a host that is not attached yet still sees its own subtree change.
+    if (root && root !== element && root.nodeType === 1) {
+        roots.push(root);
+    }
+    const documentElement = element.ownerDocument?.documentElement;
+    if (documentElement && !roots.includes(documentElement)) {
+        roots.push(documentElement);
+    }
+    return roots;
+}
+function registerDirectionSubscriber(observedRoot, subscriber) {
+    let registry = directionRegistries.get(observedRoot);
+    if (!registry) {
+        const subscribers = new Set();
+        const observer = new MutationObserver(records => {
+            const targets = new Set();
+            for (const record of records) {
+                targets.add(record.target);
+            }
+            for (const candidate of Array.from(subscribers)) {
+                if (subscribers.has(candidate) && isAffectedByDirChange(candidate, targets)) {
+                    candidate.invalidate();
+                }
+            }
+        });
+        observer.observe(observedRoot, { attributes: true, attributeFilter: ["dir"], subtree: true });
+        registry = { observer, subscribers };
+        directionRegistries.set(observedRoot, registry);
+    }
+    const activeRegistry = registry;
+    activeRegistry.subscribers.add(subscriber);
     return () => {
-        if (cleanedUp || !entry) {
-            return;
-        }
-        cleanedUp = true;
-        entry.callbacks.delete(callback);
-        entry.refCount--;
-        if (entry.refCount <= 0) {
-            entry.observer.disconnect();
-            documentObservers.delete(doc);
+        activeRegistry.subscribers.delete(subscriber);
+        if (activeRegistry.subscribers.size === 0) {
+            activeRegistry.observer.disconnect();
+            if (directionRegistries.get(observedRoot) === activeRegistry) {
+                directionRegistries.delete(observedRoot);
+            }
         }
     };
 }
@@ -320,46 +444,61 @@ function observeAutoDirectionChanges(autoRoot, callback) {
         }
     };
 }
+/** The nearest `dir="auto"` ancestor-or-self, unless an explicit `ltr`/`rtl` comes first. */
+function findAutoRoot(element) {
+    for (let current = element; current; current = current.parentElement) {
+        const rawDir = current.getAttribute?.("dir")?.trim().toLowerCase();
+        if (rawDir === "auto") {
+            return current;
+        }
+        if (rawDir === "rtl" || rawDir === "ltr") {
+            return null;
+        }
+    }
+    return null;
+}
 function observeComponentDirection(hostElement, directionality, onChange) {
     const element = hostElement instanceof ElementRef ? hostElement.nativeElement : hostElement;
+    const canObserve = typeof MutationObserver !== "undefined" && !!element;
     let currentDir = resolveComponentDirection(element, directionality);
     let unobserveAuto = null;
-    let observedAutoElement = null;
+    const rootSubscriptions = new Map();
+    const subscriber = element
+        ? { autoRoot: null, element, invalidate: () => check() }
+        : null;
     const updateAutoContentObserver = () => {
-        if (typeof MutationObserver === "undefined" || !element) {
+        if (!canObserve || !subscriber) {
             return;
         }
-        let autoRoot = null;
-        let current = element;
-        while (current) {
-            const rawDir = current.getAttribute?.("dir")?.trim().toLowerCase();
-            if (rawDir === "auto") {
-                autoRoot = current;
-                break;
-            }
-            if (rawDir === "rtl" || rawDir === "ltr") {
-                break;
-            }
-            current = current.parentElement;
+        const autoRoot = findAutoRoot(subscriber.element);
+        if (autoRoot === subscriber.autoRoot) {
+            return;
         }
-        if (autoRoot) {
-            if (observedAutoElement !== autoRoot) {
-                if (unobserveAuto) {
-                    unobserveAuto();
-                }
-                observedAutoElement = autoRoot;
-                unobserveAuto = observeAutoDirectionChanges(autoRoot, () => check());
+        unobserveAuto?.();
+        unobserveAuto = autoRoot ? observeAutoDirectionChanges(autoRoot, () => check()) : null;
+        subscriber.autoRoot = autoRoot;
+    };
+    // Re-registers with the roots the host is under now: it may have been created in a detached view and inserted
+    // into the document or a shadow root later.
+    const syncObservedRoots = () => {
+        if (!canObserve || !subscriber) {
+            return;
+        }
+        const roots = getObservedRoots(subscriber.element);
+        for (const [root, unsubscribe] of rootSubscriptions) {
+            if (!roots.includes(root)) {
+                unsubscribe();
+                rootSubscriptions.delete(root);
             }
         }
-        else {
-            if (unobserveAuto) {
-                unobserveAuto();
-                unobserveAuto = null;
-                observedAutoElement = null;
+        for (const root of roots) {
+            if (!rootSubscriptions.has(root)) {
+                rootSubscriptions.set(root, registerDirectionSubscriber(root, subscriber));
             }
         }
     };
     const check = () => {
+        syncObservedRoots();
         updateAutoContentObserver();
         const nextDir = resolveComponentDirection(element, directionality);
         if (nextDir !== currentDir) {
@@ -377,27 +516,24 @@ function observeComponentDirection(hostElement, directionality, onChange) {
         });
         cleanupFns.push(() => sub.unsubscribe());
     }
-    if (typeof MutationObserver !== "undefined") {
-        if (element) {
-            const elObserver = new MutationObserver(() => check());
-            elObserver.observe(element, { attributes: true, attributeFilter: ["dir"] });
-            cleanupFns.push(() => elObserver.disconnect());
-            const root = element.getRootNode?.();
-            if (root && root !== element && root !== element.ownerDocument) {
-                const rootObserver = new MutationObserver(() => check());
-                rootObserver.observe(root, { attributes: true, attributeFilter: ["dir"], subtree: true });
-                cleanupFns.push(() => rootObserver.disconnect());
-            }
-            if (element.ownerDocument) {
-                cleanupFns.push(observeDocumentDirChanges(element.ownerDocument, check));
-            }
-        }
+    if (canObserve && element) {
+        // The host's own dir, which the shared root observers miss while the host is outside them (detached or moved).
+        const hostObserver = new MutationObserver(() => check());
+        hostObserver.observe(element, { attributes: true, attributeFilter: ["dir"] });
+        cleanupFns.push(() => hostObserver.disconnect());
     }
+    syncObservedRoots();
+    cleanupFns.push(() => {
+        for (const unsubscribe of rootSubscriptions.values()) {
+            unsubscribe();
+        }
+        rootSubscriptions.clear();
+    });
     cleanupFns.push(() => {
-        if (unobserveAuto) {
-            unobserveAuto();
-            unobserveAuto = null;
-            observedAutoElement = null;
+        unobserveAuto?.();
+        unobserveAuto = null;
+        if (subscriber) {
+            subscriber.autoRoot = null;
         }
     });
     const handle = Object.assign(() => {
@@ -416,17 +552,17 @@ function injectComponentDirection(hostElementRef) {
     const destroyRef = inject(DestroyRef, { optional: true });
     const domVersion = signal(0, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "domVersion" }] : /* istanbul ignore next */ []));
-    let updateAutoObserverFn = () => { };
     if (destroyRef) {
-        const cleanup = observeComponentDirection(hostRef, directionality, () => {
+        const handle = observeComponentDirection(hostRef, directionality, () => {
             domVersion.update(v => v + 1);
         });
-        updateAutoObserverFn = cleanup.updateAutoObserver;
-        destroyRef.onDestroy(() => cleanup());
+        destroyRef.onDestroy(() => handle());
+        // A host can be moved under a different `dir="auto"` root after it is created; re-check once it has rendered.
+        afterNextRender(() => handle.check(), { injector: inject(Injector) });
     }
+    // Pure: observers are managed by the handle above, never during signal evaluation.
     return computed(() => {
         domVersion();
-        updateAutoObserverFn();
         return resolveComponentDirection(hostRef, directionality);
     });
 }
@@ -452,11 +588,20 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.6", ngImpor
         }] });
 
 function provideMonaI18n(config = {}) {
+    const initialLocale = config.initialLocale;
     return makeEnvironmentProviders([
         {
             provide: MONA_I18N_CONFIG,
             useValue: config
-        }
+        },
+        ...(initialLocale == null
+            ? []
+            : [
+                // A failed load must not stop the application from starting: it keeps the configured locale.
+                provideAppInitializer(() => inject(MonaI18nService)
+                    .load(initialLocale)
+                    .catch((error) => console.error(`[mona-ui] Could not load the initial locale "${initialLocale}".`, error)))
+            ])
     ]);
 }
 
@@ -601,7 +746,12 @@ function getNumberFormatter(locale, options) {
     }
     return formatter;
 }
+/**
+ * Formats a number for the locale. A decimal string, such as one returned by {@link parseLocalizedDecimal}, is
+ * formatted exactly, without converting it to a `number` first.
+ */
 function formatNumber(value, locale, options) {
+    // Intl.NumberFormat formats decimal strings exactly (Intl.NumberFormat v3); the ES2022 lib types only declare numbers.
     return getNumberFormatter(locale, options).format(value);
 }
 /**
@@ -676,7 +826,52 @@ function getEditDecimalSeparators(symbols) {
     }
     return separators;
 }
+const MAX_SAFE_INTEGER_DIGITS = String(Number.MAX_SAFE_INTEGER);
+/** The most significant digits a double reproduces exactly when converted from decimal text and back. */
+const MAX_EXACT_SIGNIFICANT_DIGITS = 15;
+/** Whether ASCII integer and fraction digits survive conversion to a `number` unchanged. */
+function isRepresentableAsNumber(intDigits, fracDigits) {
+    const integer = intDigits.replace(/^0+/, "");
+    const fraction = fracDigits.replace(/0+$/, "");
+    if (fraction === "") {
+        return (integer.length < MAX_SAFE_INTEGER_DIGITS.length ||
+            (integer.length === MAX_SAFE_INTEGER_DIGITS.length && integer <= MAX_SAFE_INTEGER_DIGITS));
+    }
+    return (integer + fraction).replace(/^0+/, "").length <= MAX_EXACT_SIGNIFICANT_DIGITS;
+}
+function partsToNumber(parts) {
+    if (!isRepresentableAsNumber(parts.integer, parts.fraction)) {
+        return "precision";
+    }
+    return Number((parts.negative ? "-" : "") + parts.integer + (parts.fraction ? "." + parts.fraction : ""));
+}
+/** Leading zeros, trailing fraction zeros and the sign of zero are dropped: `"-0012.500"` becomes `"-12.5"`. */
+function partsToDecimal(parts) {
+    const integer = parts.integer.replace(/^0+(?=\d)/, "") || "0";
+    const fraction = parts.fraction.replace(/0+$/, "");
+    const digits = fraction ? `${integer}.${fraction}` : integer;
+    return parts.negative && /[1-9]/.test(digits) ? `-${digits}` : digits;
+}
+/**
+ * Parses localized text to a number. Returns `null` when the text is not a number in the locale, or when a
+ * `number` cannot hold it exactly (see {@link LocalizedNumberInvalidReason}); it never rounds silently.
+ * Use {@link parseLocalizedDecimal} for values that need more precision.
+ */
 function parseLocalizedNumber(text, localeId, options) {
+    const parts = parseLocalizedNumberParts(text, localeId, options);
+    const value = parts === null ? null : partsToNumber(parts);
+    return value === "precision" ? null : value;
+}
+/**
+ * Parses localized text with the same rules as {@link parseLocalizedNumber}, but returns a canonical decimal string
+ * (`"-1234.5"`: ASCII digits, `.` as the decimal separator, no grouping, exponent, leading zeros or trailing
+ * fraction zeros) and has no precision limit. Returns `null` when the text is not a number in the locale.
+ */
+function parseLocalizedDecimal(text, localeId, options) {
+    const parts = parseLocalizedNumberParts(text, localeId, options);
+    return parts === null ? null : partsToDecimal(parts);
+}
+function parseLocalizedNumberParts(text, localeId, options) {
     if (text == null) {
         return null;
     }
@@ -819,9 +1014,7 @@ function parseLocalizedNumber(text, localeId, options) {
                 }
             }
         }
-        const normalizedStr = sign + intPart + (fracPart && fracPart.length > 0 ? "." + fracPart : "");
-        const num = Number(normalizedStr);
-        return Number.isFinite(num) ? num : null;
+        return { fraction: fracPart ?? "", integer: intPart, negative: sign === "-" };
     }
     else {
         // mode === "edit": editor buffer grammar with exactly one decimal separator (locale primary or alternate)
@@ -875,11 +1068,7 @@ function parseLocalizedNumber(text, localeId, options) {
             intPart = cleaned;
             fracPart = "";
         }
-        const normalizedStr = sign +
-            (intPart.length > 0 ? intPart : "0") +
-            (fracPart.length > 0 ? "." + fracPart : cleaned.endsWith(foundSep ?? "") ? "" : "");
-        const num = Number(normalizedStr);
-        return Number.isFinite(num) ? num : null;
+        return { fraction: fracPart, integer: intPart.length > 0 ? intPart : "0", negative: sign === "-" };
     }
 }
 function validateLocalizedNumber(text, localeId, options) {
@@ -891,9 +1080,13 @@ function validateLocalizedNumber(text, localeId, options) {
         return { value: null, valid: true, fractionDigits: 0 };
     }
     const mode = options?.mode ?? "locale";
-    const parsed = parseLocalizedNumber(trimmed, localeId, { mode });
+    const parts = parseLocalizedNumberParts(trimmed, localeId, { mode });
+    const parsed = parts === null ? null : partsToNumber(parts);
+    if (parsed === "precision") {
+        return { value: null, valid: false, fractionDigits: 0, reason: "precision" };
+    }
     if (parsed === null || !Number.isFinite(parsed)) {
-        return { value: null, valid: false, fractionDigits: 0 };
+        return { value: null, valid: false, fractionDigits: 0, reason: "syntax" };
     }
     // Determine the number of fraction digits from the source string
     const symbols = getNumberSymbols(localeId);
@@ -952,11 +1145,42 @@ function validateLocalizedNumber(text, localeId, options) {
         }
     }
     if (options?.decimals !== undefined && fractionDigits > options.decimals) {
-        return { value: parsed, valid: false, fractionDigits };
+        return { value: parsed, valid: false, fractionDigits, reason: "decimals" };
     }
     return { value: parsed, valid: true, fractionDigits };
 }
+/**
+ * Validates localized text like {@link validateLocalizedNumber}, but returns a canonical decimal string and has no
+ * precision limit, so `reason` is never `"precision"`.
+ */
+function validateLocalizedDecimal(text, localeId, options) {
+    const trimmed = text == null ? "" : String(text).trim();
+    if (trimmed === "" || trimmed === "-" || trimmed === "+") {
+        return { fractionDigits: 0, valid: true, value: null };
+    }
+    const parts = parseLocalizedNumberParts(trimmed, localeId, { mode: options?.mode ?? "locale" });
+    if (parts === null) {
+        return { fractionDigits: 0, reason: "syntax", valid: false, value: null };
+    }
+    const value = partsToDecimal(parts);
+    const fractionDigits = parts.fraction.length;
+    if (options?.decimals !== undefined && fractionDigits > options.decimals) {
+        return { fractionDigits, reason: "decimals", valid: false, value };
+    }
+    return { fractionDigits, valid: true, value };
+}
+const EDIT_SYNTAX_ERROR = { complete: false, reason: "syntax", valid: false, value: null };
 function validateLocalizedNumberEdit(text, localeId, options) {
+    return validateEditInput(text, localeId, options, partsToNumber);
+}
+/**
+ * Validates text while it is typed, like {@link validateLocalizedNumberEdit}, but returns a canonical decimal string
+ * and has no precision limit.
+ */
+function validateLocalizedDecimalEdit(text, localeId, options) {
+    return validateEditInput(text, localeId, options, partsToDecimal);
+}
+function validateEditInput(text, localeId, options, convert) {
     if (text == null) {
         return { valid: true, complete: false, value: null };
     }
@@ -966,7 +1190,7 @@ function validateLocalizedNumberEdit(text, localeId, options) {
     }
     // Reject control or whitespace characters in interactive typing
     if (/[\s\u00A0\u202F]/.test(raw)) {
-        return { valid: false, complete: false, value: null };
+        return EDIT_SYNTAX_ERROR;
     }
     const symbols = getNumberSymbols(localeId);
     // Normalize minus signs and bidi controls
@@ -977,12 +1201,12 @@ function validateLocalizedNumberEdit(text, localeId, options) {
     const allowSign = options?.allowSign ?? true;
     if (normalized.startsWith("-") || normalized.startsWith("+")) {
         if (!allowSign) {
-            return { valid: false, complete: false, value: null };
+            return EDIT_SYNTAX_ERROR;
         }
         normalized = normalized.slice(1);
     }
     if (normalized.includes("-") || normalized.includes("+")) {
-        return { valid: false, complete: false, value: null };
+        return EDIT_SYNTAX_ERROR;
     }
     // If input was just "-" or "+"
     if (normalized === "") {
@@ -997,7 +1221,7 @@ function validateLocalizedNumberEdit(text, localeId, options) {
             if (normalized.startsWith(sep, i)) {
                 if (foundSep !== null) {
                     // More than one separator is rejected in edit mode
-                    return { valid: false, complete: false, value: null };
+                    return EDIT_SYNTAX_ERROR;
                 }
                 foundSep = sep;
                 sepIndex = i;
@@ -1010,23 +1234,28 @@ function validateLocalizedNumberEdit(text, localeId, options) {
     if (foundSep !== null) {
         if (decimals === 0) {
             // No decimal point permitted when decimals === 0
-            return { valid: false, complete: false, value: null };
+            return { valid: false, complete: false, value: null, reason: "decimals" };
         }
         const intPart = normalized.slice(0, sepIndex);
         const fracPart = normalized.slice(sepIndex + foundSep.length);
         // Integer part before separator must consist purely of ASCII digits (or empty, e.g. ".5")
         if (intPart.length > 0 && !/^\d+$/.test(intPart)) {
-            return { valid: false, complete: false, value: null };
+            return EDIT_SYNTAX_ERROR;
         }
         // Fractional part after separator must consist purely of ASCII digits (or empty, e.g. "12.")
         if (fracPart.length > 0 && !/^\d+$/.test(fracPart)) {
-            return { valid: false, complete: false, value: null };
+            return EDIT_SYNTAX_ERROR;
         }
         // Count fraction digits using normalized ASCII characters (safe against UTF-16 astral splitting)
         if (fracPart.length > decimals) {
-            return { valid: false, complete: false, value: null };
+            return { valid: false, complete: false, value: null, reason: "decimals" };
+        }
+        const parts = parseLocalizedNumberParts(raw, localeId, { mode: "edit" });
+        const parsed = parts === null ? null : convert(parts);
+        // Refuse the keystroke that would make the value too precise for the target type, instead of rounding it.
+        if (parsed === "precision") {
+            return { valid: false, complete: false, value: null, reason: "precision" };
         }
-        const parsed = parseLocalizedNumber(raw, localeId, { mode: "edit" });
         const complete = fracPart.length > 0 && (intPart.length > 0 || fracPart.length > 0);
         return {
             valid: true,
@@ -1036,9 +1265,13 @@ function validateLocalizedNumberEdit(text, localeId, options) {
     }
     // No separator found: must be purely ASCII digits
     if (!/^\d+$/.test(normalized)) {
-        return { valid: false, complete: false, value: null };
+        return EDIT_SYNTAX_ERROR;
+    }
+    const parts = parseLocalizedNumberParts(raw, localeId, { mode: "edit" });
+    const parsed = parts === null ? null : convert(parts);
+    if (parsed === "precision") {
+        return { valid: false, complete: false, value: null, reason: "precision" };
     }
-    const parsed = parseLocalizedNumber(raw, localeId, { mode: "edit" });
     return {
         valid: true,
         complete: true,
@@ -4979,5 +5212,5 @@ function generatePseudoLocale(catalogs, options) {
  * Generated bundle index. Do not edit.
  */
 
-export { BIDI_CONTROL_REGEX, MONA_DEFAULT_LOCALE, MONA_I18N_CONFIG, MonaDirectionService, MonaI18nService, formatGregorianDateToLocaleString, formatNumber, generatePseudoLocale, getEditDecimalSeparators, getLocaleDateInputFormat, getLocaleDateTimeInputFormat, getLocaleFirstDayOfWeek, getLocaleTimeInputFormat, getNumberFormatter, getNumberGroupingPattern, getNumberSymbols, gregorianDateTime, gregorianDateTimeFromObject, injectComponentDirection, mergeMessages, mergeTwo, normalizeGregorianLocale, normalizeLocalizedDigits, normalizeLocalizedInput, normalizeLocalizedMinus, observeComponentDirection, parseGregorianDate, parseLocalizedNumber, provideMonaI18n, pseudoLocalize, pseudoLocalizeCatalog, resolveComponentDirection, sanitizeDateText, stripBidiControls, validateLocalizedNumber, validateLocalizedNumberEdit };
+export { BIDI_CONTROL_REGEX, MONA_DEFAULT_LOCALE, MONA_FALLBACK_LOCALE_ID, MONA_I18N_CONFIG, MonaDirectionService, MonaI18nService, canonicalizeLocaleId, formatGregorianDateToLocaleString, formatNumber, generatePseudoLocale, getEditDecimalSeparators, getLocaleDateInputFormat, getLocaleDateTimeInputFormat, getLocaleFirstDayOfWeek, getLocaleTimeInputFormat, getNumberFormatter, getNumberGroupingPattern, getNumberSymbols, gregorianDateTime, gregorianDateTimeFromObject, injectComponentDirection, mergeMessages, mergeTwo, normalizeGregorianLocale, normalizeLocalizedDigits, normalizeLocalizedInput, normalizeLocalizedMinus, observeComponentDirection, parseGregorianDate, parseLocalizedDecimal, parseLocalizedNumber, provideMonaI18n, pseudoLocalize, pseudoLocalizeCatalog, resolveComponentDirection, sanitizeDateText, stripBidiControls, tryCanonicalizeLocaleId, validateLocalizedDecimal, validateLocalizedDecimalEdit, validateLocalizedNumber, validateLocalizedNumberEdit };
 //# sourceMappingURL=nanahoshi-mona-ui-i18n.mjs.map

package/fesm2022/nanahoshi-mona-ui-internal-list.mjs

@@ -14,6 +14,8 @@ import { v4 } from 'uuid';
 import { cva } from 'class-variance-authority';
 import { CheckboxDirective } from '@nanahoshi/mona-ui/check-box';
 
+// Generated from i18n/catalogs/en-US.messages.json by scripts/generate-locale-catalogs.ts. Do not edit.
+// Edit the JSON file and run `npm run generate:locale-catalogs`.
 const LIST_DEFAULT_MESSAGES = {
     filterList: "Filter list",
     noData: "No data"

package/fesm2022/nanahoshi-mona-ui-internal-tree.mjs

@@ -1352,6 +1352,8 @@ const treeNodeExpanderThemeVariants = cva(`
         cursor-pointer text-sm text-foreground
     `);
 
+// Generated from i18n/catalogs/en-US.messages.json by scripts/generate-locale-catalogs.ts. Do not edit.
+// Edit the JSON file and run `npm run generate:locale-catalogs`.
 const TREE_DEFAULT_MESSAGES = {
     collapse: "Collapse",
     expand: "Expand",