@formatjs/intl-pluralrules 5.0.1 → 5.1.0

package/abstract/GetOperands.ts

@@ -0,0 +1,75 @@
+import {invariant, ToNumber} from '@formatjs/ecma402-abstract'
+
+export interface OperandsRecord {
+  /**
+   * Absolute value of the source number (integer and decimals)
+   */
+  Number: number
+  /**
+   * Number of digits of `number`
+   */
+  IntegerDigits: number
+  /**
+   * Number of visible fraction digits in [[Number]], with trailing zeroes.
+   */
+  NumberOfFractionDigits: number
+  /**
+   * Number of visible fraction digits in [[Number]], without trailing zeroes.
+   */
+  NumberOfFractionDigitsWithoutTrailing: number
+  /**
+   * Number of visible fractional digits in [[Number]], with trailing zeroes.
+   */
+  FractionDigits: number
+  /**
+   * Number of visible fractional digits in [[Number]], without trailing zeroes.
+   */
+  FractionDigitsWithoutTrailing: number
+}
+
+/**
+ * http://ecma-international.org/ecma-402/7.0/index.html#sec-getoperands
+ * @param s
+ */
+export function GetOperands(s: string): OperandsRecord {
+  invariant(
+    typeof s === 'string',
+    `GetOperands should have been called with a string`
+  )
+  const n = ToNumber(s)
+  invariant(isFinite(n), 'n should be finite')
+  let dp = s.indexOf('.')
+  let iv: string | number
+  let f: number
+  let v: number
+  let fv = ''
+  if (dp === -1) {
+    iv = n
+    f = 0
+    v = 0
+  } else {
+    iv = s.slice(0, dp)
+    fv = s.slice(dp, s.length)
+    f = ToNumber(fv)
+    v = fv.length
+  }
+  const i = Math.abs(ToNumber(iv))
+  let w: number
+  let t: number
+  if (f !== 0) {
+    const ft = fv.replace(/0+$/, '')
+    w = ft.length
+    t = ToNumber(ft)
+  } else {
+    w = 0
+    t = 0
+  }
+  return {
+    Number: n,
+    IntegerDigits: i,
+    NumberOfFractionDigits: v,
+    NumberOfFractionDigitsWithoutTrailing: w,
+    FractionDigits: f,
+    FractionDigitsWithoutTrailing: t,
+  }
+}

package/abstract/InitializePluralRules.ts

@@ -0,0 +1,61 @@
+import {
+  PluralRulesInternal,
+  PluralRulesData,
+  CanonicalizeLocaleList,
+  CoerceOptionsToObject,
+  GetOption,
+  SetNumberFormatDigitOptions,
+} from '@formatjs/ecma402-abstract'
+import {ResolveLocale} from '@formatjs/intl-localematcher'
+
+export function InitializePluralRules(
+  pl: Intl.PluralRules,
+  locales: string | string[] | undefined,
+  options: Intl.PluralRulesOptions | undefined,
+  {
+    availableLocales,
+    relevantExtensionKeys,
+    localeData,
+    getDefaultLocale,
+    getInternalSlots,
+  }: {
+    availableLocales: Set<string>
+    relevantExtensionKeys: string[]
+    localeData: Record<string, PluralRulesData | undefined>
+    getDefaultLocale(): string
+    getInternalSlots(pl: Intl.PluralRules): PluralRulesInternal
+  }
+) {
+  const requestedLocales = CanonicalizeLocaleList(locales)
+  const opt: any = Object.create(null)
+  const opts = CoerceOptionsToObject<Intl.PluralRulesOptions>(options)
+  const internalSlots = getInternalSlots(pl)
+  internalSlots.initializedPluralRules = true
+  const matcher = GetOption(
+    opts,
+    'localeMatcher',
+    'string',
+    ['best fit', 'lookup'],
+    'best fit'
+  )
+  opt.localeMatcher = matcher
+  internalSlots.type = GetOption(
+    opts,
+    'type',
+    'string',
+    ['cardinal', 'ordinal'],
+    'cardinal'
+  )
+
+  SetNumberFormatDigitOptions(internalSlots, opts, 0, 3, 'standard')
+  const r = ResolveLocale(
+    availableLocales,
+    requestedLocales,
+    opt,
+    relevantExtensionKeys,
+    localeData,
+    getDefaultLocale
+  )
+  internalSlots.locale = r.locale
+  return pl
+}

