@discord/intl 0.2.0 → 0.2.1-canary.11837d1

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.
@@ -49,7 +50,7 @@ var FormatBuilder = /** @class */ (function () {
 exports.FormatBuilder = FormatBuilder;
 function bindFormatValuesWithBuilder(builder, nodes, locales, formatters, formats, values, currentPluralValue, originalMessage) {
     var e_1, _a;
-    var _b;
+    var _b, _c;
     if (values === void 0) { values = {}; }
     // Hot path for static messages that are just parsed as a single string element.
     if (nodes.length === 1 && nodes[0].type === keyless_json_1.FormatJsNodeType.Literal) {
@@ -57,7 +58,7 @@ function bindFormatValuesWithBuilder(builder, nodes, locales, formatters, format
         return;
     }
     var _loop_1 = function (node) {
-        var e_2, _c;
+        var e_2, _d;
         switch (node.type) {
             case keyless_json_1.FormatJsNodeType.Literal:
                 builder.pushLiteralText(node.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,14 @@ 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();
-                // @ts-expect-error Support `scale` style property.
-                var scaledValue = value;
-                // const scaledValue = (value as number) * (style?.scale ?? 1);
+                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;
+                var scaledValue = 
+                // @ts-expect-error This is a weird cast that's not accurate, but works in the short term.
+                typeof value !== 'number' ? value : ((_b = value * (style === null || style === void 0 ? void 0 : style.scale)) !== null && _b !== void 0 ? _b : 1);
                 builder.pushLiteralText(formatters.getNumberFormat(locales, style).format(scaledValue));
                 break;
             }
@@ -155,7 +159,7 @@ function bindFormatValuesWithBuilder(builder, nodes, locales, formatters, format
                     catch (e_2_1) { e_2 = { error: e_2_1 }; }
                     finally {
                         try {
-                            if (chunks_1_1 && !chunks_1_1.done && (_c = chunks_1.return)) _c.call(chunks_1);
+                            if (chunks_1_1 && !chunks_1_1.done && (_d = chunks_1.return)) _d.call(chunks_1);
                         }
                         finally { if (e_2) throw e_2.error; }
                     }
@@ -187,7 +191,7 @@ function bindFormatValuesWithBuilder(builder, nodes, locales, formatters, format
                 }
                 bindFormatValuesWithBuilder(builder, option.value, locales, formatters, formats, values, 
                 // @ts-expect-error assert this `as number` properly.
-                value - ((_b = node.offset) !== null && _b !== void 0 ? _b : 0));
+                value - ((_c = node.offset) !== null && _c !== void 0 ? _c : 0));
                 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/formatters/string.js

@@ -67,7 +67,7 @@ var StringBuilder = /** @class */ (function (_super) {
     StringBuilder.prototype.pushObject = function (value) {
         // Objects are only included in the result if they specify a toString value directly.
         // Otherwise, they would be rendered as `[object Object]`, which is never helpful.
-        if ('toString' in value) {
+        if (value != null && 'toString' in value) {
             this.result += value.toString();
         }
     };

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 {};