@discord/intl 0.5.2 → 0.6.0

package/dist/formatters/react.js

@@ -1,63 +1,20 @@
 "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;
+const React = require("react");
+const format_1 = require("../format");
+const h = React.createElement;
 exports.DEFAULT_REACT_RICH_TEXT_ELEMENTS = {
-    $_: function () { return ''; },
-    $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); },
+    $_: () => '',
+    $b: (content, key) => h('strong', { key }, content),
+    $i: (content, key) => h('em', { key }, content),
+    $del: (content, key) => h('del', { key }, content),
+    $code: (content, key) => h('code', { key }, content),
     // $link will always be [href, <empty>, ...content]
-    $link: function (_a, key) {
-        var _b = __read(_a), href = _b[0], content = _b.slice(1);
-        return h('a', { href: href, key: key }, content);
-    },
-    $p: function (content, key) { return h('p', { key: key }, content); },
+    $link: ([href, ...content], key) => h('a', { href, key }, content),
+    $p: (content, key) => h('p', { key }, content),
 };
 /**
  * Creates a new `FormatBuilder` class that constructs a React element tree
@@ -67,36 +24,33 @@ exports.DEFAULT_REACT_RICH_TEXT_ELEMENTS = {
  * @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._nodeKey = 0;
-            _this.result = [];
-            return _this;
+    return class extends format_1.FormatBuilder {
+        constructor() {
+            super(...arguments);
+            this._nodeKey = 0;
+            this.result = [];
         }
-        class_1.prototype.pushRichTextTag = function (tag, children) {
-            this.result.push(richTextElements[tag](children, "".concat(this._nodeKey++)));
-        };
-        class_1.prototype.pushLiteralText = function (text) {
+        pushRichTextTag(tag, children) {
+            this.result.push(richTextElements[tag](children, `${this._nodeKey++}`));
+        }
+        pushLiteralText(text) {
             this.result.push(text);
-        };
-        class_1.prototype.pushObject = function (value) {
+        }
+        pushObject(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 () {
+        }
+        finish() {
             return this.result;
-        };
-        return class_1;
-    }(format_1.FormatBuilder));
+        }
+    };
 }
 function formatReact(message, values, Builder) {
     if (typeof message === 'string') {
         return [message];
     }
-    var parts = this.bindFormatValues(Builder, message, values);
+    const parts = this.bindFormatValues(Builder, message, values);
     return parts;
 }
 /**

package/dist/formatters/string.js

@@ -1,56 +1,14 @@
 "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;
+const format_1 = require("../format");
+class StringBuilder extends format_1.FormatBuilder {
+    constructor() {
+        super(...arguments);
+        this.result = '';
     }
-    StringBuilder.prototype.pushRichTextTag = function (tag, children) {
+    pushRichTextTag(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
@@ -60,27 +18,26 @@ var StringBuilder = /** @class */ (function (_super) {
             return;
         }
         this.result += children.join('');
-    };
-    StringBuilder.prototype.pushLiteralText = function (text) {
+    }
+    pushLiteralText(text) {
         this.result += text;
-    };
-    StringBuilder.prototype.pushObject = function (value) {
+    }
+    pushObject(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 (value != null && 'toString' in value) {
             this.result += value.toString();
         }
-    };
-    StringBuilder.prototype.finish = function () {
+    }
+    finish() {
         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);
+    const result = this.bindFormatValues(StringBuilder, message, values);
     // StringBuilder always creates a single element array with the string value.
     return result[0];
 }

package/dist/hash.js

