@formatjs/intl-localematcher 0.7.3 → 0.7.5

package/abstract/BestAvailableLocale.d.ts

@@ -1,6 +1,6 @@
 /**
- * https://tc39.es/ecma402/#sec-bestavailablelocale
- * @param availableLocales
- * @param locale
- */
+* https://tc39.es/ecma402/#sec-bestavailablelocale
+* @param availableLocales
+* @param locale
+*/
 export declare function BestAvailableLocale(availableLocales: readonly string[], locale: string): string | undefined;

package/abstract/BestAvailableLocale.js

@@ -1,29 +1,29 @@
 // Cache for Set conversions to avoid repeated array->Set conversions
-var availableLocalesSetCache = new WeakMap();
+const availableLocalesSetCache = new WeakMap();
 /**
- * https://tc39.es/ecma402/#sec-bestavailablelocale
- * @param availableLocales
- * @param locale
- */
+* https://tc39.es/ecma402/#sec-bestavailablelocale
+* @param availableLocales
+* @param locale
+*/
 export function BestAvailableLocale(availableLocales, locale) {
-    // Fast path: use Set for O(1) lookups instead of O(n) indexOf
-    var availableSet = availableLocalesSetCache.get(availableLocales);
-    if (!availableSet) {
-        availableSet = new Set(availableLocales);
-        availableLocalesSetCache.set(availableLocales, availableSet);
-    }
-    var candidate = locale;
-    while (true) {
-        if (availableSet.has(candidate)) {
-            return candidate;
-        }
-        var pos = candidate.lastIndexOf('-');
-        if (!~pos) {
-            return undefined;
-        }
-        if (pos >= 2 && candidate[pos - 2] === '-') {
-            pos -= 2;
-        }
-        candidate = candidate.slice(0, pos);
-    }
+	// Fast path: use Set for O(1) lookups instead of O(n) indexOf
+	let availableSet = availableLocalesSetCache.get(availableLocales);
+	if (!availableSet) {
+		availableSet = new Set(availableLocales);
+		availableLocalesSetCache.set(availableLocales, availableSet);
+	}
+	let candidate = locale;
+	while (true) {
+		if (availableSet.has(candidate)) {
+			return candidate;
+		}
+		let pos = candidate.lastIndexOf("-");
+		if (!~pos) {
+			return undefined;
+		}
+		if (pos >= 2 && candidate[pos - 2] === "-") {
+			pos -= 2;
+		}
+		candidate = candidate.slice(0, pos);
+	}
 }

package/abstract/BestFitMatcher.d.ts

@@ -1,8 +1,8 @@
-import { LookupMatcherResult } from './types.js';
+import type { LookupMatcherResult } from "./types.js";
 /**
- * https://tc39.es/ecma402/#sec-bestfitmatcher
- * @param availableLocales
- * @param requestedLocales
- * @param getDefaultLocale
- */
+* https://tc39.es/ecma402/#sec-bestfitmatcher
+* @param availableLocales
+* @param requestedLocales
+* @param getDefaultLocale
+*/
 export declare function BestFitMatcher(availableLocales: readonly string[], requestedLocales: readonly string[], getDefaultLocale: () => string): LookupMatcherResult;

package/abstract/BestFitMatcher.js

