Datasets:

Continual-Learning-Exam
/

CLE-Lite-Workspaces

import baseLogger from './logger.js';
import { getCleanedCode, isString } from './utils.js';

class LanguageUtil {
  constructor(options) {
    this.options = options;

    this.supportedLngs = this.options.supportedLngs || false;
    this.logger = baseLogger.create('languageUtils');
    this.resolveHierarchyCache = {};
  }

  clearCache() {
    this.resolveHierarchyCache = {};
  }

  getScriptPartFromCode(code) {
    code = getCleanedCode(code);
    if (!code || !code.includes('-')) return null;

    const p = code.split('-');
    if (p.length === 2) return null;
    p.pop();
    if (p[p.length - 1].toLowerCase() === 'x') return null;
    return this.formatLanguageCode(p.join('-'));
  }

  getLanguagePartFromCode(code) {
    code = getCleanedCode(code);
    if (!code || !code.includes('-')) return code;

    const p = code.split('-');
    return this.formatLanguageCode(p[0]);
  }

  formatLanguageCode(code) {
    // http://www.iana.org/assignments/language-tags/language-tags.xhtml
    if (isString(code) && code.includes('-')) {
      let formattedCode;
      try {
        formattedCode = Intl.getCanonicalLocales(code)[0];
      } catch (e) {
        /* fall through */
      }
      if (formattedCode && this.options.lowerCaseLng) {
        formattedCode = formattedCode.toLowerCase();
      }
      if (formattedCode) return formattedCode;

      if (this.options.lowerCaseLng) {
        return code.toLowerCase();
      }

      return code;
    }

    return this.options.cleanCode || this.options.lowerCaseLng ? code.toLowerCase() : code;
  }

  isSupportedCode(code) {
    if (this.options.load === 'languageOnly' || this.options.nonExplicitSupportedLngs) {
      code = this.getLanguagePartFromCode(code);
    }
    return !this.supportedLngs || !this.supportedLngs.length || this.supportedLngs.includes(code);
  }

  getBestMatchFromCodes(codes) {
    if (!codes) return null;

    let found;

    // pick first supported code or if no restriction pick the first one (highest prio)
    codes.forEach((code) => {
      if (found) return;
      const cleanedLng = this.formatLanguageCode(code);
      if (!this.options.supportedLngs || this.isSupportedCode(cleanedLng)) found = cleanedLng;
    });

    // if we got no match in supportedLngs yet - check for similar locales
    // first  de-CH --> de
    // second de-CH --> de-DE
    if (!found && this.options.supportedLngs) {
      codes.forEach((code) => {
        if (found) return;

        const lngScOnly = this.getScriptPartFromCode(code);

        if (this.isSupportedCode(lngScOnly)) return (found = lngScOnly);

        const lngOnly = this.getLanguagePartFromCode(code);

        if (this.isSupportedCode(lngOnly)) return (found = lngOnly);

        found = this.options.supportedLngs.find((supportedLng) => {
          if (supportedLng === lngOnly) return true;
          if (!supportedLng.includes('-') && !lngOnly.includes('-')) return false;
          if (
            supportedLng.includes('-') &&
            !lngOnly.includes('-') &&
            supportedLng.slice(0, supportedLng.indexOf('-')) === lngOnly
          )
            return true;
          if (supportedLng.startsWith(lngOnly) && lngOnly.length > 1) return true;
          return false;
        });
      });
    }
    // if nothing found, use fallbackLng
    if (!found) found = this.getFallbackCodes(this.options.fallbackLng)[0];

    return found;
  }

  getFallbackCodes(fallbacks, code) {
    if (!fallbacks) return [];
    if (typeof fallbacks === 'function') fallbacks = fallbacks(code);
    if (isString(fallbacks)) fallbacks = [fallbacks];
    if (Array.isArray(fallbacks)) return fallbacks;

    if (!code) return fallbacks.default || [];

    // assume we have an object defining fallbacks
    let found = fallbacks[code];
    if (!found) found = fallbacks[this.getScriptPartFromCode(code)];
    if (!found) found = fallbacks[this.formatLanguageCode(code)];
    if (!found) found = fallbacks[this.getLanguagePartFromCode(code)];
    if (!found) found = fallbacks.default;

    return found || [];
  }

