/*
* loader.js - A bootstrap module. Runs before the hostenv_*.js file. Contains all of the package loading methods.
*/
//A semi-colon is at the start of the line because after doing a build, this function definition
//get compressed onto the same line as the last line in bootstrap1.js. That list line is just a
//curly bracket, and the browser complains about that syntax. The semicolon fixes it. Putting it
//here instead of at the end of bootstrap1.js, since it is more of an issue for this file, (using
//the closure), and bootstrap1.js could change in the future.
;(function(){
//Additional properties for dojo.hostenv
var _addHostEnv = {
pkgFileName: "__package__",
// for recursion protection
loading_modules_: {},
loaded_modules_: {},
addedToLoadingCount: [],
removedFromLoadingCount: [],
inFlightCount: 0,
// FIXME: it should be possible to pull module prefixes in from djConfig
modulePrefixes_: {
dojo: {name: "dojo", value: "src"}
},
setModulePrefix: function(/*String*/module, /*String*/prefix){
// summary: establishes module/prefix pair
this.modulePrefixes_[module] = {name: module, value: prefix};
},
moduleHasPrefix: function(/*String*/module){
// summary: checks to see if module has been established
var mp = this.modulePrefixes_;
return Boolean(mp[module] && mp[module].value); // Boolean
},
getModulePrefix: function(/*String*/module){
// summary: gets the prefix associated with module
if(this.moduleHasPrefix(module)){
return this.modulePrefixes_[module].value; // String
}
return module; // String
},
getTextStack: [],
loadUriStack: [],
loadedUris: [],
//WARNING: This variable is referenced by packages outside of bootstrap: FloatingPane.js and undo/browser.js
post_load_: false,
//Egad! Lots of test files push on this directly instead of using dojo.addOnLoad.
modulesLoadedListeners: [],
unloadListeners: [],
loadNotifying: false
};
//Add all of these properties to dojo.hostenv
for(var param in _addHostEnv){
dojo.hostenv[param] = _addHostEnv[param];
}
})();
dojo.hostenv.loadPath = function(/*String*/relpath, /*String?*/module, /*Function?*/cb){
// summary:
// Load a Javascript module given a relative path
//
// description:
// Loads and interprets the script located at relpath, which is relative to the
// script root directory. If the script is found but its interpretation causes
// a runtime exception, that exception is not caught by us, so the caller will
// see it. We return a true value if and only if the script is found.
//
// For now, we do not have an implementation of a true search path. We
// consider only the single base script uri, as returned by getBaseScriptUri().
//
// relpath: A relative path to a script (no leading '/index.html', and typically
// ending in '/doc/j/jc/jcap/Dojo/common/041/lib/src/.js').
// module: A module whose existance to check for after loading a path.
// Can be used to determine success or failure of the load.
// cb: a callback function to pass the result of evaluating the script
var uri;
if(relpath.charAt(0) == '/index.html' || relpath.match(/^\w+:/)){
// dojo.raise("relpath '" + relpath + "'; must be relative");
uri = relpath;
}else{
uri = this.getBaseScriptUri() + relpath;
}
if(djConfig.cacheBust && dojo.render.html.capable){
uri += "?" + String(djConfig.cacheBust).replace(/\W+/g,"");
}
try{
return !module ? this.loadUri(uri, cb) : this.loadUriAndCheck(uri, module, cb); // Boolean
}catch(e){
dojo.debug(e);
return false; // Boolean
}
}
dojo.hostenv.loadUri = function(/*String (URL)*/uri, /*Function?*/cb){
// summary:
// Loads JavaScript from a URI
//
// description:
// Reads the contents of the URI, and evaluates the contents. This is used to load modules as well
// as resource bundles. Returns true if it succeeded. Returns false if the URI reading failed.
// Throws if the evaluation throws.
//
// uri: a uri which points at the script to be loaded
// cb: a callback function to process the result of evaluating the script as an expression, typically
// used by the resource bundle loader to load JSON-style resources
if(this.loadedUris[uri]){
return true; // Boolean
}
var contents = this.getText(uri, null, true);
if(!contents){ return false; } // Boolean
this.loadedUris[uri] = true;
if(cb){ contents = '('+contents+')'; }
var value = dj_eval(contents);
if(cb){ cb(value); }
return true; // Boolean
}
// FIXME: probably need to add logging to this method
dojo.hostenv.loadUriAndCheck = function(/*String (URL)*/uri, /*String*/moduleName, /*Function?*/cb){
// summary: calls loadUri then findModule and returns true if both succeed
var ok = true;
try{
ok = this.loadUri(uri, cb);
}catch(e){
dojo.debug("failed loading ", uri, " with error: ", e);
}
return Boolean(ok && this.findModule(moduleName, false)); // Boolean
}
dojo.loaded = function(){ }
dojo.unloaded = function(){ }
dojo.hostenv.loaded = function(){
this.loadNotifying = true;
this.post_load_ = true;
var mll = this.modulesLoadedListeners;
for(var x=0; x<mll.length; x++){
mll[x]();
}
//Clear listeners so new ones can be added
//For other xdomain package loads after the initial load.
this.modulesLoadedListeners = [];
this.loadNotifying = false;
dojo.loaded();
}
dojo.hostenv.unloaded = function(){
var mll = this.unloadListeners;
while(mll.length){
(mll.pop())();
}
dojo.unloaded();
}
dojo.addOnLoad = function(/*Object?*/obj, /*String|Function*/functionName) {
// summary:
// Registers a function to be triggered after the DOM has finished loading
// and widgets declared in markup have been instantiated. Images and CSS files
// may or may not have finished downloading when the specified function is called.
// (Note that widgets' CSS and HTML code is guaranteed to be downloaded before said
// widgets are instantiated.)
//
// usage:
// dojo.addOnLoad(functionPointer)
// dojo.addOnLoad(object, "functionName")
var dh = dojo.hostenv;
if(arguments.length == 1) {
dh.modulesLoadedListeners.push(obj);
} else if(arguments.length > 1) {
dh.modulesLoadedListeners.push(function() {
obj[functionName]();
});
}
//Added for xdomain loading. dojo.addOnLoad is used to
//indicate callbacks after doing some dojo.require() statements.
//In the xdomain case, if all the requires are loaded (after initial
//page load), then immediately call any listeners.
if(dh.post_load_ && dh.inFlightCount == 0 && !dh.loadNotifying){
dh.callLoaded();
}
}
dojo.addOnUnload = function(/*Object?*/obj, /*String|Function?*/functionName){
// summary: registers a function to be triggered when the page unloads
//
// usage:
// dojo.addOnLoad(functionPointer)
// dojo.addOnLoad(object, "functionName")
var dh = dojo.hostenv;
if(arguments.length == 1){
dh.unloadListeners.push(obj);
} else if(arguments.length > 1) {
dh.unloadListeners.push(function() {
obj[functionName]();
});
}
}
dojo.hostenv.modulesLoaded = function(){
if(this.post_load_){ return; }
if(this.loadUriStack.length==0 && this.getTextStack.length==0){
if(this.inFlightCount > 0){
dojo.debug("files still in flight!");
return;
}
dojo.hostenv.callLoaded();
}
}
dojo.hostenv.callLoaded = function(){
if(typeof setTimeout == "object"){
setTimeout("dojo.hostenv.loaded();", 0);
}else{
dojo.hostenv.loaded();
}
}
dojo.hostenv.getModuleSymbols = function(/*String*/modulename){
// summary:
// Converts a module name in dotted JS notation to an array representing the path in the source tree
var syms = modulename.split(".");
for(var i = syms.length; i>0; i--){
var parentModule = syms.slice(0, i).join(".");
if((i==1) && !this.moduleHasPrefix(parentModule)){
// Support default module directory (sibling of dojo) for top-level modules
syms[0] = "../" + syms[0];
}else{
var parentModulePath = this.getModulePrefix(parentModule);
if(parentModulePath != parentModule){
syms.splice(0, i, parentModulePath);
break;
}
}
}
return syms; // Array
}
dojo.hostenv._global_omit_module_check = false;
dojo.hostenv.loadModule = function(/*String*/moduleName, /*Boolean?*/exactOnly, /*Boolean?*/omitModuleCheck){
// summary:
// loads a Javascript module from the appropriate URI
//
// description:
// loadModule("A.B") first checks to see if symbol A.B is defined.
// If it is, it is simply returned (nothing to do).
//
// If it is not defined, it will look for "A/B.js" in the script root directory,
// followed by "A.js".
//
// It throws if it cannot find a file to load, or if the symbol A.B is not
// defined after loading.
//
// It returns the object A.B.
//
// This does nothing about importing symbols into the current package.
// It is presumed that the caller will take care of that. For example, to import
// all symbols:
//
// with (dojo.hostenv.loadModule("A.B")) {
// ...
// }
//
// And to import just the leaf symbol:
//
// var B = dojo.hostenv.loadModule("A.B");
// ...
//
// dj_load is an alias for dojo.hostenv.loadModule
if(!moduleName){ return; }
omitModuleCheck = this._global_omit_module_check || omitModuleCheck;
var module = this.findModule(moduleName, false);
if(module){
return module;
}
// protect against infinite recursion from mutual dependencies
if(dj_undef(moduleName, this.loading_modules_)){
this.addedToLoadingCount.push(moduleName);
}
this.loading_modules_[moduleName] = 1;
// convert periods to slashes
var relpath = moduleName.replace(/\./g, '/index.html') + '/doc/j/jc/jcap/Dojo/common/041/lib/src/.js';
var nsyms = moduleName.split(".");
// this line allowed loading of a module manifest as if it were a namespace
// it's an interesting idea, but shouldn't be combined with 'namespaces' proper
// and leads to unwanted dependencies
// the effect can be achieved in other (albeit less-flexible) ways now, so I am
// removing this pending further design work
// perhaps we can explicitly define this idea of a 'module manifest', and subclass
// 'namespace manifest' from that
//dojo.getNamespace(nsyms[0]);
var syms = this.getModuleSymbols(moduleName);
var startedRelative = ((syms[0].charAt(0) != '/index.html') && !syms[0].match(/^\w+:/));
var last = syms[syms.length - 1];
var ok;
// figure out if we're looking for a full package, if so, we want to do
// things slightly diffrently
if(last=="*"){
moduleName = nsyms.slice(0, -1).join('.');
while(syms.length){
syms.pop();
syms.push(this.pkgFileName);
relpath = syms.join("/") + '/doc/j/jc/jcap/Dojo/common/041/lib/src/.js';
if(startedRelative && relpath.charAt(0)=="/"){
relpath = relpath.slice(1);
}
ok = this.loadPath(relpath, !omitModuleCheck ? moduleName : null);
if(ok){ break; }
syms.pop();
}
}else{
relpath = syms.join("/") + '/doc/j/jc/jcap/Dojo/common/041/lib/src/.js';
moduleName = nsyms.join('.');
var modArg = !omitModuleCheck ? moduleName : null;
ok = this.loadPath(relpath, modArg);
if(!ok && !exactOnly){
syms.pop();
while(syms.length){
relpath = syms.join('/index.html') + '/doc/j/jc/jcap/Dojo/common/041/lib/src/.js';
ok = this.loadPath(relpath, modArg);
if(ok){ break; }
syms.pop();
relpath = syms.join('/index.html') + '/index.html'+this.pkgFileName+'/doc/j/jc/jcap/Dojo/common/041/lib/src/.js';
if(startedRelative && relpath.charAt(0)=="/"){
relpath = relpath.slice(1);
}
ok = this.loadPath(relpath, modArg);
if(ok){ break; }
}
}
if(!ok && !omitModuleCheck){
dojo.raise("Could not load '" + moduleName + "'; last tried '" + relpath + "'");
}
}
// check that the symbol was defined
//Don't bother if we're doing xdomain (asynchronous) loading.
if(!omitModuleCheck && !this["isXDomain"]){
// pass in false so we can give better error
module = this.findModule(moduleName, false);
if(!module){
dojo.raise("symbol '" + moduleName + "' is not defined after loading '" + relpath + "'");
}
}
return module;
}
dojo.hostenv.startPackage = function(/*String*/packageName){
// summary:
// Creates a JavaScript package
//
// description:
// startPackage("A.B") follows the path, and at each level creates a new empty
// object or uses what already exists. It returns the result.
//
// packageName: the package to be created as a String in dot notation
//Make sure we have a string.
var fullPkgName = String(packageName);
var strippedPkgName = fullPkgName;
var syms = packageName.split(/\./);
if(syms[syms.length-1]=="*"){
syms.pop();
strippedPkgName = syms.join(".");
}
var evaledPkg = dojo.evalObjPath(strippedPkgName, true);
this.loaded_modules_[fullPkgName] = evaledPkg;
this.loaded_modules_[strippedPkgName] = evaledPkg;
return evaledPkg; // Object
}
dojo.hostenv.findModule = function(/*String*/moduleName, /*Boolean?*/mustExist){
// summary:
// Returns the Object representing the module, if it exists, otherwise null.
//
// moduleName A fully qualified module including package name, like 'A.B'.
// mustExist Optional, default false. throw instead of returning null
// if the module does not currently exist.
var lmn = String(moduleName);
if(this.loaded_modules_[lmn]){
return this.loaded_modules_[lmn]; // Object
}
if(mustExist){
dojo.raise("no loaded module named '" + moduleName + "'");
}
return null; // null
}
//Start of old bootstrap2:
dojo.kwCompoundRequire = function(/*Object containing Arrays*/modMap){
// description:
// This method taks a "map" of arrays which one can use to optionally load dojo
// modules. The map is indexed by the possible dojo.hostenv.name_ values, with
// two additional values: "default" and "common". The items in the "default"
// array will be loaded if none of the other items have been choosen based on
// the hostenv.name_ item. The items in the "common" array will _always_ be
// loaded, regardless of which list is chosen. Here's how it's normally
// called:
//
// dojo.kwCompoundRequire({
// browser: [
// ["foo.bar.baz", true, true], // an example that passes multiple args to loadModule()
// "foo.sample.*",
// "foo.test,
// ],
// default: [ "foo.sample.*" ],
// common: [ "really.important.module.*" ]
// });
var common = modMap["common"]||[];
var result = modMap[dojo.hostenv.name_] ? common.concat(modMap[dojo.hostenv.name_]||[]) : common.concat(modMap["default"]||[]);
for(var x=0; x<result.length; x++){
var curr = result[x];
if(curr.constructor == Array){
dojo.hostenv.loadModule.apply(dojo.hostenv, curr);
}else{
dojo.hostenv.loadModule(curr);
}
}
}
dojo.require = function(/*String*/ resourceName){
// summary
// Ensure that the given resource (ie, javascript
// source file) has been loaded.
// description
// dojo.require() is similar to C's #include command or java's "import" command.
// You call dojo.require() to pull in the resources (ie, javascript source files)
// that define the functions you are using.
//
// Note that in the case of a build, many resources have already been included
// into dojo.js (ie, many of the javascript source files have been compressed and
// concatened into dojo.js), so many dojo.require() calls will simply return
// without downloading anything.
dojo.hostenv.loadModule.apply(dojo.hostenv, arguments);
}
dojo.requireIf = function(/*Boolean*/ condition, /*String*/ resourceName){
// summary
// If the condition is true then call dojo.require() for the specified resource
var arg0 = arguments[0];
if((arg0 === true)||(arg0=="common")||(arg0 && dojo.render[arg0].capable)){
var args = [];
for (var i = 1; i < arguments.length; i++) { args.push(arguments[i]); }
dojo.require.apply(dojo, args);
}
}
dojo.requireAfterIf = dojo.requireIf;
dojo.provide = function(/*String*/ resourceName){
// summary
// Each javascript source file must have (exactly) one dojo.provide()
// call at the top of the file, corresponding to the file name.
// For example, dojo/src/foo.js must have dojo.provide("dojo.foo"); at the top of the file.
//
// description
// Each javascript source file is called a resource. When a resource
// is loaded by the browser, dojo.provide() registers that it has
// been loaded.
//
// For backwards compatibility reasons, in addition to registering the resource,
// dojo.provide() also ensures that the javascript object for the module exists. For
// example, dojo.provide("dojo.html.common"), in addition to registering that common.js
// is a resource for the dojo.html module, will ensure that the dojo.html javascript object
// exists, so that calls like dojo.html.foo = function(){ ... } don't fail.
//
// In the case of a build (or in the future, a rollup), where multiple javascript source
// files are combined into one bigger file (similar to a .lib or .jar file), that file
// will contain multiple dojo.provide() calls, to note that it includes
// multiple resources.
return dojo.hostenv.startPackage.apply(dojo.hostenv, arguments);
}
dojo.registerModulePath = function(/*String*/module, /*String*/prefix){
// summary: maps a module name to a path
// description: An unregistered module is given the default path of ../<module>,
// relative to Dojo root. For example, module acme is mapped to ../acme.
// If you want to use a different module name, use dojo.registerModulePath.
return dojo.hostenv.setModulePrefix(module, prefix);
}
dojo.setModulePrefix = function(/*String*/module, /*String*/prefix){
// summary: maps a module name to a path
dojo.deprecated('dojo.setModulePrefix("' + module + '", "' + prefix + '")', "replaced by dojo.registerModulePath", "0.5");
return dojo.registerModulePath(module, prefix);
}
dojo.exists = function(/*Object*/obj, /*String*/name){
// summary: determine if an object supports a given method
// description: useful for longer api chains where you have to test each object in the chain
var p = name.split(".");
for(var i = 0; i < p.length; i++){
if(!obj[p[i]]){ return false; } // Boolean
obj = obj[p[i]];
}
return true; // Boolean
}
// Localization routines
dojo.hostenv.normalizeLocale = function(/*String?*/locale){
// summary:
// Returns canonical form of locale, as used by Dojo. All variants are case-insensitive and are separated by '-'
// as specified in RFC 3066. If no locale is specified, the user agent's default is returned.
var result = locale ? locale.toLowerCase() : dojo.locale;
if(result == "root"){
result = "ROOT";
}
return result;// String
};
dojo.hostenv.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.hostenv.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; }
}
}
//These two functions are placed outside of preloadLocalizations
//So that the xd loading can use/override them.
dojo.hostenv.localesGenerated /***BUILD:localesGenerated***/; // value will be inserted here at build time, if necessary
dojo.hostenv.registerNlsPrefix = function(){
// summary:
// Register module "nls" to point where Dojo can find pre-built localization files
dojo.registerModulePath("nls","nls");
}
dojo.hostenv.preloadLocalizations = function(){
// summary:
// Load built, flattened resource bundles, if available for all locales used in the page.
// Execute only once. Note that this is a no-op unless there is a build.
if(dojo.hostenv.localesGenerated){
dojo.hostenv.registerNlsPrefix();
function preload(locale){
locale = dojo.hostenv.normalizeLocale(locale);
dojo.hostenv.searchLocalePath(locale, true, function(loc){
for(var i=0; i<dojo.hostenv.localesGenerated.length;i++){
if(dojo.hostenv.localesGenerated[i] == loc){
dojo["require"]("nls.dojo_"+loc);
return true; // Boolean
}
}
return false; // Boolean
});
}
preload();
var extra = djConfig.extraLocale||[];
for(var i=0; i<extra.length; i++){
preload(extra[i]);
}
}
dojo.hostenv.preloadLocalizations = function(){};
}
dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*String?*/availableFlatLocales){
// summary:
// Declares translated resources and loads them if necessary, in the same style as dojo.require.
// Contents of the resource bundle are typically strings, but may be any name/value pair,
// represented in JSON format. See also dojo.i18n.getLocalization.
//
// moduleName: name of the package containing the "nls" directory in which the bundle is found
// bundleName: bundle name, i.e. the filename without the '/doc/j/jc/jcap/Dojo/common/041/lib/src/.js' suffix
// locale: the locale to load (optional) By default, the browser's user locale as defined by dojo.locale
// availableFlatLocales: A comma-separated list of the available, flattened locales for this bundle.
// This argument should only be set by the build process.
//
// description:
// Load translated resource bundles provided underneath the "nls" directory within a package.
// Translated resources may be located in different packages throughout the source tree. For example,
// a particular widget may define one or more resource bundles, structured in a program as follows,
// where moduleName is mycode.mywidget and bundleNames available include bundleone and bundletwo:
// ...
// mycode/
// mywidget/
// nls/
// bundleone.js (the fallback translation, English in this example)
// bundletwo.js (also a fallback translation)
// de/
// bundleone.js
// bundletwo.js
// de-at/
// bundleone.js
// en/
// (empty; use the fallback translation)
// en-us/
// bundleone.js
// en-gb/
// bundleone.js
// es/
// bundleone.js
// bundletwo.js
// ...etc
// ...
// Each directory is named for a locale as specified by RFC 3066, (http://www.ietf.org/rfc/rfc3066.txt),
// normalized in lowercase. Note that the two bundles in the example do not define all the same variants.
// For a given locale, bundles will be loaded for that locale and all more general locales above it, including
// a fallback at the root directory. For example, a declaration for the "de-at" locale will first
// load nls/de-at/bundleone.js, then nls/de/bundleone.js and finally nls/bundleone.js. The data will
// be flattened into a single Object so that lookups will follow this cascading pattern. An optional build
// step can preload the bundles to avoid data redundancy and the multiple network hits normally required to
// load these resources.
dojo.hostenv.preloadLocalizations();
var targetLocale = dojo.hostenv.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.
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.hostenv.findModule(bundlePackage);
var localizedBundle = null;
if(bundle){
if(djConfig.localizationComplete && bundle._built){return;}
var jsLoc = tempLocale.replace('-', '_');
var translationPackage = bundlePackage+"."+jsLoc;
localizedBundle = dojo.hostenv.findModule(translationPackage);
}
if(!localizedBundle){
bundle = dojo.hostenv.startPackage(bundlePackage);
var syms = dojo.hostenv.getModuleSymbols(moduleName);
var modpath = syms.concat("nls").join("/");
var parent;
dojo.hostenv.searchLocalePath(tempLocale, availableFlatLocales, function(loc){
var jsLoc = loc.replace('-', '_');
var translationPackage = bundlePackage + "." + jsLoc;
var loaded = false;
if(!dojo.hostenv.findModule(translationPackage)){
// Mark loaded whether it's found or not, so that further load attempts will not be made
dojo.hostenv.startPackage(translationPackage);
var module = [modpath];
if(loc != "ROOT"){module.push(loc);}
module.push(bundleName);
var filespec = module.join("/") + '/doc/j/jc/jcap/Dojo/common/041/lib/src/.js';
loaded = dojo.hostenv.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('-', '_')] = bundle[bestLocale.replace('-', '_')];
}
};
(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 = djConfig.extraLocale;
if(extra){
if(!extra instanceof Array){
extra = [extra];
}
var req = dojo.requireLocalization;
dojo.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);
}
};
}
})();