@formatjs/intl-localematcher 0.2.29 → 0.2.30

package/abstract/ResolveLocale.ts

@@ -1,100 +0,0 @@
-import {LookupMatcherResult} from './types'
-import {LookupMatcher} from './LookupMatcher'
-import {BestFitMatcher} from './BestFitMatcher'
-import {invariant} from './utils'
-import {UnicodeExtensionValue} from './UnicodeExtensionValue'
-
-export interface ResolveLocaleResult {
-  locale: string
-  dataLocale: string
-  [k: string]: any
-}
-
-/**
- * https://tc39.es/ecma402/#sec-resolvelocale
- */
-export function ResolveLocale<K extends string, D extends {[k in K]: any}>(
-  availableLocales: Set<string>,
-  requestedLocales: string[],
-  options: {localeMatcher: string; [k: string]: string},
-  relevantExtensionKeys: K[],
-  localeData: Record<string, D | undefined>,
-  getDefaultLocale: () => string
-): ResolveLocaleResult {
-  const matcher = options.localeMatcher
-  let r: LookupMatcherResult
-  if (matcher === 'lookup') {
-    r = LookupMatcher(availableLocales, requestedLocales, getDefaultLocale)
-  } else {
-    r = BestFitMatcher(availableLocales, requestedLocales, getDefaultLocale)
-  }
-  let foundLocale = r.locale
-  const result: ResolveLocaleResult = {locale: '', dataLocale: foundLocale}
-  let supportedExtension = '-u'
-  for (const key of relevantExtensionKeys) {
-    invariant(
-      foundLocale in localeData,
-      `Missing locale data for ${foundLocale}`
-    )
-    const foundLocaleData = localeData[foundLocale]
-    invariant(
-      typeof foundLocaleData === 'object' && foundLocaleData !== null,
-      `locale data ${key} must be an object`
-    )
-    const keyLocaleData = foundLocaleData[key]
-    invariant(
-      Array.isArray(keyLocaleData),
-      `keyLocaleData for ${key} must be an array`
-    )
-    let value = keyLocaleData[0]
-    invariant(
-      typeof value === 'string' || value === null,
-      `value must be string or null but got ${typeof value} in key ${key}`
-    )
-    let supportedExtensionAddition = ''
-    if (r.extension) {
-      const requestedValue = UnicodeExtensionValue(r.extension, key)
-      if (requestedValue !== undefined) {
-        if (requestedValue !== '') {
-          if (~keyLocaleData.indexOf(requestedValue)) {
-            value = requestedValue
-            supportedExtensionAddition = `-${key}-${value}`
-          }
-        } else if (~requestedValue.indexOf('true')) {
-          value = 'true'
-          supportedExtensionAddition = `-${key}`
-        }
-      }
-    }
-    if (key in options) {
-      const optionsValue = options[key]
-      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 = ''
-        }
-      }
-    }
-    result[key] = value
-    supportedExtension += supportedExtensionAddition
-  }
-  if (supportedExtension.length > 2) {
-    const privateIndex = foundLocale.indexOf('-x-')
-    if (privateIndex === -1) {
-      foundLocale = foundLocale + supportedExtension
-    } else {
-      const preExtension = foundLocale.slice(0, privateIndex)
-      const postExtension = foundLocale.slice(privateIndex, foundLocale.length)
-      foundLocale = preExtension + supportedExtension + postExtension
-    }
-    foundLocale = (Intl as any).getCanonicalLocales(foundLocale)[0]
-  }
-  result.locale = foundLocale
-  return result
-}

package/abstract/UnicodeExtensionValue.ts

@@ -1,44 +0,0 @@
-import {invariant} from './utils'
-
-/**
- * https://tc39.es/ecma402/#sec-unicodeextensionvalue
- * @param extension
- * @param key
- */
-export function UnicodeExtensionValue(extension: string, key: string) {
-  invariant(key.length === 2, 'key must have 2 elements')
-  const size = extension.length
-  let searchValue = `-${key}-`
-  let pos = extension.indexOf(searchValue)
-  if (pos !== -1) {
-    const start = pos + 4
-    let end = start
-    let k = start
-    let done = false
-    while (!done) {
-      const e = extension.indexOf('-', k)
-      let len
-      if (e === -1) {
-        len = size - k
-      } else {
-        len = e - k
-      }
-      if (len === 2) {
-        done = true
-      } else if (e === -1) {
-        end = size
-        done = true
-      } else {
-        end = e
-        k = e + 1
-      }
-    }
-    return extension.slice(start, end)
-  }
-  searchValue = `-${key}`
-  pos = extension.indexOf(searchValue)
-  if (pos !== -1 && pos + 3 === size) {
-    return ''
-  }
-  return undefined
-}

