/**
|
* ESL (Enterprise Standard Loader)
|
* Copyright 2013 Baidu Inc. All rights reserved.
|
*
|
* @file Browser端标准加载器，符合AMD规范
|
* @author errorrik(errorrik@gmail.com)
|
* Firede(firede@firede.us)
|
*/
|
|
/* jshint ignore:start */
|
var define;
|
var require;
|
var esl;
|
/* jshint ignore:end */
|
|
(function (global) {
|
// "mod"开头的变量或函数为内部模块管理函数
|
// 为提高压缩率，不使用function或object包装
|
|
/**
|
* 模块容器
|
*
|
* @inner
|
* @type {Object}
|
*/
|
var modModules = {};
|
|
/**
|
* 自动定义的模块表
|
*
|
* 模块define factory是用到时才执行，但是以下几种情况需要自动马上执行：
|
* 1. require( [moduleId], callback )
|
* 2. plugin module: require( 'plugin!resource' )
|
*
|
* @inner
|
* @type {Object}
|
*/
|
var autoDefineModules = {};
|
|
|
// 模块状态枚举量
|
var MODULE_PRE_DEFINED = 1;
|
var MODULE_ANALYZED = 2;
|
var MODULE_PREPARED = 3;
|
var MODULE_DEFINED = 4;
|
|
/**
|
* 内建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 : [],
|
// #begin-ignore
|
waitSeconds: 0,
|
// #end-ignore
|
noRequests : {},
|
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 = '1.8.8';
|
|
/**
|
* 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);
|
}
|
);
|
}
|
}
|
|
/* eslint-disable guard-for-in */
|
for (var id in autoDefineModules) {
|
checkError(id, 1);
|
}
|
/* eslint-enable guard-for-in */
|
|
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 completePreDefine(currentId) {
|
// HACK: 这里在IE下有个性能陷阱，不能使用任何变量。
|
// 否则貌似会形成变量引用和修改的读写锁，导致wait4PreDefine释放困难
|
each(wait4PreDefine, function (mod) {
|
modPreDefine(
|
currentId,
|
mod.deps,
|
mod.factory
|
);
|
});
|
|
wait4PreDefine.length = 0;
|
modAnalyse(currentId);
|
}
|
|
/**
|
* 定义模块
|
*
|
* @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: 实际依赖的资源集合
|
// depPMs: 用于加载资源的模块集合，key是模块名，value是1，仅用于快捷查找
|
// ------------------------------------
|
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 : [],
|
depPMs : []
|
};
|
/* eslint-enable key-spacing */
|
}
|
}
|
|
/**
|
* 预分析模块
|
*
|
* 首先，完成对factory中声明依赖的分析提取
|
* 然后，尝试加载"资源加载所需模块"
|
*
|
* 需要先加载模块的原因是：如果模块不存在，无法进行resourceId normalize化
|
* modAnalyse完成后续的依赖分析处理，并进行依赖模块的加载
|
*
|
* @inner
|
* @param {string} id 模块id
|
*/
|
function modAnalyse(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 = [];
|
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
|
};
|
autoDefineModules[absId] = 1;
|
mod.depPMs.push(absId);
|
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);
|
nativeRequire(requireModules);
|
}
|
|
/**
|
* 对一些需要自动定义的模块进行自动定义
|
*
|
* @inner
|
*/
|
function modAutoInvoke() {
|
/* eslint-disable guard-for-in */
|
for (var id in autoDefineModules) {
|
modUpdatePreparedState(id);
|
modTryInvokeFactory(id);
|
}
|
/* eslint-enable guard-for-in */
|
}
|
|
/**
|
* 更新模块的准备状态
|
*
|
* @inner
|
* @param {string} id 模块id
|
*/
|
function modUpdatePreparedState(id) {
|
var visited = {};
|
update(id);
|
|
function update(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 && modIs(dep.absId, MODULE_DEFINED));
|
return prepared;
|
}
|
);
|
/* jshint ignore:end */
|
|
if (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;
|
/* eslint-disable max-nested-callbacks */
|
each(
|
mod.depPMs,
|
function (pluginModuleId) {
|
|
modAddDefinedListener(
|
pluginModuleId,
|
function () {
|
each(mod.depRs, function (res) {
|
if (!res.absId && res.mod === pluginModuleId) {
|
res.absId = normalize(res.id, id);
|
nativeRequire([res.absId], modAutoInvoke);
|
}
|
});
|
}
|
);
|
|
}
|
);
|
/* eslint-enable max-nested-callbacks */
|
|
/**
|
* 初始化模块
|
*
|
* @inner
|
*/
|
function invokeFactory() {
|
if (invoking || mod.state !== MODULE_PREPARED) {
|
return;
|
}
|
|
invoking = 1;
|
|
// 拼接factory invoke所需的arguments
|
var factoryReady = 1;
|
var factoryDeps = [];
|
each(
|
mod.factoryDeps,
|
function (dep) {
|
var depId = dep.absId;
|
|
if (!BUILDIN_MODULE[depId]) {
|
modTryInvokeFactory(depId);
|
if (!modIs(depId, MODULE_DEFINED)) {
|
factoryReady = 0;
|
return false;
|
}
|
}
|
|
factoryDeps.push(depId);
|
}
|
);
|
|
if (factoryReady) {
|
try {
|
var args = modGetModulesExports(
|
factoryDeps,
|
{
|
require: mod.require,
|
exports: mod.exports,
|
module: mod
|
}
|
);
|
|
// 调用factory函数初始化module
|
var factory = mod.factory;
|
var exports = typeof factory === 'function'
|
? factory.apply(global, args)
|
: factory;
|
|
if (exports != null) {
|
mod.exports = exports;
|
}
|
|
mod.invokeFactory = null;
|
delete autoDefineModules[id];
|
}
|
catch (ex) {
|
invoking = 0;
|
if (/^\[MODULE_MISS\]"([^"]+)/.test(ex.message)) {
|
// 出错，则说明在factory的运行中，该require的模块是需要的
|
// 所以把它加入强依赖中
|
var hardCirclurDep = mod.depMkv[RegExp.$1];
|
hardCirclurDep && (hardCirclurDep.hard = 1);
|
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) {
|
args[index] = buildinModules[id] || modGetModuleExports(id);
|
}
|
);
|
|
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 listeners = modDefinedListeners[id] || [];
|
var mod = modModules[id];
|
mod.state = MODULE_DEFINED;
|
|
var len = listeners.length;
|
while (len--) {
|
// 这里不做function类型的检测
|
// 因为listener都是通过modOn传入的，modOn为内部调用
|
listeners[len]();
|
}
|
|
// 清理listeners
|
listeners.length = 0;
|
delete modDefinedListeners[id];
|
}
|
|
/**
|
* 获取模块的exports
|
*
|
* @inner
|
* @param {string} id 模块标识
|
* @return {*} 模块的exports
|
*/
|
function modGetModuleExports(id) {
|
if (modIs(id, MODULE_DEFINED)) {
|
return modModules[id].exports;
|
}
|
|
return null;
|
}
|
|
/**
|
* 获取模块
|
*
|
* @param {string|Array} ids 模块名称或模块名称列表
|
* @param {Function=} callback 获取模块完成时的回调函数
|
* @param {string} baseId 基础id，用于当ids是relative id时的normalize
|
* @param {Object} noRequests 无需发起请求的模块集合
|
* @return {Object} 模块对象
|
*/
|
function nativeRequire(ids, callback, baseId, noRequests) {
|
// 根据 https://github.com/amdjs/amdjs-api/wiki/require
|
// It MUST throw an error if the module has not
|
// already been loaded and evaluated.
|
if (typeof ids === 'string') {
|
modTryInvokeFactory(ids);
|
if (!modIs(ids, MODULE_DEFINED)) {
|
throw new Error('[MODULE_MISS]"' + ids + '" is not exists!');
|
}
|
|
return modGetModuleExports(ids);
|
}
|
|
noRequests = noRequests || {};
|
var isCallbackCalled = 0;
|
if (ids instanceof Array) {
|
tryFinishRequire();
|
|
if (!isCallbackCalled) {
|
each(ids, function (id) {
|
if (!(BUILDIN_MODULE[id] || modIs(id, MODULE_DEFINED))) {
|
modAddDefinedListener(id, tryFinishRequire);
|
|
if (!noRequests[id]) {
|
(id.indexOf('!') > 0
|
? loadResource
|
: loadModule
|
)(id, baseId);
|
}
|
|
modAnalyse(id);
|
}
|
});
|
|
modAutoInvoke();
|
}
|
}
|
|
/**
|
* 尝试完成require，调用callback
|
* 在模块与其依赖模块都加载完时调用
|
*
|
* @inner
|
*/
|
function tryFinishRequire() {
|
if (!isCallbackCalled) {
|
var isAllCompleted = 1;
|
each(ids, function (id) {
|
if (!BUILDIN_MODULE[id]) {
|
return (isAllCompleted = !!modIs(id, MODULE_DEFINED));
|
}
|
});
|
|
// 检测并调用callback
|
if (isAllCompleted) {
|
isCallbackCalled = 1;
|
|
(typeof callback === 'function') && 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;
|
|
// 创建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 = loadedListener;
|
}
|
else {
|
script.onload = loadedListener;
|
}
|
appendScript(script);
|
|
/**
|
* script标签加载完成的事件处理函数
|
*
|
* @inner
|
*/
|
function loadedListener() {
|
var readyState = script.readyState;
|
if (
|
typeof readyState === 'undefined'
|
|| /^(loaded|complete)$/.test(readyState)
|
) {
|
script.onload = script.onreadystatechange = null;
|
script = null;
|
|
completePreDefine(moduleId);
|
/* eslint-disable guard-for-in */
|
for (var key in autoDefineModules) {
|
modAnalyse(key);
|
}
|
/* eslint-enable guard-for-in */
|
modAutoInvoke();
|
}
|
}
|
}
|
|
/**
|
* 加载资源
|
*
|
* @inner
|
* @param {string} pluginAndResource 插件与资源标识
|
* @param {string} baseId 当前环境的模块标识
|
*/
|
function loadResource(pluginAndResource, baseId) {
|
if (modModules[pluginAndResource]) {
|
return;
|
}
|
|
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) {
|
autoDefineModules[id] = 1;
|
new Function(text)();
|
completePreDefine(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(modGetModuleExports(idInfo.mod));
|
}
|
|
/**
|
* 配置require
|
*
|
* @param {Object} conf 配置对象
|
*/
|
globalRequire.config = function (conf) {
|
if (conf) {
|
/* eslint-disable guard-for-in */
|
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;
|
}
|
}
|
}
|
/* eslint-enable guard-for-in */
|
|
createConfIndex();
|
}
|
|
// 配置信息对象clone返回，避免返回结果对象被用户程序修改可能导致的问题
|
// return clone(requireConf);
|
};
|
|
/**
|
* 对象克隆，支持raw type, Array, raw Object
|
*
|
* @inner
|
* @param {*} source 要克隆的对象
|
* @return {*}
|
*/
|
// function clone(source) {
|
// var result = source;
|
|
// if (source instanceof Array) {
|
// result = [];
|
// each(source, function (item, i) {
|
// result[i] = clone(item);
|
// });
|
// }
|
// else if (typeof source === 'object') {
|
// result = {};
|
// for (var key in source) {
|
// if (source.hasOwnProperty(key)) {
|
// result[key] = clone(source[key]);
|
// }
|
// }
|
// }
|
|
// return result;
|
// }
|
|
// 初始化时需要创建配置索引
|
createConfIndex();
|
|
/**
|
* paths内部索引
|
*
|
* @inner
|
* @type {Array}
|
*/
|
var pathsIndex;
|
|
/**
|
* packages内部索引
|
*
|
* @inner
|
* @type {Array}
|
*/
|
var packagesIndex;
|
|
/**
|
* mapping内部索引
|
*
|
* @inner
|
* @type {Array}
|
*/
|
var mappingIdIndex;
|
|
/**
|
* urlArgs内部索引
|
*
|
* @inner
|
* @type {Array}
|
*/
|
var urlArgsIndex;
|
|
/**
|
* noRequests内部索引
|
*
|
* @inner
|
* @type {Array}
|
*/
|
var noRequestsIndex;
|
|
/**
|
* 将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 noRequests index
|
noRequestsIndex = createKVSortedIndex(requireConf.noRequests);
|
each(noRequestsIndex, function (item) {
|
var value = item.v;
|
var mapIndex = {};
|
item.v = mapIndex;
|
|
if (!(value instanceof Array)) {
|
value = [value];
|
}
|
|
each(value, function (meetId) {
|
mapIndex[meetId] = 1;
|
});
|
});
|
}
|
|
/**
|
* 对配置信息的索引进行检索
|
*
|
* @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]) {
|
requiredCache[requireId] =
|
nativeRequire(normalize(requireId, baseId));
|
}
|
|
return requiredCache[requireId];
|
}
|
else if (requireId instanceof Array) {
|
// 分析是否有resource，取出pluginModule先
|
var pluginModules = [];
|
var pureModules = [];
|
var normalizedIds = [];
|
|
each(
|
requireId,
|
function (id, i) {
|
var idInfo = parseId(id);
|
var absId = normalize(idInfo.mod, baseId);
|
pureModules.push(absId);
|
autoDefineModules[absId] = 1;
|
|
if (idInfo.res) {
|
pluginModules.push(absId);
|
normalizedIds[i] = null;
|
}
|
else {
|
normalizedIds[i] = absId;
|
}
|
}
|
);
|
|
var noRequestModules = {};
|
each(
|
pureModules,
|
function (id) {
|
var meet;
|
indexRetrieve(
|
id,
|
noRequestsIndex,
|
function (value) {
|
meet = value;
|
}
|
);
|
|
if (meet) {
|
if (meet['*']) {
|
noRequestModules[id] = 1;
|
}
|
else {
|
each(pureModules, function (meetId) {
|
if (meet[meetId]) {
|
noRequestModules[id] = 1;
|
return false;
|
}
|
});
|
}
|
}
|
}
|
);
|
|
// 加载模块
|
nativeRequire(
|
pureModules,
|
function () {
|
/* jshint ignore:start */
|
each(normalizedIds, function (id, i) {
|
if (id == null) {
|
normalizedIds[i] = normalize(requireId[i], baseId);
|
}
|
});
|
/* jshint ignore:end */
|
|
nativeRequire(normalizedIds, callback, baseId);
|
},
|
baseId,
|
noRequestModules
|
);
|
}
|
}
|
|
/**
|
* 将[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 = relative2absolute(idInfo.mod, baseId);
|
|
each(
|
packagesIndex,
|
function (packageConf) {
|
var name = packageConf.name;
|
if (name === moduleId) {
|
moduleId = name + '/' + packageConf.main;
|
return false;
|
}
|
}
|
);
|
|
// 根据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 = modGetModuleExports(moduleId);
|
resourceId = mod.normalize
|
? mod.normalize(
|
resourceId,
|
function (resId) {
|
return normalize(resId, baseId);
|
}
|
)
|
: normalize(resourceId, baseId);
|
|
moduleId += '!' + resourceId;
|
}
|
|
return moduleId;
|
}
|
|
/**
|
* 相对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]
|
};
|
}
|
|
return null;
|
}
|
|
/**
|
* 将对象数据转换成数组，数组每项是带有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;
|
}
|
|
/**
|
* 向页面中插入script标签
|
*
|
* @inner
|
* @param {HTMLScriptElement} script script标签
|
*/
|
function appendScript(script) {
|
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;
|
}
|
})(this);
|
