@formatjs/intl 2.3.2 → 2.3.4

package/src/message.ts

@@ -1,246 +0,0 @@
-import {invariant} from '@formatjs/ecma402-abstract'
-
-import {Formatters, MessageDescriptor, CustomFormats, OnErrorFn} from './types'
-
-import {
-  IntlMessageFormat,
-  FormatXMLElementFn,
-  PrimitiveType,
-  Formatters as IntlMessageFormatFormatters,
-  Options,
-} from 'intl-messageformat'
-import {MissingTranslationError, MessageFormatError} from './error'
-import {TYPE, MessageFormatElement} from '@formatjs/icu-messageformat-parser'
-
-function setTimeZoneInOptions(
-  opts: Record<string, Intl.DateTimeFormatOptions>,
-  timeZone: string
-): Record<string, Intl.DateTimeFormatOptions> {
-  return Object.keys(opts).reduce(
-    (all: Record<string, Intl.DateTimeFormatOptions>, k) => {
-      all[k] = {
-        timeZone,
-        ...opts[k],
-      }
-      return all
-    },
-    {}
-  )
-}
-
-function deepMergeOptions(
-  opts1: Record<string, Intl.DateTimeFormatOptions>,
-  opts2: Record<string, Intl.DateTimeFormatOptions>
-): Record<string, Intl.DateTimeFormatOptions> {
-  const keys = Object.keys({...opts1, ...opts2})
-  return keys.reduce((all: Record<string, Intl.DateTimeFormatOptions>, k) => {
-    all[k] = {
-      ...(opts1[k] || {}),
-      ...(opts2[k] || {}),
-    }
-    return all
-  }, {})
-}
-
-function deepMergeFormatsAndSetTimeZone(
-  f1: CustomFormats,
-  timeZone?: string
-): CustomFormats {
-  if (!timeZone) {
-    return f1
-  }
-  const mfFormats = IntlMessageFormat.formats
-  return {
-    ...mfFormats,
-    ...f1,
-    date: deepMergeOptions(
-      setTimeZoneInOptions(mfFormats.date, timeZone),
-      setTimeZoneInOptions(f1.date || {}, timeZone)
-    ),
-    time: deepMergeOptions(
-      setTimeZoneInOptions(mfFormats.time, timeZone),
-      setTimeZoneInOptions(f1.time || {}, timeZone)
-    ),
-  }
-}
-
-export type FormatMessageFn<T> = (
-  {
-    locale,
-    formats,
-    messages,
-    defaultLocale,
-    defaultFormats,
-    fallbackOnEmptyString,
-    onError,
-    timeZone,
-    defaultRichTextElements,
-  }: {
-    locale: string
-    timeZone?: string
-    formats: CustomFormats
-    messages: Record<string, string> | Record<string, MessageFormatElement[]>
-    defaultLocale: string
-    defaultFormats: CustomFormats
-    defaultRichTextElements?: Record<string, FormatXMLElementFn<T>>
-    fallbackOnEmptyString?: boolean
-    onError: OnErrorFn
-  },
-  state: IntlMessageFormatFormatters & Pick<Formatters, 'getMessageFormat'>,
-  messageDescriptor: MessageDescriptor,
-  values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T>>,
-  opts?: Options
-) => T extends string ? string : Array<T | string> | string | T
-
-export const formatMessage: FormatMessageFn<any> = (
-  {
-    locale,
-    formats,
-    messages,
-    defaultLocale,
-    defaultFormats,
-    fallbackOnEmptyString,
-    onError,
-    timeZone,
-    defaultRichTextElements,
-  },
-  state,
-  messageDescriptor = {id: ''},
-  values,
-  opts
-) => {
-  const {id: msgId, defaultMessage} = messageDescriptor
-
-  // `id` is a required field of a Message Descriptor.
-  invariant(
-    !!msgId,
-    `[@formatjs/intl] An \`id\` must be provided to format a message. You can either:
-1. Configure your build toolchain with [babel-plugin-formatjs](https://formatjs.io/docs/tooling/babel-plugin)
-or [@formatjs/ts-transformer](https://formatjs.io/docs/tooling/ts-transformer) OR
-2. Configure your \`eslint\` config to include [eslint-plugin-formatjs](https://formatjs.io/docs/tooling/linter#enforce-id)
-to autofix this issue`
-  )
-  const id = String(msgId)
-  const message =
-    // In case messages is Object.create(null)
-    // e.g import('foo.json') from webpack)
-    // See https://github.com/formatjs/formatjs/issues/1914
-    messages &&
-    Object.prototype.hasOwnProperty.call(messages, id) &&
-    messages[id]
-
-  // IMPORTANT: Hot path if `message` is AST with a single literal node
-  if (
-    Array.isArray(message) &&
-    message.length === 1 &&
-    message[0].type === TYPE.literal
-  ) {
-    return message[0].value
-  }
-
-  // IMPORTANT: Hot path straight lookup for performance
-  if (
-    !values &&
-    message &&
-    typeof message === 'string' &&
-    !defaultRichTextElements
-  ) {
-    return message.replace(/'\{(.*?)\}'/gi, `{$1}`)
-  }
-  values = {
-    ...defaultRichTextElements,
-    ...(values || {}),
-  }
-  formats = deepMergeFormatsAndSetTimeZone(formats, timeZone)
-  defaultFormats = deepMergeFormatsAndSetTimeZone(defaultFormats, timeZone)
-
-  if (!message) {
-    if (fallbackOnEmptyString === false && message === '') {
-      return message
-    }
-
-    if (
-      !defaultMessage ||
-      (locale && locale.toLowerCase() !== defaultLocale.toLowerCase())
-    ) {
-      // This prevents warnings from littering the console in development
-      // when no `messages` are passed into the <IntlProvider> for the
-      // default locale.
-      onError(new MissingTranslationError(messageDescriptor, locale))
-    }
-    if (defaultMessage) {
-      try {
-        const formatter = state.getMessageFormat(
-          defaultMessage,
-          defaultLocale,
-          defaultFormats,
-          opts
-        )
-
-        return formatter.format(values)
-      } catch (e) {
-        onError(
-          new MessageFormatError(
-            `Error formatting default message for: "${id}", rendering default message verbatim`,
-            locale,
-            messageDescriptor,
-            e
-          )
-        )
-        return typeof defaultMessage === 'string' ? defaultMessage : id
-      }
-    }
-    return id
-  }
-
-  // We have the translated message
-  try {
-    const formatter = state.getMessageFormat(message, locale, formats, {
-      formatters: state,
-      ...(opts || {}),
-    })
-
-    return formatter.format<any>(values)
-  } catch (e) {
-    onError(
-      new MessageFormatError(
-        `Error formatting message: "${id}", using ${
-          defaultMessage ? 'default message' : 'id'
-        } as fallback.`,
-        locale,
-        messageDescriptor,
-        e
-      )
-    )
-  }
-
-  if (defaultMessage) {
-    try {
-      const formatter = state.getMessageFormat(
-        defaultMessage,
-        defaultLocale,
-        defaultFormats,
-        opts
-      )
-
-      return formatter.format(values)
-    } catch (e) {
-      onError(
-        new MessageFormatError(
-          `Error formatting the default message for: "${id}", rendering message verbatim`,
-          locale,
-          messageDescriptor,
-          e
-        )
-      )
-    }
-  }
-
-  if (typeof message === 'string') {
-    return message
-  }
-  if (typeof defaultMessage === 'string') {
-    return defaultMessage
-  }
-  return id
-}

