matrix-react-sdk/lib/languageHandler.js

SDK for matrix.org using React

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.UserFriendlyError = exports.CustomTranslationOptions = void 0;
exports._t = _t;
exports._tDom = _tDom;
exports._td = _td;
exports.getAllLanguagesFromJson = getAllLanguagesFromJson;
exports.getAllLanguagesWithLabels = getAllLanguagesWithLabels;
exports.getCurrentLanguage = getCurrentLanguage;
exports.getLanguageFromBrowser = getLanguageFromBrowser;
exports.getLanguagesFromBrowser = getLanguagesFromBrowser;
Object.defineProperty(exports, "getNormalizedLanguageKeys", {
  enumerable: true,
  get: function () {
    return _matrixWebI18n.getNormalizedLanguageKeys;
  }
});
exports.getUserLanguage = getUserLanguage;
exports.lookupString = lookupString;
Object.defineProperty(exports, "normalizeLanguageKey", {
  enumerable: true,
  get: function () {
    return _matrixWebI18n.normalizeLanguageKey;
  }
});
exports.pickBestLanguage = pickBestLanguage;
exports.registerCustomTranslations = registerCustomTranslations;
exports.replaceByRegexes = replaceByRegexes;
exports.sanitizeForTranslation = sanitizeForTranslation;
exports.setLanguage = setLanguage;
exports.setMissingEntryGenerator = setMissingEntryGenerator;
exports.substitute = substitute;
var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _counterpart = _interopRequireDefault(require("counterpart"));
var _react = _interopRequireDefault(require("react"));
var _logger = require("matrix-js-sdk/src/logger");
var _utils = require("matrix-js-sdk/src/utils");
var _matrixWebI18n = require("matrix-web-i18n");
var _lodash = _interopRequireDefault(require("lodash"));
var _SettingsStore = _interopRequireDefault(require("./settings/SettingsStore"));
var _PlatformPeg = _interopRequireDefault(require("./PlatformPeg"));
var _SettingLevel = require("./settings/SettingLevel");
var _promise = require("./utils/promise");
var _SdkConfig = _interopRequireDefault(require("./SdkConfig"));
var _ModuleRunner = require("./modules/ModuleRunner");
var _languages = _interopRequireDefault(require("$webapp/i18n/languages.json"));
const _excluded = ["cause"];
/*
Copyright 2024 New Vector Ltd.
Copyright 2019-2022 The Matrix.org Foundation C.I.C.
Copyright 2019 Michael Telatynski <7t3chguy@gmail.com>
Copyright 2017 MTRNord and Cooperative EITA
Copyright 2017 Vector Creations Ltd.

SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only
Please see LICENSE files in the repository root for full details.
*/
// @ts-ignore - $webapp is a webpack resolve alias pointing to the output directory, see webpack config
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
const i18nFolder = "i18n/";

// Control whether to also return original, untranslated strings
// Useful for debugging and testing
const ANNOTATE_STRINGS = false;

// We use english strings as keys, some of which contain full stops
_counterpart.default.setSeparator(_matrixWebI18n.KEY_SEPARATOR);

// see `translateWithFallback` for an explanation of fallback handling
const FALLBACK_LOCALE = "en";
_counterpart.default.setFallbackLocale(FALLBACK_LOCALE);
/**
 * Used to rethrow an error with a user-friendly translatable message while maintaining
 * access to that original underlying error. Downstream consumers can display the
 * `translatedMessage` property in the UI and inspect the underlying error with the
 * `cause` property.
 *
 * The error message will display as English in the console and logs so Element
 * developers can easily understand the error and find the source in the code. It also
 * helps tools like Sentry deduplicate the error, or just generally searching in
 * rageshakes to find all instances regardless of the users locale.
 *
 * @param message - The untranslated error message text, e.g "Something went wrong with %(foo)s".
 * @param substitutionVariablesAndCause - Variable substitutions for the translation and
 * original cause of the error. If there is no cause, just pass `undefined`, e.g { foo:
 * 'bar', cause: err || undefined }
 */
class UserFriendlyError extends Error {
  constructor(message, substitutionVariablesAndCause) {
    // Prevent "Could not find /%\(cause\)s/g in x" logs to the console by removing it from the list
    const _ref = substitutionVariablesAndCause ?? {},
      {
        cause
      } = _ref,
      substitutionVariables = (0, _objectWithoutProperties2.default)(_ref, _excluded);
    const errorOptions = {
      cause
    };

    // Create the error with the English version of the message that we want to show up in the logs
    const englishTranslatedMessage = _t(message, _objectSpread(_objectSpread({}, substitutionVariables), {}, {
      locale: "en"
    }));
    super(englishTranslatedMessage, errorOptions);

    // Also provide a translated version of the error in the users locale to display
    (0, _defineProperty2.default)(this, "translatedMessage", void 0);
    this.translatedMessage = _t(message, substitutionVariables);
  }
}
exports.UserFriendlyError = UserFriendlyError;
function getUserLanguage() {
  const language = _SettingsStore.default.getValue("language", null, /*excludeDefault:*/true);
  if (typeof language === "string" && language !== "") {
    return language;
  } else {
    return (0, _matrixWebI18n.normalizeLanguageKey)(getLanguageFromBrowser());
  }
}