package/abstract/ResolvePlural.ts

@@ -0,0 +1,47 @@
+import {
+  Type,
+  invariant,
+  PluralRulesInternal,
+  LDMLPluralRule,
+  FormatNumericToString,
+} from '@formatjs/ecma402-abstract'
+import {GetOperands, OperandsRecord} from './GetOperands'
+
+/**
+ * http://ecma-international.org/ecma-402/7.0/index.html#sec-resolveplural
+ * @param pl
+ * @param n
+ * @param PluralRuleSelect Has to pass in bc it's implementation-specific
+ */
+export function ResolvePlural(
+  pl: Intl.PluralRules,
+  n: number,
+  {
+    getInternalSlots,
+    PluralRuleSelect,
+  }: {
+    getInternalSlots(pl: Intl.PluralRules): PluralRulesInternal
+    PluralRuleSelect: (
+      locale: string,
+      type: 'cardinal' | 'ordinal',
+      n: number,
+      operands: OperandsRecord
+    ) => LDMLPluralRule
+  }
+): LDMLPluralRule {
+  const internalSlots = getInternalSlots(pl)
+  invariant(Type(internalSlots) === 'Object', 'pl has to be an object')
+  invariant(
+    'initializedPluralRules' in internalSlots,
+    'pluralrules must be initialized'
+  )
+  invariant(Type(n) === 'Number', 'n must be a number')
+  if (!isFinite(n)) {
+    return 'other'
+  }
+  const {locale, type} = internalSlots
+  const res = FormatNumericToString(internalSlots, n)
+  const s = res.formattedString
+  const operands = GetOperands(s)
+  return PluralRuleSelect(locale, type, n, operands)
+}

package/get_internal_slots.ts

@@ -0,0 +1,14 @@
+// Type-only circular import
+// eslint-disable-next-line import/no-cycle
+import {PluralRules, PluralRulesInternal} from '.'
+
+const internalSlotMap = new WeakMap<PluralRules, PluralRulesInternal>()
+
+export default function getInternalSlots(x: PluralRules): PluralRulesInternal {
+  let internalSlots = internalSlotMap.get(x)
+  if (!internalSlots) {
+    internalSlots = Object.create(null) as PluralRulesInternal
+    internalSlotMap.set(x, internalSlots)
+  }
+  return internalSlots
+}

package/index.ts

