@discord/intl 0.1.3-rc.0 → 0.2.0

package/dist/formatters/react.js

@@ -0,0 +1,111 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reactFormatter = exports.DEFAULT_REACT_RICH_TEXT_ELEMENTS = void 0;
+exports.formatReact = formatReact;
+exports.makeReactFormatter = makeReactFormatter;
+var React = require("react");
+var format_1 = require("../format");
+var h = React.createElement;
+exports.DEFAULT_REACT_RICH_TEXT_ELEMENTS = {
+    $_: function () { return ''; },
+    $b: function (content) { return h('strong', undefined, content); },
+    $code: function (content) { return h('code', undefined, content); },
+    $i: function (content) { return h('em', undefined, content); },
+    // $link will always be [href, <empty>, ...content]
+    $link: function (_a) {
+        var _b = __read(_a), href = _b[0], content = _b.slice(1);
+        return h('a', { href: href }, content);
+    },
+    $p: function (content) { return h('p', undefined, content); },
+};
+/**
+ * Creates a new `FormatBuilder` class that constructs a React element tree
+ * from the message using the given `richTextElements` to apply formatting.
+ * This allows consumers to inject their own design system components and
+ * overrides for rendering elements like links, paragraphs, and code blocks.
+ * @param richTextElements
+ */
+function createReactBuilder(richTextElements) {
+    return /** @class */ (function (_super) {
+        __extends(class_1, _super);
+        function class_1() {
+            var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+            _this.result = [];
+            return _this;
+        }
+        class_1.prototype.pushRichTextTag = function (tag, children) {
+            this.result.push(richTextElements[tag](children));
+        };
+        class_1.prototype.pushLiteralText = function (text) {
+            this.result.push(text);
+        };
+        class_1.prototype.pushObject = function (value) {
+            // @ts-expect-error this is technically invalid, but we'll just assume that if a format returns
+            // an object, it'll be acting as some form of ReactNode.
+            this.result.push(value);
+        };
+        class_1.prototype.finish = function () {
+            return this.result;
+        };
+        return class_1;
+    }(format_1.FormatBuilder));
+}
+function formatReact(message, values, Builder) {
+    if (typeof message === 'string') {
+        return React.createElement(React.Fragment, undefined, message);
+    }
+    var parts = this.bindFormatValues(Builder, message, values);
+    return React.createElement(React.Fragment, undefined, parts);
+}
+/**
+ * Create a new React formatter with the given rich text elements replacing the defaults. Use this
+ * function to inject custom components for things like links and paragraphs, which may be best
+ * suited to use components from a Design System or other library rather than native DOM elements.
+ */
+function makeReactFormatter(richTextElements) {
+    return {
+        format: formatReact,
+        builder: createReactBuilder(richTextElements),
+    };
+}
+exports.reactFormatter = makeReactFormatter(exports.DEFAULT_REACT_RICH_TEXT_ELEMENTS);

package/dist/formatters/string.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Format the given message with the provided values, removing any styling
+ * and non-textual content from the message, returning a plain string.
+ */
+import { AnyIntlMessage, FormatterImplementation, FunctionTypes, RichTextTagNames } from '../types';
+import { FormatBuilder } from '../format';
+import { IntlManager } from '../intl-manager';
+/**
+ * Types for formatting functions when calling `bindFormatValues`, ensuring the
+ * functions always yield plain strings.
+ */
+export type StringFunctionTypes = FunctionTypes<string>;
+export declare class StringBuilder extends FormatBuilder<string> {
+    result: string;
+    pushRichTextTag(tag: RichTextTagNames, children: string[]): void;
+    pushLiteralText(text: string): void;
+    pushObject(value: object): void;
+    finish(): string[];
+}
+export declare function formatToPlainString(this: IntlManager, message: AnyIntlMessage, values: object): string;
+export declare const stringFormatter: FormatterImplementation<StringFunctionTypes, string>;

package/dist/formatters/string.js

