webpack 4.16.1 → 4.16.5

package/hot/log.js

@@ -30,9 +30,11 @@ module.exports = function(level, msg) {
 	}
 };
 
+/* eslint-disable node/no-unsupported-features/node-builtins */
 var group = console.group || dummy;
 var groupCollapsed = console.groupCollapsed || dummy;
 var groupEnd = console.groupEnd || dummy;
+/* eslint-enable node/no-unsupported-features/node-builtins */
 
 module.exports.group = logGroup(group);
 

package/lib/Chunk.js

@@ -8,6 +8,7 @@ const util = require("util");
 const SortableSet = require("./util/SortableSet");
 const intersect = require("./util/SetHelpers").intersect;
 const GraphHelpers = require("./GraphHelpers");
+const Entrypoint = require("./Entrypoint");
 let debugId = 1000;
 const ERR_CHUNK_ENTRY = "Chunk.entry was removed. Use hasRuntime()";
 const ERR_CHUNK_INITIAL =
@@ -123,9 +124,6 @@ class Chunk {
 		this._modules = new SortableSet(undefined, sortByIdentifier);
 		/** @type {string?} */
 		this.filenameTemplate = undefined;
-
-		/** @private */
-		this._groups = new SortableSet(undefined, sortChunkGroupById);
 		/** @private @type {SortableSet<ChunkGroup>} */
 		this._groups = new SortableSet(undefined, sortChunkGroupById);
 		/** @type {string[]} */
@@ -185,7 +183,11 @@ class Chunk {
 	hasRuntime() {
 		for (const chunkGroup of this._groups) {
 			// We only need to check the first one
-			return chunkGroup.isInitial() && chunkGroup.getRuntimeChunk() === this;
+			return (
+				chunkGroup.isInitial() &&
+				chunkGroup instanceof Entrypoint &&
+				chunkGroup.getRuntimeChunk() === this
+			);
 		}
 		return false;
 	}
@@ -749,17 +751,37 @@ class Chunk {
 // TODO remove in webpack 5
 Object.defineProperty(Chunk.prototype, "forEachModule", {
 	configurable: false,
-	value: util.deprecate(function(fn) {
-		this._modules.forEach(fn);
-	}, "Chunk.forEachModule: Use for(const module of chunk.modulesIterable) instead")
+	value: util.deprecate(
+		/**
+		 * @deprecated
+		 * @this {Chunk}
+		 * @typedef {function(any, any, Set<any>): void} ForEachModuleCallback
+		 * @param {ForEachModuleCallback} fn Callback function
+		 * @returns {void}
+		 */
+		function(fn) {
+			this._modules.forEach(fn);
+		},
+		"Chunk.forEachModule: Use for(const module of chunk.modulesIterable) instead"
+	)
 });
 
 // TODO remove in webpack 5
 Object.defineProperty(Chunk.prototype, "mapModules", {
 	configurable: false,
-	value: util.deprecate(function(fn) {
-		return Array.from(this._modules, fn);
-	}, "Chunk.mapModules: Use Array.from(chunk.modulesIterable, fn) instead")
+	value: util.deprecate(
+		/**
+		 * @deprecated
+		 * @this {Chunk}
+		 * @typedef {function(any, number): any} MapModulesCallback
+		 * @param {MapModulesCallback} fn Callback function
+		 * @returns {TODO[]} result of mapped modules
+		 */
+		function(fn) {
+			return Array.from(this._modules, fn);
+		},
+		"Chunk.mapModules: Use Array.from(chunk.modulesIterable, fn) instead"
+	)
 });
 
 // TODO remove in webpack 5

package/lib/ChunkGroup.js

@@ -11,7 +11,6 @@ const compareLocations = require("./compareLocations");
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleReason")} ModuleReason */
 
-/** @typedef {{id: number}} HasId */
 /** @typedef {{module: Module, loc: TODO, request: string}} OriginRecord */
 /** @typedef {string|{name: string}} ChunkGroupOptions */
 
@@ -26,8 +25,8 @@ const getArray = set => Array.from(set);
 
 /**
  * A convenience method used to sort chunks based on their id's
- * @param {HasId} a first sorting comparator
- * @param {HasId} b second sorting comparator
+ * @param {ChunkGroup} a first sorting comparator
+ * @param {ChunkGroup} b second sorting comparator
  * @returns {1|0|-1} a sorting index to determine order
  */
 const sortById = (a, b) => {
@@ -63,6 +62,7 @@ class ChunkGroup {
 		/** @type {number} */
 		this.groupDebugId = debugId++;
 		this.options = options;
+		/** @type {SortableSet<ChunkGroup>} */
 		this._children = new SortableSet(undefined, sortById);
 		this._parents = new SortableSet(undefined, sortById);
 		this._blocks = new SortableSet();

package/lib/Compilation.js

@@ -1025,6 +1025,7 @@ class Compilation extends Tapable {
 	addEntry(context, entry, name, callback) {
 		const slot = {
 			name: name,
+			// TODO webpack 5 remove `request`
 			request: null,
 			module: null
 		};
@@ -1033,7 +1034,14 @@ class Compilation extends Tapable {
 			slot.request = entry.request;
 		}
 
-		this._preparedEntrypoints.push(slot);
+		// TODO webpack 5: merge modules instead when multiple entry modules are supported
+		const idx = this._preparedEntrypoints.findIndex(slot => slot.name === name);
+		if (idx >= 0) {
+			// Overwrite existing entrypoint
+			this._preparedEntrypoints[idx] = slot;
+		} else {
+			this._preparedEntrypoints.push(slot);
+		}
 		this._addModuleChain(
 			context,
 			entry,
@@ -1049,7 +1057,9 @@ class Compilation extends Tapable {
 					slot.module = module;
 				} else {
 					const idx = this._preparedEntrypoints.indexOf(slot);
-					this._preparedEntrypoints.splice(idx, 1);
+					if (idx >= 0) {
+						this._preparedEntrypoints.splice(idx, 1);
+					}
 				}
 				return callback(null, module);
 			}
@@ -1572,6 +1582,9 @@ class Compilation extends Tapable {
 		/** @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;
@@ -1731,6 +1744,10 @@ class Compilation extends Tapable {
 
 						// Traverse all Blocks
 						iterationOfArrayCallback(blockInfo.blocks, iteratorBlock);
+
+						if (blockInfo.blocks.length > 0 && module !== block) {
+							blocksWithNestedBlocks.add(block);
+						}
 						break;
 					}
 					case LEAVE_MODULE: {
@@ -1792,6 +1809,7 @@ class Compilation extends Tapable {
 		 */
 		const filterFn = dep => {
 			const depChunkGroup = dep.chunkGroup;
+			if (blocksWithNestedBlocks.has(dep.block)) return true;
 			if (areModulesAvailable(depChunkGroup, newAvailableModules)) return false; // break all modules are already available
 			return true;
 		};
@@ -2442,21 +2460,48 @@ class Compilation extends Tapable {
 }
 
 // TODO remove in webpack 5
-Compilation.prototype.applyPlugins = util.deprecate(function(name, ...args) {
-	this.hooks[
-		name.replace(/[- ]([a-z])/g, match => match[1].toUpperCase())
-	].call(...args);
-}, "Compilation.applyPlugins is deprecated. Use new API on `.hooks` instead");
+Compilation.prototype.applyPlugins = util.deprecate(
+	/**
+	 * @deprecated
+	 * @param {string} name Name
+	 * @param {any[]} args Other arguments
+	 * @returns {void}
+	 * @this {Compilation}
+	 */
+	function(name, ...args) {
+		this.hooks[
+			name.replace(/[- ]([a-z])/g, match => match[1].toUpperCase())
+		].call(...args);
+	},
+	"Compilation.applyPlugins is deprecated. Use new API on `.hooks` instead"
+);
 
 // TODO remove in webpack 5
 Object.defineProperty(Compilation.prototype, "moduleTemplate", {
 	configurable: false,
-	get: util.deprecate(function() {
-		return this.moduleTemplates.javascript;
-	}, "Compilation.moduleTemplate: Use Compilation.moduleTemplates.javascript instead"),
-	set: util.deprecate(function(value) {
-		this.moduleTemplates.javascript = value;
-	}, "Compilation.moduleTemplate: Use Compilation.moduleTemplates.javascript instead.")
+	get: util.deprecate(
+		/**
+		 * @deprecated
+		 * @this {Compilation}
+		 * @returns {TODO} module template
+		 */
+		function() {
+			return this.moduleTemplates.javascript;
+		},
+		"Compilation.moduleTemplate: Use Compilation.moduleTemplates.javascript instead"
+	),
+	set: util.deprecate(
+		/**
+		 * @deprecated
+		 * @param {ModuleTemplate} value Template value
+		 * @this {Compilation}
+		 * @returns {void}
+		 */
+		function(value) {
+			this.moduleTemplates.javascript = value;
+		},
+		"Compilation.moduleTemplate: Use Compilation.moduleTemplates.javascript instead."
+	)
 });
 
 module.exports = Compilation;

package/lib/ContextExclusionPlugin.js

@@ -1,10 +1,21 @@
 "use strict";
 
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./ContextModuleFactory")} ContextModuleFactory */
+
 class ContextExclusionPlugin {
+	/**
+	 * @param {RegExp} negativeMatcher Matcher regular expression
+	 */
 	constructor(negativeMatcher) {
 		this.negativeMatcher = negativeMatcher;
 	}
 
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler Webpack Compiler
+	 * @returns {void}
+	 */
 	apply(compiler) {
 		compiler.hooks.contextModuleFactory.tap("ContextExclusionPlugin", cmf => {
 			cmf.hooks.contextModuleFiles.tap("ContextExclusionPlugin", files => {

package/lib/ContextModule.js

@@ -10,6 +10,7 @@ const AsyncDependenciesBlock = require("./AsyncDependenciesBlock");
 const Template = require("./Template");
 const contextify = require("./util/identifier").contextify;
 
+/** @typedef {"sync" | "eager" | "weak" | "async-weak" | "lazy" | "lazy-once"} ContextMode Context mode */
 /** @typedef {import("./dependencies/ContextElementDependency")} ContextElementDependency */
 
 /**
@@ -703,56 +704,141 @@ webpackEmptyAsyncContext.id = ${JSON.stringify(id)};`;
 // TODO remove in webpack 5
 Object.defineProperty(ContextModule.prototype, "recursive", {
 	configurable: false,
-	get: util.deprecate(function() {
-		return this.options.recursive;
-	}, "ContextModule.recursive has been moved to ContextModule.options.recursive"),
-	set: util.deprecate(function(value) {
-		this.options.recursive = value;
-	}, "ContextModule.recursive has been moved to ContextModule.options.recursive")
+	get: util.deprecate(
+		/**
+		 * @deprecated
+		 * @this {ContextModule}
+		 * @returns {boolean} is recursive
+		 */
+		function() {
+			return this.options.recursive;
+		},
+		"ContextModule.recursive has been moved to ContextModule.options.recursive"
+	),
+	set: util.deprecate(
+		/**
+		 * @deprecated
+		 * @this {ContextModule}
+		 * @param {boolean} value is recursive
+		 * @returns {void}
+		 */
+		function(value) {
+			this.options.recursive = value;
+		},
+		"ContextModule.recursive has been moved to ContextModule.options.recursive"
+	)
 });
 
 // TODO remove in webpack 5
 Object.defineProperty(ContextModule.prototype, "regExp", {
 	configurable: false,
-	get: util.deprecate(function() {
-		return this.options.regExp;
-	}, "ContextModule.regExp has been moved to ContextModule.options.regExp"),
-	set: util.deprecate(function(value) {
-		this.options.regExp = value;
-	}, "ContextModule.regExp has been moved to ContextModule.options.regExp")
+	get: util.deprecate(
+		/**
+		 * @deprecated
+		 * @this {ContextModule}
+		 * @returns {RegExp} regular expression
+		 */
+		function() {
+			return this.options.regExp;
+		},
+		"ContextModule.regExp has been moved to ContextModule.options.regExp"
+	),
+	set: util.deprecate(
+		/**
+		 * @deprecated
+		 * @this {ContextModule}
+		 * @param {RegExp} value Regular expression
+		 * @returns {void}
+		 */
+		function(value) {
+			this.options.regExp = value;
+		},
+		"ContextModule.regExp has been moved to ContextModule.options.regExp"
+	)
 });
 
 // TODO remove in webpack 5
 Object.defineProperty(ContextModule.prototype, "addon", {
 	configurable: false,
-	get: util.deprecate(function() {
-		return this.options.addon;
-	}, "ContextModule.addon has been moved to ContextModule.options.addon"),
-	set: util.deprecate(function(value) {
-		this.options.addon = value;
-	}, "ContextModule.addon has been moved to ContextModule.options.addon")
+	get: util.deprecate(
+		/**
+		 * @deprecated
+		 * @this {ContextModule}
+		 * @returns {string} addon
+		 */
+		function() {
+			return this.options.addon;
+		},
+		"ContextModule.addon has been moved to ContextModule.options.addon"
+	),
+	set: util.deprecate(
+		/**
+		 * @deprecated
+		 * @this {ContextModule}
+		 * @param {string} value addon
+		 * @returns {void}
+		 */
+		function(value) {
+			this.options.addon = value;
+		},
+		"ContextModule.addon has been moved to ContextModule.options.addon"
+	)
 });
 
 // TODO remove in webpack 5
 Object.defineProperty(ContextModule.prototype, "async", {
 	configurable: false,
-	get: util.deprecate(function() {
-		return this.options.mode;
-	}, "ContextModule.async has been moved to ContextModule.options.mode"),
-	set: util.deprecate(function(value) {
-		this.options.mode = value;
-	}, "ContextModule.async has been moved to ContextModule.options.mode")
+	get: util.deprecate(
+		/**
+		 * @deprecated
+		 * @this {ContextModule}
+		 * @returns {boolean} is async
+		 */
+		function() {
+			return this.options.mode;
+		},
+		"ContextModule.async has been moved to ContextModule.options.mode"
+	),
+	set: util.deprecate(
+		/**
+		 * @deprecated
+		 * @this {ContextModule}
+		 * @param {ContextMode} value Context mode
+		 * @returns {void}
+		 */
+		function(value) {
+			this.options.mode = value;
+		},
+		"ContextModule.async has been moved to ContextModule.options.mode"
+	)
 });
 
 // TODO remove in webpack 5
 Object.defineProperty(ContextModule.prototype, "chunkName", {
 	configurable: false,
-	get: util.deprecate(function() {
-		return this.options.chunkName;
-	}, "ContextModule.chunkName has been moved to ContextModule.options.chunkName"),
-	set: util.deprecate(function(value) {
-		this.options.chunkName = value;
-	}, "ContextModule.chunkName has been moved to ContextModule.options.chunkName")
+	get: util.deprecate(
+		/**
+		 * @deprecated
+		 * @this {ContextModule}
+		 * @returns {string} chunk name
+		 */
+		function() {
+			return this.options.chunkName;
+		},
+		"ContextModule.chunkName has been moved to ContextModule.options.chunkName"
+	),
+	set: util.deprecate(
+		/**
+		 * @deprecated
+		 * @this {ContextModule}
+		 * @param {string} value chunk name
+		 * @returns {void}
+		 */
+		function(value) {
+			this.options.chunkName = value;
+		},
+		"ContextModule.chunkName has been moved to ContextModule.options.chunkName"
+	)
 });
 
 module.exports = ContextModule;

package/lib/ContextModuleFactory.js

@@ -15,15 +15,21 @@ const {
 const ContextModule = require("./ContextModule");
 const ContextElementDependency = require("./dependencies/ContextElementDependency");
 
+/** @typedef {import("./Module")} Module */
+
 const EMPTY_RESOLVE_OPTIONS = {};
 
 module.exports = class ContextModuleFactory extends Tapable {
 	constructor(resolverFactory) {
 		super();
 		this.hooks = {
+			/** @type {AsyncSeriesWaterfallHook<TODO>} */
 			beforeResolve: new AsyncSeriesWaterfallHook(["data"]),
+			/** @type {AsyncSeriesWaterfallHook<TODO>} */
 			afterResolve: new AsyncSeriesWaterfallHook(["data"]),
+			/** @type {SyncWaterfallHook<string[]>} */
 			contextModuleFiles: new SyncWaterfallHook(["files"]),
+			/** @type {SyncWaterfallHook<TODO[]>} */
 			alternatives: new AsyncSeriesWaterfallHook(["modules"])
 		};
 		this._pluginCompat.tap("ContextModuleFactory", options => {

package/lib/DelegatedModule.js

@@ -12,6 +12,7 @@ const DelegatedSourceDependency = require("./dependencies/DelegatedSourceDepende
 const DelegatedExportsDependency = require("./dependencies/DelegatedExportsDependency");
 
 /** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
+/** @typedef {import("./util/createHash").Hash} Hash */
 
 class DelegatedModule extends Module {
 	constructor(sourceRequest, data, type, userRequest, originalRequest) {
@@ -99,6 +100,10 @@ class DelegatedModule extends Module {
 		return 42;
 	}
 
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @returns {void}
+	 */
 	updateHash(hash) {
 		hash.update(this.type);
 		hash.update(JSON.stringify(this.request));

package/lib/DependenciesBlock.js

@@ -73,7 +73,7 @@ class DependenciesBlock {
 	}
 
 	/**
-	 * @param {Hash} hash the hash used to track dependencies, from "crypto" module
+	 * @param {Hash} hash the hash used to track dependencies
 	 * @returns {void}
 	 */
 	updateHash(hash) {

package/lib/DllModule.js

@@ -7,6 +7,8 @@
 const { RawSource } = require("webpack-sources");
 const Module = require("./Module");
 
+/** @typedef {import("./util/createHash").Hash} Hash */
+
 class DllModule extends Module {
 	constructor(context, dependencies, name, type) {
 		super("javascript/dynamic", context);
@@ -44,6 +46,10 @@ class DllModule extends Module {
 		return 12;
 	}
 
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @returns {void}
+	 */
 	updateHash(hash) {
 		hash.update("dll module");
 		hash.update(this.name || "");

package/lib/DllReferencePlugin.js

@@ -10,6 +10,8 @@ const DelegatedModuleFactoryPlugin = require("./DelegatedModuleFactoryPlugin");
 const ExternalModuleFactoryPlugin = require("./ExternalModuleFactoryPlugin");
 const DelegatedExportsDependency = require("./dependencies/DelegatedExportsDependency");
 const NullFactory = require("./NullFactory");
+const makePathsRelative = require("./util/identifier").makePathsRelative;
+const WebpackError = require("./WebpackError");
 
 const validateOptions = require("schema-utils");
 const schema = require("../schemas/plugins/DllReferencePlugin.json");
@@ -43,9 +45,23 @@ class DllReferencePlugin {
 					params.compilationDependencies.add(manifest);
 					compiler.inputFileSystem.readFile(manifest, (err, result) => {
 						if (err) return callback(err);
-						params["dll reference " + manifest] = parseJson(
-							result.toString("utf-8")
-						);
+						// Catch errors parsing the manifest so that blank
+						// or malformed manifest files don't kill the process.
+						try {
+							params["dll reference " + manifest] = parseJson(
+								result.toString("utf-8")
+							);
+						} catch (e) {
+							// Store the error in the params so that it can
+							// be added as a compilation error later on.
+							const manifestPath = makePathsRelative(
+								compiler.options.context,
+								manifest
+							);
+							params[
+								"dll reference parse error " + manifest
+							] = new DllManifestError(manifestPath, e.message);
+						}
 						return callback();
 					});
 				} else {
@@ -57,6 +73,12 @@ class DllReferencePlugin {
 		compiler.hooks.compile.tap("DllReferencePlugin", params => {
 			let manifest = this.options.manifest;
 			if (typeof manifest === "string") {
+				// If there was an error parsing the manifest
+				// file, exit now because the error will be added
+				// as a compilation error in the "compilation" hook.
+				if (params["dll reference parse error " + manifest]) {
+					return;
+				}
 				manifest = params["dll reference " + manifest];
 			}
 			const name = this.options.name || manifest.name;
@@ -78,6 +100,32 @@ class DllReferencePlugin {
 				extensions: this.options.extensions
 			}).apply(normalModuleFactory);
 		});
+
+		compiler.hooks.compilation.tap(
+			"DllReferencePlugin",
+			(compilation, params) => {
+				let manifest = this.options.manifest;
+				if (typeof manifest === "string") {
+					// If there was an error parsing the manifest file, add the
+					// error as a compilation error to make the compilation fail.
+					let e = params["dll reference parse error " + manifest];
+					if (e) {
+						compilation.errors.push(e);
+					}
+				}
+			}
+		);
+	}
+}
+
+class DllManifestError extends WebpackError {
+	constructor(filename, message) {
+		super();
+
+		this.name = "DllManifestError";
+		this.message = `Dll manifest ${filename}\n${message}`;
+
+		Error.captureStackTrace(this, this.constructor);
 	}
 }
 

package/lib/ExternalModule.js

@@ -9,6 +9,8 @@ const Module = require("./Module");
 const WebpackMissingModule = require("./dependencies/WebpackMissingModule");
 const Template = require("./Template");
 
+/** @typedef {import("./util/createHash").Hash} Hash */
+
 class ExternalModule extends Module {
 	constructor(request, type, userRequest) {
 		super("javascript/dynamic", null);
@@ -148,6 +150,10 @@ class ExternalModule extends Module {
 		return 42;
 	}
 
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @returns {void}
+	 */
 	updateHash(hash) {
 		hash.update(this.externalType);
 		hash.update(JSON.stringify(this.request));

package/lib/Generator.js

@@ -4,9 +4,10 @@
 */
 "use strict";
 
-/** @typedef {import("./Module")} Module */
+/** @typedef {import("./NormalModule")} NormalModule */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./Dependency").DependencyTemplate} DependencyTemplate */
 
 /**
  *
@@ -18,8 +19,8 @@ class Generator {
 
 	/**
 	 * @abstract
-	 * @param {Module} module module for which the code should be generated
-	 * @param {Map<Function, TODO>} dependencyTemplates mapping from dependencies to templates
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {Map<Function, DependencyTemplate>} dependencyTemplates mapping from dependencies to templates
 	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
 	 * @param {string} type which kind of code should be generated
 	 * @returns {Source} generated code
@@ -35,6 +36,13 @@ class ByTypeGenerator extends Generator {
 		this.map = map;
 	}
 
+	/**
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {Map<Function, DependencyTemplate>} dependencyTemplates mapping from dependencies to templates
+	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
+	 * @param {string} type which kind of code should be generated
+	 * @returns {Source} generated code
+	 */
 	generate(module, dependencyTemplates, runtimeTemplate, type) {
 		const generator = this.map[type];
 		if (!generator) {

package/lib/HotModuleReplacementPlugin.js

@@ -285,11 +285,7 @@ module.exports = class HotModuleReplacementPlugin {
 									compilation.assets[filename] = source;
 									hotUpdateMainContent.c[chunkId] = true;
 									currentChunk.files.push(filename);
-									compilation.hooks.chunkAsset.call(
-										"HotModuleReplacementPlugin",
-										currentChunk,
-										filename
-									);
+									compilation.hooks.chunkAsset.call(currentChunk, filename);
 								}
 							} else {
 								hotUpdateMainContent.c[chunkId] = false;