expeditaea 1.0.0

package/packages/builder/test/context/__snapshots__/template.test.js.snap

@@ -0,0 +1,117 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`builder: buildContext should construct context 1`] = `
+TemplateContext {
+  "templateFiles": Array [
+    "template.js",
+  ],
+  "templateVars": Object {
+    "appPath": "./App.js",
+    "buildIndicator": undefined,
+    "components": Object {
+      "ErrorPage": "relativeBuild(test_error_page)",
+    },
+    "css": Array [
+      "test.css",
+    ],
+    "debug": "test_debug",
+    "dir": Array [
+      "test_dir",
+    ],
+    "env": "test_env",
+    "extensions": "test|ext",
+    "features": Object {
+      "store": true,
+    },
+    "fetch": undefined,
+    "globalName": "test_global",
+    "globals": Array [
+      "globals",
+    ],
+    "head": "test_head",
+    "isDev": "test_dev",
+    "isFullStatic": false,
+    "isTest": "test_test",
+    "layoutTransition": Object {
+      "name": "test_layout_trans",
+    },
+    "layouts": Object {
+      "test-layout": "test.template",
+    },
+    "loading": "relativeBuild(test_src_dir, test-loading)",
+    "messages": Object {
+      "test": "test message",
+    },
+    "mode": "test mode",
+    "nuxtOptions": Object {
+      "ErrorPage": "test_error_page",
+      "build": Object {
+        "splitChunks": Object {
+          "testSC": true,
+        },
+      },
+      "css": Array [
+        "test.css",
+      ],
+      "debug": "test_debug",
+      "dev": "test_dev",
+      "dir": Array [
+        "test_dir",
+      ],
+      "env": "test_env",
+      "extensions": Array [
+        "test",
+        "ext",
+      ],
+      "features": Object {
+        "store": true,
+      },
+      "globalName": "test_global",
+      "head": "test_head",
+      "layoutTransition": Object {
+        "name": "test_layout_trans",
+      },
+      "layouts": Object {
+        "test-layout": "test.template",
+      },
+      "loading": "test-loading",
+      "messages": Object {
+        "test": "test message",
+      },
+      "mode": "test mode",
+      "pageTransition": Object {
+        "name": "test_trans",
+      },
+      "rootDir": "test_root_dir",
+      "router": Object {
+        "route": "test",
+      },
+      "srcDir": "test_src_dir",
+      "store": "test_store",
+      "test": "test_test",
+      "vue": Object {
+        "config": "test_config",
+      },
+    },
+    "pageTransition": Object {
+      "name": "test_trans",
+    },
+    "plugins": Array [
+      "plugins",
+    ],
+    "rootDir": "test_root_dir",
+    "router": Object {
+      "route": "test",
+    },
+    "splitChunks": Object {
+      "testSC": true,
+    },
+    "srcDir": "test_src_dir",
+    "store": "test_store",
+    "uniqBy": [Function],
+    "vue": Object {
+      "config": "test_config",
+    },
+  },
+}
+`;

package/packages/builder/test/context/build.test.js

@@ -0,0 +1,38 @@
+import { TARGETS } from '@nuxt/utils'
+import BuildContext from '../../src/context/build'
+
+describe('builder: buildContext', () => {
+  test('should construct context', () => {
+    const builder = {
+      nuxt: {
+        options: {
+          target: TARGETS.server
+        }
+      }
+    }
+    const context = new BuildContext(builder)
+    expect(context._builder).toEqual(builder)
+    expect(context.nuxt).toEqual(builder.nuxt)
+    expect(context.options).toEqual(builder.nuxt.options)
+    expect(context.target).toEqual('server')
+  })
+
+  test('should return builder plugins context', () => {
+    const builder = {
+      plugins: [],
+      nuxt: { options: {} }
+    }
+    const context = new BuildContext(builder)
+    expect(context.plugins).toEqual(builder.plugins)
+  })
+
+  test('should return builder build options', () => {
+    const buildOptions = { id: 'test-build-options' }
+    const builder = {
+      plugins: [],
+      nuxt: { options: { build: buildOptions } }
+    }
+    const context = new BuildContext(builder)
+    expect(context.buildOptions).toEqual(buildOptions)
+  })
+})

package/packages/builder/test/context/template.test.js

