webpack 5.2.1 → 5.4.0

package/bin/webpack.js

@@ -41,6 +41,19 @@ const isInstalled = packageName => {
 	}
 };
 
+/**
+ * @param {CliOption} cli options
+ * @returns {void}
+ */
+const runCli = cli => {
+	const path = require("path");
+	const pkgPath = require.resolve(`${cli.package}/package.json`);
+	// eslint-disable-next-line node/no-missing-require
+	const pkg = require(pkgPath);
+	// eslint-disable-next-line node/no-missing-require
+	require(path.resolve(path.dirname(pkgPath), pkg.bin[cli.binName]));
+};
+
 /**
  * @typedef {Object} CliOption
  * @property {string} name display name
@@ -116,7 +129,7 @@ if (!cli.installed) {
 
 		runCommand(packageManager, installOptions.concat(cli.package))
 			.then(() => {
-				require(cli.package); //eslint-disable-line
+				runCli(cli);
 			})
 			.catch(error => {
 				console.error(error);
@@ -124,10 +137,5 @@ if (!cli.installed) {
 			});
 	});
 } else {
-	const path = require("path");
-	const pkgPath = require.resolve(`${cli.package}/package.json`);
-	// eslint-disable-next-line node/no-missing-require
-	const pkg = require(pkgPath);
-	// eslint-disable-next-line node/no-missing-require
-	require(path.resolve(path.dirname(pkgPath), pkg.bin[cli.binName]));
+	runCli(cli);
 }

package/lib/ChunkGraph.js

@@ -200,6 +200,8 @@ class ChunkGraph {
 		this._chunks = new WeakMap();
 		/** @private @type {WeakMap<AsyncDependenciesBlock, ChunkGroup>} */
 		this._blockChunkGroups = new WeakMap();
+		/** @private @type {Map<string, string | number>} */
+		this._runtimeIds = new Map();
 		/** @type {ModuleGraph} */
 		this.moduleGraph = moduleGraph;
 
@@ -1144,6 +1146,23 @@ class ChunkGraph {
 		cgm.id = id;
 	}
 