/**
 * A type representing the union of possible keys into the translation file using `|` delimiter to access nested fields.
 * @example `common|error` to access `error` within the `common` sub-object.
 * {
 *     "common": {
 *         "error": "Error"
 *     }
 * }
 */

// Function which only purpose is to mark that a string is translatable
// Does not actually do anything. It's helpful for automatic extraction of translatable strings
function _td(s) {
  return s;
}

/**
 * to improve screen reader experience translations that are not in the main page language
 * eg a translation that fell back to english from another language
 * should be wrapped with an appropriate `lang='en'` attribute
 * counterpart's `translate` doesn't expose a way to determine if the resulting translation
 * is in the target locale or a fallback locale
 * for this reason, force fallbackLocale === locale in the first call to translate
 * and fallback 'manually' so we can mark fallback strings appropriately
 * */
const translateWithFallback = (text, options) => {
  const translated = _counterpart.default.translate(text, _objectSpread(_objectSpread({}, options), {}, {
    fallbackLocale: _counterpart.default.getLocale()
  }));
  if (!translated || translated.startsWith("missing translation:")) {
    const fallbackTranslated = _counterpart.default.translate(text, _objectSpread(_objectSpread({}, options), {}, {
      locale: FALLBACK_LOCALE
    }));
    if ((!fallbackTranslated || fallbackTranslated.startsWith("missing translation:")) && process.env.NODE_ENV !== "development") {
      // Even the translation via FALLBACK_LOCALE failed; this can happen if
      //
      // 1. The string isn't in the translations dictionary, usually because you're in develop
      // and haven't run yarn i18n
      // 2. Loading the translation resources over the network failed, which can happen due to
      // to network or if the client tried to load a translation that's been removed from the
      // server.
      //
      // At this point, its the lesser evil to show the untranslated text, which
      // will be in English, so the user can still make out *something*, rather than an opaque
      // "missing translation" error.
      //
      // Don't do this in develop so people remember to run yarn i18n.
      return {
        translated: text,
        isFallback: true
      };
    }
    return {
      translated: fallbackTranslated,
      isFallback: true
    };
  }
  return {
    translated
  };
};

// Wrapper for counterpart's translation function so that it handles nulls and undefineds properly
// Takes the same arguments as counterpart.translate()
function safeCounterpartTranslate(text, variables) {
  // Don't do substitutions in counterpart. We handle it ourselves so we can replace with React components
  // However, still pass the variables to counterpart so that it can choose the correct plural if count is given
  // It is enough to pass the count variable, but in the future counterpart might make use of other information too
  const options = _objectSpread(_objectSpread({}, variables), {}, {
    interpolate: false
  });

  // Horrible hack to avoid https://github.com/vector-im/element-web/issues/4191
  // The interpolation library that counterpart uses does not support undefined/null
  // values and instead will throw an error. This is a problem since everywhere else
  // in JS land passing undefined/null will simply stringify instead, and when converting
  // valid ES6 template strings to i18n strings it's extremely easy to pass undefined/null
  // if there are no existing null guards. To avoid this making the app completely inoperable,
  // we'll check all the values for undefined/null and stringify them here.
  if (options && typeof options === "object") {
    Object.keys(options).forEach(k => {
      if (options[k] === undefined) {
        _logger.logger.warn("safeCounterpartTranslate called with undefined interpolation name: " + k);
        options[k] = "undefined";
      }
      if (options[k] === null) {
        _logger.logger.warn("safeCounterpartTranslate called with null interpolation name: " + k);
        options[k] = "null";
      }
    });
  }
  return translateWithFallback(text, options);
}

/**
 * The value a variable or tag can take for a translation interpolation.
 */

// For development/testing purposes it is useful to also output the original string
// Don't do that for release versions
const annotateStrings = (result, translationKey) => {
  if (!ANNOTATE_STRINGS) {
    return result;
  }
  if (typeof result === "string") {
    return `@@${translationKey}##${result}@@`;
  } else {
    return /*#__PURE__*/_react.default.createElement("span", {
      className: "translated-string",
      "data-orig-string": translationKey
    }, result);
  }
};

/*
 * Translates text and optionally also replaces XML-ish elements in the text with e.g. React components
 * @param {string} text The untranslated text, e.g "click <a>here</a> now to %(foo)s".
 * @param {object} variables Variable substitutions, e.g { foo: 'bar' }
 * @param {object} tags Tag substitutions e.g. { 'a': (sub) => <a>{sub}</a> }
 *
 * In both variables and tags, the values to substitute with can be either simple strings, React components,
 * or functions that return the value to use in the substitution (e.g. return a React component). In case of
 * a tag replacement, the function receives as the argument the text inside the element corresponding to the tag.
 *
 * Use tag substitutions if you need to translate text between tags (e.g. "<a>Click here!</a>"), otherwise
 * you will end up with literal "<a>" in your output, rather than HTML. Note that you can also use variable
 * substitution to insert React components, but you can't use it to translate text between tags.
 *
 * @return a React <span> component if any non-strings were used in substitutions, otherwise a string
 */
