webpack 4.9.1 → 4.10.2

package/lib/optimize/OccurrenceOrderPlugin.js

@@ -1,126 +1,133 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-class OccurrenceOrderPlugin {
-	constructor(preferEntry) {
-		if (preferEntry !== undefined && typeof preferEntry !== "boolean") {
-			throw new Error(
-				"Argument should be a boolean.\nFor more info on this plugin, see https://webpack.js.org/plugins/"
-			);
-		}
-		this.preferEntry = preferEntry;
-	}
-	apply(compiler) {
-		const preferEntry = this.preferEntry;
-		compiler.hooks.compilation.tap("OccurrenceOrderPlugin", compilation => {
-			compilation.hooks.optimizeModuleOrder.tap(
-				"OccurrenceOrderPlugin",
-				modules => {
-					const occursInInitialChunksMap = new Map();
-					const occursInAllChunksMap = new Map();
-
-					const initialChunkChunkMap = new Map();
-					const entryCountMap = new Map();
-					for (const m of modules) {
-						let initial = 0;
-						let entry = 0;
-						for (const c of m.chunksIterable) {
-							if (c.canBeInitial()) initial++;
-							if (c.entryModule === m) entry++;
-						}
-						initialChunkChunkMap.set(m, initial);
-						entryCountMap.set(m, entry);
-					}
-
-					const countOccursInEntry = (sum, r) => {
-						if (!r.module) return sum;
-						return sum + initialChunkChunkMap.get(r.module);
-					};
-					const countOccurs = (sum, r) => {
-						if (!r.module) return sum;
-						let factor = 1;
-						if (typeof r.dependency.getNumberOfIdOccurrences === "function")
-							factor = r.dependency.getNumberOfIdOccurrences();
-						if (factor === 0) return sum;
-						return sum + factor * r.module.getNumberOfChunks();
-					};
-
-					if (preferEntry) {
-						for (const m of modules) {
-							const result =
-								m.reasons.reduce(countOccursInEntry, 0) +
-								initialChunkChunkMap.get(m) +
-								entryCountMap.get(m);
-							occursInInitialChunksMap.set(m, result);
-						}
-					}
-
-					const originalOrder = new Map();
-					let i = 0;
-					for (const m of modules) {
-						const result =
-							m.reasons.reduce(countOccurs, 0) +
-							m.getNumberOfChunks() +
-							entryCountMap.get(m);
-						occursInAllChunksMap.set(m, result);
-						originalOrder.set(m, i++);
-					}
-
-					modules.sort((a, b) => {
-						if (preferEntry) {
-							const aEntryOccurs = occursInInitialChunksMap.get(a);
-							const bEntryOccurs = occursInInitialChunksMap.get(b);
-							if (aEntryOccurs > bEntryOccurs) return -1;
-							if (aEntryOccurs < bEntryOccurs) return 1;
-						}
-						const aOccurs = occursInAllChunksMap.get(a);
-						const bOccurs = occursInAllChunksMap.get(b);
-						if (aOccurs > bOccurs) return -1;
-						if (aOccurs < bOccurs) return 1;
-						const orgA = originalOrder.get(a);
-						const orgB = originalOrder.get(b);
-						return orgB - orgA;
-					});
-				}
-			);
-			compilation.hooks.optimizeChunkOrder.tap(
-				"OccurrenceOrderPlugin",
-				chunks => {
-					const occursInInitialChunksMap = new Map();
-					const originalOrder = new Map();
-
-					let i = 0;
-					for (const c of chunks) {
-						let occurs = 0;
-						for (const chunkGroup of c.groupsIterable) {
-							for (const parent of chunkGroup.parentsIterable) {
-								if (parent.isInitial()) occurs++;
-							}
-						}
-						occursInInitialChunksMap.set(c, occurs);
-						originalOrder.set(c, i++);
-					}
-
-					chunks.sort((a, b) => {
-						const aEntryOccurs = occursInInitialChunksMap.get(a);
-						const bEntryOccurs = occursInInitialChunksMap.get(b);
-						if (aEntryOccurs > bEntryOccurs) return -1;
-						if (aEntryOccurs < bEntryOccurs) return 1;
-						const aOccurs = a.getNumberOfGroups();
-						const bOccurs = b.getNumberOfGroups();
-						if (aOccurs > bOccurs) return -1;
-						if (aOccurs < bOccurs) return 1;
-						const orgA = originalOrder.get(a);
-						const orgB = originalOrder.get(b);
-						return orgB - orgA;
-					});
-				}
-			);
-		});
-	}
-}
-
-module.exports = OccurrenceOrderPlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class OccurrenceOrderPlugin {
+	constructor(preferEntry) {
+		if (preferEntry !== undefined && typeof preferEntry !== "boolean") {
+			throw new Error(
+				"Argument should be a boolean.\nFor more info on this plugin, see https://webpack.js.org/plugins/"
+			);
+		}
+		this.preferEntry = preferEntry;
+	}
+	apply(compiler) {
+		const preferEntry = this.preferEntry;
+		compiler.hooks.compilation.tap("OccurrenceOrderPlugin", compilation => {
+			compilation.hooks.optimizeModuleOrder.tap(
+				"OccurrenceOrderPlugin",
+				modules => {
+					const occursInInitialChunksMap = new Map();
+					const occursInAllChunksMap = new Map();
+
+					const initialChunkChunkMap = new Map();
+					const entryCountMap = new Map();
+					for (const m of modules) {
+						let initial = 0;
+						let entry = 0;
+						for (const c of m.chunksIterable) {
+							if (c.canBeInitial()) initial++;
+							if (c.entryModule === m) entry++;
+						}
+						initialChunkChunkMap.set(m, initial);
+						entryCountMap.set(m, entry);
+					}
+
+					const countOccursInEntry = (sum, r) => {
+						if (!r.module) {
+							return sum;
+						}
+						return sum + initialChunkChunkMap.get(r.module);
+					};
+					const countOccurs = (sum, r) => {
+						if (!r.module) {
+							return sum;
+						}
+						let factor = 1;
+						if (typeof r.dependency.getNumberOfIdOccurrences === "function") {
+							factor = r.dependency.getNumberOfIdOccurrences();
+						}
+						if (factor === 0) {
+							return sum;
+						}
+						return sum + factor * r.module.getNumberOfChunks();
+					};
+
+					if (preferEntry) {
+						for (const m of modules) {
+							const result =
+								m.reasons.reduce(countOccursInEntry, 0) +
+								initialChunkChunkMap.get(m) +
+								entryCountMap.get(m);
+							occursInInitialChunksMap.set(m, result);
+						}
+					}
+
+					const originalOrder = new Map();
+					let i = 0;
+					for (const m of modules) {
+						const result =
+							m.reasons.reduce(countOccurs, 0) +
+							m.getNumberOfChunks() +
+							entryCountMap.get(m);
+						occursInAllChunksMap.set(m, result);
+						originalOrder.set(m, i++);
+					}
+
+					modules.sort((a, b) => {
+						if (preferEntry) {
+							const aEntryOccurs = occursInInitialChunksMap.get(a);
+							const bEntryOccurs = occursInInitialChunksMap.get(b);
+							if (aEntryOccurs > bEntryOccurs) return -1;
+							if (aEntryOccurs < bEntryOccurs) return 1;
+						}
+						const aOccurs = occursInAllChunksMap.get(a);
+						const bOccurs = occursInAllChunksMap.get(b);
+						if (aOccurs > bOccurs) return -1;
+						if (aOccurs < bOccurs) return 1;
+						const orgA = originalOrder.get(a);
+						const orgB = originalOrder.get(b);
+						return orgB - orgA;
+					});
+				}
+			);
+			compilation.hooks.optimizeChunkOrder.tap(
+				"OccurrenceOrderPlugin",
+				chunks => {
+					const occursInInitialChunksMap = new Map();
+					const originalOrder = new Map();
+
+					let i = 0;
+					for (const c of chunks) {
+						let occurs = 0;
+						for (const chunkGroup of c.groupsIterable) {
+							for (const parent of chunkGroup.parentsIterable) {
+								if (parent.isInitial()) occurs++;
+							}
+						}
+						occursInInitialChunksMap.set(c, occurs);
+						originalOrder.set(c, i++);
+					}
+
+					chunks.sort((a, b) => {
+						const aEntryOccurs = occursInInitialChunksMap.get(a);
+						const bEntryOccurs = occursInInitialChunksMap.get(b);
+						if (aEntryOccurs > bEntryOccurs) return -1;
+						if (aEntryOccurs < bEntryOccurs) return 1;
+						const aOccurs = a.getNumberOfGroups();
+						const bOccurs = b.getNumberOfGroups();
+						if (aOccurs > bOccurs) return -1;
+						if (aOccurs < bOccurs) return 1;
+						const orgA = originalOrder.get(a);
+						const orgB = originalOrder.get(b);
+						return orgB - orgA;
+					});
+				}
+			);
+		});
+	}
+}
+
+module.exports = OccurrenceOrderPlugin;

