@atlaspack/cli 2.12.1-dev.3478 → 2.12.1-dev.3520

package/lib/applyOptions.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyOptions = applyOptions;
+function _commander() {
+  const data = _interopRequireDefault(require("commander"));
+  _commander = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function applyOptions(cmd, options) {
+  for (let opt in options) {
+    const option = options[opt];
+    if (option instanceof _commander().default.Option) {
+      cmd.addOption(option);
+    } else if (Array.isArray(option)) {
+      cmd.option(opt, ...option);
+    } else if (typeof option === 'string') {
+      cmd.option(opt, option);
+    }
+  }
+}

package/lib/cli.js

@@ -14,13 +14,6 @@ function _fs() {
   };
   return data;
 }
-function _diagnostic() {
-  const data = _interopRequireDefault(require("@atlaspack/diagnostic"));
-  _diagnostic = function () {
-    return data;
-  };
-  return data;
-}
 function _utils() {
   const data = require("@atlaspack/utils");
   _utils = function () {
@@ -63,21 +56,12 @@ function _path() {
   };
   return data;
 }
-function _getPort() {
-  const data = _interopRequireDefault(require("get-port"));
-  _getPort = function () {
-    return data;
-  };
-  return data;
-}
 var _package = require("../package.json");
-function _featureFlags() {
-  const data = require("@atlaspack/feature-flags");
-  _featureFlags = function () {
-    return data;
-  };
-  return data;
-}
+var _applyOptions = require("./applyOptions");
+var _makeDebugCommand = require("./makeDebugCommand");
+var _normalizeOptions = require("./normalizeOptions");
+var _handleUncaughtException = require("./handleUncaughtException");
+var _options = require("./options");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const program = new (_commander().default.Command)();
 
@@ -85,180 +69,18 @@ const program = new (_commander().default.Command)();
 // 128 + signal value
 // https://tldp.org/LDP/abs/html/exitcodes.html
 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('');
-      }
-      _logger().INTERNAL_ORIGINAL_CONSOLE.error(codeframe);
-      _logger().INTERNAL_ORIGINAL_CONSOLE.error(stack);
-      if ((stack || codeframe) && hints.length > 0) {
-        _logger().INTERNAL_ORIGINAL_CONSOLE.error('');
-      }
-      for (let h of hints) {
-        _logger().INTERNAL_ORIGINAL_CONSOLE.error(_chalk().default.blue(h));
-      }
-      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
-  await new Promise(resolve => setTimeout(resolve, 100));
-}
-const handleUncaughtException = async exception => {
-  try {
-    await logUncaughtError(exception);
-  } catch (err) {
-    console.error(exception);
-    console.error(err);
-  }
-  process.exit(1);
-};
-process.on('unhandledRejection', handleUncaughtException);
+process.on('unhandledRejection', _handleUncaughtException.handleUncaughtException);
 program.storeOptionsAsProperties();
 program.version(_package.version);
