expeditaea 1.0.0

package/packages/config/test/config/_common.test.js

@@ -0,0 +1,14 @@
+import commonConfig from '../../src/config/_common'
+
+describe('config: common', () => {
+  test('should return globals with given globalName', () => {
+    const globalName = 'nuxt_global'
+    const { globals } = commonConfig()
+    expect(globals.id(globalName)).toEqual('__nuxt_global')
+    expect(globals.nuxt(globalName)).toEqual('$nuxt_global')
+    expect(globals.context(globalName)).toEqual('__NUXT_GLOBAL__')
+    expect(globals.pluginPrefix(globalName)).toEqual('nuxt_global')
+    expect(globals.readyCallback(globalName)).toEqual('onNuxt_globalReady')
+    expect(globals.loadedCallback(globalName)).toEqual('_onNuxt_globalLoaded')
+  })
+})

package/packages/config/test/config/build.test.js

@@ -0,0 +1,32 @@
+import buildConfig from '../../src/config/build'
+
+describe('config: build', () => {
+  test('should return dev filenames', () => {
+    const { filenames } = buildConfig()
+    const env = { isDev: true }
+    expect(filenames.app(env)).toEqual('[name].js')
+    expect(filenames.chunk(env)).toEqual('[name].js')
+    expect(filenames.css(env)).toEqual('[name].css')
+    expect(filenames.img(env)).toEqual('[path][name].[ext]')
+    expect(filenames.font(env)).toEqual('[path][name].[ext]')
+    expect(filenames.video(env)).toEqual('[path][name].[ext]')
+  })
+
+  test('should return prod filenames', () => {
+    const { filenames } = buildConfig()
+    const env = { isDev: false }
+    expect(filenames.app(env)).toEqual('[contenthash:7].js')
+    expect(filenames.chunk(env)).toEqual('[contenthash:7].js')
+    expect(filenames.css(env)).toEqual('css/[contenthash:7].css')
+    expect(filenames.img(env)).toEqual('img/[name].[contenthash:7].[ext]')
+    expect(filenames.font(env)).toEqual('fonts/[name].[contenthash:7].[ext]')
+    expect(filenames.video(env)).toEqual('videos/[name].[contenthash:7].[ext]')
+  })
+
+  test('should return modern filenames', () => {
+    const { filenames } = buildConfig()
+    const env = { isDev: true, isModern: true }
+    expect(filenames.app(env)).toEqual('[name].modern.js')
+    expect(filenames.chunk(env)).toEqual('[name].modern.js')
+  })
+})

package/packages/config/test/config/index.test.js

@@ -0,0 +1,28 @@
+import { getDefaultNuxtConfig } from '../../src/config'
+
+jest.mock('std-env', () => ({
+  browser: false,
+  test: 'test',
+  dev: false,
+  production: true,
+  debug: false,
+  ci: true,
+  windows: false,
+  darwin: false,
+  linux: true
+}))
+
+describe('config', () => {
+  test('should return default nuxt configurations', () => {
+    expect(getDefaultNuxtConfig()).toMatchSnapshot()
+  })
+
+  test('should return nuxt configurations with custom env', () => {
+    const env = {
+      NUXT_PORT: '3001',
+      NUXT_HOST: 'localhost',
+      UNIX_SOCKET: '/var/run/nuxt.sock'
+    }
+    expect(getDefaultNuxtConfig({ env })).toMatchSnapshot()
+  })
+})

package/packages/config/test/config/render.test.js

@@ -0,0 +1,19 @@
+import renderConfig from '../../src/config/render'
+
+describe('config: render', () => {
+  test('should return false in default shouldPrefetch', () => {
+    const { bundleRenderer: { shouldPrefetch } } = renderConfig()
+    expect(shouldPrefetch()).toEqual(false)
+  })
+
+  test('should return true in script/style shouldPreload', () => {
+    const { bundleRenderer: { shouldPreload } } = renderConfig()
+    expect(shouldPreload(undefined, 'script')).toEqual(true)
+    expect(shouldPreload(undefined, 'style')).toEqual(true)
+  })
+
+  test('should return false in other shouldPreload', () => {
+    const { bundleRenderer: { shouldPreload } } = renderConfig()
+    expect(shouldPreload(undefined, 'font')).toEqual(false)
+  })
+})

package/packages/config/test/config/server.test.js