// eslint-next-line @typescript-eslint/naming-convention

function _t(text, variables, tags) {
  // The translation returns text so there's no XSS vector here (no unsafe HTML, no code execution)
  const {
    translated
  } = safeCounterpartTranslate(text, variables);
  const substituted = substitute(translated, variables, tags);
  return annotateStrings(substituted, text);
}

/**
 * Utility function to look up a string by its translation key without resolving variables & tags
 * @param key - the translation key to return the value for
 */
function lookupString(key) {
  return safeCounterpartTranslate(key, {}).translated;
}

/*
 * Wraps normal _t function and adds atttribution for translations that used a fallback locale
 * Wraps translations that fell back from active locale to fallback locale with a `<span lang=<fallback locale>>`
 * @param {string} text The untranslated text, e.g "click <a>here</a> now to %(foo)s".
 * @param {object} variables Variable substitutions, e.g { foo: 'bar' }
 * @param {object} tags Tag substitutions e.g. { 'a': (sub) => <a>{sub}</a> }
 *
 * @return a React <span> component if any non-strings were used in substitutions
 * or translation used a fallback locale, otherwise a string
 */
// eslint-next-line @typescript-eslint/naming-convention

function _tDom(text, variables, tags) {
  // The translation returns text so there's no XSS vector here (no unsafe HTML, no code execution)
  const {
    translated,
    isFallback
  } = safeCounterpartTranslate(text, variables);
  const substituted = substitute(translated, variables, tags);

  // wrap en fallback translation with lang attribute for screen readers
  const result = isFallback ? /*#__PURE__*/_react.default.createElement("span", {
    lang: "en"
  }, substituted) : substituted;
  return annotateStrings(result, text);
}

/**
 * Sanitizes unsafe text for the sanitizer, ensuring references to variables will not be considered
 * replaceable by the translation functions.
 * @param {string} text The text to sanitize.
 * @returns {string} The sanitized text.
 */
function sanitizeForTranslation(text) {
  // Add a non-breaking space so the regex doesn't trigger when translating.
  return text.replace(/%\(([^)]*)\)/g, "%\xa0($1)");
}

/*
 * Similar to _t(), except only does substitutions, and no translation
 * @param {string} text The text, e.g "click <a>here</a> now to %(foo)s".
 * @param {object} variables Variable substitutions, e.g { foo: 'bar' }
 * @param {object} tags Tag substitutions e.g. { 'a': (sub) => <a>{sub}</a> }
 *
 * The values to substitute with can be either simple strings, or functions that return the value to use in
 * the substitution (e.g. return a React component). In case of a tag replacement, the function receives as
 * the argument the text inside the element corresponding to the tag.
 *
 * @return a React <span> component if any non-strings were used in substitutions, otherwise a string
 */

function substitute(text, variables, tags) {
  let result = text;
  if (variables !== undefined) {
    const regexpMapping = {};
    for (const variable in variables) {
      regexpMapping[`%\\(${variable}\\)s`] = variables[variable];
    }
    result = replaceByRegexes(result, regexpMapping);
  }
  if (tags !== undefined) {
    const regexpMapping = {};
    for (const tag in tags) {
      regexpMapping[`(<${tag}>(.*?)<\\/${tag}>|<${tag}>|<${tag}\\s*\\/>)`] = tags[tag];
    }
    result = replaceByRegexes(result, regexpMapping);
  }
  return result;
}

/**
 * Replace parts of a text using regular expressions
 * @param text - The text on which to perform substitutions
 * @param mapping - A mapping from regular expressions in string form to replacement string or a
 * function which will receive as the argument the capture groups defined in the regexp. E.g.
 * { 'Hello (.?) World': (sub) => sub.toUpperCase() }
 *
 * @return a React <span> component if any non-strings were used in substitutions, otherwise a string
 */