package/abstract/types.ts

@@ -1,5 +0,0 @@
-export interface LookupMatcherResult {
-  locale: string
-  extension?: string
-  nu?: string
-}

package/abstract/utils.ts

@@ -1,11 +0,0 @@
-export const UNICODE_EXTENSION_SEQUENCE_REGEX = /-u(?:-[0-9a-z]{2,8})+/gi
-
-export function invariant(
-  condition: boolean,
-  message: string,
-  Err: any = Error
-): asserts condition {
-  if (!condition) {
-    throw new Err(message)
-  }
-}

package/index.ts

@@ -1,32 +0,0 @@
-import {CanonicalizeLocaleList} from './abstract/CanonicalizeLocaleList'
-import {ResolveLocale} from './abstract/ResolveLocale'
-
-export interface Opts {
-  algorithm: 'lookup' | 'best fit'
-}
-
-export function match(
-  requestedLocales: string[],
-  availableLocales: string[],
-  defaultLocale: string,
-  opts?: Opts
-): string {
-  const locales = availableLocales.reduce((all, l) => {
-    all.add(l)
-    return all
-  }, new Set<string>())
-
-  return ResolveLocale(
-    locales,
-    CanonicalizeLocaleList(requestedLocales),
-    {
-      localeMatcher: opts?.algorithm || 'best fit',
-    },
-    [],
-    {},
-    () => defaultLocale
-  ).locale
-}
-
-export {LookupSupportedLocales} from './abstract/LookupSupportedLocales'
-export {ResolveLocale} from './abstract/ResolveLocale'

package/tests/BestFitMatcher.test.ts

@@ -1,23 +0,0 @@
-import {BestFitMatcher} from '../abstract/BestFitMatcher'
-
-test('BestFitMatcher', function () {
-  expect(
-    BestFitMatcher(new Set(['fr', 'en']), ['fr-XX', 'en'], () => 'en')
-  ).toEqual({
-    locale: 'fr',
-  })
-})
-
-test('BestFitMatcher zh-TW', function () {
-  expect(
-    BestFitMatcher(new Set(['zh', 'zh-Hant']), ['zh-TW'], () => 'en')
-  ).toEqual({
-    locale: 'zh-Hant',
-  })
-})
-
-test('BestFitMatcher en', function () {
-  expect(BestFitMatcher(new Set(['en', 'und']), ['en'], () => 'en')).toEqual({
-    locale: 'en',
-  })
-})

package/tests/LookupMatcher.test.ts

@@ -1,17 +0,0 @@
-import {LookupMatcher} from '../abstract/LookupMatcher'
-
-test('LookupMatcher', function () {
-  expect(
-    LookupMatcher(new Set(['fr', 'en']), ['fr-XX', 'en'], () => 'en')
-  ).toEqual({
-    locale: 'fr',
-  })
-})
-
-test('LookupMatcher', function () {
-  expect(
-    LookupMatcher(new Set(['zh', 'zh-Hant']), ['zh-Hans'], () => 'en')
-  ).toEqual({
-    locale: 'zh',
-  })
-})

package/tests/ResolveLocale.test.ts

@@ -1,47 +0,0 @@
-import {ResolveLocale} from '../abstract/ResolveLocale'
-
-test('ResolveLocale', function () {
-  expect(
-    ResolveLocale(
-      new Set(['fr', 'en']),
-      ['fr-XX', 'en'],
-      {localeMatcher: 'best fit'},
-      [],
-      {},
-      () => 'en'
-    )
-  ).toEqual({
-    dataLocale: 'fr',
-    locale: 'fr',
-  })
-
-  expect(
-    ResolveLocale(
-      new Set(['zh-Hant-TW', 'en']),
-      ['zh-TW', 'en'],
-      {localeMatcher: 'best fit'},
-      [],
-      {},
-      () => 'en'
-    )
-  ).toEqual({
-    dataLocale: 'zh-Hant-TW',
-    locale: 'zh-Hant-TW',
-  })
-})
-
-test('empty requested', function () {
-  expect(
-    ResolveLocale(
-      new Set(['zh-Hant-TW', 'en']),
-      [],
-      {localeMatcher: 'best fit'},
-      [],
-      {},
-      () => 'en'
-    )
-  ).toEqual({
-    dataLocale: 'en',
-    locale: 'en',
-  })
-})

package/tests/index.test.ts

