@discord/intl 0.1.2 → 0.2.0-canary.641ab2f

package/dist/message-loader.d.ts

@@ -1,7 +1,6 @@
+import { FormatJsNode } from './keyless-json';
 import { InternalIntlMessage } from './message';
-import type { MessageFormatElement } from '@formatjs/icu-messageformat-parser';
-type AnyRawMessage = string | MessageFormatElement[];
-type MessagesData = Record<string, AnyRawMessage>;
+type MessagesData = Record<string, FormatJsNode[]>;
 export interface IntlMessageGetterAdditions {
     onChange(callback: () => void): () => void;
 }
@@ -29,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
      */
@@ -100,5 +107,30 @@ 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>;
 }
+/**
+ * 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 {};

package/dist/message-loader.js

@@ -64,6 +64,8 @@ var __read = (this && this.__read) || function (o, n) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageLoader = void 0;
+exports.waitForAllDefaultIntlMessagesLoaded = waitForAllDefaultIntlMessagesLoaded;
+exports.createLoader = createLoader;
 var message_1 = require("./message");
 var MessageLoader = /** @class */ (function () {
     function MessageLoader(messageKeys, localeImportMap, defaultLocale) {
@@ -78,17 +80,24 @@ var MessageLoader = /** @class */ (function () {
         this._parseCache = new Map();
         this._subscribers = new Set();
         this._loadLocale(this.defaultLocale);
-        this.fallbackMessage = new message_1.InternalIntlMessage('THIS MESSAGE FAILED TO LOAD', 'en-US');
+        this.fallbackMessage = new message_1.InternalIntlMessage([], this.defaultLocale);
         // In cases where hot module replacement is available, set up cache clearing whenever the
         // 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) {
                 // @ts-expect-error `hot` not defined in types.
-                module.hot.accept(file, function () {
-                    _this._parseCache.clear();
-                    _this._loadLocale(locale);
-                });
+                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()) {
@@ -119,9 +128,8 @@ var MessageLoader = /** @class */ (function () {
     MessageLoader.prototype.get = function (key, locale) {
         var _a;
         var value = (_a = this.getMessageValue(key, locale)) !== null && _a !== void 0 ? _a : this.getMessageValue(key, this.defaultLocale);
-        if (value != null) {
+        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;
@@ -146,13 +154,11 @@ var MessageLoader = /** @class */ (function () {
         var cachedValue = this._parseCache.get(cacheKey);
         if (cachedValue != null)
             return cachedValue;
-        // Return early if this locale is still in the process of being loaded.
-        if (this._localeLoadingPromises[locale] != null) {
-            return undefined;
-        }
-        // If not, check whether it's been loaded and trigger a load if not.
+        // Check whether the locale exists in memory. If not, start a request to
+        // load the locale if one has not already started. It's impossible for
+        // the request to finish within the same tick, so return undefined in any
+        // case then.
         if (this.messages[locale] == null) {
-            // Ensure the locale is loaded, if it is supported
             if (this.supportedLocales.includes(locale)) {
                 this._loadLocale(locale);
             }
@@ -186,12 +192,13 @@ var MessageLoader = /** @class */ (function () {
     };
     MessageLoader.prototype._loadLocale = function (locale) {
         return __awaiter(this, void 0, void 0, function () {
-            var loadingPromise, _a, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            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 (this._localeLoadingPromises[locale] != null) {
+                        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
@@ -203,14 +210,14 @@ var MessageLoader = /** @class */ (function () {
                         // 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*/];
-                        loadingPromise = this.localeImportMap[locale]();
-                        this._localeLoadingPromises[locale] = loadingPromise;
+                        current = this.localeImportMap[locale]();
+                        this._localeLoadingPromises[locale] = { initialized: false, current: current };
                         _a = this.messages;
                         _b = locale;
-                        return [4 /*yield*/, loadingPromise];
+                        return [4 /*yield*/, current];
                     case 1:
-                        _a[_b] = (_c.sent()).default;
-                        delete this._localeLoadingPromises[locale];
+                        _a[_b] = (_d.sent()).default;
+                        this._localeLoadingPromises[locale] = { initialized: true, current: undefined };
                         this.emitChange();
                         return [2 /*return*/];
                 }
@@ -245,6 +252,94 @@ var MessageLoader = /** @class */ (function () {
         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];
+        // Ensure the locale at least exists and is initialized.
+        if (ref == null || ref.initialized == false)
+            return false;
+        // `current` will be deleted once the locale has loaded, so if it is null,
+        // then the locale data is current.
+        if (requireCurrent)
+            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*/];
+                }
+            });
+        });
+    };
+    /**
+     * 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)];
+            });
+        });
+    };
     return MessageLoader;
 }());
 exports.MessageLoader = MessageLoader;
+var LOADER_REGISTRY = [];
+/**
+ * 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.
+ */
+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*/];
+            }
+        });
+    });
+}
+/**
+ * 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) {
+    var loader = new MessageLoader(messageKeys, localeImportMap, defaultLocale);
+    LOADER_REGISTRY.push(loader);
+    return loader;
+}

package/dist/message.d.ts

@@ -1,41 +1,6 @@
-import { Formats, Formatters, MessageFormatPart } from 'intl-messageformat';
-import type { MessageFormatElement } from '@formatjs/icu-messageformat-parser';
+import { FormatJsNode } from './keyless-json';
 export declare class InternalIntlMessage {
     locale: string;
-    message?: string;
-    ast: MessageFormatElement[];
-    /**
-     * A stripped-down representation of the message with no rich formatting
-     * elements preserved. This will be lazily created the first time it is
-     * requested (e.g., by calling `formatToPlainString`).
-     */
-    plainAst?: MessageFormatElement[];
-    constructor(messageOrAst: string | MessageFormatElement[], locale: string);
-    /**
-     * Format this message with the given locale into an AST of chunks that can
-     * then be used or rendered into strings, React elements, or anything else as
-     * needed.
-     */
-    formatToParts<T>(formatters: Formatters, formats: Formats, values?: Record<string, any>): Array<MessageFormatPart<T>>;
-    /**
-     * Formats this message just like `formatToParts`, but strips all stylistic
-     * elements and tags and returns a plain string with only the literal text of
-     * the message remaining.
-     *
-     * This method works by quickly scanning the string and removing any tag
-     * elements, formatting, then concatenating the pieces into a single result.
-     *
-     * Note that this function does _not_ handle serializing values other than
-     * plain/primitive values into strings. All values are simply converted using
-     * the `String()` constructor. So, for example, passing a function as a value
-     * will directly serialize the function definition into a string, rather than
-     * calling the function or evaluating the result.
-     */
-    formatToPlainString(formatters: Formatters, formats: Formats, values?: Record<string, any>): string;
-    /**
-     * Returns the same element with any formatting tags removed. If the element
-     * itself is a tag, the children will be hoisted and returned, otherwise the
-     * element is returned as an array of itself.
-     */
-    _removeRichTags(element: MessageFormatElement): MessageFormatElement[];
+    ast: FormatJsNode[];
+    constructor(messageOrAst: FormatJsNode[], locale: string);
 }

package/dist/message.js

@@ -1,142 +1,11 @@
 "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;
-};
-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.InternalIntlMessage = void 0;
-var icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
-var intl_messageformat_1 = require("intl-messageformat");
 var InternalIntlMessage = /** @class */ (function () {
     function InternalIntlMessage(messageOrAst, locale) {
         this.locale = locale;
-        if (typeof messageOrAst === 'string') {
-            this.message = messageOrAst;
-            this.ast = (0, icu_messageformat_parser_1.parse)(messageOrAst);
-        }
-        else {
-            this.ast = messageOrAst;
-        }
-        this.plainAst = undefined;
+        this.ast = messageOrAst;
     }
-    /**
-     * Format this message with the given locale into an AST of chunks that can
-     * then be used or rendered into strings, React elements, or anything else as
-     * needed.
-     */
-    InternalIntlMessage.prototype.formatToParts = function (formatters, formats, values) {
-        return (0, intl_messageformat_1.formatToParts)(this.ast, this.locale, formatters, formats, values);
-    };
-    /**
-     * Formats this message just like `formatToParts`, but strips all stylistic
-     * elements and tags and returns a plain string with only the literal text of
-     * the message remaining.
-     *
-     * This method works by quickly scanning the string and removing any tag
-     * elements, formatting, then concatenating the pieces into a single result.
-     *
-     * Note that this function does _not_ handle serializing values other than
-     * plain/primitive values into strings. All values are simply converted using
-     * the `String()` constructor. So, for example, passing a function as a value
-     * will directly serialize the function definition into a string, rather than
-     * calling the function or evaluating the result.
-     */
-    InternalIntlMessage.prototype.formatToPlainString = function (formatters, formats, values) {
-        var e_1, _a, _b, e_2, _c;
-        // Lazily create the reduced AST if it hasn't already been done.
-        if (this.plainAst == null) {
-            this.plainAst = [];
-            try {
-                for (var _d = __values(this.ast), _e = _d.next(); !_e.done; _e = _d.next()) {
-                    var part = _e.value;
-                    (_b = this.plainAst).push.apply(_b, __spreadArray([], __read(this._removeRichTags(part)), false));
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-        }
-        var parts = (0, intl_messageformat_1.formatToParts)(this.plainAst, this.locale, formatters, formats, values);
-        var result = '';
-        try {
-            for (var parts_1 = __values(parts), parts_1_1 = parts_1.next(); !parts_1_1.done; parts_1_1 = parts_1.next()) {
-                var part = parts_1_1.value;
-                result += String(part.value);
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (parts_1_1 && !parts_1_1.done && (_c = parts_1.return)) _c.call(parts_1);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-        return result;
-    };
-    /**
-     * Returns the same element with any formatting tags removed. If the element
-     * itself is a tag, the children will be hoisted and returned, otherwise the
-     * element is returned as an array of itself.
-     */
-    InternalIntlMessage.prototype._removeRichTags = function (element) {
-        var e_3, _a;
-        if (element.type === icu_messageformat_parser_1.TYPE.tag) {
-            var childContent = [];
-            try {
-                for (var _b = __values(element.children), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var child = _c.value;
-                    childContent.push.apply(childContent, __spreadArray([], __read(this._removeRichTags(child)), false));
-                }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_3) throw e_3.error; }
-            }
-            return childContent;
-        }
-        else {
-            return [element];
-        }
-    };
     return InternalIntlMessage;
 }());
 exports.InternalIntlMessage = InternalIntlMessage;

package/dist/types.d.ts

@@ -1,5 +1,6 @@
 import type { InternalIntlMessage } from './message';
 import type { IntlMessageGetterAdditions } from './message-loader';
+import { FormatBuilderConstructor } from './format';
 
 /**
  * Use this function to define messages as part of the `@discord/intl`
@@ -11,14 +12,6 @@ import type { IntlMessageGetterAdditions } from './message-loader';
  */
 export declare function defineMessages(messages: object): object;
 
-/**
- * A map of tag names to render functions to apply when the tags are
- * encountered while formatting a message. Each `IntlManager` can be
- * constructed with a different map of these elements, for example to allow
- * one manager to render React output while another renders accessibility text.
- */
-export type RichTextElementMap = Record<string, (chunks: any[]) => any>;
-
 /**
  * Placeholder type representing that this property is a Hook to be rendered
  * while formatting.
@@ -46,19 +39,8 @@ export type IntlTime = string | number | Date | null | undefined;
  * strings, and are able to skip multiple formatting steps to work more
  * efficiently. This type represents those messages distinctly.
  */
-type PlainIntlMessage = string;
-/**
- * A richly-formatted message that injects dynamic values while formatting,
- * with the types of those values defined by the `FormatValues` object. All
- * messages of this type must have at least one value in the object, otherwise
- * the message should be typed as a `PlainIntlMessage`.
- */
-type TypedIntlMessage<FormatValues extends object> = InternalIntlMessage & {
-  __values: FormatValues;
-};
-
-type AnyIntlMessage<FormatValues extends object | undefined = undefined> =
-  FormatValues extends undefined ? PlainIntlMessage : TypedIntlMessage<FormatValues>;
+export type PlainIntlMessage = string;
+export type AnyIntlMessage = PlainIntlMessage | InternalIntlMessage;
 
 export interface IntlMessageGetter extends IntlMessageGetterAdditions {
   (locale: string): InternalIntlMessage | PlainIntlMessage;
@@ -85,8 +67,8 @@ export interface TypedIntlMessageGetter<FormatValues extends object | undefined>
   // from the declared type. The latter of these is definitely semantically
   // correct, but the former is more just an annoying part of the type system
   // because of this returned type being nested within this interface and the
-  // strict subtying that TypeScript uses.
-  (locale: string): InternalIntlMessage | PlainIntlMessage;
+  // strict subtyping that TypeScript uses.
+  (locale: string): InternalIntlMessage;
 
   /**
    * A phantom type (not part of the actual typing of the object) that ensures
@@ -183,7 +165,7 @@ type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
  * checked against the provided message types, and error messages will be
  * accurate as a result.
  */
-type FormatValuesFor<T> =
+export type FormatValuesFor<T> =
   // `[]` syntax forces TypeScript to not distribute the possible union of
   // types, meaning this represents "_all_ values of T are an extension of
   // the parent type", which in this case represents messages with no
@@ -209,12 +191,18 @@ type FormatValuesFor<T> =
  * the caller to inject React elements within a string, while an AST formatter
  * might require a specific object shape, or allow any plain object.
  */
-interface FunctionTypeMap {
+export interface FunctionTypeMap {
   link: any;
   hook: any;
   handler: any;
 }
 
+export interface FunctionTypes<Result, HandlerType = (content: Result[]) => Result | Result[]> {
+  link: undefined | ((content: Result[]) => Result | Result[]);
+  hook: undefined | ((content: Result[]) => Result | Result[]);
+  handler: undefined | HandlerType;
+}
+
 type ReplaceKeepingNullability<T, P> = P | Exclude<T, NonNullable<T>>;
 
 /**
@@ -226,6 +214,8 @@ type ReplaceKeepingNullability<T, P> = P | Exclude<T, NonNullable<T>>;
 type MapFunctionTypes<T, FunctionTypes extends FunctionTypeMap> = {
   [K in keyof T]: ReplaceKeepingNullability<
     T[K],
+    // TODO: replace these types with string literal types in the generated
+    // file, turning this whole chain into `FunctionTypes[T[K]] ?? T[K]`.
     NonNullable<T[K]> extends LinkFunction
       ? FunctionTypes['link']
       : NonNullable<T[K]> extends HookFunction
@@ -251,7 +241,7 @@ type CheckStrictAny<Check, Yes, No> = (Check extends never ? true : false) exten
  * // Result is `{name: string}`
  * ```
  */
-type IntlMessageGetterInnerType<T extends IntlMessageGetter> =
+export type IntlMessageGetterInnerType<T extends IntlMessageGetter> =
   T extends TypedIntlMessageGetter<infer U> ? U : never;
 
 /**
@@ -260,13 +250,12 @@ type IntlMessageGetterInnerType<T extends IntlMessageGetter> =
  * types from `FunctionTypes`. The result is the set of required values
  * necessary to format the message of type `T` with the calling formatter.
  */
-type RequiredFormatValues<
+export type RequiredFormatValues<
   Values extends IntlMessageGetter,
-  DefaultElements,
   FunctionTypes extends FunctionTypeMap,
 > =
   IntlMessageGetterInnerType<Values> extends undefined
-    ? never
+    ? {}
     : CheckStrictAny<
         IntlMessageGetterInnerType<Values>,
         // If `T` is explicitly `any`, then individual properties can't be typed and
@@ -277,23 +266,30 @@ type RequiredFormatValues<
         // value and turn every property into the mapped `LinkFunction` type, which
         // is almost always going to be wrong.
         any,
-        MapFunctionTypes<
-          Omit<FormatValuesFor<IntlMessageGetterInnerType<Values>>, keyof DefaultElements>,
-          FunctionTypes
-        >
+        MapFunctionTypes<FormatValuesFor<IntlMessageGetterInnerType<Values>>, FunctionTypes>
       >;
 
-export interface IntlOptionalRichTextKeys {
-  $_: any;
-  $b: any;
-  $i: any;
-  $p: any;
-  $link: any;
-  $code: any;
+export interface RichTextFormattingMap<T = any> {
+  $_: T;
+  $b: T;
+  $i: T;
+  $p: T;
+  $link: T;
+  $code: T;
 }
 
-export type IntlFormatFunctionValuesArg<T extends IntlMessageGetter> = RequiredFormatValues<
-  T,
-  IntlOptionalRichTextKeys,
-  FunctionTypeMap
->;
+export type RichTextTagNames = keyof RichTextFormattingMap;
+
+export interface FormatterImplementation<
+  FunctionTypes extends FunctionTypeMap,
+  Result,
+  BuilderResult = Result,
+> {
+  format: (
+    message: AnyIntlMessage,
+    values: object,
+    builder?: FormatBuilderConstructor<BuilderResult>,
+  ) => Result;
+  builder: FormatBuilderConstructor<BuilderResult extends (infer T)[] ? T : BuilderResult>;
+  __$functionTypes?: FunctionTypes;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@discord/intl",
-  "version": "0.1.2",
+  "version": "0.2.0-canary.641ab2f",
   "license": "MIT",
   "description": "Client runtime for managing messages and translations in a React project.",
   "main": "./dist/index.js",
@@ -15,7 +15,6 @@
     "src"
   ],
   "dependencies": {
-    "@formatjs/icu-messageformat-parser": "^2.7.6",
     "@formatjs/intl": "^2.10.1",
     "intl-messageformat": "^10.5.11"
   },