in zh/builder/lib/esl.js [19:1643]
(function (global) {
// "mod"开头的变量或函数为内部模块管理函数
// 为提高压缩率，不使用function或object包装
/**
* 模块容器
*
* @inner
* @type {Object}
*/
var modModules = {};
// 模块状态枚举量
var MODULE_PRE_DEFINED = 1;
var MODULE_ANALYZED = 2;
var MODULE_PREPARED = 3;
var MODULE_DEFINED = 4;
/**
* 自动定义的模块表
*
* 模块define factory是用到时才执行，但是以下几种情况需要自动马上执行：
* 1. require([moduleId], callback)
* 2. plugin module and plugin resource: require('plugin!resource')
* 3. shim module
*
* @inner
* @type {Object}
*/
var modAutoDefineModules = {};
/**
* 标记模块自动进行定义
*
* @inner
* @param {string} id 模块id
*/
function modFlagAutoDefine(id) {
if (!modIs(id, MODULE_DEFINED)) {
modAutoDefineModules[id] = 1;
}
}
/**
* 内建module名称集合
*
* @inner
* @type {Object}
*/
var BUILDIN_MODULE = {
require: globalRequire,
exports: 1,
module: 1
};
/**
* 全局require函数
*
* @inner
* @type {Function}
*/
var actualGlobalRequire = createLocalRequire();
// #begin-ignore
/**
* 超时提醒定时器
*
* @inner
* @type {number}
*/
var waitTimeout;
// #end-ignore
/* eslint-disable fecs-key-spacing */
/* eslint-disable key-spacing */
/**
* require配置
*
* @inner
* @type {Object}
*/
var requireConf = {
baseUrl : './',
paths : {},
config : {},
map : {},
packages : [],
shim : {},
// #begin-ignore
waitSeconds: 0,
// #end-ignore
bundles : {},
urlArgs : {}
};
/* eslint-enable key-spacing */
/**
* 加载模块
*
* @param {string|Array} requireId 模块id或模块id数组，
* @param {Function=} callback 加载完成的回调函数
* @return {*} requireId为string时返回模块暴露对象
*/
function globalRequire(requireId, callback) {
// #begin-ignore
// #begin assertNotContainRelativeId
// 确定require的模块id不包含相对id。用于global require，提前预防难以跟踪的错误出现
var invalidIds = [];
/**
* 监测模块id是否relative id
*
* @inner
* @param {string} id 模块id
*/
function monitor(id) {
if (id.indexOf('.') === 0) {
invalidIds.push(id);
}
}
if (typeof requireId === 'string') {
monitor(requireId);
}
else {
each(
requireId,
function (id) {
monitor(id);
}
);
}
// 包含相对id时，直接抛出错误
if (invalidIds.length > 0) {
throw new Error(
'[REQUIRE_FATAL]Relative ID is not allowed in global require: '
+ invalidIds.join(', ')
);
}
// #end assertNotContainRelativeId
// 超时提醒
var timeout = requireConf.waitSeconds;
if (timeout && (requireId instanceof Array)) {
if (waitTimeout) {
clearTimeout(waitTimeout);
}
waitTimeout = setTimeout(waitTimeoutNotice, timeout * 1000);
}
// #end-ignore
return actualGlobalRequire(requireId, callback);
}
/**
* 版本号
*
* @type {string}
*/
globalRequire.version = '2.0.4';
/**
* loader名称
*
* @type {string}
*/
globalRequire.loader = 'esl';
/**
* 将模块标识转换成相对的url
*
* @param {string} id 模块标识
* @return {string}
*/
globalRequire.toUrl = actualGlobalRequire.toUrl;
// #begin-ignore
/**
* 超时提醒函数
*
* @inner
*/
function waitTimeoutNotice() {
var hangModules = [];
var missModules = [];
var hangModulesMap = {};
var missModulesMap = {};
var visited = {};
/**
* 检查模块的加载错误
*
* @inner
* @param {string} id 模块id
* @param {boolean} hard 是否装载时依赖
*/
function checkError(id, hard) {
if (visited[id] || modIs(id, MODULE_DEFINED)) {
return;
}
visited[id] = 1;
if (!modIs(id, MODULE_PREPARED)) {
// HACK: 为gzip后体积优化，不做抽取
if (!hangModulesMap[id]) {
hangModulesMap[id] = 1;
hangModules.push(id);
}
}
var mod = modModules[id];
if (!mod) {
if (!missModulesMap[id]) {
missModulesMap[id] = 1;
missModules.push(id);
}
}
else if (hard) {
if (!hangModulesMap[id]) {
hangModulesMap[id] = 1;
hangModules.push(id);
}
each(
mod.depMs,
function (dep) {
checkError(dep.absId, dep.hard);
}
);
}
}
for (var id in modAutoDefineModules) {
checkError(id, 1);
}
if (hangModules.length || missModules.length) {
throw new Error(
'[MODULE_TIMEOUT]Hang( '
+ (hangModules.join(', ') || 'none')
+ ' ) Miss( '
+ (missModules.join(', ') || 'none')
+ ' )'
);
}
}
// #end-ignore
/**
* 未预定义的模块集合
* 主要存储匿名方式define的模块
*
* @inner
* @type {Array}
*/
var wait4PreDefine = [];
/**
* 完成模块预定义，此时处理的模块是匿名define的模块
*
* @inner
* @param {string} currentId 匿名define的模块的id
*/
function modCompletePreDefine(currentId) {
// HACK: 这里在IE下有个性能陷阱，不能使用任何变量。
// 否则貌似会形成变量引用和修改的读写锁，导致wait4PreDefine释放困难
each(wait4PreDefine, function (mod) {
modPreDefine(
currentId,
mod.deps,
mod.factory
);
});
wait4PreDefine.length = 0;
}
/**
* 定义模块
*
* @param {string=} id 模块标识
* @param {Array=} dependencies 依赖模块列表
* @param {Function=} factory 创建模块的工厂方法
*/
function globalDefine(id, dependencies, factory) {
// define(factory)
// define(dependencies, factory)
// define(id, factory)
// define(id, dependencies, factory)
if (factory == null) {
if (dependencies == null) {
factory = id;
id = null;
}
else {
factory = dependencies;
dependencies = null;
if (id instanceof Array) {
dependencies = id;
id = null;
}
}
}
if (factory == null) {
return;
}
var opera = window.opera;
// IE下通过current script的data-require-id获取当前id
if (
!id
&& document.attachEvent
&& (!(opera && opera.toString() === '[object Opera]'))
) {
var currentScript = getCurrentScript();
id = currentScript && currentScript.getAttribute('data-require-id');
}
if (id) {
modPreDefine(id, dependencies, factory);
}
else {
// 纪录到共享变量中，在load或readystatechange中处理
// 标准浏览器下，使用匿名define时，将进入这个分支
wait4PreDefine[0] = {
deps: dependencies,
factory: factory
};
}
}
globalDefine.amd = {};
/**
* 模块配置获取函数
*
* @inner
* @return {Object} 模块配置对象
*/
function moduleConfigGetter() {
var conf = requireConf.config[this.id];
if (conf && typeof conf === 'object') {
return conf;
}
return {};
}
/**
* 预定义模块
*
* @inner
* @param {string} id 模块标识
* @param {Array.<string>} dependencies 显式声明的依赖模块列表
* @param {*} factory 模块定义函数或模块对象
*/
function modPreDefine(id, dependencies, factory) {
// 将模块存入容器
//
// 模块内部信息包括
// -----------------------------------
// id: module id
// depsDec: 模块定义时声明的依赖
// deps: 模块依赖，默认为['require', 'exports', 'module']
// factory: 初始化函数或对象
// factoryDeps: 初始化函数的参数依赖
// exports: 模块的实际暴露对象（AMD定义）
// config: 用于获取模块配置信息的函数（AMD定义）
// state: 模块当前状态
// require: local require函数
// depMs: 实际依赖的模块集合，数组形式
// depMkv: 实际依赖的模块集合，表形式，便于查找
// depRs: 实际依赖的资源集合
// ------------------------------------
if (!modModules[id]) {
/* eslint-disable key-spacing */
modModules[id] = {
id : id,
depsDec : dependencies,
deps : dependencies || ['require', 'exports', 'module'],
factoryDeps : [],
factory : factory,
exports : {},
config : moduleConfigGetter,
state : MODULE_PRE_DEFINED,
require : createLocalRequire(id),
depMs : [],
depMkv : {},
depRs : []
};
/* eslint-enable key-spacing */
}
}
/**
* 开始执行模块定义前的准备工作
*
* 首先，完成对factory中声明依赖的分析提取
* 然后，尝试加载"资源加载所需模块"
*
* 需要先加载模块的原因是：如果模块不存在，无法进行resourceId normalize化
*
* @inner
* @param {string} id 模块id
*/
function modPrepare(id) {
var mod = modModules[id];
if (!mod || modIs(id, MODULE_ANALYZED)) {
return;
}
var deps = mod.deps;
var factory = mod.factory;
var hardDependsCount = 0;
// 分析function body中的require
// 如果包含显式依赖声明，根据AMD规定和性能考虑，可以不分析factoryBody
if (typeof factory === 'function') {
hardDependsCount = Math.min(factory.length, deps.length);
// If the dependencies argument is present, the module loader
// SHOULD NOT scan for dependencies within the factory function.
!mod.depsDec && factory.toString()
.replace(/(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg, '')
.replace(/require\(\s*(['"'])([^'"]+)\1\s*\)/g,
function ($0, $1, depId) {
deps.push(depId);
}
);
}
var requireModules = [];
var depResources = [];
each(deps, function (depId, index) {
var idInfo = parseId(depId);
var absId = normalize(idInfo.mod, id);
var moduleInfo;
var resInfo;
if (absId && !BUILDIN_MODULE[absId]) {
// 如果依赖是一个资源，将其信息添加到module.depRs
//
// module.depRs中的项有可能是重复的。
// 在这个阶段，加载resource的module可能还未defined，
// 导致此时resource id无法被normalize。
//
// 比如对a/b/c而言，下面几个resource可能指的是同一个资源：
// - js!../name.js
// - js!a/name.js
// - ../../js!../name.js
//
// 所以加载资源的module ready时，需要遍历module.depRs进行处理
if (idInfo.res) {
resInfo = {
id: depId,
mod: absId,
res: idInfo.res
};
depResources.push(depId);
mod.depRs.push(resInfo);
}
// 对依赖模块的id normalize能保证正确性，在此处进行去重
moduleInfo = mod.depMkv[absId];
if (!moduleInfo) {
moduleInfo = {
id: idInfo.mod,
absId: absId,
hard: index < hardDependsCount
};
mod.depMs.push(moduleInfo);
mod.depMkv[absId] = moduleInfo;
requireModules.push(absId);
}
}
else {
moduleInfo = {absId: absId};
}
// 如果当前正在分析的依赖项是define中声明的，
// 则记录到module.factoryDeps中
// 在factory invoke前将用于生成invoke arguments
if (index < hardDependsCount) {
mod.factoryDeps.push(resInfo || moduleInfo);
}
});
mod.state = MODULE_ANALYZED;
modInitFactoryInvoker(id);
nativeAsyncRequire(requireModules);
depResources.length && mod.require(
depResources,
function () {
each(mod.depRs, function (res) {
if (!res.absId) {
res.absId = normalize(res.id, id);
}
});
modAutoDefine();
}
);
}
/**
* 对一些需要自动定义的模块进行自动定义
*
* @inner
*/
function modAutoDefine() {
for (var id in modAutoDefineModules) {
modPrepare(id);
modUpdatePreparedState(id);
modTryInvokeFactory(id);
}
}
/**
* 更新模块的准备状态
*
* @inner
* @param {string} id 模块id
*/
function modUpdatePreparedState(id) {
var visited = {};
update(id);
function update(id) {
modPrepare(id);
if (!modIs(id, MODULE_ANALYZED)) {
return false;
}
if (modIs(id, MODULE_PREPARED) || visited[id]) {
return true;
}
visited[id] = 1;
var mod = modModules[id];
var prepared = true;
each(
mod.depMs,
function (dep) {
return (prepared = update(dep.absId));
}
);
// 判断resource是否加载完成。如果resource未加载完成，则认为未准备好
/* jshint ignore:start */
prepared && each(
mod.depRs,
function (dep) {
prepared = !!dep.absId;
return prepared;
}
);
/* jshint ignore:end */
if (prepared && !modIs(id, MODULE_PREPARED)) {
mod.state = MODULE_PREPARED;
}
return prepared;
}
}
/**
* 初始化模块定义时所需的factory执行器
*
* @inner
* @param {string} id 模块id
*/
function modInitFactoryInvoker(id) {
var mod = modModules[id];
var invoking;
mod.invokeFactory = invokeFactory;
/**
* 初始化模块
*
* @inner
*/
function invokeFactory() {
if (invoking || mod.state !== MODULE_PREPARED) {
return;
}
invoking = 1;
// 拼接factory invoke所需的arguments
var factoryReady = 1;
each(
mod.factoryDeps,
function (dep) {
var depId = dep.absId;
if (!BUILDIN_MODULE[depId]) {
modTryInvokeFactory(depId);
return (factoryReady = modIs(depId, MODULE_DEFINED));
}
}
);
if (factoryReady) {
try {
// 调用factory函数初始化module
var factory = mod.factory;
var exports = typeof factory === 'function'
? factory.apply(global, modGetModulesExports(
mod.factoryDeps,
{
require: mod.require,
exports: mod.exports,
module: mod
}
))
: factory;
if (exports != null) {
mod.exports = exports;
}
mod.invokeFactory = null;
}
catch (ex) {
if (/^\[MODULE_MISS\]"([^"]+)/.test(ex.message)) {
// 出错，则说明在factory的运行中，该require的模块是需要的
// 所以把它加入强依赖中
var hardCirclurDep = mod.depMkv[RegExp.$1];
hardCirclurDep && (hardCirclurDep.hard = 1);
// 如果是模块本身有问题导致的运行错误
// 就不要把invoking置回去了，避免影响autoInvoke其他模块的初始化
invoking = 0;
return;
}
throw ex;
}
// 完成define
// 不放在try里，避免后续的运行错误被这里吞掉
modDefined(id);
}
}
}
/**
* 判断模块是否完成相应的状态
*
* @inner
* @param {string} id 模块标识
* @param {number} state 状态码，使用时传入相应的枚举变量，比如`MODULE_DEFINED`
* @return {boolean} 是否完成相应的状态
*/
function modIs(id, state) {
return modModules[id] && modModules[id].state >= state;
}
/**
* 尝试执行模块factory函数，进行模块初始化
*
* @inner
* @param {string} id 模块id
*/
function modTryInvokeFactory(id) {
var mod = modModules[id];
if (mod && mod.invokeFactory) {
mod.invokeFactory();
}
}
/**
* 根据模块id数组，获取其的exports数组
* 用于模块初始化的factory参数或require的callback参数生成
*
* @inner
* @param {Array} modules 模块id数组
* @param {Object} buildinModules 内建模块对象
* @return {Array} 模块exports数组
*/
function modGetModulesExports(modules, buildinModules) {
var args = [];
each(
modules,
function (id, index) {
if (typeof id === 'object') {
id = id.absId;
}
args[index] = buildinModules[id] || modModules[id].exports;
}
);
return args;
}
/**
* 模块定义完成事件监听器容器
*
* @inner
* @type {Object}
*/
var modDefinedListeners = {};
/**
* 添加模块定义完成时间的监听器
*
* @inner
* @param {string} id 模块标识
* @param {Function} listener 监听函数
*/
function modAddDefinedListener(id, listener) {
if (modIs(id, MODULE_DEFINED)) {
listener();
return;
}
var listeners = modDefinedListeners[id];
if (!listeners) {
listeners = modDefinedListeners[id] = [];
}
listeners.push(listener);
}
/**
* 模块状态切换为定义完成
* 因为需要触发事件，MODULE_DEFINED状态切换通过该函数
*
* @inner
* @param {string} id 模块标识
*/
function modDefined(id) {
var mod = modModules[id];
mod.state = MODULE_DEFINED;
delete modAutoDefineModules[id];
var listeners = modDefinedListeners[id] || [];
var len = listeners.length;
while (len--) {
// 这里不做function类型的检测
// 因为listener都是通过modOn传入的，modOn为内部调用
listeners[len]();
}
// 清理listeners
listeners.length = 0;
modDefinedListeners[id] = null;
}
/**
* 异步加载模块
* 内部使用，模块ID必须是经过normalize的Top-Level ID
*
* @inner
* @param {Array} ids 模块名称或模块名称列表
* @param {Function=} callback 获取模块完成时的回调函数
* @param {string} baseId 基础id，用于当ids是relative id时的normalize
*/
function nativeAsyncRequire(ids, callback, baseId) {
var isCallbackCalled = 0;
each(ids, function (id) {
if (!(BUILDIN_MODULE[id] || modIs(id, MODULE_DEFINED))) {
modAddDefinedListener(id, tryFinishRequire);
(id.indexOf('!') > 0
? loadResource
: loadModule
)(id, baseId);
}
});
tryFinishRequire();
/**
* 尝试完成require，调用callback
* 在模块与其依赖模块都加载完时调用
*
* @inner
*/
function tryFinishRequire() {
if (typeof callback === 'function' && !isCallbackCalled) {
var isAllCompleted = 1;
each(ids, function (id) {
if (!BUILDIN_MODULE[id]) {
return (isAllCompleted = !!modIs(id, MODULE_DEFINED));
}
});
// 检测并调用callback
if (isAllCompleted) {
isCallbackCalled = 1;
callback.apply(
global,
modGetModulesExports(ids, BUILDIN_MODULE)
);
}
}
}
}
/**
* 正在加载的模块列表
*
* @inner
* @type {Object}
*/
var loadingModules = {};
/**
* 加载模块
*
* @inner
* @param {string} moduleId 模块标识
*/
function loadModule(moduleId) {
// 加载过的模块，就不要再继续了
if (loadingModules[moduleId] || modModules[moduleId]) {
return;
}
loadingModules[moduleId] = 1;
// 初始化相关 shim 的配置
var shimConf = requireConf.shim[moduleId];
if (shimConf instanceof Array) {
requireConf.shim[moduleId] = shimConf = {
deps: shimConf
};
}
// shim依赖的模块需要自动标识为shim
// 无论是纯正的shim模块还是hybird模块
var shimDeps = shimConf && (shimConf.deps || []);
if (shimDeps) {
each(shimDeps, function (dep) {
if (!requireConf.shim[dep]) {
requireConf.shim[dep] = {};
}
});
actualGlobalRequire(shimDeps, load);
}
else {
load();
}
/**
* 发送请求去加载模块
*
* @inner
*/
function load() {
/* eslint-disable no-use-before-define */
var bundleModuleId = bundlesIndex[moduleId];
createScript(bundleModuleId || moduleId, loaded);
/* eslint-enable no-use-before-define */
}
/**
* script标签加载完成的事件处理函数
*
* @inner
*/
function loaded() {
if (shimConf) {
var exports;
if (typeof shimConf.init === 'function') {
exports = shimConf.init.apply(
global,
modGetModulesExports(shimDeps, BUILDIN_MODULE)
);
}
if (exports == null && shimConf.exports) {
exports = global;
each(
shimConf.exports.split('.'),
function (prop) {
exports = exports[prop];
return !!exports;
}
);
}
globalDefine(moduleId, shimDeps, exports || {});
}
else {
modCompletePreDefine(moduleId);
}
modAutoDefine();
}
}
/**
* 加载资源
*
* @inner
* @param {string} pluginAndResource 插件与资源标识
* @param {string} baseId 当前环境的模块标识
*/
function loadResource(pluginAndResource, baseId) {
if (modModules[pluginAndResource]) {
return;
}
/* eslint-disable no-use-before-define */
var bundleModuleId = bundlesIndex[pluginAndResource];
if (bundleModuleId) {
loadModule(bundleModuleId);
return;
}
/* eslint-enable no-use-before-define */
var idInfo = parseId(pluginAndResource);
var resource = {
id: pluginAndResource,
state: MODULE_ANALYZED
};
modModules[pluginAndResource] = resource;
/**
* plugin加载完成的回调函数
*
* @inner
* @param {*} value resource的值
*/
function pluginOnload(value) {
resource.exports = value || true;
modDefined(pluginAndResource);
}
/* jshint ignore:start */
/**
* 该方法允许plugin使用加载的资源声明模块
*
* @param {string} id 模块id
* @param {string} text 模块声明字符串
*/
pluginOnload.fromText = function (id, text) {
new Function(text)();
modCompletePreDefine(id);
};
/* jshint ignore:end */
/**
* 加载资源
*
* @inner
* @param {Object} plugin 用于加载资源的插件模块
*/
function load(plugin) {
var pluginRequire = baseId
? modModules[baseId].require
: actualGlobalRequire;
plugin.load(
idInfo.res,
pluginRequire,
pluginOnload,
moduleConfigGetter.call({id: pluginAndResource})
);
}
load(actualGlobalRequire(idInfo.mod));
}
/**
* 配置require
*
* @param {Object} conf 配置对象
*/
globalRequire.config = function (conf) {
if (conf) {
for (var key in requireConf) {
var newValue = conf[key];
var oldValue = requireConf[key];
if (!newValue) {
continue;
}
if (key === 'urlArgs' && typeof newValue === 'string') {
requireConf.urlArgs['*'] = newValue;
}
else {
// 简单的多处配置还是需要支持，所以配置实现为支持二级mix
if (oldValue instanceof Array) {
oldValue.push.apply(oldValue, newValue);
}
else if (typeof oldValue === 'object') {
for (var k in newValue) {
oldValue[k] = newValue[k];
}
}
else {
requireConf[key] = newValue;
}
}
}
createConfIndex();
}
};
// 初始化时需要创建配置索引
createConfIndex();
/**
* paths内部索引
*
* @inner
* @type {Array}
*/
var pathsIndex;
/**
* packages内部索引
*
* @inner
* @type {Array}
*/
var packagesIndex;
/**
* mapping内部索引
*
* @inner
* @type {Array}
*/
var mappingIdIndex;
/**
* bundles内部索引
*
* @inner
* @type {Object}
*/
var bundlesIndex;
/**
* urlArgs内部索引
*
* @inner
* @type {Array}
*/
var urlArgsIndex;
/**
* 将key为module id prefix的Object，生成数组形式的索引，并按照长度和字面排序
*
* @inner
* @param {Object} value 源值
* @param {boolean} allowAsterisk 是否允许*号表示匹配所有
* @return {Array} 索引对象
*/
function createKVSortedIndex(value, allowAsterisk) {
var index = kv2List(value, 1, allowAsterisk);
index.sort(descSorterByKOrName);
return index;
}
/**
* 创建配置信息内部索引
*
* @inner
*/
function createConfIndex() {
requireConf.baseUrl = requireConf.baseUrl.replace(/\/$/, '') + '/';
// create paths index
pathsIndex = createKVSortedIndex(requireConf.paths);
// create mappingId index
mappingIdIndex = createKVSortedIndex(requireConf.map, 1);
each(
mappingIdIndex,
function (item) {
item.v = createKVSortedIndex(item.v);
}
);
// create packages index
packagesIndex = [];
each(
requireConf.packages,
function (packageConf) {
var pkg = packageConf;
if (typeof packageConf === 'string') {
pkg = {
name: packageConf.split('/')[0],
location: packageConf,
main: 'main'
};
}
pkg.location = pkg.location || pkg.name;
pkg.main = (pkg.main || 'main').replace(/\.js$/i, '');
pkg.reg = createPrefixRegexp(pkg.name);
packagesIndex.push(pkg);
}
);
packagesIndex.sort(descSorterByKOrName);
// create urlArgs index
urlArgsIndex = createKVSortedIndex(requireConf.urlArgs, 1);
// create bundles index
bundlesIndex = {};
/* eslint-disable no-use-before-define */
function bundlesIterator(id) {
bundlesIndex[resolvePackageId(id)] = key;
}
/* eslint-enable no-use-before-define */
for (var key in requireConf.bundles) {
each(requireConf.bundles[key], bundlesIterator);
}
}
/**
* 对配置信息的索引进行检索
*
* @inner
* @param {string} value 要检索的值
* @param {Array} index 索引对象
* @param {Function} hitBehavior 索引命中的行为函数
*/
function indexRetrieve(value, index, hitBehavior) {
each(index, function (item) {
if (item.reg.test(value)) {
hitBehavior(item.v, item.k, item);
return false;
}
});
}
/**
* 将`模块标识+'.extension'`形式的字符串转换成相对的url
*
* @inner
* @param {string} source 源字符串
* @return {string} url
*/
function toUrl(source) {
// 分离 模块标识 和 .extension
var extReg = /(\.[a-z0-9]+)$/i;
var queryReg = /(\?[^#]*)$/;
var extname = '';
var id = source;
var query = '';
if (queryReg.test(source)) {
query = RegExp.$1;
source = source.replace(queryReg, '');
}
if (extReg.test(source)) {
extname = RegExp.$1;
id = source.replace(extReg, '');
}
var url = id;
// paths处理和匹配
var isPathMap;
indexRetrieve(id, pathsIndex, function (value, key) {
url = url.replace(key, value);
isPathMap = 1;
});
// packages处理和匹配
if (!isPathMap) {
indexRetrieve(id, packagesIndex, function (value, key, item) {
url = url.replace(item.name, item.location);
});
}
// 相对路径时，附加baseUrl
if (!/^([a-z]{2,10}:\/)?\//i.test(url)) {
url = requireConf.baseUrl + url;
}
// 附加 .extension 和 query
url += extname + query;
// urlArgs处理和匹配
indexRetrieve(id, urlArgsIndex, function (value) {
url += (url.indexOf('?') > 0 ? '&' : '?') + value;
});
return url;
}
/**
* 创建local require函数
*
* @inner
* @param {number} baseId 当前module id
* @return {Function} local require函数
*/
function createLocalRequire(baseId) {
var requiredCache = {};
function req(requireId, callback) {
if (typeof requireId === 'string') {
if (!requiredCache[requireId]) {
var topLevelId = normalize(requireId, baseId);
// 根据 https://github.com/amdjs/amdjs-api/wiki/require
// It MUST throw an error if the module has not
// already been loaded and evaluated.
modTryInvokeFactory(topLevelId);
if (!modIs(topLevelId, MODULE_DEFINED)) {
throw new Error('[MODULE_MISS]"' + topLevelId + '" is not exists!');
}
requiredCache[requireId] = modModules[topLevelId].exports;
}
return requiredCache[requireId];
}
else if (requireId instanceof Array) {
// 分析是否有resource，取出pluginModule先
var pureModules = [];
var normalizedIds = [];
each(
requireId,
function (id, i) {
var idInfo = parseId(id);
var absId = normalize(idInfo.mod, baseId);
var resId = idInfo.res;
var normalizedId = absId;
if (resId) {
var trueResId = absId + '!' + resId;
if (resId.indexOf('.') !== 0 && bundlesIndex[trueResId]) {
absId = normalizedId = trueResId;
}
else {
normalizedId = null;
}
}
normalizedIds[i] = normalizedId;
modFlagAutoDefine(absId);
pureModules.push(absId);
}
);
// 加载模块
nativeAsyncRequire(
pureModules,
function () {
/* jshint ignore:start */
each(normalizedIds, function (id, i) {
if (id == null) {
id = normalizedIds[i] = normalize(requireId[i], baseId);
modFlagAutoDefine(id);
}
});
/* jshint ignore:end */
// modAutoDefine中，factory invoke可能发生错误
// 从而导致nativeAsyncRequire没有被调用，callback没挂上
// 所以nativeAsyncRequire要先运行
nativeAsyncRequire(normalizedIds, callback, baseId);
modAutoDefine();
},
baseId
);
modAutoDefine();
}
}
/**
* 将[module ID] + '.extension'格式的字符串转换成url
*
* @inner
* @param {string} id 符合描述格式的源字符串
* @return {string} url
*/
req.toUrl = function (id) {
return toUrl(normalize(id, baseId));
};
return req;
}
/**
* id normalize化
*
* @inner
* @param {string} id 需要normalize的模块标识
* @param {string} baseId 当前环境的模块标识
* @return {string} normalize结果
*/
function normalize(id, baseId) {
if (!id) {
return '';
}
baseId = baseId || '';
var idInfo = parseId(id);
if (!idInfo) {
return id;
}
var resourceId = idInfo.res;
var moduleId = resolvePackageId(
relative2absolute(idInfo.mod, baseId)
);
// 根据config中的map配置进行module id mapping
indexRetrieve(
baseId,
mappingIdIndex,
function (value) {
indexRetrieve(
moduleId,
value,
function (mdValue, mdKey) {
moduleId = moduleId.replace(mdKey, mdValue);
}
);
}
);
if (resourceId) {
var mod = modIs(moduleId, MODULE_DEFINED) && actualGlobalRequire(moduleId);
resourceId = mod && mod.normalize
? mod.normalize(
resourceId,
function (resId) {
return normalize(resId, baseId);
}
)
: normalize(resourceId, baseId);
moduleId += '!' + resourceId;
}
return moduleId;
}
/**
* 对id进行package解析
* 如果是package，则附加主模块id
*
* @inner
* @param {string} id 模块id
* @return {string} 解析后的id
*/
function resolvePackageId(id) {
each(
packagesIndex,
function (packageConf) {
var name = packageConf.name;
if (name === id) {
id = name + '/' + packageConf.main;
return false;
}
}
);
return id;
}
/**
* 相对id转换成绝对id
*
* @inner
* @param {string} id 要转换的相对id
* @param {string} baseId 当前所在环境id
* @return {string} 绝对id
*/
function relative2absolute(id, baseId) {
if (id.indexOf('.') === 0) {
var basePath = baseId.split('/');
var namePath = id.split('/');
var baseLen = basePath.length - 1;
var nameLen = namePath.length;
var cutBaseTerms = 0;
var cutNameTerms = 0;
/* eslint-disable block-scoped-var */
pathLoop: for (var i = 0; i < nameLen; i++) {
switch (namePath[i]) {
case '..':
if (cutBaseTerms < baseLen) {
cutBaseTerms++;
cutNameTerms++;
}
else {
break pathLoop;
}
break;
case '.':
cutNameTerms++;
break;
default:
break pathLoop;
}
}
/* eslint-enable block-scoped-var */
basePath.length = baseLen - cutBaseTerms;
namePath = namePath.slice(cutNameTerms);
return basePath.concat(namePath).join('/');
}
return id;
}
/**
* 解析id，返回带有module和resource属性的Object
*
* @inner
* @param {string} id 标识
* @return {Object} id解析结果对象
*/
function parseId(id) {
var segs = id.split('!');
if (segs[0]) {
return {
mod: segs[0],
res: segs[1]
};
}
}
/**
* 将对象数据转换成数组，数组每项是带有k和v的Object
*
* @inner
* @param {Object} source 对象数据
* @param {boolean} keyMatchable key是否允许被前缀匹配
* @param {boolean} allowAsterisk 是否支持*匹配所有
* @return {Array.<Object>} 对象转换数组
*/
function kv2List(source, keyMatchable, allowAsterisk) {
var list = [];
for (var key in source) {
if (source.hasOwnProperty(key)) {
var item = {
k: key,
v: source[key]
};
list.push(item);
if (keyMatchable) {
item.reg = key === '*' && allowAsterisk
? /^/
: createPrefixRegexp(key);
}
}
}
return list;
}
// 感谢requirejs，通过currentlyAddingScript兼容老旧ie
//
// For some cache cases in IE 6-8, the script executes before the end
// of the appendChild execution, so to tie an anonymous define
// call to the module name (which is stored on the node), hold on
// to a reference to this node, but clear after the DOM insertion.
var currentlyAddingScript;
var interactiveScript;
/**
* 获取当前script标签
* 用于ie下define未指定module id时获取id
*
* @inner
* @return {HTMLScriptElement} 当前script标签
*/
function getCurrentScript() {
if (currentlyAddingScript) {
return currentlyAddingScript;
}
else if (
interactiveScript
&& interactiveScript.readyState === 'interactive'
) {
return interactiveScript;
}
var scripts = document.getElementsByTagName('script');
var scriptLen = scripts.length;
while (scriptLen--) {
var script = scripts[scriptLen];
if (script.readyState === 'interactive') {
interactiveScript = script;
return script;
}
}
}
var headElement = document.getElementsByTagName('head')[0];
var baseElement = document.getElementsByTagName('base')[0];
if (baseElement) {
headElement = baseElement.parentNode;
}
function createScript(moduleId, onload) {
// 创建script标签
//
// 这里不挂接onerror的错误处理
// 因为高级浏览器在devtool的console面板会报错
// 再throw一个Error多此一举了
var script = document.createElement('script');
script.setAttribute('data-require-id', moduleId);
script.src = toUrl(moduleId + '.js');
script.async = true;
if (script.readyState) {
script.onreadystatechange = innerOnload;
}
else {
script.onload = innerOnload;
}
function innerOnload() {
var readyState = script.readyState;
if (
typeof readyState === 'undefined'
|| /^(loaded|complete)$/.test(readyState)
) {
script.onload = script.onreadystatechange = null;
script = null;
// Script onload hooker
// ECHARTS-BUILDER-WEB
esl.onModuleLoad && esl.onModuleLoad(moduleId);
onload();
}
}
currentlyAddingScript = script;
// If BASE tag is in play, using appendChild is a problem for IE6.
// See: http://dev.jquery.com/ticket/2709
baseElement
? headElement.insertBefore(script, baseElement)
: headElement.appendChild(script);
currentlyAddingScript = null;
}
/**
* 创建id前缀匹配的正则对象
*
* @inner
* @param {string} prefix id前缀
* @return {RegExp} 前缀匹配的正则对象
*/
function createPrefixRegexp(prefix) {
return new RegExp('^' + prefix + '(/|$)');
}
/**
* 循环遍历数组集合
*
* @inner
* @param {Array} source 数组源
* @param {function(Array,Number):boolean} iterator 遍历函数
*/
function each(source, iterator) {
if (source instanceof Array) {
for (var i = 0, len = source.length; i < len; i++) {
if (iterator(source[i], i) === false) {
break;
}
}
}
}
/**
* 根据元素的k或name项进行数组字符数逆序的排序函数
*
* @inner
* @param {Object} a 要比较的对象a
* @param {Object} b 要比较的对象b
* @return {number} 比较结果
*/
function descSorterByKOrName(a, b) {
var aValue = a.k || a.name;
var bValue = b.k || b.name;
if (bValue === '*') {
return -1;
}
if (aValue === '*') {
return 1;
}
return bValue.length - aValue.length;
}
// 暴露全局对象
if (!define) {
define = globalDefine;
// 可能碰到其他形式的loader，所以，不要覆盖人家
if (!require) {
require = globalRequire;
}
// 如果存在其他版本的esl，在define那里就判断过了，不会进入这个分支
// 所以这里就不判断了，直接写
esl = globalRequire;
// 为 echarts-builder-web 暴露模块
// ECHARTS-BUILDER-WEB
esl.modules = modModules;
}
})(this);