function replaceByRegexes(text, mapping) {
  // We initially store our output as an array of strings and objects (e.g. React components).
  // This will then be converted to a string or a <span> at the end
  const output = [text];

  // If we insert any components we need to wrap the output in a span. React doesn't like just an array of components.
  let shouldWrapInSpan = false;
  for (const regexpString in mapping) {
    // TODO: Cache regexps
    const regexp = new RegExp(regexpString, "g");

    // Loop over what output we have so far and perform replacements
    // We look for matches: if we find one, we get three parts: everything before the match, the replaced part,
    // and everything after the match. Insert all three into the output. We need to do this because we can insert objects.
    // Otherwise there would be no need for the splitting and we could do simple replacement.
    let matchFoundSomewhere = false; // If we don't find a match anywhere we want to log it
    for (let outputIndex = 0; outputIndex < output.length; outputIndex++) {
      const inputText = output[outputIndex];
      if (typeof inputText !== "string") {
        // We might have inserted objects earlier, don't try to replace them
        continue;
      }

      // process every match in the string
      // starting with the first
      let match = regexp.exec(inputText);
      if (!match) continue;
      matchFoundSomewhere = true;

      // The textual part before the first match
      const head = inputText.slice(0, match.index);
      const parts = [];
      // keep track of prevMatch
      let prevMatch;
      while (match) {
        // store prevMatch
        prevMatch = match;
        const capturedGroups = match.slice(2);
        let replaced;
        // If substitution is a function, call it
        if (mapping[regexpString] instanceof Function) {
          replaced = mapping[regexpString](...capturedGroups);
        } else {
          replaced = mapping[regexpString];
        }
        if (typeof replaced === "object") {
          shouldWrapInSpan = true;
        }

        // Here we also need to check that it actually is a string before comparing against one
        // The head and tail are always strings
        if (typeof replaced !== "string" || replaced !== "") {
          parts.push(replaced);
        }

        // try the next match
        match = regexp.exec(inputText);

        // add the text between prevMatch and this one
        // or the end of the string if prevMatch is the last match
        let tail;
        if (match) {
          const startIndex = prevMatch.index + prevMatch[0].length;
          tail = inputText.slice(startIndex, match.index);
        } else {
          tail = inputText.slice(prevMatch.index + prevMatch[0].length);
        }
        if (tail) {
          parts.push(tail);
        }
      }

      // Insert in reverse order as splice does insert-before and this way we get the final order correct
      // remove the old element at the same time
      output.splice(outputIndex, 1, ...parts);
      if (head !== "") {
        // Don't push empty nodes, they are of no use
        output.splice(outputIndex, 0, head);
      }
    }
    if (!matchFoundSomewhere) {
      if (
      // The current regexp did not match anything in the input. Missing
      // matches is entirely possible because you might choose to show some
      // variables only in the case of e.g. plurals. It's still a bit
      // suspicious, and could be due to an error, so log it. However, not
      // showing count is so common that it's not worth logging. And other
      // commonly unused variables here, if there are any.
      regexpString !== "%\\(count\\)s" &&
      // Ignore the `locale` option which can be used to override the locale
      // in counterpart
      regexpString !== "%\\(locale\\)s") {
        _logger.logger.log(`Could not find ${regexp} in ${text}`);
      }
    }
  }
  if (shouldWrapInSpan) {
    return /*#__PURE__*/_react.default.createElement("span", null, ...output);
  } else {
    return output.join("");
  }
}

// Allow overriding the text displayed when no translation exists
// Currently only used in unit tests to avoid having to load
// the translations in element-web
function setMissingEntryGenerator(f) {
  _counterpart.default.setMissingEntryGenerator(f);
}
function setLanguage(preferredLangs) {
  if (!Array.isArray(preferredLangs)) {
    preferredLangs = [preferredLangs];
  }
  const plaf = _PlatformPeg.default.get();
  if (plaf) {
    plaf.setLanguage(preferredLangs);
  }
  let langToUse;
  let availLangs;
  return getLangsJson().then(result => {
    availLangs = result;
    for (let i = 0; i < preferredLangs.length; ++i) {
      if (availLangs.hasOwnProperty(preferredLangs[i])) {
        langToUse = preferredLangs[i];
        break;
      }
    }
    if (!langToUse) {
      // Fallback to en_EN if none is found
      langToUse = "en";
      _logger.logger.error("Unable to find an appropriate language");
    }
    return getLanguageRetry(i18nFolder + availLangs[langToUse]);
  }).then(async langData => {
    _counterpart.default.registerTranslations(langToUse, langData);
    await registerCustomTranslations();
    _counterpart.default.setLocale(langToUse);
    await _SettingsStore.default.setValue("language", null, _SettingLevel.SettingLevel.DEVICE, langToUse);
    // Adds a lot of noise to test runs, so disable logging there.
    if (process.env.NODE_ENV !== "test") {
      _logger.logger.log("set language to " + langToUse);
    }

    // Set 'en' as fallback language:
    if (langToUse !== "en") {
      return getLanguageRetry(i18nFolder + availLangs["en"]);
    }
  }).then(async langData => {
    if (langData) _counterpart.default.registerTranslations("en", langData);
    await registerCustomTranslations();
  });
}
async function getAllLanguagesFromJson() {
  return Object.keys(await getLangsJson());
}
async function getAllLanguagesWithLabels() {
  const languageNames = new Intl.DisplayNames([getUserLanguage()], {
    type: "language",
    style: "short"
  });
  const languages = await getAllLanguagesFromJson();
  return languages.map(langKey => {
    return {
      value: langKey,
      label: languageNames.of(langKey),
      labelInTargetLanguage: new Intl.DisplayNames([langKey], {
        type: "language",
        style: "short"
      }).of(langKey)
    };
  });
}
function getLanguagesFromBrowser() {
  if (navigator.languages && navigator.languages.length) return navigator.languages;
  if (navigator.language) return [navigator.language];
  return [navigator.userLanguage || "en"];
}
function getLanguageFromBrowser() {
  return getLanguagesFromBrowser()[0];
}
function getCurrentLanguage() {
  return _counterpart.default.getLocale();
}

