requirejs-rails 0.8.2 → 0.9.0
Sign up to get free protection for your applications and to get access to all the features.
- data/CHANGELOG.md +6 -0
- data/Gemfile.lock +1 -1
- data/README.md +6 -1
- data/app/helpers/requirejs_helper.rb +1 -10
- data/bin/r.js +6428 -3514
- data/lib/requirejs/rails/config.rb +2 -9
- data/lib/requirejs/rails/version.rb +2 -2
- data/test/requirejs-rails_test.rb +3 -23
- data/vendor/assets/javascripts/almond.js +84 -47
- data/vendor/assets/javascripts/require.js +1378 -1404
- metadata +10 -11
- data/vendor/assets/javascripts/order.js +0 -189
@@ -40,6 +40,7 @@ module Requirejs::Rails
|
|
40
40
|
paths
|
41
41
|
priority
|
42
42
|
scriptType
|
43
|
+
shim
|
43
44
|
urlArgs
|
44
45
|
waitSeconds
|
45
46
|
xhtml
|
@@ -75,6 +76,7 @@ module Requirejs::Rails
|
|
75
76
|
pragmas
|
76
77
|
pragmasOnSave
|
77
78
|
preserveLicenseComments
|
79
|
+
shim
|
78
80
|
skipModuleInsertion
|
79
81
|
skipPragmas
|
80
82
|
uglify
|
@@ -108,7 +110,6 @@ module Requirejs::Rails
|
|
108
110
|
mod['name'] = 'almond'
|
109
111
|
mod['include'] = name
|
110
112
|
end
|
111
|
-
self.rewrite_urls_in_paths self[:build_config]
|
112
113
|
end
|
113
114
|
self[:build_config]
|
114
115
|
end
|
@@ -150,13 +151,5 @@ module Requirejs::Rails
|
|
150
151
|
accum || (matcher =~ asset)
|
151
152
|
end ? true : false
|
152
153
|
end
|
153
|
-
|
154
|
-
def rewrite_urls_in_paths(cfg)
|
155
|
-
if cfg.has_key? 'paths'
|
156
|
-
cfg['paths'] = cfg['paths'].each_with_object({}) do |(k, v), h|
|
157
|
-
h[k] = (v =~ /^https?:/) ? 'empty:' : v
|
158
|
-
end
|
159
|
-
end
|
160
|
-
end
|
161
154
|
end
|
162
155
|
end
|
@@ -85,27 +85,7 @@ class RequirejsRailsConfigTest < ActiveSupport::TestCase
|
|
85
85
|
assert_nil @cfg.build_config['priority']
|
86
86
|
end
|
87
87
|
|
88
|
-
|
89
|
-
@cfg.user_config = { 'paths' =>
|
90
|
-
{
|
91
|
-
'jquery' => 'http://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js',
|
92
|
-
'jqueryssl' => 'https://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js'
|
93
|
-
}
|
94
|
-
}
|
95
|
-
assert_equal 'empty:', @cfg.build_config['paths']['jquery']
|
96
|
-
assert_equal 'empty:', @cfg.build_config['paths']['jqueryssl']
|
97
|
-
end
|
98
|
-
|
99
|
-
test "build_config should not modify non-urls in paths" do
|
100
|
-
@cfg.user_config = { 'paths' =>
|
101
|
-
{
|
102
|
-
'foo' => 'components/foo'
|
103
|
-
}
|
104
|
-
}
|
105
|
-
assert_equal 'components/foo', @cfg.build_config['paths']['foo']
|
106
|
-
end
|
107
|
-
|
108
|
-
## Almond-specific tests
|
88
|
+
## Almond tests
|
109
89
|
test "build_config with almond should accept one module" do
|
110
90
|
@cfg.loader = :almond
|
111
91
|
@cfg.user_config = { 'modules' => [ { 'name' => 'foo' } ] }
|
@@ -149,7 +129,7 @@ class RequirejsHelperTest < ActionView::TestCase
|
|
149
129
|
|
150
130
|
test "requirejs_include_tag_with_param" do
|
151
131
|
render :text => wrap(requirejs_include_tag("application"))
|
152
|
-
assert_select "script:last-of-type[src^=/javascripts/require.js][data-main^=/javascripts/application
|
132
|
+
assert_select "script:last-of-type[src^=/javascripts/require.js][data-main^=/javascripts/application]", :count => 1
|
153
133
|
end
|
154
134
|
|
155
135
|
test "requirejs_include_tag_with_block" do
|
@@ -158,7 +138,7 @@ class RequirejsHelperTest < ActionView::TestCase
|
|
158
138
|
end
|
159
139
|
|
160
140
|
render :text => wrap(requirejs_include_tag("application", &test_block))
|
161
|
-
assert_select "script:last-of-type[src^=/javascripts/require.js][data-main^=/javascripts/application
|
141
|
+
assert_select "script:last-of-type[src^=/javascripts/require.js][data-main^=/javascripts/application]", :count => 1
|
162
142
|
assert_select "script:last-of-type[src^=/javascripts/require.js][data-class^=TestController]", :count => 1
|
163
143
|
end
|
164
144
|
|
@@ -1,25 +1,22 @@
|
|
1
1
|
/**
|
2
|
-
* almond 0.
|
2
|
+
* almond 0.1.1 Copyright (c) 2011, The Dojo Foundation All Rights Reserved.
|
3
3
|
* Available via the MIT or new BSD license.
|
4
4
|
* see: http://github.com/jrburke/almond for details
|
5
5
|
*/
|
6
|
-
|
6
|
+
//Going sloppy to avoid 'use strict' string cost, but strict practices should
|
7
|
+
//be followed.
|
8
|
+
/*jslint sloppy: true */
|
7
9
|
/*global setTimeout: false */
|
8
10
|
|
9
11
|
var requirejs, require, define;
|
10
12
|
(function (undef) {
|
11
|
-
|
12
13
|
var defined = {},
|
13
14
|
waiting = {},
|
15
|
+
config = {},
|
16
|
+
defining = {},
|
14
17
|
aps = [].slice,
|
15
18
|
main, req;
|
16
19
|
|
17
|
-
if (typeof define === "function") {
|
18
|
-
//If a define is already in play via another AMD loader,
|
19
|
-
//do not overwrite.
|
20
|
-
return;
|
21
|
-
}
|
22
|
-
|
23
20
|
/**
|
24
21
|
* Given a relative module name, like ./something, normalize it to
|
25
22
|
* a real name that can be mapped to a path.
|
@@ -29,6 +26,11 @@ var requirejs, require, define;
|
|
29
26
|
* @returns {String} normalized name
|
30
27
|
*/
|
31
28
|
function normalize(name, baseName) {
|
29
|
+
var baseParts = baseName && baseName.split("/"),
|
30
|
+
map = config.map,
|
31
|
+
starMap = (map && map['*']) || {},
|
32
|
+
nameParts, nameSegment, mapValue, foundMap, i, j, part;
|
33
|
+
|
32
34
|
//Adjust any relative paths.
|
33
35
|
if (name && name.charAt(0) === ".") {
|
34
36
|
//If have a base name, try to normalize against it,
|
@@ -40,13 +42,11 @@ var requirejs, require, define;
|
|
40
42
|
//module. For instance, baseName of "one/two/three", maps to
|
41
43
|
//"one/two/three.js", but we want the directory, "one/two" for
|
42
44
|
//this normalization.
|
43
|
-
|
44
|
-
baseName = baseName.slice(0, baseName.length - 1);
|
45
|
+
baseParts = baseParts.slice(0, baseParts.length - 1);
|
45
46
|
|
46
|
-
name =
|
47
|
+
name = baseParts.concat(name.split("/"));
|
47
48
|
|
48
49
|
//start trimDots
|
49
|
-
var i, part;
|
50
50
|
for (i = 0; (part = name[i]); i++) {
|
51
51
|
if (part === ".") {
|
52
52
|
name.splice(i, 1);
|
@@ -59,7 +59,7 @@ var requirejs, require, define;
|
|
59
59
|
//no path mapping for a path starting with '..'.
|
60
60
|
//This can still fail, but catches the most reasonable
|
61
61
|
//uses of ..
|
62
|
-
|
62
|
+
return true;
|
63
63
|
} else if (i > 0) {
|
64
64
|
name.splice(i - 1, 2);
|
65
65
|
i -= 2;
|
@@ -71,6 +71,43 @@ var requirejs, require, define;
|
|
71
71
|
name = name.join("/");
|
72
72
|
}
|
73
73
|
}
|
74
|
+
|
75
|
+
//Apply map config if available.
|
76
|
+
if ((baseParts || starMap) && map) {
|
77
|
+
nameParts = name.split('/');
|
78
|
+
|
79
|
+
for (i = nameParts.length; i > 0; i -= 1) {
|
80
|
+
nameSegment = nameParts.slice(0, i).join("/");
|
81
|
+
|
82
|
+
if (baseParts) {
|
83
|
+
//Find the longest baseName segment match in the config.
|
84
|
+
//So, do joins on the biggest to smallest lengths of baseParts.
|
85
|
+
for (j = baseParts.length; j > 0; j -= 1) {
|
86
|
+
mapValue = map[baseParts.slice(0, j).join('/')];
|
87
|
+
|
88
|
+
//baseName segment has config, find if it has one for
|
89
|
+
//this name.
|
90
|
+
if (mapValue) {
|
91
|
+
mapValue = mapValue[nameSegment];
|
92
|
+
if (mapValue) {
|
93
|
+
//Match, update name to the new value.
|
94
|
+
foundMap = mapValue;
|
95
|
+
break;
|
96
|
+
}
|
97
|
+
}
|
98
|
+
}
|
99
|
+
}
|
100
|
+
|
101
|
+
foundMap = foundMap || starMap[nameSegment];
|
102
|
+
|
103
|
+
if (foundMap) {
|
104
|
+
nameParts.splice(0, i, foundMap);
|
105
|
+
name = nameParts.join('/');
|
106
|
+
break;
|
107
|
+
}
|
108
|
+
}
|
109
|
+
}
|
110
|
+
|
74
111
|
return name;
|
75
112
|
}
|
76
113
|
|
@@ -99,8 +136,13 @@ var requirejs, require, define;
|
|
99
136
|
if (waiting.hasOwnProperty(name)) {
|
100
137
|
var args = waiting[name];
|
101
138
|
delete waiting[name];
|
139
|
+
defining[name] = true;
|
102
140
|
main.apply(undef, args);
|
103
141
|
}
|
142
|
+
|
143
|
+
if (!defined.hasOwnProperty(name)) {
|
144
|
+
throw new Error('No ' + name);
|
145
|
+
}
|
104
146
|
return defined[name];
|
105
147
|
}
|
106
148
|
|
@@ -136,27 +178,27 @@ var requirejs, require, define;
|
|
136
178
|
};
|
137
179
|
}
|
138
180
|
|
181
|
+
function makeConfig(name) {
|
182
|
+
return function () {
|
183
|
+
return (config && config.config && config.config[name]) || {};
|
184
|
+
};
|
185
|
+
}
|
186
|
+
|
139
187
|
main = function (name, deps, callback, relName) {
|
140
188
|
var args = [],
|
141
189
|
usingExports,
|
142
|
-
cjsModule, depName,
|
190
|
+
cjsModule, depName, ret, map, i;
|
143
191
|
|
144
192
|
//Use name if no relName
|
145
|
-
|
146
|
-
relName = name;
|
147
|
-
}
|
193
|
+
relName = relName || name;
|
148
194
|
|
149
195
|
//Call the callback to define the module, if necessary.
|
150
196
|
if (typeof callback === 'function') {
|
151
197
|
|
152
|
-
//Default to require, exports, module if no deps if
|
153
|
-
//the factory arg has any arguments specified.
|
154
|
-
if (!deps.length && callback.length) {
|
155
|
-
deps = ['require', 'exports', 'module'];
|
156
|
-
}
|
157
|
-
|
158
198
|
//Pull out the defined dependencies and pass the ordered
|
159
199
|
//values to the callback.
|
200
|
+
//Default to [require, exports, module] if no deps
|
201
|
+
deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps;
|
160
202
|
for (i = 0; i < deps.length; i++) {
|
161
203
|
map = makeMap(deps[i], relName);
|
162
204
|
depName = map.f;
|
@@ -173,15 +215,16 @@ var requirejs, require, define;
|
|
173
215
|
cjsModule = args[i] = {
|
174
216
|
id: name,
|
175
217
|
uri: '',
|
176
|
-
exports: defined[name]
|
218
|
+
exports: defined[name],
|
219
|
+
config: makeConfig(name)
|
177
220
|
};
|
178
221
|
} else if (defined.hasOwnProperty(depName) || waiting.hasOwnProperty(depName)) {
|
179
222
|
args[i] = callDep(depName);
|
180
223
|
} else if (map.p) {
|
181
224
|
map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {});
|
182
225
|
args[i] = defined[depName];
|
183
|
-
} else {
|
184
|
-
throw name + ' missing ' + depName;
|
226
|
+
} else if (!defining[depName]) {
|
227
|
+
throw new Error(name + ' missing ' + depName);
|
185
228
|
}
|
186
229
|
}
|
187
230
|
|
@@ -191,9 +234,10 @@ var requirejs, require, define;
|
|
191
234
|
//If setting exports via "module" is in play,
|
192
235
|
//favor that over return value and exports. After that,
|
193
236
|
//favor a non-undefined return value over exports use.
|
194
|
-
if (cjsModule && cjsModule.exports !== undef
|
237
|
+
if (cjsModule && cjsModule.exports !== undef &&
|
238
|
+
cjsModule.exports !== defined[name]) {
|
195
239
|
defined[name] = cjsModule.exports;
|
196
|
-
} else if (!usingExports) {
|
240
|
+
} else if (ret !== undef || !usingExports) {
|
197
241
|
//Use the return value from the function.
|
198
242
|
defined[name] = ret;
|
199
243
|
}
|
@@ -205,9 +249,8 @@ var requirejs, require, define;
|
|
205
249
|
}
|
206
250
|
};
|
207
251
|
|
208
|
-
requirejs = req = function (deps, callback, relName, forceSync) {
|
252
|
+
requirejs = require = req = function (deps, callback, relName, forceSync) {
|
209
253
|
if (typeof deps === "string") {
|
210
|
-
|
211
254
|
//Just return the module wanted. In this scenario, the
|
212
255
|
//deps arg is the module name, and second arg (if passed)
|
213
256
|
//is just the relName.
|
@@ -215,17 +258,21 @@ var requirejs, require, define;
|
|
215
258
|
return callDep(makeMap(deps, callback).f);
|
216
259
|
} else if (!deps.splice) {
|
217
260
|
//deps is a config object, not an array.
|
218
|
-
|
261
|
+
config = deps;
|
219
262
|
if (callback.splice) {
|
220
263
|
//callback is an array, which means it is a dependency list.
|
221
264
|
//Adjust args if there are dependencies
|
222
265
|
deps = callback;
|
223
|
-
callback =
|
266
|
+
callback = relName;
|
267
|
+
relName = null;
|
224
268
|
} else {
|
225
|
-
deps =
|
269
|
+
deps = undef;
|
226
270
|
}
|
227
271
|
}
|
228
272
|
|
273
|
+
//Support require(['a'])
|
274
|
+
callback = callback || function () {};
|
275
|
+
|
229
276
|
//Simulate async callback;
|
230
277
|
if (forceSync) {
|
231
278
|
main(undef, deps, callback, relName);
|
@@ -242,17 +289,11 @@ var requirejs, require, define;
|
|
242
289
|
* Just drops the config on the floor, but returns req in case
|
243
290
|
* the config return value is used.
|
244
291
|
*/
|
245
|
-
req.config = function () {
|
292
|
+
req.config = function (cfg) {
|
293
|
+
config = cfg;
|
246
294
|
return req;
|
247
295
|
};
|
248
296
|
|
249
|
-
/**
|
250
|
-
* Export require as a global, but only if it does not already exist.
|
251
|
-
*/
|
252
|
-
if (!require) {
|
253
|
-
require = req;
|
254
|
-
}
|
255
|
-
|
256
297
|
define = function (name, deps, callback) {
|
257
298
|
|
258
299
|
//This module may not have dependencies
|
@@ -264,11 +305,7 @@ var requirejs, require, define;
|
|
264
305
|
deps = [];
|
265
306
|
}
|
266
307
|
|
267
|
-
|
268
|
-
waiting[name] = [name, deps, callback];
|
269
|
-
} else {
|
270
|
-
main(name, deps, callback);
|
271
|
-
}
|
308
|
+
waiting[name] = [name, deps, callback];
|
272
309
|
};
|
273
310
|
|
274
311
|
define.amd = {
|
@@ -1,54 +1,98 @@
|
|
1
1
|
/** vim: et:ts=4:sw=4:sts=4
|
2
|
-
* @license RequireJS
|
2
|
+
* @license RequireJS 2.0.2 Copyright (c) 2010-2012, The Dojo Foundation All Rights Reserved.
|
3
3
|
* Available via the MIT or new BSD license.
|
4
4
|
* see: http://github.com/jrburke/requirejs for details
|
5
5
|
*/
|
6
|
-
/*jslint
|
6
|
+
/*jslint regexp: true, nomen: true */
|
7
7
|
/*global window, navigator, document, importScripts, jQuery, setTimeout, opera */
|
8
8
|
|
9
9
|
var requirejs, require, define;
|
10
|
-
(function (
|
11
|
-
|
12
|
-
|
10
|
+
(function (global) {
|
11
|
+
'use strict';
|
12
|
+
|
13
|
+
var version = '2.0.2',
|
13
14
|
commentRegExp = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg,
|
14
|
-
cjsRequireRegExp = /require\(\s*["']([^'"\s]+)["']\s*\)/g,
|
15
|
-
currDirRegExp = /^\.\//,
|
15
|
+
cjsRequireRegExp = /require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
|
16
16
|
jsSuffixRegExp = /\.js$/,
|
17
|
+
currDirRegExp = /^\.\//,
|
17
18
|
ostring = Object.prototype.toString,
|
18
19
|
ap = Array.prototype,
|
19
20
|
aps = ap.slice,
|
20
21
|
apsp = ap.splice,
|
21
|
-
isBrowser = !!(typeof window !==
|
22
|
-
isWebWorker = !isBrowser && typeof importScripts !==
|
22
|
+
isBrowser = !!(typeof window !== 'undefined' && navigator && document),
|
23
|
+
isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
|
23
24
|
//PS3 indicates loaded and complete, but need to wait for complete
|
24
|
-
//specifically. Sequence is
|
25
|
-
// then
|
25
|
+
//specifically. Sequence is 'loading', 'loaded', execution,
|
26
|
+
// then 'complete'. The UA check is unfortunate, but not sure how
|
26
27
|
//to feature test w/o causing perf issues.
|
27
28
|
readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
|
28
29
|
/^complete$/ : /^(complete|loaded)$/,
|
29
|
-
defContextName =
|
30
|
+
defContextName = '_',
|
30
31
|
//Oh the tragedy, detecting opera. See the usage of isOpera for reason.
|
31
|
-
isOpera = typeof opera !==
|
32
|
-
empty = {},
|
32
|
+
isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
|
33
33
|
contexts = {},
|
34
|
+
cfg = {},
|
34
35
|
globalDefQueue = [],
|
35
|
-
interactiveScript = null,
|
36
|
-
checkLoadedDepth = 0,
|
37
36
|
useInteractive = false,
|
38
|
-
|
39
|
-
|
40
|
-
module: true,
|
41
|
-
exports: true
|
42
|
-
},
|
43
|
-
req, cfg = {}, currentlyAddingScript, s, head, baseElement, scripts, script,
|
44
|
-
src, subPath, mainScript, dataMain, globalI, ctx, jQueryCheck, checkLoadedTimeoutId;
|
37
|
+
req, s, head, baseElement, dataMain, src,
|
38
|
+
interactiveScript, currentlyAddingScript, mainScript, subPath;
|
45
39
|
|
46
40
|
function isFunction(it) {
|
47
|
-
return ostring.call(it) ===
|
41
|
+
return ostring.call(it) === '[object Function]';
|
48
42
|
}
|
49
43
|
|
50
44
|
function isArray(it) {
|
51
|
-
return ostring.call(it) ===
|
45
|
+
return ostring.call(it) === '[object Array]';
|
46
|
+
}
|
47
|
+
|
48
|
+
/**
|
49
|
+
* Helper function for iterating over an array. If the func returns
|
50
|
+
* a true value, it will break out of the loop.
|
51
|
+
*/
|
52
|
+
function each(ary, func) {
|
53
|
+
if (ary) {
|
54
|
+
var i;
|
55
|
+
for (i = 0; i < ary.length; i += 1) {
|
56
|
+
if (ary[i] && func(ary[i], i, ary)) {
|
57
|
+
break;
|
58
|
+
}
|
59
|
+
}
|
60
|
+
}
|
61
|
+
}
|
62
|
+
|
63
|
+
/**
|
64
|
+
* Helper function for iterating over an array backwards. If the func
|
65
|
+
* returns a true value, it will break out of the loop.
|
66
|
+
*/
|
67
|
+
function eachReverse(ary, func) {
|
68
|
+
if (ary) {
|
69
|
+
var i;
|
70
|
+
for (i = ary.length - 1; i > -1; i -= 1) {
|
71
|
+
if (ary[i] && func(ary[i], i, ary)) {
|
72
|
+
break;
|
73
|
+
}
|
74
|
+
}
|
75
|
+
}
|
76
|
+
}
|
77
|
+
|
78
|
+
function hasProp(obj, prop) {
|
79
|
+
return obj.hasOwnProperty(prop);
|
80
|
+
}
|
81
|
+
|
82
|
+
/**
|
83
|
+
* Cycles over properties in an object and calls a function for each
|
84
|
+
* property value. If the function returns a truthy value, then the
|
85
|
+
* iteration is stopped.
|
86
|
+
*/
|
87
|
+
function eachProp(obj, func) {
|
88
|
+
var prop;
|
89
|
+
for (prop in obj) {
|
90
|
+
if (obj.hasOwnProperty(prop)) {
|
91
|
+
if (func(obj[prop], prop)) {
|
92
|
+
break;
|
93
|
+
}
|
94
|
+
}
|
95
|
+
}
|
52
96
|
}
|
53
97
|
|
54
98
|
/**
|
@@ -58,13 +102,82 @@ var requirejs, require, define;
|
|
58
102
|
* Object.prototype names, but the uses of mixin here seem unlikely to
|
59
103
|
* trigger a problem related to that.
|
60
104
|
*/
|
61
|
-
function mixin(target, source, force) {
|
62
|
-
|
63
|
-
|
64
|
-
target
|
65
|
-
|
105
|
+
function mixin(target, source, force, deepStringMixin) {
|
106
|
+
if (source) {
|
107
|
+
eachProp(source, function (value, prop) {
|
108
|
+
if (force || !hasProp(target, prop)) {
|
109
|
+
if (deepStringMixin && typeof value !== 'string') {
|
110
|
+
if (!target[prop]) {
|
111
|
+
target[prop] = {};
|
112
|
+
}
|
113
|
+
mixin(target[prop], value, force, deepStringMixin);
|
114
|
+
} else {
|
115
|
+
target[prop] = value;
|
116
|
+
}
|
117
|
+
}
|
118
|
+
});
|
119
|
+
}
|
120
|
+
return target;
|
121
|
+
}
|
122
|
+
|
123
|
+
//Similar to Function.prototype.bind, but the 'this' object is specified
|
124
|
+
//first, since it is easier to read/figure out what 'this' will be.
|
125
|
+
function bind(obj, fn) {
|
126
|
+
return function () {
|
127
|
+
return fn.apply(obj, arguments);
|
128
|
+
};
|
129
|
+
}
|
130
|
+
|
131
|
+
function scripts() {
|
132
|
+
return document.getElementsByTagName('script');
|
133
|
+
}
|
134
|
+
|
135
|
+
//Allow getting a global that expressed in
|
136
|
+
//dot notation, like 'a.b.c'.
|
137
|
+
function getGlobal(value) {
|
138
|
+
if (!value) {
|
139
|
+
return value;
|
66
140
|
}
|
67
|
-
|
141
|
+
var g = global;
|
142
|
+
each(value.split('.'), function (part) {
|
143
|
+
g = g[part];
|
144
|
+
});
|
145
|
+
return g;
|
146
|
+
}
|
147
|
+
|
148
|
+
function makeContextModuleFunc(func, relMap, enableBuildCallback) {
|
149
|
+
return function () {
|
150
|
+
//A version of a require function that passes a moduleName
|
151
|
+
//value for items that may need to
|
152
|
+
//look up paths relative to the moduleName
|
153
|
+
var args = aps.call(arguments, 0), lastArg;
|
154
|
+
if (enableBuildCallback &&
|
155
|
+
isFunction((lastArg = args[args.length - 1]))) {
|
156
|
+
lastArg.__requireJsBuild = true;
|
157
|
+
}
|
158
|
+
args.push(relMap);
|
159
|
+
return func.apply(null, args);
|
160
|
+
};
|
161
|
+
}
|
162
|
+
|
163
|
+
function addRequireMethods(req, context, relMap) {
|
164
|
+
each([
|
165
|
+
['toUrl'],
|
166
|
+
['undef'],
|
167
|
+
['defined', 'requireDefined'],
|
168
|
+
['specified', 'requireSpecified']
|
169
|
+
], function (item) {
|
170
|
+
var prop = item[1] || item[0];
|
171
|
+
req[item[0]] = context ? makeContextModuleFunc(context[prop], relMap) :
|
172
|
+
//If no context, then use default context. Reference from
|
173
|
+
//contexts instead of early binding to default context, so
|
174
|
+
//that during builds, the latest instance of the default
|
175
|
+
//context with its config gets used.
|
176
|
+
function () {
|
177
|
+
var ctx = contexts[defContextName];
|
178
|
+
return ctx[prop].apply(ctx, arguments);
|
179
|
+
};
|
180
|
+
});
|
68
181
|
}
|
69
182
|
|
70
183
|
/**
|
@@ -75,128 +188,60 @@ var requirejs, require, define;
|
|
75
188
|
*
|
76
189
|
* @returns {Error}
|
77
190
|
*/
|
78
|
-
function makeError(id, msg, err) {
|
191
|
+
function makeError(id, msg, err, requireModules) {
|
79
192
|
var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id);
|
193
|
+
e.requireType = id;
|
194
|
+
e.requireModules = requireModules;
|
80
195
|
if (err) {
|
81
196
|
e.originalError = err;
|
82
197
|
}
|
83
198
|
return e;
|
84
199
|
}
|
85
200
|
|
86
|
-
|
87
|
-
* Used to set up package paths from a packagePaths or packages config object.
|
88
|
-
* @param {Object} pkgs the object to store the new package config
|
89
|
-
* @param {Array} currentPackages an array of packages to configure
|
90
|
-
* @param {String} [dir] a prefix dir to use.
|
91
|
-
*/
|
92
|
-
function configurePackageDir(pkgs, currentPackages, dir) {
|
93
|
-
var i, location, pkgObj;
|
94
|
-
|
95
|
-
for (i = 0; (pkgObj = currentPackages[i]); i++) {
|
96
|
-
pkgObj = typeof pkgObj === "string" ? { name: pkgObj } : pkgObj;
|
97
|
-
location = pkgObj.location;
|
98
|
-
|
99
|
-
//Add dir to the path, but avoid paths that start with a slash
|
100
|
-
//or have a colon (indicates a protocol)
|
101
|
-
if (dir && (!location || (location.indexOf("/") !== 0 && location.indexOf(":") === -1))) {
|
102
|
-
location = dir + "/" + (location || pkgObj.name);
|
103
|
-
}
|
104
|
-
|
105
|
-
//Create a brand new object on pkgs, since currentPackages can
|
106
|
-
//be passed in again, and config.pkgs is the internal transformed
|
107
|
-
//state for all package configs.
|
108
|
-
pkgs[pkgObj.name] = {
|
109
|
-
name: pkgObj.name,
|
110
|
-
location: location || pkgObj.name,
|
111
|
-
//Remove leading dot in main, so main paths are normalized,
|
112
|
-
//and remove any trailing .js, since different package
|
113
|
-
//envs have different conventions: some use a module name,
|
114
|
-
//some use a file name.
|
115
|
-
main: (pkgObj.main || "main")
|
116
|
-
.replace(currDirRegExp, '')
|
117
|
-
.replace(jsSuffixRegExp, '')
|
118
|
-
};
|
119
|
-
}
|
120
|
-
}
|
121
|
-
|
122
|
-
/**
|
123
|
-
* jQuery 1.4.3-1.5.x use a readyWait/ready() pairing to hold DOM
|
124
|
-
* ready callbacks, but jQuery 1.6 supports a holdReady() API instead.
|
125
|
-
* At some point remove the readyWait/ready() support and just stick
|
126
|
-
* with using holdReady.
|
127
|
-
*/
|
128
|
-
function jQueryHoldReady($, shouldHold) {
|
129
|
-
if ($.holdReady) {
|
130
|
-
$.holdReady(shouldHold);
|
131
|
-
} else if (shouldHold) {
|
132
|
-
$.readyWait += 1;
|
133
|
-
} else {
|
134
|
-
$.ready(true);
|
135
|
-
}
|
136
|
-
}
|
137
|
-
|
138
|
-
if (typeof define !== "undefined") {
|
201
|
+
if (typeof define !== 'undefined') {
|
139
202
|
//If a define is already in play via another AMD loader,
|
140
203
|
//do not overwrite.
|
141
204
|
return;
|
142
205
|
}
|
143
206
|
|
144
|
-
if (typeof requirejs !==
|
207
|
+
if (typeof requirejs !== 'undefined') {
|
145
208
|
if (isFunction(requirejs)) {
|
146
209
|
//Do not overwrite and existing requirejs instance.
|
147
210
|
return;
|
148
|
-
} else {
|
149
|
-
cfg = requirejs;
|
150
|
-
requirejs = undefined;
|
151
211
|
}
|
212
|
+
cfg = requirejs;
|
213
|
+
requirejs = undefined;
|
152
214
|
}
|
153
215
|
|
154
216
|
//Allow for a require config object
|
155
|
-
if (typeof require !==
|
217
|
+
if (typeof require !== 'undefined' && !isFunction(require)) {
|
156
218
|
//assume it is a config object.
|
157
219
|
cfg = require;
|
158
220
|
require = undefined;
|
159
221
|
}
|
160
222
|
|
161
|
-
/**
|
162
|
-
* Creates a new context for use in require and define calls.
|
163
|
-
* Handle most of the heavy lifting. Do not want to use an object
|
164
|
-
* with prototype here to avoid using "this" in require, in case it
|
165
|
-
* needs to be used in more super secure envs that do not want this.
|
166
|
-
* Also there should not be that many contexts in the page. Usually just
|
167
|
-
* one for the default context, but could be extra for multiversion cases
|
168
|
-
* or if a package needs a special context for a dependency that conflicts
|
169
|
-
* with the standard context.
|
170
|
-
*/
|
171
223
|
function newContext(contextName) {
|
172
|
-
var
|
173
|
-
config = {
|
224
|
+
var config = {
|
174
225
|
waitSeconds: 7,
|
175
|
-
baseUrl:
|
226
|
+
baseUrl: './',
|
176
227
|
paths: {},
|
177
228
|
pkgs: {},
|
178
|
-
|
229
|
+
shim: {}
|
179
230
|
},
|
231
|
+
registry = {},
|
232
|
+
undefEvents = {},
|
180
233
|
defQueue = [],
|
181
|
-
specified = {
|
182
|
-
"require": true,
|
183
|
-
"exports": true,
|
184
|
-
"module": true
|
185
|
-
},
|
186
|
-
urlMap = {},
|
187
234
|
defined = {},
|
188
|
-
loaded = {},
|
189
|
-
waiting = {},
|
190
|
-
waitAry = [],
|
191
235
|
urlFetched = {},
|
192
|
-
|
193
|
-
|
194
|
-
|
195
|
-
//
|
196
|
-
//
|
197
|
-
|
198
|
-
|
199
|
-
|
236
|
+
requireCounter = 1,
|
237
|
+
unnormalizedCounter = 1,
|
238
|
+
//Used to track the order in which modules
|
239
|
+
//should be executed, by the order they
|
240
|
+
//load. Important for consistent cycle resolution
|
241
|
+
//behavior.
|
242
|
+
waitAry = [],
|
243
|
+
inCheckLoaded, Module, context, handlers,
|
244
|
+
checkLoadedTimeoutId;
|
200
245
|
|
201
246
|
/**
|
202
247
|
* Trims the . and .. from an array of path segments.
|
@@ -209,11 +254,12 @@ var requirejs, require, define;
|
|
209
254
|
*/
|
210
255
|
function trimDots(ary) {
|
211
256
|
var i, part;
|
212
|
-
for (i = 0;
|
213
|
-
|
257
|
+
for (i = 0; ary[i]; i+= 1) {
|
258
|
+
part = ary[i];
|
259
|
+
if (part === '.') {
|
214
260
|
ary.splice(i, 1);
|
215
261
|
i -= 1;
|
216
|
-
} else if (part ===
|
262
|
+
} else if (part === '..') {
|
217
263
|
if (i === 1 && (ary[2] === '..' || ary[0] === '..')) {
|
218
264
|
//End of the line. Keep at least one non-dot
|
219
265
|
//path segment at the front so it can be mapped
|
@@ -236,13 +282,19 @@ var requirejs, require, define;
|
|
236
282
|
* @param {String} name the relative name
|
237
283
|
* @param {String} baseName a real name that the name arg is relative
|
238
284
|
* to.
|
285
|
+
* @param {Boolean} applyMap apply the map config to the value. Should
|
286
|
+
* only be done if this normalization is for a dependency ID.
|
239
287
|
* @returns {String} normalized name
|
240
288
|
*/
|
241
|
-
function normalize(name, baseName) {
|
242
|
-
var
|
289
|
+
function normalize(name, baseName, applyMap) {
|
290
|
+
var baseParts = baseName && baseName.split('/'),
|
291
|
+
map = config.map,
|
292
|
+
starMap = map && map['*'],
|
293
|
+
pkgName, pkgConfig, mapValue, nameParts, i, j, nameSegment,
|
294
|
+
foundMap;
|
243
295
|
|
244
296
|
//Adjust any relative paths.
|
245
|
-
if (name && name.charAt(0) ===
|
297
|
+
if (name && name.charAt(0) === '.') {
|
246
298
|
//If have a base name, try to normalize against it,
|
247
299
|
//otherwise, assume it is a top-level require that will
|
248
300
|
//be relative to baseUrl in the end.
|
@@ -250,36 +302,99 @@ var requirejs, require, define;
|
|
250
302
|
if (config.pkgs[baseName]) {
|
251
303
|
//If the baseName is a package name, then just treat it as one
|
252
304
|
//name to concat the name with.
|
253
|
-
|
305
|
+
baseParts = [baseName];
|
254
306
|
} else {
|
255
307
|
//Convert baseName to array, and lop off the last part,
|
256
|
-
//so that . matches that
|
257
|
-
//module. For instance, baseName of
|
258
|
-
//
|
308
|
+
//so that . matches that 'directory' and not name of the baseName's
|
309
|
+
//module. For instance, baseName of 'one/two/three', maps to
|
310
|
+
//'one/two/three.js', but we want the directory, 'one/two' for
|
259
311
|
//this normalization.
|
260
|
-
|
261
|
-
baseName = baseName.slice(0, baseName.length - 1);
|
312
|
+
baseParts = baseParts.slice(0, baseParts.length - 1);
|
262
313
|
}
|
263
314
|
|
264
|
-
name =
|
315
|
+
name = baseParts.concat(name.split('/'));
|
265
316
|
trimDots(name);
|
266
317
|
|
267
318
|
//Some use of packages may use a . path to reference the
|
268
|
-
//
|
319
|
+
//'main' module name, so normalize for that.
|
269
320
|
pkgConfig = config.pkgs[(pkgName = name[0])];
|
270
|
-
name = name.join(
|
321
|
+
name = name.join('/');
|
271
322
|
if (pkgConfig && name === pkgName + '/' + pkgConfig.main) {
|
272
323
|
name = pkgName;
|
273
324
|
}
|
274
|
-
} else if (name.indexOf(
|
325
|
+
} else if (name.indexOf('./') === 0) {
|
275
326
|
// No baseName, so this is ID is resolved relative
|
276
327
|
// to baseUrl, pull off the leading dot.
|
277
328
|
name = name.substring(2);
|
278
329
|
}
|
279
330
|
}
|
331
|
+
|
332
|
+
//Apply map config if available.
|
333
|
+
if (applyMap && (baseParts || starMap) && map) {
|
334
|
+
nameParts = name.split('/');
|
335
|
+
|
336
|
+
for (i = nameParts.length; i > 0; i -= 1) {
|
337
|
+
nameSegment = nameParts.slice(0, i).join('/');
|
338
|
+
|
339
|
+
if (baseParts) {
|
340
|
+
//Find the longest baseName segment match in the config.
|
341
|
+
//So, do joins on the biggest to smallest lengths of baseParts.
|
342
|
+
for (j = baseParts.length; j > 0; j -= 1) {
|
343
|
+
mapValue = map[baseParts.slice(0, j).join('/')];
|
344
|
+
|
345
|
+
//baseName segment has config, find if it has one for
|
346
|
+
//this name.
|
347
|
+
if (mapValue) {
|
348
|
+
mapValue = mapValue[nameSegment];
|
349
|
+
if (mapValue) {
|
350
|
+
//Match, update name to the new value.
|
351
|
+
foundMap = mapValue;
|
352
|
+
break;
|
353
|
+
}
|
354
|
+
}
|
355
|
+
}
|
356
|
+
}
|
357
|
+
|
358
|
+
if (!foundMap && starMap && starMap[nameSegment]) {
|
359
|
+
foundMap = starMap[nameSegment];
|
360
|
+
}
|
361
|
+
|
362
|
+
if (foundMap) {
|
363
|
+
nameParts.splice(0, i, foundMap);
|
364
|
+
name = nameParts.join('/');
|
365
|
+
break;
|
366
|
+
}
|
367
|
+
}
|
368
|
+
}
|
369
|
+
|
280
370
|
return name;
|
281
371
|
}
|
282
372
|
|
373
|
+
function removeScript(name) {
|
374
|
+
if (isBrowser) {
|
375
|
+
each(scripts(), function (scriptNode) {
|
376
|
+
if (scriptNode.getAttribute('data-requiremodule') === name &&
|
377
|
+
scriptNode.getAttribute('data-requirecontext') === context.contextName) {
|
378
|
+
scriptNode.parentNode.removeChild(scriptNode);
|
379
|
+
return true;
|
380
|
+
}
|
381
|
+
});
|
382
|
+
}
|
383
|
+
}
|
384
|
+
|
385
|
+
function hasPathFallback(id) {
|
386
|
+
var pathConfig = config.paths[id];
|
387
|
+
if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
|
388
|
+
removeScript(id);
|
389
|
+
//Pop off the first array value, since it failed, and
|
390
|
+
//retry
|
391
|
+
pathConfig.shift();
|
392
|
+
context.undef(id);
|
393
|
+
context.require([id]);
|
394
|
+
return true;
|
395
|
+
}
|
396
|
+
}
|
397
|
+
|
283
398
|
/**
|
284
399
|
* Creates a module mapping that includes plugin prefix, module
|
285
400
|
* name, and path. If parentModuleMap is provided it will
|
@@ -288,15 +403,28 @@ var requirejs, require, define;
|
|
288
403
|
* @param {String} name the module name
|
289
404
|
* @param {String} [parentModuleMap] parent module map
|
290
405
|
* for the module name, used to resolve relative names.
|
406
|
+
* @param {Boolean} isNormalized: is the ID already normalized.
|
407
|
+
* This is true if this call is done for a define() module ID.
|
408
|
+
* @param {Boolean} applyMap: apply the map config to the ID.
|
409
|
+
* Should only be true if this map is for a dependency.
|
291
410
|
*
|
292
411
|
* @returns {Object}
|
293
412
|
*/
|
294
|
-
function makeModuleMap(name, parentModuleMap) {
|
295
|
-
var index = name ? name.indexOf(
|
413
|
+
function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
|
414
|
+
var index = name ? name.indexOf('!') : -1,
|
296
415
|
prefix = null,
|
297
416
|
parentName = parentModuleMap ? parentModuleMap.name : null,
|
298
417
|
originalName = name,
|
299
|
-
|
418
|
+
isDefine = true,
|
419
|
+
normalizedName = '',
|
420
|
+
url, pluginModule, suffix;
|
421
|
+
|
422
|
+
//If no name, then it means it is a require call, generate an
|
423
|
+
//internal name.
|
424
|
+
if (!name) {
|
425
|
+
isDefine = false;
|
426
|
+
name = '_@r' + (requireCounter += 1);
|
427
|
+
}
|
300
428
|
|
301
429
|
if (index !== -1) {
|
302
430
|
prefix = name.substring(0, index);
|
@@ -304,1015 +432,947 @@ var requirejs, require, define;
|
|
304
432
|
}
|
305
433
|
|
306
434
|
if (prefix) {
|
307
|
-
prefix = normalize(prefix, parentName);
|
435
|
+
prefix = normalize(prefix, parentName, applyMap);
|
436
|
+
pluginModule = defined[prefix];
|
308
437
|
}
|
309
438
|
|
310
439
|
//Account for relative paths if there is a base name.
|
311
440
|
if (name) {
|
312
441
|
if (prefix) {
|
313
|
-
pluginModule = defined[prefix];
|
314
442
|
if (pluginModule && pluginModule.normalize) {
|
315
443
|
//Plugin is loaded, use its normalize method.
|
316
444
|
normalizedName = pluginModule.normalize(name, function (name) {
|
317
|
-
return normalize(name, parentName);
|
445
|
+
return normalize(name, parentName, applyMap);
|
318
446
|
});
|
319
447
|
} else {
|
320
|
-
normalizedName = normalize(name, parentName);
|
448
|
+
normalizedName = normalize(name, parentName, applyMap);
|
321
449
|
}
|
322
450
|
} else {
|
323
451
|
//A regular module.
|
324
|
-
normalizedName = normalize(name, parentName);
|
325
|
-
|
326
|
-
url
|
327
|
-
|
328
|
-
|
329
|
-
|
330
|
-
|
331
|
-
|
332
|
-
|
333
|
-
|
334
|
-
|
335
|
-
|
336
|
-
//messy to support.
|
337
|
-
url = context.nameToUrl(name, null, parentModuleMap);
|
338
|
-
|
339
|
-
//Store the URL mapping for later.
|
340
|
-
urlMap[normalizedName] = url;
|
341
|
-
}
|
452
|
+
normalizedName = normalize(name, parentName, applyMap);
|
453
|
+
|
454
|
+
//Calculate url for the module, if it has a name.
|
455
|
+
//Use name here since nameToUrl also calls normalize,
|
456
|
+
//and for relative names that are outside the baseUrl
|
457
|
+
//this causes havoc. Was thinking of just removing
|
458
|
+
//parentModuleMap to avoid extra normalization, but
|
459
|
+
//normalize() still does a dot removal because of
|
460
|
+
//issue #142, so just pass in name here and redo
|
461
|
+
//the normalization. Paths outside baseUrl are just
|
462
|
+
//messy to support.
|
463
|
+
url = context.nameToUrl(name, null, parentModuleMap);
|
342
464
|
}
|
343
465
|
}
|
344
466
|
|
467
|
+
//If the id is a plugin id that cannot be determined if it needs
|
468
|
+
//normalization, stamp it with a unique ID so two matching relative
|
469
|
+
//ids that may conflict can be separate.
|
470
|
+
suffix = prefix && !pluginModule && !isNormalized ?
|
471
|
+
'_unnormalized' + (unnormalizedCounter += 1) :
|
472
|
+
'';
|
473
|
+
|
345
474
|
return {
|
346
475
|
prefix: prefix,
|
347
476
|
name: normalizedName,
|
348
477
|
parentMap: parentModuleMap,
|
478
|
+
unnormalized: !!suffix,
|
349
479
|
url: url,
|
350
480
|
originalName: originalName,
|
351
|
-
|
481
|
+
isDefine: isDefine,
|
482
|
+
id: (prefix ?
|
483
|
+
prefix + '!' + normalizedName :
|
484
|
+
normalizedName) + suffix
|
352
485
|
};
|
353
486
|
}
|
354
487
|
|
355
|
-
|
356
|
-
|
357
|
-
|
358
|
-
|
359
|
-
|
360
|
-
|
361
|
-
priorityName, i;
|
362
|
-
if (priorityWait) {
|
363
|
-
for (i = 0; (priorityName = priorityWait[i]); i++) {
|
364
|
-
if (!loaded[priorityName]) {
|
365
|
-
priorityDone = false;
|
366
|
-
break;
|
367
|
-
}
|
368
|
-
}
|
369
|
-
if (priorityDone) {
|
370
|
-
delete config.priorityWait;
|
371
|
-
}
|
488
|
+
function getModule(depMap) {
|
489
|
+
var id = depMap.id,
|
490
|
+
mod = registry[id];
|
491
|
+
|
492
|
+
if (!mod) {
|
493
|
+
mod = registry[id] = new context.Module(depMap);
|
372
494
|
}
|
373
|
-
return priorityDone;
|
374
|
-
}
|
375
495
|
|
376
|
-
|
377
|
-
return function () {
|
378
|
-
//A version of a require function that passes a moduleName
|
379
|
-
//value for items that may need to
|
380
|
-
//look up paths relative to the moduleName
|
381
|
-
var args = aps.call(arguments, 0), lastArg;
|
382
|
-
if (enableBuildCallback &&
|
383
|
-
isFunction((lastArg = args[args.length - 1]))) {
|
384
|
-
lastArg.__requireJsBuild = true;
|
385
|
-
}
|
386
|
-
args.push(relModuleMap);
|
387
|
-
return func.apply(null, args);
|
388
|
-
};
|
496
|
+
return mod;
|
389
497
|
}
|
390
498
|
|
391
|
-
|
392
|
-
|
393
|
-
|
394
|
-
* per module because of the implication of path mappings that may
|
395
|
-
* need to be relative to the module name.
|
396
|
-
*/
|
397
|
-
function makeRequire(relModuleMap, enableBuildCallback, altRequire) {
|
398
|
-
var modRequire = makeContextModuleFunc(altRequire || context.require, relModuleMap, enableBuildCallback);
|
399
|
-
|
400
|
-
mixin(modRequire, {
|
401
|
-
nameToUrl: makeContextModuleFunc(context.nameToUrl, relModuleMap),
|
402
|
-
toUrl: makeContextModuleFunc(context.toUrl, relModuleMap),
|
403
|
-
defined: makeContextModuleFunc(context.requireDefined, relModuleMap),
|
404
|
-
specified: makeContextModuleFunc(context.requireSpecified, relModuleMap),
|
405
|
-
isBrowser: req.isBrowser
|
406
|
-
});
|
407
|
-
return modRequire;
|
408
|
-
}
|
499
|
+
function on(depMap, name, fn) {
|
500
|
+
var id = depMap.id,
|
501
|
+
mod = registry[id];
|
409
502
|
|
410
|
-
|
411
|
-
|
412
|
-
|
413
|
-
|
414
|
-
|
415
|
-
|
416
|
-
|
503
|
+
if (hasProp(defined, id) &&
|
504
|
+
(!mod || mod.defineEmitComplete)) {
|
505
|
+
if (name === 'defined') {
|
506
|
+
fn(defined[id]);
|
507
|
+
}
|
508
|
+
} else {
|
509
|
+
getModule(depMap).on(name, fn);
|
510
|
+
}
|
417
511
|
}
|
418
512
|
|
419
|
-
function
|
420
|
-
var
|
421
|
-
|
422
|
-
map = manager.map,
|
423
|
-
fullName = map.fullName,
|
424
|
-
args = manager.deps,
|
425
|
-
listeners = manager.listeners,
|
426
|
-
execCb = config.requireExecCb || req.execCb,
|
427
|
-
cjsModule;
|
428
|
-
|
429
|
-
//Call the callback to define the module, if necessary.
|
430
|
-
if (cb && isFunction(cb)) {
|
431
|
-
if (config.catchError.define) {
|
432
|
-
try {
|
433
|
-
ret = execCb(fullName, manager.callback, args, defined[fullName]);
|
434
|
-
} catch (e) {
|
435
|
-
err = e;
|
436
|
-
}
|
437
|
-
} else {
|
438
|
-
ret = execCb(fullName, manager.callback, args, defined[fullName]);
|
439
|
-
}
|
513
|
+
function onError(err, errback) {
|
514
|
+
var ids = err.requireModules,
|
515
|
+
notified = false;
|
440
516
|
|
441
|
-
|
442
|
-
|
443
|
-
|
444
|
-
|
445
|
-
|
446
|
-
if (
|
447
|
-
|
448
|
-
|
449
|
-
|
450
|
-
|
451
|
-
|
452
|
-
//exports already set the defined value.
|
453
|
-
ret = defined[fullName];
|
454
|
-
} else {
|
455
|
-
//Use the return value from the function.
|
456
|
-
defined[fullName] = ret;
|
457
|
-
//If this module needed full execution in a build
|
458
|
-
//environment, mark that now.
|
459
|
-
if (needFullExec[fullName]) {
|
460
|
-
fullExec[fullName] = true;
|
517
|
+
if (errback) {
|
518
|
+
errback(err);
|
519
|
+
} else {
|
520
|
+
each(ids, function (id) {
|
521
|
+
var mod = registry[id];
|
522
|
+
if (mod) {
|
523
|
+
//Set error on module, so it skips timeout checks.
|
524
|
+
mod.error = err;
|
525
|
+
if (mod.events.error) {
|
526
|
+
notified = true;
|
527
|
+
mod.emit('error', err);
|
461
528
|
}
|
462
529
|
}
|
463
|
-
}
|
464
|
-
|
465
|
-
|
466
|
-
|
467
|
-
ret = defined[fullName] = cb;
|
468
|
-
|
469
|
-
//If this module needed full execution in a build
|
470
|
-
//environment, mark that now.
|
471
|
-
if (needFullExec[fullName]) {
|
472
|
-
fullExec[fullName] = true;
|
530
|
+
});
|
531
|
+
|
532
|
+
if (!notified) {
|
533
|
+
req.onError(err);
|
473
534
|
}
|
474
535
|
}
|
536
|
+
}
|
475
537
|
|
476
|
-
|
477
|
-
|
478
|
-
|
479
|
-
|
480
|
-
|
481
|
-
|
482
|
-
|
483
|
-
|
484
|
-
|
485
|
-
|
486
|
-
|
487
|
-
|
488
|
-
|
538
|
+
/**
|
539
|
+
* Internal method to transfer globalQueue items to this context's
|
540
|
+
* defQueue.
|
541
|
+
*/
|
542
|
+
function takeGlobalQueue() {
|
543
|
+
//Push all the globalDefQueue items into the context's defQueue
|
544
|
+
if (globalDefQueue.length) {
|
545
|
+
//Array splice in the values since the context code has a
|
546
|
+
//local var ref to defQueue, so cannot just reassign the one
|
547
|
+
//on context.
|
548
|
+
apsp.apply(defQueue,
|
549
|
+
[defQueue.length - 1, 0].concat(globalDefQueue));
|
550
|
+
globalDefQueue = [];
|
489
551
|
}
|
552
|
+
}
|
490
553
|
|
491
|
-
|
492
|
-
|
554
|
+
/**
|
555
|
+
* Helper function that creates a require function object to give to
|
556
|
+
* modules that ask for it as a dependency. It needs to be specific
|
557
|
+
* per module because of the implication of path mappings that may
|
558
|
+
* need to be relative to the module name.
|
559
|
+
*/
|
560
|
+
function makeRequire(mod, enableBuildCallback, altRequire) {
|
561
|
+
var relMap = mod && mod.map,
|
562
|
+
modRequire = makeContextModuleFunc(altRequire || context.require,
|
563
|
+
relMap,
|
564
|
+
enableBuildCallback);
|
493
565
|
|
494
|
-
|
495
|
-
|
496
|
-
if (req.onResourceLoad && !manager.placeholder) {
|
497
|
-
req.onResourceLoad(context, map, manager.depArray);
|
498
|
-
}
|
566
|
+
addRequireMethods(modRequire, context, relMap);
|
567
|
+
modRequire.isBrowser = isBrowser;
|
499
568
|
|
500
|
-
|
501
|
-
|
502
|
-
err.fileName || err.sourceURL;
|
503
|
-
errModuleTree = err.moduleTree;
|
504
|
-
err = makeError('defineerror', 'Error evaluating ' +
|
505
|
-
'module "' + fullName + '" at location "' +
|
506
|
-
errFile + '":\n' +
|
507
|
-
err + '\nfileName:' + errFile +
|
508
|
-
'\nlineNumber: ' + (err.lineNumber || err.line), err);
|
509
|
-
err.moduleName = fullName;
|
510
|
-
err.moduleTree = errModuleTree;
|
511
|
-
return req.onError(err);
|
512
|
-
}
|
569
|
+
return modRequire;
|
570
|
+
}
|
513
571
|
|
514
|
-
|
515
|
-
|
516
|
-
|
572
|
+
handlers = {
|
573
|
+
'require': function (mod) {
|
574
|
+
return makeRequire(mod);
|
575
|
+
},
|
576
|
+
'exports': function (mod) {
|
577
|
+
mod.usingExports = true;
|
578
|
+
if (mod.map.isDefine) {
|
579
|
+
return (mod.exports = defined[mod.map.id] = {});
|
580
|
+
}
|
581
|
+
},
|
582
|
+
'module': function (mod) {
|
583
|
+
return (mod.module = {
|
584
|
+
id: mod.map.id,
|
585
|
+
uri: mod.map.url,
|
586
|
+
config: function () {
|
587
|
+
return (config.config && config.config[mod.map.id]) || {};
|
588
|
+
},
|
589
|
+
exports: defined[mod.map.id]
|
590
|
+
});
|
517
591
|
}
|
592
|
+
};
|
518
593
|
|
519
|
-
|
520
|
-
|
594
|
+
function removeWaiting(id) {
|
595
|
+
//Clean up machinery used for waiting modules.
|
596
|
+
delete registry[id];
|
521
597
|
|
522
|
-
|
523
|
-
|
524
|
-
|
525
|
-
|
526
|
-
|
527
|
-
function makeArgCallback(manager, i) {
|
528
|
-
return function (value) {
|
529
|
-
//Only do the work if it has not been done
|
530
|
-
//already for a dependency. Cycle breaking
|
531
|
-
//logic in forceExec could mean this function
|
532
|
-
//is called more than once for a given dependency.
|
533
|
-
if (!manager.depDone[i]) {
|
534
|
-
manager.depDone[i] = true;
|
535
|
-
manager.deps[i] = value;
|
536
|
-
manager.depCount -= 1;
|
537
|
-
if (!manager.depCount) {
|
538
|
-
//All done, execute!
|
539
|
-
execManager(manager);
|
598
|
+
each(waitAry, function (mod, i) {
|
599
|
+
if (mod.map.id === id) {
|
600
|
+
waitAry.splice(i, 1);
|
601
|
+
if (!mod.defined) {
|
602
|
+
context.waitCount -= 1;
|
540
603
|
}
|
604
|
+
return true;
|
541
605
|
}
|
542
|
-
};
|
606
|
+
});
|
543
607
|
}
|
544
608
|
|
545
|
-
function
|
546
|
-
var
|
547
|
-
|
548
|
-
|
549
|
-
|
550
|
-
|
551
|
-
|
552
|
-
|
553
|
-
//No need to continue if the manager is already
|
554
|
-
//in the process of loading.
|
555
|
-
if (depManager.loading) {
|
609
|
+
function findCycle(mod, traced) {
|
610
|
+
var id = mod.map.id,
|
611
|
+
depArray = mod.depMaps,
|
612
|
+
foundModule;
|
613
|
+
|
614
|
+
//Do not bother with unitialized modules or not yet enabled
|
615
|
+
//modules.
|
616
|
+
if (!mod.inited) {
|
556
617
|
return;
|
557
618
|
}
|
558
|
-
depManager.loading = true;
|
559
619
|
|
560
|
-
|
561
|
-
|
562
|
-
|
563
|
-
|
564
|
-
execManager(depManager);
|
565
|
-
|
566
|
-
loaded[depManager.id] = true;
|
567
|
-
|
568
|
-
//The loading of this plugin
|
569
|
-
//might have placed other things
|
570
|
-
//in the paused queue. In particular,
|
571
|
-
//a loader plugin that depends on
|
572
|
-
//a different plugin loaded resource.
|
573
|
-
resume();
|
574
|
-
};
|
620
|
+
//Found the cycle.
|
621
|
+
if (traced[id]) {
|
622
|
+
return mod;
|
623
|
+
}
|
575
624
|
|
576
|
-
|
577
|
-
//context or how to "complete" the load.
|
578
|
-
load.fromText = function (moduleName, text) {
|
579
|
-
/*jslint evil: true */
|
580
|
-
var hasInteractive = useInteractive;
|
625
|
+
traced[id] = true;
|
581
626
|
|
582
|
-
|
583
|
-
|
584
|
-
|
627
|
+
//Trace through the dependencies.
|
628
|
+
each(depArray, function (depMap) {
|
629
|
+
var depId = depMap.id,
|
630
|
+
depMod = registry[depId];
|
585
631
|
|
586
|
-
|
587
|
-
|
588
|
-
|
632
|
+
if (!depMod) {
|
633
|
+
return;
|
634
|
+
}
|
589
635
|
|
590
|
-
|
591
|
-
|
592
|
-
|
593
|
-
|
636
|
+
if (!depMod.inited || !depMod.enabled) {
|
637
|
+
//Dependency is not inited, so this cannot
|
638
|
+
//be used to determine a cycle.
|
639
|
+
foundModule = null;
|
640
|
+
delete traced[id];
|
641
|
+
return true;
|
594
642
|
}
|
595
643
|
|
596
|
-
|
644
|
+
//mixin traced to a new object for each dependency, so that
|
645
|
+
//sibling dependencies in this object to not generate a
|
646
|
+
//false positive match on a cycle. Ideally an Object.create
|
647
|
+
//type of prototype delegation would be used here, but
|
648
|
+
//optimizing for file size vs. execution speed since hopefully
|
649
|
+
//the trees are small for circular dependency scans relative
|
650
|
+
//to the full app perf.
|
651
|
+
return (foundModule = findCycle(depMod, mixin({}, traced)));
|
652
|
+
});
|
597
653
|
|
598
|
-
|
599
|
-
|
600
|
-
}
|
654
|
+
return foundModule;
|
655
|
+
}
|
601
656
|
|
602
|
-
|
603
|
-
|
604
|
-
|
657
|
+
function forceExec(mod, traced, uninited) {
|
658
|
+
var id = mod.map.id,
|
659
|
+
depArray = mod.depMaps;
|
605
660
|
|
606
|
-
|
607
|
-
|
608
|
-
if (fullName in defined) {
|
609
|
-
load(defined[fullName]);
|
610
|
-
} else {
|
611
|
-
//Use parentName here since the plugin's name is not reliable,
|
612
|
-
//could be some weird string with no path that actually wants to
|
613
|
-
//reference the parentName's path.
|
614
|
-
plugin.load(name, makeRequire(map.parentMap, true, function (deps, cb) {
|
615
|
-
var moduleDeps = [],
|
616
|
-
i, dep, depMap;
|
617
|
-
//Convert deps to full names and hold on to them
|
618
|
-
//for reference later, when figuring out if they
|
619
|
-
//are blocked by a circular dependency.
|
620
|
-
for (i = 0; (dep = deps[i]); i++) {
|
621
|
-
depMap = makeModuleMap(dep, map.parentMap);
|
622
|
-
deps[i] = depMap.fullName;
|
623
|
-
if (!depMap.prefix) {
|
624
|
-
moduleDeps.push(deps[i]);
|
625
|
-
}
|
626
|
-
}
|
627
|
-
depManager.moduleDeps = (depManager.moduleDeps || []).concat(moduleDeps);
|
628
|
-
return context.require(deps, cb);
|
629
|
-
}), load, config);
|
661
|
+
if (!mod.inited || !mod.map.isDefine) {
|
662
|
+
return;
|
630
663
|
}
|
631
|
-
}
|
632
664
|
|
633
|
-
|
634
|
-
|
635
|
-
* resolved items should be in the waiting queue.
|
636
|
-
*/
|
637
|
-
function addWait(manager) {
|
638
|
-
if (!waiting[manager.id]) {
|
639
|
-
waiting[manager.id] = manager;
|
640
|
-
waitAry.push(manager);
|
641
|
-
context.waitCount += 1;
|
665
|
+
if (traced[id]) {
|
666
|
+
return defined[id];
|
642
667
|
}
|
643
|
-
}
|
644
668
|
|
645
|
-
|
646
|
-
* Function added to every manager object. Created out here
|
647
|
-
* to avoid new function creation for each manager instance.
|
648
|
-
*/
|
649
|
-
function managerAdd(cb) {
|
650
|
-
this.listeners.push(cb);
|
651
|
-
}
|
669
|
+
traced[id] = mod;
|
652
670
|
|
653
|
-
|
654
|
-
|
655
|
-
|
656
|
-
|
657
|
-
(plugins[prefix] = defined[prefix]) : null,
|
658
|
-
manager, created, pluginManager, prefixMap;
|
671
|
+
each(depArray, function(depMap) {
|
672
|
+
var depId = depMap.id,
|
673
|
+
depMod = registry[depId],
|
674
|
+
value;
|
659
675
|
|
660
|
-
|
661
|
-
|
662
|
-
|
676
|
+
if (handlers[depId]) {
|
677
|
+
return;
|
678
|
+
}
|
663
679
|
|
664
|
-
|
665
|
-
|
666
|
-
|
667
|
-
|
668
|
-
|
669
|
-
|
670
|
-
|
671
|
-
|
672
|
-
(fullName || '__r@' + (managerCounter++)),
|
673
|
-
map: map,
|
674
|
-
depCount: 0,
|
675
|
-
depDone: [],
|
676
|
-
depCallbacks: [],
|
677
|
-
deps: [],
|
678
|
-
listeners: [],
|
679
|
-
add: managerAdd
|
680
|
-
};
|
680
|
+
if (depMod) {
|
681
|
+
if (!depMod.inited || !depMod.enabled) {
|
682
|
+
//Dependency is not inited,
|
683
|
+
//so this module cannot be
|
684
|
+
//given a forced value yet.
|
685
|
+
uninited[id] = true;
|
686
|
+
return;
|
687
|
+
}
|
681
688
|
|
682
|
-
|
689
|
+
//Get the value for the current dependency
|
690
|
+
value = forceExec(depMod, traced, uninited);
|
683
691
|
|
684
|
-
|
685
|
-
|
686
|
-
|
687
|
-
|
688
|
-
|
689
|
-
|
692
|
+
//Even with forcing it may not be done,
|
693
|
+
//in particular if the module is waiting
|
694
|
+
//on a plugin resource.
|
695
|
+
if (!uninited[depId]) {
|
696
|
+
mod.defineDepById(depId, value);
|
697
|
+
}
|
690
698
|
}
|
691
|
-
}
|
699
|
+
});
|
692
700
|
|
693
|
-
|
694
|
-
//first load the plugin, then continue on.
|
695
|
-
if (prefix && !plugin) {
|
696
|
-
prefixMap = makeModuleMap(prefix);
|
697
|
-
|
698
|
-
//Clear out defined and urlFetched if the plugin was previously
|
699
|
-
//loaded/defined, but not as full module (as in a build
|
700
|
-
//situation). However, only do this work if the plugin is in
|
701
|
-
//defined but does not have a module export value.
|
702
|
-
if (prefix in defined && !defined[prefix]) {
|
703
|
-
delete defined[prefix];
|
704
|
-
delete urlFetched[prefixMap.url];
|
705
|
-
}
|
701
|
+
mod.check(true);
|
706
702
|
|
707
|
-
|
708
|
-
|
709
|
-
//Create a new manager for the normalized
|
710
|
-
//resource ID and have it call this manager when
|
711
|
-
//done.
|
712
|
-
var newMap = makeModuleMap(map.originalName, map.parentMap),
|
713
|
-
normalizedManager = getManager(newMap, true);
|
714
|
-
|
715
|
-
//Indicate this manager is a placeholder for the real,
|
716
|
-
//normalized thing. Important for when trying to map
|
717
|
-
//modules and dependencies, for instance, in a build.
|
718
|
-
manager.placeholder = true;
|
719
|
-
|
720
|
-
normalizedManager.add(function (resource) {
|
721
|
-
manager.callback = function () {
|
722
|
-
return resource;
|
723
|
-
};
|
724
|
-
execManager(manager);
|
725
|
-
});
|
726
|
-
});
|
727
|
-
} else if (created && shouldQueue) {
|
728
|
-
//Indicate the resource is not loaded yet if it is to be
|
729
|
-
//queued.
|
730
|
-
loaded[manager.id] = false;
|
731
|
-
queueDependency(manager);
|
732
|
-
addWait(manager);
|
733
|
-
}
|
703
|
+
return defined[id];
|
704
|
+
}
|
734
705
|
|
735
|
-
|
706
|
+
function modCheck(mod) {
|
707
|
+
mod.check();
|
736
708
|
}
|
737
709
|
|
738
|
-
function
|
739
|
-
var
|
740
|
-
|
741
|
-
|
742
|
-
|
743
|
-
|
744
|
-
|
745
|
-
|
746
|
-
|
747
|
-
if (fullName) {
|
748
|
-
//If module already defined for context, or already loaded,
|
749
|
-
//then leave. Also leave if jQuery is registering but it does
|
750
|
-
//not match the desired version number in the config.
|
751
|
-
if (fullName in defined || loaded[id] === true ||
|
752
|
-
(fullName === "jquery" && config.jQuery &&
|
753
|
-
config.jQuery !== callback().fn.jquery)) {
|
754
|
-
return;
|
755
|
-
}
|
710
|
+
function checkLoaded() {
|
711
|
+
var waitInterval = config.waitSeconds * 1000,
|
712
|
+
//It is possible to disable the wait interval by using waitSeconds of 0.
|
713
|
+
expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
|
714
|
+
noLoads = [],
|
715
|
+
stillLoading = false,
|
716
|
+
needCycleCheck = true,
|
717
|
+
map, modId, err, usingPathFallback;
|
756
718
|
|
757
|
-
|
758
|
-
|
759
|
-
|
760
|
-
|
761
|
-
|
762
|
-
|
719
|
+
//Do not bother if this call was a result of a cycle break.
|
720
|
+
if (inCheckLoaded) {
|
721
|
+
return;
|
722
|
+
}
|
723
|
+
|
724
|
+
inCheckLoaded = true;
|
763
725
|
|
764
|
-
|
765
|
-
|
766
|
-
|
726
|
+
//Figure out the state of all the modules.
|
727
|
+
eachProp(registry, function (mod) {
|
728
|
+
map = mod.map;
|
729
|
+
modId = map.id;
|
730
|
+
|
731
|
+
//Skip things that are not enabled or in error state.
|
732
|
+
if (!mod.enabled) {
|
733
|
+
return;
|
767
734
|
}
|
768
|
-
}
|
769
735
|
|
770
|
-
|
771
|
-
|
772
|
-
|
773
|
-
|
774
|
-
|
775
|
-
|
776
|
-
|
777
|
-
|
778
|
-
|
779
|
-
|
780
|
-
|
781
|
-
|
782
|
-
|
783
|
-
|
784
|
-
|
785
|
-
|
786
|
-
|
787
|
-
|
788
|
-
|
789
|
-
|
790
|
-
//Fix the name in depArray to be just the name, since
|
791
|
-
//that is how it will be called back later.
|
792
|
-
depArray[i] = depName;
|
793
|
-
|
794
|
-
//Fast path CommonJS standard dependencies.
|
795
|
-
if (depName === "require") {
|
796
|
-
deps[i] = makeRequire(moduleMap);
|
797
|
-
} else if (depName === "exports") {
|
798
|
-
//CommonJS module spec 1.1
|
799
|
-
deps[i] = defined[fullName] = {};
|
800
|
-
manager.usingExports = true;
|
801
|
-
} else if (depName === "module") {
|
802
|
-
//CommonJS module spec 1.1
|
803
|
-
manager.cjsModule = cjsMod = deps[i] = {
|
804
|
-
id: name,
|
805
|
-
uri: name ? context.nameToUrl(name, null, relModuleMap) : undefined,
|
806
|
-
exports: defined[fullName]
|
807
|
-
};
|
808
|
-
} else if (depName in defined && !(depName in waiting) &&
|
809
|
-
(!(fullName in needFullExec) ||
|
810
|
-
(fullName in needFullExec && fullExec[depName]))) {
|
811
|
-
//Module already defined, and not in a build situation
|
812
|
-
//where the module is a something that needs full
|
813
|
-
//execution and this dependency has not been fully
|
814
|
-
//executed. See r.js's requirePatch.js for more info
|
815
|
-
//on fullExec.
|
816
|
-
deps[i] = defined[depName];
|
817
|
-
} else {
|
818
|
-
//Mark this dependency as needing full exec if
|
819
|
-
//the current module needs full exec.
|
820
|
-
if (fullName in needFullExec) {
|
821
|
-
needFullExec[depName] = true;
|
822
|
-
//Reset state so fully executed code will get
|
823
|
-
//picked up correctly.
|
824
|
-
delete defined[depName];
|
825
|
-
urlFetched[depArg.url] = false;
|
736
|
+
if (!mod.error) {
|
737
|
+
//If the module should be executed, and it has not
|
738
|
+
//been inited and time is up, remember it.
|
739
|
+
if (!mod.inited && expired) {
|
740
|
+
if (hasPathFallback(modId)) {
|
741
|
+
usingPathFallback = true;
|
742
|
+
stillLoading = true;
|
743
|
+
} else {
|
744
|
+
noLoads.push(modId);
|
745
|
+
removeScript(modId);
|
746
|
+
}
|
747
|
+
} else if (!mod.inited && mod.fetched && map.isDefine) {
|
748
|
+
stillLoading = true;
|
749
|
+
if (!map.prefix) {
|
750
|
+
//No reason to keep looking for unfinished
|
751
|
+
//loading. If the only stillLoading is a
|
752
|
+
//plugin resource though, keep going,
|
753
|
+
//because it may be that a plugin resource
|
754
|
+
//is waiting on a non-plugin cycle.
|
755
|
+
return (needCycleCheck = false);
|
826
756
|
}
|
827
|
-
|
828
|
-
//Either a resource that is not loaded yet, or a plugin
|
829
|
-
//resource for either a plugin that has not
|
830
|
-
//loaded yet.
|
831
|
-
manager.depCount += 1;
|
832
|
-
manager.depCallbacks[i] = makeArgCallback(manager, i);
|
833
|
-
getManager(depArg, true).add(manager.depCallbacks[i]);
|
834
757
|
}
|
835
758
|
}
|
836
|
-
}
|
759
|
+
});
|
837
760
|
|
838
|
-
|
839
|
-
|
840
|
-
|
841
|
-
|
842
|
-
|
843
|
-
addWait(manager);
|
761
|
+
if (expired && noLoads.length) {
|
762
|
+
//If wait time expired, throw error of unloaded modules.
|
763
|
+
err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
|
764
|
+
err.contextName = context.contextName;
|
765
|
+
return onError(err);
|
844
766
|
}
|
845
|
-
}
|
846
767
|
|
847
|
-
|
848
|
-
|
849
|
-
* hold in the defQueue.
|
850
|
-
*/
|
851
|
-
function callDefMain(args) {
|
852
|
-
main.apply(null, args);
|
853
|
-
}
|
768
|
+
//Not expired, check for a cycle.
|
769
|
+
if (needCycleCheck) {
|
854
770
|
|
855
|
-
|
856
|
-
|
857
|
-
* calling jQuery ready callbacks until all scripts are loaded. Be sure
|
858
|
-
* to track it if the capability exists.. Also, since jQuery 1.4.3 does
|
859
|
-
* not register as a module, need to do some global inference checking.
|
860
|
-
* Even if it does register as a module, not guaranteed to be the precise
|
861
|
-
* name of the global. If a jQuery is tracked for this context, then go
|
862
|
-
* ahead and register it as a module too, if not already in process.
|
863
|
-
*/
|
864
|
-
jQueryCheck = function (jqCandidate) {
|
865
|
-
if (!context.jQuery) {
|
866
|
-
var $ = jqCandidate || (typeof jQuery !== "undefined" ? jQuery : null);
|
867
|
-
|
868
|
-
if ($) {
|
869
|
-
//If a specific version of jQuery is wanted, make sure to only
|
870
|
-
//use this jQuery if it matches.
|
871
|
-
if (config.jQuery && $.fn.jquery !== config.jQuery) {
|
771
|
+
each(waitAry, function (mod) {
|
772
|
+
if (mod.defined) {
|
872
773
|
return;
|
873
774
|
}
|
874
775
|
|
875
|
-
|
876
|
-
|
877
|
-
|
878
|
-
//Manually create a "jquery" module entry if not one already
|
879
|
-
//or in process. Note this could trigger an attempt at
|
880
|
-
//a second jQuery registration, but does no harm since
|
881
|
-
//the first one wins, and it is the same value anyway.
|
882
|
-
callDefMain(["jquery", [], function () {
|
883
|
-
return jQuery;
|
884
|
-
}]);
|
885
|
-
|
886
|
-
//Ask jQuery to hold DOM ready callbacks.
|
887
|
-
if (context.scriptCount) {
|
888
|
-
jQueryHoldReady($, true);
|
889
|
-
context.jQueryIncremented = true;
|
890
|
-
}
|
891
|
-
}
|
892
|
-
}
|
893
|
-
}
|
894
|
-
};
|
776
|
+
var cycleMod = findCycle(mod, {}),
|
777
|
+
traced = {};
|
895
778
|
|
896
|
-
|
897
|
-
|
898
|
-
depArray = manager.depArray,
|
899
|
-
fullyLoaded = true,
|
900
|
-
i, depName, depManager, result;
|
779
|
+
if (cycleMod) {
|
780
|
+
forceExec(cycleMod, traced, {});
|
901
781
|
|
902
|
-
|
903
|
-
|
904
|
-
|
782
|
+
//traced modules may have been
|
783
|
+
//removed from the registry, but
|
784
|
+
//their listeners still need to
|
785
|
+
//be called.
|
786
|
+
eachProp(traced, modCheck);
|
787
|
+
}
|
788
|
+
});
|
905
789
|
|
906
|
-
|
907
|
-
|
908
|
-
|
790
|
+
//Now that dependencies have
|
791
|
+
//been satisfied, trigger the
|
792
|
+
//completion check that then
|
793
|
+
//notifies listeners.
|
794
|
+
eachProp(registry, modCheck);
|
909
795
|
}
|
910
796
|
|
911
|
-
|
912
|
-
|
913
|
-
//
|
914
|
-
if (
|
915
|
-
|
916
|
-
|
917
|
-
|
918
|
-
|
919
|
-
|
920
|
-
|
921
|
-
|
922
|
-
}
|
923
|
-
depManager = waiting[depName];
|
924
|
-
if (depManager && !depManager.isDone && loaded[depName]) {
|
925
|
-
result = findCycle(depManager, traced);
|
926
|
-
if (result) {
|
927
|
-
break;
|
928
|
-
}
|
929
|
-
}
|
930
|
-
}
|
931
|
-
if (!fullyLoaded) {
|
932
|
-
//Discard the cycle that was found, since it cannot
|
933
|
-
//be forced yet. Also clear this module from traced.
|
934
|
-
result = undefined;
|
935
|
-
delete traced[fullName];
|
797
|
+
//If still waiting on loads, and the waiting load is something
|
798
|
+
//other than a plugin resource, or there are still outstanding
|
799
|
+
//scripts, then just try back later.
|
800
|
+
if ((!expired || usingPathFallback) && stillLoading) {
|
801
|
+
//Something is still waiting to load. Wait for it, but only
|
802
|
+
//if a timeout is not already in effect.
|
803
|
+
if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
|
804
|
+
checkLoadedTimeoutId = setTimeout(function () {
|
805
|
+
checkLoadedTimeoutId = 0;
|
806
|
+
checkLoaded();
|
807
|
+
}, 50);
|
936
808
|
}
|
937
809
|
}
|
938
810
|
|
939
|
-
|
811
|
+
inCheckLoaded = false;
|
940
812
|
}
|
941
813
|
|
942
|
-
function
|
943
|
-
|
944
|
-
|
945
|
-
|
814
|
+
Module = function (map) {
|
815
|
+
this.events = undefEvents[map.id] || {};
|
816
|
+
this.map = map;
|
817
|
+
this.shim = config.shim[map.id];
|
818
|
+
this.depExports = [];
|
819
|
+
this.depMaps = [];
|
820
|
+
this.depMatched = [];
|
821
|
+
this.pluginMaps = {};
|
822
|
+
this.depCount = 0;
|
823
|
+
|
824
|
+
/* this.exports this.factory
|
825
|
+
this.depMaps = [],
|
826
|
+
this.enabled, this.fetched
|
827
|
+
*/
|
828
|
+
};
|
946
829
|
|
830
|
+
Module.prototype = {
|
831
|
+
init: function(depMaps, factory, errback, options) {
|
832
|
+
options = options || {};
|
947
833
|
|
948
|
-
|
949
|
-
|
950
|
-
|
834
|
+
//Do not do more inits if already done. Can happen if there
|
835
|
+
//are multiple define calls for the same module. That is not
|
836
|
+
//a normal, common case, but it is also not unexpected.
|
837
|
+
if (this.inited) {
|
838
|
+
return;
|
839
|
+
}
|
951
840
|
|
952
|
-
|
953
|
-
|
954
|
-
|
841
|
+
this.factory = factory;
|
842
|
+
|
843
|
+
if (errback) {
|
844
|
+
//Register for errors on this module.
|
845
|
+
this.on('error', errback);
|
846
|
+
} else if (this.events.error) {
|
847
|
+
//If no errback already, but there are error listeners
|
848
|
+
//on this module, set up an errback to pass to the deps.
|
849
|
+
errback = bind(this, function (err) {
|
850
|
+
this.emit('error', err);
|
851
|
+
});
|
955
852
|
}
|
956
853
|
|
957
|
-
|
958
|
-
|
854
|
+
//Do a copy of the dependency array, so that
|
855
|
+
//source inputs are not modified. For example
|
856
|
+
//"shim" deps are passed in here directly, and
|
857
|
+
//doing a direct modification of the depMaps array
|
858
|
+
//would affect that config.
|
859
|
+
this.depMaps = depMaps && depMaps.slice(0);
|
860
|
+
this.depMaps.rjsSkipMap = depMaps.rjsSkipMap;
|
861
|
+
|
862
|
+
this.errback = errback;
|
863
|
+
|
864
|
+
//Indicate this module has be initialized
|
865
|
+
this.inited = true;
|
866
|
+
|
867
|
+
this.ignore = options.ignore;
|
868
|
+
|
869
|
+
//Could have option to init this module in enabled mode,
|
870
|
+
//or could have been previously marked as enabled. However,
|
871
|
+
//the dependencies are not known until init is called. So
|
872
|
+
//if enabled previously, now trigger dependencies as enabled.
|
873
|
+
if (options.enabled || this.enabled) {
|
874
|
+
//Enable this module and dependencies.
|
875
|
+
//Will call this.check()
|
876
|
+
this.enable();
|
877
|
+
} else {
|
878
|
+
this.check();
|
879
|
+
}
|
880
|
+
},
|
959
881
|
|
960
|
-
|
961
|
-
|
962
|
-
|
963
|
-
|
964
|
-
|
965
|
-
|
966
|
-
|
967
|
-
|
968
|
-
//plugin is not blocked.
|
969
|
-
prefix = makeModuleMap(depName).prefix;
|
970
|
-
if (prefix && (prefixManager = waiting[prefix])) {
|
971
|
-
forceExec(prefixManager, traced);
|
972
|
-
}
|
973
|
-
depManager = waiting[depName];
|
974
|
-
if (depManager && !depManager.isDone && loaded[depName]) {
|
975
|
-
value = forceExec(depManager, traced);
|
976
|
-
manager.depCallbacks[i](value);
|
977
|
-
}
|
882
|
+
defineDepById: function (id, depExports) {
|
883
|
+
var i;
|
884
|
+
|
885
|
+
//Find the index for this dependency.
|
886
|
+
each(this.depMaps, function (map, index) {
|
887
|
+
if (map.id === id) {
|
888
|
+
i = index;
|
889
|
+
return true;
|
978
890
|
}
|
891
|
+
});
|
892
|
+
|
893
|
+
return this.defineDep(i, depExports);
|
894
|
+
},
|
895
|
+
|
896
|
+
defineDep: function (i, depExports) {
|
897
|
+
//Because of cycles, defined callback for a given
|
898
|
+
//export can be called more than once.
|
899
|
+
if (!this.depMatched[i]) {
|
900
|
+
this.depMatched[i] = true;
|
901
|
+
this.depCount -= 1;
|
902
|
+
this.depExports[i] = depExports;
|
979
903
|
}
|
980
|
-
}
|
904
|
+
},
|
981
905
|
|
982
|
-
|
983
|
-
|
906
|
+
fetch: function () {
|
907
|
+
if (this.fetched) {
|
908
|
+
return;
|
909
|
+
}
|
910
|
+
this.fetched = true;
|
984
911
|
|
985
|
-
|
986
|
-
|
987
|
-
|
988
|
-
*
|
989
|
-
* @private
|
990
|
-
*/
|
991
|
-
function checkLoaded() {
|
992
|
-
var waitInterval = config.waitSeconds * 1000,
|
993
|
-
//It is possible to disable the wait interval by using waitSeconds of 0.
|
994
|
-
expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
|
995
|
-
noLoads = "", hasLoadedProp = false, stillLoading = false,
|
996
|
-
cycleDeps = [],
|
997
|
-
i, prop, err, manager, cycleManager, moduleDeps;
|
998
|
-
|
999
|
-
//If there are items still in the paused queue processing wait.
|
1000
|
-
//This is particularly important in the sync case where each paused
|
1001
|
-
//item is processed right away but there may be more waiting.
|
1002
|
-
if (context.pausedCount > 0) {
|
1003
|
-
return undefined;
|
1004
|
-
}
|
912
|
+
context.startTime = (new Date()).getTime();
|
913
|
+
|
914
|
+
var map = this.map;
|
1005
915
|
|
1006
|
-
|
1007
|
-
|
1008
|
-
|
1009
|
-
|
1010
|
-
|
1011
|
-
|
1012
|
-
resume();
|
916
|
+
//If the manager is for a plugin managed resource,
|
917
|
+
//ask the plugin to load it now.
|
918
|
+
if (this.shim) {
|
919
|
+
makeRequire(this, true)(this.shim.deps || [], bind(this, function () {
|
920
|
+
return map.prefix ? this.callPlugin() : this.load();
|
921
|
+
}));
|
1013
922
|
} else {
|
1014
|
-
|
923
|
+
//Regular dependency.
|
924
|
+
return map.prefix ? this.callPlugin() : this.load();
|
1015
925
|
}
|
1016
|
-
}
|
926
|
+
},
|
1017
927
|
|
1018
|
-
|
1019
|
-
|
1020
|
-
|
1021
|
-
|
1022
|
-
|
1023
|
-
|
1024
|
-
|
1025
|
-
|
1026
|
-
|
1027
|
-
|
1028
|
-
|
1029
|
-
|
1030
|
-
|
1031
|
-
|
1032
|
-
|
1033
|
-
|
1034
|
-
|
928
|
+
load: function() {
|
929
|
+
var url = this.map.url;
|
930
|
+
|
931
|
+
//Regular dependency.
|
932
|
+
if (!urlFetched[url]) {
|
933
|
+
urlFetched[url] = true;
|
934
|
+
context.load(this.map.id, url);
|
935
|
+
}
|
936
|
+
},
|
937
|
+
|
938
|
+
/**
|
939
|
+
* Checks is the module is ready to define itself, and if so,
|
940
|
+
* define it. If the silent argument is true, then it will just
|
941
|
+
* define, but not notify listeners, and not ask for a context-wide
|
942
|
+
* check of all loaded modules. That is useful for cycle breaking.
|
943
|
+
*/
|
944
|
+
check: function (silent) {
|
945
|
+
if (!this.enabled || this.enabling) {
|
946
|
+
return;
|
947
|
+
}
|
948
|
+
|
949
|
+
var id = this.map.id,
|
950
|
+
depExports = this.depExports,
|
951
|
+
exports = this.exports,
|
952
|
+
factory = this.factory,
|
953
|
+
err, cjsModule;
|
954
|
+
|
955
|
+
if (!this.inited) {
|
956
|
+
this.fetch();
|
957
|
+
} else if (this.error) {
|
958
|
+
this.emit('error', this.error);
|
959
|
+
} else if (!this.defining) {
|
960
|
+
//The factory could trigger another require call
|
961
|
+
//that would result in checking this module to
|
962
|
+
//define itself again. If already in the process
|
963
|
+
//of doing that, skip this work.
|
964
|
+
this.defining = true;
|
965
|
+
|
966
|
+
if (this.depCount < 1 && !this.defined) {
|
967
|
+
if (isFunction(factory)) {
|
968
|
+
//If there is an error listener, favor passing
|
969
|
+
//to that instead of throwing an error.
|
970
|
+
if (this.events.error) {
|
971
|
+
try {
|
972
|
+
exports = context.execCb(id, factory, depExports, exports);
|
973
|
+
} catch (e) {
|
974
|
+
err = e;
|
975
|
+
}
|
1035
976
|
} else {
|
1036
|
-
|
1037
|
-
|
1038
|
-
|
977
|
+
exports = context.execCb(id, factory, depExports, exports);
|
978
|
+
}
|
979
|
+
|
980
|
+
if (this.map.isDefine) {
|
981
|
+
//If setting exports via 'module' is in play,
|
982
|
+
//favor that over return value and exports. After that,
|
983
|
+
//favor a non-undefined return value over exports use.
|
984
|
+
cjsModule = this.module;
|
985
|
+
if (cjsModule &&
|
986
|
+
cjsModule.exports !== undefined &&
|
987
|
+
//Make sure it is not already the exports value
|
988
|
+
cjsModule.exports !== this.exports) {
|
989
|
+
exports = cjsModule.exports;
|
990
|
+
} else if (exports === undefined && this.usingExports) {
|
991
|
+
//exports already set the defined value.
|
992
|
+
exports = this.exports;
|
1039
993
|
}
|
1040
994
|
}
|
995
|
+
|
996
|
+
if (err) {
|
997
|
+
err.requireMap = this.map;
|
998
|
+
err.requireModules = [this.map.id];
|
999
|
+
err.requireType = 'define';
|
1000
|
+
return onError((this.error = err));
|
1001
|
+
}
|
1002
|
+
|
1003
|
+
} else {
|
1004
|
+
//Just a literal value
|
1005
|
+
exports = factory;
|
1006
|
+
}
|
1007
|
+
|
1008
|
+
this.exports = exports;
|
1009
|
+
|
1010
|
+
if (this.map.isDefine && !this.ignore) {
|
1011
|
+
defined[id] = exports;
|
1012
|
+
|
1013
|
+
if (req.onResourceLoad) {
|
1014
|
+
req.onResourceLoad(context, this.map, this.depMaps);
|
1015
|
+
}
|
1016
|
+
}
|
1017
|
+
|
1018
|
+
//Clean up
|
1019
|
+
delete registry[id];
|
1020
|
+
|
1021
|
+
this.defined = true;
|
1022
|
+
context.waitCount -= 1;
|
1023
|
+
if (context.waitCount === 0) {
|
1024
|
+
//Clear the wait array used for cycles.
|
1025
|
+
waitAry = [];
|
1041
1026
|
}
|
1042
1027
|
}
|
1043
|
-
}
|
1044
|
-
}
|
1045
1028
|
|
1046
|
-
|
1047
|
-
|
1048
|
-
|
1049
|
-
|
1050
|
-
return undefined;
|
1051
|
-
}
|
1052
|
-
if (expired && noLoads) {
|
1053
|
-
//If wait time expired, throw error of unloaded modules.
|
1054
|
-
err = makeError("timeout", "Load timeout for modules: " + noLoads);
|
1055
|
-
err.requireType = "timeout";
|
1056
|
-
err.requireModules = noLoads;
|
1057
|
-
err.contextName = context.contextName;
|
1058
|
-
return req.onError(err);
|
1059
|
-
}
|
1029
|
+
//Finished the define stage. Allow calling check again
|
1030
|
+
//to allow define notifications below in the case of a
|
1031
|
+
//cycle.
|
1032
|
+
this.defining = false;
|
1060
1033
|
|
1061
|
-
|
1062
|
-
|
1063
|
-
|
1064
|
-
|
1065
|
-
|
1066
|
-
|
1067
|
-
break;
|
1034
|
+
if (!silent) {
|
1035
|
+
if (this.defined && !this.defineEmitted) {
|
1036
|
+
this.defineEmitted = true;
|
1037
|
+
this.emit('defined', this.exports);
|
1038
|
+
this.defineEmitComplete = true;
|
1039
|
+
}
|
1068
1040
|
}
|
1069
1041
|
}
|
1042
|
+
},
|
1070
1043
|
|
1071
|
-
|
1044
|
+
callPlugin: function() {
|
1045
|
+
var map = this.map,
|
1046
|
+
id = map.id,
|
1047
|
+
pluginMap = makeModuleMap(map.prefix, null, false, true);
|
1048
|
+
|
1049
|
+
on(pluginMap, 'defined', bind(this, function (plugin) {
|
1050
|
+
var name = this.map.name,
|
1051
|
+
parentName = this.map.parentMap ? this.map.parentMap.name : null,
|
1052
|
+
load, normalizedMap, normalizedMod;
|
1053
|
+
|
1054
|
+
//If current map is not normalized, wait for that
|
1055
|
+
//normalized name to load instead of continuing.
|
1056
|
+
if (this.map.unnormalized) {
|
1057
|
+
//Normalize the ID if the plugin allows it.
|
1058
|
+
if (plugin.normalize) {
|
1059
|
+
name = plugin.normalize(name, function (name) {
|
1060
|
+
return normalize(name, parentName, true);
|
1061
|
+
}) || '';
|
1062
|
+
}
|
1072
1063
|
|
1073
|
-
|
1074
|
-
|
1075
|
-
|
1076
|
-
|
1077
|
-
|
1078
|
-
|
1079
|
-
|
1080
|
-
|
1081
|
-
|
1082
|
-
|
1083
|
-
|
1084
|
-
|
1085
|
-
|
1086
|
-
|
1064
|
+
normalizedMap = makeModuleMap(map.prefix + '!' + name,
|
1065
|
+
this.map.parentMap,
|
1066
|
+
false,
|
1067
|
+
true);
|
1068
|
+
on(normalizedMap,
|
1069
|
+
'defined', bind(this, function (value) {
|
1070
|
+
this.init([], function () { return value; }, null, {
|
1071
|
+
enabled: true,
|
1072
|
+
ignore: true
|
1073
|
+
});
|
1074
|
+
}));
|
1075
|
+
normalizedMod = registry[normalizedMap.id];
|
1076
|
+
if (normalizedMod) {
|
1077
|
+
if (this.events.error) {
|
1078
|
+
normalizedMod.on('error', bind(this, function (err) {
|
1079
|
+
this.emit('error', err);
|
1080
|
+
}));
|
1081
|
+
}
|
1082
|
+
normalizedMod.enable();
|
1083
|
+
}
|
1087
1084
|
|
1088
|
-
|
1089
|
-
|
1090
|
-
//that need to be broken.
|
1091
|
-
//However, as a waiting thing is fired, then it can add items to
|
1092
|
-
//the waiting cue, and those items should not be fired yet, so
|
1093
|
-
//make sure to redo the checkLoaded call after breaking a single
|
1094
|
-
//cycle, if nothing else loaded then this logic will pick it up
|
1095
|
-
//again.
|
1096
|
-
if (context.waitCount) {
|
1097
|
-
//Cycle through the waitAry, and call items in sequence.
|
1098
|
-
for (i = 0; (manager = waitAry[i]); i++) {
|
1099
|
-
forceExec(manager, {});
|
1100
|
-
}
|
1085
|
+
return;
|
1086
|
+
}
|
1101
1087
|
|
1102
|
-
|
1103
|
-
|
1104
|
-
|
1105
|
-
|
1088
|
+
load = bind(this, function (value) {
|
1089
|
+
this.init([], function () { return value; }, null, {
|
1090
|
+
enabled: true
|
1091
|
+
});
|
1092
|
+
});
|
1106
1093
|
|
1107
|
-
|
1108
|
-
|
1109
|
-
|
1110
|
-
|
1111
|
-
//The value of 5 is a bit arbitrary. Hopefully just one extra
|
1112
|
-
//pass, or two for the case of circular dependencies generating
|
1113
|
-
//more work that gets resolved in the sync node case.
|
1114
|
-
if (checkLoadedDepth < 5) {
|
1115
|
-
checkLoadedDepth += 1;
|
1116
|
-
checkLoaded();
|
1117
|
-
}
|
1118
|
-
}
|
1094
|
+
load.error = bind(this, function (err) {
|
1095
|
+
this.inited = true;
|
1096
|
+
this.error = err;
|
1097
|
+
err.requireModules = [id];
|
1119
1098
|
|
1120
|
-
|
1099
|
+
//Remove temp unnormalized modules for this module,
|
1100
|
+
//since they will never be resolved otherwise now.
|
1101
|
+
eachProp(registry, function (mod) {
|
1102
|
+
if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
|
1103
|
+
removeWaiting(mod.map.id);
|
1104
|
+
}
|
1105
|
+
});
|
1121
1106
|
|
1122
|
-
|
1123
|
-
|
1107
|
+
onError(err);
|
1108
|
+
});
|
1124
1109
|
|
1125
|
-
|
1126
|
-
|
1110
|
+
//Allow plugins to load other code without having to know the
|
1111
|
+
//context or how to 'complete' the load.
|
1112
|
+
load.fromText = function (moduleName, text) {
|
1113
|
+
/*jslint evil: true */
|
1114
|
+
var hasInteractive = useInteractive;
|
1127
1115
|
|
1128
|
-
|
1129
|
-
|
1130
|
-
|
1131
|
-
|
1132
|
-
|
1116
|
+
//Turn off interactive script matching for IE for any define
|
1117
|
+
//calls in the text, then turn it back on at the end.
|
1118
|
+
if (hasInteractive) {
|
1119
|
+
useInteractive = false;
|
1120
|
+
}
|
1133
1121
|
|
1134
|
-
|
1135
|
-
|
1122
|
+
//Prime the system by creating a module instance for
|
1123
|
+
//it.
|
1124
|
+
getModule(makeModuleMap(moduleName));
|
1136
1125
|
|
1137
|
-
|
1126
|
+
req.exec(text);
|
1138
1127
|
|
1139
|
-
|
1140
|
-
|
1141
|
-
|
1142
|
-
//require() calls that also do not end up loading scripts could
|
1143
|
-
//push the number negative too.
|
1144
|
-
context.scriptCount = 0;
|
1145
|
-
}
|
1128
|
+
if (hasInteractive) {
|
1129
|
+
useInteractive = true;
|
1130
|
+
}
|
1146
1131
|
|
1147
|
-
|
1148
|
-
|
1149
|
-
|
1150
|
-
|
1151
|
-
|
1152
|
-
|
1153
|
-
|
1132
|
+
//Support anonymous modules.
|
1133
|
+
context.completeLoad(moduleName);
|
1134
|
+
};
|
1135
|
+
|
1136
|
+
//Use parentName here since the plugin's name is not reliable,
|
1137
|
+
//could be some weird string with no path that actually wants to
|
1138
|
+
//reference the parentName's path.
|
1139
|
+
plugin.load(map.name, makeRequire(map.parentMap, true, function (deps, cb) {
|
1140
|
+
deps.rjsSkipMap = true;
|
1141
|
+
return context.require(deps, cb);
|
1142
|
+
}), load, config);
|
1143
|
+
}));
|
1144
|
+
|
1145
|
+
context.enable(pluginMap, this);
|
1146
|
+
this.pluginMaps[pluginMap.id] = pluginMap;
|
1147
|
+
},
|
1148
|
+
|
1149
|
+
enable: function () {
|
1150
|
+
this.enabled = true;
|
1151
|
+
|
1152
|
+
if (!this.waitPushed) {
|
1153
|
+
waitAry.push(this);
|
1154
|
+
context.waitCount += 1;
|
1155
|
+
this.waitPushed = true;
|
1154
1156
|
}
|
1155
|
-
}
|
1156
1157
|
|
1157
|
-
|
1158
|
-
|
1159
|
-
|
1160
|
-
|
1161
|
-
|
1162
|
-
|
1163
|
-
|
1164
|
-
|
1165
|
-
|
1166
|
-
|
1167
|
-
|
1168
|
-
|
1169
|
-
|
1170
|
-
|
1171
|
-
|
1172
|
-
|
1173
|
-
|
1174
|
-
|
1175
|
-
|
1176
|
-
|
1177
|
-
|
1178
|
-
|
1179
|
-
|
1180
|
-
|
1181
|
-
|
1182
|
-
|
1183
|
-
|
1184
|
-
|
1185
|
-
|
1186
|
-
|
1187
|
-
|
1188
|
-
|
1189
|
-
|
1158
|
+
//Set flag mentioning that the module is enabling,
|
1159
|
+
//so that immediate calls to the defined callbacks
|
1160
|
+
//for dependencies do not trigger inadvertent load
|
1161
|
+
//with the depCount still being zero.
|
1162
|
+
this.enabling = true;
|
1163
|
+
|
1164
|
+
//Enable each dependency
|
1165
|
+
each(this.depMaps, bind(this, function (depMap, i) {
|
1166
|
+
var id, mod, handler;
|
1167
|
+
|
1168
|
+
if (typeof depMap === 'string') {
|
1169
|
+
//Dependency needs to be converted to a depMap
|
1170
|
+
//and wired up to this module.
|
1171
|
+
depMap = makeModuleMap(depMap,
|
1172
|
+
(this.map.isDefine ? this.map : this.map.parentMap),
|
1173
|
+
false,
|
1174
|
+
!this.depMaps.rjsSkipMap);
|
1175
|
+
this.depMaps[i] = depMap;
|
1176
|
+
|
1177
|
+
handler = handlers[depMap.id];
|
1178
|
+
|
1179
|
+
if (handler) {
|
1180
|
+
this.depExports[i] = handler(this);
|
1181
|
+
return;
|
1182
|
+
}
|
1183
|
+
|
1184
|
+
this.depCount += 1;
|
1185
|
+
|
1186
|
+
on(depMap, 'defined', bind(this, function (depExports) {
|
1187
|
+
this.defineDep(i, depExports);
|
1188
|
+
this.check();
|
1189
|
+
}));
|
1190
|
+
|
1191
|
+
if (this.errback) {
|
1192
|
+
on(depMap, 'error', this.errback);
|
1190
1193
|
}
|
1191
1194
|
}
|
1192
1195
|
|
1193
|
-
|
1194
|
-
|
1195
|
-
|
1196
|
+
id = depMap.id;
|
1197
|
+
mod = registry[id];
|
1198
|
+
|
1199
|
+
//Skip special modules like 'require', 'exports', 'module'
|
1200
|
+
//Also, don't call enable if it is already enabled,
|
1201
|
+
//important in circular dependency cases.
|
1202
|
+
if (!handlers[id] && mod && !mod.enabled) {
|
1203
|
+
context.enable(depMap, this);
|
1204
|
+
}
|
1205
|
+
}));
|
1206
|
+
|
1207
|
+
//Enable each plugin that is used in
|
1208
|
+
//a dependency
|
1209
|
+
eachProp(this.pluginMaps, bind(this, function (pluginMap) {
|
1210
|
+
var mod = registry[pluginMap.id];
|
1211
|
+
if (mod && !mod.enabled) {
|
1212
|
+
context.enable(pluginMap, this);
|
1213
|
+
}
|
1214
|
+
}));
|
1215
|
+
|
1216
|
+
this.enabling = false;
|
1217
|
+
|
1218
|
+
this.check();
|
1219
|
+
},
|
1220
|
+
|
1221
|
+
on: function(name, cb) {
|
1222
|
+
var cbs = this.events[name];
|
1223
|
+
if (!cbs) {
|
1224
|
+
cbs = this.events[name] = [];
|
1225
|
+
}
|
1226
|
+
cbs.push(cb);
|
1227
|
+
},
|
1228
|
+
|
1229
|
+
emit: function (name, evt) {
|
1230
|
+
each(this.events[name], function (cb) {
|
1231
|
+
cb(evt);
|
1232
|
+
});
|
1233
|
+
if (name === 'error') {
|
1234
|
+
//Now that the error handler was triggered, remove
|
1235
|
+
//the listeners, since this broken Module instance
|
1236
|
+
//can stay around for a while in the registry/waitAry.
|
1237
|
+
delete this.events[name];
|
1196
1238
|
}
|
1197
1239
|
}
|
1240
|
+
};
|
1198
1241
|
|
1199
|
-
|
1200
|
-
|
1201
|
-
|
1202
|
-
|
1203
|
-
|
1204
|
-
|
1205
|
-
|
1242
|
+
function callGetModule(args) {
|
1243
|
+
getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
|
1244
|
+
}
|
1245
|
+
|
1246
|
+
function removeListener(node, func, name, ieName) {
|
1247
|
+
//Favor detachEvent because of IE9
|
1248
|
+
//issue, see attachEvent/addEventListener comment elsewhere
|
1249
|
+
//in this file.
|
1250
|
+
if (node.detachEvent && !isOpera) {
|
1251
|
+
//Probably IE. If not it will throw an error, which will be
|
1252
|
+
//useful to know.
|
1253
|
+
if (ieName) {
|
1254
|
+
node.detachEvent(ieName, func);
|
1255
|
+
}
|
1256
|
+
} else {
|
1257
|
+
node.removeEventListener(name, func, false);
|
1206
1258
|
}
|
1259
|
+
}
|
1207
1260
|
|
1208
|
-
|
1261
|
+
/**
|
1262
|
+
* Given an event from a script node, get the requirejs info from it,
|
1263
|
+
* and then removes the event listeners on the node.
|
1264
|
+
* @param {Event} evt
|
1265
|
+
* @returns {Object}
|
1266
|
+
*/
|
1267
|
+
function getScriptData(evt) {
|
1268
|
+
//Using currentTarget instead of target for Firefox 2.0's sake. Not
|
1269
|
+
//all old browsers will be supported, but this one was easy enough
|
1270
|
+
//to support and still makes sense.
|
1271
|
+
var node = evt.currentTarget || evt.srcElement;
|
1209
1272
|
|
1210
|
-
|
1211
|
-
|
1273
|
+
//Remove the listeners once here.
|
1274
|
+
removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
|
1275
|
+
removeListener(node, context.onScriptError, 'error');
|
1212
1276
|
|
1213
|
-
|
1214
|
-
|
1215
|
-
|
1216
|
-
|
1277
|
+
return {
|
1278
|
+
node: node,
|
1279
|
+
id: node && node.getAttribute('data-requiremodule')
|
1280
|
+
};
|
1281
|
+
}
|
1282
|
+
|
1283
|
+
return (context = {
|
1217
1284
|
config: config,
|
1218
|
-
|
1219
|
-
|
1220
|
-
waitCount: 0,
|
1221
|
-
specified: specified,
|
1222
|
-
loaded: loaded,
|
1223
|
-
urlMap: urlMap,
|
1224
|
-
urlFetched: urlFetched,
|
1225
|
-
scriptCount: 0,
|
1285
|
+
contextName: contextName,
|
1286
|
+
registry: registry,
|
1226
1287
|
defined: defined,
|
1227
|
-
|
1228
|
-
|
1229
|
-
|
1230
|
-
|
1231
|
-
fake: {},
|
1232
|
-
fullExec: fullExec,
|
1233
|
-
managerCallbacks: managerCallbacks,
|
1288
|
+
urlFetched: urlFetched,
|
1289
|
+
waitCount: 0,
|
1290
|
+
defQueue: defQueue,
|
1291
|
+
Module: Module,
|
1234
1292
|
makeModuleMap: makeModuleMap,
|
1235
|
-
|
1293
|
+
|
1236
1294
|
/**
|
1237
1295
|
* Set a configuration for the context.
|
1238
1296
|
* @param {Object} cfg config object to integrate.
|
1239
1297
|
*/
|
1240
1298
|
configure: function (cfg) {
|
1241
|
-
var paths, prop, packages, pkgs, packagePaths, requireWait;
|
1242
|
-
|
1243
1299
|
//Make sure the baseUrl ends in a slash.
|
1244
1300
|
if (cfg.baseUrl) {
|
1245
|
-
if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !==
|
1246
|
-
cfg.baseUrl +=
|
1301
|
+
if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
|
1302
|
+
cfg.baseUrl += '/';
|
1247
1303
|
}
|
1248
1304
|
}
|
1249
1305
|
|
1250
1306
|
//Save off the paths and packages since they require special processing,
|
1251
1307
|
//they are additive.
|
1252
|
-
|
1253
|
-
|
1254
|
-
|
1308
|
+
var pkgs = config.pkgs,
|
1309
|
+
shim = config.shim,
|
1310
|
+
paths = config.paths,
|
1311
|
+
map = config.map;
|
1255
1312
|
|
1256
1313
|
//Mix in the config values, favoring the new values over
|
1257
1314
|
//existing ones in context.config.
|
1258
1315
|
mixin(config, cfg, true);
|
1259
1316
|
|
1260
|
-
//
|
1261
|
-
|
1262
|
-
|
1263
|
-
|
1264
|
-
|
1265
|
-
|
1266
|
-
}
|
1267
|
-
config.paths = paths;
|
1317
|
+
//Merge paths.
|
1318
|
+
config.paths = mixin(paths, cfg.paths, true);
|
1319
|
+
|
1320
|
+
//Merge map
|
1321
|
+
if (cfg.map) {
|
1322
|
+
config.map = mixin(map || {}, cfg.map, true, true);
|
1268
1323
|
}
|
1269
1324
|
|
1270
|
-
|
1271
|
-
if (
|
1272
|
-
|
1273
|
-
|
1274
|
-
|
1275
|
-
|
1276
|
-
|
1277
|
-
}
|
1325
|
+
//Merge shim
|
1326
|
+
if (cfg.shim) {
|
1327
|
+
eachProp(cfg.shim, function (value, id) {
|
1328
|
+
//Normalize the structure
|
1329
|
+
if (isArray(value)) {
|
1330
|
+
value = {
|
1331
|
+
deps: value
|
1332
|
+
};
|
1278
1333
|
}
|
1279
|
-
|
1334
|
+
if (value.exports && !value.exports.__buildReady) {
|
1335
|
+
value.exports = context.makeShimExports(value.exports);
|
1336
|
+
}
|
1337
|
+
shim[id] = value;
|
1338
|
+
});
|
1339
|
+
config.shim = shim;
|
1340
|
+
}
|
1280
1341
|
|
1281
|
-
|
1282
|
-
|
1283
|
-
|
1284
|
-
|
1342
|
+
//Adjust packages if necessary.
|
1343
|
+
if (cfg.packages) {
|
1344
|
+
each(cfg.packages, function (pkgObj) {
|
1345
|
+
var location;
|
1346
|
+
|
1347
|
+
pkgObj = typeof pkgObj === 'string' ? { name: pkgObj } : pkgObj;
|
1348
|
+
location = pkgObj.location;
|
1349
|
+
|
1350
|
+
//Create a brand new object on pkgs, since currentPackages can
|
1351
|
+
//be passed in again, and config.pkgs is the internal transformed
|
1352
|
+
//state for all package configs.
|
1353
|
+
pkgs[pkgObj.name] = {
|
1354
|
+
name: pkgObj.name,
|
1355
|
+
location: location || pkgObj.name,
|
1356
|
+
//Remove leading dot in main, so main paths are normalized,
|
1357
|
+
//and remove any trailing .js, since different package
|
1358
|
+
//envs have different conventions: some use a module name,
|
1359
|
+
//some use a file name.
|
1360
|
+
main: (pkgObj.main || 'main')
|
1361
|
+
.replace(currDirRegExp, '')
|
1362
|
+
.replace(jsSuffixRegExp, '')
|
1363
|
+
};
|
1364
|
+
});
|
1285
1365
|
|
1286
1366
|
//Done with modifications, assing packages back to context config
|
1287
1367
|
config.pkgs = pkgs;
|
1288
1368
|
}
|
1289
1369
|
|
1290
|
-
//If
|
1291
|
-
|
1292
|
-
|
1293
|
-
|
1294
|
-
|
1295
|
-
|
1296
|
-
//of the priority config.
|
1297
|
-
context.requireWait = false;
|
1298
|
-
//But first, call resume to register any defined modules that may
|
1299
|
-
//be in a data-main built file before the priority config
|
1300
|
-
//call.
|
1301
|
-
resume();
|
1302
|
-
|
1303
|
-
context.require(cfg.priority);
|
1304
|
-
|
1305
|
-
//Trigger a resume right away, for the case when
|
1306
|
-
//the script with the priority load is done as part
|
1307
|
-
//of a data-main call. In that case the normal resume
|
1308
|
-
//call will not happen because the scriptCount will be
|
1309
|
-
//at 1, since the script for data-main is being processed.
|
1310
|
-
resume();
|
1311
|
-
|
1312
|
-
//Restore previous state.
|
1313
|
-
context.requireWait = requireWait;
|
1314
|
-
config.priorityWait = cfg.priority;
|
1315
|
-
}
|
1370
|
+
//If there are any "waiting to execute" modules in the registry,
|
1371
|
+
//update the maps for them, since their info, like URLs to load,
|
1372
|
+
//may have changed.
|
1373
|
+
eachProp(registry, function (mod, id) {
|
1374
|
+
mod.map = makeModuleMap(id);
|
1375
|
+
});
|
1316
1376
|
|
1317
1377
|
//If a deps array or a config callback is specified, then call
|
1318
1378
|
//require with those args. This is useful when require is defined as a
|
@@ -1322,77 +1382,132 @@ var requirejs, require, define;
|
|
1322
1382
|
}
|
1323
1383
|
},
|
1324
1384
|
|
1325
|
-
|
1326
|
-
|
1385
|
+
makeShimExports: function (exports) {
|
1386
|
+
var func;
|
1387
|
+
if (typeof exports === 'string') {
|
1388
|
+
func = function () {
|
1389
|
+
return getGlobal(exports);
|
1390
|
+
};
|
1391
|
+
//Save the exports for use in nodefine checking.
|
1392
|
+
func.exports = exports;
|
1393
|
+
return func;
|
1394
|
+
} else {
|
1395
|
+
return function () {
|
1396
|
+
return exports.apply(global, arguments);
|
1397
|
+
};
|
1398
|
+
}
|
1399
|
+
},
|
1400
|
+
|
1401
|
+
requireDefined: function (id, relMap) {
|
1402
|
+
return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
|
1327
1403
|
},
|
1328
1404
|
|
1329
|
-
requireSpecified: function (
|
1330
|
-
|
1405
|
+
requireSpecified: function (id, relMap) {
|
1406
|
+
id = makeModuleMap(id, relMap, false, true).id;
|
1407
|
+
return hasProp(defined, id) || hasProp(registry, id);
|
1331
1408
|
},
|
1332
1409
|
|
1333
|
-
require: function (deps, callback,
|
1334
|
-
var moduleName,
|
1335
|
-
if (typeof deps ===
|
1410
|
+
require: function (deps, callback, errback, relMap) {
|
1411
|
+
var moduleName, id, map, requireMod, args;
|
1412
|
+
if (typeof deps === 'string') {
|
1336
1413
|
if (isFunction(callback)) {
|
1337
1414
|
//Invalid call
|
1338
|
-
return
|
1415
|
+
return onError(makeError('requireargs', 'Invalid require call'), errback);
|
1339
1416
|
}
|
1340
1417
|
|
1341
1418
|
//Synchronous access to one module. If require.get is
|
1342
1419
|
//available (as in the Node adapter), prefer that.
|
1343
1420
|
//In this case deps is the moduleName and callback is
|
1344
|
-
//the
|
1421
|
+
//the relMap
|
1345
1422
|
if (req.get) {
|
1346
1423
|
return req.get(context, deps, callback);
|
1347
1424
|
}
|
1348
1425
|
|
1349
1426
|
//Just return the module wanted. In this scenario, the
|
1350
|
-
//second arg (if passed) is just the
|
1427
|
+
//second arg (if passed) is just the relMap.
|
1351
1428
|
moduleName = deps;
|
1352
|
-
|
1429
|
+
relMap = callback;
|
1353
1430
|
|
1354
1431
|
//Normalize module name, if it contains . or ..
|
1355
|
-
|
1356
|
-
|
1432
|
+
map = makeModuleMap(moduleName, relMap, false, true);
|
1433
|
+
id = map.id;
|
1357
1434
|
|
1358
|
-
if (!(
|
1359
|
-
return
|
1360
|
-
|
1361
|
-
"
|
1435
|
+
if (!hasProp(defined, id)) {
|
1436
|
+
return onError(makeError('notloaded', 'Module name "' +
|
1437
|
+
id +
|
1438
|
+
'" has not been loaded yet for context: ' +
|
1362
1439
|
contextName));
|
1363
1440
|
}
|
1364
|
-
return defined[
|
1441
|
+
return defined[id];
|
1365
1442
|
}
|
1366
1443
|
|
1367
|
-
//
|
1368
|
-
//a
|
1369
|
-
if (
|
1370
|
-
|
1444
|
+
//Callback require. Normalize args. if callback or errback is
|
1445
|
+
//not a function, it means it is a relMap. Test errback first.
|
1446
|
+
if (errback && !isFunction(errback)) {
|
1447
|
+
relMap = errback;
|
1448
|
+
errback = undefined;
|
1371
1449
|
}
|
1450
|
+
if (callback && !isFunction(callback)) {
|
1451
|
+
relMap = callback;
|
1452
|
+
callback = undefined;
|
1453
|
+
}
|
1454
|
+
|
1455
|
+
//Any defined modules in the global queue, intake them now.
|
1456
|
+
takeGlobalQueue();
|
1372
1457
|
|
1373
|
-
//
|
1374
|
-
|
1375
|
-
|
1376
|
-
|
1377
|
-
|
1458
|
+
//Make sure any remaining defQueue items get properly processed.
|
1459
|
+
while (defQueue.length) {
|
1460
|
+
args = defQueue.shift();
|
1461
|
+
if (args[0] === null) {
|
1462
|
+
return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' + args[args.length - 1]));
|
1463
|
+
} else {
|
1464
|
+
//args are id, deps, factory. Should be normalized by the
|
1465
|
+
//define() function.
|
1466
|
+
callGetModule(args);
|
1378
1467
|
}
|
1379
1468
|
}
|
1469
|
+
|
1470
|
+
//Mark all the dependencies as needing to be loaded.
|
1471
|
+
requireMod = getModule(makeModuleMap(null, relMap));
|
1472
|
+
|
1473
|
+
requireMod.init(deps, callback, errback, {
|
1474
|
+
enabled: true
|
1475
|
+
});
|
1476
|
+
|
1477
|
+
checkLoaded();
|
1478
|
+
|
1380
1479
|
return context.require;
|
1381
1480
|
},
|
1382
1481
|
|
1482
|
+
undef: function (id) {
|
1483
|
+
var map = makeModuleMap(id, null, true),
|
1484
|
+
mod = registry[id];
|
1485
|
+
|
1486
|
+
delete defined[id];
|
1487
|
+
delete urlFetched[map.url];
|
1488
|
+
delete undefEvents[id];
|
1489
|
+
|
1490
|
+
if (mod) {
|
1491
|
+
//Hold on to listeners in case the
|
1492
|
+
//module will be attempted to be reloaded
|
1493
|
+
//using a different config.
|
1494
|
+
if (mod.events.defined) {
|
1495
|
+
undefEvents[id] = mod.events;
|
1496
|
+
}
|
1497
|
+
|
1498
|
+
removeWaiting(id);
|
1499
|
+
}
|
1500
|
+
},
|
1501
|
+
|
1383
1502
|
/**
|
1384
|
-
*
|
1385
|
-
*
|
1503
|
+
* Called to enable a module if it is still in the registry
|
1504
|
+
* awaiting enablement. parent module is passed in for context,
|
1505
|
+
* used by the optimizer.
|
1386
1506
|
*/
|
1387
|
-
|
1388
|
-
|
1389
|
-
if (
|
1390
|
-
|
1391
|
-
//local var ref to defQueue, so cannot just reassign the one
|
1392
|
-
//on context.
|
1393
|
-
apsp.apply(context.defQueue,
|
1394
|
-
[context.defQueue.length - 1, 0].concat(globalDefQueue));
|
1395
|
-
globalDefQueue = [];
|
1507
|
+
enable: function (depMap, parent) {
|
1508
|
+
var mod = registry[depMap.id];
|
1509
|
+
if (mod) {
|
1510
|
+
getModule(depMap).enable();
|
1396
1511
|
}
|
1397
1512
|
},
|
1398
1513
|
|
@@ -1403,51 +1518,55 @@ var requirejs, require, define;
|
|
1403
1518
|
* @param {String} moduleName the name of the module to potentially complete.
|
1404
1519
|
*/
|
1405
1520
|
completeLoad: function (moduleName) {
|
1406
|
-
var
|
1521
|
+
var shim = config.shim[moduleName] || {},
|
1522
|
+
shExports = shim.exports && shim.exports.exports,
|
1523
|
+
found, args, mod;
|
1407
1524
|
|
1408
|
-
|
1525
|
+
takeGlobalQueue();
|
1409
1526
|
|
1410
1527
|
while (defQueue.length) {
|
1411
1528
|
args = defQueue.shift();
|
1412
|
-
|
1413
1529
|
if (args[0] === null) {
|
1414
1530
|
args[0] = moduleName;
|
1415
|
-
|
1531
|
+
//If already found an anonymous module and bound it
|
1532
|
+
//to this name, then this is some other anon module
|
1533
|
+
//waiting for its completeLoad to fire.
|
1534
|
+
if (found) {
|
1535
|
+
break;
|
1536
|
+
}
|
1537
|
+
found = true;
|
1416
1538
|
} else if (args[0] === moduleName) {
|
1417
1539
|
//Found matching define call for this script!
|
1418
|
-
|
1419
|
-
} else {
|
1420
|
-
//Some other named define call, most likely the result
|
1421
|
-
//of a build layer that included many define calls.
|
1422
|
-
callDefMain(args);
|
1423
|
-
args = null;
|
1540
|
+
found = true;
|
1424
1541
|
}
|
1425
|
-
}
|
1426
|
-
if (args) {
|
1427
|
-
callDefMain(args);
|
1428
|
-
} else {
|
1429
|
-
//A script that does not call define(), so just simulate
|
1430
|
-
//the call for it. Special exception for jQuery dynamic load.
|
1431
|
-
callDefMain([moduleName, [],
|
1432
|
-
moduleName === "jquery" && typeof jQuery !== "undefined" ?
|
1433
|
-
function () {
|
1434
|
-
return jQuery;
|
1435
|
-
} : null]);
|
1436
|
-
}
|
1437
1542
|
|
1438
|
-
|
1439
|
-
//need to decrement after resume, otherwise it looks like
|
1440
|
-
//loading is complete after the first dependency is fetched.
|
1441
|
-
//For browsers, it works fine to decrement after, but it means
|
1442
|
-
//the checkLoaded setTimeout 50 ms cost is taken. To avoid
|
1443
|
-
//that cost, decrement beforehand.
|
1444
|
-
if (req.isAsync) {
|
1445
|
-
context.scriptCount -= 1;
|
1543
|
+
callGetModule(args);
|
1446
1544
|
}
|
1447
|
-
|
1448
|
-
|
1449
|
-
|
1545
|
+
|
1546
|
+
//Do this after the cycle of callGetModule in case the result
|
1547
|
+
//of those calls/init calls changes the registry.
|
1548
|
+
mod = registry[moduleName];
|
1549
|
+
|
1550
|
+
if (!found &&
|
1551
|
+
!defined[moduleName] &&
|
1552
|
+
mod && !mod.inited) {
|
1553
|
+
if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {
|
1554
|
+
if (hasPathFallback(moduleName)) {
|
1555
|
+
return;
|
1556
|
+
} else {
|
1557
|
+
return onError(makeError('nodefine',
|
1558
|
+
'No define call for ' + moduleName,
|
1559
|
+
null,
|
1560
|
+
[moduleName]));
|
1561
|
+
}
|
1562
|
+
} else {
|
1563
|
+
//A script that does not call define(), so just simulate
|
1564
|
+
//the call for it.
|
1565
|
+
callGetModule([moduleName, (shim.deps || []), shim.exports]);
|
1566
|
+
}
|
1450
1567
|
}
|
1568
|
+
|
1569
|
+
checkLoaded();
|
1451
1570
|
},
|
1452
1571
|
|
1453
1572
|
/**
|
@@ -1456,7 +1575,7 @@ var requirejs, require, define;
|
|
1456
1575
|
* plain URLs like nameToUrl.
|
1457
1576
|
*/
|
1458
1577
|
toUrl: function (moduleNamePlusExt, relModuleMap) {
|
1459
|
-
var index = moduleNamePlusExt.lastIndexOf(
|
1578
|
+
var index = moduleNamePlusExt.lastIndexOf('.'),
|
1460
1579
|
ext = null;
|
1461
1580
|
|
1462
1581
|
if (index !== -1) {
|
@@ -1473,10 +1592,10 @@ var requirejs, require, define;
|
|
1473
1592
|
*/
|
1474
1593
|
nameToUrl: function (moduleName, ext, relModuleMap) {
|
1475
1594
|
var paths, pkgs, pkg, pkgPath, syms, i, parentModule, url,
|
1476
|
-
|
1595
|
+
parentPath;
|
1477
1596
|
|
1478
1597
|
//Normalize module name if have a base relative module name to work from.
|
1479
|
-
moduleName = normalize(moduleName, relModuleMap && relModuleMap.
|
1598
|
+
moduleName = normalize(moduleName, relModuleMap && relModuleMap.id, true);
|
1480
1599
|
|
1481
1600
|
//If a colon is in the URL, it indicates a protocol is used and it is just
|
1482
1601
|
//an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
|
@@ -1486,22 +1605,29 @@ var requirejs, require, define;
|
|
1486
1605
|
//Just a plain path, not module name lookup, so just return it.
|
1487
1606
|
//Add extension if it is included. This is a bit wonky, only non-.js things pass
|
1488
1607
|
//an extension, this method probably needs to be reworked.
|
1489
|
-
url = moduleName + (ext
|
1608
|
+
url = moduleName + (ext || '');
|
1490
1609
|
} else {
|
1491
1610
|
//A module that needs to be converted to a path.
|
1492
1611
|
paths = config.paths;
|
1493
1612
|
pkgs = config.pkgs;
|
1494
1613
|
|
1495
|
-
syms = moduleName.split(
|
1614
|
+
syms = moduleName.split('/');
|
1496
1615
|
//For each module name segment, see if there is a path
|
1497
1616
|
//registered for it. Start with most specific name
|
1498
1617
|
//and work up from it.
|
1499
|
-
for (i = syms.length; i > 0; i
|
1500
|
-
parentModule = syms.slice(0, i).join(
|
1501
|
-
|
1502
|
-
|
1618
|
+
for (i = syms.length; i > 0; i -= 1) {
|
1619
|
+
parentModule = syms.slice(0, i).join('/');
|
1620
|
+
pkg = pkgs[parentModule];
|
1621
|
+
parentPath = paths[parentModule];
|
1622
|
+
if (parentPath) {
|
1623
|
+
//If an array, it means there are a few choices,
|
1624
|
+
//Choose the one that is desired
|
1625
|
+
if (isArray(parentPath)) {
|
1626
|
+
parentPath = parentPath[0];
|
1627
|
+
}
|
1628
|
+
syms.splice(0, i, parentPath);
|
1503
1629
|
break;
|
1504
|
-
} else if (
|
1630
|
+
} else if (pkg) {
|
1505
1631
|
//If module name is just the package name, then looking
|
1506
1632
|
//for the main module.
|
1507
1633
|
if (moduleName === pkg.name) {
|
@@ -1515,22 +1641,64 @@ var requirejs, require, define;
|
|
1515
1641
|
}
|
1516
1642
|
|
1517
1643
|
//Join the path parts together, then figure out if baseUrl is needed.
|
1518
|
-
url = syms.join(
|
1519
|
-
url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ?
|
1644
|
+
url = syms.join('/') + (ext || '.js');
|
1645
|
+
url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
|
1520
1646
|
}
|
1521
1647
|
|
1522
1648
|
return config.urlArgs ? url +
|
1523
1649
|
((url.indexOf('?') === -1 ? '?' : '&') +
|
1524
1650
|
config.urlArgs) : url;
|
1525
|
-
}
|
1526
|
-
|
1651
|
+
},
|
1652
|
+
|
1653
|
+
//Delegates to req.load. Broken out as a separate function to
|
1654
|
+
//allow overriding in the optimizer.
|
1655
|
+
load: function (id, url) {
|
1656
|
+
req.load(context, id, url);
|
1657
|
+
},
|
1658
|
+
|
1659
|
+
/**
|
1660
|
+
* Executes a module callack function. Broken out as a separate function
|
1661
|
+
* solely to allow the build system to sequence the files in the built
|
1662
|
+
* layer in the right sequence.
|
1663
|
+
*
|
1664
|
+
* @private
|
1665
|
+
*/
|
1666
|
+
execCb: function (name, callback, args, exports) {
|
1667
|
+
return callback.apply(exports, args);
|
1668
|
+
},
|
1527
1669
|
|
1528
|
-
|
1529
|
-
|
1530
|
-
|
1531
|
-
|
1670
|
+
/**
|
1671
|
+
* callback for script loads, used to check status of loading.
|
1672
|
+
*
|
1673
|
+
* @param {Event} evt the event from the browser for the script
|
1674
|
+
* that was loaded.
|
1675
|
+
*/
|
1676
|
+
onScriptLoad: function (evt) {
|
1677
|
+
//Using currentTarget instead of target for Firefox 2.0's sake. Not
|
1678
|
+
//all old browsers will be supported, but this one was easy enough
|
1679
|
+
//to support and still makes sense.
|
1680
|
+
if (evt.type === 'load' ||
|
1681
|
+
(readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {
|
1682
|
+
//Reset interactive script so a script node is not held onto for
|
1683
|
+
//to long.
|
1684
|
+
interactiveScript = null;
|
1685
|
+
|
1686
|
+
//Pull out the name of the module and the context.
|
1687
|
+
var data = getScriptData(evt);
|
1688
|
+
context.completeLoad(data.id);
|
1689
|
+
}
|
1690
|
+
},
|
1532
1691
|
|
1533
|
-
|
1692
|
+
/**
|
1693
|
+
* Callback for script errors.
|
1694
|
+
*/
|
1695
|
+
onScriptError: function (evt) {
|
1696
|
+
var data = getScriptData(evt);
|
1697
|
+
if (!hasPathFallback(data.id)) {
|
1698
|
+
return onError(makeError('scripterror', 'Script error', evt, [data.id]));
|
1699
|
+
}
|
1700
|
+
}
|
1701
|
+
});
|
1534
1702
|
}
|
1535
1703
|
|
1536
1704
|
/**
|
@@ -1547,20 +1715,21 @@ var requirejs, require, define;
|
|
1547
1715
|
* on a require that are not standardized), and to give a short
|
1548
1716
|
* name for minification/local scope use.
|
1549
1717
|
*/
|
1550
|
-
req = requirejs = function (deps, callback) {
|
1718
|
+
req = requirejs = function (deps, callback, errback, optional) {
|
1551
1719
|
|
1552
1720
|
//Find the right context, use default
|
1553
1721
|
var contextName = defContextName,
|
1554
1722
|
context, config;
|
1555
1723
|
|
1556
1724
|
// Determine if have config object in the call.
|
1557
|
-
if (!isArray(deps) && typeof deps !==
|
1725
|
+
if (!isArray(deps) && typeof deps !== 'string') {
|
1558
1726
|
// deps is a config object
|
1559
1727
|
config = deps;
|
1560
1728
|
if (isArray(callback)) {
|
1561
1729
|
// Adjust args if there are dependencies
|
1562
1730
|
deps = callback;
|
1563
|
-
callback =
|
1731
|
+
callback = errback;
|
1732
|
+
errback = optional;
|
1564
1733
|
} else {
|
1565
1734
|
deps = [];
|
1566
1735
|
}
|
@@ -1570,14 +1739,16 @@ var requirejs, require, define;
|
|
1570
1739
|
contextName = config.context;
|
1571
1740
|
}
|
1572
1741
|
|
1573
|
-
context = contexts[contextName]
|
1574
|
-
|
1742
|
+
context = contexts[contextName];
|
1743
|
+
if (!context) {
|
1744
|
+
context = contexts[contextName] = req.s.newContext(contextName);
|
1745
|
+
}
|
1575
1746
|
|
1576
1747
|
if (config) {
|
1577
1748
|
context.configure(config);
|
1578
1749
|
}
|
1579
1750
|
|
1580
|
-
return context.require(deps, callback);
|
1751
|
+
return context.require(deps, callback, errback);
|
1581
1752
|
};
|
1582
1753
|
|
1583
1754
|
/**
|
@@ -1595,31 +1766,29 @@ var requirejs, require, define;
|
|
1595
1766
|
require = req;
|
1596
1767
|
}
|
1597
1768
|
|
1598
|
-
/**
|
1599
|
-
* Global require.toUrl(), to match global require, mostly useful
|
1600
|
-
* for debugging/work in the global space.
|
1601
|
-
*/
|
1602
|
-
req.toUrl = function (moduleNamePlusExt) {
|
1603
|
-
return contexts[defContextName].toUrl(moduleNamePlusExt);
|
1604
|
-
};
|
1605
|
-
|
1606
1769
|
req.version = version;
|
1607
1770
|
|
1608
1771
|
//Used to filter out dependencies that are already paths.
|
1609
1772
|
req.jsExtRegExp = /^\/|:|\?|\.js$/;
|
1773
|
+
req.isBrowser = isBrowser;
|
1610
1774
|
s = req.s = {
|
1611
1775
|
contexts: contexts,
|
1612
|
-
|
1613
|
-
skipAsync: {}
|
1776
|
+
newContext: newContext
|
1614
1777
|
};
|
1615
1778
|
|
1616
|
-
|
1779
|
+
//Create default context.
|
1780
|
+
req({});
|
1781
|
+
|
1782
|
+
//Exports some context-sensitive methods on global require, using
|
1783
|
+
//default context if no context specified.
|
1784
|
+
addRequireMethods(req);
|
1785
|
+
|
1617
1786
|
if (isBrowser) {
|
1618
|
-
head = s.head = document.getElementsByTagName(
|
1787
|
+
head = s.head = document.getElementsByTagName('head')[0];
|
1619
1788
|
//If BASE tag is in play, using appendChild is a problem for IE6.
|
1620
1789
|
//When that browser dies, this can be removed. Details in this jQuery bug:
|
1621
1790
|
//http://dev.jquery.com/ticket/2709
|
1622
|
-
baseElement = document.getElementsByTagName(
|
1791
|
+
baseElement = document.getElementsByTagName('base')[0];
|
1623
1792
|
if (baseElement) {
|
1624
1793
|
head = s.head = baseElement.parentNode;
|
1625
1794
|
}
|
@@ -1644,34 +1813,139 @@ var requirejs, require, define;
|
|
1644
1813
|
* @param {Object} url the URL to the module.
|
1645
1814
|
*/
|
1646
1815
|
req.load = function (context, moduleName, url) {
|
1647
|
-
|
1816
|
+
var config = (context && context.config) || {},
|
1817
|
+
node;
|
1818
|
+
if (isBrowser) {
|
1819
|
+
//In the browser so use a script tag
|
1820
|
+
node = config.xhtml ?
|
1821
|
+
document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') :
|
1822
|
+
document.createElement('script');
|
1823
|
+
node.type = config.scriptType || 'text/javascript';
|
1824
|
+
node.charset = 'utf-8';
|
1825
|
+
|
1826
|
+
node.setAttribute('data-requirecontext', context.contextName);
|
1827
|
+
node.setAttribute('data-requiremodule', moduleName);
|
1828
|
+
|
1829
|
+
//Set up load listener. Test attachEvent first because IE9 has
|
1830
|
+
//a subtle issue in its addEventListener and script onload firings
|
1831
|
+
//that do not match the behavior of all other browsers with
|
1832
|
+
//addEventListener support, which fire the onload event for a
|
1833
|
+
//script right after the script execution. See:
|
1834
|
+
//https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
|
1835
|
+
//UNFORTUNATELY Opera implements attachEvent but does not follow the script
|
1836
|
+
//script execution mode.
|
1837
|
+
if (node.attachEvent &&
|
1838
|
+
//Check if node.attachEvent is artificially added by custom script or
|
1839
|
+
//natively supported by browser
|
1840
|
+
//read https://github.com/jrburke/requirejs/issues/187
|
1841
|
+
//if we can NOT find [native code] then it must NOT natively supported.
|
1842
|
+
//in IE8, node.attachEvent does not have toString()
|
1843
|
+
//Note the test for "[native code" with no closing brace, see:
|
1844
|
+
//https://github.com/jrburke/requirejs/issues/273
|
1845
|
+
!(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
|
1846
|
+
!isOpera) {
|
1847
|
+
//Probably IE. IE (at least 6-8) do not fire
|
1848
|
+
//script onload right after executing the script, so
|
1849
|
+
//we cannot tie the anonymous define call to a name.
|
1850
|
+
//However, IE reports the script as being in 'interactive'
|
1851
|
+
//readyState at the time of the define call.
|
1852
|
+
useInteractive = true;
|
1853
|
+
|
1854
|
+
node.attachEvent('onreadystatechange', context.onScriptLoad);
|
1855
|
+
//It would be great to add an error handler here to catch
|
1856
|
+
//404s in IE9+. However, onreadystatechange will fire before
|
1857
|
+
//the error handler, so that does not help. If addEvenListener
|
1858
|
+
//is used, then IE will fire error before load, but we cannot
|
1859
|
+
//use that pathway given the connect.microsoft.com issue
|
1860
|
+
//mentioned above about not doing the 'script execute,
|
1861
|
+
//then fire the script load event listener before execute
|
1862
|
+
//next script' that other browsers do.
|
1863
|
+
//Best hope: IE10 fixes the issues,
|
1864
|
+
//and then destroys all installs of IE 6-9.
|
1865
|
+
//node.attachEvent('onerror', context.onScriptError);
|
1866
|
+
} else {
|
1867
|
+
node.addEventListener('load', context.onScriptLoad, false);
|
1868
|
+
node.addEventListener('error', context.onScriptError, false);
|
1869
|
+
}
|
1870
|
+
node.src = url;
|
1871
|
+
|
1872
|
+
//For some cache cases in IE 6-8, the script executes before the end
|
1873
|
+
//of the appendChild execution, so to tie an anonymous define
|
1874
|
+
//call to the module name (which is stored on the node), hold on
|
1875
|
+
//to a reference to this node, but clear after the DOM insertion.
|
1876
|
+
currentlyAddingScript = node;
|
1877
|
+
if (baseElement) {
|
1878
|
+
head.insertBefore(node, baseElement);
|
1879
|
+
} else {
|
1880
|
+
head.appendChild(node);
|
1881
|
+
}
|
1882
|
+
currentlyAddingScript = null;
|
1648
1883
|
|
1649
|
-
|
1650
|
-
|
1884
|
+
return node;
|
1885
|
+
} else if (isWebWorker) {
|
1886
|
+
//In a web worker, use importScripts. This is not a very
|
1887
|
+
//efficient use of importScripts, importScripts will block until
|
1888
|
+
//its script is downloaded and evaluated. However, if web workers
|
1889
|
+
//are in play, the expectation that a build has been done so that
|
1890
|
+
//only one script needs to be loaded anyway. This may need to be
|
1891
|
+
//reevaluated if other use cases become common.
|
1892
|
+
importScripts(url);
|
1651
1893
|
|
1652
|
-
|
1653
|
-
|
1654
|
-
//triggering too soon.
|
1655
|
-
if (context.jQuery && !context.jQueryIncremented) {
|
1656
|
-
jQueryHoldReady(context.jQuery, true);
|
1657
|
-
context.jQueryIncremented = true;
|
1894
|
+
//Account for anonymous modules
|
1895
|
+
context.completeLoad(moduleName);
|
1658
1896
|
}
|
1659
1897
|
};
|
1660
1898
|
|
1661
1899
|
function getInteractiveScript() {
|
1662
|
-
var scripts, i, script;
|
1663
1900
|
if (interactiveScript && interactiveScript.readyState === 'interactive') {
|
1664
1901
|
return interactiveScript;
|
1665
1902
|
}
|
1666
1903
|
|
1667
|
-
scripts
|
1668
|
-
for (i = scripts.length - 1; i > -1 && (script = scripts[i]); i--) {
|
1904
|
+
eachReverse(scripts(), function (script) {
|
1669
1905
|
if (script.readyState === 'interactive') {
|
1670
1906
|
return (interactiveScript = script);
|
1671
1907
|
}
|
1672
|
-
}
|
1908
|
+
});
|
1909
|
+
return interactiveScript;
|
1910
|
+
}
|
1911
|
+
|
1912
|
+
//Look for a data-main script attribute, which could also adjust the baseUrl.
|
1913
|
+
if (isBrowser) {
|
1914
|
+
//Figure out baseUrl. Get it from the script tag with require.js in it.
|
1915
|
+
eachReverse(scripts(), function (script) {
|
1916
|
+
//Set the 'head' where we can append children by
|
1917
|
+
//using the script's parent.
|
1918
|
+
if (!head) {
|
1919
|
+
head = script.parentNode;
|
1920
|
+
}
|
1921
|
+
|
1922
|
+
//Look for a data-main attribute to set main script for the page
|
1923
|
+
//to load. If it is there, the path to data main becomes the
|
1924
|
+
//baseUrl, if it is not already set.
|
1925
|
+
dataMain = script.getAttribute('data-main');
|
1926
|
+
if (dataMain) {
|
1927
|
+
|
1928
|
+
//Pull off the directory of data-main for use as the
|
1929
|
+
//baseUrl.
|
1930
|
+
src = dataMain.split('/');
|
1931
|
+
mainScript = src.pop();
|
1932
|
+
subPath = src.length ? src.join('/') + '/' : './';
|
1933
|
+
|
1934
|
+
//Set final baseUrl if there is not already an explicit one.
|
1935
|
+
if (!cfg.baseUrl) {
|
1936
|
+
cfg.baseUrl = subPath;
|
1937
|
+
}
|
1938
|
+
|
1939
|
+
//Strip off any trailing .js since dataMain is now
|
1940
|
+
//like a module name.
|
1941
|
+
dataMain = mainScript.replace(jsSuffixRegExp, '');
|
1673
1942
|
|
1674
|
-
|
1943
|
+
//Put the data-main script in the files to load.
|
1944
|
+
cfg.deps = cfg.deps ? cfg.deps.concat(dataMain) : [dataMain];
|
1945
|
+
|
1946
|
+
return true;
|
1947
|
+
}
|
1948
|
+
});
|
1675
1949
|
}
|
1676
1950
|
|
1677
1951
|
/**
|
@@ -1707,7 +1981,7 @@ var requirejs, require, define;
|
|
1707
1981
|
if (callback.length) {
|
1708
1982
|
callback
|
1709
1983
|
.toString()
|
1710
|
-
.replace(commentRegExp,
|
1984
|
+
.replace(commentRegExp, '')
|
1711
1985
|
.replace(cjsRequireRegExp, function (match, dep) {
|
1712
1986
|
deps.push(dep);
|
1713
1987
|
});
|
@@ -1717,7 +1991,7 @@ var requirejs, require, define;
|
|
1717
1991
|
//work though if it just needs require.
|
1718
1992
|
//REQUIRES the function to expect the CommonJS variables in the
|
1719
1993
|
//order listed below.
|
1720
|
-
deps = (callback.length === 1 ? [
|
1994
|
+
deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
|
1721
1995
|
}
|
1722
1996
|
}
|
1723
1997
|
|
@@ -1727,9 +2001,9 @@ var requirejs, require, define;
|
|
1727
2001
|
node = currentlyAddingScript || getInteractiveScript();
|
1728
2002
|
if (node) {
|
1729
2003
|
if (!name) {
|
1730
|
-
name = node.getAttribute(
|
2004
|
+
name = node.getAttribute('data-requiremodule');
|
1731
2005
|
}
|
1732
|
-
context = contexts[node.getAttribute(
|
2006
|
+
context = contexts[node.getAttribute('data-requirecontext')];
|
1733
2007
|
}
|
1734
2008
|
}
|
1735
2009
|
|
@@ -1740,324 +2014,24 @@ var requirejs, require, define;
|
|
1740
2014
|
//occurs. If no context, use the global queue, and get it processed
|
1741
2015
|
//in the onscript load callback.
|
1742
2016
|
(context ? context.defQueue : globalDefQueue).push([name, deps, callback]);
|
1743
|
-
|
1744
|
-
return undefined;
|
1745
2017
|
};
|
1746
2018
|
|
1747
2019
|
define.amd = {
|
1748
|
-
multiversion: true,
|
1749
|
-
plugins: true,
|
1750
2020
|
jQuery: true
|
1751
2021
|
};
|
1752
2022
|
|
2023
|
+
|
1753
2024
|
/**
|
1754
2025
|
* Executes the text. Normally just uses eval, but can be modified
|
1755
|
-
* to use a
|
2026
|
+
* to use a better, environment-specific call. Only used for transpiling
|
2027
|
+
* loader plugins, not for plain JS modules.
|
1756
2028
|
* @param {String} text the text to execute/evaluate.
|
1757
2029
|
*/
|
1758
2030
|
req.exec = function (text) {
|
2031
|
+
/*jslint evil: true */
|
1759
2032
|
return eval(text);
|
1760
2033
|
};
|
1761
2034
|
|
1762
|
-
|
1763
|
-
* Executes a module callack function. Broken out as a separate function
|
1764
|
-
* solely to allow the build system to sequence the files in the built
|
1765
|
-
* layer in the right sequence.
|
1766
|
-
*
|
1767
|
-
* @private
|
1768
|
-
*/
|
1769
|
-
req.execCb = function (name, callback, args, exports) {
|
1770
|
-
return callback.apply(exports, args);
|
1771
|
-
};
|
1772
|
-
|
1773
|
-
|
1774
|
-
/**
|
1775
|
-
* Adds a node to the DOM. Public function since used by the order plugin.
|
1776
|
-
* This method should not normally be called by outside code.
|
1777
|
-
*/
|
1778
|
-
req.addScriptToDom = function (node) {
|
1779
|
-
//For some cache cases in IE 6-8, the script executes before the end
|
1780
|
-
//of the appendChild execution, so to tie an anonymous define
|
1781
|
-
//call to the module name (which is stored on the node), hold on
|
1782
|
-
//to a reference to this node, but clear after the DOM insertion.
|
1783
|
-
currentlyAddingScript = node;
|
1784
|
-
if (baseElement) {
|
1785
|
-
head.insertBefore(node, baseElement);
|
1786
|
-
} else {
|
1787
|
-
head.appendChild(node);
|
1788
|
-
}
|
1789
|
-
currentlyAddingScript = null;
|
1790
|
-
};
|
1791
|
-
|
1792
|
-
/**
|
1793
|
-
* callback for script loads, used to check status of loading.
|
1794
|
-
*
|
1795
|
-
* @param {Event} evt the event from the browser for the script
|
1796
|
-
* that was loaded.
|
1797
|
-
*
|
1798
|
-
* @private
|
1799
|
-
*/
|
1800
|
-
req.onScriptLoad = function (evt) {
|
1801
|
-
//Using currentTarget instead of target for Firefox 2.0's sake. Not
|
1802
|
-
//all old browsers will be supported, but this one was easy enough
|
1803
|
-
//to support and still makes sense.
|
1804
|
-
var node = evt.currentTarget || evt.srcElement, contextName, moduleName,
|
1805
|
-
context;
|
1806
|
-
|
1807
|
-
if (evt.type === "load" || (node && readyRegExp.test(node.readyState))) {
|
1808
|
-
//Reset interactive script so a script node is not held onto for
|
1809
|
-
//to long.
|
1810
|
-
interactiveScript = null;
|
1811
|
-
|
1812
|
-
//Pull out the name of the module and the context.
|
1813
|
-
contextName = node.getAttribute("data-requirecontext");
|
1814
|
-
moduleName = node.getAttribute("data-requiremodule");
|
1815
|
-
context = contexts[contextName];
|
1816
|
-
|
1817
|
-
contexts[contextName].completeLoad(moduleName);
|
1818
|
-
|
1819
|
-
//Clean up script binding. Favor detachEvent because of IE9
|
1820
|
-
//issue, see attachEvent/addEventListener comment elsewhere
|
1821
|
-
//in this file.
|
1822
|
-
if (node.detachEvent && !isOpera) {
|
1823
|
-
//Probably IE. If not it will throw an error, which will be
|
1824
|
-
//useful to know.
|
1825
|
-
node.detachEvent("onreadystatechange", req.onScriptLoad);
|
1826
|
-
} else {
|
1827
|
-
node.removeEventListener("load", req.onScriptLoad, false);
|
1828
|
-
}
|
1829
|
-
}
|
1830
|
-
};
|
1831
|
-
|
1832
|
-
/**
|
1833
|
-
* Attaches the script represented by the URL to the current
|
1834
|
-
* environment. Right now only supports browser loading,
|
1835
|
-
* but can be redefined in other environments to do the right thing.
|
1836
|
-
* @param {String} url the url of the script to attach.
|
1837
|
-
* @param {Object} context the context that wants the script.
|
1838
|
-
* @param {moduleName} the name of the module that is associated with the script.
|
1839
|
-
* @param {Function} [callback] optional callback, defaults to require.onScriptLoad
|
1840
|
-
* @param {String} [type] optional type, defaults to text/javascript
|
1841
|
-
* @param {Function} [fetchOnlyFunction] optional function to indicate the script node
|
1842
|
-
* should be set up to fetch the script but do not attach it to the DOM
|
1843
|
-
* so that it can later be attached to execute it. This is a way for the
|
1844
|
-
* order plugin to support ordered loading in IE. Once the script is fetched,
|
1845
|
-
* but not executed, the fetchOnlyFunction will be called.
|
1846
|
-
*/
|
1847
|
-
req.attach = function (url, context, moduleName, callback, type, fetchOnlyFunction) {
|
1848
|
-
var node;
|
1849
|
-
if (isBrowser) {
|
1850
|
-
//In the browser so use a script tag
|
1851
|
-
callback = callback || req.onScriptLoad;
|
1852
|
-
node = context && context.config && context.config.xhtml ?
|
1853
|
-
document.createElementNS("http://www.w3.org/1999/xhtml", "html:script") :
|
1854
|
-
document.createElement("script");
|
1855
|
-
node.type = type || (context && context.config.scriptType) ||
|
1856
|
-
"text/javascript";
|
1857
|
-
node.charset = "utf-8";
|
1858
|
-
//Use async so Gecko does not block on executing the script if something
|
1859
|
-
//like a long-polling comet tag is being run first. Gecko likes
|
1860
|
-
//to evaluate scripts in DOM order, even for dynamic scripts.
|
1861
|
-
//It will fetch them async, but only evaluate the contents in DOM
|
1862
|
-
//order, so a long-polling script tag can delay execution of scripts
|
1863
|
-
//after it. But telling Gecko we expect async gets us the behavior
|
1864
|
-
//we want -- execute it whenever it is finished downloading. Only
|
1865
|
-
//Helps Firefox 3.6+
|
1866
|
-
//Allow some URLs to not be fetched async. Mostly helps the order!
|
1867
|
-
//plugin
|
1868
|
-
node.async = !s.skipAsync[url];
|
1869
|
-
|
1870
|
-
if (context) {
|
1871
|
-
node.setAttribute("data-requirecontext", context.contextName);
|
1872
|
-
}
|
1873
|
-
node.setAttribute("data-requiremodule", moduleName);
|
1874
|
-
|
1875
|
-
//Set up load listener. Test attachEvent first because IE9 has
|
1876
|
-
//a subtle issue in its addEventListener and script onload firings
|
1877
|
-
//that do not match the behavior of all other browsers with
|
1878
|
-
//addEventListener support, which fire the onload event for a
|
1879
|
-
//script right after the script execution. See:
|
1880
|
-
//https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
|
1881
|
-
//UNFORTUNATELY Opera implements attachEvent but does not follow the script
|
1882
|
-
//script execution mode.
|
1883
|
-
if (node.attachEvent &&
|
1884
|
-
// check if node.attachEvent is artificially added by custom script or
|
1885
|
-
// natively supported by browser
|
1886
|
-
// read https://github.com/jrburke/requirejs/issues/187
|
1887
|
-
// if we can NOT find [native code] then it must NOT natively supported.
|
1888
|
-
// in IE8, node.attachEvent does not have toString()
|
1889
|
-
// TODO: a better way to check interactive mode
|
1890
|
-
!(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code]') < 0) &&
|
1891
|
-
!isOpera) {
|
1892
|
-
//Probably IE. IE (at least 6-8) do not fire
|
1893
|
-
//script onload right after executing the script, so
|
1894
|
-
//we cannot tie the anonymous define call to a name.
|
1895
|
-
//However, IE reports the script as being in "interactive"
|
1896
|
-
//readyState at the time of the define call.
|
1897
|
-
useInteractive = true;
|
1898
|
-
|
1899
|
-
|
1900
|
-
if (fetchOnlyFunction) {
|
1901
|
-
//Need to use old school onreadystate here since
|
1902
|
-
//when the event fires and the node is not attached
|
1903
|
-
//to the DOM, the evt.srcElement is null, so use
|
1904
|
-
//a closure to remember the node.
|
1905
|
-
node.onreadystatechange = function (evt) {
|
1906
|
-
//Script loaded but not executed.
|
1907
|
-
//Clear loaded handler, set the real one that
|
1908
|
-
//waits for script execution.
|
1909
|
-
if (node.readyState === 'loaded') {
|
1910
|
-
node.onreadystatechange = null;
|
1911
|
-
node.attachEvent("onreadystatechange", callback);
|
1912
|
-
fetchOnlyFunction(node);
|
1913
|
-
}
|
1914
|
-
};
|
1915
|
-
} else {
|
1916
|
-
node.attachEvent("onreadystatechange", callback);
|
1917
|
-
}
|
1918
|
-
} else {
|
1919
|
-
node.addEventListener("load", callback, false);
|
1920
|
-
}
|
1921
|
-
node.src = url;
|
1922
|
-
|
1923
|
-
//Fetch only means waiting to attach to DOM after loaded.
|
1924
|
-
if (!fetchOnlyFunction) {
|
1925
|
-
req.addScriptToDom(node);
|
1926
|
-
}
|
1927
|
-
|
1928
|
-
return node;
|
1929
|
-
} else if (isWebWorker) {
|
1930
|
-
//In a web worker, use importScripts. This is not a very
|
1931
|
-
//efficient use of importScripts, importScripts will block until
|
1932
|
-
//its script is downloaded and evaluated. However, if web workers
|
1933
|
-
//are in play, the expectation that a build has been done so that
|
1934
|
-
//only one script needs to be loaded anyway. This may need to be
|
1935
|
-
//reevaluated if other use cases become common.
|
1936
|
-
importScripts(url);
|
1937
|
-
|
1938
|
-
//Account for anonymous modules
|
1939
|
-
context.completeLoad(moduleName);
|
1940
|
-
}
|
1941
|
-
return null;
|
1942
|
-
};
|
1943
|
-
|
1944
|
-
//Look for a data-main script attribute, which could also adjust the baseUrl.
|
1945
|
-
if (isBrowser) {
|
1946
|
-
//Figure out baseUrl. Get it from the script tag with require.js in it.
|
1947
|
-
scripts = document.getElementsByTagName("script");
|
1948
|
-
|
1949
|
-
for (globalI = scripts.length - 1; globalI > -1 && (script = scripts[globalI]); globalI--) {
|
1950
|
-
//Set the "head" where we can append children by
|
1951
|
-
//using the script's parent.
|
1952
|
-
if (!head) {
|
1953
|
-
head = script.parentNode;
|
1954
|
-
}
|
1955
|
-
|
1956
|
-
//Look for a data-main attribute to set main script for the page
|
1957
|
-
//to load. If it is there, the path to data main becomes the
|
1958
|
-
//baseUrl, if it is not already set.
|
1959
|
-
if ((dataMain = script.getAttribute('data-main'))) {
|
1960
|
-
if (!cfg.baseUrl) {
|
1961
|
-
//Pull off the directory of data-main for use as the
|
1962
|
-
//baseUrl.
|
1963
|
-
src = dataMain.split('/');
|
1964
|
-
mainScript = src.pop();
|
1965
|
-
subPath = src.length ? src.join('/') + '/' : './';
|
1966
|
-
|
1967
|
-
//Set final config.
|
1968
|
-
cfg.baseUrl = subPath;
|
1969
|
-
//Strip off any trailing .js since dataMain is now
|
1970
|
-
//like a module name.
|
1971
|
-
dataMain = mainScript.replace(jsSuffixRegExp, '');
|
1972
|
-
}
|
1973
|
-
|
1974
|
-
//Put the data-main script in the files to load.
|
1975
|
-
cfg.deps = cfg.deps ? cfg.deps.concat(dataMain) : [dataMain];
|
1976
|
-
|
1977
|
-
break;
|
1978
|
-
}
|
1979
|
-
}
|
1980
|
-
}
|
1981
|
-
|
1982
|
-
//See if there is nothing waiting across contexts, and if not, trigger
|
1983
|
-
//resourcesReady.
|
1984
|
-
req.checkReadyState = function () {
|
1985
|
-
var contexts = s.contexts, prop;
|
1986
|
-
for (prop in contexts) {
|
1987
|
-
if (!(prop in empty)) {
|
1988
|
-
if (contexts[prop].waitCount) {
|
1989
|
-
return;
|
1990
|
-
}
|
1991
|
-
}
|
1992
|
-
}
|
1993
|
-
req.resourcesReady(true);
|
1994
|
-
};
|
1995
|
-
|
1996
|
-
/**
|
1997
|
-
* Internal function that is triggered whenever all scripts/resources
|
1998
|
-
* have been loaded by the loader. Can be overridden by other, for
|
1999
|
-
* instance the domReady plugin, which wants to know when all resources
|
2000
|
-
* are loaded.
|
2001
|
-
*/
|
2002
|
-
req.resourcesReady = function (isReady) {
|
2003
|
-
var contexts, context, prop;
|
2004
|
-
|
2005
|
-
//First, set the public variable indicating that resources are loading.
|
2006
|
-
req.resourcesDone = isReady;
|
2007
|
-
|
2008
|
-
if (req.resourcesDone) {
|
2009
|
-
//If jQuery with DOM ready delayed, release it now.
|
2010
|
-
contexts = s.contexts;
|
2011
|
-
for (prop in contexts) {
|
2012
|
-
if (!(prop in empty)) {
|
2013
|
-
context = contexts[prop];
|
2014
|
-
if (context.jQueryIncremented) {
|
2015
|
-
jQueryHoldReady(context.jQuery, false);
|
2016
|
-
context.jQueryIncremented = false;
|
2017
|
-
}
|
2018
|
-
}
|
2019
|
-
}
|
2020
|
-
}
|
2021
|
-
};
|
2022
|
-
|
2023
|
-
//FF < 3.6 readyState fix. Needed so that domReady plugin
|
2024
|
-
//works well in that environment, since require.js is normally
|
2025
|
-
//loaded via an HTML script tag so it will be there before window load,
|
2026
|
-
//where the domReady plugin is more likely to be loaded after window load.
|
2027
|
-
req.pageLoaded = function () {
|
2028
|
-
if (document.readyState !== "complete") {
|
2029
|
-
document.readyState = "complete";
|
2030
|
-
}
|
2031
|
-
};
|
2032
|
-
if (isBrowser) {
|
2033
|
-
if (document.addEventListener) {
|
2034
|
-
if (!document.readyState) {
|
2035
|
-
document.readyState = "loading";
|
2036
|
-
window.addEventListener("load", req.pageLoaded, false);
|
2037
|
-
}
|
2038
|
-
}
|
2039
|
-
}
|
2040
|
-
|
2041
|
-
//Set up default context. If require was a configuration object, use that as base config.
|
2035
|
+
//Set up with config info.
|
2042
2036
|
req(cfg);
|
2043
|
-
|
2044
|
-
//If modules are built into require.js, then need to make sure dependencies are
|
2045
|
-
//traced. Use a setTimeout in the browser world, to allow all the modules to register
|
2046
|
-
//themselves. In a non-browser env, assume that modules are not built into require.js,
|
2047
|
-
//which seems odd to do on the server.
|
2048
|
-
if (req.isAsync && typeof setTimeout !== "undefined") {
|
2049
|
-
ctx = s.contexts[(cfg.context || defContextName)];
|
2050
|
-
//Indicate that the script that includes require() is still loading,
|
2051
|
-
//so that require()'d dependencies are not traced until the end of the
|
2052
|
-
//file is parsed (approximated via the setTimeout call).
|
2053
|
-
ctx.requireWait = true;
|
2054
|
-
setTimeout(function () {
|
2055
|
-
ctx.requireWait = false;
|
2056
|
-
|
2057
|
-
if (!ctx.scriptCount) {
|
2058
|
-
ctx.resume();
|
2059
|
-
}
|
2060
|
-
req.checkReadyState();
|
2061
|
-
}, 0);
|
2062
|
-
}
|
2063
|
-
}());
|
2037
|
+
}(this));
|