devfty
Version:
Devfty is a library for developer building low code factory
1,277 lines (1,128 loc) • 87.2 kB
JavaScript
/** vim: et:ts=4:sw=4:sts=4
* @license RequireJS 2.3.7 Copyright jQuery Foundation and other contributors.
* Released under MIT license, https://github.com/requirejs/requirejs/blob/master/LICENSE
*/
//Not using strict: uneven strict support in browsers, #392, and causes
//problems with requirejs.exec()/transpiler plugins that may not be strict.
/*jslint regexp: true, nomen: true, sloppy: true */
/*global window, navigator, document, importScripts, setTimeout, opera */
window.devfty = window.devfty || {}
var requirejs, require, define
;(function (global, setTimeout) {
var req,
s,
head,
baseElement,
dataMain,
src,
interactiveScript,
currentlyAddingScript,
mainScript,
subPath,
version = '2.3.7',
commentRegExp = /\/\*[\s\S]*?\*\/|([^:"'=]|^)\/\/.*$/gm,
cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
jsSuffixRegExp = /\.js$/,
currDirRegExp = /^\.\//,
op = Object.prototype,
ostring = op.toString,
hasOwn = op.hasOwnProperty,
isBrowser = !!(typeof window !== 'undefined' && typeof navigator !== 'undefined' && window.document),
isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
//PS3 indicates loaded and complete, but need to wait for complete
//specifically. Sequence is 'loading', 'loaded', execution,
// then 'complete'. The UA check is unfortunate, but not sure how
//to feature test w/o causing perf issues.
readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ? /^complete$/ : /^(complete|loaded)$/,
defContextName = '_',
//Oh the tragedy, detecting opera. See the usage of isOpera for reason.
isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
contexts = {},
cfg = {},
globalDefQueue = [],
useInteractive = false,
disallowedProps = ['__proto__', 'constructor']
//Could match something like ')//comment', do not lose the prefix to comment.
function commentReplace(match, singlePrefix) {
return singlePrefix || ''
}
function isFunction(it) {
return ostring.call(it) === '[object Function]'
}
function isArray(it) {
return ostring.call(it) === '[object Array]'
}
/**
* Helper function for iterating over an array. If the func returns
* a true value, it will break out of the loop.
*/
function each(ary, func) {
if (ary) {
var i
for (i = 0; i < ary.length; i += 1) {
if (ary[i] && func(ary[i], i, ary)) {
break
}
}
}
}
/**
* Helper function for iterating over an array backwards. If the func
* returns a true value, it will break out of the loop.
*/
function eachReverse(ary, func) {
if (ary) {
var i
for (i = ary.length - 1; i > -1; i -= 1) {
if (ary[i] && func(ary[i], i, ary)) {
break
}
}
}
}
function hasProp(obj, prop) {
return hasOwn.call(obj, prop)
}
function getOwn(obj, prop) {
return hasProp(obj, prop) && obj[prop]
}
/**
* Cycles over properties in an object and calls a function for each
* property value. If the function returns a truthy value, then the
* iteration is stopped.
*/
function eachProp(obj, func) {
var prop
for (prop in obj) {
if (hasProp(obj, prop) && disallowedProps.indexOf(prop) == -1) {
if (func(obj[prop], prop)) {
break
}
}
}
}
/**
* Simple function to mix in properties from source into target,
* but only if target does not already have a property of the same name.
*/
function mixin(target, source, force, deepStringMixin) {
if (source) {
eachProp(source, function (value, prop) {
if (force || !hasProp(target, prop)) {
if (deepStringMixin && typeof value === 'object' && value && !isArray(value) && !isFunction(value) && !(value instanceof RegExp)) {
if (!target[prop]) {
target[prop] = {}
}
mixin(target[prop], value, force, deepStringMixin)
} else {
target[prop] = value
}
}
})
}
return target
}
//Similar to Function.prototype.bind, but the 'this' object is specified
//first, since it is easier to read/figure out what 'this' will be.
function bind(obj, fn) {
return function () {
return fn.apply(obj, arguments)
}
}
function scripts() {
return document.getElementsByTagName('script')
}
function defaultOnError(err) {
throw err
}
//Allow getting a global that is expressed in
//dot notation, like 'a.b.c'.
function getGlobal(value) {
if (!value) {
return value
}
var g = global
each(value.split('.'), function (part) {
g = g[part]
})
return g
}
/**
* 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.
* @param {String} message human readable error.
* @param {Error} [err] the original error, if there is one.
*
* @returns {Error}
*/
function makeError(id, msg, err, requireModules) {
var e = new Error(msg + '\nhttps://requirejs.org/docs/errors.html#' + id)
e.requireType = id
e.requireModules = requireModules
if (err) {
e.originalError = err
}
return e
}
if (typeof define !== 'undefined') {
//If a define is already in play via another AMD loader,
//do not overwrite.
return
}
if (typeof requirejs !== 'undefined') {
if (isFunction(requirejs)) {
//Do not overwrite an existing requirejs instance.
return
}
cfg = requirejs
requirejs = undefined
}
//Allow for a require config object
if (typeof require !== 'undefined' && !isFunction(require)) {
//assume it is a config object.
cfg = require
require = undefined
}
function newContext(contextName) {
var inCheckLoaded,
Module,
context,
handlers,
checkLoadedTimeoutId,
config = {
//Defaults. Do not set a default for map
//config to speed up normalize(), which
//will run faster if there is no default.
waitSeconds: 7,
baseUrl: './',
paths: {},
bundles: {},
pkgs: {},
shim: {},
config: {},
},
registry = {},
//registry of just enabled modules, to speed
//cycle breaking code when lots of modules
//are registered, but not activated.
enabledRegistry = {},
undefEvents = {},
defQueue = [],
defined = {},
urlFetched = {},
bundlesMap = {},
requireCounter = 1,
unnormalizedCounter = 1
/**
* Trims the . and .. from an array of path segments.
* It will keep a leading path segment if a .. will become
* the first path segment, to help with module name lookups,
* which act like paths, but can be remapped. But the end result,
* all paths that use this function should look normalized.
* NOTE: this method MODIFIES the input array.
* @param {Array} ary the array of path segments.
*/
function trimDots(ary) {
var i, part
for (i = 0; i < ary.length; i++) {
part = ary[i]
if (part === '.') {
ary.splice(i, 1)
i -= 1
} else if (part === '..') {
// If at the start, or previous value is still ..,
// keep them so that when converted to a path it may
// still work when converted to a path, even though
// as an ID it is less than ideal. In larger point
// releases, may be better to just kick out an error.
if (i === 0 || (i === 1 && ary[2] === '..') || ary[i - 1] === '..') {
continue
} else if (i > 0) {
ary.splice(i - 1, 2)
i -= 2
}
}
}
}
/**
* Given a relative module name, like ./something, normalize it to
* a real name that can be mapped to a path.
* @param {String} name the relative name
* @param {String} baseName a real name that the name arg is relative
* to.
* @param {Boolean} applyMap apply the map config to the value. Should
* only be done if this normalization is for a dependency ID.
* @returns {String} normalized name
*/
function normalize(name, baseName, applyMap) {
var pkgMain,
mapValue,
nameParts,
i,
j,
nameSegment,
lastIndex,
foundMap,
foundI,
foundStarMap,
starI,
normalizedBaseParts,
baseParts = baseName && baseName.split('/'),
map = config.map,
starMap = map && map['*']
//Adjust any relative paths.
if (name) {
name = name.split('/')
lastIndex = name.length - 1
// If wanting node ID compatibility, strip .js from end
// of IDs. Have to do this here, and not in nameToUrl
// because node allows either .js or non .js to map
// to same file.
if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '')
}
// Starts with a '.' so need the baseName
if (name[0].charAt(0) === '.' && baseParts) {
//Convert baseName to array, and lop off the last part,
//so that . matches that 'directory' and not name of the baseName's
//module. For instance, baseName of 'one/two/three', maps to
//'one/two/three.js', but we want the directory, 'one/two' for
//this normalization.
normalizedBaseParts = baseParts.slice(0, baseParts.length - 1)
name = normalizedBaseParts.concat(name)
}
trimDots(name)
name = name.join('/')
}
//Apply map config if available.
if (applyMap && map && (baseParts || starMap)) {
nameParts = name.split('/')
outerLoop: for (i = nameParts.length; i > 0; i -= 1) {
nameSegment = nameParts.slice(0, i).join('/')
if (baseParts) {
//Find the longest baseName segment match in the config.
//So, do joins on the biggest to smallest lengths of baseParts.
for (j = baseParts.length; j > 0; j -= 1) {
mapValue = getOwn(map, baseParts.slice(0, j).join('/'))
//baseName segment has config, find if it has one for
//this name.
if (mapValue) {
mapValue = getOwn(mapValue, nameSegment)
if (mapValue) {
//Match, update name to the new value.
foundMap = mapValue
foundI = i
break outerLoop
}
}
}
}
//Check for a star map match, but just hold on to it,
//if there is a shorter segment match later in a matching
//config, then favor over this star map.
if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
foundStarMap = getOwn(starMap, nameSegment)
starI = i
}
}
if (!foundMap && foundStarMap) {
foundMap = foundStarMap
foundI = starI
}
if (foundMap) {
nameParts.splice(0, foundI, foundMap)
name = nameParts.join('/')
}
}
// If the name points to a package's name, use
// the package main instead.
pkgMain = getOwn(config.pkgs, name)
return pkgMain ? pkgMain : name
}
function removeScript(name) {
if (isBrowser) {
each(scripts(), function (scriptNode) {
if (scriptNode.getAttribute('data-requiremodule') === name && scriptNode.getAttribute('data-requirecontext') === context.contextName) {
scriptNode.parentNode.removeChild(scriptNode)
return true
}
})
}
}
function hasPathFallback(id) {
var pathConfig = getOwn(config.paths, id)
if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
//Pop off the first array value, since it failed, and
//retry
pathConfig.shift()
context.require.undef(id)
//Custom require that does not do map translation, since
//ID is "absolute", already mapped/resolved.
context.makeRequire(null, {
skipMap: true,
})([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
* also normalize the name via require.normalize()
*
* @param {String} name the module name
* @param {String} [parentModuleMap] parent module map
* for the module name, used to resolve relative names.
* @param {Boolean} isNormalized: is the ID already normalized.
* This is true if this call is done for a define() module ID.
* @param {Boolean} applyMap: apply the map config to the ID.
* Should only be true if this map is for a dependency.
*
* @returns {Object}
*/
function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
var url,
pluginModule,
suffix,
nameParts,
prefix = null,
parentName = parentModuleMap ? parentModuleMap.name : null,
originalName = name,
isDefine = true,
normalizedName = ''
//If no name, then it means it is a require call, generate an
//internal name.
if (!name) {
isDefine = false
name = '_@r' + (requireCounter += 1)
}
nameParts = splitPrefix(name)
prefix = nameParts[0]
name = nameParts[1]
if (prefix) {
prefix = normalize(prefix, parentName, applyMap)
pluginModule = getOwn(defined, prefix)
}
//Account for relative paths if there is a base name.
if (name) {
if (prefix) {
if (isNormalized) {
normalizedName = name
} else if (pluginModule && pluginModule.normalize) {
//Plugin is loaded, use its normalize method.
normalizedName = pluginModule.normalize(name, function (name) {
return normalize(name, parentName, applyMap)
})
} else {
// If nested plugin references, then do not try to
// normalize, as it will not normalize correctly. This
// places a restriction on resourceIds, and the longer
// term solution is not to normalize until plugins are
// loaded and all normalizations to allow for async
// loading of a loader plugin. But for now, fixes the
// common uses. Details in #1131
normalizedName = name.indexOf('!') === -1 ? normalize(name, parentName, applyMap) : name
}
} 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)
}
}
//If the id is a plugin id that cannot be determined if it needs
//normalization, stamp it with a unique ID so two matching relative
//ids that may conflict can be separate.
suffix = prefix && !pluginModule && !isNormalized ? '_unnormalized' + (unnormalizedCounter += 1) : ''
return {
prefix: prefix,
name: normalizedName,
parentMap: parentModuleMap,
unnormalized: !!suffix,
url: url,
originalName: originalName,
isDefine: isDefine,
id: (prefix ? prefix + '!' + normalizedName : normalizedName) + suffix,
}
}
function getModule(depMap) {
var id = depMap.id,
mod = getOwn(registry, id)
if (!mod) {
mod = registry[id] = new context.Module(depMap)
}
return mod
}
function on(depMap, name, fn) {
var id = depMap.id,
mod = getOwn(registry, id)
if (hasProp(defined, id) && (!mod || mod.defineEmitComplete)) {
if (name === 'defined') {
fn(defined[id])
}
} else {
mod = getModule(depMap)
if (mod.error && name === 'error') {
fn(mod.error)
} else {
mod.on(name, fn)
}
}
}
function onError(err, errback) {
var ids = err.requireModules,
notified = false
if (errback) {
errback(err)
} else {
each(ids, function (id) {
var mod = getOwn(registry, id)
if (mod) {
//Set error on module, so it skips timeout checks.
mod.error = err
if (mod.events.error) {
notified = true
mod.emit('error', err)
}
}
})
if (!notified) {
req.onError(err)
}
}
}
/**
* Internal method to transfer globalQueue items to this context's
* defQueue.
*/
function takeGlobalQueue() {
//Push all the globalDefQueue items into the context's defQueue
if (globalDefQueue.length) {
each(globalDefQueue, function (queueItem) {
var id = queueItem[0]
if (typeof id === 'string') {
context.defQueueMap[id] = true
}
defQueue.push(queueItem)
})
globalDefQueue = []
}
}
handlers = {
require: function (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) {
if (mod.exports) {
return (defined[mod.map.id] = mod.exports)
} else {
return (mod.exports = defined[mod.map.id] = {})
}
}
},
module: function (mod) {
if (mod.module) {
return mod.module
} else {
return (mod.module = {
id: mod.map.id,
uri: mod.map.url,
config: function () {
return getOwn(config.config, mod.map.id) || {}
},
exports: mod.exports || (mod.exports = {}),
})
}
},
}
function cleanRegistry(id) {
//Clean up machinery used for waiting modules.
delete registry[id]
delete enabledRegistry[id]
}
function breakCycle(mod, traced, processed) {
var id = mod.map.id
if (mod.error) {
mod.emit('error', mod.error)
} else {
traced[id] = true
each(mod.depMaps, function (depMap, i) {
var depId = depMap.id,
dep = getOwn(registry, depId)
//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 (getOwn(traced, depId)) {
mod.defineDep(i, defined[depId])
mod.check() //pass false?
} else {
breakCycle(dep, traced, processed)
}
}
})
processed[id] = true
}
}
function checkLoaded() {
var err,
usingPathFallback,
waitInterval = config.waitSeconds * 1000,
//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
//Do not bother if this call was a result of a cycle break.
if (inCheckLoaded) {
return
}
inCheckLoaded = true
//Figure out the state of all the modules.
eachProp(enabledRegistry, function (mod) {
var map = mod.map,
modId = map.id
//Skip things that are not enabled or in error state.
if (!mod.enabled) {
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.
if (!mod.inited && expired) {
if (hasPathFallback(modId)) {
usingPathFallback = true
stillLoading = true
} else {
noLoads.push(modId)
removeScript(modId)
}
} else if (!mod.inited && mod.fetched && map.isDefine) {
stillLoading = true
if (!map.prefix) {
//No reason to keep looking for unfinished
//loading. If the only stillLoading is a
//plugin resource though, keep going,
//because it may be that a plugin resource
//is waiting on a non-plugin cycle.
return (needCycleCheck = false)
}
}
}
})
if (expired && noLoads.length) {
//If wait time expired, throw error of unloaded modules.
err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads)
err.contextName = context.contextName
return onError(err)
}
//Not expired, check for a cycle.
if (needCycleCheck) {
each(reqCalls, function (mod) {
breakCycle(mod, {}, {})
})
}
//If still waiting on loads, and the waiting load is something
//other than a plugin resource, or there are still outstanding
//scripts, then just try back later.
if ((!expired || usingPathFallback) && stillLoading) {
//Something is still waiting to load. Wait for it, but only
//if a timeout is not already in effect.
if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
checkLoadedTimeoutId = setTimeout(function () {
checkLoadedTimeoutId = 0
checkLoaded()
}, 50)
}
}
inCheckLoaded = false
}
Module = function (map) {
this.events = getOwn(undefEvents, map.id) || {}
this.map = map
this.shim = getOwn(config.shim, map.id)
this.depExports = []
this.depMaps = []
this.depMatched = []
this.pluginMaps = {}
this.depCount = 0
/* this.exports this.factory
this.depMaps = [],
this.enabled, this.fetched
*/
}
Module.prototype = {
init: function (depMaps, factory, errback, options) {
options = options || {}
//Do not do more inits if already done. Can happen if there
//are multiple define calls for the same module. That is not
//a normal, common case, but it is also not unexpected.
if (this.inited) {
return
}
this.factory = factory
if (errback) {
//Register for errors on this module.
this.on('error', errback)
} else if (this.events.error) {
//If no errback already, but there are error listeners
//on this module, set up an errback to pass to the deps.
errback = bind(this, function (err) {
this.emit('error', err)
})
}
//Do a copy of the dependency array, so that
//source inputs are not modified. For example
//"shim" deps are passed in here directly, and
//doing a direct modification of the depMaps array
//would affect that config.
this.depMaps = depMaps && depMaps.slice(0)
this.errback = errback
//Indicate this module has be initialized
this.inited = true
this.ignore = options.ignore
//Could have option to init this module in enabled mode,
//or could have been previously marked as enabled. However,
//the dependencies are not known until init is called. So
//if enabled previously, now trigger dependencies as enabled.
if (options.enabled || this.enabled) {
//Enable this module and dependencies.
//Will call this.check()
this.enable()
} else {
this.check()
}
},
defineDep: function (i, depExports) {
//Because of cycles, defined callback for a given
//export can be called more than once.
if (!this.depMatched[i]) {
this.depMatched[i] = true
this.depCount -= 1
this.depExports[i] = depExports
}
},
fetch: function () {
if (this.fetched) {
return
}
this.fetched = true
context.startTime = new Date().getTime()
var map = this.map
//If the manager is for a plugin managed resource,
//ask the plugin to load it now.
if (this.shim) {
context.makeRequire(this.map, {
enableBuildCallback: true,
})(
this.shim.deps || [],
bind(this, function () {
return map.prefix ? this.callPlugin() : this.load()
})
)
} else {
//Regular dependency.
return map.prefix ? this.callPlugin() : this.load()
}
},
load: function () {
var url = this.map.url
//Regular dependency.
if (!urlFetched[url]) {
urlFetched[url] = true
context.load(this.map.id, url)
}
},
/**
* Checks if the module is ready to define itself, and if so,
* define it.
*/
check: function () {
if (!this.enabled || this.enabling) {
return
}
var err,
cjsModule,
id = this.map.id,
depExports = this.depExports,
exports = this.exports,
factory = this.factory
if (!this.inited) {
// Only fetch if not already in the defQueue.
if (!hasProp(context.defQueueMap, id)) {
this.fetch()
}
} else if (this.error) {
this.emit('error', this.error)
} else if (!this.defining) {
//The factory could trigger another require call
//that would result in checking this module to
//define itself again. If already in the process
//of doing that, skip this work.
this.defining = true
if (this.depCount < 1 && !this.defined) {
if (isFunction(factory)) {
//If there is an error listener, favor passing
//to that instead of throwing an error. However,
//only do it for define()'d modules. require
//errbacks should not be called for failures in
//their callbacks (#699). However if a global
//onError is set, use that.
if ((this.events.error && this.map.isDefine) || req.onError !== defaultOnError) {
try {
exports = context.execCb(id, factory, depExports, exports)
} catch (e) {
err = e
}
} else {
exports = context.execCb(id, factory, depExports, exports)
}
// Favor return value over exports. If node/cjs in play,
// then will not have a return value anyway. Favor
// module.exports assignment over exports object.
if (this.map.isDefine && exports === undefined) {
cjsModule = this.module
if (cjsModule) {
exports = cjsModule.exports
} else if (this.usingExports) {
//exports already set the defined value.
exports = this.exports
}
}
if (err) {
err.requireMap = this.map
err.requireModules = this.map.isDefine ? [this.map.id] : null
err.requireType = this.map.isDefine ? 'define' : 'require'
return onError((this.error = err))
}
} else {
//Just a literal value
exports = factory
}
this.exports = exports
if (this.map.isDefine && !this.ignore) {
defined[id] = exports
if (req.onResourceLoad) {
var resLoadMaps = []
each(this.depMaps, function (depMap) {
resLoadMaps.push(depMap.normalizedMap || depMap)
})
req.onResourceLoad(context, this.map, resLoadMaps)
}
}
//Clean up
cleanRegistry(id)
this.defined = true
}
//Finished the define stage. Allow calling check again
//to allow define notifications below in the case of a
//cycle.
this.defining = false
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,
//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,
bundleId = getOwn(bundlesMap, this.map.id),
name = this.map.name,
parentName = this.map.parentMap ? this.map.parentMap.name : null,
localRequire = context.makeRequire(map.parentMap, {
enableBuildCallback: true,
})
//If current map is not normalized, wait for that
//normalized name to load instead of continuing.
if (this.map.unnormalized) {
//Normalize the ID if the plugin allows it.
if (plugin.normalize) {
name =
plugin.normalize(name, function (name) {
return normalize(name, parentName, true)
}) || ''
}
//prefix and name should already be normalized, no need
//for applying map config again either.
normalizedMap = makeModuleMap(map.prefix + '!' + name, this.map.parentMap, true)
on(
normalizedMap,
'defined',
bind(this, function (value) {
this.map.normalizedMap = normalizedMap
this.init(
[],
function () {
return value
},
null,
{
enabled: true,
ignore: true,
}
)
})
)
normalizedMod = getOwn(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)
})
)
}
normalizedMod.enable()
}
return
}
//If a paths config, then just load that file instead to
//resolve the plugin, as it is built into that paths layer.
if (bundleId) {
this.map.url = context.nameToUrl(bundleId)
this.load()
return
}
load = bind(this, function (value) {
this.init(
[],
function () {
return value
},
null,
{
enabled: true,
}
)
})
load.error = bind(this, function (err) {
this.inited = true
this.error = err
err.requireModules = [id]
//Remove temp unnormalized modules for this module,
//since they will never be resolved otherwise now.
eachProp(registry, function (mod) {
if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
cleanRegistry(mod.map.id)
}
})
onError(err)
})
//Allow plugins to load other code without having to know the
//context or how to 'complete' the load.
load.fromText = bind(this, function (text, textAlt) {
/*jslint evil: true */
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.
if (hasInteractive) {
useInteractive = false
}
//Prime the system by creating a module instance for
//it.
getModule(moduleMap)
//Transfer any config to this other module.
if (hasProp(config.config, id)) {
config.config[moduleName] = config.config[id]
}
try {
req.exec(text)
} catch (e) {
return onError(makeError('fromtexteval', 'fromText eval for ' + id + ' failed: ' + e, e, [id]))
}
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, localRequire, load, config)
})
)
context.enable(pluginMap, this)
this.pluginMaps[pluginMap.id] = pluginMap
},
enable: function () {
enabledRegistry[this.map.id] = this
this.enabled = true
//Set flag mentioning that the module is enabling,
//so that immediate calls to the defined callbacks
//for dependencies do not trigger inadvertent load
//with the depCount still being zero.
this.enabling = true
//Enable each dependency
each(
this.depMaps,
bind(this, function (depMap, i) {
var id, mod, handler
if (typeof depMap === 'string') {
//Dependency needs to be converted to a depMap
//and wired up to this module.
depMap = makeModuleMap(depMap, this.map.isDefine ? this.map : this.map.parentMap, false, !this.skipMap)
this.depMaps[i] = depMap
handler = getOwn(handlers, depMap.id)
if (handler) {
this.depExports[i] = handler(this)
return
}
this.depCount += 1
on(
depMap,
'defined',
bind(this, function (depExports) {
if (this.undefed) {
return
}
this.defineDep(i, depExports)
this.check()
})
)
if (this.errback) {
on(depMap, 'error', bind(this, this.errback))
} else if (this.events.error) {
// No direct errback on this module, but something
// else is listening for errors, so be sure to
// propagate the error correctly.
on(
depMap,
'error',
bind(this, function (err) {
this.emit('error', err)
})
)
}
}
id = depMap.id
mod = registry[id]
//Skip special modules like 'require', 'exports', 'module'
//Also, don't call enable if it is already enabled,
//important in circular dependency cases.
if (!hasProp(handlers, id) && mod && !mod.enabled) {
context.enable(depMap, this)
}
})
)
//Enable each plugin that is used in
//a dependency
eachProp(
this.pluginMaps,
bind(this, function (pluginMap) {
var mod = getOwn(registry, pluginMap.id)
if (mod && !mod.enabled) {
context.enable(pluginMap, this)
}
})
)
this.enabling = false
this.check()
},
on: function (name, cb) {
var cbs = this.events[name]
if (!cbs) {
cbs = this.events[name] = []
}
cbs.push(cb)
},
emit: function (name, evt) {
each(this.events[name], function (cb) {
cb(evt)
})
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.
delete this.events[name]
}
},
}
function callGetModule(args) {
//Skip modules already defined.
if (!hasProp(defined, args[0])) {
getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2])
}
}
function removeListener(node, func, name, ieName) {
//Favor detachEvent because of IE9
//issue, see attachEvent/addEventListener comment elsewhere
//in this file.
if (node.detachEvent && !isOpera) {
//Probably IE. If not it will throw an error, which will be
//useful to know.
if (ieName) {
node.detachEvent(ieName, func)
}
} else {
node.removeEventListener(name, func, false)
}
}
/**
* Given an event from a script node, get the requirejs info from it,
* and then removes the event listeners on the node.
* @param {Event} evt
* @returns {Object}
*/
function getScriptData(evt) {