expeditaea 1.0.0

package/packages/core/src/module.js

@@ -0,0 +1,219 @@
+import path from 'path'
+import fs from 'fs'
+import hash from 'hash-sum'
+import consola from 'consola'
+
+import { chainFn, sequence } from '@nuxt/utils'
+
+export default class ModuleContainer {
+  constructor (nuxt) {
+    this.nuxt = nuxt
+    this.options = nuxt.options
+    this.requiredModules = {}
+
+    // Self bind to allow destructre from container
+    for (const method of Object.getOwnPropertyNames(ModuleContainer.prototype)) {
+      if (typeof this[method] === 'function') {
+        this[method] = this[method].bind(this)
+      }
+    }
+  }
+
+  async ready () {
+    // Call before hook
+    await this.nuxt.callHook('modules:before', this, this.options.modules)
+
+    if (this.options.buildModules && !this.options._start) {
+      // Load every devModule in sequence
+      await sequence(this.options.buildModules, this.addModule)
+    }
+
+    // Load every module in sequence
+    await sequence(this.options.modules, this.addModule)
+
+    // Load ah-hoc modules last
+    await sequence(this.options._modules, this.addModule)
+
+    // Call done hook
+    await this.nuxt.callHook('modules:done', this)
+  }
+
+  addVendor () {
+    consola.warn('addVendor has been deprecated due to webpack4 optimization')
+  }
+
+  addTemplate (template) {
+    if (!template) {
+      throw new Error('Invalid template: ' + JSON.stringify(template))
+    }
+
+    // Validate & parse source
+    const src = template.src || template
+    const srcPath = path.parse(src)
+
+    if (typeof src !== 'string' || !fs.existsSync(src)) {
+      throw new Error('Template src not found: ' + src)
+    }
+
+    // Mostly for DX, some people prefers `filename` vs `fileName`
+    const fileName = template.fileName || template.filename
+    // Generate unique and human readable dst filename if not provided
+    const dst = fileName || `${path.basename(srcPath.dir)}.${srcPath.name}.${hash(src)}${srcPath.ext}`
+    // Add to templates list
+    const templateObj = {
+      src,
+      dst,
+      options: template.options
+    }
+
+    this.options.build.templates.push(templateObj)
+
+    return templateObj
+  }
+
+  addPlugin (template) {
+    const { dst } = this.addTemplate(template)
+
+    // Add to nuxt plugins
+    this.options.plugins.unshift({
+      src: path.join(this.options.buildDir, dst),
+      // TODO: remove deprecated option in Nuxt 3
+      ssr: template.ssr,
+      mode: template.mode
+    })
+  }
+
+  addLayout (template, name) {
+    const { dst, src } = this.addTemplate(template)
+    const layoutName = name || path.parse(src).name
+    const layout = this.options.layouts[layoutName]
+
+    if (layout) {
+      consola.warn(`Duplicate layout registration, "${layoutName}" has been registered as "${layout}"`)
+    }
+
+    // Add to nuxt layouts
+    this.options.layouts[layoutName] = `./${dst}`
+
+    // If error layout, set ErrorPage
+    if (name === 'error') {
+      this.addErrorLayout(dst)
+    }
+  }
+
+  addErrorLayout (dst) {
+    const relativeBuildDir = path.relative(this.options.rootDir, this.options.buildDir)
+    this.options.ErrorPage = `~/${relativeBuildDir}/${dst}`
+  }
+
+  addServerMiddleware (middleware) {
+    this.options.serverMiddleware.push(middleware)
+  }
+
+  extendBuild (fn) {
+    this.options.build.extend = chainFn(this.options.build.extend, fn)
+  }
+
+  extendRoutes (fn) {
+    this.options.router.extendRoutes = chainFn(
+      this.options.router.extendRoutes,
+      fn
+    )
+  }
+
+  requireModule (moduleOpts, { paths } = {}) {
+    return this.addModule(moduleOpts, undefined, { paths })
+  }
+
+  async addModule (moduleOpts, arg2, arg3) {
+    // Arg2 was previously used for requireOnce which is ignored now
+    const { paths } = { ...arg2, ...arg3 }
+    let src
+    let options
+    let handler
+
+    // Type 1: String or Function
+    if (typeof moduleOpts === 'string' || typeof moduleOpts === 'function') {
+      src = moduleOpts
+    } else if (Array.isArray(moduleOpts)) {
+      // Type 2: Babel style array
+      [src, options] = moduleOpts
+    } else if (typeof moduleOpts === 'object') {
+      // Type 3: Pure object
+      ({ src, options, handler } = moduleOpts)
+    }
+
+    // Define handler if src is a function
+    if (typeof src === 'function') {
+      handler = src
+    }
+
+    // Prevent adding buildModules-listed entries in production
+    if (this.options.buildModules.includes(handler) && this.options._start) {
+      return
+    }
+
+    // Resolve handler
+    if (!handler) {
+      try {
+        handler = this.nuxt.resolver.requireModule(src, { paths })
+        // pnp support
+        try { (global.__NUXT_PATHS__ || []).push(this.nuxt.resolver.resolvePath(src, { paths })) } catch (_err) {}
+      } catch (error) {
+        if (error.code !== 'MODULE_NOT_FOUND') {
+          throw error
+        }
+
+        // Hint only if entrypoint is not found and src is not local alias or path
+        if (error.message.includes(src) && !/^[~.]|^@\//.test(src)) {
+          let message = 'Module `{name}` not found.'
+
+          if (this.options.buildModules.includes(src)) {
+            message += ' Please ensure `{name}` is in `devDependencies` and installed. HINT: During build step, for npm/yarn, `NODE_ENV=production` or `--production` should NOT be used.'.replace('{name}', src)
+          } else if (this.options.modules.includes(src)) {
+            message += ' Please ensure `{name}` is in `dependencies` and installed.'
+          }
+
+          message = message.replace(/{name}/g, src)
+
+          consola.warn(message)
+        }
+
+        if (this.options._cli) {
+          throw error
+        } else {
+          // TODO: Remove in next major version
+          consola.warn('Silently ignoring module as programatic usage detected.')
+          return
+        }
+      }
+    }
+
+    // Validate handler
+    if (typeof handler !== 'function') {
+      throw new TypeError('Module should export a function: ' + src)
+    }
+
+    // Ensure module is required once
+    const metaKey = handler.meta && handler.meta.name
+    const key = metaKey || src
+    if (typeof key === 'string') {
+      if (this.requiredModules[key]) {
+        if (!metaKey) {
+          // TODO: Skip with nuxt3
+          consola.warn('Modules should be only specified once:', key)
+        } else {
+          return
+        }
+      }
+      this.requiredModules[key] = { src, options, handler }
+    }
+
+    // Default module options to empty object
+    if (options === undefined) {
+      options = {}
+    }
+    const result = await handler.call(this, options)
+    return result
+  }
+}

