@discord/intl 0.1.2 → 0.2.0-canary.cad566b

package/dist/format.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The core formatter, responsible for applying values to placeholders in
+ * messages and creating a static CST from the result. This method does _not_
+ * replace any of the rich-text formatting values (e.g., `$b` or `$link`) and
+ * leaves those to final formatters to apply as appropriate for the context
+ * of where the message is being rendered (e.g., React versus a plain string).
+ *
+ * The majority of this method is lifted from FormatJS' own `formatToParts`
+ * implementation, but is abstracted here to provide a few benefits:
+ * - working with the keyless AST format rather than having to transpose to the
+ *   exact object format that FormatJS expects.
+ * - understanding the difference between rich text formatting values and
+ *   user-provided values.
+ * - provide extra options related to the above for more control over how
+ *   formatting operates, while abstracting out some of the common values.
+ * - adding extra context for hook and link functions to provide a `key`
+ *   parameter, important to have React treat the resulting elements nicely.
+ */
+import { FormatJsNode } from './keyless-json';
+import { Formats, Formatters } from 'intl-messageformat';
+import { RichTextTagNames } from './types';
+export declare abstract class FormatBuilder<Result> {
+    abstract pushRichTextTag(tag: RichTextTagNames, children: Result[]): void;
+    abstract pushLiteralText(text: string): void;
+    abstract pushObject(value: object): void;
+    abstract finish(): Result[];
+}
+export type FormatBuilderConstructor<Result> = new () => FormatBuilder<Result>;
+export declare function bindFormatValuesWithBuilder<T, Builder extends FormatBuilder<T>>(builder: Builder, nodes: FormatJsNode[], locales: string | string[], formatters: Formatters, formats: Formats, values?: Record<string, string | object>, currentPluralValue?: number, originalMessage?: string): void;
+export declare function bindFormatValues<Result>(Builder: FormatBuilderConstructor<Result>, nodes: FormatJsNode[], locales: string | string[], formatters: Formatters, formats: Formats, values?: Record<string, string | object>, currentPluralValue?: number): Result[];

package/dist/format.js