  toResolveHierarchy(code, fallbackCode) {
    const fallbackLng = this.options.fallbackLng;
    // join so in-place array mutation (fallbackLng.push(...)) also invalidates, not only reassignment
    const fallbackLngKey = Array.isArray(fallbackLng) ? fallbackLng.join('|') : fallbackLng;
    if (fallbackLngKey !== this._cachedFallbackLng) {
      this.resolveHierarchyCache = {};
      this._cachedFallbackLng = fallbackLngKey;
    }

    const hasCacheableFallback =
      fallbackCode === undefined || fallbackCode === false || isString(fallbackCode);
    const usesUncacheableOptionsFallback =
      fallbackCode === undefined && typeof this.options.fallbackLng === 'function';
    const cacheable = isString(code) && hasCacheableFallback && !usesUncacheableOptionsFallback;
    let cacheKey = null;
    if (cacheable) {
      let fallbackCacheKey;
      if (fallbackCode === undefined) fallbackCacheKey = 'undefined';
      else if (fallbackCode === false) fallbackCacheKey = 'boolean:false';
      else fallbackCacheKey = `string:${fallbackCode}`;
      cacheKey = `${code.length}:${code}|${fallbackCacheKey}`;
    }
    if (cacheKey !== null) {
      const cached = this.resolveHierarchyCache[cacheKey];
      if (cached !== undefined) return cached.slice();
    }

    const fallbackCodes = this.getFallbackCodes(
      (fallbackCode === false ? [] : fallbackCode) || this.options.fallbackLng || [],
      code,
    );

    const codes = [];
    const addCode = (c) => {
      if (!c) return;
      if (this.isSupportedCode(c)) {
        codes.push(c);
      } else {
        this.logger.warn(`rejecting language code not found in supportedLngs: ${c}`);
      }
    };

    if (isString(code) && (code.includes('-') || code.includes('_'))) {
      if (this.options.load !== 'languageOnly') addCode(this.formatLanguageCode(code));
      if (this.options.load !== 'languageOnly' && this.options.load !== 'currentOnly')
        addCode(this.getScriptPartFromCode(code));
      if (this.options.load !== 'currentOnly') addCode(this.getLanguagePartFromCode(code));
    } else if (isString(code)) {
      addCode(this.formatLanguageCode(code));
    }

    fallbackCodes.forEach((fc) => {
      if (!codes.includes(fc)) addCode(this.formatLanguageCode(fc));
    });

    if (cacheKey !== null) {
      this.resolveHierarchyCache[cacheKey] = codes;
      return codes.slice();
    }

    return codes;
  }
}

