Class FluentBundle

constructor

• new FluentBundle(
      locales: string | string[],
      options?: {
          functions?: Record<string, FluentFunction>;
          transform?: TextTransform;
          useIsolating?: boolean;
      },
  ): FluentBundle

  Create an instance of FluentBundle.

  Parameters

  • locales: string | string[]

    Used to instantiate Intl formatters used by translations.
  • options: {
        functions?: Record<string, FluentFunction>;
        transform?: TextTransform;
        useIsolating?: boolean;
    } = {}

    Optional configuration for the bundle.

    • Optionalfunctions?: Record<string, FluentFunction>

      Additional functions available to translations as builtins.

    • Optionaltransform?: TextTransform

      A function used to transform string parts of patterns.

    • OptionaluseIsolating?: boolean

      Whether to use Unicode isolation marks (FSI, PDI) for bidi interpolations.

      Default: true.

  Returns FluentBundle

  Example

  let bundle = new FluentBundle(["en-US", "en"]);
  
  let bundle = new FluentBundle(locales, {useIsolating: false});
  
  let bundle = new FluentBundle(locales, {
    useIsolating: true,
    functions: {
      NODE_ENV: () => process.env.NODE_ENV
    }
  });
  Copy

locales

addResource

• addResource(
      res: FluentResource,
      options?: { allowOverrides?: boolean },
  ): Error[]

  Add a translation resource to the bundle.

  Parameters

  • res: FluentResource
  • options: { allowOverrides?: boolean } = {}

    • OptionalallowOverrides?: boolean

      Boolean specifying whether it's allowed to override an existing message or term with a new value.

      Default: false.

  Returns Error[]

  Example

  let res = new FluentResource("foo = Foo");
  bundle.addResource(res);
  bundle.getMessage("foo");
  // → {value: .., attributes: {..}}
  Copy

formatPattern

• formatPattern(
      pattern: Pattern,
      args?: null | Record<string, FluentVariable>,
      errors?: null | Error[],
  ): string

  Format a Pattern to a string.

  Format a raw Pattern into a string. args will be used to resolve references to variables passed as arguments to the translation.

  In case of errors formatPattern will try to salvage as much of the translation as possible and will still return a string. For performance reasons, the encountered errors are not returned but instead are appended to the errors array passed as the third argument.

  If errors is omitted, the first encountered error will be thrown.

  Parameters

  • pattern: Pattern
  • args: null | Record<string, FluentVariable> = null
  • errors: null | Error[] = null

  Returns string

  Example

  let errors = [];
  bundle.addResource(
      new FluentResource("hello = Hello, {$name}!"));
  
  let hello = bundle.getMessage("hello");
  if (hello.value) {
      bundle.formatPattern(hello.value, {name: "Jane"}, errors);
      // Returns "Hello, Jane!" and `errors` is empty.
  
      bundle.formatPattern(hello.value, undefined, errors);
      // Returns "Hello, {$name}!" and `errors` is now:
      // [<ReferenceError: Unknown variable: name>]
  }
  Copy

getMessage

• getMessage(id: string): undefined | Message

  Return a raw unformatted message object from the bundle.

  Raw messages are {value, attributes} shapes containing translation units called Patterns. Patterns are implementation-specific; they should be treated as black boxes and formatted with FluentBundle.formatPattern.

  Parameters

  • id: string

    The identifier of the message to check.

  Returns undefined | Message

hasMessage

• hasMessage(id: string): boolean

  Check if a message is present in the bundle.

  Parameters

  • id: string

    The identifier of the message to check.

  Returns boolean