@formatjs/intl-relativetimeformat 11.1.0 → 11.1.2

package/abstract/FormatRelativeTime.ts

@@ -1,18 +0,0 @@
-import {RelativeTimeFormatInternal} from '@formatjs/ecma402-abstract'
-import {PartitionRelativeTimePattern} from './PartitionRelativeTimePattern'
-
-export function FormatRelativeTime(
-  rtf: Intl.RelativeTimeFormat,
-  value: number,
-  unit: Intl.RelativeTimeFormatUnit,
-  implDetails: {
-    getInternalSlots(rtf: Intl.RelativeTimeFormat): RelativeTimeFormatInternal
-  }
-): string {
-  const parts = PartitionRelativeTimePattern(rtf, value, unit, implDetails)
-  let result = ''
-  for (const part of parts) {
-    result += part.value
-  }
-  return result
-}

package/abstract/FormatRelativeTimeToParts.ts

@@ -1,29 +0,0 @@
-import {
-  ArrayCreate,
-  RelativeTimeFormatInternal,
-} from '@formatjs/ecma402-abstract'
-import {PartitionRelativeTimePattern} from './PartitionRelativeTimePattern'
-
-export function FormatRelativeTimeToParts(
-  rtf: Intl.RelativeTimeFormat,
-  value: number,
-  unit: Intl.RelativeTimeFormatUnit,
-  implDetails: {
-    getInternalSlots(rtf: Intl.RelativeTimeFormat): RelativeTimeFormatInternal
-  }
-): Intl.RelativeTimeFormatPart[] {
-  const parts = PartitionRelativeTimePattern(rtf, value, unit, implDetails)
-  const result = ArrayCreate(0) as Intl.RelativeTimeFormatPart[]
-
-  for (const part of parts) {
-    const o = {
-      type: part.type,
-      value: part.value,
-    } as Intl.RelativeTimeFormatPart
-    if ('unit' in part) {
-      o.unit = part.unit
-    }
-    result.push(o)
-  }
-  return result
-}

package/abstract/InitializeRelativeTimeFormat.ts

@@ -1,89 +0,0 @@
-import {
-  RelativeTimeFormatInternal,
-  LocaleFieldsData,
-  CanonicalizeLocaleList,
-  CoerceOptionsToObject,
-  GetOption,
-  invariant,
-} from '@formatjs/ecma402-abstract'
-import {ResolveLocale} from '@formatjs/intl-localematcher'
-
-const NUMBERING_SYSTEM_REGEX = /^[a-z0-9]{3,8}(-[a-z0-9]{3,8})*$/i
-
-export function InitializeRelativeTimeFormat(
-  rtf: Intl.RelativeTimeFormat,
-  locales: string | string[] | undefined,
-  options: Intl.RelativeTimeFormatOptions | undefined,
-  {
-    getInternalSlots,
-    availableLocales,
-    relevantExtensionKeys,
-    localeData,
-    getDefaultLocale,
-  }: {
-    getInternalSlots(rtf: Intl.RelativeTimeFormat): RelativeTimeFormatInternal
-    availableLocales: Set<string>
-    relevantExtensionKeys: string[]
-    localeData: Record<string, LocaleFieldsData | undefined>
-    getDefaultLocale(): string
-  }
-) {
-  const internalSlots = getInternalSlots(rtf)
-  internalSlots.initializedRelativeTimeFormat = true
-  const requestedLocales = CanonicalizeLocaleList(locales)
-  const opt: any = Object.create(null)
-  const opts = CoerceOptionsToObject<Intl.RelativeTimeFormatOptions>(options)
-  const matcher = GetOption(
-    opts,
-    'localeMatcher',
-    'string',
-    ['best fit', 'lookup'],
-    'best fit'
-  )
-  opt.localeMatcher = matcher
-  const numberingSystem = GetOption(
-    opts,
-    // @ts-expect-error TS option is wack
-    'numberingSystem',
-    'string',
-    undefined,
-    undefined
-  )
-  if (numberingSystem !== undefined) {
-    if (!NUMBERING_SYSTEM_REGEX.test(numberingSystem)) {
-      throw new RangeError(`Invalid numbering system ${numberingSystem}`)
-    }
-  }
-  opt.nu = numberingSystem
-  const r = ResolveLocale(
-    availableLocales,
-    requestedLocales,
-    opt,
-    relevantExtensionKeys,
-    localeData,
-    getDefaultLocale
-  )
-  const {locale, nu} = r
-  internalSlots.locale = locale
-  internalSlots.style = GetOption(
-    opts,
-    'style',
-    'string',
-    ['long', 'narrow', 'short'],
-    'long'
-  )
-  internalSlots.numeric = GetOption(
-    opts,
-    'numeric',
-    'string',
-    ['always', 'auto'],
-    'always'
-  )
-  const fields = localeData[r.dataLocale]
-  invariant(!!fields, `Missing locale data for ${r.dataLocale}`)
-  internalSlots.fields = fields
-  internalSlots.numberFormat = new Intl.NumberFormat(locales)
-  internalSlots.pluralRules = new Intl.PluralRules(locales)
-  internalSlots.numberingSystem = nu
-  return rtf
-}

