expeditaea 1.0.0

package/packages/cli/src/options/locking.js

@@ -0,0 +1,7 @@
+export default {
+  lock: {
+    type: 'boolean',
+    default: true,
+    description: 'Do not set a lock on the project when building'
+  }
+}

package/packages/cli/src/options/server.js

@@ -0,0 +1,29 @@
+import consola from 'consola'
+
+export default {
+  port: {
+    alias: 'p',
+    type: 'string',
+    description: 'Port number on which to start the application',
+    prepare (cmd, options, argv) {
+      if (argv.port) {
+        options.server.port = +argv.port
+      }
+    }
+  },
+  hostname: {
+    alias: 'H',
+    type: 'string',
+    description: 'Hostname on which to start the application',
+    prepare (cmd, options, argv) {
+      if (argv.hostname === '') {
+        consola.fatal('Provided hostname argument has no value')
+      }
+    }
+  },
+  'unix-socket': {
+    alias: 'n',
+    type: 'string',
+    description: 'Path to a UNIX socket'
+  }
+}

package/packages/cli/src/run.js

@@ -0,0 +1,56 @@
+import { existsSync } from 'fs'
+import { resolve } from 'path'
+import execa from 'execa'
+import consola from 'consola'
+import { requireModule } from '@nuxt/utils'
+import { name as pkgName } from '../package.json'
+import NuxtCommand from './command'
+import setup from './setup'
+import getCommand from './commands'
+import { isNuxtDir } from './utils/dir'
+
+export default async function run (_argv, hooks = {}) {
+  // Check for not installing both nuxt and nuxt-edge
+  const dupPkg = pkgName === '@nuxt/cli-edge' ? 'cli' : 'cli-edge'
+  const dupPkgJSON = resolve(__dirname, '../..' /* dist/../.. */, dupPkg, 'package.json')
+  if (existsSync(dupPkgJSON) && requireModule(dupPkgJSON).name !== '@nuxt/' + dupPkg) {
+    consola.warn('Both `nuxt` and `nuxt-edge` dependencies are installed! Please choose one and remove the other one from dependencies.')
+  }
+
+  // Read from process.argv
+  const argv = _argv ? Array.from(_argv) : process.argv.slice(2)
+
+  // Check for internal command
+  let cmd = await getCommand(argv[0])
+
+  // Matching `nuxt` or `nuxt [dir]` or `nuxt -*` for `nuxt dev` shortcut
+  if (!cmd && (!argv[0] || argv[0][0] === '-' || isNuxtDir(argv[0]))) {
+    argv.unshift('dev')
+    cmd = await getCommand('dev')
+  }
+
+  // Check for dev
+  const dev = argv[0] === 'dev'
+
+  // Setup env
+  setup({ dev })
+
+  // Try internal command
+  if (cmd) {
+    return NuxtCommand.run(cmd, argv.slice(1), hooks)
+  }
+
+  // Try external command
+  try {
+    await execa(`nuxt-${argv[0]}`, argv.slice(1), {
+      stdout: process.stdout,
+      stderr: process.stderr,
+      stdin: process.stdin
+    })
+  } catch (error) {
+    if (error.exitCode === 2) {
+      throw String(`Command not found: nuxt-${argv[0]}`)
+    }
+    throw String(`Failed to run command \`nuxt-${argv[0]}\`:\n${error}`)
+  }
+}

package/packages/cli/src/setup.js

@@ -0,0 +1,41 @@
+import consola from 'consola'
+import exit from 'exit'
+import { checkDependencies } from './utils/dependencies'
+import { fatalBox } from './utils/formatting'
+
+let _setup = false
+
+export default function setup ({ dev }) {
+  // Apply default NODE_ENV if not provided
+  if (!process.env.NODE_ENV) {
+    process.env.NODE_ENV = dev ? 'development' : 'production'
+  }
+
+  if (_setup) {
+    return
+  }
+  _setup = true
+
+  checkDependencies()
+
+  // Global error handler
+  /* istanbul ignore next */
+  process.on('unhandledRejection', (err) => {
+    consola.error(err)
+  })
+
+  // Exit process on fatal errors
+  /* istanbul ignore next */
+  consola.addReporter({
+    log (logObj) {
+      if (logObj.type === 'fatal') {
+        const errorMessage = String(logObj.args[0])
+        process.stderr.write(fatalBox(errorMessage))
+        exit(1)
+      }
+    }
+  })
+
+  // Wrap all console logs with consola for better DX
+  consola.wrapConsole()
+}

