@formatjs/intl-localematcher 0.5.7 → 0.5.9

package/README.md

@@ -1,3 +1,3 @@
 # Intl LocaleMatcher
 
-We've migrated the docs to https://formatjs.io/docs/polyfills/intl-localematcher.
+We've migrated the docs to https://formatjs.github.io/docs/polyfills/intl-localematcher.

package/abstract/BestAvailableLocale.js

@@ -22,4 +22,3 @@ function BestAvailableLocale(availableLocales, locale) {
         candidate = candidate.slice(0, pos);
     }
 }
-//# sourceMappingURL=BestAvailableLocale.js.map

package/abstract/BestFitMatcher.js

@@ -32,4 +32,3 @@ function BestFitMatcher(availableLocales, requestedLocales, getDefaultLocale) {
         extension: extension,
     };
 }
-//# sourceMappingURL=BestFitMatcher.js.map

package/abstract/CanonicalizeLocaleList.js

@@ -6,7 +6,5 @@ exports.CanonicalizeLocaleList = CanonicalizeLocaleList;
  * @param locales
  */
 function CanonicalizeLocaleList(locales) {
-    // TODO
     return Intl.getCanonicalLocales(locales);
 }
-//# sourceMappingURL=CanonicalizeLocaleList.js.map

package/abstract/CanonicalizeUValue.d.ts

@@ -0,0 +1 @@
+export declare function CanonicalizeUValue(ukey: string, uvalue: string): string;

package/abstract/CanonicalizeUValue.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanonicalizeUValue = CanonicalizeUValue;
+var utils_1 = require("./utils");
+function CanonicalizeUValue(ukey, uvalue) {
+    // TODO: Implement algorithm for CanonicalizeUValue per https://tc39.es/ecma402/#sec-canonicalizeuvalue
+    var lowerValue = uvalue.toLowerCase();
+    (0, utils_1.invariant)(ukey !== undefined, "ukey must be defined");
+    var canonicalized = lowerValue;
+    return canonicalized;
+}

package/abstract/CanonicalizeUnicodeLocaleId.d.ts

@@ -0,0 +1 @@
+export declare function CanonicalizeUnicodeLocaleId(locale: string): string;

package/abstract/CanonicalizeUnicodeLocaleId.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanonicalizeUnicodeLocaleId = CanonicalizeUnicodeLocaleId;
+function CanonicalizeUnicodeLocaleId(locale) {
+    return Intl.getCanonicalLocales(locale)[0];
+}

package/abstract/InsertUnicodeExtensionAndCanonicalize.d.ts

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

