@astryxdesign/core 0.4.7 → 0.5.0-canary.009bcb3

package/src/NumberInput/numberParser.test.ts

@@ -0,0 +1,222 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import {describe, it, expect} from 'vitest';
+import {formatEditableNumber, parseLocaleNumber} from './numberParser';
+
+const NBSP = '\u00A0';
+const NARROW_NBSP = '\u202F';
+const APOSTROPHE = '\u2019';
+const MIDDLE_DOT = '\u00B7';
+
+/**
+ * The contract, enumerated. A row is `[input, locale, expected]`, and `null`
+ * means the field stays visibly invalid rather than committing a guess.
+ */
+const CORPUS: [string, string, number | null][] = [
+  // Grouped — the case this exists for, and it holds in every locale because
+  // a repeated separator with three digits after it cannot be a decimal point.
+  ['1,234,234,234', 'en-US', 1234234234],
+  ['1,234,234,234', 'de-DE', 1234234234],
+  ['1,234,234,234', 'fr-FR', 1234234234],
+  ['1,234,234,234', 'ar-SA', 1234234234],
+  ['1.234.234.234', 'de-DE', 1234234234],
+  ['1.234.234.234', 'en-US', 1234234234],
+  [`1${NARROW_NBSP}234${NARROW_NBSP}234${NARROW_NBSP}234`, 'fr-FR', 1234234234],
+  [`1${NBSP}234${NBSP}234`, 'fr-FR', 1234234],
+  [`1${NBSP}234`, 'en-US', 1234],
+  [`1${APOSTROPHE}234${APOSTROPHE}234`, 'de-CH', 1234234],
+  ["1'234'234", 'de-CH', 1234234],
+  ['1,234', 'en-US', 1234],
+  ['1,234', 'de-DE', 1.234],
+
+  // Indian lakh grouping, derived from the locale's own group sizes.
+  ['12,34,567', 'en-IN', 1234567],
+  ['12,34,567', 'en-US', null],
+
+  // Ragged grouping is a typo, not a number: the last group is not three.
+  ['1,23,4', 'en-US', null],
+  ['1,2345', 'en-US', null],
+  ['12 34', 'en-US', null],
+
+  // One separator, one meaning per locale, and no meaning across them.
+  ['1,5', 'de-DE', 1.5],
+  ['1,5', 'en-US', null],
+  ['1.5', 'en-US', 1.5],
+
+  // The machine decimal point reads everywhere: a full stop the locale cannot
+  // read as grouping has one meaning left, and refusing it lost a number the
+  // person had typed. Where grouping IS well formed the locale still wins.
+  ['1.5', 'de-DE', 1.5],
+  ['1.5', 'fr-FR', 1.5],
+  ['1234.56', 'de-DE', 1234.56],
+  ['-3.25', 'fr-FR', -3.25],
+  ['0.5', 'de-DE', 0.5],
+  ['1.5e3', 'de-DE', 1500],
+  ['1.234', 'de-DE', 1234],
+  ['1.2345', 'de-DE', 1.2345],
+  // The same text in the other comma-decimal locale: fr-FR groups with a
+  // space, so a full stop has no grouping reading there and stays the point.
+  ['1.234', 'fr-FR', 1.234],
+
+  // Decimals and signs.
+  ['1,234.56', 'en-US', 1234.56],
+  ['1.234,56', 'de-DE', 1234.56],
+  ['1,234.56', 'de-DE', null],
+  ['-1,234.56', 'en-US', -1234.56],
+  ['+7', 'en-US', 7],
+  ['-7', 'en-US', -7],
+  ['7-', 'ar-SA', -7],
+  ['.5', 'en-US', 0.5],
+  ['5.', 'en-US', 5],
+  ['-', 'en-US', null],
+  ['', 'en-US', null],
+  ['   ', 'en-US', null],
+
+  // Spreadsheet cells arrive with their whitespace attached.
+  ['  42  ', 'en-US', 42],
+  ['\t1,234\n', 'en-US', 1234],
+  ['1,234\n5,678', 'en-US', null],
+
+  // Digit scripts, derived from \p{Nd} rather than enumerated.
+  ['١٢٣', 'ar-SA', 123],
+  ['۱۲۳', 'fa-IR', 123],
+  ['१२३', 'hi-IN', 123],
+  ['１２３', 'ja-JP', 123],
+  ['١,٢٣٤', 'en-US', 1234],
+  ['٣٫٥', 'ar-SA', 3.5],
+
+  // Currency decorates the number without changing its magnitude, so the
+  // symbol is dropped and the separators still decide. A number written for
+  // another locale still refuses.
+  ['$1,234.56', 'en-US', 1234.56],
+  ['£1,234', 'en-US', 1234],
+  ['1.234,56 €', 'de-DE', 1234.56],
+  ['1.234,56 €', 'en-US', null],
+  ['-$1,234', 'en-US', -1234],
+
+  // A unit suffix is not dropped: `B` and `k` carry magnitude, so guessing
+  // which trailing letters are inert is how a wrong number gets committed.
+  ['1,234 GB', 'en-US', null],
+  ['72°F', 'en-US', null],
+  ['1,234 kg', 'en-US', null],
+
+  // Accounting negatives.
+  ['(1,234)', 'en-US', -1234],
+  ['($1,234.50)', 'en-US', -1234.5],
+  ['(1,234', 'en-US', null],
+  // The parens already carry the sign; a second one reads two ways.
+  ['(-1,234)', 'en-US', null],
+  ['(+1,234)', 'en-US', null],
+
+  // Typographic minus signs.
+  ['\u22121234', 'en-US', -1234],
+  ['\u20131234', 'en-US', -1234],
+
+  // Exponents, including the shape a spreadsheet exports.
+  ['1.23E+09', 'en-US', 1230000000],
+  ['1.23e9', 'en-US', 1230000000],
+  ['1.5e-3', 'en-US', 0.0015],
+  ['1e', 'en-US', null],
+
+  // Invisible characters Excel and Sheets attach.
+  ['\uFEFF1,234', 'en-US', 1234],
+  ['1,234\u200B', 'en-US', 1234],
+  ['\u200E1,234', 'en-US', 1234],
+
+  // Junk.
+  ['NaN', 'en-US', null],
+  ['Infinity', 'en-US', null],
+  ['abc', 'en-US', null],
+  ['12abc', 'en-US', null],
+  ['1/2', 'en-US', null],
+  ['1 234 (approx)', 'en-US', null],
+  ['--5', 'en-US', null],
+  ['1..234', 'en-US', null],
+
+  // Only a character some locale writes between digits is a separator. None of
+  // these are numbers, and the last two were refused before only because their
+  // final group is the wrong length — luck, not a rule.
+  ['123-456-789', 'en-US', null],
+  ['1-800-555', 'en-US', null],
+  ['555-123-456', 'en-US', null],
+  ['1_234_567', 'en-US', null],
+  ['1/234/567', 'en-US', null],
+  ['1:234:567', 'en-US', null],
+  ['1*234*567', 'en-US', null],
+  ['800-555-1212', 'en-US', null],
+  ['2024-01-15', 'en-US', null],
+
+  // U+00B7 was in the alphabet as the Catalan middle dot. Catalan groups with
+  // a full stop, and no locale ICU resolves writes it between digits at all.
+  [`1${MIDDLE_DOT}234${MIDDLE_DOT}567`, 'en-US', null],
+  [`1${MIDDLE_DOT}234${MIDDLE_DOT}567`, 'ca-ES', null],
+
+  // The field has no percent semantics, so a percent sign is not dropped:
+  // committing 45 for `45%` is off by a factor of a hundred.
+  ['45%', 'en-US', null],
+  ['0.5%', 'en-US', null],
+  ['45 %', 'fr-FR', null],
+];
+
+describe('parseLocaleNumber', () => {
+  it.each(CORPUS)('parses %j in %s', (input, locale, expected) => {
+    expect(parseLocaleNumber(input, locale)).toBe(expected);
+  });
+
+  it('reads back the grouping every locale writes', () => {
+    for (const locale of [
+      'en-US',
+      'de-DE',
+      'fr-FR',
+      'de-CH',
+      'en-IN',
+      'ar-SA',
+    ]) {
+      const text = new Intl.NumberFormat(locale).format(1234234234);
+      expect(parseLocaleNumber(text, locale)).toBe(1234234234);
+    }
+  });
+});
+
+describe('formatEditableNumber', () => {
+  it.each([
+    [1.5, 'en-US', '1.5'],
+    [1.5, 'de-DE', '1,5'],
+    [-1234.56, 'fr-FR', '-1234,56'],
+    // Only the decimal separator is localized. The digits stay as `String`
+    // writes them, which is what the field shows at rest when no `formatValue`
+    // is given, so localizing them here would flip the script on focus.
+    [3.5, 'ar-SA', '3٫5'],
+    // No grouping: the text has to be editable, and a separator the person did
+    // not type is one they have to delete.
+    [1234234234, 'de-DE', '1234234234'],
+    [42, 'de-DE', '42'],
+    // What `String` writes for the extremes stays untouched but for the point.
+    [1e21, 'de-DE', '1e+21'],
+    [1.5e-7, 'de-DE', '1,5e-7'],
+  ])('shows %j in %s as %j', (value, locale, expected) => {
+    expect(formatEditableNumber(value, locale)).toBe(expected);
+  });
+
+  it('round trips through the parser in every locale', () => {
+    for (const locale of [
+      'en-US',
+      'de-DE',
+      'fr-FR',
+      'de-CH',
+      'en-IN',
+      'ar-SA',
+      'ja-JP',
+      'hi-IN',
+    ]) {
+      for (const value of [
+        0, 1, -1, 0.1, 1.5, -0.5, 1234.56, -1234567.125, 123456789,
+        3.141592653589793, 1e21, 1.5e-7, -9007199254740991,
+      ]) {
+        expect(
+          parseLocaleNumber(formatEditableNumber(value, locale), locale),
+        ).toBe(value);
+      }
+    }
+  });
+});

