1 files changed, 283 insertions, 164 deletions
diff --git a/node_modules/webpack/lib/MultiCompiler.js b/node_modules/webpack/lib/MultiCompiler.js
index 8c9b8c183..cdc7fb508 100644
--- a/node_modules/webpack/lib/MultiCompiler.js
+++ b/node_modules/webpack/lib/MultiCompiler.js
@@ -1,164 +1,283 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const Tapable = require("tapable");
-const asyncLib = require("async");
-const MultiWatching = require("./MultiWatching");
-const MultiStats = require("./MultiStats");
-
-module.exports = class MultiCompiler extends Tapable {
-	constructor(compilers) {
-		super();
-		if(!Array.isArray(compilers)) {
-			compilers = Object.keys(compilers).map((name) => {
-				compilers[name].name = name;
-				return compilers[name];
-			});
-		}
-		this.compilers = compilers;
-		let doneCompilers = 0;
-		let compilerStats = [];
-		this.compilers.forEach((compiler, idx) => {
-			let compilerDone = false;
-			compiler.plugin("done", stats => {
-				if(!compilerDone) {
-					compilerDone = true;
-					doneCompilers++;
-				}
-				compilerStats[idx] = stats;
-				if(doneCompilers === this.compilers.length) {
-					this.applyPlugins("done", new MultiStats(compilerStats));
-				}
-			});
-			compiler.plugin("invalid", () => {
-				if(compilerDone) {
-					compilerDone = false;
-					doneCompilers--;
-				}
-				this.applyPlugins("invalid");
-			});
-		}, this);
-	}
-
-	get outputPath() {
-		let commonPath = this.compilers[0].outputPath;
-		for(const compiler of this.compilers) {
-			while(compiler.outputPath.indexOf(commonPath) !== 0 && /[/\\]/.test(commonPath)) {
-				commonPath = commonPath.replace(/[/\\][^/\\]*$/, "");
-			}
-		}
-
-		if(!commonPath && this.compilers[0].outputPath[0] === "/") return "/";
-		return commonPath;
-	}
-
-	get inputFileSystem() {
-		throw new Error("Cannot read inputFileSystem of a MultiCompiler");
-	}
-
-	get outputFileSystem() {
-		throw new Error("Cannot read outputFileSystem of a MultiCompiler");
-	}
-
-	set inputFileSystem(value) {
-		this.compilers.forEach(compiler => {
-			compiler.inputFileSystem = value;
-		});
-	}
-
-	set outputFileSystem(value) {
-		this.compilers.forEach(compiler => {
-			compiler.outputFileSystem = value;
-		});
-	}
-
-	runWithDependencies(compilers, fn, callback) {
-		let fulfilledNames = {};
-		let remainingCompilers = compilers;
-		const isDependencyFulfilled = (d) => fulfilledNames[d];
-		const getReadyCompilers = () => {
-			let readyCompilers = [];
-			let list = remainingCompilers;
-			remainingCompilers = [];
-			for(const c of list) {
-				const ready = !c.dependencies || c.dependencies.every(isDependencyFulfilled);
-				if(ready)
-					readyCompilers.push(c);
-				else
-					remainingCompilers.push(c);
-			}
-			return readyCompilers;
-		};
-		const runCompilers = (callback) => {
-			if(remainingCompilers.length === 0) return callback();
-			asyncLib.map(getReadyCompilers(), (compiler, callback) => {
-				fn(compiler, (err) => {
-					if(err) return callback(err);
-					fulfilledNames[compiler.name] = true;
-					runCompilers(callback);
-				});
-			}, callback);
-		};
-		runCompilers(callback);
-	}
-
-	watch(watchOptions, handler) {
-		let watchings = [];
-		let allStats = this.compilers.map(() => null);
-		let compilerStatus = this.compilers.map(() => false);
-		this.runWithDependencies(this.compilers, (compiler, callback) => {
-			const compilerIdx = this.compilers.indexOf(compiler);
-			let firstRun = true;
-			let watching = compiler.watch(Array.isArray(watchOptions) ? watchOptions[compilerIdx] : watchOptions, (err, stats) => {
-				if(err)
-					handler(err);
-				if(stats) {
-					allStats[compilerIdx] = stats;
-					compilerStatus[compilerIdx] = "new";
-					if(compilerStatus.every(Boolean)) {
-						const freshStats = allStats.filter((s, idx) => {
-							return compilerStatus[idx] === "new";
-						});
-						compilerStatus.fill(true);
-						const multiStats = new MultiStats(freshStats);
-						handler(null, multiStats);
-					}
-				}
-				if(firstRun && !err) {
-					firstRun = false;
-					callback();
-				}
-			});
-			watchings.push(watching);
-		}, () => {
-			// ignore
-		});
-
-		return new MultiWatching(watchings, this);
-	}
-
-	run(callback) {
-		const allStats = this.compilers.map(() => null);
-		this.runWithDependencies(this.compilers, ((compiler, callback) => {
-			const compilerIdx = this.compilers.indexOf(compiler);
-			compiler.run((err, stats) => {
-				if(err) return callback(err);
-				allStats[compilerIdx] = stats;
-				callback();
-			});
-		}), (err) => {
-			if(err) return callback(err);
-			callback(null, new MultiStats(allStats));
-		});
-	}
-
-	purgeInputFileSystem() {
-		this.compilers.forEach((compiler) => {
-			if(compiler.inputFileSystem && compiler.inputFileSystem.purge)
-				compiler.inputFileSystem.purge();
-		});
-	}
-};
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const { Tapable, SyncHook, MultiHook } = require("tapable");
+const asyncLib = require("neo-async");
+const MultiWatching = require("./MultiWatching");
+const MultiStats = require("./MultiStats");
+const ConcurrentCompilationError = require("./ConcurrentCompilationError");
+
+module.exports = class MultiCompiler extends Tapable {
+	constructor(compilers) {
+		super();
+		this.hooks = {
+			done: new SyncHook(["stats"]),
+			invalid: new MultiHook(compilers.map(c => c.hooks.invalid)),
+			run: new MultiHook(compilers.map(c => c.hooks.run)),
+			watchClose: new SyncHook([]),
+			watchRun: new MultiHook(compilers.map(c => c.hooks.watchRun))
+		};
+		if (!Array.isArray(compilers)) {
+			compilers = Object.keys(compilers).map(name => {
+				compilers[name].name = name;
+				return compilers[name];
+			});
+		}
+		this.compilers = compilers;
+		let doneCompilers = 0;
+		let compilerStats = [];
+		let index = 0;
+		for (const compiler of this.compilers) {
+			let compilerDone = false;
+			const compilerIndex = index++;
+			// eslint-disable-next-line no-loop-func
+			compiler.hooks.done.tap("MultiCompiler", stats => {
+				if (!compilerDone) {
+					compilerDone = true;
+					doneCompilers++;
+				}
+				compilerStats[compilerIndex] = stats;
+				if (doneCompilers === this.compilers.length) {
+					this.hooks.done.call(new MultiStats(compilerStats));
+				}
+			});
+			// eslint-disable-next-line no-loop-func
+			compiler.hooks.invalid.tap("MultiCompiler", () => {
+				if (compilerDone) {
+					compilerDone = false;
+					doneCompilers--;
+				}
+			});
+		}
+		this.running = false;
+	}
+
+	get outputPath() {
+		let commonPath = this.compilers[0].outputPath;
+		for (const compiler of this.compilers) {
+			while (
+				compiler.outputPath.indexOf(commonPath) !== 0 &&
+				/[/\\]/.test(commonPath)
+			) {
+				commonPath = commonPath.replace(/[/\\][^/\\]*$/, "");
+			}
+		}
+
+		if (!commonPath && this.compilers[0].outputPath[0] === "/") return "/";
+		return commonPath;
+	}
+
+	get inputFileSystem() {
+		throw new Error("Cannot read inputFileSystem of a MultiCompiler");
+	}
+
+	get outputFileSystem() {
+		throw new Error("Cannot read outputFileSystem of a MultiCompiler");
+	}
+
+	set inputFileSystem(value) {
+		for (const compiler of this.compilers) {
+			compiler.inputFileSystem = value;
+		}
+	}
+
+	set outputFileSystem(value) {
+		for (const compiler of this.compilers) {
+			compiler.outputFileSystem = value;
+		}
+	}
+
+	validateDependencies(callback) {
+		const edges = new Set();
+		const missing = [];
+		const targetFound = compiler => {
+			for (const edge of edges) {
+				if (edge.target === compiler) {
+					return true;
+				}
+			}
+			return false;
+		};
+		const sortEdges = (e1, e2) => {
+			return (
+				e1.source.name.localeCompare(e2.source.name) ||
+				e1.target.name.localeCompare(e2.target.name)
+			);
+		};
+		for (const source of this.compilers) {
+			if (source.dependencies) {
+				for (const dep of source.dependencies) {
+					const target = this.compilers.find(c => c.name === dep);
+					if (!target) {
+						missing.push(dep);
+					} else {
+						edges.add({
+							source,
+							target
+						});
+					}
+				}
+			}
+		}
+		const errors = missing.map(m => `Compiler dependency \`${m}\` not found.`);
+		const stack = this.compilers.filter(c => !targetFound(c));
+		while (stack.length > 0) {
+			const current = stack.pop();
+			for (const edge of edges) {
+				if (edge.source === current) {
+					edges.delete(edge);
+					const target = edge.target;
+					if (!targetFound(target)) {
+						stack.push(target);
+					}
+				}
+			}
+		}
+		if (edges.size > 0) {
+			const lines = Array.from(edges)
+				.sort(sortEdges)
+				.map(edge => `${edge.source.name} -> ${edge.target.name}`);
+			lines.unshift("Circular dependency found in compiler dependencies.");
+			errors.unshift(lines.join("\n"));
+		}
+		if (errors.length > 0) {
+			const message = errors.join("\n");
+			callback(new Error(message));
+			return false;
+		}
+		return true;
+	}
+
+	runWithDependencies(compilers, fn, callback) {
+		const fulfilledNames = new Set();
+		let remainingCompilers = compilers;
+		const isDependencyFulfilled = d => fulfilledNames.has(d);
+		const getReadyCompilers = () => {
+			let readyCompilers = [];
+			let list = remainingCompilers;
+			remainingCompilers = [];
+			for (const c of list) {
+				const ready =
+					!c.dependencies || c.dependencies.every(isDependencyFulfilled);
+				if (ready) {
+					readyCompilers.push(c);
+				} else {
+					remainingCompilers.push(c);
+				}
+			}
+			return readyCompilers;
+		};
+		const runCompilers = callback => {
+			if (remainingCompilers.length === 0) return callback();
+			asyncLib.map(
+				getReadyCompilers(),
+				(compiler, callback) => {
+					fn(compiler, err => {
+						if (err) return callback(err);
+						fulfilledNames.add(compiler.name);
+						runCompilers(callback);
+					});
+				},
+				callback
+			);
+		};
+		runCompilers(callback);
+	}
+
+	watch(watchOptions, handler) {
+		if (this.running) return handler(new ConcurrentCompilationError());
+
+		let watchings = [];
+		let allStats = this.compilers.map(() => null);
+		let compilerStatus = this.compilers.map(() => false);
+		if (this.validateDependencies(handler)) {
+			this.running = true;
+			this.runWithDependencies(
+				this.compilers,
+				(compiler, callback) => {
+					const compilerIdx = this.compilers.indexOf(compiler);
+					let firstRun = true;
+					let watching = compiler.watch(
+						Array.isArray(watchOptions)
+							? watchOptions[compilerIdx]
+							: watchOptions,
+						(err, stats) => {
+							if (err) handler(err);
+							if (stats) {
+								allStats[compilerIdx] = stats;
+								compilerStatus[compilerIdx] = "new";
+								if (compilerStatus.every(Boolean)) {
+									const freshStats = allStats.filter((s, idx) => {
+										return compilerStatus[idx] === "new";
+									});
+									compilerStatus.fill(true);
+									const multiStats = new MultiStats(freshStats);
+									handler(null, multiStats);
+								}
+							}
+							if (firstRun && !err) {
+								firstRun = false;
+								callback();
+							}
+						}
+					);
+					watchings.push(watching);
+				},
+				() => {
+					// ignore
+				}
+			);
+		}
+
+		return new MultiWatching(watchings, this);
+	}
+
+	run(callback) {
+		if (this.running) {
+			return callback(new ConcurrentCompilationError());
+		}
+
+		const finalCallback = (err, stats) => {
+			this.running = false;
+
+			if (callback !== undefined) {
+				return callback(err, stats);
+			}
+		};
+
+		const allStats = this.compilers.map(() => null);
+		if (this.validateDependencies(callback)) {
+			this.running = true;
+			this.runWithDependencies(
+				this.compilers,
+				(compiler, callback) => {
+					const compilerIdx = this.compilers.indexOf(compiler);
+					compiler.run((err, stats) => {
+						if (err) {
+							return callback(err);
+						}
+						allStats[compilerIdx] = stats;
+						callback();
+					});
+				},
+				err => {
+					if (err) {
+						return finalCallback(err);
+					}
+					finalCallback(null, new MultiStats(allStats));
+				}
+			);
+		}
+	}
+
+	purgeInputFileSystem() {
+		for (const compiler of this.compilers) {
+			if (compiler.inputFileSystem && compiler.inputFileSystem.purge) {
+				compiler.inputFileSystem.purge();
+			}
+		}
+	}
+};