intl-messageformat 10.1.2 → 10.1.3

package/index.ts

@@ -1,11 +0,0 @@
-/*
-Copyright (c) 2014, Yahoo! Inc. All rights reserved.
-Copyrights licensed under the New BSD License.
-See the accompanying LICENSE file for terms.
-*/
-
-import {IntlMessageFormat} from './src/core'
-export * from './src/formatters'
-export * from './src/core'
-export * from './src/error'
-export default IntlMessageFormat

package/src/core.ts

@@ -1,294 +0,0 @@
-/*
-Copyright (c) 2014, Yahoo! Inc. All rights reserved.
-Copyrights licensed under the New BSD License.
-See the accompanying LICENSE file for terms.
-*/
-
-import {parse, MessageFormatElement} from '@formatjs/icu-messageformat-parser'
-import memoize, {Cache, strategies} from '@formatjs/fast-memoize'
-import {
-  FormatterCache,
-  Formatters,
-  Formats,
-  formatToParts,
-  FormatXMLElementFn,
-  PrimitiveType,
-  MessageFormatPart,
-  PART_TYPE,
-} from './formatters'
-
-// -- MessageFormat --------------------------------------------------------
-
-function mergeConfig(c1: Record<string, object>, c2?: Record<string, object>) {
-  if (!c2) {
-    return c1
-  }
-  return {
-    ...(c1 || {}),
-    ...(c2 || {}),
-    ...Object.keys(c1).reduce((all: Record<string, object>, k) => {
-      all[k] = {
-        ...c1[k],
-        ...(c2[k] || {}),
-      }
-      return all
-    }, {}),
-  }
-}
-
-function mergeConfigs(
-  defaultConfig: Formats,
-  configs?: Partial<Formats>
-): Formats {
-  if (!configs) {
-    return defaultConfig
-  }
-
-  return (Object.keys(defaultConfig) as Array<keyof Formats>).reduce(
-    (all: Formats, k: keyof Formats) => {
-      all[k] = mergeConfig(defaultConfig[k], configs[k])
-      return all
-    },
-    {...defaultConfig}
-  )
-}
-
-export interface Options {
-  formatters?: Formatters
-  /**
-   * Whether to treat HTML/XML tags as string literal
-   * instead of parsing them as tag token.
-   * When this is false we only allow simple tags without
-   * any attributes
-   */
-  ignoreTag?: boolean
-}
-
-function createFastMemoizeCache<V>(store: Record<string, V>): Cache<string, V> {
-  return {
-    create() {
-      return {
-        get(key) {
-          return store[key]
-        },
-        set(key, value) {
-          store[key] = value
-        },
-      }
-    },
-  }
-}
-
-function createDefaultFormatters(
-  cache: FormatterCache = {
-    number: {},
-    dateTime: {},
-    pluralRules: {},
-  }
-): Formatters {
-  return {
-    getNumberFormat: memoize((...args) => new Intl.NumberFormat(...args), {
-      cache: createFastMemoizeCache(cache.number),
-      strategy: strategies.variadic,
-    }),
-    getDateTimeFormat: memoize((...args) => new Intl.DateTimeFormat(...args), {
-      cache: createFastMemoizeCache(cache.dateTime),
-      strategy: strategies.variadic,
-    }),
-    getPluralRules: memoize((...args) => new Intl.PluralRules(...args), {
-      cache: createFastMemoizeCache(cache.pluralRules),
-      strategy: strategies.variadic,
-    }),
-  }
-}
-
-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`'
-        )
-      }
-      // Parse string messages into an AST.
-      this.ast = IntlMessageFormat.__parse(message, {
-        ignoreTag: opts?.ignoreTag,
-        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>>
-  ) => {
-    const parts = this.formatToParts(values)
-    // Hot path for straight simple msg translations
-    if (parts.length === 1) {
-      return parts[0].value
-    }
-    const result = parts.reduce((all, part) => {
-      if (
-        !all.length ||
-        part.type !== PART_TYPE.literal ||
-        typeof all[all.length - 1] !== 'string'
-      ) {
-        all.push(part.value)
-      } else {
-        all[all.length - 1] += part.value
-      }
-      return all
-    }, [] as Array<string | T>)
-
-    if (result.length <= 1) {
-      return result[0] || ''
-    }
-    return result
-  }
-  formatToParts = <T>(
-    values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T>>
-  ): MessageFormatPart<T>[] =>
-    formatToParts(
-      this.ast,
-      this.locales,
-      this.formatters,
-      this.formats,
-      values,
-      undefined,
-      this.message
-    )
-  resolvedOptions = () => ({
-    locale:
-      this.resolvedLocale?.toString() ||
-      Intl.NumberFormat.supportedLocalesOf(this.locales)[0],
-  })
-  getAst = () => this.ast
-  private static memoizedDefaultLocale: string | null = null
-
-  static get defaultLocale() {
-    if (!IntlMessageFormat.memoizedDefaultLocale) {
-      IntlMessageFormat.memoizedDefaultLocale =
-        new Intl.NumberFormat().resolvedOptions().locale
-    }
-
-    return IntlMessageFormat.memoizedDefaultLocale
-  }
-  static resolveLocale = (
-    locales: string | string[]
-  ): Intl.Locale | undefined => {
-    if (typeof Intl.Locale === 'undefined') {
-      return
-    }
-    const supportedLocales = Intl.NumberFormat.supportedLocalesOf(locales)
-    if (supportedLocales.length > 0) {
-      return new Intl.Locale(supportedLocales[0])
-    }
-
-    return new Intl.Locale(typeof locales === 'string' ? locales : locales[0])
-  }
-  static __parse: typeof parse | undefined = parse
-  // Default format options used as the prototype of the `formats` provided to the
-  // constructor. These are used when constructing the internal Intl.NumberFormat
-  // and Intl.DateTimeFormat instances.
-  static formats: Formats = {
-    number: {
-      integer: {
-        maximumFractionDigits: 0,
-      },
-      currency: {
-        style: 'currency',
-      },
-
-      percent: {
-        style: 'percent',
-      },
-    },
-
-    date: {
-      short: {
-        month: 'numeric',
-        day: 'numeric',
-        year: '2-digit',
-      },
-
-      medium: {
-        month: 'short',
-        day: 'numeric',
-        year: 'numeric',
-      },
-
-      long: {
-        month: 'long',
-        day: 'numeric',
-        year: 'numeric',
-      },
-
-      full: {
-        weekday: 'long',
-        month: 'long',
-        day: 'numeric',
-        year: 'numeric',
-      },
-    },
-
-    time: {
-      short: {
-        hour: 'numeric',
-        minute: 'numeric',
-      },
-
-      medium: {
-        hour: 'numeric',
-        minute: 'numeric',
-        second: 'numeric',
-      },
-
-      long: {
-        hour: 'numeric',
-        minute: 'numeric',
-        second: 'numeric',
-        timeZoneName: 'short',
-      },
-
-      full: {
-        hour: 'numeric',
-        minute: 'numeric',
-        second: 'numeric',
-        timeZoneName: 'short',
-      },
-    },
-  }
-}

package/src/error.ts

@@ -1,65 +0,0 @@
-export enum ErrorCode {
-  // When we have a placeholder but no value to format
-  MISSING_VALUE = 'MISSING_VALUE',
-  // When value supplied is invalid
-  INVALID_VALUE = 'INVALID_VALUE',
-  // When we need specific Intl API but it's not available
-  MISSING_INTL_API = 'MISSING_INTL_API',
-}
-
-export class FormatError extends Error {
-  public readonly code: ErrorCode
-  /**
-   * Original message we're trying to format
-   * `undefined` if we're only dealing w/ AST
-   *
-   * @type {(string | undefined)}
-   * @memberof FormatError
-   */
-  public readonly originalMessage: string | undefined
-  constructor(msg: string, code: ErrorCode, originalMessage?: string) {
-    super(msg)
-    this.code = code
-    this.originalMessage = originalMessage
-  }
-  public toString() {
-    return `[formatjs Error: ${this.code}] ${this.message}`
-  }
-}
-
-export class InvalidValueError extends FormatError {
-  constructor(
-    variableId: string,
-    value: any,
-    options: string[],
-    originalMessage?: string
-  ) {
-    super(
-      `Invalid values for "${variableId}": "${value}". Options are "${Object.keys(
-        options
-      ).join('", "')}"`,
-      ErrorCode.INVALID_VALUE,
-      originalMessage
-    )
-  }
-}
-
-export class InvalidValueTypeError extends FormatError {
-  constructor(value: any, type: string, originalMessage?: string) {
-    super(
-      `Value for "${value}" must be of type ${type}`,
-      ErrorCode.INVALID_VALUE,
-      originalMessage
-    )
-  }
-}
-
-export class MissingValueError extends FormatError {
-  constructor(variableId: string, originalMessage?: string) {
-    super(
-      `The intl string context variable "${variableId}" was not provided to the string "${originalMessage}"`,
-      ErrorCode.MISSING_VALUE,
-      originalMessage
-    )
-  }
-}

