@formatjs/intl-numberformat 8.1.0 → 8.1.2

package/index.ts

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

package/polyfill-force.ts

@@ -1,13 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,89 +0,0 @@
-/*
- * 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

@@ -1,151 +0,0 @@
-/*
- * 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

@@ -1,91 +0,0 @@
-/*
- * 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

@@ -1,18 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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
-  }
-}