webpack-dev-server 2.2.1 → 2.4.2

package/lib/OptionsValidationError.js

@@ -2,69 +2,7 @@
 
 const optionsSchema = require("./optionsSchema.json");
 
-function OptionsValidationError(validationErrors) {
-	Error.call(this);
-	Error.captureStackTrace(this, OptionsValidationError);
-	this.name = "WebpackDevServerOptionsValidationError";
-	this.message = `${"Invalid configuration object. " +
-		"webpack-dev-server has been initialised using a configuration object that does not match the API schema.\n"}${
-		validationErrors.map(function(err) {
-			return ` - ${indent(OptionsValidationError.formatValidationError(err), "   ", false)}`;
-		}).join("\n")}`;
-	this.validationErrors = validationErrors;
-}
-module.exports = OptionsValidationError;
-
-OptionsValidationError.prototype = Object.create(Error.prototype);
-OptionsValidationError.prototype.constructor = OptionsValidationError;
-
-OptionsValidationError.formatValidationError = function formatValidationError(err) {
-	const dataPath = `configuration${err.dataPath}`;
-	switch(err.keyword) {
-		case "additionalProperties":
-			return `${dataPath} has an unknown property '${err.params.additionalProperty}'. These properties are valid:\n${
-				getSchemaPartText(err.parentSchema)}`;
-		case "oneOf":
-		case "anyOf":
-		case "enum":
-			return `${dataPath} should be one of these:\n${
-				getSchemaPartText(err.parentSchema)}`;
-		case "allOf":
-			return `${dataPath} should be:\n${
-				getSchemaPartText(err.parentSchema)}`;
-		case "type":
-			switch(err.params.type) {
-				case "object":
-					return `${dataPath} should be an object.`;
-				case "array":
-					return `${dataPath} should be an array.`;
-				case "string":
-					return `${dataPath} should be a string.`;
-				case "boolean":
-					return `${dataPath} should be a boolean.`;
-				case "number":
-					return `${dataPath} should be a number.`;
-			}
-			return `${dataPath} should be ${err.params.type}:\n${
-				getSchemaPartText(err.parentSchema)}`;
-		case "instanceof":
-			return `${dataPath} should be an instance of ${getSchemaPartText(err.parentSchema)}.`;
-		case "required": // eslint-disable-line no-case-declarations
-			const missingProperty = err.params.missingProperty.replace(/^\./, "");
-			return `${dataPath} misses the property '${missingProperty}'.\n${
-				getSchemaPartText(err.parentSchema, ["properties", missingProperty])}`;
-		case "minLength":
-			if(err.params.limit === 1)
-				return `${dataPath} should not be empty.`;
-			else
-				return `${dataPath} ${err.message}`;
-		default:
-			return `${dataPath} ${err.message} (${JSON.stringify(err, 0, 2)}).\n${
-				getSchemaPartText(err.parentSchema)}`;
-	}
-}
-
-function getSchemaPart(path, parents, additionalPath) {
+const getSchemaPart = (path, parents, additionalPath) => {
 	parents = parents || 0;
 	path = path.split("/");
 	path = path.slice(0, path.length - parents);
@@ -79,9 +17,9 @@ function getSchemaPart(path, parents, additionalPath) {
 			schemaPart = inner;
 	}
 	return schemaPart;
-}
+};
 