package/packages/cli/src/utils/banner.js

@@ -0,0 +1,60 @@
+import consola from 'consola'
+import env from 'std-env'
+import chalk from 'chalk'
+import { successBox } from './formatting'
+import { getFormattedMemoryUsage } from './memory'
+
+export function showBanner (nuxt, showMemoryUsage = true) {
+  if (env.test) {
+    return
+  }
+
+  if (env.minimalCLI) {
+    for (const listener of nuxt.server.listeners) {
+      consola.info('Listening on: ' + listener.url)
+    }
+    return
+  }
+
+  const titleLines = []
+  const messageLines = []
+
+  // Name and version
+  const { bannerColor, badgeMessages } = nuxt.options.cli
+  titleLines.push(`${chalk[bannerColor].bold('Nuxt')} @ ${nuxt.constructor.version || 'exotic'}\n`)
+
+  const label = name => chalk.bold.cyan(`▸ ${name}:`)
+
+  // Environment
+  const isDev = nuxt.options.dev
+  let _env = isDev ? 'development' : 'production'
+  if (process.env.NODE_ENV !== _env) {
+    _env += ` (${chalk.cyan(process.env.NODE_ENV)})`
+  }
+  titleLines.push(`${label('Environment')} ${_env}`)
+
+  // Rendering
+  const isSSR = nuxt.options.render.ssr
+  const rendering = isSSR ? 'server-side' : 'client-side'
+  titleLines.push(`${label('Rendering')}   ${rendering}`)
+
+  // Target
+  const target = nuxt.options.target || 'server'
+  titleLines.push(`${label('Target')}      ${target}`)
+
+  if (showMemoryUsage) {
+    titleLines.push('\n' + getFormattedMemoryUsage())
+  }
+
+  // Listeners
+  for (const listener of nuxt.server.listeners) {
+    messageLines.push(chalk.bold('Listening: ') + chalk.underline.blue(listener.url))
+  }
+
+  // Add custom badge messages
+  if (badgeMessages.length) {
+    messageLines.push('', ...badgeMessages)
+  }
+
+  process.stdout.write(successBox(messageLines.join('\n'), titleLines.join('\n')))
+}

package/packages/cli/src/utils/config.js

@@ -0,0 +1,34 @@
+import path from 'path'
+import defu from 'defu'
+import { loadNuxtConfig as _loadNuxtConfig, getDefaultNuxtConfig } from '@nuxt/config'
+
+export async function loadNuxtConfig (argv, configContext) {
+  const rootDir = path.resolve(argv._[0] || '.')
+  const configFile = argv['config-file']
+
+  // Load config
+  const options = await _loadNuxtConfig({
+    rootDir,
+    configFile,
+    configContext,
+    envConfig: {
+      dotenv: argv.dotenv === 'false' ? false : argv.dotenv,
+      env: argv.processenv ? process.env : {}
+    }
+  })
+
+  if (argv.spa === true) {
+    options.ssr = false
+  } else if (argv.universal === true) {
+    options.ssr = true
+  }
+
+  // Server options
+  options.server = defu({
+    port: argv.port || null,
+    host: argv.hostname || null,
+    socket: argv['unix-socket'] || null
+  }, options.server || {}, getDefaultNuxtConfig().server)
+
+  return options
+}

package/packages/cli/src/utils/constants.js

@@ -0,0 +1,8 @@
+export const forceExitTimeout = 5
+
+export const startSpaces = 2
+export const optionSpaces = 2
+
+// 80% of terminal column width
+// this is a fn because console width can have changed since startup
+export const maxCharsPerLine = () => (process.stdout.columns || 100) * 80 / 100

package/packages/cli/src/utils/dependencies.js

