@discord/intl 0.17.0 → 0.18.0-canary.40cad9d

package/dist/data-formatters/cache.d.ts

@@ -0,0 +1,21 @@
+import type { DurationFormat as FormatJsDurationFormat } from '@formatjs/intl-durationformat';
+type Cache<Value> = Map<string, Value>;
+type TemporaryIntlDurationFormat = typeof FormatJsDurationFormat;
+declare class FormatterCache {
+    dateTime: Cache<Intl.DateTimeFormat>;
+    duration: Cache<TemporaryIntlDurationFormat>;
+    list: Cache<Intl.ListFormat>;
+    number: Cache<Intl.NumberFormat>;
+    pluralRules: Cache<Intl.PluralRules>;
+    relativeTime: Cache<Intl.RelativeTimeFormat>;
+    getDateTimeFormatter(...args: ConstructorParameters<typeof Intl.DateTimeFormat>): Intl.DateTimeFormat;
+    getDurationFormatter(...args: ConstructorParameters<TemporaryIntlDurationFormat>): any;
+    getListFormatter(...args: ConstructorParameters<typeof Intl.ListFormat>): Intl.ListFormat;
+    getNumberFormatter(...args: ConstructorParameters<typeof Intl.NumberFormat>): Intl.NumberFormat;
+    getPluralRules(...args: ConstructorParameters<typeof Intl.PluralRules>): Intl.PluralRules;
+    getRelativeTimeFormatter(...args: ConstructorParameters<typeof Intl.RelativeTimeFormat>): Intl.RelativeTimeFormat;
+    _getCached<T, Args>(cache: Cache<T>, args: Args, constructor: (args: Args) => T): T;
+    _getKey(...args: any): string;
+}
+export declare const dataFormatterCache: FormatterCache;
+export {};

package/dist/data-formatters/cache.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataFormatterCache = void 0;
+class FormatterCache {
+    constructor() {
+        this.dateTime = new Map();
+        this.duration = new Map();
+        this.list = new Map();
+        this.number = new Map();
+        this.pluralRules = new Map();
+        this.relativeTime = new Map();
+    }
+    getDateTimeFormatter(...args) {
+        return this._getCached(this.dateTime, args, (args) => new Intl.DateTimeFormat(...args));
+    }
+    getDurationFormatter(...args) {
+        return this._getCached(this.duration, args, 
+        // @ts-expect-error DurationFormat is _not_ included in typescript
+        // https://github.com/microsoft/TypeScript/issues/60608
+        (args) => new Intl.DurationFormat(...args));
+    }
+    getListFormatter(...args) {
+        return this._getCached(this.list, args, (args) => new Intl.ListFormat(...args));
+    }
+    getNumberFormatter(...args) {
+        return this._getCached(this.number, args, (args) => new Intl.NumberFormat(...args));
+    }
+    getPluralRules(...args) {
+        return this._getCached(this.pluralRules, args, (args) => new Intl.PluralRules(...args));
+    }
+    getRelativeTimeFormatter(...args) {
+        return this._getCached(this.relativeTime, args, (args) => new Intl.RelativeTimeFormat(...args));
+    }
+    _getCached(cache, args, constructor) {
+        const key = this._getKey(args);
+        const cached = cache.get(key);
+        if (cached)
+            return cached;
+        const created = constructor(args);
+        cache.set(key, created);
+        return created;
+    }
+    _getKey(...args) {
+        return JSON.stringify(args);
+    }
+}
+exports.dataFormatterCache = new FormatterCache();

package/dist/data-formatters/config.d.ts

