@formatjs/intl-numberformat 8.0.2 → 8.1.0

package/index.ts

@@ -0,0 +1 @@
+export * from './src/core'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@formatjs/intl-numberformat",
-  "version": "8.0.2",
+  "version": "8.1.0",
   "description": "Ponyfill for ES2020 Intl.NumberFormat",
   "keywords": [
     "polyfill",
@@ -22,12 +22,17 @@
     "url": "git+https://github.com/formatjs/formatjs.git"
   },
   "dependencies": {
-    "@formatjs/ecma402-abstract": "1.11.7",
-    "@formatjs/intl-localematcher": "0.2.28",
+    "@formatjs/ecma402-abstract": "1.11.9",
+    "@formatjs/intl-localematcher": "0.2.29",
     "tslib": "2.4.0"
   },
+  "devDependencies": {
+    "@formatjs/intl-getcanonicallocales": "2.0.3",
+    "@formatjs/intl-locale": "3.0.4",
+    "@formatjs/intl-pluralrules": "5.1.0"
+  },
   "bugs": {
     "url": "https://github.com/formatjs/formatjs/issues"
   },
   "gitHead": "a7842673d8ad205171ad7c8cb8bb2f318b427c0c"
-}
+}

package/polyfill-force.ts

@@ -0,0 +1,13 @@
+import {NumberFormat} from './src/core'
+import {toLocaleString as _toLocaleString} from './src/to_locale_string'
+import {defineProperty, NumberFormatOptions} from '@formatjs/ecma402-abstract'
+
+defineProperty(Intl, 'NumberFormat', {value: NumberFormat})
+defineProperty(Number.prototype, 'toLocaleString', {
+  value: function toLocaleString(
+    locales?: string | string[],
+    options?: NumberFormatOptions
+  ) {
+    return _toLocaleString(this, locales, options)
+  },
+})

package/polyfill.ts

@@ -0,0 +1,16 @@
+import {NumberFormat} from './src/core'
+import {toLocaleString as _toLocaleString} from './src/to_locale_string'
+import {defineProperty, NumberFormatOptions} from '@formatjs/ecma402-abstract'
+import {shouldPolyfill} from './should-polyfill'
+
+if (shouldPolyfill()) {
+  defineProperty(Intl, 'NumberFormat', {value: NumberFormat})
+  defineProperty(Number.prototype, 'toLocaleString', {
+    value: function toLocaleString(
+      locales?: string | string[],
+      options?: NumberFormatOptions
+    ) {
+      return _toLocaleString(this, locales, options)
+    },
+  })
+}

package/scripts/cldr-raw.ts

@@ -0,0 +1,42 @@
+import {generateDataForLocales as extractCurrencies} from './extract-currencies'
+import {generateDataForLocales as extractUnits} from './extract-units'
+import {generateDataForLocales as extractNumbers} from './extract-numbers'
+import {join} from 'path'
+import {outputJSONSync} from 'fs-extra'
+import * as AVAILABLE_LOCALES from 'cldr-core/availableLocales.json'
+import minimist from 'minimist'
+
+async function main(args: minimist.ParsedArgs) {
+  const {outDir} = args
+  // Dist all locale files to locale-data
+  const locales = AVAILABLE_LOCALES.availableLocales.full.filter(l => {
+    try {
+      return (Intl as any).getCanonicalLocales(l).length
+    } catch (e) {
+      console.warn(`Invalid locale ${l}`)
+      return false
+    }
+  })
+  const [numbersData, currenciesData, unitsData] = await Promise.all([
+    extractNumbers(locales),
+    extractCurrencies(locales),
+    extractUnits(locales),
+  ])
+
+  for (let locale of locales) {
+    const d = {
+      units: unitsData[locale],
+      currencies: currenciesData[locale],
+      numbers: numbersData[locale],
+      nu: numbersData[locale].nu,
+    }
+    outputJSONSync(join(outDir, `${locale}.json`), {
+      data: d,
+      locale,
+    })
+  }
+}
+
+if (require.main === module) {
+  ;(async () => main(minimist(process.argv)))()
+}