package/src/number.ts

@@ -1,101 +0,0 @@
-import {Formatters, IntlFormatters, CustomFormats, OnErrorFn} from './types'
-import {getNamedFormat, filterProps} from './utils'
-import {IntlError, IntlErrorCode} from './error'
-import {NumberFormatOptions} from '@formatjs/ecma402-abstract'
-
-const NUMBER_FORMAT_OPTIONS: Array<keyof NumberFormatOptions> = [
-  'style',
-  'currency',
-  'currencyDisplay',
-  'unit',
-  'unitDisplay',
-  'useGrouping',
-
-  'minimumIntegerDigits',
-  'minimumFractionDigits',
-  'maximumFractionDigits',
-  'minimumSignificantDigits',
-  'maximumSignificantDigits',
-
-  // ES2020 NumberFormat
-  'compactDisplay',
-  'currencyDisplay',
-  'currencySign',
-  'notation',
-  'signDisplay',
-  'unit',
-  'unitDisplay',
-  'numberingSystem',
-]
-
-export function getFormatter(
-  {
-    locale,
-    formats,
-    onError,
-  }: {
-    locale: string
-
-    formats: CustomFormats
-    onError: OnErrorFn
-  },
-  getNumberFormat: Formatters['getNumberFormat'],
-  options: Parameters<IntlFormatters['formatNumber']>[1] = {}
-): Intl.NumberFormat {
-  const {format} = options
-  const defaults = ((format &&
-    getNamedFormat(formats!, 'number', format, onError)) ||
-    {}) as NumberFormatOptions
-  const filteredOptions = filterProps(
-    options,
-    NUMBER_FORMAT_OPTIONS,
-    defaults
-  ) as NumberFormatOptions
-
-  return getNumberFormat(locale, filteredOptions)
-}
-
-export function formatNumber(
-  config: {
-    locale: string
-
-    formats: CustomFormats
-    onError: OnErrorFn
-  },
-  getNumberFormat: Formatters['getNumberFormat'],
-  value: Parameters<IntlFormatters['formatNumber']>[0],
-  options: Parameters<IntlFormatters['formatNumber']>[1] = {}
-): string {
-  try {
-    return getFormatter(config, getNumberFormat, options).format(value)
-  } catch (e) {
-    config.onError(
-      new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting number.', e)
-    )
-  }
-
-  return String(value)
-}
-
-export function formatNumberToParts(
-  config: {
-    locale: string
-    formats: CustomFormats
-    onError: OnErrorFn
-  },
-  getNumberFormat: Formatters['getNumberFormat'],
-  value: Parameters<IntlFormatters['formatNumber']>[0],
-  options: Parameters<IntlFormatters['formatNumber']>[1] = {}
-): Intl.NumberFormatPart[] {
-  try {
-    return getFormatter(config, getNumberFormat, options).formatToParts(
-      value as number
-    )
-  } catch (e) {
-    config.onError(
-      new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting number.', e)
-    )
-  }
-
-  return []
-}

