Dedupe NumberFormatUtils try/catch and sanitize remaining Intl callers

- Extract createFormatter helper in NumberFormatUtils/index.ts so format
  and formatToParts share a single try/catch + USD fallback path
  (addresses the CONSISTENCY-3 bot review on discussion_r3274381328).
- Apply sanitizeCurrencyCode to the two remaining direct callers that
  bypassed layer-1 validation: the convertToDisplayString and
  convertToDisplayStringWithoutCurrency closures in
  CurrencyListContextProvider, and the formatToParts call in
  SearchChartView. These previously only had the anonymous layer-2 catch
  as a safety net and missed normalization (e.g. 'eur' rendering as USD).
- Add resetInvalidCurrencyWarningsForTesting in CurrencyUtils.ts so
  Log.warn-asserting tests can clear the module-level throttle Set in
  beforeEach instead of relying on globally-unique fixture strings.
- Add a cross-helper throttle test asserting the shared Set deduplicates
  warnings across convertToDisplayString, getLocalizedCurrencySymbol,
  and convertToShortDisplayString for the same malformed code.
- Add malformed-currency test matrix for
  convertToDisplayStringWithExplicitCurrency, including the falsy
  branch that delegates to convertToDisplayStringWithoutCurrency.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: mountiny

src/components/CurrencyListContextProvider/index.tsx

@@ -1,7 +1,7 @@
 import React, {createContext, useCallback, useContext, useMemo} from 'react';
 import useLocalize from '@hooks/useLocalize';
 import useOnyx from '@hooks/useOnyx';
