@formatjs/intl-localematcher 0.4.2 → 0.5.1

package/abstract/utils.d.ts

@@ -1,2 +1,10 @@
 export declare const UNICODE_EXTENSION_SEQUENCE_REGEX: RegExp;
 export declare function invariant(condition: boolean, message: string, Err?: any): asserts condition;
+export declare function findMatchingDistance(desired: string, supported: string): number;
+interface LocaleMatchingResult {
+    distances: Record<string, Record<string, number>>;
+    matchedSupportedLocale?: string;
+    matchedDesiredLocale?: string;
+}
+export declare function findBestMatch(requestedLocales: readonly string[], supportedLocales: readonly string[], threshold?: number): LocaleMatchingResult;
+export {};

package/abstract/utils.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.invariant = exports.UNICODE_EXTENSION_SEQUENCE_REGEX = void 0;
+exports.findBestMatch = exports.findMatchingDistance = exports.invariant = exports.UNICODE_EXTENSION_SEQUENCE_REGEX = void 0;
+var tslib_1 = require("tslib");
+var languageMatching_1 = require("./languageMatching");
+var regions_generated_1 = require("./regions.generated");
 exports.UNICODE_EXTENSION_SEQUENCE_REGEX = /-u(?:-[0-9a-z]{2,8})+/gi;
 function invariant(condition, message, Err) {
     if (Err === void 0) { Err = Error; }
@@ -9,3 +12,159 @@ function invariant(condition, message, Err) {
     }
 }
 exports.invariant = invariant;