package/abstract/MakePartsList.ts

@@ -1,28 +0,0 @@
-import {invariant, PartitionPattern} from '@formatjs/ecma402-abstract'
-
-export function MakePartsList(
-  pattern: string,
-  unit: Intl.RelativeTimeFormatUnit,
-  parts: Intl.NumberFormatPart[] | Intl.RelativeTimeFormatPart[]
-) {
-  const patternParts = PartitionPattern(pattern)
-  const result: Intl.RelativeTimeFormatPart[] = []
-  for (const patternPart of patternParts) {
-    if (patternPart.type === 'literal') {
-      result.push({
-        type: 'literal',
-        value: patternPart.value!,
-      })
-    } else {
-      invariant(patternPart.type === '0', `Malformed pattern ${pattern}`)
-      for (const part of parts) {
-        result.push({
-          type: part.type,
-          value: part.value,
-          unit,
-        })
-      }
-    }
-  }
-  return result
-}

package/abstract/PartitionRelativeTimePattern.ts

@@ -1,81 +0,0 @@
-import {
-  FieldData,
-  invariant,
-  LDMLPluralRule,
-  RelativeTimeField,
-  RelativeTimeFormatInternal,
-  SameValue,
-  ToString,
-  Type,
-} from '@formatjs/ecma402-abstract'
-import {SingularRelativeTimeUnit} from './SingularRelativeTimeUnit'
-import {MakePartsList} from './MakePartsList'
-
-export function PartitionRelativeTimePattern(
-  rtf: Intl.RelativeTimeFormat,
-  value: number,
-  unit: Intl.RelativeTimeFormatUnit,
-  {
-    getInternalSlots,
-  }: {
-    getInternalSlots(rtf: Intl.RelativeTimeFormat): RelativeTimeFormatInternal
-  }
-): Intl.RelativeTimeFormatPart[] {
-  invariant(
-    Type(value) === 'Number',
-    `value must be number, instead got ${typeof value}`,
-    TypeError
-  )
-  invariant(
-    Type(unit) === 'String',
-    `unit must be number, instead got ${typeof value}`,
-    TypeError
-  )
-  if (isNaN(value) || !isFinite(value)) {
-    throw new RangeError(`Invalid value ${value}`)
-  }
-  const resolvedUnit = SingularRelativeTimeUnit(unit)
-  const {fields, style, numeric, pluralRules, numberFormat} =
-    getInternalSlots(rtf)
-  let entry: RelativeTimeField = resolvedUnit
-  if (style === 'short') {
-    entry = `${resolvedUnit}-short` as RelativeTimeField
-  } else if (style === 'narrow') {
-    entry = `${resolvedUnit}-narrow` as RelativeTimeField
-  }
-  if (!(entry in fields)) {
-    entry = resolvedUnit as RelativeTimeField
-  }
-  const patterns = fields[entry]!
-
-  if (numeric === 'auto') {
-    if (ToString(value) in patterns) {
-      return [
-        {
-          type: 'literal',
-          value: patterns[ToString(value) as '-1']!,
-        },
-      ]
-    }
-  }
-  let tl: keyof FieldData = 'future'
-  if (SameValue(value, -0) || value < 0) {
-    tl = 'past'
-  }
-  const po = patterns[tl]
-  const fv =
-    typeof numberFormat.formatToParts === 'function'
-      ? numberFormat.formatToParts(Math.abs(value))
-      : // TODO: If formatToParts is not supported, we assume the whole formatted
-        // number is a part
-        [
-          {
-            type: 'literal',
-            value: numberFormat.format(Math.abs(value)),
-            unit,
-          } as Intl.RelativeTimeFormatPart,
-        ]
-  const pr = pluralRules.select(value) as LDMLPluralRule
-  const pattern = po[pr]
-  return MakePartsList(pattern!, resolvedUnit, fv)
-}

