]>
Commit | Line | Data |
---|---|---|
81bea17a AD |
1 | /* |
2 | Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. | |
3 | Available via Academic Free License >= 2.1 OR the modified BSD license. | |
4 | see: http://dojotoolkit.org/license for details | |
5 | */ | |
6 | ||
7 | ||
8 | // AMD module id = dojo/lib/backCompat | |
9 | // | |
10 | // This module defines those dojo properties/methods that are defined by | |
11 | // dojo/_base/_loader/loader and are still needed when loading with and | |
12 | // AMD loader (when loading with an AMD loader, dojo/_base/_loader/loader | |
13 | // is never loaded). | |
14 | // | |
15 | // note: this module is relevant only when loading dojo with an AMD loader; | |
16 | // it is never evaluated otherwise. | |
17 | ||
18 | define(["require", "dojo/_base/_loader/bootstrap"], function(require, dojo){ | |
19 | // the following dojo properties do not exist in the AMD-loaded version of dojo 1.x: | |
20 | var names= [ | |
21 | "_moduleHasPrefix", | |
22 | "_loadPath", | |
23 | "_loadUri", | |
24 | "_loadUriAndCheck", | |
25 | "loaded", | |
26 | "_callLoaded", | |
27 | "_getModuleSymbols", | |
28 | "_loadModule", | |
29 | "require", | |
30 | "provide", | |
31 | "platformRequire", | |
32 | "requireIf", | |
33 | "requireAfterIf", | |
34 | "registerModulePath" | |
35 | ], i, name; | |
36 | for(i = 0; i<names.length;){ | |
37 | name = names[i++]; | |
38 | dojo[name] = (function(name) { | |
39 | return function(){ | |
40 | console.warn("dojo." + name + " not available when using an AMD loader."); | |
41 | }; | |
42 | })(name); | |
43 | } | |
44 | ||
45 | // define dojo.addOnLoad in terms of the DOMContentLoaded detection available from the AMD loaders | |
46 | // (requirejs and bdBuild). Note that the behavior of this feature is slightly different compared to the dojo | |
47 | // v1.x sync loader. There, the onload queue is fired upon detecting both DOMContentLoaded *and* all | |
48 | // demanded modules have arrived. It is impossible to simulate this behavior with requirejs since it does | |
49 | // not publish its internal status (it is possible with bdLoad). | |
50 | // TODO: consider taking ownership of this API back from the loader. | |
51 | // TODO: consider requesting requirejs publish more enough internal state to determine if all demanded | |
52 | // modules have been defined. | |
53 | var | |
54 | argsToArray = function(args) { | |
55 | var result = [], i; | |
56 | for(i = 0; i<args.length;){ | |
57 | result.push(args[i++]); | |
58 | } | |
59 | return result; | |
60 | }, | |
61 | ||
62 | simpleHitch = function(context, callback){ | |
63 | if(callback){ | |
64 | return (typeof callback=="string") ? | |
65 | function(){context[callback]();} : | |
66 | function(){callback.call(context);}; | |
67 | }else{ | |
68 | return context; | |
69 | } | |
70 | }; | |
71 | dojo.ready = dojo.addOnLoad = function(context, callback){ | |
72 | require.ready(callback ? simpleHitch(context, callback) : context); | |
73 | }; | |
74 | dojo.addOnLoad(function() { | |
75 | dojo.postLoad = dojo.config.afterOnLoad = true; | |
76 | }); | |
77 | var dca = dojo.config.addOnLoad; | |
78 | if(dca){ | |
79 | dojo.addOnLoad[(dca instanceof Array ? "apply" : "call")](dojo, dca); | |
80 | } | |
81 | ||
82 | // TODO: in the dojo 1.x sync loader the array dojo._loaders holds the queue of callbacks to be executed | |
83 | // upon DOMContentLoaded. This queue is manipulated directly by dojo/uacss, dojo/parser, dijit/_base/wia | |
84 | // and others (at least in dojox). This is also impossible to simulate universally across all AMD loaders. | |
85 | // The following will at least accept client code accessing dojo._loaders , dojo._loaders.unshift, and | |
86 | // dojo._loaders.splice--which is all that exists in the current dojo/dijit code stacks. | |
87 | var | |
88 | loaders = dojo._loaders = [], | |
89 | runLoaders = function(){ | |
90 | var temp= loaders.slice(0); | |
91 | Array.prototype.splice.apply(loaders, [0, loaders.length]); | |
92 | while(temp.length){ | |
93 | temp.shift().call(); | |
94 | }; | |
95 | }; | |
96 | loaders.unshift = function() { | |
97 | Array.prototype.unshift.apply(loaders, argsToArray(arguments)); | |
98 | require.ready(runLoaders); | |
99 | }; | |
100 | loaders.splice = function() { | |
101 | Array.prototype.splice.apply(loaders, argsToArray(arguments)); | |
102 | require.ready(runLoaders); | |
103 | }; | |
104 | ||
105 | //TODO: put unload handling in a separate module | |
106 | var unloaders = dojo._unloaders = []; | |
107 | dojo.unloaded = function(){ | |
108 | while(unloaders.length){ | |
109 | unloaders.pop().call(); | |
110 | } | |
111 | }; | |
112 | ||
113 | //TODO: kill this low-value function when it is exorcised from dojo | |
114 | dojo._onto = function(arr, obj, fn){ | |
115 | arr.push(fn ? simpleHitch(obj, fn) : obj); | |
116 | }; | |
117 | ||
118 | //TODO: kill this when the bootstrap is rewritten to not include DOMContentLoaded detection | |
119 | // (it should probably be just a module) for now, just sink the detection; leverage the | |
120 | // AMD loaders to handle DOMContentLoaded detection | |
121 | dojo._modulesLoaded = function(){}; | |
122 | ||
123 | //TODO: kill this when we understand its purpose relative to AMD | |
124 | dojo.loadInit = function(init){ | |
125 | init(); | |
126 | }; | |
127 | ||
128 | var amdModuleName= function(moduleName){ | |
129 | return moduleName.replace(/\./g, "/"); | |
130 | }; | |
131 | ||
132 | dojo.getL10nName = function(moduleName, bundleName, locale){ | |
133 | locale = locale ? locale.toLowerCase() : dojo.locale; | |
134 | moduleName = "i18n!" + amdModuleName(moduleName); | |
135 | return (/root/i.test(locale)) ? | |
136 | (moduleName + "/nls/" + bundleName) : | |
137 | (moduleName + "/nls/" + locale + "/" + bundleName); | |
138 | }; | |
139 | ||
140 | dojo.requireLocalization = function(moduleName, bundleName, locale){ | |
141 | // NOTE: locales other than the locale specified in dojo.locale need to be specifically | |
142 | // declared as a module dependency when using AMD. | |
143 | if(require.vendor!="altoviso.com"){ | |
144 | locale = !locale || locale.toLowerCase() === dojo.locale ? "root" : locale; | |
145 | } | |
146 | return require(dojo.getL10nName(moduleName, bundleName, locale)); | |
147 | }; | |
148 | ||
149 | dojo.i18n= { | |
150 | getLocalization: dojo.requireLocalization, | |
151 | normalizeLocale: function(locale){ | |
152 | var result = locale ? locale.toLowerCase() : dojo.locale; | |
153 | if(result == "root"){ | |
154 | result = "ROOT"; | |
155 | } | |
156 | return result; | |
157 | } | |
158 | }; | |
159 | ||
160 | //TODO: dojo._Url seems rarely used and long to be part of the boostrap; consider moving | |
161 | //note: this routine cut and paste from dojo/_base/_loader/loader | |
162 | var | |
163 | ore = new RegExp("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$"), | |
164 | ire = new RegExp("^((([^\\[:]+):)?([^@]+)@)?(\\[([^\\]]+)\\]|([^\\[:]*))(:([0-9]+))?$"); | |
165 | dojo._Url = function(){ | |
166 | var n = null, | |
167 | _a = arguments, | |
168 | uri = [_a[0]]; | |
169 | // resolve uri components relative to each other | |
170 | for(var i = 1; i<_a.length; i++){ | |
171 | if(!_a[i]){ continue; } | |
172 | ||
173 | // Safari doesn't support this.constructor so we have to be explicit | |
174 | // FIXME: Tracked (and fixed) in Webkit bug 3537. | |
175 | // http://bugs.webkit.org/show_bug.cgi?id=3537 | |
176 | var relobj = new dojo._Url(_a[i]+""), | |
177 | uriobj = new dojo._Url(uri[0]+""); | |
178 | ||
179 | if( | |
180 | relobj.path == "" && | |
181 | !relobj.scheme && | |
182 | !relobj.authority && | |
183 | !relobj.query | |
184 | ){ | |
185 | if(relobj.fragment != n){ | |
186 | uriobj.fragment = relobj.fragment; | |
187 | } | |
188 | relobj = uriobj; | |
189 | }else if(!relobj.scheme){ | |
190 | relobj.scheme = uriobj.scheme; | |
191 | ||
192 | if(!relobj.authority){ | |
193 | relobj.authority = uriobj.authority; | |
194 | ||
195 | if(relobj.path.charAt(0) != "/"){ | |
196 | var path = uriobj.path.substring(0, | |
197 | uriobj.path.lastIndexOf("/") + 1) + relobj.path; | |
198 | ||
199 | var segs = path.split("/"); | |
200 | for(var j = 0; j < segs.length; j++){ | |
201 | if(segs[j] == "."){ | |
202 | // flatten "./" references | |
203 | if(j == segs.length - 1){ | |
204 | segs[j] = ""; | |
205 | }else{ | |
206 | segs.splice(j, 1); | |
207 | j--; | |
208 | } | |
209 | }else if(j > 0 && !(j == 1 && segs[0] == "") && | |
210 | segs[j] == ".." && segs[j-1] != ".."){ | |
211 | // flatten "../" references | |
212 | if(j == (segs.length - 1)){ | |
213 | segs.splice(j, 1); | |
214 | segs[j - 1] = ""; | |
215 | }else{ | |
216 | segs.splice(j - 1, 2); | |
217 | j -= 2; | |
218 | } | |
219 | } | |
220 | } | |
221 | relobj.path = segs.join("/"); | |
222 | } | |
223 | } | |
224 | } | |
225 | ||
226 | uri = []; | |
227 | if(relobj.scheme){ | |
228 | uri.push(relobj.scheme, ":"); | |
229 | } | |
230 | if(relobj.authority){ | |
231 | uri.push("//", relobj.authority); | |
232 | } | |
233 | uri.push(relobj.path); | |
234 | if(relobj.query){ | |
235 | uri.push("?", relobj.query); | |
236 | } | |
237 | if(relobj.fragment){ | |
238 | uri.push("#", relobj.fragment); | |
239 | } | |
240 | } | |
241 | ||
242 | this.uri = uri.join(""); | |
243 | ||
244 | // break the uri into its main components | |
245 | var r = this.uri.match(ore); | |
246 | ||
247 | this.scheme = r[2] || (r[1] ? "" : n); | |
248 | this.authority = r[4] || (r[3] ? "" : n); | |
249 | this.path = r[5]; // can never be undefined | |
250 | this.query = r[7] || (r[6] ? "" : n); | |
251 | this.fragment = r[9] || (r[8] ? "" : n); | |
252 | ||
253 | if(this.authority != n){ | |
254 | // server based naming authority | |
255 | r = this.authority.match(ire); | |
256 | ||
257 | this.user = r[3] || n; | |
258 | this.password = r[4] || n; | |
259 | this.host = r[6] || r[7]; // ipv6 || ipv4 | |
260 | this.port = r[9] || n; | |
261 | } | |
262 | }; | |
263 | ||
264 | dojo._Url.prototype.toString = function(){ return this.uri; }; | |
265 | ||
266 | dojo.moduleUrl = function(module, url){ | |
267 | if(!module){ | |
268 | //TODO: don't understand why this would ever be so, but that's the logic in loader | |
269 | return null; | |
270 | } | |
271 | module = amdModuleName(module) + (url ? ("/" + url) : ""); | |
272 | var | |
273 | type= "", | |
274 | match= module.match(/(.+)(\.[^\/]*)$/); | |
275 | if (match) { | |
276 | module= match[1]; | |
277 | type= match[2]; | |
278 | } | |
279 | return new dojo._Url(require.nameToUrl(module, type)); // dojo._Url | |
280 | }; | |
281 | ||
282 | return dojo; | |
283 | }); |