diff options
Diffstat (limited to 'node_modules/webpack-cli/bin/cli.js')
| -rwxr-xr-x | node_modules/webpack-cli/bin/cli.js | 366 |
1 files changed, 366 insertions, 0 deletions
diff --git a/node_modules/webpack-cli/bin/cli.js b/node_modules/webpack-cli/bin/cli.js new file mode 100755 index 0000000..79f667b --- /dev/null +++ b/node_modules/webpack-cli/bin/cli.js @@ -0,0 +1,366 @@ +#!/usr/bin/env node + +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +const { NON_COMPILATION_ARGS } = require("./utils/constants"); + +(function() { + // wrap in IIFE to be able to use return + + const importLocal = require("import-local"); + // Prefer the local installation of webpack-cli + if (importLocal(__filename)) { + return; + } + + require("v8-compile-cache"); + + const ErrorHelpers = require("./utils/errorHelpers"); + + const NON_COMPILATION_CMD = process.argv.find(arg => { + if (arg === "serve") { + global.process.argv = global.process.argv.filter(a => a !== "serve"); + process.argv = global.process.argv; + } + return NON_COMPILATION_ARGS.find(a => a === arg); + }); + + if (NON_COMPILATION_CMD) { + return require("./utils/prompt-command")(NON_COMPILATION_CMD, ...process.argv); + } + + const yargs = require("yargs").usage(`webpack-cli ${require("../package.json").version} + +Usage: webpack-cli [options] + webpack-cli [options] --entry <entry> --output <output> + webpack-cli [options] <entries...> --output <output> + webpack-cli <command> [options] + +For more information, see https://webpack.js.org/api/cli/.`); + + require("./config/config-yargs")(yargs); + + // yargs will terminate the process early when the user uses help or version. + // This causes large help outputs to be cut short (https://github.com/nodejs/node/wiki/API-changes-between-v0.10-and-v4#process). + // To prevent this we use the yargs.parse API and exit the process normally + yargs.parse(process.argv.slice(2), (err, argv, output) => { + Error.stackTraceLimit = 30; + + // arguments validation failed + if (err && output) { + console.error(output); + process.exitCode = 1; + return; + } + + // help or version info + if (output) { + console.log(output); + return; + } + + if (argv.verbose) { + argv["display"] = "verbose"; + } + + let options; + try { + options = require("./utils/convert-argv")(argv); + } catch (err) { + if (err.code === "MODULE_NOT_FOUND") { + const moduleName = err.message.split("'")[1]; + let instructions = ""; + let errorMessage = ""; + + if (moduleName === "webpack") { + errorMessage = `\n${moduleName} not installed`; + instructions = `Install webpack to start bundling: \u001b[32m\n $ npm install --save-dev ${moduleName}\n`; + + if (process.env.npm_execpath !== undefined && process.env.npm_execpath.includes("yarn")) { + instructions = `Install webpack to start bundling: \u001b[32m\n $ yarn add ${moduleName} --dev\n`; + } + Error.stackTraceLimit = 1; + console.error(`${errorMessage}\n\n${instructions}`); + process.exitCode = 1; + return; + } + } + + if (err.name !== "ValidationError") { + throw err; + } + + const stack = ErrorHelpers.cleanUpWebpackOptions(err.stack, err.message); + const message = err.message + "\n" + stack; + + if (argv.color) { + console.error(`\u001b[1m\u001b[31m${message}\u001b[39m\u001b[22m`); + } else { + console.error(message); + } + + process.exitCode = 1; + return; + } + + /** + * When --silent flag is present, an object with a no-op write method is + * used in place of process.stout + */ + const stdout = argv.silent ? { write: () => {} } : process.stdout; + + function ifArg(name, fn, init) { + if (Array.isArray(argv[name])) { + if (init) init(); + argv[name].forEach(fn); + } else if (typeof argv[name] !== "undefined") { + if (init) init(); + fn(argv[name], -1); + } + } + + function processOptions(options) { + // process Promise + if (typeof options.then === "function") { + options.then(processOptions).catch(function(err) { + console.error(err.stack || err); + // eslint-disable-next-line no-process-exit + process.exit(1); + }); + return; + } + + const firstOptions = [].concat(options)[0]; + const statsPresetToOptions = require("webpack").Stats.presetToOptions; + + let outputOptions = options.stats; + if (typeof outputOptions === "boolean" || typeof outputOptions === "string") { + outputOptions = statsPresetToOptions(outputOptions); + } else if (!outputOptions) { + outputOptions = {}; + } + + ifArg("display", function(preset) { + outputOptions = statsPresetToOptions(preset); + }); + + outputOptions = Object.create(outputOptions); + if (Array.isArray(options) && !outputOptions.children) { + outputOptions.children = options.map(o => o.stats); + } + if (typeof outputOptions.context === "undefined") outputOptions.context = firstOptions.context; + + ifArg("env", function(value) { + if (outputOptions.env) { + outputOptions._env = value; + } + }); + + ifArg("json", function(bool) { + if (bool) { + outputOptions.json = bool; + outputOptions.modules = bool; + } + }); + + if (typeof outputOptions.colors === "undefined") outputOptions.colors = require("supports-color").stdout; + + ifArg("sort-modules-by", function(value) { + outputOptions.modulesSort = value; + }); + + ifArg("sort-chunks-by", function(value) { + outputOptions.chunksSort = value; + }); + + ifArg("sort-assets-by", function(value) { + outputOptions.assetsSort = value; + }); + + ifArg("display-exclude", function(value) { + outputOptions.exclude = value; + }); + + if (!outputOptions.json) { + if (typeof outputOptions.cached === "undefined") outputOptions.cached = false; + if (typeof outputOptions.cachedAssets === "undefined") outputOptions.cachedAssets = false; + + ifArg("display-chunks", function(bool) { + if (bool) { + outputOptions.modules = false; + outputOptions.chunks = true; + outputOptions.chunkModules = true; + } + }); + + ifArg("display-entrypoints", function(bool) { + outputOptions.entrypoints = bool; + }); + + ifArg("display-reasons", function(bool) { + if (bool) outputOptions.reasons = true; + }); + + ifArg("display-depth", function(bool) { + if (bool) outputOptions.depth = true; + }); + + ifArg("display-used-exports", function(bool) { + if (bool) outputOptions.usedExports = true; + }); + + ifArg("display-provided-exports", function(bool) { + if (bool) outputOptions.providedExports = true; + }); + + ifArg("display-optimization-bailout", function(bool) { + if (bool) outputOptions.optimizationBailout = bool; + }); + + ifArg("display-error-details", function(bool) { + if (bool) outputOptions.errorDetails = true; + }); + + ifArg("display-origins", function(bool) { + if (bool) outputOptions.chunkOrigins = true; + }); + + ifArg("display-max-modules", function(value) { + outputOptions.maxModules = +value; + }); + + ifArg("display-cached", function(bool) { + if (bool) outputOptions.cached = true; + }); + + ifArg("display-cached-assets", function(bool) { + if (bool) outputOptions.cachedAssets = true; + }); + + if (!outputOptions.exclude) outputOptions.exclude = ["node_modules", "bower_components", "components"]; + + if (argv["display-modules"]) { + outputOptions.maxModules = Infinity; + outputOptions.exclude = undefined; + outputOptions.modules = true; + } + } + + ifArg("hide-modules", function(bool) { + if (bool) { + outputOptions.modules = false; + outputOptions.chunkModules = false; + } + }); + + ifArg("info-verbosity", function(value) { + outputOptions.infoVerbosity = value; + }); + + ifArg("build-delimiter", function(value) { + outputOptions.buildDelimiter = value; + }); + + const webpack = require("webpack"); + + let lastHash = null; + let compiler; + try { + compiler = webpack(options); + } catch (err) { + if (err.name === "WebpackOptionsValidationError") { + if (argv.color) console.error(`\u001b[1m\u001b[31m${err.message}\u001b[39m\u001b[22m`); + else console.error(err.message); + // eslint-disable-next-line no-process-exit + process.exit(1); + } + + throw err; + } + + if (argv.progress) { + const ProgressPlugin = require("webpack").ProgressPlugin; + new ProgressPlugin({ + profile: argv.profile + }).apply(compiler); + } + if (outputOptions.infoVerbosity === "verbose") { + if (argv.w) { + compiler.hooks.watchRun.tap("WebpackInfo", compilation => { + const compilationName = compilation.name ? compilation.name : ""; + console.error("\nCompilation " + compilationName + " starting…\n"); + }); + } else { + compiler.hooks.beforeRun.tap("WebpackInfo", compilation => { + const compilationName = compilation.name ? compilation.name : ""; + console.error("\nCompilation " + compilationName + " starting…\n"); + }); + } + compiler.hooks.done.tap("WebpackInfo", compilation => { + const compilationName = compilation.name ? compilation.name : ""; + console.error("\nCompilation " + compilationName + " finished\n"); + }); + } + + function compilerCallback(err, stats) { + if (!options.watch || err) { + // Do not keep cache anymore + compiler.purgeInputFileSystem(); + } + if (err) { + lastHash = null; + console.error(err.stack || err); + if (err.details) console.error(err.details); + process.exitCode = 1; + return; + } + if (outputOptions.json) { + stdout.write(JSON.stringify(stats.toJson(outputOptions), null, 2) + "\n"); + } else if (stats.hash !== lastHash) { + lastHash = stats.hash; + if (stats.compilation && stats.compilation.errors.length !== 0) { + const errors = stats.compilation.errors; + if (errors[0].name === "EntryModuleNotFoundError") { + console.error("\n\u001b[1m\u001b[31mInsufficient number of arguments or no entry found."); + console.error( + "\u001b[1m\u001b[31mAlternatively, run 'webpack(-cli) --help' for usage info.\u001b[39m\u001b[22m\n" + ); + } + } + const statsString = stats.toString(outputOptions); + const delimiter = outputOptions.buildDelimiter ? `${outputOptions.buildDelimiter}\n` : ""; + if (statsString) stdout.write(`${statsString}\n${delimiter}`); + } + if (!options.watch && stats.hasErrors()) { + process.exitCode = 2; + } + } + if (firstOptions.watch || options.watch) { + const watchOptions = + firstOptions.watchOptions || options.watchOptions || firstOptions.watch || options.watch || {}; + if (watchOptions.stdin) { + process.stdin.on("end", function(_) { + process.exit(); // eslint-disable-line + }); + process.stdin.resume(); + } + compiler.watch(watchOptions, compilerCallback); + if (outputOptions.infoVerbosity !== "none") console.error("\nwebpack is watching the files…\n"); + } else { + compiler.run((err, stats) => { + if (compiler.close) { + compiler.close(err2 => { + compilerCallback(err || err2, stats); + }); + } else { + compilerCallback(err, stats); + } + }); + } + } + processOptions(options); + }); +})(); |