Address PR feedback: throttle NumberFormatUtils warn, polish

- Replace literal 'USD' in SearchChartView with CONST.CURRENCY.USD per
  CONSISTENCY-2 (FitseTLT and github-actions bot flagged the same line).
- Clarify the createFormatter JSDoc in NumberFormatUtils per FitseTLT's
  comment: split the general purpose from the empty-string nuance so the
  two ideas don't read as one run-on sentence.
- Throttle the Log.warn in createFormatter via a local Set so the
  safety-net log doesn't fire on every render for the same malformed
  currency. Mirrors the pattern in CurrencyUtils.sanitizeCurrencyCode
  but uses a local Set to avoid a circular import (CurrencyUtils
  already imports NumberFormatUtils).
- Export resetMalformedCurrenciesForTesting and call it in beforeEach
  in NumberFormatUtilsTest so warn-assertion tests stay isolated.
- Add two tests: same malformed currency warns only once across
  repeated format calls, and the deduplication is shared between
  format and formatToParts.

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

Author: mountiny

src/components/Search/SearchChartView.tsx

@@ -71,7 +71,7 @@ function SearchChartView({queryJSON, view, groupBy, data, isLoading}: SearchChar
     };
 
     const firstItem = data.at(0);
-    const currency = sanitizeCurrencyCode(firstItem?.currency ?? 'USD');
+    const currency = sanitizeCurrencyCode(firstItem?.currency ?? CONST.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/NumberFormatUtils/index.ts

@@ -9,17 +9,26 @@ intlPolyfill();
 
 const MemoizedNumberFormat = memoize(Intl.NumberFormat, {maxSize: 10, monitoringName: 'NumberFormatUtils'});
 
+// Tracks malformed currency codes that have already produced a warning in this module, so the
+// safety-net log doesn't fire on every render for the same bad value.
+const warnedMalformedCurrencies = new Set<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.
+ * Build an Intl.NumberFormat. If construction throws a RangeError due to a malformed currency
+ * code (Intl rejects empty strings and non-ISO-4217 codes), fall back to USD instead of letting
+ * the error crash the screen. We check `'currency' in options` rather than `options.currency`
+ * truthiness so an empty-string currency still triggers the fallback.
  */
 function createFormatter(locale: Locale | undefined, options?: Intl.NumberFormatOptions): Intl.NumberFormat {
     try {
         return new MemoizedNumberFormat(locale ?? CONST.LOCALES.DEFAULT, options);
     } catch (e) {
         if (e instanceof RangeError && options && 'currency' in options) {
-            Log.warn('NumberFormatUtils: malformed currency code, falling back to USD', {currency: options.currency});
+            const currency = String(options.currency ?? '');
+            if (!warnedMalformedCurrencies.has(currency)) {
+                warnedMalformedCurrencies.add(currency);
+                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});
         }
         throw e;
@@ -34,4 +43,11 @@ function formatToParts(locale: Locale | undefined, number: number, options?: Int
     return createFormatter(locale, options).formatToParts(number);
 }
 
-export {format, formatToParts};
+/**
+ * Test-only: clears the malformed-currency deduplication so warn-assertion tests don't pollute each other.
+ */
+function resetMalformedCurrenciesForTesting() {
+    warnedMalformedCurrencies.clear();
+}
+
+export {format, formatToParts, resetMalformedCurrenciesForTesting};

tests/unit/NumberFormatUtilsTest.ts

@@ -6,6 +6,7 @@ describe('NumberFormatUtils', () => {
     let warnSpy: jest.SpyInstance;
 
     beforeEach(() => {
+        NumberFormatUtils.resetMalformedCurrenciesForTesting();
         warnSpy = jest.spyOn(Log, 'warn').mockImplementation(() => undefined);
     });
 
@@ -82,4 +83,22 @@ describe('NumberFormatUtils', () => {
             expect(() => NumberFormatUtils.formatToParts(CONST.LOCALES.EN, 0, {style: 'unit', unit: 'not-a-real-unit'} as Intl.NumberFormatOptions)).toThrow(RangeError);
         });
     });
+
+    describe('malformed-currency warn deduplication', () => {
+        test('warns at most once per unique malformed currency across repeated format calls', () => {
+            NumberFormatUtils.format(CONST.LOCALES.EN, 25, {style: 'currency', currency: 'XX'});
+            NumberFormatUtils.format(CONST.LOCALES.EN, 25, {style: 'currency', currency: 'XX'});
+            NumberFormatUtils.format(CONST.LOCALES.EN, 25, {style: 'currency', currency: 'XX'});
+            expect(warnSpy).toHaveBeenCalledTimes(1);
+
+            NumberFormatUtils.format(CONST.LOCALES.EN, 25, {style: 'currency', currency: '???'});
+            expect(warnSpy).toHaveBeenCalledTimes(2);
+        });
+
+        test('the deduplication is shared between format and formatToParts', () => {
+            NumberFormatUtils.format(CONST.LOCALES.EN, 25, {style: 'currency', currency: 'YY'});
+            NumberFormatUtils.formatToParts(CONST.LOCALES.EN, 0, {style: 'currency', currency: 'YY'});
+            expect(warnSpy).toHaveBeenCalledTimes(1);
+        });
+    });
 });