@discord/intl 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Discord, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { IntlManager, createLoader, DEFAULT_LOCALE } from './intl-manager';
+export { IntlManagerReact } from './react';
+export type * from './types.d.ts';

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntlManagerReact = 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; } });

package/dist/intl-manager.d.ts

@@ -0,0 +1,59 @@
+import { IntlShape } from '@formatjs/intl';
+import { LocaleImportMap, MessageLoader } from './message-loader';
+import type { TypedIntlMessageGetter, FormatValuesFor, RichTextElementMap } from './types';
+/**
+ * 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, DefaultValues extends keyof DefaultElements> {
+    defaultLocale: string;
+    currentLocale: string;
+    intl: IntlShape;
+    /**
+     * 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.
+     */
+    defaultRichTextElements: DefaultElements;
+    _localeSubscriptions: Set<(locale: string) => void>;
+    constructor(defaultLocale: string, defaultRichTextElements: DefaultElements);
+    /**
+     * 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.
+     */
+    setLocale(locale: string): void;
+    emitLocaleChange(locale: string): void;
+    /**
+     * Subscribe to changes in the current locale for this manager.
+     */
+    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<object | undefined>>(message: T): Array<string | any>;
+    formatToParts<T extends TypedIntlMessageGetter<object | undefined>>(message: T, values: Omit<FormatValuesFor<T>, DefaultValues>): Array<string | any>;
+    /**
+     * 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<object | undefined>>(message: T): string;
+    formatToPlainString<T extends TypedIntlMessageGetter<object | undefined>>(message: T, values: Omit<FormatValuesFor<T>, DefaultValues>): string;
+}
+/**
+ * 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): MessageLoader;

package/dist/intl-manager.js

@@ -0,0 +1,138 @@
+"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);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+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");
+/**
+ * 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) {
+        if (defaultLocale === void 0) { defaultLocale = exports.DEFAULT_LOCALE; }
+        var _this = this;
+        /**
+         * Subscribe to changes in the current locale for this manager.
+         */
+        this.onLocaleChange = function (callback) {
+            _this._localeSubscriptions.add(callback);
+            return function () { return _this._localeSubscriptions.delete(callback); };
+        };
+        this.defaultLocale = defaultLocale;
+        this.currentLocale = defaultLocale;
+        this.intl = (0, intl_1.createIntl)({
+            formats: intl_messageformat_1.IntlMessageFormat.formats,
+            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.
+     */
+    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_1, _a;
+        try {
+            for (var _b = __values(this._localeSubscriptions), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var callback = _c.value;
+                callback(locale);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    IntlManager.prototype.formatToParts = function (message, values) {
+        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);
+            }
+        }
+        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);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return result;
+    };
+    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);
+    };
+    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) {
+    return new message_loader_1.MessageLoader(messageKeys, localeImportMap);
+}

package/dist/keyless-json.d.ts

@@ -0,0 +1,61 @@
+export declare enum FormatJsNodeType {
+    Literal = 0,
+    Argument = 1,
+    Number = 2,
+    Date = 3,
+    Time = 4,
+    Select = 5,
+    Plural = 6,
+    Pound = 7,
+    Tag = 8
+}
+export interface FormatJsLiteral {
+    type: FormatJsNodeType.Literal;
+    value: string;
+}
+export interface FormatJsArgument {
+    type: FormatJsNodeType.Argument;
+    value: string;
+}
+export interface FormatJsNumber {
+    type: FormatJsNodeType.Number;
+    value: string;
+    style?: string;
+}
+export interface FormatJsDate {
+    type: FormatJsNodeType.Date;
+    value: string;
+    style?: string;
+}
+export interface FormatJsTime {
+    type: FormatJsNodeType.Time;
+    value: string;
+    style?: string;
+}
+export type FormatJsPluralType = 'cardinal' | 'ordinal';
+export interface FormatJsPlural {
+    type: FormatJsNodeType.Plural;
+    value: string;
+    options: Record<string, {
+        value: FormatJsNode[];
+    }>;
+    offset: number;
+    pluralType: FormatJsPluralType;
+}
+export interface FormatJsPound {
+    type: FormatJsNodeType.Pound;
+}
+export interface FormatJsTag {
+    type: FormatJsNodeType.Tag;
+    value: string;
+    children: FormatJsNode[];
+}
+export type FormatJsNode = FormatJsLiteral | FormatJsArgument | FormatJsNumber | FormatJsDate | FormatJsTime | FormatJsPlural | FormatJsPound | FormatJsTag;
+export declare const FORMAT_JS_POUND: FormatJsPound;
+/**
+ * Hydrate the given keyless JSON into a FormatJS-compatible AST structure.
+ * The given object is reused as much as possible, meaning it cannot be safely
+ * used again after hydrating.
+ */
+export declare function hydrateFormatJsAst(keyless: Array<Array<any>>): FormatJsNode[];
+export declare function hydrateMessages(messages: Record<string, any>): Record<string, any>;

