intl-messageformat 10.0.1 → 10.1.2

package/index.ts

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

@@ -1,6 +1,6 @@
 {
   "name": "intl-messageformat",
-  "version": "10.0.1",
+  "version": "10.1.2",
   "description": "Formats ICU Message strings with number, date, plural, and select placeholders to create localized messages.",
   "keywords": [
     "i18n",
@@ -31,13 +31,13 @@
   "module": "lib/index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "@formatjs/ecma402-abstract": "1.11.6",
-    "@formatjs/fast-memoize": "1.2.3",
-    "@formatjs/icu-messageformat-parser": "2.1.2",
+    "@formatjs/ecma402-abstract": "1.11.9",
+    "@formatjs/fast-memoize": "1.2.5",
+    "@formatjs/icu-messageformat-parser": "2.1.5",
     "tslib": "2.4.0"
   },
   "sideEffects": false,
   "homepage": "https://github.com/formatjs/formatjs",
   "license": "BSD-3-Clause",
   "gitHead": "a7842673d8ad205171ad7c8cb8bb2f318b427c0c"
-}
+}

package/src/core.ts

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

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

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