@formatjs/intl 2.3.2 → 2.3.4

package/src/create-intl.ts

@@ -1,159 +0,0 @@
-import {IntlCache, IntlShape, IntlConfig, ResolvedIntlConfig} from './types'
-import {createFormatters, DEFAULT_INTL_CONFIG} from './utils'
-import {InvalidConfigError, MissingDataError} from './error'
-import {formatNumber, formatNumberToParts} from './number'
-import {formatRelativeTime} from './relativeTime'
-import {
-  formatDate,
-  formatDateToParts,
-  formatTime,
-  formatTimeToParts,
-  formatDateTimeRange,
-} from './dateTime'
-import {formatPlural} from './plural'
-import {formatMessage} from './message'
-import {formatList, formatListToParts} from './list'
-import {formatDisplayName} from './displayName'
-import {MessageFormatElement} from '@formatjs/icu-messageformat-parser'
-
-export interface CreateIntlFn<
-  T = string,
-  C extends IntlConfig<T> = IntlConfig<T>,
-  S extends IntlShape<T> = IntlShape<T>
-> {
-  (config: C, cache?: IntlCache): S
-}
-
-function messagesContainString(
-  messages: Record<string, string> | Record<string, MessageFormatElement[]>
-): messages is Record<string, MessageFormatElement[]> {
-  const firstMessage = messages ? messages[Object.keys(messages)[0]] : undefined
-
-  return typeof firstMessage === 'string'
-}
-
-function verifyConfigMessages<T = string>(config: IntlConfig<T>) {
-  if (
-    config.onWarn &&
-    config.defaultRichTextElements &&
-    messagesContainString(config.messages || {})
-  ) {
-    config.onWarn(`[@formatjs/intl] "defaultRichTextElements" was specified but "message" was not pre-compiled. 
-Please consider using "@formatjs/cli" to pre-compile your messages for performance.
-For more details see https://formatjs.io/docs/getting-started/message-distribution`)
-  }
-}
-
-/**
- * Create intl object
- * @param config intl config
- * @param cache cache for formatter instances to prevent memory leak
- */
-export function createIntl<T = string>(
-  config: IntlConfig<T>,
-  cache?: IntlCache
-): IntlShape<T> {
-  const formatters = createFormatters(cache)
-  const resolvedConfig: ResolvedIntlConfig<T> = {
-    ...DEFAULT_INTL_CONFIG,
-    ...config,
-  }
-
-  const {locale, defaultLocale, onError} = resolvedConfig
-  if (!locale) {
-    if (onError) {
-      onError(
-        new InvalidConfigError(
-          `"locale" was not configured, using "${defaultLocale}" as fallback. See https://formatjs.io/docs/react-intl/api#intlshape for more details`
-        )
-      )
-    }
-    // Since there's no registered locale data for `locale`, this will
-    // fallback to the `defaultLocale` to make sure things can render.
-    // The `messages` are overridden to the `defaultProps` empty object
-    // to maintain referential equality across re-renders. It's assumed
-    // each <FormattedMessage> contains a `defaultMessage` prop.
-    resolvedConfig.locale = resolvedConfig.defaultLocale || 'en'
-  } else if (!Intl.NumberFormat.supportedLocalesOf(locale).length && onError) {
-    onError(
-      new MissingDataError(
-        `Missing locale data for locale: "${locale}" in Intl.NumberFormat. Using default locale: "${defaultLocale}" as fallback. See https://formatjs.io/docs/react-intl#runtime-requirements for more details`
-      )
-    )
-  } else if (
-    !Intl.DateTimeFormat.supportedLocalesOf(locale).length &&
-    onError
-  ) {
-    onError(
-      new MissingDataError(
-        `Missing locale data for locale: "${locale}" in Intl.DateTimeFormat. Using default locale: "${defaultLocale}" as fallback. See https://formatjs.io/docs/react-intl#runtime-requirements for more details`
-      )
-    )
-  }
-
-  verifyConfigMessages(resolvedConfig)
-  return {
-    ...resolvedConfig,
-    formatters,
-    formatNumber: formatNumber.bind(
-      null,
-      resolvedConfig,
-      formatters.getNumberFormat
-    ),
-    formatNumberToParts: formatNumberToParts.bind(
-      null,
-      resolvedConfig,
-      formatters.getNumberFormat
-    ),
-    formatRelativeTime: formatRelativeTime.bind(
-      null,
-      resolvedConfig,
-      formatters.getRelativeTimeFormat
-    ),
-    formatDate: formatDate.bind(
-      null,
-      resolvedConfig,
-      formatters.getDateTimeFormat
-    ),
-    formatDateToParts: formatDateToParts.bind(
-      null,
-      resolvedConfig,
-      formatters.getDateTimeFormat
-    ),
-    formatTime: formatTime.bind(
-      null,
-      resolvedConfig,
-      formatters.getDateTimeFormat
-    ),
-    formatDateTimeRange: formatDateTimeRange.bind(
-      null,
-      resolvedConfig,
-      formatters.getDateTimeFormat
-    ),
-    formatTimeToParts: formatTimeToParts.bind(
-      null,
-      resolvedConfig,
-      formatters.getDateTimeFormat
-    ),
-    formatPlural: formatPlural.bind(
-      null,
-      resolvedConfig,
-      formatters.getPluralRules
-    ),
-    // @ts-expect-error TODO: will get to this later
-    formatMessage: formatMessage.bind(null, resolvedConfig, formatters),
-    // @ts-expect-error TODO: will get to this later
-    $t: formatMessage.bind(null, resolvedConfig, formatters),
-    formatList: formatList.bind(null, resolvedConfig, formatters.getListFormat),
-    formatListToParts: formatListToParts.bind(
-      null,
-      resolvedConfig,
-      formatters.getListFormat
-    ),
-    formatDisplayName: formatDisplayName.bind(
-      null,
-      resolvedConfig,
-      formatters.getDisplayNames
-    ),
-  }
-}

