webpack 3.5.2 → 3.5.6

package/bin/config-yargs.js

@@ -172,7 +172,7 @@ module.exports = function(yargs) {
 				requiresArg: true
 			},
 			"watch-poll": {
-				type: "boolean",
+				type: "string",
 				describe: "The polling interval for watching (also enable polling)",
 				group: ADVANCED_GROUP
 			},

package/bin/convert-argv.js

@@ -166,12 +166,12 @@ module.exports = function(yargs, argv, convertOptions) {
 			options.watchOptions.aggregateTimeout = +argv["watch-aggregate-timeout"];
 		}
 
-		if(argv["watch-poll"]) {
+		if(typeof argv["watch-poll"] !== undefined) {
 			options.watchOptions = options.watchOptions || {};
-			if(typeof argv["watch-poll"] !== "boolean")
-				options.watchOptions.poll = +argv["watch-poll"];
-			else
+			if(argv["watch-poll"] === "true" || argv["watch-poll"] === "")
 				options.watchOptions.poll = true;
+			else if(!isNaN(argv["watch-poll"]))
+				options.watchOptions.poll = +argv["watch-poll"];
 		}
 
 		if(argv["watch-stdin"]) {

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 => {

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));
 	}
 };