@automattic/number-formatters 1.1.9 → 1.2.0

package/CHANGELOG.md

@@ -4,10 +4,22 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [1.2.0] - 2026-05-25
+### Added
+- Currency formatting: Add `setCurrencyOverrides` for installing a dynamic per-currency override map (e.g. from the WordPress.com currencies endpoint). Falls back to the hard-coded smallest-unit exponent overrides when not called. [#49016]
+
+## [1.1.10] - 2026-05-21
+### Changed
+- Update package dependencies. [#49012]
+
 ## [1.1.9] - 2026-05-19
 ### Fixed
 - Currency formatting: use ISO 4217 minor-unit exponent for smallest-unit conversion to correctly format IDR and other currencies where browser ICU disagrees with ISO 4217. [#48967]
 
+## [1.1.8] - 2026-05-19
+### Changed
+- Internal updates.
+
 ## [1.1.7] - 2026-05-04
 ### Changed
 - Internal: No longer require automattic/jetpack-changelogger as a per-project dev dependency. [#48225]
@@ -144,6 +156,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Initial release
 - Basic number formatting functionality
 
+[1.2.0]: https://github.com/Automattic/number-formatters/compare/1.1.10...1.2.0
+[1.1.10]: https://github.com/Automattic/number-formatters/compare/1.1.9...1.1.10
+[1.1.9]: https://github.com/Automattic/number-formatters/compare/1.1.8...1.1.9
 [1.1.8]: https://github.com/Automattic/number-formatters/compare/1.1.7...1.1.8
 [1.1.7]: https://github.com/Automattic/number-formatters/compare/1.1.6...1.1.7
 [1.1.6]: https://github.com/Automattic/number-formatters/compare/1.1.5...1.1.6

package/dist/cjs/create-number-formatters.cjs

@@ -10,6 +10,7 @@ const number_format_ts_1 = require("./number-format.cjs");
 function createNumberFormatters() {
     let localeState;
     let geoLocationState;
+    let currencyOverridesState;
     const setLocale = (locale) => {
         /**
          * The `Intl.NumberFormat` constructor fails only when there is a variant, divided by `_`.
@@ -18,6 +19,9 @@ function createNumberFormatters() {
          */
         localeState = locale;
     };
+    const setCurrencyOverrides = (overrides) => {
+        currencyOverridesState = overrides;
+    };
     /**
      * Returns the locale defined on the module instance (through `setLocale`)
      * or the "fallback locale" if no locale has been set.
@@ -80,6 +84,7 @@ function createNumberFormatters() {
             signForPositive,
             geoLocation: geoLocationState,
             forceLatin,
+            currencyOverrides: currencyOverridesState,
         });
     };
     const getCurrencyObject = (number, currency, { stripZeros = false, isSmallestUnit = false, signForPositive = false, forceLatin = true } = {}) => {
@@ -92,11 +97,13 @@ function createNumberFormatters() {
             signForPositive,
             geoLocation: geoLocationState,
             forceLatin,
+            currencyOverrides: currencyOverridesState,
         });
     };
     return {
         setLocale,
         setGeoLocation,
+        setCurrencyOverrides,
         formatNumber,
         formatNumberCompact,
         formatCurrency,

package/dist/cjs/index.cjs

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNumberFormatters = exports.getCurrencyObject = exports.formatCurrency = exports.formatNumberCompact = exports.formatNumber = exports.setGeoLocation = exports.setLocale = void 0;
+exports.createNumberFormatters = exports.getCurrencyObject = exports.formatCurrency = exports.formatNumberCompact = exports.formatNumber = exports.setCurrencyOverrides = exports.setGeoLocation = exports.setLocale = void 0;
 const tslib_1 = require("tslib");
 const create_number_formatters_ts_1 = tslib_1.__importDefault(require("./create-number-formatters.cjs"));
 exports.createNumberFormatters = create_number_formatters_ts_1.default;
 const defaultFormatter = (0, create_number_formatters_ts_1.default)();
-exports.setLocale = defaultFormatter.setLocale, exports.setGeoLocation = defaultFormatter.setGeoLocation, exports.formatNumber = defaultFormatter.formatNumber, exports.formatNumberCompact = defaultFormatter.formatNumberCompact, exports.formatCurrency = defaultFormatter.formatCurrency, exports.getCurrencyObject = defaultFormatter.getCurrencyObject;
+exports.setLocale = defaultFormatter.setLocale, exports.setGeoLocation = defaultFormatter.setGeoLocation, exports.setCurrencyOverrides = defaultFormatter.setCurrencyOverrides, exports.formatNumber = defaultFormatter.formatNumber, exports.formatNumberCompact = defaultFormatter.formatNumberCompact, exports.formatCurrency = defaultFormatter.formatCurrency, exports.getCurrencyObject = defaultFormatter.getCurrencyObject;
 // We can optionally export the formatters individually if we want to use them in a more granular way.
 // export { numberFormat, numberFormatCompact, numberFormatCurrency, getCurrencyObject };

package/dist/cjs/number-format-currency/index.cjs

@@ -9,26 +9,38 @@ const currencies_ts_1 = require("./currencies.cjs");
 const debug = (0, debug_1.default)('number-formatters:number-format-currency');
 /**
  * Retrieves the currency override for a given currency.
+ *
  * If the currency is USD and the user is not in the US, it will return `US$`.
- * @param  currency    - The currency to get the override for.
- * @param  geoLocation - The geo location of the user.
+ *
+ * Per-field merge order is: dynamic overrides (from `currencyOverrides`) → hard-coded defaults.
+ * This means a caller can supply a partial map (eg: only `decimal`) without losing the
+ * default `symbol`.
+ * @param  currency          - The currency to get the override for.
+ * @param  geoLocation       - The geo location of the user.
+ * @param  currencyOverrides - Dynamic per-currency overrides supplied by the host application.
  * @return {CurrencyOverride | undefined} The currency override.
  */
-function getCurrencyOverride(currency, geoLocation) {
+function getCurrencyOverride(currency, geoLocation, currencyOverrides) {
     if (currency === 'USD' && geoLocation && geoLocation !== '' && geoLocation !== 'US') {
-        return { symbol: 'US$' };
+        return { symbol: 'US$', ...currencyOverrides?.USD };
+    }
+    const defaultOverride = currencies_ts_1.defaultCurrencyOverrides[currency];
+    const dynamicOverride = currencyOverrides?.[currency];
+    if (!defaultOverride && !dynamicOverride) {
+        return undefined;
     }
-    return currencies_ts_1.defaultCurrencyOverrides[currency];
+    return { ...defaultOverride, ...dynamicOverride };
 }
 /**
  * Returns a valid currency code based on a shortlist of currency codes.
  * Only currencies from the shortlist are allowed. Everything else will fall back to `FALLBACK_CURRENCY`.
- * @param  currency    - The currency to get the valid currency for.
- * @param  geoLocation - The geo location of the user.
+ * @param  currency          - The currency to get the valid currency for.
+ * @param  geoLocation       - The geo location of the user.
+ * @param  currencyOverrides - Dynamic per-currency overrides supplied by the host application.
  * @return {string} The valid currency.
  */
-function getValidCurrency(currency, geoLocation) {
-    if (!getCurrencyOverride(currency, geoLocation)) {
+function getValidCurrency(currency, geoLocation, currencyOverrides) {
+    if (!getCurrencyOverride(currency, geoLocation, currencyOverrides)) {
         debug(`getValidCurrency was called with a non-existent currency "${currency}"; falling back to ${constants_ts_1.FALLBACK_CURRENCY}`);
         return constants_ts_1.FALLBACK_CURRENCY;
     }
@@ -85,9 +97,14 @@ function getCurrencyFormatter({ number, currency, browserSafeLocale, forceLatin
     });
 }
 /**
- * Smallest-unit exponent overrides for currencies where browser ICU's
+ * Hard-coded smallest-unit exponent overrides for currencies where browser ICU's
  * `maximumFractionDigits` disagrees with the API's smallest-unit encoding.
  *
+ * This list exists as a safety net for callers that have not yet wired up the
+ * dynamic `currencyOverrides` path (eg: the WPCOM currencies endpoint). Once a
+ * host application provides overrides via `setCurrencyOverrides`, those take
+ * precedence on a per-currency basis.
+ *
  * Keep this list minimal — the backend is the source of truth for the API's
  * smallest-unit encoding, so adding speculative entries here risks silent
  * drift. Only add a currency once we've verified that browsers report a
@@ -103,14 +120,20 @@ const SMALLEST_UNIT_EXPONENT_OVERRIDES = {
 /**
  * Returns the smallest unit exponent for a currency.
  *
- * Falls back to the browser-derived display precision for any currency not in
- * the override map — i.e. existing behavior is preserved for everything except
- * the explicitly listed currencies.
- * @param currency - The currency code (ISO 4217)
- * @param fallback - The browser-derived precision to use when no override applies
- * @return number  - The smallest unit exponent
+ * Lookup order:
+ * 1. The dynamic `currencyOverrides[currency].decimal` if a host application has supplied one (typically via `setCurrencyOverrides`).
+ * 2. The hard-coded `SMALLEST_UNIT_EXPONENT_OVERRIDES` map.
+ * 3. The browser-derived display precision (`fallback`).
+ * @param currency          - The currency code (ISO 4217)
+ * @param fallback          - The browser-derived precision to use when no override applies
+ * @param currencyOverrides - Dynamic per-currency overrides supplied by the host application
+ * @return number           - The smallest unit exponent
  */
-function getSmallestUnitExponent(currency, fallback) {
+function getSmallestUnitExponent(currency, fallback, currencyOverrides) {
+    const dynamicDecimal = currencyOverrides?.[currency]?.decimal;
+    if (typeof dynamicDecimal === 'number') {
+        return dynamicDecimal;
+    }
     return SMALLEST_UNIT_EXPONENT_OVERRIDES[currency] ?? fallback;
 }
 /**
@@ -151,9 +174,10 @@ function scaleNumberForPrecision(number, currencyPrecision) {
  * @param  currencyPrecision - The display precision (from the browser) to round the result to.
  * @param  currency          - The currency code, used to look up any smallest-unit exponent override.
  * @param  isSmallestUnit    - Whether the number is the smallest unit of a currency.
+ * @param  currencyOverrides - Dynamic per-currency overrides supplied by the host application.
  * @return {number} The prepared number.
  */
-function prepareNumberForFormatting(number, currencyPrecision, currency, isSmallestUnit) {
+function prepareNumberForFormatting(number, currencyPrecision, currency, isSmallestUnit, currencyOverrides) {
     if (isNaN(number)) {
         debug('formatCurrency was called with NaN');
         return 0;
@@ -162,7 +186,7 @@ function prepareNumberForFormatting(number, currencyPrecision, currency, isSmall
         if (!Number.isInteger(number)) {
             debug('formatCurrency was called with isSmallestUnit and a float which will be rounded', number);
         }
-        const smallestUnitDivisor = 10 ** getSmallestUnitExponent(currency, currencyPrecision);
+        const smallestUnitDivisor = 10 ** getSmallestUnitExponent(currency, currencyPrecision, currencyOverrides);
         return scaleNumberForPrecision(Math.round(number) / smallestUnitDivisor, currencyPrecision);
     }
     return scaleNumberForPrecision(number, currencyPrecision);
@@ -204,16 +228,17 @@ function prepareNumberForFormatting(number, currencyPrecision, currency, isSmall
  * @param  params.signForPositive   - Whether to show the sign for positive numbers.
  * @param  params.geoLocation       - The geo location of the user.
  * @param  params.forceLatin        - Whether to force the latin locale.
+ * @param  params.currencyOverrides - Dynamic per-currency overrides supplied by the host application.
  * @return {string} A formatted string.
  */
-const numberFormatCurrency = ({ number, browserSafeLocale, currency, stripZeros, isSmallestUnit, signForPositive, geoLocation, forceLatin, }) => {
-    const validCurrency = getValidCurrency(currency, geoLocation);
-    const currencyOverride = getCurrencyOverride(validCurrency, geoLocation);
+const numberFormatCurrency = ({ number, browserSafeLocale, currency, stripZeros, isSmallestUnit, signForPositive, geoLocation, forceLatin, currencyOverrides, }) => {
+    const validCurrency = getValidCurrency(currency, geoLocation, currencyOverrides);
+    const currencyOverride = getCurrencyOverride(validCurrency, geoLocation, currencyOverrides);
     const currencyPrecision = getPrecisionForLocaleAndCurrency(browserSafeLocale, validCurrency, forceLatin);
     if (isSmallestUnit && typeof currencyPrecision === 'undefined') {
         throw new Error(`Could not determine currency precision for ${validCurrency} in ${browserSafeLocale}`);
     }
-    const numberAsFloat = prepareNumberForFormatting(number, currencyPrecision ?? 0, validCurrency, isSmallestUnit);
+    const numberAsFloat = prepareNumberForFormatting(number, currencyPrecision ?? 0, validCurrency, isSmallestUnit, currencyOverrides);
     const formatter = getCurrencyFormatter({
         number: numberAsFloat,
         currency: validCurrency,
@@ -280,13 +305,14 @@ exports.numberFormatCurrency = numberFormatCurrency;
  * @param  params.signForPositive   - Whether to show the sign for positive numbers.
  * @param  params.geoLocation       - The geo location of the user.
  * @param  params.forceLatin        - Whether to force the latin locale.
+ * @param  params.currencyOverrides - Dynamic per-currency overrides supplied by the host application.
  * @return {CurrencyObject} A formatted string e.g. { symbol:'$', integer: '$99', fraction: '.99', sign: '-' }
  */
-const getCurrencyObject = ({ number, browserSafeLocale, currency, stripZeros, isSmallestUnit, signForPositive, geoLocation, forceLatin, }) => {
-    const validCurrency = getValidCurrency(currency, geoLocation);
-    const currencyOverride = getCurrencyOverride(validCurrency, geoLocation);
+const getCurrencyObject = ({ number, browserSafeLocale, currency, stripZeros, isSmallestUnit, signForPositive, geoLocation, forceLatin, currencyOverrides, }) => {
+    const validCurrency = getValidCurrency(currency, geoLocation, currencyOverrides);
+    const currencyOverride = getCurrencyOverride(validCurrency, geoLocation, currencyOverrides);
     const currencyPrecision = getPrecisionForLocaleAndCurrency(browserSafeLocale, validCurrency, forceLatin);
-    const numberAsFloat = prepareNumberForFormatting(number, currencyPrecision ?? 0, validCurrency, isSmallestUnit);
+    const numberAsFloat = prepareNumberForFormatting(number, currencyPrecision ?? 0, validCurrency, isSmallestUnit, currencyOverrides);
     const formatter = getCurrencyFormatter({
         number: numberAsFloat,
         currency: validCurrency,

package/dist/esm/create-number-formatters.js

@@ -8,6 +8,7 @@ import { numberFormat, numberFormatCompact } from "./number-format.js";
 function createNumberFormatters() {
     let localeState;
     let geoLocationState;
+    let currencyOverridesState;
     const setLocale = (locale) => {
         /**
          * The `Intl.NumberFormat` constructor fails only when there is a variant, divided by `_`.
@@ -16,6 +17,9 @@ function createNumberFormatters() {
          */
         localeState = locale;
     };
+    const setCurrencyOverrides = (overrides) => {
+        currencyOverridesState = overrides;
+    };
     /**
      * Returns the locale defined on the module instance (through `setLocale`)
      * or the "fallback locale" if no locale has been set.
@@ -78,6 +82,7 @@ function createNumberFormatters() {
             signForPositive,
             geoLocation: geoLocationState,
             forceLatin,
+            currencyOverrides: currencyOverridesState,
         });
     };
     const getCurrencyObject = (number, currency, { stripZeros = false, isSmallestUnit = false, signForPositive = false, forceLatin = true } = {}) => {
@@ -90,11 +95,13 @@ function createNumberFormatters() {
             signForPositive,
             geoLocation: geoLocationState,
             forceLatin,
+            currencyOverrides: currencyOverridesState,
         });
     };
     return {
         setLocale,
         setGeoLocation,
+        setCurrencyOverrides,
         formatNumber,
         formatNumberCompact,
         formatCurrency,

package/dist/esm/index.js

@@ -1,6 +1,6 @@
 import createNumberFormatters from "./create-number-formatters.js";
 const defaultFormatter = createNumberFormatters();
-export const { setLocale, setGeoLocation, formatNumber, formatNumberCompact, formatCurrency, getCurrencyObject, } = defaultFormatter;
+export const { setLocale, setGeoLocation, setCurrencyOverrides, formatNumber, formatNumberCompact, formatCurrency, getCurrencyObject, } = defaultFormatter;
 export { createNumberFormatters };
 // We can optionally export the formatters individually if we want to use them in a more granular way.
 // export { numberFormat, numberFormatCompact, numberFormatCurrency, getCurrencyObject };

package/dist/esm/number-format-currency/index.js

@@ -5,26 +5,38 @@ import { defaultCurrencyOverrides } from "./currencies.js";
 const debug = debugFactory('number-formatters:number-format-currency');
 /**
  * Retrieves the currency override for a given currency.
+ *
  * If the currency is USD and the user is not in the US, it will return `US$`.
- * @param  currency    - The currency to get the override for.
- * @param  geoLocation - The geo location of the user.
+ *
+ * Per-field merge order is: dynamic overrides (from `currencyOverrides`) → hard-coded defaults.
+ * This means a caller can supply a partial map (eg: only `decimal`) without losing the
+ * default `symbol`.
+ * @param  currency          - The currency to get the override for.
+ * @param  geoLocation       - The geo location of the user.
+ * @param  currencyOverrides - Dynamic per-currency overrides supplied by the host application.
  * @return {CurrencyOverride | undefined} The currency override.
  */
-function getCurrencyOverride(currency, geoLocation) {
+function getCurrencyOverride(currency, geoLocation, currencyOverrides) {
     if (currency === 'USD' && geoLocation && geoLocation !== '' && geoLocation !== 'US') {
-        return { symbol: 'US$' };
+        return { symbol: 'US$', ...currencyOverrides?.USD };
+    }
+    const defaultOverride = defaultCurrencyOverrides[currency];
+    const dynamicOverride = currencyOverrides?.[currency];
+    if (!defaultOverride && !dynamicOverride) {
+        return undefined;
     }
-    return defaultCurrencyOverrides[currency];
+    return { ...defaultOverride, ...dynamicOverride };
 }
 /**
  * Returns a valid currency code based on a shortlist of currency codes.
  * Only currencies from the shortlist are allowed. Everything else will fall back to `FALLBACK_CURRENCY`.
- * @param  currency    - The currency to get the valid currency for.
- * @param  geoLocation - The geo location of the user.
+ * @param  currency          - The currency to get the valid currency for.
+ * @param  geoLocation       - The geo location of the user.
+ * @param  currencyOverrides - Dynamic per-currency overrides supplied by the host application.
  * @return {string} The valid currency.
  */
-function getValidCurrency(currency, geoLocation) {
-    if (!getCurrencyOverride(currency, geoLocation)) {
+function getValidCurrency(currency, geoLocation, currencyOverrides) {
+    if (!getCurrencyOverride(currency, geoLocation, currencyOverrides)) {
         debug(`getValidCurrency was called with a non-existent currency "${currency}"; falling back to ${FALLBACK_CURRENCY}`);
         return FALLBACK_CURRENCY;
     }
@@ -81,9 +93,14 @@ function getCurrencyFormatter({ number, currency, browserSafeLocale, forceLatin
     });
 }
 /**
- * Smallest-unit exponent overrides for currencies where browser ICU's
+ * Hard-coded smallest-unit exponent overrides for currencies where browser ICU's
  * `maximumFractionDigits` disagrees with the API's smallest-unit encoding.
  *
+ * This list exists as a safety net for callers that have not yet wired up the
+ * dynamic `currencyOverrides` path (eg: the WPCOM currencies endpoint). Once a
+ * host application provides overrides via `setCurrencyOverrides`, those take
+ * precedence on a per-currency basis.
+ *
  * Keep this list minimal — the backend is the source of truth for the API's
  * smallest-unit encoding, so adding speculative entries here risks silent
  * drift. Only add a currency once we've verified that browsers report a
@@ -99,14 +116,20 @@ const SMALLEST_UNIT_EXPONENT_OVERRIDES = {
 /**
  * Returns the smallest unit exponent for a currency.
  *
- * Falls back to the browser-derived display precision for any currency not in
- * the override map — i.e. existing behavior is preserved for everything except
- * the explicitly listed currencies.
- * @param currency - The currency code (ISO 4217)
- * @param fallback - The browser-derived precision to use when no override applies
- * @return number  - The smallest unit exponent
+ * Lookup order:
+ * 1. The dynamic `currencyOverrides[currency].decimal` if a host application has supplied one (typically via `setCurrencyOverrides`).
+ * 2. The hard-coded `SMALLEST_UNIT_EXPONENT_OVERRIDES` map.
+ * 3. The browser-derived display precision (`fallback`).
+ * @param currency          - The currency code (ISO 4217)
+ * @param fallback          - The browser-derived precision to use when no override applies
+ * @param currencyOverrides - Dynamic per-currency overrides supplied by the host application
+ * @return number           - The smallest unit exponent
  */
-function getSmallestUnitExponent(currency, fallback) {
+function getSmallestUnitExponent(currency, fallback, currencyOverrides) {
+    const dynamicDecimal = currencyOverrides?.[currency]?.decimal;
+    if (typeof dynamicDecimal === 'number') {
+        return dynamicDecimal;
+    }
     return SMALLEST_UNIT_EXPONENT_OVERRIDES[currency] ?? fallback;
 }
 /**
@@ -147,9 +170,10 @@ function scaleNumberForPrecision(number, currencyPrecision) {
  * @param  currencyPrecision - The display precision (from the browser) to round the result to.
  * @param  currency          - The currency code, used to look up any smallest-unit exponent override.
  * @param  isSmallestUnit    - Whether the number is the smallest unit of a currency.
+ * @param  currencyOverrides - Dynamic per-currency overrides supplied by the host application.
  * @return {number} The prepared number.
  */
-function prepareNumberForFormatting(number, currencyPrecision, currency, isSmallestUnit) {
+function prepareNumberForFormatting(number, currencyPrecision, currency, isSmallestUnit, currencyOverrides) {
     if (isNaN(number)) {
         debug('formatCurrency was called with NaN');
         return 0;
@@ -158,7 +182,7 @@ function prepareNumberForFormatting(number, currencyPrecision, currency, isSmall
         if (!Number.isInteger(number)) {
             debug('formatCurrency was called with isSmallestUnit and a float which will be rounded', number);
         }
-        const smallestUnitDivisor = 10 ** getSmallestUnitExponent(currency, currencyPrecision);
+        const smallestUnitDivisor = 10 ** getSmallestUnitExponent(currency, currencyPrecision, currencyOverrides);
         return scaleNumberForPrecision(Math.round(number) / smallestUnitDivisor, currencyPrecision);
     }
     return scaleNumberForPrecision(number, currencyPrecision);
@@ -200,16 +224,17 @@ function prepareNumberForFormatting(number, currencyPrecision, currency, isSmall
  * @param  params.signForPositive   - Whether to show the sign for positive numbers.
  * @param  params.geoLocation       - The geo location of the user.
  * @param  params.forceLatin        - Whether to force the latin locale.
+ * @param  params.currencyOverrides - Dynamic per-currency overrides supplied by the host application.
  * @return {string} A formatted string.
  */
-const numberFormatCurrency = ({ number, browserSafeLocale, currency, stripZeros, isSmallestUnit, signForPositive, geoLocation, forceLatin, }) => {
-    const validCurrency = getValidCurrency(currency, geoLocation);
-    const currencyOverride = getCurrencyOverride(validCurrency, geoLocation);
+const numberFormatCurrency = ({ number, browserSafeLocale, currency, stripZeros, isSmallestUnit, signForPositive, geoLocation, forceLatin, currencyOverrides, }) => {
+    const validCurrency = getValidCurrency(currency, geoLocation, currencyOverrides);
+    const currencyOverride = getCurrencyOverride(validCurrency, geoLocation, currencyOverrides);
     const currencyPrecision = getPrecisionForLocaleAndCurrency(browserSafeLocale, validCurrency, forceLatin);
     if (isSmallestUnit && typeof currencyPrecision === 'undefined') {
         throw new Error(`Could not determine currency precision for ${validCurrency} in ${browserSafeLocale}`);
     }
-    const numberAsFloat = prepareNumberForFormatting(number, currencyPrecision ?? 0, validCurrency, isSmallestUnit);
+    const numberAsFloat = prepareNumberForFormatting(number, currencyPrecision ?? 0, validCurrency, isSmallestUnit, currencyOverrides);
     const formatter = getCurrencyFormatter({
         number: numberAsFloat,
         currency: validCurrency,
@@ -275,13 +300,14 @@ const numberFormatCurrency = ({ number, browserSafeLocale, currency, stripZeros,
  * @param  params.signForPositive   - Whether to show the sign for positive numbers.
  * @param  params.geoLocation       - The geo location of the user.
  * @param  params.forceLatin        - Whether to force the latin locale.
+ * @param  params.currencyOverrides - Dynamic per-currency overrides supplied by the host application.
  * @return {CurrencyObject} A formatted string e.g. { symbol:'$', integer: '$99', fraction: '.99', sign: '-' }
  */
-const getCurrencyObject = ({ number, browserSafeLocale, currency, stripZeros, isSmallestUnit, signForPositive, geoLocation, forceLatin, }) => {
-    const validCurrency = getValidCurrency(currency, geoLocation);
-    const currencyOverride = getCurrencyOverride(validCurrency, geoLocation);
+const getCurrencyObject = ({ number, browserSafeLocale, currency, stripZeros, isSmallestUnit, signForPositive, geoLocation, forceLatin, currencyOverrides, }) => {
+    const validCurrency = getValidCurrency(currency, geoLocation, currencyOverrides);
+    const currencyOverride = getCurrencyOverride(validCurrency, geoLocation, currencyOverrides);
     const currencyPrecision = getPrecisionForLocaleAndCurrency(browserSafeLocale, validCurrency, forceLatin);
-    const numberAsFloat = prepareNumberForFormatting(number, currencyPrecision ?? 0, validCurrency, isSmallestUnit);
+    const numberAsFloat = prepareNumberForFormatting(number, currencyPrecision ?? 0, validCurrency, isSmallestUnit, currencyOverrides);
     const formatter = getCurrencyFormatter({
         number: numberAsFloat,
         currency: validCurrency,

package/dist/types/create-number-formatters.d.ts

@@ -1,4 +1,4 @@
-import type { FormatCurrency, FormatNumber, GetCurrencyObject } from './types.ts';
+import type { CurrencyOverride, FormatCurrency, FormatNumber, GetCurrencyObject } from './types.ts';
 declare global {
     interface Window {
         wp?: {
@@ -23,6 +23,23 @@ export interface NumberFormatters {
      * @param geoLocation - The geo location to use for formatting
      */
     setGeoLocation(geoLocation: string): void;
+    /**
+     * Sets a dynamic map of per-currency overrides used by currency formatting.
+     *
+     * Typical use: load `{ "IDR": { "decimal": 0 } }` from the WPCOM currencies
+     * endpoint at app boot and pass the parsed object here. Each entry can carry
+     * a `symbol` and/or `decimal` (the smallest-unit exponent), and additional
+     * fields may be added to `CurrencyOverride` in the future.
+     *
+     * If this setter is never called, the package falls back to the hard-coded
+     * defaults shipped with the package, preserving previous behavior.
+     *
+     * When called with a partial map, missing currencies or fields fall back to
+     * the hard-coded defaults — passing `{ IDR: { decimal: 0 } }` does not clear
+     * the default IDR symbol, for example.
+     * @param overrides - Map of currency code to override settings
+     */
+    setCurrencyOverrides(overrides: Record<string, CurrencyOverride>): void;
     /**
      * Formats numbers using locale settings and/or passed options.
      * @param  number                     - The number to format.

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
 import createNumberFormatters from './create-number-formatters.ts';
-export declare const setLocale: (locale: string) => void, setGeoLocation: (geoLocation: string) => void, formatNumber: import("./types.ts").FormatNumber, formatNumberCompact: import("./types.ts").FormatNumber, formatCurrency: import("./types.ts").FormatCurrency, getCurrencyObject: import("./types.ts").GetCurrencyObject;
+export declare const setLocale: (locale: string) => void, setGeoLocation: (geoLocation: string) => void, setCurrencyOverrides: (overrides: Record<string, import("./types.ts").CurrencyOverride>) => void, formatNumber: import("./types.ts").FormatNumber, formatNumberCompact: import("./types.ts").FormatNumber, formatCurrency: import("./types.ts").FormatCurrency, getCurrencyObject: import("./types.ts").GetCurrencyObject;
 export { createNumberFormatters };
 export type * from './types.ts';

package/dist/types/number-format-currency/index.d.ts

@@ -36,9 +36,10 @@ import type { CurrencyObject, NumberFormatCurrencyParams } from '../types.ts';
  * @param  params.signForPositive   - Whether to show the sign for positive numbers.
  * @param  params.geoLocation       - The geo location of the user.
  * @param  params.forceLatin        - Whether to force the latin locale.
+ * @param  params.currencyOverrides - Dynamic per-currency overrides supplied by the host application.
  * @return {string} A formatted string.
  */
-declare const numberFormatCurrency: ({ number, browserSafeLocale, currency, stripZeros, isSmallestUnit, signForPositive, geoLocation, forceLatin, }: NumberFormatCurrencyParams) => string;
+declare const numberFormatCurrency: ({ number, browserSafeLocale, currency, stripZeros, isSmallestUnit, signForPositive, geoLocation, forceLatin, currencyOverrides, }: NumberFormatCurrencyParams) => string;
 /**
  * Returns a formatted price object which can be used to manually render a
  * formatted currency (eg: if you wanted to render the currency symbol in a
@@ -83,7 +84,8 @@ declare const numberFormatCurrency: ({ number, browserSafeLocale, currency, stri
  * @param  params.signForPositive   - Whether to show the sign for positive numbers.
  * @param  params.geoLocation       - The geo location of the user.
  * @param  params.forceLatin        - Whether to force the latin locale.
+ * @param  params.currencyOverrides - Dynamic per-currency overrides supplied by the host application.
  * @return {CurrencyObject} A formatted string e.g. { symbol:'$', integer: '$99', fraction: '.99', sign: '-' }
  */
-declare const getCurrencyObject: ({ number, browserSafeLocale, currency, stripZeros, isSmallestUnit, signForPositive, geoLocation, forceLatin, }: NumberFormatCurrencyParams) => CurrencyObject;
+declare const getCurrencyObject: ({ number, browserSafeLocale, currency, stripZeros, isSmallestUnit, signForPositive, geoLocation, forceLatin, currencyOverrides, }: NumberFormatCurrencyParams) => CurrencyObject;
 export { numberFormatCurrency, getCurrencyObject };

package/dist/types/types.d.ts

@@ -21,6 +21,19 @@ export interface NumberFormatParams {
 }
 export interface CurrencyOverride {
     symbol?: string;
+    /**
+     * Smallest-unit exponent for this currency, used when the browser's ICU
+     * `maximumFractionDigits` disagrees with the API's smallest-unit encoding,
+     * or when this package's hard-coded fallback exponent (see
+     * `SMALLEST_UNIT_EXPONENT_OVERRIDES` in `number-format-currency/index.ts`)
+     * disagrees with the host application's source of truth.
+     *
+     * For example, modern browser ICU (Chrome / Node 24+) reports IDR as
+     * 0-decimal, but this package's hard-coded fallback applies an exponent of
+     * 2 for legacy compatibility. The WPCOM currencies endpoint can send
+     * `{ "IDR": { "decimal": 0 } }` to override that hard-coded 2 back to 0.
+     */
+    decimal?: number;
 }
 export interface NumberFormatCurrencyParams {
     /**
@@ -67,6 +80,16 @@ export interface NumberFormatCurrencyParams {
      * sign (eg: `+$35.00`). Has no effect on negative numbers or 0.
      */
     signForPositive?: boolean;
+    /**
+     * Dynamic currency overrides, typically supplied by the host application
+     * (eg: from a remote endpoint) via `setCurrencyOverrides`.
+     *
+     * When provided, entries here take precedence over the hard-coded defaults
+     * baked into the package on a per-field basis. Anything not specified in
+     * this map falls back to the hard-coded defaults, so passing a partial map
+     * is safe.
+     */
+    currencyOverrides?: Record<string, CurrencyOverride>;
 }
 export interface CurrencyObject {
     /**
@@ -115,5 +138,5 @@ export interface CurrencyObject {
     floatValue: number;
 }
 export type FormatNumber = (number: number, options?: Omit<NumberFormatParams, 'browserSafeLocale'>) => string;
-export type FormatCurrency = (number: number, currency: string, options?: Omit<NumberFormatCurrencyParams, 'number' | 'currency' | 'browserSafeLocale' | 'geoLocation'>) => string;
-export type GetCurrencyObject = (number: number, currency: string, options?: Omit<NumberFormatCurrencyParams, 'number' | 'currency' | 'browserSafeLocale' | 'geoLocation'>) => CurrencyObject;
+export type FormatCurrency = (number: number, currency: string, options?: Omit<NumberFormatCurrencyParams, 'number' | 'currency' | 'browserSafeLocale' | 'geoLocation' | 'currencyOverrides'>) => string;
+export type GetCurrencyObject = (number: number, currency: string, options?: Omit<NumberFormatCurrencyParams, 'number' | 'currency' | 'browserSafeLocale' | 'geoLocation' | 'currencyOverrides'>) => CurrencyObject;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@automattic/number-formatters",
-	"version": "1.1.9",
+	"version": "1.2.0",
 	"description": "Number formatting utilities",
 	"homepage": "https://github.com/Automattic/jetpack/tree/HEAD/projects/js-packages/number-formatters/#readme",
 	"bugs": {
@@ -39,11 +39,11 @@
 	"devDependencies": {
 		"@babel/core": "7.29.0",
 		"@babel/preset-react": "7.28.5",
-		"@jest/globals": "30.3.0",
+		"@jest/globals": "30.4.1",
 		"@knighted/duel": "4.0.2",
 		"@types/jest": "30.0.0",
 		"@typescript/native-preview": "7.0.0-dev.20260225.1",
-		"jest": "30.3.0",
+		"jest": "30.4.2",
 		"jetpack-js-tools": "workspace:*",
 		"typescript": "5.9.3"
 	}

package/src/create-number-formatters.ts

@@ -4,7 +4,13 @@ import {
 	getCurrencyObject as getCurrencyObjectFromCurrencyFormatter,
 } from './number-format-currency/index.ts';
 import { numberFormat, numberFormatCompact } from './number-format.ts';
-import type { CurrencyObject, FormatCurrency, FormatNumber, GetCurrencyObject } from './types.ts';
+import type {
+	CurrencyObject,
+	CurrencyOverride,
+	FormatCurrency,
+	FormatNumber,
+	GetCurrencyObject,
+} from './types.ts';
 
 declare global {
 	interface Window {
@@ -33,6 +39,24 @@ export interface NumberFormatters {
 	 */
 	setGeoLocation( geoLocation: string ): void;
 
+	/**
+	 * Sets a dynamic map of per-currency overrides used by currency formatting.
+	 *
+	 * Typical use: load `{ "IDR": { "decimal": 0 } }` from the WPCOM currencies
+	 * endpoint at app boot and pass the parsed object here. Each entry can carry
+	 * a `symbol` and/or `decimal` (the smallest-unit exponent), and additional
+	 * fields may be added to `CurrencyOverride` in the future.
+	 *
+	 * If this setter is never called, the package falls back to the hard-coded
+	 * defaults shipped with the package, preserving previous behavior.
+	 *
+	 * When called with a partial map, missing currencies or fields fall back to
+	 * the hard-coded defaults — passing `{ IDR: { decimal: 0 } }` does not clear
+	 * the default IDR symbol, for example.
+	 * @param overrides - Map of currency code to override settings
+	 */
+	setCurrencyOverrides( overrides: Record< string, CurrencyOverride > ): void;
+
 	/**
 	 * Formats numbers using locale settings and/or passed options.
 	 * @param  number                     - The number to format.
@@ -150,6 +174,7 @@ export interface NumberFormatters {
 function createNumberFormatters(): NumberFormatters {
 	let localeState: string | undefined;
 	let geoLocationState: string | undefined;
+	let currencyOverridesState: Record< string, CurrencyOverride > | undefined;
 
 	const setLocale = ( locale: string ): void => {
 		/**
@@ -160,6 +185,10 @@ function createNumberFormatters(): NumberFormatters {
 		localeState = locale;
 	};
 
+	const setCurrencyOverrides = ( overrides: Record< string, CurrencyOverride > ): void => {
+		currencyOverridesState = overrides;
+	};
+
 	/**
 	 * Returns the locale defined on the module instance (through `setLocale`)
 	 * or the "fallback locale" if no locale has been set.
@@ -242,6 +271,7 @@ function createNumberFormatters(): NumberFormatters {
 			signForPositive,
 			geoLocation: geoLocationState,
 			forceLatin,
+			currencyOverrides: currencyOverridesState,
 		} );
 	};
 
@@ -259,12 +289,14 @@ function createNumberFormatters(): NumberFormatters {
 			signForPositive,
 			geoLocation: geoLocationState,
 			forceLatin,
+			currencyOverrides: currencyOverridesState,
 		} );
 	};
 
 	return {
 		setLocale,
 		setGeoLocation,
+		setCurrencyOverrides,
 		formatNumber,
 		formatNumberCompact,
 		formatCurrency,

package/src/index.ts

@@ -5,6 +5,7 @@ const defaultFormatter = createNumberFormatters();
 export const {
 	setLocale,
 	setGeoLocation,
+	setCurrencyOverrides,
 	formatNumber,
 	formatNumberCompact,
 	formatCurrency,

package/src/number-format-currency/index.ts

@@ -8,30 +8,47 @@ const debug = debugFactory( 'number-formatters:number-format-currency' );
 
 /**
  * Retrieves the currency override for a given currency.
+ *
  * If the currency is USD and the user is not in the US, it will return `US$`.
- * @param  currency    - The currency to get the override for.
- * @param  geoLocation - The geo location of the user.
+ *
+ * Per-field merge order is: dynamic overrides (from `currencyOverrides`) → hard-coded defaults.
+ * This means a caller can supply a partial map (eg: only `decimal`) without losing the
+ * default `symbol`.
+ * @param  currency          - The currency to get the override for.
+ * @param  geoLocation       - The geo location of the user.
+ * @param  currencyOverrides - Dynamic per-currency overrides supplied by the host application.
  * @return {CurrencyOverride | undefined} The currency override.
  */
 function getCurrencyOverride(
 	currency: string,
-	geoLocation?: string
+	geoLocation?: string,
+	currencyOverrides?: Record< string, CurrencyOverride >
 ): CurrencyOverride | undefined {
 	if ( currency === 'USD' && geoLocation && geoLocation !== '' && geoLocation !== 'US' ) {
-		return { symbol: 'US$' };
+		return { symbol: 'US$', ...currencyOverrides?.USD };
 	}
-	return defaultCurrencyOverrides[ currency ];
+	const defaultOverride = defaultCurrencyOverrides[ currency ];
+	const dynamicOverride = currencyOverrides?.[ currency ];
+	if ( ! defaultOverride && ! dynamicOverride ) {
+		return undefined;
+	}
+	return { ...defaultOverride, ...dynamicOverride };
 }
 
 /**
  * Returns a valid currency code based on a shortlist of currency codes.
  * Only currencies from the shortlist are allowed. Everything else will fall back to `FALLBACK_CURRENCY`.
- * @param  currency    - The currency to get the valid currency for.
- * @param  geoLocation - The geo location of the user.
+ * @param  currency          - The currency to get the valid currency for.
+ * @param  geoLocation       - The geo location of the user.
+ * @param  currencyOverrides - Dynamic per-currency overrides supplied by the host application.
  * @return {string} The valid currency.
  */
-function getValidCurrency( currency: string, geoLocation?: string ): string {
-	if ( ! getCurrencyOverride( currency, geoLocation ) ) {
+function getValidCurrency(
+	currency: string,
+	geoLocation?: string,
+	currencyOverrides?: Record< string, CurrencyOverride >
+): string {
+	if ( ! getCurrencyOverride( currency, geoLocation, currencyOverrides ) ) {
 		debug(
 			`getValidCurrency was called with a non-existent currency "${ currency }"; falling back to ${ FALLBACK_CURRENCY }`
 		);
@@ -99,9 +116,14 @@ function getCurrencyFormatter( {
 }
 
 /**
- * Smallest-unit exponent overrides for currencies where browser ICU's
+ * Hard-coded smallest-unit exponent overrides for currencies where browser ICU's
  * `maximumFractionDigits` disagrees with the API's smallest-unit encoding.
  *
+ * This list exists as a safety net for callers that have not yet wired up the
+ * dynamic `currencyOverrides` path (eg: the WPCOM currencies endpoint). Once a
+ * host application provides overrides via `setCurrencyOverrides`, those take
+ * precedence on a per-currency basis.
+ *
  * Keep this list minimal — the backend is the source of truth for the API's
  * smallest-unit encoding, so adding speculative entries here risks silent
  * drift. Only add a currency once we've verified that browsers report a
@@ -118,14 +140,24 @@ const SMALLEST_UNIT_EXPONENT_OVERRIDES: Record< string, number > = {
 /**
  * Returns the smallest unit exponent for a currency.
  *
- * Falls back to the browser-derived display precision for any currency not in
- * the override map — i.e. existing behavior is preserved for everything except
- * the explicitly listed currencies.
- * @param currency - The currency code (ISO 4217)
- * @param fallback - The browser-derived precision to use when no override applies
- * @return number  - The smallest unit exponent
+ * Lookup order:
+ * 1. The dynamic `currencyOverrides[currency].decimal` if a host application has supplied one (typically via `setCurrencyOverrides`).
+ * 2. The hard-coded `SMALLEST_UNIT_EXPONENT_OVERRIDES` map.
+ * 3. The browser-derived display precision (`fallback`).
+ * @param currency          - The currency code (ISO 4217)
+ * @param fallback          - The browser-derived precision to use when no override applies
+ * @param currencyOverrides - Dynamic per-currency overrides supplied by the host application
+ * @return number           - The smallest unit exponent
  */
-function getSmallestUnitExponent( currency: string, fallback: number ): number {
+function getSmallestUnitExponent(
+	currency: string,
+	fallback: number,
+	currencyOverrides?: Record< string, CurrencyOverride >
+): number {
+	const dynamicDecimal = currencyOverrides?.[ currency ]?.decimal;
+	if ( typeof dynamicDecimal === 'number' ) {
+		return dynamicDecimal;
+	}
 	return SMALLEST_UNIT_EXPONENT_OVERRIDES[ currency ] ?? fallback;
 }
 
@@ -173,13 +205,15 @@ function scaleNumberForPrecision( number: number, currencyPrecision: number ): n
  * @param  currencyPrecision - The display precision (from the browser) to round the result to.
  * @param  currency          - The currency code, used to look up any smallest-unit exponent override.
  * @param  isSmallestUnit    - Whether the number is the smallest unit of a currency.
+ * @param  currencyOverrides - Dynamic per-currency overrides supplied by the host application.
  * @return {number} The prepared number.
  */
 function prepareNumberForFormatting(
 	number: number,
 	currencyPrecision: number,
 	currency: string,
-	isSmallestUnit?: boolean
+	isSmallestUnit?: boolean,
+	currencyOverrides?: Record< string, CurrencyOverride >
 ): number {
 	if ( isNaN( number ) ) {
 		debug( 'formatCurrency was called with NaN' );
@@ -193,7 +227,8 @@ function prepareNumberForFormatting(
 				number
 			);
 		}
-		const smallestUnitDivisor = 10 ** getSmallestUnitExponent( currency, currencyPrecision );
+		const smallestUnitDivisor =
+			10 ** getSmallestUnitExponent( currency, currencyPrecision, currencyOverrides );
 		return scaleNumberForPrecision( Math.round( number ) / smallestUnitDivisor, currencyPrecision );
 	}
 
@@ -237,6 +272,7 @@ function prepareNumberForFormatting(
  * @param  params.signForPositive   - Whether to show the sign for positive numbers.
  * @param  params.geoLocation       - The geo location of the user.
  * @param  params.forceLatin        - Whether to force the latin locale.
+ * @param  params.currencyOverrides - Dynamic per-currency overrides supplied by the host application.
  * @return {string} A formatted string.
  */
 const numberFormatCurrency = ( {
@@ -248,9 +284,10 @@ const numberFormatCurrency = ( {
 	signForPositive,
 	geoLocation,
 	forceLatin,
+	currencyOverrides,
 }: NumberFormatCurrencyParams ) => {
-	const validCurrency = getValidCurrency( currency, geoLocation );
-	const currencyOverride = getCurrencyOverride( validCurrency, geoLocation );
+	const validCurrency = getValidCurrency( currency, geoLocation, currencyOverrides );
+	const currencyOverride = getCurrencyOverride( validCurrency, geoLocation, currencyOverrides );
 	const currencyPrecision = getPrecisionForLocaleAndCurrency(
 		browserSafeLocale,
 		validCurrency,
@@ -267,7 +304,8 @@ const numberFormatCurrency = ( {
 		number,
 		currencyPrecision ?? 0,
 		validCurrency,
-		isSmallestUnit
+		isSmallestUnit,
+		currencyOverrides
 	);
 	const formatter = getCurrencyFormatter( {
 		number: numberAsFloat,
@@ -336,6 +374,7 @@ const numberFormatCurrency = ( {
  * @param  params.signForPositive   - Whether to show the sign for positive numbers.
  * @param  params.geoLocation       - The geo location of the user.
  * @param  params.forceLatin        - Whether to force the latin locale.
+ * @param  params.currencyOverrides - Dynamic per-currency overrides supplied by the host application.
  * @return {CurrencyObject} A formatted string e.g. { symbol:'$', integer: '$99', fraction: '.99', sign: '-' }
  */
 const getCurrencyObject = ( {
@@ -347,9 +386,10 @@ const getCurrencyObject = ( {
 	signForPositive,
 	geoLocation,
 	forceLatin,
+	currencyOverrides,
 }: NumberFormatCurrencyParams ): CurrencyObject => {
-	const validCurrency = getValidCurrency( currency, geoLocation );
-	const currencyOverride = getCurrencyOverride( validCurrency, geoLocation );
+	const validCurrency = getValidCurrency( currency, geoLocation, currencyOverrides );
+	const currencyOverride = getCurrencyOverride( validCurrency, geoLocation, currencyOverrides );
 	const currencyPrecision = getPrecisionForLocaleAndCurrency(
 		browserSafeLocale,
 		validCurrency,
@@ -359,7 +399,8 @@ const getCurrencyObject = ( {
 		number,
 		currencyPrecision ?? 0,
 		validCurrency,
-		isSmallestUnit
+		isSmallestUnit,
+		currencyOverrides
 	);
 	const formatter = getCurrencyFormatter( {
 		number: numberAsFloat,

package/src/types.ts

@@ -22,6 +22,19 @@ export interface NumberFormatParams {
 
 export interface CurrencyOverride {
 	symbol?: string;
+	/**
+	 * Smallest-unit exponent for this currency, used when the browser's ICU
+	 * `maximumFractionDigits` disagrees with the API's smallest-unit encoding,
+	 * or when this package's hard-coded fallback exponent (see
+	 * `SMALLEST_UNIT_EXPONENT_OVERRIDES` in `number-format-currency/index.ts`)
+	 * disagrees with the host application's source of truth.
+	 *
+	 * For example, modern browser ICU (Chrome / Node 24+) reports IDR as
+	 * 0-decimal, but this package's hard-coded fallback applies an exponent of
+	 * 2 for legacy compatibility. The WPCOM currencies endpoint can send
+	 * `{ "IDR": { "decimal": 0 } }` to override that hard-coded 2 back to 0.
+	 */
+	decimal?: number;
 }
 
 export interface NumberFormatCurrencyParams {
@@ -76,6 +89,17 @@ export interface NumberFormatCurrencyParams {
 	 * sign (eg: `+$35.00`). Has no effect on negative numbers or 0.
 	 */
 	signForPositive?: boolean;
+
+	/**
+	 * Dynamic currency overrides, typically supplied by the host application
+	 * (eg: from a remote endpoint) via `setCurrencyOverrides`.
+	 *
+	 * When provided, entries here take precedence over the hard-coded defaults
+	 * baked into the package on a per-field basis. Anything not specified in
+	 * this map falls back to the hard-coded defaults, so passing a partial map
+	 * is safe.
+	 */
+	currencyOverrides?: Record< string, CurrencyOverride >;
 }
 
 export interface CurrencyObject {
@@ -141,7 +165,7 @@ export type FormatCurrency = (
 	currency: string,
 	options?: Omit<
 		NumberFormatCurrencyParams,
-		'number' | 'currency' | 'browserSafeLocale' | 'geoLocation'
+		'number' | 'currency' | 'browserSafeLocale' | 'geoLocation' | 'currencyOverrides'
 	>
 ) => string;
 
@@ -150,6 +174,6 @@ export type GetCurrencyObject = (
 	currency: string,
 	options?: Omit<
 		NumberFormatCurrencyParams,
-		'number' | 'currency' | 'browserSafeLocale' | 'geoLocation'
+		'number' | 'currency' | 'browserSafeLocale' | 'geoLocation' | 'currencyOverrides'
 	>
 ) => CurrencyObject;