Node.js based forum software built for the modern web
'use strict';
module.exports = function (utils, load, warn) {
const assign = Object.assign || jQuery.extend;
function escapeHTML(str) {
return utils.escapeHTML(utils.decodeHTMLEntities(
String(str)
.replace(/[\s\xa0]+/g, ' ')
.replace(/^\s+|\s+$/g, '')
));
}
function fixDoubleEscaped(str) {
// fix double escaped translation keys, see https://github.com/NodeBB/NodeBB/issues/9206
return str.replace(/[/g, '[')
.replace(/]/g, ']');
}
function isTranslationKey(str) {
const tokens = parseTranslationString(str);
return tokens.length === 1 && tokens[0].tx;
}
function hasTranslationKey(str) {
return parseTranslationString(str).some(token => token.tx);
}
// supports nested keys like 'nested-key.nested-1' and returns the value if found, otherwise returns false
function resolveKey(x, key) {
if (!x || !key) return false;
if (typeof x[key] === 'string') return x[key];
const keyParts = key.split('.');
for (let i = 0; i <= keyParts.length; i++) {
if (i === keyParts.length) {
// default to trying to find key with the same name as parent or equal to empty string
return x[keyParts[i - 1]] !== undefined ? x[keyParts[i - 1]] : x[''];
}
switch (typeof x[keyParts[i]]) {
case 'object':
x = x[keyParts[i]];
break;
case 'string':
if (i === keyParts.length - 1) {
return x[keyParts[i]];
}
return false;
default:
return false;
}
}
}
// takes token '[[topic:moved-from, arg1, arg2]]' and
// normalizes it to ['topic:moved-from', ['arg1', 'arg2']]
function normalizeToken(token, ignoreArgs = false) {
if (typeof token !== 'string' || token === '') {
return [String(token), []];
}
if (token.startsWith('[[') && token.endsWith(']]')) {
token = token.slice(2, -2);
}
if (ignoreArgs) {
return [token.trim(), []];
}
const parts = split(token); // use same split as translator.translate
if (parts.length === 0) {
return [token.trim(), []];
}
const txToken = parts[0].trim();
const args = parts.slice(1).map(part => part.trim());
return [txToken, args];
}
// replaces %1, %2 in translation with args[0], args[1] respectively
function replaceArguments(translation, args) {
if (!Array.isArray(args) || args.length === 0) {
return translation;
}
args.forEach((arg, index) => {
const argEscaped = arg.replace(/%(?=\d)/g, '%').replace(/\\,/g, ',');
translation = translation.replaceAll(`%${index + 1}`, argEscaped);
});
return validateHrefAttributes(translation);
}
function validateHrefAttributes(translated) {
return translated.replace(/href\s*=\s*(["'])(.*?)\1/gi, (match, quote, href) => {
return utils.isSafeHref(href) ? match : 'href=""';
});
}
// split a translator string into an array of tokens
// but don't split by commas inside other translator strings
// "namespace:key, arg1, [[namespace:key, arg2]]" becomes
// ["namespace:key", "arg1", "[[namespace:key, arg2]]"]
function split(text) {
// skip strings that don't have commas, this makes [[namespace:key]] tokens faster
if (text.indexOf(',') === - 1) {
return [];
}
const lenLessOne = text.length - 1;
const arr = [];
let i = 0;
let brk = 0;
let level = 0;
while (i < lenLessOne) {
const cur = text[i];
const next = text[i + 1];
if (cur === '[' && next === '[') {
level += 1;
i += 1;
} else if (cur === ']' && next === ']') {
level -= 1;
i += 1;
} else if (level === 0 && cur === ',' && text[i - 1] !== '\\') {
arr.push(text.slice(brk, i).trim());
i += 1;
brk = i;
}
i += 1;
}
arr.push(text.slice(brk, i + 1).trim());
return arr;
}
/*
turns
`]] some text here [[namespace1:key1, arg1, arg2]] other text [[invalid]] test [[namespace2:key2]] [[invalid`;
into
[
{ text: ']] some text here ', tx: false },
{ text: '[[namespace1:key1, arg1, arg2]]', tx: true },
{ text: ' other text [[invalid]] test ', tx: false },
{ text: '[[namespace2:key2]]', tx: true },
{ text: ' [[invalid', tx: false }
]
*/
const TOKEN_VALIDATOR = /^\[\[[^[\]\s,]+:[^[\]\s,]+/;
function parseTranslationString(str) {
const results = [];
let cursor = 0;
let lastCut = 0;
const len = str.length;
while (cursor < len) {
// jump directly to the next opening bracket
const nextOpen = str.indexOf('[[', cursor);
if (nextOpen === -1) break; // No more tokens, exit loop
let depth = 1;
let i = nextOpen + 2;
let foundClose = false;
while (i < len) {
// jump from bracket to bracket instead of char to char
const closeIdx = str.indexOf(']]', i);
if (closeIdx === -1) {
break; // Missing a closing bracket entirely
}
const openIdx = str.indexOf('[[', i);
// If we found another '[[', and it's BEFORE the next ']]', we are nesting
if (openIdx !== -1 && openIdx < closeIdx) {
depth++;
i = openIdx + 2;
} else {
// Otherwise, we are closing a bracket
depth--;
i = closeIdx + 2;
// If depth hits 0, we found the end of the outer token!
if (depth === 0) {
foundClose = true;
break;
}
}
}
if (foundClose) {
const token = str.slice(nextOpen, i);
// Validate the token format
if (TOKEN_VALIDATOR.test(token)) {
// Push leading normal text if it exists
if (nextOpen > lastCut) {
results.push({ text: str.slice(lastCut, nextOpen), tx: false });
}
// Push the valid token
results.push({ text: token, tx: true });
// Advance our cuts and cursors past this token
lastCut = i;
cursor = i;
continue;
}
}
// --- BACKTRACKING ---
// If we get here, the token was unclosed OR invalid.
// We simply move the cursor past the broken '[[' and let the outer loop try again.
// The broken brackets will eventually just get sliced as normal text.
cursor = nextOpen + 2;
}
// Catch any remaining text at the end of the string
if (lastCut < len) {
results.push({ text: str.slice(lastCut), tx: false });
}
return results;
}
const Translator = (function () {
/**
* Construct a new Translator object
* @param {string} language - Language code for this translator instance
* @exports translator.Translator
*/
function Translator(language) {
const self = this;
if (!language) {
throw new TypeError('Parameter `language` must be a language string. Received ' + language + (language === '' ? '(empty string)' : ''));
}
self.modules = Object.keys(Translator.moduleFactories).map(function (namespace) {
const factory = Translator.moduleFactories[namespace];
return [namespace, factory(language)];
}).reduce(function (prev, elem) {
const namespace = elem[0];
const module = elem[1];
prev[namespace] = module;
return prev;
}, {});
self.lang = language;
self.translations = {};
}
Translator.prototype.load = load;
/**
* Parse the translation instructions into the language of the Translator instance
* @param {string} str - Source string
* @returns {Promise<string>}
*/
Translator.prototype.translate = function translate(str) {
const tokens = parseTranslationString(str);
return Promise.all(tokens.map(async (token) => {
if (token.tx) {
const [txToken, args] = normalizeToken(token.text);
return await this.translateKey(txToken, args, token.text);
}
return token.text;
})).then(translations => translations.join('')).catch(err => {
warn('Translation failed: ' + err.stack);
});
};
/**
* Translates a specific key and array of arguments
* @param {string} name - Translation key (ex. 'global:home')
* @param {string[]} args - Arguments for `%1`, `%2`, etc
* @param {string|Promise<string>} backup - Text to use in case the key can't be found
* @returns {Promise<string>}
*/
Translator.prototype.translateKey = function translateKey(name, args, backup) {
const self = this;
const result = name.split(':', 2);
const namespace = result[0];
const key = result[1];
if (self.modules[namespace]) {
return Promise.resolve(self.modules[namespace](key, args));
}
if (!namespace || (result.length === 1 || !key)) {
return Promise.resolve(escapeHTML(backup || name));
}
const translation = this.getTranslation(namespace, key);
return translation.then(function (translated) {
// check if the translation is missing first
if (!translated) {
warn('Missing translation "' + name + '" for language "' + self.lang + '"');
return escapeHTML(backup || name);
}
return self.txArgs(args).then(function (translatedArgs) {
return replaceArguments(translated, translatedArgs);
});
});
};
// translate arguments
Translator.prototype.txArgs = async function (args) {
if (!Array.isArray(args) || args.length === 0) {
return args;
}
return await Promise.all(args.map(async (arg) => {
const escapedArg = fixDoubleEscaped(escapeHTML(arg));
if (escapedArg.startsWith('[[') && escapedArg.endsWith(']]')) {
const [txToken, args] = normalizeToken(escapedArg);
return await this.translateKey(txToken, args);
}
return escapedArg;
}));
},
/**
* Load translation file (or use a cached version), and optionally return the translation of a certain key
* @param {string} namespace - The file name of the translation namespace
* @param {string} [key] - The key of the specific translation to getJSON
* @returns {Promise<{ [key: string]: string } | string>}
*/
Translator.prototype.getTranslation = function getTranslation(namespace, key) {
let translation;
if (!namespace) {
warn('[translator] Parameter `namespace` is ' + namespace + (namespace === '' ? '(empty string)' : ''));
translation = Promise.resolve({});
} else {
this.translations[namespace] = this.translations[namespace] ||
this.load(this.lang, namespace).catch(function () { return {}; });
translation = this.translations[namespace];
}
if (key) {
return translation.then(function (x) {
return resolveKey(x, key);
});
}
return translation;
};
/**
* Get the language of the current environment, falling back to defaults
* @returns {string}
*/
Translator.getLanguage = function getLanguage() {
return utils.getLanguage();
};
/**
* Create and cache a new Translator instance, or return a cached one
* @param {string} [language] - ('en-GB') Language string
* @returns {Translator}
*/
Translator.create = function create(language) {
if (!language) {
language = Translator.getLanguage();
}
Translator.cache[language] = Translator.cache[language] || new Translator(language);
return Translator.cache[language];
};
Translator.cache = {};
/**
* Register a custom module to handle translations
* @param {string} namespace - Namespace to handle translation for
* @param {Function} factory - Function to return the translation function for this namespace
*/
Translator.registerModule = function registerModule(namespace, factory) {
Translator.moduleFactories[namespace] = factory;
Object.keys(Translator.cache).forEach(function (key) {
const translator = Translator.cache[key];
translator.modules[namespace] = factory(translator.lang);
});
};
Translator.moduleFactories = {};
/**
* Remove the translator patterns from text
* @param {string} text
* @returns {string}
*/
Translator.removePatterns = function removePatterns(text) {
const len = text.length;
let cursor = 0;
let lastBreak = 0;
let level = 0;
let out = '';
let sub;
while (cursor < len) {
sub = text.slice(cursor, cursor + 2);
if (sub === '[[') {
if (level === 0) {
out += text.slice(lastBreak, cursor);
}
level += 1;
cursor += 2;
} else if (sub === ']]') {
level -= 1;
cursor += 2;
if (level === 0) {
lastBreak = cursor;
}
} else {
cursor += 1;
}
}
out += text.slice(lastBreak, cursor);
return out;
};
/**
* Escape translator patterns in text
* @param {string} text
* @returns {string}
*/
Translator.escape = function escape(text) {
return typeof text === 'string' ?
text.replace(/\[\[/g, '[[').replace(/\]\]/g, ']]') :
text;
/*
if (typeof text !== 'string') return text;
let previous;
// Keep matching the innermost unescaped brackets and converting them
while (text !== previous) {
previous = text;
text = text.replace(/\[\[([a-zA-Z0-9_.-]+:[^\[\]]+)\]\]/g, '[[$1]]');
}
return text;
*/
};
/**
* Unescape escaped translator patterns in text
* @param {string} text
* @returns {string}
*/
Translator.unescape = function unescape(text) {
return typeof text === 'string' ?
text.replace(/]]/g, ']]').replace(/[[/g, '[[') :
text;
/*
if (typeof text !== 'string') return text;
let previous;
// Keep matching the innermost escaped brackets and converting them back
while (text !== previous) {
previous = text;
text = text.replace(/[[([a-zA-Z0-9_.-]+:(?:(?![|]).)+)]]/g, '[[$1]]');
}
return text;
*/
};
/**
* Construct a translator pattern
* @param {string} name - Translation name
* @param {...string} arg - Optional argument for the pattern
*/
Translator.compile = function compile(...args) {
return `[[${args.map(Translator.escapeArg).join(', ')}]]`;
};
Translator.escapeArg = function (arg) {
arg = String(arg).replace(/%/g, '%').replace(/,/g, ',');
return isTranslationKey(arg) ? arg : Translator.escape(arg);
};
return Translator;
}());
/**
* @exports translator
*/
const adaptor = {
/**
* The Translator class
*/
Translator: Translator,
compile: Translator.compile,
escape: Translator.escape,
unescape: Translator.unescape,
escapeArg: Translator.escapeArg,
escapeHTML: escapeHTML,
fixDoubleEscaped: fixDoubleEscaped,
normalizeToken: normalizeToken,
replaceArguments: replaceArguments,
getLanguage: Translator.getLanguage,
rtlLanguages: ['ar', 'fa-IR', 'he', 'ur'],
languageDirection: function (lang) {
return this.rtlLanguages.includes(lang) ? 'rtl' : 'ltr';
},
isTranslationKey: isTranslationKey,
hasTranslationKey: hasTranslationKey,
resolveKey: resolveKey,
flush: function () {
Object.keys(Translator.cache).forEach(function (code) {
Translator.cache[code].translations = {};
});
},
flushNamespace: function (namespace) {
Object.keys(Translator.cache).forEach(function (code) {
if (Translator.cache[code] &&
Translator.cache[code].translations &&
Translator.cache[code].translations[namespace]
) {
Translator.cache[code].translations[namespace] = null;
}
});
},
/**
* translator function for backwards compatibility
*/
translate: function translate(text, language, callback) {
let cb = callback;
let lang = language;
if (typeof language === 'function') {
cb = language;
lang = null;
}
if (!(typeof text === 'string' || text instanceof String) || text === '') {
if (cb) {
return setTimeout(cb, 0, '');
}
return '';
}
return Translator.create(lang).translate(text).then(function (output) {
if (cb) {
setTimeout(cb, 0, output);
}
return output;
}, function (err) {
warn('Translation failed: ' + err.stack);
});
},
translateKeys: async function (data, language, callback) {
if (!Array.isArray(data)) {
throw new Error('[[error:invalid-data]]');
}
let cb = callback;
let lang = language;
if (typeof language === 'function') {
cb = language;
lang = null;
}
lang = lang || Translator.getLanguage();
// convert old format([[topic:moved-from]]) to new format [token, args, language]
data = data.map(key => (typeof key === 'string' ? [key || '', [], lang] : key));
const translations = await Promise.all(data.map(async (item) => {
const [token, itemArgs, language] = item;
const hasPassedArgs = Array.isArray(itemArgs) && itemArgs.length > 0;
const [txToken, argsFromToken] = adaptor.normalizeToken(token, hasPassedArgs);
let args = itemArgs;
if (!hasPassedArgs && Array.isArray(argsFromToken) && argsFromToken.length > 0) {
args = argsFromToken;
}
const tokenLanguage = language || lang;
return Translator.create(tokenLanguage).translateKey(txToken, args, token);
}));
if (typeof cb === 'function') {
return setTimeout(cb, 0, translations);
}
return translations;
},
// single tx token '[[topic:moved-from]]'
translateKey: async function (token, args, language) {
const [translation] = await adaptor.translateKeys([[token, args, language]]);
return translation;
},
/**
* Add translations to the cache
*/
addTranslation: function addTranslation(language, namespace, translation) {
Translator.create(language).getTranslation(namespace).then(function (translations) {
assign(translations, translation);
});
},
/**
* Get the translations object
*/
getTranslations: function getTranslations(language, namespace, callback) {
callback = callback || function () {};
Translator.create(language).getTranslation(namespace).then(callback);
},
/**
* Alias of getTranslations
*/
load: function load(language, namespace, callback) {
adaptor.getTranslations(language, namespace, callback);
},
toggleTimeagoShorthand: function toggleTimeagoShorthand(callback) {
/* eslint "prefer-object-spread": "off" */
function toggle() {
const tmp = assign({}, jQuery.timeago.settings.strings);
jQuery.timeago.settings.strings = assign({}, adaptor.timeagoShort);
adaptor.timeagoShort = assign({}, tmp);
if (typeof callback === 'function') {
callback();
}
}
if (!adaptor.timeagoShort) {
let languageCode = utils.userLangToTimeagoCode(config.userLang);
if (!config.timeagoCodes.includes(languageCode + '-short')) {
languageCode = 'en';
}
const originalSettings = assign({}, jQuery.timeago.settings.strings);
adaptor.switchTimeagoLanguage(languageCode + '-short', function () {
adaptor.timeagoShort = assign({}, jQuery.timeago.settings.strings);
jQuery.timeago.settings.strings = assign({}, originalSettings);
toggle();
});
} else {
toggle();
}
},
switchTimeagoLanguage: function switchTimeagoLanguage(langCode, callback) {
// Delete the cached shorthand strings if present
delete adaptor.timeagoShort;
import(/* webpackChunkName: "timeago/[request]" */ 'timeago/locales/jquery.timeago.' + langCode).then(callback);
},
};
return adaptor;
};