@@ -0,0 +1,174 @@
+import {
+  LDMLPluralRule,
+  PluralRulesLocaleData,
+  PluralRulesData,
+  SupportedLocales,
+  NumberFormatDigitInternalSlots,
+  ToNumber,
+  CanonicalizeLocaleList,
+} from '@formatjs/ecma402-abstract'
+import {OperandsRecord} from './abstract/GetOperands'
+import {InitializePluralRules} from './abstract/InitializePluralRules'
+import {ResolvePlural} from './abstract/ResolvePlural'
+import getInternalSlots from './get_internal_slots'
+
+function validateInstance(instance: any, method: string) {
+  if (!(instance instanceof PluralRules)) {
+    throw new TypeError(
+      `Method Intl.PluralRules.prototype.${method} called on incompatible receiver ${String(
+        instance
+      )}`
+    )
+  }
+}
+
+export interface PluralRulesInternal extends NumberFormatDigitInternalSlots {
+  initializedPluralRules: boolean
+  locale: string
+  type: 'cardinal' | 'ordinal'
+}
+
+/**
+ * http://ecma-international.org/ecma-402/7.0/index.html#sec-pluralruleselect
+ * @param locale
+ * @param type
+ * @param _n
+ * @param param3
+ */
+function PluralRuleSelect(
+  locale: string,
+  type: 'cardinal' | 'ordinal',
+  _n: number,
+  {IntegerDigits, NumberOfFractionDigits, FractionDigits}: OperandsRecord
+): LDMLPluralRule {
+  return PluralRules.localeData[locale].fn(
+    NumberOfFractionDigits
+      ? `${IntegerDigits}.${FractionDigits}`
+      : IntegerDigits,
+    type === 'ordinal'
+  )
+}
+
+export class PluralRules implements Intl.PluralRules {
+  constructor(locales?: string | string[], options?: Intl.PluralRulesOptions) {
+    // test262/test/intl402/RelativeTimeFormat/constructor/constructor/newtarget-undefined.js
+    // Cannot use `new.target` bc of IE11 & TS transpiles it to something else
+    const newTarget =
+      this && this instanceof PluralRules ? this.constructor : void 0
+    if (!newTarget) {
+      throw new TypeError("Intl.PluralRules must be called with 'new'")
+    }
+    return InitializePluralRules(this, locales, options, {
+      availableLocales: PluralRules.availableLocales,
+      relevantExtensionKeys: PluralRules.relevantExtensionKeys,
+      localeData: PluralRules.localeData,
+      getDefaultLocale: PluralRules.getDefaultLocale,
+      getInternalSlots,
+    })
+  }
+  public resolvedOptions() {
+    validateInstance(this, 'resolvedOptions')
+    const opts = Object.create(null)
+    const internalSlots = getInternalSlots(this)
+    opts.locale = internalSlots.locale
+    opts.type = internalSlots.type
+    ;(
+      [
+        'minimumIntegerDigits',
+        'minimumFractionDigits',
+        'maximumFractionDigits',
+        'minimumSignificantDigits',
+        'maximumSignificantDigits',
+      ] as Array<keyof PluralRulesInternal>
+    ).forEach(field => {
+      const val = internalSlots[field]
+      if (val !== undefined) {
+        opts[field] = val
+      }
+    })
+
+    opts.pluralCategories = [
+      ...PluralRules.localeData[opts.locale].categories[
+        opts.type as 'cardinal'
+      ],
+    ]
+    return opts
+  }
+  public select(val: number): LDMLPluralRule {
+    const pr = this
+    validateInstance(pr, 'select')
+    const n = ToNumber(val)
+    return ResolvePlural(pr, n, {getInternalSlots, PluralRuleSelect})
+  }
+  toString() {
+    return '[object Intl.PluralRules]'
+  }
+  public static supportedLocalesOf(
+    locales?: string | string[],
+    options?: Pick<Intl.PluralRulesOptions, 'localeMatcher'>
+  ) {
+    return SupportedLocales(
+      PluralRules.availableLocales,
+      CanonicalizeLocaleList(locales),
+      options
+    )
+  }
+  public static __addLocaleData(...data: PluralRulesLocaleData[]) {
+    for (const {data: d, locale} of data) {
+      PluralRules.localeData[locale] = d
+      PluralRules.availableLocales.add(locale)
+      if (!PluralRules.__defaultLocale) {
+        PluralRules.__defaultLocale = locale
+      }
+    }
+  }
+  static localeData: Record<string, PluralRulesData> = {}
+  static availableLocales = new Set<string>()
+  static __defaultLocale = ''
+  static getDefaultLocale() {
+    return PluralRules.__defaultLocale
+  }
+  static relevantExtensionKeys = []
+  public static polyfilled = true
+}
+
+try {
+  // IE11 does not have Symbol
+  if (typeof Symbol !== 'undefined') {
+    Object.defineProperty(PluralRules.prototype, Symbol.toStringTag, {
+      value: 'Intl.PluralRules',
+      writable: false,
+      enumerable: false,
+      configurable: true,
+    })
+  }
+
+  try {
+    // https://github.com/tc39/test262/blob/master/test/intl402/PluralRules/length.js
+    Object.defineProperty(PluralRules, 'length', {
+      value: 0,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+    })
+  } catch (error) {
+    // IE 11 sets Function.prototype.length to be non-configurable which will cause the
+    // above Object.defineProperty to throw an error.
+  }
+  // https://github.com/tc39/test262/blob/master/test/intl402/RelativeTimeFormat/constructor/length.js
+  Object.defineProperty(PluralRules.prototype.constructor, 'length', {
+    value: 0,
+    writable: false,
+    enumerable: false,
+    configurable: true,
+  })
+  // https://github.com/tc39/test262/blob/master/test/intl402/RelativeTimeFormat/constructor/supportedLocalesOf/length.js
+  Object.defineProperty(PluralRules.supportedLocalesOf, 'length', {
+    value: 1,
+    writable: false,
+    enumerable: false,
+    configurable: true,
+  })
+} catch (ex) {
+  // Meta fixes for test262
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@formatjs/intl-pluralrules",
-  "version": "5.0.1",
+  "version": "5.1.0",
   "description": "Polyfill for Intl.PluralRules",
   "keywords": [
     "polyfill",
@@ -20,12 +20,16 @@
     "url": "git+https://github.com/formatjs/formatjs.git"
   },
   "dependencies": {
-    "@formatjs/ecma402-abstract": "1.11.6",
-    "@formatjs/intl-localematcher": "0.2.27",
+    "@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"
+  },
   "bugs": {
     "url": "https://github.com/formatjs/formatjs/issues"
   },
   "gitHead": "a7842673d8ad205171ad7c8cb8bb2f318b427c0c"
-}
+}

