@formatjs/intl 3.1.8 → 4.0.1

package/lib/src/types.d.ts

@@ -1,109 +0,0 @@
-import { MessageFormatElement } from '@formatjs/icu-messageformat-parser';
-import { NumberFormatOptions } from '@formatjs/ecma402-abstract';
-import { FormatError, Formats, FormatXMLElementFn, IntlMessageFormat, Options as IntlMessageFormatOptions, PrimitiveType } from 'intl-messageformat';
-import { InvalidConfigError, MessageFormatError, MissingDataError, MissingTranslationError, UnsupportedFormatterError } from './error';
-import { DEFAULT_INTL_CONFIG } from './utils';
-export interface Part<T = string> {
-    type: 'element' | 'literal';
-    value: T;
-}
-declare global {
-    namespace FormatjsIntl {
-        interface Message {
-        }
-        interface IntlConfig {
-        }
-        interface Formats {
-        }
-    }
-}
-type MessageIds = FormatjsIntl.Message extends {
-    ids: infer T;
-} ? T extends string ? T : string : string;
-type Locale = FormatjsIntl.IntlConfig extends {
-    locale: infer T;
-} ? T extends string ? T : string : string;
-export type OnErrorFn = (err: MissingTranslationError | MessageFormatError | MissingDataError | InvalidConfigError | UnsupportedFormatterError | FormatError) => void;
-export type OnWarnFn = (warning: string) => void;
-/**
- * Config for intl object.
- * Generic type T is the type of potential rich text element. For example:
- * With React, T would be React.ReactNode
- */
-export interface ResolvedIntlConfig<T = string> {
-    locale: Locale;
-    timeZone?: string;
-    fallbackOnEmptyString?: boolean;
-    formats: CustomFormats;
-    messages: Record<MessageIds, string> | Record<MessageIds, MessageFormatElement[]>;
-    defaultLocale: string;
-    defaultFormats: CustomFormats;
-    defaultRichTextElements?: Record<string, FormatXMLElementFn<T>>;
-    onError: OnErrorFn;
-    onWarn?: OnWarnFn;
-}
-export interface CustomFormats extends Partial<Formats> {
-    relative?: Record<string, Intl.RelativeTimeFormatOptions>;
-    dateTimeRange?: Record<string, Intl.DateTimeFormatOptions>;
-}
-export interface CustomFormatConfig<Source = string> {
-    format?: Source extends keyof FormatjsIntl.Formats ? FormatjsIntl.Formats[Source] : string;
-}
-export type FormatDateTimeRangeOptions = Omit<Intl.DateTimeFormatOptions, 'localeMatcher'> & CustomFormatConfig<'dateTimeRange'>;
-export type FormatDateOptions = Omit<Intl.DateTimeFormatOptions, 'localeMatcher'> & CustomFormatConfig<'date'>;
-export type FormatNumberOptions = Omit<NumberFormatOptions, 'localeMatcher'> & CustomFormatConfig<'number'>;
-export type FormatRelativeTimeOptions = Omit<Intl.RelativeTimeFormatOptions, 'localeMatcher'> & CustomFormatConfig<'time'>;
-export type FormatPluralOptions = Omit<Intl.PluralRulesOptions, 'localeMatcher'> & CustomFormatConfig;
-export type FormatListOptions = Omit<Intl.ListFormatOptions, 'localeMatcher'>;
-export type FormatDisplayNameOptions = Omit<Intl.DisplayNamesOptions, 'localeMatcher'>;
-/**
- * `TBase` is the type constraints of the rich text element in the formatted output.
- * For example, with React, `TBase` should be `React.ReactNode`.
- */
-export interface IntlFormatters<TBase = unknown> {
-    formatDateTimeRange(this: void, from: Parameters<Intl.DateTimeFormat['formatRange']>[0] | string, to: Parameters<Intl.DateTimeFormat['formatRange']>[1] | string, opts?: FormatDateTimeRangeOptions): string;
-    formatDate(this: void, value: Parameters<Intl.DateTimeFormat['format']>[0] | string, opts?: FormatDateOptions): string;
-    formatTime(this: void, value: Parameters<Intl.DateTimeFormat['format']>[0] | string, opts?: FormatDateOptions): string;
-    formatDateToParts(this: void, value: Parameters<Intl.DateTimeFormat['format']>[0] | string, opts?: FormatDateOptions): Intl.DateTimeFormatPart[];
-    formatTimeToParts(this: void, value: Parameters<Intl.DateTimeFormat['format']>[0] | string, opts?: FormatDateOptions): Intl.DateTimeFormatPart[];
-    formatRelativeTime(this: void, value: Parameters<Intl.RelativeTimeFormat['format']>[0], unit?: Parameters<Intl.RelativeTimeFormat['format']>[1], opts?: FormatRelativeTimeOptions): string;
-    formatNumber(this: void, value: Parameters<Intl.NumberFormat['format']>[0], opts?: FormatNumberOptions): string;
-    formatNumberToParts(this: void, value: Parameters<Intl.NumberFormat['format']>[0], opts?: FormatNumberOptions): Intl.NumberFormatPart[];
-    formatPlural(this: void, value: Parameters<Intl.PluralRules['select']>[0], opts?: FormatPluralOptions): ReturnType<Intl.PluralRules['select']>;
-    formatMessage(this: void, descriptor: MessageDescriptor, values?: Record<string, PrimitiveType | FormatXMLElementFn<string, string>>, opts?: IntlMessageFormatOptions): string;
-    formatMessage<T extends TBase, TValue extends T | FormatXMLElementFn<T>>(this: void, descriptor: MessageDescriptor, values?: Record<string, PrimitiveType | TValue>, opts?: IntlMessageFormatOptions): string | T | Array<string | T>;
-    $t(this: void, descriptor: MessageDescriptor, values?: Record<string, PrimitiveType | FormatXMLElementFn<string, string>>, opts?: IntlMessageFormatOptions): string;
-    $t<T extends TBase>(this: void, descriptor: MessageDescriptor, values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T>>, opts?: IntlMessageFormatOptions): string | T | (T | string)[];
-    formatList(this: void, values: Iterable<string>, opts?: FormatListOptions): string;
-    formatList<T extends TBase>(this: void, values: Iterable<string | T>, opts?: FormatListOptions): T | string | (string | T)[];
-    formatListToParts<T extends TBase>(this: void, values: Iterable<string | T>, opts?: FormatListOptions): Part[];
-    formatDisplayName(this: void, value: Parameters<Intl.DisplayNames['of']>[0], opts: FormatDisplayNameOptions): string | undefined;
-}
-export interface Formatters {
-    getDateTimeFormat(this: void, ...args: ConstructorParameters<typeof Intl.DateTimeFormat>): Intl.DateTimeFormat;
-    getNumberFormat(this: void, locales?: string | string[], opts?: NumberFormatOptions): Intl.NumberFormat;
-    getMessageFormat(this: void, ...args: ConstructorParameters<typeof IntlMessageFormat>): IntlMessageFormat;
-    getRelativeTimeFormat(this: void, ...args: ConstructorParameters<typeof Intl.RelativeTimeFormat>): Intl.RelativeTimeFormat;
-    getPluralRules(this: void, ...args: ConstructorParameters<typeof Intl.PluralRules>): Intl.PluralRules;
-    getListFormat(this: void, ...args: ConstructorParameters<typeof Intl.ListFormat>): Intl.ListFormat;
-    getDisplayNames(this: void, ...args: ConstructorParameters<typeof Intl.DisplayNames>): Intl.DisplayNames;
-}
-export interface IntlShape<T = string> extends ResolvedIntlConfig<T>, IntlFormatters<T> {
-    formatters: Formatters;
-}
-export interface IntlCache {
-    dateTime: Record<string, Intl.DateTimeFormat>;
-    number: Record<string, Intl.NumberFormat>;
-    message: Record<string, IntlMessageFormat>;
-    relativeTime: Record<string, Intl.RelativeTimeFormat>;
-    pluralRules: Record<string, Intl.PluralRules>;
-    list: Record<string, Intl.ListFormat>;
-    displayNames: Record<string, Intl.DisplayNames>;
-}
-export interface MessageDescriptor {
-    id?: MessageIds;
-    description?: string | object;
-    defaultMessage?: string | MessageFormatElement[];
-}
-export type IntlConfig<T = string> = Omit<ResolvedIntlConfig<T>, keyof typeof DEFAULT_INTL_CONFIG> & Partial<typeof DEFAULT_INTL_CONFIG>;
-export {};