@@ -0,0 +1,35 @@
+import consola from 'consola'
+import { satisfies } from 'semver'
+import { getPKG } from '@nuxt/utils'
+
+const dependencies = {
+  webpack: '^4.46.0',
+  'css-loader': '>=4.2.0',
+  'sass-loader': '^10.1.1'
+}
+
+const nodeVersion = '>=12.0.0'
+
+function getInstalledVersion (name) {
+  try {
+    return getPKG(name).version
+  } catch { }
+}
+
+export function checkDependencies () {
+  for (const name in dependencies) {
+    const installedVersion = getInstalledVersion(name)
+    if (!installedVersion) {
+      continue // Ignore to avoid false-positive warnings
+    }
+    const expectedRange = dependencies[name]
+    if (!satisfies(installedVersion, expectedRange)) {
+      consola.warn(`${name}@${installedVersion} is installed but ${expectedRange} is expected`)
+    }
+  }
+
+  // Check Node versions
+  if (!satisfies(process.version, nodeVersion)) {
+    consola.warn(`You are using an unsupported version of Node.js (${process.version}). It is recommended to use the latest LTS version (https://nodejs.org/en/about/releases)`)
+  }
+}

package/packages/cli/src/utils/dir.js

@@ -0,0 +1,11 @@
+import fs from 'fs'
+import path from 'path'
+
+export function isNuxtDir (rootDir) {
+  if (fs.existsSync(path.join(rootDir, 'nuxt.config.js')) ||
+    fs.existsSync(path.join(rootDir, 'pages')) ||
+    fs.existsSync(path.join(rootDir, 'nuxt.config.ts'))) {
+    return true
+  }
+  return false
+}

package/packages/cli/src/utils/formatting.js

