mirror of
https://github.com/whoisclebs/lodash.git
synced 2026-02-11 11:27:50 +00:00
Update vendors.
Former-commit-id: e88301bddf23f177a2d14f2c729877eaede022e5
This commit is contained in:
John-David Dalton
679
vendor/requirejs/require.js
vendored
679
vendor/requirejs/require.js
vendored
@@ -1,5 +1,5 @@
|
||||
/** vim: et:ts=4:sw=4:sts=4
|
||||
* @license RequireJS 2.0.6 Copyright (c) 2010-2012, The Dojo Foundation All Rights Reserved.
|
||||
* @license RequireJS 2.1.0 Copyright (c) 2010-2012, The Dojo Foundation All Rights Reserved.
|
||||
* Available via the MIT or new BSD license.
|
||||
* see: http://github.com/jrburke/requirejs for details
|
||||
*/
|
||||
@@ -12,7 +12,7 @@ var requirejs, require, define;
|
||||
(function (global) {
|
||||
var req, s, head, baseElement, dataMain, src,
|
||||
interactiveScript, currentlyAddingScript, mainScript, subPath,
|
||||
version = '2.0.6',
|
||||
version = '2.1.0',
|
||||
commentRegExp = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg,
|
||||
cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
|
||||
jsSuffixRegExp = /\.js$/,
|
||||
@@ -147,41 +147,6 @@ var requirejs, require, define;
|
||||
return g;
|
||||
}
|
||||
|
||||
function makeContextModuleFunc(func, relMap, enableBuildCallback) {
|
||||
return function () {
|
||||
//A version of a require function that passes a moduleName
|
||||
//value for items that may need to
|
||||
//look up paths relative to the moduleName
|
||||
var args = aps.call(arguments, 0), lastArg;
|
||||
if (enableBuildCallback &&
|
||||
isFunction((lastArg = args[args.length - 1]))) {
|
||||
lastArg.__requireJsBuild = true;
|
||||
}
|
||||
args.push(relMap);
|
||||
return func.apply(null, args);
|
||||
};
|
||||
}
|
||||
|
||||
function addRequireMethods(req, context, relMap) {
|
||||
each([
|
||||
['toUrl'],
|
||||
['undef'],
|
||||
['defined', 'requireDefined'],
|
||||
['specified', 'requireSpecified']
|
||||
], function (item) {
|
||||
var prop = item[1] || item[0];
|
||||
req[item[0]] = context ? makeContextModuleFunc(context[prop], relMap) :
|
||||
//If no context, then use default context. Reference from
|
||||
//contexts instead of early binding to default context, so
|
||||
//that during builds, the latest instance of the default
|
||||
//context with its config gets used.
|
||||
function () {
|
||||
var ctx = contexts[defContextName];
|
||||
return ctx[prop].apply(ctx, arguments);
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructs an error with a pointer to an URL with more information.
|
||||
* @param {String} id the error ID that maps to an ID on a web page.
|
||||
@@ -238,12 +203,7 @@ var requirejs, require, define;
|
||||
defined = {},
|
||||
urlFetched = {},
|
||||
requireCounter = 1,
|
||||
unnormalizedCounter = 1,
|
||||
//Used to track the order in which modules
|
||||
//should be executed, by the order they
|
||||
//load. Important for consistent cycle resolution
|
||||
//behavior.
|
||||
waitAry = [];
|
||||
unnormalizedCounter = 1;
|
||||
|
||||
/**
|
||||
* Trims the . and .. from an array of path segments.
|
||||
@@ -405,12 +365,25 @@ var requirejs, require, define;
|
||||
//Pop off the first array value, since it failed, and
|
||||
//retry
|
||||
pathConfig.shift();
|
||||
context.undef(id);
|
||||
context.require.undef(id);
|
||||
context.require([id]);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
//Turns a plugin!resource to [plugin, resource]
|
||||
//with the plugin being undefined if the name
|
||||
//did not have a plugin prefix.
|
||||
function splitPrefix(name) {
|
||||
var prefix,
|
||||
index = name ? name.indexOf('!') : -1;
|
||||
if (index > -1) {
|
||||
prefix = name.substring(0, index);
|
||||
name = name.substring(index + 1, name.length);
|
||||
}
|
||||
return [prefix, name];
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a module mapping that includes plugin prefix, module
|
||||
* name, and path. If parentModuleMap is provided it will
|
||||
@@ -427,8 +400,7 @@ var requirejs, require, define;
|
||||
* @returns {Object}
|
||||
*/
|
||||
function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
|
||||
var url, pluginModule, suffix,
|
||||
index = name ? name.indexOf('!') : -1,
|
||||
var url, pluginModule, suffix, nameParts,
|
||||
prefix = null,
|
||||
parentName = parentModuleMap ? parentModuleMap.name : null,
|
||||
originalName = name,
|
||||
@@ -442,10 +414,9 @@ var requirejs, require, define;
|
||||
name = '_@r' + (requireCounter += 1);
|
||||
}
|
||||
|
||||
if (index !== -1) {
|
||||
prefix = name.substring(0, index);
|
||||
name = name.substring(index + 1, name.length);
|
||||
}
|
||||
nameParts = splitPrefix(name);
|
||||
prefix = nameParts[0];
|
||||
name = nameParts[1];
|
||||
|
||||
if (prefix) {
|
||||
prefix = normalize(prefix, parentName, applyMap);
|
||||
@@ -466,6 +437,15 @@ var requirejs, require, define;
|
||||
} else {
|
||||
//A regular module.
|
||||
normalizedName = normalize(name, parentName, applyMap);
|
||||
|
||||
//Normalized name may be a plugin ID due to map config
|
||||
//application in normalize. The map config values must
|
||||
//already be normalized, so do not need to redo that part.
|
||||
nameParts = splitPrefix(normalizedName);
|
||||
prefix = nameParts[0];
|
||||
normalizedName = nameParts[1];
|
||||
isNormalized = true;
|
||||
|
||||
url = context.nameToUrl(normalizedName);
|
||||
}
|
||||
}
|
||||
@@ -557,148 +537,71 @@ var requirejs, require, define;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function that creates a require function object to give to
|
||||
* modules that ask for it as a dependency. It needs to be specific
|
||||
* per module because of the implication of path mappings that may
|
||||
* need to be relative to the module name.
|
||||
*/
|
||||
function makeRequire(mod, enableBuildCallback, altRequire) {
|
||||
var relMap = mod && mod.map,
|
||||
modRequire = makeContextModuleFunc(altRequire || context.require,
|
||||
relMap,
|
||||
enableBuildCallback);
|
||||
|
||||
addRequireMethods(modRequire, context, relMap);
|
||||
modRequire.isBrowser = isBrowser;
|
||||
|
||||
return modRequire;
|
||||
}
|
||||
|
||||
handlers = {
|
||||
'require': function (mod) {
|
||||
return makeRequire(mod);
|
||||
if (mod.require) {
|
||||
return mod.require;
|
||||
} else {
|
||||
return (mod.require = context.makeRequire(mod.map));
|
||||
}
|
||||
},
|
||||
'exports': function (mod) {
|
||||
mod.usingExports = true;
|
||||
if (mod.map.isDefine) {
|
||||
return (mod.exports = defined[mod.map.id] = {});
|
||||
if (mod.exports) {
|
||||
return mod.exports;
|
||||
} else {
|
||||
return (mod.exports = defined[mod.map.id] = {});
|
||||
}
|
||||
}
|
||||
},
|
||||
'module': function (mod) {
|
||||
return (mod.module = {
|
||||
id: mod.map.id,
|
||||
uri: mod.map.url,
|
||||
config: function () {
|
||||
return (config.config && config.config[mod.map.id]) || {};
|
||||
},
|
||||
exports: defined[mod.map.id]
|
||||
});
|
||||
if (mod.module) {
|
||||
return mod.module;
|
||||
} else {
|
||||
return (mod.module = {
|
||||
id: mod.map.id,
|
||||
uri: mod.map.url,
|
||||
config: function () {
|
||||
return (config.config && config.config[mod.map.id]) || {};
|
||||
},
|
||||
exports: defined[mod.map.id]
|
||||
});
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
function removeWaiting(id) {
|
||||
function cleanRegistry(id) {
|
||||
//Clean up machinery used for waiting modules.
|
||||
delete registry[id];
|
||||
|
||||
each(waitAry, function (mod, i) {
|
||||
if (mod.map.id === id) {
|
||||
waitAry.splice(i, 1);
|
||||
if (!mod.defined) {
|
||||
context.waitCount -= 1;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function findCycle(mod, traced, processed) {
|
||||
var id = mod.map.id,
|
||||
depArray = mod.depMaps,
|
||||
foundModule;
|
||||
function breakCycle(mod, traced, processed) {
|
||||
var id = mod.map.id;
|
||||
|
||||
//Do not bother with unitialized modules or not yet enabled
|
||||
//modules.
|
||||
if (!mod.inited) {
|
||||
return;
|
||||
}
|
||||
if (mod.error) {
|
||||
mod.emit('error', mod.error);
|
||||
} else {
|
||||
traced[id] = true;
|
||||
each(mod.depMaps, function (depMap, i) {
|
||||
var depId = depMap.id,
|
||||
dep = registry[depId];
|
||||
|
||||
//Found the cycle.
|
||||
if (traced[id]) {
|
||||
return mod;
|
||||
}
|
||||
|
||||
traced[id] = true;
|
||||
|
||||
//Trace through the dependencies.
|
||||
each(depArray, function (depMap) {
|
||||
var depId = depMap.id,
|
||||
depMod = registry[depId];
|
||||
|
||||
if (!depMod || processed[depId] ||
|
||||
!depMod.inited || !depMod.enabled) {
|
||||
return;
|
||||
}
|
||||
|
||||
return (foundModule = findCycle(depMod, traced, processed));
|
||||
});
|
||||
|
||||
processed[id] = true;
|
||||
|
||||
return foundModule;
|
||||
}
|
||||
|
||||
function forceExec(mod, traced, uninited) {
|
||||
var id = mod.map.id,
|
||||
depArray = mod.depMaps;
|
||||
|
||||
if (!mod.inited || !mod.map.isDefine) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (traced[id]) {
|
||||
return defined[id];
|
||||
}
|
||||
|
||||
traced[id] = mod;
|
||||
|
||||
each(depArray, function (depMap) {
|
||||
var depId = depMap.id,
|
||||
depMod = registry[depId],
|
||||
value;
|
||||
|
||||
if (handlers[depId]) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (depMod) {
|
||||
if (!depMod.inited || !depMod.enabled) {
|
||||
//Dependency is not inited,
|
||||
//so this module cannot be
|
||||
//given a forced value yet.
|
||||
uninited[id] = true;
|
||||
return;
|
||||
//Only force things that have not completed
|
||||
//being defined, so still in the registry,
|
||||
//and only if it has not been matched up
|
||||
//in the module already.
|
||||
if (dep && !mod.depMatched[i] && !processed[depId]) {
|
||||
if (traced[depId]) {
|
||||
mod.defineDep(i, defined[depId]);
|
||||
mod.check(); //pass false?
|
||||
} else {
|
||||
breakCycle(dep, traced, processed);
|
||||
}
|
||||
}
|
||||
|
||||
//Get the value for the current dependency
|
||||
value = forceExec(depMod, traced, uninited);
|
||||
|
||||
//Even with forcing it may not be done,
|
||||
//in particular if the module is waiting
|
||||
//on a plugin resource.
|
||||
if (!uninited[depId]) {
|
||||
mod.defineDepById(depId, value);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
mod.check(true);
|
||||
|
||||
return defined[id];
|
||||
}
|
||||
|
||||
function modCheck(mod) {
|
||||
mod.check();
|
||||
});
|
||||
processed[id] = true;
|
||||
}
|
||||
}
|
||||
|
||||
function checkLoaded() {
|
||||
@@ -707,6 +610,7 @@ var requirejs, require, define;
|
||||
//It is possible to disable the wait interval by using waitSeconds of 0.
|
||||
expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
|
||||
noLoads = [],
|
||||
reqCalls = [],
|
||||
stillLoading = false,
|
||||
needCycleCheck = true;
|
||||
|
||||
@@ -727,6 +631,10 @@ var requirejs, require, define;
|
||||
return;
|
||||
}
|
||||
|
||||
if (!map.isDefine) {
|
||||
reqCalls.push(mod);
|
||||
}
|
||||
|
||||
if (!mod.error) {
|
||||
//If the module should be executed, and it has not
|
||||
//been inited and time is up, remember it.
|
||||
@@ -761,31 +669,9 @@ var requirejs, require, define;
|
||||
|
||||
//Not expired, check for a cycle.
|
||||
if (needCycleCheck) {
|
||||
|
||||
each(waitAry, function (mod) {
|
||||
if (mod.defined) {
|
||||
return;
|
||||
}
|
||||
|
||||
var cycleMod = findCycle(mod, {}, {}),
|
||||
traced = {};
|
||||
|
||||
if (cycleMod) {
|
||||
forceExec(cycleMod, traced, {});
|
||||
|
||||
//traced modules may have been
|
||||
//removed from the registry, but
|
||||
//their listeners still need to
|
||||
//be called.
|
||||
eachProp(traced, modCheck);
|
||||
}
|
||||
each(reqCalls, function (mod) {
|
||||
breakCycle(mod, {}, {});
|
||||
});
|
||||
|
||||
//Now that dependencies have
|
||||
//been satisfied, trigger the
|
||||
//completion check that then
|
||||
//notifies listeners.
|
||||
eachProp(registry, modCheck);
|
||||
}
|
||||
|
||||
//If still waiting on loads, and the waiting load is something
|
||||
@@ -851,7 +737,6 @@ var requirejs, require, define;
|
||||
//doing a direct modification of the depMaps array
|
||||
//would affect that config.
|
||||
this.depMaps = depMaps && depMaps.slice(0);
|
||||
this.depMaps.rjsSkipMap = depMaps.rjsSkipMap;
|
||||
|
||||
this.errback = errback;
|
||||
|
||||
@@ -873,20 +758,6 @@ var requirejs, require, define;
|
||||
}
|
||||
},
|
||||
|
||||
defineDepById: function (id, depExports) {
|
||||
var i;
|
||||
|
||||
//Find the index for this dependency.
|
||||
each(this.depMaps, function (map, index) {
|
||||
if (map.id === id) {
|
||||
i = index;
|
||||
return true;
|
||||
}
|
||||
});
|
||||
|
||||
return this.defineDep(i, depExports);
|
||||
},
|
||||
|
||||
defineDep: function (i, depExports) {
|
||||
//Because of cycles, defined callback for a given
|
||||
//export can be called more than once.
|
||||
@@ -910,7 +781,9 @@ var requirejs, require, define;
|
||||
//If the manager is for a plugin managed resource,
|
||||
//ask the plugin to load it now.
|
||||
if (this.shim) {
|
||||
makeRequire(this, true)(this.shim.deps || [], bind(this, function () {
|
||||
context.makeRequire(this.map, {
|
||||
enableBuildCallback: true
|
||||
})(this.shim.deps || [], bind(this, function () {
|
||||
return map.prefix ? this.callPlugin() : this.load();
|
||||
}));
|
||||
} else {
|
||||
@@ -931,11 +804,9 @@ var requirejs, require, define;
|
||||
|
||||
/**
|
||||
* Checks is the module is ready to define itself, and if so,
|
||||
* define it. If the silent argument is true, then it will just
|
||||
* define, but not notify listeners, and not ask for a context-wide
|
||||
* check of all loaded modules. That is useful for cycle breaking.
|
||||
* define it.
|
||||
*/
|
||||
check: function (silent) {
|
||||
check: function () {
|
||||
if (!this.enabled || this.enabling) {
|
||||
return;
|
||||
}
|
||||
@@ -1013,11 +884,6 @@ var requirejs, require, define;
|
||||
delete registry[id];
|
||||
|
||||
this.defined = true;
|
||||
context.waitCount -= 1;
|
||||
if (context.waitCount === 0) {
|
||||
//Clear the wait array used for cycles.
|
||||
waitAry = [];
|
||||
}
|
||||
}
|
||||
|
||||
//Finished the define stage. Allow calling check again
|
||||
@@ -1025,25 +891,33 @@ var requirejs, require, define;
|
||||
//cycle.
|
||||
this.defining = false;
|
||||
|
||||
if (!silent) {
|
||||
if (this.defined && !this.defineEmitted) {
|
||||
this.defineEmitted = true;
|
||||
this.emit('defined', this.exports);
|
||||
this.defineEmitComplete = true;
|
||||
}
|
||||
if (this.defined && !this.defineEmitted) {
|
||||
this.defineEmitted = true;
|
||||
this.emit('defined', this.exports);
|
||||
this.defineEmitComplete = true;
|
||||
}
|
||||
|
||||
}
|
||||
},
|
||||
|
||||
callPlugin: function () {
|
||||
var map = this.map,
|
||||
id = map.id,
|
||||
pluginMap = makeModuleMap(map.prefix, null, false, true);
|
||||
//Map already normalized the prefix.
|
||||
pluginMap = makeModuleMap(map.prefix);
|
||||
|
||||
//Mark this as a dependency for this plugin, so it
|
||||
//can be traced for cycles.
|
||||
this.depMaps.push(pluginMap);
|
||||
|
||||
on(pluginMap, 'defined', bind(this, function (plugin) {
|
||||
var load, normalizedMap, normalizedMod,
|
||||
name = this.map.name,
|
||||
parentName = this.map.parentMap ? this.map.parentMap.name : null;
|
||||
parentName = this.map.parentMap ? this.map.parentMap.name : null,
|
||||
localRequire = context.makeRequire(map.parentMap, {
|
||||
enableBuildCallback: true,
|
||||
skipMap: true
|
||||
});
|
||||
|
||||
//If current map is not normalized, wait for that
|
||||
//normalized name to load instead of continuing.
|
||||
@@ -1055,10 +929,10 @@ var requirejs, require, define;
|
||||
}) || '';
|
||||
}
|
||||
|
||||
//prefix and name should already be normalized, no need
|
||||
//for applying map config again either.
|
||||
normalizedMap = makeModuleMap(map.prefix + '!' + name,
|
||||
this.map.parentMap,
|
||||
false,
|
||||
true);
|
||||
this.map.parentMap);
|
||||
on(normalizedMap,
|
||||
'defined', bind(this, function (value) {
|
||||
this.init([], function () { return value; }, null, {
|
||||
@@ -1066,8 +940,13 @@ var requirejs, require, define;
|
||||
ignore: true
|
||||
});
|
||||
}));
|
||||
|
||||
normalizedMod = registry[normalizedMap.id];
|
||||
if (normalizedMod) {
|
||||
//Mark this as a dependency for this plugin, so it
|
||||
//can be traced for cycles.
|
||||
this.depMaps.push(normalizedMap);
|
||||
|
||||
if (this.events.error) {
|
||||
normalizedMod.on('error', bind(this, function (err) {
|
||||
this.emit('error', err);
|
||||
@@ -1094,7 +973,7 @@ var requirejs, require, define;
|
||||
//since they will never be resolved otherwise now.
|
||||
eachProp(registry, function (mod) {
|
||||
if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
|
||||
removeWaiting(mod.map.id);
|
||||
cleanRegistry(mod.map.id);
|
||||
}
|
||||
});
|
||||
|
||||
@@ -1103,9 +982,19 @@ var requirejs, require, define;
|
||||
|
||||
//Allow plugins to load other code without having to know the
|
||||
//context or how to 'complete' the load.
|
||||
load.fromText = function (moduleName, text) {
|
||||
load.fromText = bind(this, function (text, textAlt) {
|
||||
/*jslint evil: true */
|
||||
var hasInteractive = useInteractive;
|
||||
var moduleName = map.name,
|
||||
moduleMap = makeModuleMap(moduleName),
|
||||
hasInteractive = useInteractive;
|
||||
|
||||
//As of 2.1.0, support just passing the text, to reinforce
|
||||
//fromText only being called once per resource. Still
|
||||
//support old style of passing moduleName but discard
|
||||
//that moduleName in favor of the internal ref.
|
||||
if (textAlt) {
|
||||
text = textAlt;
|
||||
}
|
||||
|
||||
//Turn off interactive script matching for IE for any define
|
||||
//calls in the text, then turn it back on at the end.
|
||||
@@ -1115,25 +1004,35 @@ var requirejs, require, define;
|
||||
|
||||
//Prime the system by creating a module instance for
|
||||
//it.
|
||||
getModule(makeModuleMap(moduleName));
|
||||
getModule(moduleMap);
|
||||
|
||||
req.exec(text);
|
||||
try {
|
||||
req.exec(text);
|
||||
} catch (e) {
|
||||
throw new Error('fromText eval for ' + moduleName +
|
||||
' failed: ' + e);
|
||||
}
|
||||
|
||||
if (hasInteractive) {
|
||||
useInteractive = true;
|
||||
}
|
||||
|
||||
//Mark this as a dependency for the plugin
|
||||
//resource
|
||||
this.depMaps.push(moduleMap);
|
||||
|
||||
//Support anonymous modules.
|
||||
context.completeLoad(moduleName);
|
||||
};
|
||||
|
||||
//Bind the value of that module to the value for this
|
||||
//resource ID.
|
||||
localRequire([moduleName], load);
|
||||
});
|
||||
|
||||
//Use parentName here since the plugin's name is not reliable,
|
||||
//could be some weird string with no path that actually wants to
|
||||
//reference the parentName's path.
|
||||
plugin.load(map.name, makeRequire(map.parentMap, true, function (deps, cb, er) {
|
||||
deps.rjsSkipMap = true;
|
||||
return context.require(deps, cb, er);
|
||||
}), load, config);
|
||||
plugin.load(map.name, localRequire, load, config);
|
||||
}));
|
||||
|
||||
context.enable(pluginMap, this);
|
||||
@@ -1143,12 +1042,6 @@ var requirejs, require, define;
|
||||
enable: function () {
|
||||
this.enabled = true;
|
||||
|
||||
if (!this.waitPushed) {
|
||||
waitAry.push(this);
|
||||
context.waitCount += 1;
|
||||
this.waitPushed = true;
|
||||
}
|
||||
|
||||
//Set flag mentioning that the module is enabling,
|
||||
//so that immediate calls to the defined callbacks
|
||||
//for dependencies do not trigger inadvertent load
|
||||
@@ -1165,7 +1058,7 @@ var requirejs, require, define;
|
||||
depMap = makeModuleMap(depMap,
|
||||
(this.map.isDefine ? this.map : this.map.parentMap),
|
||||
false,
|
||||
!this.depMaps.rjsSkipMap);
|
||||
!this.skipMap);
|
||||
this.depMaps[i] = depMap;
|
||||
|
||||
handler = handlers[depMap.id];
|
||||
@@ -1227,7 +1120,7 @@ var requirejs, require, define;
|
||||
if (name === 'error') {
|
||||
//Now that the error handler was triggered, remove
|
||||
//the listeners, since this broken Module instance
|
||||
//can stay around for a while in the registry/waitAry.
|
||||
//can stay around for a while in the registry.
|
||||
delete this.events[name];
|
||||
}
|
||||
}
|
||||
@@ -1274,16 +1167,16 @@ var requirejs, require, define;
|
||||
};
|
||||
}
|
||||
|
||||
return (context = {
|
||||
context = {
|
||||
config: config,
|
||||
contextName: contextName,
|
||||
registry: registry,
|
||||
defined: defined,
|
||||
urlFetched: urlFetched,
|
||||
waitCount: 0,
|
||||
defQueue: defQueue,
|
||||
Module: Module,
|
||||
makeModuleMap: makeModuleMap,
|
||||
nextTick: req.nextTick,
|
||||
|
||||
/**
|
||||
* Set a configuration for the context.
|
||||
@@ -1325,8 +1218,8 @@ var requirejs, require, define;
|
||||
deps: value
|
||||
};
|
||||
}
|
||||
if (value.exports && !value.exports.__buildReady) {
|
||||
value.exports = context.makeShimExports(value.exports);
|
||||
if (value.exports && !value.exportsFn) {
|
||||
value.exportsFn = context.makeShimExports(value);
|
||||
}
|
||||
shim[id] = value;
|
||||
});
|
||||
@@ -1381,125 +1274,152 @@ var requirejs, require, define;
|
||||
}
|
||||
},
|
||||
|
||||
makeShimExports: function (exports) {
|
||||
var func;
|
||||
if (typeof exports === 'string') {
|
||||
func = function () {
|
||||
return getGlobal(exports);
|
||||
};
|
||||
//Save the exports for use in nodefine checking.
|
||||
func.exports = exports;
|
||||
return func;
|
||||
} else {
|
||||
return function () {
|
||||
return exports.apply(global, arguments);
|
||||
};
|
||||
makeShimExports: function (value) {
|
||||
function fn() {
|
||||
var ret;
|
||||
if (value.init) {
|
||||
ret = value.init.apply(global, arguments);
|
||||
}
|
||||
return ret || getGlobal(value.exports);
|
||||
}
|
||||
return fn;
|
||||
},
|
||||
|
||||
requireDefined: function (id, relMap) {
|
||||
return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
|
||||
},
|
||||
makeRequire: function (relMap, options) {
|
||||
options = options || {};
|
||||
|
||||
requireSpecified: function (id, relMap) {
|
||||
id = makeModuleMap(id, relMap, false, true).id;
|
||||
return hasProp(defined, id) || hasProp(registry, id);
|
||||
},
|
||||
function require(deps, callback, errback) {
|
||||
var id, map, requireMod, args;
|
||||
|
||||
require: function (deps, callback, errback, relMap) {
|
||||
var moduleName, id, map, requireMod, args;
|
||||
if (typeof deps === 'string') {
|
||||
if (isFunction(callback)) {
|
||||
//Invalid call
|
||||
return onError(makeError('requireargs', 'Invalid require call'), errback);
|
||||
if (options.enableBuildCallback && callback && isFunction(callback)) {
|
||||
callback.__requireJsBuild = true;
|
||||
}
|
||||
|
||||
//Synchronous access to one module. If require.get is
|
||||
//available (as in the Node adapter), prefer that.
|
||||
//In this case deps is the moduleName and callback is
|
||||
//the relMap
|
||||
if (req.get) {
|
||||
return req.get(context, deps, callback);
|
||||
if (typeof deps === 'string') {
|
||||
if (isFunction(callback)) {
|
||||
//Invalid call
|
||||
return onError(makeError('requireargs', 'Invalid require call'), errback);
|
||||
}
|
||||
|
||||
//If require|exports|module are requested, get the
|
||||
//value for them from the special handlers. Caveat:
|
||||
//this only works while module is being defined.
|
||||
if (relMap && handlers[deps]) {
|
||||
return handlers[deps](registry[relMap.id]);
|
||||
}
|
||||
|
||||
//Synchronous access to one module. If require.get is
|
||||
//available (as in the Node adapter), prefer that.
|
||||
if (req.get) {
|
||||
return req.get(context, deps, relMap);
|
||||
}
|
||||
|
||||
//Normalize module name, if it contains . or ..
|
||||
map = makeModuleMap(deps, relMap, false, true);
|
||||
id = map.id;
|
||||
|
||||
if (!hasProp(defined, id)) {
|
||||
return onError(makeError('notloaded', 'Module name "' +
|
||||
id +
|
||||
'" has not been loaded yet for context: ' +
|
||||
contextName +
|
||||
(relMap ? '' : '. Use require([])')));
|
||||
}
|
||||
return defined[id];
|
||||
}
|
||||
|
||||
//Just return the module wanted. In this scenario, the
|
||||
//second arg (if passed) is just the relMap.
|
||||
moduleName = deps;
|
||||
relMap = callback;
|
||||
//Any defined modules in the global queue, intake them now.
|
||||
takeGlobalQueue();
|
||||
|
||||
//Normalize module name, if it contains . or ..
|
||||
map = makeModuleMap(moduleName, relMap, false, true);
|
||||
id = map.id;
|
||||
|
||||
if (!hasProp(defined, id)) {
|
||||
return onError(makeError('notloaded', 'Module name "' +
|
||||
id +
|
||||
'" has not been loaded yet for context: ' +
|
||||
contextName));
|
||||
//Make sure any remaining defQueue items get properly processed.
|
||||
while (defQueue.length) {
|
||||
args = defQueue.shift();
|
||||
if (args[0] === null) {
|
||||
return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' + args[args.length - 1]));
|
||||
} else {
|
||||
//args are id, deps, factory. Should be normalized by the
|
||||
//define() function.
|
||||
callGetModule(args);
|
||||
}
|
||||
}
|
||||
return defined[id];
|
||||
|
||||
//Mark all the dependencies as needing to be loaded.
|
||||
context.nextTick(function () {
|
||||
requireMod = getModule(makeModuleMap(null, relMap));
|
||||
|
||||
//Store if map config should be applied to this require
|
||||
//call for dependencies.
|
||||
requireMod.skipMap = options.skipMap;
|
||||
|
||||
requireMod.init(deps, callback, errback, {
|
||||
enabled: true
|
||||
});
|
||||
|
||||
checkLoaded();
|
||||
});
|
||||
|
||||
return require;
|
||||
}
|
||||
|
||||
//Callback require. Normalize args. if callback or errback is
|
||||
//not a function, it means it is a relMap. Test errback first.
|
||||
if (errback && !isFunction(errback)) {
|
||||
relMap = errback;
|
||||
errback = undefined;
|
||||
}
|
||||
if (callback && !isFunction(callback)) {
|
||||
relMap = callback;
|
||||
callback = undefined;
|
||||
}
|
||||
mixin(require, {
|
||||
isBrowser: isBrowser,
|
||||
|
||||
//Any defined modules in the global queue, intake them now.
|
||||
takeGlobalQueue();
|
||||
/**
|
||||
* Converts a module name + .extension into an URL path.
|
||||
* *Requires* the use of a module name. It does not support using
|
||||
* plain URLs like nameToUrl.
|
||||
*/
|
||||
toUrl: function (moduleNamePlusExt) {
|
||||
var index = moduleNamePlusExt.lastIndexOf('.'),
|
||||
ext = null;
|
||||
|
||||
//Make sure any remaining defQueue items get properly processed.
|
||||
while (defQueue.length) {
|
||||
args = defQueue.shift();
|
||||
if (args[0] === null) {
|
||||
return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' + args[args.length - 1]));
|
||||
} else {
|
||||
//args are id, deps, factory. Should be normalized by the
|
||||
//define() function.
|
||||
callGetModule(args);
|
||||
if (index !== -1) {
|
||||
ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
|
||||
moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
|
||||
}
|
||||
|
||||
return context.nameToUrl(normalize(moduleNamePlusExt,
|
||||
relMap && relMap.id, true), ext);
|
||||
},
|
||||
|
||||
defined: function (id) {
|
||||
return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
|
||||
},
|
||||
|
||||
specified: function (id) {
|
||||
id = makeModuleMap(id, relMap, false, true).id;
|
||||
return hasProp(defined, id) || hasProp(registry, id);
|
||||
}
|
||||
}
|
||||
|
||||
//Mark all the dependencies as needing to be loaded.
|
||||
requireMod = getModule(makeModuleMap(null, relMap));
|
||||
|
||||
requireMod.init(deps, callback, errback, {
|
||||
enabled: true
|
||||
});
|
||||
|
||||
checkLoaded();
|
||||
//Only allow undef on top level require calls
|
||||
if (!relMap) {
|
||||
require.undef = function (id) {
|
||||
//Bind any waiting define() calls to this context,
|
||||
//fix for #408
|
||||
takeGlobalQueue();
|
||||
|
||||
return context.require;
|
||||
},
|
||||
var map = makeModuleMap(id, relMap, true),
|
||||
mod = registry[id];
|
||||
|
||||
undef: function (id) {
|
||||
//Bind any waiting define() calls to this context,
|
||||
//fix for #408
|
||||
takeGlobalQueue();
|
||||
delete defined[id];
|
||||
delete urlFetched[map.url];
|
||||
delete undefEvents[id];
|
||||
|
||||
var map = makeModuleMap(id, null, true),
|
||||
mod = registry[id];
|
||||
if (mod) {
|
||||
//Hold on to listeners in case the
|
||||
//module will be attempted to be reloaded
|
||||
//using a different config.
|
||||
if (mod.events.defined) {
|
||||
undefEvents[id] = mod.events;
|
||||
}
|
||||
|
||||
delete defined[id];
|
||||
delete urlFetched[map.url];
|
||||
delete undefEvents[id];
|
||||
|
||||
if (mod) {
|
||||
//Hold on to listeners in case the
|
||||
//module will be attempted to be reloaded
|
||||
//using a different config.
|
||||
if (mod.events.defined) {
|
||||
undefEvents[id] = mod.events;
|
||||
}
|
||||
|
||||
removeWaiting(id);
|
||||
cleanRegistry(id);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
return require;
|
||||
},
|
||||
|
||||
/**
|
||||
@@ -1523,7 +1443,7 @@ var requirejs, require, define;
|
||||
completeLoad: function (moduleName) {
|
||||
var found, args, mod,
|
||||
shim = config.shim[moduleName] || {},
|
||||
shExports = shim.exports && shim.exports.exports;
|
||||
shExports = shim.exports;
|
||||
|
||||
takeGlobalQueue();
|
||||
|
||||
@@ -1563,31 +1483,13 @@ var requirejs, require, define;
|
||||
} else {
|
||||
//A script that does not call define(), so just simulate
|
||||
//the call for it.
|
||||
callGetModule([moduleName, (shim.deps || []), shim.exports]);
|
||||
callGetModule([moduleName, (shim.deps || []), shim.exportsFn]);
|
||||
}
|
||||
}
|
||||
|
||||
checkLoaded();
|
||||
},
|
||||
|
||||
/**
|
||||
* Converts a module name + .extension into an URL path.
|
||||
* *Requires* the use of a module name. It does not support using
|
||||
* plain URLs like nameToUrl.
|
||||
*/
|
||||
toUrl: function (moduleNamePlusExt, relModuleMap) {
|
||||
var index = moduleNamePlusExt.lastIndexOf('.'),
|
||||
ext = null;
|
||||
|
||||
if (index !== -1) {
|
||||
ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
|
||||
moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
|
||||
}
|
||||
|
||||
return context.nameToUrl(normalize(moduleNamePlusExt, relModuleMap && relModuleMap.id, true),
|
||||
ext);
|
||||
},
|
||||
|
||||
/**
|
||||
* Converts a module name to a file path. Supports cases where
|
||||
* moduleName may actually be just an URL.
|
||||
@@ -1701,7 +1603,10 @@ var requirejs, require, define;
|
||||
return onError(makeError('scripterror', 'Script error', evt, [data.id]));
|
||||
}
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
context.require = context.makeRequire();
|
||||
return context;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -1762,6 +1667,16 @@ var requirejs, require, define;
|
||||
return req(config);
|
||||
};
|
||||
|
||||
/**
|
||||
* Execute something after the current tick
|
||||
* of the event loop. Override for other envs
|
||||
* that have a better solution than setTimeout.
|
||||
* @param {Function} fn function to execute later.
|
||||
*/
|
||||
req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) {
|
||||
setTimeout(fn, 4);
|
||||
} : function (fn) { fn(); };
|
||||
|
||||
/**
|
||||
* Export require as a global, but only if it does not already exist.
|
||||
*/
|
||||
@@ -1782,9 +1697,21 @@ var requirejs, require, define;
|
||||
//Create default context.
|
||||
req({});
|
||||
|
||||
//Exports some context-sensitive methods on global require, using
|
||||
//default context if no context specified.
|
||||
addRequireMethods(req);
|
||||
//Exports some context-sensitive methods on global require.
|
||||
each([
|
||||
'toUrl',
|
||||
'undef',
|
||||
'defined',
|
||||
'specified'
|
||||
], function (prop) {
|
||||
//Reference from contexts instead of early binding to default context,
|
||||
//so that during builds, the latest instance of the default context
|
||||
//with its config gets used.
|
||||
req[prop] = function () {
|
||||
var ctx = contexts[defContextName];
|
||||
return ctx.require[prop].apply(ctx, arguments);
|
||||
};
|
||||
});
|
||||
|
||||
if (isBrowser) {
|
||||
head = s.head = document.getElementsByTagName('head')[0];
|
||||
@@ -1962,7 +1889,7 @@ var requirejs, require, define;
|
||||
define = function (name, deps, callback) {
|
||||
var node, context;
|
||||
|
||||
//Allow for anonymous functions
|
||||
//Allow for anonymous modules
|
||||
if (typeof name !== 'string') {
|
||||
//Adjust args appropriately
|
||||
callback = deps;
|
||||
|
||||
Reference in New Issue
Block a user