package/scripts/cldr.ts

@@ -0,0 +1,31 @@
+import {join, basename} from 'path'
+import {outputFileSync, readFileSync} from 'fs-extra'
+import minimist from 'minimist'
+
+interface Args extends minimist.ParsedArgs {
+  cldrFile: string[]
+  outDir: string
+}
+
+function main(args: Args) {
+  const {cldrFile: cldrFiles, outDir} = args
+  cldrFiles.sort()
+  cldrFiles.forEach(cldrFile => {
+    const locale = basename(cldrFile, '.json')
+    // Dist all locale files to locale-data (JS)
+    const data = readFileSync(cldrFile)
+    outputFileSync(
+      join(outDir, locale + '.js'),
+      `/* @generated */
+// prettier-ignore
+if (Intl.NumberFormat && typeof Intl.NumberFormat.__addLocaleData === 'function') {
+  Intl.NumberFormat.__addLocaleData(${data})
+}`
+    )
+    outputFileSync(join(outDir, locale + '.d.ts'), 'export {}')
+  })
+}
+
+if (require.main === module) {
+  main(minimist<Args>(process.argv))
+}

package/scripts/currency-digits.ts

@@ -0,0 +1,18 @@
+import minimist from 'minimist'
+import {extractCurrencyDigits} from './extract-currencies'
+import {outputFileSync} from 'fs-extra'
+
+function main(args: minimist.ParsedArgs) {
+  const {out} = args
+  // Output currency digits file
+  outputFileSync(
+    out,
+    `export const currencyDigitsData: Record<string, number> = ${JSON.stringify(
+      extractCurrencyDigits()
+    )}`
+  )
+}
+
+if (require.main === module) {
+  main(minimist(process.argv))
+}

package/scripts/extract-currencies.ts

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2015, Yahoo Inc.
+ * Copyrights licensed under the New BSD License.
+ * See the accompanying LICENSE file for terms.
+ */
+'use strict'
+import * as CurrenciesData from 'cldr-numbers-full/main/en/currencies.json'
+import * as supplementalCurrencyData from 'cldr-core/supplemental/currencyData.json'
+import {sync as globSync} from 'fast-glob'
+import {resolve, dirname} from 'path'
+import {CurrencyData, LDMLPluralRuleMap} from '@formatjs/ecma402-abstract'
+import * as AVAILABLE_LOCALES from 'cldr-core/availableLocales.json'
+import {collapseSingleValuePluralRule, PLURAL_RULES} from './utils'
+
+export type Currencies =
+  typeof CurrenciesData['main']['en']['numbers']['currencies']
+
+function extractCurrencyPattern(d: Currencies['USD']) {
+  if (!d['displayName-count-other']) {
+    return
+  }
+  return collapseSingleValuePluralRule(
+    PLURAL_RULES.reduce(
+      (all: LDMLPluralRuleMap<string>, ldml) => {
+        if (d[`displayName-count-${ldml}` as 'displayName-count-one']) {
+          all[ldml] = d[`displayName-count-${ldml}` as 'displayName-count-one']
+        }
+        return all
+      },
+      {other: d['displayName-count-other']}
+    )
+  )
+}
+
+export function getAllLocales(): string[] {
+  return globSync('*/units.json', {
+    cwd: resolve(
+      dirname(require.resolve('cldr-units-full/package.json')),
+      './main'
+    ),
+  }).map(dirname)
+}
+
+async function loadCurrencies(
+  locale: string
+): Promise<Record<string, CurrencyData>> {
+  const currencies = (
+    (await import(
+      `cldr-numbers-full/main/${locale}/currencies.json`
+    )) as typeof CurrenciesData
+  ).main[locale as 'en'].numbers.currencies
+  return (Object.keys(currencies) as Array<keyof typeof currencies>).reduce(
+    (all: Record<string, CurrencyData>, isoCode) => {
+      const d = currencies[isoCode] as Currencies['USD']
+      const displayName = extractCurrencyPattern(d) || {other: d.displayName}
+      all[isoCode] = {
+        displayName,
+        symbol: d.symbol || isoCode,
+        narrow: d['symbol-alt-narrow'] || d.symbol || isoCode,
+      }
+      return all
+    },
+    {}
+  )
+}
+
+export async function generateDataForLocales(
+  locales: string[] = AVAILABLE_LOCALES.availableLocales.full
+): Promise<Record<string, Record<string, CurrencyData>>> {
+  const data = await Promise.all(locales.map(loadCurrencies))
+  return data.reduce(
+    (all: Record<string, Record<string, CurrencyData>>, d, i) => {
+      all[locales[i]] = d
+      return all
+    },
+    {}
+  )
+}
+
+export function extractCurrencyDigits(): Record<string, number> {
+  const data = supplementalCurrencyData.supplemental.currencyData.fractions
+  return (Object.keys(data) as Array<keyof typeof data>).reduce(
+    (all: Record<string, number>, code) => {
+      all[code] = +data[code]._digits
+      return all
+    },
+    {}
+  )
+}