package/polyfill-force.ts

@@ -0,0 +1,8 @@
+import {PluralRules} from './'
+
+Object.defineProperty(Intl, 'PluralRules', {
+  value: PluralRules,
+  writable: true,
+  enumerable: false,
+  configurable: true,
+})

package/polyfill.ts

@@ -0,0 +1,11 @@
+import {PluralRules} from './'
+import {shouldPolyfill} from './should-polyfill'
+
+if (shouldPolyfill()) {
+  Object.defineProperty(Intl, 'PluralRules', {
+    value: PluralRules,
+    writable: true,
+    enumerable: false,
+    configurable: true,
+  })
+}

package/scripts/cldr-raw.ts

@@ -0,0 +1,70 @@
+import {join} from 'path'
+import {outputFileSync} from 'fs-extra'
+import serialize from 'serialize-javascript'
+import {PluralRulesLocaleData} from '@formatjs/ecma402-abstract'
+import plurals from 'cldr-core/supplemental/plurals.json'
+import minimist from 'minimist'
+
+const Compiler = require('make-plural-compiler')
+Compiler.load(
+  require('cldr-core/supplemental/plurals.json'),
+  require('cldr-core/supplemental/ordinals.json')
+)
+
+const languages = Object.keys(plurals.supplemental['plurals-type-cardinal'])
+
+function generateLocaleData(locale: string): PluralRulesLocaleData | undefined {
+  let compiler, fn
+  compiler = new Compiler(locale, {cardinals: true, ordinals: true})
+  fn = compiler.compile()
+
+  return {
+    data: {
+      categories: compiler.categories,
+      fn,
+    },
+    locale,
+  }
+}
+
+interface Args extends minimist.ParsedArgs {
+  outDir: string
+  out: string
+}
+
+function main(args: Args) {
+  const {outDir, out} = args
+
+  const locales = languages
+    .filter(locale => {
+      try {
+        ;(Intl as any).getCanonicalLocales(locale)
+      } catch (e) {
+        console.warn(`Invalid locale ${locale}`)
+        return false
+      }
+      return true
+    })
+    .sort()
+
+  if (outDir) {
+    locales.forEach(
+      locale =>
+        +console.log(join(outDir, `${locale}.js`)) ||
+        outputFileSync(
+          join(outDir, `${locale}.js`),
+          serialize(generateLocaleData(locale))
+        )
+    )
+  } else if (out) {
+    outputFileSync(
+      out,
+      `// This file is generated from supported-locales-gen.ts
+export const supportedLocales: string[] = ${JSON.stringify(locales)}
+`
+    )
+  }
+}
+if (require.main === module) {
+  main(minimist<Args>(process.argv))
+}