package/abstract/InsertUnicodeExtensionAndCanonicalize.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsertUnicodeExtensionAndCanonicalize = InsertUnicodeExtensionAndCanonicalize;
+var CanonicalizeUnicodeLocaleId_1 = require("./CanonicalizeUnicodeLocaleId");
+var utils_1 = require("./utils");
+function InsertUnicodeExtensionAndCanonicalize(locale, attributes, keywords) {
+    (0, utils_1.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 (0, CanonicalizeUnicodeLocaleId_1.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 (0, CanonicalizeUnicodeLocaleId_1.CanonicalizeUnicodeLocaleId)(newLocale);
+}

package/abstract/LookupMatcher.js

@@ -26,4 +26,3 @@ function LookupMatcher(availableLocales, requestedLocales, getDefaultLocale) {
     result.locale = getDefaultLocale();
     return result;
 }
-//# sourceMappingURL=LookupMatcher.js.map

package/abstract/LookupSupportedLocales.js

@@ -20,4 +20,3 @@ function LookupSupportedLocales(availableLocales, requestedLocales) {
     }
     return subset;
 }
-//# sourceMappingURL=LookupSupportedLocales.js.map

package/abstract/ResolveLocale.js

@@ -2,13 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResolveLocale = ResolveLocale;
 var BestFitMatcher_1 = require("./BestFitMatcher");
+var CanonicalizeUValue_1 = require("./CanonicalizeUValue");
+var InsertUnicodeExtensionAndCanonicalize_1 = require("./InsertUnicodeExtensionAndCanonicalize");
 var LookupMatcher_1 = require("./LookupMatcher");
-var UnicodeExtensionValue_1 = require("./UnicodeExtensionValue");
+var UnicodeExtensionComponents_1 = require("./UnicodeExtensionComponents");
 var utils_1 = require("./utils");
 /**
  * https://tc39.es/ecma402/#sec-resolvelocale
  */
 function ResolveLocale(availableLocales, requestedLocales, options, relevantExtensionKeys, localeData, getDefaultLocale) {
+    var _a;
     var matcher = options.localeMatcher;
     var r;
     if (matcher === 'lookup') {
@@ -17,62 +20,84 @@ function ResolveLocale(availableLocales, requestedLocales, options, relevantExte
     else {
         r = (0, BestFitMatcher_1.BestFitMatcher)(Array.from(availableLocales), requestedLocales, getDefaultLocale);
     }
+    if (r == null) {
+        r = {
+            locale: getDefaultLocale(),
+            extension: '',
+        };
+    }
     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];
-        (0, utils_1.invariant)(foundLocale in localeData, "Missing locale data for ".concat(foundLocale));
-        var foundLocaleData = localeData[foundLocale];
-        (0, utils_1.invariant)(typeof foundLocaleData === 'object' && foundLocaleData !== null, "locale data ".concat(key, " must be an object"));
-        var keyLocaleData = foundLocaleData[key];
+    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 = (0, UnicodeExtensionComponents_1.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 : [];
         (0, utils_1.invariant)(Array.isArray(keyLocaleData), "keyLocaleData for ".concat(key, " must be an array"));
         var value = keyLocaleData[0];
-        (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 = (0, UnicodeExtensionValue_1.UnicodeExtensionValue)(r.extension, key);
-            if (requestedValue !== undefined) {
-                if (requestedValue !== '') {
-                    if (~keyLocaleData.indexOf(requestedValue)) {
-                        value = requestedValue;
-                        supportedExtensionAddition = "-".concat(key, "-").concat(value);
-                    }
-                }
-                else if (~requestedValue.indexOf('true')) {
-                    value = 'true';
-                    supportedExtensionAddition = "-".concat(key);
+        (0, utils_1.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,
+                };
+            }
         }
-        if (key in options) {
-            var optionsValue = options[key];
-            (0, utils_1.invariant)(typeof optionsValue === 'string' ||
-                typeof optionsValue === 'undefined' ||
-                optionsValue === null, 'optionsValue must be String, Undefined or Null');
-            if (~keyLocaleData.indexOf(optionsValue)) {
-                if (optionsValue !== value) {
-                    value = optionsValue;
-                    supportedExtensionAddition = '';
-                }
+        var optionsValue = options[key];
+        (0, utils_1.invariant)(optionsValue == null || typeof optionsValue === 'string', "optionsValue must be a string or undefined");
+        if (typeof optionsValue === 'string') {
+            var ukey = key.toLowerCase();
+            optionsValue = (0, CanonicalizeUValue_1.CanonicalizeUValue)(ukey, optionsValue);
+            if (optionsValue === '') {
+                optionsValue = 'true';
             }
         }
-        result[key] = value;
-        supportedExtension += supportedExtensionAddition;
-    }
-    if (supportedExtension.length > 2) {
-        var privateIndex = foundLocale.indexOf('-x-');
-        if (privateIndex === -1) {
-            foundLocale = foundLocale + supportedExtension;
+        if (optionsValue !== value && keyLocaleData.indexOf(optionsValue) > -1) {
+            value = optionsValue;
+            supportedKeyword = undefined;
         }
-        else {
-            var preExtension = foundLocale.slice(0, privateIndex);
-            var postExtension = foundLocale.slice(privateIndex, foundLocale.length);
-            foundLocale = preExtension + supportedExtension + postExtension;
+        if (supportedKeyword) {
+            supportedKeywords.push(supportedKeyword);
         }
-        foundLocale = Intl.getCanonicalLocales(foundLocale)[0];
+        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 = (0, InsertUnicodeExtensionAndCanonicalize_1.InsertUnicodeExtensionAndCanonicalize)(foundLocale, supportedAttributes, supportedKeywords);
     }
     result.locale = foundLocale;
     return result;
 }
-//# sourceMappingURL=ResolveLocale.js.map

package/abstract/UnicodeExtensionComponents.d.ts

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

package/abstract/UnicodeExtensionComponents.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnicodeExtensionComponents = UnicodeExtensionComponents;
+var utils_1 = require("./utils");
+function UnicodeExtensionComponents(extension) {
+    (0, utils_1.invariant)(extension === extension.toLowerCase(), 'Expected extension to be lowercase');
+    (0, utils_1.invariant)(extension.slice(0, 3) === '-u-', 'Expected extension to be a Unicode locale extension');
+    var attributes = [];
+    var keywords = [];
+    var keyword;
+    var size = extension.length;
+    var k = 3;
+    while (k < size) {
+        var e = extension.indexOf('-', k);
+        var len = void 0;
+        if (e === -1) {
+            len = size - k;
+        }
+        else {
+            len = e - k;
+        }
+        var subtag = extension.slice(k, k + len);
+        (0, utils_1.invariant)(len >= 2, 'Expected a subtag to have at least 2 characters');
+        if (keyword === undefined && len != 2) {
+            if (attributes.indexOf(subtag) === -1) {
+                attributes.push(subtag);
+            }
+        }
+        else if (len === 2) {
+            keyword = { key: subtag, value: '' };
+            if (keywords.find(function (k) { return k.key === (keyword === null || keyword === void 0 ? void 0 : keyword.key); }) === undefined) {
+                keywords.push(keyword);
+            }
+        }
+        else if ((keyword === null || keyword === void 0 ? void 0 : keyword.value) === '') {
+            keyword.value = subtag;
+        }
+        else {
+            (0, utils_1.invariant)(keyword !== undefined, 'Expected keyword to be defined');
+            keyword.value += '-' + subtag;
+        }
+        k += len + 1;
+    }
+    return { attributes: attributes, keywords: keywords };
+}

package/abstract/UnicodeExtensionValue.js

@@ -47,4 +47,3 @@ function UnicodeExtensionValue(extension, key) {
     }
     return undefined;
 }
-//# sourceMappingURL=UnicodeExtensionValue.js.map