@@ -0,0 +1,45 @@
+import serverConfig from '../../src/config/server'
+
+const serverDefaults = serverConfig()
+
+describe('config: server', () => {
+  test('should return server configurations with NUXT_* env', () => {
+    const env = {
+      NUXT_PORT: 3001,
+      NUXT_HOST: '127.0.0.1'
+    }
+    expect(serverConfig({ env })).toEqual({
+      ...serverDefaults,
+      port: env.NUXT_PORT,
+      host: env.NUXT_HOST
+    })
+  })
+
+  test('should return server configurations with env', () => {
+    const env = {
+      PORT: 3002,
+      HOST: 'local.env',
+      UNIX_SOCKET: '/var/run/env.sock'
+    }
+    expect(serverConfig({ env })).toEqual({
+      ...serverDefaults,
+      port: env.PORT,
+      host: env.HOST,
+      socket: env.UNIX_SOCKET
+    })
+  })
+
+  test('should return server configurations with npm_* env', () => {
+    const env = {
+      npm_package_config_nuxt_port: 3003,
+      npm_package_config_nuxt_host: 'local.npm',
+      npm_package_config_unix_socket: '/var/run/env.npm.sock'
+    }
+    expect(serverConfig({ env })).toEqual({
+      ...serverDefaults,
+      port: env.npm_package_config_nuxt_port,
+      host: env.npm_package_config_nuxt_host,
+      socket: env.npm_package_config_unix_socket
+    })
+  })
+})

package/packages/config/test/fixtures/nuxtrc/.nuxtrc

@@ -0,0 +1 @@
+rc.works=true

package/packages/config/test/index.test.js

@@ -0,0 +1,16 @@
+import { getDefaultNuxtConfig, getNuxtConfig } from '../src'
+
+jest.mock('../src/options', () => ({
+  getNuxtConfig: jest.fn(() => 'nuxt config')
+}))
+
+jest.mock('../src/config', () => ({
+  getDefaultNuxtConfig: jest.fn(() => 'default nuxt config')
+}))
+
+describe('config: entry', () => {
+  test('should export getDefaultNuxtConfig and getNuxtConfig', () => {
+    expect(getNuxtConfig()).toEqual('nuxt config')
+    expect(getDefaultNuxtConfig()).toEqual('default nuxt config')
+  })
+})

package/packages/config/test/load.test.js

@@ -0,0 +1,10 @@
+
+import { resolve } from 'path'
+import { loadNuxtConfig } from '../src/load'
+
+describe('config: load', () => {
+  test('load local nuxtrc', async () => {
+    const config = await loadNuxtConfig({ rootDir: resolve(__dirname, 'fixtures/nuxtrc') })
+    expect(config.rc.works).toBe(true)
+  })
+})

package/packages/config/test/options.test.js