@@ -0,0 +1,87 @@
+import hash from 'hash-sum'
+import consola from 'consola'
+import serialize from 'serialize-javascript'
+
+import devalue from '@nuxt/devalue'
+import { r, wp, wChunk, serializeFunction } from '@nuxt/utils'
+import TemplateContext from '../../src/context/template'
+
+jest.mock('lodash', () => ({
+  ...jest.requireActual('lodash'),
+  test: 'test lodash',
+  warn: 'only once'
+}))
+
+describe('builder: buildContext', () => {
+  const builder = {
+    template: { files: ['template.js'] },
+    globals: ['globals'],
+    plugins: ['plugins'],
+    relativeToBuild: jest.fn((...args) => `relativeBuild(${args.join(', ')})`)
+  }
+  const options = {
+    features: { store: true },
+    extensions: ['test', 'ext'],
+    messages: { test: 'test message' },
+    build: {
+      splitChunks: { testSC: true }
+    },
+    dev: 'test_dev',
+    test: 'test_test',
+    debug: 'test_debug',
+    vue: { config: 'test_config' },
+    mode: 'test mode',
+    router: { route: 'test' },
+    env: 'test_env',
+    head: 'test_head',
+    store: 'test_store',
+    globalName: 'test_global',
+    css: ['test.css'],
+    layouts: {
+      'test-layout': 'test.template'
+    },
+    srcDir: 'test_src_dir',
+    rootDir: 'test_root_dir',
+    loading: 'test-loading',
+    pageTransition: { name: 'test_trans' },
+    layoutTransition: { name: 'test_layout_trans' },
+    dir: ['test_dir'],
+    ErrorPage: 'test_error_page'
+  }
+
+  test('should construct context', () => {
+    const context = new TemplateContext(builder, options)
+    expect(context).toMatchSnapshot()
+  })
+
+  test('should return object loading template options', () => {
+    const context = new TemplateContext(builder, {
+      ...options,
+      loading: { name: 'test_loading' }
+    })
+
+    expect(context.templateVars.loading).toEqual({ name: 'test_loading' })
+  })
+
+  test('should return object loading template options', () => {
+    const context = new TemplateContext(builder, options)
+    const templateOptions = context.templateOptions
+    expect(templateOptions).toEqual({
+      imports: {
+        serialize,
+        serializeFunction,
+        devalue,
+        hash,
+        r,
+        wp,
+        wChunk,
+        _: {}
+      },
+      interpolate: /<%=([\s\S]+?)%>/g
+    })
+    expect(templateOptions.imports._.test).toEqual('test lodash')
+    expect(templateOptions.imports._.warn).toEqual('only once')
+    expect(consola.warn).toBeCalledTimes(1)
+    expect(consola.warn).toBeCalledWith('Avoid using _ inside templates')
+  })
+})

package/packages/builder/test/ignore.test.js

