Message bundles are single-language stores of translation resources. They are responsible for formatting message values and attributes to strings.

Hierarchy

  • FluentBundle

Constructors

  • Create an instance of 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
    }
    });

    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.

      • Optional functions?: Record<string, FluentFunction>

        Additional functions available to translations as builtins.

      • Optional transform?: TextTransform

        A function used to transform string parts of patterns.

      • Optional useIsolating?: boolean

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

        Default: true.

    Returns FluentBundle

Properties

locales: string[]

Methods

  • Add a translation resource to the bundle.

    Example

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

    Parameters

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

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

        Default: false.

    Returns Error[]

  • 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.

    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>]
    }

    Parameters

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

    Returns string

  • 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

  • Check if a message is present in the bundle.

    Parameters

    • id: string

      The identifier of the message to check.

    Returns boolean