@@ -1,31 +1,30 @@
-import { UNICODE_EXTENSION_SEQUENCE_REGEX, findBestMatch } from './utils.js';
+import { UNICODE_EXTENSION_SEQUENCE_REGEX, findBestMatch } from "./utils.js";
 /**
- * https://tc39.es/ecma402/#sec-bestfitmatcher
- * @param availableLocales
- * @param requestedLocales
- * @param getDefaultLocale
- */
+* https://tc39.es/ecma402/#sec-bestfitmatcher
+* @param availableLocales
+* @param requestedLocales
+* @param getDefaultLocale
+*/
 export function BestFitMatcher(availableLocales, requestedLocales, getDefaultLocale) {
-    var foundLocale;
-    var extension;
-    var noExtensionLocales = [];
-    var noExtensionLocaleMap = requestedLocales.reduce(function (all, l) {
-        var noExtensionLocale = l.replace(UNICODE_EXTENSION_SEQUENCE_REGEX, '');
-        noExtensionLocales.push(noExtensionLocale);
-        all[noExtensionLocale] = l;
-        return all;
-    }, {});
-    var result = findBestMatch(noExtensionLocales, availableLocales);
-    if (result.matchedSupportedLocale && result.matchedDesiredLocale) {
-        foundLocale = result.matchedSupportedLocale;
-        extension =
-            noExtensionLocaleMap[result.matchedDesiredLocale].slice(result.matchedDesiredLocale.length) || undefined;
-    }
-    if (!foundLocale) {
-        return { locale: getDefaultLocale() };
-    }
-    return {
-        locale: foundLocale,
-        extension: extension,
-    };
+	let foundLocale;
+	let extension;
+	const noExtensionLocales = [];
+	const noExtensionLocaleMap = requestedLocales.reduce((all, l) => {
+		const noExtensionLocale = l.replace(UNICODE_EXTENSION_SEQUENCE_REGEX, "");
+		noExtensionLocales.push(noExtensionLocale);
+		all[noExtensionLocale] = l;
+		return all;
+	}, {});
+	const result = findBestMatch(noExtensionLocales, availableLocales);
+	if (result.matchedSupportedLocale && result.matchedDesiredLocale) {
+		foundLocale = result.matchedSupportedLocale;
+		extension = noExtensionLocaleMap[result.matchedDesiredLocale].slice(result.matchedDesiredLocale.length) || undefined;
+	}
+	if (!foundLocale) {
+		return { locale: getDefaultLocale() };
+	}
+	return {
+		locale: foundLocale,
+		extension
+	};
 }

package/abstract/CanonicalizeLocaleList.d.ts

@@ -1,5 +1,5 @@
 /**
- * http://ecma-international.org/ecma-402/7.0/index.html#sec-canonicalizelocalelist
- * @param locales
- */
+* http://ecma-international.org/ecma-402/7.0/index.html#sec-canonicalizelocalelist
+* @param locales
+*/
 export declare function CanonicalizeLocaleList(locales?: string | readonly string[]): string[];

package/abstract/CanonicalizeLocaleList.js

@@ -1,7 +1,7 @@
 /**
- * http://ecma-international.org/ecma-402/7.0/index.html#sec-canonicalizelocalelist
- * @param locales
- */
+* http://ecma-international.org/ecma-402/7.0/index.html#sec-canonicalizelocalelist
+* @param locales
+*/
 export function CanonicalizeLocaleList(locales) {
-    return Intl.getCanonicalLocales(locales);
+	return Intl.getCanonicalLocales(locales);
 }

package/abstract/CanonicalizeUValue.js

@@ -1,8 +1,8 @@
-import { invariant } from './utils.js';
+import { invariant } from "./utils.js";
 export function CanonicalizeUValue(ukey, uvalue) {
-    // TODO: Implement algorithm for CanonicalizeUValue per https://tc39.es/ecma402/#sec-canonicalizeuvalue
-    var lowerValue = uvalue.toLowerCase();
-    invariant(ukey !== undefined, "ukey must be defined");
-    var canonicalized = lowerValue;
-    return canonicalized;
+	// TODO: Implement algorithm for CanonicalizeUValue per https://tc39.es/ecma402/#sec-canonicalizeuvalue
+	let lowerValue = uvalue.toLowerCase();
+	invariant(ukey !== undefined, `ukey must be defined`);
+	let canonicalized = lowerValue;
+	return canonicalized;
 }

package/abstract/CanonicalizeUnicodeLocaleId.js

@@ -1,3 +1,3 @@
 export function CanonicalizeUnicodeLocaleId(locale) {
-    return Intl.getCanonicalLocales(locale)[0];
+	return Intl.getCanonicalLocales(locale)[0];
 }

package/abstract/InsertUnicodeExtensionAndCanonicalize.d.ts

@@ -1,2 +1,2 @@
-import { Keyword } from './types.js';
+import type { Keyword } from "./types.js";
 export declare function InsertUnicodeExtensionAndCanonicalize(locale: string, attributes: string[], keywords: Array<Keyword>): string;

package/abstract/InsertUnicodeExtensionAndCanonicalize.js

