// (c) 2012-2016 Airbnb, Inc.
//
// polyglot.js may be freely distributed under the terms of the BSD
// license. For all licensing information, details, and documention:
// http://airbnb.github.com/polyglot.js
//
//
// Polyglot.js is an I18n helper library written in JavaScript, made to
// work both in the browser and in Node. It provides a simple solution for
// interpolation and pluralization, based off of Airbnb's
// experience adding I18n functionality to its Backbone.js and Node apps.
//
// Polylglot is agnostic to your translation backend. It doesn't perform any
// translation; it simply gives you a way to manage translated phrases from
// your client- or server-side JavaScript application.
//
(function(root, factory) {
if (typeof define === 'function' && define.amd) {
define([], function() {
return factory(root);
});
} else if (typeof exports === 'object') {
module.exports = factory(root);
} else {
root.Polyglot = factory(root);
}
}(typeof global !== 'undefined' ? global : this, function(root) {
'use strict';
var replace = String.prototype.replace;
// ### Polyglot class constructor
function Polyglot(options) {
options = options || {};
this.phrases = {};
this.extend(options.phrases || {});
this.currentLocale = options.locale || 'en';
this.allowMissing = !!options.allowMissing;
this.warn = options.warn || warn;
}
// ### Version
Polyglot.VERSION = '1.0.0';
// ### polyglot.locale([locale])
//
// Get or set locale. Internally, Polyglot only uses locale for pluralization.
Polyglot.prototype.locale = function(newLocale) {
if (newLocale) this.currentLocale = newLocale;
return this.currentLocale;
};
// ### polyglot.extend(phrases)
//
// Use `extend` to tell Polyglot how to translate a given key.
//
// polyglot.extend({
// "hello": "Hello",
// "hello_name": "Hello, %{name}"
// });
//
// The key can be any string. Feel free to call `extend` multiple times;
// it will override any phrases with the same key, but leave existing phrases
// untouched.
//
// It is also possible to pass nested phrase objects, which get flattened
// into an object with the nested keys concatenated using dot notation.
//
// polyglot.extend({
// "nav": {
// "hello": "Hello",
// "hello_name": "Hello, %{name}",
// "sidebar": {
// "welcome": "Welcome"
// }
// }
// });
//
// console.log(polyglot.phrases);
// // {
// // 'nav.hello': 'Hello',
// // 'nav.hello_name': 'Hello, %{name}',
// // 'nav.sidebar.welcome': 'Welcome'
// // }
//
// `extend` accepts an optional second argument, `prefix`, which can be used
// to prefix every key in the phrases object with some string, using dot
// notation.
//
// polyglot.extend({
// "hello": "Hello",
// "hello_name": "Hello, %{name}"
// }, "nav");
//
// console.log(polyglot.phrases);
// // {
// // 'nav.hello': 'Hello',
// // 'nav.hello_name': 'Hello, %{name}'
// // }
//
// This feature is used internally to support nested phrase objects.
Polyglot.prototype.extend = function(morePhrases, prefix) {
var phrase;
for (var key in morePhrases) {
if (morePhrases.hasOwnProperty(key)) {
phrase = morePhrases[key];
if (prefix) key = prefix + '.' + key;
if (typeof phrase === 'object') {
this.extend(phrase, key);
} else {
this.phrases[key] = phrase;
}
}
}
};
// ### polyglot.unset(phrases)
// Use `unset` to selectively remove keys from a polyglot instance.
//
// polyglot.unset("some_key");
// polyglot.unset({
// "hello": "Hello",
// "hello_name": "Hello, %{name}"
// });
//
// The unset method can take either a string (for the key), or an object hash with
// the keys that you would like to unset.
Polyglot.prototype.unset = function(morePhrases, prefix) {
var phrase;
if (typeof morePhrases === 'string') {
delete this.phrases[morePhrases];
} else {
for (var key in morePhrases) {
if (morePhrases.hasOwnProperty(key)) {
phrase = morePhrases[key];
if (prefix) key = prefix + '.' + key;
if (typeof phrase === 'object') {
this.unset(phrase, key);
} else {
delete this.phrases[key];
}
}
}
}
};
// ### polyglot.clear()
//
// Clears all phrases. Useful for special cases, such as freeing
// up memory if you have lots of phrases but no longer need to
// perform any translation. Also used internally by `replace`.
Polyglot.prototype.clear = function() {
this.phrases = {};
};
// ### polyglot.replace(phrases)
//
// Completely replace the existing phrases with a new set of phrases.
// Normally, just use `extend` to add more phrases, but under certain
// circumstances, you may want to make sure no old phrases are lying around.
Polyglot.prototype.replace = function(newPhrases) {
this.clear();
this.extend(newPhrases);
};
// ### polyglot.t(key, options)
//
// The most-used method. Provide a key, and `t` will return the
// phrase.
//
// polyglot.t("hello");
// => "Hello"
//
// The phrase value is provided first by a call to `polyglot.extend()` or
// `polyglot.replace()`.
//
// Pass in an object as the second argument to perform interpolation.
//
// polyglot.t("hello_name", {name: "Spike"});
// => "Hello, Spike"
//
// If you like, you can provide a default value in case the phrase is missing.
// Use the special option key "_" to specify a default.
//
// polyglot.t("i_like_to_write_in_language", {
// _: "I like to write in %{language}.",
// language: "JavaScript"
// });
// => "I like to write in JavaScript."
//
Polyglot.prototype.t = function(key, options) {
var phrase, result;
options = options == null ? {} : options;
// allow number as a pluralization shortcut
if (typeof options === 'number') {
options = {smart_count: options};
}
if (typeof this.phrases[key] === 'string') {
phrase = this.phrases[key];
} else if (typeof options._ === 'string') {
phrase = options._;
} else if (this.allowMissing) {
phrase = key;
} else {
this.warn('Missing translation for key: "'+key+'"');
result = key;
}
if (typeof phrase === 'string') {
options = clone(options);
result = choosePluralForm(phrase, this.currentLocale, options.smart_count);
result = interpolate(result, options);
}
return result;
};
// ### polyglot.has(key)
//
// Check if polyglot has a translation for given key
Polyglot.prototype.has = function(key) {
return key in this.phrases;
};
// #### Pluralization methods
// The string that separates the different phrase possibilities.
var delimeter = '||||';
// Mapping from pluralization group plural logic.
var pluralTypes = {
chinese: function(n) { return 0; },
german: function(n) { return n !== 1 ? 1 : 0; },
french: function(n) { return n > 1 ? 1 : 0; },
russian: function(n) { return n % 10 === 1 && n % 100 !== 11 ? 0 : n % 10 >= 2 && n % 10 <= 4 && (n % 100 < 10 || n % 100 >= 20) ? 1 : 2; },
czech: function(n) { return (n === 1) ? 0 : (n >= 2 && n <= 4) ? 1 : 2; },
polish: function(n) { return (n === 1 ? 0 : n % 10 >= 2 && n % 10 <= 4 && (n % 100 < 10 || n % 100 >= 20) ? 1 : 2); },
icelandic: function(n) { return (n % 10 !== 1 || n % 100 === 11) ? 1 : 0; }
};
// Mapping from pluralization group to individual locales.
var pluralTypeToLanguages = {
chinese: ['fa', 'id', 'ja', 'ko', 'lo', 'ms', 'th', 'tr', 'zh'],
german: ['da', 'de', 'en', 'es', 'fi', 'el',
