webpack 4.23.1 → 4.26.0

package/declarations/plugins/DllPlugin.d.ts

@@ -13,6 +13,10 @@ export interface DllPluginOptions {
 	 * If true, only entry points will be exposed
 	 */
 	entryOnly?: boolean;
+	/**
+	 * If true, manifest json file (output) will be formatted
+	 */
+	format?: boolean;
 	/**
 	 * Name of the exposed dll function (external name, use value of 'output.library')
 	 */

package/declarations/plugins/ProgressPlugin.d.ts

@@ -0,0 +1,42 @@
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY BY HAND.
+ * Run `yarn special-lint-fix` to update
+ */
+
+export type ProgressPluginArgument = ProgressPluginOptions | HandlerFunction;
+/**
+ * Function that executes for every progress step
+ */
+export type HandlerFunction = ((
+	percentage: number,
+	msg: string,
+	...args: string[]
+) => void);
+
+export interface ProgressPluginOptions {
+	/**
+	 * Show active modules count and one active module in progress message
+	 */
+	activeModules?: boolean;
+	/**
+	 * Show entries count in progress message
+	 */
+	entries?: boolean;
+	/**
+	 * Function that executes for every progress step
+	 */
+	handler?: HandlerFunction;
+	/**
+	 * Show modules count in progress message
+	 */
+	modules?: boolean;
+	/**
+	 * Minimum modules count to start with. Only for mode=modules. Default: 500
+	 */
+	modulesCount?: number;
+	/**
+	 * Collect profile data for progress steps. Default: false
+	 */
+	profile?: true | false | null;
+}

package/lib/BasicEvaluatedExpression.js

@@ -29,11 +29,14 @@ class BasicEvaluatedExpression {
 		this.regExp = null;
 		this.string = null;
 		this.quasis = null;
+		this.parts = null;
 		this.array = null;
 		this.items = null;
 		this.options = null;
 		this.prefix = null;
 		this.postfix = null;
+		this.wrappedInnerExpressions = null;
+		this.expression = null;
 	}
 
 	isNull() {
@@ -105,10 +108,36 @@ class BasicEvaluatedExpression {
 				: undefined;
 		}
 		if (this.isTemplateString()) {
-			for (const quasi of this.quasis) {
-				if (quasi.asBool()) return true;
+			const str = this.asString();
+			if (typeof str === "string") return str !== "";
+		}
+		return undefined;
+	}
+
+	asString() {
+		if (this.isBoolean()) return `${this.bool}`;
+		if (this.isNull()) return "null";
+		if (this.isString()) return this.string;
+		if (this.isNumber()) return `${this.number}`;
+		if (this.isRegExp()) return `${this.regExp}`;
+		if (this.isArray()) {
+			let array = [];
+			for (const item of this.items) {
+				const itemStr = item.asString();
+				if (itemStr === undefined) return undefined;
+				array.push(itemStr);
+			}
+			return `${array}`;
+		}
+		if (this.isConstArray()) return `${this.array}`;
+		if (this.isTemplateString()) {
+			let str = "";
+			for (const part of this.parts) {
+				const partStr = part.asString();
+				if (partStr === undefined) return undefined;
+				str += partStr;
 			}
-			// can't tell if string will be empty without executing
+			return str;
 		}
 		return undefined;
 	}
@@ -148,10 +177,11 @@ class BasicEvaluatedExpression {
 		return this;
 	}
 
-	setWrapped(prefix, postfix) {
+	setWrapped(prefix, postfix, innerExpressions) {
 		this.type = TypeWrapped;
 		this.prefix = prefix;
 		this.postfix = postfix;
+		this.wrappedInnerExpressions = innerExpressions;
 		return this;
 	}
 
@@ -184,9 +214,11 @@ class BasicEvaluatedExpression {
 		return this;
 	}
 
-	setTemplateString(quasis) {
+	setTemplateString(quasis, parts, kind) {
 		this.type = TypeTemplateString;
 		this.quasis = quasis;
+		this.parts = parts;
+		this.templateStringKind = kind;
 		return this;
 	}
 
@@ -206,6 +238,11 @@ class BasicEvaluatedExpression {
 		this.range = range;
 		return this;
 	}
+
+	setExpression(expression) {
+		this.expression = expression;
+		return this;
+	}
 }
 
 module.exports = BasicEvaluatedExpression;

package/lib/Chunk.js

@@ -430,7 +430,7 @@ class Chunk {
 	}
 
 	/**
-	 * @param {Chunk} newChunk the new chunk that will be split out of, and then chunk raphi twil=
+	 * @param {Chunk} newChunk the new chunk that will be split out of the current chunk
 	 * @returns {void}
 	 */
 	split(newChunk) {

package/lib/Compilation.js

@@ -224,6 +224,13 @@ class Compilation extends Tapable {
 			/** @type {SyncHook<Module>} */
 			succeedModule: new SyncHook(["module"]),
 
+			/** @type {SyncHook<Dependency, string>} */
+			addEntry: new SyncHook(["entry", "name"]),
+			/** @type {SyncHook<Dependency, string, Error>} */
+			failedEntry: new SyncHook(["entry", "name", "error"]),
+			/** @type {SyncHook<Dependency, string, Module>} */
+			succeedEntry: new SyncHook(["entry", "name", "module"]),
+
 			/** @type {SyncWaterfallHook<DependencyReference, Dependency, Module>} */
 			dependencyReference: new SyncWaterfallHook([
 				"dependencyReference",
@@ -1041,6 +1048,8 @@ class Compilation extends Tapable {
 	 * @returns {void} returns
 	 */
 	addEntry(context, entry, name, callback) {
+		this.hooks.addEntry.call(entry, name);
+
 		const slot = {
 			name: name,
 			// TODO webpack 5 remove `request`
@@ -1068,6 +1077,7 @@ class Compilation extends Tapable {
 			},
 			(err, module) => {
 				if (err) {
+					this.hooks.failedEntry.call(entry, name, err);
 					return callback(err);
 				}
 
@@ -1079,6 +1089,7 @@ class Compilation extends Tapable {
 						this._preparedEntrypoints.splice(idx, 1);
 					}
 				}
+				this.hooks.succeedEntry.call(entry, name, module);
 				return callback(null, module);
 			}
 		);

package/lib/DefinePlugin.js

@@ -21,11 +21,15 @@ class RuntimeValue {
 	}
 
 	exec(parser) {
-		for (const fileDependency of this.fileDependencies) {
-			parser.state.module.buildInfo.fileDependencies.add(fileDependency);
+		if (this.fileDependencies === true) {
+			parser.state.module.buildInfo.cacheable = false;
+		} else {
+			for (const fileDependency of this.fileDependencies) {
+				parser.state.module.buildInfo.fileDependencies.add(fileDependency);
+			}
 		}
 
-		return this.fn();
+		return this.fn({ module: parser.state.module });
 	}
 }
 

package/lib/HotModuleReplacementPlugin.js

@@ -255,7 +255,7 @@ module.exports = class HotModuleReplacementPlugin {
 						for (const key of Object.keys(records.chunkHashs)) {
 							const chunkId = isNaN(+key) ? key : +key;
 							const currentChunk = compilation.chunks.find(
-								chunk => chunk.id === chunkId
+								chunk => `${chunk.id}` === key
 							);
 							if (currentChunk) {
 								const newModules = currentChunk

package/lib/LibManifestPlugin.js

@@ -67,7 +67,11 @@ class LibManifestPlugin {
 									return obj;
 								}, Object.create(null))
 						};
-						const content = Buffer.from(JSON.stringify(manifest), "utf8");
+						// Apply formatting to content if format flag is true;
+						const manifestContent = this.options.format
+							? JSON.stringify(manifest, null, 2)
+							: JSON.stringify(manifest);
+						const content = Buffer.from(manifestContent, "utf8");
 						compiler.outputFileSystem.mkdirp(path.dirname(targetPath), err => {
 							if (err) return callback(err);
 							compiler.outputFileSystem.writeFile(

package/lib/Parser.js

@@ -216,62 +216,114 @@ class Parser extends Tapable {
 						right.prefix &&
 						right.prefix.isString()
 					) {
+						// "left" + ("prefix" + inner + "postfix")
+						// => ("leftprefix" + inner + "postfix")
 						res.setWrapped(
 							new BasicEvaluatedExpression()
 								.setString(left.string + right.prefix.string)
 								.setRange(joinRanges(left.range, right.prefix.range)),
-							right.postfix
+							right.postfix,
+							right.wrappedInnerExpressions
 						);
 					} else if (right.isWrapped()) {
-						res.setWrapped(
-							new BasicEvaluatedExpression()
-								.setString(left.string)
-								.setRange(left.range),
-							right.postfix
-						);
+						// "left" + ([null] + inner + "postfix")
+						// => ("left" + inner + "postfix")
+						res.setWrapped(left, right.postfix, right.wrappedInnerExpressions);
 					} else {
-						res.setWrapped(left, null);
+						// "left" + expr
+						// => ("left" + expr + "")
+						res.setWrapped(left, null, [right]);
 					}
 				} else if (left.isNumber()) {
 					if (right.isString()) {
 						res.setString(left.number + right.string);
 					} else if (right.isNumber()) {
 						res.setNumber(left.number + right.number);
+					} else {
+						return;
 					}
 				} else if (left.isWrapped()) {
 					if (left.postfix && left.postfix.isString() && right.isString()) {
+						// ("prefix" + inner + "postfix") + "right"
+						// => ("prefix" + inner + "postfixright")
 						res.setWrapped(
 							left.prefix,
 							new BasicEvaluatedExpression()
 								.setString(left.postfix.string + right.string)
-								.setRange(joinRanges(left.postfix.range, right.range))
+								.setRange(joinRanges(left.postfix.range, right.range)),
+							left.wrappedInnerExpressions
 						);
 					} else if (
 						left.postfix &&
 						left.postfix.isString() &&
 						right.isNumber()
 					) {
+						// ("prefix" + inner + "postfix") + 123
+						// => ("prefix" + inner + "postfix123")
 						res.setWrapped(
 							left.prefix,
 							new BasicEvaluatedExpression()
 								.setString(left.postfix.string + right.number)
-								.setRange(joinRanges(left.postfix.range, right.range))
+								.setRange(joinRanges(left.postfix.range, right.range)),
+							left.wrappedInnerExpressions
 						);
 					} else if (right.isString()) {
-						res.setWrapped(left.prefix, right);
+						// ("prefix" + inner + [null]) + "right"
+						// => ("prefix" + inner + "right")
+						res.setWrapped(left.prefix, right, left.wrappedInnerExpressions);
 					} else if (right.isNumber()) {
+						// ("prefix" + inner + [null]) + 123
+						// => ("prefix" + inner + "123")
 						res.setWrapped(
 							left.prefix,
 							new BasicEvaluatedExpression()
 								.setString(right.number + "")
-								.setRange(right.range)
+								.setRange(right.range),
+							left.wrappedInnerExpressions
+						);
+					} else if (right.isWrapped()) {
+						// ("prefix1" + inner1 + "postfix1") + ("prefix2" + inner2 + "postfix2")
+						// ("prefix1" + inner1 + "postfix1" + "prefix2" + inner2 + "postfix2")
+						res.setWrapped(
+							left.prefix,
+							right.postfix,
+							left.wrappedInnerExpressions &&
+								right.wrappedInnerExpressions &&
+								left.wrappedInnerExpressions
+									.concat(left.postfix ? [left.postfix] : [])
+									.concat(right.prefix ? [right.prefix] : [])
+									.concat(right.wrappedInnerExpressions)
 						);
 					} else {
-						res.setWrapped(left.prefix, new BasicEvaluatedExpression());
+						// ("prefix" + inner + postfix) + expr
+						// => ("prefix" + inner + postfix + expr + [null])
+						res.setWrapped(
+							left.prefix,
+							null,
+							left.wrappedInnerExpressions &&
+								left.wrappedInnerExpressions.concat(
+									left.postfix ? [left.postfix, right] : [right]
+								)
+						);
 					}
 				} else {
 					if (right.isString()) {
-						res.setWrapped(null, right);
+						// left + "right"
+						// => ([null] + left + "right")
+						res.setWrapped(null, right, [left]);
+					} else if (right.isWrapped()) {
+						// left + (prefix + inner + "postfix")
+						// => ([null] + left + prefix + inner + "postfix")
+						res.setWrapped(
+							null,
+							right.postfix,
+							right.wrappedInnerExpressions &&
+								(right.prefix ? [left, right.prefix] : [left]).concat(
+									right.wrappedInnerExpressions
+								)
+						);
+					} else {
+						return;
 					}
 				}
 				res.setRange(expr.range);
@@ -602,62 +654,66 @@ class Parser extends Tapable {
 
 		/**
 		 * @param {string} kind "cooked" | "raw"
-		 * @param {TODO[]} quasis quasis
-		 * @param {TODO[]} expressions expressions
-		 * @returns {BasicEvaluatedExpression[]} Simplified template
+		 * @param {TODO} templateLiteralExpr TemplateLiteral expr
+		 * @returns {{quasis: BasicEvaluatedExpression[], parts: BasicEvaluatedExpression[]}} Simplified template
 		 */
-		const getSimplifiedTemplateResult = (kind, quasis, expressions) => {
+		const getSimplifiedTemplateResult = (kind, templateLiteralExpr) => {
+			const quasis = [];
 			const parts = [];
 
-			for (let i = 0; i < quasis.length; i++) {
-				parts.push(
-					new BasicEvaluatedExpression()
-						.setString(quasis[i].value[kind])
-						.setRange(quasis[i].range)
-				);
+			for (let i = 0; i < templateLiteralExpr.quasis.length; i++) {
+				const quasiExpr = templateLiteralExpr.quasis[i];
+				const quasi = quasiExpr.value[kind];
 
 				if (i > 0) {
-					const prevExpr = parts[parts.length - 2],
-						lastExpr = parts[parts.length - 1];
-					const expr = this.evaluateExpression(expressions[i - 1]);
-					if (!(expr.isString() || expr.isNumber())) continue;
-
-					prevExpr.setString(
-						prevExpr.string +
-							(expr.isString() ? expr.string : expr.number) +
-							lastExpr.string
+					const prevExpr = parts[parts.length - 1];
+					const expr = this.evaluateExpression(
+						templateLiteralExpr.expressions[i - 1]
 					);
-					prevExpr.setRange([prevExpr.range[0], lastExpr.range[1]]);
-					parts.pop();
+					const exprAsString = expr.asString();
+					if (typeof exprAsString === "string") {
+						// We can merge quasi + expr + quasi when expr
+						// is a const string
+
+						prevExpr.setString(prevExpr.string + exprAsString + quasi);
+						prevExpr.setRange([prevExpr.range[0], quasiExpr.range[1]]);
+						// We unset the expression as it doesn't match to a single expression
+						prevExpr.setExpression(undefined);
+						continue;
+					}
+					parts.push(expr);
 				}
+
+				const part = new BasicEvaluatedExpression()
+					.setString(quasi)
+					.setRange(quasiExpr.range)
+					.setExpression(quasiExpr);
+				quasis.push(part);
+				parts.push(part);
 			}
-			return parts;
+			return {
+				quasis,
+				parts
+			};
 		};
 
 		this.hooks.evaluate.for("TemplateLiteral").tap("Parser", node => {
-			const parts = getSimplifiedTemplateResult.call(
-				this,
-				"cooked",
-				node.quasis,
-				node.expressions
-			);
+			const { quasis, parts } = getSimplifiedTemplateResult("cooked", node);
 			if (parts.length === 1) {
 				return parts[0].setRange(node.range);
 			}
 			return new BasicEvaluatedExpression()
-				.setTemplateString(parts)
+				.setTemplateString(quasis, parts, "cooked")
 				.setRange(node.range);
 		});
 		this.hooks.evaluate.for("TaggedTemplateExpression").tap("Parser", node => {
 			if (this.evaluateExpression(node.tag).identifier !== "String.raw") return;
-			const parts = getSimplifiedTemplateResult.call(
-				this,
-				"raw",
-				node.quasi.quasis,
-				node.quasi.expressions
-			);
+			const { quasis, parts } = getSimplifiedTemplateResult("raw", node.quasi);
+			if (parts.length === 1) {
+				return parts[0].setRange(node.range);
+			}
 			return new BasicEvaluatedExpression()
-				.setTemplateString(parts)
+				.setTemplateString(quasis, parts, "raw")
 				.setRange(node.range);
 		});
 
@@ -1926,13 +1982,20 @@ class Parser extends Tapable {
 			const hook = this.hooks.evaluate.get(expression.type);
 			if (hook !== undefined) {
 				const result = hook.call(expression);
-				if (result !== undefined) return result;
+				if (result !== undefined) {
+					if (result) {
+						result.setExpression(expression);
+					}
+					return result;
+				}
 			}
 		} catch (e) {
 			console.warn(e);
 			// ignore error
 		}
-		return new BasicEvaluatedExpression().setRange(expression.range);
+		return new BasicEvaluatedExpression()
+			.setRange(expression.range)
+			.setExpression(expression);
 	}
 
 	parseString(expression) {

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/node/NodeTargetPlugin.js

@@ -7,7 +7,7 @@
 const ExternalsPlugin = require("../ExternalsPlugin");
 
 const builtins =
-	// eslint-disable-next-line node/no-unsupported-features/node-builtins
+	// eslint-disable-next-line node/no-unsupported-features/node-builtins,node/no-deprecated-api
 	require("module").builtinModules || Object.keys(process.binding("natives"));
 
 class NodeTargetPlugin {

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "webpack",
-  "version": "4.23.1",
+  "version": "4.26.0",
   "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",
   "dependencies": {
-    "@webassemblyjs/ast": "1.7.10",
-    "@webassemblyjs/helper-module-context": "1.7.10",
-    "@webassemblyjs/wasm-edit": "1.7.10",
-    "@webassemblyjs/wasm-parser": "1.7.10",
+    "@webassemblyjs/ast": "1.7.11",
+    "@webassemblyjs/helper-module-context": "1.7.11",
+    "@webassemblyjs/wasm-edit": "1.7.11",
+    "@webassemblyjs/wasm-parser": "1.7.11",
     "acorn": "^5.6.2",
     "acorn-dynamic-import": "^3.0.0",
     "ajv": "^6.1.0",
@@ -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"
   },
@@ -42,27 +42,28 @@
     "coveralls": "^3.0.2",
     "css-loader": "^0.28.3",
     "es6-promise-polyfill": "^1.1.1",
-    "eslint": "^5.2.0",
-    "eslint-config-prettier": "^2.9.0",
-    "eslint-plugin-jest": "^21.18.0",
-    "eslint-plugin-node": "^7.0.1",
-    "eslint-plugin-prettier": "^2.6.2",
+    "eslint": "^5.8.0",
+    "eslint-config-prettier": "^3.1.0",
+    "eslint-plugin-jest": "^21.26.2",
+    "eslint-plugin-node": "^8.0.0",
+    "eslint-plugin-prettier": "^3.0.0",
     "express": "~4.13.1",
     "file-loader": "^1.1.6",
-    "glob": "^7.1.2",
-    "husky": "^1.0.0-rc.6",
+    "glob": "^7.1.3",
+    "husky": "^1.1.3",
     "i18n-webpack-plugin": "^1.0.0",
     "istanbul": "^0.4.5",
     "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",
     "less-loader": "^4.0.3",
-    "lint-staged": "^7.2.0",
+    "lint-staged": "^8.0.4",
     "lodash": "^4.17.4",
-    "prettier": "^1.14.0",
+    "prettier": "^1.14.3",
     "pug": "^2.0.3",
     "pug-loader": "^2.4.0",
     "raw-loader": "~0.5.0",

package/schemas/plugins/DllPlugin.json

@@ -12,6 +12,10 @@
       "description": "If true, only entry points will be exposed",
       "type": "boolean"
     },
+    "format": {
+      "description": "If true, manifest json file (output) will be formatted",
+      "type": "boolean"
+    },
     "name": {
       "description": "Name of the exposed dll function (external name, use value of 'output.library')",
       "type": "string",

package/schemas/plugins/ProgressPlugin.json

@@ -0,0 +1,52 @@
+{
+  "definitions": {
+    "HandlerFunction": {
+      "description": "Function that executes for every progress step",
+      "instanceof": "Function",
+      "tsType": "((percentage: number, msg: string, ...args: string[]) => void)"
+    },
+    "ProgressPluginOptions": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "activeModules": {
+          "description": "Show active modules count and one active module in progress message",
+          "type": "boolean"
+        },
+        "entries": {
+          "description": "Show entries count in progress message",
+          "type": "boolean"
+        },
+        "handler": {
+          "description": "Function that executes for every progress step",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/HandlerFunction"
+            }
+          ]
+        },
+        "modules": {
+          "description": "Show modules count in progress message",
+          "type": "boolean"
+        },
+        "modulesCount": {
+          "description": "Minimum modules count to start with. Only for mode=modules. Default: 500",
+          "type": "number"
+        },
+        "profile": {
+          "description": "Collect profile data for progress steps. Default: false",
+          "enum": [true, false, null]
+        }
+      }
+    }
+  },
+  "title": "ProgressPluginArgument",
+  "oneOf": [
+    {
+      "$ref": "#/definitions/ProgressPluginOptions"
+    },
+    {
+      "$ref": "#/definitions/HandlerFunction"
+    }
+  ]
+}