@formatjs/intl 4.1.5 → 4.1.6

package/src/relativeTime.js

@@ -1,28 +0,0 @@
-import "./types.js";
-import { getNamedFormat, filterProps } from "./utils.js";
-import { FormatError, ErrorCode } from "intl-messageformat";
-import { IntlFormatError } from "./error.js";
-const RELATIVE_TIME_FORMAT_OPTIONS = ["numeric", "style"];
-function getFormatter({ locale, formats, onError }, getRelativeTimeFormat, options = {}) {
-	const { format } = options;
-	const defaults = !!format && getNamedFormat(formats, "relative", format, onError) || {};
-	const filteredOptions = filterProps(options, RELATIVE_TIME_FORMAT_OPTIONS, defaults);
-	return getRelativeTimeFormat(locale, filteredOptions);
-}
-export function formatRelativeTime(config, getRelativeTimeFormat, value, unit, options = {}) {
-	if (!unit) {
-		unit = "second";
-	}
-	const RelativeTimeFormat = Intl.RelativeTimeFormat;
-	if (!RelativeTimeFormat) {
-		config.onError(new FormatError(`Intl.RelativeTimeFormat is not available in this environment.
-Try polyfilling it using "@formatjs/intl-relativetimeformat"
-`, ErrorCode.MISSING_INTL_API));
-	}
-	try {
-		return getFormatter(config, getRelativeTimeFormat, options).format(value, unit);
-	} catch (e) {
-		config.onError(new IntlFormatError("Error formatting relative time.", config.locale, e));
-	}
-	return String(value);
-}

package/src/types.d.ts

@@ -1,111 +0,0 @@
-import { type MessageFormatElement } from "@formatjs/icu-messageformat-parser";
-import { type NumberFormatOptions } from "@formatjs/ecma402-abstract";
-import type { FormatError, IntlMessageFormat } from "intl-messageformat";
-import { type Formats, type FormatXMLElementFn, type Options as IntlMessageFormatOptions, type PrimitiveType } from "intl-messageformat";
-import type { InvalidConfigError, MessageFormatError, MissingDataError, MissingTranslationError, UnsupportedFormatterError } from "./error.js";
-import type { DEFAULT_INTL_CONFIG } from "./utils.js";
-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 FormatTimeOptions = Omit<Intl.DateTimeFormatOptions, "localeMatcher"> & CustomFormatConfig<"time">;
-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?: FormatTimeOptions): 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/src/types.js

@@ -1,3 +0,0 @@
-import "@formatjs/icu-messageformat-parser";
-import "@formatjs/ecma402-abstract";
-import "intl-messageformat";

package/src/utils.d.ts

@@ -1,15 +0,0 @@
-import { type NumberFormatOptions } from "@formatjs/ecma402-abstract";
-import { type CustomFormats, type Formatters, type IntlCache, type OnErrorFn, type ResolvedIntlConfig } from "./types.js";
-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/src/utils.js

@@ -1,125 +0,0 @@
-import "@formatjs/ecma402-abstract";
-import { memoize, strategies } from "@formatjs/fast-memoize";
-import { IntlMessageFormat } from "intl-messageformat";
-import { UnsupportedFormatterError } from "./error.js";
-import "./types.js";
-export function invariant(condition, message, Err = Error) {
-	if (!condition) {
-		throw new Err(message);
-	}
-}
-export function filterProps(props, allowlist, defaults = {}) {
-	return allowlist.reduce((filtered, name) => {
-		if (name in props) {
-			filtered[name] = props[name];
-		} else if (name in defaults) {
-			filtered[name] = defaults[name];
-		}
-		return filtered;
-	}, {});
-}
-const defaultErrorHandler = (error) => {
-	// @ts-ignore just so we don't need to declare dep on @types/node
-	if (process.env.NODE_ENV !== "production") {
-		console.error(error);
-	}
-};
-const defaultWarnHandler = (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 const 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() {
-		return {
-			get(key) {
-				return store[key];
-			},
-			set(key, value) {
-				store[key] = value;
-			}
-		};
-	} };
-}
-/**
-* Create intl formatters and populate cache
-* @param cache explicit cache to prevent leaking memory
-*/
-export function createFormatters(cache = createIntlCache()) {
-	const RelativeTimeFormat = Intl.RelativeTimeFormat;
-	const ListFormat = Intl.ListFormat;
-	const DisplayNames = Intl.DisplayNames;
-	const getDateTimeFormat = memoize((...args) => new Intl.DateTimeFormat(...args), {
-		cache: createFastMemoizeCache(cache.dateTime),
-		strategy: strategies.variadic
-	});
-	const getNumberFormat = memoize((...args) => new Intl.NumberFormat(...args), {
-		cache: createFastMemoizeCache(cache.number),
-		strategy: strategies.variadic
-	});
-	const getPluralRules = memoize((...args) => new Intl.PluralRules(...args), {
-		cache: createFastMemoizeCache(cache.pluralRules),
-		strategy: strategies.variadic
-	});
-	return {
-		getDateTimeFormat,
-		getNumberFormat,
-		getMessageFormat: memoize((message, locales, overrideFormats, opts) => new IntlMessageFormat(message, locales, overrideFormats, {
-			formatters: {
-				getNumberFormat,
-				getDateTimeFormat,
-				getPluralRules
-			},
-			...opts
-		}), {
-			cache: createFastMemoizeCache(cache.message),
-			strategy: strategies.variadic
-		}),
-		getRelativeTimeFormat: memoize((...args) => new RelativeTimeFormat(...args), {
-			cache: createFastMemoizeCache(cache.relativeTime),
-			strategy: strategies.variadic
-		}),
-		getPluralRules,
-		getListFormat: memoize((...args) => new ListFormat(...args), {
-			cache: createFastMemoizeCache(cache.list),
-			strategy: strategies.variadic
-		}),
-		getDisplayNames: memoize((...args) => new DisplayNames(...args), {
-			cache: createFastMemoizeCache(cache.displayNames),
-			strategy: strategies.variadic
-		})
-	};
-}
-export function getNamedFormat(formats, type, name, onError) {
-	const formatType = formats && formats[type];
-	let format;
-	if (formatType) {
-		format = formatType[name];
-	}
-	if (format) {
-		return format;
-	}
-	onError(new UnsupportedFormatterError(`No ${type} format named: ${name}`));
-}