-import {convertToFrontendAmountAsInteger} from '@libs/CurrencyUtils';
+import {convertToFrontendAmountAsInteger, sanitizeCurrencyCode} from '@libs/CurrencyUtils';
 import {format, formatToParts} from '@libs/NumberFormatUtils';
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
@@ -34,15 +34,12 @@ function CurrencyListContextProvider({children}: React.PropsWithChildren) {
 
     const convertToDisplayString = useCallback(
         (amountInCents: number | undefined, currencyCode: string | undefined): string => {
-            const decimals = getCurrencyDecimals(currencyCode);
+            const sanitizedCurrency = sanitizeCurrencyCode(currencyCode);
+            const decimals = getCurrencyDecimals(sanitizedCurrency);
             const convertedAmount = convertToFrontendAmountAsInteger(amountInCents ?? 0, decimals);
-            let currencyWithFallback = currencyCode;
-            if (!currencyCode) {
-                currencyWithFallback = CONST.CURRENCY.USD;
-            }
             return format(preferredLocale, convertedAmount, {
                 style: 'currency',
-                currency: currencyWithFallback,
+                currency: sanitizedCurrency,
 
                 // We are forcing the number of decimals because we override the default number of decimals in the backend for some currencies
                 // See: https://github.com/Expensify/PHP-Libs/pull/834
@@ -56,11 +53,12 @@ function CurrencyListContextProvider({children}: React.PropsWithChildren) {
 
     const convertToDisplayStringWithoutCurrency = useCallback(
         (amountInCents: number, currencyCode: string = CONST.CURRENCY.USD): string => {
-            const decimals = getCurrencyDecimals(currencyCode);
+            const sanitizedCurrency = sanitizeCurrencyCode(currencyCode);
+            const decimals = getCurrencyDecimals(sanitizedCurrency);
             const convertedAmount = convertToFrontendAmountAsInteger(amountInCents, decimals);
             return formatToParts(preferredLocale, convertedAmount, {
                 style: 'currency',
-                currency: currencyCode,
+                currency: sanitizedCurrency,
 
                 // We are forcing the number of decimals because we override the default number of decimals in the backend for some currencies
                 // See: https://github.com/Expensify/PHP-Libs/pull/834

src/components/Search/SearchChartView.tsx

@@ -1,6 +1,6 @@
 import React from 'react';
 import useLocalize from '@hooks/useLocalize';
-import {getCurrencySymbol} from '@libs/CurrencyUtils';
+import {getCurrencySymbol, sanitizeCurrencyCode} from '@libs/CurrencyUtils';
 import Log from '@libs/Log';
 import Navigation from '@libs/Navigation/Navigation';
 import {formatToParts} from '@libs/NumberFormatUtils';
@@ -71,7 +71,7 @@ function SearchChartView({queryJSON, view, groupBy, data, isLoading}: SearchChar
     };
 
     const firstItem = data.at(0);
-    const currency = firstItem?.currency ?? 'USD';
+    const currency = sanitizeCurrencyCode(firstItem?.currency ?? 'USD');
     const parts = formatToParts(preferredLocale, 0, {style: 'currency', currency});
     const currencyIndex = parts.findIndex((p) => p.type === 'currency');
     const integerIndex = parts.findIndex((p) => p.type === 'integer');

src/libs/CurrencyUtils.ts

@@ -31,6 +31,14 @@ function isValidCurrencyCode(currencyCode: unknown): currencyCode is string {
 // Tracks invalid currency codes already warned about so the same bad value doesn't spam the log on every render.
 const warnedInvalidCurrencyCodes = new Set<string>();
 
+/**
+ * Test-only: clears the in-memory de-dup of malformed currency codes so tests asserting on `Log.warn`
+ * are not affected by warnings emitted by earlier tests. Production code should not call this.
+ */
+function resetInvalidCurrencyWarningsForTesting() {
+    warnedInvalidCurrencyCodes.clear();
+}
+
 /**
  * Validates a currency code and returns it unchanged if it is a valid ISO 4217 code.
  * Whitespace and case-only variations (e.g. " usd ") are normalized rather than discarded.
@@ -230,6 +238,7 @@ function convertToDisplayStringWithoutCurrency(amountInCents: number, currency:
 export {
     isValidCurrencyCode,
     sanitizeCurrencyCode,
+    resetInvalidCurrencyWarningsForTesting,
     getCurrencyDecimals,
     getCurrencyUnit,
     getLocalizedCurrencySymbol,

src/libs/NumberFormatUtils/index.ts

@@ -9,30 +9,29 @@ intlPolyfill();
 
 const MemoizedNumberFormat = memoize(Intl.NumberFormat, {maxSize: 10, monitoringName: 'NumberFormatUtils'});
 
-function format(locale: Locale | undefined, number: number, options?: Intl.NumberFormatOptions): string {
+/**
+ * Build an Intl.NumberFormat with a USD fallback for malformed currency codes.
+ * Intl throws RangeError for empty/malformed currency values; check presence of the option (not truthiness)
+ * so we still recover when currency is '' rather than rethrowing and crashing the screen.
+ */
+function createFormatter(locale: Locale | undefined, options?: Intl.NumberFormatOptions): Intl.NumberFormat {
     try {
-        return new MemoizedNumberFormat(locale ?? CONST.LOCALES.DEFAULT, options).format(number);
+        return new MemoizedNumberFormat(locale ?? CONST.LOCALES.DEFAULT, options);
     } catch (e) {
-        // Intl throws RangeError for empty/malformed currency values; check presence of the option (not truthiness)
-        // so we still recover when currency is '' rather than rethrowing and crashing the screen.
         if (e instanceof RangeError && options && 'currency' in options) {
             Log.warn('NumberFormatUtils: malformed currency code, falling back to USD', {currency: options.currency});
-            return new MemoizedNumberFormat(locale ?? CONST.LOCALES.DEFAULT, {...options, currency: CONST.CURRENCY.USD}).format(number);
+            return new MemoizedNumberFormat(locale ?? CONST.LOCALES.DEFAULT, {...options, currency: CONST.CURRENCY.USD});
         }
         throw e;
     }
 }
 
+function format(locale: Locale | undefined, number: number, options?: Intl.NumberFormatOptions): string {
+    return createFormatter(locale, options).format(number);
+}
+
 function formatToParts(locale: Locale | undefined, number: number, options?: Intl.NumberFormatOptions): Intl.NumberFormatPart[] {
-    try {
-        return new MemoizedNumberFormat(locale ?? CONST.LOCALES.DEFAULT, options).formatToParts(number);
-    } catch (e) {
-        if (e instanceof RangeError && options && 'currency' in options) {
-            Log.warn('NumberFormatUtils: malformed currency code, falling back to USD', {currency: options.currency});
-            return new MemoizedNumberFormat(locale ?? CONST.LOCALES.DEFAULT, {...options, currency: CONST.CURRENCY.USD}).formatToParts(number);
-        }
-        throw e;
-    }
+    return createFormatter(locale, options).formatToParts(number);
 }
 
 export {format, formatToParts};

tests/unit/CurrencyUtilsTest.ts

@@ -214,6 +214,10 @@ describe('CurrencyUtils', () => {
     });
 
     describe('sanitizeCurrencyCode', () => {
+        beforeEach(() => {
+            CurrencyUtils.resetInvalidCurrencyWarningsForTesting();
+        });
+
         test('returns the input unchanged for a valid ISO 4217 code', () => {
             expect(CurrencyUtils.sanitizeCurrencyCode('EUR')).toBe('EUR');
         });
@@ -240,13 +244,12 @@ describe('CurrencyUtils', () => {
         test('logs a warning at most once per unique malformed value', () => {
             const warnSpy = jest.spyOn(Log, 'warn').mockImplementation(() => undefined);
             try {
-                // Use unique fixtures so other tests don't already mark these as warned.
-                CurrencyUtils.sanitizeCurrencyCode('TEST_THROTTLE_A');
-                CurrencyUtils.sanitizeCurrencyCode('TEST_THROTTLE_A');
-                CurrencyUtils.sanitizeCurrencyCode('TEST_THROTTLE_A');
+                CurrencyUtils.sanitizeCurrencyCode('XX');
+                CurrencyUtils.sanitizeCurrencyCode('XX');
+                CurrencyUtils.sanitizeCurrencyCode('XX');
                 expect(warnSpy).toHaveBeenCalledTimes(1);
 
-                CurrencyUtils.sanitizeCurrencyCode('TEST_THROTTLE_B');
+                CurrencyUtils.sanitizeCurrencyCode('???');
                 expect(warnSpy).toHaveBeenCalledTimes(2);
             } finally {
                 warnSpy.mockRestore();
@@ -262,6 +265,18 @@ describe('CurrencyUtils', () => {
                 warnSpy.mockRestore();
             }
         });
+
+        test('shares the throttle across helpers that go through sanitizeCurrencyCode', () => {
+            const warnSpy = jest.spyOn(Log, 'warn').mockImplementation(() => undefined);
+            try {
+                CurrencyUtils.convertToDisplayString(2500, 'XX');
+                CurrencyUtils.getLocalizedCurrencySymbol(CONST.LOCALES.EN, 'XX');
+                CurrencyUtils.convertToShortDisplayString(2500, 'XX');
+                expect(warnSpy).toHaveBeenCalledTimes(1);
+            } finally {
+                warnSpy.mockRestore();
+            }
+        });
     });
 
     describe('convertToDisplayString with malformed currency', () => {
@@ -310,6 +325,19 @@ describe('CurrencyUtils', () => {
         });
     });
 
+    describe('convertToDisplayStringWithExplicitCurrency with malformed currency', () => {
+        test.each(['XX', 'USDD', '???'])('does not throw and falls back to USD formatting for truthy malformed %p', (input) => {
+            expect(() => CurrencyUtils.convertToDisplayStringWithExplicitCurrency(2500, input)).not.toThrow();
+            expect(CurrencyUtils.convertToDisplayStringWithExplicitCurrency(2500, input)).toBe('$25.00');
+        });
+
+        test.each([undefined, ''])('returns the symbol-less form for falsy currency %p (delegates to convertToDisplayStringWithoutCurrency)', (input) => {
+            const result = CurrencyUtils.convertToDisplayStringWithExplicitCurrency(2500, input);
+            expect(result).not.toMatch(/\$/);
+            expect(result).toContain('25');
+        });
+    });
+
     describe('getLocalizedCurrencySymbol with malformed currency', () => {
         test.each(['', 'XX', 'USDD'])('returns the USD symbol without throwing for %p', (input) => {
             expect(() => CurrencyUtils.getLocalizedCurrencySymbol(CONST.LOCALES.EN, input)).not.toThrow();