@@ -0,0 +1,147 @@
+import path from 'path'
+import fs from 'fs-extra'
+
+import Ignore from '../src/ignore'
+
+jest.mock('path')
+jest.mock('fs-extra')
+jest.mock('ignore', () => () => ({
+  add: jest.fn(),
+  filter: jest.fn(paths => paths)
+}))
+
+describe('builder: Ignore', () => {
+  beforeAll(() => {
+    path.resolve.mockImplementation((...args) => `resolve(${args.join(', ')})`)
+  })
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test('should construct Ignore', () => {
+    jest.spyOn(Ignore.prototype, 'addIgnoresRules').mockImplementation(() => {})
+
+    const ignore = new Ignore({
+      rootDir: '/var/nuxt'
+    })
+
+    expect(Ignore.IGNORE_FILENAME).toEqual('.nuxtignore')
+    expect(ignore.rootDir).toEqual('/var/nuxt')
+    expect(ignore.addIgnoresRules).toBeCalledTimes(1)
+
+    Ignore.prototype.addIgnoresRules.mockRestore()
+  })
+
+  test('should add ignore file', () => {
+    jest.spyOn(Ignore.prototype, 'addIgnoresRules')
+    jest.spyOn(Ignore.prototype, 'readIgnoreFile').mockReturnValue('')
+
+    const ignore = new Ignore({
+      rootDir: '/var/nuxt'
+    })
+
+    expect(Ignore.IGNORE_FILENAME).toEqual('.nuxtignore')
+    expect(ignore.rootDir).toEqual('/var/nuxt')
+    expect(ignore.addIgnoresRules).toBeCalledTimes(1)
+    expect(ignore.readIgnoreFile).toBeCalledTimes(1)
+
+    Ignore.prototype.addIgnoresRules.mockRestore()
+    Ignore.prototype.readIgnoreFile.mockRestore()
+  })
+
+  test('should find ignore file', () => {
+    fs.existsSync.mockReturnValueOnce(true)
+    fs.statSync.mockReturnValueOnce({ isFile: () => true })
+    fs.readFileSync.mockReturnValueOnce('pages/ignore.vue')
+
+    const ignore = new Ignore({
+      rootDir: '/var/nuxt'
+    })
+
+    expect(path.resolve).toBeCalledTimes(1)
+    expect(path.resolve).toBeCalledWith('/var/nuxt', '.nuxtignore')
+    expect(fs.existsSync).toBeCalledTimes(1)
+    expect(fs.existsSync).toBeCalledWith('resolve(/var/nuxt, .nuxtignore)')
+    expect(fs.statSync).toBeCalledTimes(1)
+    expect(fs.statSync).toBeCalledWith('resolve(/var/nuxt, .nuxtignore)')
+    expect(ignore.ignoreFile).toEqual('resolve(/var/nuxt, .nuxtignore)')
+    expect(fs.readFileSync).toBeCalledTimes(1)
+    expect(fs.readFileSync).toBeCalledWith('resolve(/var/nuxt, .nuxtignore)', 'utf8')
+    expect(ignore.ignore.add).toBeCalledTimes(1)
+    expect(ignore.ignore.add).toBeCalledWith('pages/ignore.vue')
+
+    fs.existsSync.mockClear()
+    ignore.findIgnoreFile()
+    expect(fs.existsSync).not.toBeCalled()
+  })
+
+  test('should only find existed ignore file', () => {
+    fs.existsSync.mockReturnValueOnce(false)
+
+    const ignore = new Ignore({
+      rootDir: '/var/nuxt'
+    })
+
+    expect(path.resolve).toBeCalledTimes(1)
+    expect(path.resolve).toBeCalledWith('/var/nuxt', '.nuxtignore')
+    expect(fs.existsSync).toBeCalledTimes(1)
+    expect(fs.existsSync).toBeCalledWith('resolve(/var/nuxt, .nuxtignore)')
+    expect(fs.statSync).not.toBeCalled()
+    expect(ignore.ignoreFile).toBeUndefined()
+    expect(ignore.ignore).toBeUndefined()
+  })
+
+  test('should filter ignore files', () => {
+    fs.existsSync.mockReturnValueOnce(true)
+    fs.statSync.mockReturnValueOnce({ isFile: () => true })
+    fs.readFileSync.mockReturnValueOnce('pages/ignore.vue')
+
+    const ignore = new Ignore({
+      rootDir: '/var/nuxt'
+    })
+
+    ignore.filter()
+    ignore.filter('pages/ignore.vue')
+    const paths = ignore.filter(['pages/ignore.vue', 'layouts/ignore.vue'])
+
+    expect(ignore.ignore.filter).toBeCalledTimes(3)
+    expect(ignore.ignore.filter).nthCalledWith(1, [])
+    expect(ignore.ignore.filter).nthCalledWith(2, ['pages/ignore.vue'])
+    expect(ignore.ignore.filter).nthCalledWith(3, ['pages/ignore.vue', 'layouts/ignore.vue'])
+    expect(paths).toEqual(['pages/ignore.vue', 'layouts/ignore.vue'])
+  })
+
+  test('should return origin paths if there is no ignorefile', () => {
+    fs.existsSync.mockReturnValueOnce(false)
+
+    const ignore = new Ignore({
+      rootDir: '/var/nuxt'
+    })
+
+    const paths = ignore.filter(['pages/ignore.vue', 'layouts/ignore.vue'])
+
+    expect(paths).toEqual(['pages/ignore.vue', 'layouts/ignore.vue'])
+  })
+
+  test('should reload ignore', () => {
+    fs.existsSync.mockReturnValueOnce(true)
+    fs.statSync.mockReturnValueOnce({ isFile: () => true })
+    fs.readFileSync.mockReturnValueOnce('pages/ignore.vue')
+
+    const ignore = new Ignore({
+      rootDir: '/var/nuxt'
+    })
+
+    expect(ignore.ignore).toBeDefined()
+    expect(ignore.ignoreFile).toEqual('resolve(/var/nuxt, .nuxtignore)')
+
+    ignore.addIgnoresRules = jest.fn()
+
+    ignore.reload()
+
+    expect(ignore.ignore).toBeUndefined()
+    expect(ignore.ignoreFile).toBeUndefined()
+    expect(ignore.addIgnoresRules).toBeCalledTimes(1)
+  })
+})

package/packages/builder/test/index.test.js