package/src/dateTime.ts

@@ -1,204 +0,0 @@
-import {Formatters, IntlFormatters, CustomFormats, OnErrorFn} from './types'
-
-import {filterProps, getNamedFormat} from './utils'
-import {IntlError, IntlErrorCode} from './error'
-import {DateTimeFormat} from '@formatjs/ecma402-abstract'
-
-const DATE_TIME_FORMAT_OPTIONS: Array<keyof Intl.DateTimeFormatOptions> = [
-  'formatMatcher',
-
-  'timeZone',
-  'hour12',
-
-  'weekday',
-  'era',
-  'year',
-  'month',
-  'day',
-  'hour',
-  'minute',
-  'second',
-  'timeZoneName',
-  'hourCycle',
-  'dateStyle',
-  'timeStyle',
-  'calendar',
-  // 'dayPeriod',
-  'numberingSystem',
-  'fractionalSecondDigits',
-]
-
-export function getFormatter(
-  {
-    locale,
-    formats,
-    onError,
-    timeZone,
-  }: {
-    locale: string
-    timeZone?: string
-    formats: CustomFormats
-    onError: OnErrorFn
-  },
-  type: 'date' | 'time',
-  getDateTimeFormat: Formatters['getDateTimeFormat'],
-  options: Parameters<IntlFormatters['formatDate']>[1] = {}
-): DateTimeFormat {
-  const {format} = options
-  const defaults = {
-    ...(timeZone && {timeZone}),
-    ...(format && getNamedFormat(formats!, type, format, onError)),
-  }
-
-  let filteredOptions = filterProps(
-    options,
-    DATE_TIME_FORMAT_OPTIONS,
-    defaults
-  ) as Intl.DateTimeFormatOptions
-
-  if (
-    type === 'time' &&
-    !filteredOptions.hour &&
-    !filteredOptions.minute &&
-    !filteredOptions.second &&
-    !filteredOptions.timeStyle &&
-    !filteredOptions.dateStyle
-  ) {
-    // Add default formatting options if hour, minute, or second isn't defined.
-    filteredOptions = {...filteredOptions, hour: 'numeric', minute: 'numeric'}
-  }
-
-  return getDateTimeFormat(locale, filteredOptions)
-}
-
-export function formatDate(
-  config: {
-    locale: string
-    timeZone?: string
-    formats: CustomFormats
-    onError: OnErrorFn
-  },
-  getDateTimeFormat: Formatters['getDateTimeFormat'],
-  ...[value, options = {}]: Parameters<IntlFormatters['formatDate']>
-): string {
-  const date = typeof value === 'string' ? new Date(value || 0) : value
-  try {
-    return getFormatter(config, 'date', getDateTimeFormat, options).format(date)
-  } catch (e) {
-    config.onError(
-      new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting date.', e)
-    )
-  }
-
-  return String(date)
-}
-
-export function formatTime(
-  config: {
-    locale: string
-    timeZone?: string
-    formats: CustomFormats
-    onError: OnErrorFn
-  },
-  getDateTimeFormat: Formatters['getDateTimeFormat'],
-  ...[value, options = {}]: Parameters<IntlFormatters['formatTime']>
-): string {
-  const date = typeof value === 'string' ? new Date(value || 0) : value
-
-  try {
-    return getFormatter(config, 'time', getDateTimeFormat, options).format(date)
-  } catch (e) {
-    config.onError(
-      new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting time.', e)
-    )
-  }
-
-  return String(date)
-}
-
-export function formatDateTimeRange(
-  config: {
-    locale: string
-    timeZone?: string
-    onError: OnErrorFn
-  },
-  getDateTimeFormat: Formatters['getDateTimeFormat'],
-  ...[from, to, options = {}]: Parameters<IntlFormatters['formatDateTimeRange']>
-): string {
-  const {timeZone, locale, onError} = config
-
-  const filteredOptions = filterProps(
-    options,
-    DATE_TIME_FORMAT_OPTIONS,
-    timeZone ? {timeZone} : {}
-  ) as Intl.DateTimeFormatOptions
-
-  try {
-    return getDateTimeFormat(locale, filteredOptions).formatRange(from, to)
-  } catch (e) {
-    onError(
-      new IntlError(
-        IntlErrorCode.FORMAT_ERROR,
-        'Error formatting date time range.',
-        e
-      )
-    )
-  }
-
-  return String(from)
-}
-
-export function formatDateToParts(
-  config: {
-    locale: string
-    timeZone?: string
-    formats: CustomFormats
-    onError: OnErrorFn
-  },
-  getDateTimeFormat: Formatters['getDateTimeFormat'],
-  ...[value, options = {}]: Parameters<IntlFormatters['formatDate']>
-): Intl.DateTimeFormatPart[] {
-  const date = typeof value === 'string' ? new Date(value || 0) : value
-  try {
-    return getFormatter(
-      config,
-      'date',
-      getDateTimeFormat,
-      options
-    ).formatToParts(date)
-  } catch (e) {
-    config.onError(
-      new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting date.', e)
-    )
-  }
-
-  return []
-}
-
-export function formatTimeToParts(
-  config: {
-    locale: string
-    timeZone?: string
-    formats: CustomFormats
-    onError: OnErrorFn
-  },
-  getDateTimeFormat: Formatters['getDateTimeFormat'],
-  ...[value, options = {}]: Parameters<IntlFormatters['formatTimeToParts']>
-): Intl.DateTimeFormatPart[] {
-  const date = typeof value === 'string' ? new Date(value || 0) : value
-
-  try {
-    return getFormatter(
-      config,
-      'time',
-      getDateTimeFormat,
-      options
-    ).formatToParts(date)
-  } catch (e) {
-    config.onError(
-      new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting time.', e)
-    )
-  }
-
-  return []
-}