@@ -1,21 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runtimeHashMessageKey = runtimeHashMessageKey;
-var xxhash64_1 = require("@intrnl/xxhash64");
-var BASE64_TABLE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');
-var IS_BIG_ENDIAN = (function () {
-    var array = new Uint8Array(4);
-    var view = new Uint32Array(array.buffer);
+const xxhash64_1 = require("@intrnl/xxhash64");
+const BASE64_TABLE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');
+const IS_BIG_ENDIAN = (() => {
+    const array = new Uint8Array(4);
+    const view = new Uint32Array(array.buffer);
     return !((view[0] = 1) & array[0]);
 })();
 function numberToBytes(number) {
     number = BigInt(number);
-    var array = [];
-    var byteCount = Math.ceil(Math.floor(Math.log2(Number(number)) + 1) / 8);
-    for (var i = 0; i < byteCount; i++) {
+    const array = [];
+    const byteCount = Math.ceil(Math.floor(Math.log2(Number(number)) + 1) / 8);
+    for (let i = 0; i < byteCount; i++) {
         array.unshift(Number((number >> BigInt(8 * i)) & BigInt(255)));
     }
-    var bytes = new Uint8Array(array);
+    const bytes = new Uint8Array(array);
     // The native `hashToMessageKey` always works in Big/Network Endian bytes, so this array
     // needs to be converted to the same endianness to get the same base64 result.
     return IS_BIG_ENDIAN ? bytes : bytes.reverse();
@@ -28,8 +28,8 @@ function numberToBytes(number) {
  * `@discord/intl-loader-core`, to be able to hash names at runtime.
  */
 function runtimeHashMessageKey(key) {
-    var hash = (0, xxhash64_1.hash)(key, 0);
-    var bytes = numberToBytes(hash);
+    const hash = (0, xxhash64_1.hash)(key, 0);
+    const bytes = numberToBytes(hash);
     return [
         BASE64_TABLE[bytes[0] >> 2],
         BASE64_TABLE[((bytes[0] & 0x03) << 4) | (bytes[1] >> 4)],

package/dist/intl-manager.js

@@ -1,58 +1,30 @@
 "use strict";
-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.IntlManager = exports.DEFAULT_LOCALE = void 0;
-var intl_1 = require("@formatjs/intl");
-var format_1 = require("./format");
-var format_config_1 = require("./format-config");
+const intl_ast_1 = require("@discord/intl-ast");
+const intl_1 = require("@formatjs/intl");
+const format_1 = require("./format");
+const format_config_1 = require("./format-config");
 /**
  * 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) {
-        if (defaultLocale === void 0) { defaultLocale = exports.DEFAULT_LOCALE; }
-        var _this = this;
+class IntlManager {
+    constructor(defaultLocale = exports.DEFAULT_LOCALE) {
         /**
          * 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.onLocaleChange = (callback) => {
+            this._localeSubscriptions.add(callback);
+            return () => this._localeSubscriptions.delete(callback);
         };
         this.defaultLocale = defaultLocale;
         this.currentLocale = defaultLocale;
         this.formatConfig = format_config_1.DEFAULT_FORMAT_CONFIG;
         this.intl = (0, intl_1.createIntl)({
             formats: format_config_1.DEFAULT_FORMAT_CONFIG,
-            defaultLocale: defaultLocale,
+            defaultLocale,
             locale: defaultLocale,
         });
         this._localeSubscriptions = new Set();
@@ -61,74 +33,52 @@ var IntlManager = /** @class */ (function () {
      * Add a set of formatter implementations to this manager, making each available as a direct
      * property
      */
-    IntlManager.prototype.withFormatters = function (formatters) {
-        var e_1, _a;
-        try {
-            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 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_1) throw e_1.error; }
+    withFormatters(formatters) {
+        for (const [name, formatter] of Object.entries(formatters)) {
+            this[name] = this.makeFormatFunction(formatter);
         }
         return this;
-    };
+    }
     /**
      * 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);
+    makeFormatFunction({ format, builder, }) {
+        const formatter = format.bind(this);
+        return (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) {
+    setLocale(locale) {
         this.currentLocale = locale;
-        this.intl = (0, intl_1.createIntl)({ defaultLocale: this.defaultLocale, locale: locale });
+        this.intl = (0, intl_1.createIntl)({ defaultLocale: this.defaultLocale, locale });
         this.emitLocaleChange(locale);
-    };
-    IntlManager.prototype.emitLocaleChange = function (locale) {
-        var e_2, _a;
-        try {
-            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 (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_2) throw e_2.error; }
+    }
+    emitLocaleChange(locale) {
+        for (const callback of this._localeSubscriptions) {
+            callback(locale);
         }
-    };
+    }
     /**
      * 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) {
-        var resolved = message(this.currentLocale);
+    string(message) {
+        const 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;
-    };
+        // As it stands, this is _technically_ typed as string | undefined, even though
+        // TypeScript doesn't actually complain about it.
+        return resolved.ast[0][intl_ast_1.AstNodeIndices.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
@@ -138,15 +88,14 @@ var IntlManager = /** @class */ (function () {
      * This should rarely be necessary outside of sending raw messages to other
      * applications that do their own message parsing.
      */
-    IntlManager.prototype.reserialize = function (message) {
-        var resolved = message(this.currentLocale);
+    reserialize(message) {
+        const resolved = message(this.currentLocale);
         if (typeof resolved === 'string')
             return resolved;
         return resolved.reserialize();
-    };
-    IntlManager.prototype.bindFormatValues = function (Builder, message, values) {
+    }
+    bindFormatValues(Builder, message, values) {
         return (0, format_1.bindFormatValues)(Builder, message.ast, [this.currentLocale, this.defaultLocale], this.intl.formatters, this.formatConfig, values);
-    };
-    return IntlManager;
-}());
+    }
+}
 exports.IntlManager = IntlManager;

package/dist/message-loader.d.ts

@@ -1,6 +1,12 @@
-import { FormatJsNode } from './keyless-json';
+import { AstNode, FullFormatJsNode } from '@discord/intl-ast';
 import { InternalIntlMessage } from './message';
-type MessagesData = Record<string, FormatJsNode[]>;
+/**
+ * Type representing the serialized content of a translations file, which is a record of hashed
+ * message keys to their AST structure. This type represents both compressed, keyless AstNodes as
+ * well as fully-typed, object FullFormatJsNodes as the message content, since either can be given
+ * depending on the configuration of the bundler/compiler.
+ */
+type MessagesData = Record<string, AstNode[] | FullFormatJsNode[]>;
 export interface IntlMessageGetterAdditions {
     onChange(callback: () => void): () => void;
 }