@@ -0,0 +1,81 @@
+import type { DurationFormatOptions, DurationInput } from '@formatjs/intl-durationformat/src/types';
+export type TemporaryDurationInput = DurationInput;
+export type TemporaryDurationFormatOptions = DurationFormatOptions;
+export interface FormatConfigType {
+    date: Record<string, Intl.DateTimeFormatOptions>;
+    duration: Record<string, TemporaryDurationFormatOptions>;
+    list: Record<string, Intl.ListFormatOptions>;
+    number: Record<string, Intl.NumberFormatOptions>;
+    relativeTime: Record<string, Intl.RelativeTimeFormatOptions>;
+    time: Record<string, Intl.DateTimeFormatOptions>;
+}
+export declare function resolveFormatConfigOptions<T extends object, const K extends string>(config: Record<K, T>, style?: T & {
+    format?: K;
+}): T;
+export declare const DEFAULT_FORMAT_CONFIG: {
+    duration: {};
+    list: {};
+    relativeTime: {};
+    /**
+     * Default formatting configuration options for common date, time, and number formats. This is
+     * taken almost directly from FormatJS's defaults here, for the sake of compatibility.
+     * https://github.com/formatjs/formatjs/blob/c30975bfbe2db7eb62f4dbe6c8ad6ca5e786dcb3/packages/intl-messageformat/src/core.ts#L229-L296
+     */
+    number: {
+        integer: {
+            maximumFractionDigits: number;
+        };
+        currency: {
+            style: "currency";
+        };
+        percent: {
+            style: "percent";
+        };
+    };
+    date: {
+        short: {
+            month: "numeric";
+            day: "numeric";
+            year: "2-digit";
+        };
+        medium: {
+            month: "short";
+            day: "numeric";
+            year: "numeric";
+        };
+        long: {
+            month: "long";
+            day: "numeric";
+            year: "numeric";
+        };
+        full: {
+            weekday: "long";
+            month: "long";
+            day: "numeric";
+            year: "numeric";
+        };
+    };
+    time: {
+        short: {
+            hour: "numeric";
+            minute: "numeric";
+        };
+        medium: {
+            hour: "numeric";
+            minute: "numeric";
+            second: "numeric";
+        };
+        long: {
+            hour: "numeric";
+            minute: "numeric";
+            second: "numeric";
+            timeZoneName: "short";
+        };
+        full: {
+            hour: "numeric";
+            minute: "numeric";
+            second: "numeric";
+            timeZoneName: "short";
+        };
+    };
+};

package/dist/{format-config.js → data-formatters/config.js}