package/scripts/extract-numbers.ts

@@ -0,0 +1,151 @@
+/*
+ * Copyright 2015, Yahoo Inc.
+ * Copyrights licensed under the New BSD License.
+ * See the accompanying LICENSE file for terms.
+ */
+import * as NumbersData from 'cldr-numbers-full/main/ar/numbers.json'
+import * as numberingSystems from 'cldr-core/supplemental/numberingSystems.json'
+import {
+  RawNumberData,
+  SymbolsData,
+  LDMLPluralRuleMap,
+  DecimalFormatNum,
+  RawCurrencyData,
+  invariant,
+} from '@formatjs/ecma402-abstract'
+import * as AVAILABLE_LOCALES from 'cldr-core/availableLocales.json'
+import {collapseSingleValuePluralRule, PLURAL_RULES} from './utils'
+
+export type Numbers = typeof NumbersData['main']['ar']['numbers']
+
+const COUNTS = [
+  '1000',
+  '10000',
+  '100000',
+  '1000000',
+  '10000000',
+  '100000000',
+  '1000000000',
+  '10000000000',
+  '100000000000',
+  '1000000000000',
+  '10000000000000',
+  '100000000000000',
+] as Array<DecimalFormatNum>
+
+function reduceNumCount<
+  T extends Numbers['decimalFormats-numberSystem-latn']['long']['decimalFormat']
+>(d: T): Record<DecimalFormatNum, LDMLPluralRuleMap<string>> {
+  return COUNTS.reduce(
+    (all: Record<DecimalFormatNum, LDMLPluralRuleMap<string>>, num) => {
+      all[num] = collapseSingleValuePluralRule(
+        PLURAL_RULES.reduce(
+          (all: LDMLPluralRuleMap<string>, pl) => {
+            all[pl] = d[`${num}-count-${pl}` as '1000-count-one']
+            return all
+          },
+          {other: d[`${num}-count-other` as '1000-count-other']}
+        )
+      )
+      return all
+    },
+    {} as Record<DecimalFormatNum, LDMLPluralRuleMap<string>>
+  )
+}
+
+function extractNumbers(d: Numbers): RawNumberData {
+  const nu =
+    d.defaultNumberingSystem === 'latn'
+      ? ['latn']
+      : [d.defaultNumberingSystem, 'latn']
+  return {
+    nu,
+    symbols: nu.reduce((all: Record<string, SymbolsData>, ns) => {
+      all[ns] = d[`symbols-numberSystem-${ns}` as 'symbols-numberSystem-latn']
+      return all
+    }, {}),
+    percent: nu.reduce((all: RawNumberData['percent'], ns) => {
+      all[ns] =
+        d[
+          `percentFormats-numberSystem-${ns}` as 'percentFormats-numberSystem-latn'
+        ].standard
+      return all
+    }, {}),
+    decimal: nu.reduce((all: RawNumberData['decimal'], ns) => {
+      const decimalData =
+        d[
+          `decimalFormats-numberSystem-${ns}` as 'decimalFormats-numberSystem-latn'
+        ]
+      const longData = decimalData.long.decimalFormat
+      const shortData = decimalData.short.decimalFormat
+
+      invariant(
+        decimalData.standard.includes('.'),
+        `Decimal pattern does not contain decimal point: ${decimalData.standard}`
+      )
+
+      all[ns] = {
+        standard: decimalData.standard,
+        long: reduceNumCount(longData),
+        short: reduceNumCount(shortData),
+      }
+      return all
+    }, {}),
+    currency: nu.reduce((all: RawNumberData['currency'], ns) => {
+      const {
+        currencySpacing,
+        standard,
+        accounting,
+        'unitPattern-count-other': unitPattern,
+        short,
+      } = d[
+        `currencyFormats-numberSystem-${ns}` as 'currencyFormats-numberSystem-latn'
+      ]
+      all[ns] = {
+        currencySpacing: {
+          beforeInsertBetween: currencySpacing.beforeCurrency.insertBetween,
+          afterInsertBetween: currencySpacing.afterCurrency.insertBetween,
+        },
+        standard,
+        accounting,
+        unitPattern,
+      } as RawCurrencyData
+      if (short) {
+        all[ns].short = reduceNumCount(short.standard)
+      }
+      return all
+    }, {}),
+  }
+}
+
+async function loadNumbers(locale: string): Promise<RawNumberData> {
+  try {
+    return extractNumbers(
+      (
+        (await import(
+          `cldr-numbers-full/main/${locale}/numbers.json`
+        )) as typeof NumbersData
+      ).main[locale as 'ar'].numbers
+    )
+  } catch (e) {
+    console.error('Issue processing numbers data for ' + locale)
+    throw e
+  }
+}
+
+export async function generateDataForLocales(
+  locales: string[] = AVAILABLE_LOCALES.availableLocales.full
+): Promise<Record<string, RawNumberData>> {
+  const data = await Promise.all(locales.map(loadNumbers))
+  return data.reduce((all: Record<string, RawNumberData>, d, i) => {
+    all[locales[i]] = d
+    return all
+  }, {})
+}
+
+export function extractNumberingSystemNames() {
+  // Export an object instead of array to be more compatible with rollup.
+  return {
+    names: Object.keys(numberingSystems.supplemental.numberingSystems),
+  }
+}

