intl-messageformat 11.2.0 → 11.2.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "intl-messageformat",
   "description": "Formats ICU Message strings with number, date, plural, and select placeholders to create localized messages.",
-  "version": "11.2.0",
+  "version": "11.2.1",
   "license": "BSD-3-Clause",
   "author": "Eric Ferraiuolo <eferraiuolo@gmail.com>",
   "type": "module",
@@ -11,9 +11,8 @@
     ".": "./index.js"
   },
   "dependencies": {
-    "@formatjs/ecma402-abstract": "3.2.0",
-    "@formatjs/icu-messageformat-parser": "3.5.3",
-    "@formatjs/fast-memoize": "3.1.1"
+    "@formatjs/fast-memoize": "3.1.2",
+    "@formatjs/icu-messageformat-parser": "3.5.4"
   },
   "bugs": "https://github.com/formatjs/formatjs/issues",
   "contributors": [

package/src/core.d.ts

@@ -1,26 +0,0 @@
-import { type MessageFormatElement, parse, type ParserOptions } from "@formatjs/icu-messageformat-parser";
-import { type Formats, type Formatters, type FormatXMLElementFn, type MessageFormatPart, type PrimitiveType } from "./formatters.js";
-export interface Options extends Omit<ParserOptions, "locale"> {
-	formatters?: Formatters;
-}
-export declare class IntlMessageFormat {
-	private readonly ast;
-	private readonly locales;
-	private readonly resolvedLocale?;
-	private readonly formatters;
-	private readonly formats;
-	private readonly message;
-	private readonly formatterCache;
-	constructor(message: string | MessageFormatElement[], locales?: string | string[], overrideFormats?: Partial<Formats>, opts?: Options);
-	format: <T = void>(values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T>>) => string | T | (string | T)[];
-	formatToParts: <T>(values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T>>) => MessageFormatPart<T>[];
-	resolvedOptions: () => {
-		locale: string;
-	};
-	getAst: () => MessageFormatElement[];
-	private static memoizedDefaultLocale;
-	static get defaultLocale(): string;
-	static resolveLocale: (locales: string | string[]) => Intl.Locale | undefined;
-	static __parse: typeof parse | undefined;
-	static formats: Formats;
-}

package/src/core.js

@@ -1,201 +0,0 @@
-/*
-Copyright (c) 2014, Yahoo! Inc. All rights reserved.
-Copyrights licensed under the New BSD License.
-See the accompanying LICENSE file for terms.
-*/
-import { memoize, strategies } from "@formatjs/fast-memoize";
-import { parse } from "@formatjs/icu-messageformat-parser";
-import { formatToParts, PART_TYPE } from "./formatters.js";
-// -- MessageFormat --------------------------------------------------------
-function mergeConfig(c1, c2) {
-	if (!c2) {
-		return c1;
-	}
-	return {
-		...c1,
-		...c2,
-		...Object.keys(c1).reduce((all, k) => {
-			all[k] = {
-				...c1[k],
-				...c2[k]
-			};
-			return all;
-		}, {})
-	};
-}
-function mergeConfigs(defaultConfig, configs) {
-	if (!configs) {
-		return defaultConfig;
-	}
-	return Object.keys(defaultConfig).reduce((all, k) => {
-		all[k] = mergeConfig(defaultConfig[k], configs[k]);
-		return all;
-	}, { ...defaultConfig });
-}
-function createFastMemoizeCache(store) {
-	return { create() {
-		return {
-			get(key) {
-				return store[key];
-			},
-			set(key, value) {
-				store[key] = value;
-			}
-		};
-	} };
-}
-function createDefaultFormatters(cache = {
-	number: {},
-	dateTime: {},
-	pluralRules: {}
-}) {
-	return {
-		getNumberFormat: memoize((...args) => new Intl.NumberFormat(...args), {
-			cache: createFastMemoizeCache(cache.number),
-			strategy: strategies.variadic
-		}),
-		getDateTimeFormat: memoize((...args) => new Intl.DateTimeFormat(...args), {
-			cache: createFastMemoizeCache(cache.dateTime),
-			strategy: strategies.variadic
-		}),
-		getPluralRules: memoize((...args) => new Intl.PluralRules(...args), {
-			cache: createFastMemoizeCache(cache.pluralRules),
-			strategy: strategies.variadic
-		})
-	};
-}
-export class IntlMessageFormat {
-	ast;
-	locales;
-	resolvedLocale;
-	formatters;
-	formats;
-	message;
-	formatterCache = {
-		number: {},
-		dateTime: {},
-		pluralRules: {}
-	};
-	constructor(message, locales = IntlMessageFormat.defaultLocale, overrideFormats, opts) {
-		// Defined first because it's used to build the format pattern.
-		this.locales = locales;
-		this.resolvedLocale = IntlMessageFormat.resolveLocale(locales);
-		if (typeof message === "string") {
-			this.message = message;
-			if (!IntlMessageFormat.__parse) {
-				throw new TypeError("IntlMessageFormat.__parse must be set to process `message` of type `string`");
-			}
-			const { ...parseOpts } = opts || {};
-			// Parse string messages into an AST.
-			this.ast = IntlMessageFormat.__parse(message, {
-				...parseOpts,
-				locale: this.resolvedLocale
-			});
-		} else {
-			this.ast = message;
-		}
-		if (!Array.isArray(this.ast)) {
-			throw new TypeError("A message must be provided as a String or AST.");
-		}
-		// Creates a new object with the specified `formats` merged with the default
-		// formats.
-		this.formats = mergeConfigs(IntlMessageFormat.formats, overrideFormats);
-		this.formatters = opts && opts.formatters || createDefaultFormatters(this.formatterCache);
-	}
-	format = (values) => {
-		const parts = this.formatToParts(values);
-		// Hot path for straight simple msg translations
-		if (parts.length === 1) {
-			return parts[0].value;
-		}
-		const result = parts.reduce((all, part) => {
-			if (!all.length || part.type !== PART_TYPE.literal || typeof all[all.length - 1] !== "string") {
-				all.push(part.value);
-			} else {
-				all[all.length - 1] += part.value;
-			}
-			return all;
-		}, []);
-		if (result.length <= 1) {
-			return result[0] || "";
-		}
-		return result;
-	};
-	formatToParts = (values) => formatToParts(this.ast, this.locales, this.formatters, this.formats, values, undefined, this.message);
-	resolvedOptions = () => ({ locale: this.resolvedLocale?.toString() || Intl.NumberFormat.supportedLocalesOf(this.locales)[0] });
-	getAst = () => this.ast;
-	static memoizedDefaultLocale = null;
-	static get defaultLocale() {
-		if (!IntlMessageFormat.memoizedDefaultLocale) {
-			IntlMessageFormat.memoizedDefaultLocale = new Intl.NumberFormat().resolvedOptions().locale;
-		}
-		return IntlMessageFormat.memoizedDefaultLocale;
-	}
-	static resolveLocale = (locales) => {
-		if (typeof Intl.Locale === "undefined") {
-			return;
-		}
-		const supportedLocales = Intl.NumberFormat.supportedLocalesOf(locales);
-		if (supportedLocales.length > 0) {
-			return new Intl.Locale(supportedLocales[0]);
-		}
-		return new Intl.Locale(typeof locales === "string" ? locales : locales[0]);
-	};
-	static __parse = parse;
-	// Default format options used as the prototype of the `formats` provided to the
-	// constructor. These are used when constructing the internal Intl.NumberFormat
-	// and Intl.DateTimeFormat instances.
-	static formats = {
-		number: {
-			integer: { maximumFractionDigits: 0 },
-			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/src/error.d.ts

@@ -1,27 +0,0 @@
-export declare enum ErrorCode {
-	MISSING_VALUE = "MISSING_VALUE",
-	INVALID_VALUE = "INVALID_VALUE",
-	MISSING_INTL_API = "MISSING_INTL_API"
-}
-export declare class FormatError extends Error {
-	readonly code: ErrorCode;
-	/**
-	* Original message we're trying to format
-	* `undefined` if we're only dealing w/ AST
-	*
-	* @type {(string | undefined)}
-	* @memberof FormatError
-	*/
-	readonly originalMessage: string | undefined;
-	constructor(msg: string, code: ErrorCode, originalMessage?: string);
-	toString(): string;
-}
-export declare class InvalidValueError extends FormatError {
-	constructor(variableId: string, value: any, options: string[], originalMessage?: string);
-}
-export declare class InvalidValueTypeError extends FormatError {
-	constructor(value: any, type: string, originalMessage?: string);
-}
-export declare class MissingValueError extends FormatError {
-	constructor(variableId: string, originalMessage?: string);
-}

package/src/error.js

@@ -1,43 +0,0 @@
-export let ErrorCode = /* @__PURE__ */ function(ErrorCode) {
-	// When we have a placeholder but no value to format
-	ErrorCode["MISSING_VALUE"] = "MISSING_VALUE";
-	// When value supplied is invalid
-	ErrorCode["INVALID_VALUE"] = "INVALID_VALUE";
-	// When we need specific Intl API but it's not available
-	ErrorCode["MISSING_INTL_API"] = "MISSING_INTL_API";
-	return ErrorCode;
-}({});
-export class FormatError extends Error {
-	code;
-	/**
-	* Original message we're trying to format
-	* `undefined` if we're only dealing w/ AST
-	*
-	* @type {(string | undefined)}
-	* @memberof FormatError
-	*/
-	originalMessage;
-	constructor(msg, code, originalMessage) {
-		super(msg);
-		this.code = code;
-		this.originalMessage = originalMessage;
-	}
-	toString() {
-		return `[formatjs Error: ${this.code}] ${this.message}`;
-	}
-}
-export class InvalidValueError extends FormatError {
-	constructor(variableId, value, options, originalMessage) {
-		super(`Invalid values for "${variableId}": "${value}". Options are "${Object.keys(options).join("\", \"")}"`, ErrorCode.INVALID_VALUE, originalMessage);
-	}
-}
-export class InvalidValueTypeError extends FormatError {
-	constructor(value, type, originalMessage) {
-		super(`Value for "${value}" must be of type ${type}`, ErrorCode.INVALID_VALUE, originalMessage);
-	}
-}
-export class MissingValueError extends FormatError {
-	constructor(variableId, originalMessage) {
-		super(`The intl string context variable "${variableId}" was not provided to the string "${originalMessage}"`, ErrorCode.MISSING_VALUE, originalMessage);
-	}
-}

package/src/formatters.d.ts

@@ -1,46 +0,0 @@
-import { type NumberFormatOptions } from "@formatjs/ecma402-abstract";
-import { type MessageFormatElement } from "@formatjs/icu-messageformat-parser";
-declare global {
-	namespace FormatjsIntl {
-		interface Message {}
-		interface IntlConfig {}
-		interface Formats {}
-	}
-}
-type Format<Source = string> = Source extends keyof FormatjsIntl.Formats ? FormatjsIntl.Formats[Source] : string;
-export interface Formats {
-	number: Record<Format<"number">, NumberFormatOptions>;
-	date: Record<Format<"date">, Intl.DateTimeFormatOptions>;
-	time: Record<Format<"time">, Intl.DateTimeFormatOptions>;
-}
-export interface FormatterCache {
-	number: Record<string, NumberFormatOptions>;
-	dateTime: Record<string, Intl.DateTimeFormat>;
-	pluralRules: Record<string, Intl.PluralRules>;
-}
-export interface Formatters {
-	getNumberFormat(locals?: string | string[], opts?: NumberFormatOptions): Intl.NumberFormat;
-	getDateTimeFormat(...args: ConstructorParameters<typeof Intl.DateTimeFormat>): Intl.DateTimeFormat;
-	getPluralRules(...args: ConstructorParameters<typeof Intl.PluralRules>): Intl.PluralRules;
-}
-export declare enum PART_TYPE {
-	literal = 0,
-	object = 1
-}
-export interface LiteralPart {
-	type: PART_TYPE.literal;
-	value: string;
-}
-export interface ObjectPart<T = any> {
-	type: PART_TYPE.object;
-	value: T;
-}
-export type MessageFormatPart<T> = LiteralPart | ObjectPart<T>;
-export type PrimitiveType = string | number | bigint | boolean | null | undefined | Date;
-export declare function isFormatXMLElementFn<T>(el: PrimitiveType | T | FormatXMLElementFn<T>): el is FormatXMLElementFn<T>;
-export declare function formatToParts<T>(els: MessageFormatElement[], locales: string | string[], formatters: Formatters, formats: Formats, values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T>>, currentPluralValue?: number, originalMessage?: string): MessageFormatPart<T>[];
-export type FormatXMLElementFn<
-	T,
-	R = string | T | (string | T)[]
-> = (parts: Array<string | T>) => R;
-export {};

package/src/formatters.js

@@ -1,166 +0,0 @@
-import "@formatjs/ecma402-abstract";
-import { isArgumentElement, isDateElement, isDateTimeSkeleton, isLiteralElement, isNumberElement, isNumberSkeleton, isPluralElement, isPoundElement, isSelectElement, isTagElement, isTimeElement } from "@formatjs/icu-messageformat-parser";
-import { ErrorCode, FormatError, InvalidValueError, InvalidValueTypeError, MissingValueError } from "./error.js";
-export let PART_TYPE = /* @__PURE__ */ function(PART_TYPE) {
-	PART_TYPE[PART_TYPE["literal"] = 0] = "literal";
-	PART_TYPE[PART_TYPE["object"] = 1] = "object";
-	return PART_TYPE;
-}({});
-function mergeLiteral(parts) {
-	if (parts.length < 2) {
-		return parts;
-	}
-	return parts.reduce((all, part) => {
-		const lastPart = all[all.length - 1];
-		if (!lastPart || lastPart.type !== PART_TYPE.literal || part.type !== PART_TYPE.literal) {
-			all.push(part);
-		} else {
-			lastPart.value += part.value;
-		}
-		return all;
-	}, []);
-}
-export function isFormatXMLElementFn(el) {
-	return typeof el === "function";
-}
-// TODO(skeleton): add skeleton support
-export function formatToParts(els, locales, formatters, formats, values, currentPluralValue, originalMessage) {
-	// Hot path for straight simple msg translations
-	if (els.length === 1 && isLiteralElement(els[0])) {
-		return [{
-			type: PART_TYPE.literal,
-			value: els[0].value
-		}];
-	}
-	const result = [];
-	for (const el of els) {
-		// Exit early for string parts.
-		if (isLiteralElement(el)) {
-			result.push({
-				type: PART_TYPE.literal,
-				value: el.value
-			});
-			continue;
-		}
-		// TODO: should this part be literal type?
-		// Replace `#` in plural rules with the actual numeric value.
-		if (isPoundElement(el)) {
-			if (typeof currentPluralValue === "number") {
-				result.push({
-					type: PART_TYPE.literal,
-					value: formatters.getNumberFormat(locales).format(currentPluralValue)
-				});
-			}
-			continue;
-		}
-		const { value: varName } = el;
-		// Enforce that all required values are provided by the caller.
-		if (!(values && varName in values)) {
-			throw new MissingValueError(varName, originalMessage);
-		}
-		let value = values[varName];
-		if (isArgumentElement(el)) {
-			if (!value || typeof value === "string" || typeof value === "number" || typeof value === "bigint") {
-				value = typeof value === "string" || typeof value === "number" || typeof value === "bigint" ? String(value) : "";
-			}
-			result.push({
-				type: typeof value === "string" ? PART_TYPE.literal : PART_TYPE.object,
-				value
-			});
-			continue;
-		}
-		// Recursively format plural and select parts' option — which can be a
-		// nested pattern structure. The choosing of the option to use is
-		// abstracted-by and delegated-to the part helper object.
-		if (isDateElement(el)) {
-			const style = typeof el.style === "string" ? formats.date[el.style] : isDateTimeSkeleton(el.style) ? el.style.parsedOptions : undefined;
-			result.push({
-				type: PART_TYPE.literal,
-				value: formatters.getDateTimeFormat(locales, style).format(value)
-			});
-			continue;
-		}
-		if (isTimeElement(el)) {
-			const style = typeof el.style === "string" ? formats.time[el.style] : isDateTimeSkeleton(el.style) ? el.style.parsedOptions : formats.time.medium;
-			result.push({
-				type: PART_TYPE.literal,
-				value: formatters.getDateTimeFormat(locales, style).format(value)
-			});
-			continue;
-		}
-		if (isNumberElement(el)) {
-			const style = typeof el.style === "string" ? formats.number[el.style] : isNumberSkeleton(el.style) ? el.style.parsedOptions : undefined;
-			if (style && style.scale) {
-				const scale = style.scale || 1;
-				// Handle bigint scale multiplication
-				// BigInt can only be multiplied by BigInt
-				if (typeof value === "bigint") {
-					// Check if scale is a safe integer that can be converted to BigInt
-					if (!Number.isInteger(scale)) {
-						throw new TypeError(`Cannot apply fractional scale ${scale} to bigint value. Scale must be an integer when formatting bigint.`);
-					}
-					value = value * BigInt(scale);
-				} else {
-					value = value * scale;
-				}
-			}
-			result.push({
-				type: PART_TYPE.literal,
-				value: formatters.getNumberFormat(locales, style).format(value)
-			});
-			continue;
-		}
-		if (isTagElement(el)) {
-			const { children, value } = el;
-			const formatFn = values[value];
-			if (!isFormatXMLElementFn(formatFn)) {
-				throw new InvalidValueTypeError(value, "function", originalMessage);
-			}
-			const parts = formatToParts(children, locales, formatters, formats, values, currentPluralValue);
-			let chunks = formatFn(parts.map((p) => p.value));
-			if (!Array.isArray(chunks)) {
-				chunks = [chunks];
-			}
-			result.push(...chunks.map((c) => {
-				return {
-					type: typeof c === "string" ? PART_TYPE.literal : PART_TYPE.object,
-					value: c
-				};
-			}));
-		}
-		if (isSelectElement(el)) {
-			// GH #4490: Use hasOwnProperty to avoid prototype chain issues with keys like "constructor"
-			const key = value;
-			const opt = (Object.prototype.hasOwnProperty.call(el.options, key) ? el.options[key] : undefined) || el.options.other;
-			if (!opt) {
-				throw new InvalidValueError(el.value, value, Object.keys(el.options), originalMessage);
-			}
-			result.push(...formatToParts(opt.value, locales, formatters, formats, values));
-			continue;
-		}
-		if (isPluralElement(el)) {
-			// GH #4490: Use hasOwnProperty to avoid prototype chain issues
-			const exactKey = `=${value}`;
-			let opt = Object.prototype.hasOwnProperty.call(el.options, exactKey) ? el.options[exactKey] : undefined;
-			if (!opt) {
-				if (!Intl.PluralRules) {
-					throw new FormatError(`Intl.PluralRules is not available in this environment.
-Try polyfilling it using "@formatjs/intl-pluralrules"
-`, ErrorCode.MISSING_INTL_API, originalMessage);
-				}
-				// Convert bigint to number for PluralRules (which only accepts number)
-				const numericValue = typeof value === "bigint" ? Number(value) : value;
-				const rule = formatters.getPluralRules(locales, { type: el.pluralType }).select(numericValue - (el.offset || 0));
-				opt = (Object.prototype.hasOwnProperty.call(el.options, rule) ? el.options[rule] : undefined) || el.options.other;
-			}
-			if (!opt) {
-				throw new InvalidValueError(el.value, value, Object.keys(el.options), originalMessage);
-			}
-			// Convert bigint to number for currentPluralValue
-			const numericValue = typeof value === "bigint" ? Number(value) : value;
-			result.push(...formatToParts(opt.value, locales, formatters, formats, values, numericValue - (el.offset || 0)));
-			continue;
-		}
-	}
-	return mergeLiteral(result);
-}