@@ -0,0 +1,90 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringFormatter = exports.StringBuilder = void 0;
+exports.formatToPlainString = formatToPlainString;
+var format_1 = require("../format");
+var StringBuilder = /** @class */ (function (_super) {
+    __extends(StringBuilder, _super);
+    function StringBuilder() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.result = '';
+        return _this;
+    }
+    StringBuilder.prototype.pushRichTextTag = function (tag, children) {
+        // Plain string formatting ignores rich text tags and just takes the
+        // visible content from the children. This means the `target` element
+        // of a link is ignored, otherwise all the children are just joined
+        // together directly.
+        if (tag === '$link') {
+            this.result += children.slice(1).join('');
+            return;
+        }
+        this.result += children.join('');
+    };
+    StringBuilder.prototype.pushLiteralText = function (text) {
+        this.result += text;
+    };
+    StringBuilder.prototype.pushObject = function (value) {
+        // Objects are only included in the result if they specify a toString value directly.
+        // Otherwise, they would be rendered as `[object Object]`, which is never helpful.
+        if ('toString' in value) {
+            this.result += value.toString();
+        }
+    };
+    StringBuilder.prototype.finish = function () {
+        return [this.result];
+    };
+    return StringBuilder;
+}(format_1.FormatBuilder));
+exports.StringBuilder = StringBuilder;
+function formatToPlainString(message, values) {
+    if (typeof message === 'string')
+        return message;
+    var result = this.bindFormatValues(StringBuilder, message, values);
+    // StringBuilder always creates a single element array with the string value.
+    return result[0];
+}
+exports.stringFormatter = {
+    format: formatToPlainString,
+    builder: StringBuilder,
+};

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { IntlManager } from './intl-manager';
-import { IntlManagerReact } from './react';
-export { IntlManager, createLoader, DEFAULT_LOCALE } from './intl-manager';
-export { IntlManagerReact } from './react';
+import * as React from 'react';
+import { RichTextNode } from './formatters';
+export { IntlManager, createLoader, DEFAULT_LOCALE, type FormatFunction } from './intl-manager';
+export * from './formatters';
 export type * from './types.d.ts';
 /**
  * A type representing any message that has been formatted using one of the
@@ -18,7 +18,7 @@ export type * from './types.d.ts';
  * intl message, even if the actual value comes from elsewhere (like a
  * user-generated string).
  */
-export type ReactIntlMessage = string | ReturnType<IntlManagerReact<any>['format']>;
+export type ReactIntlMessage = string | React.ReactElement;
 /**
  * The return value of `formatToParts` from `@discord/intl`, this type
  * represents any AST structure for a message rendered using this system.
@@ -29,4 +29,4 @@ export type ReactIntlMessage = string | ReturnType<IntlManagerReact<any>['format
  * from a call to `formatToParts`, meaning they are intended to be fully static
  * structures passed around for custom rendering functions to use.
  */
-export type IntlMessageAst = ReturnType<IntlManager<any, any>['formatToParts']>;
+export type IntlMessageAst = RichTextNode;

package/dist/index.js

@@ -1,9 +1,22 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntlManagerReact = exports.DEFAULT_LOCALE = exports.createLoader = exports.IntlManager = void 0;
+exports.DEFAULT_LOCALE = exports.createLoader = exports.IntlManager = void 0;
 var intl_manager_1 = require("./intl-manager");
 Object.defineProperty(exports, "IntlManager", { enumerable: true, get: function () { return intl_manager_1.IntlManager; } });
 Object.defineProperty(exports, "createLoader", { enumerable: true, get: function () { return intl_manager_1.createLoader; } });
 Object.defineProperty(exports, "DEFAULT_LOCALE", { enumerable: true, get: function () { return intl_manager_1.DEFAULT_LOCALE; } });
-var react_1 = require("./react");
-Object.defineProperty(exports, "IntlManagerReact", { enumerable: true, get: function () { return react_1.IntlManagerReact; } });
+__exportStar(require("./formatters"), exports);

package/dist/intl-manager.d.ts

@@ -1,34 +1,36 @@
 import { IntlShape } from '@formatjs/intl';
 import { LocaleId, LocaleImportMap, MessageLoader } from './message-loader';
-import type { FunctionTypeMap, IntlMessageGetter, RequiredFormatValues, RichTextElementMap, TypedIntlMessageGetter } from './types';
-/**
- * Types for formatting functions when calling `formatToParts`, ensuring the
- * functions yield value AST nodes.
- */
-type AstFunctionTypes = {
-    link: undefined | object | ((children: object) => Array<string | any>);
-    hook: undefined | object | ((children: object) => Array<string | any>);
-    handler: undefined | object | ((children: object) => Array<string | any>);
-};
+import type { FormatterImplementation, IntlMessageGetter, RequiredFormatValues, TypedIntlMessageGetter } from './types';
+import { InternalIntlMessage } from './message';
+import { FormatBuilderConstructor } from './format';
 /**
  * Fallback locale used for all internationalization when an operation in the
  * requested locale is not possible.
  */
 export declare const DEFAULT_LOCALE: string;