package/dist/keyless-json.js

@@ -0,0 +1,107 @@
+"use strict";
+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.FORMAT_JS_POUND = exports.FormatJsNodeType = void 0;
+exports.hydrateFormatJsAst = hydrateFormatJsAst;
+exports.hydrateMessages = hydrateMessages;
+var FormatJsNodeType;
+(function (FormatJsNodeType) {
+    FormatJsNodeType[FormatJsNodeType["Literal"] = 0] = "Literal";
+    FormatJsNodeType[FormatJsNodeType["Argument"] = 1] = "Argument";
+    FormatJsNodeType[FormatJsNodeType["Number"] = 2] = "Number";
+    FormatJsNodeType[FormatJsNodeType["Date"] = 3] = "Date";
+    FormatJsNodeType[FormatJsNodeType["Time"] = 4] = "Time";
+    FormatJsNodeType[FormatJsNodeType["Select"] = 5] = "Select";
+    FormatJsNodeType[FormatJsNodeType["Plural"] = 6] = "Plural";
+    FormatJsNodeType[FormatJsNodeType["Pound"] = 7] = "Pound";
+    FormatJsNodeType[FormatJsNodeType["Tag"] = 8] = "Tag";
+})(FormatJsNodeType || (exports.FormatJsNodeType = FormatJsNodeType = {}));
+// Using a static object here ensures there's only one allocation for it, which
+// will likely appear in many, many messages. Freezing ensures that the shared
+// object can't be accidentally modified if a consumer tries to transform the
+// AST.
+exports.FORMAT_JS_POUND = Object.freeze({ type: 7 });
+function hydrateArray(elements) {
+    for (var i = 0; i < elements.length; i++) {
+        elements[i] = hydrateFormatJsAst(elements[i]);
+    }
+}
+function hydratePlural(keyless) {
+    var _a = __read(keyless, 5), type = _a[0], value = _a[1], options = _a[2], offset = _a[3], pluralType = _a[4];
+    // This tries to be efficient about updating the value for each option
+    // with a parsed version, reusing the same receiving object, and even
+    // the inner key within it, just replacing the end value with the
+    // parsed version.
+    // This saves multiple allocations compared to building a new object
+    // from scratch, either for the whole options object or for each value.
+    for (var key in options) {
+        hydrateArray(options[key].value);
+    }
+    // `pluralType` is technically only valid on `Plural` nodes, even
+    // though the structure is identical to `Select`.
+    if (type === FormatJsNodeType.Plural) {
+        return { type: type, value: value, options: options, offset: offset, pluralType: pluralType };
+    }
+    else {
+        return { type: type, value: value, options: options, offset: offset };
+    }
+}
+function hydrateSingle(keyless) {
+    var _a = __read(keyless, 1), type = _a[0];
+    switch (type) {
+        case FormatJsNodeType.Literal:
+        case FormatJsNodeType.Argument:
+            return { type: type, value: keyless[1] };
+        case FormatJsNodeType.Number:
+        case FormatJsNodeType.Date:
+        case FormatJsNodeType.Time:
+            return { type: type, value: keyless[1], style: keyless[2] };
+        case FormatJsNodeType.Select:
+        case FormatJsNodeType.Plural:
+            return hydratePlural(keyless);
+        case FormatJsNodeType.Pound:
+            return exports.FORMAT_JS_POUND;
+        case FormatJsNodeType.Tag: {
+            var _b = __read(keyless, 3), type_1 = _b[0], value = _b[1], children = _b[2];
+            hydrateArray(children);
+            return { type: type_1, value: value, children: children };
+        }
+        default:
+            throw new Error("FormatJS keyless JSON encountered an unknown type: ".concat(type));
+    }
+}
+function hydrateFormatJsAst(keyless) {
+    // If the first element of the array is itself an array, then we have a list
+    // of elements to parse rather than a single object.
+    if (Array.isArray(keyless[0])) {
+        hydrateArray(keyless);
+        return keyless;
+    }
+    else if (keyless.length === 0) {
+        // Some entries can be empty arrays, like an empty set of children, and those can
+        // be preserved.
+        return keyless;
+    }
+    return hydrateSingle(keyless);
+}
+function hydrateMessages(messages) {
+    for (var key in messages) {
+        messages[key] = hydrateFormatJsAst(messages[key]);
+    }
+    return messages;
+}