package/scripts/extract-units.ts

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2015, Yahoo Inc.
+ * Copyrights licensed under the New BSD License.
+ * See the accompanying LICENSE file for terms.
+ */
+import {fromPairs} from 'lodash'
+import {
+  invariant,
+  LDMLPluralRuleMap,
+  UnitDataTable,
+  removeUnitNamespace,
+  IsWellFormedUnitIdentifier,
+  UnitData,
+} from '@formatjs/ecma402-abstract'
+import * as UnitsData from 'cldr-units-full/main/en/units.json'
+import * as AVAILABLE_LOCALES from 'cldr-core/availableLocales.json'
+import {collapseSingleValuePluralRule, PLURAL_RULES} from './utils'
+
+export type Units = typeof UnitsData['main']['en']['units']
+
+function extractUnitPattern(d: Units['long']['volume-gallon']) {
+  return collapseSingleValuePluralRule(
+    PLURAL_RULES.reduce((all: LDMLPluralRuleMap<string>, ldml) => {
+      if (d[`unitPattern-count-${ldml}` as 'unitPattern-count-one']) {
+        all[ldml] = d[`unitPattern-count-${ldml}` as 'unitPattern-count-one']
+      }
+      return all
+    }, {} as any)
+  )
+}
+
+async function loadUnits(locale: string): Promise<UnitDataTable> {
+  const units = (
+    (await import(
+      `cldr-units-full/main/${locale}/units.json`
+    )) as typeof UnitsData
+  ).main[locale as 'en'].units
+
+  invariant(
+    !!(
+      units.long.per.compoundUnitPattern &&
+      units.short.per.compoundUnitPattern &&
+      units.narrow.per.compoundUnitPattern
+    ),
+    `Missing "per" compound pattern in locale ${locale}`
+  )
+
+  const validUnits = Object.keys(units.long).filter(unit => {
+    return IsWellFormedUnitIdentifier(removeUnitNamespace(unit))
+  })
+
+  const simpleUnitEntries: [string, UnitData][] = validUnits.map(unit => {
+    if (!units.long[unit as 'digital-bit']) {
+      throw new Error(`${unit} does not have any data`)
+    }
+    return [
+      removeUnitNamespace(unit),
+      {
+        // displayName: units.long[unit as 'digital-bit'].displayName,
+        long: extractUnitPattern(units.long[unit as 'volume-gallon']),
+        short: extractUnitPattern(units.short[unit as 'volume-gallon']),
+        narrow: extractUnitPattern(units.narrow[unit as 'volume-gallon']),
+        perUnit: {
+          long: units.long[unit as 'volume-gallon'].perUnitPattern,
+          short: units.short[unit as 'volume-gallon'].perUnitPattern,
+          narrow: units.narrow[unit as 'volume-gallon'].perUnitPattern,
+        },
+      },
+    ]
+  })
+
+  const compoundUnits = {
+    per: {
+      long: units.long.per.compoundUnitPattern,
+      short: units.short.per.compoundUnitPattern,
+      narrow: units.narrow.per.compoundUnitPattern,
+    },
+  }
+
+  return {simple: fromPairs(simpleUnitEntries), compound: compoundUnits}
+}
+
+export async function generateDataForLocales(
+  locales: string[] = AVAILABLE_LOCALES.availableLocales.full
+): Promise<Record<string, UnitDataTable>> {
+  const data = await Promise.all(locales.map(loadUnits))
+  return data.reduce((all: Record<string, UnitDataTable>, d, i) => {
+    all[locales[i]] = d
+    return all
+  }, {})
+}