package/src/displayName.ts

@@ -1,54 +0,0 @@
-import {Formatters, IntlFormatters, OnErrorFn} from './types'
-import {filterProps} from './utils'
-import {
-  DisplayNamesOptions,
-  DisplayNames as IntlDisplayNames,
-} from '@formatjs/intl-displaynames'
-import {FormatError, ErrorCode} from 'intl-messageformat'
-import {IntlErrorCode, IntlError} from './error'
-
-const DISPLAY_NAMES_OPTONS: Array<keyof DisplayNamesOptions> = [
-  'style',
-  'type',
-  'fallback',
-]
-
-export function formatDisplayName(
-  {
-    locale,
-    onError,
-  }: {
-    locale: string
-    onError: OnErrorFn
-  },
-  getDisplayNames: Formatters['getDisplayNames'],
-  value: Parameters<IntlFormatters['formatDisplayName']>[0],
-  options: Parameters<IntlFormatters['formatDisplayName']>[1]
-): string | undefined {
-  const DisplayNames: typeof IntlDisplayNames = (Intl as any).DisplayNames
-  if (!DisplayNames) {
-    onError(
-      new FormatError(
-        `Intl.DisplayNames is not available in this environment.
-Try polyfilling it using "@formatjs/intl-displaynames"
-`,
-        ErrorCode.MISSING_INTL_API
-      )
-    )
-  }
-  const filteredOptions = filterProps(
-    options,
-    DISPLAY_NAMES_OPTONS
-  ) as DisplayNamesOptions
-  try {
-    return getDisplayNames(locale, filteredOptions).of(value)
-  } catch (e) {
-    onError(
-      new IntlError(
-        IntlErrorCode.FORMAT_ERROR,
-        'Error formatting display name.',
-        e
-      )
-    )
-  }
-}

