webpack 3.5.3 → 3.6.0

package/lib/Compilation.js

@@ -22,6 +22,7 @@ const Dependency = require("./Dependency");
 const ChunkRenderError = require("./ChunkRenderError");
 const CachedSource = require("webpack-sources").CachedSource;
 const Stats = require("./Stats");
+const Semaphore = require("./util/Semaphore");
 
 function byId(a, b) {
 	if(a.id < b.id) return -1;
@@ -62,6 +63,8 @@ class Compilation extends Tapable {
 		this.hotUpdateChunkTemplate = new HotUpdateChunkTemplate(this.outputOptions);
 		this.moduleTemplate = new ModuleTemplate(this.outputOptions);
 
+		this.semaphore = new Semaphore(options.parallelism || 100);
+
 		this.entries = [];
 		this.preparedChunks = [];
 		this.entrypoints = {};
@@ -229,120 +232,128 @@ class Compilation extends Tapable {
 				callback();
 			};
 
-			const factory = item[0];
-			factory.create({
-				contextInfo: {
-					issuer: module.nameForCondition && module.nameForCondition(),
-					compiler: _this.compiler.name
-				},
-				context: module.context,
-				dependencies: dependencies
-			}, function factoryCallback(err, dependentModule) {
-				let afterFactory;
-
-				function isOptional() {
-					return dependencies.filter(d => !d.optional).length === 0;
-				}
+			_this.semaphore.acquire(() => {
+				const factory = item[0];
+				factory.create({
+					contextInfo: {
+						issuer: module.nameForCondition && module.nameForCondition(),
+						compiler: _this.compiler.name
+					},
+					context: module.context,
+					dependencies: dependencies
+				}, function factoryCallback(err, dependentModule) {
+					let afterFactory;
+
+					function isOptional() {
+						return dependencies.filter(d => !d.optional).length === 0;
+					}
 
-				function errorOrWarningAndCallback(err) {
-					if(isOptional()) {
-						return warningAndCallback(err);
-					} else {
-						return errorAndCallback(err);
+					function errorOrWarningAndCallback(err) {
+						if(isOptional()) {
+							return warningAndCallback(err);
+						} else {
+							return errorAndCallback(err);
+						}
 					}
-				}
 
-				function iterationDependencies(depend) {
-					for(let index = 0; index < depend.length; index++) {
-						const dep = depend[index];
-						dep.module = dependentModule;
-						dependentModule.addReason(module, dep);
+					function iterationDependencies(depend) {
+						for(let index = 0; index < depend.length; index++) {
+							const dep = depend[index];
+							dep.module = dependentModule;
+							dependentModule.addReason(module, dep);
+						}
 					}
-				}
 
-				if(err) {
-					return errorOrWarningAndCallback(new ModuleNotFoundError(module, err, dependencies));
-				}
-				if(!dependentModule) {
-					return process.nextTick(callback);
-				}
-				if(_this.profile) {
-					if(!dependentModule.profile) {
-						dependentModule.profile = {};
+					if(err) {
+						_this.semaphore.release();
+						return errorOrWarningAndCallback(new ModuleNotFoundError(module, err, dependencies));
+					}
+					if(!dependentModule) {
+						_this.semaphore.release();
+						return process.nextTick(callback);
+					}
+					if(_this.profile) {
+						if(!dependentModule.profile) {
+							dependentModule.profile = {};
+						}
+						afterFactory = Date.now();
+						dependentModule.profile.factory = afterFactory - start;
 					}
-					afterFactory = Date.now();
-					dependentModule.profile.factory = afterFactory - start;
-				}
 
-				dependentModule.issuer = module;
-				const newModule = _this.addModule(dependentModule, cacheGroup);
+					dependentModule.issuer = module;
+					const newModule = _this.addModule(dependentModule, cacheGroup);
 
-				if(!newModule) { // from cache
-					dependentModule = _this.getModule(dependentModule);
+					if(!newModule) { // from cache
+						dependentModule = _this.getModule(dependentModule);
 
-					if(dependentModule.optional) {
-						dependentModule.optional = isOptional();
-					}
+						if(dependentModule.optional) {
+							dependentModule.optional = isOptional();
+						}
 
-					iterationDependencies(dependencies);
+						iterationDependencies(dependencies);
 
-					if(_this.profile) {
-						if(!module.profile) {
-							module.profile = {};
-						}
-						const time = Date.now() - start;
-						if(!module.profile.dependencies || time > module.profile.dependencies) {
-							module.profile.dependencies = time;
+						if(_this.profile) {
+							if(!module.profile) {
+								module.profile = {};
+							}
+							const time = Date.now() - start;
+							if(!module.profile.dependencies || time > module.profile.dependencies) {
+								module.profile.dependencies = time;
+							}
 						}
+
+						_this.semaphore.release();
+						return process.nextTick(callback);
 					}
 
-					return process.nextTick(callback);
-				}
+					if(newModule instanceof Module) {
+						if(_this.profile) {
+							newModule.profile = dependentModule.profile;
+						}
 
-				if(newModule instanceof Module) {
-					if(_this.profile) {
-						newModule.profile = dependentModule.profile;
-					}
+						newModule.optional = isOptional();
+						newModule.issuer = dependentModule.issuer;
+						dependentModule = newModule;
 
-					newModule.optional = isOptional();
-					newModule.issuer = dependentModule.issuer;
-					dependentModule = newModule;
+						iterationDependencies(dependencies);
 
-					iterationDependencies(dependencies);
+						if(_this.profile) {
+							const afterBuilding = Date.now();
+							module.profile.building = afterBuilding - afterFactory;
+						}
 
-					if(_this.profile) {
-						const afterBuilding = Date.now();
-						module.profile.building = afterBuilding - afterFactory;
+						_this.semaphore.release();
+						if(recursive) {
+							return process.nextTick(_this.processModuleDependencies.bind(_this, dependentModule, callback));
+						} else {
+							return process.nextTick(callback);
+						}
 					}
 
-					if(recursive) {
-						return process.nextTick(_this.processModuleDependencies.bind(_this, dependentModule, callback));
-					} else {
-						return process.nextTick(callback);
-					}
-				}
+					dependentModule.optional = isOptional();
 
-				dependentModule.optional = isOptional();
+					iterationDependencies(dependencies);
 
-				iterationDependencies(dependencies);
+					_this.buildModule(dependentModule, isOptional(), module, dependencies, err => {
+						if(err) {
+							_this.semaphore.release();
+							return errorOrWarningAndCallback(err);
+						}
 
-				_this.buildModule(dependentModule, isOptional(), module, dependencies, err => {
-					if(err) {
-						return errorOrWarningAndCallback(err);
-					}
+						if(_this.profile) {
+							const afterBuilding = Date.now();
+							dependentModule.profile.building = afterBuilding - afterFactory;
+						}
 
-					if(_this.profile) {
-						const afterBuilding = Date.now();
-						dependentModule.profile.building = afterBuilding - afterFactory;
-					}
+						_this.semaphore.release();
+						if(recursive) {
+							_this.processModuleDependencies(dependentModule, callback);
+						} else {
+							return callback();
+						}
+					});
 
-					if(recursive) {
-						_this.processModuleDependencies(dependentModule, callback);
-					} else {
-						return callback();
-					}
 				});
-
 			});
 		}, function finalCallbackAddModuleDependencies(err) {
 			// In V8, the Error objects keep a reference to the functions on the stack. These warnings &
@@ -362,13 +373,13 @@ class Compilation extends Tapable {
 	_addModuleChain(context, dependency, onModule, callback) {
 		const start = this.profile && Date.now();
 
-		const errorAndCallback = this.bail ? function errorAndCallback(err) {
+		const errorAndCallback = this.bail ? (err) => {
 			callback(err);
-		} : function errorAndCallback(err) {
+		} : (err) => {
 			err.dependencies = [dependency];
 			this.errors.push(err);
 			callback();
-		}.bind(this);
+		};
 
 		if(typeof dependency !== "object" || dependency === null || !dependency.constructor) {
 			throw new Error("Parameter 'dependency' must be a Dependency");
@@ -379,79 +390,85 @@ class Compilation extends Tapable {
 			throw new Error(`No dependency factory available for this dependency type: ${dependency.constructor.name}`);
 		}
 
-		moduleFactory.create({
-			contextInfo: {
-				issuer: "",
-				compiler: this.compiler.name
-			},
-			context: context,
-			dependencies: [dependency]
-		}, (err, module) => {
-			if(err) {
-				return errorAndCallback(new EntryModuleNotFoundError(err));
-			}
-
-			let afterFactory;
-
-			if(this.profile) {
-				if(!module.profile) {
-					module.profile = {};
+		this.semaphore.acquire(() => {
+			moduleFactory.create({
+				contextInfo: {
+					issuer: "",
+					compiler: this.compiler.name
+				},
+				context: context,
+				dependencies: [dependency]
+			}, (err, module) => {
+				if(err) {
+					this.semaphore.release();
+					return errorAndCallback(new EntryModuleNotFoundError(err));
 				}
-				afterFactory = Date.now();
-				module.profile.factory = afterFactory - start;
-			}
-
-			const result = this.addModule(module);
-			if(!result) {
-				module = this.getModule(module);
 
-				onModule(module);
+				let afterFactory;
 
 				if(this.profile) {
-					const afterBuilding = Date.now();
-					module.profile.building = afterBuilding - afterFactory;
+					if(!module.profile) {
+						module.profile = {};
+					}
+					afterFactory = Date.now();
+					module.profile.factory = afterFactory - start;
 				}
 
-				return callback(null, module);
-			}
+				const result = this.addModule(module);
+				if(!result) {
+					module = this.getModule(module);
 
-			if(result instanceof Module) {
-				if(this.profile) {
-					result.profile = module.profile;
-				}
+					onModule(module);
 
-				module = result;
+					if(this.profile) {
+						const afterBuilding = Date.now();
+						module.profile.building = afterBuilding - afterFactory;
+					}
 
-				onModule(module);
+					this.semaphore.release();
+					return callback(null, module);
+				}
 
-				moduleReady.call(this);
-				return;
-			}
+				if(result instanceof Module) {
+					if(this.profile) {
+						result.profile = module.profile;
+					}
 
-			onModule(module);
+					module = result;
 
-			this.buildModule(module, false, null, null, (err) => {
-				if(err) {
-					return errorAndCallback(err);
-				}
+					onModule(module);
 
-				if(this.profile) {
-					const afterBuilding = Date.now();
-					module.profile.building = afterBuilding - afterFactory;
+					moduleReady.call(this);
+					return;
 				}
 
-				moduleReady.call(this);
-			});
+				onModule(module);
 
-			function moduleReady() {
-				this.processModuleDependencies(module, err => {
+				this.buildModule(module, false, null, null, (err) => {
 					if(err) {
-						return callback(err);
+						this.semaphore.release();
+						return errorAndCallback(err);
 					}
 
-					return callback(null, module);
+					if(this.profile) {
+						const afterBuilding = Date.now();
+						module.profile.building = afterBuilding - afterFactory;
+					}
+
+					moduleReady.call(this);
 				});
-			}
+
+				function moduleReady() {
+					this.semaphore.release();
+					this.processModuleDependencies(module, err => {
+						if(err) {
+							return callback(err);
+						}
+
+						return callback(null, module);
+					});
+				}
+			});
 		});
 	}
 
@@ -1103,6 +1120,17 @@ class Compilation extends Tapable {
 		for(let indexChunk = 0; indexChunk < chunks.length; indexChunk++) {
 			chunks[indexChunk].sortItems();
 		}
+
+		const byMessage = (a, b) => {
+			const ma = `${a.message}`;
+			const mb = `${b.message}`;
+			if(ma < mb) return -1;
+			if(mb < ma) return 1;
+			return 0;
+		};
+
+		this.errors.sort(byMessage);
+		this.warnings.sort(byMessage);
 	}
 
 	summarizeDependencies() {
@@ -1171,6 +1199,12 @@ class Compilation extends Tapable {
 		this.children.forEach(function(child) {
 			hash.update(child.hash);
 		});
+		this.warnings.forEach(function(warning) {
+			hash.update(`${warning.message}`);
+		});
+		this.errors.forEach(function(error) {
+			hash.update(`${error.message}`);
+		});
 		// clone needed as sort below is inplace mutation
 		const chunks = this.chunks.slice();
 		/**

package/lib/Compiler.js

@@ -201,7 +201,7 @@ class Compiler extends Tapable {
 					});
 				});
 			},
-			apply: function() {
+			apply: () => {
 				const args = arguments;
 				if(!deprecationReported) {
 					console.warn("webpack: Using compiler.parser is deprecated.\n" +
@@ -214,7 +214,7 @@ class Compiler extends Tapable {
 						parser.apply.apply(parser, args);
 					});
 				});
-			}.bind(this)
+			}
 		};
 
 		this.options = {};
@@ -313,13 +313,7 @@ class Compiler extends Tapable {
 	emitAssets(compilation, callback) {
 		let outputPath;
 
-		this.applyPluginsAsync("emit", compilation, err => {
-			if(err) return callback(err);
-			outputPath = compilation.getPath(this.outputPath);
-			this.outputFileSystem.mkdirp(outputPath, emitFiles.bind(this));
-		});
-
-		function emitFiles(err) {
+		const emitFiles = (err) => {
 			if(err) return callback(err);
 
 			require("async").forEach(Object.keys(compilation.assets), (file, callback) => {
@@ -330,12 +324,7 @@ class Compiler extends Tapable {
 					targetFile = targetFile.substr(0, queryStringIdx);
 				}
 
-				if(targetFile.match(/\/|\\/)) {
-					const dir = path.dirname(targetFile);
-					this.outputFileSystem.mkdirp(this.outputFileSystem.join(outputPath, dir), writeOut.bind(this));
-				} else writeOut.call(this);
-
-				function writeOut(err) {
+				const writeOut = (err) => {
 					if(err) return callback(err);
 					const targetPath = this.outputFileSystem.join(outputPath, targetFile);
 					const source = compilation.assets[file];
@@ -352,14 +341,25 @@ class Compiler extends Tapable {
 					source.existsAt = targetPath;
 					source.emitted = true;
 					this.outputFileSystem.writeFile(targetPath, content, callback);
-				}
+				};
+
+				if(targetFile.match(/\/|\\/)) {
+					const dir = path.dirname(targetFile);
+					this.outputFileSystem.mkdirp(this.outputFileSystem.join(outputPath, dir), writeOut);
+				} else writeOut();
 
 			}, err => {
 				if(err) return callback(err);
 
 				afterEmit.call(this);
 			});
-		}
+		};
+
+		this.applyPluginsAsync("emit", compilation, err => {
+			if(err) return callback(err);
+			outputPath = compilation.getPath(this.outputPath);
+			this.outputFileSystem.mkdirp(outputPath, emitFiles);
+		});
 
 		function afterEmit() {
 			this.applyPluginsAsyncSeries1("after-emit", compilation, err => {
@@ -438,21 +438,15 @@ class Compiler extends Tapable {
 		else
 			this.records[relativeCompilerName].push(childCompiler.records = {});
 
-		if(this.cache) {
-			if(!this.cache.children) this.cache.children = {};
-			if(!this.cache.children[compilerName]) this.cache.children[compilerName] = [];
-			if(this.cache.children[compilerName][compilerIndex])
-				childCompiler.cache = this.cache.children[compilerName][compilerIndex];
-			else
-				this.cache.children[compilerName].push(childCompiler.cache = {});
-		}
-
 		childCompiler.options = Object.create(this.options);
 		childCompiler.options.output = Object.create(childCompiler.options.output);
 		for(const name in outputOptions) {
 			childCompiler.options.output[name] = outputOptions[name];
 		}
 		childCompiler.parentCompilation = compilation;
+
+		compilation.applyPlugins("child-compiler", childCompiler, compilerName, compilerIndex);
+
 		return childCompiler;
 	}
 

package/lib/ContextModuleFactory.js

@@ -103,16 +103,16 @@ module.exports = class ContextModuleFactory extends Tapable {
 		if(!regExp || !resource)
 			return callback(null, []);
 		(function addDirectory(directory, callback) {
-			fs.readdir(directory, function(err, files) {
+			fs.readdir(directory, (err, files) => {
 				if(err) return callback(err);
 				if(!files || files.length === 0) return callback(null, []);
 				asyncLib.map(files.filter(function(p) {
 					return p.indexOf(".") !== 0;
-				}), function(seqment, callback) {
+				}), (seqment, callback) => {
 
 					const subResource = path.join(directory, seqment);
 
-					fs.stat(subResource, function(err, stat) {
+					fs.stat(subResource, (err, stat) => {
 						if(err) return callback(err);
 
 						if(stat.isDirectory()) {
@@ -141,9 +141,9 @@ module.exports = class ContextModuleFactory extends Tapable {
 
 						} else callback();
 
-					}.bind(this));
+					});
 
-				}.bind(this), (err, result) => {
+				}, (err, result) => {
 					if(err) return callback(err);
 
 					if(!result) return callback(null, []);
@@ -154,7 +154,7 @@ module.exports = class ContextModuleFactory extends Tapable {
 						return a.concat(i);
 					}, []));
 				});
-			}.bind(this));
+			});
 		}.call(this, resource, callback));
 	}
 };

package/lib/HotModuleReplacement.runtime.js

@@ -462,6 +462,9 @@ module.exports = function() {
 			// remove module from cache
 			delete installedModules[moduleId];
 
+			// when disposing there is no need to call dispose handler
+			delete outdatedDependencies[moduleId];
+
 			// remove "parents" references from all children
 			for(j = 0; j < module.children.length; j++) {
 				var child = installedModules[module.children[j]];
@@ -507,30 +510,34 @@ module.exports = function() {
 		for(moduleId in outdatedDependencies) {
 			if(Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId)) {
 				module = installedModules[moduleId];
-				moduleOutdatedDependencies = outdatedDependencies[moduleId];
-				var callbacks = [];
-				for(i = 0; i < moduleOutdatedDependencies.length; i++) {
-					dependency = moduleOutdatedDependencies[i];
-					cb = module.hot._acceptedDependencies[dependency];
-					if(callbacks.indexOf(cb) >= 0) continue;
-					callbacks.push(cb);
-				}
-				for(i = 0; i < callbacks.length; i++) {
-					cb = callbacks[i];
-					try {
-						cb(moduleOutdatedDependencies);
-					} catch(err) {
-						if(options.onErrored) {
-							options.onErrored({
-								type: "accept-errored",
-								moduleId: moduleId,
-								dependencyId: moduleOutdatedDependencies[i],
-								error: err
-							});
+				if(module) {
+					moduleOutdatedDependencies = outdatedDependencies[moduleId];
+					var callbacks = [];
+					for(i = 0; i < moduleOutdatedDependencies.length; i++) {
+						dependency = moduleOutdatedDependencies[i];
+						cb = module.hot._acceptedDependencies[dependency];
+						if(cb) {
+							if(callbacks.indexOf(cb) >= 0) continue;
+							callbacks.push(cb);
 						}
-						if(!options.ignoreErrored) {
-							if(!error)
-								error = err;
+					}
+					for(i = 0; i < callbacks.length; i++) {
+						cb = callbacks[i];
+						try {
+							cb(moduleOutdatedDependencies);
+						} catch(err) {
+							if(options.onErrored) {
+								options.onErrored({
+									type: "accept-errored",
+									moduleId: moduleId,
+									dependencyId: moduleOutdatedDependencies[i],
+									error: err
+								});
+							}
+							if(!options.ignoreErrored) {
+								if(!error)
+									error = err;
+							}
 						}
 					}
 				}
@@ -554,7 +561,8 @@ module.exports = function() {
 								type: "self-accept-error-handler-errored",
 								moduleId: moduleId,
 								error: err2,
-								orginalError: err
+								orginalError: err, // TODO remove in webpack 4
+								originalError: err
 							});
 						}
 						if(!options.ignoreErrored) {

package/lib/Module.js

@@ -58,6 +58,7 @@ class Module extends DependenciesBlock {
 		this.providedExports = null;
 		this._chunks.clear();
 		this._chunksDebugIdent = undefined;
+		this.optimizationBailout.length = 0;
 		super.disconnect();
 	}
 
@@ -73,6 +74,7 @@ class Module extends DependenciesBlock {
 
 	setChunks(chunks) {
 		this._chunks = new SortableSet(chunks, sortById);
+		this._chunksDebugIdent = undefined;
 	}
 
 	addChunk(chunk) {

package/lib/NormalModule.js

@@ -34,12 +34,13 @@ function asString(buf) {
 
 function contextify(context, request) {
 	return request.split("!").map(function(r) {
-		let rp = path.relative(context, r);
+		const splitPath = r.split("?");
+		splitPath[0] = path.relative(context, splitPath[0]);
 		if(path.sep === "\\")
-			rp = rp.replace(/\\/g, "/");
-		if(rp.indexOf("../") !== 0)
-			rp = "./" + rp;
-		return rp;
+			splitPath[0] = splitPath[0].replace(/\\/g, "/");
+		if(splitPath[0].indexOf("../") !== 0)
+			splitPath[0] = "./" + splitPath[0];
+		return splitPath.join("?");
 	}).join("!");
 }