@discord/intl 0.2.0 → 0.2.1-canary.1ed7c43

package/dist/format.js

@@ -34,6 +34,7 @@ exports.bindFormatValuesWithBuilder = bindFormatValuesWithBuilder;
 exports.bindFormatValues = bindFormatValues;
 var keyless_json_1 = require("./keyless-json");
 var intl_messageformat_1 = require("intl-messageformat");
+var icu_skeleton_parser_1 = require("@formatjs/icu-skeleton-parser");
 /**
  * Returns true if the tag name should be considered a rich text tag that
  * applies formatting to a message, rather than being a user-supplied value.
@@ -96,10 +97,11 @@ function bindFormatValuesWithBuilder(builder, nodes, locales, formatters, format
             case keyless_json_1.FormatJsNodeType.Date: {
                 // Distinct from FormatJS: We don't currently parse the skeleton ahead of time in the AST,
                 // so this manages parsing the skeleton as well before passing it onto the date formatter.
-                if (typeof node.style !== 'string') {
-                    throw '@discord/intl does not currently support non-string format skeletons';
-                }
-                var style = node.style in formats.date ? formats.date[node.style] : undefined; // TODO: parseSkeleton();
+                var style = node.style in formats.date
+                    ? formats.date[node.style]
+                    : node.style != null
+                        ? (0, icu_skeleton_parser_1.parseDateTimeSkeleton)(node.style)
+                        : undefined;
                 // @ts-expect-error Cast string values to dates properly.
                 builder.pushLiteralText(formatters.getDateTimeFormat(locales, style).format(value));
                 break;
@@ -107,10 +109,11 @@ function bindFormatValuesWithBuilder(builder, nodes, locales, formatters, format
             case keyless_json_1.FormatJsNodeType.Time: {
                 // Distinct from FormatJS: We don't currently parse the skeleton ahead of time in the AST,
                 // so this manages parsing the skeleton as well before passing it onto the date formatter.
-                if (typeof node.style !== 'string') {
-                    throw '@discord/intl does not currently support non-string format skeletons';
-                }
-                var style = node.style in formats.time ? formats.time[node.style] : undefined; // TODO: parseSkeleton();
+                var style = node.style in formats.time
+                    ? formats.time[node.style]
+                    : node.style != null
+                        ? (0, icu_skeleton_parser_1.parseDateTimeSkeleton)(node.style)
+                        : undefined; // TODO: parseSkeleton();
                 builder.pushLiteralText(
                 // @ts-expect-error Cast string values to dates properly.
                 formatters.getDateTimeFormat(locales, style).format(value));
@@ -119,13 +122,13 @@ function bindFormatValuesWithBuilder(builder, nodes, locales, formatters, format
             case keyless_json_1.FormatJsNodeType.Number: {
                 // Distinct from FormatJS: We don't currently parse the skeleton ahead of time in the AST,
                 // so this manages parsing the skeleton as well before passing it onto the date formatter.
-                if (typeof node.style !== 'string') {
-                    throw '@discord/intl does not currently support non-string format skeletons';
-                }
-                var style = node.style in formats.number ? formats.number[node.style] : undefined; // TODO: parseSkeleton();
+                var style = node.style in formats.number
+                    ? formats.number[node.style]
+                    : node.style != null
+                        ? (0, icu_skeleton_parser_1.parseNumberSkeleton)((0, icu_skeleton_parser_1.parseNumberSkeletonFromString)(node.style))
+                        : undefined;
                 // @ts-expect-error Support `scale` style property.
-                var scaledValue = value;
-                // const scaledValue = (value as number) * (style?.scale ?? 1);
+                var scaledValue = (style === null || style === void 0 ? void 0 : style.scale) != 1 ? value * style.scale : value;
                 builder.pushLiteralText(formatters.getNumberFormat(locales, style).format(scaledValue));
                 break;
             }

package/dist/formatters/ast.d.ts

@@ -4,11 +4,12 @@ import { IntlManager } from '../intl-manager';
  * Types for formatting functions when calling `formatToParts`, ensuring the
  * functions yield value AST nodes.
  */
