webpack 3.6.0 → 3.8.1

package/lib/MultiCompiler.js

@@ -1,164 +1,164 @@
-/*
-	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 = 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();
+		});
+	}
+};

package/lib/MultiEntryPlugin.js

@@ -1,39 +1,39 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const MultiEntryDependency = require("./dependencies/MultiEntryDependency");
-const SingleEntryDependency = require("./dependencies/SingleEntryDependency");
-const MultiModuleFactory = require("./MultiModuleFactory");
-
-module.exports = class MultiEntryPlugin {
-	constructor(context, entries, name) {
-		this.context = context;
-		this.entries = entries;
-		this.name = name;
-	}
-
-	apply(compiler) {
-		compiler.plugin("compilation", (compilation, params) => {
-			const multiModuleFactory = new MultiModuleFactory();
-			const normalModuleFactory = params.normalModuleFactory;
-
-			compilation.dependencyFactories.set(MultiEntryDependency, multiModuleFactory);
-			compilation.dependencyFactories.set(SingleEntryDependency, normalModuleFactory);
-		});
-		compiler.plugin("make", (compilation, callback) => {
-			const dep = MultiEntryPlugin.createDependency(this.entries, this.name);
-			compilation.addEntry(this.context, dep, this.name, callback);
-		});
-	}
-
-	static createDependency(entries, name) {
-		return new MultiEntryDependency(entries.map((e, idx) => {
-			const dep = new SingleEntryDependency(e);
-			dep.loc = name + ":" + (100000 + idx);
-			return dep;
-		}), name);
-	}
-};
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const MultiEntryDependency = require("./dependencies/MultiEntryDependency");
+const SingleEntryDependency = require("./dependencies/SingleEntryDependency");
+const MultiModuleFactory = require("./MultiModuleFactory");
+
+module.exports = class MultiEntryPlugin {
+	constructor(context, entries, name) {
+		this.context = context;
+		this.entries = entries;
+		this.name = name;
+	}
+
+	apply(compiler) {
+		compiler.plugin("compilation", (compilation, params) => {
+			const multiModuleFactory = new MultiModuleFactory();
+			const normalModuleFactory = params.normalModuleFactory;
+
+			compilation.dependencyFactories.set(MultiEntryDependency, multiModuleFactory);
+			compilation.dependencyFactories.set(SingleEntryDependency, normalModuleFactory);
+		});
+		compiler.plugin("make", (compilation, callback) => {
+			const dep = MultiEntryPlugin.createDependency(this.entries, this.name);
+			compilation.addEntry(this.context, dep, this.name, callback);
+		});
+	}
+
+	static createDependency(entries, name) {
+		return new MultiEntryDependency(entries.map((e, idx) => {
+			const dep = new SingleEntryDependency(e);
+			dep.loc = name + ":" + (100000 + idx);
+			return dep;
+		}), name);
+	}
+};

package/lib/MultiModuleFactory.js

@@ -1,19 +1,19 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const Tapable = require("tapable");
-const MultiModule = require("./MultiModule");
-
-module.exports = class MultiModuleFactory extends Tapable {
-	constructor() {
-		super();
-	}
-
-	create(data, callback) {
-		const dependency = data.dependencies[0];
-		callback(null, new MultiModule(data.context, dependency.dependencies, dependency.name));
-	}
-};
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Tapable = require("tapable");
+const MultiModule = require("./MultiModule");
+
+module.exports = class MultiModuleFactory extends Tapable {
+	constructor() {
+		super();
+	}
+
+	create(data, callback) {
+		const dependency = data.dependencies[0];
+		callback(null, new MultiModule(data.context, dependency.dependencies, dependency.name));
+	}
+};

package/lib/MultiStats.js

@@ -1,79 +1,79 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const Stats = require("./Stats");
-
-const optionOrFallback = (optionValue, fallbackValue) => optionValue !== undefined ? optionValue : fallbackValue;
-
-class MultiStats {
-	constructor(stats) {
-		this.stats = stats;
-		this.hash = stats.map(stat => stat.hash).join("");
-	}
-
-	hasErrors() {
-		return this.stats.map((stat) => stat.hasErrors()).reduce((a, b) => a || b, false);
-	}
-
-	hasWarnings() {
-		return this.stats.map((stat) => stat.hasWarnings()).reduce((a, b) => a || b, false);
-	}
-
-	toJson(options, forToString) {
-		if(typeof options === "boolean" || typeof options === "string") {
-			options = Stats.presetToOptions(options);
-		} else if(!options) {
-			options = {};
-		}
-		const jsons = this.stats.map((stat, idx) => {
-			const childOptions = Stats.getChildOptions(options, idx);
-			const obj = stat.toJson(childOptions, forToString);
-			obj.name = stat.compilation && stat.compilation.name;
-			return obj;
-		});
-		const showVersion = typeof options.version === "undefined" ? jsons.every(j => j.version) : options.version !== false;
-		const showHash = typeof options.hash === "undefined" ? jsons.every(j => j.hash) : options.hash !== false;
-		jsons.forEach(j => {
-			if(showVersion)
-				delete j.version;
-		});
-		const obj = {
-			errors: jsons.reduce((arr, j) => {
-				return arr.concat(j.errors.map(msg => {
-					return `(${j.name}) ${msg}`;
-				}));
-			}, []),
-			warnings: jsons.reduce((arr, j) => {
-				return arr.concat(j.warnings.map(msg => {
-					return `(${j.name}) ${msg}`;
-				}));
-			}, [])
-		};
-		if(showVersion)
-			obj.version = require("../package.json").version;
-		if(showHash)
-			obj.hash = this.hash;
-		if(options.children !== false)
-			obj.children = jsons;
-		return obj;
-	}
-
-	toString(options) {
-		if(typeof options === "boolean" || typeof options === "string") {
-			options = Stats.presetToOptions(options);
-		} else if(!options) {
-			options = {};
-		}
-
-		const useColors = optionOrFallback(options.colors, false);
-
-		const obj = this.toJson(options, true);
-
-		return Stats.jsonToString(obj, useColors);
-	}
-}
-
-module.exports = MultiStats;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Stats = require("./Stats");
+
+const optionOrFallback = (optionValue, fallbackValue) => optionValue !== undefined ? optionValue : fallbackValue;
+
+class MultiStats {
+	constructor(stats) {
+		this.stats = stats;
+		this.hash = stats.map(stat => stat.hash).join("");
+	}
+
+	hasErrors() {
+		return this.stats.map((stat) => stat.hasErrors()).reduce((a, b) => a || b, false);
+	}
+
+	hasWarnings() {
+		return this.stats.map((stat) => stat.hasWarnings()).reduce((a, b) => a || b, false);
+	}
+
+	toJson(options, forToString) {
+		if(typeof options === "boolean" || typeof options === "string") {
+			options = Stats.presetToOptions(options);
+		} else if(!options) {
+			options = {};
+		}
+		const jsons = this.stats.map((stat, idx) => {
+			const childOptions = Stats.getChildOptions(options, idx);
+			const obj = stat.toJson(childOptions, forToString);
+			obj.name = stat.compilation && stat.compilation.name;
+			return obj;
+		});
+		const showVersion = typeof options.version === "undefined" ? jsons.every(j => j.version) : options.version !== false;
+		const showHash = typeof options.hash === "undefined" ? jsons.every(j => j.hash) : options.hash !== false;
+		jsons.forEach(j => {
+			if(showVersion)
+				delete j.version;
+		});
+		const obj = {
+			errors: jsons.reduce((arr, j) => {
+				return arr.concat(j.errors.map(msg => {
+					return `(${j.name}) ${msg}`;
+				}));
+			}, []),
+			warnings: jsons.reduce((arr, j) => {
+				return arr.concat(j.warnings.map(msg => {
+					return `(${j.name}) ${msg}`;
+				}));
+			}, [])
+		};
+		if(showVersion)
+			obj.version = require("../package.json").version;
+		if(showHash)
+			obj.hash = this.hash;
+		if(options.children !== false)
+			obj.children = jsons;
+		return obj;
+	}
+
+	toString(options) {
+		if(typeof options === "boolean" || typeof options === "string") {
+			options = Stats.presetToOptions(options);
+		} else if(!options) {
+			options = {};
+		}
+
+		const useColors = optionOrFallback(options.colors, false);
+
+		const obj = this.toJson(options, true);
+
+		return Stats.jsonToString(obj, useColors);
+	}
+}
+
+module.exports = MultiStats;

package/lib/MultiWatching.js

@@ -1,32 +1,32 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const asyncLib = require("async");
-
-class MultiWatching {
-	constructor(watchings, compiler) {
-		this.watchings = watchings;
-		this.compiler = compiler;
-	}
-
-	invalidate() {
-		this.watchings.forEach((watching) => watching.invalidate());
-	}
-
-	close(callback) {
-		if(callback === undefined) callback = () => { /*do nothing*/ };
-
-		asyncLib.forEach(this.watchings, (watching, finishedCallback) => {
-			watching.close(finishedCallback);
-		}, err => {
-			this.compiler.applyPlugins("watch-close");
-			callback(err);
-		});
-
-	}
-}
-
-module.exports = MultiWatching;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const asyncLib = require("async");
+
+class MultiWatching {
+	constructor(watchings, compiler) {
+		this.watchings = watchings;
+		this.compiler = compiler;
+	}
+
+	invalidate() {
+		this.watchings.forEach((watching) => watching.invalidate());
+	}
+
+	close(callback) {
+		if(callback === undefined) callback = () => { /*do nothing*/ };
+
+		asyncLib.forEach(this.watchings, (watching, finishedCallback) => {
+			watching.close(finishedCallback);
+		}, err => {
+			this.compiler.applyPlugins("watch-close");
+			callback(err);
+		});
+
+	}
+}
+
+module.exports = MultiWatching;