webpack 4.13.0 → 4.16.0

package/lib/FlagDependencyUsagePlugin.js

@@ -4,6 +4,11 @@
 */
 "use strict";
 
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
+
+/** @typedef {false | true | string[]} UsedExports */
+
 const addToSet = (a, b) => {
 	for (const item of b) {
 		if (!a.includes(item)) a.push(item);
@@ -54,37 +59,36 @@ class FlagDependencyUsagePlugin {
 								return;
 						}
 
-						queue.push([module, module.usedExports]);
+						queue.push([module, module, module.usedExports]);
 					};
 
-					const processDependenciesBlock = (depBlock, usedExports) => {
+					const processDependenciesBlock = (module, depBlock, usedExports) => {
 						for (const dep of depBlock.dependencies) {
-							processDependency(dep);
+							processDependency(module, dep);
 						}
 						for (const variable of depBlock.variables) {
 							for (const dep of variable.dependencies) {
-								processDependency(dep);
+								processDependency(module, dep);
 							}
 						}
 						for (const block of depBlock.blocks) {
-							queue.push([block, usedExports]);
+							queue.push([module, block, usedExports]);
 						}
 					};
 
-					const processDependency = dep => {
-						// TODO remove dep.getReference existance check in webpack 5
-						const reference = dep.getReference && dep.getReference();
+					const processDependency = (module, dep) => {
+						const reference = compilation.getDependencyReference(module, dep);
 						if (!reference) return;
-						const module = reference.module;
+						const referenceModule = reference.module;
 						const importedNames = reference.importedNames;
-						const oldUsed = module.used;
-						const oldUsedExports = module.usedExports;
+						const oldUsed = referenceModule.used;
+						const oldUsedExports = referenceModule.usedExports;
 						if (
 							!oldUsed ||
 							(importedNames &&
 								(!oldUsedExports || !isSubset(oldUsedExports, importedNames)))
 						) {
-							processModule(module, importedNames);
+							processModule(referenceModule, importedNames);
 						}
 					};
 
@@ -92,6 +96,7 @@ class FlagDependencyUsagePlugin {
 						module.used = false;
 					}
 
+					/** @type {[Module, DependenciesBlock, UsedExports][]} */
 					const queue = [];
 					for (const preparedEntrypoint of compilation._preparedEntrypoints) {
 						if (preparedEntrypoint.module) {
@@ -101,7 +106,7 @@ class FlagDependencyUsagePlugin {
 
 					while (queue.length) {
 						const queueItem = queue.pop();
-						processDependenciesBlock(queueItem[0], queueItem[1]);
+						processDependenciesBlock(queueItem[0], queueItem[1], queueItem[2]);
 					}
 				}
 			);

package/lib/Generator.js

@@ -25,7 +25,7 @@ class Generator {
 	 * @returns {Source} generated code
 	 */
 	generate(module, dependencyTemplates, runtimeTemplate, type) {
-		throw new Error("Generator.generate: must be overriden");
+		throw new Error("Generator.generate: must be overridden");
 	}
 }
 

package/lib/GraphHelpers.js

@@ -2,6 +2,7 @@
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
+/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
 
 /**
  * @param {ChunkGroup} chunkGroup the ChunkGroup to connect
@@ -47,7 +48,7 @@ const disconnectChunkAndModule = (chunk, module) => {
 };
 
 /**
- * @param {DependenciesBlock} depBlock DepBlock being tied to ChunkGroup
+ * @param {AsyncDependenciesBlock} depBlock DepBlock being tied to ChunkGroup
  * @param {ChunkGroup} chunkGroup ChunkGroup being tied to DepBlock
  * @returns {void}
  */

package/lib/HotModuleReplacement.runtime.js

@@ -5,12 +5,15 @@
 /*global $hash$ $requestTimeout$ installedModules $require$ hotDownloadManifest hotDownloadUpdateChunk hotDisposeChunk modules */
 module.exports = function() {
 	var hotApplyOnUpdate = true;
-	var hotCurrentHash = $hash$; // eslint-disable-line no-unused-vars
+	// eslint-disable-next-line no-unused-vars
+	var hotCurrentHash = $hash$;
 	var hotRequestTimeout = $requestTimeout$;
 	var hotCurrentModuleData = {};
-	var hotCurrentChildModule; // eslint-disable-line no-unused-vars
-	var hotCurrentParents = []; // eslint-disable-line no-unused-vars
-	var hotCurrentParentsTemp = []; // eslint-disable-line no-unused-vars
+	var hotCurrentChildModule;
+	// eslint-disable-next-line no-unused-vars
+	var hotCurrentParents = [];
+	// eslint-disable-next-line no-unused-vars
+	var hotCurrentParentsTemp = [];
 
 	// eslint-disable-next-line no-unused-vars
 	function hotCreateRequire(moduleId) {
@@ -199,8 +202,8 @@ module.exports = function() {
 			});
 			hotUpdate = {};
 			/*foreachInstalledChunks*/
+			// eslint-disable-next-line no-lone-blocks
 			{
-				// eslint-disable-line no-lone-blocks
 				/*globals chunkId */
 				hotEnsureUpdateChunk(chunkId);
 			}

package/lib/HotModuleReplacementPlugin.js

@@ -35,6 +35,118 @@ module.exports = class HotModuleReplacementPlugin {
 				return callback();
 			}
 		);
+
+		const addParserPlugins = (parser, parserOptions) => {
+			parser.hooks.expression
+				.for("__webpack_hash__")
+				.tap(
+					"HotModuleReplacementPlugin",
+					ParserHelpers.toConstantDependencyWithWebpackRequire(
+						parser,
+						"__webpack_require__.h()"
+					)
+				);
+			parser.hooks.evaluateTypeof
+				.for("__webpack_hash__")
+				.tap(
+					"HotModuleReplacementPlugin",
+					ParserHelpers.evaluateToString("string")
+				);
+			parser.hooks.evaluateIdentifier.for("module.hot").tap(
+				{
+					name: "HotModuleReplacementPlugin",
+					before: "NodeStuffPlugin"
+				},
+				expr => {
+					return ParserHelpers.evaluateToIdentifier(
+						"module.hot",
+						!!parser.state.compilation.hotUpdateChunkTemplate
+					)(expr);
+				}
+			);
+			// TODO webpack 5: refactor this, no custom hooks
+			if (!parser.hooks.hotAcceptCallback) {
+				parser.hooks.hotAcceptCallback = new SyncBailHook([
+					"expression",
+					"requests"
+				]);
+			}
+			if (!parser.hooks.hotAcceptWithoutCallback) {
+				parser.hooks.hotAcceptWithoutCallback = new SyncBailHook([
+					"expression",
+					"requests"
+				]);
+			}
+			parser.hooks.call
+				.for("module.hot.accept")
+				.tap("HotModuleReplacementPlugin", expr => {
+					if (!parser.state.compilation.hotUpdateChunkTemplate) {
+						return false;
+					}
+					if (expr.arguments.length >= 1) {
+						const arg = parser.evaluateExpression(expr.arguments[0]);
+						let params = [];
+						let requests = [];
+						if (arg.isString()) {
+							params = [arg];
+						} else if (arg.isArray()) {
+							params = arg.items.filter(param => param.isString());
+						}
+						if (params.length > 0) {
+							params.forEach((param, idx) => {
+								const request = param.string;
+								const dep = new ModuleHotAcceptDependency(request, param.range);
+								dep.optional = true;
+								dep.loc = Object.create(expr.loc);
+								dep.loc.index = idx;
+								parser.state.module.addDependency(dep);
+								requests.push(request);
+							});
+							if (expr.arguments.length > 1) {
+								parser.hooks.hotAcceptCallback.call(
+									expr.arguments[1],
+									requests
+								);
+								parser.walkExpression(expr.arguments[1]); // other args are ignored
+								return true;
+							} else {
+								parser.hooks.hotAcceptWithoutCallback.call(expr, requests);
+								return true;
+							}
+						}
+					}
+				});
+			parser.hooks.call
+				.for("module.hot.decline")
+				.tap("HotModuleReplacementPlugin", expr => {
+					if (!parser.state.compilation.hotUpdateChunkTemplate) {
+						return false;
+					}
+					if (expr.arguments.length === 1) {
+						const arg = parser.evaluateExpression(expr.arguments[0]);
+						let params = [];
+						if (arg.isString()) {
+							params = [arg];
+						} else if (arg.isArray()) {
+							params = arg.items.filter(param => param.isString());
+						}
+						params.forEach((param, idx) => {
+							const dep = new ModuleHotDeclineDependency(
+								param.string,
+								param.range
+							);
+							dep.optional = true;
+							dep.loc = Object.create(expr.loc);
+							dep.loc.index = idx;
+							parser.state.module.addDependency(dep);
+						});
+					}
+				});
+			parser.hooks.expression
+				.for("module.hot")
+				.tap("HotModuleReplacementPlugin", ParserHelpers.skipTraversal);
+		};
+
 		compiler.hooks.compilation.tap(
 			"HotModuleReplacementPlugin",
 			(compilation, { normalModuleFactory }) => {
@@ -275,127 +387,13 @@ module.exports = class HotModuleReplacementPlugin {
 					}
 				);
 
-				const handler = (parser, parserOptions) => {
-					parser.hooks.expression
-						.for("__webpack_hash__")
-						.tap(
-							"HotModuleReplacementPlugin",
-							ParserHelpers.toConstantDependencyWithWebpackRequire(
-								parser,
-								"__webpack_require__.h()"
-							)
-						);
-					parser.hooks.evaluateTypeof
-						.for("__webpack_hash__")
-						.tap(
-							"HotModuleReplacementPlugin",
-							ParserHelpers.evaluateToString("string")
-						);
-					parser.hooks.evaluateIdentifier.for("module.hot").tap(
-						{
-							name: "HotModuleReplacementPlugin",
-							before: "NodeStuffPlugin"
-						},
-						expr => {
-							return ParserHelpers.evaluateToIdentifier(
-								"module.hot",
-								!!parser.state.compilation.hotUpdateChunkTemplate
-							)(expr);
-						}
-					);
-					// TODO webpack 5: refactor this, no custom hooks
-					if (!parser.hooks.hotAcceptCallback) {
-						parser.hooks.hotAcceptCallback = new SyncBailHook([
-							"expression",
-							"requests"
-						]);
-					}
-					if (!parser.hooks.hotAcceptWithoutCallback) {
-						parser.hooks.hotAcceptWithoutCallback = new SyncBailHook([
-							"expression",
-							"requests"
-						]);
-					}
-					parser.hooks.call
-						.for("module.hot.accept")
-						.tap("HotModuleReplacementPlugin", expr => {
-							if (!parser.state.compilation.hotUpdateChunkTemplate) {
-								return false;
-							}
-							if (expr.arguments.length >= 1) {
-								const arg = parser.evaluateExpression(expr.arguments[0]);
-								let params = [];
-								let requests = [];
-								if (arg.isString()) {
-									params = [arg];
-								} else if (arg.isArray()) {
-									params = arg.items.filter(param => param.isString());
-								}
-								if (params.length > 0) {
-									params.forEach((param, idx) => {
-										const request = param.string;
-										const dep = new ModuleHotAcceptDependency(
-											request,
-											param.range
-										);
-										dep.optional = true;
-										dep.loc = Object.create(expr.loc);
-										dep.loc.index = idx;
-										parser.state.module.addDependency(dep);
-										requests.push(request);
-									});
-									if (expr.arguments.length > 1) {
-										parser.hooks.hotAcceptCallback.call(
-											expr.arguments[1],
-											requests
-										);
-										parser.walkExpression(expr.arguments[1]); // other args are ignored
-										return true;
-									} else {
-										parser.hooks.hotAcceptWithoutCallback.call(expr, requests);
-										return true;
-									}
-								}
-							}
-						});
-					parser.hooks.call
-						.for("module.hot.decline")
-						.tap("HotModuleReplacementPlugin", expr => {
-							if (!parser.state.compilation.hotUpdateChunkTemplate) {
-								return false;
-							}
-							if (expr.arguments.length === 1) {
-								const arg = parser.evaluateExpression(expr.arguments[0]);
-								let params = [];
-								if (arg.isString()) {
-									params = [arg];
-								} else if (arg.isArray()) {
-									params = arg.items.filter(param => param.isString());
-								}
-								params.forEach((param, idx) => {
-									const dep = new ModuleHotDeclineDependency(
-										param.string,
-										param.range
-									);
-									dep.optional = true;
-									dep.loc = Object.create(expr.loc);
-									dep.loc.index = idx;
-									parser.state.module.addDependency(dep);
-								});
-							}
-						});
-					parser.hooks.expression
-						.for("module.hot")
-						.tap("HotModuleReplacementPlugin", ParserHelpers.skipTraversal);
-				};
-
 				// TODO add HMR support for javascript/esm
 				normalModuleFactory.hooks.parser
 					.for("javascript/auto")
-					.tap("HotModuleReplacementPlugin", handler);
+					.tap("HotModuleReplacementPlugin", addParserPlugins);
 				normalModuleFactory.hooks.parser
 					.for("javascript/dynamic")
-					.tap("HotModuleReplacementPlugin", handler);
+					.tap("HotModuleReplacementPlugin", addParserPlugins);
 
 				compilation.hooks.normalModuleLoader.tap(
 					"HotModuleReplacementPlugin",
@@ -409,5 +407,5 @@ module.exports = class HotModuleReplacementPlugin {
 };
 
 const hotInitCode = Template.getFunctionContent(
-	require("./HotModuleReplacement.runtime.js")
+	require("./HotModuleReplacement.runtime")
 );

package/lib/IgnorePlugin.js

@@ -4,7 +4,7 @@
 */
 "use strict";
 
-/** @typedef {import("./Compiler.js")} Compiler */
+/** @typedef {import("./Compiler")} Compiler */
 
 class IgnorePlugin {
 	/**

package/lib/MainTemplate.js

@@ -19,15 +19,17 @@ const {
 const Template = require("./Template");
 
 /** @typedef {import("webpack-sources").ConcatSource} ConcatSource */
+/** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("./ModuleTemplate")} ModuleTemplate */
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./Module")} Module} */
-/** @typedef {import("crypto").Hash} Hash} */
+/** @typedef {import("./util/createHash").Hash} Hash} */
+/** @typedef {import("./Dependency").DependencyTemplate} DependencyTemplate} */
 
 /**
  * @typedef {Object} RenderManifestOptions
  * @property {Chunk} chunk the chunk used to render
- * @property {Hash} hash
+ * @property {string} hash
  * @property {string} fullHash
  * @property {TODO} outputOptions
  * @property {{javascript: ModuleTemplate, webassembly: ModuleTemplate}} moduleTemplates
@@ -92,7 +94,9 @@ module.exports = class MainTemplate extends Tapable {
 			localVars: new SyncWaterfallHook(["source", "chunk", "hash"]),
 			require: new SyncWaterfallHook(["source", "chunk", "hash"]),
 			requireExtensions: new SyncWaterfallHook(["source", "chunk", "hash"]),
+			/** @type {SyncWaterfallHook<string, Chunk, string>} */
 			beforeStartup: new SyncWaterfallHook(["source", "chunk", "hash"]),
+			/** @type {SyncWaterfallHook<string, Chunk, string>} */
 			startup: new SyncWaterfallHook(["source", "chunk", "hash"]),
 			render: new SyncWaterfallHook([
 				"source",
@@ -361,7 +365,7 @@ module.exports = class MainTemplate extends Tapable {
 	 * @param {string} hash hash to be used for render call
 	 * @param {Chunk} chunk Chunk instance
 	 * @param {ModuleTemplate} moduleTemplate ModuleTemplate instance for render
-	 * @param {TODO} dependencyTemplates DependencyTemplate[]s
+	 * @param {Map<Function, DependencyTemplate>} dependencyTemplates dependency templates
 	 * @returns {ConcatSource} the newly generated source from rendering
 	 */
 	render(hash, chunk, moduleTemplate, dependencyTemplates) {
@@ -447,7 +451,7 @@ module.exports = class MainTemplate extends Tapable {
 	/**
 	 *
 	 * @param {string} hash string hash
-	 * @param {number} length length
+	 * @param {number=} length length
 	 * @returns {string} call hook return
 	 */
 	renderCurrentHashCode(hash, length) {
@@ -474,6 +478,11 @@ module.exports = class MainTemplate extends Tapable {
 		return this.hooks.assetPath.call(path, options);
 	}
 
+	/**
+	 * Updates hash with information from this template
+	 * @param {Hash} hash the hash to update
+	 * @returns {void}
+	 */
 	updateHash(hash) {
 		hash.update("maintemplate");
 		hash.update("3");
@@ -481,6 +490,12 @@ module.exports = class MainTemplate extends Tapable {
 		this.hooks.hash.call(hash);
 	}
 
+	/**
+	 * Updates hash with chunk-specific information from this template
+	 * @param {Hash} hash the hash to update
+	 * @param {Chunk} chunk the chunk
+	 * @returns {void}
+	 */
 	updateHashForChunk(hash, chunk) {
 		this.updateHash(hash);
 		this.hooks.hashForChunk.call(hash, chunk);

package/lib/Module.js

@@ -13,6 +13,7 @@ const Template = require("./Template");
 
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./WebpackError")} WebpackError */
 
 const EMPTY_RESOLVE_OPTIONS = {};
 
@@ -47,15 +48,15 @@ class Module extends DependenciesBlock {
 		this.renderedHash = undefined;
 
 		// Info from Factory
-		/** @type {object} */
+		/** @type {TODO} */
 		this.resolveOptions = EMPTY_RESOLVE_OPTIONS;
 		/** @type {object} */
 		this.factoryMeta = {};
 
 		// Info from Build
-		/** @type {Error[]} */
+		/** @type {WebpackError[]} */
 		this.warnings = [];
-		/** @type {Error[]} */
+		/** @type {WebpackError[]} */
 		this.errors = [];
 		/** @type {object} */
 		this.buildMeta = undefined;
@@ -181,6 +182,9 @@ class Module extends DependenciesBlock {
 		);
 	}
 
+	/**
+	 * @returns {Chunk[]} all chunks which contain the module
+	 */
 	getChunks() {
 		return Array.from(this._chunks);
 	}
@@ -380,6 +384,8 @@ Module.prototype.build = null;
 Module.prototype.source = null;
 Module.prototype.size = null;
 Module.prototype.nameForCondition = null;
+/** @type {null | function(Chunk): boolean} */
+Module.prototype.chunkCondition = null;
 Module.prototype.updateCacheModule = null;
 
 module.exports = Module;

package/lib/ModuleReason.js

@@ -4,7 +4,15 @@
 */
 "use strict";
 
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./Dependency")} Dependency */
+
 class ModuleReason {
+	/**
+	 * @param {Module} module the referencing module
+	 * @param {Dependency} dependency the referencing dependency
+	 * @param {string=} explanation some extra detail
+	 */
 	constructor(module, dependency, explanation) {
 		this.module = module;
 		this.dependency = dependency;

package/lib/MultiEntryPlugin.js

@@ -8,13 +8,25 @@ const MultiEntryDependency = require("./dependencies/MultiEntryDependency");
 const SingleEntryDependency = require("./dependencies/SingleEntryDependency");
 const MultiModuleFactory = require("./MultiModuleFactory");
 
-module.exports = class MultiEntryPlugin {
+/** @typedef {import("./Compiler")} Compiler */
+
+class MultiEntryPlugin {
+	/**
+	 * The MultiEntryPlugin is invoked whenever this.options.entry value is an array of paths
+	 * @param {string} context context path
+	 * @param {string[]} entries array of entry paths
+	 * @param {string} name entry key name
+	 */
 	constructor(context, entries, name) {
 		this.context = context;
 		this.entries = entries;
 		this.name = name;
 	}
 
+	/**
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
 			"MultiEntryPlugin",
@@ -43,16 +55,26 @@ module.exports = class MultiEntryPlugin {
 		);
 	}
 
+	/**
+	 * @param {string[]} entries each entry path string
+	 * @param {string} name name of the entry
+	 * @returns {MultiEntryDependency} returns a constructed Dependency
+	 */
 	static createDependency(entries, name) {
 		return new MultiEntryDependency(
 			entries.map((e, idx) => {
 				const dep = new SingleEntryDependency(e);
 				// Because entrypoints are not dependencies found in an
 				// existing module, we give it a synthetic id
-				dep.loc = `${name}:${100000 + idx}`;
+				dep.loc = {
+					name,
+					index: idx
+				};
 				return dep;
 			}),
 			name
 		);
 	}
-};
+}
+
+module.exports = MultiEntryPlugin;

package/lib/NormalModule.js

@@ -4,7 +4,6 @@
 */
 "use strict";
 
-const path = require("path");
 const NativeModule = require("module");
 
 const {
@@ -23,6 +22,7 @@ const ModuleBuildError = require("./ModuleBuildError");
 const ModuleError = require("./ModuleError");
 const ModuleWarning = require("./ModuleWarning");
 const createHash = require("./util/createHash");
+const contextify = require("./util/identifier").contextify;
 
 const asString = buf => {
 	if (Buffer.isBuffer(buf)) {
@@ -38,28 +38,6 @@ const asBuffer = str => {
 	return str;
 };
 
-const contextify = (context, request) => {
-	return request
-		.split("!")
-		.map(r => {
-			const splitPath = r.split("?");
-			if (/^[a-zA-Z]:\\/.test(splitPath[0])) {
-				splitPath[0] = path.win32.relative(context, splitPath[0]);
-				if (!/^[a-zA-Z]:\\/.test(splitPath[0])) {
-					splitPath[0] = splitPath[0].replace(/\\/g, "/");
-				}
-			}
-			if (/^\//.test(splitPath[0])) {
-				splitPath[0] = path.posix.relative(context, splitPath[0]);
-			}
-			if (!/^(\.\.\/|\/|[a-zA-Z]:\\)/.test(splitPath[0])) {
-				splitPath[0] = "./" + splitPath[0];
-			}
-			return splitPath.join("?");
-		})
-		.join("!");
-};
-
 class NonErrorEmittedError extends WebpackError {
 	constructor(error) {
 		super();
@@ -191,6 +169,7 @@ class NormalModule extends Module {
 					})
 				);
 			},
+			// TODO remove in webpack 5
 			exec: (code, filename) => {
 				// @ts-ignore Argument of type 'this' is not assignable to parameter of type 'Module'.
 				const module = new NativeModule(filename, this);
@@ -265,6 +244,8 @@ class NormalModule extends Module {
 		}
 
 		if (Buffer.isBuffer(source)) {
+			// @ts-ignore
+			// TODO We need to fix @types/webpack-sources to allow RawSource to take a Buffer | string
 			return new RawSource(source);
 		}
 
@@ -486,6 +467,7 @@ class NormalModule extends Module {
 	}
 
 	getHashDigest(dependencyTemplates) {
+		// TODO webpack 5 refactor
 		let dtHash = dependencyTemplates.get("hash");
 		return `${this.hash}-${dtHash}`;
 	}

package/lib/RuleSet.js

@@ -75,13 +75,13 @@ normalized:
 "use strict";
 
 const notMatcher = matcher => {
-	return function(str) {
+	return str => {
 		return !matcher(str);
 	};
 };
 
 const orMatcher = items => {
-	return function(str) {
+	return str => {
 		for (let i = 0; i < items.length; i++) {
 			if (items[i](str)) return true;
 		}
@@ -90,7 +90,7 @@ const orMatcher = items => {
 };
 
 const andMatcher = items => {
-	return function(str) {
+	return str => {
 		for (let i = 0; i < items.length; i++) {
 			if (!items[i](str)) return false;
 		}