package/scripts/numbering-systems.ts

@@ -0,0 +1,18 @@
+import minimist from 'minimist'
+import {outputFileSync} from 'fs-extra'
+import {extractNumberingSystemNames} from './extract-numbers'
+function main(args: minimist.ParsedArgs) {
+  const {out} = args
+
+  // Output numbering systems file
+  outputFileSync(
+    out,
+    `export const numberingSystemNames: ReadonlyArray<string> = ${JSON.stringify(
+      extractNumberingSystemNames().names
+    )};`
+  )
+}
+
+if (require.main === module) {
+  main(minimist(process.argv))
+}

package/scripts/test-locale-data-gen.ts

@@ -0,0 +1,20 @@
+import {join, basename} from 'path'
+import {copyFileSync} from 'fs-extra'
+import minimist from 'minimist'
+import {sync as globSync} from 'fast-glob'
+
+function main(args: minimist.ParsedArgs) {
+  const {cldrFolder, locales: localesToGen = '', out} = args
+  const allFiles = globSync(join(cldrFolder, '*.json'))
+  allFiles.sort()
+  const locales = localesToGen
+    ? localesToGen.split(',')
+    : allFiles.map(f => basename(f, '.json'))
+
+  // Dist all locale files to tests/locale-data
+  copyFileSync(join(cldrFolder, `${locales[0]}.json`), out)
+}
+
+if (require.main === module) {
+  main(minimist(process.argv))
+}

package/scripts/test262-main-gen.ts