@@ -0,0 +1,329 @@
+import path from 'path'
+import consola from 'consola'
+import { getNuxtConfig } from '../src/options'
+
+jest.mock('std-env', () => ({
+  browser: false,
+  test: 'test',
+  dev: false,
+  production: true,
+  debug: false,
+  ci: true,
+  windows: false,
+  darwin: false,
+  linux: true
+}))
+
+jest.mock('@nuxt/utils', () => ({
+  ...jest.requireActual('@nuxt/utils'),
+  getMainModule: () => ({ paths: ['/var/nuxt/node_modules'] }),
+  getPKG: () => ({ name: 'fake' })
+}))
+
+describe('config: options', () => {
+  test('should return default nuxt config', () => {
+    jest.spyOn(process, 'cwd').mockReturnValue('/var/nuxt/test')
+    jest.spyOn(path, 'resolve').mockImplementation((...args) => args.join('/').replace(/\\+/, '/'))
+    jest.spyOn(path, 'join').mockImplementation((...args) => args.join('/').replace(/\\+/, '/'))
+
+    expect(getNuxtConfig({
+      createRequire: jest.fn(),
+      generate: {
+        staticAssets: {
+          version: 'x'
+        }
+      }
+    })).toMatchSnapshot()
+
+    process.cwd.mockRestore()
+    path.resolve.mockRestore()
+    path.join.mockRestore()
+  })
+
+  test('should prevent duplicate calls with same options', () => {
+    const options = {}
+    const firstConfig = getNuxtConfig(options)
+    const secondConfig = getNuxtConfig(firstConfig)
+
+    expect(firstConfig).toBe(secondConfig)
+    expect(firstConfig.__normalized__).toBe(true)
+  })
+
+  test('should return default loading when loading is true', () => {
+    const { loading } = getNuxtConfig({ loading: true })
+    expect(loading).toEqual({
+      color: 'black',
+      failedColor: 'red',
+      height: '2px',
+      throttle: 200,
+      duration: 5000,
+      continuous: false,
+      rtl: false,
+      css: true
+    })
+  })
+
+  test('[Compatibility] should transform transition to pageTransition', () => {
+    const { pageTransition, transition } = getNuxtConfig({
+      transition: 'test-tran'
+    })
+    expect(pageTransition).toMatchObject({ name: 'test-tran' })
+    expect(transition).toBeUndefined()
+  })
+
+  test('should transform pageTransition/layoutTransition to name', () => {
+    const { pageTransition, layoutTransition } = getNuxtConfig({
+      pageTransition: 'test-tran',
+      layoutTransition: 'test-layout-tran'
+    })
+    expect(pageTransition).toMatchObject({ name: 'test-tran' })
+    expect(layoutTransition).toMatchObject({ name: 'test-layout-tran' })
+  })
+
+  test('should transform extensions to array', () => {
+    const { extensions } = getNuxtConfig({ extensions: 'ext' })
+    expect(extensions).toEqual(['js', 'mjs', 'ext'])
+  })
+
+  test('should support custom global name', () => {
+    const { globalName } = getNuxtConfig({ globalName: 'globalNuxt' })
+    expect(globalName).toEqual('globalnuxt')
+  })
+
+  test('should detect store dir', () => {
+    const { store } = getNuxtConfig({ rootDir: path.resolve(__dirname, 'fixtures') })
+    expect(store).toEqual(true)
+  })
+
+  test('should unset and warn when etag.hash not a function', () => {
+    const { render: { etag } } = getNuxtConfig({ render: { etag: { hash: true } } })
+    expect(etag).toMatchObject({ hash: undefined })
+    expect(consola.warn).not.toHaveBeenCalledWith('render.etag.hash should be a function, received boolean instead')
+
+    const { render: { etag: etagDev } } = getNuxtConfig({ dev: true, render: { etag: { hash: true } } })
+    expect(etagDev).toMatchObject({ hash: undefined })
+    expect(consola.warn).toHaveBeenCalledWith('render.etag.hash should be a function, received boolean instead')
+  })
+
+  test('should enable csp', () => {
+    const { render: { csp } } = getNuxtConfig({ render: { csp: { allowedSources: ['/nuxt/*'], test: true } } })
+    expect(csp).toEqual({
+      hashAlgorithm: 'sha256',
+      addMeta: false,
+      unsafeInlineCompatibility: false,
+      allowedSources: ['/nuxt/*'],
+      policies: undefined,
+      reportOnly: false,
+      test: true
+    })
+  })
+
+  // TODO: Remove this test in Nuxt 3, we will stop supporting this typo (more on: https://github.com/nuxt/nuxt.js/pull/6583)
+  test('should enable csp with old typo property name, avoiding breaking changes', () => {
+    const { render: { csp } } = getNuxtConfig({ render: { csp: { allowedSources: ['/nuxt/*'], test: true, unsafeInlineCompatiblity: true } } })
+    expect(csp).toEqual({
+      hashAlgorithm: 'sha256',
+      addMeta: false,
+      unsafeInlineCompatibility: true,
+      allowedSources: ['/nuxt/*'],
+      policies: undefined,
+      reportOnly: false,
+      test: true
+    })
+  })
+
+  test('should fallback to server target', () => {
+    const { target } = getNuxtConfig({ target: 0 })
+    expect(target).toEqual('server')
+  })
+
+  test('should check unknown target', () => {
+    const { target } = getNuxtConfig({ target: 'test' })
+    expect(consola.warn).toHaveBeenCalledWith('Unknown target: test. Falling back to server')
+    expect(target).toEqual('server')
+  })
+
+  test('should check unknown mode', () => {
+    const { build, render } = getNuxtConfig({ mode: 'test' })
+    expect(consola.warn).toHaveBeenCalledWith('Unknown mode: test. Falling back to universal')
+    expect(build.ssr).toEqual(true)
+    expect(render.ssr).toEqual(true)
+  })
+
+  test('should add appear true in pageTransition when no ssr', () => {
+    const { pageTransition } = getNuxtConfig({ render: { ssr: false } })
+    expect(pageTransition.appear).toEqual(true)
+  })
+
+  test('should return 200.html as default generate.fallback', () => {
+    const { generate: { fallback } } = getNuxtConfig({})
+    expect(fallback).toEqual('200.html')
+  })
+
+  test('should return 404.html when generate.fallback is true', () => {
+    const { generate: { fallback } } = getNuxtConfig({ generate: { fallback: true } })
+    expect(fallback).toEqual('404.html')
+  })
+
+  test('should return fallback html when generate.fallback is string', () => {
+    const { generate: { fallback } } = getNuxtConfig({ generate: { fallback: 'fallback.html' } })
+    expect(fallback).toEqual('fallback.html')
+  })
+
+  test('export should alias to generate', () => {
+    const { generate: { fallback } } = getNuxtConfig({ export: { fallback: 'fallback.html' } })
+    expect(fallback).toEqual('fallback.html')
+  })
+
+  test('should disable parallel if extractCSS is enabled', () => {
+    const { build: { parallel } } = getNuxtConfig({ build: { extractCSS: true, parallel: true } })
+    expect(parallel).toEqual(false)
+    expect(consola.warn).toHaveBeenCalledWith('extractCSS cannot work with parallel build due to limited work pool in thread-loader')
+  })
+
+  describe('config: router dir', () => {
+    test('should transform middleware to array', () => {
+      const { router: { middleware } } = getNuxtConfig({ router: { middleware: 'midd' } })
+      expect(middleware).toEqual(['midd'])
+    })
+
+    test('should set _routerBaseSpecified when base is specified', () => {
+      const { _routerBaseSpecified } = getNuxtConfig({ router: { base: '/test' } })
+      expect(_routerBaseSpecified).toEqual(true)
+    })
+  })
+
+  describe('config: options dir', () => {
+    test('should support custom root dir', () => {
+      const { rootDir } = getNuxtConfig({
+        rootDir: 'root'
+      })
+      expect(rootDir).toEqual(path.resolve('root'))
+    })
+
+    test('should support custom src dir', () => {
+      const { srcDir } = getNuxtConfig({
+        rootDir: 'root',
+        srcDir: 'src'
+      })
+      expect(srcDir).toEqual(path.resolve('root', 'src'))
+    })
+
+    test('should support custom generate dir', () => {
+      const { generate: { dir } } = getNuxtConfig({
+        rootDir: 'root',
+        generate: { dir: 'generate' }
+      })
+      expect(dir).toEqual(path.resolve('root', 'generate'))
+    })
+  })
+
+  describe('config: options template', () => {
+    test('should use default appTemplatePath', () => {
+      const { appTemplatePath } = getNuxtConfig({})
+      expect(appTemplatePath).toEqual(path.resolve('.nuxt', 'views', 'app.template.html'))
+    })
+
+    test('should use custom appTemplatePath', () => {
+      const { appTemplatePath } = getNuxtConfig({ appTemplatePath: 'templates' })
+      expect(appTemplatePath).toEqual(path.resolve('templates'))
+    })
+
+    test('should use custom app.html', () => {
+      const { appTemplatePath } = getNuxtConfig({ rootDir: path.resolve(__dirname, 'fixtures') })
+      expect(appTemplatePath).toEqual(path.resolve(__dirname, 'fixtures', 'app.html'))
+    })
+  })
+
+  describe('config: options publicPath', () => {
+    test('should fallback to default when publicPath is falsy', () => {
+      const { build: { publicPath } } = getNuxtConfig({ build: { publicPath: false } })
+      expect(publicPath).toEqual('/_nuxt/')
+    })
+
+    test('should append slash in publicPath', () => {
+      const { build: { publicPath } } = getNuxtConfig({ build: { publicPath: '/nuxt_public' } })
+      expect(publicPath).toEqual('/nuxt_public/')
+    })
+
+    test('should ignore url publicPath in dev', () => {
+      const { build: { publicPath } } = getNuxtConfig({ dev: true, build: { publicPath: 'http://nuxt_public' } })
+      expect(publicPath).toEqual('/_nuxt/')
+    })
+  })
+
+  describe('config: options babel', () => {
+    test('should replace and deprecate @nuxtjs/babel-preset-app', () => {
+      const { build: { babel } } = getNuxtConfig({
+        build: { babel: { presets: ['@nuxtjs/babel-preset-app'] } }
+      })
+      expect(consola.warn).toHaveBeenCalledWith('@nuxtjs/babel-preset-app has been deprecated, please use @nuxt/babel-preset-app.')
+      expect(babel).toEqual({
+        configFile: false,
+        babelrc: false,
+        cacheDirectory: false,
+        presets: ['@nuxt/babel-preset-app']
+      })
+    })
+
+    test('should support options in babel presets', () => {
+      const { build: { babel } } = getNuxtConfig({
+        build: { babel: { presets: [['@nuxt/babel-preset-app', { test: true }]] } }
+      })
+      expect(babel).toEqual({
+        configFile: false,
+        babelrc: false,
+        cacheDirectory: false,
+        presets: [['@nuxt/babel-preset-app', { test: true }]]
+      })
+    })
+  })
+
+  describe('config: options deprecated', () => {
+    test('should deprecate render.gzip', () => {
+      getNuxtConfig({ render: { gzip: true } })
+      expect(consola.warn).toHaveBeenCalledWith('render.gzip is deprecated and will be removed in a future version! Please switch to render.compressor')
+    })
+
+    test('should deprecate build.vendor', () => {
+      getNuxtConfig({ build: { vendor: ['lodash'] } })
+      expect(consola.warn).toHaveBeenCalledWith('vendor has been deprecated due to webpack4 optimization')
+    })
+
+    test('should deprecate devModules', () => {
+      const config = getNuxtConfig({ devModules: ['foo'], buildModules: ['bar'] })
+      expect(consola.warn).toHaveBeenCalledWith('`devModules` has been renamed to `buildModules` and will be removed in Nuxt 3.')
+      expect(config.devModules).toBe(undefined)
+      expect(config.buildModules).toEqual(['bar', 'foo'])
+    })
+
+    test('should deprecate build.extractCSS.allChunks', () => {
+      getNuxtConfig({ build: { extractCSS: { allChunks: true } } })
+      expect(consola.warn).toHaveBeenCalledWith('build.extractCSS.allChunks has no effect from v2.0.0. Please use build.optimization.splitChunks settings instead.')
+    })
+
+    test('should deprecate build.crossorigin', () => {
+      getNuxtConfig({ build: { crossorigin: 'use-credentials' } })
+      expect(consola.warn).toHaveBeenCalledWith('Using `build.crossorigin` is deprecated and will be removed in Nuxt 3. Please use `render.crossorigin` instead.')
+    })
+  })
+})
+
+describe('config: serverMiddleware', () => {
+  test('should transform serverMiddleware hash', () => {
+    const serverMiddleware = {
+      '/resource': (req, res, next) => {
+      }
+    }
+    const config = getNuxtConfig({ serverMiddleware })
+    expect(config.serverMiddleware[0].path).toBe('/resource')
+    expect(config.serverMiddleware[0].handler).toBe(serverMiddleware['/resource'])
+  })
+})
+
+describe('config: router', () => {
+  test('should sanitize router.base', () => {
+    const config = getNuxtConfig({ router: { base: '/foo' } })
+    expect(config.router.base).toBe('/foo/')
+  })
+})

