@nanahoshi/mona-ui 0.23.1 → 0.23.2

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

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, signal, computed, Injectable, ElementRef, DestroyRef, makeEnvironmentProviders } from '@angular/core';
+import { InjectionToken, inject, signal, computed, Injectable, isDevMode, ElementRef, DestroyRef, makeEnvironmentProviders } from '@angular/core';
 import { Directionality } from '@angular/cdk/bidi';
 import { DateTime } from 'luxon';
 
@@ -13,6 +13,45 @@ const MONA_I18N_CONFIG = new InjectionToken("MONA_I18N_CONFIG", {
     factory: () => ({})
 });
 
+/**
+ * Locale id used whenever a supplied id cannot be turned into a valid BCP 47 tag.
+ * Matches the id of `MONA_DEFAULT_LOCALE`.
+ */
+const MONA_FALLBACK_LOCALE_ID = "en-US";
+const canonicalLocaleCache = new Map();
+/**
+ * Converts a locale id to a canonical BCP 47 tag, or returns `null` when it is not a valid tag.
+ *
+ * POSIX/Java style ids are accepted: `en_US` becomes `en-US`, and an encoding or modifier suffix
+ * (`de_DE.UTF-8`, `de_DE@euro`) is dropped.
+ */
+function tryCanonicalizeLocaleId(localeId) {
+    const raw = (localeId ?? "").trim();
+    if (!raw) {
+        return null;
+    }
+    if (canonicalLocaleCache.has(raw)) {
+        return canonicalLocaleCache.get(raw) ?? null;
+    }
+    let canonical = null;
+    try {
+        const tag = raw.replace(/[.@].*$/, "").replace(/_/g, "-");
+        canonical = Intl.getCanonicalLocales(tag)[0] ?? null;
+    }
+    catch {
+        canonical = null;
+    }
+    canonicalLocaleCache.set(raw, canonical);
+    return canonical;
+}
+/**
+ * Converts a locale id to a canonical BCP 47 tag. Ids that are empty or not valid tags resolve to
+ * {@link MONA_FALLBACK_LOCALE_ID}, so every formatter receives the same, valid locale.
+ */
+function canonicalizeLocaleId(localeId) {
+    return tryCanonicalizeLocaleId(localeId) ?? MONA_FALLBACK_LOCALE_ID;
+}
+
 function isPlainObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -43,6 +82,9 @@ function mergeMessages(fallback, localeMessages, overrideMessages) {
 }
 
 class MonaI18nService {
+    #config;
+    #locale;
+    #overrides;
     constructor() {
         this.#config = inject(MONA_I18N_CONFIG);
         this.#locale = signal(this.#config.locale ?? MONA_DEFAULT_LOCALE, /* @ts-ignore */
@@ -52,12 +94,14 @@ class MonaI18nService {
         this.direction = computed(() => this.#locale().direction, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "direction" }] : /* istanbul ignore next */ []));
         this.locale = this.#locale.asReadonly();
-        this.localeId = computed(() => this.#locale().id, /* @ts-ignore */
+        /**
+         * Canonical BCP 47 id of the active locale. POSIX ids such as `en_US` are converted to `en-US`,
+         * and invalid ids resolve to `MONA_FALLBACK_LOCALE_ID` so formatters always receive a valid tag.
+         */
+        this.localeId = computed(() => canonicalizeLocaleId(this.#locale().id), /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "localeId" }] : /* istanbul ignore next */ []));
+        warnOnInvalidLocaleId(this.#locale().id);
     }
-    #config;
-    #locale;
-    #overrides;
     clearMessages() {
         this.#overrides.set({});
     }
@@ -75,6 +119,7 @@ class MonaI18nService {
         this.#overrides.set(messages);
     }
     use(locale) {
+        warnOnInvalidLocaleId(locale.id);
         this.#locale.set(locale);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.6", ngImport: i0, type: MonaI18nService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
@@ -85,7 +130,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.6", ngImpor
             args: [{
                     providedIn: "root"
                 }]
-        }] });
+        }], ctorParameters: () => [] });
+function warnOnInvalidLocaleId(localeId) {
+    if (isDevMode() && tryCanonicalizeLocaleId(localeId) == null) {
+        console.warn(`[mona-ui] "${localeId}" is not a valid BCP 47 locale id. Falling back to "${MONA_FALLBACK_LOCALE_ID}".`);
+    }
+}
 
 /**
  * Reads semantic document direction for a connected browser element using `:dir(rtl)` and `:dir(ltr)`.
@@ -366,6 +416,12 @@ function provideMonaI18n(config = {}) {
     ]);
 }
 
+/** Full-width forms of printable ASCII ("！" to "～"), offset from ASCII by U+FEE0. */
+const FULLWIDTH_ASCII_START = 0xff01;
+const FULLWIDTH_ASCII_END = 0xff5e;
+const FULLWIDTH_ASCII_OFFSET = 0xfee0;
+const DECIMAL_DIGIT_REGEX = /^\p{Nd}$/u;
+const asciiDigitCache = new Map();
 const numberSymbolsCache = new Map();
 const numberFormatterCache = new Map();
 const numberGroupingCache = new Map();
