@formatjs/intl-listformat 8.3.1 → 8.3.2

package/index.d.ts

@@ -1,72 +1,107 @@
-import { type ListPatternFieldsData, type ListPatternLocaleData, type LiteralPart } from "@formatjs/ecma402-abstract";
-export interface IntlListFormatOptions {
-	/**
-	* The locale matching algorithm to use.
-	* Possible values are "lookup" and "best fit"; the default is "best fit".
-	* For information about this option, see
-	* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_negotiation.
-	*/
-	localeMatcher?: "best fit" | "lookup";
-	/**
-	* The format of output message.
-	* Possible values are :
-	* - "conjunction" that stands for "and"-based lists (default, e.g., "A, B, and C")
-	* - "disjunction" that stands for "or"-based lists (e.g., "A, B, or C").
-	* - "unit" stands for lists of values with units (e.g., "5 pounds, 12 ounces").
-	*/
-	type?: "conjunction" | "disjunction" | "unit";
-	/**
-	* The length of the formatted message.
-	* Possible values are:
-	* - "long" (default, e.g., "A, B, and C");
-	* - "short" (e.g., "A, B, C"), or
-	* - "narrow" (e.g., "A B C").
-	* When style is "short" or "narrow", "unit" is the only allowed value for the type option.
-	*/
-	style?: "long" | "short" | "narrow";
+//#region packages/ecma402-abstract/types/core.d.ts
+type Locale = string;
+interface LocaleData<T> {
+  data: T;
+  locale: Locale;
 }
-export interface ResolvedIntlListFormatOptions {
-	/**
-	* A string with a BCP 47 language tag, or an array of such strings.
-	* For the general form and interpretation of the locales argument,
-	* see the [Intl](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locale_identification_and_negotiation) page.
-	*/
-	locale: string;
-	/**
-	* The format of output message.
-	* Possible values are :
-	* - "conjunction" that stands for "and"-based lists (default, e.g., "A, B, and C")
-	* - "disjunction" that stands for "or"-based lists (e.g., "A, B, or C").
-	* - "unit" stands for lists of values with units (e.g., "5 pounds, 12 ounces").
-	*/
-	type: "conjunction" | "disjunction" | "unit";
-	/**
-	* The length of the formatted message.
-	* Possible values are:
-	* - "long" (default, e.g., "A, B, and C");
-	* - "short" (e.g., "A, B, C"), or
-	* - "narrow" (e.g., "A B C").
-	* When style is "short" or "narrow", "unit" is the only allowed value for the type option.
-	*/
-	style: "long" | "short" | "narrow";
+//#endregion
+//#region packages/ecma402-abstract/types/list.d.ts
+type ListPatternLocaleData = LocaleData<ListPatternFieldsData>;
+interface ListPatternFieldsData {
+  conjunction?: ListPatternData;
+  disjunction?: ListPatternData;
+  unit?: ListPatternData;
 }
-export type Part<T = string> = LiteralPart | ElementPart | ElementPart<T>;
-export interface ElementPart<T = string> {
-	type: "element";
-	value: T;
+interface ListPattern {
+  start: string;
+  middle: string;
+  end: string;
+  pair: string;
 }
-export default class ListFormat {
-	constructor(locales?: string | string[], options?: IntlListFormatOptions);
-	format(elements: Iterable<string>): string;
-	formatToParts(elements: Iterable<string>): Part[];
-	resolvedOptions(): ResolvedIntlListFormatOptions;
-	static supportedLocalesOf(locales: string | string[], options?: Pick<IntlListFormatOptions, "localeMatcher">): string[];
-	static __addLocaleData(...data: ListPatternLocaleData[]): void;
-	static localeData: Record<string, ListPatternFieldsData | undefined>;
-	private static availableLocales;
-	private static __defaultLocale;
-	private static getDefaultLocale;
-	private static relevantExtensionKeys;
-	static polyfilled: boolean;
-	private static readonly __INTERNAL_SLOT_MAP__;
+interface ListPatternData {
+  long: ListPattern;
+  short?: ListPattern;
+  narrow?: ListPattern;
 }
+//#endregion
+//#region packages/ecma402-abstract/utils.d.ts
+interface LiteralPart {
+  type: "literal";
+  value: string;
+}
+//#endregion
+//#region packages/intl-listformat/index.d.ts
+interface IntlListFormatOptions {
+  /**
+  * The locale matching algorithm to use.
+  * Possible values are "lookup" and "best fit"; the default is "best fit".
+  * For information about this option, see
+  * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_negotiation.
+  */
+  localeMatcher?: "best fit" | "lookup";
+  /**
+  * The format of output message.
+  * Possible values are :
+  * - "conjunction" that stands for "and"-based lists (default, e.g., "A, B, and C")
+  * - "disjunction" that stands for "or"-based lists (e.g., "A, B, or C").
+  * - "unit" stands for lists of values with units (e.g., "5 pounds, 12 ounces").
+  */
+  type?: "conjunction" | "disjunction" | "unit";
+  /**
+  * The length of the formatted message.
+  * Possible values are:
+  * - "long" (default, e.g., "A, B, and C");
+  * - "short" (e.g., "A, B, C"), or
+  * - "narrow" (e.g., "A B C").
+  * When style is "short" or "narrow", "unit" is the only allowed value for the type option.
+  */
+  style?: "long" | "short" | "narrow";
+}
+interface ResolvedIntlListFormatOptions {
+  /**
+  * A string with a BCP 47 language tag, or an array of such strings.
+  * For the general form and interpretation of the locales argument,
+  * see the [Intl](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locale_identification_and_negotiation) page.
+  */
+  locale: string;
+  /**
+  * The format of output message.
+  * Possible values are :
+  * - "conjunction" that stands for "and"-based lists (default, e.g., "A, B, and C")
+  * - "disjunction" that stands for "or"-based lists (e.g., "A, B, or C").
+  * - "unit" stands for lists of values with units (e.g., "5 pounds, 12 ounces").
+  */
+  type: "conjunction" | "disjunction" | "unit";
+  /**
+  * The length of the formatted message.
+  * Possible values are:
+  * - "long" (default, e.g., "A, B, and C");
+  * - "short" (e.g., "A, B, C"), or
+  * - "narrow" (e.g., "A B C").
+  * When style is "short" or "narrow", "unit" is the only allowed value for the type option.
+  */
+  style: "long" | "short" | "narrow";
+}
+type Part<T = string> = LiteralPart | ElementPart | ElementPart<T>;
+interface ElementPart<T = string> {
+  type: "element";
+  value: T;
+}
+declare class ListFormat {
+  constructor(locales?: string | string[], options?: IntlListFormatOptions);
+  format(elements: Iterable<string>): string;
+  formatToParts(elements: Iterable<string>): Part[];
+  resolvedOptions(): ResolvedIntlListFormatOptions;
+  static supportedLocalesOf(locales: string | string[], options?: Pick<IntlListFormatOptions, "localeMatcher">): string[];
+  static __addLocaleData(...data: ListPatternLocaleData[]): void;
+  static localeData: Record<string, ListPatternFieldsData | undefined>;
+  private static availableLocales;
+  private static __defaultLocale;
+  private static getDefaultLocale;
+  private static relevantExtensionKeys;
+  static polyfilled: boolean;
+  private static readonly __INTERNAL_SLOT_MAP__;
+}
+//#endregion
+export { ElementPart, IntlListFormatOptions, Part, ResolvedIntlListFormatOptions, ListFormat as default };
+//# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,9 +1,212 @@
-import { CanonicalizeLocaleList, getInternalSlot, GetOption, GetOptionsObject, invariant, isLiteralPart, PartitionPattern, setInternalSlot, SupportedLocales } from "@formatjs/ecma402-abstract";
-import { ResolveLocale } from "@formatjs/intl-localematcher";
-function validateInstance(instance, method) {
-	if (!(instance instanceof ListFormat)) {
-		throw new TypeError(`Method Intl.ListFormat.prototype.${method} called on incompatible receiver ${String(instance)}`);
+import { LookupSupportedLocales, ResolveLocale } from "@formatjs/intl-localematcher";
+//#region packages/ecma402-abstract/CanonicalizeLocaleList.js
+/**
+* http://ecma-international.org/ecma-402/7.0/index.html#sec-canonicalizelocalelist
+* @param locales
+*/
+function CanonicalizeLocaleList(locales) {
+	return Intl.getCanonicalLocales(locales);
+}
+//#endregion
+//#region packages/ecma262-abstract/ToString.js
+/**
+* https://tc39.es/ecma262/#sec-tostring
+*/
+function ToString(o) {
+	if (typeof o === "symbol") throw TypeError("Cannot convert a Symbol value to a string");
+	return String(o);
+}
+//#endregion
+//#region packages/ecma402-abstract/GetOption.js
+/**
+* https://tc39.es/ecma402/#sec-getoption
+* @param opts
+* @param prop
+* @param type
+* @param values
+* @param fallback
+*/
+function GetOption(opts, prop, type, values, fallback) {
+	if (typeof opts !== "object") throw new TypeError("Options must be an object");
+	let value = opts[prop];
+	if (value !== void 0) {
+		if (type !== "boolean" && type !== "string") throw new TypeError("invalid type");
+		if (type === "boolean") value = Boolean(value);
+		if (type === "string") value = ToString(value);
+		if (values !== void 0 && !values.filter((val) => val == value).length) throw new RangeError(`${value} is not within ${values.join(", ")}`);
+		return value;
+	}
+	return fallback;
+}
+//#endregion
+//#region packages/ecma402-abstract/GetOptionsObject.js
+/**
+* https://tc39.es/ecma402/#sec-getoptionsobject
+* @param options
+* @returns
+*/
+function GetOptionsObject(options) {
+	if (typeof options === "undefined") return Object.create(null);
+	if (typeof options === "object") return options;
+	throw new TypeError("Options must be an object");
+}
+//#endregion
+//#region node_modules/.aspect_rules_js/@formatjs+fast-memoize@0.0.0/node_modules/@formatjs/fast-memoize/index.js
+function memoize(fn, options) {
+	const cache = options && options.cache ? options.cache : cacheDefault;
+	const serializer = options && options.serializer ? options.serializer : serializerDefault;
+	return (options && options.strategy ? options.strategy : strategyDefault)(fn, {
+		cache,
+		serializer
+	});
+}
+function isPrimitive(value) {
+	return value == null || typeof value === "number" || typeof value === "boolean";
+}
+function monadic(fn, cache, serializer, arg) {
+	const cacheKey = isPrimitive(arg) ? arg : serializer(arg);
+	let computedValue = cache.get(cacheKey);
+	if (typeof computedValue === "undefined") {
+		computedValue = fn.call(this, arg);
+		cache.set(cacheKey, computedValue);
+	}
+	return computedValue;
+}
+function variadic(fn, cache, serializer) {
+	const args = Array.prototype.slice.call(arguments, 3);
+	const cacheKey = serializer(args);
+	let computedValue = cache.get(cacheKey);
+	if (typeof computedValue === "undefined") {
+		computedValue = fn.apply(this, args);
+		cache.set(cacheKey, computedValue);
+	}
+	return computedValue;
+}
+function assemble(fn, context, strategy, cache, serialize) {
+	return strategy.bind(context, fn, cache, serialize);
+}
+function strategyDefault(fn, options) {
+	const strategy = fn.length === 1 ? monadic : variadic;
+	return assemble(fn, this, strategy, options.cache.create(), options.serializer);
+}
+function strategyVariadic(fn, options) {
+	return assemble(fn, this, variadic, options.cache.create(), options.serializer);
+}
+function strategyMonadic(fn, options) {
+	return assemble(fn, this, monadic, options.cache.create(), options.serializer);
+}
+const serializerDefault = function() {
+	return JSON.stringify(arguments);
+};
+var ObjectWithoutPrototypeCache = class {
+	constructor() {
+		this.cache = Object.create(null);
+	}
+	get(key) {
+		return this.cache[key];
+	}
+	set(key, value) {
+		this.cache[key] = value;
+	}
+};
+const cacheDefault = { create: function create() {
+	return new ObjectWithoutPrototypeCache();
+} };
+const strategies = {
+	variadic: strategyVariadic,
+	monadic: strategyMonadic
+};
+//#endregion
+//#region packages/ecma402-abstract/utils.js
+function setInternalSlot(map, pl, field, value) {
+	if (!map.get(pl)) map.set(pl, Object.create(null));
+	const slots = map.get(pl);
+	slots[field] = value;
+}
+function getInternalSlot(map, pl, field) {
+	return getMultiInternalSlots(map, pl, field)[field];
+}
+function getMultiInternalSlots(map, pl, ...fields) {
+	const slots = map.get(pl);
+	if (!slots) throw new TypeError(`${pl} InternalSlot has not been initialized`);
+	return fields.reduce((all, f) => {
+		all[f] = slots[f];
+		return all;
+	}, Object.create(null));
+}
+function isLiteralPart(patternPart) {
+	return patternPart.type === "literal";
+}
+function invariant(condition, message, Err = Error) {
+	if (!condition) throw new Err(message);
+}
+memoize((...args) => new Intl.NumberFormat(...args), { strategy: strategies.variadic });
+memoize((...args) => new Intl.PluralRules(...args), { strategy: strategies.variadic });
+memoize((...args) => new Intl.Locale(...args), { strategy: strategies.variadic });
+memoize((...args) => new Intl.ListFormat(...args), { strategy: strategies.variadic });
+//#endregion
+//#region packages/ecma402-abstract/PartitionPattern.js
+/**
+* Partition a pattern into a list of literals and placeholders
+* https://tc39.es/ecma402/#sec-partitionpattern
+* @param pattern
+*/
+function PartitionPattern(pattern) {
+	const result = [];
+	let beginIndex = pattern.indexOf("{");
+	let endIndex = 0;
+	let nextIndex = 0;
+	const length = pattern.length;
+	while (beginIndex < pattern.length && beginIndex > -1) {
+		endIndex = pattern.indexOf("}", beginIndex);
+		invariant(endIndex > beginIndex, `Invalid pattern ${pattern}`);
+		if (beginIndex > nextIndex) result.push({
+			type: "literal",
+			value: pattern.substring(nextIndex, beginIndex)
+		});
+		result.push({
+			type: pattern.substring(beginIndex + 1, endIndex),
+			value: void 0
+		});
+		nextIndex = endIndex + 1;
+		beginIndex = pattern.indexOf("{", nextIndex);
 	}
+	if (nextIndex < length) result.push({
+		type: "literal",
+		value: pattern.substring(nextIndex, length)
+	});
+	return result;
+}
+//#endregion
+//#region packages/ecma262-abstract/ToObject.js
+/**
+* https://tc39.es/ecma262/#sec-toobject
+*/
+function ToObject(arg) {
+	if (arg == null) throw new TypeError("undefined/null cannot be converted to object");
+	return Object(arg);
+}
+//#endregion
+//#region packages/ecma402-abstract/SupportedLocales.js
+/**
+* https://tc39.es/ecma402/#sec-supportedlocales
+* @param availableLocales
+* @param requestedLocales
+* @param options
+*/
+function SupportedLocales(availableLocales, requestedLocales, options) {
+	let matcher = "best fit";
+	if (options !== void 0) {
+		options = ToObject(options);
+		matcher = GetOption(options, "localeMatcher", "string", ["lookup", "best fit"], "best fit");
+	}
+	if (matcher === "best fit") return LookupSupportedLocales(Array.from(availableLocales), requestedLocales);
+	return LookupSupportedLocales(Array.from(availableLocales), requestedLocales);
+}
+//#endregion
+//#region packages/intl-listformat/index.ts
+function validateInstance(instance, method) {
+	if (!(instance instanceof ListFormat)) throw new TypeError(`Method Intl.ListFormat.prototype.${method} called on incompatible receiver ${String(instance)}`);
 }
 /**
 * https://tc39.es/proposal-intl-list-format/#sec-createstringlistfromiterable
@@ -27,39 +230,27 @@ function stringListFromIterable(iterable) {
 }
 function createPartsFromList(internalSlotMap, lf, list) {
 	const size = list.length;
-	if (size === 0) {
-		return [];
-	}
-	if (size === 2) {
-		const pattern = getInternalSlot(internalSlotMap, lf, "templatePair");
-		const first = {
+	if (size === 0) return [];
+	if (size === 2) return deconstructPattern(getInternalSlot(internalSlotMap, lf, "templatePair"), {
+		"0": {
 			type: "element",
 			value: list[0]
-		};
-		const second = {
+		},
+		"1": {
 			type: "element",
 			value: list[1]
-		};
-		return deconstructPattern(pattern, {
-			"0": first,
-			"1": second
-		});
-	}
-	const last = {
+		}
+	});
+	let parts = {
 		type: "element",
 		value: list[size - 1]
 	};
-	let parts = last;
 	let i = size - 2;
 	while (i >= 0) {
 		let pattern;
-		if (i === 0) {
-			pattern = getInternalSlot(internalSlotMap, lf, "templateStart");
-		} else if (i < size - 2) {
-			pattern = getInternalSlot(internalSlotMap, lf, "templateMiddle");
-		} else {
-			pattern = getInternalSlot(internalSlotMap, lf, "templateEnd");
-		}
+		if (i === 0) pattern = getInternalSlot(internalSlotMap, lf, "templateStart");
+		else if (i < size - 2) pattern = getInternalSlot(internalSlotMap, lf, "templateMiddle");
+		else pattern = getInternalSlot(internalSlotMap, lf, "templateEnd");
 		const head = {
 			type: "element",
 			value: list[i]
@@ -77,37 +268,27 @@ function deconstructPattern(pattern, placeables) {
 	const result = [];
 	for (const patternPart of patternParts) {
 		const { type: part } = patternPart;
-		if (isLiteralPart(patternPart)) {
-			result.push({
-				type: "literal",
-				value: patternPart.value
-			});
-		} else {
+		if (isLiteralPart(patternPart)) result.push({
+			type: "literal",
+			value: patternPart.value
+		});
+		else {
 			invariant(part in placeables, `${part} is missing from placables`);
 			const subst = placeables[part];
-			if (Array.isArray(subst)) {
-				result.push(...subst);
-			} else {
-				result.push(subst);
-			}
+			if (Array.isArray(subst)) result.push(...subst);
+			else result.push(subst);
 		}
 	}
 	return result;
 }
-export default class ListFormat {
+var ListFormat = class ListFormat {
 	constructor(locales, options) {
-		// test262/test/intl402/ListFormat/constructor/constructor/newtarget-undefined.js
-		// Cannot use `new.target` bc of IE11 & TS transpiles it to something else
-		const newTarget = this && this instanceof ListFormat ? this.constructor : void 0;
-		if (!newTarget) {
-			throw new TypeError("Intl.ListFormat must be called with 'new'");
-		}
+		if (!(this && this instanceof ListFormat ? this.constructor : void 0)) throw new TypeError("Intl.ListFormat must be called with 'new'");
 		setInternalSlot(ListFormat.__INTERNAL_SLOT_MAP__, this, "initializedListFormat", true);
 		const requestedLocales = CanonicalizeLocaleList(locales);
 		const opt = Object.create(null);
 		const opts = GetOptionsObject(options);
-		const matcher = GetOption(opts, "localeMatcher", "string", ["best fit", "lookup"], "best fit");
-		opt.localeMatcher = matcher;
+		opt.localeMatcher = GetOption(opts, "localeMatcher", "string", ["best fit", "lookup"], "best fit");
 		const { localeData } = ListFormat;
 		const r = ResolveLocale(ListFormat.availableLocales, requestedLocales, opt, ListFormat.relevantExtensionKeys, localeData, ListFormat.getDefaultLocale);
 		setInternalSlot(ListFormat.__INTERNAL_SLOT_MAP__, this, "locale", r.locale);
@@ -126,8 +307,7 @@ export default class ListFormat {
 		const { dataLocale } = r;
 		const dataLocaleData = localeData[dataLocale];
 		invariant(!!dataLocaleData, `Missing locale data for ${dataLocale}`);
-		const dataLocaleTypes = dataLocaleData[type];
-		const templates = dataLocaleTypes[style];
+		const templates = dataLocaleData[type][style];
 		setInternalSlot(ListFormat.__INTERNAL_SLOT_MAP__, this, "templatePair", templates.pair);
 		setInternalSlot(ListFormat.__INTERNAL_SLOT_MAP__, this, "templateStart", templates.start);
 		setInternalSlot(ListFormat.__INTERNAL_SLOT_MAP__, this, "templateMiddle", templates.middle);
@@ -137,24 +317,16 @@ export default class ListFormat {
 		validateInstance(this, "format");
 		let result = "";
 		const parts = createPartsFromList(ListFormat.__INTERNAL_SLOT_MAP__, this, stringListFromIterable(elements));
-		if (!Array.isArray(parts)) {
-			return parts.value;
-		}
-		for (const p of parts) {
-			result += p.value;
-		}
+		if (!Array.isArray(parts)) return parts.value;
+		for (const p of parts) result += p.value;
 		return result;
 	}
 	formatToParts(elements) {
 		validateInstance(this, "format");
 		const parts = createPartsFromList(ListFormat.__INTERNAL_SLOT_MAP__, this, stringListFromIterable(elements));
-		if (!Array.isArray(parts)) {
-			return [parts];
-		}
+		if (!Array.isArray(parts)) return [parts];
 		const result = [];
-		for (const part of parts) {
-			result.push({ ...part });
-		}
+		for (const part of parts) result.push({ ...part });
 		return result;
 	}
 	resolvedOptions() {
@@ -166,7 +338,6 @@ export default class ListFormat {
 		};
 	}
 	static supportedLocalesOf(locales, options) {
-		// test262/test/intl402/ListFormat/constructor/supportedLocalesOf/result-type.js
 		return SupportedLocales(ListFormat.availableLocales, CanonicalizeLocaleList(locales), options);
 	}
 	static __addLocaleData(...data) {
@@ -175,39 +346,44 @@ export default class ListFormat {
 			ListFormat.localeData[locale] = ListFormat.localeData[minimizedLocale] = d;
 			ListFormat.availableLocales.add(minimizedLocale);
 			ListFormat.availableLocales.add(locale);
-			if (!ListFormat.__defaultLocale) {
-				ListFormat.__defaultLocale = minimizedLocale;
-			}
+			if (!ListFormat.__defaultLocale) ListFormat.__defaultLocale = minimizedLocale;
 		}
 	}
-	static localeData = {};
-	static availableLocales = new Set();
-	static __defaultLocale = "";
+	static {
+		this.localeData = {};
+	}
+	static {
+		this.availableLocales = /* @__PURE__ */ new Set();
+	}
+	static {
+		this.__defaultLocale = "";
+	}
 	static getDefaultLocale() {
 		return ListFormat.__defaultLocale;
 	}
-	static relevantExtensionKeys = [];
-	static polyfilled = true;
-	static __INTERNAL_SLOT_MAP__ = new WeakMap();
-}
-try {
-	// IE11 does not have Symbol
-	if (typeof Symbol !== "undefined") {
-		Object.defineProperty(ListFormat.prototype, Symbol.toStringTag, {
-			value: "Intl.ListFormat",
-			writable: false,
-			enumerable: false,
-			configurable: true
-		});
+	static {
+		this.relevantExtensionKeys = [];
+	}
+	static {
+		this.polyfilled = true;
 	}
-	// https://github.com/tc39/test262/blob/master/test/intl402/ListFormat/constructor/length.js
+	static {
+		this.__INTERNAL_SLOT_MAP__ = /* @__PURE__ */ new WeakMap();
+	}
+};
+try {
+	if (typeof Symbol !== "undefined") Object.defineProperty(ListFormat.prototype, Symbol.toStringTag, {
+		value: "Intl.ListFormat",
+		writable: false,
+		enumerable: false,
+		configurable: true
+	});
 	Object.defineProperty(ListFormat.prototype.constructor, "length", {
 		value: 0,
 		writable: false,
 		enumerable: false,
 		configurable: true
 	});
-	// https://github.com/tc39/test262/blob/master/test/intl402/ListFormat/constructor/supportedLocalesOf/length.js
 	Object.defineProperty(ListFormat.supportedLocalesOf, "length", {
 		value: 1,
 		writable: false,
@@ -215,3 +391,7 @@ try {
 		configurable: true
 	});
 } catch {}
+//#endregion
+export { ListFormat as default };
+
+//# sourceMappingURL=index.js.map