-export declare class IntlManager<DefaultElements extends RichTextElementMap, FunctionTypes extends FunctionTypeMap> {
+type FormatterReturnType<F extends FormatterImplementation<any, any>> = F extends FormatterImplementation<any, infer Return> ? Return : never;
+type FormatterFunctionTypes<F extends FormatterImplementation<any, any>> = F extends FormatterImplementation<infer Functions, any> ? Functions : never;
+export type FormatFunction<F extends FormatterImplementation<any, any>> = <T extends IntlMessageGetter>(this: IntlManager, message: T, values: RequiredFormatValues<T, FormatterFunctionTypes<F>>) => FormatterReturnType<F>;
+type ThisWithFormatters<This, T extends Record<string, FormatterImplementation<any, any>>> = This & {
+    [K in keyof T]: FormatFunction<T[K]>;
+};
+export declare class IntlManager {
     defaultLocale: string;
     currentLocale: string;
     intl: IntlShape;
+    _localeSubscriptions: Set<(locale: string) => void>;
+    constructor(defaultLocale?: string);
     /**
-     * When formatting tag elements like `<b>value</b>`, these functions will
-     * automatically be used by all messages, unless they are explicitly removed
-     * for a specific call, either by overriding the value or by calling a
-     * dedicated method like `formatToPlainString` which will remove all
-     * rich elements from the string and return only the plain text result.
+     * Add a set of formatter implementations to this manager, making each available as a direct
+     * property
      */
-    defaultRichTextElements: DefaultElements;
-    _localeSubscriptions: Set<(locale: string) => void>;
-    constructor(defaultLocale: string, defaultRichTextElements: DefaultElements);
+    withFormatters<const T extends Record<string, FormatterImplementation<any, any>>>(formatters: T): ThisWithFormatters<this, T>;
+    /**
+     * Return a new function bound to this manager that uses the given `FormatterImplementation` to
+     * format a message after it has been resolved for the current locale and potentially processed in
+     * other ways by the manager.
+     */
+    makeFormatFunction<F extends FormatterImplementation<any, any>>({ format, builder, }: F): FormatFunction<FormatterReturnType<F>>;
     /**
      * Set the locale for this package to use. This is a global change, and all
      * methods on this object will use this locale for formatting.
@@ -40,44 +42,11 @@ export declare class IntlManager<DefaultElements extends RichTextElementMap, Fun
      */
     onLocaleChange: (callback: (locale: string) => void) => () => boolean;
     /**
-     * Format the given message in the current locale with the provided values.
-     * The returned values is _always_ an Array of parts, even if the message is
-     * a simple string value.
-     *
-     * This function is the basis of how messages are normally formatted, and can
-     * be used anywhere. However, it is not reactive and only functions on the
-     * data that is currently loaded and known. For a reactive function that
-     * automatically updates when the locale changes or when new data is loaded,
-     * use `format`, which will wrap the formatting in a React component that
-     * subscribes to the current locale and state of loaded messages.
-     */
-    formatToParts<T extends TypedIntlMessageGetter<undefined>>(message: T): Array<string | any>;
-    formatToParts<T extends IntlMessageGetter>(message: T, values: RequiredFormatValues<T, DefaultElements, AstFunctionTypes>): Array<string | any>;
-    /**
-     * For messages with no formatting values (i.e., plain strings, they can skip
-     * a majority of the processing work and just resolve the message itself for
-     * the current locale, then return the plain string directly.
-     *
-     * This is separate from `formatToPlainString`, which still allows for
-     * formatting variables and other elements but reduces the output to only
-     * include textual elements in a plain string.
-     */
-    string(message: TypedIntlMessageGetter<undefined>): string;
-    /**
-     * Format the given message with the provided values, removing any styling
-     * and non-textual content from the message, returning a plain string.
-     */
-    formatToPlainString<T extends TypedIntlMessageGetter<undefined>>(message: T): string;
-    formatToPlainString<T extends IntlMessageGetter>(message: T, values: RequiredFormatValues<T, DefaultElements, FunctionTypes>): string;
-    /**
-     * Similar to `formatToPlainString`, format the given message with the provided
-     * values, but convert all rich text formatting back to Markdown syntax rather
-     * than rendering the actual rich content. The result is a plain string that
-     * can be sent through a separate Markdown renderer to get an equivalent
-     * result to formatting this message directly.
+     * For static messages with no rich text and no dynamic placeholders, use this method to
+     * immediately return the plain string value of the message in the current locale.
      */
-    formatToMarkdownString<T extends TypedIntlMessageGetter<undefined>>(message: T): string;
-    formatToMarkdownString<T extends IntlMessageGetter>(message: T, values: RequiredFormatValues<T, DefaultElements, FunctionTypes>): string;
+    string<T extends TypedIntlMessageGetter<undefined>>(message: T): string;
+    bindFormatValues<T>(Builder: FormatBuilderConstructor<T>, message: InternalIntlMessage, values: Record<string, any>): T[];
 }
 /**
  * Create a new MessageLoader, which handles lazily loading messages for

package/dist/intl-manager.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __values = (this && this.__values) || function(o) {
     var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
     if (m) return m.call(o);
@@ -21,19 +10,36 @@ var __values = (this && this.__values) || function(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IntlManager = exports.DEFAULT_LOCALE = void 0;
 exports.createLoader = createLoader;
 var intl_1 = require("@formatjs/intl");
 var intl_messageformat_1 = require("intl-messageformat");
 var message_loader_1 = require("./message-loader");
+var format_1 = require("./format");
 /**
  * Fallback locale used for all internationalization when an operation in the
  * requested locale is not possible.
  */
 exports.DEFAULT_LOCALE = 'en-US';
 var IntlManager = /** @class */ (function () {
-    function IntlManager(defaultLocale, defaultRichTextElements) {
+    function IntlManager(defaultLocale) {
         if (defaultLocale === void 0) { defaultLocale = exports.DEFAULT_LOCALE; }
         var _this = this;
         /**
@@ -50,24 +56,18 @@ var IntlManager = /** @class */ (function () {
             defaultLocale: defaultLocale,
             locale: defaultLocale,
         });
-        this.defaultRichTextElements = defaultRichTextElements;
         this._localeSubscriptions = new Set();
     }
     /**
-     * Set the locale for this package to use. This is a global change, and all
-     * methods on this object will use this locale for formatting.
+     * Add a set of formatter implementations to this manager, making each available as a direct
+     * property
      */
-    IntlManager.prototype.setLocale = function (locale) {
-        this.currentLocale = locale;
-        this.intl = (0, intl_1.createIntl)({ defaultLocale: this.defaultLocale, locale: locale });
-        this.emitLocaleChange(locale);
-    };
-    IntlManager.prototype.emitLocaleChange = function (locale) {
+    IntlManager.prototype.withFormatters = function (formatters) {
         var e_1, _a;
         try {
-            for (var _b = __values(this._localeSubscriptions), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var callback = _c.value;
-                callback(locale);
+            for (var _b = __values(Object.entries(formatters)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), name = _d[0], formatter = _d[1];
+                this[name] = this.makeFormatFunction(formatter);
             }
         }
         catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -77,77 +77,56 @@ var IntlManager = /** @class */ (function () {
             }
             finally { if (e_1) throw e_1.error; }
         }
+        return this;
     };
-    IntlManager.prototype.formatToParts = function (message, values) {
+    /**
+     * Return a new function bound to this manager that uses the given `FormatterImplementation` to
+     * format a message after it has been resolved for the current locale and potentially processed in
+     * other ways by the manager.
+     */
+    IntlManager.prototype.makeFormatFunction = function (_a) {
+        var _this = this;
+        var format = _a.format, builder = _a.builder;
+        var formatter = format.bind(this);
+        return function (message, values) {
+            return formatter(message(_this.currentLocale), values, builder);
+        };
+    };
+    /**
+     * Set the locale for this package to use. This is a global change, and all
+     * methods on this object will use this locale for formatting.
+     */
+    IntlManager.prototype.setLocale = function (locale) {
+        this.currentLocale = locale;
+        this.intl = (0, intl_1.createIntl)({ defaultLocale: this.defaultLocale, locale: locale });
+        this.emitLocaleChange(locale);
+    };
+    IntlManager.prototype.emitLocaleChange = function (locale) {
         var e_2, _a;
-        if (typeof message === 'string')
-            return [message];
-        var resolvedMessage = typeof message === 'function' ? message(this.currentLocale) : message;
-        if (typeof resolvedMessage === 'string')
-            return [resolvedMessage];
-        var resolvedValues = values != null
-            ? __assign(__assign({}, this.defaultRichTextElements), values) : this.defaultRichTextElements;
-        var parts = resolvedMessage.formatToParts(this.intl.formatters, this.intl.formats, resolvedValues);
-        var result = [];
-        var inLiteral = false;
         try {
-            for (var parts_1 = __values(parts), parts_1_1 = parts_1.next(); !parts_1_1.done; parts_1_1 = parts_1.next()) {
-                var part = parts_1_1.value;
-                // This condition merges consecutive literal elements (static strings)
-                // into single parts to reduce the number of nodes in the result. This
-                // condition will never be true on the first loop, ensuring that the
-                // array must at least have one entry before it attempts to concatenate
-                // onto that value again.
-                if (inLiteral && (inLiteral = part.type === intl_messageformat_1.PART_TYPE.literal)) {
-                    result[result.length - 1] += part.value;
-                    continue;
-                }
-                inLiteral = part.type === intl_messageformat_1.PART_TYPE.literal;
-                result.push(part.value);
+            for (var _b = __values(this._localeSubscriptions), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var callback = _c.value;
+                callback(locale);
             }
         }
         catch (e_2_1) { e_2 = { error: e_2_1 }; }
         finally {
             try {
-                if (parts_1_1 && !parts_1_1.done && (_a = parts_1.return)) _a.call(parts_1);
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
             finally { if (e_2) throw e_2.error; }
         }
-        return result;
     };
     /**
-     * For messages with no formatting values (i.e., plain strings, they can skip
-     * a majority of the processing work and just resolve the message itself for
-     * the current locale, then return the plain string directly.
-     *
-     * This is separate from `formatToPlainString`, which still allows for
-     * formatting variables and other elements but reduces the output to only
-     * include textual elements in a plain string.
+     * For static messages with no rich text and no dynamic placeholders, use this method to
+     * immediately return the plain string value of the message in the current locale.
      */
     IntlManager.prototype.string = function (message) {
-        // TODO(faulty): Optimize this so that plain strings are hotpathed even faster.
-        return this.formatToPlainString(message);
-    };
-    IntlManager.prototype.formatToPlainString = function (message, values) {
-        if (typeof message === 'string')
-            return message;
-        var resolvedMessage = message(this.currentLocale);
-        if (typeof resolvedMessage === 'string')
-            return resolvedMessage;
-        // No need to pass in `defaultRichTextElements`, since the stylistic tags
-        // will be removed from the string anyway.
-        return resolvedMessage.formatToPlainString(this.intl.formatters, this.intl.formats, values);
+        // TODO: Figure out how to make this typing exact.
+        return message(this.currentLocale).message;
     };
-    IntlManager.prototype.formatToMarkdownString = function (message, values) {
-        // TODO(faulty): Implement the markdown syntax conversion here.
-        if (typeof message === 'string')
-            return message;
-        var resolvedMessage = message(this.currentLocale);
-        if (typeof resolvedMessage === 'string')
-            return resolvedMessage;
-        // No need to pass in `defaultRichTextElements`, since the stylistic tags
-        // will be removed from the string anyway.
-        return resolvedMessage.formatToPlainString(this.intl.formatters, this.intl.formats, values);
+    IntlManager.prototype.bindFormatValues = function (Builder, message, values) {
+        return (0, format_1.bindFormatValues)(Builder, message.ast, [this.currentLocale, this.defaultLocale], this.intl.formatters, this.intl.formats, values);
     };
     return IntlManager;
 }());

package/dist/keyless-json.d.ts

@@ -32,6 +32,13 @@ export interface FormatJsTime {
     value: string;
     style?: string;
 }
+export interface FormatJsSelect {
+    type: FormatJsNodeType.Select;
+    value: string;
+    options: Record<string, {
+        value: FormatJsNode[];
+    }>;
+}
 export type FormatJsPluralType = 'cardinal' | 'ordinal';
 export interface FormatJsPlural {
     type: FormatJsNodeType.Plural;
@@ -50,7 +57,7 @@ export interface FormatJsTag {
     value: string;
     children: FormatJsNode[];
 }
-export type FormatJsNode = FormatJsLiteral | FormatJsArgument | FormatJsNumber | FormatJsDate | FormatJsTime | FormatJsPlural | FormatJsPound | FormatJsTag;
+export type FormatJsNode = FormatJsLiteral | FormatJsArgument | FormatJsNumber | FormatJsDate | FormatJsTime | FormatJsSelect | FormatJsPlural | FormatJsPound | FormatJsTag;
 export declare const FORMAT_JS_POUND: FormatJsPound;
 /**
  * Hydrate the given keyless JSON into a FormatJS-compatible AST structure.

package/dist/message-loader.d.ts

@@ -1,7 +1,6 @@
+import { FormatJsNode } from './keyless-json';
 import { InternalIntlMessage } from './message';
-import type { MessageFormatElement } from '@formatjs/icu-messageformat-parser';
-type AnyRawMessage = string | MessageFormatElement[];
-type MessagesData = Record<string, AnyRawMessage>;
+type MessagesData = Record<string, FormatJsNode[]>;
 export interface IntlMessageGetterAdditions {
     onChange(callback: () => void): () => void;
 }