node_modules

1 files changed, 264 insertions, 163 deletions

diff --git a/node_modules/webpack/lib/Compilation.js b/node_modules/webpack/lib/Compilation.js
index 4ac48da50..b59c0eb53 100644
--- a/node_modules/webpack/lib/Compilation.js
+++ b/node_modules/webpack/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 = {};

@@ -80,6 +83,8 @@ class Compilation extends Tapable {
 		this.children = [];

 		this.dependencyFactories = new Map();

 		this.dependencyTemplates = new Map();

+		this.dependencyTemplates.set("hash", "");

+		this.childrenCounters = {};

 	}

 

 	getStats() {

@@ -112,8 +117,6 @@ class Compilation extends Tapable {
 				cacheModule.errors.forEach(err => this.errors.push(err), this);

 				cacheModule.warnings.forEach(err => this.warnings.push(err), this);

 				return cacheModule;

-			} else {

-				module.lastId = cacheModule.id;

 			}

 		}

 		module.unbuild();

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

+					});

+				}

+			});

 		});

 	}

 

@@ -511,7 +528,7 @@ class Compilation extends Tapable {
 				if(err) return callback(err);

 				deps.forEach(d => {

 					if(d.module && d.module.removeReason(module, d)) {

-						module.chunks.forEach(chunk => {

+						module.forEachChunk(chunk => {

 							if(!d.module.hasReasonForChunk(chunk)) {

 								if(d.module.removeChunk(chunk)) {

 									this.removeChunkFromDependencies(d.module, chunk);

@@ -568,12 +585,12 @@ class Compilation extends Tapable {
 

 		while(self.applyPluginsBailResult1("optimize-modules-basic", self.modules) ||

 			self.applyPluginsBailResult1("optimize-modules", self.modules) ||

-			self.applyPluginsBailResult1("optimize-modules-advanced", self.modules)); // eslint-disable-line no-extra-semi

+			self.applyPluginsBailResult1("optimize-modules-advanced", self.modules)) { /* empty */ }

 		self.applyPlugins1("after-optimize-modules", self.modules);

 

 		while(self.applyPluginsBailResult1("optimize-chunks-basic", self.chunks) ||

 			self.applyPluginsBailResult1("optimize-chunks", self.chunks) ||

-			self.applyPluginsBailResult1("optimize-chunks-advanced", self.chunks)); // eslint-disable-line no-extra-semi

+			self.applyPluginsBailResult1("optimize-chunks-advanced", self.chunks)) { /* empty */ }

 		self.applyPlugins1("after-optimize-chunks", self.chunks);

 

 		self.applyPluginsAsyncSeries("optimize-tree", self.chunks, self.modules, function sealPart2(err) {

@@ -583,6 +600,11 @@ class Compilation extends Tapable {
 

 			self.applyPlugins2("after-optimize-tree", self.chunks, self.modules);

 

+			while(self.applyPluginsBailResult("optimize-chunk-modules-basic", self.chunks, self.modules) ||

+				self.applyPluginsBailResult("optimize-chunk-modules", self.chunks, self.modules) ||

+				self.applyPluginsBailResult("optimize-chunk-modules-advanced", self.chunks, self.modules)) { /* empty */ }

+			self.applyPlugins2("after-optimize-chunk-modules", self.chunks, self.modules);

+

 			const shouldRecord = self.applyPluginsBailResult("should-record") !== false;

 

 			self.applyPlugins2("revive-modules", self.modules, self.records);

@@ -824,7 +846,11 @@ class Compilation extends Tapable {
 		}

 	}

 

-	processDependenciesBlockForChunk(block, chunk) {

+	processDependenciesBlockForChunk(module, chunk) {

+		let block = module;

+		const initialChunk = chunk;

+		const chunkDependencies = new Map(); // Map<Chunk, Array<{Module, Chunk}>>

+

 		const iteratorBlock = b => {

 			let c;

 			if(!b.chunks) {

@@ -834,9 +860,17 @@ class Compilation extends Tapable {
 			} else {

 				c = b.chunks[0];

 			}

-			chunk.addChunk(c);

-			c.addParent(chunk);

-			queue.push([b, c]);

+			let deps = chunkDependencies.get(chunk);

+			if(!deps) chunkDependencies.set(chunk, deps = []);

+			deps.push({

+				chunk: c,

+				module

+			});

+			queue.push({

+				block: b,

+				module: null,

+				chunk: c

+			});

 		};

 

 		const iteratorDependency = d => {

@@ -848,18 +882,25 @@ class Compilation extends Tapable {
 			}

 			if(chunk.addModule(d.module)) {

 				d.module.addChunk(chunk);

-				queue.push([d.module, chunk]);

+				queue.push({

+					block: d.module,

+					module: d.module,

+					chunk

+				});

 			}

 		};

 

-		const queue = [

-			[block, chunk]

-		];

+		const queue = [{

+			block,

+			module,

+			chunk

+		}];

 

 		while(queue.length) {

 			const queueItem = queue.pop();

-			block = queueItem[0];

-			chunk = queueItem[1];

+			block = queueItem.block;

+			module = queueItem.module;

+			chunk = queueItem.chunk;

 

 			if(block.variables) {

 				iterationBlockVariable(block.variables, iteratorDependency);

@@ -873,6 +914,47 @@ class Compilation extends Tapable {
 				iterationOfArrayCallback(block.blocks, iteratorBlock);

 			}

 		}

+

+		chunk = initialChunk;

+		let chunks = new Set();

+		const queue2 = [{

+			chunk,

+			chunks

+		}];

+

+		const filterFn = dep => {

+			if(chunks.has(dep.chunk)) return false;

+			for(const chunk of chunks) {

+				if(chunk.containsModule(dep.module))

+					return false;

+			}

+			return true;

+		};

+

+		while(queue2.length) {

+			const queueItem = queue2.pop();

+			chunk = queueItem.chunk;

+			chunks = queueItem.chunks;

+

+			const deps = chunkDependencies.get(chunk);

+			if(!deps) continue;

+

+			const depsFiltered = deps.filter(filterFn);

+

+			for(let i = 0; i < depsFiltered.length; i++) {

+				const dep = depsFiltered[i];

+				const depChunk = dep.chunk;

+				chunk.addChunk(depChunk);

+				depChunk.addParent(chunk);

+

+				const newChunks = depsFiltered.length > 1 ? new Set(chunks) : chunks;

+				newChunks.add(chunk);

+				queue2.push({

+					chunk: depChunk,

+					chunks: newChunks

+				});

+			}

+		}

 	}

 

 	removeChunkFromDependencies(block, chunk) {

@@ -1017,7 +1099,7 @@ class Compilation extends Tapable {
 

 		const modules = this.modules;

 		for(let indexModule = 0; indexModule < modules.length; indexModule++) {

-			modules[indexModule].sortItems();

+			modules[indexModule].sortItems(false);

 		}

 

 		const chunks = this.chunks;

@@ -1031,13 +1113,24 @@ class Compilation extends Tapable {
 

 		const modules = this.modules;

 		for(let indexModule = 0; indexModule < modules.length; indexModule++) {

-			modules[indexModule].sortItems();

+			modules[indexModule].sortItems(true);

 		}

 

 		const chunks = this.chunks;

 		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() {

@@ -1106,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();

 		/**

@@ -1218,8 +1317,10 @@ class Compilation extends Tapable {
 		return this.mainTemplate.applyPluginsWaterfall("asset-path", filename, data);

 	}

 

-	createChildCompiler(name, outputOptions) {

-		return this.compiler.createChildCompiler(this, name, outputOptions);

+	createChildCompiler(name, outputOptions, plugins) {

+		var idx = (this.childrenCounters[name] || 0);

+		this.childrenCounters[name] = idx + 1;

+		return this.compiler.createChildCompiler(this, name, idx, outputOptions, plugins);

 	}

 

 	checkConstraints() {