diff options
Diffstat (limited to 'lib/dojo/lib/backCompat.js')
-rw-r--r-- | lib/dojo/lib/backCompat.js | 283 |
1 files changed, 283 insertions, 0 deletions
diff --git a/lib/dojo/lib/backCompat.js b/lib/dojo/lib/backCompat.js new file mode 100644 index 000000000..101f4e520 --- /dev/null +++ b/lib/dojo/lib/backCompat.js @@ -0,0 +1,283 @@ +/* + 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; +}); |