expeditaea 1.0.0

package/scripts/package.js

@@ -0,0 +1,382 @@
+import { resolve } from 'path'
+import consola from 'consola'
+import spawn from 'cross-spawn'
+import { existsSync, readJSONSync, writeFile, copy, remove } from 'fs-extra'
+import _ from 'lodash'
+import { rollup, watch } from 'rollup'
+import _glob from 'glob'
+import pify from 'pify'
+import sortPackageJson from 'sort-package-json'
+
+import rollupConfig from './rollup.config'
+import { builtins } from './builtins'
+
+const DEFAULTS = {
+  rootDir: process.cwd(),
+  pkgPath: 'package.json',
+  configPath: 'package.js',
+  distDir: 'dist',
+  build: false,
+  suffix: process.env.PACKAGE_SUFFIX ? `-${process.env.PACKAGE_SUFFIX}` : '',
+  hooks: {}
+}
+
+const glob = pify(_glob)
+
+const sortObjectKeys = obj => _(obj).toPairs().sortBy(0).fromPairs().value()
+
+export default class Package {
+  constructor (options) {
+    // Assign options
+    this.options = Object.assign({}, DEFAULTS, options)
+
+    // Basic logger
+    this.logger = consola
+
+    // Init (sync)
+    this._init()
+  }
+
+  _init () {
+    // Try to read package.json
+    this.readPkg()
+
+    // Use tagged logger
+    this.logger = consola.withTag(this.pkg.name)
+
+    // Try to load config
+    this.loadConfig()
+  }
+
+  resolvePath (...args) {
+    return resolve(this.options.rootDir, ...args)
+  }
+
+  readPkg () {
+    this.pkg = readJSONSync(this.resolvePath(this.options.pkgPath))
+  }
+
+  loadConfig () {
+    const configPath = this.resolvePath(this.options.configPath)
+
+    if (existsSync(configPath)) {
+      let config = require(configPath)
+      config = config.default || config
+
+      Object.assign(this.options, config)
+    }
+  }
+
+  async callHook (name, ...args) {
+    let fns = this.options.hooks[name]
+
+    if (!fns) {
+      return
+    }
+
+    if (!Array.isArray(fns)) {
+      fns = [fns]
+    }
+
+    for (const fn of fns) {
+      await fn(this, ...args)
+    }
+  }
+
+  load (relativePath, opts) {
+    return new Package(Object.assign({
+      rootDir: this.resolvePath(relativePath)
+    }, opts))
+  }
+
+  async writePackage () {
+    if (this.options.sortDependencies) {
+      this.sortDependencies()
+    }
+    const pkgPath = this.resolvePath(this.options.pkgPath)
+    this.logger.debug('Writing', pkgPath)
+    await writeFile(pkgPath, JSON.stringify(this.pkg, null, 2) + '\n')
+  }
+
+  generateVersion () {
+    const date = Math.round(Date.now() / (1000 * 60))
+    const gitCommit = this.gitShortCommit()
+    const baseVersion = this.pkg.version.split('-')[0]
+    this.pkg.version = `${baseVersion}-${date}.${gitCommit}`
+  }
+
+  tryRequire (id) {
+    try {
+      return require(id)
+    } catch (e) {
+    }
+  }
+
+  suffixAndVersion () {
+    this.logger.info(`Adding suffix ${this.options.suffix}`)
+
+    const oldPkgName = this.pkg.name
+
+    // Add suffix to the package name
+    if (!oldPkgName.includes(this.options.suffix)) {
+      this.pkg.name += this.options.suffix
+    }
+
+    // Apply suffix to all linkedDependencies
+    if (this.pkg.dependencies) {
+      for (const oldName of (this.options.linkedDependencies || [])) {
+        if (!this.pkg.dependencies[oldName]) {
+          continue
+        }
+
+        const name = oldName + this.options.suffix
+        const version = this.pkg.dependencies[oldName] || this.pkg.dependencies[name]
+
+        delete this.pkg.dependencies[oldName]
+        this.pkg.dependencies[name] = version
+      }
+    }
+
+    if (typeof this.pkg.bin === 'string') {
+      const { bin } = this.pkg
+      this.pkg.bin = {
+        [oldPkgName]: bin,
+        [this.pkg.name]: bin
+      }
+    }
+
+    this.generateVersion()
+  }
+
+  syncLinkedDependencies () {
+    // Apply suffix to all linkedDependencies
+    for (const _name of (this.options.linkedDependencies || [])) {
+      const name = _name + (this.options.suffix || '')
+
+      // Try to read pkg
+      const pkg = this.tryRequire(`${name}/package.json`) ||
+        this.tryRequire(`${_name}/package.json`)
+
+      // Skip if pkg or dependency not found
+      if (!pkg || !this.pkg.dependencies || !this.pkg.dependencies[name]) {
+        continue
+      }
+
+      // Current version
+      const currentVersion = this.pkg.dependencies[name]
+      const caret = currentVersion[0] === '^'
+
+      // Sync version
+      this.pkg.dependencies[name] = caret ? `^${pkg.version}` : pkg.version
+    }
+  }
+
+  async getWorkspacePackages () {
+    const packages = []
+
+    for (const workspace of this.pkg.workspaces || []) {
+      const dirs = await glob(workspace)
+      for (const dir of dirs) {
+        if (existsSync(this.resolvePath(dir, 'package.json'))) {
+          const pkg = new Package({ rootDir: this.resolvePath(dir) })
+          packages.push(pkg)
+        } else {
+          consola.warn('Invalid workspace package:', dir)
+        }
+      }
+    }
+
+    return packages
+  }
+
+  async build (_watch = false) {
+    // Externals
+    const externals = [
+      // Dependencies that will be installed alongise with the nuxt package
+      ...Object.keys(this.pkg.dependencies || {}),
+      // Builtin node modules
+      ...builtins,
+      // Custom externals
+      ...(this.options.externals || [])
+    ]
+
+    // Prepare rollup config
+    const config = {
+      rootDir: this.options.rootDir,
+      alias: {},
+      replace: {},
+      externals,
+      ...this.options.rollup
+    }
+
+    // Replace linkedDependencies with their suffixed version
+    if (this.options.suffix && this.options.suffix.length) {
+      for (const _name of (this.options.linkedDependencies || [])) {
+        const name = _name + this.options.suffix
+        config.replace[`'${_name}'`] = `'${name}'`
+        config.alias[_name] = name
+      }
+    }
+
+    // Allow extending config
+    await this.callHook('build:extend', { config })
+
+    // Create rollup config
+    const _rollupConfig = rollupConfig(config, this.pkg)
+
+    // Allow extending rollup config
+    await this.callHook('build:extendRollup', {
+      rollupConfig: _rollupConfig
+    })
+
+    if (_watch) {
+      // Watch
+      const watcher = watch(_rollupConfig)
+      watcher.on('event', (event) => {
+        switch (event.code) {
+          // The watcher is (re)starting
+          case 'START':
+            return this.logger.debug('Watching for changes')
+
+          // Building an individual bundle
+          case 'BUNDLE_START':
+            return this.logger.debug('Building bundle')
+
+          // Finished building a bundle
+          case 'BUNDLE_END':
+            return
+
+          // Finished building all bundles
+          case 'END':
+            return this.logger.success('Bundle built')
+
+          // Encountered an error while bundling
+          case 'ERROR':
+            this.formatError(event.error)
+            return this.logger.error(event.error)
+
+          // Unknown event
+          default:
+            return this.logger.info(JSON.stringify(event))
+        }
+      })
+    } else {
+      // Build
+      this.logger.info('Building bundle')
+      try {
+        const bundle = await rollup(_rollupConfig)
+        await remove(_rollupConfig.output.dir)
+        const result = await bundle.write(_rollupConfig.output)
+
+        this.logger.success('Bundle built')
+        await this.callHook('build:done', { bundle })
+
+        // Analyze bundle imports against pkg
+        const dependencies = Object.keys(this.pkg.dependencies || {})
+        const imports = [].concat(...result.output.map(o => o.imports))
+
+        const missingDependencies = imports
+          .filter(i => !i.endsWith('.js')) // dynamic imports
+          .filter(i => !dependencies.includes(i) && !externals.find(e => i.startsWith(e)))
+        if (missingDependencies.length) {
+          throw new Error(`Missing dependencies in ${this.pkg.name}: ` + missingDependencies.join(', '))
+        }
+        const ignoreUnused = this.options.ignoreUnused || []
+        const stripEdge = s => s.replace(/-edge$/, '')
+        const unusedDependencies = dependencies.filter(d =>
+          !imports.find(i => i.startsWith(d)) && !ignoreUnused.includes(stripEdge(d))
+        )
+        if (unusedDependencies.length) {
+          throw new Error(`Unused dependencies in ${this.pkg.name}: ` + unusedDependencies.join(', '))
+        }
+      } catch (err) {
+        this.formatError(err)
+        throw err
+      }
+    }
+  }
+
+  formatError (error) {
+    let loc = this.options.rootDir
+    if (error.loc) {
+      const { file, column, line } = error.loc
+      loc = `${file}:${line}:${column}`
+    }
+    error.message = `[${error.code || ''}] ${error.message}\nat ${loc}`
+    return error
+  }
+
+  watch () {
+    return this.build(true)
+  }
+
+  publish (tag = 'latest') {
+    this.logger.info(`publishing ${this.pkg.name}@${this.pkg.version} with tag ${tag}`)
+    this.exec('npm', `publish --tag ${tag}`)
+  }
+
+  copyFieldsFrom (source, fields = []) {
+    for (const field of fields) {
+      this.pkg[field] = source.pkg[field]
+    }
+  }
+
+  async copyFilesFrom (source, files) {
+    for (const file of files || source.pkg.files || []) {
+      const src = resolve(source.options.rootDir, file)
+      const dst = resolve(this.options.rootDir, file)
+      await copy(src, dst)
+    }
+  }
+
+  autoFix () {
+    this.pkg = sortPackageJson(this.pkg)
+    this.sortDependencies()
+  }
+
+  sortDependencies () {
+    if (this.pkg.dependencies) {
+      this.pkg.dependencies = sortObjectKeys(this.pkg.dependencies)
+    }
+
+    if (this.pkg.devDependencies) {
+      this.pkg.devDependencies = sortObjectKeys(this.pkg.devDependencies)
+    }
+  }
+
+  exec (command, args, silent = false) {
+    const r = spawn.sync(command, args.split(' '), { cwd: this.options.rootDir, env: process.env })
+
+    if (!silent) {
+      const fullCommand = command + ' ' + args
+      if (r.error) {
+        this.logger.error(fullCommand, r.error)
+      } else {
+        this.logger.success(fullCommand, r.output)
+      }
+    }
+
+    return {
+      error: r.error,
+      pid: r.pid,
+      status: r.status,
+      signal: r.signal,
+      stdout: String(r.stdout).trim(),
+      stderr: String(r.stderr).trim(),
+      output: (r.output || [])
+        .map(l => String(l).trim())
+        .filter(l => l.length)
+        .join('\n')
+    }
+  }
+
+  gitShortCommit () {
+    const { stdout } = this.exec('git', 'rev-parse --short HEAD', true)
+    return stdout
+  }
+
+  gitBranch () {
+    const { stdout } = this.exec('git', 'rev-parse --abbrev-ref HEAD', true)
+    return stdout
+  }
+}