-export type AstFunctionTypes = FunctionTypes<RichTextNode>;
+export type AstFunctionTypes = FunctionTypes<RichTextNode, object>;
 export declare enum RichTextNodeType {
     Text = "text",
     Strong = "strong",
     Emphasis = "emphasis",
+    Strikethrough = "strikethrough",
     Code = "code",
     Link = "link",
     Paragraph = "paragraph",
@@ -36,6 +37,9 @@ interface RichTextStrongNode extends RichTextNodeBase<RichTextNode[]> {
 interface RichTextEmphasisNode extends RichTextNodeBase<RichTextNode[]> {
     type: RichTextNodeType.Emphasis;
 }
+interface RichTextStrikethroughNode extends RichTextNodeBase<RichTextNode[]> {
+    type: RichTextNodeType.Strikethrough;
+}
 interface RichTextCodeNode extends RichTextNodeBase<RichTextNode[]> {
     type: RichTextNodeType.Code;
 }
@@ -49,7 +53,7 @@ interface RichTextLinkNode extends RichTextNodeBase<RichTextNode[]> {
 interface RichTextObjectNode extends RichTextNodeBase<object> {
     type: RichTextNodeType.Object;
 }
-export type RichTextNode = RichTextTextNode | RichTextStrongNode | RichTextEmphasisNode | RichTextCodeNode | RichTextParagraphNode | RichTextLinkNode | RichTextObjectNode;
+export type RichTextNode = RichTextTextNode | RichTextStrongNode | RichTextEmphasisNode | RichTextStrikethroughNode | RichTextCodeNode | RichTextParagraphNode | RichTextLinkNode | RichTextObjectNode;
 /**
  * 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

package/dist/formatters/ast.js

@@ -51,6 +51,7 @@ var RichTextNodeType;
     RichTextNodeType["Text"] = "text";
     RichTextNodeType["Strong"] = "strong";
     RichTextNodeType["Emphasis"] = "emphasis";
+    RichTextNodeType["Strikethrough"] = "strikethrough";
     RichTextNodeType["Code"] = "code";
     RichTextNodeType["Link"] = "link";
     RichTextNodeType["Paragraph"] = "paragraph";
@@ -65,19 +66,12 @@ var RichTextNodeType;
      */
     RichTextNodeType["Object"] = "object";
 })(RichTextNodeType || (exports.RichTextNodeType = RichTextNodeType = {}));
-var RICH_TEXT_TAG_TYPES = {
-    $_: RichTextNodeType.Text,
-    $b: RichTextNodeType.Strong,
-    $i: RichTextNodeType.Emphasis,
-    $code: RichTextNodeType.Code,
-    $link: RichTextNodeType.Link,
-    $p: RichTextNodeType.Paragraph,
-};
 var AST_RICH_TEXT_ELEMENTS = {
     $_: function () { return ({ type: RichTextNodeType.Text, content: '' }); },
     $b: function (content) { return ({ type: RichTextNodeType.Strong, content: content }); },
-    $code: function (content) { return ({ type: RichTextNodeType.Code, content: content }); },
     $i: function (content) { return ({ type: RichTextNodeType.Emphasis, content: content }); },
+    $del: function (content) { return ({ type: RichTextNodeType.Strikethrough, content: content }); },
+    $code: function (content) { return ({ type: RichTextNodeType.Code, content: content }); },
     $link: function (_a) {
         var _b = __read(_a), target = _b[0], content = _b.slice(1);
         return ({
@@ -100,7 +94,7 @@ var AstBuilder = /** @class */ (function (_super) {
         if (!(tag in AST_RICH_TEXT_ELEMENTS)) {
             throw "".concat(tag, " is not a known rich text formatting tag");
         }
-        var result = AST_RICH_TEXT_ELEMENTS[tag](children);
+        var result = AST_RICH_TEXT_ELEMENTS[tag](children, '');
         if (Array.isArray(result)) {
             (_a = this.result).push.apply(_a, __spreadArray([], __read(result), false));
         }

package/dist/formatters/markdown.js

@@ -46,8 +46,9 @@ var string_1 = require("./string");
 var MARKDOWN_RICH_TEXT_ELEMENTS = {
     $_: function () { return ''; },
     $b: function (content) { return '**' + content.join('') + '**'; },
-    $code: function (content) { return '`' + content.join('') + '`'; },
     $i: function (content) { return '*' + content.join('') + '*'; },
+    $del: function (content) { return '~~' + content.join('') + '~~'; },
+    $code: function (content) { return '`' + content.join('') + '`'; },
     $link: function (_a) {
         var _b = __read(_a), target = _b[0], content = _b.slice(1);
         return '[' + content.join('') + '](' + target + ')';
@@ -62,7 +63,7 @@ var MarkdownBuilder = /** @class */ (function (_super) {
         return _this;
     }
     MarkdownBuilder.prototype.pushRichTextTag = function (tag, children) {
-        this.result += MARKDOWN_RICH_TEXT_ELEMENTS[tag](children);
+        this.result += MARKDOWN_RICH_TEXT_ELEMENTS[tag](children, '');
     };
     return MarkdownBuilder;
 }(string_1.StringBuilder));

package/dist/formatters/react.d.ts

@@ -18,11 +18,14 @@ export type ReactFunctionTypes = FunctionTypes<React.ReactNode, ReactClickHandle
     onContextMenu: ReactClickHandler;
 }>;
 export declare const DEFAULT_REACT_RICH_TEXT_ELEMENTS: RichTextFormattingMap<ReactFunctionTypes['hook']>;
-export declare function formatReact(this: IntlManager, message: AnyIntlMessage, values: object, Builder: FormatBuilderConstructor<React.ReactElement>): React.ReactElement;
+export type ReactIntlMessage = React.ReactElement<{}, typeof React.Fragment & {
+    __brand: 'discord-intl';
+}>;
+export declare function formatReact(this: IntlManager, message: AnyIntlMessage, values: object, Builder: FormatBuilderConstructor<React.ReactElement>): ReactIntlMessage;
 /**
  * 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.
  */
-export declare function makeReactFormatter(richTextElements: RichTextFormattingMap<ReactFunctionTypes['hook']>): FormatterImplementation<ReactFunctionTypes, React.ReactElement, React.ReactNode>;
-export declare const reactFormatter: FormatterImplementation<ReactFunctionTypes, React.ReactElement<any, string | React.JSXElementConstructor<any>>, React.ReactNode>;
+export declare function makeReactFormatter(richTextElements: RichTextFormattingMap<ReactFunctionTypes['hook']>): FormatterImplementation<ReactFunctionTypes, ReactIntlMessage, React.ReactNode>;
+export declare const reactFormatter: FormatterImplementation<ReactFunctionTypes, ReactIntlMessage, React.ReactNode>;

package/dist/formatters/react.js

@@ -48,15 +48,16 @@ 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); },
+    $b: function (content, key) { return h('strong', { key: key }, content); },
+    $i: function (content, key) { return h('em', { key: key }, content); },
+    $del: function (content, key) { return h('del', { key: key }, content); },
+    $code: function (content, key) { return h('code', { key: key }, content); },
     // $link will always be [href, <empty>, ...content]
-    $link: function (_a) {
+    $link: function (_a, key) {
         var _b = __read(_a), href = _b[0], content = _b.slice(1);
-        return h('a', { href: href }, content);
+        return h('a', { href: href, key: key }, content);
     },
-    $p: function (content) { return h('p', undefined, content); },
+    $p: function (content, key) { return h('p', { key: key }, content); },
 };
 /**
  * Creates a new `FormatBuilder` class that constructs a React element tree
@@ -70,11 +71,12 @@ function createReactBuilder(richTextElements) {
         __extends(class_1, _super);
         function class_1() {
             var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+            _this._nodeKey = 0;
             _this.result = [];
             return _this;
         }
         class_1.prototype.pushRichTextTag = function (tag, children) {
-            this.result.push(richTextElements[tag](children));
+            this.result.push(richTextElements[tag](children, "".concat(this._nodeKey++)));
         };
         class_1.prototype.pushLiteralText = function (text) {
             this.result.push(text);

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import * as React from 'react';
 import { RichTextNode } from './formatters';
-export { IntlManager, createLoader, DEFAULT_LOCALE, type FormatFunction } from './intl-manager';
 export * from './formatters';
+export { IntlManager, DEFAULT_LOCALE, type FormatFunction } from './intl-manager';
+export { createLoader, loadAllMessagesInLocale, waitForAllDefaultIntlMessagesLoaded, MessageLoader, } from './message-loader';
 export type * from './types.d.ts';
 /**
  * A type representing any message that has been formatted using one of the

package/dist/index.js

@@ -14,9 +14,13 @@ 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.DEFAULT_LOCALE = exports.createLoader = exports.IntlManager = void 0;
+exports.MessageLoader = exports.waitForAllDefaultIntlMessagesLoaded = exports.loadAllMessagesInLocale = exports.createLoader = exports.DEFAULT_LOCALE = exports.IntlManager = void 0;
+__exportStar(require("./formatters"), exports);
 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; } });
-__exportStar(require("./formatters"), exports);
+var message_loader_1 = require("./message-loader");
+Object.defineProperty(exports, "createLoader", { enumerable: true, get: function () { return message_loader_1.createLoader; } });
+Object.defineProperty(exports, "loadAllMessagesInLocale", { enumerable: true, get: function () { return message_loader_1.loadAllMessagesInLocale; } });
+Object.defineProperty(exports, "waitForAllDefaultIntlMessagesLoaded", { enumerable: true, get: function () { return message_loader_1.waitForAllDefaultIntlMessagesLoaded; } });
+Object.defineProperty(exports, "MessageLoader", { enumerable: true, get: function () { return message_loader_1.MessageLoader; } });

package/dist/intl-manager.d.ts

@@ -1,5 +1,4 @@
 import { IntlShape } from '@formatjs/intl';
-import { LocaleId, LocaleImportMap, MessageLoader } from './message-loader';
 import type { FormatterImplementation, IntlMessageGetter, RequiredFormatValues, TypedIntlMessageGetter } from './types';
 import { InternalIntlMessage } from './message';
 import { FormatBuilderConstructor } from './format';
@@ -8,7 +7,7 @@ import { FormatBuilderConstructor } from './format';
  * requested locale is not possible.
  */
 export declare const DEFAULT_LOCALE: string;
-type FormatterReturnType<F extends FormatterImplementation<any, any>> = F extends FormatterImplementation<any, infer Return> ? Return : never;
+type FormatterReturnType<F extends FormatterImplementation<any, any>> = ReturnType<F['format']>;
 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 & {
@@ -46,12 +45,16 @@ export declare class IntlManager {
      * immediately return the plain string value of the message in the current locale.
      */
     string<T extends TypedIntlMessageGetter<undefined>>(message: T): string;
+    /**
+     * Return a raw string representing the syntax of the original message, as
+     * authored, with no values replaced. The result of this function could be
+     * written back to the definition file for the message and re-parsed to
+     * create an identical message to the original.
+     *
+     * This should rarely be necessary outside of sending raw messages to other
+     * applications that do their own message parsing.
+     */
+    reserialize<T extends IntlMessageGetter>(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
- * different locales and sanity checks as needed to provide accessors for each
- * message defined in `messageKeys`.
- */
-export declare function createLoader(messageKeys: string[], localeImportMap: LocaleImportMap, defaultLocale: LocaleId): MessageLoader;
 export {};

package/dist/intl-manager.js

@@ -28,10 +28,8 @@ var __read = (this && this.__read) || function (o, n) {
 };
 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
@@ -122,8 +120,25 @@ var IntlManager = /** @class */ (function () {
      * immediately return the plain string value of the message in the current locale.
      */
     IntlManager.prototype.string = function (message) {
-        // TODO: Figure out how to make this typing exact.
-        return message(this.currentLocale).message;
+        var resolved = message(this.currentLocale);
+        if (resolved == null || resolved.ast.length === 0)
+            return '';
+        // TODO: Figure out how to make this typing exact. This currently relies on
+        // the generic typing being sound enough to know that the message can only
+        // contain a single static text node and no placeholders or rich text.
+        return resolved.ast[0].value;
+    };
+    /**
+     * Return a raw string representing the syntax of the original message, as
+     * authored, with no values replaced. The result of this function could be
+     * written back to the definition file for the message and re-parsed to
+     * create an identical message to the original.
+     *
+     * This should rarely be necessary outside of sending raw messages to other
+     * applications that do their own message parsing.
+     */
+    IntlManager.prototype.reserialize = function (message) {
+        return message(this.currentLocale)[0].reserialize();
     };
     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);
@@ -131,11 +146,3 @@ var IntlManager = /** @class */ (function () {
     return IntlManager;
 }());
 exports.IntlManager = IntlManager;
-/**
- * Create a new MessageLoader, which handles lazily loading messages for
- * different locales and sanity checks as needed to provide accessors for each
- * message defined in `messageKeys`.
- */
-function createLoader(messageKeys, localeImportMap, defaultLocale) {
-    return new message_loader_1.MessageLoader(messageKeys, localeImportMap, defaultLocale);
-}

package/dist/message-loader.d.ts

@@ -28,9 +28,17 @@ export declare class MessageLoader {
      * then a request has already been made to load the locale and it is waiting
      * to resolve.
      */
-    _localeLoadingPromises: Record<LocaleId, Promise<{
-        default: MessagesData;
-    }> | undefined>;
+    _localeLoadingPromises: Record<LocaleId, {
+        /**`true` if this locale has been loaded at least once. */
+        initialized: boolean;
+        /**
+         * If the locale is currently being loaded, this Promise will exist and
+         * represent that loading status. Otherwise, this value is undefined.
+         */
+        current?: Promise<{
+            default: MessagesData;
+        }> | undefined;
+    }>;
     /**
      * Map of pre-parsed messages, keyed by the message key and locale
      */
@@ -99,5 +107,36 @@ export declare class MessageLoader {
      * Subscribe to events about when a locale has loaded.
      */
     onChange(callback: () => void): () => void;
+    isLocaleLoaded(locale: LocaleId, requireCurrent?: boolean): boolean;
+    waitForLocaleLoaded(locale: LocaleId, requireCurrent?: boolean): Promise<void>;
+    /**
+     * Returns true if this loader's default locale has finished loading. When
+     * true, all messages managed by this loader are guaranteed to have _a_
+     * render-able value, even if one does not exist in the current locale.
+     */
+    waitForDefaultLocale(requireCurrent?: boolean): Promise<void>;
 }
+/**
+ * Kick off a load request for the given locale across all currently-registered
+ * message loaders, returning a Promise that resolves when all loaders have
+ * finished loading that locale.
+ */
+export declare function loadAllMessagesInLocale(locale: LocaleId): Promise<void>;
+/**
+ * Returns a new Promise that resolves after all currently-registered message
+ * loaders have finished successfully loading their default locale content.
+ * Once this Promise has resolved, all messages that currently exist in the
+ * application (i.e., within all modules that have been imported or required in
+ * the current session) can be guaranteed to have _a_ render-able value.
+ *
+ * This function can be called at any point in an applications life cycle and
+ * will always ensure that _all_ loaders that currently exist are initialized.
+ */
+export declare function waitForAllDefaultIntlMessagesLoaded(): Promise<void>;
+/**
+ * Create a new MessageLoader, which handles lazily loading messages for
+ * different locales and sanity checks as needed to provide accessors for each
+ * message defined in `messageKeys`.
+ */
+export declare function createLoader(messageKeys: string[], localeImportMap: LocaleImportMap, defaultLocale: LocaleId): MessageLoader;
 export {};

package/dist/message-loader.js

@@ -64,6 +64,9 @@ var __read = (this && this.__read) || function (o, n) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageLoader = void 0;
+exports.loadAllMessagesInLocale = loadAllMessagesInLocale;
+exports.waitForAllDefaultIntlMessagesLoaded = waitForAllDefaultIntlMessagesLoaded;
+exports.createLoader = createLoader;
 var message_1 = require("./message");
 var MessageLoader = /** @class */ (function () {
     function MessageLoader(messageKeys, localeImportMap, defaultLocale) {
@@ -78,17 +81,24 @@ var MessageLoader = /** @class */ (function () {
         this._parseCache = new Map();
         this._subscribers = new Set();
         this._loadLocale(this.defaultLocale);
-        this.fallbackMessage = new message_1.InternalIntlMessage('THIS MESSAGE FAILED TO LOAD', 'en-US');
+        this.fallbackMessage = new message_1.InternalIntlMessage([], this.defaultLocale);
         // In cases where hot module replacement is available, set up cache clearing whenever the
         // targets change so that values are always replaced.
         // @ts-expect-error `hot` not defined in types.
         if (module.hot) {
             var _loop_1 = function (locale, file) {
                 // @ts-expect-error `hot` not defined in types.
-                module.hot.accept(file, function () {
-                    _this._parseCache.clear();
-                    _this._loadLocale(locale);
-                });
+                module.hot.accept(file, function () { return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, this._loadLocale(locale)];
+                            case 1:
+                                _a.sent();
+                                this._parseCache.clear();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
             };
             try {
                 for (var _b = __values(Object.entries(localeImportMap)), _c = _b.next(); !_c.done; _c = _b.next()) {
@@ -119,9 +129,8 @@ var MessageLoader = /** @class */ (function () {
     MessageLoader.prototype.get = function (key, locale) {
         var _a;
         var value = (_a = this.getMessageValue(key, locale)) !== null && _a !== void 0 ? _a : this.getMessageValue(key, this.defaultLocale);
-        if (value != null) {
+        if (value != null)
             return value;
-        }
         // If the message couldn't be found in either the requested nor the default locale, then
         // nothing can be done.
         var errorKey = this._debugKeyMap != null ? "\"".concat(this._debugKeyMap[key], "\" (").concat(key, ")") : undefined;
@@ -146,13 +155,11 @@ var MessageLoader = /** @class */ (function () {
         var cachedValue = this._parseCache.get(cacheKey);
         if (cachedValue != null)
             return cachedValue;
-        // Return early if this locale is still in the process of being loaded.
-        if (this._localeLoadingPromises[locale] != null) {
-            return undefined;
-        }
-        // If not, check whether it's been loaded and trigger a load if not.
+        // Check whether the locale exists in memory. If not, start a request to
+        // load the locale if one has not already started. It's impossible for
+        // the request to finish within the same tick, so return undefined in any
+        // case then.
         if (this.messages[locale] == null) {
-            // Ensure the locale is loaded, if it is supported
             if (this.supportedLocales.includes(locale)) {
                 this._loadLocale(locale);
             }
@@ -186,12 +193,13 @@ var MessageLoader = /** @class */ (function () {
     };
     MessageLoader.prototype._loadLocale = function (locale) {
         return __awaiter(this, void 0, void 0, function () {
-            var loadingPromise, _a, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            var current, _a, _b;
+            var _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
                         // Don't re-load a locale that's already in progress.
-                        if (this._localeLoadingPromises[locale] != null) {
+                        if (((_c = this._localeLoadingPromises[locale]) === null || _c === void 0 ? void 0 : _c.current) != null) {
                             return [2 /*return*/];
                         }
                         // Safety check in case the locale map doesn't include a require for the
@@ -203,14 +211,14 @@ var MessageLoader = /** @class */ (function () {
                         // If the locale is already set in `messages`, then it doesn't need to be loaded again.
                         if (this.messages[locale] != null)
                             return [2 /*return*/];
-                        loadingPromise = this.localeImportMap[locale]();
-                        this._localeLoadingPromises[locale] = loadingPromise;
+                        current = this.localeImportMap[locale]();
+                        this._localeLoadingPromises[locale] = { initialized: false, current: current };
                         _a = this.messages;
                         _b = locale;
-                        return [4 /*yield*/, loadingPromise];
+                        return [4 /*yield*/, current];
                     case 1:
-                        _a[_b] = (_c.sent()).default;
-                        delete this._localeLoadingPromises[locale];
+                        _a[_b] = (_d.sent()).default;
+                        this._localeLoadingPromises[locale] = { initialized: true, current: undefined };
                         this.emitChange();
                         return [2 /*return*/];
                 }
@@ -245,6 +253,111 @@ var MessageLoader = /** @class */ (function () {
         this._subscribers.add(callback);
         return function () { return _this._subscribers.delete(callback); };
     };
+    MessageLoader.prototype.isLocaleLoaded = function (locale, requireCurrent) {
+        if (requireCurrent === void 0) { requireCurrent = false; }
+        var ref = this._localeLoadingPromises[locale];
+        // Ensure the locale at least exists and is initialized.
+        if (ref == null || ref.initialized == false)
+            return false;
+        // `current` will be deleted once the locale has loaded, so if it is null,
+        // then the locale data is current.
+        if (requireCurrent)
+            return ref.current == null;
+        // Otherwise, initialization is enough.
+        return true;
+    };
+    MessageLoader.prototype.waitForLocaleLoaded = function (locale_1) {
+        return __awaiter(this, arguments, void 0, function (locale, requireCurrent) {
+            var ref;
+            if (requireCurrent === void 0) { requireCurrent = false; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        ref = this._localeLoadingPromises[locale];
+                        // If the locale hasn't been loaded at all, kick off the load and return
+                        // that Promise directly.
+                        if (ref == null)
+                            return [2 /*return*/, this._loadLocale(locale)];
+                        // If initialization is enough for this request, just resolve immediately.
+                        if (ref.initialized && !requireCurrent)
+                            return [2 /*return*/];
+                        // Otherwise, check the `current` loading state on the object, and if that
+                        // doesn't exist, then the locale data is already finished loading, and the
+                        // containing Promise will just resolve with `undefined`.
+                        return [4 /*yield*/, ref.current];
+                    case 1:
+                        // Otherwise, check the `current` loading state on the object, and if that
+                        // doesn't exist, then the locale data is already finished loading, and the
+                        // containing Promise will just resolve with `undefined`.
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Returns true if this loader's default locale has finished loading. When
+     * true, all messages managed by this loader are guaranteed to have _a_
+     * render-able value, even if one does not exist in the current locale.
+     */
+    MessageLoader.prototype.waitForDefaultLocale = function () {
+        return __awaiter(this, arguments, void 0, function (requireCurrent) {
+            if (requireCurrent === void 0) { requireCurrent = false; }
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.waitForLocaleLoaded(this.defaultLocale, requireCurrent)];
+            });
+        });
+    };
     return MessageLoader;
 }());
 exports.MessageLoader = MessageLoader;
+var LOADER_REGISTRY = [];
+/**
+ * Kick off a load request for the given locale across all currently-registered
+ * message loaders, returning a Promise that resolves when all loaders have
+ * finished loading that locale.
+ */
+function loadAllMessagesInLocale(locale) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.all(LOADER_REGISTRY.map(function (loader) { return loader._loadLocale(locale); }))];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * Returns a new Promise that resolves after all currently-registered message
+ * loaders have finished successfully loading their default locale content.
+ * Once this Promise has resolved, all messages that currently exist in the
+ * application (i.e., within all modules that have been imported or required in
+ * the current session) can be guaranteed to have _a_ render-able value.
+ *
+ * This function can be called at any point in an applications life cycle and
+ * will always ensure that _all_ loaders that currently exist are initialized.
+ */
+function waitForAllDefaultIntlMessagesLoaded() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.all(LOADER_REGISTRY.map(function (loader) { return loader.waitForDefaultLocale(); }))];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * Create a new MessageLoader, which handles lazily loading messages for
+ * different locales and sanity checks as needed to provide accessors for each
+ * message defined in `messageKeys`.
+ */
+function createLoader(messageKeys, localeImportMap, defaultLocale) {
+    var loader = new MessageLoader(messageKeys, localeImportMap, defaultLocale);
+    LOADER_REGISTRY.push(loader);
+    return loader;
+}

package/dist/message.d.ts

@@ -1,20 +1,11 @@
 import { FormatJsNode } from './keyless-json';
 export declare class InternalIntlMessage {
     locale: string;
-    message?: string;
     ast: FormatJsNode[];
+    constructor(messageOrAst: FormatJsNode[], locale: string);
     /**
-     * A stripped-down representation of the message with no rich formatting
-     * elements preserved. This will be lazily created the first time it is
-     * requested (e.g., by calling `formatToPlainString`).
+     * Return a stringified serialization of this message's AST, with no
+     * formatting or values applied.
      */
-    get plainAst(): FormatJsNode[];
-    _plainAst: FormatJsNode[];
-    constructor(messageOrAst: string | FormatJsNode[], locale: string);
-    /**
-     * Returns the same element with any formatting tags removed. If the element
-     * itself is a tag, the children will be hoisted and returned, otherwise the
-     * element is returned as an array of itself.
-     */
-    private _removeRichTags;
+    reserialize(): string;
 }