package/src/error.ts

@@ -1,106 +0,0 @@
-import {MessageDescriptor} from './types'
-
-export enum IntlErrorCode {
-  FORMAT_ERROR = 'FORMAT_ERROR',
-  UNSUPPORTED_FORMATTER = 'UNSUPPORTED_FORMATTER',
-  INVALID_CONFIG = 'INVALID_CONFIG',
-  MISSING_DATA = 'MISSING_DATA',
-  MISSING_TRANSLATION = 'MISSING_TRANSLATION',
-}
-
-export class IntlError<
-  T extends IntlErrorCode = IntlErrorCode.FORMAT_ERROR
-> extends Error {
-  public readonly code: T
-
-  constructor(code: T, message: string, exception?: Error | unknown) {
-    const err = exception
-      ? exception instanceof Error
-        ? exception
-        : new Error(String(exception))
-      : undefined
-    super(
-      `[@formatjs/intl Error ${code}] ${message}
-${err ? `\n${err.message}\n${err.stack}` : ''}`
-    )
-    this.code = code
-    // @ts-ignore just so we don't need to declare dep on @types/node
-    if (typeof Error.captureStackTrace === 'function') {
-      // @ts-ignore just so we don't need to declare dep on @types/node
-      Error.captureStackTrace(this, IntlError)
-    }
-  }
-}
-
-export class UnsupportedFormatterError extends IntlError<IntlErrorCode.UNSUPPORTED_FORMATTER> {
-  constructor(message: string, exception?: Error | unknown) {
-    super(IntlErrorCode.UNSUPPORTED_FORMATTER, message, exception)
-  }
-}
-
-export class InvalidConfigError extends IntlError<IntlErrorCode.INVALID_CONFIG> {
-  constructor(message: string, exception?: Error | unknown) {
-    super(IntlErrorCode.INVALID_CONFIG, message, exception)
-  }
-}
-
-export class MissingDataError extends IntlError<IntlErrorCode.MISSING_DATA> {
-  constructor(message: string, exception?: Error | unknown) {
-    super(IntlErrorCode.MISSING_DATA, message, exception)
-  }
-}
-
-export class IntlFormatError extends IntlError<IntlErrorCode.FORMAT_ERROR> {
-  public readonly descriptor?: MessageDescriptor
-  constructor(message: string, locale: string, exception?: Error | unknown) {
-    super(
-      IntlErrorCode.FORMAT_ERROR,
-      `${message}
-Locale: ${locale}
-`,
-      exception
-    )
-  }
-}
-
-export class MessageFormatError extends IntlFormatError {
-  public readonly descriptor?: MessageDescriptor
-  constructor(
-    message: string,
-    locale: string,
-    descriptor?: MessageDescriptor,
-    exception?: Error | unknown
-  ) {
-    super(
-      `${message}
-MessageID: ${descriptor?.id}
-Default Message: ${descriptor?.defaultMessage}
-Description: ${descriptor?.description}
-`,
-      locale,
-      exception
-    )
-    this.descriptor = descriptor
-  }
-}
-
-export class MissingTranslationError extends IntlError<IntlErrorCode.MISSING_TRANSLATION> {
-  public readonly descriptor?: MessageDescriptor
-  constructor(descriptor: MessageDescriptor, locale: string) {
-    super(
-      IntlErrorCode.MISSING_TRANSLATION,
-      `Missing message: "${descriptor.id}" for locale "${locale}", using ${
-        descriptor.defaultMessage
-          ? `default message (${
-              typeof descriptor.defaultMessage === 'string'
-                ? descriptor.defaultMessage
-                : descriptor.defaultMessage
-                    .map((e: any) => e.value ?? JSON.stringify(e))
-                    .join()
-            })`
-          : 'id'
-      } as fallback.`
-    )
-    this.descriptor = descriptor
-  }
-}

