@discord/intl 0.5.2 → 0.6.0

package/dist/message-loader.js

@@ -8,70 +8,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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.");
-};
-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.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) {
-        var e_1, _a;
-        var _this = this;
+const message_1 = require("./message");
+class MessageLoader {
+    constructor(messageKeys, localeImportMap, defaultLocale) {
         this.messageKeys = messageKeys;
         this.messages = {};
         this.localeImportMap = localeImportMap;
@@ -86,32 +30,12 @@ var MessageLoader = /** @class */ (function () {
         // 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) {
+            for (const [locale, file] of Object.entries(localeImportMap)) {
                 // @ts-expect-error `hot` not defined in types.
-                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()) {
-                    var _d = __read(_c.value, 2), locale = _d[0], file = _d[1];
-                    _loop_1(locale, file);
-                }
-            }
-            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; }
+                module.hot.accept(file, () => __awaiter(this, void 0, void 0, function* () {
+                    yield this._loadLocale(locale);
+                    this._parseCache.clear();
+                }));
             }
         }
     }
@@ -122,25 +46,25 @@ var MessageLoader = /** @class */ (function () {
      * @param {Record<string, string>} keyMap
      * @param {Record<string, string>} localeFileMap
      */
-    MessageLoader.prototype.withDebugValues = function (keyMap, localeFileMap) {
+    withDebugValues(keyMap, localeFileMap) {
         this._debugKeyMap = keyMap;
         this._localeFileMap = localeFileMap;
-    };
-    MessageLoader.prototype.get = function (key, locale) {
+    }
+    get(key, locale) {
         var _a;
-        var value = (_a = this.getMessageValue(key, locale)) !== null && _a !== void 0 ? _a : this.getMessageValue(key, this.defaultLocale);
+        const value = (_a = this.getMessageValue(key, locale)) !== null && _a !== void 0 ? _a : this.getMessageValue(key, this.defaultLocale);
         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;
-        var requestedLocale = this._localeFileMap != null ? "".concat(locale, " (").concat(this._localeFileMap[locale], ")") : locale;
-        var defaultLocale = this._localeFileMap != null
-            ? "".concat(this.defaultLocale, " (").concat(this._localeFileMap[this.defaultLocale], ")")
+        const errorKey = this._debugKeyMap != null ? `"${this._debugKeyMap[key]}" (${key})` : undefined;
+        const requestedLocale = this._localeFileMap != null ? `${locale} (${this._localeFileMap[locale]})` : locale;
+        const defaultLocale = this._localeFileMap != null
+            ? `${this.defaultLocale} (${this._localeFileMap[this.defaultLocale]})`
             : this.defaultLocale;
-        console.warn("Requested message ".concat(errorKey, " does not have a value in the requested locale ").concat(requestedLocale, " nor the default locale ").concat(defaultLocale));
+        console.warn(`Requested message ${errorKey} does not have a value in the requested locale ${requestedLocale} nor the default locale ${defaultLocale}`);
         return this.fallbackMessage;
-    };
+    }
     /**
      * Return the value of the message with the given `key` in the given `locale`. If the message has
      * no value in that locale, this function returns `undefined`.
@@ -150,9 +74,9 @@ var MessageLoader = /** @class */ (function () {
      * function will trigger a load for that locale, but will not wait for it to resolve before
      * returning.
      */
-    MessageLoader.prototype.getMessageValue = function (key, locale) {
-        var cacheKey = key + '@' + locale;
-        var cachedValue = this._parseCache.get(cacheKey);
+    getMessageValue(key, locale) {
+        const cacheKey = key + '@' + locale;
+        const cachedValue = this._parseCache.get(cacheKey);
         if (cachedValue != null)
             return cachedValue;
         // Check whether the locale exists in memory. If not, start a request to
@@ -167,102 +91,77 @@ var MessageLoader = /** @class */ (function () {
         }
         // 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);
+            const content = this.messages[locale][key];
+            const message = new message_1.InternalIntlMessage(content, locale);
             this._parseCache.set(cacheKey, message);
             return message;
         }
         // Otherwise just assume it doesn't exist.
         return undefined;
-    };
+    }
     /**
      * 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 Object.keys(this.messageKeys).reduce(function (acc, key) {
-            var bound = _this.get.bind(_this, key);
+    getBinds() {
+        const onChange = this.onChange.bind(this);
+        return Object.keys(this.messageKeys).reduce((acc, key) => {
+            const 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 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 (((_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
-                        // requested locale. Shouldn't happen, but throwing here is much more
-                        // contextual than whatever error would result otherwise.
-                        if (this.localeImportMap[locale] == null) {
-                            if (this.supportedLocales.includes(locale)) {
-                                // `supportedLocales` is determined by the `localeImportMap`, so if it's present but
-                                // nullish, it's almost definitely a configuration error and deserves to be reported loudly.
-                                throw new Error("Requested to load locale ".concat(locale, ", which should be supported, but no source for translation data was provided."));
-                            }
-                            else {
-                                return [2 /*return*/];
-                            }
-                        }
-                        // 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*/];
-                        current = this.localeImportMap[locale]();
-                        this._localeLoadingPromises[locale] = { initialized: false, current: current };
-                        _a = this.messages;
-                        _b = locale;
-                        return [4 /*yield*/, current];
-                    case 1:
-                        _a[_b] = (_d.sent()).default;
-                        this._localeLoadingPromises[locale] = { initialized: true, current: undefined };
-                        this.emitChange();
-                        return [2 /*return*/];
+    }
+    _loadLocale(locale) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // Don't re-load a locale that's already in progress.
+            if (((_a = this._localeLoadingPromises[locale]) === null || _a === void 0 ? void 0 : _a.current) != null) {
+                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) {
+                if (this.supportedLocales.includes(locale)) {
+                    // `supportedLocales` is determined by the `localeImportMap`, so if it's present but
+                    // nullish, it's almost definitely a configuration error and deserves to be reported loudly.
+                    throw new Error(`Requested to load locale ${locale}, which should be supported, but no source for translation data was provided.`);
                 }
-            });
+                else {
+                    return;
+                }
+            }
+            // If the locale is already set in `messages`, then it doesn't need to be loaded again.
+            if (this.messages[locale] != null)
+                return;
+            const current = this.localeImportMap[locale]();
+            this._localeLoadingPromises[locale] = { initialized: false, current };
+            this.messages[locale] = (yield current).default;
+            this._localeLoadingPromises[locale] = { initialized: true, current: undefined };
+            this.emitChange();
         });