@@ -0,0 +1,28 @@
+import {outputFileSync, readFileSync} from 'fs-extra'
+import minimist from 'minimist'
+interface Args extends minimist.ParsedArgs {
+  cldrFile: string[]
+  localesToGen: string[]
+  out: string
+}
+
+function main(args: Args) {
+  const {cldrFile: cldrFiles, out} = args
+  cldrFiles.sort()
+
+  // Aggregate all into ../test262-main.js
+  const allData = cldrFiles.map(f => readFileSync(f))
+  outputFileSync(
+    out,
+    `// @generated
+// @ts-nocheck
+import './polyfill-force';
+if (Intl.NumberFormat && typeof Intl.NumberFormat.__addLocaleData === 'function') {
+  Intl.NumberFormat.__addLocaleData(${allData.join(',\n')})
+}`
+  )
+}
+
+if (require.main === module) {
+  main(minimist<Args>(process.argv))
+}

package/scripts/units-constants.ts

@@ -0,0 +1,20 @@
+import minimist from 'minimist'
+import {SIMPLE_UNITS} from '@formatjs/ecma402-abstract'
+import {outputFileSync} from 'fs-extra'
+
+function main(args: minimist.ParsedArgs) {
+  const {out} = args
+
+  outputFileSync(
+    out,
+    `/* @generated */
+  // prettier-ignore
+  export type Unit =
+    ${SIMPLE_UNITS.map(u => `'${u}'`).join(' | ')}
+  `
+  )
+}
+
+if (require.main === module) {
+  main(minimist(process.argv))
+}

package/scripts/utils.ts

@@ -0,0 +1,25 @@
+import {LDMLPluralRuleMap, LDMLPluralRule} from '@formatjs/ecma402-abstract'
+import {isEqual} from 'lodash'
+export function collapseSingleValuePluralRule<T>(
+  rules: LDMLPluralRuleMap<T>
+): LDMLPluralRuleMap<T> {
+  const keys = Object.keys(rules) as Array<LDMLPluralRule>
+  return keys.reduce(
+    (all: LDMLPluralRuleMap<T>, k) => {
+      if (k !== 'other' && rules[k] && !isEqual(rules[k], rules.other)) {
+        all[k] = rules[k]
+      }
+      return all
+    },
+    {other: rules.other}
+  )
+}
+
+export const PLURAL_RULES: Array<LDMLPluralRule> = [
+  'other',
+  'zero',
+  'one',
+  'two',
+  'few',
+  'many',
+]

package/should-polyfill.ts

@@ -0,0 +1,59 @@
+import {match} from '@formatjs/intl-localematcher'
+import {supportedLocales} from './supported-locales.generated'
+/**
+ * Check if this is old Node that only supports en
+ * @returns
+ */
+function onlySupportsEn() {
+  return (
+    !(Intl.NumberFormat as any).polyfilled &&
+    !Intl.NumberFormat.supportedLocalesOf(['es']).length
+  )
+}
+
+/**
+ * Check if Intl.NumberFormat is ES2020 compatible.
+ * Caveat: we are not checking `toLocaleString`.
+ *
+ * @public
+ * @param unit unit to check
+ */
+function supportsES2020() {
+  try {
+    const s = new Intl.NumberFormat('en', {
+      style: 'unit',
+      unit: 'bit',
+      unitDisplay: 'long',
+      notation: 'scientific',
+    }).format(10000)
+
+    // Check for a plurality bug in environment that uses the older versions of ICU:
+    // https://unicode-org.atlassian.net/browse/ICU-13836
+    if (s !== '1E4 bits') {
+      return false
+    }
+  } catch (e) {
+    return false
+  }
+  return true
+}
+
+function supportedLocalesOf(locale?: string | string[]) {
+  if (!locale) {
+    return true
+  }
+  const locales = Array.isArray(locale) ? locale : [locale]
+  return Intl.NumberFormat.supportedLocalesOf(locales).length === locales.length
+}
+
+export function shouldPolyfill(locale = 'en') {
+  if (
+    typeof Intl === 'undefined' ||
+    !('NumberFormat' in Intl) ||
+    !supportsES2020() ||
+    onlySupportsEn() ||
+    !supportedLocalesOf(locale)
+  ) {
+    return locale ? match([locale], supportedLocales, 'en') : undefined
+  }
+}