export default LanguageUtil;

	import baseLogger from './logger.js';
	import { getCleanedCode, isString } from './utils.js';

	class LanguageUtil {
	constructor(options) {
	this.options = options;

	this.supportedLngs = this.options.supportedLngs \|\| false;
	this.logger = baseLogger.create('languageUtils');
	this.resolveHierarchyCache = {};
	}

	clearCache() {
	this.resolveHierarchyCache = {};
	}

	getScriptPartFromCode(code) {
	code = getCleanedCode(code);
	if (!code \|\| !code.includes('-')) return null;

	const p = code.split('-');
	if (p.length === 2) return null;
	p.pop();
	if (p[p.length - 1].toLowerCase() === 'x') return null;
	return this.formatLanguageCode(p.join('-'));
	}

	getLanguagePartFromCode(code) {
	code = getCleanedCode(code);
	if (!code \|\| !code.includes('-')) return code;

	const p = code.split('-');
	return this.formatLanguageCode(p[0]);
	}

	formatLanguageCode(code) {
	// http://www.iana.org/assignments/language-tags/language-tags.xhtml
	if (isString(code) && code.includes('-')) {
	let formattedCode;
	try {
	formattedCode = Intl.getCanonicalLocales(code)[0];
	} catch (e) {
	/* fall through */
	}
	if (formattedCode && this.options.lowerCaseLng) {
	formattedCode = formattedCode.toLowerCase();
	}
	if (formattedCode) return formattedCode;

	if (this.options.lowerCaseLng) {
	return code.toLowerCase();
	}

	return code;
	}

	return this.options.cleanCode \|\| this.options.lowerCaseLng ? code.toLowerCase() : code;
	}

	isSupportedCode(code) {
	if (this.options.load === 'languageOnly' \|\| this.options.nonExplicitSupportedLngs) {
	code = this.getLanguagePartFromCode(code);
	}
	return !this.supportedLngs \|\| !this.supportedLngs.length \|\| this.supportedLngs.includes(code);
	}

	getBestMatchFromCodes(codes) {
	if (!codes) return null;

	let found;

	// pick first supported code or if no restriction pick the first one (highest prio)
	codes.forEach((code) => {
	if (found) return;
	const cleanedLng = this.formatLanguageCode(code);
	if (!this.options.supportedLngs \|\| this.isSupportedCode(cleanedLng)) found = cleanedLng;
	});

	// if we got no match in supportedLngs yet - check for similar locales
	// first de-CH --> de
	// second de-CH --> de-DE
	if (!found && this.options.supportedLngs) {
	codes.forEach((code) => {
	if (found) return;

	const lngScOnly = this.getScriptPartFromCode(code);

	if (this.isSupportedCode(lngScOnly)) return (found = lngScOnly);

	const lngOnly = this.getLanguagePartFromCode(code);

	if (this.isSupportedCode(lngOnly)) return (found = lngOnly);

	found = this.options.supportedLngs.find((supportedLng) => {
	if (supportedLng === lngOnly) return true;
	if (!supportedLng.includes('-') && !lngOnly.includes('-')) return false;
	if (
	supportedLng.includes('-') &&
	!lngOnly.includes('-') &&
	supportedLng.slice(0, supportedLng.indexOf('-')) === lngOnly
	)
	return true;
	if (supportedLng.startsWith(lngOnly) && lngOnly.length > 1) return true;
	return false;
	});
	});
	}
	// if nothing found, use fallbackLng
	if (!found) found = this.getFallbackCodes(this.options.fallbackLng)[0];

	return found;
	}

	getFallbackCodes(fallbacks, code) {
	if (!fallbacks) return [];
	if (typeof fallbacks === 'function') fallbacks = fallbacks(code);
	if (isString(fallbacks)) fallbacks = [fallbacks];
	if (Array.isArray(fallbacks)) return fallbacks;

	if (!code) return fallbacks.default \|\| [];

	// assume we have an object defining fallbacks
	let found = fallbacks[code];
	if (!found) found = fallbacks[this.getScriptPartFromCode(code)];
	if (!found) found = fallbacks[this.formatLanguageCode(code)];
	if (!found) found = fallbacks[this.getLanguagePartFromCode(code)];
	if (!found) found = fallbacks.default;

	return found \|\| [];
	}

	toResolveHierarchy(code, fallbackCode) {
	const fallbackLng = this.options.fallbackLng;
	// join so in-place array mutation (fallbackLng.push(...)) also invalidates, not only reassignment
	const fallbackLngKey = Array.isArray(fallbackLng) ? fallbackLng.join('\|') : fallbackLng;
	if (fallbackLngKey !== this._cachedFallbackLng) {
	this.resolveHierarchyCache = {};
	this._cachedFallbackLng = fallbackLngKey;
	}

	const hasCacheableFallback =
	fallbackCode === undefined \|\| fallbackCode === false \|\| isString(fallbackCode);
	const usesUncacheableOptionsFallback =
	fallbackCode === undefined && typeof this.options.fallbackLng === 'function';
	const cacheable = isString(code) && hasCacheableFallback && !usesUncacheableOptionsFallback;
	let cacheKey = null;
	if (cacheable) {
	let fallbackCacheKey;
	if (fallbackCode === undefined) fallbackCacheKey = 'undefined';
	else if (fallbackCode === false) fallbackCacheKey = 'boolean:false';
	else fallbackCacheKey = `string:${fallbackCode}`;
	cacheKey = `${code.length}:${code}\|${fallbackCacheKey}`;
	}
	if (cacheKey !== null) {
	const cached = this.resolveHierarchyCache[cacheKey];
	if (cached !== undefined) return cached.slice();
	}

	const fallbackCodes = this.getFallbackCodes(
	(fallbackCode === false ? [] : fallbackCode) \|\| this.options.fallbackLng \|\| [],
	code,
	);

	const codes = [];
	const addCode = (c) => {
	if (!c) return;
	if (this.isSupportedCode(c)) {
	codes.push(c);
	} else {
	this.logger.warn(`rejecting language code not found in supportedLngs: ${c}`);
	}
	};

	if (isString(code) && (code.includes('-') \|\| code.includes('_'))) {
	if (this.options.load !== 'languageOnly') addCode(this.formatLanguageCode(code));
	if (this.options.load !== 'languageOnly' && this.options.load !== 'currentOnly')
	addCode(this.getScriptPartFromCode(code));
	if (this.options.load !== 'currentOnly') addCode(this.getLanguagePartFromCode(code));
	} else if (isString(code)) {
	addCode(this.formatLanguageCode(code));
	}

	fallbackCodes.forEach((fc) => {
	if (!codes.includes(fc)) addCode(this.formatLanguageCode(fc));
	});

	if (cacheKey !== null) {
	this.resolveHierarchyCache[cacheKey] = codes;
	return codes.slice();
	}

	return codes;
	}
	}

	export default LanguageUtil;