package/abstract/SingularRelativeTimeUnit.ts

@@ -1,36 +0,0 @@
-import {
-  invariant,
-  RelativeTimeFormatSingularUnit,
-  Type,
-} from '@formatjs/ecma402-abstract'
-
-/**
- * https://tc39.es/proposal-intl-relative-time/#sec-singularrelativetimeunit
- * @param unit
- */
-export function SingularRelativeTimeUnit(
-  unit: Intl.RelativeTimeFormatUnit
-): RelativeTimeFormatSingularUnit {
-  invariant(Type(unit) === 'String', 'unit must be a string')
-  if (unit === 'seconds') return 'second'
-  if (unit === 'minutes') return 'minute'
-  if (unit === 'hours') return 'hour'
-  if (unit === 'days') return 'day'
-  if (unit === 'weeks') return 'week'
-  if (unit === 'months') return 'month'
-  if (unit === 'quarters') return 'quarter'
-  if (unit === 'years') return 'year'
-  if (
-    unit !== 'second' &&
-    unit !== 'minute' &&
-    unit !== 'hour' &&
-    unit !== 'day' &&
-    unit !== 'week' &&
-    unit !== 'month' &&
-    unit !== 'quarter' &&
-    unit !== 'year'
-  ) {
-    throw new RangeError('invalid unit')
-  }
-  return unit
-}

package/get_internal_slots.ts

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

package/index.ts