@@ -0,0 +1,214 @@
+"use strict";
+/**
+ * The core formatter, responsible for applying values to placeholders in
+ * messages and creating a static CST from the result. This method does _not_
+ * replace any of the rich-text formatting values (e.g., `$b` or `$link`) and
+ * leaves those to final formatters to apply as appropriate for the context
+ * of where the message is being rendered (e.g., React versus a plain string).
+ *
+ * The majority of this method is lifted from FormatJS' own `formatToParts`
+ * implementation, but is abstracted here to provide a few benefits:
+ * - working with the keyless AST format rather than having to transpose to the
+ *   exact object format that FormatJS expects.
+ * - understanding the difference between rich text formatting values and
+ *   user-provided values.
+ * - provide extra options related to the above for more control over how
+ *   formatting operates, while abstracting out some of the common values.
+ * - adding extra context for hook and link functions to provide a `key`
+ *   parameter, important to have React treat the resulting elements nicely.
+ */
+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.FormatBuilder = void 0;
+exports.bindFormatValuesWithBuilder = bindFormatValuesWithBuilder;
+exports.bindFormatValues = bindFormatValues;
+var keyless_json_1 = require("./keyless-json");
+var intl_messageformat_1 = require("intl-messageformat");
+/**
+ * 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.
+ */
+function isRichTextTag(name) {
+    return name[0] === '$';
+}
+var FormatBuilder = /** @class */ (function () {
+    function FormatBuilder() {
+    }
+    return FormatBuilder;
+}());
+exports.FormatBuilder = FormatBuilder;
+function bindFormatValuesWithBuilder(builder, nodes, locales, formatters, formats, values, currentPluralValue, originalMessage) {
+    var e_1, _a;
+    var _b;
+    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) {
+        builder.pushLiteralText(nodes[0].value);
+        return;
+    }
+    var _loop_1 = function (node) {
+        var e_2, _c;
+        switch (node.type) {
+            case keyless_json_1.FormatJsNodeType.Literal:
+                builder.pushLiteralText(node.value);
+                return "continue";
+            case keyless_json_1.FormatJsNodeType.Pound:
+                // Replace `#` in plural rules with the actual numeric value. Only
+                // numeric values are replaced, otherwise the value is completed ignored?
+                // Behavior copied from FormatJS directly.
+                if (typeof currentPluralValue === 'number') {
+                    var value_1 = formatters.getNumberFormat(locales).format(currentPluralValue);
+                    builder.pushLiteralText(value_1);
+                }
+                return "continue";
+        }
+        var variableName = node.value;
+        // Enforce that all required values are provided by the caller, even if the
+        // actual value is falsy/undefined.
+        if (!(variableName in values) && !isRichTextTag(variableName)) {
+            throw new intl_messageformat_1.MissingValueError(variableName, originalMessage);
+        }
+        var value = values[variableName];
+        switch (node.type) {
+            case keyless_json_1.FormatJsNodeType.Argument:
+                // Empty values don't need to be added at all, they are purely for AST representation.
+                if (variableName == '$_')
+                    break;
+                if (typeof value === 'object') {
+                    builder.pushObject(value);
+                }
+                else {
+                    // Taken from FormatJS: non-objects (strings, numbers, and falsy
+                    // values) all get cast to strings immediately as literal nodes.
+                    builder.pushLiteralText(String(value));
+                }
+                break;
+            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();
+                // @ts-expect-error Cast string values to dates properly.
+                builder.pushLiteralText(formatters.getDateTimeFormat(locales, style).format(value));
+                break;
+            }
+            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();
+                builder.pushLiteralText(
+                // @ts-expect-error Cast string values to dates properly.
+                formatters.getDateTimeFormat(locales, style).format(value));
+                break;
+            }
+            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);
+                builder.pushLiteralText(formatters.getNumberFormat(locales, style).format(scaledValue));
+                break;
+            }
+            case keyless_json_1.FormatJsNodeType.Tag: {
+                var children = node.children;
+                var appliedChildren = bindFormatValues(builder.constructor, children, locales, formatters, formats, values, currentPluralValue);
+                if (isRichTextTag(variableName)) {
+                    builder.pushRichTextTag(variableName, appliedChildren);
+                }
+                else {
+                    if (typeof value !== 'function') {
+                        throw "expected a function type for a Tag formatting value, ".concat(variableName, ". got ").concat(typeof value, ": ").concat(value);
+                    }
+                    var chunks = value(appliedChildren);
+                    chunks = Array.isArray(chunks) ? chunks : [chunks];
+                    try {
+                        for (var chunks_1 = (e_2 = void 0, __values(chunks)), chunks_1_1 = chunks_1.next(); !chunks_1_1.done; chunks_1_1 = chunks_1.next()) {
+                            var chunk = chunks_1_1.value;
+                            if (typeof chunk === 'string') {
+                                builder.pushLiteralText(chunk);
+                            }
+                            else {
+                                builder.pushObject(chunk);
+                            }
+                        }
+                    }
+                    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);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                }
+                break;
+            }
+            case keyless_json_1.FormatJsNodeType.Select: {
+                var option = node.value in node.options ? node.options[node.value] : node.options.other;
+                if (option == null) {
+                    throw "".concat(node.value, " is not a known option for select value ").concat(variableName, ". Valid options are ").concat(Object.keys(node.options).join(', '));
+                }
+                bindFormatValuesWithBuilder(builder, option.value, locales, formatters, formats, values);
+                break;
+            }
+            case keyless_json_1.FormatJsNodeType.Plural: {
+                var option = (function () {
+                    var _a, _b;
+                    var exactSelector = "=".concat(value);
+                    if (exactSelector in node.options)
+                        return node.options[exactSelector];
+                    var rule = formatters
+                        .getPluralRules(locales, { type: node.pluralType })
+                        // @ts-expect-error Assert this `as number` properly.
+                        .select(value - ((_a = node.offset) !== null && _a !== void 0 ? _a : 0));
+                    return (_b = node.options[rule]) !== null && _b !== void 0 ? _b : node.options.other;
+                })();
+                if (option == null) {
+                    throw "".concat(node.value, " is not a known option for plural value ").concat(variableName, ". Valid options are ").concat(Object.keys(node.options).join(', '));
+                }
+                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));
+                break;
+            }
+        }
+    };
+    try {
+        for (var nodes_1 = __values(nodes), nodes_1_1 = nodes_1.next(); !nodes_1_1.done; nodes_1_1 = nodes_1.next()) {
+            var node = nodes_1_1.value;
+            _loop_1(node);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (nodes_1_1 && !nodes_1_1.done && (_a = nodes_1.return)) _a.call(nodes_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}
+function bindFormatValues(Builder, nodes, locales, formatters, formats, values, currentPluralValue) {
+    if (values === void 0) { values = {}; }
+    var builder = new Builder();
+    bindFormatValuesWithBuilder(builder, nodes, locales, formatters, formats, values, currentPluralValue);
+    return builder.finish();
+}

package/dist/formatters/ast.d.ts

@@ -0,0 +1,67 @@
+import { AnyIntlMessage, FormatterImplementation, FunctionTypes } from '../types';
+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 declare enum RichTextNodeType {
+    Text = "text",
+    Strong = "strong",
+    Emphasis = "emphasis",
+    Code = "code",
+    Link = "link",
+    Paragraph = "paragraph",
+    /**
+     * A special extension for when the value of a placeholder is an object.
+     * Rather than casting to a string here, the object is preserved as-is for a
+     * future formatter to render as appropriate (i.e., using an object as a
+     * value when formatting to an AST should keep that object structure so that
+     * the final AST is accurate for what the user expects, but when rendering to
+     * a plain string, the final formatter can just cast that object to a string
+     * using its `toString` method or some other mechanism).
+     */
+    Object = "object"
+}
+interface RichTextNodeBase<ContentType> {
+    type: RichTextNodeType;
+    content: ContentType;
+}
+interface RichTextTextNode extends RichTextNodeBase<string> {
+    type: RichTextNodeType.Text;
+}
+interface RichTextStrongNode extends RichTextNodeBase<RichTextNode[]> {
+    type: RichTextNodeType.Strong;
+}
+interface RichTextEmphasisNode extends RichTextNodeBase<RichTextNode[]> {
+    type: RichTextNodeType.Emphasis;
+}
+interface RichTextCodeNode extends RichTextNodeBase<RichTextNode[]> {
+    type: RichTextNodeType.Code;
+}
+interface RichTextParagraphNode extends RichTextNodeBase<RichTextNode[]> {
+    type: RichTextNodeType.Paragraph;
+}
+interface RichTextLinkNode extends RichTextNodeBase<RichTextNode[]> {
+    type: RichTextNodeType.Link;
+    target: string;
+}
+interface RichTextObjectNode extends RichTextNodeBase<object> {
+    type: RichTextNodeType.Object;
+}
+export type RichTextNode = RichTextTextNode | RichTextStrongNode | RichTextEmphasisNode | 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
+ * 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.
+ */
+export declare function formatToAst(this: IntlManager, message: AnyIntlMessage, values: object): RichTextNode[];
+export declare const astFormatter: FormatterImplementation<AstFunctionTypes, RichTextNode[]>;
+export {};

package/dist/formatters/ast.js

@@ -0,0 +1,148 @@
+"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.astFormatter = exports.RichTextNodeType = void 0;
+exports.formatToAst = formatToAst;
+var format_1 = require("../format");
+// This structure aims to match `simple-markdown`'s AST, but that type is very
+// loosely defined as just "type" and "arbitrary map of content". This is more
+// explicit and type-safe.
+var RichTextNodeType;
+(function (RichTextNodeType) {
+    RichTextNodeType["Text"] = "text";
+    RichTextNodeType["Strong"] = "strong";
+    RichTextNodeType["Emphasis"] = "emphasis";
+    RichTextNodeType["Code"] = "code";
+    RichTextNodeType["Link"] = "link";
+    RichTextNodeType["Paragraph"] = "paragraph";
+    /**
+     * A special extension for when the value of a placeholder is an object.
+     * Rather than casting to a string here, the object is preserved as-is for a
+     * future formatter to render as appropriate (i.e., using an object as a
+     * value when formatting to an AST should keep that object structure so that
+     * the final AST is accurate for what the user expects, but when rendering to
+     * a plain string, the final formatter can just cast that object to a string
+     * using its `toString` method or some other mechanism).
+     */
+    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 }); },
+    $link: function (_a) {
+        var _b = __read(_a), target = _b[0], content = _b.slice(1);
+        return ({
+            type: RichTextNodeType.Link,
+            target: target.content,
+            content: content,
+        });
+    },
+    $p: function (content) { return ({ type: RichTextNodeType.Paragraph, content: content }); },
+};
+var AstBuilder = /** @class */ (function (_super) {
+    __extends(AstBuilder, _super);
+    function AstBuilder() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.result = [];
+        return _this;
+    }
+    AstBuilder.prototype.pushRichTextTag = function (tag, children) {
+        var _a;
+        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);
+        if (Array.isArray(result)) {
+            (_a = this.result).push.apply(_a, __spreadArray([], __read(result), false));
+        }
+        else {
+            this.result.push(result);
+        }
+    };
+    AstBuilder.prototype.pushLiteralText = function (text) {
+        var last = this.result[this.result.length - 1];
+        if (last.type === RichTextNodeType.Text) {
+            last.content += text;
+        }
+        else {
+            this.result.push({ type: RichTextNodeType.Text, content: text });
+        }
+    };
+    AstBuilder.prototype.pushObject = function (value) {
+        this.result.push({ type: RichTextNodeType.Object, content: value });
+    };
+    AstBuilder.prototype.finish = function () {
+        return this.result;
+    };
+    return AstBuilder;
+}(format_1.FormatBuilder));
+/**
+ * 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.
+ */
+function formatToAst(message, values) {
+    if (typeof message === 'string')
+        return [{ type: RichTextNodeType.Text, content: message }];
+    return this.bindFormatValues(AstBuilder, message, values);
+}
+exports.astFormatter = {
+    format: formatToAst,
+    builder: AstBuilder,
+};

