@formatjs/intl-relativetimeformat 11.0.1 → 11.1.0

package/abstract/FormatRelativeTime.ts

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

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

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

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

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

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

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

@@ -0,0 +1,151 @@
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@formatjs/intl-relativetimeformat",
-  "version": "11.0.1",
+  "version": "11.1.0",
   "description": "Formats JavaScript dates to relative time strings.",
   "keywords": [
     "intl",
@@ -20,13 +20,18 @@
     "url": "git@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",
+    "@formatjs/intl-pluralrules": "5.1.0"
+  },
   "main": "index.js",
   "types": "index.d.ts",
   "homepage": "https://github.com/formatjs/formatjs",
   "license": "MIT",
   "gitHead": "a7842673d8ad205171ad7c8cb8bb2f318b427c0c"
-}
+}

package/polyfill-force.ts

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

package/polyfill.ts

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

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

@@ -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, '.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))
+}