@formatjs/intl-getcanonicallocales 1.2.1 → 1.2.6

package/src/canonicalizer.ts

@@ -12,6 +12,7 @@ import {
   SEPARATOR,
 } from './parser';
 import * as likelySubtags from 'cldr-core/supplemental/likelySubtags.json';
+import {emitUnicodeLanguageId} from './emitter';
 
 function canonicalizeAttrs(strs: string[]): string[] {
   return Object.keys(
@@ -47,6 +48,16 @@ function compareExtension(e1: Extension, e2: Extension): number {
   return e1.type < e2.type ? -1 : e1.type > e2.type ? 1 : 0;
 }
 
+function mergeVariants(v1: string[], v2: string[]): string[] {
+  const result = [...v1];
+  for (const v of v2) {
+    if (v1.indexOf(v) < 0) {
+      result.push(v);
+    }
+  }
+  return result;
+}
+
 /**
  * CAVEAT: We don't do this section in the spec bc they have no JSON data
  * Use the bcp47 data to replace keys, types, tfields, and tvalues by their canonical forms. See Section 3.6.4 U Extension Data Files) and Section 3.7.1 T Extension Data Files. The aliases are in the alias attribute value, while the canonical is in the name attribute value. For example,
@@ -56,30 +67,132 @@ We get the following transformation:
 en-u-ms-imperial ⇒ en-u-ms-uksystem
  * @param lang 
  */
-export function canonicalizeUnicodeLanguageId(lang: UnicodeLanguageId): void {
+export function canonicalizeUnicodeLanguageId(
+  unicodeLanguageId: UnicodeLanguageId
+): UnicodeLanguageId {
   /**
-   * If the language subtag matches the type attribute of a languageAlias element in Supplemental Data,
-   * replace the language subtag with the replacement value.
-   * - If there are additional subtags in the replacement value, add them to the result, but only if there is no corresponding subtag already in the tag.
-   * - Five special deprecated grandfathered codes (such as i-default) are in type attributes, and are also replaced.
+   * If the language subtag matches the type attribute of a languageAlias element in Supplemental Data, replace the language subtag with the replacement value.
+   *  1. If there are additional subtags in the replacement value, add them to the result, but only if there is no corresponding subtag already in the tag.
+   *  2. Five special deprecated grandfathered codes (such as i-default) are in type attributes, and are also replaced.
    */
-  let sourceLang = lang.lang.toLowerCase();
-  const langAlias = languageAlias[sourceLang];
-  if (langAlias) {
-    const langAliasAst = parseUnicodeLanguageId(langAlias.split('-'));
-    lang.lang = langAliasAst.lang;
-    lang.script = lang.script || langAliasAst.script;
-    lang.region = lang.region || langAliasAst.region;
+
+  // From https://github.com/unicode-org/icu/blob/master/icu4j/main/classes/core/src/com/ibm/icu/util/ULocale.java#L1246
+
+  // Try language _ variant
+  let finalLangAst = unicodeLanguageId;
+  if (unicodeLanguageId.variants.length) {
+    let replacedLang: string = '';
+    for (const variant of unicodeLanguageId.variants) {
+      if (
+        (replacedLang =
+          languageAlias[
+            emitUnicodeLanguageId({
+              lang: unicodeLanguageId.lang,
+              variants: [variant],
+            })
+          ])
+      ) {
+        const replacedLangAst = parseUnicodeLanguageId(
+          replacedLang.split(SEPARATOR)
+        );
+        finalLangAst = {
+          lang: replacedLangAst.lang,
+          script: finalLangAst.script || replacedLangAst.script,
+          region: finalLangAst.region || replacedLangAst.region,
+          variants: mergeVariants(
+            finalLangAst.variants,
+            replacedLangAst.variants
+          ),
+        };
+        break;
+      }
+    }
   }
-  if (lang.region) {
-    const region = lang.region.toUpperCase();
+
+  // language _ script _ country
+  // ug-Arab-CN -> ug-CN
+  if (finalLangAst.script && finalLangAst.region) {
+    const replacedLang =
+      languageAlias[
+        emitUnicodeLanguageId({
+          lang: finalLangAst.lang,
+          script: finalLangAst.script,
+          region: finalLangAst.region,
+          variants: [],
+        })
+      ];
+    if (replacedLang) {
+      const replacedLangAst = parseUnicodeLanguageId(
+        replacedLang.split(SEPARATOR)
+      );
+      finalLangAst = {
+        lang: replacedLangAst.lang,
+        script: replacedLangAst.script,
+        region: replacedLangAst.region,
+        variants: finalLangAst.variants,
+      };
+    }
+  }
+
+  // language _ country
+  // eg. az_AZ -> az_Latn_A
+  if (finalLangAst.region) {
+    const replacedLang =
+      languageAlias[
+        emitUnicodeLanguageId({
+          lang: finalLangAst.lang,
+          region: finalLangAst.region,
+          variants: [],
+        })
+      ];
+    if (replacedLang) {
+      const replacedLangAst = parseUnicodeLanguageId(
+        replacedLang.split(SEPARATOR)
+      );
+      finalLangAst = {
+        lang: replacedLangAst.lang,
+        script: finalLangAst.script || replacedLangAst.script,
+        region: replacedLangAst.region,
+        variants: finalLangAst.variants,
+      };
+    }
+  }
+  // only language
+  // e.g. twi -> ak
+  const replacedLang =
+    languageAlias[
+      emitUnicodeLanguageId({
+        lang: finalLangAst.lang,
+        variants: [],
+      })
+    ];
+  if (replacedLang) {
+    const replacedLangAst = parseUnicodeLanguageId(
+      replacedLang.split(SEPARATOR)
+    );
+    finalLangAst = {
+      lang: replacedLangAst.lang,
+      script: finalLangAst.script || replacedLangAst.script,
+      region: finalLangAst.region || replacedLangAst.region,
+      variants: finalLangAst.variants,
+    };
+  }
+
+  if (finalLangAst.region) {
+    const region = finalLangAst.region.toUpperCase();
     const regionAlias = territoryAlias[region];
     let replacedRegion: string | undefined;
     if (regionAlias) {
       const regions = regionAlias.split(' ');
       replacedRegion = regions[0];
       const likelySubtag =
-        likelySubtags.supplemental.likelySubtags[lang.lang as 'aa'];
+        likelySubtags.supplemental.likelySubtags[
+          emitUnicodeLanguageId({
+            lang: finalLangAst.lang,
+            script: finalLangAst.script,
+            variants: [],
+          }) as 'aa'
+        ];
       if (likelySubtag) {
         const {region: likelyRegion} = parseUnicodeLanguageId(
           likelySubtag.split(SEPARATOR)
@@ -90,32 +203,35 @@ export function canonicalizeUnicodeLanguageId(lang: UnicodeLanguageId): void {
       }
     }
     if (replacedRegion) {
-      lang.region = replacedRegion;
+      finalLangAst.region = replacedRegion;
     }
+    finalLangAst.region = finalLangAst.region.toUpperCase();
   }
-  if (lang.script) {
-    lang.script =
-      lang.script[0].toUpperCase() + lang.script.slice(1).toLowerCase();
-    if (scriptAlias[lang.script]) {
-      lang.script = scriptAlias[lang.script];
+  if (finalLangAst.script) {
+    finalLangAst.script =
+      finalLangAst.script[0].toUpperCase() +
+      finalLangAst.script.slice(1).toLowerCase();
+    if (scriptAlias[finalLangAst.script]) {
+      finalLangAst.script = scriptAlias[finalLangAst.script];
     }
   }
 
-  if (lang.variants.length) {
-    for (let i = 0; i < lang.variants.length; i++) {
-      let variant = lang.variants[i].toLowerCase();
+  if (finalLangAst.variants.length) {
+    for (let i = 0; i < finalLangAst.variants.length; i++) {
+      let variant = finalLangAst.variants[i].toLowerCase();
       if (variantAlias[variant]) {
         const alias = variantAlias[variant];
         if (isUnicodeVariantSubtag(alias)) {
-          lang.variants[i] = alias;
+          finalLangAst.variants[i] = alias;
         } else if (isUnicodeLanguageSubtag(alias)) {
           // Yes this can happen per the spec
-          lang.lang = alias;
+          finalLangAst.lang = alias;
         }
       }
     }
-    lang.variants.sort();
+    finalLangAst.variants.sort();
   }
+  return finalLangAst;
 }
 
 /**
@@ -128,7 +244,7 @@ export function canonicalizeUnicodeLanguageId(lang: UnicodeLanguageId): void {
 export function canonicalizeUnicodeLocaleId(
   locale: UnicodeLocaleId
 ): UnicodeLocaleId {
-  canonicalizeUnicodeLanguageId(locale.lang);
+  locale.lang = canonicalizeUnicodeLanguageId(locale.lang);
   if (locale.extensions) {
     for (const extension of locale.extensions) {
       switch (extension.type) {
@@ -140,7 +256,7 @@ export function canonicalizeUnicodeLocaleId(
           break;
         case 't':
           if (extension.lang) {
-            canonicalizeUnicodeLanguageId(extension.lang);
+            extension.lang = canonicalizeUnicodeLanguageId(extension.lang);
           }
           extension.fields = canonicalizeKVs(extension.fields);
           break;

package/src/polyfill.ts

@@ -1,5 +1,22 @@
-import {getCanonicalLocales} from './';
-if (!('getCanonicalLocales' in Intl)) {
+import {getCanonicalLocales} from '.';
+if (typeof Intl === 'undefined') {
+  if (typeof window !== 'undefined') {
+    Object.defineProperty(window, 'Intl', {
+      value: {},
+    });
+  } else if (typeof global !== 'undefined') {
+    Object.defineProperty(global, 'Intl', {
+      value: {},
+    });
+  }
+}
+if (
+  !('getCanonicalLocales' in Intl) ||
+  // Native Intl.getCanonicalLocales is just buggy
+  ((Intl as any).getCanonicalLocales as typeof getCanonicalLocales)(
+    'und-x-private'
+  )[0] === 'x-private'
+) {
   Object.defineProperty(Intl, 'getCanonicalLocales', {
     value: getCanonicalLocales,
     writable: true,