orionsoft-react-scripts
Version:
Orionsoft Configuration and scripts for Create React App.
574 lines (503 loc) • 15.1 kB
JavaScript
var path = require("path");
var fs = require("fs");
fs.existsSync = fs.existsSync || path.existsSync;
var resolve = require("enhanced-resolve");
var interpret = require("interpret");
module.exports = function(optimist, argv, convertOptions) {
var options = {};
// Help
if(argv.help) {
optimist.showHelp();
process.exit(-1); // eslint-disable-line
}
// Shortcuts
if(argv.d) {
argv.debug = true;
argv["output-pathinfo"] = true;
if(!argv.devtool) {
argv.devtool = "sourcemap";
}
}
if(argv.p) {
argv["optimize-minimize"] = true;
argv["optimize-occurence-order"] = true;
}
var configPath, ext;
var extensions = Object.keys(interpret.extensions).sort(function(a, b) {
return a.length - b.length;
});
if(argv.config) {
configPath = path.resolve(argv.config);
for(var i = extensions.length - 1; i >= 0; i--) {
var tmpExt = extensions[i];
if(configPath.indexOf(tmpExt, configPath.length - tmpExt.length) > -1) {
ext = tmpExt;
break;
}
}
if(!ext) {
ext = path.extname(configPath);
}
} else {
for(var i = 0; i < extensions.length; i++) {
var webpackConfig = path.resolve("webpack.config" + extensions[i]);
if(fs.existsSync(webpackConfig)) {
ext = extensions[i];
configPath = webpackConfig;
break;
}
}
}
if(configPath) {
function registerCompiler(moduleDescriptor) {
if(moduleDescriptor) {
if(typeof moduleDescriptor === "string") {
require(moduleDescriptor);
} else if(!Array.isArray(moduleDescriptor)) {
moduleDescriptor.register(require(moduleDescriptor.module));
} else {
for(var i = 0; i < moduleDescriptor.length; i++) {
try {
registerCompiler(moduleDescriptor[i]);
break;
} catch(e) {
// do nothing
}
}
}
}
}
registerCompiler(interpret.extensions[ext]);
options = require(configPath);
}
return processConfiguredOptions(options);
function processConfiguredOptions(options) {
if(typeof options !== "object" || options === null) {
console.log("Config did not export an object.");
process.exit(-1); // eslint-disable-line
}
// process Promise
if(typeof options.then === "function") {
return options.then(processConfiguredOptions);
}
// process ES6 default
if(typeof options === "object" && typeof options["default"] === "object") {
return processConfiguredOptions(options["default"]);
}
if(Array.isArray(options)) {
options.forEach(processOptions);
} else {
processOptions(options);
}
if(argv.context) {
options.context = path.resolve(argv.context);
}
if(!options.context) {
options.context = process.cwd();
}
if(argv.watch) {
// TODO remove this in next major version
if(options.watch && typeof options.watch === "object") {
console.warn("options.watch is deprecated: Use 'options.watchOptions' instead");
options.watchOptions = options.watch;
}
// TODO remove this in next major version
if(options.watchDelay) {
console.warn("options.watchDelay is deprecated: Use 'options.watchOptions.aggregateTimeout' instead");
options.watchOptions = options.watchOptions || {};
options.watchOptions.aggregateTimeout = options.watchDelay;
}
options.watch = true;
}
if(argv["watch-delay"]) {
console.warn("--watch-delay is deprecated: Use '--watch-aggregate-timeout' instead");
options.watchOptions = options.watchOptions || {};
options.watchOptions.aggregateTimeout = +argv["watch-delay"];
}
if(argv["watch-aggregate-timeout"]) {
options.watchOptions = options.watchOptions || {};
options.watchOptions.aggregateTimeout = +argv["watch-aggregate-timeout"];
}
if(argv["watch-poll"]) {
options.watchOptions = options.watchOptions || {};
if(typeof argv["watch-poll"] !== "boolean")
options.watchOptions.poll = +argv["watch-poll"];
else
options.watchOptions.poll = true;
}
if(argv["watch-stdin"]) {
options.watchOptions = options.watchOptions || {};
options.watchOptions.stdin = true;
options.watch = true;
}
return options;
}
function processOptions(options) {
function ifArg(name, fn, init, finalize) {
if(Array.isArray(argv[name])) {
if(init) {
init();
}
argv[name].forEach(fn);
if(finalize) {
finalize();
}
} else if(typeof argv[name] !== "undefined") {
if(init) {
init();
}
fn(argv[name], -1);
if(finalize) {
finalize();
}
}
}
function ifArgPair(name, fn, init, finalize) {
ifArg(name, function(content, idx) {
var i = content.indexOf("=");
if(i < 0) {
return fn(null, content, idx);
} else {
return fn(content.substr(0, i), content.substr(i + 1), idx);
}
}, init, finalize);
}
function ifBooleanArg(name, fn) {
ifArg(name, function(bool) {
if(bool) {
fn();
}
});
}
function mapArgToBoolean(name, optionName) {
ifBooleanArg(name, function() {
options[optionName || name] = true;
});
}
function mapArgToBooleanInverse(name, optionName) {
ifArg(name, function(bool) {
if(!bool) {
options[optionName || name] = false;
}
});
}
function mapArgToPath(name, optionName) {
ifArg(name, function(str) {
options[optionName || name] = path.resolve(str);
});
}
function loadPlugin(name) {
var loadUtils = require("loader-utils");
var args = null;
try {
var p = name && name.indexOf("?");
if(p > -1) {
args = loadUtils.parseQuery(name.substring(p));
name = name.substring(0, p);
}
} catch(e) {
console.log("Invalid plugin arguments " + name + " (" + e + ").");
process.exit(-1); // eslint-disable-line
}
var path;
try {
path = resolve.sync(process.cwd(), name);
} catch(e) {
console.log("Cannot resolve plugin " + name + ".");
process.exit(-1); // eslint-disable-line
}
var Plugin;
try {
Plugin = require(path);
} catch(e) {
console.log("Cannot load plugin " + name + ". (" + path + ")");
throw e;
}
try {
return new Plugin(args);
} catch(e) {
console.log("Cannot instantiate plugin " + name + ". (" + path + ")");
throw e;
}
}
function ensureObject(parent, name) {
if(typeof parent[name] !== "object" || parent[name] === null) {
parent[name] = {};
}
}
function ensureArray(parent, name) {
if(!Array.isArray(parent[name])) {
parent[name] = [];
}
}
ifArgPair("entry", function(name, entry) {
options.entry[name] = entry;
}, function() {
ensureObject(options, "entry");
});
function bindLoaders(arg, collection) {
ifArgPair(arg, function(name, binding) {
if(name === null) {
name = binding;
}
options.module[collection].push({
test: new RegExp("\\." + name.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&") + "$"),
loader: binding
});
}, function() {
ensureObject(options, "module");
ensureArray(options.module, collection);
});
}
bindLoaders("module-bind", "loaders");
bindLoaders("module-bind-pre", "preLoaders");
bindLoaders("module-bind-post", "postLoaders");
var defineObject;
ifArgPair("define", function(name, value) {
if(name === null) {
name = value;
value = true;
}
defineObject[name] = value;
}, function() {
defineObject = {};
}, function() {
ensureArray(options, "plugins");
var DefinePlugin = require("../lib/DefinePlugin");
options.plugins.push(new DefinePlugin(defineObject));
});
ifArg("output-path", function(value) {
ensureObject(options, "output");
options.output.path = value;
});
ifArg("output-file", function(value) {
console.warn("output.file will be deprecated: Use 'output.filename' instead");
ensureObject(options, "output");
options.output.filename = value;
});
ifArg("output-filename", function(value) {
ensureObject(options, "output");
options.output.filename = value;
});
ifArg("output-chunk-file", function(value) {
ensureObject(options, "output");
options.output.chunkFilename = value;
});
ifArg("output-named-chunk-file", function(value) {
ensureObject(options, "output");
options.output.namedChunkFilename = value;
});
ifArg("output-source-map-file", function(value) {
ensureObject(options, "output");
options.output.sourceMapFilename = value;
});
ifArg("output-public-path", function(value) {
ensureObject(options, "output");
options.output.publicPath = value;
});
ifArg("output-jsonp-function", function(value) {
ensureObject(options, "output");
options.output.jsonpFunction = value;
});
ifBooleanArg("output-pathinfo", function() {
ensureObject(options, "output");
options.output.pathinfo = true;
});
ifArg("output-library", function(value) {
ensureObject(options, "output");
options.output.library = value;
});
ifArg("output-library-target", function(value) {
ensureObject(options, "output");
options.output.libraryTarget = value;
});
ifArg("records-input-path", function(value) {
options.recordsInputPath = path.resolve(value);
});
ifArg("records-output-path", function(value) {
options.recordsOutputPath = path.resolve(value);
});
ifArg("records-path", function(value) {
options.recordsPath = path.resolve(value);
});
ifArg("target", function(value) {
options.target = value;
});
mapArgToBooleanInverse("cache");
ifBooleanArg("hot", function() {
ensureArray(options, "plugins");
var HotModuleReplacementPlugin = require("../lib/HotModuleReplacementPlugin");
options.plugins.push(new HotModuleReplacementPlugin());
});
mapArgToBoolean("debug");
ifBooleanArg("progress", function() {
var ProgressPlugin = require("../lib/ProgressPlugin");
ensureArray(options, "plugins");
var chars = 0,
lastState, lastStateTime;
options.plugins.push(new ProgressPlugin(function(percentage, msg) {
var state = msg;
if(percentage < 1) {
percentage = Math.floor(percentage * 100);
msg = percentage + "% " + msg;
if(percentage < 100) {
msg = " " + msg;
}
if(percentage < 10) {
msg = " " + msg;
}
}
if(options.profile) {
state = state.replace(/^\d+\/\d+\s+/, "");
if(percentage === 0) {
lastState = null;
lastStateTime = +new Date();
} else if(state !== lastState || percentage === 1) {
var now = +new Date();
if(lastState) {
var stateMsg = (now - lastStateTime) + "ms " + lastState;
goToLineStart(stateMsg);
process.stderr.write(stateMsg + "\n");
chars = 0;
}
lastState = state;
lastStateTime = now;
}
}
goToLineStart(msg);
process.stderr.write(msg);
}));
function goToLineStart(nextMessage) {
var str = "";
for(; chars > nextMessage.length; chars--) {
str += "\b \b";
}
chars = nextMessage.length;
for(var i = 0; i < chars; i++) {
str += "\b";
}
if(str) process.stderr.write(str);
}
});
ifArg("devtool", function(value) {
options.devtool = value;
});
function processResolveAlias(arg, key) {
ifArgPair(arg, function(name, value) {
if(!name) {
throw new Error("--" + arg + " <string>=<string>");
}
ensureObject(options, key);
ensureObject(options[key], "alias");
options[key].alias[name] = value;
});
}
processResolveAlias("resolve-alias", "resolve");
processResolveAlias("resolve-loader-alias", "resolveLoader");
ifArg("optimize-max-chunks", function(value) {
ensureArray(options, "plugins");
var LimitChunkCountPlugin = require("../lib/optimize/LimitChunkCountPlugin");
options.plugins.push(new LimitChunkCountPlugin({
maxChunks: parseInt(value, 10)
}));
});
ifArg("optimize-min-chunk-size", function(value) {
ensureArray(options, "plugins");
var MinChunkSizePlugin = require("../lib/optimize/MinChunkSizePlugin");
options.plugins.push(new MinChunkSizePlugin({
minChunkSize: parseInt(value, 10)
}));
});
ifBooleanArg("optimize-minimize", function() {
ensureArray(options, "plugins");
var UglifyJsPlugin = require("../lib/optimize/UglifyJsPlugin");
options.plugins.push(new UglifyJsPlugin());
});
ifBooleanArg("optimize-occurence-order", function() {
ensureArray(options, "plugins");
var OccurenceOrderPlugin = require("../lib/optimize/OccurenceOrderPlugin");
options.plugins.push(new OccurenceOrderPlugin());
});
ifBooleanArg("optimize-dedupe", function() {
ensureArray(options, "plugins");
var DedupePlugin = require("../lib/optimize/DedupePlugin");
options.plugins.push(new DedupePlugin());
});
ifArg("prefetch", function(request) {
ensureArray(options, "plugins");
var PrefetchPlugin = require("../lib/PrefetchPlugin");
options.plugins.push(new PrefetchPlugin(request));
});
ifArg("provide", function(value) {
ensureArray(options, "plugins");
var idx = value.indexOf("=");
var name;
if(idx >= 0) {
name = value.substr(0, idx);
value = value.substr(idx + 1);
} else {
name = value;
}
var ProvidePlugin = require("../lib/ProvidePlugin");
options.plugins.push(new ProvidePlugin(name, value));
});
ifBooleanArg("labeled-modules", function() {
ensureArray(options, "plugins");
var LabeledModulesPlugin = require("../lib/dependencies/LabeledModulesPlugin");
options.plugins.push(new LabeledModulesPlugin());
});
ifArg("plugin", function(value) {
ensureArray(options, "plugins");
options.plugins.push(loadPlugin(value));
});
mapArgToBoolean("bail");
mapArgToBoolean("profile");
if(!options.output || !options.output.filename) {
ensureObject(options, "output");
if(convertOptions && convertOptions.outputFilename) {
options.output.path = path.dirname(convertOptions.outputFilename);
options.output.filename = path.basename(convertOptions.outputFilename);
} else if(argv._.length > 0) {
options.output.filename = argv._.pop();
options.output.path = path.dirname(options.output.filename);
options.output.filename = path.basename(options.output.filename);
} else {
optimist.showHelp();
console.error("Output filename not configured.");
process.exit(-1); // eslint-disable-line
}
}
if(argv._.length > 0) {
if(Array.isArray(options.entry) || typeof options.entry === "string") {
options.entry = {
main: options.entry
};
}
ensureObject(options, "entry");
function addTo(name, entry) {
if(options.entry[name]) {
if(!Array.isArray(options.entry[name])) {
options.entry[name] = [options.entry[name]];
}
options.entry[name].push(entry);
} else {
options.entry[name] = entry;
}
}
argv._.forEach(function(content) {
var i = content.indexOf("=");
var j = content.indexOf("?");
if(i < 0 || (j >= 0 && j < i)) {
var resolved = path.resolve(content);
if(fs.existsSync(resolved)) {
addTo("main", resolved);
} else {
addTo("main", content);
}
} else {
addTo(content.substr(0, i), content.substr(i + 1));
}
});
}
}
};