package/dist/formatters/index.d.ts

@@ -0,0 +1,4 @@
+export { astFormatter, type AstFunctionTypes, type RichTextNode, RichTextNodeType } from './ast';
+export { markdownFormatter, type MarkdownFunctionTypes } from './markdown';
+export { reactFormatter, makeReactFormatter, DEFAULT_REACT_RICH_TEXT_ELEMENTS, type ReactFunctionTypes, } from './react';
+export { stringFormatter, type StringFunctionTypes } from './string';

package/dist/formatters/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringFormatter = exports.DEFAULT_REACT_RICH_TEXT_ELEMENTS = exports.makeReactFormatter = exports.reactFormatter = exports.markdownFormatter = exports.RichTextNodeType = exports.astFormatter = void 0;
+var ast_1 = require("./ast");
+Object.defineProperty(exports, "astFormatter", { enumerable: true, get: function () { return ast_1.astFormatter; } });
+Object.defineProperty(exports, "RichTextNodeType", { enumerable: true, get: function () { return ast_1.RichTextNodeType; } });
+var markdown_1 = require("./markdown");
+Object.defineProperty(exports, "markdownFormatter", { enumerable: true, get: function () { return markdown_1.markdownFormatter; } });
+var react_1 = require("./react");
+Object.defineProperty(exports, "reactFormatter", { enumerable: true, get: function () { return react_1.reactFormatter; } });
+Object.defineProperty(exports, "makeReactFormatter", { enumerable: true, get: function () { return react_1.makeReactFormatter; } });
+Object.defineProperty(exports, "DEFAULT_REACT_RICH_TEXT_ELEMENTS", { enumerable: true, get: function () { return react_1.DEFAULT_REACT_RICH_TEXT_ELEMENTS; } });
+var string_1 = require("./string");
+Object.defineProperty(exports, "stringFormatter", { enumerable: true, get: function () { return string_1.stringFormatter; } });

