1405 lines
42 KiB
JavaScript
1405 lines
42 KiB
JavaScript
/**
|
|
* @author Created by Marcus Spiegel <spiegel@uscreen.de> on 2011-03-25.
|
|
* @link https://github.com/mashpie/i18n-node
|
|
* @license http://opensource.org/licenses/MIT
|
|
*/
|
|
|
|
'use strict'
|
|
|
|
// dependencies
|
|
const printf = require('fast-printf').printf
|
|
const pkgVersion = require('./package.json').version
|
|
const fs = require('fs')
|
|
const url = require('url')
|
|
const path = require('path')
|
|
const debug = require('debug')('i18n:debug')
|
|
const warn = require('debug')('i18n:warn')
|
|
const error = require('debug')('i18n:error')
|
|
const Mustache = require('mustache')
|
|
const Messageformat = require('@messageformat/core')
|
|
const MakePlural = require('make-plural')
|
|
const parseInterval = require('math-interval-parser').default
|
|
|
|
// utils
|
|
const escapeRegExp = (string) => string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') // $& means the whole matched string
|
|
|
|
/**
|
|
* create constructor function
|
|
*/
|
|
const i18n = function I18n(_OPTS = false) {
|
|
const MessageformatInstanceForLocale = {}
|
|
const PluralsForLocale = {}
|
|
let locales = {}
|
|
const api = {
|
|
__: '__',
|
|
__n: '__n',
|
|
__l: '__l',
|
|
__h: '__h',
|
|
__mf: '__mf',
|
|
getLocale: 'getLocale',
|
|
setLocale: 'setLocale',
|
|
getCatalog: 'getCatalog',
|
|
getLocales: 'getLocales',
|
|
addLocale: 'addLocale',
|
|
removeLocale: 'removeLocale'
|
|
}
|
|
const mustacheConfig = {
|
|
tags: ['{{', '}}'],
|
|
disable: false
|
|
}
|
|
|
|
let mustacheRegex
|
|
const pathsep = path.sep // ---> means win support will be available in node 0.8.x and above
|
|
let autoReload
|
|
let cookiename
|
|
let languageHeaderName
|
|
let defaultLocale
|
|
let retryInDefaultLocale
|
|
let directory
|
|
let directoryPermissions
|
|
let extension
|
|
let fallbacks
|
|
let indent
|
|
let logDebugFn
|
|
let logErrorFn
|
|
let logWarnFn
|
|
let preserveLegacyCase
|
|
let objectNotation
|
|
let prefix
|
|
let queryParameter
|
|
let register
|
|
let updateFiles
|
|
let syncFiles
|
|
let missingKeyFn
|
|
let parser
|
|
|
|
// public exports
|
|
const i18n = {}
|
|
|
|
i18n.version = pkgVersion
|
|
|
|
i18n.configure = function i18nConfigure(opt) {
|
|
// reset locales
|
|
locales = {}
|
|
|
|
// Provide custom API method aliases if desired
|
|
// This needs to be processed before the first call to applyAPItoObject()
|
|
if (opt.api && typeof opt.api === 'object') {
|
|
for (const method in opt.api) {
|
|
if (Object.prototype.hasOwnProperty.call(opt.api, method)) {
|
|
const alias = opt.api[method]
|
|
if (typeof api[method] !== 'undefined') {
|
|
api[method] = alias
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// you may register i18n in global scope, up to you
|
|
if (typeof opt.register === 'object') {
|
|
register = opt.register
|
|
// or give an array objects to register to
|
|
if (Array.isArray(opt.register)) {
|
|
register = opt.register
|
|
register.forEach(applyAPItoObject)
|
|
} else {
|
|
applyAPItoObject(opt.register)
|
|
}
|
|
}
|
|
|
|
// sets a custom cookie name to parse locale settings from
|
|
cookiename = typeof opt.cookie === 'string' ? opt.cookie : null
|
|
|
|
// set the custom header name to extract the language locale
|
|
languageHeaderName =
|
|
typeof opt.header === 'string' ? opt.header : 'accept-language'
|
|
|
|
// query-string parameter to be watched - @todo: add test & doc
|
|
queryParameter =
|
|
typeof opt.queryParameter === 'string' ? opt.queryParameter : null
|
|
|
|
// where to store json files
|
|
directory =
|
|
typeof opt.directory === 'string'
|
|
? opt.directory
|
|
: path.join(__dirname, 'locales')
|
|
|
|
// permissions when creating new directories
|
|
directoryPermissions =
|
|
typeof opt.directoryPermissions === 'string'
|
|
? parseInt(opt.directoryPermissions, 8)
|
|
: null
|
|
|
|
// write new locale information to disk
|
|
updateFiles = typeof opt.updateFiles === 'boolean' ? opt.updateFiles : true
|
|
|
|
// sync locale information accros all files
|
|
syncFiles = typeof opt.syncFiles === 'boolean' ? opt.syncFiles : false
|
|
|
|
// what to use as the indentation unit (ex: "\t", " ")
|
|
indent = typeof opt.indent === 'string' ? opt.indent : '\t'
|
|
|
|
// json files prefix
|
|
prefix = typeof opt.prefix === 'string' ? opt.prefix : ''
|
|
|
|
// where to store json files
|
|
extension = typeof opt.extension === 'string' ? opt.extension : '.json'
|
|
|
|
// setting defaultLocale
|
|
defaultLocale =
|
|
typeof opt.defaultLocale === 'string' ? opt.defaultLocale : 'en'
|
|
|
|
// allow to retry in default locale, useful for production
|
|
retryInDefaultLocale =
|
|
typeof opt.retryInDefaultLocale === 'boolean'
|
|
? opt.retryInDefaultLocale
|
|
: false
|
|
|
|
// auto reload locale files when changed
|
|
autoReload = typeof opt.autoReload === 'boolean' ? opt.autoReload : false
|
|
|
|
// enable object notation?
|
|
objectNotation =
|
|
typeof opt.objectNotation !== 'undefined' ? opt.objectNotation : false
|
|
if (objectNotation === true) objectNotation = '.'
|
|
|
|
// read language fallback map
|
|
fallbacks = typeof opt.fallbacks === 'object' ? opt.fallbacks : {}
|
|
|
|
// setting custom logger functions
|
|
logDebugFn = typeof opt.logDebugFn === 'function' ? opt.logDebugFn : debug
|
|
logWarnFn = typeof opt.logWarnFn === 'function' ? opt.logWarnFn : warn
|
|
logErrorFn = typeof opt.logErrorFn === 'function' ? opt.logErrorFn : error
|
|
|
|
preserveLegacyCase =
|
|
typeof opt.preserveLegacyCase === 'boolean'
|
|
? opt.preserveLegacyCase
|
|
: true
|
|
|
|
// setting custom missing key function
|
|
missingKeyFn =
|
|
typeof opt.missingKeyFn === 'function' ? opt.missingKeyFn : missingKey
|
|
|
|
parser =
|
|
typeof opt.parser === 'object' &&
|
|
typeof opt.parser.parse === 'function' &&
|
|
typeof opt.parser.stringify === 'function'
|
|
? opt.parser
|
|
: JSON
|
|
|
|
// when missing locales we try to guess that from directory
|
|
opt.locales = opt.staticCatalog
|
|
? Object.keys(opt.staticCatalog)
|
|
: opt.locales || guessLocales(directory)
|
|
|
|
// some options should be disabled when using staticCatalog
|
|
if (opt.staticCatalog) {
|
|
updateFiles = false
|
|
autoReload = false
|
|
syncFiles = false
|
|
}
|
|
|
|
// customize mustache parsing
|
|
if (opt.mustacheConfig) {
|
|
if (Array.isArray(opt.mustacheConfig.tags)) {
|
|
mustacheConfig.tags = opt.mustacheConfig.tags
|
|
}
|
|
if (opt.mustacheConfig.disable === true) {
|
|
mustacheConfig.disable = true
|
|
}
|
|
}
|
|
|
|
const [start, end] = mustacheConfig.tags
|
|
mustacheRegex = new RegExp(escapeRegExp(start) + '.*' + escapeRegExp(end))
|
|
|
|
// implicitly read all locales
|
|
if (Array.isArray(opt.locales)) {
|
|
if (opt.staticCatalog) {
|
|
locales = opt.staticCatalog
|
|
} else {
|
|
opt.locales.forEach(read)
|
|
}
|
|
|
|
// auto reload locale files when changed
|
|
if (autoReload) {
|
|
// watch changes of locale files (it's called twice because fs.watch is still unstable)
|
|
fs.watch(directory, (event, filename) => {
|
|
const localeFromFile = guessLocaleFromFile(filename)
|
|
|
|
if (localeFromFile && opt.locales.indexOf(localeFromFile) > -1) {
|
|
logDebug('Auto reloading locale file "' + filename + '".')
|
|
read(localeFromFile)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
i18n.init = function i18nInit(request, response, next) {
|
|
if (typeof request === 'object') {
|
|
// guess requested language/locale
|
|
guessLanguage(request)
|
|
|
|
// bind api to req
|
|
applyAPItoObject(request)
|
|
|
|
// looks double but will ensure schema on api refactor
|
|
i18n.setLocale(request, request.locale)
|
|
} else {
|
|
return logError(
|
|
'i18n.init must be called with one parameter minimum, ie. i18n.init(req)'
|
|
)
|
|
}
|
|
|
|
if (typeof response === 'object') {
|
|
applyAPItoObject(response)
|
|
|
|
// and set that locale to response too
|
|
i18n.setLocale(response, request.locale)
|
|
}
|
|
|
|
// head over to next callback when bound as middleware
|
|
if (typeof next === 'function') {
|
|
return next()
|
|
}
|
|
}
|
|
|
|
i18n.__ = function i18nTranslate(phrase) {
|
|
let msg
|
|
const argv = parseArgv(arguments)
|
|
const namedValues = argv[0]
|
|
const args = argv[1]
|
|
|
|
// called like __({phrase: "Hello", locale: "en"})
|
|
if (typeof phrase === 'object') {
|
|
if (
|
|
typeof phrase.locale === 'string' &&
|
|
typeof phrase.phrase === 'string'
|
|
) {
|
|
msg = translate(phrase.locale, phrase.phrase)
|
|
}
|
|
}
|
|
// called like __("Hello")
|
|
else {
|
|
// get translated message with locale from scope (deprecated) or object
|
|
msg = translate(getLocaleFromObject(this), phrase)
|
|
}
|
|
|
|
// postprocess to get compatible to plurals
|
|
if (typeof msg === 'object' && msg.one) {
|
|
msg = msg.one
|
|
}
|
|
|
|
// in case there is no 'one' but an 'other' rule
|
|
if (typeof msg === 'object' && msg.other) {
|
|
msg = msg.other
|
|
}
|
|
|
|
// head over to postProcessing
|
|
return postProcess(msg, namedValues, args)
|
|
}
|
|
|
|
i18n.__mf = function i18nMessageformat(phrase) {
|
|
let msg, mf, f
|
|
let targetLocale = defaultLocale
|
|
const argv = parseArgv(arguments)
|
|
const namedValues = argv[0]
|
|
const args = argv[1]
|
|
|
|
// called like __({phrase: "Hello", locale: "en"})
|
|
if (typeof phrase === 'object') {
|
|
if (
|
|
typeof phrase.locale === 'string' &&
|
|
typeof phrase.phrase === 'string'
|
|
) {
|
|
msg = phrase.phrase
|
|
targetLocale = phrase.locale
|
|
}
|
|
}
|
|
// called like __("Hello")
|
|
else {
|
|
// get translated message with locale from scope (deprecated) or object
|
|
msg = phrase
|
|
targetLocale = getLocaleFromObject(this)
|
|
}
|
|
|
|
msg = translate(targetLocale, msg)
|
|
// --- end get msg
|
|
|
|
// now head over to Messageformat
|
|
// and try to cache instance
|
|
if (MessageformatInstanceForLocale[targetLocale]) {
|
|
mf = MessageformatInstanceForLocale[targetLocale]
|
|
} else {
|
|
mf = new Messageformat(targetLocale)
|
|
|
|
mf.compiledFunctions = {}
|
|
MessageformatInstanceForLocale[targetLocale] = mf
|
|
}
|
|
|
|
// let's try to cache that function
|
|
if (mf.compiledFunctions[msg]) {
|
|
f = mf.compiledFunctions[msg]
|
|
} else {
|
|
f = mf.compile(msg)
|
|
mf.compiledFunctions[msg] = f
|
|
}
|
|
|
|
return postProcess(f(namedValues), namedValues, args)
|
|
}
|
|
|
|
i18n.__l = function i18nTranslationList(phrase) {
|
|
const translations = []
|
|
Object.keys(locales)
|
|
.sort()
|
|
.forEach((l) => {
|
|
translations.push(i18n.__({ phrase: phrase, locale: l }))
|
|
})
|
|
return translations
|
|
}
|
|
|
|
i18n.__h = function i18nTranslationHash(phrase) {
|
|
const translations = []
|
|
Object.keys(locales)
|
|
.sort()
|
|
.forEach((l) => {
|
|
const hash = {}
|
|
hash[l] = i18n.__({ phrase: phrase, locale: l })
|
|
translations.push(hash)
|
|
})
|
|
return translations
|
|
}
|
|
|
|
i18n.__n = function i18nTranslatePlural(singular, plural, count) {
|
|
let msg
|
|
let namedValues
|
|
let targetLocale
|
|
let args = []
|
|
|
|
// Accept an object with named values as the last parameter
|
|
if (argsEndWithNamedObject(arguments)) {
|
|
namedValues = arguments[arguments.length - 1]
|
|
args =
|
|
arguments.length >= 5
|
|
? Array.prototype.slice.call(arguments, 3, -1)
|
|
: []
|
|
} else {
|
|
namedValues = {}
|
|
args =
|
|
arguments.length >= 4 ? Array.prototype.slice.call(arguments, 3) : []
|
|
}
|
|
|
|
// called like __n({singular: "%s cat", plural: "%s cats", locale: "en"}, 3)
|
|
if (typeof singular === 'object') {
|
|
if (
|
|
typeof singular.locale === 'string' &&
|
|
typeof singular.singular === 'string' &&
|
|
typeof singular.plural === 'string'
|
|
) {
|
|
targetLocale = singular.locale
|
|
msg = translate(singular.locale, singular.singular, singular.plural)
|
|
}
|
|
args.unshift(count)
|
|
|
|
// some template engines pass all values as strings -> so we try to convert them to numbers
|
|
if (typeof plural === 'number' || Number(plural) + '' === plural) {
|
|
count = plural
|
|
}
|
|
|
|
// called like __n({singular: "%s cat", plural: "%s cats", locale: "en", count: 3})
|
|
if (
|
|
typeof singular.count === 'number' ||
|
|
typeof singular.count === 'string'
|
|
) {
|
|
count = singular.count
|
|
args.unshift(plural)
|
|
}
|
|
} else {
|
|
// called like __n('cat', 3)
|
|
if (typeof plural === 'number' || Number(plural) + '' === plural) {
|
|
count = plural
|
|
|
|
// we add same string as default
|
|
// which efectivly copies the key to the plural.value
|
|
// this is for initialization of new empty translations
|
|
plural = singular
|
|
|
|
args.unshift(count)
|
|
args.unshift(plural)
|
|
}
|
|
// called like __n('%s cat', '%s cats', 3)
|
|
// get translated message with locale from scope (deprecated) or object
|
|
msg = translate(getLocaleFromObject(this), singular, plural)
|
|
targetLocale = getLocaleFromObject(this)
|
|
}
|
|
|
|
if (count === null) count = namedValues.count
|
|
|
|
// enforce number
|
|
count = Number(count)
|
|
|
|
// find the correct plural rule for given locale
|
|
if (typeof msg === 'object') {
|
|
let p
|
|
// create a new Plural for locale
|
|
// and try to cache instance
|
|
if (PluralsForLocale[targetLocale]) {
|
|
p = PluralsForLocale[targetLocale]
|
|
} else {
|
|
// split locales with a region code
|
|
const lc = targetLocale
|
|
.toLowerCase()
|
|
.split(/[_-\s]+/)
|
|
.filter((el) => true && el)
|
|
// take the first part of locale, fallback to full locale
|
|
p = MakePlural[lc[0] || targetLocale]
|
|
PluralsForLocale[targetLocale] = p
|
|
}
|
|
|
|
// fallback to 'other' on case of missing translations
|
|
msg = msg[p(count)] || msg.other
|
|
}
|
|
|
|
// head over to postProcessing
|
|
return postProcess(msg, namedValues, args, count)
|
|
}
|
|
|
|
i18n.setLocale = function i18nSetLocale(object, locale, skipImplicitObjects) {
|
|
// when given an array of objects => setLocale on each
|
|
if (Array.isArray(object) && typeof locale === 'string') {
|
|
for (let i = object.length - 1; i >= 0; i--) {
|
|
i18n.setLocale(object[i], locale, true)
|
|
}
|
|
return i18n.getLocale(object[0])
|
|
}
|
|
|
|
// defaults to called like i18n.setLocale(req, 'en')
|
|
let targetObject = object
|
|
let targetLocale = locale
|
|
|
|
// called like req.setLocale('en') or i18n.setLocale('en')
|
|
if (locale === undefined && typeof object === 'string') {
|
|
targetObject = this
|
|
targetLocale = object
|
|
}
|
|
|
|
// consider a fallback
|
|
if (!locales[targetLocale]) {
|
|
targetLocale = getFallback(targetLocale, fallbacks) || targetLocale
|
|
}
|
|
|
|
// now set locale on object
|
|
targetObject.locale = locales[targetLocale] ? targetLocale : defaultLocale
|
|
|
|
// consider any extra registered objects
|
|
if (typeof register === 'object') {
|
|
if (Array.isArray(register) && !skipImplicitObjects) {
|
|
register.forEach((r) => {
|
|
r.locale = targetObject.locale
|
|
})
|
|
} else {
|
|
register.locale = targetObject.locale
|
|
}
|
|
}
|
|
|
|
// consider res
|
|
if (targetObject.res && !skipImplicitObjects) {
|
|
// escape recursion
|
|
// @see - https://github.com/balderdashy/sails/pull/3631
|
|
// - https://github.com/mashpie/i18n-node/pull/218
|
|
if (targetObject.res.locals) {
|
|
i18n.setLocale(targetObject.res, targetObject.locale, true)
|
|
i18n.setLocale(targetObject.res.locals, targetObject.locale, true)
|
|
} else {
|
|
i18n.setLocale(targetObject.res, targetObject.locale)
|
|
}
|
|
}
|
|
|
|
// consider locals
|
|
if (targetObject.locals && !skipImplicitObjects) {
|
|
// escape recursion
|
|
// @see - https://github.com/balderdashy/sails/pull/3631
|
|
// - https://github.com/mashpie/i18n-node/pull/218
|
|
if (targetObject.locals.res) {
|
|
i18n.setLocale(targetObject.locals, targetObject.locale, true)
|
|
i18n.setLocale(targetObject.locals.res, targetObject.locale, true)
|
|
} else {
|
|
i18n.setLocale(targetObject.locals, targetObject.locale)
|
|
}
|
|
}
|
|
|
|
return i18n.getLocale(targetObject)
|
|
}
|
|
|
|
i18n.getLocale = function i18nGetLocale(request) {
|
|
// called like i18n.getLocale(req)
|
|
if (request && request.locale) {
|
|
return request.locale
|
|
}
|
|
|
|
// called like req.getLocale()
|
|
return this.locale || defaultLocale
|
|
}
|
|
|
|
i18n.getCatalog = function i18nGetCatalog(object, locale) {
|
|
let targetLocale
|
|
|
|
// called like i18n.getCatalog(req)
|
|
if (
|
|
typeof object === 'object' &&
|
|
typeof object.locale === 'string' &&
|
|
locale === undefined
|
|
) {
|
|
targetLocale = object.locale
|
|
}
|
|
|
|
// called like i18n.getCatalog(req, 'en')
|
|
if (
|
|
!targetLocale &&
|
|
typeof object === 'object' &&
|
|
typeof locale === 'string'
|
|
) {
|
|
targetLocale = locale
|
|
}
|
|
|
|
// called like req.getCatalog('en')
|
|
if (!targetLocale && locale === undefined && typeof object === 'string') {
|
|
targetLocale = object
|
|
}
|
|
|
|
// called like req.getCatalog()
|
|
if (
|
|
!targetLocale &&
|
|
object === undefined &&
|
|
locale === undefined &&
|
|
typeof this.locale === 'string'
|
|
) {
|
|
if (register && register.global) {
|
|
targetLocale = ''
|
|
} else {
|
|
targetLocale = this.locale
|
|
}
|
|
}
|
|
|
|
// called like i18n.getCatalog()
|
|
if (targetLocale === undefined || targetLocale === '') {
|
|
return locales
|
|
}
|
|
|
|
if (!locales[targetLocale]) {
|
|
targetLocale = getFallback(targetLocale, fallbacks) || targetLocale
|
|
}
|
|
|
|
if (locales[targetLocale]) {
|
|
return locales[targetLocale]
|
|
} else {
|
|
logWarn('No catalog found for "' + targetLocale + '"')
|
|
return false
|
|
}
|
|
}
|
|
|
|
i18n.getLocales = function i18nGetLocales() {
|
|
return Object.keys(locales)
|
|
}
|
|
|
|
i18n.addLocale = function i18nAddLocale(locale) {
|
|
read(locale)
|
|
}
|
|
|
|
i18n.removeLocale = function i18nRemoveLocale(locale) {
|
|
delete locales[locale]
|
|
}
|
|
|
|
// ===================
|
|
// = private methods =
|
|
// ===================
|
|
|
|
const postProcess = (msg, namedValues, args, count) => {
|
|
// test for parsable interval string
|
|
if (/\|/.test(msg)) {
|
|
msg = parsePluralInterval(msg, count)
|
|
}
|
|
|
|
// replace the counter
|
|
if (typeof count === 'number') {
|
|
msg = printf(msg, Number(count))
|
|
}
|
|
|
|
// if the msg string contains {{Mustache}} patterns we render it as a mini template
|
|
if (!mustacheConfig.disable && mustacheRegex.test(msg)) {
|
|
msg = Mustache.render(msg, namedValues, {}, mustacheConfig.tags)
|
|
}
|
|
|
|
// if we have extra arguments with values to get replaced,
|
|
// an additional substition injects those strings afterwards
|
|
if (/%/.test(msg) && args && args.length > 0) {
|
|
msg = printf(msg, ...args)
|
|
}
|
|
|
|
return msg
|
|
}
|
|
|
|
const argsEndWithNamedObject = (args) =>
|
|
args.length > 1 &&
|
|
args[args.length - 1] !== null &&
|
|
typeof args[args.length - 1] === 'object'
|
|
|
|
const parseArgv = (args) => {
|
|
let namedValues, returnArgs
|
|
|
|
if (argsEndWithNamedObject(args)) {
|
|
namedValues = args[args.length - 1]
|
|
returnArgs = Array.prototype.slice.call(args, 1, -1)
|
|
} else {
|
|
namedValues = {}
|
|
returnArgs = args.length >= 2 ? Array.prototype.slice.call(args, 1) : []
|
|
}
|
|
|
|
return [namedValues, returnArgs]
|
|
}
|
|
|
|
/**
|
|
* registers all public API methods to a given response object when not already declared
|
|
*/
|
|
const applyAPItoObject = (object) => {
|
|
let alreadySetted = true
|
|
|
|
// attach to itself if not provided
|
|
for (const method in api) {
|
|
if (Object.prototype.hasOwnProperty.call(api, method)) {
|
|
const alias = api[method]
|
|
|
|
// be kind rewind, or better not touch anything already existing
|
|
if (!object[alias]) {
|
|
alreadySetted = false
|
|
object[alias] = i18n[method].bind(object)
|
|
}
|
|
}
|
|
}
|
|
|
|
// set initial locale if not set
|
|
if (!object.locale) {
|
|
object.locale = defaultLocale
|
|
}
|
|
|
|
// escape recursion
|
|
if (alreadySetted) {
|
|
return
|
|
}
|
|
|
|
// attach to response if present (ie. in express)
|
|
if (object.res) {
|
|
applyAPItoObject(object.res)
|
|
}
|
|
|
|
// attach to locals if present (ie. in express)
|
|
if (object.locals) {
|
|
applyAPItoObject(object.locals)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* tries to guess locales by scanning the given directory
|
|
*/
|
|
const guessLocales = (directory) => {
|
|
const entries = fs.readdirSync(directory)
|
|
const localesFound = []
|
|
|
|
for (let i = entries.length - 1; i >= 0; i--) {
|
|
if (entries[i].match(/^\./)) continue
|
|
const localeFromFile = guessLocaleFromFile(entries[i])
|
|
if (localeFromFile) localesFound.push(localeFromFile)
|
|
}
|
|
|
|
return localesFound.sort()
|
|
}
|
|
|
|
/**
|
|
* tries to guess locales from a given filename
|
|
*/
|
|
const guessLocaleFromFile = (filename) => {
|
|
const extensionRegex = new RegExp(extension + '$', 'g')
|
|
const prefixRegex = new RegExp('^' + prefix, 'g')
|
|
|
|
if (!filename) return false
|
|
if (prefix && !filename.match(prefixRegex)) return false
|
|
if (extension && !filename.match(extensionRegex)) return false
|
|
return filename.replace(prefix, '').replace(extensionRegex, '')
|
|
}
|
|
|
|
/**
|
|
* @param queryLanguage - language query parameter, either an array or a string.
|
|
* @return the first non-empty language query parameter found, null otherwise.
|
|
*/
|
|
const extractQueryLanguage = (queryLanguage) => {
|
|
if (Array.isArray(queryLanguage)) {
|
|
return queryLanguage.find((lang) => lang !== '' && lang)
|
|
}
|
|
return typeof queryLanguage === 'string' && queryLanguage
|
|
}
|
|
|
|
/**
|
|
* guess language setting based on http headers
|
|
*/
|
|
|
|
const guessLanguage = (request) => {
|
|
if (typeof request === 'object') {
|
|
const languageHeader = request.headers
|
|
? request.headers[languageHeaderName]
|
|
: undefined
|
|
const languages = []
|
|
const regions = []
|
|
|
|
request.languages = [defaultLocale]
|
|
request.regions = [defaultLocale]
|
|
request.language = defaultLocale
|
|
request.region = defaultLocale
|
|
|
|
// a query parameter overwrites all
|
|
if (queryParameter && request.url) {
|
|
const urlAsString =
|
|
typeof request.url === 'string' ? request.url : request.url.toString()
|
|
|
|
/**
|
|
* @todo WHATWG new URL() requires full URL including hostname - that might change
|
|
* @see https://github.com/nodejs/node/issues/12682
|
|
*/
|
|
// eslint-disable-next-line node/no-deprecated-api
|
|
const urlObj = url.parse(urlAsString, true)
|
|
const languageQueryParameter = urlObj.query[queryParameter]
|
|
if (languageQueryParameter) {
|
|
let queryLanguage = extractQueryLanguage(languageQueryParameter)
|
|
if (queryLanguage) {
|
|
logDebug('Overriding locale from query: ' + queryLanguage)
|
|
if (preserveLegacyCase) {
|
|
queryLanguage = queryLanguage.toLowerCase()
|
|
}
|
|
return i18n.setLocale(request, queryLanguage)
|
|
}
|
|
}
|
|
}
|
|
|
|
// a cookie overwrites headers
|
|
if (cookiename && request.cookies && request.cookies[cookiename]) {
|
|
request.language = request.cookies[cookiename]
|
|
return i18n.setLocale(request, request.language)
|
|
}
|
|
|
|
// 'accept-language' is the most common source
|
|
if (languageHeader) {
|
|
const acceptedLanguages = getAcceptedLanguagesFromHeader(languageHeader)
|
|
let match
|
|
let fallbackMatch
|
|
let fallback
|
|
for (let i = 0; i < acceptedLanguages.length; i++) {
|
|
const lang = acceptedLanguages[i]
|
|
const lr = lang.split('-', 2)
|
|
const parentLang = lr[0]
|
|
const region = lr[1]
|
|
|
|
// Check if we have a configured fallback set for this language.
|
|
const fallbackLang = getFallback(lang, fallbacks)
|
|
if (fallbackLang) {
|
|
fallback = fallbackLang
|
|
// Fallbacks for languages should be inserted
|
|
// where the original, unsupported language existed.
|
|
const acceptedLanguageIndex = acceptedLanguages.indexOf(lang)
|
|
const fallbackIndex = acceptedLanguages.indexOf(fallback)
|
|
if (fallbackIndex > -1) {
|
|
acceptedLanguages.splice(fallbackIndex, 1)
|
|
}
|
|
acceptedLanguages.splice(acceptedLanguageIndex + 1, 0, fallback)
|
|
}
|
|
|
|
// Check if we have a configured fallback set for the parent language of the locale.
|
|
const fallbackParentLang = getFallback(parentLang, fallbacks)
|
|
if (fallbackParentLang) {
|
|
fallback = fallbackParentLang
|
|
// Fallbacks for a parent language should be inserted
|
|
// to the end of the list, so they're only picked
|
|
// if there is no better match.
|
|
if (acceptedLanguages.indexOf(fallback) < 0) {
|
|
acceptedLanguages.push(fallback)
|
|
}
|
|
}
|
|
|
|
if (languages.indexOf(parentLang) < 0) {
|
|
languages.push(parentLang.toLowerCase())
|
|
}
|
|
if (region) {
|
|
regions.push(region.toLowerCase())
|
|
}
|
|
|
|
if (!match && locales[lang]) {
|
|
match = lang
|
|
break
|
|
}
|
|
|
|
if (!fallbackMatch && locales[parentLang]) {
|
|
fallbackMatch = parentLang
|
|
}
|
|
}
|
|
|
|
request.language = match || fallbackMatch || request.language
|
|
request.region = regions[0] || request.region
|
|
return i18n.setLocale(request, request.language)
|
|
}
|
|
}
|
|
|
|
// last resort: defaultLocale
|
|
return i18n.setLocale(request, defaultLocale)
|
|
}
|
|
|
|
/**
|
|
* Get a sorted list of accepted languages from the HTTP Accept-Language header
|
|
*/
|
|
const getAcceptedLanguagesFromHeader = (header) => {
|
|
const languages = header.split(',')
|
|
const preferences = {}
|
|
return languages
|
|
.map((item) => {
|
|
const preferenceParts = item.trim().split(';q=')
|
|
if (preferenceParts.length < 2) {
|
|
preferenceParts[1] = 1.0
|
|
} else {
|
|
const quality = parseFloat(preferenceParts[1])
|
|
preferenceParts[1] = quality || 0.0
|
|
}
|
|
preferences[preferenceParts[0]] = preferenceParts[1]
|
|
|
|
return preferenceParts[0]
|
|
})
|
|
.filter((lang) => preferences[lang] > 0)
|
|
.sort((a, b) => preferences[b] - preferences[a])
|
|
}
|
|
|
|
/**
|
|
* searches for locale in given object
|
|
*/
|
|
|
|
const getLocaleFromObject = (obj) => {
|
|
let locale
|
|
if (obj && obj.scope) {
|
|
locale = obj.scope.locale
|
|
}
|
|
if (obj && obj.locale) {
|
|
locale = obj.locale
|
|
}
|
|
return locale
|
|
}
|
|
|
|
/**
|
|
* splits and parses a phrase for mathematical interval expressions
|
|
*/
|
|
const parsePluralInterval = (phrase, count) => {
|
|
let returnPhrase = phrase
|
|
const phrases = phrase.split(/\|/)
|
|
let intervalRuleExists = false
|
|
|
|
// some() breaks on 1st true
|
|
phrases.some((p) => {
|
|
const matches = p.match(/^\s*([()[\]]+[\d,]+[()[\]]+)?\s*(.*)$/)
|
|
|
|
// not the same as in combined condition
|
|
if (matches != null && matches[1]) {
|
|
intervalRuleExists = true
|
|
if (matchInterval(count, matches[1]) === true) {
|
|
returnPhrase = matches[2]
|
|
return true
|
|
}
|
|
} else {
|
|
// this is a other or catch all case, this only is taken into account if there is actually another rule
|
|
if (intervalRuleExists) {
|
|
returnPhrase = p
|
|
}
|
|
}
|
|
return false
|
|
})
|
|
return returnPhrase
|
|
}
|
|
|
|
/**
|
|
* test a number to match mathematical interval expressions
|
|
* [0,2] - 0 to 2 (including, matches: 0, 1, 2)
|
|
* ]0,3[ - 0 to 3 (excluding, matches: 1, 2)
|
|
* [1] - 1 (matches: 1)
|
|
* [20,] - all numbers ≥20 (matches: 20, 21, 22, ...)
|
|
* [,20] - all numbers ≤20 (matches: 20, 21, 22, ...)
|
|
*/
|
|
const matchInterval = (number, interval) => {
|
|
interval = parseInterval(interval)
|
|
if (interval && typeof number === 'number') {
|
|
if (interval.from.value === number) {
|
|
return interval.from.included
|
|
}
|
|
if (interval.to.value === number) {
|
|
return interval.to.included
|
|
}
|
|
|
|
return (
|
|
Math.min(interval.from.value, number) === interval.from.value &&
|
|
Math.max(interval.to.value, number) === interval.to.value
|
|
)
|
|
}
|
|
return false
|
|
}
|
|
|
|
/**
|
|
* read locale file, translate a msg and write to fs if new
|
|
*/
|
|
const translate = (locale, singular, plural, skipSyncToAllFiles) => {
|
|
// add same key to all translations
|
|
if (!skipSyncToAllFiles && syncFiles) {
|
|
syncToAllFiles(singular, plural)
|
|
}
|
|
|
|
if (locale === undefined) {
|
|
logWarn(
|
|
'WARN: No locale found - check the context of the call to __(). Using ' +
|
|
defaultLocale +
|
|
' as current locale'
|
|
)
|
|
locale = defaultLocale
|
|
}
|
|
|
|
// try to get a fallback
|
|
if (!locales[locale]) {
|
|
locale = getFallback(locale, fallbacks) || locale
|
|
}
|
|
|
|
// attempt to read when defined as valid locale
|
|
if (!locales[locale]) {
|
|
read(locale)
|
|
}
|
|
|
|
// fallback to default when missed
|
|
if (!locales[locale]) {
|
|
logWarn(
|
|
'WARN: Locale ' +
|
|
locale +
|
|
" couldn't be read - check the context of the call to $__. Using " +
|
|
defaultLocale +
|
|
' (default) as current locale'
|
|
)
|
|
|
|
locale = defaultLocale
|
|
read(locale)
|
|
}
|
|
|
|
// dotnotaction add on, @todo: factor out
|
|
let defaultSingular = singular
|
|
let defaultPlural = plural
|
|
if (objectNotation) {
|
|
let indexOfColon = singular.indexOf(':')
|
|
// We compare against 0 instead of -1 because
|
|
// we don't really expect the string to start with ':'.
|
|
if (indexOfColon > 0) {
|
|
defaultSingular = singular.substring(indexOfColon + 1)
|
|
singular = singular.substring(0, indexOfColon)
|
|
}
|
|
if (plural && typeof plural !== 'number') {
|
|
indexOfColon = plural.indexOf(':')
|
|
if (indexOfColon > 0) {
|
|
defaultPlural = plural.substring(indexOfColon + 1)
|
|
plural = plural.substring(0, indexOfColon)
|
|
}
|
|
}
|
|
}
|
|
|
|
const accessor = localeAccessor(locale, singular)
|
|
const mutator = localeMutator(locale, singular)
|
|
|
|
// if (plural) {
|
|
// if (accessor() == null) {
|
|
// mutator({
|
|
// 'one': defaultSingular || singular,
|
|
// 'other': defaultPlural || plural
|
|
// });
|
|
// write(locale);
|
|
// }
|
|
// }
|
|
// if (accessor() == null) {
|
|
// mutator(defaultSingular || singular);
|
|
// write(locale);
|
|
// }
|
|
if (plural) {
|
|
if (accessor() == null) {
|
|
// when retryInDefaultLocale is true - try to set default value from defaultLocale
|
|
if (retryInDefaultLocale && locale !== defaultLocale) {
|
|
logDebug(
|
|
'Missing ' +
|
|
singular +
|
|
' in ' +
|
|
locale +
|
|
' retrying in ' +
|
|
defaultLocale
|
|
)
|
|
mutator(translate(defaultLocale, singular, plural, true))
|
|
} else {
|
|
mutator({
|
|
one: defaultSingular || singular,
|
|
other: defaultPlural || plural
|
|
})
|
|
}
|
|
write(locale)
|
|
}
|
|
}
|
|
|
|
if (accessor() == null) {
|
|
// when retryInDefaultLocale is true - try to set default value from defaultLocale
|
|
if (retryInDefaultLocale && locale !== defaultLocale) {
|
|
logDebug(
|
|
'Missing ' +
|
|
singular +
|
|
' in ' +
|
|
locale +
|
|
' retrying in ' +
|
|
defaultLocale
|
|
)
|
|
mutator(translate(defaultLocale, singular, plural, true))
|
|
} else {
|
|
mutator(defaultSingular || singular)
|
|
}
|
|
write(locale)
|
|
}
|
|
|
|
return accessor()
|
|
}
|
|
|
|
/**
|
|
* initialize the same key in all locales
|
|
* when not already existing, checked via translate
|
|
*/
|
|
const syncToAllFiles = (singular, plural) => {
|
|
// iterate over locales and translate again
|
|
// this will implicitly write/sync missing keys
|
|
// to the rest of locales
|
|
for (const l in locales) {
|
|
translate(l, singular, plural, true)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Allows delayed access to translations nested inside objects.
|
|
* @param {String} locale The locale to use.
|
|
* @param {String} singular The singular term to look up.
|
|
* @param {Boolean} [allowDelayedTraversal=true] Is delayed traversal of the tree allowed?
|
|
* This parameter is used internally. It allows to signal the accessor that
|
|
* a translation was not found in the initial lookup and that an invocation
|
|
* of the accessor may trigger another traversal of the tree.
|
|
* @returns {Function} A function that, when invoked, returns the current value stored
|
|
* in the object at the requested location.
|
|
*/
|
|
const localeAccessor = (locale, singular, allowDelayedTraversal) => {
|
|
// Bail out on non-existent locales to defend against internal errors.
|
|
if (!locales[locale]) return Function.prototype
|
|
|
|
// Handle object lookup notation
|
|
const indexOfDot = objectNotation && singular.lastIndexOf(objectNotation)
|
|
if (objectNotation && indexOfDot > 0 && indexOfDot < singular.length - 1) {
|
|
// If delayed traversal wasn't specifically forbidden, it is allowed.
|
|
if (typeof allowDelayedTraversal === 'undefined')
|
|
allowDelayedTraversal = true
|
|
// The accessor we're trying to find and which we want to return.
|
|
let accessor = null
|
|
// An accessor that returns null.
|
|
const nullAccessor = () => null
|
|
// Do we need to re-traverse the tree upon invocation of the accessor?
|
|
let reTraverse = false
|
|
// Split the provided term and run the callback for each subterm.
|
|
singular.split(objectNotation).reduce((object, index) => {
|
|
// Make the accessor return null.
|
|
accessor = nullAccessor
|
|
// If our current target object (in the locale tree) doesn't exist or
|
|
// it doesn't have the next subterm as a member...
|
|
if (
|
|
object === null ||
|
|
!Object.prototype.hasOwnProperty.call(object, index)
|
|
) {
|
|
// ...remember that we need retraversal (because we didn't find our target).
|
|
reTraverse = allowDelayedTraversal
|
|
// Return null to avoid deeper iterations.
|
|
return null
|
|
}
|
|
// We can traverse deeper, so we generate an accessor for this current level.
|
|
accessor = () => object[index]
|
|
// Return a reference to the next deeper level in the locale tree.
|
|
return object[index]
|
|
}, locales[locale])
|
|
// Return the requested accessor.
|
|
return () =>
|
|
// If we need to re-traverse (because we didn't find our target term)
|
|
// traverse again and return the new result (but don't allow further iterations)
|
|
// or return the previously found accessor if it was already valid.
|
|
reTraverse ? localeAccessor(locale, singular, false)() : accessor()
|
|
} else {
|
|
// No object notation, just return an accessor that performs array lookup.
|
|
return () => locales[locale][singular]
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Allows delayed mutation of a translation nested inside objects.
|
|
* @description Construction of the mutator will attempt to locate the requested term
|
|
* inside the object, but if part of the branch does not exist yet, it will not be
|
|
* created until the mutator is actually invoked. At that point, re-traversal of the
|
|
* tree is performed and missing parts along the branch will be created.
|
|
* @param {String} locale The locale to use.
|
|
* @param {String} singular The singular term to look up.
|
|
* @param [Boolean} [allowBranching=false] Is the mutator allowed to create previously
|
|
* non-existent branches along the requested locale path?
|
|
* @returns {Function} A function that takes one argument. When the function is
|
|
* invoked, the targeted translation term will be set to the given value inside the locale table.
|
|
*/
|
|
const localeMutator = function (locale, singular, allowBranching) {
|
|
// Bail out on non-existent locales to defend against internal errors.
|
|
if (!locales[locale]) return Function.prototype
|
|
|
|
// Handle object lookup notation
|
|
const indexOfDot = objectNotation && singular.lastIndexOf(objectNotation)
|
|
if (objectNotation && indexOfDot > 0 && indexOfDot < singular.length - 1) {
|
|
// If branching wasn't specifically allowed, disable it.
|
|
if (typeof allowBranching === 'undefined') allowBranching = false
|
|
// This will become the function we want to return.
|
|
let accessor = null
|
|
// An accessor that takes one argument and returns null.
|
|
const nullAccessor = () => null
|
|
// Fix object path.
|
|
let fixObject = () => ({})
|
|
// Are we going to need to re-traverse the tree when the mutator is invoked?
|
|
let reTraverse = false
|
|
// Split the provided term and run the callback for each subterm.
|
|
singular.split(objectNotation).reduce((object, index) => {
|
|
// Make the mutator do nothing.
|
|
accessor = nullAccessor
|
|
// If our current target object (in the locale tree) doesn't exist or
|
|
// it doesn't have the next subterm as a member...
|
|
if (
|
|
object === null ||
|
|
!Object.prototype.hasOwnProperty.call(object, index)
|
|
) {
|
|
// ...check if we're allowed to create new branches.
|
|
if (allowBranching) {
|
|
// Fix `object` if `object` is not Object.
|
|
if (object === null || typeof object !== 'object') {
|
|
object = fixObject()
|
|
}
|
|
// If we are allowed to, create a new object along the path.
|
|
object[index] = {}
|
|
} else {
|
|
// If we aren't allowed, remember that we need to re-traverse later on and...
|
|
reTraverse = true
|
|
// ...return null to make the next iteration bail our early on.
|
|
return null
|
|
}
|
|
}
|
|
// Generate a mutator for the current level.
|
|
accessor = (value) => {
|
|
object[index] = value
|
|
return value
|
|
}
|
|
// Generate a fixer for the current level.
|
|
fixObject = () => {
|
|
object[index] = {}
|
|
return object[index]
|
|
}
|
|
|
|
// Return a reference to the next deeper level in the locale tree.
|
|
return object[index]
|
|
}, locales[locale])
|
|
|
|
// Return the final mutator.
|
|
return (value) => {
|
|
// If we need to re-traverse the tree
|
|
// invoke the search again, but allow branching
|
|
// this time (because here the mutator is being invoked)
|
|
// otherwise, just change the value directly.
|
|
value = missingKeyFn(locale, value)
|
|
return reTraverse
|
|
? localeMutator(locale, singular, true)(value)
|
|
: accessor(value)
|
|
}
|
|
} else {
|
|
// No object notation, just return a mutator that performs array lookup and changes the value.
|
|
return (value) => {
|
|
value = missingKeyFn(locale, value)
|
|
locales[locale][singular] = value
|
|
return value
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* try reading a file
|
|
*/
|
|
const read = (locale) => {
|
|
let localeFile = {}
|
|
const file = getStorageFilePath(locale)
|
|
try {
|
|
logDebug('read ' + file + ' for locale: ' + locale)
|
|
localeFile = fs.readFileSync(file, 'utf-8')
|
|
try {
|
|
// parsing filecontents to locales[locale]
|
|
locales[locale] = parser.parse(localeFile)
|
|
} catch (parseError) {
|
|
logError(
|
|
'unable to parse locales from file (maybe ' +
|
|
file +
|
|
' is empty or invalid json?): ',
|
|
parseError
|
|
)
|
|
}
|
|
} catch (readError) {
|
|
// unable to read, so intialize that file
|
|
// locales[locale] are already set in memory, so no extra read required
|
|
// or locales[locale] are empty, which initializes an empty locale.json file
|
|
// since the current invalid locale could exist, we should back it up
|
|
if (fs.existsSync(file)) {
|
|
logDebug(
|
|
'backing up invalid locale ' + locale + ' to ' + file + '.invalid'
|
|
)
|
|
fs.renameSync(file, file + '.invalid')
|
|
}
|
|
|
|
logDebug('initializing ' + file)
|
|
write(locale)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* try writing a file in a created directory
|
|
*/
|
|
const write = (locale) => {
|
|
let stats, target, tmp
|
|
|
|
// don't write new locale information to disk if updateFiles isn't true
|
|
if (!updateFiles) {
|
|
return
|
|
}
|
|
|
|
// creating directory if necessary
|
|
try {
|
|
stats = fs.lstatSync(directory)
|
|
} catch (e) {
|
|
logDebug('creating locales dir in: ' + directory)
|
|
try {
|
|
fs.mkdirSync(directory, directoryPermissions)
|
|
} catch (e) {
|
|
// in case of parallel tasks utilizing in same dir
|
|
if (e.code !== 'EEXIST') throw e
|
|
}
|
|
}
|
|
|
|
// first time init has an empty file
|
|
if (!locales[locale]) {
|
|
locales[locale] = {}
|
|
}
|
|
|
|
// writing to tmp and rename on success
|
|
try {
|
|
target = getStorageFilePath(locale)
|
|
tmp = target + '.tmp'
|
|
fs.writeFileSync(
|
|
tmp,
|
|
parser.stringify(locales[locale], null, indent),
|
|
'utf8'
|
|
)
|
|
stats = fs.statSync(tmp)
|
|
if (stats.isFile()) {
|
|
fs.renameSync(tmp, target)
|
|
} else {
|
|
logError(
|
|
'unable to write locales to file (either ' +
|
|
tmp +
|
|
' or ' +
|
|
target +
|
|
' are not writeable?): '
|
|
)
|
|
}
|
|
} catch (e) {
|
|
logError(
|
|
'unexpected error writing files (either ' +
|
|
tmp +
|
|
' or ' +
|
|
target +
|
|
' are not writeable?): ',
|
|
e
|
|
)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* basic normalization of filepath
|
|
*/
|
|
const getStorageFilePath = (locale) => {
|
|
// changed API to use .json as default, #16
|
|
const ext = extension || '.json'
|
|
const filepath = path.normalize(directory + pathsep + prefix + locale + ext)
|
|
const filepathJS = path.normalize(
|
|
directory + pathsep + prefix + locale + '.js'
|
|
)
|
|
// use .js as fallback if already existing
|
|
try {
|
|
if (fs.statSync(filepathJS)) {
|
|
logDebug('using existing file ' + filepathJS)
|
|
extension = '.js'
|
|
return filepathJS
|
|
}
|
|
} catch (e) {
|
|
logDebug('will use ' + filepath)
|
|
}
|
|
return filepath
|
|
}
|
|
|
|
/**
|
|
* Get locales with wildcard support
|
|
*/
|
|
const getFallback = (targetLocale, fallbacks) => {
|
|
fallbacks = fallbacks || {}
|
|
if (fallbacks[targetLocale]) return fallbacks[targetLocale]
|
|
let fallBackLocale = null
|
|
for (const key in fallbacks) {
|
|
if (targetLocale.match(new RegExp('^' + key.replace('*', '.*') + '$'))) {
|
|
fallBackLocale = fallbacks[key]
|
|
break
|
|
}
|
|
}
|
|
return fallBackLocale
|
|
}
|
|
|
|
/**
|
|
* Logging proxies
|
|
*/
|
|
const logDebug = (msg) => {
|
|
logDebugFn(msg)
|
|
}
|
|
|
|
const logWarn = (msg) => {
|
|
logWarnFn(msg)
|
|
}
|
|
|
|
const logError = (msg) => {
|
|
logErrorFn(msg)
|
|
}
|
|
|
|
/**
|
|
* Missing key function
|
|
*/
|
|
const missingKey = (locale, value) => {
|
|
return value
|
|
}
|
|
|
|
/**
|
|
* implicitly configure when created with given options
|
|
* @example
|
|
* const i18n = new I18n({
|
|
* locales: ['en', 'fr']
|
|
* });
|
|
*/
|
|
if (_OPTS) i18n.configure(_OPTS)
|
|
|
|
return i18n
|
|
}
|
|
|
|
module.exports = i18n
|