package/src/list.ts

@@ -1,119 +0,0 @@
-import {Formatters, IntlFormatters, OnErrorFn} from './types'
-import {filterProps} from './utils'
-import type IntlListFormat from '@formatjs/intl-listformat'
-import type {Part} from '@formatjs/intl-listformat'
-import type {IntlListFormatOptions} from '@formatjs/intl-listformat'
-import {FormatError, ErrorCode} from 'intl-messageformat'
-import {IntlError, IntlErrorCode} from './error'
-
-const LIST_FORMAT_OPTIONS: Array<keyof IntlListFormatOptions> = [
-  'type',
-  'style',
-]
-
-const now = Date.now()
-
-function generateToken(i: number): string {
-  return `${now}_${i}_${now}`
-}
-
-export function formatList(
-  opts: {
-    locale: string
-    onError: OnErrorFn
-  },
-  getListFormat: Formatters['getListFormat'],
-  values: ReadonlyArray<string>,
-  options: Parameters<IntlFormatters['formatList']>[1]
-): string
-export function formatList<T>(
-  opts: {
-    locale: string
-    onError: OnErrorFn
-  },
-  getListFormat: Formatters['getListFormat'],
-  values: Parameters<IntlFormatters['formatList']>[0],
-  options: Parameters<IntlFormatters['formatList']>[1] = {}
-): Array<T | string> | T | string {
-  const results = formatListToParts(
-    opts,
-    getListFormat,
-    values,
-    options
-  ).reduce((all: Array<string | T>, el) => {
-    const val = el.value
-    if (typeof val !== 'string') {
-      all.push(val)
-    } else if (typeof all[all.length - 1] === 'string') {
-      all[all.length - 1] += val
-    } else {
-      all.push(val)
-    }
-    return all
-  }, [])
-  return results.length === 1 ? results[0] : results
-}
-
-export function formatListToParts<T>(
-  opts: {
-    locale: string
-    onError: OnErrorFn
-  },
-  getListFormat: Formatters['getListFormat'],
-  values: ReadonlyArray<string>,
-  options: Parameters<IntlFormatters['formatList']>[1]
-): Part[]
-export function formatListToParts<T>(
-  {
-    locale,
-    onError,
-  }: {
-    locale: string
-    onError: OnErrorFn
-  },
-  getListFormat: Formatters['getListFormat'],
-  values: Parameters<IntlFormatters['formatList']>[0],
-  options: Parameters<IntlFormatters['formatList']>[1] = {}
-): Part<T | string>[] {
-  const ListFormat: typeof IntlListFormat = (Intl as any).ListFormat
-  if (!ListFormat) {
-    onError(
-      new FormatError(
-        `Intl.ListFormat is not available in this environment.
-Try polyfilling it using "@formatjs/intl-listformat"
-`,
-        ErrorCode.MISSING_INTL_API
-      )
-    )
-  }
-  const filteredOptions = filterProps(
-    options,
-    LIST_FORMAT_OPTIONS
-  ) as IntlListFormatOptions
-
-  try {
-    const richValues: Record<string, T> = {}
-    const serializedValues = values.map((v, i) => {
-      if (typeof v === 'object') {
-        const id = generateToken(i)
-        richValues[id] = v as any
-        return id
-      }
-      return String(v)
-    })
-    return getListFormat(locale, filteredOptions)
-      .formatToParts(serializedValues)
-      .map(part =>
-        part.type === 'literal'
-          ? part
-          : {...part, value: richValues[part.value] || part.value}
-      )
-  } catch (e) {
-    onError(
-      new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting list.', e)
-    )
-  }
-
-  // @ts-ignore
-  return values
-}