@@ -1,151 +0,0 @@
-import {
-  CanonicalizeLocaleList,
-  LocaleFieldsData,
-  RelativeTimeLocaleData,
-  SupportedLocales,
-  ToString,
-} from '@formatjs/ecma402-abstract'
-import {InitializeRelativeTimeFormat} from './abstract/InitializeRelativeTimeFormat'
-import {PartitionRelativeTimePattern} from './abstract/PartitionRelativeTimePattern'
-import getInternalSlots from './get_internal_slots'
-
-export default class RelativeTimeFormat {
-  constructor(
-    locales?: string | string[],
-    options?: Intl.RelativeTimeFormatOptions
-  ) {
-    // 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 RelativeTimeFormat ? this.constructor : void 0
-    if (!newTarget) {
-      throw new TypeError("Intl.RelativeTimeFormat must be called with 'new'")
-    }
-    return InitializeRelativeTimeFormat(this, locales, options, {
-      getInternalSlots,
-      availableLocales: RelativeTimeFormat.availableLocales,
-      relevantExtensionKeys: RelativeTimeFormat.relevantExtensionKeys,
-      localeData: RelativeTimeFormat.localeData,
-      getDefaultLocale: RelativeTimeFormat.getDefaultLocale,
-    })
-  }
-  format(value: number, unit: Intl.RelativeTimeFormatUnit): string {
-    if (typeof this !== 'object') {
-      throw new TypeError('format was called on a non-object')
-    }
-    const internalSlots = getInternalSlots(this)
-    if (!internalSlots.initializedRelativeTimeFormat) {
-      throw new TypeError('format was called on a invalid context')
-    }
-    return PartitionRelativeTimePattern(
-      this,
-      Number(value),
-      ToString(unit) as Intl.RelativeTimeFormatUnit,
-      {
-        getInternalSlots,
-      }
-    )
-      .map(el => el.value)
-      .join('')
-  }
-  formatToParts(
-    value: number,
-    unit: Intl.RelativeTimeFormatUnit
-  ): Intl.RelativeTimeFormatPart[] {
-    if (typeof this !== 'object') {
-      throw new TypeError('formatToParts was called on a non-object')
-    }
-    const internalSlots = getInternalSlots(this)
-    if (!internalSlots.initializedRelativeTimeFormat) {
-      throw new TypeError('formatToParts was called on a invalid context')
-    }
-    return PartitionRelativeTimePattern(
-      this,
-      Number(value),
-      ToString(unit) as Intl.RelativeTimeFormatUnit,
-      {getInternalSlots}
-    )
-  }
-
-  resolvedOptions(): Intl.ResolvedRelativeTimeFormatOptions {
-    if (typeof this !== 'object') {
-      throw new TypeError('resolvedOptions was called on a non-object')
-    }
-    const internalSlots = getInternalSlots(this)
-    if (!internalSlots.initializedRelativeTimeFormat) {
-      throw new TypeError('resolvedOptions was called on a invalid context')
-    }
-
-    // test262/test/intl402/RelativeTimeFormat/prototype/resolvedOptions/type.js
-    return {
-      locale: internalSlots.locale,
-      style: internalSlots.style,
-      numeric: internalSlots.numeric,
-      numberingSystem: internalSlots.numberingSystem,
-    }
-  }
-
-  public static supportedLocalesOf(
-    locales: string | string[],
-    options?: Pick<Intl.RelativeTimeFormatOptions, 'localeMatcher'>
-  ): string[] {
-    return SupportedLocales(
-      RelativeTimeFormat.availableLocales,
-      CanonicalizeLocaleList(locales),
-      options
-    )
-  }
-
-  public static __addLocaleData(...data: RelativeTimeLocaleData[]): void {
-    for (const {data: d, locale} of data) {
-      const minimizedLocale = new (Intl as any).Locale(locale)
-        .minimize()
-        .toString()
-      RelativeTimeFormat.localeData[locale] = RelativeTimeFormat.localeData[
-        minimizedLocale
-      ] = d
-      RelativeTimeFormat.availableLocales.add(minimizedLocale)
-      RelativeTimeFormat.availableLocales.add(locale)
-      if (!RelativeTimeFormat.__defaultLocale) {
-        RelativeTimeFormat.__defaultLocale = minimizedLocale
-      }
-    }
-  }
-  static localeData: Record<string, LocaleFieldsData> = {}
-  private static availableLocales = new Set<string>()
-  private static __defaultLocale = ''
-  private static getDefaultLocale() {
-    return RelativeTimeFormat.__defaultLocale
-  }
-  private static relevantExtensionKeys = ['nu']
-  public static polyfilled = true
-}
-
-try {
-  // IE11 does not have Symbol
-  if (typeof Symbol !== 'undefined') {
-    Object.defineProperty(RelativeTimeFormat.prototype, Symbol.toStringTag, {
-      value: 'Intl.RelativeTimeFormat',
-      writable: false,
-      enumerable: false,
-      configurable: true,
-    })
-  }
-
-  // https://github.com/tc39/test262/blob/master/test/intl402/RelativeTimeFormat/constructor/length.js
-  Object.defineProperty(RelativeTimeFormat.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(RelativeTimeFormat.supportedLocalesOf, 'length', {
-    value: 1,
-    writable: false,
-    enumerable: false,
-    configurable: true,
-  })
-} catch (e) {
-  // Meta fix so we're test262-compliant, not important
-}

package/polyfill-force.ts

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

package/polyfill.ts

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

package/scripts/cldr-raw.ts

@@ -1,21 +0,0 @@
-import {extractRelativeFields, getAllLocales} from './extract-relative'
-import {join} from 'path'
-import {outputJSONSync} from 'fs-extra'
-
-import minimist from 'minimist'
-
-async function main(args: minimist.ParsedArgs) {
-  const {outDir} = args
-  const locales = await getAllLocales()
-  const data = await extractRelativeFields(locales)
-  locales.forEach(locale =>
-    outputJSONSync(join(outDir, `${locale}.json`), {
-      data: data[locale],
-      locale,
-    })
-  )
-}
-
-if (require.main === module) {
-  ;(async () => main(minimist(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, '.json')
-    // Dist all locale files to locale-data (JS)
-    const data = readFileSync(cldrFile)
-    outputFileSync(
-      join(outDir, locale + '.js'),
-      `/* @generated */
-// prettier-ignore
-if (Intl.RelativeTimeFormat && typeof Intl.RelativeTimeFormat.__addLocaleData === 'function') {
-  Intl.RelativeTimeFormat.__addLocaleData(${data})
-}
-`
-    )
-    outputFileSync(join(outDir, locale + '.d.ts'), 'export {}')
-  })
-}
-if (require.main === module) {
-  main(minimist<Args>(process.argv))
-}

package/scripts/extract-relative.ts

@@ -1,132 +0,0 @@
-/*
- * Copyright 2015, Yahoo Inc.
- * Copyrights licensed under the New BSD License.
- * See the accompanying LICENSE file for terms.
- */
-'use strict'
-
-import * as DateFields from 'cldr-dates-full/main/en/dateFields.json'
-import * as NumberFields from 'cldr-numbers-full/main/en/numbers.json'
-import glob from 'fast-glob'
-import {resolve, dirname} from 'path'
-import {FieldData, LocaleFieldsData} from '@formatjs/ecma402-abstract'
-import * as AVAILABLE_LOCALES from 'cldr-core/availableLocales.json'
-
-// The set of CLDR date field names that are used in FormatJS.
-const FIELD_NAMES = [
-  'year',
-  'year-short',
-  'year-narrow',
-  'quarter',
-  'quarter-short',
-  'quarter-narrow',
-  'month',
-  'month-short',
-  'month-narrow',
-  'week',
-  'week-short',
-  'week-narrow',
-  'day',
-  'day-short',
-  'day-narrow',
-  'hour',
-  'hour-short',
-  'hour-narrow',
-  'minute',
-  'minute-short',
-  'minute-narrow',
-  'second',
-  'second-short',
-  'second-narrow',
-]
-
-type Fields = typeof DateFields['main']['en']['dates']['fields']
-
-export async function getAllLocales(): Promise<string[]> {
-  const fns = await glob('*/dateFields.json', {
-    cwd: resolve(
-      dirname(require.resolve('cldr-dates-full/package.json')),
-      './main'
-    ),
-  })
-  return fns.map(dirname).filter(l => {
-    try {
-      return (Intl as any).getCanonicalLocales(l).length
-    } catch (e) {
-      console.warn(`Invalid locale ${l}`)
-      return false
-    }
-  })
-}
-
-async function loadRelativeFields(locale: string): Promise<LocaleFieldsData> {
-  const [dateFileds, numbers] = await Promise.all([
-    import(`cldr-dates-full/main/${locale}/dateFields.json`) as Promise<
-      typeof DateFields
-    >,
-    import(`cldr-numbers-full/main/${locale}/numbers.json`).catch(
-      _ => undefined
-    ) as Promise<typeof NumberFields | undefined>,
-  ])
-  const fields = dateFileds.main[locale as 'en'].dates.fields
-  const nu = numbers?.main[locale as 'en'].numbers.defaultNumberingSystem
-
-  // Reduce the date fields data down to allowlist of fields needed in the
-  // FormatJS libs.
-  return FIELD_NAMES.reduce(
-    (relative: LocaleFieldsData, field) => {
-      // Transform the fields data from the CLDR structure to one that's
-      // easier to override and customize (if needed). This is also required
-      // back-compat in v1.x of the FormatJS libs.
-      relative[field as 'year'] = transformFieldData(fields[field as 'week'])
-      return relative
-    },
-    {
-      nu: [nu],
-    } as LocaleFieldsData
-  )
-}
-
-// Transforms the CLDR's data structure for the relative fields into a structure
-// that's more concise and easier to override to supply custom data.
-function transformFieldData(data: Fields['week']): FieldData {
-  const processed: FieldData = {
-    future: {},
-    past: {},
-  }
-  Object.keys(data).forEach(function (key) {
-    const type = key.match(/^(relative|relativeTime)-type-(.+)$/) || []
-
-    switch (type[1]) {
-      case 'relative':
-        processed[type[2] as '0'] = data[key as 'relative-type-0']
-        break
-
-      case 'relativeTime':
-        processed[type[2] as 'past'] = Object.keys(
-          data[key as 'relativeTime-type-past']
-        ).reduce((counts: FieldData['past'], count) => {
-          const k = count.replace('relativeTimePattern-count-', '')
-          counts[k as 'other'] =
-            data[key as 'relativeTime-type-past'][
-              count as 'relativeTimePattern-count-other'
-            ]
-          return counts
-        }, {})
-
-        break
-    }
-  })
-
-  return processed
-}
-
-export async function extractRelativeFields(
-  locales: string[] = AVAILABLE_LOCALES.availableLocales.full
-): Promise<Record<string, LocaleFieldsData>> {
-  const data = await Promise.all(locales.map(loadRelativeFields))
-  return locales.reduce((all: Record<string, LocaleFieldsData>, locale, i) => {
-    all[locale] = data[i]
-    return all
-  }, {})
-}

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

@@ -1,18 +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'))
-
-  copyFileSync(join(cldrFolder, `${locales[0]}.json`), out)
-}
-
-if (require.main === module) {
-  main(minimist(process.argv))
-}