@@ -376,7 +432,8 @@ function serializeOptions(options) {
     const keys = Object.keys(options).sort();
     return keys.map(k => `${k}:${String(options[k])}`).join(";");
 }
-function getNumberGroupingPattern(localeId) {
+function getNumberGroupingPattern(locale) {
+    const localeId = canonicalizeLocaleId(locale);
     let pattern = numberGroupingCache.get(localeId);
     if (!pattern) {
         try {
@@ -439,7 +496,8 @@ function getNumberGroupingPattern(localeId) {
     }
     return pattern;
 }
-function getNumberSymbols(localeId) {
+function getNumberSymbols(locale) {
+    const localeId = canonicalizeLocaleId(locale);
     let symbols = numberSymbolsCache.get(localeId);
     if (!symbols) {
         const digitMap = new Map();
@@ -482,7 +540,7 @@ function getNumberSymbols(localeId) {
     return symbols;
 }
 function getNumberFormatter(locale, options) {
-    const cleanLocale = (locale ?? "").trim() || "en-US";
+    const cleanLocale = canonicalizeLocaleId(locale);
     const key = `${cleanLocale}:${serializeOptions(options)}`;
     let formatter = numberFormatterCache.get(key);
     if (!formatter) {
@@ -499,6 +557,30 @@ function getNumberFormatter(locale, options) {
 function formatNumber(value, locale, options) {
     return getNumberFormatter(locale, options).format(value);
 }
+/**
+ * ASCII value of a Unicode decimal digit (\p{Nd}), or null for any other character. Unicode encodes every
+ * decimal digit set as a contiguous 0-9 run, so the value is the distance from the start of the run.
+ */
+function toAsciiDigit(char) {
+    let digit = asciiDigitCache.get(char);
+    if (digit === undefined) {
+        digit = null;
+        if (DECIMAL_DIGIT_REGEX.test(char)) {
+            const code = char.codePointAt(0);
+            let runStart = code;
+            while (DECIMAL_DIGIT_REGEX.test(String.fromCodePoint(runStart - 1))) {
+                runStart--;
+            }
+            digit = String((code - runStart) % 10);
+        }
+        asciiDigitCache.set(char, digit);
+    }
+    return digit;
+}
+/**
+ * Converts digits of any script to ASCII digits. Full-width forms typed by CJK input methods
+ * ("１２．５", "－３", "１，０００") are folded to ASCII first.
+ */
 function normalizeLocalizedDigits(text, localeId) {
     if (!text) {
         return text;
@@ -506,27 +588,11 @@ function normalizeLocalizedDigits(text, localeId) {
     const symbols = localeId ? getNumberSymbols(localeId) : null;
     let result = "";
     for (const char of text) {
-        if (symbols?.digits.has(char)) {
-            result += symbols.digits.get(char);
-        }
-        else {
-            const code = char.charCodeAt(0);
-            if (code >= 0x0660 && code <= 0x0669) {
-                result += String(code - 0x0660);
-            }
-            else if (code >= 0x06f0 && code <= 0x06f9) {
-                result += String(code - 0x06f0);
-            }
-            else if (code >= 0x09e6 && code <= 0x09ef) {
-                result += String(code - 0x09e6);
-            }
-            else if (code >= 0x0966 && code <= 0x096f) {
-                result += String(code - 0x0966);
-            }
-            else {
-                result += char;
-            }
-        }
+        const code = char.codePointAt(0);
+        const folded = code >= FULLWIDTH_ASCII_START && code <= FULLWIDTH_ASCII_END
+            ? String.fromCharCode(code - FULLWIDTH_ASCII_OFFSET)
+            : char;
+        result += symbols?.digits.get(folded) ?? toAsciiDigit(folded) ?? folded;
     }
     return result;
 }
@@ -548,6 +614,21 @@ function normalizeLocalizedInput(text, localeId) {
     cleaned = normalizeLocalizedDigits(cleaned, localeId);
     return cleaned;
 }
+/**
+ * Decimal separators accepted while editing: the locale's own, plus "." and "," so a separator typed on a
+ * keyboard layout that does not match the locale still works. An alternate is dropped when it is the locale's
+ * group separator; otherwise "1,234" typed in en-US (or "1.234" in de-DE) would be read as 1.234.
+ */
+function getEditDecimalSeparators(symbols) {
+    const primary = symbols.decimal || ".";
+    const separators = new Set([primary]);
+    for (const alternate of [".", ","]) {
+        if (alternate !== symbols.group) {
+            separators.add(alternate);
+        }
+    }
+    return separators;
+}
 function parseLocalizedNumber(text, localeId, options) {
     if (text == null) {
         return null;
@@ -699,27 +780,7 @@ function parseLocalizedNumber(text, localeId, options) {
         if (/[\s\u00A0\u202F]/.test(cleaned)) {
             return null;
         }
-        const primaryDec = symbols.decimal || ".";
-        const candidateSeparators = new Set();
-        candidateSeparators.add(primaryDec);
-        if (primaryDec === ".") {
-            candidateSeparators.add(",");
-        }
-        else if (primaryDec === ",") {
-            candidateSeparators.add(".");
-        }
-        else {
-            candidateSeparators.add(".");
-            candidateSeparators.add(",");
-        }
-        if (primaryDec === "\u066B") {
-            candidateSeparators.add(".");
-            candidateSeparators.add(",");
-        }
-        if (primaryDec === "/") {
-            candidateSeparators.add(".");
-            candidateSeparators.add(",");
-        }
+        const candidateSeparators = getEditDecimalSeparators(symbols);
         let foundSep = null;
         let sepIndex = -1;
         for (let i = 0; i < cleaned.length; i++) {
@@ -878,25 +939,7 @@ function validateLocalizedNumberEdit(text, localeId, options) {
     if (normalized === "") {
         return { valid: true, complete: false, value: null };
     }
-    // Identify allowed decimal separators
-    const primaryDec = symbols.decimal || ".";
-    // Candidate separators: primary decimal, plus alternate '.' or ','
-    const candidateSeparators = new Set();
-    candidateSeparators.add(primaryDec);
-    if (primaryDec === ".") {
-        candidateSeparators.add(",");
-    }
-    else if (primaryDec === ",") {
-        candidateSeparators.add(".");
-    }
-    else {
-        candidateSeparators.add(".");
-        candidateSeparators.add(",");
-    }
-    if (primaryDec === "\u066B") {
-        candidateSeparators.add(".");
-        candidateSeparators.add(",");
-    }
+    const candidateSeparators = getEditDecimalSeparators(symbols);
     // Count how many separators from the candidate set appear
     let foundSep = null;
     let sepIndex = -1;
@@ -957,22 +1000,20 @@ function validateLocalizedNumberEdit(text, localeId, options) {
 /**
  * Normalizes a locale string to ensure it uses the Gregorian calendar system
  * and doesn't contain a conflicting -u-ca-* extension.
+ * Empty or malformed ids resolve to `MONA_FALLBACK_LOCALE_ID` (en-US).
  */
 function normalizeGregorianLocale(localeId) {
-    const trimmed = (localeId ?? "").trim();
-    if (!trimmed) {
-        return trimmed;
-    }
+    const canonical = canonicalizeLocaleId(localeId);
     try {
         if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
-            const loc = new Intl.Locale(trimmed, { calendar: "gregory" });
+            const loc = new Intl.Locale(canonical, { calendar: "gregory" });
             return loc.toString();
         }
     }
     catch {
-        // Fallback safely if localeId is malformed
+        // Canonical tags are always accepted; keep the canonical id if Intl.Locale still refuses it
     }
-    return trimmed;
+    return canonical;
 }
 /**
  * Creates a Luxon DateTime from a Date instance, reconfigured to the specified locale
@@ -1023,17 +1064,29 @@ function stripBidiControls(value) {
 function sanitizeDateText(value) {
     return stripBidiControls(value).replace(/[\u00A0\u2009\u202F]/g, " ");
 }
+/**
+ * Luxon throws for formats that mix incompatible fields (e.g. ordinal and month/day tokens). Callers treat
+ * such input as unparsable, so the error becomes an invalid DateTime.
+ */
+function fromFormatSafe(text, format, options) {
+    try {
+        return DateTime.fromFormat(text, format, options);
+    }
+    catch (error) {
+        return DateTime.invalid("unparsable", error instanceof Error ? error.message : String(error));
+    }
+}
 /**
  * Parses a date string using the specified format and locale, forcing Gregorian calendar.
  * Localized digits are normalized first to support locales that use native numbering systems.
  */
 function parseGregorianDate(text, format, localeId) {
     const locale = normalizeGregorianLocale(localeId);
-    let dt = DateTime.fromFormat(text, format, { locale, outputCalendar: "gregory" });
+    let dt = fromFormatSafe(text, format, { locale, outputCalendar: "gregory" });
     if (!dt.isValid) {
         const sanitizedText = sanitizeDateText(text);
         const sanitizedFormat = sanitizeDateText(format);
-        dt = DateTime.fromFormat(sanitizedText, sanitizedFormat, { locale, outputCalendar: "gregory" });
+        dt = fromFormatSafe(sanitizedText, sanitizedFormat, { locale, outputCalendar: "gregory" });
         if (!dt.isValid) {
             let normalizedText = normalizeLocalizedDigits(sanitizedText, locale);
             let latnLocale = locale;
@@ -1045,20 +1098,20 @@ function parseGregorianDate(text, format, localeId) {
             catch {
                 // fallback
             }
-            dt = DateTime.fromFormat(normalizedText, sanitizedFormat, { locale: latnLocale, outputCalendar: "gregory" });
+            dt = fromFormatSafe(normalizedText, sanitizedFormat, { locale: latnLocale, outputCalendar: "gregory" });
             if (!dt.isValid) {
-                dt = DateTime.fromFormat(normalizedText, sanitizedFormat, { locale, outputCalendar: "gregory" });
+                dt = fromFormatSafe(normalizedText, sanitizedFormat, { locale, outputCalendar: "gregory" });
             }
             if (!dt.isValid) {
                 const effectiveLocale = latnLocale !== locale ? latnLocale : locale;
                 if (sanitizedFormat.includes(". ") && !normalizedText.includes(". ")) {
                     const textWithDotSpaces = normalizedText.replace(/\.(?!\s|$)/g, ". ");
-                    dt = DateTime.fromFormat(textWithDotSpaces, sanitizedFormat, {
+                    dt = fromFormatSafe(textWithDotSpaces, sanitizedFormat, {
                         locale: effectiveLocale,
                         outputCalendar: "gregory"
                     });
                     if (!dt.isValid && effectiveLocale !== locale) {
-                        dt = DateTime.fromFormat(textWithDotSpaces, sanitizedFormat, {
+                        dt = fromFormatSafe(textWithDotSpaces, sanitizedFormat, {
                             locale,
                             outputCalendar: "gregory"
                         });
@@ -1071,12 +1124,12 @@ function parseGregorianDate(text, format, localeId) {
                 if (sanitizedFormat.includes("dd. ") &&
                     /(\b\d{4}\.\s*\d{1,2}\.\s*\d{1,2})\.?\s+/.test(normalizedText)) {
                     const withDotBeforeTime = normalizedText.replace(/(\b\d{4}\.\s*\d{1,2}\.\s*\d{1,2})\.?\s+/, (_match, datePart) => `${datePart}. `);
-                    dt = DateTime.fromFormat(withDotBeforeTime, sanitizedFormat, {
+                    dt = fromFormatSafe(withDotBeforeTime, sanitizedFormat, {
                         locale: effectiveLocale,
                         outputCalendar: "gregory"
                     });
                     if (!dt.isValid && effectiveLocale !== locale) {
-                        dt = DateTime.fromFormat(withDotBeforeTime, sanitizedFormat, {
+                        dt = fromFormatSafe(withDotBeforeTime, sanitizedFormat, {
                             locale,
                             outputCalendar: "gregory"
                         });
@@ -1089,12 +1142,12 @@ function parseGregorianDate(text, format, localeId) {
                 const trimmedText = normalizedText.trim();
                 if (trimmedFormat.endsWith(".")) {
                     const textWithDot = trimmedText.endsWith(".") ? trimmedText : trimmedText + ".";
-                    dt = DateTime.fromFormat(textWithDot, trimmedFormat, {
+                    dt = fromFormatSafe(textWithDot, trimmedFormat, {
                         locale: effectiveLocale,
                         outputCalendar: "gregory"
                     });
                     if (!dt.isValid && effectiveLocale !== locale) {
-                        dt = DateTime.fromFormat(textWithDot, trimmedFormat, {
+                        dt = fromFormatSafe(textWithDot, trimmedFormat, {
                             locale,
                             outputCalendar: "gregory"
                         });
@@ -4560,8 +4613,15 @@ const dateFormatCache = new Map();
 const timeFormatCache = new Map();
 const dateTimeFormatCache = new Map();
 const firstDayCache = new Map();
+/**
+ * Turns an Intl literal part into Luxon format text. ASCII letters would otherwise be read as format tokens
+ * (the "h" in fr-CA "21 h 30", the "klo" in fi-FI "15.09.2026 klo 21.30"), so letter runs are quoted and
+ * apostrophes are doubled.
+ */
 function normalizeEditableLiteral(value) {
-    return sanitizeDateText(value);
+    return sanitizeDateText(value)
+        .replace(/'/g, "''")
+        .replace(/[A-Za-z]+/g, run => `'${run}'`);
 }
 /**
  * Derives a localized numeric date format (e.g. "yyyy/MM/dd" or "dd/MM/yyyy") for the given locale.
@@ -4721,7 +4781,7 @@ function getLocaleDateTimeInputFormat(localeId, options) {
  * Intl.Locale.getWeekInfo(), or CLDR fallbacks.
  */
 function getLocaleFirstDayOfWeek(localeId) {
-    const normalizedLocaleId = (localeId ?? "").trim();
+    const normalizedLocaleId = canonicalizeLocaleId(localeId);
     let firstDay = firstDayCache.get(normalizedLocaleId);
     if (!firstDay) {
         firstDay = resolveLocaleFirstDayOfWeek(normalizedLocaleId);
@@ -4870,5 +4930,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, 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_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 };
 //# sourceMappingURL=nanahoshi-mona-ui-i18n.mjs.map

package/fesm2022/nanahoshi-mona-ui-numeric-text-box.mjs

@@ -10,7 +10,7 @@ import { ButtonDirective } from '@nanahoshi/mona-ui/button';
 import { themeControlSurfaceClasses, rxTimeout } from '@nanahoshi/mona-ui/internal';
 import { Subject, filter, switchMap, of, tap, delay, concatMap, timer, takeUntil, distinctUntilChanged, map } from 'rxjs';
 import { twMerge } from 'tailwind-merge';
-import { MonaI18nService, formatNumber, validateLocalizedNumber, validateLocalizedNumberEdit } from '@nanahoshi/mona-ui/i18n';
+import { MonaI18nService, formatNumber, validateLocalizedNumber, getNumberSymbols, validateLocalizedNumberEdit } from '@nanahoshi/mona-ui/i18n';
 import { TextBoxDirective } from '@nanahoshi/mona-ui/text-box';
 import { cva } from 'class-variance-authority';
 
@@ -521,6 +521,28 @@ class NumericTextBoxComponent {
         }
         this.#pendingPaste = true;
     }
+    /**
+     * The numpad decimal key types "." or "," depending on the keyboard layout, not the locale. Insert the
+     * locale's decimal separator instead, so a de-DE layout used with an en-US locale still types a decimal.
+     */
+    insertLocaleDecimal(event) {
+        const localeId = this.#i18n.localeId();
+        const decimal = getNumberSymbols(localeId).decimal;
+        if (event.key.length !== 1 || event.key === decimal || event.ctrlKey || event.altKey || event.metaKey) {
+            return;
+        }
+        event.preventDefault();
+        const inputElement = this.valueTextBoxRef().nativeElement;
+        const { value, selectionStart, selectionEnd } = inputElement;
+        const start = selectionStart ?? value.length;
+        const end = selectionEnd ?? value.length;
+        const proposedValue = value.slice(0, start) + decimal + value.slice(end);
+        if (!validateLocalizedNumberEdit(proposedValue, localeId, { decimals: this.decimals() }).valid) {
+            return;
+        }
+        inputElement.setRangeText(decimal, start, end, "end");
+        inputElement.dispatchEvent(new Event("input", { bubbles: true }));
+    }
     parseValue(value) {
         const raw = value == null ? "" : value;
         this.rawInputValue.set(raw);
@@ -611,6 +633,10 @@ class NumericTextBoxComponent {
             if (event.key === "ArrowDown") {
                 event.preventDefault();
                 this.decrease();
+                return;
+            }
+            if (event.code === "NumpadDecimal") {
+                this.insertLocaleDecimal(event);
             }
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanahoshi/mona-ui",
-  "version": "0.23.1",
+  "version": "0.23.2",
   "description": "A very light Angular UI framework",
   "author": "Nanahoshi",
   "repository": {

package/types/nanahoshi-mona-ui-i18n.d.ts

@@ -493,7 +493,12 @@ declare class MonaI18nService {
     #private;
     readonly direction: Signal<_nanahoshi_mona_ui_i18n.MonaTextDirection>;
     readonly locale: Signal<MonaLocale>;
+    /**
+     * Canonical BCP 47 id of the active locale. POSIX ids such as `en_US` are converted to `en-US`,
+     * and invalid ids resolve to `MONA_FALLBACK_LOCALE_ID` so formatters always receive a valid tag.
+     */
     readonly localeId: Signal<string>;
+    constructor();
     clearMessages(): void;
     componentMessages<K extends keyof MonaLocaleMessages>(namespace: K, fallback: MonaLocaleMessages[K]): Signal<MonaLocaleMessages[K]>;
     patchMessages(messages: DeepPartial<MonaLocaleMessages>): void;
@@ -537,13 +542,23 @@ interface NumberGroupingPattern {
     readonly groupSeparator: string;
     readonly minimumGroupedIntegerDigits: number;
 }
-declare function getNumberGroupingPattern(localeId: string): NumberGroupingPattern;
-declare function getNumberSymbols(localeId: string): NumberSymbols;
+declare function getNumberGroupingPattern(locale: string): NumberGroupingPattern;
+declare function getNumberSymbols(locale: string): NumberSymbols;
 declare function getNumberFormatter(locale: string, options?: Intl.NumberFormatOptions): Intl.NumberFormat;
 declare function formatNumber(value: number, locale: string, options?: Intl.NumberFormatOptions): string;
+/**
+ * Converts digits of any script to ASCII digits. Full-width forms typed by CJK input methods
+ * ("１２．５", "－３", "１，０００") are folded to ASCII first.
+ */
 declare function normalizeLocalizedDigits(text: string, localeId?: string): string;
 declare function normalizeLocalizedMinus(text: string, symbols?: NumberSymbols): string;
 declare function normalizeLocalizedInput(text: string, localeId: string): string;
+/**
+ * Decimal separators accepted while editing: the locale's own, plus "." and "," so a separator typed on a
+ * keyboard layout that does not match the locale still works. An alternate is dropped when it is the locale's
+ * group separator; otherwise "1,234" typed in en-US (or "1.234" in de-DE) would be read as 1.234.
+ */
+declare function getEditDecimalSeparators(symbols: NumberSymbols): ReadonlySet<string>;
 type LocalizedNumberParseMode = "edit" | "locale";
 interface ParseLocalizedNumberOptions {
     /**
@@ -551,7 +566,7 @@ interface ParseLocalizedNumberOptions {
      * Only the locale's canonical decimal separator is treated as decimal, and only
      * canonical grouping separators are treated as grouping.
      * When "edit", allows alternate decimal separators (such as '.' in comma-decimal locales)
-     * during interactive input entry.
+     * during interactive input entry, unless the alternate is the locale's group separator.
      */
     mode?: LocalizedNumberParseMode;
     /**
@@ -583,6 +598,7 @@ declare function validateLocalizedNumberEdit(text: string | null | undefined, lo
 /**
  * Normalizes a locale string to ensure it uses the Gregorian calendar system
  * and doesn't contain a conflicting -u-ca-* extension.
+ * Empty or malformed ids resolve to `MONA_FALLBACK_LOCALE_ID` (en-US).
  */
 declare function normalizeGregorianLocale(localeId: string): string;
 /**
@@ -678,5 +694,5 @@ declare function pseudoLocalizeCatalog<T extends object>(catalog: T, options?: P
  */
 declare function generatePseudoLocale(catalogs: DeepPartial<MonaLocaleMessages>, options?: GeneratePseudoLocaleOptions): MonaLocale;
 
-export { BIDI_CONTROL_REGEX, MONA_DEFAULT_LOCALE, MONA_I18N_CONFIG, MonaDirectionService, MonaI18nService, formatGregorianDateToLocaleString, formatNumber, generatePseudoLocale, 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_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 type { CalendarMessages, DatePickerMessages, DateTimePickerMessages, DeepPartial, DialogMessages, DirectionObserverHandle, FilterMessages, GeneratePseudoLocaleOptions, LocaleFirstDayOfWeek, LocaleTimeFormatOptions, LocalizedNumberEditValidationResult, LocalizedNumberParseMode, LocalizedNumberValidationResult, MonaAutoCompleteMessages, MonaBreadcrumbMessages, MonaButtonGroupMessages, MonaCalendarMessages, MonaCardMessages, MonaChartMessages, MonaChipMessages, MonaColorGradientMessages, MonaColorPaletteMessages, MonaColorPickerMessages, MonaComboBoxMessages, MonaDatePickerMessages, MonaDateTimePickerMessages, MonaDialogMessages, MonaDropdownListMessages, MonaDropdownsMessages, MonaEditorMessages, MonaFilterMessages, MonaGridMessages, MonaI18nConfig, MonaListBoxMessages, MonaListMessages, MonaLocale, MonaLocaleMessages, MonaMessageNamespace, MonaMultiSelectMessages, MonaNotificationMessages, MonaNumericTextBoxMessages, MonaOtpInputMessages, MonaPagerMessages, MonaRatingMessages, MonaScrollViewMessages, MonaSheetMessages, MonaSliderMessages, MonaSpinnerMessages, MonaSplitButtonMessages, MonaSplitterMessages, MonaStepperMessages, MonaTabsMessages, MonaTextBoxMessages, MonaTextDirection, MonaTimePickerMessages, MonaTimeSelectorMessages, MonaTreeViewMessages, MonaWindowMessages, NotificationMessages, NumberGroupingPattern, NumberSymbols, ParseLocalizedNumberOptions, PseudoLocalizationOptions, SheetMessages, TimePickerMessages, TimeSelectorMessages, ValidateLocalizedNumberEditOptions, WindowMessages };

package/types/nanahoshi-mona-ui-numeric-text-box.d.ts

@@ -146,6 +146,11 @@ declare class NumericTextBoxComponent implements NumericTextboxVariantInputs, Fo
     private formatEditValue;
     private formatValueForDisplay;
     protected onPaste(event: ClipboardEvent): void;
+    /**
+     * The numpad decimal key types "." or "," depending on the keyboard layout, not the locale. Insert the
+     * locale's decimal separator instead, so a de-DE layout used with an en-US locale still types a decimal.
+     */
+    private insertLocaleDecimal;
     private parseValue;
     private setBeforeInputSubscription;
     private setInputFocusSubscription;