kopia lustrzana https://github.com/c9/core
175 wiersze
5.7 KiB
JavaScript
175 wiersze
5.7 KiB
JavaScript
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Distributed under the BSD license:
|
|
*
|
|
* Copyright (c) 2010, Ajax.org B.V.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of Ajax.org B.V. nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL AJAX.ORG B.V. BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
/**
|
|
* Define a module along with a payload
|
|
* @param module a name for the payload
|
|
* @param payload a function to call with (require, exports, module) params
|
|
*/
|
|
|
|
(function() {
|
|
|
|
var ACE_NAMESPACE = "";
|
|
|
|
var global = (function() { return this; })();
|
|
if (!global && typeof window != "undefined") global = window; // strict mode
|
|
|
|
|
|
if (!ACE_NAMESPACE && typeof requirejs !== "undefined")
|
|
return;
|
|
|
|
|
|
var define = function(module, deps, payload) {
|
|
if (typeof module !== "string") {
|
|
if (define.original)
|
|
define.original.apply(this, arguments);
|
|
else {
|
|
console.error("dropping module because define wasn\'t a string.");
|
|
console.trace();
|
|
}
|
|
return;
|
|
}
|
|
if (arguments.length == 2)
|
|
payload = deps;
|
|
if (!define.modules[module]) {
|
|
define.payloads[module] = payload;
|
|
define.modules[module] = null;
|
|
}
|
|
};
|
|
|
|
define.modules = {};
|
|
define.payloads = {};
|
|
|
|
/**
|
|
* Get at functionality define()ed using the function above
|
|
*/
|
|
var _require = function(parentId, module, callback) {
|
|
if (typeof module === "string") {
|
|
var payload = lookup(parentId, module);
|
|
if (payload != undefined) {
|
|
callback && callback();
|
|
return payload;
|
|
}
|
|
} else if (Object.prototype.toString.call(module) === "[object Array]") {
|
|
var params = [];
|
|
for (var i = 0, l = module.length; i < l; ++i) {
|
|
var dep = lookup(parentId, module[i]);
|
|
if (dep == undefined && require.original)
|
|
return;
|
|
params.push(dep);
|
|
}
|
|
return callback && callback.apply(null, params) || true;
|
|
}
|
|
};
|
|
|
|
var require = function(module, callback) {
|
|
var packagedModule = _require("", module, callback);
|
|
if (packagedModule == undefined && require.original)
|
|
return require.original.apply(this, arguments);
|
|
return packagedModule;
|
|
};
|
|
|
|
var normalizeModule = function(parentId, moduleName) {
|
|
// normalize plugin requires
|
|
if (moduleName.indexOf("!") !== -1) {
|
|
var chunks = moduleName.split("!");
|
|
return normalizeModule(parentId, chunks[0]) + "!" + normalizeModule(parentId, chunks[1]);
|
|
}
|
|
// normalize relative requires
|
|
if (moduleName.charAt(0) == ".") {
|
|
var base = parentId.split("/").slice(0, -1).join("/");
|
|
moduleName = base + "/" + moduleName;
|
|
|
|
while(moduleName.indexOf(".") !== -1 && previous != moduleName) {
|
|
var previous = moduleName;
|
|
moduleName = moduleName.replace(/\/\.\//, "/").replace(/[^\/]+\/\.\.\//, "");
|
|
}
|
|
}
|
|
return moduleName;
|
|
};
|
|
|
|
/**
|
|
* Internal function to lookup moduleNames and resolve them by calling the
|
|
* definition function if needed.
|
|
*/
|
|
var lookup = function(parentId, moduleName) {
|
|
moduleName = normalizeModule(parentId, moduleName);
|
|
|
|
var module = define.modules[moduleName];
|
|
if (!module) {
|
|
module = define.payloads[moduleName];
|
|
if (typeof module === 'function') {
|
|
var exports = {};
|
|
var mod = {
|
|
id: moduleName,
|
|
uri: '',
|
|
exports: exports,
|
|
packaged: true
|
|
};
|
|
|
|
var req = function(module, callback) {
|
|
return _require(moduleName, module, callback);
|
|
};
|
|
|
|
var returnValue = module(req, exports, mod);
|
|
exports = returnValue || mod.exports;
|
|
define.modules[moduleName] = exports;
|
|
delete define.payloads[moduleName];
|
|
}
|
|
module = define.modules[moduleName] = exports || module;
|
|
}
|
|
return module;
|
|
};
|
|
|
|
function exportAce(ns) {
|
|
var root = global;
|
|
if (ns) {
|
|
if (!global[ns])
|
|
global[ns] = {};
|
|
root = global[ns];
|
|
}
|
|
|
|
if (!root.define || !root.define.packaged) {
|
|
define.original = root.define;
|
|
root.define = define;
|
|
root.define.packaged = true;
|
|
}
|
|
|
|
if (!root.require || !root.require.packaged) {
|
|
require.original = root.require;
|
|
root.require = require;
|
|
root.require.packaged = true;
|
|
}
|
|
}
|
|
|
|
exportAce(ACE_NAMESPACE);
|
|
|
|
})();
|