+	/**
+	 * @param {string} runtime runtime
+	 * @returns {string | number} the id of the runtime
+	 */
+	getRuntimeId(runtime) {
+		return this._runtimeIds.get(runtime);
+	}
+
+	/**
+	 * @param {string} runtime runtime
+	 * @param {string | number} id the id of the runtime
+	 * @returns {void}
+	 */
+	setRuntimeId(runtime, id) {
+		this._runtimeIds.set(runtime, id);
+	}
+
 	/**
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime the runtime

package/lib/Compilation.js

@@ -1939,6 +1939,8 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					this.hooks.optimizeChunkIds.call(this.chunks);
 					this.hooks.afterOptimizeChunkIds.call(this.chunks);
 
+					this.assignRuntimeIds();
+
 					this.sortItemsWithChunkIds();
 
 					if (shouldRecord) {
@@ -2556,6 +2558,21 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		}
 	}
 
+	assignRuntimeIds() {
+		const { chunkGraph } = this;
+		const processEntrypoint = ep => {
+			const runtime = ep.options.runtime || ep.name;
+			const chunk = ep.getRuntimeChunk();
+			chunkGraph.setRuntimeId(runtime, chunk.id);
+		};
+		for (const ep of this.entrypoints.values()) {
+			processEntrypoint(ep);
+		}
+		for (const ep of this.asyncEntrypoints) {
+			processEntrypoint(ep);
+		}
+	}
+
 	sortItemsWithChunkIds() {
 		for (const chunkGroup of this.chunkGroups) {
 			chunkGroup.sortItems();
@@ -2592,7 +2609,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 	createModuleHashes() {
 		let statModulesHashed = 0;
-		const chunkGraph = this.chunkGraph;
+		const { chunkGraph, runtimeTemplate } = this;
 		const { hashFunction, hashDigest, hashDigestLength } = this.outputOptions;
 		for (const module of this.modules) {
 			for (const runtime of chunkGraph.getModuleRuntimes(module)) {
@@ -2600,7 +2617,8 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				const moduleHash = createHash(hashFunction);
 				module.updateHash(moduleHash, {
 					chunkGraph,
-					runtime
+					runtime,
+					runtimeTemplate
 				});
 				const moduleHashDigest = /** @type {string} */ (moduleHash.digest(
 					hashDigest
@@ -2623,6 +2641,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	createHash() {
 		this.logger.time("hashing: initialize hash");
 		const chunkGraph = this.chunkGraph;
+		const runtimeTemplate = this.runtimeTemplate;
 		const outputOptions = this.outputOptions;
 		const hashFunction = outputOptions.hashFunction;
 		const hashDigest = outputOptions.hashDigest;
@@ -2707,7 +2726,8 @@ This prevents using hashes of each other and should be avoided.`
 					const moduleHash = createHash(hashFunction);
 					module.updateHash(moduleHash, {
 						chunkGraph,
-						runtime: chunk.runtime
+						runtime: chunk.runtime,
+						runtimeTemplate
 					});
 					const moduleHashDigest = /** @type {string} */ (moduleHash.digest(
 						hashDigest
@@ -2769,7 +2789,8 @@ This prevents using hashes of each other and should be avoided.`
 				const moduleHash = createHash(hashFunction);
 				module.updateHash(moduleHash, {
 					chunkGraph,
-					runtime: chunk.runtime
+					runtime: chunk.runtime,
+					runtimeTemplate
 				});
 				const moduleHashDigest = /** @type {string} */ (moduleHash.digest(
 					hashDigest

package/lib/ConcatenationScope.js

@@ -39,16 +39,19 @@ const NAMESPACE_OBJECT_EXPORT = "__WEBPACK_NAMESPACE_OBJECT__";
 
 class ConcatenationScope {
 	/**
-	 * @param {ModuleInfo[]} modulesWithInfo all module info in order
+	 * @param {ModuleInfo[] | Map<Module, ModuleInfo>} modulesMap all module info by module
 	 * @param {ConcatenatedModuleInfo} currentModule the current module info
 	 */
-	constructor(modulesWithInfo, currentModule) {
+	constructor(modulesMap, currentModule) {
 		this._currentModule = currentModule;
-		this._modulesWithInfo = modulesWithInfo;
-		this._modulesMap = new Map();
-		for (const info of modulesWithInfo) {
-			this._modulesMap.set(info.module, info);
+		if (Array.isArray(modulesMap)) {
+			const map = new Map();
+			for (const info of modulesMap) {
+				map.set(info.module, info);
+			}
+			modulesMap = map;
 		}
+		this._modulesMap = modulesMap;
 	}
 
 	/**

package/lib/ConditionalInitFragment.js

@@ -0,0 +1,109 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { ConcatSource, PrefixSource } = require("webpack-sources");
+const InitFragment = require("./InitFragment");
+const Template = require("./Template");
+const { mergeRuntime } = require("./util/runtime");
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./Generator").GenerateContext} GenerateContext */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+
+const wrapInCondition = (condition, source) => {
+	if (typeof source === "string") {
+		return Template.asString([
+			`if (${condition}) {`,
+			Template.indent(source),
+			"}",
+			""
+		]);
+	} else {
+		return new ConcatSource(
+			`if (${condition}) {\n`,
+			new PrefixSource("\t", source),
+			"}\n"
+		);
+	}
+};
+
+class ConditionalInitFragment extends InitFragment {
+	/**
+	 * @param {string|Source} content the source code that will be included as initialization code
+	 * @param {number} stage category of initialization code (contribute to order)
+	 * @param {number} position position in the category (contribute to order)
+	 * @param {string} key unique key to avoid emitting the same initialization code twice
+	 * @param {RuntimeSpec | boolean} runtimeCondition in which runtime this fragment should be executed
+	 * @param {string|Source=} endContent the source code that will be included at the end of the module
+	 */
+	constructor(
+		content,
+		stage,
+		position,
+		key,
+		runtimeCondition = true,
+		endContent
+	) {
+		super(content, stage, position, key, endContent);
+		this.runtimeCondition = runtimeCondition;
+	}
+
+	/**
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {string|Source} the source code that will be included as initialization code
+	 */
+	getContent(generateContext) {
+		if (this.runtimeCondition === false || !this.content) return "";
+		if (this.runtimeCondition === true) return this.content;
+		const expr = generateContext.runtimeTemplate.runtimeConditionExpression({
+			chunkGraph: generateContext.chunkGraph,
+			runtimeRequirements: generateContext.runtimeRequirements,
+			runtime: generateContext.runtime,
+			runtimeCondition: this.runtimeCondition
+		});
+		if (expr === "true") return this.content;
+		return wrapInCondition(expr, this.content);
+	}
+
+	/**
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {string|Source=} the source code that will be included at the end of the module
+	 */
+	getEndContent(generateContext) {
+		if (this.runtimeCondition === false || !this.endContent) return "";
+		if (this.runtimeCondition === true) return this.endContent;
+		const expr = generateContext.runtimeTemplate.runtimeConditionExpression({
+			chunkGraph: generateContext.chunkGraph,
+			runtimeRequirements: generateContext.runtimeRequirements,
+			runtime: generateContext.runtime,
+			runtimeCondition: this.runtimeCondition
+		});
+		if (expr === "true") return this.endContent;
+		return wrapInCondition(expr, this.endContent);
+	}
+
+	merge(other) {
+		if (this.runtimeCondition === true) return this;
+		if (other.runtimeCondition === true) return other;
+		if (this.runtimeCondition === false) return other;
+		if (other.runtimeCondition === false) return this;
+		const runtimeCondition = mergeRuntime(
+			this.runtimeCondition,
+			other.runtimeCondition
+		);
+		return new ConditionalInitFragment(
+			this.content,
+			this.stage,
+			this.position,
+			this.key,
+			runtimeCondition,
+			this.endContent
+		);
+	}
+}
+
+module.exports = ConditionalInitFragment;

package/lib/Dependency.js

@@ -21,6 +21,7 @@
  * @typedef {Object} UpdateHashContext
  * @property {ChunkGraph} chunkGraph
  * @property {RuntimeSpec} runtime
+ * @property {RuntimeTemplate=} runtimeTemplate
  */
 
 /**

package/lib/Module.js

@@ -415,19 +415,20 @@ class Module extends DependenciesBlock {
 	getExportsType(moduleGraph, strict) {
 		switch (this.buildMeta && this.buildMeta.exportsType) {
 			case "flagged":
-				return strict ? "default-only" : "namespace";
+				return strict ? "default-with-named" : "namespace";
 			case "namespace":
 				return "namespace";
 			case "default":
 				switch (this.buildMeta.defaultObject) {
 					case "redirect":
+						return "default-with-named";
 					case "redirect-warn":
 						return strict ? "default-only" : "default-with-named";
 					default:
 						return "default-only";
 				}
 			case "dynamic": {
-				if (strict) return "default-only";
+				if (strict) return "default-with-named";
 				// Try to figure out value of __esModule by following reexports
 				const handleDefault = () => {
 					switch (this.buildMeta.defaultObject) {
@@ -465,7 +466,7 @@ class Module extends DependenciesBlock {
 				}
 			}
 			default:
-				return strict ? "default-only" : "dynamic";
+				return strict ? "default-with-named" : "dynamic";
 		}
 	}
 

package/lib/ProgressPlugin.js

@@ -281,14 +281,13 @@ class ProgressPlugin {
 			if (modulesCount % 100 === 0) updateThrottled();
 		};
 
+		// only used when showActiveModules is set
 		const moduleBuild = module => {
-			if (showActiveModules) {
-				const ident = module.identifier();
-				if (ident) {
-					activeModules.add(ident);
-					lastActiveModule = ident;
-					update();
-				}
+			const ident = module.identifier();
+			if (ident) {
+				activeModules.add(ident);
+				lastActiveModule = ident;
+				update();
 			}
 		};
 
@@ -346,6 +345,7 @@ class ProgressPlugin {
 		});
 
 		compiler.hooks.afterCompile.tapPromise("ProgressPlugin", compilation => {
+			if (compilation.compiler.isChild()) return Promise.resolve();
 			return cacheGetPromise.then(async oldData => {
 				if (
 					!oldData ||
@@ -380,7 +380,9 @@ class ProgressPlugin {
 				moduleDone
 			);
 
-			compilation.hooks.buildModule.tap("ProgressPlugin", moduleBuild);
+			if (showActiveModules) {
+				compilation.hooks.buildModule.tap("ProgressPlugin", moduleBuild);
+			}
 
 			compilation.hooks.addEntry.tap("ProgressPlugin", entryAdd);
 			compilation.hooks.failedEntry.tap("ProgressPlugin", entryDone);

package/lib/RuntimeGlobals.js

@@ -173,6 +173,11 @@ exports.loadScript = "__webpack_require__.l";
  */
 exports.chunkName = "__webpack_require__.cn";
 
+/**
+ * the runtime id of the current runtime
+ */
+exports.runtimeId = "__webpack_require__.j";
+
 /**
  * the filename of the script part of the chunk
  */

package/lib/RuntimePlugin.js

@@ -21,6 +21,7 @@ const HasOwnPropertyRuntimeModule = require("./runtime/HasOwnPropertyRuntimeModu
 const LoadScriptRuntimeModule = require("./runtime/LoadScriptRuntimeModule");
 const MakeNamespaceObjectRuntimeModule = require("./runtime/MakeNamespaceObjectRuntimeModule");
 const PublicPathRuntimeModule = require("./runtime/PublicPathRuntimeModule");
+const RuntimeIdRuntimeModule = require("./runtime/RuntimeIdRuntimeModule");
 const SystemContextRuntimeModule = require("./runtime/SystemContextRuntimeModule");
 const ShareRuntimeModule = require("./sharing/ShareRuntimeModule");
 const StringXor = require("./util/StringXor");
@@ -31,6 +32,7 @@ const StringXor = require("./util/StringXor");
 
 const GLOBALS_ON_REQUIRE = [
 	RuntimeGlobals.chunkName,
+	RuntimeGlobals.runtimeId,
 	RuntimeGlobals.compatGetDefaultExport,
 	RuntimeGlobals.createFakeNamespaceObject,
 	RuntimeGlobals.definePropertyGetters,
@@ -156,6 +158,12 @@ class RuntimePlugin {
 					);
 					return true;
 				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.runtimeId)
+				.tap("RuntimePlugin", chunk => {
+					compilation.addRuntimeModule(chunk, new RuntimeIdRuntimeModule());
+					return true;
+				});
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.publicPath)
 				.tap("RuntimePlugin", (chunk, set) => {

package/lib/RuntimeTemplate.js

@@ -9,7 +9,9 @@ const InitFragment = require("./InitFragment");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const Template = require("./Template");
 const { equals } = require("./util/ArrayHelpers");
+const compileBooleanMatcher = require("./util/compileBooleanMatcher");
 const propertyAccess = require("./util/propertyAccess");
+const { forEachRuntime, subtractRuntime } = require("./util/runtime");
 
 /** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
@@ -562,6 +564,39 @@ class RuntimeTemplate {
 		return `${promise || "Promise.resolve()"}${appending}`;
 	}
 
+	/**
+	 * @param {Object} options options object
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {RuntimeSpec=} options.runtime runtime for which this code will be generated
+	 * @param {RuntimeSpec | boolean=} options.runtimeCondition only execute the statement in some runtimes
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @returns {string} expression
+	 */
+	runtimeConditionExpression({
+		chunkGraph,
+		runtimeCondition,
+		runtime,
+		runtimeRequirements
+	}) {
+		if (runtimeCondition === undefined) return "true";
+		if (typeof runtimeCondition === "boolean") return `${runtimeCondition}`;
+		/** @type {Set<string>} */
+		const positiveRuntimeIds = new Set();
+		forEachRuntime(runtimeCondition, runtime =>
+			positiveRuntimeIds.add(`${chunkGraph.getRuntimeId(runtime)}`)
+		);
+		/** @type {Set<string>} */
+		const negativeRuntimeIds = new Set();
+		forEachRuntime(subtractRuntime(runtime, runtimeCondition), runtime =>
+			negativeRuntimeIds.add(`${chunkGraph.getRuntimeId(runtime)}`)
+		);
+		runtimeRequirements.add(RuntimeGlobals.runtimeId);
+		return compileBooleanMatcher.fromLists(
+			Array.from(positiveRuntimeIds),
+			Array.from(negativeRuntimeIds)
+		)(RuntimeGlobals.runtimeId);
+	}
+
 	/**
 	 *
 	 * @param {Object} options options object
@@ -572,6 +607,8 @@ class RuntimeTemplate {
 	 * @param {string} options.importVar name of the import variable
 	 * @param {Module} options.originModule module in which the statement is emitted
 	 * @param {boolean=} options.weak true, if this is a weak dependency
+	 * @param {RuntimeSpec=} options.runtime runtime for which this code will be generated
+	 * @param {RuntimeSpec | boolean=} options.runtimeCondition only execute the statement in some runtimes
 	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
 	 * @returns {[string, string]} the import statement and the compat statement
 	 */

package/lib/WebpackOptionsApply.js

@@ -124,7 +124,7 @@ class WebpackOptionsApply extends OptionsApply {
 				}
 				case "module":
 					throw new Error(
-						"EcmaScript Module CHunk Format is not implemented yet"
+						"EcmaScript Module Chunk Format is not implemented yet"
 					);
 				default:
 					throw new Error(
@@ -308,7 +308,9 @@ class WebpackOptionsApply extends OptionsApply {
 		}
 		if (options.optimization.sideEffects) {
 			const SideEffectsFlagPlugin = require("./optimize/SideEffectsFlagPlugin");
-			new SideEffectsFlagPlugin().apply(compiler);
+			new SideEffectsFlagPlugin(
+				options.optimization.sideEffects === true
+			).apply(compiler);
 		}
 		if (options.optimization.providedExports) {
 			const FlagDependencyExportsPlugin = require("./FlagDependencyExportsPlugin");