package/lib/optimize/RemoveParentModulesPlugin.js

@@ -1,117 +1,127 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const Queue = require("../util/Queue");
-const { intersect } = require("../util/SetHelpers");
-
-const getParentChunksWithModule = (currentChunk, module) => {
-	const chunks = [];
-	const stack = new Set(currentChunk.parentsIterable);
-
-	for (const chunk of stack) {
-		if (chunk.containsModule(module)) {
-			chunks.push(chunk);
-		} else {
-			for (const parent of chunk.parentsIterable) {
-				stack.add(parent);
-			}
-		}
-	}
-
-	return chunks;
-};
-
-class RemoveParentModulesPlugin {
-	apply(compiler) {
-		compiler.hooks.compilation.tap("RemoveParentModulesPlugin", compilation => {
-			const handler = (chunks, chunkGroups) => {
-				const queue = new Queue();
-				const availableModulesMap = new WeakMap();
-
-				for (const chunkGroup of compilation.entrypoints.values()) {
-					// initialize available modules for chunks without parents
-					availableModulesMap.set(chunkGroup, new Set());
-					for (const child of chunkGroup.childrenIterable) queue.enqueue(child);
-				}
-
-				while (queue.length > 0) {
-					const chunkGroup = queue.dequeue();
-					let availableModules = availableModulesMap.get(chunkGroup);
-					let changed = false;
-					for (const parent of chunkGroup.parentsIterable) {
-						const availableModulesInParent = availableModulesMap.get(parent);
-						if (availableModulesInParent !== undefined) {
-							// If we know the available modules in parent: process these
-							if (availableModules === undefined) {
-								// if we have not own info yet: create new entry
-								availableModules = new Set(availableModulesInParent);
-								for (const chunk of parent.chunks) {
-									for (const m of chunk.modulesIterable)
-										availableModules.add(m);
-								}
-								availableModulesMap.set(chunkGroup, availableModules);
-								changed = true;
-							} else {
-								for (const m of availableModules) {
-									if (
-										!parent.containsModule(m) &&
-										!availableModulesInParent.has(m)
-									) {
-										availableModules.delete(m);
-										changed = true;
-									}
-								}
-							}
-						}
-					}
-					if (changed) {
-						// if something changed: enqueue our children
-						for (const child of chunkGroup.childrenIterable)
-							queue.enqueue(child);
-					}
-				}
-
-				// now we have available modules for every chunk
-				for (const chunk of chunks) {
-					const availableModulesSets = Array.from(
-						chunk.groupsIterable,
-						chunkGroup => availableModulesMap.get(chunkGroup)
-					);
-					if (availableModulesSets.some(s => s === undefined)) continue; // No info about this chunk group
-					const availableModules =
-						availableModulesSets.length === 1
-							? availableModulesSets[0]
-							: intersect(availableModulesSets);
-					const numberOfModules = chunk.getNumberOfModules();
-					const toRemove = new Set();
-					if (numberOfModules < availableModules.size) {
-						for (const m of chunk.modulesIterable)
-							if (availableModules.has(m)) toRemove.add(m);
-					} else {
-						for (const m of availableModules)
-							if (chunk.containsModule(m)) toRemove.add(m);
-					}
-					for (const module of toRemove) {
-						module.rewriteChunkInReasons(
-							chunk,
-							getParentChunksWithModule(chunk, module)
-						);
-						chunk.removeModule(module);
-					}
-				}
-			};
-			compilation.hooks.optimizeChunksBasic.tap(
-				"RemoveParentModulesPlugin",
-				handler
-			);
-			compilation.hooks.optimizeExtractedChunksBasic.tap(
-				"RemoveParentModulesPlugin",
-				handler
-			);
-		});
-	}
-}
-module.exports = RemoveParentModulesPlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Queue = require("../util/Queue");
+const { intersect } = require("../util/SetHelpers");
+
+const getParentChunksWithModule = (currentChunk, module) => {
+	const chunks = [];
+	const stack = new Set(currentChunk.parentsIterable);
+
+	for (const chunk of stack) {
+		if (chunk.containsModule(module)) {
+			chunks.push(chunk);
+		} else {
+			for (const parent of chunk.parentsIterable) {
+				stack.add(parent);
+			}
+		}
+	}
+
+	return chunks;
+};
+
+class RemoveParentModulesPlugin {
+	apply(compiler) {
+		compiler.hooks.compilation.tap("RemoveParentModulesPlugin", compilation => {
+			const handler = (chunks, chunkGroups) => {
+				const queue = new Queue();
+				const availableModulesMap = new WeakMap();
+
+				for (const chunkGroup of compilation.entrypoints.values()) {
+					// initialize available modules for chunks without parents
+					availableModulesMap.set(chunkGroup, new Set());
+					for (const child of chunkGroup.childrenIterable) {
+						queue.enqueue(child);
+					}
+				}
+
+				while (queue.length > 0) {
+					const chunkGroup = queue.dequeue();
+					let availableModules = availableModulesMap.get(chunkGroup);
+					let changed = false;
+					for (const parent of chunkGroup.parentsIterable) {
+						const availableModulesInParent = availableModulesMap.get(parent);
+						if (availableModulesInParent !== undefined) {
+							// If we know the available modules in parent: process these
+							if (availableModules === undefined) {
+								// if we have not own info yet: create new entry
+								availableModules = new Set(availableModulesInParent);
+								for (const chunk of parent.chunks) {
+									for (const m of chunk.modulesIterable) {
+										availableModules.add(m);
+									}
+								}
+								availableModulesMap.set(chunkGroup, availableModules);
+								changed = true;
+							} else {
+								for (const m of availableModules) {
+									if (
+										!parent.containsModule(m) &&
+										!availableModulesInParent.has(m)
+									) {
+										availableModules.delete(m);
+										changed = true;
+									}
+								}
+							}
+						}
+					}
+					if (changed) {
+						// if something changed: enqueue our children
+						for (const child of chunkGroup.childrenIterable) {
+							queue.enqueue(child);
+						}
+					}
+				}
+
+				// now we have available modules for every chunk
+				for (const chunk of chunks) {
+					const availableModulesSets = Array.from(
+						chunk.groupsIterable,
+						chunkGroup => availableModulesMap.get(chunkGroup)
+					);
+					if (availableModulesSets.some(s => s === undefined)) continue; // No info about this chunk group
+					const availableModules =
+						availableModulesSets.length === 1
+							? availableModulesSets[0]
+							: intersect(availableModulesSets);
+					const numberOfModules = chunk.getNumberOfModules();
+					const toRemove = new Set();
+					if (numberOfModules < availableModules.size) {
+						for (const m of chunk.modulesIterable) {
+							if (availableModules.has(m)) {
+								toRemove.add(m);
+							}
+						}
+					} else {
+						for (const m of availableModules) {
+							if (chunk.containsModule(m)) {
+								toRemove.add(m);
+							}
+						}
+					}
+					for (const module of toRemove) {
+						module.rewriteChunkInReasons(
+							chunk,
+							getParentChunksWithModule(chunk, module)
+						);
+						chunk.removeModule(module);
+					}
+				}
+			};
+			compilation.hooks.optimizeChunksBasic.tap(
+				"RemoveParentModulesPlugin",
+				handler
+			);
+			compilation.hooks.optimizeExtractedChunksBasic.tap(
+				"RemoveParentModulesPlugin",
+				handler
+			);
+		});
+	}
+}
+module.exports = RemoveParentModulesPlugin;

