webpack 4.13.0 → 4.16.0

package/lib/dependencies/LoaderDependency.js

@@ -6,6 +6,9 @@
 const ModuleDependency = require("./ModuleDependency");
 
 class LoaderDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request string
+	 */
 	constructor(request) {
 		super(request);
 	}

package/lib/dependencies/LoaderPlugin.js

@@ -5,6 +5,17 @@
 "use strict";
 
 const LoaderDependency = require("./LoaderDependency");
+const NormalModule = require("../NormalModule");
+
+/** @typedef {import("../Module")} Module */
+
+/**
+ * @callback LoadModuleCallback
+ * @param {Error=} err error object
+ * @param {string=} source source code
+ * @param {object=} map source map
+ * @param {Module=} module loaded module if successful
+ */
 
 class LoaderPlugin {
 	apply(compiler) {
@@ -22,9 +33,16 @@ class LoaderPlugin {
 			compilation.hooks.normalModuleLoader.tap(
 				"LoaderPlugin",
 				(loaderContext, module) => {
+					/**
+					 * @param {string} request the request string to load the module from
+					 * @param {LoadModuleCallback} callback callback returning the loaded module or error
+					 * @returns {void}
+					 */
 					loaderContext.loadModule = (request, callback) => {
 						const dep = new LoaderDependency(request);
-						dep.loc = request;
+						dep.loc = {
+							name: request
+						};
 						const factory = compilation.dependencyFactories.get(
 							dep.constructor
 						);
@@ -57,7 +75,8 @@ class LoaderPlugin {
 									if (!dep.module) {
 										return callback(new Error("Cannot load the module"));
 									}
-									if (dep.module.error) {
+									// TODO consider removing this in webpack 5
+									if (dep.module instanceof NormalModule && dep.module.error) {
 										return callback(dep.module.error);
 									}
 									if (!dep.module._source) {

package/lib/dependencies/ModuleDependency.js

@@ -6,6 +6,9 @@
 const Dependency = require("../Dependency");
 
 class ModuleDependency extends Dependency {
+	/**
+	 * @param {string} request request path which needs resolving
+	 */
 	constructor(request) {
 		super();
 		this.request = request;

package/lib/dependencies/MultiEntryDependency.js

@@ -3,9 +3,14 @@
 	Author Tobias Koppers @sokra
 */
 "use strict";
+/** @typedef {import("./SingleEntryDependency")} SingleEntryDependency */
 const Dependency = require("../Dependency");
 
 class MultiEntryDependency extends Dependency {
+	/**
+	 * @param {SingleEntryDependency[]} dependencies an array of SingleEntryDependencies
+	 * @param {string} name entry name
+	 */
 	constructor(dependencies, name) {
 		super();
 		this.dependencies = dependencies;

package/lib/dependencies/SingleEntryDependency.js

@@ -6,6 +6,9 @@
 const ModuleDependency = require("./ModuleDependency");
 
 class SingleEntryDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request path for entry
+	 */
 	constructor(request) {
 		super(request);
 	}

package/lib/dependencies/SystemPlugin.js

@@ -72,7 +72,7 @@ class SystemPlugin {
 					parser.hooks.expression.for("System").tap("SystemPlugin", () => {
 						const systemPolyfillRequire = ParserHelpers.requireFileAsExpression(
 							parser.state.module.context,
-							require.resolve("../../buildin/system.js")
+							require.resolve("../../buildin/system")
 						);
 						return ParserHelpers.addParsedVariableToModule(
 							parser,

package/lib/formatLocation.js

@@ -5,57 +5,71 @@
 
 "use strict";
 
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Dependency").SourcePosition} SourcePosition */
+
+// TODO webpack 5: pos must be SourcePosition
+/**
+ * @param {SourcePosition|DependencyLocation|string} pos position
+ * @returns {string} formatted position
+ */
 const formatPosition = pos => {
 	if (pos === null) return "";
-	const typeOfPos = typeof pos;
-	switch (typeOfPos) {
-		case "string":
-			return pos;
-		case "number":
-			return `${pos}`;
-		case "object":
-			if (typeof pos.line === "number" && typeof pos.column === "number") {
-				return `${pos.line}:${pos.column}`;
-			} else if (typeof pos.line === "number") {
-				return `${pos.line}:?`;
-			} else if (typeof pos.index === "number") {
-				return `+${pos.index}`;
-			} else {
-				return "";
-			}
-		default:
+	// TODO webpack 5: Simplify this
+	if (typeof pos === "string") return pos;
+	if (typeof pos === "number") return `${pos}`;
+	if (typeof pos === "object") {
+		if ("line" in pos && "column" in pos) {
+			return `${pos.line}:${pos.column}`;
+		} else if ("line" in pos) {
+			return `${pos.line}:?`;
+		} else if ("index" in pos) {
+			// TODO webpack 5 remove this case
+			return `+${pos.index}`;
+		} else {
 			return "";
+		}
 	}
+	return "";
 };
 
+// TODO webpack 5: loc must be DependencyLocation
+/**
+ * @param {DependencyLocation|SourcePosition|string} loc location
+ * @returns {string} formatted location
+ */
 const formatLocation = loc => {
 	if (loc === null) return "";
-	const typeOfLoc = typeof loc;
-	switch (typeOfLoc) {
-		case "string":
-			return loc;
-		case "number":
-			return `${loc}`;
-		case "object":
-			if (loc.start && loc.end) {
-				if (
-					typeof loc.start.line === "number" &&
-					typeof loc.end.line === "number" &&
-					typeof loc.end.column === "number" &&
-					loc.start.line === loc.end.line
-				) {
-					return `${formatPosition(loc.start)}-${loc.end.column}`;
-				} else {
-					return `${formatPosition(loc.start)}-${formatPosition(loc.end)}`;
-				}
-			}
-			if (loc.start) {
-				return formatPosition(loc.start);
+	// TODO webpack 5: Simplify this
+	if (typeof loc === "string") return loc;
+	if (typeof loc === "number") return `${loc}`;
+	if (typeof loc === "object") {
+		if ("start" in loc && loc.start && "end" in loc && loc.end) {
+			if (
+				typeof loc.start === "object" &&
+				typeof loc.start.line === "number" &&
+				typeof loc.end === "object" &&
+				typeof loc.end.line === "number" &&
+				typeof loc.end.column === "number" &&
+				loc.start.line === loc.end.line
+			) {
+				return `${formatPosition(loc.start)}-${loc.end.column}`;
+			} else {
+				return `${formatPosition(loc.start)}-${formatPosition(loc.end)}`;
 			}
-			return formatPosition(loc);
-		default:
-			return "";
+		}
+		if ("start" in loc && loc.start) {
+			return formatPosition(loc.start);
+		}
+		if ("name" in loc && "index" in loc) {
+			return `${loc.name}[${loc.index}]`;
+		}
+		if ("name" in loc) {
+			return loc.name;
+		}
+		return formatPosition(loc);
 	}
+	return "";
 };
 
 module.exports = formatLocation;

package/lib/node/NodeMainTemplateAsync.runtime.js

@@ -37,7 +37,7 @@ module.exports = function() {
 		});
 	}
 
-	//eslint-disable-next-line no-unused-vars
+	// eslint-disable-next-line no-unused-vars
 	function hotDisposeChunk(chunkId) {
 		delete installedChunks[chunkId];
 	}

package/lib/node/NodeMainTemplatePlugin.js

@@ -305,8 +305,8 @@ module.exports = class NodeMainTemplatePlugin {
 				);
 				return Template.getFunctionContent(
 					asyncChunkLoading
-						? require("./NodeMainTemplateAsync.runtime.js")
-						: require("./NodeMainTemplate.runtime.js")
+						? require("./NodeMainTemplateAsync.runtime")
+						: require("./NodeMainTemplate.runtime")
 				)
 					.replace(/\$require\$/g, mainTemplate.requireFn)
 					.replace(/\$hotMainFilename\$/g, currentHotUpdateMainFilename)

package/lib/node/NodeSourcePlugin.js

@@ -71,7 +71,7 @@ module.exports = class NodeSourcePlugin {
 							.tap("NodeSourcePlugin", () => {
 								const retrieveGlobalModule = ParserHelpers.requireFileAsExpression(
 									parser.state.module.context,
-									require.resolve("../../buildin/global.js")
+									require.resolve("../../buildin/global")
 								);
 								return ParserHelpers.addParsedVariableToModule(
 									parser,

package/lib/optimize/ConcatenatedModule.js

@@ -20,6 +20,13 @@ const HarmonyCompatibilityDependency = require("../dependencies/HarmonyCompatibi
 const createHash = require("../util/createHash");
 
 /** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Compilation")} Compilation */
+
+/**
+ * @typedef {Object} ConcatenationEntry
+ * @property {"concatenated" | "external"} type
+ * @property {Module} module
+ */
 
 const ensureNsObjSource = (
 	info,
@@ -125,6 +132,8 @@ const getFinalName = (
 						requestShortener,
 						strictHarmonyModule
 					);
+				} else if (!info.module.isUsed(exportName)) {
+					return "/* unused export */ undefined";
 				}
 				const name = info.internalNames.get(directExport);
 				if (!name) {
@@ -275,7 +284,7 @@ const getPathInAst = (ast, node) => {
 };
 
 class ConcatenatedModule extends Module {
-	constructor(rootModule, modules) {
+	constructor(rootModule, modules, concatenationList) {
 		super("javascript/esm", null);
 		super.setChunks(rootModule._chunks);
 
@@ -320,10 +329,9 @@ class ConcatenatedModule extends Module {
 
 		this.warnings = [];
 		this.errors = [];
-		this._orderedConcatenationList = this._createOrderedConcatenationList(
-			rootModule,
-			modulesSet
-		);
+		this._orderedConcatenationList =
+			concatenationList ||
+			ConcatenatedModule.createConcatenationList(rootModule, modulesSet, null);
 		for (const info of this._orderedConcatenationList) {
 			if (info.type === "concatenated") {
 				const m = info.module;
@@ -410,7 +418,13 @@ class ConcatenatedModule extends Module {
 		}, 0);
 	}
 
-	_createOrderedConcatenationList(rootModule, modulesSet) {
+	/**
+	 * @param {Module} rootModule the root of the concatenation
+	 * @param {Set<Module>} modulesSet a set of modules which should be concatenated
+	 * @param {Compilation} compilation the compilation context
+	 * @returns {ConcatenationEntry[]} concatenation list
+	 */
+	static createConcatenationList(rootModule, modulesSet, compilation) {
 		const list = [];
 		const set = new Set();
 
@@ -424,15 +438,16 @@ class ConcatenatedModule extends Module {
 			const references = module.dependencies
 				.filter(dep => dep instanceof HarmonyImportDependency)
 				.map(dep => {
-					const ref = dep.getReference();
+					const ref = compilation.getDependencyReference(module, dep);
 					if (ref) map.set(ref, dep);
 					return ref;
 				})
 				.filter(ref => ref);
 			DependencyReference.sort(references);
+			// TODO webpack 5: remove this hack, see also DependencyReference
 			return references.map(ref => {
 				const dep = map.get(ref);
-				return () => dep.getReference().module;
+				return () => compilation.getDependencyReference(module, dep).module;
 			});
 		};
 
@@ -624,6 +639,7 @@ class ConcatenatedModule extends Module {
 
 		// Must use full identifier in our cache here to ensure that the source
 		// is updated should our dependencies list change.
+		// TODO webpack 5 refactor
 		innerDependencyTemplates.set(
 			"hash",
 			innerDependencyTemplates.get("hash") + this.identifier()

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -213,8 +213,9 @@ class ModuleConcatenationPlugin {
 							const failureCache = new Map();
 
 							// try to add all imports
-							for (const imp of this.getImports(currentRoot)) {
-								const problem = this.tryToAdd(
+							for (const imp of this._getImports(compilation, currentRoot)) {
+								const problem = this._tryToAdd(
+									compilation,
 									currentConfiguration,
 									imp,
 									possibleInners,
@@ -245,9 +246,15 @@ class ModuleConcatenationPlugin {
 						for (const concatConfiguration of concatConfigurations) {
 							if (usedModules.has(concatConfiguration.rootModule)) continue;
 							const modules = concatConfiguration.getModules();
+							const rootModule = concatConfiguration.rootModule;
 							const newModule = new ConcatenatedModule(
-								concatConfiguration.rootModule,
-								modules
+								rootModule,
+								Array.from(modules),
+								ConcatenatedModule.createConcatenationList(
+									rootModule,
+									modules,
+									compilation
+								)
 							);
 							for (const warning of concatConfiguration.getWarningsSorted()) {
 								newModule.optimizationBailout.push(requestShortener => {
@@ -320,15 +327,16 @@ class ModuleConcatenationPlugin {
 		);
 	}
 
-	getImports(module) {
+	_getImports(compilation, module) {
 		return new Set(
 			module.dependencies
 
 				// Get reference info only for harmony Dependencies
-				.map(
-					dep =>
-						dep instanceof HarmonyImportDependency ? dep.getReference() : null
-				)
+				.map(dep => {
+					if (!(dep instanceof HarmonyImportDependency)) return null;
+					if (!compilation) return dep.getReference();
+					return compilation.getDependencyReference(module, dep);
+				})
 
 				// Reference is valid and has a module
 				// Dependencies are simple enough to concat them
@@ -345,7 +353,7 @@ class ModuleConcatenationPlugin {
 		);
 	}
 
-	tryToAdd(config, module, possibleModules, failureCache) {
+	_tryToAdd(compilation, config, module, possibleModules, failureCache) {
 		const cacheEntry = failureCache.get(module);
 		if (cacheEntry) {
 			return cacheEntry;
@@ -383,7 +391,8 @@ class ModuleConcatenationPlugin {
 			)
 				continue;
 
-			const problem = this.tryToAdd(
+			const problem = this._tryToAdd(
+				compilation,
 				testConfig,
 				reason.module,
 				possibleModules,
@@ -399,8 +408,14 @@ class ModuleConcatenationPlugin {
 		config.set(testConfig);
 
 		// Eagerly try to add imports too if possible
-		for (const imp of this.getImports(module)) {
-			const problem = this.tryToAdd(config, imp, possibleModules, failureCache);
+		for (const imp of this._getImports(compilation, module)) {
+			const problem = this._tryToAdd(
+				compilation,
+				config,
+				imp,
+				possibleModules,
+				failureCache
+			);
 			if (problem) {
 				config.addWarning(imp, problem);
 			}
@@ -451,7 +466,7 @@ class ConcatConfiguration {
 	}
 
 	getModules() {
-		return this.modules.asArray();
+		return this.modules.asSet();
 	}
 
 	clone() {

package/lib/optimize/NaturalChunkOrderPlugin.js

@@ -0,0 +1,41 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class NaturalChunkOrderPlugin {
+	/**
+	 * @param {Compiler} compiler webpack compiler
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap("NaturalChunkOrderPlugin", compilation => {
+			compilation.hooks.optimizeChunkOrder.tap(
+				"NaturalChunkOrderPlugin",
+				chunks => {
+					chunks.sort((chunkA, chunkB) => {
+						const a = chunkA.modulesIterable[Symbol.iterator]();
+						const b = chunkB.modulesIterable[Symbol.iterator]();
+						// eslint-disable-next-line no-constant-condition
+						while (true) {
+							const aItem = a.next();
+							const bItem = b.next();
+							if (aItem.done && bItem.done) return 0;
+							if (aItem.done) return -1;
+							if (bItem.done) return 1;
+							const aModuleId = aItem.value.id;
+							const bModuleId = bItem.value.id;
+							if (aModuleId < bModuleId) return -1;
+							if (aModuleId > bModuleId) return 1;
+						}
+					});
+				}
+			);
+		});
+	}
+}
+
+module.exports = NaturalChunkOrderPlugin;

package/lib/optimize/OccurrenceChunkOrderPlugin.js

@@ -0,0 +1,61 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const validateOptions = require("schema-utils");
+const schema = require("../../schemas/plugins/optimize/OccurrenceOrderChunkIdsPlugin.json");
+
+class OccurrenceOrderChunkIdsPlugin {
+	constructor(options = {}) {
+		validateOptions(schema, options, "Occurrence Order Chunk Ids Plugin");
+		this.options = options;
+	}
+
+	apply(compiler) {
+		const prioritiseInitial = this.options.prioritiseInitial;
+		compiler.hooks.compilation.tap(
+			"OccurrenceOrderChunkIdsPlugin",
+			compilation => {
+				compilation.hooks.optimizeChunkOrder.tap(
+					"OccurrenceOrderChunkIdsPlugin",
+					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) => {
+							if (prioritiseInitial) {
+								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 = OccurrenceOrderChunkIdsPlugin;

package/lib/optimize/OccurrenceModuleOrderPlugin.js

@@ -0,0 +1,103 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const validateOptions = require("schema-utils");
+const schema = require("../../schemas/plugins/optimize/OccurrenceOrderModuleIdsPlugin.json");
+
+class OccurrenceOrderModuleIdsPlugin {
+	constructor(options = {}) {
+		validateOptions(schema, options, "Occurrence Order Module Ids Plugin");
+		this.options = options;
+	}
+
+	apply(compiler) {
+		const prioritiseInitial = this.options.prioritiseInitial;
+		compiler.hooks.compilation.tap(
+			"OccurrenceOrderModuleIdsPlugin",
+			compilation => {
+				compilation.hooks.optimizeModuleOrder.tap(
+					"OccurrenceOrderModuleIdsPlugin",
+					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 (prioritiseInitial) {
+							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 (prioritiseInitial) {
+								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;
+						});
+					}
+				);
+			}
+		);
+	}
+}
+
+module.exports = OccurrenceOrderModuleIdsPlugin;

package/lib/optimize/OccurrenceOrderPlugin.js

@@ -4,6 +4,8 @@
 */
 "use strict";
 
+// TODO webpack 5 remove this plugin
+// It has been splitted into separate plugins for modules and chunks
 class OccurrenceOrderPlugin {
 	constructor(preferEntry) {
 		if (preferEntry !== undefined && typeof preferEntry !== "boolean") {