@formatjs/intl-pluralrules 5.1.0 → 5.1.2

package/abstract/GetOperands.ts

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

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

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

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

@@ -1,174 +0,0 @@
-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/polyfill-force.ts

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

package/polyfill.ts

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

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

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

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

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

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