Class IntlMessageFormat

packages/intl-messageformat/core.ts:104–299

}

export class IntlMessageFormat {
  private readonly ast: MessageFormatElement[]
  private readonly locales: string | string[]
  private readonly resolvedLocale?: Intl.Locale
  private readonly formatters: Formatters
  private readonly formats: Formats
  private readonly message: string | undefined
  private readonly formatterCache: FormatterCache = {
    number: {},
    dateTime: {},
    pluralRules: {},
  }
  constructor(
    message: string | MessageFormatElement[],
    locales: string | string[] = IntlMessageFormat.defaultLocale,
    overrideFormats?: Partial<Formats>,
    opts?: Options
  ) {
    // Defined first because it's used to build the format pattern.
    this.locales = locales
    this.resolvedLocale = IntlMessageFormat.resolveLocale(locales)

    if (typeof message === 'string') {
      this.message = message
      if (!IntlMessageFormat.__parse) {
        throw new TypeError(
          'IntlMessageFormat.__parse must be set to process `message` of type `string`'
        )
      }
      const {...parseOpts} = opts || {}
      // Parse string messages into an AST.
      this.ast = IntlMessageFormat.__parse(message, {
        ...parseOpts,
        locale: this.resolvedLocale,
      })
    } else {
      this.ast = message
    }

    if (!Array.isArray(this.ast)) {
      throw new TypeError('A message must be provided as a String or AST.')
    }

    // Creates a new object with the specified `formats` merged with the default
    // formats.
    this.formats = mergeConfigs(IntlMessageFormat.formats, overrideFormats)

    this.formatters =
      (opts && opts.formatters) || createDefaultFormatters(this.formatterCache)
  }

  format = <T = void>(
    values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T>>
  ): string | T | (string | T)[] => {
    const parts = this.formatToParts(values)
    // Hot path for straight simple msg translations
    if (parts.length === 1) {
      return parts[0].value