mirror of
https://github.com/nuxt/nuxt.git
synced 2024-12-05 03:47:12 +00:00
164 lines
4.4 KiB
JavaScript
Executable File
164 lines
4.4 KiB
JavaScript
Executable File
'use strict'
|
|
|
|
import path from 'path'
|
|
import fs from 'fs'
|
|
import { uniq } from 'lodash'
|
|
import hash from 'hash-sum'
|
|
import { chainFn, sequence } from './utils'
|
|
|
|
const debug = require('debug')('nuxt:module')
|
|
|
|
class Module {
|
|
constructor (nuxt) {
|
|
this.nuxt = nuxt
|
|
this.options = nuxt.options
|
|
this.requiredModules = []
|
|
this.initing = this.ready()
|
|
}
|
|
|
|
async ready () {
|
|
if (this.initing) {
|
|
await this.initing
|
|
return this
|
|
}
|
|
// Install all modules in sequence
|
|
await sequence(this.options.modules, this.addModule.bind(this))
|
|
return this
|
|
}
|
|
|
|
addVendor (vendor) {
|
|
/* istanbul ignore if */
|
|
if (!vendor) {
|
|
return
|
|
}
|
|
this.options.build.vendor = uniq(this.options.build.vendor.concat(vendor))
|
|
}
|
|
|
|
addTemplate (template) {
|
|
/* istanbul ignore if */
|
|
if (!template) {
|
|
return
|
|
}
|
|
// Validate & parse source
|
|
const src = template.src || template
|
|
const srcPath = path.parse(src)
|
|
/* istanbul ignore if */
|
|
if (!src || typeof src !== 'string' || !fs.existsSync(src)) {
|
|
debug('[nuxt] invalid template', template)
|
|
return
|
|
}
|
|
// Generate unique and human readable dst filename
|
|
const dst = template.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.nuxt.buildDir, dst),
|
|
ssr: template.ssr
|
|
})
|
|
}
|
|
|
|
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) {
|
|
// Require once
|
|
return this.addModule(moduleOpts, true)
|
|
}
|
|
|
|
addModule (moduleOpts, requireOnce) {
|
|
/* istanbul ignore if */
|
|
if (!moduleOpts) {
|
|
return
|
|
}
|
|
// Allow using babel style array options
|
|
if (Array.isArray(moduleOpts)) {
|
|
moduleOpts = {
|
|
src: moduleOpts[0],
|
|
options: moduleOpts[1]
|
|
}
|
|
}
|
|
// Allows passing runtime options to each module
|
|
const options = moduleOpts.options || (typeof moduleOpts === 'object' ? moduleOpts : {})
|
|
const originalSrc = moduleOpts.src || moduleOpts
|
|
// Resolve module
|
|
let module = originalSrc
|
|
try {
|
|
if (typeof module === 'string') {
|
|
// Using ~ or ./ shorthand modules are resolved from project srcDir
|
|
if (module.indexOf('~') === 0 || module.indexOf('./') === 0) {
|
|
module = path.join(this.options.srcDir, module.substr(1))
|
|
}
|
|
// eslint-disable-next-line no-eval
|
|
module = eval('require')(module)
|
|
}
|
|
} catch (e) /* istanbul ignore next */ {
|
|
// eslint-disable-next-line no-console
|
|
console.error('[nuxt] Unable to resolve module', module)
|
|
// eslint-disable-next-line no-console
|
|
console.error(e)
|
|
process.exit(0)
|
|
}
|
|
// Validate module
|
|
/* istanbul ignore if */
|
|
if (typeof module !== 'function') {
|
|
// eslint-disable-next-line no-console
|
|
console.error(`[nuxt] Module [${originalSrc}] should export a function`)
|
|
process.exit(1)
|
|
}
|
|
// Module meta
|
|
if (!module.meta) {
|
|
module.meta = {}
|
|
}
|
|
if (module.meta.name) {
|
|
const alreadyRequired = this.requiredModules.indexOf(module.meta.name) !== -1
|
|
if (requireOnce && alreadyRequired) {
|
|
return
|
|
}
|
|
if (!alreadyRequired) {
|
|
this.requiredModules.push(module.meta.name)
|
|
}
|
|
}
|
|
// Call module with `this` context and pass options
|
|
return new Promise((resolve, reject) => {
|
|
const result = module.call(this, options, err => {
|
|
/* istanbul ignore if */
|
|
if (err) {
|
|
return reject(err)
|
|
}
|
|
resolve(module)
|
|
})
|
|
// If module send back a promise
|
|
if (result && result.then instanceof Function) {
|
|
return result.then(resolve)
|
|
}
|
|
// If not expecting a callback but returns no promise (=synchronous)
|
|
if (module.length < 2) {
|
|
return resolve(module)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
export default Module
|