mirror of
https://github.com/overleaf/overleaf.git
synced 2024-09-16 02:52:31 -04:00
295 lines
9.2 KiB
JavaScript
Executable file
295 lines
9.2 KiB
JavaScript
Executable file
/* ***** 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(function(require, exports, module) {
|
|
"no use strict";
|
|
|
|
var lang = require("./lib/lang");
|
|
var oop = require("./lib/oop");
|
|
var net = require("./lib/net");
|
|
var EventEmitter = require("./lib/event_emitter").EventEmitter;
|
|
|
|
var global = (function() {
|
|
return this;
|
|
})();
|
|
|
|
var options = {
|
|
packaged: false,
|
|
workerPath: null,
|
|
modePath: null,
|
|
themePath: null,
|
|
basePath: "",
|
|
suffix: ".js",
|
|
$moduleUrls: {}
|
|
};
|
|
|
|
exports.get = function(key) {
|
|
if (!options.hasOwnProperty(key))
|
|
throw new Error("Unknown config key: " + key);
|
|
|
|
return options[key];
|
|
};
|
|
|
|
exports.set = function(key, value) {
|
|
if (!options.hasOwnProperty(key))
|
|
throw new Error("Unknown config key: " + key);
|
|
|
|
options[key] = value;
|
|
};
|
|
|
|
exports.all = function() {
|
|
return lang.copyObject(options);
|
|
};
|
|
|
|
// module loading
|
|
oop.implement(exports, EventEmitter);
|
|
|
|
exports.moduleUrl = function(name, component) {
|
|
if (options.$moduleUrls[name])
|
|
return options.$moduleUrls[name];
|
|
|
|
var parts = name.split("/");
|
|
component = component || parts[parts.length - 2] || "";
|
|
|
|
// todo make this configurable or get rid of '-'
|
|
var sep = component == "snippets" ? "/" : "-";
|
|
var base = parts[parts.length - 1];
|
|
if (sep == "-") {
|
|
var re = new RegExp("^" + component + "[\\-_]|[\\-_]" + component + "$", "g");
|
|
base = base.replace(re, "");
|
|
}
|
|
|
|
if ((!base || base == component) && parts.length > 1)
|
|
base = parts[parts.length - 2];
|
|
var path = options[component + "Path"];
|
|
if (path == null) {
|
|
path = options.basePath;
|
|
} else if (sep == "/") {
|
|
component = sep = "";
|
|
}
|
|
if (path && path.slice(-1) != "/")
|
|
path += "/";
|
|
return path + component + sep + base + this.get("suffix");
|
|
};
|
|
|
|
exports.setModuleUrl = function(name, subst) {
|
|
return options.$moduleUrls[name] = subst;
|
|
};
|
|
|
|
exports.$loading = {};
|
|
exports.loadModule = function(moduleName, onLoad) {
|
|
var module, moduleType;
|
|
if (Array.isArray(moduleName)) {
|
|
moduleType = moduleName[0];
|
|
moduleName = moduleName[1];
|
|
}
|
|
|
|
try {
|
|
module = require(moduleName);
|
|
} catch (e) {}
|
|
// require(moduleName) can return empty object if called after require([moduleName], callback)
|
|
if (module && !exports.$loading[moduleName])
|
|
return onLoad && onLoad(module);
|
|
|
|
if (!exports.$loading[moduleName])
|
|
exports.$loading[moduleName] = [];
|
|
|
|
exports.$loading[moduleName].push(onLoad);
|
|
|
|
if (exports.$loading[moduleName].length > 1)
|
|
return;
|
|
|
|
var afterLoad = function() {
|
|
require([moduleName], function(module) {
|
|
exports._emit("load.module", {name: moduleName, module: module});
|
|
var listeners = exports.$loading[moduleName];
|
|
exports.$loading[moduleName] = null;
|
|
listeners.forEach(function(onLoad) {
|
|
onLoad && onLoad(module);
|
|
});
|
|
});
|
|
};
|
|
|
|
if (!exports.get("packaged"))
|
|
return afterLoad();
|
|
net.loadScript(exports.moduleUrl(moduleName, moduleType), afterLoad);
|
|
};
|
|
|
|
|
|
// initialization
|
|
exports.init = function() {
|
|
options.packaged = require.packaged || module.packaged || (global.define && define.packaged);
|
|
|
|
if (!global.document)
|
|
return "";
|
|
|
|
var scriptOptions = {};
|
|
var scriptUrl = "";
|
|
|
|
var scripts = document.getElementsByTagName("script");
|
|
for (var i=0; i<scripts.length; i++) {
|
|
var script = scripts[i];
|
|
|
|
var src = script.src || script.getAttribute("src");
|
|
if (!src)
|
|
continue;
|
|
|
|
var attributes = script.attributes;
|
|
for (var j=0, l=attributes.length; j < l; j++) {
|
|
var attr = attributes[j];
|
|
if (attr.name.indexOf("data-ace-") === 0) {
|
|
scriptOptions[deHyphenate(attr.name.replace(/^data-ace-/, ""))] = attr.value;
|
|
}
|
|
}
|
|
|
|
var m = src.match(/^(.*)\/ace(\-\w+)?\.js(\?|$)/);
|
|
if (m)
|
|
scriptUrl = m[1];
|
|
}
|
|
|
|
if (scriptUrl) {
|
|
scriptOptions.base = scriptOptions.base || scriptUrl;
|
|
scriptOptions.packaged = true;
|
|
}
|
|
|
|
scriptOptions.basePath = scriptOptions.base;
|
|
scriptOptions.workerPath = scriptOptions.workerPath || scriptOptions.base;
|
|
scriptOptions.modePath = scriptOptions.modePath || scriptOptions.base;
|
|
scriptOptions.themePath = scriptOptions.themePath || scriptOptions.base;
|
|
delete scriptOptions.base;
|
|
|
|
for (var key in scriptOptions)
|
|
if (typeof scriptOptions[key] !== "undefined")
|
|
exports.set(key, scriptOptions[key]);
|
|
};
|
|
|
|
function deHyphenate(str) {
|
|
return str.replace(/-(.)/g, function(m, m1) { return m1.toUpperCase(); });
|
|
}
|
|
|
|
var optionsProvider = {
|
|
setOptions: function(optList) {
|
|
Object.keys(optList).forEach(function(key) {
|
|
this.setOption(key, optList[key]);
|
|
}, this);
|
|
},
|
|
getOptions: function(optionNames) {
|
|
var result = {};
|
|
if (!optionNames) {
|
|
optionNames = Object.keys(this.$options);
|
|
} else if (!Array.isArray(optionNames)) {
|
|
result = optionNames;
|
|
optionNames = Object.keys(result);
|
|
}
|
|
optionNames.forEach(function(key) {
|
|
result[key] = this.getOption(key);
|
|
}, this);
|
|
return result;
|
|
},
|
|
setOption: function(name, value) {
|
|
if (this["$" + name] === value)
|
|
return;
|
|
var opt = this.$options[name];
|
|
if (!opt) {
|
|
if (typeof console != "undefined" && console.warn)
|
|
console.warn('misspelled option "' + name + '"');
|
|
return undefined;
|
|
}
|
|
if (opt.forwardTo)
|
|
return this[opt.forwardTo] && this[opt.forwardTo].setOption(name, value);
|
|
|
|
if (!opt.handlesSet)
|
|
this["$" + name] = value;
|
|
if (opt && opt.set)
|
|
opt.set.call(this, value);
|
|
},
|
|
getOption: function(name) {
|
|
var opt = this.$options[name];
|
|
if (!opt) {
|
|
if (typeof console != "undefined" && console.warn)
|
|
console.warn('misspelled option "' + name + '"');
|
|
return undefined;
|
|
}
|
|
if (opt.forwardTo)
|
|
return this[opt.forwardTo] && this[opt.forwardTo].getOption(name);
|
|
return opt && opt.get ? opt.get.call(this) : this["$" + name];
|
|
}
|
|
};
|
|
|
|
var defaultOptions = {};
|
|
/*
|
|
* option {name, value, initialValue, setterName, set, get }
|
|
*/
|
|
exports.defineOptions = function(obj, path, options) {
|
|
if (!obj.$options)
|
|
defaultOptions[path] = obj.$options = {};
|
|
|
|
Object.keys(options).forEach(function(key) {
|
|
var opt = options[key];
|
|
if (typeof opt == "string")
|
|
opt = {forwardTo: opt};
|
|
|
|
opt.name || (opt.name = key);
|
|
obj.$options[opt.name] = opt;
|
|
if ("initialValue" in opt)
|
|
obj["$" + opt.name] = opt.initialValue;
|
|
});
|
|
|
|
// implement option provider interface
|
|
oop.implement(obj, optionsProvider);
|
|
|
|
return this;
|
|
};
|
|
|
|
exports.resetOptions = function(obj) {
|
|
Object.keys(obj.$options).forEach(function(key) {
|
|
var opt = obj.$options[key];
|
|
if ("value" in opt)
|
|
obj.setOption(key, opt.value);
|
|
});
|
|
};
|
|
|
|
exports.setDefaultValue = function(path, name, value) {
|
|
var opts = defaultOptions[path] || (defaultOptions[path] = {});
|
|
if (opts[name]) {
|
|
if (opts.forwardTo)
|
|
exports.setDefaultValue(opts.forwardTo, name, value);
|
|
else
|
|
opts[name].value = value;
|
|
}
|
|
};
|
|
|
|
exports.setDefaultValues = function(path, optionHash) {
|
|
Object.keys(optionHash).forEach(function(key) {
|
|
exports.setDefaultValue(path, key, optionHash[key]);
|
|
});
|
|
};
|
|
|
|
});
|