-
-// Only display choices available to callers OS
-let watcherBackendChoices = ['brute-force'];
-switch (process.platform) {
-  case 'darwin':
-    {
-      watcherBackendChoices.push('watchman', 'fs-events');
-      break;
-    }
-  case 'linux':
-    {
-      watcherBackendChoices.push('watchman', 'inotify');
-      break;
-    }
-  case 'win32':
-    {
-      watcherBackendChoices.push('watchman', 'windows');
-      break;
-    }
-  case 'freebsd' || 'openbsd':
-    {
-      watcherBackendChoices.push('watchman');
-      break;
-    }
-  default:
-    break;
-}
-
-// --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"',
-  '--watch-dir <path>': 'set the root watch directory. defaults to nearest lockfile or source control dir.',
-  '--watch-ignore [path]': [`list of directories watcher should not be tracking for changes. defaults to ['.git', '.hg']`, dirs => dirs.split(',')],
-  '--watch-backend': new (_commander().default.Option)('--watch-backend <name>', 'set watcher backend').choices(watcherBackendChoices),
-  '--no-source-maps': 'disable sourcemaps',
-  '--target [name]': ['only build given target(s)', (val, list) => list.concat([val]), []],
-  '--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 sampling build profiling',
-  '--trace': 'enable build tracing',
-  '-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;
-  }, []],
-  '--feature-flag <name=value>': ['sets the value of a feature flag', (value, previousValue) => {
-    let [name, val] = value.split('=');
-    if (name in _featureFlags().DEFAULT_FEATURE_FLAGS) {
-      let featureFlagValue;
-      if (typeof _featureFlags().DEFAULT_FEATURE_FLAGS[name] === 'boolean') {
-        if (val !== 'true' && val !== 'false') {
-          throw new Error(`Feature flag ${name} must be set to true or false`);
-        }
-        featureFlagValue = val === 'true';
-      }
-      previousValue[name] = featureFlagValue ?? String(val);
-    } else {
-      _logger().INTERNAL_ORIGINAL_CONSOLE.warn(`Unknown feature flag ${name} specified, it will be ignored`);
-    }
-    return previousValue;
-  }, {}]
-};
-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',
-  '--hmr-port <port>': ['hot module replacement port', process.env.HMR_PORT],
-  '--hmr-host <host>': ['hot module replacement host', process.env.HMR_HOST]
-};
-function applyOptions(cmd, options) {
-  for (let opt in options) {
-    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('--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 [includes]', 'Build async bundles on demand, when requested in the browser. Defaults to all async bundles, unless a comma separated list of source file globs is provided. Only async bundles whose entry points match these globs will be built lazily').option('--lazy-exclude <excludes>', 'Can only be used in combination with --lazy. Comma separated list of source file globs, async bundles whose entry points match these globs will not be built lazily').option('--production', 'Run with production mode defaults').action(runCommand);
-applyOptions(serve, hmrOptions);
-applyOptions(serve, commonOptions);
+(0, _applyOptions.applyOptions)(serve, _options.hmrOptions);
+(0, _applyOptions.applyOptions)(serve, _options.commonOptions);
 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').option('--production', 'Run with production mode defaults').action(runCommand);
-applyOptions(watch, hmrOptions);
-applyOptions(watch, commonOptions);
+(0, _applyOptions.applyOptions)(watch, _options.hmrOptions);
+(0, _applyOptions.applyOptions)(watch, _options.commonOptions);
 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);
-function makeDebugCommand() {
-  const debug = new (_commander().default.Command)('debug').description('Debug commands for atlaspack');
-  const invalidate = debug.command('invalidate [input...]').description('Run cache invalidation, then exit').action(async (entries, opts, command) => {
-    try {
-      if (entries.length === 0) {
-        entries = ['.'];
-      }
-      entries = entries.map(entry => _path().default.resolve(entry));
-      Object.assign(command, opts);
-      const Atlaspack = require('@atlaspack/core').default;
-      const fs = new (_fs().NodeFS)();
-      const options = await normalizeOptions(command, fs);
-      console.log(command.featureFlag);
-      const atlaspack = new Atlaspack({
-        entries,
-        defaultConfig: require.resolve('@atlaspack/config-default', {
-          paths: [fs.cwd(), __dirname]
-        }),
-        shouldPatchConsole: false,
-        ...options,
-        shouldBuildLazily: true,
-        watchBackend: 'watchman'
-      });
-      console.log('Created atlaspack instance');
-      await atlaspack.unstable_invalidate();
-      console.log('Done invalidating cache');
-    } catch (err) {
-      handleUncaughtException(err);
-    }
-  });
-  applyOptions(invalidate, commonOptions);
-  return debug;
-}
-program.addCommand(makeDebugCommand());
+(0, _applyOptions.applyOptions)(build, _options.commonOptions);
+program.addCommand((0, _makeDebugCommand.makeDebugCommand)());
 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();
@@ -285,7 +107,7 @@ if (!args[2] || !program.commands.some(c => c.name() === args[2])) {
 }
 program.parse(args);
 function runCommand(...args) {
-  run(...args).catch(handleUncaughtException);
+  run(...args).catch(_handleUncaughtException.handleUncaughtException);
 }
 async function run(entries, _opts,
 // using pre v7 Commander options as properties
@@ -296,7 +118,7 @@ command) {
   entries = entries.map(entry => _path().default.resolve(entry));
   let Atlaspack = require('@atlaspack/core').default;
   let fs = new (_fs().NodeFS)();
-  let options = await normalizeOptions(command, fs);
+  let options = await (0, _normalizeOptions.normalizeOptions)(command, fs);
   let atlaspack = new Atlaspack({
     entries,
     defaultConfig: require.resolve('@atlaspack/config-default', {
@@ -392,161 +214,10 @@ command) {
       // If an exception is thrown during Atlaspack.build, it is given to reporters in a
       // buildFailure event, and has been shown to the user.
       if (!(err instanceof _core().BuildError)) {
-        await logUncaughtError(err);
+        await (0, _handleUncaughtException.logUncaughtError)(err);
       }
       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;
-}
-function parseOptionInt(value) {
-  const parsedValue = parseInt(value, 10);
-  if (isNaN(parsedValue)) {
-    throw new (_commander().default.InvalidOptionArgumentError)('Must be an integer.');
-  }
-  return parsedValue;
-}
-function shouldUseProductionDefaults(command) {
-  return command.name() === 'build' || command.production === true;
-}
-async function normalizeOptions(command, inputFS) {
-  let nodeEnv;
-  if (shouldUseProductionDefaults(command)) {
-    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 = 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) {
-    https = {
-      cert: command.cert,
-      key: command.key
-    };
-  }
-  let serveOptions = false;
-  let {
-    host
-  } = command;
-
-  // Ensure port is valid and available
-  let port = parsePort(command.port || '1234');
-  let originalPort = port;
-  if (!shouldUseProductionDefaults(command) && (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: 'atlaspack',
-          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 {
-        // Atlaspack 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 {
-      publicUrl
-    } = command;
-    serveOptions = {
-      https,
-      port,
-      host,
-      publicUrl
-    };
-  }
-  let hmrOptions = null;
-  if (!shouldUseProductionDefaults(command) && command.hmr !== false) {
-    let hmrport = command.hmrPort ? parsePort(command.hmrPort) : port;
-    let hmrhost = command.hmrHost ? command.hmrHost : host;
-    hmrOptions = {
-      port: hmrport,
-      host: hmrhost
-    };
-  }
-  if (command.detailedReport === true) {
-    command.detailedReport = '10';
-  }
-  let additionalReporters = [{
-    packageName: '@atlaspack/reporter-cli',
-    resolveFrom: __filename
-  }, ...command.reporter.map(packageName => ({
-    packageName,
-    resolveFrom: _path().default.join(inputFS.cwd(), 'index')
-  }))];
-  if (command.trace) {
-    additionalReporters.unshift({
-      packageName: '@atlaspack/reporter-tracer',
-      resolveFrom: __filename
-    });
-  }
-  let mode = shouldUseProductionDefaults(command) ? 'production' : 'development';
-  const normalizeIncludeExcludeList = input => {
-    if (typeof input !== 'string') return [];
-    return input.split(',').map(value => value.trim());
-  };
-  return {
-    shouldDisableCache: command.cache === false,
-    cacheDir: command.cacheDir,
-    watchDir: command.watchDir,
-    watchBackend: command.watchBackend,
-    watchIgnore: command.watchIgnore,
-    config: command.config,
-    mode,
-    hmrOptions,
-    shouldContentHash: hmrOptions ? false : command.contentHash,
-    serveOptions,
-    targets: command.target.length > 0 ? command.target : null,
-    shouldAutoInstall: command.autoinstall ?? true,
-    logLevel: command.logLevel,
-    shouldProfile: command.profile,
-    shouldTrace: command.trace,
-    shouldBuildLazily: typeof command.lazy !== 'undefined',
-    lazyIncludes: normalizeIncludeExcludeList(command.lazy),
-    lazyExcludes: normalizeIncludeExcludeList(command.lazyExclude),
-    shouldBundleIncrementally: process.env.ATLASPACK_INCREMENTAL_BUNDLING === 'false' ? false : true,
-    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 ?? true,
-      shouldScopeHoist: command.scopeHoist,
-      publicUrl: command.publicUrl,
-      distDir: command.distDir
-    },
-    featureFlags: command.featureFlag
-  };
 }

package/lib/handleUncaughtException.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleUncaughtException = handleUncaughtException;
+exports.logUncaughtError = logUncaughtError;
+function _diagnostic() {
+  const data = _interopRequireDefault(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = require("@atlaspack/logger");
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _chalk() {
+  const data = _interopRequireDefault(require("chalk"));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+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('');
+      }
+      _logger().INTERNAL_ORIGINAL_CONSOLE.error(codeframe);
+      _logger().INTERNAL_ORIGINAL_CONSOLE.error(stack);
+      if ((stack || codeframe) && hints.length > 0) {
+        _logger().INTERNAL_ORIGINAL_CONSOLE.error('');
+      }
+      for (let h of hints) {
+        _logger().INTERNAL_ORIGINAL_CONSOLE.error(_chalk().default.blue(h));
+      }
+      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
+  await new Promise(resolve => setTimeout(resolve, 100));
+}
+async function handleUncaughtException(exception) {
+  try {
+    await logUncaughtError(exception);
+  } catch (err) {
+    console.error(exception);
+    console.error(err);
+  }
+  process.exit(1);
+}

package/lib/makeDebugCommand.js

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeDebugCommand = makeDebugCommand;
+function _fs() {
+  const data = require("@atlaspack/fs");
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+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;
+}
+var _normalizeOptions = require("./normalizeOptions");
+var _applyOptions = require("./applyOptions");
+var _options = require("./options");
+var _handleUncaughtException = require("./handleUncaughtException");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function makeDebugCommand() {
+  const debug = new (_commander().default.Command)('debug').description('Debug commands for atlaspack');
+  const invalidate = debug.command('invalidate [input...]').description('Run cache invalidation, then exit').action(async (args, opts, command) => {
+    try {
+      let entries = args;
+      if (entries.length === 0) {
+        entries = ['.'];
+      }
+      entries = entries.map(entry => _path().default.resolve(entry));
+      Object.assign(command, opts);
+      const fs = new (_fs().NodeFS)();
+      const options = await (0, _normalizeOptions.normalizeOptions)(command, fs);
+      const Atlaspack = require('@atlaspack/core').default;
+      const atlaspack = new Atlaspack({
+        entries,
+        defaultConfig: require.resolve('@atlaspack/config-default', {
+          paths: [fs.cwd(), __dirname]
+        }),
+        shouldPatchConsole: false,
+        ...options,
+        shouldBuildLazily: true,
+        watchBackend: 'watchman'
+      });
+      console.log('Created atlaspack instance');
+      await atlaspack.unstable_invalidate();
+      console.log('Done invalidating cache');
+    } catch (err) {
+      (0, _handleUncaughtException.handleUncaughtException)(err);
+    }
+  });
+  (0, _applyOptions.applyOptions)(invalidate, _options.commonOptions);
+  const buildAssetGraph = debug.command('build-asset-graph [input...]').description('Build the asset graph then exit').action(async (args, opts, command) => {
+    try {
+      let entries = args;
+      if (entries.length === 0) {
+        entries = ['.'];
+      }
+      entries = entries.map(entry => _path().default.resolve(entry));
+      Object.assign(command, opts);
+      const fs = new (_fs().NodeFS)();
+      const options = await (0, _normalizeOptions.normalizeOptions)(command, fs);
+      const Atlaspack = require('@atlaspack/core').default;
+      const atlaspack = new Atlaspack({
+        entries,
+        defaultConfig: require.resolve('@atlaspack/config-default', {
+          paths: [fs.cwd(), __dirname]
+        }),
+        shouldPatchConsole: false,
+        ...options,
+        shouldBuildLazily: true,
+        watchBackend: 'watchman',
+        featureFlags: {
+          ...options.featureFlags,
+          fixQuadraticCacheInvalidation: 'NEW',
+          useLmdbJsLite: true
+        }
+      });
+      console.log('Created atlaspack instance');
+      await atlaspack.unstable_buildAssetGraph();
+      console.log('Done building asset graph');
+      process.exit(0);
+    } catch (err) {
+      (0, _handleUncaughtException.handleUncaughtException)(err);
+    }
+  });
+  (0, _applyOptions.applyOptions)(buildAssetGraph, _options.commonOptions);
+  return debug;
+}