package/dist/message-loader.d.ts

@@ -0,0 +1,60 @@
+import { InternalIntlMessage } from './message';
+import type { MessageFormatElement } from '@formatjs/icu-messageformat-parser';
+type AnyRawMessage = string | MessageFormatElement[];
+type MessagesData = Record<string, AnyRawMessage>;
+export interface IntlMessageGetterAdditions {
+    isLocaleLoaded(locale: LocaleId): boolean;
+    onChange(callback: () => void): () => void;
+}
+export interface IntlMessageGetter extends IntlMessageGetterAdditions {
+    (locale: LocaleId): InternalIntlMessage;
+}
+type LocaleId = string;
+export type LocaleImportMap = Record<LocaleId, () => Promise<{
+    default: MessagesData;
+}>>;
+export declare class MessageLoader {
+    messageKeys: string[];
+    /** Map of locale to string key to message content. */
+    messages: Record<LocaleId, MessagesData>;
+    localeImportMap: LocaleImportMap;
+    supportedLocales: LocaleId[];
+    /**
+     * Promise representing the current locale being loaded. If this is non-null,
+     * then a request has already been made to load the locale and it is waiting
+     * to resolve.
+     */
+    _localeLoadingPromises: Record<LocaleId, Promise<{
+        default: MessagesData;
+    }> | undefined>;
+    /**
+     * Map of pre-parsed messages, keyed by the message key and locale
+     */
+    _parseCache: Map<string, InternalIntlMessage>;
+    /**
+     * List of subscribers listening for changes to the current locale and
+     * when it has loaded.
+     */
+    _subscribers: Set<() => void>;
+    fallbackMessage: InternalIntlMessage;
+    constructor(messageKeys: string[], localeImportMap: LocaleImportMap);
+    get(key: string, locale: LocaleId): InternalIntlMessage;
+    /**
+     * Returns a record mapping the keys this object manages to bound functions
+     * for `get` with the that key as the first argument, allowing consumers to
+     * just call the function with a locale to retrieve the translated message
+     * for that key.
+     */
+    getBinds(): Record<string, IntlMessageGetter>;
+    _loadLocale(locale: LocaleId): Promise<void>;
+    /**
+     * Inform subscribers that the loader state has changed and they should
+     * potentially update to get new values for messages.
+     */
+    emitChange(): void;
+    /**
+     * Subscribe to events about when a locale has loaded.
+     */
+    onChange(callback: () => void): () => void;
+}
+export {};

package/dist/message-loader.js