@@ -1,12 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_FORMAT_CONFIG = void 0;
-/**
- * Default formatting configuration options for common date, time, and number formats. This is
- * taken almost directly from FormatJS's defaults here, for the sake of compatibility.
- * https://github.com/formatjs/formatjs/blob/c30975bfbe2db7eb62f4dbe6c8ad6ca5e786dcb3/packages/intl-messageformat/src/core.ts#L229-L296
- */
+exports.resolveFormatConfigOptions = resolveFormatConfigOptions;
+function resolveFormatConfigOptions(config, style) {
+    if (typeof (style === null || style === void 0 ? void 0 : style.format) === 'string') {
+        return Object.assign(Object.assign({}, config[style.format]), style);
+    }
+    return style;
+}
 exports.DEFAULT_FORMAT_CONFIG = {
+    // These have no known defaults, so they can't be applied easily.
+    duration: {},
+    list: {},
+    relativeTime: {},
+    /**
+     * Default formatting configuration options for common date, time, and number formats. This is
+     * taken almost directly from FormatJS's defaults here, for the sake of compatibility.
+     * https://github.com/formatjs/formatjs/blob/c30975bfbe2db7eb62f4dbe6c8ad6ca5e786dcb3/packages/intl-messageformat/src/core.ts#L229-L296
+     */
     number: {
         integer: { maximumFractionDigits: 0 },
         currency: { style: 'currency' },

package/dist/data-formatters/index.d.ts

@@ -0,0 +1,32 @@
+import { FormatConfigType, TemporaryDurationFormatOptions, TemporaryDurationInput } from './config';
+export interface DataFormatters<FormatConfig extends FormatConfigType> {
+    formatDate(value: number | Date, style?: Intl.DateTimeFormatOptions | {
+        format?: keyof FormatConfig['date'] & string;
+    }): string;
+    formatDuration(value: TemporaryDurationInput, style?: TemporaryDurationFormatOptions | {
+        format?: keyof FormatConfig['duration'] & string;
+    }): string;
+    formatNumber(value: number, style?: Intl.NumberFormatOptions | {
+        format?: keyof FormatConfig['number'] & string;
+    }): string;
+    formatList(values: any[], style?: Intl.ListFormatOptions | {
+        format?: keyof FormatConfig['list'] & string;
+    }): string;
+    formatListToParts<T>(values: T[], style?: Intl.ListFormatOptions | {
+        format?: keyof FormatConfig['list'] & string;
+    }): Array<T | string>;
+    formatRelativeTime(value: number, unit: Intl.RelativeTimeFormatUnit, style?: Intl.RelativeTimeFormatOptions | {
+        format?: keyof FormatConfig['relativeTime'] & string;
+    }): string;
+    formatTime(value: number | Date, style?: Intl.DateTimeFormatOptions | {
+        format?: keyof FormatConfig['time'] & string;
+    }): string;
+    getPluralRules(options: Intl.PluralRulesOptions): Intl.PluralRules;
+}
+export declare function makeDataFormatters<const FormatConfig extends FormatConfigType>(locales: string[], formatConfig: FormatConfig, 
+/**
+ * The FormatJs Polyfill for locale-matcher has really poor performance when
+ * using the BestFitMatcher. When this value is set, the matcher will be
+ * forced to use the LookupMatcher instead, which is much more performant.
+ */
+forceLookupMatch?: boolean): DataFormatters<FormatConfig>;

package/dist/data-formatters/index.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDataFormatters = makeDataFormatters;
+const config_1 = require("./config");
+const cache_1 = require("./cache");
+function makeDataFormatters(locales, formatConfig, 
+/**
+ * The FormatJs Polyfill for locale-matcher has really poor performance when
+ * using the BestFitMatcher. When this value is set, the matcher will be
+ * forced to use the LookupMatcher instead, which is much more performant.
+ */
+forceLookupMatch = false) {
+    function optionsWithLocaleMatcher(options) {
+        return forceLookupMatch ? Object.assign(Object.assign({}, options), { localeMatcher: 'lookup' }) : options;
+    }
+    return {
+        formatDate(value, style) {
+            const options = (0, config_1.resolveFormatConfigOptions)(formatConfig.date, style);
+            return cache_1.dataFormatterCache
+                .getDateTimeFormatter(locales, optionsWithLocaleMatcher(options))
+                .format(value);
+        },
+        formatDuration(value, style) {
+            const options = (0, config_1.resolveFormatConfigOptions)(formatConfig.time, style);
+            return cache_1.dataFormatterCache
+                .getDurationFormatter(locales, optionsWithLocaleMatcher(options))
+                .format(value);
+        },
+        formatNumber(value, style) {
+            const options = (0, config_1.resolveFormatConfigOptions)(formatConfig.number, style);
+            return cache_1.dataFormatterCache
+                .getNumberFormatter(locales, optionsWithLocaleMatcher(options))
+                .format(value);
+        },
+        formatList(values, style) {
+            const options = (0, config_1.resolveFormatConfigOptions)(formatConfig.list, style);
+            return cache_1.dataFormatterCache
+                .getListFormatter(locales, optionsWithLocaleMatcher(options))
+                .format(values);
+        },
+        formatListToParts(values, style) {
+            const options = (0, config_1.resolveFormatConfigOptions)(formatConfig.list, style);
+            // Intl.ListFormat only accepts string arguments, even for `formatToParts`,
+            // but we want to support formatting of complex values like React nodes as
+            // part of a list (think an "and more" link at the end of a list).
+            //
+            // To enable that, we make placeholders with hopefully-unusable sentinel
+            // values that can be passed to `formatToParts`, then after the formatting
+            // we map the original values back into the parts.
+            const placeholders = {};
+            for (const index in values) {
+                placeholders['$+/-$placeholder.' + index] = values[index];
+            }
+            const parts = cache_1.dataFormatterCache
+                .getListFormatter(locales, optionsWithLocaleMatcher(options))
+                .formatToParts(Object.keys(placeholders));
+            return parts.map((part) => { var _a; return (part.value = (_a = placeholders[part.value]) !== null && _a !== void 0 ? _a : part.value); });
+        },
+        formatRelativeTime(value, unit, style) {
+            const options = (0, config_1.resolveFormatConfigOptions)(formatConfig.relativeTime, style);
+            return cache_1.dataFormatterCache
+                .getRelativeTimeFormatter(locales, optionsWithLocaleMatcher(options))
+                .format(value, unit);
+        },
+        formatTime(value, style) {
+            const options = (0, config_1.resolveFormatConfigOptions)(formatConfig.time, style);
+            return cache_1.dataFormatterCache
+                .getDateTimeFormatter(locales, optionsWithLocaleMatcher(options))
+                .format(value);
+        },
+        getPluralRules(options) {
+            return cache_1.dataFormatterCache.getPluralRules(locales, optionsWithLocaleMatcher(options));
+        },
+    };
+}

package/dist/format.d.ts

@@ -17,9 +17,9 @@
  *   parameter, important to have React treat the resulting elements nicely.
  */
 import { AstNode } from '@discord/intl-ast';
-import { Formatters } from 'intl-messageformat';
-import type { FormatConfig } from './format-config';
 import type { RichTextTagNames } from './types';
+import { FormatConfigType } from './data-formatters/config';
+import { DataFormatters } from './data-formatters';
 export declare abstract class FormatBuilder<Result, ObjectType = Result extends object ? Result : never> {
     abstract pushRichTextTag(tag: RichTextTagNames, children: Result[], control: Result[]): void;
     abstract pushLiteralText(text: string): void;
@@ -27,5 +27,5 @@ export declare abstract class FormatBuilder<Result, ObjectType = Result extends
     abstract finish(): Result[];
 }
 export type FormatBuilderConstructor<Result> = new () => FormatBuilder<Result>;
-export declare function bindFormatValuesWithBuilder<T, ObjectType, Builder extends FormatBuilder<T, ObjectType>>(builder: Builder, nodes: AstNode[], locales: string | string[], formatters: Formatters, formatConfig: FormatConfig, values?: Record<string, string | object>, currentPluralValue?: number, originalMessage?: string): void;
-export declare function bindFormatValues<Result>(Builder: FormatBuilderConstructor<Result>, nodes: string | AstNode[], locales: string | string[], formatters: Formatters, formatConfig: FormatConfig, values?: Record<string, string | object>, currentPluralValue?: number): Result[];
+export declare function bindFormatValuesWithBuilder<T, ObjectType, Builder extends FormatBuilder<T, ObjectType>, FormatConfig extends FormatConfigType>(builder: Builder, nodes: AstNode[], locales: string | string[], formatters: DataFormatters<FormatConfig>, formatConfig: FormatConfig, values?: Record<string, string | object>, currentPluralValue?: number, originalMessage?: string): void;
+export declare function bindFormatValues<Result, FormatConfig extends FormatConfigType>(Builder: FormatBuilderConstructor<Result>, nodes: string | AstNode[], locales: string | string[], dataFormatters: DataFormatters<FormatConfig>, formatConfig: FormatConfig, values?: Record<string, string | object>, currentPluralValue?: number): Result[];

package/dist/format.js

@@ -23,7 +23,6 @@ exports.bindFormatValuesWithBuilder = bindFormatValuesWithBuilder;
 exports.bindFormatValues = bindFormatValues;
 const icu_skeleton_parser_1 = require("@formatjs/icu-skeleton-parser");
 const intl_ast_1 = require("@discord/intl-ast");
-const 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.
@@ -34,6 +33,14 @@ function isRichTextTag(name) {
 class FormatBuilder {
 }
 exports.FormatBuilder = FormatBuilder;
+class MissingValueError extends Error {
+    constructor(variableName, originalMessage, nodeType) {
+        super(`No value for variable '${variableName}' was provided for the localized message '${originalMessage}'`);
+        this.variableName = variableName;
+        this.originalMessage = originalMessage;
+        this.nodeType = nodeType;
+    }
+}
 function bindFormatValuesWithBuilder(builder, nodes, locales, formatters, formatConfig, values = {}, currentPluralValue, originalMessage) {
     var _a;
     // Hot path for static messages that are just parsed as a single string element.
@@ -41,6 +48,7 @@ function bindFormatValuesWithBuilder(builder, nodes, locales, formatters, format
         builder.pushLiteralText(nodes[0]);
         return;
     }
+    let keyIndex = 0;
     for (const node of nodes) {
         if (typeof node === 'string') {
             builder.pushLiteralText(node);
@@ -53,7 +61,7 @@ function bindFormatValuesWithBuilder(builder, nodes, locales, formatters, format
                 // numeric values are replaced, otherwise the value is completed ignored?
                 // Behavior copied from FormatJS directly.
                 if (typeof currentPluralValue === 'number') {
-                    const value = formatters.getNumberFormat(locales).format(currentPluralValue);
+                    const value = formatters.formatNumber(currentPluralValue);
                     builder.pushLiteralText(value);
                 }
                 continue;
@@ -62,7 +70,7 @@ function bindFormatValuesWithBuilder(builder, nodes, locales, formatters, format
         // 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);
+            throw new MissingValueError(variableName, originalMessage, nodeType);
         }
         const value = values[variableName];
         switch (nodeType) {
@@ -91,9 +99,8 @@ function bindFormatValuesWithBuilder(builder, nodes, locales, formatters, format
                     ? formatConfig.date[nodeStyle]
                     : nodeStyle != null
                         ? (0, icu_skeleton_parser_1.parseDateTimeSkeleton)(nodeStyle)
-                        : formatConfig.time.medium;
-                // @ts-expect-error Cast string values to dates properly.
-                builder.pushLiteralText(formatters.getDateTimeFormat(locales, style).format(value));
+                        : undefined;
+                builder.pushLiteralText(formatters.formatDate(value, style));
                 break;
             }
             case intl_ast_1.FormatJsNodeType.Time: {
@@ -104,10 +111,8 @@ function bindFormatValuesWithBuilder(builder, nodes, locales, formatters, format
                     ? formatConfig.time[nodeStyle]
                     : nodeStyle != null
                         ? (0, icu_skeleton_parser_1.parseDateTimeSkeleton)(nodeStyle)
-                        : undefined; // TODO: parseSkeleton();
-                builder.pushLiteralText(
-                // @ts-expect-error Cast string values to dates properly.
-                formatters.getDateTimeFormat(locales, style).format(value));
+                        : undefined;
+                builder.pushLiteralText(formatters.formatTime(value, style));
                 break;
             }
             case intl_ast_1.FormatJsNodeType.Number: {
@@ -122,7 +127,7 @@ function bindFormatValuesWithBuilder(builder, nodes, locales, formatters, format
                 const scaledValue = 
                 // @ts-expect-error This is a weird cast that's not accurate, but works in the short term.
                 typeof value !== 'number' ? value : value * ((_a = style === null || style === void 0 ? void 0 : style.scale) !== null && _a !== void 0 ? _a : 1);
-                builder.pushLiteralText(formatters.getNumberFormat(locales, style).format(scaledValue));
+                builder.pushLiteralText(formatters.formatNumber(scaledValue, style));
                 break;
             }
             case intl_ast_1.FormatJsNodeType.Tag: {
@@ -139,7 +144,7 @@ function bindFormatValuesWithBuilder(builder, nodes, locales, formatters, format
                     if (typeof value !== 'function') {
                         throw `expected a function type for a Tag formatting value, ${variableName}. got ${typeof value}: ${value}`;
                     }
-                    let chunks = value(appliedChildren);
+                    let chunks = value(appliedChildren, `${keyIndex++}`);
                     chunks = Array.isArray(chunks) ? chunks : [chunks];
                     for (const chunk of chunks) {
                         if (typeof chunk === 'string') {
@@ -171,10 +176,9 @@ function bindFormatValuesWithBuilder(builder, nodes, locales, formatters, format
                     const exactSelector = `=${value}`;
                     if (exactSelector in options)
                         return options[exactSelector];
-                    const rule = formatters
-                        .getPluralRules(locales, { type: pluralType })
-                        // @ts-expect-error Assert this `as number` properly.
-                        .select(value - (offset !== null && offset !== void 0 ? offset : 0));
+                    const rule = formatters.getPluralRules({ type: pluralType }).select(
+                    // @ts-expect-error Assert this `as number` properly.
+                    value - (offset !== null && offset !== void 0 ? offset : 0));
                     return (_a = options[rule]) !== null && _a !== void 0 ? _a : options.other;
                 })();
                 if (option == null) {
@@ -188,14 +192,14 @@ function bindFormatValuesWithBuilder(builder, nodes, locales, formatters, format
         }
     }
 }
-function bindFormatValues(Builder, nodes, locales, formatters, formatConfig, values = {}, currentPluralValue) {
+function bindFormatValues(Builder, nodes, locales, dataFormatters, formatConfig, values = {}, currentPluralValue) {
     const builder = new Builder();
     if (typeof nodes === 'string') {
         builder.pushLiteralText(nodes);
         return builder.finish();
     }
     else {
-        bindFormatValuesWithBuilder(builder, nodes, locales, formatters, formatConfig, values, currentPluralValue);
+        bindFormatValuesWithBuilder(builder, nodes, locales, dataFormatters, formatConfig, values, currentPluralValue);
         return builder.finish();
     }
 }

package/dist/formatters/index.d.ts

@@ -1,4 +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, ReactIntlMessage, } from './react';
+export { reactFormatter, makeReactFormatter, DEFAULT_REACT_RICH_TEXT_ELEMENTS, type ReactFunctionTypes, ReactIntlMessage, ReactIntlPlainString, ReactIntlRichText, } from './react';
 export { stringFormatter, type StringFunctionTypes } from './string';

package/dist/formatters/react.d.ts

@@ -18,7 +18,36 @@ export type ReactFunctionTypes = FunctionTypes<React.ReactNode, ReactClickHandle
     onContextMenu: ReactClickHandler;
 }>;
 export declare const DEFAULT_REACT_RICH_TEXT_ELEMENTS: RichTextFormattingMap<ReactFunctionTypes['hook']>;
-export type ReactIntlMessage = Array<React.ReactElement | string> & {
+/**
+ * A type representing any message that has been formatted using one of the
+ * default React formatting methods in the `@discord/intl` system. Use this
+ * type when you don't care about whether a message is static or contains rich
+ * text or has dynamically-formatted values, when you need to handle both in
+ * tandem, or when you need a generic return type for a function returning "any
+ * already-formatted React message".
+ *
+ * Generally, this is like `React.ReactNode`, accepting both strings and rich
+ * `ReactElement`s, but it is more specific to disallow nullish values and
+ * other special React elements like `ReactPortal`. Seeing this type, you can
+ * be confident that the value is intended to be the result of formatting an
+ * intl message, even if the actual value comes from elsewhere (like a
+ * user-generated string).
+ */
+export type ReactIntlMessage = string | ReactIntlRichText;
+/**
+ * A branded type representing a plain string that has been rendered by the React formatter. This
+ * type should generally _not_ be used as a type constraint unless _absolute certainty_ that a
+ * message was formatted is desirable. Instead, accept plain `string`, and this will be compatible.
+ */
+export type ReactIntlPlainString = string & {
+    __brand: 'discord-intl';
+};
+/**
+ * While `ReactIntlMessage` represents the result of rendering _any_ message with the React
+ * formatter, `ReactIntlRichText` specifically represents a message that was rendered and contains
+ * rich text, meaning the result contains React nodes itself and represents a CST of the message.
+ */
+export type ReactIntlRichText = Array<React.ReactElement | string> & {
     __brand: 'discord-intl';
 };
 export declare function formatReact(this: IntlManager, message: AnyIntlMessage, values: object, Builder: FormatBuilderConstructor<React.ReactElement>): ReactIntlMessage;

package/dist/formatters/react.js

@@ -49,9 +49,8 @@ function createReactBuilder(richTextElements) {
     };
 }
 function formatReact(message, values, Builder) {
-    if (typeof message === 'string') {
-        return [message];
-    }
+    if (typeof message === 'string')
+        return message;
     const parts = this.bindFormatValues(Builder, message, values);
     return parts;
 }

package/dist/index.d.ts

@@ -1,27 +1,11 @@
-import * as React from 'react';
-import { RichTextNode } from './formatters';
-export * from './formatters';
+export { type DataFormatters, makeDataFormatters } from './data-formatters';
+export { dataFormatterCache } from './data-formatters/cache';
 export { FormatBuilder, FormatBuilderConstructor, bindFormatValues } from './format';
+export * from './formatters';
 export { runtimeHashMessageKey } from './hash';
 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
- * default formatting methods in the `@discord/intl` system. Use this type
- * when you don't care about whether a message is static or contains rich text
- * or has dynamically-formatted values, when you need to handle both in tandem,
- * or when you need a generic return type for a function returning "any
- * any-already formatted message".
- *
- * Generally, this is like `React.ReactNode`, accepting both strings and rich
- * `ReactElement`s, but it is more specific to disallow nullish values and
- * other special React elements like `ReactPortal`. Seeing this type, you can
- * be confident that the value is intended to be the result of formatting an
- * intl message, even if the actual value comes from elsewhere (like a
- * user-generated string).
- */
-export type ReactIntlMessage = string | React.ReactElement | Array<string | React.ReactElement>;
 /**
  * The return value of `formatToParts` from `@discord/intl`, this type
  * represents any AST structure for a message rendered using this system.
@@ -32,4 +16,5 @@ export type ReactIntlMessage = string | React.ReactElement | Array<string | Reac
  * from a call to `formatToParts`, meaning they are intended to be fully static
  * structures passed around for custom rendering functions to use.
  */
+import { type RichTextNode } from './formatters';
 export type IntlMessageAst = RichTextNode;

package/dist/index.js

@@ -14,11 +14,15 @@ 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.MessageLoader = exports.waitForAllDefaultIntlMessagesLoaded = exports.loadAllMessagesInLocale = exports.createLoader = exports.DEFAULT_LOCALE = exports.IntlManager = exports.runtimeHashMessageKey = exports.bindFormatValues = exports.FormatBuilder = void 0;
-__exportStar(require("./formatters"), exports);
+exports.MessageLoader = exports.waitForAllDefaultIntlMessagesLoaded = exports.loadAllMessagesInLocale = exports.createLoader = exports.DEFAULT_LOCALE = exports.IntlManager = exports.runtimeHashMessageKey = exports.bindFormatValues = exports.FormatBuilder = exports.dataFormatterCache = exports.makeDataFormatters = void 0;
+var data_formatters_1 = require("./data-formatters");
+Object.defineProperty(exports, "makeDataFormatters", { enumerable: true, get: function () { return data_formatters_1.makeDataFormatters; } });
+var cache_1 = require("./data-formatters/cache");
+Object.defineProperty(exports, "dataFormatterCache", { enumerable: true, get: function () { return cache_1.dataFormatterCache; } });
 var format_1 = require("./format");
 Object.defineProperty(exports, "FormatBuilder", { enumerable: true, get: function () { return format_1.FormatBuilder; } });
 Object.defineProperty(exports, "bindFormatValues", { enumerable: true, get: function () { return format_1.bindFormatValues; } });
+__exportStar(require("./formatters"), exports);
 var hash_1 = require("./hash");
 Object.defineProperty(exports, "runtimeHashMessageKey", { enumerable: true, get: function () { return hash_1.runtimeHashMessageKey; } });
 var intl_manager_1 = require("./intl-manager");

package/dist/intl-manager.d.ts

@@ -1,8 +1,8 @@
-import { IntlShape } from '@formatjs/intl';
+import { DEFAULT_FORMAT_CONFIG, type FormatConfigType } from './data-formatters/config';
+import { FormatBuilderConstructor } from './format';
 import type { FormatterImplementation, IntlMessageGetter, RequiredFormatValues, TypedIntlMessageGetter } from './types';
 import { InternalIntlMessage } from './message';
-import { FormatBuilderConstructor } from './format';
-import { FormatConfig } from './format-config';
+import { DataFormatters } from './data-formatters';
 /**
  * Fallback locale used for all internationalization when an operation in the
  * requested locale is not possible.
@@ -14,7 +14,7 @@ export type FormatFunction<F extends FormatterImplementation<any, any>> = <T ext
 type ThisWithFormatters<This, T extends Record<string, FormatterImplementation<any, any>>> = This & {
     [K in keyof T]: FormatFunction<T[K]>;
 };
-export interface IntlManagerOptions {
+export interface IntlManagerOptions<FormatConfig> {
     /**
      * The locale to initially have this manager use. Useful to set when information about the user's
      * likely locale is available sooner than when that information is definitely known (at which
@@ -30,19 +30,37 @@ export interface IntlManagerOptions {
      * @default DEFAULT_LOCALE
      */
     defaultLocale?: string;
+    /**
+     * Configuration for the different kinds of data dataFormatters that can be used both inside of
+     * messages and in their own functions (like `intl.formatDate`) as shorthands for common sets of
+     * options. For example, with the default config, this enables `intl.formatDate(now, 'short')`
+     * rather than having to specify the exact properties of each style every time.
+     *
+     * @default DEFAULT_FORMATTER_CONFIG
+     */
+    formatConfig?: FormatConfig;
+    /**
+     * The FormatJs Polyfill for locale-matcher has really poor performance when
+     * using the BestFitMatcher. When this value is set, the matcher will be
+     * forced to use the LookupMatcher instead, which is much more performant.
+     *
+     * @default false
+     */
+    forceLookupMatcher?: boolean;
 }
-export declare class IntlManager {
+export declare class IntlManager<const FormatConfig extends FormatConfigType = typeof DEFAULT_FORMAT_CONFIG> {
     defaultLocale: string;
     currentLocale: string;
-    intl: IntlShape;
     formatConfig: FormatConfig;
+    data: DataFormatters<FormatConfig>;
     _localeSubscriptions: Set<(locale: string) => void>;
-    constructor({ initialLocale, defaultLocale, }: IntlManagerOptions);
+    _forceLookupMatcher: boolean;
+    constructor({ initialLocale, defaultLocale, formatConfig, forceLookupMatcher, }: IntlManagerOptions<FormatConfig>);
     /**
      * Add a set of formatter implementations to this manager, making each available as a direct
      * property
      */
-    withFormatters<const T extends Record<string, FormatterImplementation<any, any>>>(formatters: T): ThisWithFormatters<this, T>;
+    withFormatters<const T extends Record<string, FormatterImplementation<any, any>>>(dataFormatters: T): ThisWithFormatters<this, T>;
     /**
      * 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