package/src/plural.ts

@@ -1,45 +0,0 @@
-import {Formatters, IntlFormatters, OnErrorFn} from './types'
-import {filterProps} from './utils'
-import {IntlFormatError} from './error'
-import {ErrorCode, FormatError} from 'intl-messageformat'
-import {LDMLPluralRule} from '@formatjs/ecma402-abstract'
-
-const PLURAL_FORMAT_OPTIONS: Array<keyof Intl.PluralRulesOptions> = ['type']
-
-export function formatPlural(
-  {
-    locale,
-    onError,
-  }: {
-    locale: string
-    onError: OnErrorFn
-  },
-  getPluralRules: Formatters['getPluralRules'],
-  value: Parameters<IntlFormatters['formatPlural']>[0],
-  options: Parameters<IntlFormatters['formatPlural']>[1] = {}
-): LDMLPluralRule {
-  if (!Intl.PluralRules) {
-    onError(
-      new FormatError(
-        `Intl.PluralRules is not available in this environment.
-Try polyfilling it using "@formatjs/intl-pluralrules"
-`,
-        ErrorCode.MISSING_INTL_API
-      )
-    )
-  }
-  const filteredOptions = filterProps(
-    options,
-    PLURAL_FORMAT_OPTIONS
-  ) as Intl.PluralRulesOptions
-
-  try {
-    return getPluralRules(locale, filteredOptions).select(
-      value
-    ) as LDMLPluralRule
-  } catch (e) {
-    onError(new IntlFormatError('Error formatting plural.', locale, e))
-  }
-
-  return 'other'
-}

