webpack 4.24.0 → 4.26.1

package/lib/ProgressPlugin.js

@@ -4,8 +4,15 @@
 */
 "use strict";
 
+const validateOptions = require("schema-utils");
+const schema = require("../schemas/plugins/ProgressPlugin.json");
+
+/** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginArgument} ProgressPluginArgument */
+/** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginOptions} ProgressPluginOptions */
+
 const createDefaultHandler = profile => {
 	let lineCaretPosition = 0;
+	let lastMessage = "";
 	let lastState;
 	let lastStateTime;
 
@@ -46,8 +53,11 @@ const createDefaultHandler = profile => {
 				lastStateTime = now;
 			}
 		}
-		goToLineStart(msg);
-		process.stderr.write(msg);
+		if (lastMessage !== msg) {
+			goToLineStart(msg);
+			process.stderr.write(msg);
+			lastMessage = msg;
+		}
 	};
 
 	const goToLineStart = nextMessage => {
@@ -66,19 +76,34 @@ const createDefaultHandler = profile => {
 };
 
 class ProgressPlugin {
+	/**
+	 * @param {ProgressPluginArgument} options options
+	 */
 	constructor(options) {
 		if (typeof options === "function") {
 			options = {
 				handler: options
 			};
 		}
+
 		options = options || {};
+		validateOptions(schema, options, "Progress Plugin");
+		options = Object.assign({}, ProgressPlugin.defaultOptions, options);
+
 		this.profile = options.profile;
 		this.handler = options.handler;
+		this.modulesCount = options.modulesCount;
+		this.showEntries = options.entries;
+		this.showModules = options.modules;
+		this.showActiveModules = options.activeModules;
 	}
 
 	apply(compiler) {
+		const { modulesCount } = this;
 		const handler = this.handler || createDefaultHandler(this.profile);
+		const showEntries = this.showEntries;
+		const showModules = this.showModules;
+		const showActiveModules = this.showActiveModules;
 		if (compiler.compilers) {
 			const states = new Array(compiler.compilers.length);
 			compiler.compilers.forEach((compiler, idx) => {
@@ -95,48 +120,97 @@ class ProgressPlugin {
 			});
 		} else {
 			let lastModulesCount = 0;
-			let moduleCount = 500;
+			let lastEntriesCount = 0;
+			let moduleCount = modulesCount;
+			let entriesCount = 1;
 			let doneModules = 0;
-			const activeModules = [];
-
-			const update = module => {
-				handler(
-					0.1 + (doneModules / Math.max(lastModulesCount, moduleCount)) * 0.6,
-					"building modules",
-					`${doneModules}/${moduleCount} modules`,
-					`${activeModules.length} active`,
-					activeModules[activeModules.length - 1]
-				);
+			let doneEntries = 0;
+			const activeModules = new Set();
+			let lastActiveModule = "";
+
+			const update = () => {
+				const percentByModules =
+					doneModules / Math.max(lastModulesCount, moduleCount);
+				const percentByEntries =
+					doneEntries / Math.max(lastEntriesCount, entriesCount);
+
+				const items = [
+					0.1 + Math.max(percentByModules, percentByEntries) * 0.6,
+					"building"
+				];
+				if (showEntries) {
+					items.push(`${doneEntries}/${entriesCount} entries`);
+				}
+				if (showModules) {
+					items.push(`${doneModules}/${moduleCount} modules`);
+				}
+				if (showActiveModules) {
+					items.push(`${activeModules.size} active`);
+					items.push(lastActiveModule);
+				}
+				handler(...items);
+			};
+
+			const moduleAdd = module => {
+				moduleCount++;
+				if (showActiveModules) {
+					const ident = module.identifier();
+					if (ident) {
+						activeModules.add(ident);
+						lastActiveModule = ident;
+					}
+				}
+				update();
+			};
+
+			const entryAdd = (entry, name) => {
+				entriesCount++;
+				update();
 			};
 
 			const moduleDone = module => {
 				doneModules++;
-				const ident = module.identifier();
-				if (ident) {
-					const idx = activeModules.indexOf(ident);
-					if (idx >= 0) activeModules.splice(idx, 1);
+				if (showActiveModules) {
+					const ident = module.identifier();
+					if (ident) {
+						activeModules.delete(ident);
+						if (lastActiveModule === ident) {
+							lastActiveModule = "";
+							for (const m of activeModules) {
+								lastActiveModule = m;
+							}
+						}
+					}
 				}
 				update();
 			};
+
+			const entryDone = (entry, name) => {
+				doneEntries++;
+				update();
+			};
+
 			compiler.hooks.compilation.tap("ProgressPlugin", compilation => {
 				if (compilation.compiler.isChild()) return;
 				lastModulesCount = moduleCount;
-				moduleCount = 0;
-				doneModules = 0;
+				lastEntriesCount = entriesCount;
+				moduleCount = entriesCount = 0;
+				doneModules = doneEntries = 0;
 				handler(0, "compiling");
-				compilation.hooks.buildModule.tap("ProgressPlugin", module => {
-					moduleCount++;
-					const ident = module.identifier();
-					if (ident) {
-						activeModules.push(ident);
-					}
-					update();
-				});
+
+				compilation.hooks.buildModule.tap("ProgressPlugin", moduleAdd);
 				compilation.hooks.failedModule.tap("ProgressPlugin", moduleDone);
 				compilation.hooks.succeedModule.tap("ProgressPlugin", moduleDone);
+
+				compilation.hooks.addEntry.tap("ProgressPlugin", entryAdd);
+				compilation.hooks.failedEntry.tap("ProgressPlugin", entryDone);
+				compilation.hooks.succeedEntry.tap("ProgressPlugin", entryDone);
+
 				const hooks = {
 					finishModules: "finish module graph",
 					seal: "sealing",
+					beforeChunks: "chunk graph",
+					afterChunks: "after chunk graph",
 					optimizeDependenciesBasic: "basic dependencies optimization",
 					optimizeDependencies: "dependencies optimization",
 					optimizeDependenciesAdvanced: "advanced dependencies optimization",
@@ -171,6 +245,7 @@ class ProgressPlugin {
 					recordModules: "record modules",
 					recordChunks: "record chunks",
 					beforeHash: "hashing",
+					contentHash: "content hashing",
 					afterHash: "after hashing",
 					recordHash: "record hash",
 					beforeModuleAssets: "module assets processing",
@@ -243,4 +318,14 @@ class ProgressPlugin {
 		}
 	}
 }
+
+ProgressPlugin.defaultOptions = {
+	profile: false,
+	modulesCount: 500,
+	modules: true,
+	activeModules: true,
+	// TODO webpack 5 default this to true
+	entries: false
+};
+
 module.exports = ProgressPlugin;

package/lib/ProvidePlugin.js

@@ -76,9 +76,8 @@ class ProvidePlugin {
 				normalModuleFactory.hooks.parser
 					.for("javascript/dynamic")
 					.tap("ProvidePlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("ProvidePlugin", handler);
+
+				// Disable ProvidePlugin for javascript/esm, see https://github.com/webpack/webpack/issues/7032
 			}
 		);
 	}

package/lib/WebpackOptionsDefaulter.js

@@ -302,10 +302,10 @@ class WebpackOptionsDefaulter extends OptionsDefaulter {
 		this.set("optimization.minimizer", "make", options => [
 			{
 				apply: compiler => {
-					// Lazy load the uglifyjs plugin
-					const UglifyJsPlugin = require("uglifyjs-webpack-plugin");
+					// Lazy load the Terser plugin
+					const TerserPlugin = require("terser-webpack-plugin");
 					const SourceMapDevToolPlugin = require("./SourceMapDevToolPlugin");
-					new UglifyJsPlugin({
+					new TerserPlugin({
 						cache: true,
 						parallel: true,
 						sourceMap:

package/lib/dependencies/AMDDefineDependencyParserPlugin.js

@@ -136,7 +136,9 @@ class AMDDefineDependencyParserPlugin {
 			param.range,
 			param,
 			expr,
-			this.options
+			this.options,
+			{},
+			parser
 		);
 		if (!dep) return;
 		dep.loc = expr.loc;

package/lib/dependencies/AMDRequireDependenciesBlockParserPlugin.js

@@ -142,7 +142,9 @@ class AMDRequireDependenciesBlockParserPlugin {
 			param.range,
 			param,
 			expr,
-			this.options
+			this.options,
+			{},
+			parser
 		);
 		if (!dep) return;
 		dep.loc = expr.loc;

package/lib/dependencies/CommonJsRequireDependencyParserPlugin.js

@@ -35,7 +35,9 @@ class CommonJsRequireDependencyParserPlugin {
 				expr.range,
 				param,
 				expr,
-				options
+				options,
+				{},
+				parser
 			);
 			if (!dep) return;
 			dep.loc = expr.loc;

package/lib/dependencies/ContextDependencyHelpers.js

@@ -47,7 +47,9 @@ ContextDependencyHelpers.create = (
 	param,
 	expr,
 	options,
-	contextOptions
+	contextOptions,
+	// when parser is not passed in, expressions won't be walked
+	parser = null
 ) => {
 	if (param.isTemplateString()) {
 		let prefixRaw = param.quasis[0].string;
@@ -55,19 +57,30 @@ ContextDependencyHelpers.create = (
 			param.quasis.length > 1
 				? param.quasis[param.quasis.length - 1].string
 				: "";
-		const prefixRange = [param.quasis[0].range[0], param.quasis[0].range[1]];
-		const postfixRange =
-			param.quasis.length > 1
-				? param.quasis[param.quasis.length - 1].range
-				: "";
+
 		const valueRange = param.range;
 		const { context, prefix } = splitContextFromPrefix(prefixRaw);
 		const { postfix, query } = splitQueryFromPostfix(postfixRaw);
-		// If there are more than two quasis, maybe the generated RegExp can be more precise?
+
+		// When there are more than two quasis, the generated RegExp can be more precise
+		// We join the quasis with the expression regexp
+		const innerQuasis = param.quasis.slice(1, param.quasis.length - 1);
+		const innerRegExp =
+			options.wrappedContextRegExp.source +
+			innerQuasis
+				.map(q => quotemeta(q.string) + options.wrappedContextRegExp.source)
+				.join("");
+
+		// Example: `./context/pre${e}inner${e}inner2${e}post?query`
+		// context: "./context"
+		// prefix: "./pre"
+		// innerQuasis: [BEE("inner"), BEE("inner2")]
+		// (BEE = BasicEvaluatedExpression)
+		// postfix: "post"
+		// query: "?query"
+		// regExp: /^\.\/pre.*inner.*inner2.*post$/
 		const regExp = new RegExp(
-			`^${quotemeta(prefix)}${options.wrappedContextRegExp.source}${quotemeta(
-				postfix
-			)}$`
+			`^${quotemeta(prefix)}${innerRegExp}${quotemeta(postfix)}$`
 		);
 		const dep = new Dep(
 			Object.assign(
@@ -84,18 +97,48 @@ ContextDependencyHelpers.create = (
 		);
 		dep.loc = expr.loc;
 		const replaces = [];
-		if (prefixRange && prefix !== prefixRaw) {
-			replaces.push({
-				range: prefixRange,
-				value: prefix
-			});
-		}
-		if (postfixRange && postfix !== postfixRaw) {
-			replaces.push({
-				range: postfixRange,
-				value: postfix
-			});
-		}
+
+		param.parts.forEach((part, i) => {
+			if (i % 2 === 0) {
+				// Quasis or merged quasi
+				let range = part.range;
+				let value = part.string;
+				if (param.templateStringKind === "cooked") {
+					value = JSON.stringify(value);
+					value = value.slice(1, value.length - 1);
+				}
+				if (i === 0) {
+					// prefix
+					value = prefix;
+					range = [param.range[0], part.range[1]];
+					value =
+						(param.templateStringKind === "cooked" ? "`" : "String.raw`") +
+						value;
+				} else if (i === param.parts.length - 1) {
+					// postfix
+					value = postfix;
+					range = [part.range[0], param.range[1]];
+					value = value + "`";
+				} else if (
+					part.expression &&
+					part.expression.type === "TemplateElement" &&
+					part.expression.value.raw === value
+				) {
+					// Shortcut when it's a single quasi and doesn't need to be replaced
+					return;
+				}
+				replaces.push({
+					range,
+					value
+				});
+			} else {
+				// Expression
+				if (parser) {
+					parser.walkExpression(part.expression);
+				}
+			}
+		});
+
 		dep.replaces = replaces;
 		dep.critical =
 			options.wrappedContextCritical &&
@@ -137,13 +180,13 @@ ContextDependencyHelpers.create = (
 		);
 		dep.loc = expr.loc;
 		const replaces = [];
-		if (prefixRange && prefix !== prefixRaw) {
+		if (prefixRange) {
 			replaces.push({
 				range: prefixRange,
 				value: JSON.stringify(prefix)
 			});
 		}
-		if (postfixRange && postfix !== postfixRaw) {
+		if (postfixRange) {
 			replaces.push({
 				range: postfixRange,
 				value: JSON.stringify(postfix)
@@ -153,6 +196,13 @@ ContextDependencyHelpers.create = (
 		dep.critical =
 			options.wrappedContextCritical &&
 			"a part of the request of a dependency is an expression";
+
+		if (parser && param.wrappedInnerExpressions) {
+			for (const part of param.wrappedInnerExpressions) {
+				if (part.expression) parser.walkExpression(part.expression);
+			}
+		}
+
 		return dep;
 	} else {
 		const dep = new Dep(
@@ -172,6 +222,11 @@ ContextDependencyHelpers.create = (
 		dep.critical =
 			options.exprContextCritical &&
 			"the request of a dependency is an expression";
+
+		if (parser) {
+			parser.walkExpression(param.expression);
+		}
+
 		return dep;
 	}
 };

package/lib/dependencies/ImportParserPlugin.js

@@ -248,7 +248,8 @@ class ImportParserPlugin {
 						namespaceObject: parser.state.module.buildMeta.strictHarmonyModule
 							? "strict"
 							: true
-					}
+					},
+					parser
 				);
 				if (!dep) return;
 				dep.loc = expr.loc;

package/lib/dependencies/RequireResolveDependencyParserPlugin.js

@@ -61,7 +61,8 @@ class RequireResolveDependencyParserPlugin {
 				options,
 				{
 					mode: weak ? "weak" : "sync"
-				}
+				},
+				parser
 			);
 			if (!dep) return;
 			dep.loc = expr.loc;

package/lib/optimize/SplitChunksPlugin.js

@@ -795,7 +795,7 @@ module.exports = class SplitChunksPlugin {
 							maxSizeQueueMap.get(chunk) || this.options.fallbackCacheGroup;
 						if (!maxSize) continue;
 						const results = deterministicGroupingForModules({
-							maxSize,
+							maxSize: Math.max(minSize, maxSize),
 							minSize,
 							items: chunk.modulesIterable,
 							getKey(module) {

package/lib/util/deterministicGrouping.js

@@ -124,6 +124,13 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 	/** @type {Node<T>[]} */
 	const initialNodes = [];
 
+	// lexically ordering of keys
+	nodes.sort((a, b) => {
+		if (a.key < b.key) return -1;
+		if (a.key > b.key) return 1;
+		return 0;
+	});
+
 	// return nodes bigger than maxSize directly as group
 	for (const node of nodes) {
 		if (node.size >= maxSize) {
@@ -134,13 +141,6 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 	}
 
 	if (initialNodes.length > 0) {
-		// lexically ordering of keys
-		initialNodes.sort((a, b) => {
-			if (a.key < b.key) return -1;
-			if (a.key > b.key) return 1;
-			return 0;
-		});
-
 		// calculate similarities between lexically adjacent nodes
 		/** @type {number[]} */
 		const similarities = [];
@@ -150,76 +150,99 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 			similarities.push(similarity(a.key, b.key));
 		}
 
-		const queue = [new Group(initialNodes, similarities)];
+		const initialGroup = new Group(initialNodes, similarities);
 
-		while (queue.length) {
-			const group = queue.pop();
-			// only groups bigger than maxSize need to be splitted
-			if (group.size < maxSize) {
-				result.push(group);
-				continue;
+		if (initialGroup.size < minSize) {
+			// We hit an edgecase where the working set is already smaller than minSize
+			// We merge it with the smallest result node to keep minSize intact
+			if (result.length > 0) {
+				const smallestGroup = result.reduce(
+					(min, group) => (min.size > group.size ? group : min)
+				);
+				for (const node of initialGroup.nodes) smallestGroup.nodes.push(node);
+				smallestGroup.nodes.sort((a, b) => {
+					if (a.key < b.key) return -1;
+					if (a.key > b.key) return 1;
+					return 0;
+				});
+			} else {
+				// There are no other nodes
+				// We use all nodes and have to accept that it's smaller than minSize
+				result.push(initialGroup);
 			}
+		} else {
+			const queue = [initialGroup];
 
-			// find unsplittable area from left and right
-			// going minSize from left and right
-			let left = 0;
-			let leftSize = 0;
-			while (leftSize < minSize) {
-				leftSize += group.nodes[left].size;
-				left++;
-			}
-			let right = group.nodes.length - 1;
-			let rightSize = 0;
-			while (rightSize < minSize) {
-				rightSize += group.nodes[right].size;
-				right--;
-			}
+			while (queue.length) {
+				const group = queue.pop();
+				// only groups bigger than maxSize need to be splitted
+				if (group.size < maxSize) {
+					result.push(group);
+					continue;
+				}
 
-			if (left - 1 > right) {
-				// can't split group while holding minSize
-				// because minSize is preferred of maxSize we return
-				// the group here even while it's too big
-				// To avoid this make sure maxSize > minSize * 3
-				result.push(group);
-				continue;
-			}
-			if (left <= right) {
-				// when there is a area between left and right
-				// we look for best split point
-				// we split at the minimum similarity
-				// here key space is separated the most
-				let best = left - 1;
-				let bestSimilarity = group.similarities[best];
-				for (let i = left; i <= right; i++) {
-					const similarity = group.similarities[i];
-					if (similarity < bestSimilarity) {
-						best = i;
-						bestSimilarity = similarity;
+				// find unsplittable area from left and right
+				// going minSize from left and right
+				// at least one node need to be included otherwise we get stuck
+				let left = 0;
+				let leftSize = 0;
+				while (leftSize <= minSize) {
+					leftSize += group.nodes[left].size;
+					left++;
+				}
+				let right = group.nodes.length - 1;
+				let rightSize = 0;
+				while (rightSize <= minSize) {
+					rightSize += group.nodes[right].size;
+					right--;
+				}
+
+				if (left - 1 > right) {
+					// can't split group while holding minSize
+					// because minSize is preferred of maxSize we return
+					// the group here even while it's too big
+					// To avoid this make sure maxSize > minSize * 3
+					result.push(group);
+					continue;
+				}
+				if (left <= right) {
+					// when there is a area between left and right
+					// we look for best split point
+					// we split at the minimum similarity
+					// here key space is separated the most
+					let best = left - 1;
+					let bestSimilarity = group.similarities[best];
+					for (let i = left; i <= right; i++) {
+						const similarity = group.similarities[i];
+						if (similarity < bestSimilarity) {
+							best = i;
+							bestSimilarity = similarity;
+						}
 					}
+					left = best + 1;
+					right = best;
 				}
-				left = best + 1;
-				right = best;
-			}
 
-			// create two new groups for left and right area
-			// and queue them up
-			const rightNodes = [group.nodes[right + 1]];
-			/** @type {number[]} */
-			const rightSimilaries = [];
-			for (let i = right + 2; i < group.nodes.length; i++) {
-				rightSimilaries.push(group.similarities[i - 1]);
-				rightNodes.push(group.nodes[i]);
-			}
-			queue.push(new Group(rightNodes, rightSimilaries));
-
-			const leftNodes = [group.nodes[0]];
-			/** @type {number[]} */
-			const leftSimilaries = [];
-			for (let i = 1; i < left; i++) {
-				leftSimilaries.push(group.similarities[i - 1]);
-				leftNodes.push(group.nodes[i]);
+				// create two new groups for left and right area
+				// and queue them up
+				const rightNodes = [group.nodes[right + 1]];
+				/** @type {number[]} */
+				const rightSimilaries = [];
+				for (let i = right + 2; i < group.nodes.length; i++) {
+					rightSimilaries.push(group.similarities[i - 1]);
+					rightNodes.push(group.nodes[i]);
+				}
+				queue.push(new Group(rightNodes, rightSimilaries));
+
+				const leftNodes = [group.nodes[0]];
+				/** @type {number[]} */
+				const leftSimilaries = [];
+				for (let i = 1; i < left; i++) {
+					leftSimilaries.push(group.similarities[i - 1]);
+					leftNodes.push(group.nodes[i]);
+				}
+				queue.push(new Group(leftNodes, leftSimilaries));
 			}
-			queue.push(new Group(leftNodes, leftSimilaries));
 		}
 	}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "4.24.0",
+  "version": "4.26.1",
   "author": "Tobias Koppers @sokra",
   "description": "Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "license": "MIT",
@@ -26,7 +26,7 @@
     "node-libs-browser": "^2.0.0",
     "schema-utils": "^0.4.4",
     "tapable": "^1.1.0",
-    "uglifyjs-webpack-plugin": "^1.2.4",
+    "terser-webpack-plugin": "^1.1.0",
     "watchpack": "^1.5.0",
     "webpack-sources": "^1.3.0"
   },
@@ -56,6 +56,7 @@
     "jade": "^1.11.0",
     "jade-loader": "~0.8.0",
     "jest": "24.0.0-alpha.1",
+    "jest-junit": "^5.2.0",
     "json-loader": "^0.5.7",
     "json-schema-to-typescript": "^6.0.1",
     "less": "^2.5.1",