-function getSchemaPartText(schemaPart, additionalPath) {
+const getSchemaPartText = (schemaPart, additionalPath) => {
 	if(additionalPath) {
 		for(let i = 0; i < additionalPath.length; i++) {
 			const inner = schemaPart[additionalPath[i]];
@@ -94,28 +32,56 @@ function getSchemaPartText(schemaPart, additionalPath) {
 	if(schemaPart.description)
 		schemaText += `\n${schemaPart.description}`;
 	return schemaText;
-}
+};
 
-function formatSchema(schema, prevSchemas) {
-	prevSchemas = prevSchemas || [];
+const indent = (str, prefix, firstLine) => {
+	if(firstLine) {
+		return prefix + str.replace(/\n(?!$)/g, "\n" + prefix);
+	} else {
+		return str.replace(/\n(?!$)/g, `\n${prefix}`);
+	}
+};
+
+class OptionsValidationError extends Error {
+
+	constructor(validationErrors) {
+		super();
+
+		if(Error.hasOwnProperty("captureStackTrace")) {
+			Error.captureStackTrace(this, this.constructor);
+		}
+		this.name = "WebpackDevServerOptionsValidationError";
 
-	function formatInnerSchema(innerSchema, addSelf) {
-		if(!addSelf) return formatSchema(innerSchema, prevSchemas);
-		if(prevSchemas.indexOf(innerSchema) >= 0) return "(recursive)";
-		return formatSchema(innerSchema, prevSchemas.concat(schema));
+		this.message = "Invalid configuration object. " +
+			"webpack-dev-server has been initialised using a configuration object that does not match the API schema.\n" +
+			validationErrors.map(err => " - " + indent(OptionsValidationError.formatValidationError(err), "   ", false)).join("\n");
+		this.validationErrors = validationErrors;
 	}
-	switch(schema.type) {
-		case "string":
+
+	static formatSchema(schema, prevSchemas) {
+		prevSchemas = prevSchemas || [];
+
+		const formatInnerSchema = (innerSchema, addSelf) => {
+			if(!addSelf) return OptionsValidationError.formatSchema(innerSchema, prevSchemas);
+			if(prevSchemas.indexOf(innerSchema) >= 0) return "(recursive)";
+			return OptionsValidationError.formatSchema(innerSchema, prevSchemas.concat(schema));
+		};
+
+		if(schema.type === "string") {
+			if(schema.minLength === 1)
+				return "non-empty string";
+			else if(schema.minLength > 1)
+				return `string (min length ${schema.minLength})`;
 			return "string";
-		case "boolean":
+		} else if(schema.type === "boolean") {
 			return "boolean";
-		case "number":
+		} else if(schema.type === "number") {
 			return "number";
-		case "object":
+		} else if(schema.type === "object") {
 			if(schema.properties) {
 				const required = schema.required || [];
-				return `object { ${Object.keys(schema.properties).map(function(property) {
-					if(required.indexOf(property) < 0) return `${property}?`;
+				return `object { ${Object.keys(schema.properties).map(property => {
+					if(required.indexOf(property) < 0) return property + "?";
 					return property;
 				}).concat(schema.additionalProperties ? ["..."] : []).join(", ")} }`;
 			}
@@ -123,31 +89,71 @@ function formatSchema(schema, prevSchemas) {
 				return `object { <key>: ${formatInnerSchema(schema.additionalProperties)} }`;
 			}
 			return "object";
-		case "array":
+		} else if(schema.type === "array") {
 			return `[${formatInnerSchema(schema.items)}]`;
+		}
+
+		switch(schema.instanceof) {
+			case "Function":
+				return "function";
+			case "RegExp":
+				return "RegExp";
+		}
+		if(schema.$ref) return formatInnerSchema(getSchemaPart(schema.$ref), true);
+		if(schema.allOf) return schema.allOf.map(formatInnerSchema).join(" & ");
+		if(schema.oneOf) return schema.oneOf.map(formatInnerSchema).join(" | ");
+		if(schema.anyOf) return schema.anyOf.map(formatInnerSchema).join(" | ");
+		if(schema.enum) return schema.enum.map(item => JSON.stringify(item)).join(" | ");
+		return JSON.stringify(schema, 0, 2);
 	}
-	switch(schema.instanceof) {
-		case "Function":
-			return "function";
-		case "RegExp":
-			return "RegExp";
-	}
-	if(schema.$ref) return formatInnerSchema(getSchemaPart(schema.$ref), true);
-	if(schema.allOf) return schema.allOf.map(formatInnerSchema).join(" & ");
-	if(schema.oneOf) return schema.oneOf.map(formatInnerSchema).join(" | ");
-	if(schema.anyOf) return schema.anyOf.map(formatInnerSchema).join(" | ");
-	if(schema.enum) return schema.enum.map(function(item) {
-		return JSON.stringify(item);
-	}).join(" | ");
-	return JSON.stringify(schema, 0, 2);
-}
 
-function indent(str, prefix, firstLine) {
-	if(firstLine) {
-		return prefix + str.replace(/\n(?!$)/g, `\n${prefix}`);
-	} else {
-		return str.replace(/\n(?!$)/g, `\n${prefix}`);
+	static formatValidationError(err) {
+		const dataPath = `configuration${err.dataPath}`;
+		if(err.keyword === "additionalProperties") {
+			return `${dataPath} has an unknown property '${err.params.additionalProperty}'. These properties are valid:\n${getSchemaPartText(err.parentSchema)}`;
+		} else if(err.keyword === "oneOf" || err.keyword === "anyOf") {
+			if(err.children && err.children.length > 0) {
+				return `${dataPath} should be one of these:\n${getSchemaPartText(err.parentSchema)}\n` +
+					`Details:\n${err.children.map(err => " * " + indent(OptionsValidationError.formatValidationError(err), "   ", false)).join("\n")}`;
+			}
+			return `${dataPath} should be one of these:\n${getSchemaPartText(err.parentSchema)}`;
+
+		} else if(err.keyword === "enum") {
+			if(err.parentSchema && err.parentSchema.enum && err.parentSchema.enum.length === 1) {
+				return `${dataPath} should be ${getSchemaPartText(err.parentSchema)}`;
+			}
+			return `${dataPath} should be one of these:\n${getSchemaPartText(err.parentSchema)}`;
+		} else if(err.keyword === "allOf") {
+			return `${dataPath} should be:\n${getSchemaPartText(err.parentSchema)}`;
+		} else if(err.keyword === "type") {
+			switch(err.params.type) {
+				case "object":
+					return `${dataPath} should be an object.`;
+				case "string":
+					return `${dataPath} should be a string.`;
+				case "boolean":
+					return `${dataPath} should be a boolean.`;
+				case "number":
+					return `${dataPath} should be a number.`;
+				case "array":
+					return `${dataPath} should be an array:\n${getSchemaPartText(err.parentSchema)}`;
+			}
+			return `${dataPath} should be ${err.params.type}:\n${getSchemaPartText(err.parentSchema)}`;
+		} else if(err.keyword === "instanceof") {
+			return `${dataPath} should be an instance of ${getSchemaPartText(err.parentSchema)}.`;
+		} else if(err.keyword === "required") {
+			const missingProperty = err.params.missingProperty.replace(/^\./, "");
+			return `${dataPath} misses the property '${missingProperty}'.\n${getSchemaPartText(err.parentSchema, ["properties", missingProperty])}`;
+		} else if(err.keyword === "minLength" || err.keyword === "minItems") {
+			if(err.params.limit === 1)
+				return `${dataPath} should not be empty.`;
+			else
+				return `${dataPath} ${err.message}`;
+		} else {
+			// eslint-disable-line no-fallthrough
+			return `${dataPath} ${err.message} (${JSON.stringify(err, 0, 2)}).\n${getSchemaPartText(err.parentSchema)}`;
+		}
 	}
 }
 
-OptionsValidationError.formatSchema = formatSchema;
+module.exports = OptionsValidationError;

package/lib/Server.js

@@ -34,19 +34,20 @@ function Server(compiler, options) {
 	this.hot = options.hot || options.hotOnly;
 	this.headers = options.headers;
 	this.clientLogLevel = options.clientLogLevel;
+	this.clientOverlay = options.overlay;
 	this.sockets = [];
 	this.contentBaseWatchers = [];
 
 	// Listening for events
-	const invalidPlugin = function() {
+	const invalidPlugin = () => {
 		this.sockWrite(this.sockets, "invalid");
-	}.bind(this);
+	};
 	compiler.plugin("compile", invalidPlugin);
 	compiler.plugin("invalid", invalidPlugin);
-	compiler.plugin("done", function(stats) {
+	compiler.plugin("done", (stats) => {
 		this._sendStats(this.sockets, stats.toJson(clientStats));
 		this._stats = stats;
-	}.bind(this));
+	});
 
 	// Init express server
 	const app = this.app = new express();
@@ -54,27 +55,27 @@ function Server(compiler, options) {
 	// middleware for serving webpack bundle
 	this.middleware = webpackDevMiddleware(compiler, options);
 
-	app.get("/__webpack_dev_server__/live.bundle.js", function(req, res) {
+	app.get("/__webpack_dev_server__/live.bundle.js", (req, res) => {
 		res.setHeader("Content-Type", "application/javascript");
 		fs.createReadStream(path.join(__dirname, "..", "client", "live.bundle.js")).pipe(res);
 	});
 
-	app.get("/__webpack_dev_server__/sockjs.bundle.js", function(req, res) {
+	app.get("/__webpack_dev_server__/sockjs.bundle.js", (req, res) => {
 		res.setHeader("Content-Type", "application/javascript");
 		fs.createReadStream(path.join(__dirname, "..", "client", "sockjs.bundle.js")).pipe(res);
 	});
 
-	app.get("/webpack-dev-server.js", function(req, res) {
+	app.get("/webpack-dev-server.js", (req, res) => {
 		res.setHeader("Content-Type", "application/javascript");
 		fs.createReadStream(path.join(__dirname, "..", "client", "index.bundle.js")).pipe(res);
 	});
 
-	app.get("/webpack-dev-server/*", function(req, res) {
+	app.get("/webpack-dev-server/*", (req, res) => {
 		res.setHeader("Content-Type", "text/html");
 		fs.createReadStream(path.join(__dirname, "..", "client", "live.html")).pipe(res);
 	});
 
-	app.get("/webpack-dev-server", function(req, res) {
+	app.get("/webpack-dev-server", (req, res) => {
 		res.setHeader("Content-Type", "text/html");
 		/* eslint-disable quotes */
 		res.write('<!DOCTYPE html><html><head><meta charset="utf-8"/></head><body>');
@@ -117,7 +118,7 @@ function Server(compiler, options) {
 		/* eslint-enable quotes */
 		writeDirectory(options.publicPath || "/", path);
 		res.end("</body></html>");
-	}.bind(this));
+	});
 
 	let contentBase;
 	if(options.contentBase !== undefined) {
@@ -126,15 +127,18 @@ function Server(compiler, options) {
 		contentBase = process.cwd();
 	}
 
+	// Keep track of websocket proxies for external websocket upgrade.
+	const websocketProxies = [];
+
 	const features = {
-		compress: function() {
+		compress() {
 			if(options.compress) {
 				// Enable gzip compression.
 				app.use(compress());
 			}
 		},
 
-		proxy: function() {
+		proxy() {
 			if(options.proxy) {
 				/**
 				 * Assume a proxy configuration specified as:
@@ -147,7 +151,7 @@ function Server(compiler, options) {
 				 * }
 				 */
 				if(!Array.isArray(options.proxy)) {
-					options.proxy = Object.keys(options.proxy).map(function(context) {
+					options.proxy = Object.keys(options.proxy).map((context) => {
 						let proxyOptions;
 						// For backwards compatibility reasons.
 						const correctedContext = context.replace(/^\*$/, "**").replace(/\/\*$/, "");
@@ -158,7 +162,7 @@ function Server(compiler, options) {
 								target: options.proxy[context]
 							};
 						} else {
-							proxyOptions = options.proxy[context];
+							proxyOptions = Object.assign({}, options.proxy[context]);
 							proxyOptions.context = correctedContext;
 						}
 						proxyOptions.logLevel = proxyOptions.logLevel || "warn";
@@ -167,7 +171,7 @@ function Server(compiler, options) {
 					});
 				}
 
-				const getProxyMiddleware = function(proxyConfig) {
+				const getProxyMiddleware = (proxyConfig) => {
 					const context = proxyConfig.context || proxyConfig.path;
 
 					// It is possible to use the `bypass` method without a `target`.
@@ -193,7 +197,7 @@ function Server(compiler, options) {
 				 *	 }
 				 * ]
 				 */
-				options.proxy.forEach(function(proxyConfigOrCallback) {
+				options.proxy.forEach((proxyConfigOrCallback) => {
 					let proxyConfig;
 					let proxyMiddleware;
 
@@ -204,8 +208,11 @@ function Server(compiler, options) {
 					}
 
 					proxyMiddleware = getProxyMiddleware(proxyConfig);
+					if(proxyConfig.ws) {
+						websocketProxies.push(proxyMiddleware);
+					}
 
-					app.use(function(req, res, next) {
+					app.use((req, res, next) => {
 						if(typeof proxyConfigOrCallback === "function") {
 							const newProxyConfig = proxyConfigOrCallback();
 							if(newProxyConfig !== proxyConfig) {
@@ -229,7 +236,7 @@ function Server(compiler, options) {
 			}
 		},
 
-		historyApiFallback: function() {
+		historyApiFallback() {
 			if(options.historyApiFallback) {
 				// Fall back to /index.html if nothing else matches.
 				app.use(
@@ -238,16 +245,16 @@ function Server(compiler, options) {
 			}
 		},
 
-		contentBaseFiles: function() {
+		contentBaseFiles() {
 			if(Array.isArray(contentBase)) {
-				contentBase.forEach(function(item) {
+				contentBase.forEach((item) => {
 					app.get("*", express.static(item));
 				});
 			} else if(/^(https?:)?\/\//.test(contentBase)) {
 				console.log("Using a URL as contentBase is deprecated and will be removed in the next major version. Please use the proxy option instead.");
 				console.log('proxy: {\n\t"*": "<your current contentBase configuration>"\n}'); // eslint-disable-line quotes
 				// Redirect every request to contentBase
-				app.get("*", function(req, res) {
+				app.get("*", (req, res) => {
 					res.writeHead(302, {
 						"Location": contentBase + req.path + (req._parsedUrl.search || "")
 					});
@@ -257,7 +264,7 @@ function Server(compiler, options) {
 				console.log("Using a number as contentBase is deprecated and will be removed in the next major version. Please use the proxy option instead.");
 				console.log('proxy: {\n\t"*": "//localhost:<your current contentBase configuration>"\n}'); // eslint-disable-line quotes
 				// Redirect every request to the port contentBase
-				app.get("*", function(req, res) {
+				app.get("*", (req, res) => {
 					res.writeHead(302, {
 						"Location": `//localhost:${contentBase}${req.path}${req._parsedUrl.search || ""}`
 					});
@@ -269,9 +276,9 @@ function Server(compiler, options) {
 			}
 		},
 
-		contentBaseIndex: function() {
+		contentBaseIndex() {
 			if(Array.isArray(contentBase)) {
-				contentBase.forEach(function(item) {
+				contentBase.forEach((item) => {
 					app.get("*", serveIndex(item));
 				});
 			} else if(!/^(https?:)?\/\//.test(contentBase) && typeof contentBase !== "number") {
@@ -279,35 +286,35 @@ function Server(compiler, options) {
 			}
 		},
 
-		watchContentBase: function() {
+		watchContentBase: () => {
 			if(/^(https?:)?\/\//.test(contentBase) || typeof contentBase === "number") {
 				throw new Error("Watching remote files is not supported.");
 			} else if(Array.isArray(contentBase)) {
-				contentBase.forEach(function(item) {
+				contentBase.forEach((item) => {
 					this._watch(item);
-				}.bind(this));
+				});
 			} else {
 				this._watch(contentBase);
 			}
-		}.bind(this),
+		},
 
-		middleware: function() {
+		middleware: () => {
 			// include our middleware to ensure it is able to handle '/index.html' request after redirect
 			app.use(this.middleware);
-		}.bind(this),
+		},
 
-		headers: function() {
+		headers: () => {
 			app.all("*", this.setContentHeaders.bind(this));
-		}.bind(this),
+		},
 
-		magicHtml: function() {
+		magicHtml: () => {
 			app.get("*", this.serveMagicHtml.bind(this));
-		}.bind(this),
+		},
 
-		setup: function() {
+		setup: () => {
 			if(typeof options.setup === "function")
 				options.setup(app, this);
-		}.bind(this)
+		}
 	};
 
 	const defaultFeatures = ["setup", "headers", "middleware"];
@@ -317,8 +324,11 @@ function Server(compiler, options) {
 		defaultFeatures.push("contentBaseFiles");
 	if(options.watchContentBase)
 		defaultFeatures.push("watchContentBase");
-	if(options.historyApiFallback)
-		defaultFeatures.push("historyApiFallback", "middleware", "contentBaseFiles");
+	if(options.historyApiFallback) {
+		defaultFeatures.push("historyApiFallback", "middleware");
+		if(contentBase !== false)
+			defaultFeatures.push("contentBaseFiles");
+	}
 	defaultFeatures.push("magicHtml");
 	if(contentBase !== false)
 		defaultFeatures.push("contentBaseIndex");
@@ -326,9 +336,9 @@ function Server(compiler, options) {
 	if(options.compress)
 		defaultFeatures.unshift("compress");
 
-	(options.features || defaultFeatures).forEach(function(feature) {
+	(options.features || defaultFeatures).forEach((feature) => {
 		features[feature]();
-	}, this);
+	});
 
 	if(options.https) {
 		// for keep supporting CLI parameters
@@ -357,6 +367,12 @@ function Server(compiler, options) {
 	} else {
 		this.listeningApp = http.createServer(app);
 	}
+
+	// Proxy websockets without the initial http request
+	// https://github.com/chimurai/http-proxy-middleware#external-websocket-upgrade
+	websocketProxies.forEach(function(wsProxy) {
+		this.listeningApp.on("upgrade", wsProxy.upgrade);
+	}, this);
 }
 
 Server.prototype.use = function() {
@@ -386,25 +402,28 @@ Server.prototype.listen = function() {
 			}
 		}
 	});
-	sockServer.on("connection", function(conn) {
+	sockServer.on("connection", (conn) => {
 		if(!conn) return;
 		this.sockets.push(conn);
 
-		conn.on("close", function() {
+		conn.on("close", () => {
 			const connIndex = this.sockets.indexOf(conn);
 			if(connIndex >= 0) {
 				this.sockets.splice(connIndex, 1);
 			}
-		}.bind(this));
+		});
 
 		if(this.clientLogLevel)
 			this.sockWrite([conn], "log-level", this.clientLogLevel);
 
+		if(this.clientOverlay)
+			this.sockWrite([conn], "overlay", this.clientOverlay);
+
 		if(this.hot) this.sockWrite([conn], "hot");
 
 		if(!this._stats) return;
 		this._sendStats([conn], this._stats.toJson(clientStats), true);
-	}.bind(this));
+	});
 
 	sockServer.installHandlers(this.listeningApp, {
 		prefix: "/sockjs-node"
@@ -413,22 +432,22 @@ Server.prototype.listen = function() {
 }
 
 Server.prototype.close = function(callback) {
-	this.sockets.forEach(function(sock) {
+	this.sockets.forEach((sock) => {
 		sock.close();
 	});
 	this.sockets = [];
-	this.listeningApp.close(function() {
+	this.listeningApp.close(() => {
 		this.middleware.close(callback);
-	}.bind(this));
+	});
 
-	this.contentBaseWatchers.forEach(function(watcher) {
+	this.contentBaseWatchers.forEach((watcher) => {
 		watcher.close();
 	});
 	this.contentBaseWatchers = [];
 }
 
 Server.prototype.sockWrite = function(sockets, type, data) {
-	sockets.forEach(function(sock) {
+	sockets.forEach((sock) => {
 		sock.write(JSON.stringify({
 			type: type,
 			data: data
@@ -460,9 +479,7 @@ Server.prototype._sendStats = function(sockets, stats, force) {
 		stats &&
 		(!stats.errors || stats.errors.length === 0) &&
 		stats.assets &&
-		stats.assets.every(function(asset) {
-			return !asset.emitted;
-		})
+		stats.assets.every((asset) => !asset.emitted)
 	)
 		return this.sockWrite(sockets, "still-ok");
 	this.sockWrite(sockets, "hash", stats.hash);
@@ -475,9 +492,9 @@ Server.prototype._sendStats = function(sockets, stats, force) {
 }
 
 Server.prototype._watch = function(path) {
-	const watcher = chokidar.watch(path).on("change", function() {
+	const watcher = chokidar.watch(path).on("change", () => {
 		this.sockWrite(this.sockets, "content-changed");
-	}.bind(this))
+	});
 
 	this.contentBaseWatchers.push(watcher);
 }
@@ -486,4 +503,7 @@ Server.prototype.invalidate = function() {
 	if(this.middleware) this.middleware.invalidate();
 }
 
+// Export this logic, so that other implementations, like task-runners can use it
+Server.addDevServerEntrypoints = require("./util/addDevServerEntrypoints");
+
 module.exports = Server;

package/lib/optionsSchema.json

@@ -34,7 +34,14 @@
     },
     "port": {
       "description": "The port the server listens to.",
-      "type": "number"
+      "anyOf": [
+        {
+          "type": "number"
+        },
+        {
+          "type": "string"
+        }
+      ]
     },
     "socket": {
       "description": "The Unix socket to listen to (instead of on a host).",
@@ -60,6 +67,25 @@
         "error"
       ]
     },
+    "overlay": {
+      "description": "Shows an error overlay in browser.",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "errors": {
+              "type": "boolean"
+            },
+            "warnings": {
+              "type": "boolean"
+            }
+          }
+        }
+      ]
+    },
     "key": {
       "description": "The contents of a SSL key.",
       "anyOf": [

package/lib/util/addDevServerEntrypoints.js

@@ -0,0 +1,26 @@
+"use strict";
+const createDomain = require("./createDomain");
+
+module.exports = function addDevServerEntrypoints(webpackOptions, devServerOptions) {
+	if(devServerOptions.inline !== false) {
+		const domain = createDomain(devServerOptions);
+		const devClient = [`${require.resolve("../../client/")}?${domain}`];
+
+		if(devServerOptions.hotOnly)
+			devClient.push("webpack/hot/only-dev-server");
+		else if(devServerOptions.hot)
+			devClient.push("webpack/hot/dev-server");
+
+		[].concat(webpackOptions).forEach((wpOpt) => {
+			if(typeof wpOpt.entry === "object" && !Array.isArray(wpOpt.entry)) {
+				Object.keys(wpOpt.entry).forEach((key) => {
+					wpOpt.entry[key] = devClient.concat(wpOpt.entry[key]);
+				});
+			} else if(typeof wpOpt.entry === "function") {
+				wpOpt.entry = wpOpt.entry(devClient);
+			} else {
+				wpOpt.entry = devClient.concat(wpOpt.entry);
+			}
+		});
+	}
+};