webpack 4.14.0 → 4.15.1

package/lib/WebpackOptionsValidationError.js

@@ -332,7 +332,6 @@ class WebpackOptionsValidationError extends WebpackError {
 			}
 			return baseMessage;
 		} else {
-			// eslint-disable-line no-fallthrough
 			return `${dataPath} ${err.message} (${JSON.stringify(
 				err,
 				null,

package/lib/compareLocations.js

@@ -4,23 +4,13 @@
 */
 "use strict";
 
-/**
- * @typedef {Object} LineAndColumn
- * @property {number=} line
- * @property {number=} column
- */
-
-/**
- * @typedef {Object} NodeLocation
- * @property {LineAndColumn=} start
- * @property {LineAndColumn=} end
- * @property {number=} index
- */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 
+// TODO webpack 5 remove string type from a and b
 /**
  * Compare two locations
- * @param {string|NodeLocation} a A location node
- * @param {string|NodeLocation} b A location node
+ * @param {string|DependencyLocation} a A location node
+ * @param {string|DependencyLocation} b A location node
  * @returns {-1|0|1} sorting comparator value
  */
 module.exports = (a, b) => {
@@ -38,7 +28,7 @@ module.exports = (a, b) => {
 		if (typeof b === "string") {
 			return -1;
 		} else if (typeof b === "object") {
-			if (a.start && b.start) {
+			if ("start" in a && "start" in b) {
 				const ap = a.start;
 				const bp = b.start;
 				if (ap.line < bp.line) return -1;
@@ -46,8 +36,14 @@ module.exports = (a, b) => {
 				if (ap.column < bp.column) return -1;
 				if (ap.column > bp.column) return 1;
 			}
-			if (a.index < b.index) return -1;
-			if (a.index > b.index) return 1;
+			if ("name" in a && "name" in b) {
+				if (a.name < b.name) return -1;
+				if (a.name > b.name) return 1;
+			}
+			if ("index" in a && "index" in b) {
+				if (a.index < b.index) return -1;
+				if (a.index > b.index) return 1;
+			}
 			return 0;
 		} else {
 			return 0;

package/lib/debug/ProfilingPlugin.js

@@ -5,7 +5,8 @@ const schema = require("../../schemas/plugins/debug/ProfilingPlugin.json");
 let inspector = undefined;
 
 try {
-	inspector = require("inspector"); // eslint-disable-line node/no-missing-require
+	// eslint-disable-next-line node/no-missing-require
+	inspector = require("inspector");
 } catch (e) {
 	console.log("Unable to CPU profile in < node 8.0");
 }
@@ -84,7 +85,7 @@ class Profiler {
  * @param {string} outputPath The location where to write the log.
  * @returns {Trace} The trace object
  */
-function createTrace(outputPath) {
+const createTrace = outputPath => {
 	const trace = new Tracer({
 		noStream: true
 	});
@@ -136,10 +137,10 @@ function createTrace(outputPath) {
 				callback();
 			});
 			// Tear down the readable trace stream.
-			trace.destroy();
+			trace.push(null);
 		}
 	};
-}
+};
 
 const pluginName = "ProfilingPlugin";
 
@@ -354,7 +355,6 @@ const makeNewProfiledTapFn = (hookName, tracer, { name, type, fn }) => {
 	switch (type) {
 		case "promise":
 			return (...args) => {
-				// eslint-disable-line
 				const id = ++tracer.counter;
 				tracer.trace.begin({
 					name,
@@ -373,7 +373,6 @@ const makeNewProfiledTapFn = (hookName, tracer, { name, type, fn }) => {
 			};
 		case "async":
 			return (...args) => {
-				// eslint-disable-line
 				const id = ++tracer.counter;
 				tracer.trace.begin({
 					name,
@@ -392,7 +391,6 @@ const makeNewProfiledTapFn = (hookName, tracer, { name, type, fn }) => {
 			};
 		case "sync":
 			return (...args) => {
-				// eslint-disable-line
 				const id = ++tracer.counter;
 				// Do not instrument ourself due to the CPU
 				// profile needing to be the last event in the trace.

package/lib/dependencies/AMDDefineDependencyParserPlugin.js

@@ -23,17 +23,17 @@ const isBoundFunctionExpression = expr => {
 	return true;
 };
 
-function isUnboundFunctionExpression(expr) {
+const isUnboundFunctionExpression = expr => {
 	if (expr.type === "FunctionExpression") return true;
 	if (expr.type === "ArrowFunctionExpression") return true;
 	return false;
-}
+};
 
-function isCallable(expr) {
+const isCallable = expr => {
 	if (isUnboundFunctionExpression(expr)) return true;
 	if (isBoundFunctionExpression(expr)) return true;
 	return false;
-}
+};
 
 class AMDDefineDependencyParserPlugin {
 	constructor(options) {
@@ -80,7 +80,6 @@ class AMDDefineDependencyParserPlugin {
 						request
 					))
 				) {
-					// eslint-disable-line no-cond-assign
 					dep = new LocalModuleDependency(localModule, undefined, false);
 					dep.loc = expr.loc;
 					parser.state.current.addDependency(dep);
@@ -121,7 +120,6 @@ class AMDDefineDependencyParserPlugin {
 					namedModule
 				))
 			) {
-				// eslint-disable-line no-cond-assign
 				dep = new LocalModuleDependency(localModule, param.range, false);
 			} else {
 				dep = this.newRequireItemDependency(param.string, param.range);

package/lib/dependencies/AMDRequireDependenciesBlockParserPlugin.js

@@ -79,7 +79,6 @@ class AMDRequireDependenciesBlockParserPlugin {
 						request
 					))
 				) {
-					// eslint-disable-line no-cond-assign
 					dep = new LocalModuleDependency(localModule, undefined, false);
 					dep.loc = expr.loc;
 					parser.state.current.addDependency(dep);
@@ -127,7 +126,6 @@ class AMDRequireDependenciesBlockParserPlugin {
 					param.string
 				))
 			) {
-				// eslint-disable-line no-cond-assign
 				dep = new LocalModuleDependency(localModule, param.range, false);
 			} else {
 				dep = this.newRequireItemDependency(param.string, param.range);

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,7 @@
 "use strict";
 
 const LoaderDependency = require("./LoaderDependency");
+const NormalModule = require("../NormalModule");
 
 class LoaderPlugin {
 	apply(compiler) {
@@ -57,7 +58,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/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/optimize/ConcatenatedModule.js

@@ -639,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/SplitChunksPlugin.js

@@ -8,9 +8,16 @@ const crypto = require("crypto");
 const SortableSet = require("../util/SortableSet");
 const GraphHelpers = require("../GraphHelpers");
 const { isSubset } = require("../util/SetHelpers");
+const deterministicGrouping = require("../util/deterministicGrouping");
+const contextify = require("../util/identifier").contextify;
 
+/** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../util/deterministicGrouping").Options<Module>} DeterministicGroupingOptionsForModule */
+/** @typedef {import("../util/deterministicGrouping").GroupedItems<Module>} DeterministicGroupingGroupedItemsForModule */
+
+const deterministicGroupingForModules = /** @type {function(DeterministicGroupingOptionsForModule): DeterministicGroupingGroupedItemsForModule[]} */ (deterministicGrouping);
 
 const hashFilename = name => {
 	return crypto
@@ -104,6 +111,7 @@ module.exports = class SplitChunksPlugin {
 				options.chunks || "all"
 			),
 			minSize: options.minSize || 0,
+			maxSize: options.maxSize || 0,
 			minChunks: options.minChunks || 1,
 			maxAsyncRequests: options.maxAsyncRequests || 1,
 			maxInitialRequests: options.maxInitialRequests || 1,
@@ -112,17 +120,24 @@ module.exports = class SplitChunksPlugin {
 					name: options.name,
 					automaticNameDelimiter: options.automaticNameDelimiter
 				}) || (() => {}),
+			hidePathInfo: options.hidePathInfo || false,
 			filename: options.filename || undefined,
 			getCacheGroups: SplitChunksPlugin.normalizeCacheGroups({
 				cacheGroups: options.cacheGroups,
 				automaticNameDelimiter: options.automaticNameDelimiter
-			})
+			}),
+			automaticNameDelimiter: options.automaticNameDelimiter,
+			fallbackCacheGroup: SplitChunksPlugin.normalizeFallbackCacheGroup(
+				options.fallbackCacheGroup || {},
+				options
+			)
 		};
 	}
 
 	static normalizeName({ name, automaticNameDelimiter }) {
 		if (name === true) {
-			const cache = new Map();
+			/** @type {WeakMap<Chunk[], Record<string, string>>} */
+			const cache = new WeakMap();
 			const fn = (module, chunks, cacheGroup) => {
 				let cacheEntry = cache.get(chunks);
 				if (cacheEntry === undefined) {
@@ -177,6 +192,26 @@ module.exports = class SplitChunksPlugin {
 		if (typeof chunks === "function") return chunks;
 	}
 
+	static normalizeFallbackCacheGroup(
+		{
+			minSize = undefined,
+			maxSize = undefined,
+			automaticNameDelimiter = undefined
+		},
+		{
+			minSize: defaultMinSize = undefined,
+			maxSize: defaultMaxSize = undefined,
+			automaticNameDelimiter: defaultAutomaticNameDelimiter = undefined
+		}
+	) {
+		return {
+			minSize: typeof minSize === "number" ? minSize : defaultMinSize || 0,
+			maxSize: typeof maxSize === "number" ? maxSize : defaultMaxSize || 0,
+			automaticNameDelimiter:
+				automaticNameDelimiter || defaultAutomaticNameDelimiter || "~"
+		};
+	}
+
 	static normalizeCacheGroups({ cacheGroups, automaticNameDelimiter }) {
 		if (typeof cacheGroups === "function") {
 			// TODO webpack 5 remove this
@@ -225,6 +260,7 @@ module.exports = class SplitChunksPlugin {
 							),
 							enforce: option.enforce,
 							minSize: option.minSize,
+							maxSize: option.maxSize,
 							minChunks: option.minChunks,
 							maxAsyncRequests: option.maxAsyncRequests,
 							maxInitialRequests: option.maxInitialRequests,
@@ -278,6 +314,10 @@ module.exports = class SplitChunksPlugin {
 		return false;
 	}
 
+	/**
+	 * @param {Compiler} compiler webpack compiler
+	 * @returns {void}
+	 */
 	apply(compiler) {
 		compiler.hooks.thisCompilation.tap("SplitChunksPlugin", compilation => {
 			let alreadyOptimized = false;
@@ -486,6 +526,12 @@ module.exports = class SplitChunksPlugin {
 										: cacheGroupSource.enforce
 											? 0
 											: this.options.minSize,
+								maxSize:
+									cacheGroupSource.maxSize !== undefined
+										? cacheGroupSource.maxSize
+										: cacheGroupSource.enforce
+											? 0
+											: this.options.maxSize,
 								minChunks:
 									cacheGroupSource.minChunks !== undefined
 										? cacheGroupSource.minChunks
@@ -512,6 +558,10 @@ module.exports = class SplitChunksPlugin {
 									cacheGroupSource.filename !== undefined
 										? cacheGroupSource.filename
 										: this.options.filename,
+								automaticNameDelimiter:
+									cacheGroupSource.automaticNameDelimiter !== undefined
+										? cacheGroupSource.automaticNameDelimiter
+										: this.options.automaticNameDelimiter,
 								reuseExistingChunk: cacheGroupSource.reuseExistingChunk
 							};
 							// For all combination of chunk selection
@@ -537,6 +587,9 @@ module.exports = class SplitChunksPlugin {
 						}
 					}
 
+					/** @type {Map<Chunk, {minSize: number, maxSize: number, automaticNameDelimiter: string}>} */
+					const maxSizeQueueMap = new Map();
+
 					while (chunksInfoMap.size > 0) {
 						// Find best matching entry
 						let bestEntryKey;
@@ -563,6 +616,7 @@ module.exports = class SplitChunksPlugin {
 
 						let chunkName = item.name;
 						// Variable for the new chunk (lazy created)
+						/** @type {Chunk} */
 						let newChunk;
 						// When no chunk name, check if we can reuse a chunk instead of creating a new one
 						let isReused = false;
@@ -689,6 +743,22 @@ module.exports = class SplitChunksPlugin {
 								}
 							}
 						}
+
+						if (item.cacheGroup.maxSize > 0) {
+							const oldMaxSizeSettings = maxSizeQueueMap.get(newChunk);
+							maxSizeQueueMap.set(newChunk, {
+								minSize: Math.max(
+									oldMaxSizeSettings ? oldMaxSizeSettings.minSize : 0,
+									item.cacheGroup.minSize
+								),
+								maxSize: Math.min(
+									oldMaxSizeSettings ? oldMaxSizeSettings.maxSize : Infinity,
+									item.cacheGroup.maxSize
+								),
+								automaticNameDelimiter: item.cacheGroup.automaticNameDelimiter
+							});
+						}
+
 						// remove all modules from other entries and update size
 						for (const [key, info] of chunksInfoMap) {
 							if (isOverlap(info.chunks, item.chunks)) {
@@ -709,6 +779,76 @@ module.exports = class SplitChunksPlugin {
 							}
 						}
 					}
+
+					// Make sure that maxSize is fulfilled
+					for (const chunk of compilation.chunks.slice()) {
+						const { minSize, maxSize, automaticNameDelimiter } =
+							maxSizeQueueMap.get(chunk) || this.options.fallbackCacheGroup;
+						if (!maxSize) continue;
+						const results = deterministicGroupingForModules({
+							maxSize,
+							minSize,
+							items: chunk.modulesIterable,
+							getKey(module) {
+								const ident = contextify(
+									compilation.options.context,
+									module.identifier()
+								);
+								const name = module.nameForCondition
+									? contextify(
+											compilation.options.context,
+											module.nameForCondition()
+									  )
+									: ident.replace(/^.*!|\?[^?!]*$/g, "");
+								const fullKey =
+									name + automaticNameDelimiter + hashFilename(ident);
+								return fullKey.replace(/[\\/?]/g, "_");
+							},
+							getSize(module) {
+								return module.size();
+							}
+						});
+						results.sort((a, b) => {
+							if (a.key < b.key) return -1;
+							if (a.key > b.key) return 1;
+							return 0;
+						});
+						for (let i = 0; i < results.length; i++) {
+							const group = results[i];
+							const key = this.options.hidePathInfo
+								? hashFilename(group.key)
+								: group.key;
+							let name = chunk.name
+								? chunk.name + automaticNameDelimiter + key
+								: null;
+							if (name && name.length > 100) {
+								name =
+									name.slice(0, 100) +
+									automaticNameDelimiter +
+									hashFilename(name);
+							}
+							let newPart;
+							if (i !== results.length - 1) {
+								newPart = compilation.addChunk(name);
+								chunk.split(newPart);
+								// Add all modules to the new chunk
+								for (const module of group.items) {
+									if (typeof module.chunkCondition === "function") {
+										if (!module.chunkCondition(newPart)) continue;
+									}
+									// Add module to new chunk
+									GraphHelpers.connectChunkAndModule(newPart, module);
+									// Remove module from used chunks
+									chunk.removeModule(module);
+									module.rewriteChunkInReasons(chunk, [newPart]);
+								}
+							} else {
+								// change the chunk to be a part
+								newPart = chunk;
+								chunk.name = name;
+							}
+						}
+					}
 				}
 			);
 		});

package/lib/util/Semaphore.js

@@ -5,12 +5,24 @@
 "use strict";
 
 class Semaphore {
+	/**
+	 * Creates an instance of Semaphore.
+	 *
+	 * @param {number} available the amount available number of "tasks"
+	 * in the Semaphore
+	 */
 	constructor(available) {
 		this.available = available;
+		/** @type {(function(): void)[]} */
 		this.waiters = [];
+		/** @private */
 		this._continue = this._continue.bind(this);
 	}
 
+	/**
+	 * @param {function(): void} callback function block to capture and run
+	 * @returns {void}
+	 */
 	acquire(callback) {
 		if (this.available > 0) {
 			this.available--;

package/lib/util/SetHelpers.js

@@ -5,7 +5,7 @@
  * @param {Set[]} sets an array of sets being checked for shared elements
  * @returns {Set<TODO>} returns a new Set containing the intersecting items
  */
-function intersect(sets) {
+const intersect = sets => {
 	if (sets.length === 0) return new Set();
 	if (sets.length === 1) return new Set(sets[0]);
 	let minSize = Infinity;
@@ -28,7 +28,7 @@ function intersect(sets) {
 		}
 	}
 	return current;
-}
+};
 
 /**
  * Checks if a set is the subset of another set
@@ -36,13 +36,13 @@ function intersect(sets) {
  * @param {Set<TODO>} smallSet the set whos elements might be contained inside of bigSet
  * @returns {boolean} returns true if smallSet contains all elements inside of the bigSet
  */
-function isSubset(bigSet, smallSet) {
+const isSubset = (bigSet, smallSet) => {
 	if (bigSet.size < smallSet.size) return false;
 	for (const item of smallSet) {
 		if (!bigSet.has(item)) return false;
 	}
 	return true;
-}
+};
 
 exports.intersect = intersect;
 exports.isSubset = isSubset;

package/lib/util/SortableSet.js

@@ -7,7 +7,7 @@
 class SortableSet extends Set {
 	/**
 	 * Create a new sortable set
-	 * @param {Array<T>=} initialIterable The initial iterable value
+	 * @param {Iterable<T>=} initialIterable The initial iterable value
 	 * @typedef {function(T, T): number} SortFunction
 	 * @param {SortFunction=} defaultSort Default sorting function
 	 */

package/lib/util/createHash.js

@@ -4,8 +4,18 @@
 */
 "use strict";
 
+/** @typedef {{new(): Hash}} HashConstructor */
+/**
+ * @typedef {Object} Hash
+ * @property {function(string|Buffer, string=): Hash} update
+ * @property {function(string): string} digest
+ */
+
 const BULK_SIZE = 1000;
 
+/**
+ * @implements {Hash}
+ */
 class BulkUpdateDecorator {
 	constructor(hash) {
 		this.hash = hash;
@@ -63,6 +73,11 @@ class DebugHash {
 	}
 }
 
+/**
+ * Creates a hash by name or function
+ * @param {string | HashConstructor} algorithm the algorithm name or a constructor creating a hash
+ * @returns {Hash} the hash
+ */
 module.exports = algorithm => {
 	if (typeof algorithm === "function") {
 		return new BulkUpdateDecorator(new algorithm());