webpack 4.37.0 → 4.39.2

package/README.md

@@ -14,6 +14,7 @@
 [![builds2][builds2]][builds2-url]
 [![coverage][cover]][cover-url]
 [![licenses][licenses]][licenses-url]
+[![PR's welcome][prs]][prs-url]
 
   <br>
   <a href="https://dependabot.com/compatibility-score.html?dependency-name=webpack&package-manager=npm_and_yarn&new-version=latest">
@@ -767,6 +768,9 @@ src="https://static.monei.net/monei-logo.svg" height="30" alt="MONEI"></a>
 [tests]: https://img.shields.io/travis/webpack/webpack/master.svg
 [tests-url]: https://travis-ci.org/webpack/webpack
 
+[prs]: https://img.shields.io/badge/PRs-welcome-brightgreen.svg
+[prs-url]: https://webpack.js.org/contribute/
+
 [builds-url]: https://ci.appveyor.com/project/sokra/webpack/branch/master
 [builds]: https://ci.appveyor.com/api/projects/status/github/webpack/webpack?svg=true
 

package/lib/BannerPlugin.js

@@ -81,7 +81,6 @@ class BannerPlugin {
 							continue;
 						}
 
-						let basename;
 						let query = "";
 						let filename = file;
 						const hash = compilation.hash;
@@ -94,11 +93,10 @@ class BannerPlugin {
 
 						const lastSlashIndex = filename.lastIndexOf("/");
 
-						if (lastSlashIndex === -1) {
-							basename = filename;
-						} else {
-							basename = filename.substr(lastSlashIndex + 1);
-						}
+						const basename =
+							lastSlashIndex === -1
+								? filename
+								: filename.substr(lastSlashIndex + 1);
 
 						const data = {
 							hash,

package/lib/Chunk.js

@@ -355,7 +355,11 @@ class Chunk {
 		return this._modules.getFromUnorderedCache(getModulesIdent);
 	}
 
-	remove() {
+	/**
+	 * @param {string=} reason reason why chunk is removed
+	 * @returns {void}
+	 */
+	remove(reason) {
 		// cleanup modules
 		// Array.from is used here to create a clone, because removeChunk modifies this._modules
 		for (const module of Array.from(this._modules)) {

package/lib/ChunkGroup.js

@@ -70,12 +70,12 @@ class ChunkGroup {
 		this.chunks = [];
 		/** @type {OriginRecord[]} */
 		this.origins = [];
-		/** Indicies in top-down order */
+		/** Indices in top-down order */
 		/** @private @type {Map<Module, number>} */
-		this._moduleIndicies = new Map();
-		/** Indicies in bottom-up order */
+		this._moduleIndices = new Map();
+		/** Indices in bottom-up order */
 		/** @private @type {Map<Module, number>} */
-		this._moduleIndicies2 = new Map();
+		this._moduleIndices2 = new Map();
 	}
 
 	/**
@@ -174,7 +174,7 @@ class ChunkGroup {
 	/**
 	 * add a chunk into ChunkGroup. Is pushed on or prepended
 	 * @param {Chunk} chunk chunk being pushed into ChunkGroupS
-	 * @returns {boolean} returns true if chunk addition was ssuccesful.
+	 * @returns {boolean} returns true if chunk addition was successful.
 	 */
 	pushChunk(chunk) {
 		const oldIdx = this.chunks.indexOf(chunk);
@@ -187,8 +187,8 @@ class ChunkGroup {
 
 	/**
 	 * @param {Chunk} oldChunk chunk to be replaced
-	 * @param {Chunk} newChunk New chunkt that will be replaced
-	 * @returns {boolean} rerturns true for
+	 * @param {Chunk} newChunk New chunk that will be replaced with
+	 * @returns {boolean} returns true if the replacement was successful
 	 */
 	replaceChunk(oldChunk, newChunk) {
 		const oldIdx = this.chunks.indexOf(oldChunk);
@@ -345,7 +345,7 @@ class ChunkGroup {
 	}
 
 	/**
-	 * @param {ModuleReason} reason reason for removing ChunkGroup
+	 * @param {string=} reason reason for removing ChunkGroup
 	 * @returns {void}
 	 */
 	remove(reason) {
@@ -369,7 +369,7 @@ class ChunkGroup {
 
 		/**
 		 * we need to iterate again over the children
-		 * to remove this from the childs parents.
+		 * to remove this from the child's parents.
 		 * This can not be done in the above loop
 		 * as it is not guaranteed that `this._parents` contains anything.
 		 */
@@ -460,7 +460,7 @@ class ChunkGroup {
 	 * @returns {void}
 	 */
 	setModuleIndex(module, index) {
-		this._moduleIndicies.set(module, index);
+		this._moduleIndices.set(module, index);
 	}
 
 	/**
@@ -469,7 +469,7 @@ class ChunkGroup {
 	 * @returns {number} index
 	 */
 	getModuleIndex(module) {
-		return this._moduleIndicies.get(module);
+		return this._moduleIndices.get(module);
 	}
 
 	/**
@@ -479,7 +479,7 @@ class ChunkGroup {
 	 * @returns {void}
 	 */
 	setModuleIndex2(module, index) {
-		this._moduleIndicies2.set(module, index);
+		this._moduleIndices2.set(module, index);
 	}
 
 	/**
@@ -488,7 +488,7 @@ class ChunkGroup {
 	 * @returns {number} index
 	 */
 	getModuleIndex2(module) {
-		return this._moduleIndicies2.get(module);
+		return this._moduleIndices2.get(module);
 	}
 
 	checkConstraints() {

package/lib/Compilation.js

@@ -27,17 +27,16 @@ const HotUpdateChunkTemplate = require("./HotUpdateChunkTemplate");
 const ModuleTemplate = require("./ModuleTemplate");
 const RuntimeTemplate = require("./RuntimeTemplate");
 const ChunkRenderError = require("./ChunkRenderError");
-const AsyncDependencyToInitialChunkError = require("./AsyncDependencyToInitialChunkError");
 const Stats = require("./Stats");
 const Semaphore = require("./util/Semaphore");
 const createHash = require("./util/createHash");
-const Queue = require("./util/Queue");
 const SortableSet = require("./util/SortableSet");
 const GraphHelpers = require("./GraphHelpers");
 const ModuleDependency = require("./dependencies/ModuleDependency");
 const compareLocations = require("./compareLocations");
 const { Logger, LogType } = require("./logging/Logger");
 const ErrorHelpers = require("./ErrorHelpers");
+const buildChunkGraph = require("./buildChunkGraph");
 
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./Compiler")} Compiler */
@@ -165,16 +164,6 @@ const byNameOrHash = (a, b) => {
 	return 0;
 };
 
-/**
- * @template T
- * @param {Set<T>} a first set
- * @param {Set<T>} b second set
- * @returns {number} cmp
- */
-const bySetSize = (a, b) => {
-	return a.size - b.size;
-};
-
 /**
  * @param {DependenciesBlockVariable[]} variables DepBlock Variables to iterate over
  * @param {DepBlockVarDependenciesCallback} fn callback to apply on iterated elements
@@ -924,11 +913,6 @@ class Compilation extends Tapable {
 							iterationDependencies(dependencies);
 
 							const afterBuild = () => {
-								if (currentProfile) {
-									const afterBuilding = Date.now();
-									currentProfile.building = afterBuilding - afterFactory;
-								}
-
 								if (recursive && addModuleResult.dependencies) {
 									this.processModuleDependencies(dependentModule, callback);
 								} else {
@@ -1070,11 +1054,6 @@ class Compilation extends Tapable {
 					module.addReason(null, dependency);
 
 					const afterBuild = () => {
-						if (currentProfile) {
-							const afterBuilding = Date.now();
-							currentProfile.building = afterBuilding - afterFactory;
-						}
-
 						if (addModuleResult.dependencies) {
 							this.processModuleDependencies(module, err => {
 								if (err) return callback(err);
@@ -1295,7 +1274,10 @@ class Compilation extends Tapable {
 
 			this.assignDepth(module);
 		}
-		this.processDependenciesBlocksForChunkGroups(this.chunkGroups.slice());
+		buildChunkGraph(
+			this,
+			/** @type {Entrypoint[]} */ (this.chunkGroups.slice())
+		);
 		this.sortModules(this.modules);
 		this.hooks.afterChunks.call(this.chunks);
 
@@ -1583,460 +1565,6 @@ class Compilation extends Tapable {
 		return this.hooks.dependencyReference.call(ref, dependency, module);
 	}
 
-	/**
-	 * This method creates the Chunk graph from the Module graph
-	 * @private
-	 * @param {TODO[]} inputChunkGroups chunk groups which are processed
-	 * @returns {void}
-	 */
-	processDependenciesBlocksForChunkGroups(inputChunkGroups) {
-		// Process is splitting into two parts:
-		// Part one traverse the module graph and builds a very basic chunks graph
-		//   in chunkDependencies.
-		// Part two traverse every possible way through the basic chunk graph and
-		//   tracks the available modules. While traversing it connects chunks with
-		//   eachother and Blocks with Chunks. It stops traversing when all modules
-		//   for a chunk are already available. So it doesn't connect unneeded chunks.
-
-		/** @type {Map<ChunkGroup, {block: AsyncDependenciesBlock, chunkGroup: ChunkGroup, couldBeFiltered: boolean}[]>} */
-		const chunkDependencies = new Map();
-		const allCreatedChunkGroups = new Set();
-
-		// PREPARE
-		/** @type {Map<DependenciesBlock, { modules: Module[], blocks: AsyncDependenciesBlock[]}>} */
-		const blockInfoMap = new Map();
-
-		/**
-		 * @param {Dependency} d dependency to iterate over
-		 * @returns {void}
-		 */
-		const iteratorDependency = d => {
-			// We skip Dependencies without Reference
-			const ref = this.getDependencyReference(currentModule, d);
-			if (!ref) {
-				return;
-			}
-			// We skip Dependencies without Module pointer
-			const refModule = ref.module;
-			if (!refModule) {
-				return;
-			}
-			// We skip weak Dependencies
-			if (ref.weak) {
-				return;
-			}
-
-			blockInfoModules.add(refModule);
-		};
-
-		/**
-		 * @param {AsyncDependenciesBlock} b blocks to prepare
-		 * @returns {void}
-		 */
-		const iteratorBlockPrepare = b => {
-			blockInfoBlocks.push(b);
-			blockQueue.push(b);
-		};
-
-		/** @type {Module} */
-		let currentModule;
-		/** @type {DependenciesBlock} */
-		let block;
-		/** @type {DependenciesBlock[]} */
-		let blockQueue;
-		/** @type {Set<Module>} */
-		let blockInfoModules;
-		/** @type {AsyncDependenciesBlock[]} */
-		let blockInfoBlocks;
-
-		for (const module of this.modules) {
-			blockQueue = [module];
-			currentModule = module;
-			while (blockQueue.length > 0) {
-				block = blockQueue.pop();
-				blockInfoModules = new Set();
-				blockInfoBlocks = [];
-
-				if (block.variables) {
-					iterationBlockVariable(block.variables, iteratorDependency);
-				}
-
-				if (block.dependencies) {
-					iterationOfArrayCallback(block.dependencies, iteratorDependency);
-				}
-
-				if (block.blocks) {
-					iterationOfArrayCallback(block.blocks, iteratorBlockPrepare);
-				}
-
-				const blockInfo = {
-					modules: Array.from(blockInfoModules),
-					blocks: blockInfoBlocks
-				};
-				blockInfoMap.set(block, blockInfo);
-			}
-		}
-
-		// PART ONE
-
-		/** @type {Map<ChunkGroup, { index: number, index2: number }>} */
-		const chunkGroupCounters = new Map();
-		for (const chunkGroup of inputChunkGroups) {
-			chunkGroupCounters.set(chunkGroup, { index: 0, index2: 0 });
-		}
-
-		let nextFreeModuleIndex = 0;
-		let nextFreeModuleIndex2 = 0;
-
-		/** @type {Map<DependenciesBlock, ChunkGroup>} */
-		const blockChunkGroups = new Map();
-
-		/** @type {Set<DependenciesBlock>} */
-		const blocksWithNestedBlocks = new Set();
-
-		const ADD_AND_ENTER_MODULE = 0;
-		const ENTER_MODULE = 1;
-		const PROCESS_BLOCK = 2;
-		const LEAVE_MODULE = 3;
-
-		/**
-		 * @typedef {Object} QueueItem
-		 * @property {number} action
-		 * @property {DependenciesBlock} block
-		 * @property {Module} module
-		 * @property {Chunk} chunk
-		 * @property {ChunkGroup} chunkGroup
-		 */
-
-		/**
-		 * @param {ChunkGroup} chunkGroup chunk group
-		 * @returns {QueueItem} queue item
-		 */
-		const chunkGroupToQueueItem = chunkGroup => ({
-			action: ENTER_MODULE,
-			block: chunkGroup.chunks[0].entryModule,
-			module: chunkGroup.chunks[0].entryModule,
-			chunk: chunkGroup.chunks[0],
-			chunkGroup
-		});
-
-		// Start with the provided modules/chunks
-		/** @type {QueueItem[]} */
-		let queue = inputChunkGroups.map(chunkGroupToQueueItem).reverse();
-		/** @type {QueueItem[]} */
-		let queueDelayed = [];
-
-		/** @type {Module} */
-		let module;
-		/** @type {Chunk} */
-		let chunk;
-		/** @type {ChunkGroup} */
-		let chunkGroup;
-
-		// For each async Block in graph
-		/**
-		 * @param {AsyncDependenciesBlock} b iterating over each Async DepBlock
-		 * @returns {void}
-		 */
-		const iteratorBlock = b => {
-			// 1. We create a chunk for this Block
-			// but only once (blockChunkGroups map)
-			let c = blockChunkGroups.get(b);
-			if (c === undefined) {
-				c = this.namedChunkGroups.get(b.chunkName);
-				if (c && c.isInitial()) {
-					this.errors.push(
-						new AsyncDependencyToInitialChunkError(b.chunkName, module, b.loc)
-					);
-					c = chunkGroup;
-				} else {
-					c = this.addChunkInGroup(
-						b.groupOptions || b.chunkName,
-						module,
-						b.loc,
-						b.request
-					);
-					chunkGroupCounters.set(c, { index: 0, index2: 0 });
-					blockChunkGroups.set(b, c);
-					allCreatedChunkGroups.add(c);
-				}
-			} else {
-				// TODO webpack 5 remove addOptions check
-				if (c.addOptions) c.addOptions(b.groupOptions);
-				c.addOrigin(module, b.loc, b.request);
-			}
-
-			// 2. We store the Block+Chunk mapping as dependency for the chunk
-			let deps = chunkDependencies.get(chunkGroup);
-			if (!deps) chunkDependencies.set(chunkGroup, (deps = []));
-			deps.push({
-				block: b,
-				chunkGroup: c,
-				couldBeFiltered: true
-			});
-
-			// 3. We enqueue the DependenciesBlock for traversal
-			queueDelayed.push({
-				action: PROCESS_BLOCK,
-				block: b,
-				module: module,
-				chunk: c.chunks[0],
-				chunkGroup: c
-			});
-		};
-
-		// Iterative traversal of the Module graph
-		// Recursive would be simpler to write but could result in Stack Overflows
-		while (queue.length) {
-			while (queue.length) {
-				const queueItem = queue.pop();
-				module = queueItem.module;
-				block = queueItem.block;
-				chunk = queueItem.chunk;
-				chunkGroup = queueItem.chunkGroup;
-
-				switch (queueItem.action) {
-					case ADD_AND_ENTER_MODULE: {
-						// We connect Module and Chunk when not already done
-						if (chunk.addModule(module)) {
-							module.addChunk(chunk);
-						} else {
-							// already connected, skip it
-							break;
-						}
-					}
-					// fallthrough
-					case ENTER_MODULE: {
-						if (chunkGroup !== undefined) {
-							const index = chunkGroup.getModuleIndex(module);
-							if (index === undefined) {
-								chunkGroup.setModuleIndex(
-									module,
-									chunkGroupCounters.get(chunkGroup).index++
-								);
-							}
-						}
-
-						if (module.index === null) {
-							module.index = nextFreeModuleIndex++;
-						}
-
-						queue.push({
-							action: LEAVE_MODULE,
-							block,
-							module,
-							chunk,
-							chunkGroup
-						});
-					}
-					// fallthrough
-					case PROCESS_BLOCK: {
-						// get prepared block info
-						const blockInfo = blockInfoMap.get(block);
-
-						// Traverse all referenced modules
-						for (let i = blockInfo.modules.length - 1; i >= 0; i--) {
-							const refModule = blockInfo.modules[i];
-							if (chunk.containsModule(refModule)) {
-								// skip early if already connected
-								continue;
-							}
-							// enqueue the add and enter to enter in the correct order
-							// this is relevant with circular dependencies
-							queue.push({
-								action: ADD_AND_ENTER_MODULE,
-								block: refModule,
-								module: refModule,
-								chunk,
-								chunkGroup
-							});
-						}
-
-						// Traverse all Blocks
-						iterationOfArrayCallback(blockInfo.blocks, iteratorBlock);
-
-						if (blockInfo.blocks.length > 0 && module !== block) {
-							blocksWithNestedBlocks.add(block);
-						}
-						break;
-					}
-					case LEAVE_MODULE: {
-						if (chunkGroup !== undefined) {
-							const index = chunkGroup.getModuleIndex2(module);
-							if (index === undefined) {
-								chunkGroup.setModuleIndex2(
-									module,
-									chunkGroupCounters.get(chunkGroup).index2++
-								);
-							}
-						}
-
-						if (module.index2 === null) {
-							module.index2 = nextFreeModuleIndex2++;
-						}
-						break;
-					}
-				}
-			}
-			const tempQueue = queue;
-			queue = queueDelayed.reverse();
-			queueDelayed = tempQueue;
-		}
-
-		// PART TWO
-		/** @type {Set<Module>} */
-		let newAvailableModules;
-
-		/**
-		 * @typedef {Object} ChunkGroupInfo
-		 * @property {Set<Module>} minAvailableModules current minimal set of modules available at this point
-		 * @property {Set<Module>[]} availableModulesToBeMerged enqueued updates to the minimal set of available modules
-		 */
-
-		/** @type {Map<ChunkGroup, ChunkGroupInfo>} */
-		const chunkGroupInfoMap = new Map();
-
-		/** @type {Queue<ChunkGroup>} */
-		const queue2 = new Queue(inputChunkGroups);
-
-		for (const chunkGroup of inputChunkGroups) {
-			chunkGroupInfoMap.set(chunkGroup, {
-				minAvailableModules: undefined,
-				availableModulesToBeMerged: [new Set()]
-			});
-		}
-
-		/**
-		 * Helper function to check if all modules of a chunk are available
-		 *
-		 * @param {ChunkGroup} chunkGroup the chunkGroup to scan
-		 * @param {Set<Module>} availableModules the comparitor set
-		 * @returns {boolean} return true if all modules of a chunk are available
-		 */
-		const areModulesAvailable = (chunkGroup, availableModules) => {
-			for (const chunk of chunkGroup.chunks) {
-				for (const module of chunk.modulesIterable) {
-					if (!availableModules.has(module)) return false;
-				}
-			}
-			return true;
-		};
-
-		// For each edge in the basic chunk graph
-		/**
-		 * @param {TODO} dep the dependency used for filtering
-		 * @returns {boolean} used to filter "edges" (aka Dependencies) that were pointing
-		 * to modules that are already available. Also filters circular dependencies in the chunks graph
-		 */
-		const filterFn = dep => {
-			const depChunkGroup = dep.chunkGroup;
-			if (!dep.couldBeFiltered) return true;
-			if (blocksWithNestedBlocks.has(dep.block)) return true;
-			if (areModulesAvailable(depChunkGroup, newAvailableModules)) {
-				return false; // break all modules are already available
-			}
-			dep.couldBeFiltered = false;
-			return true;
-		};
-
-		// Iterative traversing of the basic chunk graph
-		while (queue2.length) {
-			chunkGroup = queue2.dequeue();
-			const info = chunkGroupInfoMap.get(chunkGroup);
-			const availableModulesToBeMerged = info.availableModulesToBeMerged;
-			let minAvailableModules = info.minAvailableModules;
-
-			// 1. Get minimal available modules
-			// It doesn't make sense to traverse a chunk again with more available modules.
-			// This step calculates the minimal available modules and skips traversal when
-			// the list didn't shrink.
-			availableModulesToBeMerged.sort(bySetSize);
-			let changed = false;
-			for (const availableModules of availableModulesToBeMerged) {
-				if (minAvailableModules === undefined) {
-					minAvailableModules = new Set(availableModules);
-					info.minAvailableModules = minAvailableModules;
-					changed = true;
-				} else {
-					for (const m of minAvailableModules) {
-						if (!availableModules.has(m)) {
-							minAvailableModules.delete(m);
-							changed = true;
-						}
-					}
-				}
-			}
-			availableModulesToBeMerged.length = 0;
-			if (!changed) continue;
-
-			// 2. Get the edges at this point of the graph
-			const deps = chunkDependencies.get(chunkGroup);
-			if (!deps) continue;
-			if (deps.length === 0) continue;
-
-			// 3. Create a new Set of available modules at this points
-			newAvailableModules = new Set(minAvailableModules);
-			for (const chunk of chunkGroup.chunks) {
-				for (const m of chunk.modulesIterable) {
-					newAvailableModules.add(m);
-				}
-			}
-
-			// 4. Foreach remaining edge
-			const nextChunkGroups = new Set();
-			for (let i = 0; i < deps.length; i++) {
-				const dep = deps[i];
-
-				// Filter inline, rather than creating a new array from `.filter()`
-				if (!filterFn(dep)) {
-					continue;
-				}
-				const depChunkGroup = dep.chunkGroup;
-				const depBlock = dep.block;
-
-				// 5. Connect block with chunk
-				GraphHelpers.connectDependenciesBlockAndChunkGroup(
-					depBlock,
-					depChunkGroup
-				);
-
-				// 6. Connect chunk with parent
-				GraphHelpers.connectChunkGroupParentAndChild(chunkGroup, depChunkGroup);
-
-				nextChunkGroups.add(depChunkGroup);
-			}
-
-			// 7. Enqueue further traversal
-			for (const nextChunkGroup of nextChunkGroups) {
-				let nextInfo = chunkGroupInfoMap.get(nextChunkGroup);
-				if (nextInfo === undefined) {
-					nextInfo = {
-						minAvailableModules: undefined,
-						availableModulesToBeMerged: []
-					};
-					chunkGroupInfoMap.set(nextChunkGroup, nextInfo);
-				}
-				nextInfo.availableModulesToBeMerged.push(newAvailableModules);
-
-				// As queue deduplicates enqueued items this makes sure that a ChunkGroup
-				// is not enqueued twice
-				queue2.enqueue(nextChunkGroup);
-			}
-		}
-
-		// Remove all unconnected chunk groups
-		for (const chunkGroup of allCreatedChunkGroups) {
-			if (chunkGroup.getNumberOfParents() === 0) {
-				for (const chunk of chunkGroup.chunks) {
-					const idx = this.chunks.indexOf(chunk);
-					if (idx >= 0) this.chunks.splice(idx, 1);
-					chunk.remove("unconnected");
-				}
-				chunkGroup.remove("unconnected");
-			}
-		}
-	}
-
 	/**
 	 *
 	 * @param {Module} module module relationship for removal