package/scripts/pkg.js

@@ -0,0 +1,55 @@
+import consola from 'consola'
+
+import Package from './package.js'
+
+async function main () {
+  // Read package at current directory
+  const rootPackage = new Package()
+  const workspacePackages = await rootPackage.getWorkspacePackages()
+
+  const watch = process.argv.includes('--watch')
+
+  if (watch) {
+    consola.info('Watch mode')
+  }
+
+  // Universal linkedDependencies based on workspace
+  const linkedDependencies = workspacePackages
+    .map(p => p.pkg.name.replace(p.options.suffix, ''))
+
+  for (const pkg of workspacePackages) {
+    pkg.options.linkedDependencies = (pkg.options.linkedDependencies || [])
+      .concat(linkedDependencies)
+  }
+
+  // Step 1: Apply suffixes
+  for (const pkg of workspacePackages) {
+    if (pkg.options.suffix && pkg.options.suffix.length) {
+      pkg.suffixAndVersion()
+      await pkg.writePackage()
+    }
+  }
+
+  // Step 2: Build packages
+  for (const pkg of workspacePackages) {
+    if (pkg.options.build) {
+      if (watch) {
+        pkg.watch()
+      } else {
+        await pkg.build()
+      }
+    }
+  }
+
+  // Step 3: Link dependencies and Fix packages
+  for (const pkg of workspacePackages) {
+    pkg.syncLinkedDependencies()
+    pkg.autoFix()
+    pkg.writePackage()
+  }
+}
+
+main().catch((error) => {
+  consola.error(error)
+  process.exit(1)
+})

