webpack 5.1.2 → 5.3.0

package/lib/container/ContainerEntryModule.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const { OriginalSource } = require("webpack-sources");
+const { OriginalSource, RawSource } = require("webpack-sources");
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Module = require("../Module");
 const RuntimeGlobals = require("../RuntimeGlobals");
@@ -233,7 +233,9 @@ class ContainerEntryModule extends Module {
 
 		sources.set(
 			"javascript",
-			new OriginalSource(source, "webpack/container-entry")
+			this.useSourceMap || this.useSimpleSourceMap
+				? new OriginalSource(source, "webpack/container-entry")
+				: new RawSource(source)
 		);
 
 		return {

package/lib/dependencies/HarmonyAcceptDependency.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const Template = require("../Template");
 const makeSerializable = require("../util/makeSerializable");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
 const NullDependency = require("./NullDependency");
@@ -62,14 +63,41 @@ HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate extends
 	 */
 	apply(dependency, source, templateContext) {
 		const dep = /** @type {HarmonyAcceptDependency} */ (dependency);
-		const { module, runtimeTemplate } = templateContext;
+		const {
+			module,
+			runtime,
+			runtimeRequirements,
+			runtimeTemplate,
+			moduleGraph,
+			chunkGraph
+		} = templateContext;
 		const content = dep.dependencies
-			.filter(dependency =>
-				HarmonyImportDependency.Template.isImportEmitted(dependency, module)
-			)
 			.map(dependency => {
+				const referencedModule = moduleGraph.getModule(dependency);
+				return {
+					dependency,
+					runtimeCondition: referencedModule
+						? HarmonyImportDependency.Template.getImportEmittedRuntime(
+								module,
+								referencedModule
+						  )
+						: false
+				};
+			})
+			.filter(({ runtimeCondition }) => runtimeCondition !== false)
+			.map(({ dependency, runtimeCondition }) => {
+				const condition = runtimeTemplate.runtimeConditionExpression({
+					chunkGraph,
+					runtime,
+					runtimeCondition,
+					runtimeRequirements
+				});
 				const s = dependency.getImportStatement(true, templateContext);
-				return s[0] + s[1];
+				const code = s[0] + s[1];
+				if (condition !== "true") {
+					return `if (${condition}) {\n${Template.indent(code)}\n}\n`;
+				}
+				return code;
 			})
 			.join("");
 

package/lib/dependencies/HarmonyImportDependency.js

@@ -5,11 +5,13 @@
 
 "use strict";
 
+const ConditionalInitFragment = require("../ConditionalInitFragment");
 const Dependency = require("../Dependency");
 const HarmonyLinkingError = require("../HarmonyLinkingError");
 const InitFragment = require("../InitFragment");
 const Template = require("../Template");
 const AwaitDependenciesInitFragment = require("../async-modules/AwaitDependenciesInitFragment");
+const { filterRuntime, mergeRuntime } = require("../util/runtime");
 const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
@@ -199,21 +201,38 @@ class HarmonyImportDependency extends ModuleDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		const { chunkGraph } = context;
+		const { chunkGraph, runtime, runtimeTemplate } = context;
 		const { moduleGraph } = chunkGraph;
 		super.updateHash(hash, context);
-		const importedModule = moduleGraph.getModule(this);
-		if (importedModule) {
-			const parentModule = moduleGraph.getParentModule(this);
-			hash.update(
-				importedModule.getExportsType(
-					moduleGraph,
-					parentModule.buildMeta && parentModule.buildMeta.strictHarmonyModule
-				)
-			);
-			if (moduleGraph.isAsync(importedModule)) hash.update("async");
-		}
 		hash.update(`${this.sourceOrder}`);
+		const connection = moduleGraph.getConnection(this);
+		if (connection) {
+			const importedModule = connection.module;
+			if (importedModule) {
+				const parentModule = moduleGraph.getParentModule(this);
+				hash.update(
+					importedModule.getExportsType(
+						moduleGraph,
+						parentModule.buildMeta && parentModule.buildMeta.strictHarmonyModule
+					)
+				);
+				if (moduleGraph.isAsync(importedModule)) hash.update("async");
+			}
+			if (runtimeTemplate) {
+				const runtimeRequirements = new Set();
+				hash.update(
+					runtimeTemplate.runtimeConditionExpression({
+						chunkGraph,
+						runtimeCondition: filterRuntime(runtime, runtime => {
+							return connection.isTargetActive(runtime);
+						}),
+						runtime,
+						runtimeRequirements
+					})
+				);
+				for (const rr of runtimeRequirements) hash.update(rr);
+			}
+		}
 	}
 
 	serialize(context) {
@@ -231,6 +250,7 @@ class HarmonyImportDependency extends ModuleDependency {
 
 module.exports = HarmonyImportDependency;
 
+/** @type {WeakMap<Module, WeakMap<Module, RuntimeSpec | boolean>>} */
 const importEmittedMap = new WeakMap();
 
 HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends ModuleDependency.Template {
@@ -265,23 +285,42 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 			: dep.request;
 		const key = `harmony import ${moduleKey}`;
 
-		if (module) {
-			let emittedModules = importEmittedMap.get(dep);
+		const runtimeCondition = dep.weak
+			? false
+			: connection
+			? filterRuntime(runtime, r => connection.isTargetActive(r))
+			: true;
+
+		if (module && referencedModule) {
+			let emittedModules = importEmittedMap.get(module);
 			if (emittedModules === undefined) {
-				emittedModules = new WeakSet();
-				importEmittedMap.set(dep, emittedModules);
+				emittedModules = new WeakMap();
+				importEmittedMap.set(module, emittedModules);
+			}
+			let mergedRuntimeCondition = runtimeCondition;
+			const oldRuntimeCondition = emittedModules.get(referencedModule) || false;
+			if (oldRuntimeCondition !== false && mergedRuntimeCondition !== true) {
+				if (mergedRuntimeCondition === false || oldRuntimeCondition === true) {
+					mergedRuntimeCondition = oldRuntimeCondition;
+				} else {
+					mergedRuntimeCondition = mergeRuntime(
+						oldRuntimeCondition,
+						mergedRuntimeCondition
+					);
+				}
 			}
-			emittedModules.add(module);
+			emittedModules.set(referencedModule, mergedRuntimeCondition);
 		}
 
 		const importStatement = dep.getImportStatement(false, templateContext);
 		if (templateContext.moduleGraph.isAsync(referencedModule)) {
 			templateContext.initFragments.push(
-				new InitFragment(
+				new ConditionalInitFragment(
 					importStatement[0],
 					InitFragment.STAGE_HARMONY_IMPORTS,
 					dep.sourceOrder,
-					key
+					key,
+					runtimeCondition
 				)
 			);
 			templateContext.initFragments.push(
@@ -290,20 +329,22 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 				)
 			);
 			templateContext.initFragments.push(
-				new InitFragment(
+				new ConditionalInitFragment(
 					importStatement[1],
 					InitFragment.STAGE_ASYNC_HARMONY_IMPORTS,
 					dep.sourceOrder,
-					key + " compat"
+					key + " compat",
+					runtimeCondition
 				)
 			);
 		} else {
 			templateContext.initFragments.push(
-				new InitFragment(
+				new ConditionalInitFragment(
 					importStatement[0] + importStatement[1],
 					InitFragment.STAGE_HARMONY_IMPORTS,
 					dep.sourceOrder,
-					key
+					key,
+					runtimeCondition
 				)
 			);
 		}
@@ -311,12 +352,13 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 
 	/**
 	 *
-	 * @param {Dependency} dep the dependency
 	 * @param {Module} module the module
-	 * @returns {boolean} true, when for this dependency and module a import init fragment was created
+	 * @param {Module} referencedModule the referenced module
+	 * @returns {RuntimeSpec | boolean} runtimeCondition in which this import has been emitted
 	 */
-	static isImportEmitted(dep, module) {
-		const emittedModules = importEmittedMap.get(dep);
-		return emittedModules !== undefined && emittedModules.has(module);
+	static getImportEmittedRuntime(module, referencedModule) {
+		const emittedModules = importEmittedMap.get(module);
+		if (emittedModules === undefined) return false;
+		return emittedModules.get(referencedModule) || false;
 	}
 };

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -196,7 +196,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		const { chunkGraph } = context;
+		const { chunkGraph, runtime } = context;
 		super.updateHash(hash, context);
 		const moduleGraph = chunkGraph.moduleGraph;
 		const importedModule = moduleGraph.getModule(this);
@@ -204,7 +204,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		hash.update(ids.join());
 		if (importedModule) {
 			const exportsInfo = moduleGraph.getExportsInfo(importedModule);
-			hash.update(`${exportsInfo.getUsedName(ids, context.runtime)}`);
+			hash.update(`${exportsInfo.getUsedName(ids, runtime)}`);
 		}
 	}
 

package/lib/dependencies/PureExpressionDependency.js

@@ -7,6 +7,7 @@
 
 const { UsageState } = require("../ExportsInfo");
 const makeSerializable = require("../util/makeSerializable");
+const { filterRuntime } = require("../util/runtime");
 const NullDependency = require("./NullDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
@@ -74,22 +75,45 @@ PureExpressionDependency.Template = class PureExpressionDependencyTemplate exten
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(dependency, source, { moduleGraph, runtime }) {
+	apply(
+		dependency,
+		source,
+		{ chunkGraph, moduleGraph, runtime, runtimeTemplate, runtimeRequirements }
+	) {
 		const dep = /** @type {PureExpressionDependency} */ (dependency);
 
-		if (dep.usedByExports !== false) {
+		const usedByExports = dep.usedByExports;
+		if (usedByExports !== false) {
 			const selfModule = moduleGraph.getParentModule(dep);
 			const exportsInfo = moduleGraph.getExportsInfo(selfModule);
-			for (const exportName of dep.usedByExports) {
-				if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused) {
-					return;
+			const runtimeCondition = filterRuntime(runtime, runtime => {
+				for (const exportName of usedByExports) {
+					if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused) {
+						return true;
+					}
 				}
+				return false;
+			});
+			if (runtimeCondition === true) return;
+			if (runtimeCondition !== false) {
+				const condition = runtimeTemplate.runtimeConditionExpression({
+					chunkGraph,
+					runtime,
+					runtimeCondition,
+					runtimeRequirements
+				});
+				source.insert(
+					dep.range[0],
+					`(/* runtime-dependent pure expression or super */ ${condition} ? (`
+				);
+				source.insert(dep.range[1], ") : null)");
+				return;
 			}
 		}
 
 		source.insert(
 			dep.range[0],
-			"(/* unused pure expression or super */ null && ("
+			`(/* unused pure expression or super */ null && (`
 		);
 		source.insert(dep.range[1], "))");
 	}

package/lib/dependencies/WorkerPlugin.js

@@ -12,6 +12,7 @@ const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 const formatLocation = require("../formatLocation");
 const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin");
 const { equals } = require("../util/ArrayHelpers");
+const { contextify } = require("../util/identifier");
 const {
 	harmonySpecifierTag
 } = require("./HarmonyImportDependencyParserPlugin");
@@ -48,6 +49,10 @@ class WorkerPlugin {
 		if (this._chunkLoading) {
 			new EnableChunkLoadingPlugin(this._chunkLoading).apply(compiler);
 		}
+		const cachedContextify = contextify.bindContextCache(
+			compiler.context,
+			compiler.root
+		);
 		compiler.hooks.thisCompilation.tap(
 			"WorkerPlugin",
 			(compilation, { normalModuleFactory }) => {
@@ -213,9 +218,9 @@ class WorkerPlugin {
 							}
 
 							if (!entryOptions.runtime) {
-								entryOptions.runtime = `${parser.state.module.identifier()}|${formatLocation(
-									expr.loc
-								)}`;
+								entryOptions.runtime = `${cachedContextify(
+									parser.state.module.identifier()
+								)}|${formatLocation(expr.loc)}`;
 							}
 
 							const block = new AsyncDependenciesBlock({

package/lib/javascript/JavascriptModulesPlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const { SyncWaterfallHook, SyncHook } = require("tapable");
+const { SyncWaterfallHook, SyncHook, SyncBailHook } = require("tapable");
 const {
 	ConcatSource,
 	OriginalSource,
@@ -103,6 +103,7 @@ const chunkHasJs = (chunk, chunkGraph) => {
  * @property {SyncWaterfallHook<[Source, RenderContext]>} render
  * @property {SyncWaterfallHook<[string, RenderBootstrapContext]>} renderRequire
  * @property {SyncHook<[Chunk, Hash, ChunkHashContext]>} chunkHash
+ * @property {SyncBailHook<[Chunk, RenderContext], boolean>} useSourceMap
  */
 
 /** @type {WeakMap<Compilation, CompilationHooks>} */
@@ -141,7 +142,8 @@ class JavascriptModulesPlugin {
 				renderChunk: new SyncWaterfallHook(["source", "renderContext"]),
 				renderMain: new SyncWaterfallHook(["source", "renderContext"]),
 				renderRequire: new SyncWaterfallHook(["code", "renderContext"]),
-				chunkHash: new SyncHook(["chunk", "hash", "context"])
+				chunkHash: new SyncHook(["chunk", "hash", "context"]),
+				useSourceMap: new SyncBailHook(["chunk", "renderContext"])
 			};
 			compilationHooksMap.set(compilation, hooks);
 		}
@@ -272,6 +274,9 @@ class JavascriptModulesPlugin {
 								chunk,
 								contentHashType: "javascript"
 							},
+							info: {
+								javascriptModule: compilation.runtimeTemplate.isModule()
+							},
 							identifier: hotUpdateChunk
 								? `hotupdatechunk${chunk.id}`
 								: `chunk${chunk.id}`,
@@ -531,6 +536,7 @@ class JavascriptModulesPlugin {
 		const iife = runtimeTemplate.isIIFE();
 
 		const bootstrap = this.renderBootstrap(renderContext, hooks);
+		const useSourceMap = hooks.useSourceMap.call(chunk, renderContext);
 
 		const allModules = Array.from(
 			chunkGraph.getOrderedChunkModulesIterableBySourceType(
@@ -590,13 +596,13 @@ class JavascriptModulesPlugin {
 		}
 
 		if (bootstrap.header.length > 0) {
+			const header = Template.asString(bootstrap.header) + "\n";
 			source.add(
 				new PrefixSource(
 					prefix,
-					new OriginalSource(
-						Template.asString(bootstrap.header) + "\n",
-						"webpack/bootstrap"
-					)
+					useSourceMap
+						? new OriginalSource(header, "webpack/bootstrap")
+						: new RawSource(header)
 				)
 			);
 			source.add(
@@ -653,13 +659,13 @@ class JavascriptModulesPlugin {
 				}
 			}
 		} else {
+			const startup = Template.asString(bootstrap.startup) + "\n";
 			source.add(
 				new PrefixSource(
 					prefix,
-					new OriginalSource(
-						Template.asString(bootstrap.startup) + "\n",
-						"webpack/startup"
-					)
+					useSourceMap
+						? new OriginalSource(startup, "webpack/startup")
+						: new RawSource(startup)
 				)
 			);
 		}