/*
Copyright (c) 2004-2011, 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
*/
// AMD module id = dojo/lib/backCompat
//
// This module defines those dojo properties/methods that are defined by
// dojo/_base/_loader/loader and are still needed when loading with and
// AMD loader (when loading with an AMD loader, dojo/_base/_loader/loader
// is never loaded).
//
// note: this module is relevant only when loading dojo with an AMD loader;
// it is never evaluated otherwise.
define(["require", "dojo/_base/_loader/bootstrap"], function(require, dojo){
// the following dojo properties do not exist in the AMD-loaded version of dojo 1.x:
var names= [
"_moduleHasPrefix",
"_loadPath",
"_loadUri",
"_loadUriAndCheck",
"loaded",
"_callLoaded",
"_getModuleSymbols",
"_loadModule",
"require",
"provide",
"platformRequire",
"requireIf",
"requireAfterIf",
"registerModulePath"
], i, name;
for(i = 0; i<names.length;){
name = names[i++];
dojo[name] = (function(name) {
return function(){
console.warn("dojo." + name + " not available when using an AMD loader.");
};
})(name);
}
// define dojo.addOnLoad in terms of the DOMContentLoaded detection available from the AMD loaders
// (requirejs and bdBuild). Note that the behavior of this feature is slightly different compared to the dojo
// v1.x sync loader. There, the onload queue is fired upon detecting both DOMContentLoaded *and* all
// demanded modules have arrived. It is impossible to simulate this behavior with requirejs since it does
// not publish its internal status (it is possible with bdLoad).
// TODO: consider taking ownership of this API back from the loader.
// TODO: consider requesting requirejs publish more enough internal state to determine if all demanded
// modules have been defined.
var
argsToArray = function(args) {
var result = [], i;
for(i = 0; i<args.length;){
result.push(args[i++]);
}
return result;
},
simpleHitch = function(context, callback){
if(callback){
return (typeof callback=="string") ?
function(){context[callback]();} :
function(){callback.call(context);};
}else{
return context;
}
};
dojo.ready = dojo.addOnLoad = function(context, callback){
require.ready(callback ? simpleHitch(context, callback) : context);
};
dojo.addOnLoad(function() {
dojo.postLoad = dojo.config.afterOnLoad = true;
});
var dca = dojo.config.addOnLoad;
if(dca){
dojo.addOnLoad[(dca instanceof Array ? "apply" : "call")](dojo, dca);
}
// TODO: in the dojo 1.x sync loader the array dojo._loaders holds the queue of callbacks to be executed
// upon DOMContentLoaded. This queue is manipulated directly by dojo/uacss, dojo/parser, dijit/_base/wia
// and others (at least in dojox). This is also impossible to simulate universally across all AMD loaders.
// The following will at least accept client code accessing dojo._loaders , dojo._loaders.unshift, and
// dojo._loaders.splice--which is all that exists in the current dojo/dijit code stacks.
var
loaders = dojo._loaders = [],
runLoaders = function(){
var temp= loaders.slice(0);
Array.prototype.splice.apply(loaders, [0, loaders.length]);
while(temp.length){
temp.shift().call();
};
};
loaders.unshift = function() {
Array.prototype.unshift.apply(loaders, argsToArray(arguments));
require.ready(runLoaders);
};
loaders.splice = function() {
Array.prototype.splice.apply(loaders, argsToArray(arguments));
require.ready(runLoaders);
};
//TODO: put unload handling in a separate module
var unloaders = dojo._unloaders = [];
dojo.unloaded = function(){
while(unloaders.length){
unloaders.pop().call();
}
};
//TODO: kill this low-value function when it is exorcised from dojo
dojo._onto = function(arr, obj, fn){
arr.push(fn ? simpleHitch(obj, fn) : obj);
};
//TODO: kill this when the bootstrap is rewritten to not include DOMContentLoaded detection
// (it should probably be just a module) for now, just sink the detection; leverage the
// AMD loaders to handle DOMContentLoaded detection
dojo._modulesLoaded = function(){};
//TODO: kill this when we understand its purpose relative to AMD
dojo.loadInit = function(init){
init();
};
var amdModuleName= function(moduleName){
return moduleName.replace(/\./g, "/");
};
dojo.getL10nName = function(moduleName, bundleName, locale){
locale = locale ? locale.toLowerCase() : dojo.locale;
moduleName = "i18n!" + amdModuleName(moduleName);
return (/root/i.test(locale)) ?
(moduleName + "/nls/" + bundleName) :
(moduleName + "/nls/" + locale + "/" + bundleName);
};
dojo.requireLocalization = function(moduleName, bundleName, locale){
// NOTE: locales other than the locale specified in dojo.locale need to be specifically
// declared as a module dependency when using AMD.
if(require.vendor!="altoviso.com"){
locale = !locale || locale.toLowerCase() === dojo.locale ? "root" : locale;
}
return require(dojo.getL10nName(moduleName, bundleName, locale));
};
dojo.i18n= {
getLocalization: dojo.requireLocalization,
normalizeLocale: function(locale){
var result = locale ? locale.toLowerCase() : dojo.locale;
if(result == "root"){
result = "ROOT";
}
return result;
}
};
//TODO: dojo._Url seems rarely used and long to be part of the boostrap; consider moving
//note: this routine cut and paste from dojo/_base/_loader/loader
var
ore = new RegExp("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$"),
ire = new RegExp("^((([^\\[:]+):)?([^@]+)@)?(\\[([^\\]]+)\\]|([^\\[:]*))(:([0-9]+))?$");
dojo._Url = function(){
var n = null,
_a = arguments,
uri = [_a[0]];
// resolve uri components relative to each other
for(var i = 1; i<_a.length; i++){
if(!_a[i]){ continue; }
// Safari doesn't support this.constructor so we have to be explicit
// FIXME: Tracked (and fixed) in Webkit bug 3537.
// http://bugs.webkit.org/show_bug.cgi?id=3537
var relobj = new dojo._Url(_a[i]+""),
uriobj = new dojo._Url(uri[0]+"");
if(
relobj.path == "" &&
!relobj.scheme &&
!relobj.authority &&
!relobj.query
){
if(relobj.fragment != n){
uriobj.fragment = relobj.fragment;
}
relobj = uriobj;
}else if(!relobj.scheme){
relobj.scheme = uriobj.scheme;
if(!relobj.authority){
relobj.authority = uriobj.authority;
if(relobj.path.charAt(0) != "/"){
var path = uriobj.path.substring(0,
uriobj.path.lastIndexOf("/") + 1) + relobj.path;
var segs = path.split("/");
for(var j = 0; j < segs.length; j++){
if(segs[j] == "."){
// flatten "./" references
if(j == segs.length - 1){
segs[j] = "";
}else{
segs.splice(j, 1);
j--;
}
}else if(j > 0 && !(j == 1 && segs[0] == "") &&
segs[j] == ".." && segs[j-1] != ".."){
// flatten "../" references
if(j == (segs.length - 1)){
segs.splice(j, 1);
segs[j - 1] = "";
}else{
segs.splice(j - 1, 2);
j -= 2;
}
}
}
relobj.path = segs.join("/");
}
}
}
uri = [];
if(relobj.scheme){
uri.push(relobj.scheme, ":");
}
if(relobj.authority){
uri.push("//", relobj.authority);
}
uri.push(relobj.path);
if(relobj.query){
uri.push("?", relobj.query);
}
if(relobj.fragment){
uri.push("#", relobj.fragment);
}
}
this.uri = uri.join("");
// break the uri into its main components
var r = this.uri.match(ore);
this.scheme = r[2] || (r[1] ? "" : n);
this.authority = r[4] || (r[3] ? "" : n);
this.path = r[5]; // can never be undefined
this.query = r[7] || (r[6] ? "" : n);
this.fragment = r[9] || (r[8] ? "" : n);
if(this.authority != n){
// server based naming authority
r = this.authority.match(ire);
this.user = r[3] || n;
this.password = r[4] || n;
this.host = r[6] || r[7]; // ipv6 || ipv4
this.port = r[9] || n;
}
};
dojo._Url.prototype.toString = function(){ return this.uri; };
dojo.moduleUrl = function(module, url){
if(!module){
//TODO: don't understand why this would ever be so, but that's the logic in loader
return null;
}
module = amdModuleName(module) + (url ? ("/" + url) : "");
var
type= "",
match= module.match(/(.+)(\.[^\/]*)$/);
if (match) {
module= match[1];
type= match[2];
}
return new dojo._Url(require.nameToUrl(module, type)); // dojo._Url
};
return dojo;
});