From 363723fc84f7b8477592e0105aeb331ec9a017af Mon Sep 17 00:00:00 2001
From: Florian Dold <florian.dold@gmail.com>
Date: Mon, 14 Aug 2017 05:01:11 +0200
Subject: node_modules

---
 node_modules/webpack/lib/MultiCompiler.js | 284 ++++++++++++++----------------
 1 file changed, 136 insertions(+), 148 deletions(-)

(limited to 'node_modules/webpack/lib/MultiCompiler.js')

diff --git a/node_modules/webpack/lib/MultiCompiler.js b/node_modules/webpack/lib/MultiCompiler.js
index d04ef778f..8c9b8c183 100644
--- a/node_modules/webpack/lib/MultiCompiler.js
+++ b/node_modules/webpack/lib/MultiCompiler.js
@@ -2,175 +2,163 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-var Tapable = require("tapable");
-var asyncLib = require("async");
-var MultiWatching = require("./MultiWatching");
-var MultiStats = require("./MultiStats");
+"use strict";
 
-function MultiCompiler(compilers) {
-	Tapable.call(this);
-	if(!Array.isArray(compilers)) {
-		compilers = Object.keys(compilers).map(function(name) {
-			compilers[name].name = name;
-			return compilers[name];
-		});
-	}
-	this.compilers = compilers;
+const Tapable = require("tapable");
+const asyncLib = require("async");
+const MultiWatching = require("./MultiWatching");
+const MultiStats = require("./MultiStats");
 
-	function delegateProperty(name) {
-		Object.defineProperty(this, name, {
-			configurable: false,
-			get: function() {
-				throw new Error("Cannot read " + name + " of a MultiCompiler");
-			},
-			set: function(value) {
-				this.compilers.forEach(function(compiler) {
-					compiler[name] = value;
-				});
-			}.bind(this)
-		});
+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);
 	}
-	delegateProperty.call(this, "outputFileSystem");
-	delegateProperty.call(this, "inputFileSystem");
 
-	Object.defineProperty(this, "outputPath", {
-		configurable: false,
-		get: function() {
-			var commonPath = compilers[0].outputPath;
-			for(var i = 1; i < compilers.length; i++) {
-				while(compilers[i].outputPath.indexOf(commonPath) !== 0 && /[\/\\]/.test(commonPath)) {
-					commonPath = commonPath.replace(/[\/\\][^\/\\]*$/, "");
-				}
+	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 && compilers[0].outputPath[0] === "/") return "/";
-			return commonPath;
 		}
-	});
 
-	var doneCompilers = 0;
-	var compilerStats = [];
-	this.compilers.forEach(function(compiler, idx) {
-		var compilerDone = false;
-		compiler.plugin("done", function(stats) {
-			if(!compilerDone) {
-				compilerDone = true;
-				doneCompilers++;
-			}
-			compilerStats[idx] = stats;
-			if(doneCompilers === this.compilers.length) {
-				this.applyPlugins("done", new MultiStats(compilerStats));
-			}
-		}.bind(this));
-		compiler.plugin("invalid", function() {
-			if(compilerDone) {
-				compilerDone = false;
-				doneCompilers--;
-			}
-			this.applyPlugins("invalid");
-		}.bind(this));
-	}, this);
-}
-module.exports = MultiCompiler;
+		if(!commonPath && this.compilers[0].outputPath[0] === "/") return "/";
+		return commonPath;
+	}
 
-MultiCompiler.prototype = Object.create(Tapable.prototype);
-MultiCompiler.prototype.constructor = MultiCompiler;
+	get inputFileSystem() {
+		throw new Error("Cannot read inputFileSystem of a MultiCompiler");
+	}
 
-function runWithDependencies(compilers, fn, callback) {
-	var fulfilledNames = {};
-	var remainingCompilers = compilers;
+	get outputFileSystem() {
+		throw new Error("Cannot read outputFileSystem of a MultiCompiler");
+	}
 
-	function isDependencyFulfilled(d) {
-		return fulfilledNames[d];
+	set inputFileSystem(value) {
+		this.compilers.forEach(compiler => {
+			compiler.inputFileSystem = value;
+		});
 	}
 
-	function getReadyCompilers() {
-		var readyCompilers = [];
-		var list = remainingCompilers;
-		remainingCompilers = [];
-		for(var i = 0; i < list.length; i++) {
-			var c = list[i];
-			var ready = !c.dependencies || c.dependencies.every(isDependencyFulfilled);
-			if(ready)
-				readyCompilers.push(c);
-			else
-				remainingCompilers.push(c);
-		}
-		return readyCompilers;
+	set outputFileSystem(value) {
+		this.compilers.forEach(compiler => {
+			compiler.outputFileSystem = value;
+		});
 	}
 
-	function runCompilers(callback) {
-		if(remainingCompilers.length === 0) return callback();
-		asyncLib.map(getReadyCompilers(), function(compiler, callback) {
-			fn(compiler, function(err) {
-				if(err) return callback(err);
-				fulfilledNames[compiler.name] = true;
-				runCompilers(callback);
-			});
-		}, callback);
+	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);
 	}
-	runCompilers(callback);
-}
 
-MultiCompiler.prototype.watch = function(watchOptions, handler) {
-	var watchings = [];
-	var allStats = this.compilers.map(function() {
-		return null;
-	});
-	var compilerStatus = this.compilers.map(function() {
-		return false;
-	});
-	runWithDependencies(this.compilers, function(compiler, callback) {
-		var compilerIdx = this.compilers.indexOf(compiler);
-		var firstRun = true;
-		var watching = compiler.watch(Array.isArray(watchOptions) ? watchOptions[compilerIdx] : watchOptions, function(err, stats) {
-			if(err)
-				handler(err);
-			if(stats) {
-				allStats[compilerIdx] = stats;
-				compilerStatus[compilerIdx] = "new";
-				if(compilerStatus.every(Boolean)) {
-					var freshStats = allStats.filter(function(s, idx) {
-						return compilerStatus[idx] === "new";
-					});
-					compilerStatus.fill(true);
-					var multiStats = new MultiStats(freshStats);
-					handler(null, multiStats);
+	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();
-			}
+				if(firstRun && !err) {
+					firstRun = false;
+					callback();
+				}
+			});
+			watchings.push(watching);
+		}, () => {
+			// ignore
 		});
-		watchings.push(watching);
-	}.bind(this), function() {
-		// ignore
-	});
 
-	return new MultiWatching(watchings, this);
-};
-
-MultiCompiler.prototype.run = function(callback) {
-	var allStats = this.compilers.map(function() {
-		return null;
-	});
+		return new MultiWatching(watchings, this);
+	}
 
-	runWithDependencies(this.compilers, function(compiler, callback) {
-		var compilerIdx = this.compilers.indexOf(compiler);
-		compiler.run(function(err, stats) {
+	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);
-			allStats[compilerIdx] = stats;
-			callback();
+			callback(null, new MultiStats(allStats));
 		});
-	}.bind(this), function(err) {
-		if(err) return callback(err);
-		callback(null, new MultiStats(allStats));
-	});
-};
+	}
 
-MultiCompiler.prototype.purgeInputFileSystem = function() {
-	this.compilers.forEach(function(compiler) {
-		if(compiler.inputFileSystem && compiler.inputFileSystem.purge)
-			compiler.inputFileSystem.purge();
-	});
+	purgeInputFileSystem() {
+		this.compilers.forEach((compiler) => {
+			if(compiler.inputFileSystem && compiler.inputFileSystem.purge)
+				compiler.inputFileSystem.purge();
+		});
+	}
 };
-- 
cgit v1.2.3