summaryrefslogtreecommitdiff
path: root/js/dojo-1.7.2/dojo/i18n.js
diff options
context:
space:
mode:
Diffstat (limited to 'js/dojo-1.7.2/dojo/i18n.js')
-rw-r--r--js/dojo-1.7.2/dojo/i18n.js302
1 files changed, 302 insertions, 0 deletions
diff --git a/js/dojo-1.7.2/dojo/i18n.js b/js/dojo-1.7.2/dojo/i18n.js
new file mode 100644
index 0000000..e205a3f
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/i18n.js
@@ -0,0 +1,302 @@
+//>>built
+define("dojo/i18n", ["./_base/kernel", "require", "./has", "./_base/array", "./_base/config", "./_base/lang", "./_base/xhr"],
+ function(dojo, require, has, array, config, lang, xhr) {
+ // module:
+ // dojo/i18n
+ // summary:
+ // This module implements the !dojo/i18n plugin and the v1.6- i18n API
+ // description:
+ // We choose to include our own plugin to leverage functionality already contained in dojo
+ // and thereby reduce the size of the plugin compared to various loader implementations. Also, this
+ // allows foreign AMD loaders to be used without their plugins.
+ var
+ thisModule= dojo.i18n=
+ // the dojo.i18n module
+ {},
+
+ nlsRe=
+ // regexp for reconstructing the master bundle name from parts of the regexp match
+ // nlsRe.exec("foo/bar/baz/nls/en-ca/foo") gives:
+ // ["foo/bar/baz/nls/en-ca/foo", "foo/bar/baz/nls/", "/", "/", "en-ca", "foo"]
+ // nlsRe.exec("foo/bar/baz/nls/foo") gives:
+ // ["foo/bar/baz/nls/foo", "foo/bar/baz/nls/", "/", "/", "foo", ""]
+ // so, if match[5] is blank, it means this is the top bundle definition.
+ // courtesy of http://requirejs.org
+ /(^.*(^|\/)nls)(\/|$)([^\/]*)\/?([^\/]*)/,
+
+ getAvailableLocales= function(
+ root,
+ locale,
+ bundlePath,
+ bundleName
+ ){
+ // return a vector of module ids containing all available locales with respect to the target locale
+ // For example, assuming:
+ // * the root bundle indicates specific bundles for "fr" and "fr-ca",
+ // * bundlePath is "myPackage/nls"
+ // * bundleName is "myBundle"
+ // Then a locale argument of "fr-ca" would return
+ // ["myPackage/nls/myBundle", "myPackage/nls/fr/myBundle", "myPackage/nls/fr-ca/myBundle"]
+ // Notice that bundles are returned least-specific to most-specific, starting with the root.
+ //
+ // If root===false indicates we're working with a pre-AMD i18n bundle that doesn't tell about the available locales;
+ // therefore, assume everything is available and get 404 errors that indicate a particular localization is not available
+ //
+
+ for(var result= [bundlePath + bundleName], localeParts= locale.split("-"), current= "", i= 0; i<localeParts.length; i++){
+ current+= (current ? "-" : "") + localeParts[i];
+ if(!root || root[current]){
+ result.push(bundlePath + current + "/" + bundleName);
+ }
+ }
+ return result;
+ },
+
+ cache= {},
+
+ getL10nName= dojo.getL10nName = function(moduleName, bundleName, locale){
+ locale = locale ? locale.toLowerCase() : dojo.locale;
+ moduleName = "dojo/i18n!" + moduleName.replace(/\./g, "/");
+ bundleName = bundleName.replace(/\./g, "/");
+ return (/root/i.test(locale)) ?
+ (moduleName + "/nls/" + bundleName) :
+ (moduleName + "/nls/" + locale + "/" + bundleName);
+ },
+
+ doLoad = function(require, bundlePathAndName, bundlePath, bundleName, locale, load){
+ // get the root bundle which instructs which other bundles are required to construct the localized bundle
+ require([bundlePathAndName], function(root){
+ var
+ current= cache[bundlePathAndName + "/"]= lang.clone(root.root),
+ availableLocales= getAvailableLocales(!root._v1x && root, locale, bundlePath, bundleName);
+ require(availableLocales, function(){
+ for (var i= 1; i<availableLocales.length; i++){
+ cache[availableLocales[i]]= current= lang.mixin(lang.clone(current), arguments[i]);
+ }
+ // target may not have been resolve (e.g., maybe only "fr" exists when "fr-ca" was requested)
+ var target= bundlePathAndName + "/" + locale;
+ cache[target]= current;
+ load && load(lang.delegate(current));
+ });
+ });
+ },
+
+ normalize = function(id, toAbsMid){
+ // note: id may be relative
+ var match= nlsRe.exec(id),
+ bundlePath= match[1];
+ return /^\./.test(bundlePath) ? toAbsMid(bundlePath) + "/" + id.substring(bundlePath.length) : id;
+ },
+
+ checkForLegacyModules = function(){},
+
+ load = function(id, require, load){
+ // note: id is always absolute
+ var
+ match= nlsRe.exec(id),
+ bundlePath= match[1] + "/",
+ bundleName= match[5] || match[4],
+ bundlePathAndName= bundlePath + bundleName,
+ localeSpecified = (match[5] && match[4]),
+ targetLocale= localeSpecified || dojo.locale,
+ target= bundlePathAndName + "/" + targetLocale;
+
+ if(localeSpecified){
+ checkForLegacyModules(target);
+ if(cache[target]){
+ // a request for a specific local that has already been loaded; just return it
+ load(cache[target]);
+ }else{
+ // a request for a specific local that has not been loaded; load and return just that locale
+ doLoad(require, bundlePathAndName, bundlePath, bundleName, targetLocale, load);
+ }
+ return;
+ }// else a non-locale-specific request; therefore always load dojo.locale + config.extraLocale
+
+ // notice the subtle algorithm that loads targetLocal last, which is the only doLoad application that passes a value for the load callback
+ // this makes the sync loader follow a clean code path that loads extras first and then proceeds with tracing the current deps graph
+ var extra = config.extraLocale || [];
+ extra = lang.isArray(extra) ? extra : [extra];
+ extra.push(targetLocale);
+ var remaining = extra.length,
+ targetBundle;
+ array.forEach(extra, function(locale){
+ doLoad(require, bundlePathAndName, bundlePath, bundleName, locale, function(bundle){
+ if(locale == targetLocale){
+ targetBundle = bundle;
+ }
+ if(!--remaining){
+ load(targetBundle);
+ }
+ });
+ });
+ };
+
+ if(has("dojo-unit-tests")){
+ var unitTests = thisModule.unitTests = [];
+ }
+
+ true || has.add("dojo-v1x-i18n-Api",
+ // if true, define the v1.x i18n functions
+ 1
+ );
+
+ if(1){
+ var
+ __evalError = {},
+
+ evalBundle=
+ // use the function ctor to keep the minifiers away and come close to global scope
+ // if bundle is an AMD bundle, then __amdResult will be defined; otherwise it's a pre-amd bundle and the bundle value is returned by eval
+ new Function("bundle, __evalError",
+ "var __amdResult, define = function(x){__amdResult= x;};" +
+ "return [(function(){" +
+ "try{eval(arguments[0]);}catch(e){}" +
+ "if(__amdResult)return 0;" +
+ "try{return eval('('+arguments[0]+')');}" +
+ "catch(e){__evalError.e = e; return __evalError;}" +
+ "})(arguments[0]) , __amdResult];"
+ ),
+
+ fixup= function(url, preAmdResult, amdResult){
+ // nls/<locale>/<bundle-name> indicates not the root.
+ if(preAmdResult===__evalError){
+ console.error("failed to evaluate i18n bundle; url=" + url, __evalError.e);
+ return {};
+ }
+ return preAmdResult ? (/nls\/[^\/]+\/[^\/]+$/.test(url) ? preAmdResult : {root:preAmdResult, _v1x:1}) : amdResult;
+ },
+
+ syncRequire= function(deps, callback){
+ var results= [];
+ array.forEach(deps, function(mid){
+ var url= require.toUrl(mid + ".js");
+ if(cache[url]){
+ results.push(cache[url]);
+ }else{
+
+ try {
+ var bundle= require(mid);
+ if(bundle){
+ results.push(bundle);
+ return;
+ }
+ }catch(e){}
+
+ xhr.get({
+ url:url,
+ sync:true,
+ load:function(text){
+ var result = evalBundle(text, __evalError);
+ results.push(cache[url]= fixup(url, result[0], result[1]));
+ },
+ error:function(){
+ results.push(cache[url]= {});
+ }
+ });
+ }
+ });
+ callback && callback.apply(null, results);
+ },
+
+ normalizeLocale = thisModule.normalizeLocale= function(locale){
+ var result = locale ? locale.toLowerCase() : dojo.locale;
+ if(result == "root"){
+ result = "ROOT";
+ }
+ return result;
+ },
+
+ forEachLocale = function(locale, func){
+ // this function is equivalent to v1.6 dojo.i18n._searchLocalePath with down===true
+ var parts = locale.split("-");
+ while(parts.length){
+ if(func(parts.join("-"))){
+ return true;
+ }
+ parts.pop();
+ }
+ return func("ROOT");
+ };
+
+ checkForLegacyModules = function(target){
+ // legacy code may have already loaded [e.g] the raw bundle x/y/z at x.y.z; when true, push into the cache
+ for(var names = target.split("/"), object = dojo.global[names[0]], i = 1; object && i<names.length; object = object[names[i++]]){}
+ if(object){
+ cache[target] = object;
+ }
+ };
+
+ thisModule.getLocalization= function(moduleName, bundleName, locale){
+ var result,
+ l10nName= getL10nName(moduleName, bundleName, locale).substring(10);
+ load(l10nName, (1 && !require.isXdUrl(require.toUrl(l10nName + ".js")) ? syncRequire : require), function(result_){ result= result_; });
+ return result;
+ };
+
+ thisModule._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.
+ //
+ // note: this function a direct copy of v1.6 function of same name
+
+ function preload(locale){
+ locale = normalizeLocale(locale);
+ forEachLocale(locale, function(loc){
+ for(var i=0; i<localesGenerated.length;i++){
+ if(localesGenerated[i] == loc){
+ syncRequire([bundlePrefix.replace(/\./g, "/")+"_"+loc]);
+ return true; // Boolean
+ }
+ }
+ return false; // Boolean
+ });
+ }
+ preload();
+ var extra = dojo.config.extraLocale||[];
+ for(var i=0; i<extra.length; i++){
+ preload(extra[i]);
+ }
+ };
+
+ if(has("dojo-unit-tests")){
+ unitTests.push(function(doh){
+ doh.register("tests.i18n.unit", function(t){
+ var check;
+
+ check = evalBundle("{prop:1}", __evalError);
+ t.is({prop:1}, check[0]); t.is(undefined, check[1]);
+
+ check = evalBundle("({prop:1})", __evalError);
+ t.is({prop:1}, check[0]); t.is(undefined, check[1]);
+
+ check = evalBundle("{'prop-x':1}", __evalError);
+ t.is({'prop-x':1}, check[0]); t.is(undefined, check[1]);
+
+ check = evalBundle("({'prop-x':1})", __evalError);
+ t.is({'prop-x':1}, check[0]); t.is(undefined, check[1]);
+
+ check = evalBundle("define({'prop-x':1})", __evalError);
+ t.is(0, check[0]); t.is({'prop-x':1}, check[1]);
+
+ check = evalBundle("define({'prop-x':1});", __evalError);
+ t.is(0, check[0]); t.is({'prop-x':1}, check[1]);
+
+ check = evalBundle("this is total nonsense and should throw an error", __evalError);
+ t.is(__evalError, check[0]); t.is(undefined, check[1]);
+ t.is({}, fixup("some/url", check[0], check[1]));
+ });
+ });
+ }
+ }
+
+ return lang.mixin(thisModule, {
+ dynamic:true,
+ normalize:normalize,
+ load:load,
+ cache:function(mid, value){
+ cache[mid] = value;
+ }
+ });
+});
generated by cgit v1.0-28-g1787 at 2026-01-10 10:00:57 +0000