package/src/relativeTime.ts

@@ -1,74 +0,0 @@
-import {IntlFormatters, Formatters, CustomFormats, OnErrorFn} from './types'
-
-import {getNamedFormat, filterProps} from './utils'
-import {FormatError, ErrorCode} from 'intl-messageformat'
-import {IntlFormatError} from './error'
-
-const RELATIVE_TIME_FORMAT_OPTIONS: Array<
-  keyof Intl.RelativeTimeFormatOptions
-> = ['numeric', 'style']
-
-function getFormatter(
-  {
-    locale,
-    formats,
-    onError,
-  }: {
-    locale: string
-    formats: CustomFormats
-    onError: OnErrorFn
-  },
-  getRelativeTimeFormat: Formatters['getRelativeTimeFormat'],
-  options: Parameters<IntlFormatters['formatRelativeTime']>[2] = {}
-): Intl.RelativeTimeFormat {
-  const {format} = options
-
-  const defaults =
-    (!!format && getNamedFormat(formats, 'relative', format, onError)) || {}
-  const filteredOptions = filterProps(
-    options,
-    RELATIVE_TIME_FORMAT_OPTIONS,
-    defaults as Intl.RelativeTimeFormatOptions
-  ) as Intl.RelativeTimeFormatOptions
-
-  return getRelativeTimeFormat(locale, filteredOptions)
-}
-
-export function formatRelativeTime(
-  config: {
-    locale: string
-    formats: CustomFormats
-    onError: OnErrorFn
-  },
-  getRelativeTimeFormat: Formatters['getRelativeTimeFormat'],
-  value: Parameters<IntlFormatters['formatRelativeTime']>[0],
-  unit?: Parameters<IntlFormatters['formatRelativeTime']>[1],
-  options: Parameters<IntlFormatters['formatRelativeTime']>[2] = {}
-): string {
-  if (!unit) {
-    unit = 'second'
-  }
-  const RelativeTimeFormat = Intl.RelativeTimeFormat
-  if (!RelativeTimeFormat) {
-    config.onError(
-      new FormatError(
-        `Intl.RelativeTimeFormat is not available in this environment.
-Try polyfilling it using "@formatjs/intl-relativetimeformat"
-`,
-        ErrorCode.MISSING_INTL_API
-      )
-    )
-  }
-  try {
-    return getFormatter(config, getRelativeTimeFormat, options).format(
-      value,
-      unit
-    )
-  } catch (e) {
-    config.onError(
-      new IntlFormatError('Error formatting relative time.', config.locale, e)
-    )
-  }
-
-  return String(value)
-}

package/src/types.ts