+// This is effectively 2 languages in 2 different regions not even in the same cluster
+var DEFAULT_MATCHING_THRESHOLD = 840;
+var PROCESSED_DATA;
+function processData() {
+    var _a, _b;
+    if (!PROCESSED_DATA) {
+        var paradigmLocales = (_b = (_a = languageMatching_1.data.supplemental.languageMatching['written-new'][0]) === null || _a === void 0 ? void 0 : _a.paradigmLocales) === null || _b === void 0 ? void 0 : _b._locales.split(' ');
+        var matchVariables = languageMatching_1.data.supplemental.languageMatching['written-new'].slice(1, 5);
+        var data = languageMatching_1.data.supplemental.languageMatching['written-new'].slice(5);
+        var matches = data.map(function (d) {
+            var key = Object.keys(d)[0];
+            var value = d[key];
+            return {
+                supported: key,
+                desired: value._desired,
+                distance: +value._distance,
+                oneway: value.oneway === 'true' ? true : false,
+            };
+        }, {});
+        PROCESSED_DATA = {
+            matches: matches,
+            matchVariables: matchVariables.reduce(function (all, d) {
+                var key = Object.keys(d)[0];
+                var value = d[key];
+                all[key.slice(1)] = value._value.split('+');
+                return all;
+            }, {}),
+            paradigmLocales: tslib_1.__spreadArray(tslib_1.__spreadArray([], paradigmLocales, true), paradigmLocales.map(function (l) {
+                return new Intl.Locale(l.replace(/_/g, '-')).maximize().toString();
+            }), true),
+        };
+    }
+    return PROCESSED_DATA;
+}
+function isMatched(locale, languageMatchInfoLocale, matchVariables) {
+    var _a = languageMatchInfoLocale.split('-'), language = _a[0], script = _a[1], region = _a[2];
+    var matches = true;
+    if (region && region[0] === '$') {
+        var shouldInclude = region[1] !== '!';
+        var matchRegions = shouldInclude
+            ? matchVariables[region.slice(1)]
+            : matchVariables[region.slice(2)];
+        var expandedMatchedRegions = matchRegions
+            .map(function (r) { return regions_generated_1.regions[r] || [r]; })
+            .reduce(function (all, list) { return tslib_1.__spreadArray(tslib_1.__spreadArray([], all, true), list, true); }, []);
+        matches && (matches = !(expandedMatchedRegions.indexOf(locale.region || '') > 1 !=
+            shouldInclude));
+    }
+    else {
+        matches && (matches = locale.region
+            ? region === '*' || region === locale.region
+            : true);
+    }
+    matches && (matches = locale.script ? script === '*' || script === locale.script : true);
+    matches && (matches = locale.language
+        ? language === '*' || language === locale.language
+        : true);
+    return matches;
+}
+function serializeLSR(lsr) {
+    return [lsr.language, lsr.script, lsr.region].filter(Boolean).join('-');
+}
+function findMatchingDistanceForLSR(desired, supported, data) {
+    for (var _i = 0, _a = data.matches; _i < _a.length; _i++) {
+        var d = _a[_i];
+        var matches = isMatched(desired, d.desired, data.matchVariables) &&
+            isMatched(supported, d.supported, data.matchVariables);
+        if (!d.oneway && !matches) {
+            matches =
+                isMatched(desired, d.supported, data.matchVariables) &&
+                    isMatched(supported, d.desired, data.matchVariables);
+        }
+        if (matches) {
+            var distance = d.distance * 10;
+            if (data.paradigmLocales.indexOf(serializeLSR(desired)) > -1 !=
+                data.paradigmLocales.indexOf(serializeLSR(supported)) > -1) {
+                return distance - 1;
+            }
+            return distance;
+        }
+    }
+    throw new Error('No matching distance found');
+}
+function findMatchingDistance(desired, supported) {
+    var desiredLocale = new Intl.Locale(desired).maximize();
+    var supportedLocale = new Intl.Locale(supported).maximize();
+    var desiredLSR = {
+        language: desiredLocale.language,
+        script: desiredLocale.script || '',
+        region: desiredLocale.region || '',
+    };
+    var supportedLSR = {
+        language: supportedLocale.language,
+        script: supportedLocale.script || '',
+        region: supportedLocale.region || '',
+    };
+    var matchingDistance = 0;
+    var data = processData();
+    if (desiredLSR.language !== supportedLSR.language) {
+        matchingDistance += findMatchingDistanceForLSR({
+            language: desiredLocale.language,
+            script: '',
+            region: '',
+        }, {
+            language: supportedLocale.language,
+            script: '',
+            region: '',
+        }, data);
+    }
+    if (desiredLSR.script !== supportedLSR.script) {
+        matchingDistance += findMatchingDistanceForLSR({
+            language: desiredLocale.language,
+            script: desiredLSR.script,
+            region: '',
+        }, {
+            language: supportedLocale.language,
+            script: desiredLSR.script,
+            region: '',
+        }, data);
+    }
+    if (desiredLSR.region !== supportedLSR.region) {
+        matchingDistance += findMatchingDistanceForLSR(desiredLSR, supportedLSR, data);
+    }
+    return matchingDistance;
+}
+exports.findMatchingDistance = findMatchingDistance;
+function findBestMatch(requestedLocales, supportedLocales, threshold) {
+    if (threshold === void 0) { threshold = DEFAULT_MATCHING_THRESHOLD; }
+    var lowestDistance = Infinity;
+    var result = {
+        matchedDesiredLocale: '',
+        distances: {},
+    };
+    requestedLocales.forEach(function (desired, i) {
+        if (!result.distances[desired]) {
+            result.distances[desired] = {};
+        }
+        supportedLocales.forEach(function (supported, j) {
+            // Add some weight to the distance based on the order of the supported locales
+            // Add penalty for the order of the requested locales
+            var distance = findMatchingDistance(desired, supported) + j + i * 40;
+            result.distances[desired][supported] = distance;
+            if (distance < lowestDistance) {
+                lowestDistance = distance;
+                result.matchedDesiredLocale = desired;
+                result.matchedSupportedLocale = supported;
+            }
+        });
+    });
+    if (lowestDistance >= threshold) {
+        result.matchedDesiredLocale = undefined;
+        result.matchedSupportedLocale = undefined;
+    }
+    return result;
+}
+exports.findBestMatch = findBestMatch;

