Nuxt/lib/build.js

542 lines
18 KiB
JavaScript
Raw Normal View History

2016-11-07 01:34:58 +00:00
'use strict'
2017-01-11 19:14:59 +00:00
import _ from 'lodash'
import chokidar from 'chokidar'
import fs from 'fs-extra'
import hash from 'hash-sum'
import pify from 'pify'
import webpack from 'webpack'
import PostCompilePlugin from 'post-compile-webpack-plugin'
2017-01-13 20:30:31 +00:00
import serialize from 'serialize-javascript'
2017-01-11 19:14:59 +00:00
import { createBundleRenderer } from 'vue-server-renderer'
2017-05-18 08:45:15 +00:00
import { join, resolve, basename, dirname } from 'path'
import { isUrl, r } from './utils'
2017-01-11 19:14:59 +00:00
import clientWebpackConfig from './webpack/client.config.js'
import serverWebpackConfig from './webpack/server.config.js'
2017-03-20 16:52:35 +00:00
const debug = require('debug')('nuxt:build')
2016-11-11 14:30:11 +00:00
const remove = pify(fs.remove)
const readFile = pify(fs.readFile)
2017-03-25 02:17:26 +00:00
const utimes = pify(fs.utimes)
2016-11-11 14:30:11 +00:00
const writeFile = pify(fs.writeFile)
const mkdirp = pify(fs.mkdirp)
2016-11-24 00:47:11 +00:00
const glob = pify(require('glob'))
2017-05-18 08:45:15 +00:00
2017-02-28 16:32:03 +00:00
let webpackStats = 'none'
2017-05-18 08:45:15 +00:00
debug.color = 2 // force green color
2016-11-07 01:34:58 +00:00
const defaults = {
2017-01-23 16:55:39 +00:00
analyze: false,
2017-05-05 15:53:21 +00:00
extractCSS: false,
2017-02-13 12:34:54 +00:00
publicPath: '/_nuxt/',
filenames: {
css: 'common.[chunkhash].css',
2017-03-25 23:52:39 +00:00
manifest: 'manifest.[hash].js',
2017-05-19 07:33:33 +00:00
vendor: 'vendor.bundle.[chunkhash].js',
app: 'nuxt.bundle.[chunkhash].js'
},
vendor: [],
loaders: [],
2016-11-18 09:38:47 +00:00
plugins: [],
2016-11-22 23:47:31 +00:00
babel: {},
postcss: [],
templates: [],
watch: []
}
const defaultsLoaders = [
{
test: /\.(png|jpe?g|gif|svg)$/,
2016-11-14 22:59:54 +00:00
loader: 'url-loader',
2016-11-10 18:34:59 +00:00
query: {
limit: 1000, // 1KO
2017-01-09 14:10:22 +00:00
name: 'img/[name].[hash:7].[ext]'
}
},
{
test: /\.(woff2?|eot|ttf|otf)(\?.*)?$/,
2016-11-14 22:59:54 +00:00
loader: 'url-loader',
query: {
limit: 1000, // 1 KO
name: 'fonts/[name].[hash:7].[ext]'
}
}
]
2016-11-22 23:47:31 +00:00
const defaultsPostcss = [
require('autoprefixer')({
browsers: ['last 3 versions']
})
]
2017-01-11 19:14:59 +00:00
export function options () {
// Defaults build options
2016-11-22 23:47:31 +00:00
let extraDefaults = {}
if (this.options.build && !Array.isArray(this.options.build.loaders)) extraDefaults.loaders = defaultsLoaders
if (this.options.build && !Array.isArray(this.options.build.postcss)) extraDefaults.postcss = defaultsPostcss
this.options.build = _.defaultsDeep(this.options.build, defaults, extraDefaults)
2017-03-24 17:54:54 +00:00
/* istanbul ignore if */
2017-03-16 17:52:38 +00:00
if (this.dev && isUrl(this.options.build.publicPath)) {
this.options.build.publicPath = defaults.publicPath
2017-02-16 17:16:00 +00:00
}
2016-12-07 18:01:46 +00:00
// Production, create server-renderer
if (!this.dev) {
2017-02-28 16:32:03 +00:00
webpackStats = {
chunks: false,
children: false,
modules: false,
colors: true
}
const serverConfig = getWebpackServerConfig.call(this)
2017-03-22 14:47:34 +00:00
const bundlePath = join(serverConfig.output.path, 'server-bundle.json')
const manifestPath = join(serverConfig.output.path, 'client-manifest.json')
if (fs.existsSync(bundlePath) && fs.existsSync(manifestPath)) {
2016-12-07 18:01:46 +00:00
const bundle = fs.readFileSync(bundlePath, 'utf8')
const manifest = fs.readFileSync(manifestPath, 'utf8')
createRenderer.call(this, JSON.parse(bundle), JSON.parse(manifest))
2017-02-21 18:22:57 +00:00
addAppTemplate.call(this)
2016-11-10 01:19:47 +00:00
}
}
2016-12-07 18:01:46 +00:00
}
export async function build () {
// Check if pages dir exists and warn if not
if (typeof this.createRoutes !== 'function') {
if (!fs.existsSync(join(this.srcDir, 'pages'))) {
if (fs.existsSync(join(this.srcDir, '..', 'pages'))) {
console.error('> No `pages` directory found. Did you mean to run `nuxt` in the parent (`../`) directory?') // eslint-disable-line no-console
} else {
console.error('> Couldn\'t find a `pages` directory. Please create one under the project root') // eslint-disable-line no-console
}
process.exit(1)
}
}
2016-12-08 06:45:40 +00:00
debug(`App root: ${this.srcDir}`)
2016-11-07 01:34:58 +00:00
debug('Generating .nuxt/ files...')
2016-12-21 19:51:09 +00:00
// Create .nuxt/, .nuxt/components and .nuxt/dist folders
await remove(r(this.dir, '.nuxt'))
await mkdirp(r(this.dir, '.nuxt/components'))
if (!this.dev) {
await mkdirp(r(this.dir, '.nuxt/dist'))
2016-11-07 01:34:58 +00:00
}
// Generate routes and interpret the template files
await generateRoutesAndFiles.call(this)
2016-12-21 19:51:09 +00:00
// Generate .nuxt/dist/ files
await buildFiles.call(this)
2016-12-21 19:51:09 +00:00
return this
}
async function buildFiles () {
if (this.dev) {
2017-02-03 14:09:27 +00:00
debug('Adding webpack middleware...')
createWebpackMiddleware.call(this)
webpackWatchAndUpdate.call(this)
watchPages.call(this)
} else {
debug('Building files...')
await webpackRunClient.call(this)
await webpackRunServer.call(this)
2017-02-21 18:22:57 +00:00
addAppTemplate.call(this)
}
}
function addAppTemplate () {
let templatePath = resolve(this.dir, '.nuxt', 'dist', 'index.html')
if (fs.existsSync(templatePath)) {
this.appTemplate = _.template(fs.readFileSync(templatePath, 'utf8'), {
interpolate: /{{([\s\S]+?)}}/g
})
}
}
async function generateRoutesAndFiles () {
2017-05-18 08:45:15 +00:00
debug('Generating files...')
// -- Templates --
2016-11-07 01:34:58 +00:00
let templatesFiles = [
'App.vue',
'client.js',
'index.js',
2017-02-03 14:09:27 +00:00
'middleware.js',
2016-11-07 01:34:58 +00:00
'router.js',
'server.js',
'utils.js',
2017-01-27 22:10:02 +00:00
'components/nuxt-error.vue',
2016-12-16 16:45:47 +00:00
'components/nuxt-loading.vue',
'components/nuxt-child.js',
'components/nuxt-link.js',
'components/nuxt.vue'
2016-11-07 01:34:58 +00:00
]
2017-05-18 08:45:15 +00:00
const templateVars = {
options: this.options,
2016-11-20 11:23:48 +00:00
uniqBy: _.uniqBy,
isDev: this.dev,
2016-11-10 16:16:37 +00:00
router: {
2017-02-17 09:24:30 +00:00
mode: this.options.router.mode,
2016-11-10 16:16:37 +00:00
base: this.options.router.base,
2017-02-03 14:09:27 +00:00
middleware: this.options.router.middleware,
2017-01-26 14:56:47 +00:00
linkActiveClass: this.options.router.linkActiveClass,
scrollBehavior: this.options.router.scrollBehavior
2016-11-10 16:16:37 +00:00
},
2016-12-04 18:15:11 +00:00
env: this.options.env,
2016-11-14 22:59:54 +00:00
head: this.options.head,
middleware: fs.existsSync(join(this.srcDir, 'middleware')),
2017-05-18 08:45:15 +00:00
store: this.options.store || fs.existsSync(join(this.srcDir, 'store')),
css: this.options.css,
plugins: this.options.plugins.map((p) => {
if (typeof p === 'string') {
return { src: r(this.srcDir, p), ssr: true }
}
2017-04-15 11:19:41 +00:00
return { src: r(this.srcDir, p.src), ssr: (p.ssr !== false), injectAs: (p.injectAs || false) }
}),
appPath: './App.vue',
2017-05-18 08:45:15 +00:00
layouts: Object.assign({}, this.options.layouts),
2016-12-08 06:45:40 +00:00
loading: (typeof this.options.loading === 'string' ? r(this.srcDir, this.options.loading) : this.options.loading),
transition: this.options.transition,
2016-11-07 01:34:58 +00:00
components: {
2017-05-18 08:45:15 +00:00
ErrorPage: this.options.ErrorPage ? r(this.options.ErrorPage) : null
2016-11-10 16:16:37 +00:00
}
2016-11-07 01:34:58 +00:00
}
2017-05-18 08:45:15 +00:00
// -- Layouts --
if (fs.existsSync(resolve(this.srcDir, 'layouts'))) {
const layoutsFiles = await glob('layouts/*.vue', {cwd: this.srcDir})
layoutsFiles.forEach((file) => {
let name = file.split('/').slice(-1)[0].replace('.vue', '')
if (name === 'error') return
templateVars.layouts[name] = r(this.srcDir, file)
})
if (layoutsFiles.includes('layouts/error.vue')) {
templateVars.components.ErrorPage = r(this.srcDir, 'layouts/error.vue')
}
}
// If no default layout, create its folder and add the default folder
if (!templateVars.layouts.default) {
await mkdirp(r(this.dir, '.nuxt/layouts'))
templatesFiles.push('layouts/default.vue')
templateVars.layouts.default = r(__dirname, 'app', 'layouts', 'default.vue')
}
// -- Routes --
debug('Generating routes...')
// Format routes for the lib/app/router.js template
if (typeof this.createRoutes !== 'function') {
// Use internal createRoutes
2017-05-18 08:45:15 +00:00
const files = await glob('pages/**/*.vue', {cwd: this.srcDir})
templateVars.router.routes = createRoutes(files, this.srcDir)
} else {
templateVars.router.routes = this.createRoutes.call(this, this.srcDir)
2017-05-18 08:45:15 +00:00
}
2017-01-18 16:25:38 +00:00
if (typeof this.options.router.extendRoutes === 'function') {
// let the user extend the routes
2017-05-12 07:57:24 +00:00
this.options.router.extendRoutes.call(this, templateVars.router.routes, r)
2017-01-18 16:25:38 +00:00
}
2017-05-18 08:45:15 +00:00
// Routes for generate command
this.routes = flatRoutes(templateVars.router.routes)
2017-05-18 08:45:15 +00:00
// -- Store --
2016-12-25 20:16:30 +00:00
// Add store if needed
if (this.options.store) {
templatesFiles.push('store.js')
}
2017-05-18 08:45:15 +00:00
// Resolve template files
2017-05-18 08:45:15 +00:00
const customTemplateFiles = this.options.build.templates.map(t => t.dst || basename(t.src || t))
templatesFiles = templatesFiles.map(file => {
2017-05-18 08:45:15 +00:00
// Allow override templates using a file with same name in ${srcDir}/app
const customPath = r(this.srcDir, 'app', file)
const customFileExists = fs.existsSync(customPath)
2017-05-18 08:45:15 +00:00
// Skip if custom file was already provided in build.templates[]
if (customTemplateFiles.indexOf(file) !== -1 && !customFileExists) {
return
}
return {
src: customFileExists ? customPath : r(__dirname, 'app', file),
dst: file,
custom: customFileExists
}
2017-05-18 08:45:15 +00:00
}).filter(i => !!i)
// -- Custom templates --
// Add custom template files
templatesFiles = templatesFiles.concat(this.options.build.templates.map(t => {
return Object.assign({
src: r(this.dir, t.src || t),
dst: t.dst || basename(t.src || t),
custom: true
}, t)
}))
// Interpret and move template files to .nuxt/
2017-05-18 08:47:39 +00:00
return Promise.all(templatesFiles.map(async ({src, dst, options, custom}) => {
// Add template to watchers
this.options.build.watch.push(src)
// Render template to dst
2017-05-18 08:45:15 +00:00
const fileContent = await readFile(src, 'utf8')
const template = _.template(fileContent, {
imports: {
serialize,
hash
}
2016-11-07 01:34:58 +00:00
})
2017-05-18 08:45:15 +00:00
const content = template(Object.assign({}, templateVars, {
options: options || {},
custom,
src,
dst
}))
const path = r(this.dir, '.nuxt', dst)
// Ensure parent dir exits
await mkdirp(dirname(path))
// Write file
await writeFile(path, content, 'utf8')
// Fix webpack loop (https://github.com/webpack/watchpack/issues/25#issuecomment-287789288)
const dateFS = Date.now() / 1000 - 30
return utimes(path, dateFS, dateFS)
2017-05-18 08:47:39 +00:00
}))
2016-11-07 01:34:58 +00:00
}
2016-12-12 13:16:47 +00:00
function createRoutes (files, srcDir) {
2016-12-11 00:46:04 +00:00
let routes = []
files.forEach((file) => {
let keys = file.replace(/^pages/, '').replace(/\.vue$/, '').replace(/\/{2,}/g, '/').split('/').slice(1)
2017-01-19 15:25:55 +00:00
let route = { name: '', path: '', component: r(srcDir, file) }
2016-12-11 00:46:04 +00:00
let parent = routes
keys.forEach((key, i) => {
2016-12-23 16:31:42 +00:00
route.name = route.name ? route.name + '-' + key.replace('_', '') : key.replace('_', '')
route.name += (key === '_') ? 'all' : ''
2016-12-11 00:46:04 +00:00
let child = _.find(parent, { name: route.name })
if (child) {
if (!child.children) {
child.children = []
}
parent = child.children
2016-12-23 16:31:42 +00:00
route.path = ''
2016-12-11 00:46:04 +00:00
} else {
2016-12-23 16:31:42 +00:00
if (key === 'index' && (i + 1) === keys.length) {
route.path += (i > 0 ? '' : '/')
} else {
route.path += '/' + (key === '_' ? '*' : key.replace('_', ':'))
if (key !== '_' && key.indexOf('_') !== -1) {
2016-12-23 16:31:42 +00:00
route.path += '?'
}
}
2016-12-11 00:46:04 +00:00
}
})
2016-12-11 15:40:49 +00:00
// Order Routes path
2016-12-23 14:43:01 +00:00
parent.push(route)
parent.sort((a, b) => {
2017-02-09 00:18:29 +00:00
if (!a.path.length || a.path === '/') { return -1 }
if (!b.path.length || b.path === '/') { return 1 }
var res = 0
var _a = a.path.split('/')
var _b = b.path.split('/')
for (var i = 0; i < _a.length; i++) {
if (res !== 0) { break }
var y = (_a[i].indexOf('*') > -1) ? 2 : (_a[i].indexOf(':') > -1 ? 1 : 0)
var z = (_b[i].indexOf('*') > -1) ? 2 : (_b[i].indexOf(':') > -1 ? 1 : 0)
res = y - z
if (i === _b.length - 1 && res === 0) {
res = 1
}
}
return res === 0 ? -1 : res
2016-12-23 14:43:01 +00:00
})
2016-12-11 00:46:04 +00:00
})
return cleanChildrenRoutes(routes)
}
function cleanChildrenRoutes (routes, isChild = false) {
let start = -1
let routesIndex = []
2016-12-11 00:46:04 +00:00
routes.forEach((route) => {
if (/-index$/.test(route.name) || route.name === 'index') {
// Save indexOf 'index' key in name
let res = route.name.split('-')
let s = res.indexOf('index')
start = (start === -1 || s < start) ? s : start
routesIndex.push(res)
2017-01-11 14:03:42 +00:00
}
})
routes.forEach((route) => {
route.path = (isChild) ? route.path.replace('/', '') : route.path
if (route.path.indexOf('?') > -1) {
let names = route.name.split('-')
let paths = route.path.split('/')
if (!isChild) { paths.shift() } // clean first / for parents
routesIndex.forEach((r) => {
let i = r.indexOf('index') - start // children names
if (i < paths.length) {
for (var a = 0; a <= i; a++) {
if (a === i) { paths[a] = paths[a].replace('?', '') }
if (a < i && names[a] !== r[a]) { break }
}
}
})
route.path = (isChild ? '' : '/') + paths.join('/')
2016-12-20 16:30:43 +00:00
}
2016-12-23 16:31:42 +00:00
route.name = route.name.replace(/-index$/, '')
2016-12-11 00:46:04 +00:00
if (route.children) {
2017-01-11 11:52:39 +00:00
if (route.children.find((child) => child.path === '')) {
delete route.name
}
2016-12-11 00:46:04 +00:00
route.children = cleanChildrenRoutes(route.children, true)
}
})
return routes
}
function flatRoutes (router, path = '', routes = []) {
2017-02-21 12:01:16 +00:00
router.forEach((r) => {
if (!r.path.includes(':') && !r.path.includes('*')) {
if (r.children) {
flatRoutes(r.children, path + r.path + '/', routes)
} else {
routes.push((r.path === '' && path[path.length - 1] === '/' ? path.slice(0, -1) : path) + r.path)
}
2017-02-21 12:01:16 +00:00
}
})
return routes
}
2016-11-07 01:34:58 +00:00
function getWebpackClientConfig () {
2016-12-09 17:54:17 +00:00
return clientWebpackConfig.call(this)
2016-11-07 01:34:58 +00:00
}
function getWebpackServerConfig () {
2016-12-09 17:54:17 +00:00
return serverWebpackConfig.call(this)
2016-11-07 01:34:58 +00:00
}
2017-02-03 14:09:27 +00:00
function createWebpackMiddleware () {
2016-11-07 01:34:58 +00:00
const clientConfig = getWebpackClientConfig.call(this)
2017-03-25 17:59:46 +00:00
const host = process.env.HOST || process.env.npm_package_config_nuxt_host || '127.0.0.1'
const port = process.env.PORT || process.env.npm_package_config_nuxt_port || '3000'
2016-11-07 01:34:58 +00:00
// setup on the fly compilation + hot-reload
2016-12-27 13:53:36 +00:00
clientConfig.entry.app = _.flatten(['webpack-hot-middleware/client?reload=true', clientConfig.entry.app])
2016-11-07 01:34:58 +00:00
clientConfig.plugins.push(
new webpack.HotModuleReplacementPlugin(),
new webpack.NoEmitOnErrorsPlugin(),
new PostCompilePlugin(stats => {
if (!stats.hasErrors() && !stats.hasWarnings()) {
console.log(`> Open http://${host}:${port}\n`) // eslint-disable-line no-console
}
})
2016-11-07 01:34:58 +00:00
)
const clientCompiler = webpack(clientConfig)
this.clientCompiler = clientCompiler
2017-02-03 14:09:27 +00:00
// Add the middleware to the instance context
2016-11-07 01:34:58 +00:00
this.webpackDevMiddleware = pify(require('webpack-dev-middleware')(clientCompiler, {
publicPath: clientConfig.output.publicPath,
stats: webpackStats,
quiet: true,
noInfo: true,
watchOptions: this.options.watchers.webpack
2016-11-07 01:34:58 +00:00
}))
this.webpackHotMiddleware = pify(require('webpack-hot-middleware')(clientCompiler, {
log: () => {}
}))
clientCompiler.plugin('done', () => {
const fs = this.webpackDevMiddleware.fileSystem
const filePath = join(clientConfig.output.path, 'index.html')
if (fs.existsSync(filePath)) {
const template = fs.readFileSync(filePath, 'utf-8')
this.appTemplate = _.template(template, {
interpolate: /{{([\s\S]+?)}}/g
})
}
this.watchHandler()
})
2016-11-07 01:34:58 +00:00
}
function webpackWatchAndUpdate () {
2016-11-07 01:34:58 +00:00
const MFS = require('memory-fs') // <- dependencies of webpack
const serverFS = new MFS()
const clientFS = this.clientCompiler.outputFileSystem
2016-11-07 01:34:58 +00:00
const serverConfig = getWebpackServerConfig.call(this)
const serverCompiler = webpack(serverConfig)
const bundlePath = join(serverConfig.output.path, 'server-bundle.json')
const manifestPath = join(serverConfig.output.path, 'client-manifest.json')
serverCompiler.outputFileSystem = serverFS
const watchHandler = (err) => {
2016-11-07 01:34:58 +00:00
if (err) throw err
const bundleExists = serverFS.existsSync(bundlePath)
const manifestExists = clientFS.existsSync(manifestPath)
2017-05-05 14:47:50 +00:00
if (bundleExists && manifestExists) {
const bundle = serverFS.readFileSync(bundlePath, 'utf8')
const manifest = clientFS.readFileSync(manifestPath, 'utf8')
createRenderer.call(this, JSON.parse(bundle), JSON.parse(manifest))
}
}
this.watchHandler = watchHandler
this.webpackServerWatcher = serverCompiler.watch(this.options.watchers.webpack, watchHandler)
2016-11-07 01:34:58 +00:00
}
function webpackRunClient () {
return new Promise((resolve, reject) => {
const clientConfig = getWebpackClientConfig.call(this)
const clientCompiler = webpack(clientConfig)
clientCompiler.run((err, stats) => {
2016-11-07 01:34:58 +00:00
if (err) return reject(err)
console.log('[nuxt:build:client]\n', stats.toString(webpackStats)) // eslint-disable-line no-console
2017-03-20 16:52:35 +00:00
if (stats.hasErrors()) return reject(new Error('Webpack build exited with errors'))
2016-11-07 01:34:58 +00:00
resolve()
})
})
}
function webpackRunServer () {
return new Promise((resolve, reject) => {
const serverConfig = getWebpackServerConfig.call(this)
const serverCompiler = webpack(serverConfig)
serverCompiler.run((err, stats) => {
if (err) return reject(err)
console.log('[nuxt:build:server]\n', stats.toString(webpackStats)) // eslint-disable-line no-console
2017-03-20 16:52:35 +00:00
if (stats.hasErrors()) return reject(new Error('Webpack build exited with errors'))
2017-03-22 14:47:34 +00:00
const bundlePath = join(serverConfig.output.path, 'server-bundle.json')
const manifestPath = join(serverConfig.output.path, 'client-manifest.json')
2016-11-11 14:30:11 +00:00
readFile(bundlePath, 'utf8')
2017-05-05 14:47:50 +00:00
.then(bundle => {
readFile(manifestPath, 'utf8')
.then(manifest => {
createRenderer.call(this, JSON.parse(bundle), JSON.parse(manifest))
resolve()
2017-05-05 14:47:50 +00:00
})
})
2016-11-07 01:34:58 +00:00
})
})
}
function createRenderer (bundle, manifest) {
2016-11-07 01:34:58 +00:00
// Create bundle renderer to give a fresh context for every request
this.renderer = createBundleRenderer(bundle, Object.assign({
2017-05-02 06:57:39 +00:00
clientManifest: manifest,
2017-05-05 14:47:50 +00:00
runInNewContext: false,
baseDir: this.options.dir
}, this.options.build.ssr))
2016-11-07 01:34:58 +00:00
this.renderToString = pify(this.renderer.renderToString)
this.renderToStream = this.renderer.renderToStream
}
function watchPages () {
2016-12-24 13:15:12 +00:00
const patterns = [
2016-12-24 16:58:52 +00:00
r(this.srcDir, 'pages'),
r(this.srcDir, 'layouts'),
r(this.srcDir, 'store'),
r(this.srcDir, 'middleware'),
2016-12-24 13:15:12 +00:00
r(this.srcDir, 'pages/*.vue'),
r(this.srcDir, 'pages/**/*.vue'),
r(this.srcDir, 'layouts/*.vue'),
r(this.srcDir, 'layouts/**/*.vue')
]
const options = Object.assign({}, this.options.watchers.chokidar, {
ignoreInitial: true
})
2016-12-21 19:51:09 +00:00
/* istanbul ignore next */
const refreshFiles = _.debounce(async () => {
await generateRoutesAndFiles.call(this)
}, 200)
// Watch for internals
this.pagesFilesWatcher = chokidar.watch(patterns, options)
.on('add', refreshFiles)
.on('unlink', refreshFiles)
// Watch for custom provided files
this.customFilesWatcher = chokidar.watch(_.uniq(this.options.build.watch), options)
.on('change', refreshFiles)
}