@@ -1,242 +0,0 @@
-import {match} from '../'
-
-test('zh-HK', function () {
-  expect(match(['zh-HK'], ['zh', 'zh-HANT', 'en'], 'en')).toEqual('zh-HANT')
-})
-
-test('Intl.LocaleMatcher', function () {
-  expect(match(['fr-XX', 'en'], ['fr', 'en'], 'en')).toEqual('fr')
-  expect(match(['zh-TW', 'en'], ['zh-Hant-TW', 'en'], 'en')).toEqual(
-    'zh-Hant-TW'
-  )
-  expect(
-    match(
-      ['sr-Latn-BA'],
-      [
-        'af',
-        'ak',
-        'am',
-        'an',
-        'ar',
-        'ars',
-        'as',
-        'asa',
-        'ast',
-        'az',
-        'be',
-        'bem',
-        'bez',
-        'bg',
-        'bho',
-        'bm',
-        'bn',
-        'bo',
-        'br',
-        'brx',
-        'bs',
-        'ca',
-        'ce',
-        'ceb',
-        'cgg',
-        'chr',
-        'ckb',
-        'cs',
-        'cy',
-        'da',
-        'de',
-        'doi',
-        'dsb',
-        'dv',
-        'dz',
-        'ee',
-        'el',
-        'en',
-        'eo',
-        'es',
-        'et',
-        'eu',
-        'fa',
-        'ff',
-        'fi',
-        'fil',
-        'fo',
-        'fr',
-        'fur',
-        'fy',
-        'ga',
-        'gd',
-        'gl',
-        'gsw',
-        'gu',
-        'guw',
-        'gv',
-        'ha',
-        'haw',
-        'he',
-        'hi',
-        'hr',
-        'hsb',
-        'hu',
-        'hy',
-        'ia',
-        'id',
-        'ig',
-        'ii',
-        'in',
-        'io',
-        'is',
-        'it',
-        'iu',
-        'iw',
-        'ja',
-        'jbo',
-        'jgo',
-        'ji',
-        'jmc',
-        'jv',
-        'jw',
-        'ka',
-        'kab',
-        'kaj',
-        'kcg',
-        'kde',
-        'kea',
-        'kk',
-        'kkj',
-        'kl',
-        'km',
-        'kn',
-        'ko',
-        'ks',
-        'ksb',
-        'ksh',
-        'ku',
-        'kw',
-        'ky',
-        'lag',
-        'lb',
-        'lg',
-        'lij',
-        'lkt',
-        'ln',
-        'lo',
-        'lt',
-        'lv',
-        'mas',
-        'mg',
-        'mgo',
-        'mk',
-        'ml',
-        'mn',
-        'mo',
-        'mr',
-        'ms',
-        'mt',
-        'my',
-        'nah',
-        'naq',
-        'nb',
-        'nd',
-        'ne',
-        'nl',
-        'nn',
-        'nnh',
-        'no',
-        'nqo',
-        'nr',
-        'nso',
-        'ny',
-        'nyn',
-        'om',
-        'or',
-        'os',
-        'osa',
-        'pa',
-        'pap',
-        'pcm',
-        'pl',
-        'prg',
-        'ps',
-        'pt-PT',
-        'pt',
-        'rm',
-        'ro',
-        'rof',
-        'ru',
-        'rwk',
-        'sah',
-        'saq',
-        'sat',
-        'sc',
-        'scn',
-        'sd',
-        'sdh',
-        'se',
-        'seh',
-        'ses',
-        'sg',
-        'sh',
-        'shi',
-        'si',
-        'sk',
-        'sl',
-        'sma',
-        'smi',
-        'smj',
-        'smn',
-        'sms',
-        'sn',
-        'so',
-        'sq',
-        'sr',
-        'ss',
-        'ssy',
-        'st',
-        'su',
-        'sv',
-        'sw',
-        'syr',
-        'ta',
-        'te',
-        'teo',
-        'th',
-        'ti',
-        'tig',
-        'tk',
-        'tl',
-        'tn',
-        'to',
-        'tr',
-        'ts',
-        'tzm',
-        'ug',
-        'uk',
-        'ur',
-        'uz',
-        've',
-        'vi',
-        'vo',
-        'vun',
-        'wa',
-        'wae',
-        'wo',
-        'xh',
-        'xog',
-        'yi',
-        'yo',
-        'yue',
-        'zh',
-        'zu',
-      ],
-      'en'
-    )
-  ).toEqual('sh')
-})
-
-test('empty requested', function () {
-  expect(match([], ['zh-Hant-TW', 'en'], 'en')).toEqual('en')
-})
-
-test('extension', function () {
-  expect(match(['fr-CA-x-foo'], ['zh-Hant-TW', 'fr', 'en'], 'en')).toEqual('fr')
-})

package/tsconfig.json

@@ -1,5 +0,0 @@
-// @generated
-{
-  // This is purely for IDE, not for compilation
-  "extends": "../../tsconfig.json"
-}