package/index.js

@@ -4,11 +4,7 @@ exports.ResolveLocale = exports.LookupSupportedLocales = exports.match = void 0;
 var CanonicalizeLocaleList_1 = require("./abstract/CanonicalizeLocaleList");
 var ResolveLocale_1 = require("./abstract/ResolveLocale");
 function match(requestedLocales, availableLocales, defaultLocale, opts) {
-    var locales = availableLocales.reduce(function (all, l) {
-        all.add(l);
-        return all;
-    }, new Set());
-    return (0, ResolveLocale_1.ResolveLocale)(locales, (0, CanonicalizeLocaleList_1.CanonicalizeLocaleList)(requestedLocales), {
+    return (0, ResolveLocale_1.ResolveLocale)(availableLocales, (0, CanonicalizeLocaleList_1.CanonicalizeLocaleList)(requestedLocales), {
         localeMatcher: (opts === null || opts === void 0 ? void 0 : opts.algorithm) || 'best fit',
     }, [], {}, function () { return defaultLocale; }).locale;
 }

package/lib/abstract/BestAvailableLocale.d.ts

@@ -3,4 +3,4 @@
  * @param availableLocales
  * @param locale
  */
-export declare function BestAvailableLocale(availableLocales: Set<String>, locale: string): string | undefined;
+export declare function BestAvailableLocale(availableLocales: readonly string[], locale: string): string | undefined;

package/lib/abstract/BestAvailableLocale.js

@@ -1,12 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BestAvailableLocale = void 0;
 /**
  * https://tc39.es/ecma402/#sec-bestavailablelocale
  * @param availableLocales
  * @param locale
  */
-export function BestAvailableLocale(availableLocales, locale) {
+function BestAvailableLocale(availableLocales, locale) {
     var candidate = locale;
     while (true) {
-        if (availableLocales.has(candidate)) {
+        if (availableLocales.indexOf(candidate) > -1) {
             return candidate;
         }
         var pos = candidate.lastIndexOf('-');
@@ -19,3 +22,4 @@ export function BestAvailableLocale(availableLocales, locale) {
         candidate = candidate.slice(0, pos);
     }
 }
+exports.BestAvailableLocale = BestAvailableLocale;

package/lib/abstract/BestFitMatcher.d.ts

@@ -5,4 +5,4 @@ import { LookupMatcherResult } from './types';
  * @param requestedLocales
  * @param getDefaultLocale
  */
-export declare function BestFitMatcher(availableLocales: Set<string>, requestedLocales: string[], getDefaultLocale: () => string): LookupMatcherResult;
+export declare function BestFitMatcher(availableLocales: readonly string[], requestedLocales: readonly string[], getDefaultLocale: () => string): LookupMatcherResult;

package/lib/abstract/BestFitMatcher.js

@@ -1,66 +1,35 @@
-import { BestAvailableLocale } from './BestAvailableLocale';
-import { UNICODE_EXTENSION_SEQUENCE_REGEX } from './utils';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BestFitMatcher = void 0;
+var utils_1 = require("./utils");
 /**
  * https://tc39.es/ecma402/#sec-bestfitmatcher
  * @param availableLocales
  * @param requestedLocales
  * @param getDefaultLocale
  */
-export function BestFitMatcher(availableLocales, requestedLocales, getDefaultLocale) {
-    var minimizedAvailableLocaleMap = {};
-    var availableLocaleMap = {};
-    var canonicalizedLocaleMap = {};
-    var minimizedAvailableLocales = new Set();
-    availableLocales.forEach(function (locale) {
-        var minimizedLocale = new Intl.Locale(locale)
-            .minimize()
-            .toString();
-        var canonicalizedLocale = Intl.getCanonicalLocales(locale)[0] || locale;
-        minimizedAvailableLocaleMap[minimizedLocale] = locale;
-        availableLocaleMap[locale] = locale;
-        canonicalizedLocaleMap[canonicalizedLocale] = locale;
-        minimizedAvailableLocales.add(minimizedLocale);
-        minimizedAvailableLocales.add(locale);
-        minimizedAvailableLocales.add(canonicalizedLocale);
-    });
+function BestFitMatcher(availableLocales, requestedLocales, getDefaultLocale) {
     var foundLocale;
     var extension;
-    for (var _i = 0, requestedLocales_1 = requestedLocales; _i < requestedLocales_1.length; _i++) {
-        var l = requestedLocales_1[_i];
-        if (foundLocale) {
-            break;
-        }
-        var noExtensionLocale = l.replace(UNICODE_EXTENSION_SEQUENCE_REGEX, '');
-        if (l !== noExtensionLocale) {
-            extension = l.slice(noExtensionLocale.length, l.length);
-        }
-        if (availableLocales.has(noExtensionLocale)) {
-            foundLocale = noExtensionLocale;
-            break;
-        }
-        if (minimizedAvailableLocales.has(noExtensionLocale)) {
-            foundLocale = noExtensionLocale;
-            break;
-        }
-        var locale = new Intl.Locale(noExtensionLocale);
-        var maximizedRequestedLocale = locale.maximize().toString();
-        var minimizedRequestedLocale = locale.minimize().toString();
-        // Check minimized locale
-        if (minimizedAvailableLocales.has(minimizedRequestedLocale)) {
-            foundLocale = minimizedRequestedLocale;
-            break;
-        }
-        // Lookup algo on maximized locale
-        foundLocale = BestAvailableLocale(minimizedAvailableLocales, maximizedRequestedLocale);
+    var noExtensionLocales = [];
+    var noExtensionLocaleMap = requestedLocales.reduce(function (all, l) {
+        var noExtensionLocale = l.replace(utils_1.UNICODE_EXTENSION_SEQUENCE_REGEX, '');
+        noExtensionLocales.push(noExtensionLocale);
+        all[noExtensionLocale] = l;
+        return all;
+    }, {});
+    var result = (0, utils_1.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: availableLocaleMap[foundLocale] ||
-            canonicalizedLocaleMap[foundLocale] ||
-            minimizedAvailableLocaleMap[foundLocale] ||
-            foundLocale,
+        locale: foundLocale,
         extension: extension,
     };
 }
+exports.BestFitMatcher = BestFitMatcher;

package/lib/abstract/CanonicalizeLocaleList.js

@@ -1,8 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanonicalizeLocaleList = void 0;
 /**
  * http://ecma-international.org/ecma-402/7.0/index.html#sec-canonicalizelocalelist
  * @param locales
  */
-export function CanonicalizeLocaleList(locales) {
+function CanonicalizeLocaleList(locales) {
     // TODO
     return Intl.getCanonicalLocales(locales);
 }
+exports.CanonicalizeLocaleList = CanonicalizeLocaleList;

package/lib/abstract/LookupMatcher.d.ts

@@ -5,4 +5,4 @@ import { LookupMatcherResult } from './types';
  * @param requestedLocales
  * @param getDefaultLocale
  */
-export declare function LookupMatcher(availableLocales: Set<string>, requestedLocales: string[], getDefaultLocale: () => string): LookupMatcherResult;
+export declare function LookupMatcher(availableLocales: readonly string[], requestedLocales: readonly string[], getDefaultLocale: () => string): LookupMatcherResult;

package/lib/abstract/LookupMatcher.js

@@ -1,17 +1,20 @@
-import { UNICODE_EXTENSION_SEQUENCE_REGEX } from './utils';
-import { BestAvailableLocale } from './BestAvailableLocale';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LookupMatcher = void 0;
+var BestAvailableLocale_1 = require("./BestAvailableLocale");
+var utils_1 = require("./utils");
 /**
  * https://tc39.es/ecma402/#sec-lookupmatcher
  * @param availableLocales
  * @param requestedLocales
  * @param getDefaultLocale
  */
-export function LookupMatcher(availableLocales, requestedLocales, getDefaultLocale) {
+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);
+        var noExtensionLocale = locale.replace(utils_1.UNICODE_EXTENSION_SEQUENCE_REGEX, '');
+        var availableLocale = (0, BestAvailableLocale_1.BestAvailableLocale)(availableLocales, noExtensionLocale);
         if (availableLocale) {
             result.locale = availableLocale;
             if (locale !== noExtensionLocale) {
@@ -23,3 +26,4 @@ export function LookupMatcher(availableLocales, requestedLocales, getDefaultLoca
     result.locale = getDefaultLocale();
     return result;
 }
+exports.LookupMatcher = LookupMatcher;

package/lib/abstract/LookupSupportedLocales.d.ts

@@ -3,4 +3,4 @@
  * @param availableLocales
  * @param requestedLocales
  */
-export declare function LookupSupportedLocales(availableLocales: Set<string>, requestedLocales: string[]): string[];
+export declare function LookupSupportedLocales(availableLocales: string[], requestedLocales: string[]): string[];

package/lib/abstract/LookupSupportedLocales.js

@@ -1,19 +1,23 @@
-import { UNICODE_EXTENSION_SEQUENCE_REGEX } from './utils';
-import { BestAvailableLocale } from './BestAvailableLocale';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LookupSupportedLocales = void 0;
+var BestAvailableLocale_1 = require("./BestAvailableLocale");
+var utils_1 = require("./utils");
 /**
  * https://tc39.es/ecma402/#sec-lookupsupportedlocales
  * @param availableLocales
  * @param requestedLocales
  */
-export function LookupSupportedLocales(availableLocales, requestedLocales) {
+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);
+        var noExtensionLocale = locale.replace(utils_1.UNICODE_EXTENSION_SEQUENCE_REGEX, '');
+        var availableLocale = (0, BestAvailableLocale_1.BestAvailableLocale)(availableLocales, noExtensionLocale);
         if (availableLocale) {
             subset.push(availableLocale);
         }
     }
     return subset;
 }
+exports.LookupSupportedLocales = LookupSupportedLocales;

package/lib/abstract/ResolveLocale.d.ts

@@ -8,7 +8,7 @@ export interface ResolveLocaleResult {
  */
 export declare function ResolveLocale<K extends string, D extends {
     [k in K]: any;
-}>(availableLocales: Set<string>, requestedLocales: string[], options: {
+}>(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/lib/abstract/ResolveLocale.js

@@ -1,34 +1,37 @@
-import { LookupMatcher } from './LookupMatcher';
-import { BestFitMatcher } from './BestFitMatcher';
-import { invariant } from './utils';
-import { UnicodeExtensionValue } from './UnicodeExtensionValue';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResolveLocale = void 0;
+var BestFitMatcher_1 = require("./BestFitMatcher");
+var LookupMatcher_1 = require("./LookupMatcher");
+var UnicodeExtensionValue_1 = require("./UnicodeExtensionValue");
+var utils_1 = require("./utils");
 /**
  * https://tc39.es/ecma402/#sec-resolvelocale
  */
-export function ResolveLocale(availableLocales, requestedLocales, options, relevantExtensionKeys, localeData, getDefaultLocale) {
+function ResolveLocale(availableLocales, requestedLocales, options, relevantExtensionKeys, localeData, getDefaultLocale) {
     var matcher = options.localeMatcher;
     var r;
     if (matcher === 'lookup') {
-        r = LookupMatcher(availableLocales, requestedLocales, getDefaultLocale);
+        r = (0, LookupMatcher_1.LookupMatcher)(Array.from(availableLocales), requestedLocales, getDefaultLocale);
     }
     else {
-        r = BestFitMatcher(availableLocales, requestedLocales, getDefaultLocale);
+        r = (0, BestFitMatcher_1.BestFitMatcher)(Array.from(availableLocales), requestedLocales, getDefaultLocale);
     }
     var foundLocale = r.locale;
     var result = { locale: '', dataLocale: foundLocale };
     var supportedExtension = '-u';
     for (var _i = 0, relevantExtensionKeys_1 = relevantExtensionKeys; _i < relevantExtensionKeys_1.length; _i++) {
         var key = relevantExtensionKeys_1[_i];
-        invariant(foundLocale in localeData, "Missing locale data for ".concat(foundLocale));
+        (0, utils_1.invariant)(foundLocale in localeData, "Missing locale data for ".concat(foundLocale));
         var foundLocaleData = localeData[foundLocale];
-        invariant(typeof foundLocaleData === 'object' && foundLocaleData !== null, "locale data ".concat(key, " must be an object"));
+        (0, utils_1.invariant)(typeof foundLocaleData === 'object' && foundLocaleData !== null, "locale data ".concat(key, " must be an object"));
         var keyLocaleData = foundLocaleData[key];
-        invariant(Array.isArray(keyLocaleData), "keyLocaleData for ".concat(key, " must be an array"));
+        (0, utils_1.invariant)(Array.isArray(keyLocaleData), "keyLocaleData for ".concat(key, " must be an array"));
         var value = keyLocaleData[0];
-        invariant(typeof value === 'string' || value === null, "value must be string or null but got ".concat(typeof value, " in key ").concat(key));
+        (0, utils_1.invariant)(typeof value === 'string' || value === null, "value must be string or null but got ".concat(typeof value, " in key ").concat(key));
         var supportedExtensionAddition = '';
         if (r.extension) {
-            var requestedValue = UnicodeExtensionValue(r.extension, key);
+            var requestedValue = (0, UnicodeExtensionValue_1.UnicodeExtensionValue)(r.extension, key);
             if (requestedValue !== undefined) {
                 if (requestedValue !== '') {
                     if (~keyLocaleData.indexOf(requestedValue)) {
@@ -44,7 +47,7 @@ export function ResolveLocale(availableLocales, requestedLocales, options, relev
         }
         if (key in options) {
             var optionsValue = options[key];
-            invariant(typeof optionsValue === 'string' ||
+            (0, utils_1.invariant)(typeof optionsValue === 'string' ||
                 typeof optionsValue === 'undefined' ||
                 optionsValue === null, 'optionsValue must be String, Undefined or Null');
             if (~keyLocaleData.indexOf(optionsValue)) {
@@ -72,3 +75,4 @@ export function ResolveLocale(availableLocales, requestedLocales, options, relev
     result.locale = foundLocale;
     return result;
 }
+exports.ResolveLocale = ResolveLocale;

package/lib/abstract/UnicodeExtensionValue.js

@@ -1,11 +1,14 @@
-import { invariant } from './utils';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnicodeExtensionValue = void 0;
+var utils_1 = require("./utils");
 /**
  * https://tc39.es/ecma402/#sec-unicodeextensionvalue
  * @param extension
  * @param key
  */
-export function UnicodeExtensionValue(extension, key) {
-    invariant(key.length === 2, 'key must have 2 elements');
+function UnicodeExtensionValue(extension, key) {
+    (0, utils_1.invariant)(key.length === 2, 'key must have 2 elements');
     var size = extension.length;
     var searchValue = "-".concat(key, "-");
     var pos = extension.indexOf(searchValue);
@@ -44,3 +47,4 @@ export function UnicodeExtensionValue(extension, key) {
     }
     return undefined;
 }
+exports.UnicodeExtensionValue = UnicodeExtensionValue;