package/dist/formatters/markdown.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Similar to `formatToPlainString`, format the given message with the provided
+ * values, but convert all rich text formatting back to Markdown syntax rather
+ * than rendering the actual rich content. The result is a plain string that
+ * can be sent through a separate Markdown renderer to get an equivalent
+ * result to formatting this message directly.
+ */
+import { AnyIntlMessage, FormatterImplementation, FunctionTypes } from '../types';
+import { IntlManager } from '../intl-manager';
+import { FormatBuilderConstructor } from '../format';
+export type MarkdownFunctionTypes = FunctionTypes<string>;
+export declare function formatToMarkdownString(this: IntlManager, message: AnyIntlMessage, values: object, Builder?: FormatBuilderConstructor<string>): string;
+export declare const markdownFormatter: FormatterImplementation<MarkdownFunctionTypes, string>;

package/dist/formatters/markdown.js

@@ -0,0 +1,80 @@
+"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.markdownFormatter = void 0;
+exports.formatToMarkdownString = formatToMarkdownString;
+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('') + '*'; },
+    $link: function (_a) {
+        var _b = __read(_a), target = _b[0], content = _b.slice(1);
+        return '[' + content.join('') + '](' + target + ')';
+    },
+    $p: function (content) { return content.join('') + '\n\n'; },
+};
+var MarkdownBuilder = /** @class */ (function (_super) {
+    __extends(MarkdownBuilder, _super);
+    function MarkdownBuilder() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.result = '';
+        return _this;
+    }
+    MarkdownBuilder.prototype.pushRichTextTag = function (tag, children) {
+        this.result += MARKDOWN_RICH_TEXT_ELEMENTS[tag](children);
+    };
+    return MarkdownBuilder;
+}(string_1.StringBuilder));
+function formatToMarkdownString(message, values, Builder) {
+    if (Builder === void 0) { Builder = MarkdownBuilder; }
+    if (typeof message === 'string')
+        return message;
+    var result = this.bindFormatValues(Builder, message, values);
+    // MarkdownBuilder always creates a single-element array with the string value.
+    return result[0];
+}
+exports.markdownFormatter = {
+    format: formatToMarkdownString,
+    builder: MarkdownBuilder,
+};

package/dist/formatters/react.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Format the given message as a React component, allowing it to listen for
+ * and respond to updates about the current locale and other relevant
+ * information.
+ */
+import type { AnyIntlMessage, FormatterImplementation, FunctionTypes, RichTextFormattingMap } from '../types';
+import * as React from 'react';
+import { IntlManager } from '../intl-manager';
+import { FormatBuilderConstructor } from '../format';
+export type ReactHandlerEvent = React.MouseEvent | React.KeyboardEvent;
+export type ReactClickHandler = (e: ReactHandlerEvent) => void;
+export type ReactFunctionTypes = FunctionTypes<React.ReactNode, ReactClickHandler | {
+    onClick: ReactClickHandler;
+} | {
+    onContextMenu: ReactClickHandler;
+} | {
+    onClick: ReactClickHandler;
+    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;
+/**
+ * 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>;