package/scripts/release-publish

@@ -0,0 +1,14 @@
+#!/bin/bash
+set -e
+
+if [ ! "$1" ]; then
+  echo "Usage $0 [version]"
+  exit 1
+fi
+
+yarn build
+
+./scripts/workspace-run npm publish -q
+
+git tag -a v$1 -m v$1
+git push --tags

package/scripts/release-version

@@ -0,0 +1,4 @@
+#!/bin/bash
+set -e
+
+yarn lerna version --no-changelog --no-git-tag-version --no-push --force-publish "*"

package/scripts/rollup.config.js

@@ -0,0 +1,67 @@
+import path from 'path'
+import { readJSONSync } from 'fs-extra'
+import jsonPlugin from '@rollup/plugin-json'
+import commonjsPlugin from '@rollup/plugin-commonjs'
+import replacePlugin from '@rollup/plugin-replace'
+import aliasPlugin from '@rollup/plugin-alias'
+// import nodeResolvePlugin from '@rollup/plugin-node-resolve'
+import licensePlugin from 'rollup-plugin-license'
+import { defaultsDeep } from 'lodash'
+
+export default function rollupConfig ({
+  rootDir = process.cwd(),
+  plugins = [],
+  input = 'src/index.js',
+  replace = {},
+  alias = {},
+  externals = [],
+  ...options
+}, pkg) {
+  if (!pkg) {
+    pkg = readJSONSync(path.resolve(rootDir, 'package.json'))
+  }
+
+  const name = path.basename(pkg.name.replace('-edge', ''))
+
+  return defaultsDeep({}, options, {
+    input: path.resolve(rootDir, input),
+    output: {
+      dir: path.resolve(rootDir, 'dist'),
+      entryFileNames: `${name}.js`,
+      chunkFileNames: `${name}-[name].js`,
+      format: 'cjs',
+      preferConst: true
+    },
+    external: externals,
+    plugins: [
+      aliasPlugin(alias),
+      replacePlugin({
+        exclude: 'node_modules/**',
+        delimiters: ['', ''],
+        preventAssignment: true,
+        values: {
+          __NODE_ENV__: process.env.NODE_ENV,
+          ...replace
+        }
+      }),
+      // nodeResolvePlugin({
+      //   preferBuiltins: true,
+      //   resolveOnly: [
+      //     /lodash/
+      //   ]
+      // }),
+      commonjsPlugin({ include: /node_modules/ }),
+      jsonPlugin(),
+      licensePlugin({
+        banner: [
+          '/*!',
+          ` * ${pkg.name} v${pkg.version} (c) 2016-${new Date().getFullYear()}`,
+          ' * Released under the MIT License',
+          ' * Repository: https://github.com/nuxt/nuxt.js',
+          ' * Website: https://nuxtjs.org',
+          '*/'
+        ].join('\n')
+      })
+    ].concat(plugins)
+  })
+}