-    };
+    }
     /**
      * 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_2, _a;
-        try {
-            for (var _b = __values(this._subscribers.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var callback = _c.value;
-                callback();
-            }
+    emitChange() {
+        for (const callback of this._subscribers.values()) {
+            callback();
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-    };
+    }
     /**
      * Subscribe to events about when a locale has loaded.
      */
-    MessageLoader.prototype.onChange = function (callback) {
-        var _this = this;
+    onChange(callback) {
         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];
+        return () => this._subscribers.delete(callback);
+    }
+    isLocaleLoaded(locale, requireCurrent = false) {
+        const ref = this._localeLoadingPromises[locale];
         // Ensure the locale at least exists and is initialized.
         if (ref == null || ref.initialized == false)
             return false;
@@ -272,68 +171,44 @@ var MessageLoader = /** @class */ (function () {
             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*/];
-                }
-            });
+    }
+    waitForLocaleLoaded(locale_1) {
+        return __awaiter(this, arguments, void 0, function* (locale, requireCurrent = false) {
+            const 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 this._loadLocale(locale);
+            // If initialization is enough for this request, just resolve immediately.
+            if (ref.initialized && !requireCurrent)
+                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`.
+            yield ref.current;
         });
-    };
+    }
     /**
      * 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)];
-            });
+    waitForDefaultLocale() {
+        return __awaiter(this, arguments, void 0, function* (requireCurrent = false) {
+            return this.waitForLocaleLoaded(this.defaultLocale, requireCurrent);
         });
-    };
-    return MessageLoader;
-}());
+    }
+}
 exports.MessageLoader = MessageLoader;
-var LOADER_REGISTRY = [];
+const 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*/];
-            }
-        });
+    return __awaiter(this, void 0, void 0, function* () {
+        yield Promise.all(LOADER_REGISTRY.map((loader) => loader._loadLocale(locale)));
     });
 }
 /**
@@ -347,15 +222,8 @@ function loadAllMessagesInLocale(locale) {
  * 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*/];
-            }
-        });
+    return __awaiter(this, void 0, void 0, function* () {
+        yield Promise.all(LOADER_REGISTRY.map((loader) => loader.waitForDefaultLocale()));
     });
 }
 /**
@@ -364,7 +232,7 @@ function waitForAllDefaultIntlMessagesLoaded() {
  * message defined in `messageKeys`.
  */
 function createLoader(messageKeys, localeImportMap, defaultLocale) {
-    var loader = new MessageLoader(messageKeys, localeImportMap, defaultLocale);
+    const loader = new MessageLoader(messageKeys, localeImportMap, defaultLocale);
     LOADER_REGISTRY.push(loader);
     return loader;
 }

package/dist/message.d.ts

@@ -1,8 +1,8 @@
-import { FormatJsNode } from './keyless-json';
+import { AstNode, FullFormatJsNode } from '@discord/intl-ast';
 export declare class InternalIntlMessage {
     locale: string;
-    ast: FormatJsNode[];
-    constructor(messageOrAst: FormatJsNode[], locale: string);
+    ast: AstNode[];
+    constructor(messageOrAst: AstNode[] | FullFormatJsNode[], locale: string);
     /**
      * Return a stringified serialization of this message's AST, with no
      * formatting or values applied.