package/lib/src/types.js

@@ -1 +0,0 @@
-export {};

package/lib/src/utils.d.ts

@@ -1,12 +0,0 @@
-import { NumberFormatOptions } from '@formatjs/ecma402-abstract';
-import { CustomFormats, Formatters, IntlCache, OnErrorFn, ResolvedIntlConfig } from './types';
-export declare function invariant(condition: boolean, message: string, Err?: any): asserts condition;
-export declare function filterProps<T extends Record<string, any>, K extends string>(props: T, allowlist: Array<K>, defaults?: Partial<T>): Pick<T, K>;
-export declare const DEFAULT_INTL_CONFIG: Pick<ResolvedIntlConfig<any>, 'fallbackOnEmptyString' | 'formats' | 'messages' | 'timeZone' | 'defaultLocale' | 'defaultFormats' | 'onError' | 'onWarn'>;
-export declare function createIntlCache(): IntlCache;
-/**
- * Create intl formatters and populate cache
- * @param cache explicit cache to prevent leaking memory
- */
-export declare function createFormatters(cache?: IntlCache): Formatters;
-export declare function getNamedFormat<T extends keyof CustomFormats>(formats: CustomFormats, type: T, name: string, onError: OnErrorFn): NumberFormatOptions | Intl.DateTimeFormatOptions | Intl.RelativeTimeFormatOptions | undefined;

package/lib/src/utils.js

