1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
|
/*
SystemJS Loader Plugin Support
Supports plugin loader syntax with "!", or via metadata.loader
The plugin name is loaded as a module itself, and can override standard loader hooks
for the plugin resource. See the plugin section of the systemjs readme.
*/
(function() {
function getParentName(loader, parentName) {
// if parent is a plugin, normalize against the parent plugin argument only
if (parentName) {
var parentPluginIndex;
if (loader.pluginFirst) {
if ((parentPluginIndex = parentName.lastIndexOf('!')) != -1)
return parentName.substr(parentPluginIndex + 1);
}
else {
if ((parentPluginIndex = parentName.indexOf('!')) != -1)
return parentName.substr(0, parentPluginIndex);
}
return parentName;
}
}
function parsePlugin(loader, name) {
var argumentName;
var pluginName;
var pluginIndex = name.lastIndexOf('!');
if (pluginIndex == -1)
return;
if (loader.pluginFirst) {
argumentName = name.substr(pluginIndex + 1);
pluginName = name.substr(0, pluginIndex);
}
else {
argumentName = name.substr(0, pluginIndex);
pluginName = name.substr(pluginIndex + 1) || argumentName.substr(argumentName.lastIndexOf('.') + 1);
}
return {
argument: argumentName,
plugin: pluginName
};
}
// put name back together after parts have been normalized
function combinePluginParts(loader, argumentName, pluginName, defaultExtension) {
if (defaultExtension && argumentName.substr(argumentName.length - 3, 3) == '.js')
argumentName = argumentName.substr(0, argumentName.length - 3);
if (loader.pluginFirst) {
return pluginName + '!' + argumentName;
}
else {
return argumentName + '!' + pluginName;
}
}
// note if normalize will add a default js extension
// if so, remove for backwards compat
// this is strange and sucks, but will be deprecated
function checkDefaultExtension(loader, arg) {
return loader.defaultJSExtensions && arg.substr(arg.length - 3, 3) != '.js';
}
function createNormalizeSync(normalizeSync) {
return function(name, parentName, isPlugin) {
var loader = this;
var parsed = parsePlugin(loader, name);
parentName = getParentName(this, parentName);
if (!parsed)
return normalizeSync.call(this, name, parentName, isPlugin);
// if this is a plugin, normalize the plugin name and the argument
var argumentName = loader.normalizeSync(parsed.argument, parentName, true);
var pluginName = loader.normalizeSync(parsed.plugin, parentName, true);
return combinePluginParts(loader, argumentName, pluginName, checkDefaultExtension(loader, parsed.argument));
};
}
hook('decanonicalize', createNormalizeSync);
hook('normalizeSync', createNormalizeSync);
hook('normalize', function(normalize) {
return function(name, parentName, isPlugin) {
var loader = this;
parentName = getParentName(this, parentName);
var parsed = parsePlugin(loader, name);
if (!parsed)
return normalize.call(loader, name, parentName, isPlugin);
return Promise.all([
loader.normalize(parsed.argument, parentName, true),
loader.normalize(parsed.plugin, parentName, false)
])
.then(function(normalized) {
return combinePluginParts(loader, normalized[0], normalized[1], checkDefaultExtension(loader, parsed.argument));
});
}
});
hook('locate', function(locate) {
return function(load) {
var loader = this;
var name = load.name;
// plugin syntax
var pluginSyntaxIndex;
if (loader.pluginFirst) {
if ((pluginSyntaxIndex = name.indexOf('!')) != -1) {
load.metadata.loader = name.substr(0, pluginSyntaxIndex);
load.name = name.substr(pluginSyntaxIndex + 1);
}
}
else {
if ((pluginSyntaxIndex = name.lastIndexOf('!')) != -1) {
load.metadata.loader = name.substr(pluginSyntaxIndex + 1);
load.name = name.substr(0, pluginSyntaxIndex);
}
}
return locate.call(loader, load)
.then(function(address) {
if (pluginSyntaxIndex != -1 || !load.metadata.loader)
return address;
// normalize plugin relative to parent in locate here when
// using plugin via loader metadata
return (loader.pluginLoader || loader).normalize(load.metadata.loader, load.name)
.then(function(loaderNormalized) {
load.metadata.loader = loaderNormalized;
return address;
});
})
.then(function(address) {
var plugin = load.metadata.loader;
if (!plugin)
return address;
// don't allow a plugin to load itself
if (load.name == plugin)
throw new Error('Plugin ' + plugin + ' cannot load itself, make sure it is excluded from any wildcard meta configuration via a custom loader: false rule.');
// only fetch the plugin itself if this name isn't defined
if (loader.defined && loader.defined[name])
return address;
var pluginLoader = loader.pluginLoader || loader;
// load the plugin module and run standard locate
return pluginLoader['import'](plugin)
.then(function(loaderModule) {
// store the plugin module itself on the metadata
load.metadata.loaderModule = loaderModule;
load.address = address;
if (loaderModule.locate)
return loaderModule.locate.call(loader, load);
return address;
});
});
};
});
hook('fetch', function(fetch) {
return function(load) {
var loader = this;
if (load.metadata.loaderModule && load.metadata.loaderModule.fetch && load.metadata.format != 'defined') {
load.metadata.scriptLoad = false;
return load.metadata.loaderModule.fetch.call(loader, load, function(load) {
return fetch.call(loader, load);
});
}
else {
return fetch.call(loader, load);
}
};
});
hook('translate', function(translate) {
return function(load) {
var loader = this;
var args = arguments;
if (load.metadata.loaderModule && load.metadata.loaderModule.translate && load.metadata.format != 'defined') {
return Promise.resolve(load.metadata.loaderModule.translate.apply(loader, args)).then(function(result) {
var sourceMap = load.metadata.sourceMap;
// sanitize sourceMap if an object not a JSON string
if (sourceMap) {
if (typeof sourceMap != 'object')
throw new Error('load.metadata.sourceMap must be set to an object.');
var originalName = load.address.split('!')[0];
// force set the filename of the original file
if (!sourceMap.file || sourceMap.file == load.address)
sourceMap.file = originalName + '!transpiled';
// force set the sources list if only one source
if (!sourceMap.sources || sourceMap.sources.length <= 1 && (!sourceMap.sources[0] || sourceMap.sources[0] == load.address))
sourceMap.sources = [originalName];
}
// if running on file:/// URLs, sourcesContent is necessary
// load.metadata.sourceMap.sourcesContent = [load.source];
if (typeof result == 'string')
load.source = result;
else
warn.call(this, 'Plugin ' + load.metadata.loader + ' should return the source in translate, instead of setting load.source directly. This support will be deprecated.');
return translate.apply(loader, args);
});
}
else {
return translate.apply(loader, args);
}
};
});
hook('instantiate', function(instantiate) {
return function(load) {
var loader = this;
var calledInstantiate = false;
if (load.metadata.loaderModule && load.metadata.loaderModule.instantiate && !loader.builder && load.metadata.format != 'defined')
return Promise.resolve(load.metadata.loaderModule.instantiate.call(loader, load, function(load) {
if (calledInstantiate)
throw new Error('Instantiate must only be called once.');
calledInstantiate = true;
return instantiate.call(loader, load);
})).then(function(result) {
if (calledInstantiate)
return result;
load.metadata.entry = createEntry();
load.metadata.entry.execute = function() {
return result;
}
load.metadata.entry.deps = load.metadata.deps;
load.metadata.format = 'defined';
return instantiate.call(loader, load);
});
else
return instantiate.call(loader, load);
};
});
})();
|
