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

package/src/cli.js

@@ -1,18 +1,22 @@
 // @flow
 
-import type {InitialAtlaspackOptions} from '@atlaspack/types';
 import {BuildError} from '@atlaspack/core';
 import {NodeFS} from '@atlaspack/fs';
-import ThrowableDiagnostic from '@atlaspack/diagnostic';
-import {prettyDiagnostic, openInBrowser} from '@atlaspack/utils';
+import {openInBrowser} from '@atlaspack/utils';
 import {Disposable} from '@atlaspack/events';
 import {INTERNAL_ORIGINAL_CONSOLE} from '@atlaspack/logger';
 import chalk from 'chalk';
 import commander from 'commander';
 import path from 'path';
-import getPort from 'get-port';
 import {version} from '../package.json';
-import {DEFAULT_FEATURE_FLAGS} from '@atlaspack/feature-flags';
+import {applyOptions} from './applyOptions';
+import {makeDebugCommand} from './makeDebugCommand';
+import {normalizeOptions} from './normalizeOptions';
+import {
+  handleUncaughtException,
+  logUncaughtError,
+} from './handleUncaughtException';
+import {commonOptions, hmrOptions} from './options';
 
 const program = new commander.Command();
 
@@ -21,171 +25,11 @@ const program = new commander.Command();
 // https://tldp.org/LDP/abs/html/exitcodes.html
 const SIGINT_EXIT_CODE = 130;
 
-async function logUncaughtError(e: mixed) {
-  if (e instanceof ThrowableDiagnostic) {
-    for (let diagnostic of e.diagnostics) {
-      let {message, codeframe, stack, hints, documentation} =
-        await prettyDiagnostic(diagnostic);
-      INTERNAL_ORIGINAL_CONSOLE.error(chalk.red(message));
-      if (codeframe || stack) {
-        INTERNAL_ORIGINAL_CONSOLE.error('');
-      }
-      INTERNAL_ORIGINAL_CONSOLE.error(codeframe);
-      INTERNAL_ORIGINAL_CONSOLE.error(stack);
-      if ((stack || codeframe) && hints.length > 0) {
-        INTERNAL_ORIGINAL_CONSOLE.error('');
-      }
-      for (let h of hints) {
-        INTERNAL_ORIGINAL_CONSOLE.error(chalk.blue(h));
-      }
-      if (documentation) {
-        INTERNAL_ORIGINAL_CONSOLE.error(chalk.magenta.bold(documentation));
-      }
-    }
-  } else {
-    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);
 
 program.storeOptionsAsProperties();
 program.version(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.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.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 DEFAULT_FEATURE_FLAGS) {
-        let featureFlagValue;
-        if (typeof 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 {
-        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.Option) {
-      cmd.addOption(option);
-    } else {
-      cmd.option(opt, ...(Array.isArray(option) ? option : [option]));
-    }
-  }
-}
-
 let serve = program
   .command('serve [input...]')
   .description('starts a development server')
@@ -232,92 +76,6 @@ let build = program
 
 applyOptions(build, commonOptions);
 
-function makeDebugCommand() {
-  const debug = new commander.Command('debug').description(
-    'Debug commands for atlaspack',
-  );
-
-  const invalidate = debug
-    .command('invalidate [input...]')
-    .description('Run cache invalidation, then exit')
-    .action(async (entries, opts, command: any) => {
-      try {
-        if (entries.length === 0) {
-          entries = ['.'];
-        }
-        entries = entries.map((entry) => path.resolve(entry));
-
-        Object.assign(command, opts);
-        const fs = new NodeFS();
-        const options = await 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) {
-        handleUncaughtException(err);
-      }
-    });
-  applyOptions(invalidate, commonOptions);
-
-  const buildAssetGraph = debug
-    .command('build-asset-graph [input...]')
-    .description('Build the asset graph then exit')
-    .action(async (entries, opts, command: any) => {
-      try {
-        if (entries.length === 0) {
-          entries = ['.'];
-        }
-        entries = entries.map((entry) => path.resolve(entry));
-
-        Object.assign(command, opts);
-        const fs = new NodeFS();
-        const options = await 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) {
-        handleUncaughtException(err);
-      }
-    });
-  applyOptions(buildAssetGraph, commonOptions);
-
-  return debug;
-}
-
 program.addCommand(makeDebugCommand());
 
 program
@@ -497,178 +255,3 @@ async function run(
     await exit();
   }
 }