@@ -0,0 +1,9 @@
+import { Builder } from '../src'
+
+jest.mock('../src/builder', () => jest.fn(() => 'nuxt builder'))
+
+describe('builder: entry', () => {
+  test('should export Builder', () => {
+    expect(Builder()).toEqual('nuxt builder')
+  })
+})

package/packages/cli/bin/nuxt-cli.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+require('../dist/cli.js').run()
+  .catch((error) => {
+    require('consola').fatal(error)
+    require('exit')(2)
+  })

package/packages/cli/package.js

@@ -0,0 +1,5 @@
+export default {
+  build: true,
+  ignoreUnused: ['crc'],
+  externals: ['crc/lib/crc32']
+}

package/packages/cli/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@nuxt/cli",
+  "version": "2.15.6",
+  "repository": "nuxt/nuxt.js",
+  "license": "MIT",
+  "main": "dist/cli.js",
+  "bin": {
+    "nuxt-cli": "bin/nuxt-cli.js"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "dependencies": {
+    "@nuxt/config": "2.15.6",
+    "@nuxt/utils": "2.15.6",
+    "boxen": "^5.0.1",
+    "chalk": "^4.1.1",
+    "compression": "^1.7.4",
+    "connect": "^3.7.0",
+    "consola": "^2.15.3",
+    "crc": "^3.8.0",
+    "defu": "^4.0.1",
+    "destr": "^1.1.0",
+    "execa": "^5.0.0",
+    "exit": "^0.1.2",
+    "fs-extra": "^9.1.0",
+    "globby": "^11.0.3",
+    "hable": "^3.0.0",
+    "lodash": "^4.17.21",
+    "minimist": "^1.2.5",
+    "opener": "1.5.2",
+    "pretty-bytes": "^5.6.0",
+    "semver": "^7.3.5",
+    "serve-static": "^1.14.1",
+    "std-env": "^2.3.0",
+    "upath": "^2.0.1",
+    "wrap-ansi": "^7.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/packages/cli/src/command.js

@@ -0,0 +1,239 @@
+
+import path from 'path'
+import consola from 'consola'
+import minimist from 'minimist'
+import Hookable from 'hable'
+import { name, version } from '../package.json'
+import { forceExit } from './utils'
+import { loadNuxtConfig } from './utils/config'
+import { indent, foldLines, colorize } from './utils/formatting'
+import { startSpaces, optionSpaces, forceExitTimeout } from './utils/constants'
+import * as imports from './imports'
+
+export default class NuxtCommand extends Hookable {
+  constructor (cmd = { name: '', usage: '', description: '' }, argv = process.argv.slice(2), hooks = {}) {
+    super(consola)
+    this.addHooks(hooks)
+
+    if (!cmd.options) {
+      cmd.options = {}
+    }
+    this.cmd = cmd
+
+    this._argv = Array.from(argv)
+    this._parsedArgv = null // Lazy evaluate
+  }
+
+  static run (cmd, argv, hooks) {
+    return NuxtCommand.from(cmd, argv, hooks).run()
+  }
+
+  static from (cmd, argv, hooks) {
+    if (cmd instanceof NuxtCommand) {
+      return cmd
+    }
+    return new NuxtCommand(cmd, argv, hooks)
+  }
+
+  async run () {
+    await this.callHook('run:before', {
+      argv: this._argv,
+      cmd: this.cmd,
+      rootDir: path.resolve(this.argv._[0] || '.')
+    })
+
+    if (this.argv.help) {
+      this.showHelp()
+      return
+    }
+
+    if (this.argv.version) {
+      this.showVersion()
+      return
+    }
+
+    if (typeof this.cmd.run !== 'function') {
+      throw new TypeError('Invalid command! Commands should at least implement run() function.')
+    }
+
+    let cmdError
+
+    try {
+      await this.cmd.run(this)
+    } catch (e) {
+      cmdError = e
+    }
+
+    if (this.argv.lock) {
+      await this.releaseLock()
+    }
+
+    if (this.argv['force-exit']) {
+      const forceExitByUser = this.isUserSuppliedArg('force-exit')
+      if (cmdError) {
+        consola.fatal(cmdError)
+      }
+      forceExit(this.cmd.name, forceExitByUser ? false : forceExitTimeout)
+      if (forceExitByUser) {
+        return
+      }
+    }
+
+    if (cmdError) {
+      throw cmdError
+    }
+  }
+
+  showVersion () {
+    process.stdout.write(`${name} v${version}\n`)
+  }
+
+  showHelp () {
+    process.stdout.write(this._getHelp())
+  }
+
+  get argv () {
+    if (!this._parsedArgv) {
+      const minimistOptions = this._getMinimistOptions()
+      this._parsedArgv = minimist(this._argv, minimistOptions)
+    }
+    return this._parsedArgv
+  }
+
+  async getNuxtConfig (extraOptions = {}) {
+    // Flag to indicate nuxt is running with CLI (not programmatic)
+    extraOptions._cli = true
+
+    const context = {
+      command: this.cmd.name,
+      dev: !!extraOptions.dev
+    }
+
+    const config = await loadNuxtConfig(this.argv, context)
+    const options = Object.assign(config, extraOptions)
+
+    for (const name of Object.keys(this.cmd.options)) {
+      this.cmd.options[name].prepare && this.cmd.options[name].prepare(this, options, this.argv)
+    }
+
+    await this.callHook('config', options)
+
+    return options
+  }
+
+  async getNuxt (options) {
+    const { Nuxt } = await imports.core()
+
+    const nuxt = new Nuxt(options)
+    await nuxt.ready()
+
+    return nuxt
+  }
+
+  async getBuilder (nuxt) {
+    const { Builder } = await imports.builder()
+    const { BundleBuilder } = await imports.webpack()
+    return new Builder(nuxt, BundleBuilder)
+  }
+
+  async getGenerator (nuxt) {
+    const { Generator } = await imports.generator()
+    const builder = await this.getBuilder(nuxt)
+    return new Generator(nuxt, builder)
+  }
+
+  async setLock (lockRelease) {
+    if (lockRelease) {
+      if (this._lockRelease) {
+        consola.warn(`A previous unreleased lock was found, this shouldn't happen and is probably an error in 'nuxt ${this.cmd.name}' command. The lock will be removed but be aware of potential strange results`)
+
+        await this.releaseLock()
+        this._lockRelease = lockRelease
+      } else {
+        this._lockRelease = lockRelease
+      }
+    }
+  }
+
+  async releaseLock () {
+    if (this._lockRelease) {
+      await this._lockRelease()
+      this._lockRelease = undefined
+    }
+  }
+
+  isUserSuppliedArg (option) {
+    return this._argv.includes(`--${option}`) || this._argv.includes(`--no-${option}`)
+  }
+
+  _getDefaultOptionValue (option) {
+    return typeof option.default === 'function' ? option.default(this.cmd) : option.default
+  }
+
+  _getMinimistOptions () {
+    const minimistOptions = {
+      alias: {},
+      boolean: [],
+      string: [],
+      default: {}
+    }
+
+    for (const name of Object.keys(this.cmd.options)) {
+      const option = this.cmd.options[name]
+
+      if (option.alias) {
+        minimistOptions.alias[option.alias] = name
+      }
+      if (option.type) {
+        minimistOptions[option.type].push(option.alias || name)
+      }
+      if (option.default) {
+        minimistOptions.default[option.alias || name] = this._getDefaultOptionValue(option)
+      }
+    }
+
+    return minimistOptions
+  }
+
+  _getHelp () {
+    const options = []
+    let maxOptionLength = 0
+
+    for (const name in this.cmd.options) {
+      const option = this.cmd.options[name]
+
+      let optionHelp = '--'
+      optionHelp += option.type === 'boolean' && this._getDefaultOptionValue(option) ? 'no-' : ''
+      optionHelp += name
+      if (option.alias) {
+        optionHelp += `, -${option.alias}`
+      }
+
+      maxOptionLength = Math.max(maxOptionLength, optionHelp.length)
+      options.push([optionHelp, option.description])
+    }
+
+    const _opts = options.map(([option, description]) => {
+      const i = indent(maxOptionLength + optionSpaces - option.length)
+      return foldLines(
+        option + i + description,
+        startSpaces + maxOptionLength + optionSpaces * 2,
+        startSpaces + optionSpaces
+      )
+    }).join('\n')
+
+    const usage = foldLines(`Usage: nuxt ${this.cmd.usage} [options]`, startSpaces)
+    const description = foldLines(this.cmd.description, startSpaces)
+    const opts = foldLines('Options:', startSpaces) + '\n\n' + _opts
+
+    let helpText = colorize(`${usage}\n\n`)
+    if (this.cmd.description) {
+      helpText += colorize(`${description}\n\n`)
+    }
+    if (options.length) {
+      helpText += colorize(`${opts}\n\n`)
+    }
+
+    return helpText
+  }
+}