package/packages/core/package.js

@@ -0,0 +1,3 @@
+export default {
+  build: true
+}

package/packages/core/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@nuxt/core",
+  "version": "2.15.6",
+  "repository": "nuxt/nuxt.js",
+  "license": "MIT",
+  "main": "dist/core.js",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@nuxt/config": "2.15.6",
+    "@nuxt/server": "2.15.6",
+    "@nuxt/utils": "2.15.6",
+    "consola": "^2.15.3",
+    "fs-extra": "^9.1.0",
+    "hable": "^3.0.0",
+    "hash-sum": "^2.0.0",
+    "lodash": "^4.17.21"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/packages/core/src/index.js

@@ -0,0 +1,5 @@
+export { default as Module } from './module'
+export { default as Nuxt } from './nuxt'
+export { default as Resolver } from './resolver'
+export { loadNuxtConfig } from '@nuxt/config'
+export { loadNuxt } from './load'

package/packages/core/src/load.js

@@ -0,0 +1,40 @@
+import { loadNuxtConfig } from '@nuxt/config'
+import Nuxt from './nuxt'
+
+const OVERRIDES = {
+  dry: { dev: false, server: false },
+  dev: { dev: true, _build: true },
+  build: { dev: false, server: false, _build: true },
+  start: { dev: false, _start: true }
+}
+
+export async function loadNuxt (loadOptions) {
+  // Normalize loadOptions
+  if (typeof loadOptions === 'string') {
+    loadOptions = { for: loadOptions }
+  }
+  const { ready = true } = loadOptions
+  const _for = loadOptions.for || 'dry'
+
+  // Get overrides
+  const override = OVERRIDES[_for]
+
+  // Unsupported purpose
+  if (!override) {
+    throw new Error('Unsupported for: ' + _for)
+  }
+
+  // Load Config
+  const config = await loadNuxtConfig(loadOptions)
+
+  // Apply config overrides
+  Object.assign(config, override)
+
+  // Initiate Nuxt
+  const nuxt = new Nuxt(config)
+  if (ready) {
+    await nuxt.ready()
+  }
+
+  return nuxt
+}