mirror of
https://github.com/nuxt/nuxt.git
synced 2024-11-24 06:35:10 +00:00
234 lines
5.6 KiB
JavaScript
234 lines
5.6 KiB
JavaScript
const Debug = require('debug')
|
|
const enableDestroy = require('server-destroy')
|
|
const Module = require('module')
|
|
const { isPlainObject } = require('lodash')
|
|
const chalk = require('chalk')
|
|
const { existsSync } = require('fs-extra')
|
|
const { Options } = require('../common')
|
|
const { sequence, printError, printWarn } = require('../common/utils')
|
|
const { resolve, join } = require('path')
|
|
const { version } = require('../../package.json')
|
|
const ModuleContainer = require('./module')
|
|
const Renderer = require('./renderer')
|
|
|
|
const debug = Debug('nuxt:')
|
|
debug.color = 5
|
|
|
|
module.exports = class Nuxt {
|
|
constructor(options = {}) {
|
|
this.options = Options.from(options)
|
|
|
|
this.initialized = false
|
|
this.onError = this.onError.bind(this)
|
|
|
|
// Hooks
|
|
this._hooks = {}
|
|
this.hook = this.hook.bind(this)
|
|
|
|
// Create instance of core components
|
|
this.moduleContainer = new ModuleContainer(this)
|
|
this.renderer = new Renderer(this)
|
|
|
|
// Backward compatibility
|
|
this.errorHandler = this.onError
|
|
this.render = this.renderer.app
|
|
this.renderRoute = this.renderer.renderRoute.bind(this.renderer)
|
|
this.renderAndGetWindow = this.renderer.renderAndGetWindow.bind(
|
|
this.renderer
|
|
)
|
|
|
|
this._ready = this.ready().catch(err => this.onError(err))
|
|
}
|
|
|
|
static get version() {
|
|
return version
|
|
}
|
|
|
|
async ready() {
|
|
if (this._ready) {
|
|
return this._ready
|
|
}
|
|
|
|
// Add hooks
|
|
if (isPlainObject(this.options.hooks)) {
|
|
this.addObjectHooks(this.options.hooks)
|
|
} else if (typeof this.options.hooks === 'function') {
|
|
this.options.hooks(this.hook)
|
|
}
|
|
|
|
// Await for modules
|
|
await this.moduleContainer.ready()
|
|
|
|
// Await for renderer to be ready
|
|
await this.renderer.ready()
|
|
|
|
this.initialized = true
|
|
|
|
// Call ready hook
|
|
await this.callHook('ready', this)
|
|
|
|
return this
|
|
}
|
|
|
|
plugin(name, fn) {
|
|
// A tiny backward compatibility util
|
|
const hook = {
|
|
ready: 'ready',
|
|
close: 'close',
|
|
listen: 'listen',
|
|
built: 'build:done'
|
|
}[name]
|
|
|
|
if (hook) {
|
|
this.hook(hook, fn)
|
|
printWarn(
|
|
`nuxt.plugin('${name}',..) is deprecated. Use new hooks system.`
|
|
)
|
|
} else {
|
|
throw new Error(
|
|
`nuxt.plugin('${name}',..) is not supported. Use new hooks system.`
|
|
)
|
|
}
|
|
|
|
// Always return nuxt class which has plugin() for two level hooks
|
|
return this
|
|
}
|
|
|
|
hook(name, fn) {
|
|
if (!name || typeof fn !== 'function') {
|
|
return
|
|
}
|
|
this._hooks[name] = this._hooks[name] || []
|
|
this._hooks[name].push(fn)
|
|
}
|
|
|
|
onError(err, from = 'Nuxt error') {
|
|
// Log error to the console if there is not any error listener
|
|
if (!this._hooks['error']) {
|
|
printError(err, from)
|
|
return
|
|
}
|
|
|
|
// Call error hooks
|
|
this.callHook('error', err, from)
|
|
}
|
|
|
|
async callHook(name, ...args) {
|
|
if (!this._hooks[name]) {
|
|
return
|
|
}
|
|
debug(`Call ${name} hooks (${this._hooks[name].length})`)
|
|
try {
|
|
await sequence(this._hooks[name], fn => fn(...args))
|
|
} catch (err) {
|
|
this.onError(err, name)
|
|
}
|
|
}
|
|
|
|
addObjectHooks(hooksObj) {
|
|
Object.keys(hooksObj).forEach(name => {
|
|
let hooks = hooksObj[name]
|
|
hooks = Array.isArray(hooks) ? hooks : [hooks]
|
|
|
|
hooks.forEach(hook => {
|
|
this.hook(name, hook)
|
|
})
|
|
})
|
|
}
|
|
|
|
listen(port = 3000, host = 'localhost') {
|
|
return new Promise((resolve, reject) => {
|
|
const server = this.renderer.app.listen(
|
|
{ port, host, exclusive: false },
|
|
err => {
|
|
/* istanbul ignore if */
|
|
if (err) {
|
|
return reject(err)
|
|
}
|
|
|
|
const _host = host === '0.0.0.0' ? 'localhost' : host
|
|
// eslint-disable-next-line no-console
|
|
console.log(
|
|
'\n' +
|
|
chalk.bgGreen.black(' OPEN ') +
|
|
chalk.green(` http://${_host}:${port}\n`)
|
|
)
|
|
|
|
// Close server on nuxt close
|
|
this.hook(
|
|
'close',
|
|
() =>
|
|
new Promise((resolve, reject) => {
|
|
// Destroy server by forcing every connection to be closed
|
|
server.destroy(err => {
|
|
debug('server closed')
|
|
/* istanbul ignore if */
|
|
if (err) {
|
|
return reject(err)
|
|
}
|
|
resolve()
|
|
})
|
|
})
|
|
)
|
|
|
|
this.callHook('listen', server, { port, host }).then(resolve)
|
|
}
|
|
)
|
|
|
|
// Add server.destroy(cb) method
|
|
enableDestroy(server)
|
|
})
|
|
}
|
|
|
|
resolveAlias(path) {
|
|
if (path.indexOf('@@') === 0 || path.indexOf('~~') === 0) {
|
|
return join(this.options.rootDir, path.substr(2))
|
|
}
|
|
|
|
if (path.indexOf('@') === 0 || path.indexOf('~') === 0) {
|
|
return join(this.options.srcDir, path.substr(1))
|
|
}
|
|
|
|
return resolve(this.options.srcDir, path)
|
|
}
|
|
|
|
resolvePath(path) {
|
|
// Try to resolve using NPM resolve path first
|
|
try {
|
|
const resolvedPath = Module._resolveFilename(path, {
|
|
paths: this.options.modulesDir
|
|
})
|
|
return resolvedPath
|
|
} catch (error) {
|
|
if (error.code === 'MODULE_NOT_FOUND') {
|
|
// Continue to try other methods
|
|
} else {
|
|
throw error
|
|
}
|
|
}
|
|
|
|
let _path = this.resolveAlias(path)
|
|
|
|
if (existsSync(_path)) {
|
|
return _path
|
|
}
|
|
|
|
for (let ext of this.options.extensions) {
|
|
if (existsSync(_path + '.' + ext)) {
|
|
return _path + '.' + ext
|
|
}
|
|
}
|
|
|
|
throw new Error(`Cannot resolve "${path}" from "${_path}"`)
|
|
}
|
|
|
|
async close(callback) {
|
|
await this.callHook('close', this)
|
|
|
|
/* istanbul ignore if */
|
|
if (typeof callback === 'function') {
|
|
await callback()
|
|
}
|
|
}
|
|
}
|