@@ -0,0 +1,168 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageLoader = void 0;
+var message_1 = require("./message");
+var MessageLoader = /** @class */ (function () {
+    function MessageLoader(messageKeys, localeImportMap) {
+        this.messageKeys = messageKeys;
+        this.messages = {};
+        this.localeImportMap = localeImportMap;
+        this.supportedLocales = Object.keys(localeImportMap);
+        this._localeLoadingPromises = {};
+        this._parseCache = new Map();
+        this._subscribers = new Set();
+        this.fallbackMessage = new message_1.InternalIntlMessage('THIS MESSAGE FAILED TO LOAD', 'en-US');
+    }
+    MessageLoader.prototype.get = function (key, locale) {
+        var cacheKey = key + '@' + locale;
+        var cachedValue = this._parseCache.get(cacheKey);
+        if (cachedValue != null)
+            return cachedValue;
+        if (this.messages[locale] == null) {
+            // Ensure the locale is loaded, if it is supported
+            if (this.supportedLocales.includes(locale)) {
+                this._loadLocale(locale);
+            }
+            // Otherwise, fallback to just the key value in the meantime.
+            return this.fallbackMessage;
+        }
+        // Then try to return the loaded message
+        if (key in this.messages[locale]) {
+            var content = this.messages[locale][key];
+            var message = new message_1.InternalIntlMessage(content, locale);
+            this._parseCache.set(cacheKey, message);
+            return message;
+        }
+        // And finally throw if there's no match whatsoever
+        throw new Error("Requested message ".concat(key, " does not have a value in the requested locale nor the default locale"));
+    };
+    /**
+     * Returns a record mapping the keys this object manages to bound functions
+     * for `get` with the that key as the first argument, allowing consumers to
+     * just call the function with a locale to retrieve the translated message
+     * for that key.
+     */
+    MessageLoader.prototype.getBinds = function () {
+        var _this = this;
+        var onChange = this.onChange.bind(this);
+        return this.messageKeys.reduce(function (acc, key) {
+            var bound = _this.get.bind(_this, key);
+            bound.onChange = onChange;
+            acc[key] = bound;
+            return acc;
+        }, {});
+    };
+    MessageLoader.prototype._loadLocale = function (locale) {
+        return __awaiter(this, void 0, void 0, function () {
+            var loadStart, loadingPromise, _a, _b, loadEnd;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        // Don't re-load a locale that's already in progress.
+                        if (this._localeLoadingPromises[locale] != null) {
+                            return [2 /*return*/];
+                        }
+                        // Safety check in case the locale map doesn't include a require for the
+                        // requested locale. Shouldn't happen, but throwing here is much more
+                        // contextual than whatever error would result otherwise.
+                        if (this.localeImportMap[locale] == null) {
+                            throw new Error("Requested to load locale ".concat(locale, ", which should be supported, but no source for translation data was provided."));
+                        }
+                        // 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*/];
+                        loadStart = performance.now();
+                        loadingPromise = this.localeImportMap[locale]();
+                        this._localeLoadingPromises[locale] = loadingPromise;
+                        _a = this.messages;
+                        _b = locale;
+                        return [4 /*yield*/, loadingPromise];
+                    case 1:
+                        _a[_b] = (_c.sent()).default;
+                        delete this._localeLoadingPromises[locale];
+                        loadEnd = performance.now();
+                        console.warn("[INTL] Took ".concat(loadEnd - loadStart, "ms to load ").concat(locale, " with ").concat(Object.keys(this.messages[locale]).length, " keys"));
+                        this.emitChange();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Inform subscribers that the loader state has changed and they should
+     * potentially update to get new values for messages.
+     */
+    MessageLoader.prototype.emitChange = function () {
+        var e_1, _a;
+        try {
+            for (var _b = __values(this._subscribers.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var callback = _c.value;
+                callback();
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    /**
+     * Subscribe to events about when a locale has loaded.
+     */
+    MessageLoader.prototype.onChange = function (callback) {
+        var _this = this;
+        this._subscribers.add(callback);
+        return function () { return _this._subscribers.delete(callback); };
+    };
+    return MessageLoader;
+}());
+exports.MessageLoader = MessageLoader;

package/dist/message.d.ts

@@ -0,0 +1,41 @@
+import { Formats, Formatters, MessageFormatPart } from 'intl-messageformat';
+import type { MessageFormatElement } from '@formatjs/icu-messageformat-parser';
+export declare class InternalIntlMessage {
+    locale: string;
+    message?: string;
+    ast: MessageFormatElement[];
+    /**
+     * 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`).
+     */
+    plainAst?: MessageFormatElement[];
+    constructor(messageOrAst: string | MessageFormatElement[], locale: string);
+    /**
+     * Format this message with the given locale into an AST of chunks that can
+     * then be used or rendered into strings, React elements, or anything else as
+     * needed.
+     */
+    formatToParts<T>(formatters: Formatters, formats: Formats, values?: Record<string, any>): Array<MessageFormatPart<T>>;
+    /**
+     * Formats this message just like `formatToParts`, but strips all stylistic
+     * elements and tags and returns a plain string with only the literal text of
+     * the message remaining.
+     *
+     * This method works by quickly scanning the string and removing any tag
+     * elements, formatting, then concatenating the pieces into a single result.
+     *
+     * Note that this function does _not_ handle serializing values other than
+     * plain/primitive values into strings. All values are simply converted using
+     * the `String()` constructor. So, for example, passing a function as a value
+     * will directly serialize the function definition into a string, rather than
+     * calling the function or evaluating the result.
+     */
+    formatToPlainString(formatters: Formatters, formats: Formats, values?: Record<string, any>): 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.
+     */
+    _removeRichTags(element: MessageFormatElement): MessageFormatElement[];
+}