@@ -1,32 +1,29 @@
-import { CanonicalizeUnicodeLocaleId } from './CanonicalizeUnicodeLocaleId.js';
-import { invariant } from './utils.js';
+import { CanonicalizeUnicodeLocaleId } from "./CanonicalizeUnicodeLocaleId.js";
+import { invariant } from "./utils.js";
 export function InsertUnicodeExtensionAndCanonicalize(locale, attributes, keywords) {
-    invariant(locale.indexOf('-u-') === -1, 'Expected locale to not have a Unicode locale extension');
-    var extension = '-u';
-    for (var _i = 0, attributes_1 = attributes; _i < attributes_1.length; _i++) {
-        var attr = attributes_1[_i];
-        extension += "-".concat(attr);
-    }
-    for (var _a = 0, keywords_1 = keywords; _a < keywords_1.length; _a++) {
-        var kw = keywords_1[_a];
-        var key = kw.key, value = kw.value;
-        extension += "-".concat(key);
-        if (value !== '') {
-            extension += "-".concat(value);
-        }
-    }
-    if (extension === '-u') {
-        return CanonicalizeUnicodeLocaleId(locale);
-    }
-    var privateIndex = locale.indexOf('-x-');
-    var newLocale;
-    if (privateIndex === -1) {
-        newLocale = locale + extension;
-    }
-    else {
-        var preExtension = locale.slice(0, privateIndex);
-        var postExtension = locale.slice(privateIndex);
-        newLocale = preExtension + extension + postExtension;
-    }
-    return CanonicalizeUnicodeLocaleId(newLocale);
+	invariant(locale.indexOf("-u-") === -1, "Expected locale to not have a Unicode locale extension");
+	let extension = "-u";
+	for (const attr of attributes) {
+		extension += `-${attr}`;
+	}
+	for (const kw of keywords) {
+		const { key, value } = kw;
+		extension += `-${key}`;
+		if (value !== "") {
+			extension += `-${value}`;
+		}
+	}
+	if (extension === "-u") {
+		return CanonicalizeUnicodeLocaleId(locale);
+	}
+	let privateIndex = locale.indexOf("-x-");
+	let newLocale;
+	if (privateIndex === -1) {
+		newLocale = locale + extension;
+	} else {
+		let preExtension = locale.slice(0, privateIndex);
+		let postExtension = locale.slice(privateIndex);
+		newLocale = preExtension + extension + postExtension;
+	}
+	return CanonicalizeUnicodeLocaleId(newLocale);
 }

package/abstract/LookupMatcher.d.ts

@@ -1,8 +1,8 @@
-import { LookupMatcherResult } from './types.js';
+import type { LookupMatcherResult } from "./types.js";
 /**
- * https://tc39.es/ecma402/#sec-lookupmatcher
- * @param availableLocales
- * @param requestedLocales
- * @param getDefaultLocale
- */
+* https://tc39.es/ecma402/#sec-lookupmatcher
+* @param availableLocales
+* @param requestedLocales
+* @param getDefaultLocale
+*/
 export declare function LookupMatcher(availableLocales: readonly string[], requestedLocales: readonly string[], getDefaultLocale: () => string): LookupMatcherResult;

package/abstract/LookupMatcher.js