package/scripts/workspace-run

@@ -0,0 +1,10 @@
+#!/bin/bash
+set -e
+
+for dir in packages/* distributions/* ; do
+ # echo "$dir"
+ pushd $dir > /dev/null
+  $@
+ popd > /dev/null
+done
+

package/test/dev/async-config.size-limit.test.js

@@ -0,0 +1,45 @@
+import { resolve } from 'path'
+import { getResourcesSize } from '../utils'
+
+const distDir = resolve(__dirname, '../fixtures/async-config/.nuxt/dist')
+
+describe('nuxt basic resources size limit', () => {
+  expect.extend({
+    toBeWithinSize (received, size) {
+      const maxSize = size * 1.05
+      const minSize = size * 0.95
+      const pass = received >= minSize && received <= maxSize
+      return {
+        pass,
+        message: () =>
+          `expected ${received} to be within range ${minSize} - ${maxSize}`
+      }
+    }
+  })
+
+  it('should stay within the size limit range in legacy mode', async () => {
+    const legacyResourcesSize = await getResourcesSize(distDir, 'client', { gzip: true, brotli: true })
+
+    const LEGACY_JS_RESOURCES_KB_SIZE = 217
+    expect(legacyResourcesSize.uncompressed).toBeWithinSize(LEGACY_JS_RESOURCES_KB_SIZE)
+
+    const LEGACY_JS_RESOURCES_GZIP_KB_SIZE = 75
+    expect(legacyResourcesSize.gzip).toBeWithinSize(LEGACY_JS_RESOURCES_GZIP_KB_SIZE)
+
+    const LEGACY_JS_RESOURCES_BROTLI_KB_SIZE = 64
+    expect(legacyResourcesSize.brotli).toBeWithinSize(LEGACY_JS_RESOURCES_BROTLI_KB_SIZE)
+  })
+
+  it('should stay within the size limit range in modern mode', async () => {
+    const modernResourcesSize = await getResourcesSize(distDir, 'modern', { gzip: true, brotli: true })
+
+    const MODERN_JS_RESOURCES_KB_SIZE = 180
+    expect(modernResourcesSize.uncompressed).toBeWithinSize(MODERN_JS_RESOURCES_KB_SIZE)
+
+    const MODERN_JS_RESOURCES_GZIP_KB_SIZE = 64
+    expect(modernResourcesSize.gzip).toBeWithinSize(MODERN_JS_RESOURCES_GZIP_KB_SIZE)
+
+    const MODERN_JS_RESOURCES_BROTLI_KB_SIZE = 55
+    expect(modernResourcesSize.brotli).toBeWithinSize(MODERN_JS_RESOURCES_BROTLI_KB_SIZE)
+  })
+})

package/test/dev/async-config.test.js

@@ -0,0 +1,21 @@
+import { getPort, loadFixture, Nuxt } from '../utils'
+
+let port
+let nuxt = null
+
+describe('basic ssr', () => {
+  beforeAll(async () => {
+    const options = await loadFixture('async-config')
+    nuxt = new Nuxt(options)
+    await nuxt.ready()
+
+    port = await getPort()
+    await nuxt.server.listen(port, '0.0.0.0')
+  })
+
+  test('/', async () => {
+    expect(nuxt.options.head.title).toBe('Async Config!')
+    const { html } = await nuxt.server.renderRoute('/')
+    expect(html).toContain('<h1>I am ALIVE!</h1>')
+  })
+})

package/test/dev/basic.config.defaults.test.js

@@ -0,0 +1,73 @@
+import { resolve } from 'path'
+import consola from 'consola'
+import Glob from 'glob'
+import pify from 'pify'
+
+import { Nuxt, getNuxtConfig, version } from '../utils'
+
+const glob = pify(Glob)
+
+describe('basic config defaults', () => {
+  test('Nuxt.version is same as package', () => {
+    expect(Nuxt.version).toBe(version)
+  })
+
+  test('modulesDir uses /node_modules as default if not set', () => {
+    const options = getNuxtConfig({})
+    const currentNodeModulesDir = resolve(__dirname, '..', '..', 'node_modules')
+    expect(options.modulesDir).toContain(currentNodeModulesDir)
+  })
+
+  test('client source map not generated', async () => {
+    const mapFiles = await glob(resolve(__dirname, '..', 'fixtures/basic/.nuxt/dist/client/*.js.map'))
+    expect(mapFiles.length).toEqual(0)
+  })
+
+  test('vendor has been deprecated', () => {
+    const options = getNuxtConfig({
+      build: { vendor: 'vue' }
+    })
+    expect(options.build.vendor).toBeUndefined()
+    expect(consola.warn).toHaveBeenCalledWith('vendor has been deprecated due to webpack4 optimization')
+  })
+
+  test('globalName uses nuxt as default if not set', () => {
+    const options = getNuxtConfig({})
+    expect(options.globalName).toEqual('nuxt')
+  })
+
+  test('globalName uses nuxt as default if set to something other than only letters', () => {
+    let options = getNuxtConfig({ globalName: '12foo4' })
+    expect(options.globalName).toEqual('nuxt')
+
+    options = getNuxtConfig({ globalName: 'foo bar' })
+    expect(options.globalName).toEqual('nuxt')
+
+    options = getNuxtConfig({ globalName: 'foo?' })
+    expect(options.globalName).toEqual('nuxt')
+  })
+
+  test('@nuxtjs/babel-preset-app has been deprecated', () => {
+    let options = getNuxtConfig({
+      build: {
+        babel: {
+          presets: ['@nuxtjs/babel-preset-app']
+        }
+      }
+    })
+    expect(options.build.babel.presets).toEqual(['@nuxt/babel-preset-app'])
+    expect(consola.warn).toHaveBeenCalledWith('@nuxtjs/babel-preset-app has been deprecated, please use @nuxt/babel-preset-app.')
+
+    consola.warn.mockClear()
+
+    options = getNuxtConfig({
+      build: {
+        babel: {
+          presets: [['@nuxtjs/babel-preset-app']]
+        }
+      }
+    })
+    expect(options.build.babel.presets).toEqual([['@nuxt/babel-preset-app']])
+    expect(consola.warn).toHaveBeenCalledWith('@nuxtjs/babel-preset-app has been deprecated, please use @nuxt/babel-preset-app.')
+  })
+})