Convert format-message-parse ast to a function

Turns a compact format-message ast:

[ "You have ", [ "numBananas", "plural", 0, {
     "=0": [ "no bananas" ],
    "one": [ "a banana" ],
  "other": [ [ '#' ], " bananas" ]
} ], " for sale." ]

into a function:

format({ numBananas:0 })
//-> "You have no bananas for sale."

Quick Examples

npm install format-message-interpret --save

import parse from 'format-message-parse'
import interpret from 'format-message-interpret'

interpret('en', parse('Hello, {name}!'))({ name: 'Jane' })

API

interpret(locales: string | string[], ast: AST, types?: Types)

Generate a function from an ast, using the formatting rules of the locales that accepts an arguments object, and returns a string. You can optionally pass custom types. Any non-standard type found in ast without a corresponding formatter in types will be treated as a simple string type.

type Types = {
  [type: string]: (placeholder: string[], locales: string | string[]) =>
    (value: any, args: Object) => string
}

types is an object with each key being the name of the type as it appears in the message pattern. Each value is a function that takes the locales, and the node from the ast (like [ 'a', 'mytype', 'style' ]), and it returns a function that will be called with the specific value, and the complete arguments object. If the custom type was defined with sub-messages, those will already be converted to functions meant to be called with args.

interpret.toParts(locales: string | string[], ast: AST, types?: Types)

Like, interpret, interpretToParts will generate a function accepting the message arguments. However, it will return an array of message parts, instead of a string. This is intended to help generate rich messages.

interpret.toParts('en', parse('a {b} c'))({ b: 1 }) // [ 'a ', 1, ' c' ]
interpret.toParts('en', parse('Click {a, element, children {here}}'), {
  element: (locales, [ id, type, props ]) =>
    (fn, args) => fn(props.children(args))
})({ a: children => <a>{children}</a> })
// [ 'Click ', <a>here</a> ]

License

This software is free to use under the MIT license. See the LICENSE-MIT file for license text and copyright information.

Changelog

6.2.4

Update specs to interpret signed zeroes properly.

6.2.0

Add TypeScript type definitions.

6.0.3

Use var declarations for wider compatibility. Support Nodejs v10, and fall back to internal plural handling if Intl.PluralRules does not support the requested locale.

6.0.0

Breaking Change The order of arguments passed to interpret has been changed.

Placeholder ids absent from the arguments will no longer throw an error. You will instead see 'undefined' in the final message. If you were relying on the error for validation, please use the lint rules instead.

New Feature Styles for number placeholders can now be an LDML pattern string like "#,##0.00 GBP". These are converted to options passed to Intl.NumberFormat, so grouping placement, scientific notation, and extra characters are mostly ignored.

Styles for date and time placeholders can now be a pattern string like "MM/dd/yy". These are converted to options passed to Intl.DateTimeFormat, so extra characters (like / or -) are mostly ignored.

interpret now allows custom placeholder types.

Added interpret.toParts to get a flattened array of message parts. Parts are not coerced to strings, so this can help with rich formatting.

interpret.toParts('en', parse('a {b} c'))({ b: 1 }) // [ 'a ', 1, ' c' ]

Polish Better code reuse internally, let and const declarations instead of var. Uses flow type comments to help prevent some kinds of issues. You may need to add node_modules/format-message-interpret/intl.js.flow to your .flowconfig lib section if you do not have type definitions for the global Intl already.