mirror of
https://tt-rss.org/git/tt-rss.git
synced 2024-06-24 11:56:36 +02:00
259 lines
8.8 KiB
JavaScript
259 lines
8.8 KiB
JavaScript
/*
|
|
Copyright (c) 2004-2010, The Dojo Foundation All Rights Reserved.
|
|
Available via Academic Free License >= 2.1 OR the modified BSD license.
|
|
see: http://dojotoolkit.org/license for details
|
|
*/
|
|
|
|
|
|
if(!dojo._hasResource["dojo.i18n"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
|
|
dojo._hasResource["dojo.i18n"] = true;
|
|
dojo.provide("dojo.i18n");
|
|
|
|
/*=====
|
|
dojo.i18n = {
|
|
// summary: Utility classes to enable loading of resources for internationalization (i18n)
|
|
};
|
|
=====*/
|
|
|
|
dojo.i18n.getLocalization = function(/*String*/packageName, /*String*/bundleName, /*String?*/locale){
|
|
// summary:
|
|
// Returns an Object containing the localization for a given resource
|
|
// bundle in a package, matching the specified locale.
|
|
// description:
|
|
// Returns a hash containing name/value pairs in its prototypesuch
|
|
// that values can be easily overridden. Throws an exception if the
|
|
// bundle is not found. Bundle must have already been loaded by
|
|
// `dojo.requireLocalization()` or by a build optimization step. NOTE:
|
|
// try not to call this method as part of an object property
|
|
// definition (`var foo = { bar: dojo.i18n.getLocalization() }`). In
|
|
// some loading situations, the bundle may not be available in time
|
|
// for the object definition. Instead, call this method inside a
|
|
// function that is run after all modules load or the page loads (like
|
|
// in `dojo.addOnLoad()`), or in a widget lifecycle method.
|
|
// packageName:
|
|
// package which is associated with this resource
|
|
// bundleName:
|
|
// the base filename of the resource bundle (without the ".js" suffix)
|
|
// locale:
|
|
// the variant to load (optional). By default, the locale defined by
|
|
// the host environment: dojo.locale
|
|
|
|
locale = dojo.i18n.normalizeLocale(locale);
|
|
|
|
// look for nearest locale match
|
|
var elements = locale.split('-');
|
|
var module = [packageName,"nls",bundleName].join('.');
|
|
var bundle = dojo._loadedModules[module];
|
|
if(bundle){
|
|
var localization;
|
|
for(var i = elements.length; i > 0; i--){
|
|
var loc = elements.slice(0, i).join('_');
|
|
if(bundle[loc]){
|
|
localization = bundle[loc];
|
|
break;
|
|
}
|
|
}
|
|
if(!localization){
|
|
localization = bundle.ROOT;
|
|
}
|
|
|
|
// make a singleton prototype so that the caller won't accidentally change the values globally
|
|
if(localization){
|
|
var clazz = function(){};
|
|
clazz.prototype = localization;
|
|
return new clazz(); // Object
|
|
}
|
|
}
|
|
|
|
throw new Error("Bundle not found: " + bundleName + " in " + packageName+" , locale=" + locale);
|
|
};
|
|
|
|
dojo.i18n.normalizeLocale = function(/*String?*/locale){
|
|
// summary:
|
|
// Returns canonical form of locale, as used by Dojo.
|
|
//
|
|
// description:
|
|
// All variants are case-insensitive and are separated by '-' as specified in [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt).
|
|
// If no locale is specified, the dojo.locale is returned. dojo.locale is defined by
|
|
// the user agent's locale unless overridden by djConfig.
|
|
|
|
var result = locale ? locale.toLowerCase() : dojo.locale;
|
|
if(result == "root"){
|
|
result = "ROOT";
|
|
}
|
|
return result; // String
|
|
};
|
|
|
|
dojo.i18n._requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*String?*/availableFlatLocales){
|
|
// summary:
|
|
// See dojo.requireLocalization()
|
|
// description:
|
|
// Called by the bootstrap, but factored out so that it is only
|
|
// included in the build when needed.
|
|
|
|
var targetLocale = dojo.i18n.normalizeLocale(locale);
|
|
var bundlePackage = [moduleName, "nls", bundleName].join(".");
|
|
// NOTE:
|
|
// When loading these resources, the packaging does not match what is
|
|
// on disk. This is an implementation detail, as this is just a
|
|
// private data structure to hold the loaded resources. e.g.
|
|
// `tests/hello/nls/en-us/salutations.js` is loaded as the object
|
|
// `tests.hello.nls.salutations.en_us={...}` The structure on disk is
|
|
// intended to be most convenient for developers and translators, but
|
|
// in memory it is more logical and efficient to store in a different
|
|
// order. Locales cannot use dashes, since the resulting path will
|
|
// not evaluate as valid JS, so we translate them to underscores.
|
|
|
|
//Find the best-match locale to load if we have available flat locales.
|
|
var bestLocale = "";
|
|
if(availableFlatLocales){
|
|
var flatLocales = availableFlatLocales.split(",");
|
|
for(var i = 0; i < flatLocales.length; i++){
|
|
//Locale must match from start of string.
|
|
//Using ["indexOf"] so customBase builds do not see
|
|
//this as a dojo._base.array dependency.
|
|
if(targetLocale["indexOf"](flatLocales[i]) == 0){
|
|
if(flatLocales[i].length > bestLocale.length){
|
|
bestLocale = flatLocales[i];
|
|
}
|
|
}
|
|
}
|
|
if(!bestLocale){
|
|
bestLocale = "ROOT";
|
|
}
|
|
}
|
|
|
|
//See if the desired locale is already loaded.
|
|
var tempLocale = availableFlatLocales ? bestLocale : targetLocale;
|
|
var bundle = dojo._loadedModules[bundlePackage];
|
|
var localizedBundle = null;
|
|
if(bundle){
|
|
if(dojo.config.localizationComplete && bundle._built){return;}
|
|
var jsLoc = tempLocale.replace(/-/g, '_');
|
|
var translationPackage = bundlePackage+"."+jsLoc;
|
|
localizedBundle = dojo._loadedModules[translationPackage];
|
|
}
|
|
|
|
if(!localizedBundle){
|
|
bundle = dojo["provide"](bundlePackage);
|
|
var syms = dojo._getModuleSymbols(moduleName);
|
|
var modpath = syms.concat("nls").join("/");
|
|
var parent;
|
|
|
|
dojo.i18n._searchLocalePath(tempLocale, availableFlatLocales, function(loc){
|
|
var jsLoc = loc.replace(/-/g, '_');
|
|
var translationPackage = bundlePackage + "." + jsLoc;
|
|
var loaded = false;
|
|
if(!dojo._loadedModules[translationPackage]){
|
|
// Mark loaded whether it's found or not, so that further load attempts will not be made
|
|
dojo["provide"](translationPackage);
|
|
var module = [modpath];
|
|
if(loc != "ROOT"){module.push(loc);}
|
|
module.push(bundleName);
|
|
var filespec = module.join("/") + '.js';
|
|
loaded = dojo._loadPath(filespec, null, function(hash){
|
|
// Use singleton with prototype to point to parent bundle, then mix-in result from loadPath
|
|
var clazz = function(){};
|
|
clazz.prototype = parent;
|
|
bundle[jsLoc] = new clazz();
|
|
for(var j in hash){ bundle[jsLoc][j] = hash[j]; }
|
|
});
|
|
}else{
|
|
loaded = true;
|
|
}
|
|
if(loaded && bundle[jsLoc]){
|
|
parent = bundle[jsLoc];
|
|
}else{
|
|
bundle[jsLoc] = parent;
|
|
}
|
|
|
|
if(availableFlatLocales){
|
|
//Stop the locale path searching if we know the availableFlatLocales, since
|
|
//the first call to this function will load the only bundle that is needed.
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
|
|
//Save the best locale bundle as the target locale bundle when we know the
|
|
//the available bundles.
|
|
if(availableFlatLocales && targetLocale != bestLocale){
|
|
bundle[targetLocale.replace(/-/g, '_')] = bundle[bestLocale.replace(/-/g, '_')];
|
|
}
|
|
};
|
|
|
|
(function(){
|
|
// If other locales are used, dojo.requireLocalization should load them as
|
|
// well, by default.
|
|
//
|
|
// Override dojo.requireLocalization to do load the default bundle, then
|
|
// iterate through the extraLocale list and load those translations as
|
|
// well, unless a particular locale was requested.
|
|
|
|
var extra = dojo.config.extraLocale;
|
|
if(extra){
|
|
if(!extra instanceof Array){
|
|
extra = [extra];
|
|
}
|
|
|
|
var req = dojo.i18n._requireLocalization;
|
|
dojo.i18n._requireLocalization = function(m, b, locale, availableFlatLocales){
|
|
req(m,b,locale, availableFlatLocales);
|
|
if(locale){return;}
|
|
for(var i=0; i<extra.length; i++){
|
|
req(m,b,extra[i], availableFlatLocales);
|
|
}
|
|
};
|
|
}
|
|
})();
|
|
|
|
dojo.i18n._searchLocalePath = function(/*String*/locale, /*Boolean*/down, /*Function*/searchFunc){
|
|
// summary:
|
|
// A helper method to assist in searching for locale-based resources.
|
|
// Will iterate through the variants of a particular locale, either up
|
|
// or down, executing a callback function. For example, "en-us" and
|
|
// true will try "en-us" followed by "en" and finally "ROOT".
|
|
|
|
locale = dojo.i18n.normalizeLocale(locale);
|
|
|
|
var elements = locale.split('-');
|
|
var searchlist = [];
|
|
for(var i = elements.length; i > 0; i--){
|
|
searchlist.push(elements.slice(0, i).join('-'));
|
|
}
|
|
searchlist.push(false);
|
|
if(down){searchlist.reverse();}
|
|
|
|
for(var j = searchlist.length - 1; j >= 0; j--){
|
|
var loc = searchlist[j] || "ROOT";
|
|
var stop = searchFunc(loc);
|
|
if(stop){ break; }
|
|
}
|
|
};
|
|
|
|
dojo.i18n._preloadLocalizations = function(/*String*/bundlePrefix, /*Array*/localesGenerated){
|
|
// summary:
|
|
// Load built, flattened resource bundles, if available for all
|
|
// locales used in the page. Only called by built layer files.
|
|
|
|
function preload(locale){
|
|
locale = dojo.i18n.normalizeLocale(locale);
|
|
dojo.i18n._searchLocalePath(locale, true, function(loc){
|
|
for(var i=0; i<localesGenerated.length;i++){
|
|
if(localesGenerated[i] == loc){
|
|
dojo["require"](bundlePrefix+"_"+loc);
|
|
return true; // Boolean
|
|
}
|
|
}
|
|
return false; // Boolean
|
|
});
|
|
}
|
|
preload();
|
|
var extra = dojo.config.extraLocale||[];
|
|
for(var i=0; i<extra.length; i++){
|
|
preload(extra[i]);
|
|
}
|
|
};
|
|
|
|
}
|