1
0
Fork 0
mirror of https://github.com/terribleplan/next.js.git synced 2024-01-19 02:48:18 +00:00
next.js/server/hot-reloader.js

202 lines
5.5 KiB
JavaScript
Raw Normal View History

2016-10-24 15:20:50 +00:00
import { join, relative, sep } from 'path'
import webpackDevMiddleware from 'webpack-dev-middleware'
import webpackHotMiddleware from 'webpack-hot-middleware'
import isWindowsBash from 'is-windows-bash'
2016-10-17 07:05:46 +00:00
import webpack from './build/webpack'
import clean from './build/clean'
import readPage from './read-page'
2016-10-14 15:05:08 +00:00
export default class HotReloader {
2016-12-21 14:39:08 +00:00
constructor (dir, { quiet } = {}) {
2016-10-17 07:05:46 +00:00
this.dir = dir
2016-12-21 14:39:08 +00:00
this.quiet = quiet
this.middlewares = []
this.webpackDevMiddleware = null
this.webpackHotMiddleware = null
this.initialized = false
2016-10-19 12:41:45 +00:00
this.stats = null
this.compilationErrors = null
2016-10-24 07:22:15 +00:00
this.prevAssets = null
this.prevChunkNames = null
this.prevFailedChunkNames = null
this.prevChunkHashes = null
2016-10-17 07:05:46 +00:00
}
async run (req, res) {
for (const fn of this.middlewares) {
await new Promise((resolve, reject) => {
fn(req, res, (err) => {
if (err) return reject(err)
resolve()
})
})
}
2016-10-17 07:05:46 +00:00
}
async start () {
const [compiler] = await Promise.all([
2016-12-21 14:39:08 +00:00
webpack(this.dir, { dev: true, quiet: this.quiet }),
clean(this.dir)
])
this.prepareMiddlewares(compiler)
2016-10-19 12:41:45 +00:00
this.stats = await this.waitUntilValid()
2016-10-17 07:05:46 +00:00
}
async stop () {
if (this.webpackDevMiddleware) {
return new Promise((resolve, reject) => {
this.webpackDevMiddleware.close((err) => {
if (err) return reject(err)
resolve()
})
})
}
}
async prepareMiddlewares (compiler) {
2016-10-15 19:49:42 +00:00
compiler.plugin('after-emit', (compilation, callback) => {
const { assets } = compilation
2016-10-24 07:22:15 +00:00
if (this.prevAssets) {
for (const f of Object.keys(assets)) {
deleteCache(assets[f].existsAt)
}
for (const f of Object.keys(this.prevAssets)) {
if (!assets[f]) {
deleteCache(this.prevAssets[f].existsAt)
}
2016-10-23 16:42:13 +00:00
}
}
this.prevAssets = assets
2016-10-24 07:22:15 +00:00
2016-10-15 19:49:42 +00:00
callback()
})
2016-10-14 15:05:08 +00:00
2016-10-19 12:41:45 +00:00
compiler.plugin('done', (stats) => {
const { compilation } = stats
const chunkNames = new Set(compilation.chunks.map((c) => c.name))
const failedChunkNames = new Set(compilation.errors
.map((e) => e.module.reasons)
.reduce((a, b) => a.concat(b), [])
.map((r) => r.module.chunks)
.reduce((a, b) => a.concat(b), [])
.map((c) => c.name))
const chunkHashes = new Map(compilation.chunks.map((c) => [c.name, c.hash]))
if (this.initialized) {
// detect chunks which have to be replaced with a new template
// e.g, pages/index.js <-> pages/_error.js
const added = diff(chunkNames, this.prevChunkNames)
const removed = diff(this.prevChunkNames, chunkNames)
const succeeded = diff(this.prevFailedChunkNames, failedChunkNames)
// reload all failed chunks to replace the templace to the error ones,
// and to update error content
const failed = failedChunkNames
2016-10-24 15:20:50 +00:00
const rootDir = join('bundles', 'pages')
for (const n of new Set([...added, ...removed, ...failed, ...succeeded])) {
2016-10-24 15:20:50 +00:00
const route = toRoute(relative(rootDir, n))
this.send('reload', route)
2016-10-24 07:22:15 +00:00
}
for (const [n, hash] of chunkHashes) {
if (!this.prevChunkHashes.has(n)) continue
if (this.prevChunkHashes.get(n) === hash) continue
const route = toRoute(relative(rootDir, n))
// notify change to recover from runtime errors
this.send('change', route)
}
2016-10-24 07:22:15 +00:00
}
2016-10-24 15:20:50 +00:00
this.initialized = true
this.stats = stats
this.compilationErrors = null
this.prevChunkNames = chunkNames
this.prevFailedChunkNames = failedChunkNames
this.prevChunkHashes = chunkHashes
2016-10-19 12:41:45 +00:00
})
const ignored = [
/(^|[/\\])\../, // .dotfiles
/node_modules/
]
const windowsSettings = isWindowsBash() ? {
lazy: false,
watchOptions: {
ignored,
aggregateTimeout: 300,
poll: true
}
} : {}
this.webpackDevMiddleware = webpackDevMiddleware(compiler, {
publicPath: '/_webpack/',
2016-10-17 07:05:46 +00:00
noInfo: true,
2016-11-16 02:46:58 +00:00
quiet: true,
2016-12-02 01:21:21 +00:00
clientLogLevel: 'warning',
watchOptions: { ignored },
...windowsSettings
2016-10-17 07:05:46 +00:00
})
this.webpackHotMiddleware = webpackHotMiddleware(compiler, { log: false })
this.middlewares = [
this.webpackDevMiddleware,
this.webpackHotMiddleware
]
2016-10-14 15:05:08 +00:00
}
2016-10-19 12:41:45 +00:00
waitUntilValid () {
return new Promise((resolve) => {
this.webpackDevMiddleware.waitUntilValid(resolve)
2016-10-14 15:05:08 +00:00
})
}
2016-10-19 12:41:45 +00:00
getCompilationErrors () {
if (!this.compilationErrors) {
this.compilationErrors = new Map()
2016-10-24 15:20:50 +00:00
2016-10-19 12:41:45 +00:00
if (this.stats.hasErrors()) {
2016-10-24 15:20:50 +00:00
const { compiler, errors } = this.stats.compilation
for (const err of errors) {
for (const r of err.module.reasons) {
for (const c of r.module.chunks) {
// get the path of the bundle file
const path = join(compiler.outputPath, c.name)
const errors = this.compilationErrors.get(path) || []
this.compilationErrors.set(path, errors.concat([err]))
}
}
2016-10-19 12:41:45 +00:00
}
}
}
return this.compilationErrors
}
send (action, ...args) {
this.webpackHotMiddleware.publish({ action, data: args })
2016-10-24 07:22:15 +00:00
}
2016-10-14 15:05:08 +00:00
}
2016-10-19 12:41:45 +00:00
function deleteCache (path) {
delete require.cache[path]
delete readPage.cache[path]
2016-10-19 12:41:45 +00:00
}
2016-10-24 07:22:15 +00:00
function diff (a, b) {
return new Set([...a].filter((v) => !b.has(v)))
}
2016-10-24 15:20:50 +00:00
function toRoute (file) {
const f = sep === '\\' ? file.replace(/\\/g, '/') : file
return ('/' + f).replace(/(\/index)?\.js$/, '') || '/'
}