package/lib/optimize/RuntimeChunkPlugin.js

@@ -1,41 +1,41 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-module.exports = class RuntimeChunkPlugin {
-	constructor(options) {
-		this.options = Object.assign(
-			{
-				name: entrypoint => `runtime~${entrypoint.name}`
-			},
-			options
-		);
-	}
-
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap("RuntimeChunkPlugin", compilation => {
-			compilation.hooks.optimizeChunksAdvanced.tap("RuntimeChunkPlugin", () => {
-				for (const entrypoint of compilation.entrypoints.values()) {
-					const chunk = entrypoint.getRuntimeChunk();
-					let name = this.options.name;
-					if (typeof name === "function") {
-						name = name(entrypoint);
-					}
-					if (
-						chunk.getNumberOfModules() > 0 ||
-						!chunk.preventIntegration ||
-						chunk.name !== name
-					) {
-						const newChunk = compilation.addChunk(name);
-						newChunk.preventIntegration = true;
-						entrypoint.unshiftChunk(newChunk);
-						newChunk.addGroup(entrypoint);
-						entrypoint.setRuntimeChunk(newChunk);
-					}
-				}
-			});
-		});
-	}
-};
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+module.exports = class RuntimeChunkPlugin {
+	constructor(options) {
+		this.options = Object.assign(
+			{
+				name: entrypoint => `runtime~${entrypoint.name}`
+			},
+			options
+		);
+	}
+
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap("RuntimeChunkPlugin", compilation => {
+			compilation.hooks.optimizeChunksAdvanced.tap("RuntimeChunkPlugin", () => {
+				for (const entrypoint of compilation.entrypoints.values()) {
+					const chunk = entrypoint.getRuntimeChunk();
+					let name = this.options.name;
+					if (typeof name === "function") {
+						name = name(entrypoint);
+					}
+					if (
+						chunk.getNumberOfModules() > 0 ||
+						!chunk.preventIntegration ||
+						chunk.name !== name
+					) {
+						const newChunk = compilation.addChunk(name);
+						newChunk.preventIntegration = true;
+						entrypoint.unshiftChunk(newChunk);
+						newChunk.addGroup(entrypoint);
+						entrypoint.setRuntimeChunk(newChunk);
+					}
+				}
+			});
+		});
+	}
+};