parcel 2.0.0-nightly.99 → 2.1.0

package/lib/cli.js

@@ -1,106 +1,241 @@
 "use strict";
 
-var _core = require("@parcel/core");
+function _core() {
+  const data = require("@parcel/core");
 
-var _packageManager = require("@parcel/package-manager");
+  _core = function () {
+    return data;
+  };
 
-var _fs = require("@parcel/fs");
+  return data;
+}
 
-var _diagnostic = _interopRequireDefault(require("@parcel/diagnostic"));
+function _fs() {
+  const data = require("@parcel/fs");
 
-var _utils = require("@parcel/utils");
+  _fs = function () {
+    return data;
+  };
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+  return data;
+}
+
+function _diagnostic() {
+  const data = _interopRequireDefault(require("@parcel/diagnostic"));
+
+  _diagnostic = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _utils() {
+  const data = require("@parcel/utils");
+
+  _utils = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _events() {
+  const data = require("@parcel/events");
+
+  _events = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _logger() {
+  const data = require("@parcel/logger");
+
+  _logger = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _chalk() {
+  const data = _interopRequireDefault(require("chalk"));
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _commander() {
+  const data = _interopRequireDefault(require("commander"));
+
+  _commander = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function () {
+    return data;
+  };
+
+  return data;
+}
 
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _getPort() {
+  const data = _interopRequireDefault(require("get-port"));
+
+  _getPort = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _package = require("../package.json");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 require('v8-compile-cache');
 
-function logUncaughtError(e) {
-  if (e instanceof _diagnostic.default) {
-    for (let diagnostic of e.diagnostics) {
-      let out = (0, _utils.prettyDiagnostic)(diagnostic);
-      console.error(out.message);
-      console.error(out.codeframe || out.stack);
+const program = new (_commander().default.Command)(); // Exit codes in response to signals are traditionally
+// 128 + signal value
+// https://tldp.org/LDP/abs/html/exitcodes.html
 
-      for (let h of out.hints) {
-        console.error(h);
+const SIGINT_EXIT_CODE = 130;
+
+async function logUncaughtError(e) {
+  if (e instanceof _diagnostic().default) {
+    for (let diagnostic of e.diagnostics) {
+      let {
+        message,
+        codeframe,
+        stack,
+        hints,
+        documentation
+      } = await (0, _utils().prettyDiagnostic)(diagnostic);
+
+      _logger().INTERNAL_ORIGINAL_CONSOLE.error(_chalk().default.red(message));
+
+      if (codeframe || stack) {
+        _logger().INTERNAL_ORIGINAL_CONSOLE.error('');
       }
-    }
-  } else {
-    console.error(e);
-  }
-}
 
-process.on('unhandledRejection', reason => {
-  logUncaughtError(reason);
-  process.exit(1);
-});
+      _logger().INTERNAL_ORIGINAL_CONSOLE.error(codeframe);
 
-const chalk = require('chalk');
+      _logger().INTERNAL_ORIGINAL_CONSOLE.error(stack);
 
-const program = require('commander');
+      if ((stack || codeframe) && hints.length > 0) {
+        _logger().INTERNAL_ORIGINAL_CONSOLE.error('');
+      }
 
-const path = require('path');
+      for (let h of hints) {
+        _logger().INTERNAL_ORIGINAL_CONSOLE.error(_chalk().default.blue(h));
+      }
 
-const getPort = require('get-port');
+      if (documentation) {
+        _logger().INTERNAL_ORIGINAL_CONSOLE.error(_chalk().default.magenta.bold(documentation));
+      }
+    }
+  } else {
+    _logger().INTERNAL_ORIGINAL_CONSOLE.error(e);
+  } // A hack to definitely ensure we logged the uncaught exception
 
-const version = require('../package.json').version; // Capture the NODE_ENV this process was launched with, so that it can be
-// used in Parcel (such as in process.env inlining).
 
+  await new Promise(resolve => setTimeout(resolve, 100));
+}
 
-const initialNodeEnv = process.env.NODE_ENV; // Then, override NODE_ENV to be PARCEL_BUILD_ENV (replaced with `production` in builds)
-// so that dependencies of Parcel like React (which renders the cli through `ink`)
-// run in the appropriate mode.
+const handleUncaughtException = async exception => {
+  try {
+    await logUncaughtError(exception);
+  } catch (err) {
+    console.error(exception);
+    console.error(err);
+  }
 
-process.env.NODE_ENV = "production";
-program.version(version); // --no-cache, --cache-dir, --no-source-maps, --no-autoinstall, --global?, --public-url, --log-level
+  process.exit(1);
+};
+
+process.on('unhandledRejection', handleUncaughtException);
+program.storeOptionsAsProperties();
+program.version(_package.version); // --no-cache, --cache-dir, --no-source-maps, --no-autoinstall, --global?, --public-url, --log-level
 // --no-content-hash, --experimental-scope-hoisting, --detailed-report
 
 const commonOptions = {
   '--no-cache': 'disable the filesystem cache',
+  '--config <path>': 'specify which config to use. can be a path or a package name',
   '--cache-dir <path>': 'set the cache directory. defaults to ".parcel-cache"',
   '--no-source-maps': 'disable sourcemaps',
-  '--no-autoinstall': 'disable autoinstall',
   '--target [name]': ['only build given target(s)', (val, list) => list.concat([val]), []],
-  '--log-level <level>': ['set the log level, either "none", "error", "warn", "info", or "verbose".', /^(none|error|warn|info|verbose)$/],
+  '--log-level <level>': new (_commander().default.Option)('--log-level <level>', 'set the log level').choices(['none', 'error', 'warn', 'info', 'verbose']),
+  '--dist-dir <dir>': 'output directory to write to when unspecified by targets',
+  '--no-autoinstall': 'disable autoinstall',
   '--profile': 'enable build profiling',
-  '-V, --version': 'output the version number'
+  '-V, --version': 'output the version number',
+  '--detailed-report [count]': ['print the asset timings and sizes in the build report', parseOptionInt],
+  '--reporter <name>': ['additional reporters to run', (val, acc) => {
+    acc.push(val);
+    return acc;
+  }, []]
 };
 var hmrOptions = {
   '--no-hmr': 'disable hot module replacement',
+  '-p, --port <port>': ['set the port to serve on. defaults to $PORT or 1234', process.env.PORT],
+  '--host <host>': 'set the host to listen on, defaults to listening on all interfaces',
   '--https': 'serves files over HTTPS',
   '--cert <path>': 'path to certificate to use with HTTPS',
-  '--key <path>': 'path to private key to use with HTTPS'
+  '--key <path>': 'path to private key to use with HTTPS',
+  '--hmr-port <port>': ['hot module replacement port', process.env.HMR_PORT]
 };
 
 function applyOptions(cmd, options) {
   for (let opt in options) {
-    cmd.option(opt, ...(Array.isArray(options[opt]) ? options[opt] : [options[opt]]));
+    const option = options[opt];
+
+    if (option instanceof _commander().default.Option) {
+      cmd.addOption(option);
+    } else {
+      cmd.option(opt, ...(Array.isArray(option) ? option : [option]));
+    }
   }
 }
 
-let serve = program.command('serve [input...]').description('starts a development server').option('-p, --port <port>', 'set the port to serve on. defaults to 1234', parseInt).option('--public-url <url>', 'the path prefix for absolute urls').option('--host <host>', 'set the host to listen on, defaults to listening on all interfaces').option('--open [browser]', 'automatically open in specified browser, defaults to default browser').option('--watch-for-stdin', 'exit when stdin closes').action(run);
+let serve = program.command('serve [input...]').description('starts a development server').option('--public-url <url>', 'the path prefix for absolute urls').option('--open [browser]', 'automatically open in specified browser, defaults to default browser').option('--watch-for-stdin', 'exit when stdin closes').option('--lazy', 'Build async bundles on demand, when requested in the browser').action(runCommand);
 applyOptions(serve, hmrOptions);
 applyOptions(serve, commonOptions);
-let watch = program.command('watch [input...]').description('starts the bundler in watch mode').option('--dist-dir <dir>', 'output directory to write to when unspecified by targets').option('--public-url <url>', 'the path prefix for absolute urls').option('--watch-for-stdin', 'exit when stdin closes').action(run);
+let watch = program.command('watch [input...]').description('starts the bundler in watch mode').option('--public-url <url>', 'the path prefix for absolute urls').option('--no-content-hash', 'disable content hashing').option('--watch-for-stdin', 'exit when stdin closes').action(runCommand);
 applyOptions(watch, hmrOptions);
 applyOptions(watch, commonOptions);
-let build = program.command('build [input...]').description('bundles for production').option('--no-minify', 'disable minification').option('--no-scope-hoist', 'disable scope-hoisting').option('--public-url <url>', 'the path prefix for absolute urls').option('--dist-dir <dir>', 'Output directory to write to when unspecified by targets').action(run);
+let build = program.command('build [input...]').description('bundles for production').option('--no-optimize', 'disable minification').option('--no-scope-hoist', 'disable scope-hoisting').option('--public-url <url>', 'the path prefix for absolute urls').option('--no-content-hash', 'disable content hashing').action(runCommand);
 applyOptions(build, commonOptions);
 program.command('help [command]').description('display help information for a command').action(function (command) {
   let cmd = program.commands.find(c => c.name() === command) || program;
   cmd.help();
 });
 program.on('--help', function () {
-  console.log('');
-  console.log('  Run `' + chalk.bold('parcel help <command>') + '` for more information on specific commands');
-  console.log('');
-}); // Make serve the default command except for --help
+  _logger().INTERNAL_ORIGINAL_CONSOLE.log('');
+
+  _logger().INTERNAL_ORIGINAL_CONSOLE.log('  Run `' + _chalk().default.bold('parcel help <command>') + '` for more information on specific commands');
+
+  _logger().INTERNAL_ORIGINAL_CONSOLE.log('');
+}); // Override to output option description if argument was missing
+
+_commander().default.Command.prototype.optionMissingArgument = function (option) {
+  _logger().INTERNAL_ORIGINAL_CONSOLE.error("error: option `%s' argument missing", option.flags);
+
+  _logger().INTERNAL_ORIGINAL_CONSOLE.log(program.createHelp().optionDescription(option));
+
+  process.exit(1);
+}; // Make serve the default command except for --help
+
 
 var args = process.argv;
 if (args[2] === '--help' || args[2] === '-h') args[2] = 'help';
@@ -111,76 +246,125 @@ if (!args[2] || !program.commands.some(c => c.name() === args[2])) {
 
 program.parse(args);
 
-async function run(entries, command) {
-  entries = entries.map(entry => path.resolve(entry));
+function runCommand(...args) {
+  run(...args).catch(handleUncaughtException);
+}
 
+async function run(entries, _opts, // using pre v7 Commander options as properties
+command) {
   if (entries.length === 0) {
-    console.log('No entries found');
-    return;
+    entries = ['.'];
   }
 
+  entries = entries.map(entry => _path().default.resolve(entry));
+
   let Parcel = require('@parcel/core').default;
 
-  let packageManager = new _packageManager.NodePackageManager(new _fs.NodeFS());
-  let defaultConfig = await packageManager.require('@parcel/config-default', __filename);
-  let parcel = new Parcel(_objectSpread({
+  let fs = new (_fs().NodeFS)();
+  let options = await normalizeOptions(command, fs);
+  let parcel = new Parcel({
     entries,
-    packageManager,
-    defaultConfig: _objectSpread({}, defaultConfig, {
-      filePath: (await packageManager.resolve('@parcel/config-default', __filename)).resolved
+    // $FlowFixMe[extra-arg] - flow doesn't know about the `paths` option (added in Node v8.9.0)
+    defaultConfig: require.resolve('@parcel/config-default', {
+      paths: [fs.cwd(), __dirname]
     }),
-    patchConsole: true
-  }, (await normalizeOptions(command))));
+    shouldPatchConsole: true,
+    ...options
+  });
+  let disposable = new (_events().Disposable)();
+  let unsubscribe;
+  let isExiting;
+
+  async function exit(exitCode = 0) {
+    if (isExiting) {
+      return;
+    }
 
-  if (command.name() === 'watch' || command.name() === 'serve') {
-    let {
+    isExiting = true;
+
+    if (unsubscribe != null) {
+      await unsubscribe();
+    } else if (parcel.isProfiling) {
+      await parcel.stopProfiling();
+    }
+
+    if (process.stdin.isTTY && process.stdin.isRaw) {
+      // $FlowFixMe
+      process.stdin.setRawMode(false);
+    }
+
+    disposable.dispose();
+    process.exit(exitCode);
+  }
+
+  const isWatching = command.name() === 'watch' || command.name() === 'serve';
+
+  if (process.stdin.isTTY) {
+    // $FlowFixMe
+    process.stdin.setRawMode(true);
+
+    require('readline').emitKeypressEvents(process.stdin);
+
+    let stream = process.stdin.on('keypress', async (char, key) => {
+      if (!key.ctrl) {
+        return;
+      }
+
+      switch (key.name) {
+        case 'c':
+          // Detect the ctrl+c key, and gracefully exit after writing the asset graph to the cache.
+          // This is mostly for tools that wrap Parcel as a child process like yarn and npm.
+          //
+          // Setting raw mode prevents SIGINT from being sent in response to ctrl-c:
+          // https://nodejs.org/api/tty.html#tty_readstream_setrawmode_mode
+          //
+          // We don't use the SIGINT event for this because when run inside yarn, the parent
+          // yarn process ends before Parcel and it appears that Parcel has ended while it may still
+          // be cleaning up. Handling events from stdin prevents this impression.
+          // Enqueue a busy message to be shown if Parcel doesn't shut down
+          // within the timeout.
+          setTimeout(() => _logger().INTERNAL_ORIGINAL_CONSOLE.log(_chalk().default.bold.yellowBright('Parcel is shutting down...')), 500); // When watching, a 0 success code is acceptable when Parcel is interrupted with ctrl-c.
+          // When building, fail with a code as if we received a SIGINT.
+
+          await exit(isWatching ? 0 : SIGINT_EXIT_CODE);
+          break;
+
+        case 'e':
+          await (parcel.isProfiling ? parcel.stopProfiling() : parcel.startProfiling());
+          break;
+
+        case 'y':
+          await parcel.takeHeapSnapshot();
+          break;
+      }
+    });
+    disposable.add(() => {
+      stream.destroy();
+    });
+  }
+
+  if (isWatching) {
+    ({
       unsubscribe
     } = await parcel.watch(err => {
       if (err) {
         throw err;
       }
-    });
-    let isExiting;
-
-    const exit = async () => {
-      if (isExiting) {
-        return;
-      }
+    }));
 
-      isExiting = true;
-      await unsubscribe();
-      process.exit();
-    };
+    if (command.open && options.serveOptions) {
+      await (0, _utils().openInBrowser)(`${options.serveOptions.https ? 'https' : 'http'}://${options.serveOptions.host || 'localhost'}:${options.serveOptions.port}`, command.open);
+    }
 
     if (command.watchForStdin) {
       process.stdin.on('end', async () => {
-        console.log('STDIN closed, ending');
+        _logger().INTERNAL_ORIGINAL_CONSOLE.log('STDIN closed, ending');
+
         await exit();
       });
       process.stdin.resume();
-    } // Detect the ctrl+c key, and gracefully exit after writing the asset graph to the cache.
-    // This is mostly for tools that wrap Parcel as a child process like yarn and npm.
-    //
-    // Setting raw mode prevents SIGINT from being sent in response to ctrl-c:
-    // https://nodejs.org/api/tty.html#tty_readstream_setrawmode_mode
-    //
-    // We don't use the SIGINT event for this because when run inside yarn, the parent
-    // yarn process ends before Parcel and it appears that Parcel has ended while it may still
-    // be cleaning up. Handling events from stdin prevents this impression.
-
-
-    if (process.stdin.isTTY) {
-      // $FlowFixMe
-      process.stdin.setRawMode(true);
-
-      require('readline').emitKeypressEvents(process.stdin);
-
-      process.stdin.on('keypress', async (char, key) => {
-        if (key.ctrl && key.name === 'c') {
-          await exit();
-        }
-      });
-    } // In non-tty cases, respond to SIGINT by cleaning up.
+    } // In non-tty cases, respond to SIGINT by cleaning up. Since we're watching,
+    // a 0 success code is acceptable.
 
 
     process.on('SIGINT', exit);
@@ -188,29 +372,56 @@ async function run(entries, command) {
   } else {
     try {
       await parcel.run();
-    } catch (e) {
+    } catch (err) {
       // If an exception is thrown during Parcel.build, it is given to reporters in a
       // buildFailure event, and has been shown to the user.
-      if (!(e instanceof _core.BuildError)) {
-        logUncaughtError(e);
+      if (!(err instanceof _core().BuildError)) {
+        await logUncaughtError(err);
       }
 
-      process.exit(1);
+      await exit(1);
     }
+
+    await exit();
+  }
+}
+
+function parsePort(portValue) {
+  let parsedPort = Number(portValue); // Throw an error if port value is invalid...
+
+  if (!Number.isInteger(parsedPort)) {
+    throw new Error(`Port ${portValue} is not a valid integer.`);
   }
+
+  return parsedPort;
 }
 
-async function normalizeOptions(command) {
-  var _command$sourceMaps, _command$autoinstall;
+function parseOptionInt(value) {
+  const parsedValue = parseInt(value, 10);
+
+  if (isNaN(parsedValue)) {
+    throw new (_commander().default.InvalidOptionArgumentError)('Must be an integer.');
+  }
+
+  return parsedValue;
+}
+
+async function normalizeOptions(command, inputFS) {
+  var _command$autoinstall, _command$sourceMaps;
 
   let nodeEnv;
 
   if (command.name() === 'build') {
-    nodeEnv = initialNodeEnv || 'production';
+    nodeEnv = process.env.NODE_ENV || 'production'; // Autoinstall unless explicitly disabled or we detect a CI environment.
+
+    command.autoinstall = !(command.autoinstall === false || process.env.CI);
   } else {
-    nodeEnv = initialNodeEnv || 'development';
-  }
+    nodeEnv = process.env.NODE_ENV || 'development';
+  } // Set process.env.NODE_ENV to a default if undefined so that it is
+  // available in JS configs and plugins.
 
+
+  process.env.NODE_ENV = nodeEnv;
   let https = !!command.https;
 
   if (command.cert && command.key) {
@@ -220,25 +431,48 @@ async function normalizeOptions(command) {
     };
   }
 
-  let serve = false;
+  let serveOptions = false;
+  let {
+    host
+  } = command; // Ensure port is valid and available
+
+  let port = parsePort(command.port || '1234');
+  let originalPort = port;
+
+  if (command.name() === 'serve' || command.hmr) {
+    try {
+      port = await (0, _getPort().default)({
+        port,
+        host
+      });
+    } catch (err) {
+      throw new (_diagnostic().default)({
+        diagnostic: {
+          message: `Could not get available port: ${err.message}`,
+          origin: 'parcel',
+          stack: err.stack
+        }
+      });
+    }
+
+    if (port !== originalPort) {
+      let errorMessage = `Port "${originalPort}" could not be used`;
+
+      if (command.port != null) {
+        // Throw the error if the user defined a custom port
+        throw new Error(errorMessage);
+      } else {
+        // Parcel logger is not set up at this point, so just use native INTERNAL_ORIGINAL_CONSOLE
+        _logger().INTERNAL_ORIGINAL_CONSOLE.warn(errorMessage);
+      }
+    }
+  }
 
   if (command.name() === 'serve') {
     let {
-      port = 1234,
-      host,
       publicUrl
     } = command;
-    port = await getPort({
-      port,
-      host
-    });
-
-    if (command.port && port !== command.port) {
-      // Parcel logger is not set up at this point, so just use native console.
-      console.warn(chalk.bold.yellowBright(`⚠️  Port ${command.port} could not be used.`));
-    }
-
-    serve = {
+    serveOptions = {
       https,
       port,
       host,
@@ -246,30 +480,54 @@ async function normalizeOptions(command) {
     };
   }
 
-  let hmr = false;
+  let hmrOptions = null;
 
   if (command.name() !== 'build' && command.hmr !== false) {
-    hmr = true;
+    let hmrport = command.hmrPort ? parsePort(command.hmrPort) : port;
+    hmrOptions = {
+      port: hmrport,
+      host
+    };
+  }
+
+  if (command.detailedReport === true) {
+    command.detailedReport = '10';
   }
 
+  let additionalReporters = [{
+    packageName: '@parcel/reporter-cli',
+    resolveFrom: __filename
+  }, ...command.reporter.map(packageName => ({
+    packageName,
+    resolveFrom: _path().default.join(inputFS.cwd(), 'index')
+  }))];
   let mode = command.name() === 'build' ? 'production' : 'development';
   return {
-    disableCache: command.cache === false,
+    shouldDisableCache: command.cache === false,
     cacheDir: command.cacheDir,
+    config: command.config,
     mode,
-    minify: command.minify != null ? command.minify : mode === 'production',
-    sourceMaps: (_command$sourceMaps = command.sourceMaps) !== null && _command$sourceMaps !== void 0 ? _command$sourceMaps : true,
-    scopeHoist: command.scopeHoist,
-    publicUrl: command.publicUrl,
-    distDir: command.distDir,
-    hot: hmr,
-    serve,
+    hmrOptions,
+    shouldContentHash: hmrOptions ? false : command.contentHash,
+    serveOptions,
     targets: command.target.length > 0 ? command.target : null,
-    autoinstall: (_command$autoinstall = command.autoinstall) !== null && _command$autoinstall !== void 0 ? _command$autoinstall : true,
+    shouldAutoInstall: (_command$autoinstall = command.autoinstall) !== null && _command$autoinstall !== void 0 ? _command$autoinstall : true,
     logLevel: command.logLevel,
-    profile: command.profile,
+    shouldProfile: command.profile,
+    shouldBuildLazily: command.lazy,
+    detailedReport: command.detailedReport != null ? {
+      assetsPerBundle: parseInt(command.detailedReport, 10)
+    } : null,
     env: {
       NODE_ENV: nodeEnv
+    },
+    additionalReporters,
+    defaultTargetOptions: {
+      shouldOptimize: command.optimize != null ? command.optimize : mode === 'production',
+      sourceMaps: (_command$sourceMaps = command.sourceMaps) !== null && _command$sourceMaps !== void 0 ? _command$sourceMaps : true,
+      shouldScopeHoist: command.scopeHoist,
+      publicUrl: command.publicUrl,
+      distDir: command.distDir
     }
   };
 }