package/src/NumberInput/numberParser.ts

@@ -0,0 +1,403 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file numberParser.ts
+ * @input Text a person typed or pasted, plus the resolved BCP 47 locale
+ * @output Exports parseLocaleNumber and formatEditableNumber
+ * @position Internal to NumberInput; not part of the public surface
+ *
+ * People paste numbers out of spreadsheets, and a spreadsheet writes them
+ * grouped, signed, and decorated. This reads those back. Everything locale
+ * specific — the grouping and decimal separators, the group sizes, the digit
+ * script — is derived from Intl and Unicode rather than a table, and text that
+ * no reading fits returns null so the field stays visibly invalid instead of
+ * committing a guess. Where both readings are well formed the locale's wins,
+ * the way utils/dateParser.ts settles an ambiguous date by locale preference.
+ * Grouping is well formed only when every group fits the locale's own sizes:
+ * the last exactly the primary size, each inner one exactly the secondary, the
+ * first no longer than that. So de-DE `1.234` is 1234, while `1.2345` (last
+ * group too long) and `1234.567` (too much ahead of it) keep the full stop as
+ * a decimal point. Groups of three fit every locale, so a separator repeated
+ * with three-digit groups is grouping in all of them and `1,234,567` reads the
+ * same everywhere; for a space or apostrophe, which no locale writes as a
+ * decimal point, one occurrence is enough, so en-US `1 234` is 1234.
+ *
+ * That paragraph is executable: numberParser.docblock.test.ts implements it as
+ * code, quote by quote, and fails when the parser and the words disagree.
+ *
+ * Which characters may separate digits at all is the one thing that is NOT
+ * read off the input: SEPARATOR_CHARS below is a bounded alphabet, the same
+ * shape utils/dateParser.ts uses for its `[-/.]` date separators.
+ *
+ * SYNC: When modified, update these files to stay in sync:
+ * - /packages/core/src/NumberInput/NumberInput.tsx
+ * - /packages/core/src/NumberInput/numberParser.test.ts
+ * - /packages/core/src/NumberInput/numberParser.docblock.test.ts
+ */
+
+import type {Locale} from '../i18n';
+
+interface LocaleNumberSymbols {
+  group: string;
+  decimal: string;
+  /** Digits in the rightmost group — 3 nearly everywhere, 3 in en-IN too. */
+  primaryGroupSize: number;
+  /** Digits in every group left of it — 2 in en-IN's lakh grouping. */
+  secondaryGroupSize: number;
+}
+
+const symbolsByLocale = new Map<string, LocaleNumberSymbols>();
+
+function getLocaleNumberSymbols(locale: Locale | undefined) {
+  const key = locale ?? '';
+  let symbols = symbolsByLocale.get(key);
+  if (symbols === undefined) {
+    let format: Intl.NumberFormat;
+    try {
+      format = new Intl.NumberFormat(locale);
+    } catch {
+      format = new Intl.NumberFormat('en');
+    }
+    const parts = format.formatToParts(12345.6);
+    // A probe long enough to expose a second grouping size where one exists.
+    const groupSizes = format
+      .formatToParts(11111111111)
+      .filter(part => part.type === 'integer')
+      .map(part => part.value.length);
+    const hasGrouping = groupSizes.length > 1;
+    symbols = {
+      // Normalized so the space-family separators compare equal to the plain
+      // space that input text is normalized to.
+      group: (parts.find(p => p.type === 'group')?.value ?? ',').normalize(
+        'NFKC',
+      ),
+      decimal: parts.find(p => p.type === 'decimal')?.value ?? '.',
+      primaryGroupSize: hasGrouping ? groupSizes[groupSizes.length - 1] : 3,
+      secondaryGroupSize: hasGrouping ? groupSizes[groupSizes.length - 2] : 3,
+    };
+    symbolsByLocale.set(key, symbols);
+  }
+  return symbols;
+}
+
+// Built at runtime rather than written as literals: Babel's
+// transform-unicode-property-regex rewrites a `\p{...}` regex LITERAL into an
+// enumerated character class, and the copy bundled with Next rejects the
+// General_Category short names, failing the sandbox build. Property escapes are
+// ES2018 and need no transform in any browser this package supports.
+const DECIMAL_DIGIT = new RegExp('\\p{Nd}', 'u');
+const CURRENCY = new RegExp('\\p{Sc}', 'u');
+// Zero-width joiners, bidi isolates and the BOM Excel prepends.
+const INVISIBLES = /[\u200B-\u200D\u200E\u200F\u061C\u2066-\u2069\uFEFF]/g;
+// Hyphen last: inside the character class this builds, a leading one would
+// open a range.
+const MINUS_SIGNS = '\u2212\u2012\u2013-';
+
+/**
+ * Every character a locale writes between digits. Sweeping every language ICU
+ * resolves, in every region, yields seven: comma, full stop, apostrophe,
+ * space (the whole space family folds to it under NFKC), the Arabic decimal
+ * and thousands separators, and U+060C — which only nqo writes, and which
+ * this alphabet leaves out. U+2019 is here in its place: no locale writes it,
+ * but the corpus pins it as the Swiss spelling.
+ *
+ * The alphabet is bounded on purpose. Read the candidates off the input
+ * instead and any repeated character is grouping, so a hyphenated ID commits
+ * as a number. It bounds characters and not shapes: a full stop is a real
+ * separator, so `192.168.100.200` is four well-formed groups.
+ */
+const SEPARATOR_CHARS = ",.' \u2019\u066B\u066C";
+const NUMBER_BODY = new RegExp(`^[0-9${SEPARATOR_CHARS}]+$`);
+/** No grouping and at most one full stop: the format `Number()` reads. */
+const MACHINE_NUMBER = /^(?:\d+\.?\d*|\.\d+)$/;
+
+/**
+ * Value of any Unicode decimal digit. Each digit script lays its ten digits
+ * out consecutively, so walking back to the script's zero derives the value
+ * for Arabic-Indic, Devanagari, full-width and the rest without shipping a
+ * table of them. Returns null in the one shape the walk cannot resolve: two
+ * digit blocks adjacent in code space (the mathematical alphanumerics).
+ */
+function digitValue(char: string): number | null {
+  const codePoint = char.codePointAt(0);
+  if (codePoint == null) {
+    return null;
+  }
+  for (let zero = codePoint; codePoint - zero < 10; zero--) {
+    if (!DECIMAL_DIGIT.test(String.fromCodePoint(zero - 1))) {
+      return codePoint - zero;
+    }
+  }
+  return null;
+}
+
+function toAsciiDigits(text: string): string | null {
+  let out = '';
+  for (const char of text) {
+    if (!DECIMAL_DIGIT.test(char)) {
+      out += char;
+      continue;
+    }
+    const value = digitValue(char);
+    if (value == null) {
+      return null;
+    }
+    out += String(value);
+  }
+  return out;
+}
+
+/**
+ * Reduce a digits-and-separators string to a plain machine number under one
+ * candidate reading, or null when it is not well formed under that reading.
+ * `minGroups` is how many grouping separators the reading has to see before it
+ * believes the separator is grouping at all.
+ */
+function readUnder(
+  core: string,
+  group: string,
+  decimal: string,
+  primaryGroupSize: number,
+  secondaryGroupSize: number,
+  minGroups: number,
+): string | null {
+  let intText = core;
+  let fracText: string | null = null;
+
+  if (decimal !== '' && core.includes(decimal)) {
+    const at = core.indexOf(decimal);
+    if (core.includes(decimal, at + decimal.length)) {
+      return null;
+    }
+    intText = core.slice(0, at);
+    fracText = core.slice(at + decimal.length);
+    if (!/^\d*$/.test(fracText)) {
+      return null;
+    }
+  }
+
+  let digits: string;
+  if (group !== '' && intText.includes(group)) {
+    const chunks = intText.split(group);
+    if (
+      chunks.length - 1 < minGroups ||
+      !chunks.every(chunk => /^\d+$/.test(chunk))
+    ) {
+      return null;
+    }
+    const first = chunks[0];
+    const last = chunks[chunks.length - 1];
+    if (last.length !== primaryGroupSize || first.length > secondaryGroupSize) {
+      return null;
+    }
+    for (let i = 1; i < chunks.length - 1; i++) {
+      if (chunks[i].length !== secondaryGroupSize) {
+        return null;
+      }
+    }
+    digits = chunks.join('');
+  } else {
+    if (!/^\d*$/.test(intText)) {
+      return null;
+    }
+    digits = intText;
+  }
+
+  if (digits === '' && (fracText == null || fracText === '')) {
+    return null;
+  }
+  return fracText == null ? digits : `${digits}.${fracText}`;
+}
+
+/**
+ * A separator that no locale uses as a decimal point, so one well-formed group
+ * of it is already unambiguous. Everything else needs two before grouping
+ * beats the decimal-point reading.
+ */
+function isGroupOnlySeparator(separator: string): boolean {
+  return /^[\s'\u2019]$/.test(separator);
+}
+
+function toPlainNumber(
+  core: string,
+  locale: Locale | undefined,
+): string | null {
+  if (!NUMBER_BODY.test(core)) {
+    return null;
+  }
+
+  const {group, decimal, primaryGroupSize, secondaryGroupSize} =
+    getLocaleNumberSymbols(locale);
+  const inLocale = readUnder(
+    core,
+    group,
+    decimal,
+    primaryGroupSize,
+    secondaryGroupSize,
+    1,
+  );
+  if (inLocale != null) {
+    return inLocale;
+  }
+
+  // The machine format, which is what the field read before this parser
+  // existed. It comes after the locale rather than before it — dateParser.ts
+  // can put ISO first because `2026-01-25` has no second reading, while
+  // `1.234` in de-DE has one and grouping is the reading a German means. What
+  // reaches here is a full stop the locale could NOT read, so it is not
+  // well-formed grouping either, and exactly one reading is left.
+  if (MACHINE_NUMBER.test(core)) {
+    return core;
+  }
+
+  // A repeated separator with three digits after each occurrence can only be
+  // grouping — a decimal point appears once — so that shape reads the same in
+  // every locale, which is what lets a `1,234,234,234` pasted out of a
+  // spreadsheet land in a de-DE app.
+  const separators = [...new Set(core.replace(/\d/g, ''))];
+  if (separators.length === 0 || separators.length > 2) {
+    return null;
+  }
+  for (const candidate of separators) {
+    const occurrences = core.split(candidate).length - 1;
+    const minGroups = isGroupOnlySeparator(candidate) ? 1 : 2;
+    if (occurrences < minGroups) {
+      continue;
+    }
+    const other = separators.find(s => s !== candidate) ?? '';
+    if (other !== '' && core.split(other).length - 1 !== 1) {
+      continue;
+    }
+    const read = readUnder(core, candidate, other, 3, 3, minGroups);
+    if (read != null) {
+      return read;
+    }
+  }
+  return null;
+}
+
+/**
+ * Read a number out of text the way a person in `locale` writes one: their
+ * grouping and decimal separators, their group sizes, their digit script, an
+ * optional currency symbol, and the shapes a spreadsheet pastes.
+ *
+ * Returns null rather than a guess. Grouping is validated, so en-US `1,23` —
+ * a comma that is neither a decimal point nor a well-formed group — is not
+ * silently read as 123, and neither is a number written for another locale.
+ * Only the characters some locale writes between digits count as separators,
+ * so `123-456-789` is not a number at all.
+ *
+ * @example
+ * ```
+ * parseLocaleNumber('1,234,234,234', 'en-US')  // 1234234234
+ * parseLocaleNumber('1,234,234,234', 'de-DE')  // 1234234234
+ * parseLocaleNumber('1,5', 'de-DE')            // 1.5
+ * parseLocaleNumber('1.5', 'de-DE')            // 1.5
+ * parseLocaleNumber('1,5', 'en-US')            // null
+ * parseLocaleNumber('123-456-789', 'en-US')    // null
+ * ```
+ */
+export function parseLocaleNumber(
+  text: string,
+  locale?: Locale,
+): number | null {
+  const normalized = toAsciiDigits(
+    text.normalize('NFKC').replace(INVISIBLES, ''),
+  );
+  if (normalized == null) {
+    return null;
+  }
+
+  let rest = normalized.trim();
+  let sign = 1;
+
+  // Accounting negatives: spreadsheets write -1234 as (1,234).
+  const accounting = /^\((.*)\)$/s.exec(rest);
+  if (accounting) {
+    sign = -1;
+    rest = accounting[1].trim();
+  }
+
+  rest = stripCurrency(rest);
+
+  // The sign lands on either end — RTL locales trail it, and Intl writes
+  // U+2212 where a keyboard writes a hyphen.
+  let hasWrittenSign = false;
+  const leadingSign = new RegExp(`^([+${MINUS_SIGNS}])\\s*`).exec(rest);
+  if (leadingSign) {
+    hasWrittenSign = true;
+    sign = leadingSign[1] === '+' ? sign : -sign;
+    rest = rest.slice(leadingSign[0].length);
+  } else {
+    const trailingSign = new RegExp(`\\s*([+${MINUS_SIGNS}])$`).exec(rest);
+    if (trailingSign) {
+      hasWrittenSign = true;
+      sign = trailingSign[1] === '+' ? sign : -sign;
+      rest = rest.slice(0, rest.length - trailingSign[0].length);
+    }
+  }
+
+  // The parens already say negative, so a sign inside them contradicts or
+  // doubles it: `(-1,234)` is -1234 to one reader and +1234 to another.
+  if (accounting && hasWrittenSign) {
+    return null;
+  }
+
+  rest = stripCurrency(rest);
+
+  let exponent = 0;
+  const exponentMatch = /\s*[eE]\s*([+-]?\d+)$/.exec(rest);
+  if (exponentMatch) {
+    exponent = Number(exponentMatch[1]);
+    rest = rest.slice(0, rest.length - exponentMatch[0].length);
+  }
+
+  const core = rest.trim();
+  if (core === '') {
+    return null;
+  }
+
+  const plain = toPlainNumber(core, locale);
+  if (plain == null) {
+    return null;
+  }
+
+  const magnitude = Number(plain);
+  if (!Number.isFinite(magnitude)) {
+    return null;
+  }
+
+  const scaled =
+    exponent === 0
+      ? magnitude
+      : // 1.23 * 1e3 is 1229.9999999999998 in binary floating point, and a
+        // field that commits that instead of 1230 has not round-tripped.
+        Number((magnitude * 10 ** exponent).toPrecision(15));
+  if (!Number.isFinite(scaled)) {
+    return null;
+  }
+  const result = sign * scaled;
+  return Object.is(result, -0) ? 0 : result;
+}
+
+function stripCurrency(text: string): string {
+  let out = text.trim();
+  if (CURRENCY.test(out.charAt(0))) {
+    out = out.slice(1).trim();
+  }
+  if (CURRENCY.test(out.charAt(out.length - 1))) {
+    out = out.slice(0, -1).trim();
+  }
+  return out;
+}
+
+/**
+ * The text shown while the field is focused: the plain machine number in the
+ * locale's decimal separator, so what a person sees mid-edit is what the
+ * parser reads back on blur.
+ */
+export function formatEditableNumber(value: number, locale?: Locale): string {
+  const {decimal} = getLocaleNumberSymbols(locale);
+  const raw = String(value);
+  return decimal === '.' ? raw : raw.replace('.', decimal);
+}

package/src/Outline/Outline.tsx

@@ -37,7 +37,7 @@ import {
 import {useLinkComponent} from '../Link/useLinkComponent';
 import {useListFocus} from '../hooks/useListFocus';
 import {useIsomorphicLayoutEffect} from '../hooks/useIsomorphicLayoutEffect';
-import {mergeProps, mergeRefs} from '../utils';
+import {mergeProps} from '../utils';
 import type {BaseProps} from '../BaseProps';
 import {useScrollSpy} from './useScrollSpy';
 import type {OutlineItem} from './types';
@@ -45,6 +45,7 @@ import {themeProps} from '../utils/themeProps';
 import {focusOutlineProps} from '../utils/focusOutline.stylex';
 import {useTranslator} from '../i18n';
 
+import {useMergedRefs} from '../hooks/useMergedRefs';
 export type {OutlineItem} from './types';
 
 export interface OutlineProps extends BaseProps<HTMLElement> {
@@ -443,7 +444,7 @@ export function Outline({
   return (
     <nav
       {...props}
-      ref={mergeRefs(rootRef, ref)}
+      ref={useMergedRefs(rootRef, ref)}
       aria-label={label}
       data-testid={testId}
       {...mergeProps(

package/src/OverflowList/OverflowList.tsx

@@ -22,11 +22,12 @@ import {type ReactNode, type ReactElement, Children} from 'react';
 import type {BaseProps} from '../BaseProps';
 import type {SpacingStep} from '../utils/types';
 import * as stylex from '@stylexjs/stylex';
-import {mergeProps, mergeRefs} from '../utils';
+import {mergeProps} from '../utils';
 import {useOverflow} from '../hooks/useOverflow';
 import {spacingVars} from '../theme/tokens.stylex';
 import {themeProps} from '../utils/themeProps';
 
+import {useMergedRefs} from '../hooks/useMergedRefs';
 const styles = stylex.create({
   container: {
     display: 'flex',
@@ -280,7 +281,7 @@ export function OverflowList({
 
       {/* Visible container */}
       <div
-        ref={mergeRefs(ref, containerRef)}
+        ref={useMergedRefs(ref, containerRef)}
         {...mergeProps(
           themeProps('overflow-list'),
           stylex.props(