@@ -1,25 +1,24 @@
-import { BestAvailableLocale } from './BestAvailableLocale.js';
-import { UNICODE_EXTENSION_SEQUENCE_REGEX } from './utils.js';
+import { BestAvailableLocale } from "./BestAvailableLocale.js";
+import { UNICODE_EXTENSION_SEQUENCE_REGEX } from "./utils.js";
 /**
- * https://tc39.es/ecma402/#sec-lookupmatcher
- * @param availableLocales
- * @param requestedLocales
- * @param getDefaultLocale
- */
+* https://tc39.es/ecma402/#sec-lookupmatcher
+* @param availableLocales
+* @param requestedLocales
+* @param getDefaultLocale
+*/
 export function LookupMatcher(availableLocales, requestedLocales, getDefaultLocale) {
-    var result = { locale: '' };
-    for (var _i = 0, requestedLocales_1 = requestedLocales; _i < requestedLocales_1.length; _i++) {
-        var locale = requestedLocales_1[_i];
-        var noExtensionLocale = locale.replace(UNICODE_EXTENSION_SEQUENCE_REGEX, '');
-        var availableLocale = BestAvailableLocale(availableLocales, noExtensionLocale);
-        if (availableLocale) {
-            result.locale = availableLocale;
-            if (locale !== noExtensionLocale) {
-                result.extension = locale.slice(noExtensionLocale.length, locale.length);
-            }
-            return result;
-        }
-    }
-    result.locale = getDefaultLocale();
-    return result;
+	const result = { locale: "" };
+	for (const locale of requestedLocales) {
+		const noExtensionLocale = locale.replace(UNICODE_EXTENSION_SEQUENCE_REGEX, "");
+		const availableLocale = BestAvailableLocale(availableLocales, noExtensionLocale);
+		if (availableLocale) {
+			result.locale = availableLocale;
+			if (locale !== noExtensionLocale) {
+				result.extension = locale.slice(noExtensionLocale.length, locale.length);
+			}
+			return result;
+		}
+	}
+	result.locale = getDefaultLocale();
+	return result;
 }

package/abstract/LookupSupportedLocales.d.ts

@@ -1,6 +1,6 @@
 /**
- * https://tc39.es/ecma402/#sec-lookupsupportedlocales
- * @param availableLocales
- * @param requestedLocales
- */
+* https://tc39.es/ecma402/#sec-lookupsupportedlocales
+* @param availableLocales
+* @param requestedLocales
+*/
 export declare function LookupSupportedLocales(availableLocales: string[], requestedLocales: string[]): string[];

package/abstract/LookupSupportedLocales.js

@@ -1,19 +1,18 @@
-import { BestAvailableLocale } from './BestAvailableLocale.js';
-import { UNICODE_EXTENSION_SEQUENCE_REGEX } from './utils.js';
+import { BestAvailableLocale } from "./BestAvailableLocale.js";
+import { UNICODE_EXTENSION_SEQUENCE_REGEX } from "./utils.js";
 /**
- * https://tc39.es/ecma402/#sec-lookupsupportedlocales
- * @param availableLocales
- * @param requestedLocales
- */
+* https://tc39.es/ecma402/#sec-lookupsupportedlocales
+* @param availableLocales
+* @param requestedLocales
+*/
 export function LookupSupportedLocales(availableLocales, requestedLocales) {
-    var subset = [];
-    for (var _i = 0, requestedLocales_1 = requestedLocales; _i < requestedLocales_1.length; _i++) {
-        var locale = requestedLocales_1[_i];
-        var noExtensionLocale = locale.replace(UNICODE_EXTENSION_SEQUENCE_REGEX, '');
-        var availableLocale = BestAvailableLocale(availableLocales, noExtensionLocale);
-        if (availableLocale) {
-            subset.push(availableLocale);
-        }
-    }
-    return subset;
+	const subset = [];
+	for (const locale of requestedLocales) {
+		const noExtensionLocale = locale.replace(UNICODE_EXTENSION_SEQUENCE_REGEX, "");
+		const availableLocale = BestAvailableLocale(availableLocales, noExtensionLocale);
+		if (availableLocale) {
+			subset.push(availableLocale);
+		}
+	}
+	return subset;
 }

package/abstract/ResolveLocale.d.ts