package/packages/core/src/nuxt.js

@@ -0,0 +1,125 @@
+
+import { isPlainObject } from 'lodash'
+import consola from 'consola'
+import Hookable from 'hable'
+
+import { defineAlias } from '@nuxt/utils'
+import { getNuxtConfig } from '@nuxt/config'
+import { Server } from '@nuxt/server'
+
+import { version } from '../package.json'
+
+import ModuleContainer from './module'
+import Resolver from './resolver'
+
+export default class Nuxt extends Hookable {
+  constructor (options = {}) {
+    super(consola)
+
+    // Assign options and apply defaults
+    this.options = getNuxtConfig(options)
+
+    // Create instance of core components
+    this.resolver = new Resolver(this)
+    this.moduleContainer = new ModuleContainer(this)
+
+    // Deprecated hooks
+    this.deprecateHooks({
+      // #3294 - 7514db73b25c23b8c14ebdafbb4e129ac282aabd
+      'render:context': {
+        to: '_render:context',
+        message: '`render:context(nuxt)` is deprecated, Please use `vue-renderer:ssr:context(context)`'
+      },
+      // #3773
+      'render:routeContext': {
+        to: '_render:context',
+        message: '`render:routeContext(nuxt)` is deprecated, Please use `vue-renderer:ssr:context(context)`'
+      },
+      showReady: 'webpack:done',
+      // Introduced in 2.13
+      'export:done': 'generate:done',
+      'export:before': 'generate:before',
+      'export:extendRoutes': 'generate:extendRoutes',
+      'export:distRemoved': 'generate:distRemoved',
+      'export:distCopied': 'generate:distCopied',
+      'export:route': 'generate:route',
+      'export:routeFailed': 'generate:routeFailed',
+      'export:page': 'generate:page',
+      'export:routeCreated': 'generate:routeCreated'
+    })
+
+    // Add Legacy aliases
+    defineAlias(this, this.resolver, ['resolveAlias', 'resolvePath'])
+    this.showReady = () => { this.callHook('webpack:done') }
+
+    // Init server
+    if (this.options.server !== false) {
+      this._initServer()
+    }
+
+    // Call ready
+    if (this.options._ready !== false) {
+      this.ready().catch((err) => {
+        consola.fatal(err)
+      })
+    }
+  }
+
+  static get version () {
+    return `v${version}` + (global.__NUXT_DEV__ ? '-development' : '')
+  }
+
+  ready () {
+    if (!this._ready) {
+      this._ready = this._init()
+    }
+    return this._ready
+  }
+
+  async _init () {
+    if (this._initCalled) {
+      return this
+    }
+    this._initCalled = true
+
+    // Add hooks
+    if (isPlainObject(this.options.hooks)) {
+      this.addHooks(this.options.hooks)
+    } else if (typeof this.options.hooks === 'function') {
+      this.options.hooks(this.hook)
+    }
+
+    // Await for modules
+    await this.moduleContainer.ready()
+
+    // Await for server to be ready
+    if (this.server) {
+      await this.server.ready()
+    }
+
+    // Call ready hook
+    await this.callHook('ready', this)
+
+    return this
+  }
+
+  _initServer () {
+    if (this.server) {
+      return
+    }
+    this.server = new Server(this)
+    this.renderer = this.server
+    this.render = this.server.app
+    defineAlias(this, this.server, ['renderRoute', 'renderAndGetWindow', 'listen'])
+  }
+
+  async close (callback) {
+    await this.callHook('close', this)
+
+    if (typeof callback === 'function') {
+      await callback()
+    }
+
+    this.clearHooks()
+  }
+}