@@ -1,234 +0,0 @@
-import {
-  IntlMessageFormat,
-  Formats,
-  FormatXMLElementFn,
-  FormatError,
-  PrimitiveType,
-  Options as IntlMessageFormatOptions,
-} from 'intl-messageformat'
-import {DateTimeFormat} from '@formatjs/ecma402-abstract'
-import {MessageFormatElement} from '@formatjs/icu-messageformat-parser'
-import IntlListFormat, {
-  IntlListFormatOptions,
-  Part,
-} from '@formatjs/intl-listformat'
-import {DisplayNames, DisplayNamesOptions} from '@formatjs/intl-displaynames'
-import {
-  MissingTranslationError,
-  MessageFormatError,
-  MissingDataError,
-  InvalidConfigError,
-  UnsupportedFormatterError,
-} from './error'
-import {DEFAULT_INTL_CONFIG} from './utils'
-import {NumberFormatOptions} from '@formatjs/ecma402-abstract'
-
-declare global {
-  namespace FormatjsIntl {
-    interface Message {}
-    interface IntlConfig {}
-    interface Formats {}
-  }
-}
-
-type MessageIds = FormatjsIntl.Message extends {ids: string}
-  ? FormatjsIntl.Message['ids']
-  : string
-
-type Locale = FormatjsIntl.IntlConfig extends {locale: string}
-  ? FormatjsIntl.IntlConfig['locale']
-  : string
-
-export type OnErrorFn = (
-  err:
-    | MissingTranslationError
-    | MessageFormatError
-    | MissingDataError
-    | InvalidConfigError
-    | UnsupportedFormatterError
-    | FormatError
-) => void
-
-export type OnWarnFn = (warning: string) => void
-
-/**
- * Config for intl object.
- * Generic type T is the type of potential rich text element. For example:
- * With React, T would be React.ReactNode
- */
-export interface ResolvedIntlConfig<T = string> {
-  locale: Locale
-  timeZone?: string
-  fallbackOnEmptyString?: boolean
-  formats: CustomFormats
-  messages:
-    | Record<MessageIds, string>
-    | Record<MessageIds, MessageFormatElement[]>
-  defaultLocale: string
-  defaultFormats: CustomFormats
-  defaultRichTextElements?: Record<string, FormatXMLElementFn<T>>
-  onError: OnErrorFn
-  onWarn?: OnWarnFn
-}
-
-export interface CustomFormats extends Partial<Formats> {
-  relative?: Record<string, Intl.RelativeTimeFormatOptions>
-}
-
-export interface CustomFormatConfig<Source = string> {
-  format?: Source extends keyof FormatjsIntl.Formats
-    ? FormatjsIntl.Formats[Source]
-    : string
-}
-
-export type FormatDateOptions = Omit<
-  Intl.DateTimeFormatOptions,
-  'localeMatcher'
-> &
-  CustomFormatConfig<'date'>
-export type FormatNumberOptions = Omit<NumberFormatOptions, 'localeMatcher'> &
-  CustomFormatConfig<'number'>
-export type FormatRelativeTimeOptions = Omit<
-  Intl.RelativeTimeFormatOptions,
-  'localeMatcher'
-> &
-  CustomFormatConfig<'time'>
-export type FormatPluralOptions = Omit<
-  Intl.PluralRulesOptions,
-  'localeMatcher'
-> &
-  CustomFormatConfig
-
-export type FormatListOptions = Omit<IntlListFormatOptions, 'localeMatcher'>
-
-export type FormatDisplayNameOptions = Omit<
-  DisplayNamesOptions,
-  'localeMatcher'
->
-
-export interface IntlFormatters<T = any, R = T> {
-  formatDateTimeRange(
-    from: Parameters<DateTimeFormat['formatRange']>[0],
-    to: Parameters<DateTimeFormat['formatRange']>[1],
-    opts?: FormatDateOptions
-  ): string
-  formatDate(
-    value: Parameters<Intl.DateTimeFormat['format']>[0] | string,
-    opts?: FormatDateOptions
-  ): string
-  formatTime(
-    value: Parameters<Intl.DateTimeFormat['format']>[0] | string,
-    opts?: FormatDateOptions
-  ): string
-  formatDateToParts(
-    value: Parameters<Intl.DateTimeFormat['format']>[0] | string,
-    opts?: FormatDateOptions
-  ): Intl.DateTimeFormatPart[]
-  formatTimeToParts(
-    value: Parameters<Intl.DateTimeFormat['format']>[0] | string,
-    opts?: FormatDateOptions
-  ): Intl.DateTimeFormatPart[]
-  formatRelativeTime(
-    value: Parameters<Intl.RelativeTimeFormat['format']>[0],
-    unit?: Parameters<Intl.RelativeTimeFormat['format']>[1],
-    opts?: FormatRelativeTimeOptions
-  ): string
-  formatNumber(
-    value: Parameters<Intl.NumberFormat['format']>[0],
-    opts?: FormatNumberOptions
-  ): string
-  formatNumberToParts(
-    value: Parameters<Intl.NumberFormat['format']>[0],
-    opts?: FormatNumberOptions
-  ): Intl.NumberFormatPart[]
-  formatPlural(
-    value: Parameters<Intl.PluralRules['select']>[0],
-    opts?: FormatPluralOptions
-  ): ReturnType<Intl.PluralRules['select']>
-  formatMessage(
-    descriptor: MessageDescriptor,
-    values?: Record<string, PrimitiveType | FormatXMLElementFn<string, string>>,
-    opts?: IntlMessageFormatOptions
-  ): string
-  formatMessage(
-    descriptor: MessageDescriptor,
-    values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T, R>>,
-    opts?: IntlMessageFormatOptions
-  ): R
-  $t(
-    descriptor: MessageDescriptor,
-    values?: Record<string, PrimitiveType | FormatXMLElementFn<string, string>>,
-    opts?: IntlMessageFormatOptions
-  ): string
-  $t(
-    descriptor: MessageDescriptor,
-    values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T, R>>,
-    opts?: IntlMessageFormatOptions
-  ): R
-  formatList(values: ReadonlyArray<string>, opts?: FormatListOptions): string
-  formatList(
-    values: ReadonlyArray<string | T>,
-    opts?: FormatListOptions
-  ): T | string | Array<string | T>
-  formatListToParts(
-    values: ReadonlyArray<string | T>,
-    opts?: FormatListOptions
-  ): Part[]
-  formatDisplayName(
-    value: Parameters<DisplayNames['of']>[0],
-    opts: FormatDisplayNameOptions
-  ): string | undefined
-}
-
-export interface Formatters {
-  getDateTimeFormat(
-    ...args: ConstructorParameters<typeof Intl.DateTimeFormat>
-  ): DateTimeFormat
-  getNumberFormat(
-    locales?: string | string[],
-    opts?: NumberFormatOptions
-  ): Intl.NumberFormat
-  getMessageFormat(
-    ...args: ConstructorParameters<typeof IntlMessageFormat>
-  ): IntlMessageFormat
-  getRelativeTimeFormat(
-    ...args: ConstructorParameters<typeof Intl.RelativeTimeFormat>
-  ): Intl.RelativeTimeFormat
-  getPluralRules(
-    ...args: ConstructorParameters<typeof Intl.PluralRules>
-  ): Intl.PluralRules
-  getListFormat(
-    ...args: ConstructorParameters<typeof IntlListFormat>
-  ): IntlListFormat
-  getDisplayNames(
-    ...args: ConstructorParameters<typeof DisplayNames>
-  ): DisplayNames
-}
-
-export interface IntlShape<T = string>
-  extends ResolvedIntlConfig<T>,
-    IntlFormatters {
-  formatters: Formatters
-}
-
-export interface IntlCache {
-  dateTime: Record<string, DateTimeFormat>
-  number: Record<string, Intl.NumberFormat>
-  message: Record<string, IntlMessageFormat>
-  relativeTime: Record<string, Intl.RelativeTimeFormat>
-  pluralRules: Record<string, Intl.PluralRules>
-  list: Record<string, IntlListFormat>
-  displayNames: Record<string, DisplayNames>
-}
-
-export interface MessageDescriptor {
-  id?: MessageIds
-  description?: string | object
-  defaultMessage?: string | MessageFormatElement[]
-}
-
-export type IntlConfig<T = string> = Omit<
-  ResolvedIntlConfig<T>,
-  keyof typeof DEFAULT_INTL_CONFIG
-> &
-  Partial<typeof DEFAULT_INTL_CONFIG>