/**
 * Given a list of language codes, pick the most appropriate one
 * given the current language (ie. getCurrentLanguage())
 * English is assumed to be a reasonable default.
 *
 * @param {string[]} langs List of language codes to pick from
 * @returns {string} The most appropriate language code from langs
 */
function pickBestLanguage(langs) {
  const currentLang = getCurrentLanguage();
  const normalisedLangs = langs.map(_matrixWebI18n.normalizeLanguageKey);
  {
    // Best is an exact match
    const currentLangIndex = normalisedLangs.indexOf(currentLang);
    if (currentLangIndex > -1) return langs[currentLangIndex];
  }
  {
    // Failing that, a different dialect of the same language
    const closeLangIndex = normalisedLangs.findIndex(l => l.slice(0, 2) === currentLang.slice(0, 2));
    if (closeLangIndex > -1) return langs[closeLangIndex];
  }
  {
    // Neither of those? Try an english variant.
    const enIndex = normalisedLangs.findIndex(l => l.startsWith("en"));
    if (enIndex > -1) return langs[enIndex];
  }

  // if nothing else, use the first
  return langs[0];
}
async function getLangsJson() {
  let url;
  if (typeof _languages.default === "string") {
    // in Jest this 'url' isn't a URL, so just fall through
    url = _languages.default;
  } else {
    url = i18nFolder + "languages.json";
  }
  const res = await fetch(url, {
    method: "GET"
  });
  if (!res.ok) {
    throw new Error(`Failed to load ${url}, got ${res.status}`);
  }
  return res.json();
}
async function getLanguageRetry(langPath, num = 3) {
  return (0, _promise.retry)(() => getLanguage(langPath), num, e => {
    _logger.logger.log("Failed to load i18n", langPath);
    _logger.logger.error(e);
    return true; // always retry
  });
}
async function getLanguage(langPath) {
  const res = await fetch(langPath, {
    method: "GET"
  });
  if (!res.ok) {
    throw new Error(`Failed to load ${langPath}, got ${res.status}`);
  }
  return res.json();
}
let cachedCustomTranslations = null;
let cachedCustomTranslationsExpire = 0; // zero to trigger expiration right away

// This awkward class exists so the test runner can get at the function. It is
// not intended for practical or realistic usage.
class CustomTranslationOptions {
  constructor() {
    // static access for tests only
  }
}
exports.CustomTranslationOptions = CustomTranslationOptions;
(0, _defineProperty2.default)(CustomTranslationOptions, "lookupFn", void 0);
function doRegisterTranslations(customTranslations) {
  // We convert the operator-friendly version into something counterpart can consume.
  // Map: lang → Record: string → translation
  const langs = new _utils.MapWithDefault(() => ({}));
  for (const [translationKey, translations] of Object.entries(customTranslations)) {
    for (const [lang, translation] of Object.entries(translations)) {
      _lodash.default.set(langs.getOrCreate(lang), translationKey.split(_matrixWebI18n.KEY_SEPARATOR), translation);
    }
  }

  // Finally, tell counterpart about our translations
  for (const [lang, translations] of langs) {
    _counterpart.default.registerTranslations(lang, translations);
  }
}

/**
 * Any custom modules with translations to load are parsed first, followed by an
 * optionally defined translations file in the config. If no customization is made,
 * or the file can't be parsed, no action will be taken.
 *
 * This function should be called *after* registering other translations data to
 * ensure it overrides strings properly.
 */
