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

package/src/normalizeOptions.js

@@ -0,0 +1,220 @@
+// @flow strict-local
+
+import ThrowableDiagnostic from '@atlaspack/diagnostic';
+import commander from 'commander';
+import getPort from 'get-port';
+import type {FileSystem} from '@atlaspack/fs';
+import type {FeatureFlags} from '@atlaspack/feature-flags';
+import type {InitialAtlaspackOptions, LogLevel} from '@atlaspack/types';
+import {INTERNAL_ORIGINAL_CONSOLE} from '@atlaspack/logger';
+import path from 'path';
+
+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;
+}
+
+export interface Options {
+  production?: boolean;
+  autoinstall?: boolean;
+  https?: boolean;
+  cert?: string;
+  key?: string;
+  host: string;
+  port?: string;
+  hmr?: boolean;
+  hmrPort?: string;
+  hmrHost?: string;
+  publicUrl?: string;
+  detailedReport?: boolean | string;
+  reporter: string[];
+  trace?: boolean;
+  cache?: boolean;
+  cacheDir?: string;
+  watchDir?: string;
+  watchBackend?:
+    | 'watchman'
+    | 'fs-events'
+    | 'inotify'
+    | 'brute-force'
+    | 'windows';
+  watchIgnore?: string[];
+  config?: string;
+  logLevel?: LogLevel;
+  profile?: boolean;
+  contentHash?: boolean;
+  featureFlag?: $Partial<FeatureFlags>;
+  optimize?: boolean;
+  sourceMaps?: boolean;
+  scopeHoist?: boolean;
+  distDir?: string;
+  lazy?: string;
+  lazyExclude?: string;
+  target: string[];
+}
+
+// $FlowFixMe
+export interface CommandExt extends commander.Command, Options {}
+
+// $FlowFixMe
+function shouldUseProductionDefaults(command: CommandExt) {
+  return command.name() === 'build' || command.production === true;
+}
+
+export async function normalizeOptions(
+  command: CommandExt,
+  inputFS: FileSystem,
+): 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 != null && command.key != null) {
+    https = {
+      cert: command.cert,
+      key: command.key,
+    };
+  }
+
+  let serveOptions = false;
+  let {host} = command;
+
+  // Ensure port is valid and available
+  let port = parsePort(command.port != null ? String(command.port) : '1234');
+  let originalPort = port;
+  if (
+    !shouldUseProductionDefaults(command) &&
+    (command.name() === 'serve' || Boolean(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 != null ? parsePort(command.hmrPort) : port;
+    let hmrhost = command.hmrHost != null ? String(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/options.js

@@ -0,0 +1,123 @@
+// @flow strict-local
+
+import {INTERNAL_ORIGINAL_CONSOLE} from '@atlaspack/logger';
+import commander from 'commander';
+import {DEFAULT_FEATURE_FLAGS} from '@atlaspack/feature-flags';
+import type {OptionsDefinition} from './applyOptions';
+
+// Only display choices available to callers OS
+export let watcherBackendChoices: string[] = ['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
+export const commonOptions: OptionsDefinition = {
+  '--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: string): string[] => 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;
+    },
+    {},
+  ],
+};
+
+export const hmrOptions: OptionsDefinition = {
+  '--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 parseOptionInt(value: string): number {
+  const parsedValue = parseInt(value, 10);
+  if (isNaN(parsedValue)) {
+    throw new commander.InvalidOptionArgumentError('Must be an integer.');
+  }
+  return parsedValue;
+}