-
-function parsePort(portValue: string): number {
-  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.InvalidOptionArgumentError('Must be an integer.');
-  }
-  return parsedValue;
-}
-
-function shouldUseProductionDefaults(command) {
-  return command.name() === 'build' || command.production === true;
-}
-
-async function normalizeOptions(
-  command,
-  inputFS,
-): Promise<InitialAtlaspackOptions> {
-  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 getPort({port, host});
-    } catch (err) {
-      throw new ThrowableDiagnostic({
-        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
-        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: Array<string>).map((packageName) => ({
-      packageName,
-      resolveFrom: path.join(inputFS.cwd(), 'index'),
-    })),
-  ];
-
-  if (command.trace) {
-    additionalReporters.unshift({
-      packageName: '@atlaspack/reporter-tracer',
-      resolveFrom: __filename,
-    });
-  }
-
-  let mode = shouldUseProductionDefaults(command)
-    ? 'production'
-    : 'development';
-
-  const normalizeIncludeExcludeList = (input?: string): string[] => {
-    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/src/handleUncaughtException.js

@@ -0,0 +1,46 @@
+// @flow strict-local
+
+import ThrowableDiagnostic from '@atlaspack/diagnostic';
+import {prettyDiagnostic} from '@atlaspack/utils';
+import {INTERNAL_ORIGINAL_CONSOLE} from '@atlaspack/logger';
+import chalk from 'chalk';
+
+export async function logUncaughtError(e: mixed) {
+  if (e instanceof ThrowableDiagnostic) {
+    for (let diagnostic of e.diagnostics) {
+      let {message, codeframe, stack, hints, documentation} =
+        await prettyDiagnostic(diagnostic);
+      INTERNAL_ORIGINAL_CONSOLE.error(chalk.red(message));
+      if (codeframe || stack) {
+        INTERNAL_ORIGINAL_CONSOLE.error('');
+      }
+      INTERNAL_ORIGINAL_CONSOLE.error(codeframe);
+      INTERNAL_ORIGINAL_CONSOLE.error(stack);
+      if ((stack || codeframe) && hints.length > 0) {
+        INTERNAL_ORIGINAL_CONSOLE.error('');
+      }
+      for (let h of hints) {
+        INTERNAL_ORIGINAL_CONSOLE.error(chalk.blue(h));
+      }
+      if (documentation) {
+        INTERNAL_ORIGINAL_CONSOLE.error(chalk.magenta.bold(documentation));
+      }
+    }
+  } else {
+    INTERNAL_ORIGINAL_CONSOLE.error(e);
+  }
+
+  // A hack to definitely ensure we logged the uncaught exception
+  await new Promise((resolve) => setTimeout(resolve, 100));
+}
+
+export async function handleUncaughtException(exception: mixed) {
+  try {
+    await logUncaughtError(exception);
+  } catch (err) {
+    console.error(exception);
+    console.error(err);
+  }
+
+  process.exit(1);
+}

package/src/makeDebugCommand.js

@@ -0,0 +1,99 @@
+// @flow strict-local
+
+import {NodeFS} from '@atlaspack/fs';
+import commander, {type commander$Command} from 'commander';
+import path from 'path';
+import {normalizeOptions, type Options} from './normalizeOptions';
+import type {CommandExt} from './normalizeOptions';
+import {applyOptions} from './applyOptions';
+import {commonOptions} from './options';
+import {handleUncaughtException} from './handleUncaughtException';
+
+export function makeDebugCommand(): commander$Command {
+  const debug = new commander.Command('debug').description(
+    'Debug commands for atlaspack',
+  );
+
+  const invalidate = debug
+    .command('invalidate [input...]')
+    .description('Run cache invalidation, then exit')
+    .action(async (args: string[], opts: Options, command: CommandExt) => {
+      try {
+        let entries = args;
+        if (entries.length === 0) {
+          entries = ['.'];
+        }
+        entries = entries.map((entry) => path.resolve(entry));
+        Object.assign(command, opts);
+
+        const fs = new NodeFS();
+        const options = await 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) {
+        handleUncaughtException(err);
+      }
+    });
+  applyOptions(invalidate, commonOptions);
+
+  const buildAssetGraph = debug
+    .command('build-asset-graph [input...]')
+    .description('Build the asset graph then exit')
+    .action(async (args: string[], opts: Options, command: CommandExt) => {
+      try {
+        let entries = args;
+
+        if (entries.length === 0) {
+          entries = ['.'];
+        }
+        entries = entries.map((entry) => path.resolve(entry));
+
+        Object.assign(command, opts);
+        const fs = new NodeFS();
+        const options = await 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) {
+        handleUncaughtException(err);
+      }
+    });
+  applyOptions(buildAssetGraph, commonOptions);
+
+  return debug;
+}