package/packages/core/src/resolver.js

@@ -0,0 +1,165 @@
+import { resolve, join } from 'path'
+import fs from 'fs-extra'
+import consola from 'consola'
+
+import {
+  createRequire,
+  startsWithRootAlias,
+  startsWithSrcAlias,
+  isExternalDependency,
+  clearRequireCache
+} from '@nuxt/utils'
+
+export default class Resolver {
+  constructor (nuxt) {
+    this.nuxt = nuxt
+    this.options = this.nuxt.options
+
+    // Binds
+    this.resolvePath = this.resolvePath.bind(this)
+    this.resolveAlias = this.resolveAlias.bind(this)
+    this.resolveModule = this.resolveModule.bind(this)
+    this.requireModule = this.requireModule.bind(this)
+
+    this._createRequire = this.options.createRequire || createRequire
+    this._require = this._createRequire(__filename)
+  }
+
+  resolveModule (path, { paths } = {}) {
+    try {
+      return this._require.resolve(path, {
+        paths: [].concat(global.__NUXT_PREPATHS__ || [], paths || [], this.options.modulesDir, global.__NUXT_PATHS__ || [], process.cwd())
+      })
+    } catch (error) {
+      if (error.code !== 'MODULE_NOT_FOUND') {
+        throw error
+      }
+    }
+  }
+
+  resolveAlias (path) {
+    if (startsWithRootAlias(path)) {
+      return join(this.options.rootDir, path.substr(2))
+    }
+
+    if (startsWithSrcAlias(path)) {
+      return join(this.options.srcDir, path.substr(1))
+    }
+
+    return resolve(this.options.srcDir, path)
+  }
+
+  resolvePath (path, { alias, isAlias = alias, module, isModule = module, isStyle, paths } = {}) {
+    // TODO: Remove in Nuxt 3
+    if (alias) {
+      consola.warn('Using alias is deprecated and will be removed in Nuxt 3. Use `isAlias` instead.')
+    }
+    if (module) {
+      consola.warn('Using module is deprecated and will be removed in Nuxt 3. Use `isModule` instead.')
+    }
+
+    // Fast return in case of path exists
+    if (fs.existsSync(path)) {
+      return path
+    }
+
+    let resolvedPath
+
+    // Try to resolve it as a regular module
+    if (isModule !== false) {
+      resolvedPath = this.resolveModule(path, { paths })
+    }
+
+    // Try to resolve alias
+    if (!resolvedPath && isAlias !== false) {
+      resolvedPath = this.resolveAlias(path)
+    }
+
+    // Use path for resolvedPath
+    if (!resolvedPath) {
+      resolvedPath = path
+    }
+
+    let isDirectory
+
+    // Check if resolvedPath exits and is not a directory
+    if (fs.existsSync(resolvedPath)) {
+      isDirectory = fs.lstatSync(resolvedPath).isDirectory()
+
+      if (!isDirectory) {
+        return resolvedPath
+      }
+    }
+
+    const extensions = isStyle ? this.options.styleExtensions : this.options.extensions
+
+    // Check if any resolvedPath.[ext] or resolvedPath/index.[ext] exists
+    for (const ext of extensions) {
+      if (!isDirectory && fs.existsSync(resolvedPath + '.' + ext)) {
+        return resolvedPath + '.' + ext
+      }
+
+      const resolvedPathwithIndex = join(resolvedPath, 'index.' + ext)
+      if (isDirectory && fs.existsSync(resolvedPathwithIndex)) {
+        return resolvedPathwithIndex
+      }
+    }
+
+    // If there's no index.[ext] we just return the directory path
+    if (isDirectory) {
+      return resolvedPath
+    }
+
+    // Give up
+    throw new Error(`Cannot resolve "${path}" from "${resolvedPath}"`)
+  }
+
+  requireModule (path, { alias, isAlias = alias, intropDefault, interopDefault = intropDefault, paths } = {}) {
+    let resolvedPath = path
+    let requiredModule
+
+    // TODO: Remove in Nuxt 3
+    if (intropDefault) {
+      consola.warn('Using intropDefault is deprecated and will be removed in Nuxt 3. Use `interopDefault` instead.')
+    }
+    if (alias) {
+      consola.warn('Using alias is deprecated and will be removed in Nuxt 3. Use `isAlias` instead.')
+    }
+
+    let lastError
+
+    // Try to resolve path
+    try {
+      resolvedPath = this.resolvePath(path, { isAlias, paths })
+    } catch (e) {
+      lastError = e
+    }
+
+    const isExternal = isExternalDependency(resolvedPath)
+
+    // in dev mode make sure to clear the require cache so after
+    // a dev server restart any changed file is reloaded
+    if (this.options.dev && !isExternal) {
+      clearRequireCache(resolvedPath)
+    }
+
+    // Try to require
+    try {
+      requiredModule = this._require(resolvedPath)
+    } catch (e) {
+      lastError = e
+    }
+
+    // Interop default
+    if (interopDefault !== false && requiredModule && requiredModule.default) {
+      requiredModule = requiredModule.default
+    }
+
+    // Throw error if failed to require
+    if (requiredModule === undefined && lastError) {
+      throw lastError
+    }
+
+    return requiredModule
+  }
+}

package/packages/core/test/index.test.js

@@ -0,0 +1,17 @@
+import { Module, Nuxt, Resolver } from '../src'
+
+jest.mock('../src/module', () => ({
+  module: true
+})).mock('../src/nuxt', () => ({
+  nuxt: true
+})).mock('../src/resolver', () => ({
+  resolver: true
+}))
+
+describe('core: entry', () => {
+  test('should export Module, Nuxt and Resolver', () => {
+    expect(Module.module).toEqual(true)
+    expect(Nuxt.nuxt).toEqual(true)
+    expect(Resolver.resolver).toEqual(true)
+  })
+})