@@ -1,168 +0,0 @@
-import { __assign, __spreadArray } from "tslib";
-import { memoize, strategies } from '@formatjs/fast-memoize';
-import { IntlMessageFormat } from 'intl-messageformat';
-import { UnsupportedFormatterError } from './error';
-export function invariant(condition, message, Err) {
-    if (Err === void 0) { Err = Error; }
-    if (!condition) {
-        throw new Err(message);
-    }
-}
-export function filterProps(props, allowlist, defaults) {
-    if (defaults === void 0) { defaults = {}; }
-    return allowlist.reduce(function (filtered, name) {
-        if (name in props) {
-            filtered[name] = props[name];
-        }
-        else if (name in defaults) {
-            filtered[name] = defaults[name];
-        }
-        return filtered;
-    }, {});
-}
-var defaultErrorHandler = function (error) {
-    // @ts-ignore just so we don't need to declare dep on @types/node
-    if (process.env.NODE_ENV !== 'production') {
-        console.error(error);
-    }
-};
-var defaultWarnHandler = function (warning) {
-    // @ts-ignore just so we don't need to declare dep on @types/node
-    if (process.env.NODE_ENV !== 'production') {
-        console.warn(warning);
-    }
-};
-export var DEFAULT_INTL_CONFIG = {
-    formats: {},
-    messages: {},
-    timeZone: undefined,
-    defaultLocale: 'en',
-    defaultFormats: {},
-    fallbackOnEmptyString: true,
-    onError: defaultErrorHandler,
-    onWarn: defaultWarnHandler,
-};
-export function createIntlCache() {
-    return {
-        dateTime: {},
-        number: {},
-        message: {},
-        relativeTime: {},
-        pluralRules: {},
-        list: {},
-        displayNames: {},
-    };
-}
-function createFastMemoizeCache(store) {
-    return {
-        create: function () {
-            return {
-                get: function (key) {
-                    return store[key];
-                },
-                set: function (key, value) {
-                    store[key] = value;
-                },
-            };
-        },
-    };
-}
-/**
- * Create intl formatters and populate cache
- * @param cache explicit cache to prevent leaking memory
- */
-export function createFormatters(cache) {
-    if (cache === void 0) { cache = createIntlCache(); }
-    var RelativeTimeFormat = Intl.RelativeTimeFormat;
-    var ListFormat = Intl.ListFormat;
-    var DisplayNames = Intl.DisplayNames;
-    var getDateTimeFormat = memoize(function () {
-        var _a;
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        return new ((_a = Intl.DateTimeFormat).bind.apply(_a, __spreadArray([void 0], args, false)))();
-    }, {
-        cache: createFastMemoizeCache(cache.dateTime),
-        strategy: strategies.variadic,
-    });
-    var getNumberFormat = memoize(function () {
-        var _a;
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        return new ((_a = Intl.NumberFormat).bind.apply(_a, __spreadArray([void 0], args, false)))();
-    }, {
-        cache: createFastMemoizeCache(cache.number),
-        strategy: strategies.variadic,
-    });
-    var getPluralRules = memoize(function () {
-        var _a;
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        return new ((_a = Intl.PluralRules).bind.apply(_a, __spreadArray([void 0], args, false)))();
-    }, {
-        cache: createFastMemoizeCache(cache.pluralRules),
-        strategy: strategies.variadic,
-    });
-    return {
-        getDateTimeFormat: getDateTimeFormat,
-        getNumberFormat: getNumberFormat,
-        getMessageFormat: memoize(function (message, locales, overrideFormats, opts) {
-            return new IntlMessageFormat(message, locales, overrideFormats, __assign({ formatters: {
-                    getNumberFormat: getNumberFormat,
-                    getDateTimeFormat: getDateTimeFormat,
-                    getPluralRules: getPluralRules,
-                } }, (opts || {})));
-        }, {
-            cache: createFastMemoizeCache(cache.message),
-            strategy: strategies.variadic,
-        }),
-        getRelativeTimeFormat: memoize(function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            return new (RelativeTimeFormat.bind.apply(RelativeTimeFormat, __spreadArray([void 0], args, false)))();
-        }, {
-            cache: createFastMemoizeCache(cache.relativeTime),
-            strategy: strategies.variadic,
-        }),
-        getPluralRules: getPluralRules,
-        getListFormat: memoize(function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            return new (ListFormat.bind.apply(ListFormat, __spreadArray([void 0], args, false)))();
-        }, {
-            cache: createFastMemoizeCache(cache.list),
-            strategy: strategies.variadic,
-        }),
-        getDisplayNames: memoize(function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            return new (DisplayNames.bind.apply(DisplayNames, __spreadArray([void 0], args, false)))();
-        }, {
-            cache: createFastMemoizeCache(cache.displayNames),
-            strategy: strategies.variadic,
-        }),
-    };
-}
-export function getNamedFormat(formats, type, name, onError) {
-    var formatType = formats && formats[type];
-    var format;
-    if (formatType) {
-        format = formatType[name];
-    }
-    if (format) {
-        return format;
-    }
-    onError(new UnsupportedFormatterError("No ".concat(type, " format named: ").concat(name)));
-}