@@ -1,14 +1,15 @@
 export interface ResolveLocaleResult {
-    locale: string;
-    dataLocale: string;
-    [k: string]: any;
+	locale: string;
+	dataLocale: string;
+	[k: string]: any;
 }
 /**
- * https://tc39.es/ecma402/#sec-resolvelocale
- */
-export declare function ResolveLocale<K extends string, D extends {
-    [k in K]: any;
-}>(availableLocales: Set<string> | readonly string[], requestedLocales: readonly string[], options: {
-    localeMatcher: string;
-    [k: string]: string;
+* https://tc39.es/ecma402/#sec-resolvelocale
+*/
+export declare function ResolveLocale<
+	K extends string,
+	D extends { [k in K] : any }
+>(availableLocales: Set<string> | readonly string[], requestedLocales: readonly string[], options: {
+	localeMatcher: string;
+	[k: string]: string;
 }, relevantExtensionKeys: K[], localeData: Record<string, D | undefined>, getDefaultLocale: () => string): ResolveLocaleResult;

package/abstract/ResolveLocale.js

@@ -1,100 +1,95 @@
-import { BestFitMatcher } from './BestFitMatcher.js';
-import { CanonicalizeUValue } from './CanonicalizeUValue.js';
-import { InsertUnicodeExtensionAndCanonicalize } from './InsertUnicodeExtensionAndCanonicalize.js';
-import { LookupMatcher } from './LookupMatcher.js';
-import { UnicodeExtensionComponents } from './UnicodeExtensionComponents.js';
-import { invariant } from './utils.js';
+import { BestFitMatcher } from "./BestFitMatcher.js";
+import { CanonicalizeUValue } from "./CanonicalizeUValue.js";
+import { InsertUnicodeExtensionAndCanonicalize } from "./InsertUnicodeExtensionAndCanonicalize.js";
+import { LookupMatcher } from "./LookupMatcher.js";
+import { UnicodeExtensionComponents } from "./UnicodeExtensionComponents.js";
+import { invariant } from "./utils.js";
 /**
- * https://tc39.es/ecma402/#sec-resolvelocale
- */
+* https://tc39.es/ecma402/#sec-resolvelocale
+*/
 export function ResolveLocale(availableLocales, requestedLocales, options, relevantExtensionKeys, localeData, getDefaultLocale) {
-    var _a;
-    var matcher = options.localeMatcher;
-    var r;
-    if (matcher === 'lookup') {
-        r = LookupMatcher(Array.from(availableLocales), requestedLocales, getDefaultLocale);
-    }
-    else {
-        r = BestFitMatcher(Array.from(availableLocales), requestedLocales, getDefaultLocale);
-    }
-    if (r == null) {
-        r = {
-            locale: getDefaultLocale(),
-            extension: '',
-        };
-    }
-    var foundLocale = r.locale;
-    var foundLocaleData = localeData[foundLocale];
-    // TODO: We can't really guarantee that the locale data is available
-    // invariant(
-    //   foundLocaleData !== undefined,
-    //   `Missing locale data for ${foundLocale}`
-    // )
-    var result = { locale: 'en', dataLocale: foundLocale };
-    var components;
-    var keywords;
-    if (r.extension) {
-        components = UnicodeExtensionComponents(r.extension);
-        keywords = components.keywords;
-    }
-    else {
-        keywords = [];
-    }
-    var supportedKeywords = [];
-    var _loop_1 = function (key) {
-        // TODO: Shouldn't default to empty array, see TODO above
-        var keyLocaleData = (_a = foundLocaleData === null || foundLocaleData === void 0 ? void 0 : foundLocaleData[key]) !== null && _a !== void 0 ? _a : [];
-        invariant(Array.isArray(keyLocaleData), "keyLocaleData for ".concat(key, " must be an array"));
-        var value = keyLocaleData[0];
-        invariant(value === undefined || typeof value === 'string', "value must be a string or undefined");
-        var supportedKeyword = void 0;
-        var entry = keywords.find(function (k) { return k.key === key; });
-        if (entry) {
-            var requestedValue = entry.value;
-            if (requestedValue !== '') {
-                if (keyLocaleData.indexOf(requestedValue) > -1) {
-                    value = requestedValue;
-                    supportedKeyword = {
-                        key: key,
-                        value: value,
-                    };
-                }
-            }
-            else if (keyLocaleData.indexOf('true') > -1) {
-                value = 'true';
-                supportedKeyword = {
-                    key: key,
-                    value: value,
-                };
-            }
-        }
-        var optionsValue = options[key];
-        invariant(optionsValue == null || typeof optionsValue === 'string', "optionsValue must be a string or undefined");
-        if (typeof optionsValue === 'string') {
-            var ukey = key.toLowerCase();
-            optionsValue = CanonicalizeUValue(ukey, optionsValue);
-            if (optionsValue === '') {
-                optionsValue = 'true';
-            }
-        }
-        if (optionsValue !== value && keyLocaleData.indexOf(optionsValue) > -1) {
-            value = optionsValue;
-            supportedKeyword = undefined;
-        }
-        if (supportedKeyword) {
-            supportedKeywords.push(supportedKeyword);
-        }
-        result[key] = value;
-    };
-    for (var _i = 0, relevantExtensionKeys_1 = relevantExtensionKeys; _i < relevantExtensionKeys_1.length; _i++) {
-        var key = relevantExtensionKeys_1[_i];
-        _loop_1(key);
-    }
-    var supportedAttributes = [];
-    if (supportedKeywords.length > 0) {
-        supportedAttributes = [];
-        foundLocale = InsertUnicodeExtensionAndCanonicalize(foundLocale, supportedAttributes, supportedKeywords);
-    }
-    result.locale = foundLocale;
-    return result;
+	const matcher = options.localeMatcher;
+	let r;
+	if (matcher === "lookup") {
+		r = LookupMatcher(Array.from(availableLocales), requestedLocales, getDefaultLocale);
+	} else {
+		r = BestFitMatcher(Array.from(availableLocales), requestedLocales, getDefaultLocale);
+	}
+	if (r == null) {
+		r = {
+			locale: getDefaultLocale(),
+			extension: ""
+		};
+	}
+	let foundLocale = r.locale;
+	let foundLocaleData = localeData[foundLocale];
+	// TODO: We can't really guarantee that the locale data is available
+	// invariant(
+	//   foundLocaleData !== undefined,
+	//   `Missing locale data for ${foundLocale}`
+	// )
+	const result = {
+		locale: "en",
+		dataLocale: foundLocale
+	};
+	let components;
+	let keywords;
+	if (r.extension) {
+		components = UnicodeExtensionComponents(r.extension);
+		keywords = components.keywords;
+	} else {
+		keywords = [];
+	}
+	let supportedKeywords = [];
+	for (const key of relevantExtensionKeys) {
+		// TODO: Shouldn't default to empty array, see TODO above
+		let keyLocaleData = foundLocaleData?.[key] ?? [];
+		invariant(Array.isArray(keyLocaleData), `keyLocaleData for ${key} must be an array`);
+		let value = keyLocaleData[0];
+		invariant(value === undefined || typeof value === "string", `value must be a string or undefined`);
+		let supportedKeyword;
+		let entry = keywords.find((k) => k.key === key);
+		if (entry) {
+			let requestedValue = entry.value;
+			if (requestedValue !== "") {
+				if (keyLocaleData.indexOf(requestedValue) > -1) {
+					value = requestedValue;
+					supportedKeyword = {
+						key,
+						value
+					};
+				}
+			} else if (keyLocaleData.indexOf("true") > -1) {
+				value = "true";
+				supportedKeyword = {
+					key,
+					value
+				};
+			}
+		}
+		let optionsValue = options[key];
+		invariant(optionsValue == null || typeof optionsValue === "string", `optionsValue must be a string or undefined`);
+		if (typeof optionsValue === "string") {
+			let ukey = key.toLowerCase();
+			optionsValue = CanonicalizeUValue(ukey, optionsValue);
+			if (optionsValue === "") {
+				optionsValue = "true";
+			}
+		}
+		if (optionsValue !== value && keyLocaleData.indexOf(optionsValue) > -1) {
+			value = optionsValue;
+			supportedKeyword = undefined;
+		}
+		if (supportedKeyword) {
+			supportedKeywords.push(supportedKeyword);
+		}
+		result[key] = value;
+	}
+	let supportedAttributes = [];
+	if (supportedKeywords.length > 0) {
+		supportedAttributes = [];
+		foundLocale = InsertUnicodeExtensionAndCanonicalize(foundLocale, supportedAttributes, supportedKeywords);
+	}
+	result.locale = foundLocale;
+	return result;
 }

package/abstract/UnicodeExtensionComponents.d.ts

@@ -1,5 +1,5 @@
-import { Keyword } from './types.js';
+import type { Keyword } from "./types.js";
 export declare function UnicodeExtensionComponents(extension: string): {
-    attributes: string[];
-    keywords: Array<Keyword>;
+	attributes: string[];
+	keywords: Array<Keyword>;
 };