async function registerCustomTranslations({
  testOnlyIgnoreCustomTranslationsCache = false
} = {}) {
  const moduleTranslations = _ModuleRunner.ModuleRunner.instance.allTranslations;
  doRegisterTranslations(moduleTranslations);
  const lookupUrl = _SdkConfig.default.get().custom_translations_url;
  if (!lookupUrl) return; // easy - nothing to do

  try {
    let json;
    if (testOnlyIgnoreCustomTranslationsCache || Date.now() >= cachedCustomTranslationsExpire) {
      json = CustomTranslationOptions.lookupFn ? CustomTranslationOptions.lookupFn(lookupUrl) : await (await fetch(lookupUrl)).json();
      cachedCustomTranslations = json;

      // Set expiration to the future, but not too far. Just trying to avoid
      // repeated, successive, calls to the server rather than anything long-term.
      cachedCustomTranslationsExpire = Date.now() + 5 * 60 * 1000;
    } else {
      json = cachedCustomTranslations;
    }

    // If the (potentially cached) json is invalid, don't use it.
    if (!json) return;

    // Finally, register it.
    doRegisterTranslations(json);
  } catch (e) {
    // We consume all exceptions because it's considered non-fatal for custom
    // translations to break. Most failures will be during initial development
    // of the json file and not (hopefully) at runtime.
    _logger.logger.warn("Ignoring error while registering custom translations: ", e);

    // Like above: trigger a cache of the json to avoid successive calls.
    cachedCustomTranslationsExpire = Date.now() + 5 * 60 * 1000;
  }
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_counterpart","_interopRequireDefault","require","_react","_logger","_utils","_matrixWebI18n","_lodash","_SettingsStore","_PlatformPeg","_SettingLevel","_promise","_SdkConfig","_ModuleRunner","_languages","_excluded","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","default","getOwnPropertyDescriptors","defineProperties","defineProperty","i18nFolder","ANNOTATE_STRINGS","counterpart","setSeparator","KEY_SEPARATOR","FALLBACK_LOCALE","setFallbackLocale","UserFriendlyError","Error","constructor","message","substitutionVariablesAndCause","_ref","cause","substitutionVariables","_objectWithoutProperties2","errorOptions","englishTranslatedMessage","_t","locale","translatedMessage","exports","getUserLanguage","language","SettingsStore","getValue","normalizeLanguageKey","getLanguageFromBrowser","_td","s","translateWithFallback","text","options","translated","translate","fallbackLocale","getLocale","startsWith","fallbackTranslated","process","env","NODE_ENV","isFallback","safeCounterpartTranslate","variables","interpolate","k","undefined","logger","warn","annotateStrings","result","translationKey","createElement","className","tags","substituted","substitute","lookupString","key","_tDom","lang","sanitizeForTranslation","replace","regexpMapping","variable","replaceByRegexes","tag","mapping","output","shouldWrapInSpan","regexpString","regexp","RegExp","matchFoundSomewhere","outputIndex","inputText","match","exec","head","slice","index","parts","prevMatch","capturedGroups","replaced","Function","tail","startIndex","splice","log","React","join","setMissingEntryGenerator","f","setLanguage","preferredLangs","Array","isArray","plaf","PlatformPeg","get","langToUse","availLangs","getLangsJson","then","i","hasOwnProperty","error","getLanguageRetry","langData","registerTranslations","registerCustomTranslations","setLocale","setValue","SettingLevel","DEVICE","getAllLanguagesFromJson","getAllLanguagesWithLabels","languageNames","Intl","DisplayNames","type","style","languages","map","langKey","value","label","of","labelInTargetLanguage","getLanguagesFromBrowser","navigator","userLanguage","getCurrentLanguage","pickBestLanguage","langs","currentLang","normalisedLangs","currentLangIndex","indexOf","closeLangIndex","findIndex","l","enIndex","url","webpackLangJsonUrl","res","fetch","method","ok","status","json","langPath","num","retry","getLanguage","cachedCustomTranslations","cachedCustomTranslationsExpire","CustomTranslationOptions","doRegisterTranslations","customTranslations","MapWithDefault","translations","entries","translation","_","set","getOrCreate","split","testOnlyIgnoreCustomTranslationsCache","moduleTranslations","ModuleRunner","instance","allTranslations","lookupUrl","SdkConfig","custom_translations_url","Date","now","lookupFn"],"sources":["../src/languageHandler.tsx"],"sourcesContent":["/*\nCopyright 2024 New Vector Ltd.\nCopyright 2019-2022 The Matrix.org Foundation C.I.C.\nCopyright 2019 Michael Telatynski <7t3chguy@gmail.com>\nCopyright 2017 MTRNord and Cooperative EITA\nCopyright 2017 Vector Creations Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport counterpart from \"counterpart\";\nimport React from \"react\";\nimport { logger } from \"matrix-js-sdk/src/logger\";\nimport { Optional } from \"matrix-events-sdk\";\nimport { MapWithDefault } from \"matrix-js-sdk/src/utils\";\nimport { normalizeLanguageKey, TranslationKey as _TranslationKey, KEY_SEPARATOR } from \"matrix-web-i18n\";\nimport { TranslationStringsObject } from \"@matrix-org/react-sdk-module-api\";\nimport _ from \"lodash\";\n\nimport type Translations from \"./i18n/strings/en_EN.json\";\nimport SettingsStore from \"./settings/SettingsStore\";\nimport PlatformPeg from \"./PlatformPeg\";\nimport { SettingLevel } from \"./settings/SettingLevel\";\nimport { retry } from \"./utils/promise\";\nimport SdkConfig from \"./SdkConfig\";\nimport { ModuleRunner } from \"./modules/ModuleRunner\";\n\n// @ts-ignore - $webapp is a webpack resolve alias pointing to the output directory, see webpack config\nimport webpackLangJsonUrl from \"$webapp/i18n/languages.json\";\n\nexport { normalizeLanguageKey, getNormalizedLanguageKeys } from \"matrix-web-i18n\";\n\nconst i18nFolder = \"i18n/\";\n\n// Control whether to also return original, untranslated strings\n// Useful for debugging and testing\nconst ANNOTATE_STRINGS = false;\n\n// We use english strings as keys, some of which contain full stops\ncounterpart.setSeparator(KEY_SEPARATOR);\n\n// see `translateWithFallback` for an explanation of fallback handling\nconst FALLBACK_LOCALE = \"en\";\ncounterpart.setFallbackLocale(FALLBACK_LOCALE);\n\nexport interface ErrorOptions {\n    // Because we're mixing the substitution variables and `cause` into the same object\n    // below, we want them to always explicitly say whether there is an underlying error\n    // or not to avoid typos of \"cause\" slipping through unnoticed.\n    cause: unknown | undefined;\n}\n\n/**\n * Used to rethrow an error with a user-friendly translatable message while maintaining\n * access to that original underlying error. Downstream consumers can display the\n * `translatedMessage` property in the UI and inspect the underlying error with the\n * `cause` property.\n *\n * The error message will display as English in the console and logs so Element\n * developers can easily understand the error and find the source in the code. It also\n * helps tools like Sentry deduplicate the error, or just generally searching in\n * rageshakes to find all instances regardless of the users locale.\n *\n * @param message - The untranslated error message text, e.g \"Something went wrong with %(foo)s\".\n * @param substitutionVariablesAndCause - Variable substitutions for the translation and\n * original cause of the error. If there is no cause, just pass `undefined`, e.g { foo:\n * 'bar', cause: err || undefined }\n */\nexport class UserFriendlyError extends Error {\n    public readonly translatedMessage: string;\n\n    public constructor(\n        message: TranslationKey,\n        substitutionVariablesAndCause?: Omit<IVariables, keyof ErrorOptions> | ErrorOptions,\n    ) {\n        // Prevent \"Could not find /%\\(cause\\)s/g in x\" logs to the console by removing it from the list\n        const { cause, ...substitutionVariables } = substitutionVariablesAndCause ?? {};\n        const errorOptions = { cause };\n\n        // Create the error with the English version of the message that we want to show up in the logs\n        const englishTranslatedMessage = _t(message, { ...substitutionVariables, locale: \"en\" });\n        super(englishTranslatedMessage, errorOptions);\n\n        // Also provide a translated version of the error in the users locale to display\n        this.translatedMessage = _t(message, substitutionVariables);\n    }\n}\n\nexport function getUserLanguage(): string {\n    const language = SettingsStore.getValue(\"language\", null, /*excludeDefault:*/ true);\n    if (typeof language === \"string\" && language !== \"\") {\n        return language;\n    } else {\n        return normalizeLanguageKey(getLanguageFromBrowser());\n    }\n}\n\n/**\n * A type representing the union of possible keys into the translation file using `|` delimiter to access nested fields.\n * @example `common|error` to access `error` within the `common` sub-object.\n * {\n *     \"common\": {\n *         \"error\": \"Error\"\n *     }\n * }\n */\nexport type TranslationKey = _TranslationKey<typeof Translations>;\n\n// Function which only purpose is to mark that a string is translatable\n// Does not actually do anything. It's helpful for automatic extraction of translatable strings\nexport function _td(s: TranslationKey): TranslationKey {\n    return s;\n}\n\n/**\n * to improve screen reader experience translations that are not in the main page language\n * eg a translation that fell back to english from another language\n * should be wrapped with an appropriate `lang='en'` attribute\n * counterpart's `translate` doesn't expose a way to determine if the resulting translation\n * is in the target locale or a fallback locale\n * for this reason, force fallbackLocale === locale in the first call to translate\n * and fallback 'manually' so we can mark fallback strings appropriately\n * */\nconst translateWithFallback = (text: string, options?: IVariables): { translated: string; isFallback?: boolean } => {\n    const translated = counterpart.translate(text, { ...options, fallbackLocale: counterpart.getLocale() });\n    if (!translated || translated.startsWith(\"missing translation:\")) {\n        const fallbackTranslated = counterpart.translate(text, { ...options, locale: FALLBACK_LOCALE });\n        if (\n            (!fallbackTranslated || fallbackTranslated.startsWith(\"missing translation:\")) &&\n            process.env.NODE_ENV !== \"development\"\n        ) {\n            // Even the translation via FALLBACK_LOCALE failed; this can happen if\n            //\n            // 1. The string isn't in the translations dictionary, usually because you're in develop\n            // and haven't run yarn i18n\n            // 2. Loading the translation resources over the network failed, which can happen due to\n            // to network or if the client tried to load a translation that's been removed from the\n            // server.\n            //\n            // At this point, its the lesser evil to show the untranslated text, which\n            // will be in English, so the user can still make out *something*, rather than an opaque\n            // \"missing translation\" error.\n            //\n            // Don't do this in develop so people remember to run yarn i18n.\n            return { translated: text, isFallback: true };\n        }\n        return { translated: fallbackTranslated, isFallback: true };\n    }\n    return { translated };\n};\n\n// Wrapper for counterpart's translation function so that it handles nulls and undefineds properly\n// Takes the same arguments as counterpart.translate()\nfunction safeCounterpartTranslate(text: string, variables?: IVariables): { translated: string; isFallback?: boolean } {\n    // Don't do substitutions in counterpart. We handle it ourselves so we can replace with React components\n    // However, still pass the variables to counterpart so that it can choose the correct plural if count is given\n    // It is enough to pass the count variable, but in the future counterpart might make use of other information too\n    const options: IVariables & {\n        interpolate: boolean;\n    } = { ...variables, interpolate: false };\n\n    // Horrible hack to avoid https://github.com/vector-im/element-web/issues/4191\n    // The interpolation library that counterpart uses does not support undefined/null\n    // values and instead will throw an error. This is a problem since everywhere else\n    // in JS land passing undefined/null will simply stringify instead, and when converting\n    // valid ES6 template strings to i18n strings it's extremely easy to pass undefined/null\n    // if there are no existing null guards. To avoid this making the app completely inoperable,\n    // we'll check all the values for undefined/null and stringify them here.\n    if (options && typeof options === \"object\") {\n        Object.keys(options).forEach((k) => {\n            if (options[k] === undefined) {\n                logger.warn(\"safeCounterpartTranslate called with undefined interpolation name: \" + k);\n                options[k] = \"undefined\";\n            }\n            if (options[k] === null) {\n                logger.warn(\"safeCounterpartTranslate called with null interpolation name: \" + k);\n                options[k] = \"null\";\n            }\n        });\n    }\n    return translateWithFallback(text, options);\n}\n\n/**\n * The value a variable or tag can take for a translation interpolation.\n */\ntype SubstitutionValue = number | string | React.ReactNode | ((sub: string) => React.ReactNode);\n\nexport interface IVariables {\n    count?: number;\n    [key: string]: SubstitutionValue;\n}\n\nexport type Tags = Record<string, SubstitutionValue>;\n\nexport type TranslatedString = string | React.ReactNode;\n\n// For development/testing purposes it is useful to also output the original string\n// Don't do that for release versions\nconst annotateStrings = (result: TranslatedString, translationKey: TranslationKey): TranslatedString => {\n    if (!ANNOTATE_STRINGS) {\n        return result;\n    }\n\n    if (typeof result === \"string\") {\n        return `@@${translationKey}##${result}@@`;\n    } else {\n        return (\n            <span className=\"translated-string\" data-orig-string={translationKey}>\n                {result}\n            </span>\n        );\n    }\n};\n\n/*\n * Translates text and optionally also replaces XML-ish elements in the text with e.g. React components\n * @param {string} text The untranslated text, e.g \"click <a>here</a> now to %(foo)s\".\n * @param {object} variables Variable substitutions, e.g { foo: 'bar' }\n * @param {object} tags Tag substitutions e.g. { 'a': (sub) => <a>{sub}</a> }\n *\n * In both variables and tags, the values to substitute with can be either simple strings, React components,\n * or functions that return the value to use in the substitution (e.g. return a React component). In case of\n * a tag replacement, the function receives as the argument the text inside the element corresponding to the tag.\n *\n * Use tag substitutions if you need to translate text between tags (e.g. \"<a>Click here!</a>\"), otherwise\n * you will end up with literal \"<a>\" in your output, rather than HTML. Note that you can also use variable\n * substitution to insert React components, but you can't use it to translate text between tags.\n *\n * @return a React <span> component if any non-strings were used in substitutions, otherwise a string\n */\n// eslint-next-line @typescript-eslint/naming-convention\nexport function _t(text: TranslationKey, variables?: IVariables): string;\nexport function _t(text: TranslationKey, variables: IVariables | undefined, tags: Tags): React.ReactNode;\nexport function _t(text: TranslationKey, variables?: IVariables, tags?: Tags): TranslatedString {\n    // The translation returns text so there's no XSS vector here (no unsafe HTML, no code execution)\n    const { translated } = safeCounterpartTranslate(text, variables);\n    const substituted = substitute(translated, variables, tags);\n\n    return annotateStrings(substituted, text);\n}\n\n/**\n * Utility function to look up a string by its translation key without resolving variables & tags\n * @param key - the translation key to return the value for\n */\nexport function lookupString(key: TranslationKey): string {\n    return safeCounterpartTranslate(key, {}).translated;\n}\n\n/*\n * Wraps normal _t function and adds atttribution for translations that used a fallback locale\n * Wraps translations that fell back from active locale to fallback locale with a `<span lang=<fallback locale>>`\n * @param {string} text The untranslated text, e.g \"click <a>here</a> now to %(foo)s\".\n * @param {object} variables Variable substitutions, e.g { foo: 'bar' }\n * @param {object} tags Tag substitutions e.g. { 'a': (sub) => <a>{sub}</a> }\n *\n * @return a React <span> component if any non-strings were used in substitutions\n * or translation used a fallback locale, otherwise a string\n */\n// eslint-next-line @typescript-eslint/naming-convention\nexport function _tDom(text: TranslationKey, variables?: IVariables): TranslatedString;\nexport function _tDom(text: TranslationKey, variables: IVariables, tags: Tags): React.ReactNode;\nexport function _tDom(text: TranslationKey, variables?: IVariables, tags?: Tags): TranslatedString {\n    // The translation returns text so there's no XSS vector here (no unsafe HTML, no code execution)\n    const { translated, isFallback } = safeCounterpartTranslate(text, variables);\n    const substituted = substitute(translated, variables, tags);\n\n    // wrap en fallback translation with lang attribute for screen readers\n    const result = isFallback ? <span lang=\"en\">{substituted}</span> : substituted;\n\n    return annotateStrings(result, text);\n}\n\n/**\n * Sanitizes unsafe text