webpack 5.59.0 → 5.71.0

package/lib/Compiler.js

@@ -58,13 +58,13 @@ const { isSourceEqual } = require("./util/source");
 /**
  * @template T
  * @callback Callback
- * @param {Error=} err
+ * @param {(Error | null)=} err
  * @param {T=} result
  */
 
 /**
  * @callback RunAsChildCallback
- * @param {Error=} err
+ * @param {(Error | null)=} err
  * @param {Chunk[]=} entries
  * @param {Compilation=} compilation
  */
@@ -119,8 +119,9 @@ const includesHash = (filename, hashes) => {
 class Compiler {
 	/**
 	 * @param {string} context the compilation path
+	 * @param {WebpackOptions} options options
 	 */
-	constructor(context) {
+	constructor(context, options = /** @type {WebpackOptions} */ ({})) {
 		this.hooks = Object.freeze({
 			/** @type {SyncHook<[]>} */
 			initialize: new SyncHook([]),
@@ -164,6 +165,11 @@ class Compiler {
 			/** @type {AsyncSeriesHook<[Compilation]>} */
 			afterCompile: new AsyncSeriesHook(["compilation"]),
 
+			/** @type {AsyncSeriesHook<[]>} */
+			readRecords: new AsyncSeriesHook([]),
+			/** @type {AsyncSeriesHook<[]>} */
+			emitRecords: new AsyncSeriesHook([]),
+
 			/** @type {AsyncSeriesHook<[Compiler]>} */
 			watchRun: new AsyncSeriesHook(["compiler"]),
 			/** @type {SyncHook<[Error]>} */
@@ -240,8 +246,7 @@ class Compiler {
 
 		this.infrastructureLogger = undefined;
 
-		/** @type {WebpackOptions} */
-		this.options = /** @type {WebpackOptions} */ ({});
+		this.options = options;
 
 		this.context = context;
 
@@ -263,6 +268,8 @@ class Compiler {
 		/** @type {boolean} */
 		this.watchMode = false;
 
+		this._backCompat = this.options.experiments.backCompat !== false;
+
 		/** @type {Compilation} */
 		this._lastCompilation = undefined;
 		/** @type {NormalModuleFactory} */
@@ -538,8 +545,21 @@ class Compiler {
 	 */
 	runAsChild(callback) {
 		const startTime = Date.now();
+
+		const finalCallback = (err, entries, compilation) => {
+			try {
+				callback(err, entries, compilation);
+			} catch (e) {
+				const err = new WebpackError(
+					`compiler.runAsChild callback error: ${e}`
+				);
+				err.details = e.stack;
+				this.parentCompilation.errors.push(err);
+			}
+		};
+
 		this.compile((err, compilation) => {
-			if (err) return callback(err);
+			if (err) return finalCallback(err);
 
 			this.parentCompilation.children.push(compilation);
 			for (const { name, source, info } of compilation.getAssets()) {
@@ -554,7 +574,7 @@ class Compiler {
 			compilation.startTime = startTime;
 			compilation.endTime = Date.now();
 
-			return callback(null, entries, compilation);
+			return finalCallback(null, entries, compilation);
 		});
 	}
 
@@ -589,7 +609,7 @@ class Compiler {
 					let immutable = info.immutable;
 					const queryStringIdx = targetFile.indexOf("?");
 					if (queryStringIdx >= 0) {
-						targetFile = targetFile.substr(0, queryStringIdx);
+						targetFile = targetFile.slice(0, queryStringIdx);
 						// We may remove the hash, which is in the query string
 						// So we recheck if the file is immutable
 						// This doesn't cover all cases, but immutable is only a performance optimization anyway
@@ -880,8 +900,32 @@ ${other}`);
 	 * @returns {void}
 	 */
 	emitRecords(callback) {
-		if (!this.recordsOutputPath) return callback();
+		if (this.hooks.emitRecords.isUsed()) {
+			if (this.recordsOutputPath) {
+				asyncLib.parallel(
+					[
+						cb => this.hooks.emitRecords.callAsync(cb),
+						this._emitRecords.bind(this)
+					],
+					err => callback(err)
+				);
+			} else {
+				this.hooks.emitRecords.callAsync(callback);
+			}
+		} else {
+			if (this.recordsOutputPath) {
+				this._emitRecords(callback);
+			} else {
+				callback();
+			}
+		}
+	}
 
+	/**
+	 * @param {Callback<void>} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	_emitRecords(callback) {
 		const writeFile = () => {
 			this.outputFileSystem.writeFile(
 				this.recordsOutputPath,
@@ -924,6 +968,31 @@ ${other}`);
 	 * @returns {void}
 	 */
 	readRecords(callback) {
+		if (this.hooks.readRecords.isUsed()) {
+			if (this.recordsInputPath) {
+				asyncLib.parallel([
+					cb => this.hooks.readRecords.callAsync(cb),
+					this._readRecords.bind(this)
+				]);
+			} else {
+				this.records = {};
+				this.hooks.readRecords.callAsync(callback);
+			}
+		} else {
+			if (this.recordsInputPath) {
+				this._readRecords(callback);
+			} else {
+				this.records = {};
+				callback();
+			}
+		}
+	}
+
+	/**
+	 * @param {Callback<void>} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	_readRecords(callback) {
 		if (!this.recordsInputPath) {
 			this.records = {};
 			return callback();
@@ -963,7 +1032,13 @@ ${other}`);
 		outputOptions,
 		plugins
 	) {
-		const childCompiler = new Compiler(this.context);
+		const childCompiler = new Compiler(this.context, {
+			...this.options,
+			output: {
+				...this.options.output,
+				...outputOptions
+			}
+		});
 		childCompiler.name = compilerName;
 		childCompiler.outputPath = this.outputPath;
 		childCompiler.inputFileSystem = this.inputFileSystem;
@@ -976,6 +1051,7 @@ ${other}`);
 		childCompiler.fsStartTime = this.fsStartTime;
 		childCompiler.cache = this.cache;
 		childCompiler.compilerPath = `${this.compilerPath}${compilerName}|${compilerIndex}|`;
+		childCompiler._backCompat = this._backCompat;
 
 		const relativeCompilerName = makePathsRelative(
 			this.context,
@@ -991,13 +1067,6 @@ ${other}`);
 			this.records[relativeCompilerName].push((childCompiler.records = {}));
 		}
 
-		childCompiler.options = {
-			...this.options,
-			output: {
-				...this.options.output,
-				...outputOptions
-			}
-		};
 		childCompiler.parentCompilation = compilation;
 		childCompiler.root = this.root;
 		if (Array.isArray(plugins)) {

package/lib/ConstPlugin.js

@@ -324,7 +324,7 @@ class ConstPlugin {
 								}
 							} else if (expression.operator === "??") {
 								const param = parser.evaluateExpression(expression.left);
-								const keepRight = param && param.asNullish();
+								const keepRight = param.asNullish();
 								if (typeof keepRight === "boolean") {
 									// ------------------------------------------
 									//
@@ -407,7 +407,7 @@ class ConstPlugin {
 							const expression = optionalExpressionsStack.pop();
 							const evaluated = parser.evaluateExpression(expression);
 
-							if (evaluated && evaluated.asNullish()) {
+							if (evaluated.asNullish()) {
 								// ------------------------------------------
 								//
 								// Given the following code:

package/lib/ContextModule.js

@@ -19,7 +19,11 @@ const {
 	keepOriginalOrder,
 	compareModulesById
 } = require("./util/comparators");
-const { contextify, parseResource } = require("./util/identifier");
+const {
+	contextify,
+	parseResource,
+	makePathsRelative
+} = require("./util/identifier");
 const makeSerializable = require("./util/makeSerializable");
 
 /** @typedef {import("webpack-sources").Source} Source */
@@ -61,7 +65,7 @@ const makeSerializable = require("./util/makeSerializable");
 
 /**
  * @typedef {Object} ContextModuleOptionsExtras
- * @property {string} resource
+ * @property {false|string|string[]} resource
  * @property {string=} resourceQuery
  * @property {string=} resourceFragment
  * @property {TODO} resolveOptions
@@ -71,7 +75,7 @@ const makeSerializable = require("./util/makeSerializable");
 
 /**
  * @callback ResolveDependenciesCallback
- * @param {Error=} err
+ * @param {(Error | null)=} err
  * @param {ContextElementDependency[]=} dependencies
  */
 
@@ -92,23 +96,36 @@ class ContextModule extends Module {
 	 * @param {ContextModuleOptions} options options object
 	 */
 	constructor(resolveDependencies, options) {
-		const parsed = parseResource(options ? options.resource : "");
-		const resource = parsed.path;
-		const resourceQuery = (options && options.resourceQuery) || parsed.query;
-		const resourceFragment =
-			(options && options.resourceFragment) || parsed.fragment;
-
-		super("javascript/dynamic", resource);
+		if (!options || typeof options.resource === "string") {
+			const parsed = parseResource(
+				options ? /** @type {string} */ (options.resource) : ""
+			);
+			const resource = parsed.path;
+			const resourceQuery = (options && options.resourceQuery) || parsed.query;
+			const resourceFragment =
+				(options && options.resourceFragment) || parsed.fragment;
+
+			super("javascript/dynamic", resource);
+			/** @type {ContextModuleOptions} */
+			this.options = {
+				...options,
+				resource,
+				resourceQuery,
+				resourceFragment
+			};
+		} else {
+			super("javascript/dynamic");
+			/** @type {ContextModuleOptions} */
+			this.options = {
+				...options,
+				resource: options.resource,
+				resourceQuery: options.resourceQuery || "",
+				resourceFragment: options.resourceFragment || ""
+			};
+		}
 
 		// Info from Factory
 		this.resolveDependencies = resolveDependencies;
-		/** @type {ContextModuleOptions} */
-		this.options = {
-			...options,
-			resource,
-			resourceQuery,
-			resourceFragment
-		};
 		if (options && options.resolveOptions !== undefined) {
 			this.resolveOptions = options.resolveOptions;
 		}
@@ -149,16 +166,18 @@ class ContextModule extends Module {
 		this.resolveDependencies = undefined;
 	}
 
-	prettyRegExp(regexString) {
-		// remove the "/" at the front and the beginning
-		// "/foo/" -> "foo"
-		return regexString
-			.substring(1, regexString.length - 1)
-			.replace(/!/g, "%21");
+	_prettyRegExp(regexString, stripSlash = true) {
+		const str = (regexString + "").replace(/!/g, "%21").replace(/\|/g, "%7C");
+		return stripSlash ? str.substring(1, str.length - 1) : str;
 	}
 
 	_createIdentifier() {
-		let identifier = this.context;
+		let identifier =
+			this.context ||
+			(typeof this.options.resource === "string" ||
+			this.options.resource === false
+				? `${this.options.resource}`
+				: this.options.resource.join("|"));
 		if (this.options.resourceQuery) {
 			identifier += `|${this.options.resourceQuery}`;
 		}
@@ -175,13 +194,19 @@ class ContextModule extends Module {
 			identifier += `|${this.options.addon}`;
 		}
 		if (this.options.regExp) {
-			identifier += `|${this.options.regExp}`;
+			identifier += `|${this._prettyRegExp(this.options.regExp, false)}`;
 		}
 		if (this.options.include) {
-			identifier += `|include: ${this.options.include}`;
+			identifier += `|include: ${this._prettyRegExp(
+				this.options.include,
+				false
+			)}`;
 		}
 		if (this.options.exclude) {
-			identifier += `|exclude: ${this.options.exclude}`;
+			identifier += `|exclude: ${this._prettyRegExp(
+				this.options.exclude,
+				false
+			)}`;
 		}
 		if (this.options.referencedExports) {
 			identifier += `|referencedExports: ${JSON.stringify(
@@ -217,7 +242,19 @@ class ContextModule extends Module {
 	 * @returns {string} a user readable identifier of the module
 	 */
 	readableIdentifier(requestShortener) {
-		let identifier = requestShortener.shorten(this.context) + "/";
+		let identifier;
+		if (this.context) {
+			identifier = requestShortener.shorten(this.context) + "/";
+		} else if (
+			typeof this.options.resource === "string" ||
+			this.options.resource === false
+		) {
+			identifier = requestShortener.shorten(`${this.options.resource}`) + "/";
+		} else {
+			identifier = this.options.resource
+				.map(r => requestShortener.shorten(r) + "/")
+				.join(" ");
+		}
 		if (this.options.resourceQuery) {
 			identifier += ` ${this.options.resourceQuery}`;
 		}
@@ -231,13 +268,13 @@ class ContextModule extends Module {
 			identifier += ` ${requestShortener.shorten(this.options.addon)}`;
 		}
 		if (this.options.regExp) {
-			identifier += ` ${this.prettyRegExp(this.options.regExp + "")}`;
+			identifier += ` ${this._prettyRegExp(this.options.regExp)}`;
 		}
 		if (this.options.include) {
-			identifier += ` include: ${this.prettyRegExp(this.options.include + "")}`;
+			identifier += ` include: ${this._prettyRegExp(this.options.include)}`;
 		}
 		if (this.options.exclude) {
-			identifier += ` exclude: ${this.prettyRegExp(this.options.exclude + "")}`;
+			identifier += ` exclude: ${this._prettyRegExp(this.options.exclude)}`;
 		}
 		if (this.options.referencedExports) {
 			identifier += ` referencedExports: ${this.options.referencedExports
@@ -267,11 +304,31 @@ class ContextModule extends Module {
 	 * @returns {string | null} an identifier for library inclusion
 	 */
 	libIdent(options) {
-		let identifier = contextify(
-			options.context,
-			this.context,
-			options.associatedObjectForCache
-		);
+		let identifier;
+
+		if (this.context) {
+			identifier = contextify(
+				options.context,
+				this.context,
+				options.associatedObjectForCache
+			);
+		} else if (typeof this.options.resource === "string") {
+			identifier = contextify(
+				options.context,
+				this.options.resource,
+				options.associatedObjectForCache
+			);
+		} else if (this.options.resource === false) {
+			identifier = "false";
+		} else {
+			identifier = this.options.resource
+				.map(res =>
+					contextify(options.context, res, options.associatedObjectForCache)
+				)
+				.join(" ");
+		}
+
+		if (this.layer) identifier = `(${this.layer})/${identifier}`;
 		if (this.options.mode) {
 			identifier += ` ${this.options.mode}`;
 		}
@@ -286,13 +343,13 @@ class ContextModule extends Module {
 			)}`;
 		}
 		if (this.options.regExp) {
-			identifier += ` ${this.prettyRegExp(this.options.regExp + "")}`;
+			identifier += ` ${this._prettyRegExp(this.options.regExp)}`;
 		}
 		if (this.options.include) {
-			identifier += ` include: ${this.prettyRegExp(this.options.include + "")}`;
+			identifier += ` include: ${this._prettyRegExp(this.options.include)}`;
 		}
 		if (this.options.exclude) {
-			identifier += ` exclude: ${this.prettyRegExp(this.options.exclude + "")}`;
+			identifier += ` exclude: ${this._prettyRegExp(this.options.exclude)}`;
 		}
 		if (this.options.referencedExports) {
 			identifier += ` referencedExports: ${this.options.referencedExports
@@ -312,15 +369,16 @@ class ContextModule extends Module {
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function(WebpackError=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild({ fileSystemInfo }, callback) {
 		// build if enforced
 		if (this._forceBuild) return callback(null, true);
 
-		// always build when we have no snapshot
-		if (!this.buildInfo.snapshot) return callback(null, true);
+		// always build when we have no snapshot and context
+		if (!this.buildInfo.snapshot)
+			return callback(null, Boolean(this.context || this.options.resource));
 
 		fileSystemInfo.checkSnapshotValid(this.buildInfo.snapshot, (err, valid) => {
 			callback(err, !valid);
@@ -435,10 +493,16 @@ class ContextModule extends Module {
 				);
 				return;
 			}
+			if (!this.context && !this.options.resource) return callback();
+
 			compilation.fileSystemInfo.createSnapshot(
 				startTime,
 				null,
-				[this.context],
+				this.context
+					? [this.context]
+					: typeof this.options.resource === "string"
+					? [this.options.resource]
+					: /** @type {string[]} */ (this.options.resource),
 				null,
 				SNAPSHOT_OPTIONS,
 				(err, snapshot) => {
@@ -462,7 +526,15 @@ class ContextModule extends Module {
 		missingDependencies,
 		buildDependencies
 	) {
-		contextDependencies.add(this.context);
+		if (this.context) {
+			contextDependencies.add(this.context);
+		} else if (typeof this.options.resource === "string") {
+			contextDependencies.add(this.options.resource);
+		} else if (this.options.resource === false) {
+			return;
+		} else {
+			for (const res of this.options.resource) contextDependencies.add(res);
+		}
 	}
 
 	/**
@@ -998,9 +1070,21 @@ module.exports = webpackEmptyAsyncContext;`;
 		return this.getSourceForEmptyContext(id, runtimeTemplate);
 	}
 
-	getSource(sourceString) {
+	/**
+	 * @param {string} sourceString source content
+	 * @param {Compilation=} compilation the compilation
+	 * @returns {Source} generated source
+	 */
+	getSource(sourceString, compilation) {
 		if (this.useSourceMap || this.useSimpleSourceMap) {
-			return new OriginalSource(sourceString, this.identifier());
+			return new OriginalSource(
+				sourceString,
+				`webpack://${makePathsRelative(
+					(compilation && compilation.compiler.context) || "",
+					this.identifier(),
+					compilation && compilation.compiler.root
+				)}`
+			);
 		}
 		return new RawSource(sourceString);
 	}
@@ -1010,16 +1094,23 @@ module.exports = webpackEmptyAsyncContext;`;
 	 * @returns {CodeGenerationResult} result
 	 */
 	codeGeneration(context) {
-		const { chunkGraph } = context;
+		const { chunkGraph, compilation } = context;
 		const sources = new Map();
 		sources.set(
 			"javascript",
-			this.getSource(this.getSourceString(this.options.mode, context))
+			this.getSource(
+				this.getSourceString(this.options.mode, context),
+				compilation
+			)
 		);
 		const set = new Set();
-		const allDeps = /** @type {ContextElementDependency[]} */ (
-			this.dependencies.concat(this.blocks.map(b => b.dependencies[0]))
-		);
+		const allDeps =
+			this.dependencies.length > 0
+				? /** @type {ContextElementDependency[]} */ (this.dependencies).slice()
+				: [];
+		for (const block of this.blocks)
+			for (const dep of block.dependencies)
+				allDeps.push(/** @type {ContextElementDependency} */ (dep));
 		set.add(RuntimeGlobals.module);
 		set.add(RuntimeGlobals.hasOwnProperty);
 		if (allDeps.length > 0) {