package/src/formatters.ts

@@ -1,311 +0,0 @@
-import {NumberFormatOptions} from '@formatjs/ecma402-abstract'
-import {
-  isArgumentElement,
-  isDateElement,
-  isDateTimeSkeleton,
-  isLiteralElement,
-  isNumberElement,
-  isNumberSkeleton,
-  isPluralElement,
-  isPoundElement,
-  isSelectElement,
-  isTimeElement,
-  MessageFormatElement,
-  isTagElement,
-  ExtendedNumberFormatOptions,
-} from '@formatjs/icu-messageformat-parser'
-import {
-  MissingValueError,
-  InvalidValueError,
-  ErrorCode,
-  FormatError,
-  InvalidValueTypeError,
-} from './error'
-
-declare global {
-  namespace FormatjsIntl {
-    interface Message {}
-    interface IntlConfig {}
-    interface Formats {}
-  }
-}
-
-type Format<Source = string> = Source extends keyof FormatjsIntl.Formats
-  ? FormatjsIntl.Formats[Source]
-  : string
-
-export interface Formats {
-  number: Record<Format<'number'>, NumberFormatOptions>
-  date: Record<Format<'date'>, Intl.DateTimeFormatOptions>
-  time: Record<Format<'time'>, Intl.DateTimeFormatOptions>
-}
-
-export interface FormatterCache {
-  number: Record<string, NumberFormatOptions>
-  dateTime: Record<string, Intl.DateTimeFormat>
-  pluralRules: Record<string, Intl.PluralRules>
-}
-
-export interface Formatters {
-  getNumberFormat(
-    locals?: string | string[],
-    opts?: NumberFormatOptions
-  ): Intl.NumberFormat
-  getDateTimeFormat(
-    ...args: ConstructorParameters<typeof Intl.DateTimeFormat>
-  ): Intl.DateTimeFormat
-  getPluralRules(
-    ...args: ConstructorParameters<typeof Intl.PluralRules>
-  ): Intl.PluralRules
-}
-
-export enum PART_TYPE {
-  literal,
-  object,
-}
-
-export interface LiteralPart {
-  type: PART_TYPE.literal
-  value: string
-}
-
-export interface ObjectPart<T = any> {
-  type: PART_TYPE.object
-  value: T
-}
-
-export type MessageFormatPart<T> = LiteralPart | ObjectPart<T>
-
-export type PrimitiveType = string | number | boolean | null | undefined | Date
-
-function mergeLiteral<T>(
-  parts: MessageFormatPart<T>[]
-): MessageFormatPart<T>[] {
-  if (parts.length < 2) {
-    return parts
-  }
-  return parts.reduce((all, part) => {
-    const lastPart = all[all.length - 1]
-    if (
-      !lastPart ||
-      lastPart.type !== PART_TYPE.literal ||
-      part.type !== PART_TYPE.literal
-    ) {
-      all.push(part)
-    } else {
-      lastPart.value += part.value
-    }
-    return all
-  }, [] as MessageFormatPart<T>[])
-}
-
-export function isFormatXMLElementFn<T>(
-  el: PrimitiveType | T | FormatXMLElementFn<T>
-): el is FormatXMLElementFn<T> {
-  return typeof el === 'function'
-}
-
-// TODO(skeleton): add skeleton support
-export function formatToParts<T>(
-  els: MessageFormatElement[],
-  locales: string | string[],
-  formatters: Formatters,
-  formats: Formats,
-  values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T>>,
-  currentPluralValue?: number,
-  // For debugging
-  originalMessage?: string
-): MessageFormatPart<T>[] {
-  // Hot path for straight simple msg translations
-  if (els.length === 1 && isLiteralElement(els[0])) {
-    return [
-      {
-        type: PART_TYPE.literal,
-        value: els[0].value,
-      },
-    ]
-  }
-  const result: MessageFormatPart<T>[] = []
-  for (const el of els) {
-    // Exit early for string parts.
-    if (isLiteralElement(el)) {
-      result.push({
-        type: PART_TYPE.literal,
-        value: el.value,
-      })
-      continue
-    }
-    // TODO: should this part be literal type?
-    // Replace `#` in plural rules with the actual numeric value.
-    if (isPoundElement(el)) {
-      if (typeof currentPluralValue === 'number') {
-        result.push({
-          type: PART_TYPE.literal,
-          value: formatters.getNumberFormat(locales).format(currentPluralValue),
-        })
-      }
-      continue
-    }
-
-    const {value: varName} = el
-
-    // Enforce that all required values are provided by the caller.
-    if (!(values && varName in values)) {
-      throw new MissingValueError(varName, originalMessage)
-    }
-
-    let value = values[varName]
-    if (isArgumentElement(el)) {
-      if (!value || typeof value === 'string' || typeof value === 'number') {
-        value =
-          typeof value === 'string' || typeof value === 'number'
-            ? String(value)
-            : ''
-      }
-      result.push({
-        type: typeof value === 'string' ? PART_TYPE.literal : PART_TYPE.object,
-        value,
-      } as ObjectPart<T>)
-      continue
-    }
-
-    // Recursively format plural and select parts' option — which can be a
-    // nested pattern structure. The choosing of the option to use is
-    // abstracted-by and delegated-to the part helper object.
-    if (isDateElement(el)) {
-      const style =
-        typeof el.style === 'string'
-          ? formats.date[el.style]
-          : isDateTimeSkeleton(el.style)
-          ? el.style.parsedOptions
-          : undefined
-      result.push({
-        type: PART_TYPE.literal,
-        value: formatters
-          .getDateTimeFormat(locales, style)
-          .format(value as number),
-      })
-      continue
-    }
-    if (isTimeElement(el)) {
-      const style =
-        typeof el.style === 'string'
-          ? formats.time[el.style]
-          : isDateTimeSkeleton(el.style)
-          ? el.style.parsedOptions
-          : formats.time.medium
-      result.push({
-        type: PART_TYPE.literal,
-        value: formatters
-          .getDateTimeFormat(locales, style)
-          .format(value as number),
-      })
-      continue
-    }
-    if (isNumberElement(el)) {
-      const style =
-        typeof el.style === 'string'
-          ? formats.number[el.style]
-          : isNumberSkeleton(el.style)
-          ? el.style.parsedOptions
-          : undefined
-
-      if (style && (style as ExtendedNumberFormatOptions).scale) {
-        value =
-          (value as number) *
-          ((style as ExtendedNumberFormatOptions).scale || 1)
-      }
-      result.push({
-        type: PART_TYPE.literal,
-        value: formatters
-          .getNumberFormat(locales, style)
-          .format(value as number),
-      })
-      continue
-    }
-    if (isTagElement(el)) {
-      const {children, value} = el
-      const formatFn = values[value]
-      if (!isFormatXMLElementFn<T>(formatFn)) {
-        throw new InvalidValueTypeError(value, 'function', originalMessage)
-      }
-      const parts = formatToParts<T>(
-        children,
-        locales,
-        formatters,
-        formats,
-        values,
-        currentPluralValue
-      )
-      let chunks = formatFn(parts.map(p => p.value))
-      if (!Array.isArray(chunks)) {
-        chunks = [chunks]
-      }
-      result.push(
-        ...chunks.map((c): MessageFormatPart<T> => {
-          return {
-            type: typeof c === 'string' ? PART_TYPE.literal : PART_TYPE.object,
-            value: c,
-          } as MessageFormatPart<T>
-        })
-      )
-    }
-    if (isSelectElement(el)) {
-      const opt = el.options[value as string] || el.options.other
-      if (!opt) {
-        throw new InvalidValueError(
-          el.value,
-          value,
-          Object.keys(el.options),
-          originalMessage
-        )
-      }
-      result.push(
-        ...formatToParts(opt.value, locales, formatters, formats, values)
-      )
-      continue
-    }
-    if (isPluralElement(el)) {
-      let opt = el.options[`=${value}`]
-      if (!opt) {
-        if (!Intl.PluralRules) {
-          throw new FormatError(
-            `Intl.PluralRules is not available in this environment.
-Try polyfilling it using "@formatjs/intl-pluralrules"
-`,
-            ErrorCode.MISSING_INTL_API,
-            originalMessage
-          )
-        }
-        const rule = formatters
-          .getPluralRules(locales, {type: el.pluralType})
-          .select((value as number) - (el.offset || 0))
-        opt = el.options[rule] || el.options.other
-      }
-      if (!opt) {
-        throw new InvalidValueError(
-          el.value,
-          value,
-          Object.keys(el.options),
-          originalMessage
-        )
-      }
-      result.push(
-        ...formatToParts(
-          opt.value,
-          locales,
-          formatters,
-          formats,
-          values,
-          (value as number) - (el.offset || 0)
-        )
-      )
-      continue
-    }
-  }
-  return mergeLiteral(result)
-}
-
-export type FormatXMLElementFn<T, R = string | T | Array<string | T>> = (
-  parts: Array<string | T>
-) => R