package/scripts/cldr.ts

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

package/should-polyfill.ts

@@ -0,0 +1,21 @@
+import {match} from '@formatjs/intl-localematcher'
+import {supportedLocales} from './supported-locales.generated'
+
+function supportedLocalesOf(locale?: string | string[]) {
+  if (!locale) {
+    return true
+  }
+  const locales = Array.isArray(locale) ? locale : [locale]
+  return Intl.PluralRules.supportedLocalesOf(locales).length === locales.length
+}
+
+export function shouldPolyfill(locale = 'en') {
+  if (
+    !('PluralRules' in Intl) ||
+    new Intl.PluralRules('en', {minimumFractionDigits: 2} as any).select(1) ===
+      'one' ||
+    !supportedLocalesOf(locale)
+  ) {
+    return locale ? match([locale], supportedLocales, 'en') : undefined
+  }
+}

package/supported-locales.generated.ts

@@ -0,0 +1 @@
+export const supportedLocales: string[] = ["af", "ak", "am", "an", "ar", "ars", "as", "asa", "ast", "az", "bal", "be", "bem", "bez", "bg", "bho", "bm", "bn", "bo", "br", "brx", "bs", "ca", "ce", "ceb", "cgg", "chr", "ckb", "cs", "cy", "da", "de", "doi", "dsb", "dv", "dz", "ee", "el", "en", "eo", "es", "et", "eu", "fa", "ff", "fi", "fil", "fo", "fr", "fur", "fy", "ga", "gd", "gl", "gsw", "gu", "guw", "gv", "ha", "haw", "he", "hi", "hnj", "hr", "hsb", "hu", "hy", "ia", "id", "ig", "ii", "io", "is", "it", "iu", "ja", "jbo", "jgo", "jmc", "jv", "jw", "ka", "kab", "kaj", "kcg", "kde", "kea", "kk", "kkj", "kl", "km", "kn", "ko", "ks", "ksb", "ksh", "ku", "kw", "ky", "lag", "lb", "lg", "lij", "lkt", "ln", "lo", "lt", "lv", "mas", "mg", "mgo", "mk", "ml", "mn", "mo", "mr", "ms", "mt", "my", "nah", "naq", "nb", "nd", "ne", "nl", "nn", "nnh", "no", "nqo", "nr", "nso", "ny", "nyn", "om", "or", "os", "osa", "pa", "pap", "pcm", "pl", "prg", "ps", "pt", "pt-PT", "rm", "ro", "rof", "ru", "rwk", "sah", "saq", "sat", "sc", "scn", "sd", "sdh", "se", "seh", "ses", "sg", "sh", "shi", "si", "sk", "sl", "sma", "smi", "smj", "smn", "sms", "sn", "so", "sq", "sr", "ss", "ssy", "st", "su", "sv", "sw", "syr", "ta", "te", "teo", "th", "ti", "tig", "tk", "tl", "tn", "to", "tpi", "tr", "ts", "tzm", "ug", "uk", "und", "ur", "uz", "ve", "vi", "vo", "vun", "wa", "wae", "wo", "xh", "xog", "yi", "yo", "yue", "zh", "zu"]