@@ -0,0 +1,69 @@
+import wrapAnsi from 'wrap-ansi'
+import chalk from 'chalk'
+import boxen from 'boxen'
+import { maxCharsPerLine } from './constants'
+
+export function indent (count, chr = ' ') {
+  return chr.repeat(count)
+}
+
+export function indentLines (string, spaces, firstLineSpaces) {
+  const lines = Array.isArray(string) ? string : string.split('\n')
+  let s = ''
+  if (lines.length) {
+    const i0 = indent(firstLineSpaces === undefined ? spaces : firstLineSpaces)
+    s = i0 + lines.shift()
+  }
+  if (lines.length) {
+    const i = indent(spaces)
+    s += '\n' + lines.map(l => i + l).join('\n')
+  }
+  return s
+}
+
+export function foldLines (string, spaces, firstLineSpaces, charsPerLine = maxCharsPerLine()) {
+  return indentLines(wrapAnsi(string, charsPerLine), spaces, firstLineSpaces)
+}
+
+export function colorize (text) {
+  return text
+    .replace(/\[[^ ]+]/g, m => chalk.grey(m))
+    .replace(/<[^ ]+>/g, m => chalk.green(m))
+    .replace(/ (-[-\w,]+)/g, m => chalk.bold(m))
+    .replace(/`([^`]+)`/g, (_, m) => chalk.bold.cyan(m))
+}
+
+export function box (message, title, options) {
+  return boxen([
+    title || chalk.white('Nuxt Message'),
+    '',
+    chalk.white(foldLines(message, 0, 0, maxCharsPerLine()))
+  ].join('\n'), Object.assign({
+    borderColor: 'white',
+    borderStyle: 'round',
+    padding: 1,
+    margin: 1
+  }, options)) + '\n'
+}
+
+export function successBox (message, title) {
+  return box(message, title || chalk.green('✔ Nuxt Success'), {
+    borderColor: 'green'
+  })
+}
+
+export function warningBox (message, title) {
+  return box(message, title || chalk.yellow('⚠ Nuxt Warning'), {
+    borderColor: 'yellow'
+  })
+}
+
+export function errorBox (message, title) {
+  return box(message, title || chalk.red('✖ Nuxt Error'), {
+    borderColor: 'red'
+  })
+}
+
+export function fatalBox (message, title) {
+  return errorBox(message, title || chalk.red('✖ Nuxt Fatal Error'))
+}

package/packages/cli/src/utils/generate.js

@@ -0,0 +1,185 @@
+import path, { relative } from 'path'
+import upath from 'upath'
+import fs from 'fs-extra'
+import crc32 from 'crc/lib/crc32'
+import consola from 'consola'
+import globby from 'globby'
+import destr from 'destr'
+import { TARGETS } from '@nuxt/utils'
+
+export async function generate (cmd) {
+  const nuxt = await getNuxt({ server: true }, cmd)
+  const generator = await cmd.getGenerator(nuxt)
+
+  await nuxt.server.listen(0)
+  const { errors } = await generator.generate({ build: false })
+  await nuxt.close()
+  if (cmd.argv['fail-on-error'] && errors.length > 0) {
+    throw new Error('Error generating pages, exiting with non-zero code')
+  }
+}
+
+export async function ensureBuild (cmd) {
+  const nuxt = await getNuxt({ _build: true, server: false }, cmd)
+  const { options } = nuxt
+
+  if (options.generate.cache === false || destr(process.env.NUXT_BUILD) || cmd.argv['force-build']) {
+    const builder = await cmd.getBuilder(nuxt)
+    await builder.build()
+    await nuxt.close()
+    return
+  }
+
+  // Default build ignore files
+  const ignore = [
+    options.buildDir,
+    options.dir.static,
+    options.generate.dir,
+    'node_modules',
+    '.**/*',
+    '.*',
+    'README.md'
+  ]
+
+  // Extend ignore
+  const { generate } = options
+  if (typeof generate.cache.ignore === 'function') {
+    generate.cache.ignore = generate.cache.ignore(ignore)
+  } else if (Array.isArray(generate.cache.ignore)) {
+    generate.cache.ignore = generate.cache.ignore.concat(ignore)
+  }
+  await nuxt.callHook('generate:cache:ignore', generate.cache.ignore)
+
+  // Take a snapshot of current project
+  const snapshotOptions = {
+    rootDir: options.rootDir,
+    ignore: generate.cache.ignore.map(upath.normalize),
+    globbyOptions: generate.cache.globbyOptions
+  }
+
+  const currentBuildSnapshot = await snapshot(snapshotOptions)
+
+  // Detect process.env usage in nuxt.config
+  const processEnv = {}
+  if (nuxt.options._nuxtConfigFile) {
+    const configSrc = await fs.readFile(nuxt.options._nuxtConfigFile)
+    const envRegex = /process.env.(\w+)/g
+    let match
+    // eslint-disable-next-line no-cond-assign
+    while (match = envRegex.exec(configSrc)) {
+      processEnv[match[1]] = process.env[match[1]]
+    }
+  }
+
+  // Current build meta
+  const currentBuild = {
+    // @ts-ignore
+    nuxtVersion: nuxt.constructor.version,
+    ssr: nuxt.options.ssr,
+    target: nuxt.options.target,
+    snapshot: currentBuildSnapshot,
+    env: nuxt.options.env,
+    'process.env': processEnv
+  }
+
+  // Check if build can be skipped
+  const nuxtBuildFile = path.resolve(nuxt.options.buildDir, 'build.json')
+  if (fs.existsSync(nuxtBuildFile)) {
+    const previousBuild = destr(fs.readFileSync(nuxtBuildFile, 'utf-8')) || {}
+
+    // Quick diff
+    let needBuild = false
+    for (const field of ['nuxtVersion', 'ssr', 'target', 'env', 'process.env']) {
+      if (JSON.stringify(previousBuild[field]) !== JSON.stringify(currentBuild[field])) {
+        needBuild = true
+        consola.info(`Doing webpack rebuild because ${field} changed`)
+        break
+      }
+    }
+
+    // Full snapshot diff
+    if (!needBuild) {
+      const changed = compareSnapshots(previousBuild.snapshot, currentBuild.snapshot)
+      if (!changed) {
+        consola.success('Skipping webpack build as no changes detected')
+        return
+      } else {
+        consola.info(`Doing webpack rebuild because ${changed} modified`)
+      }
+    }
+  }
+
+  // Webpack build
+  const builder = await cmd.getBuilder(nuxt)
+  await builder.build()
+
+  // Write build.json
+  fs.writeFileSync(nuxtBuildFile, JSON.stringify(currentBuild, null, 2), 'utf-8')
+
+  await nuxt.close()
+}
+
+async function getNuxt (args, cmd) {
+  const config = await cmd.getNuxtConfig({ dev: false, ...args })
+
+  if (config.target === TARGETS.static) {
+    config._export = true
+  } else {
+    config._legacyGenerate = true
+  }
+  config.buildDir = (config.static && config.static.cacheDir) || path.resolve(config.rootDir, 'node_modules/.cache/nuxt')
+  config.build = config.build || {}
+  // https://github.com/nuxt/nuxt.js/issues/7390
+  config.build.parallel = false
+  config.build.transpile = config.build.transpile || []
+  if (!config.static || !config.static.cacheDir) {
+    config.build.transpile.push('.cache/nuxt')
+  }
+
+  const nuxt = await cmd.getNuxt(config)
+
+  return nuxt
+}
+
+export function compareSnapshots (from, to) {
+  const allKeys = Array.from(new Set([
+    ...Object.keys(from).sort(),
+    ...Object.keys(to).sort()
+  ]))
+
+  for (const key of allKeys) {
+    if (JSON.stringify(from[key]) !== JSON.stringify(to[key])) {
+      return key
+    }
+  }
+
+  return false
+}
+
+export async function snapshot ({ globbyOptions, ignore, rootDir }) {
+  const snapshot = {}
+
+  const files = await globby('**/*.*', {
+    ...globbyOptions,
+    ignore,
+    cwd: rootDir,
+    absolute: true
+  })
+
+  await Promise.all(files.map(async (p) => {
+    const key = relative(rootDir, p)
+    try {
+      const fileContent = await fs.readFile(p)
+      snapshot[key] = {
+        checksum: await crc32(fileContent).toString(16)
+      }
+    } catch (e) {
+      // TODO: Check for other errors like permission denied
+      snapshot[key] = {
+        exists: false
+      }
+    }
+  }))
+
+  return snapshot
+}

package/packages/cli/src/utils/index.js

@@ -0,0 +1,64 @@
+import path from 'path'
+import exit from 'exit'
+
+import { lock } from '@nuxt/utils'
+import chalk from 'chalk'
+import env from 'std-env'
+import { warningBox } from './formatting'
+
+export const eventsMapping = {
+  add: { icon: '+', color: 'green', action: 'Created' },
+  change: { icon: env.windows ? '»' : '↻', color: 'blue', action: 'Updated' },
+  unlink: { icon: '-', color: 'red', action: 'Removed' }
+}
+
+export function formatPath (filePath) {
+  if (!filePath) {
+    return
+  }
+  return filePath.replace(process.cwd() + path.sep, '')
+}
+
+/**
+ * Normalize string argument in command
+ *
+ * @export
+ * @param {String} argument
+ * @param {*} defaultValue
+ * @returns formatted argument
+ */
+export function normalizeArg (arg, defaultValue) {
+  switch (arg) {
+    case 'true': arg = true; break
+    case '': arg = true; break
+    case 'false': arg = false; break
+    case undefined: arg = defaultValue; break
+  }
+  return arg
+}
+
+export function forceExit (cmdName, timeout) {
+  if (timeout !== false) {
+    const exitTimeout = setTimeout(() => {
+      const msg = `The command 'nuxt ${cmdName}' finished but did not exit after ${timeout}s
+This is most likely not caused by a bug in Nuxt
+Make sure to cleanup all timers and listeners you or your plugins/modules start.
+Nuxt will now force exit
+
+${chalk.bold('DeprecationWarning: Starting with Nuxt version 3 this will be a fatal error')}`
+
+      // TODO: Change this to a fatal error in v3
+      process.stderr.write(warningBox(msg))
+      exit(0)
+    }, timeout * 1000)
+    exitTimeout.unref()
+  } else {
+    exit(0)
+  }
+}
+
+// An immediate export throws an error when mocking with jest
+// TypeError: Cannot set property createLock of #<Object> which has only a getter
+export function createLock (...args) {
+  return lock(...args)
+}

package/packages/cli/src/utils/memory.js

@@ -0,0 +1,18 @@
+import chalk from 'chalk'
+import consola from 'consola'
+import prettyBytes from 'pretty-bytes'
+
+export function getMemoryUsage () {
+  // https://nodejs.org/api/process.html#process_process_memoryusage
+  const { heapUsed, rss } = process.memoryUsage()
+  return { heap: heapUsed, rss }
+}
+
+export function getFormattedMemoryUsage () {
+  const { heap, rss } = getMemoryUsage()
+  return `Memory usage: ${chalk.bold(prettyBytes(heap))} (RSS: ${prettyBytes(rss)})`
+}
+
+export function showMemoryUsage () {
+  consola.info(getFormattedMemoryUsage())
+}