webpack 5.41.1 → 5.44.0

package/lib/Compiler.js

@@ -260,6 +260,8 @@ class Compiler {
 
 		/** @type {Compilation} */
 		this._lastCompilation = undefined;
+		/** @type {NormalModuleFactory} */
+		this._lastNormalModuleFactory = undefined;
 
 		/** @private @type {WeakMap<Source, { sizeOnlySource: SizeOnlySource, writtenTo: Map<string, number> }>} */
 		this._assetEmittingSourceCache = new WeakMap();
@@ -375,6 +377,14 @@ class Compiler {
 		}
 	}
 
+	// TODO webpack 6: solve this in a better way
+	_cleanupLastNormalModuleFactory() {
+		if (this._lastNormalModuleFactory !== undefined) {
+			this._lastNormalModuleFactory.cleanupForCache();
+			this._lastNormalModuleFactory = undefined;
+		}
+	}
+
 	/**
 	 * @param {WatchOptions} watchOptions the watcher's options
 	 * @param {Callback<Stats>} handler signals when the call finishes
@@ -1036,6 +1046,7 @@ ${other}`);
 	}
 
 	createNormalModuleFactory() {
+		this._cleanupLastNormalModuleFactory();
 		const normalModuleFactory = new NormalModuleFactory({
 			context: this.options.context,
 			fs: this.inputFileSystem,
@@ -1044,6 +1055,7 @@ ${other}`);
 			associatedObjectForCache: this.root,
 			layers: this.options.experiments.layers
 		});
+		this._lastNormalModuleFactory = normalModuleFactory;
 		this.hooks.normalModuleFactory.call(normalModuleFactory);
 		return normalModuleFactory;
 	}
@@ -1122,8 +1134,9 @@ ${other}`);
 			if (err) return callback(err);
 			// Get rid of reference to last compilation to avoid leaking memory
 			// We can't run this._cleanupLastCompilation() as the Stats to this compilation
-			// might be still in use. We try to get rid for the reference to the cache instead.
+			// might be still in use. We try to get rid of the reference to the cache instead.
 			this._lastCompilation = undefined;
+			this._lastNormalModuleFactory = undefined;
 			this.cache.shutdown(callback);
 		});
 	}

package/lib/ExternalModule.js

@@ -16,6 +16,7 @@ const StaticExportsDependency = require("./dependencies/StaticExportsDependency"
 const extractUrlAndGlobal = require("./util/extractUrlAndGlobal");
 const makeSerializable = require("./util/makeSerializable");
 const propertyAccess = require("./util/propertyAccess");
+const { register } = require("./util/serialization");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
@@ -169,6 +170,8 @@ class ModuleExternalInitFragment extends InitFragment {
 			`external module import ${id}`
 		);
 		this._identifier = identifier;
+		this._id = id;
+		this._request = request;
 	}
 
 	getNamespaceIdentifier() {
@@ -176,6 +179,21 @@ class ModuleExternalInitFragment extends InitFragment {
 	}
 }
 
+register(
+	ModuleExternalInitFragment,
+	"webpack/lib/ExternalModule",
+	"ModuleExternalInitFragment",
+	{
+		serialize(obj, { write }) {
+			write(obj._id);
+			write(obj._request);
+		},
+		deserialize({ read }) {
+			return new ModuleExternalInitFragment(read(), read());
+		}
+	}
+);
+
 const generateModuleRemapping = (input, exportsInfo, runtime) => {
 	if (exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused) {
 		const properties = [];
@@ -429,6 +447,11 @@ class ExternalModule extends Module {
 				this.buildInfo.strict = false;
 				break;
 			case "system":
+				if (!Array.isArray(request) || request.length === 1) {
+					this.buildMeta.exportsType = "namespace";
+					canMangle = true;
+				}
+				break;
 			case "module":
 				if (this.buildInfo.module) {
 					if (!Array.isArray(request) || request.length === 1) {

package/lib/ExternalModuleFactoryPlugin.js

@@ -12,7 +12,7 @@ const { resolveByProperty, cachedSetProperty } = require("./util/cleverMerge");
 /** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
 /** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 
-const UNSPECIFIED_EXTERNAL_TYPE_REGEXP = /^[a-z0-9]+ /;
+const UNSPECIFIED_EXTERNAL_TYPE_REGEXP = /^[a-z0-9-]+ /;
 const EMPTY_RESOLVE_OPTIONS = {};
 
 // TODO webpack 6 remove this

package/lib/FlagDependencyUsagePlugin.js

@@ -180,7 +180,11 @@ class FlagDependencyUsagePlugin {
 									b.groupOptions &&
 									b.groupOptions.entryOptions
 								) {
-									processModule(b, b.groupOptions.entryOptions.runtime, true);
+									processModule(
+										b,
+										b.groupOptions.entryOptions.runtime || undefined,
+										true
+									);
 								} else {
 									queue.enqueue(b);
 								}

package/lib/NormalModuleFactory.js

@@ -13,8 +13,10 @@ const {
 	SyncHook,
 	HookMap
 } = require("tapable");
+const ChunkGraph = require("./ChunkGraph");
 const Module = require("./Module");
 const ModuleFactory = require("./ModuleFactory");
+const ModuleGraph = require("./ModuleGraph");
 const NormalModule = require("./NormalModule");
 const BasicEffectRulePlugin = require("./rules/BasicEffectRulePlugin");
 const BasicMatcherRulePlugin = require("./rules/BasicMatcherRulePlugin");
@@ -257,8 +259,8 @@ class NormalModuleFactory extends ModuleFactory {
 		this.parserCache = new Map();
 		/** @type {Map<string, WeakMap<Object, Generator>>} */
 		this.generatorCache = new Map();
-		/** @type {WeakSet<Module>} */
-		this._restoredUnsafeCacheEntries = new WeakSet();
+		/** @type {Set<Module>} */
+		this._restoredUnsafeCacheEntries = new Set();
 
 		const cacheParseResource = parseResource.bindCache(
 			associatedObjectForCache
@@ -661,6 +663,14 @@ class NormalModuleFactory extends ModuleFactory {
 		);
 	}
 
+	cleanupForCache() {
+		for (const module of this._restoredUnsafeCacheEntries) {
+			ChunkGraph.clearChunkGraphForModule(module);
+			ModuleGraph.clearModuleGraphForModule(module);
+			module.cleanupForCache();
+		}
+	}
+
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
 	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
@@ -756,6 +766,7 @@ class NormalModuleFactory extends ModuleFactory {
 					if (!unsafeCacheData.has(module)) {
 						unsafeCacheData.set(module, module.getUnsafeCacheData());
 					}
+					this._restoredUnsafeCacheEntries.add(module);
 				}
 
 				callback(null, factoryResult);

package/lib/Template.js

@@ -379,6 +379,7 @@ class Template {
 				source.add(Template.toNormalComment(module.identifier()) + "\n");
 				if (!module.shouldIsolate()) {
 					source.add(runtimeSource);
+					source.add("\n\n");
 				} else if (renderContext.runtimeTemplate.supportsArrowFunction()) {
 					source.add("(() => {\n");
 					if (renderContext.useStrict) source.add('\t"use strict";\n');

package/lib/WebpackOptionsApply.js

@@ -572,7 +572,8 @@ class WebpackOptionsApply extends OptionsApply {
 									snapshot: options.snapshot,
 									maxAge: cacheOptions.maxAge,
 									profile: cacheOptions.profile,
-									allowCollectingMemory: cacheOptions.allowCollectingMemory
+									allowCollectingMemory: cacheOptions.allowCollectingMemory,
+									compression: cacheOptions.compression
 								}),
 								cacheOptions.idleTimeout,
 								cacheOptions.idleTimeoutForInitialStore,

package/lib/asset/AssetGenerator.js

@@ -265,7 +265,7 @@ class AssetGenerator extends Generator {
 	 * @returns {Set<string>} available types (do not mutate)
 	 */
 	getTypes(module) {
-		if (module.buildInfo.dataUrl || this.emit === false) {
+		if ((module.buildInfo && module.buildInfo.dataUrl) || this.emit === false) {
 			return JS_TYPES;
 		} else {
 			return JS_AND_ASSET_TYPES;
@@ -289,7 +289,7 @@ class AssetGenerator extends Generator {
 				return originalSource.size();
 			}
 			default:
-				if (module.buildInfo.dataUrl) {
+				if (module.buildInfo && module.buildInfo.dataUrl) {
 					const originalSource = module.originalSource();
 
 					if (!originalSource) {

package/lib/cache/PackFileCacheStrategy.js

@@ -848,6 +848,7 @@ class PackFileCacheStrategy {
 	 * @param {number} options.maxAge max age of cache items
 	 * @param {boolean} options.profile track and log detailed timing information for individual cache items
 	 * @param {boolean} options.allowCollectingMemory allow to collect unused memory created during deserialization
+	 * @param {false | "gzip" | "brotli"} options.compression compression used
 	 */
 	constructor({
 		compiler,
@@ -859,7 +860,8 @@ class PackFileCacheStrategy {
 		snapshot,
 		maxAge,
 		profile,
-		allowCollectingMemory
+		allowCollectingMemory,
+		compression
 	}) {
 		this.fileSerializer = createFileSerializer(fs);
 		this.fileSystemInfo = new FileSystemInfo(fs, {
@@ -875,6 +877,13 @@ class PackFileCacheStrategy {
 		this.maxAge = maxAge;
 		this.profile = profile;
 		this.allowCollectingMemory = allowCollectingMemory;
+		this.compression = compression;
+		this._extension =
+			compression === "brotli"
+				? ".pack.br"
+				: compression === "gzip"
+				? ".pack.gz"
+				: ".pack";
 		this.snapshot = snapshot;
 		/** @type {Set<string>} */
 		this.buildDependencies = new Set();
@@ -916,8 +925,8 @@ class PackFileCacheStrategy {
 		logger.time("restore cache container");
 		return this.fileSerializer
 			.deserialize(null, {
-				filename: `${cacheLocation}/index.pack`,
-				extension: ".pack",
+				filename: `${cacheLocation}/index${this._extension}`,
+				extension: `${this._extension}`,
 				logger,
 				profile,
 				retainedBuffer: this.allowCollectingMemory
@@ -927,11 +936,13 @@ class PackFileCacheStrategy {
 			.catch(err => {
 				if (err.code !== "ENOENT") {
 					logger.warn(
-						`Restoring pack failed from ${cacheLocation}.pack: ${err}`
+						`Restoring pack failed from ${cacheLocation}${this._extension}: ${err}`
 					);
 					logger.debug(err.stack);
 				} else {
-					logger.debug(`No pack exists at ${cacheLocation}.pack: ${err}`);
+					logger.debug(
+						`No pack exists at ${cacheLocation}${this._extension}: ${err}`
+					);
 				}
 				return undefined;
 			})
@@ -940,14 +951,14 @@ class PackFileCacheStrategy {
 				if (!packContainer) return undefined;
 				if (!(packContainer instanceof PackContainer)) {
 					logger.warn(
-						`Restored pack from ${cacheLocation}.pack, but contained content is unexpected.`,
+						`Restored pack from ${cacheLocation}${this._extension}, but contained content is unexpected.`,
 						packContainer
 					);
 					return undefined;
 				}
 				if (packContainer.version !== version) {
 					logger.log(
-						`Restored pack from ${cacheLocation}.pack, but version doesn't match.`
+						`Restored pack from ${cacheLocation}${this._extension}, but version doesn't match.`
 					);
 					return undefined;
 				}
@@ -959,14 +970,14 @@ class PackFileCacheStrategy {
 							(err, valid) => {
 								if (err) {
 									logger.log(
-										`Restored pack from ${cacheLocation}.pack, but checking snapshot of build dependencies errored: ${err}.`
+										`Restored pack from ${cacheLocation}${this._extension}, but checking snapshot of build dependencies errored: ${err}.`
 									);
 									logger.debug(err.stack);
 									return resolve(false);
 								}
 								if (!valid) {
 									logger.log(
-										`Restored pack from ${cacheLocation}.pack, but build dependencies have changed.`
+										`Restored pack from ${cacheLocation}${this._extension}, but build dependencies have changed.`
 									);
 									return resolve(false);
 								}
@@ -981,7 +992,7 @@ class PackFileCacheStrategy {
 							(err, valid) => {
 								if (err) {
 									logger.log(
-										`Restored pack from ${cacheLocation}.pack, but checking snapshot of resolving of build dependencies errored: ${err}.`
+										`Restored pack from ${cacheLocation}${this._extension}, but checking snapshot of resolving of build dependencies errored: ${err}.`
 									);
 									logger.debug(err.stack);
 									return resolve(false);
@@ -1001,7 +1012,7 @@ class PackFileCacheStrategy {
 									(err, valid) => {
 										if (err) {
 											logger.log(
-												`Restored pack from ${cacheLocation}.pack, but resolving of build dependencies errored: ${err}.`
+												`Restored pack from ${cacheLocation}${this._extension}, but resolving of build dependencies errored: ${err}.`
 											);
 											logger.debug(err.stack);
 											return resolve(false);
@@ -1012,7 +1023,7 @@ class PackFileCacheStrategy {
 											return resolve(true);
 										}
 										logger.log(
-											`Restored pack from ${cacheLocation}.pack, but build dependencies resolve to different locations.`
+											`Restored pack from ${cacheLocation}${this._extension}, but build dependencies resolve to different locations.`
 										);
 										return resolve(false);
 									}
@@ -1052,7 +1063,7 @@ class PackFileCacheStrategy {
 			})
 			.catch(err => {
 				this.logger.warn(
-					`Restoring pack from ${cacheLocation}.pack failed: ${err}`
+					`Restoring pack from ${cacheLocation}${this._extension} failed: ${err}`
 				);
 				this.logger.debug(err.stack);
 				return new Pack(logger, this.maxAge);
@@ -1236,8 +1247,8 @@ class PackFileCacheStrategy {
 					);
 					return this.fileSerializer
 						.serialize(content, {
-							filename: `${this.cacheLocation}/index.pack`,
-							extension: ".pack",
+							filename: `${this.cacheLocation}/index${this._extension}`,
+							extension: `${this._extension}`,
 							logger: this.logger,
 							profile: this.profile
 						})

package/lib/config/defaults.js

@@ -298,6 +298,7 @@ const applyCacheDefaults = (cache, { name, mode, development }) => {
 			);
 			D(cache, "hashAlgorithm", "md4");
 			D(cache, "store", "pack");
+			D(cache, "compression", development ? false : "gzip");
 			D(cache, "profile", false);
 			D(cache, "idleTimeout", 60000);
 			D(cache, "idleTimeoutForInitialStore", 5000);

package/lib/config/normalization.js

@@ -137,6 +137,7 @@ const getNormalizedWebpackOptions = config => {
 						cacheDirectory: cache.cacheDirectory,
 						cacheLocation: cache.cacheLocation,
 						hashAlgorithm: cache.hashAlgorithm,
+						compression: cache.compression,
 						idleTimeout: cache.idleTimeout,
 						idleTimeoutForInitialStore: cache.idleTimeoutForInitialStore,
 						idleTimeoutAfterLargeChanges: cache.idleTimeoutAfterLargeChanges,

package/lib/container/ContainerPlugin.js

@@ -39,6 +39,7 @@ class ContainerPlugin {
 				type: "var",
 				name: options.name
 			},
+			runtime: options.runtime,
 			filename: options.filename || undefined,
 			exposes: parseOptions(
 				options.exposes,
@@ -60,7 +61,8 @@ class ContainerPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const { name, exposes, shareScope, filename, library } = this._options;
+		const { name, exposes, shareScope, filename, library, runtime } =
+			this._options;
 
 		compiler.options.output.enabledLibraryTypes.push(library.type);
 
@@ -73,6 +75,7 @@ class ContainerPlugin {
 				{
 					name,
 					filename,
+					runtime,
 					library
 				},
 				error => {

package/lib/container/ModuleFederationPlugin.js

@@ -64,6 +64,7 @@ class ModuleFederationPlugin {
 					name: options.name,
 					library,
 					filename: options.filename,
+					runtime: options.runtime,
 					exposes: options.exposes
 				}).apply(compiler);
 			}

package/lib/dependencies/WorkerPlugin.js

@@ -270,7 +270,7 @@ class WorkerPlugin {
 							entryOptions.name = options.name;
 						}
 
-						if (!entryOptions.runtime) {
+						if (entryOptions.runtime === undefined) {
 							let i = workerIndexMap.get(parser.state) || 0;
 							workerIndexMap.set(parser.state, i + 1);
 							let name = `${cachedContextify(

package/lib/esm/ExportWebpackRequireRuntimeModule.js

@@ -0,0 +1,29 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeModule = require("../RuntimeModule");
+
+class ExportWebpackRequireRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("export webpack runtime", RuntimeModule.STAGE_ATTACH);
+	}
+
+	/**
+	 * @returns {boolean} true, if the runtime module should get it's own scope
+	 */
+	shouldIsolate() {
+		return false;
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		return "export default __webpack_require__;";
+	}
+}
+
+module.exports = ExportWebpackRequireRuntimeModule;

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -5,13 +5,18 @@
 
 "use strict";
 
-const { ConcatSource } = require("webpack-sources");
+const { ConcatSource, RawSource } = require("webpack-sources");
 const { RuntimeGlobals } = require("..");
 const HotUpdateChunk = require("../HotUpdateChunk");
 const Template = require("../Template");
 const {
-	getCompilationHooks
+	getCompilationHooks,
+	getChunkFilenameTemplate
 } = require("../javascript/JavascriptModulesPlugin");
+const {
+	generateEntryStartup,
+	updateHashForEntryStartup
+} = require("../javascript/StartupHelpers");
 
 /** @typedef {import("../Compiler")} Compiler */
 
@@ -30,8 +35,9 @@ class ModuleChunkFormatPlugin {
 					(chunk, set) => {
 						if (chunk.hasRuntime()) return;
 						if (compilation.chunkGraph.getNumberOfEntryModules(chunk) > 0) {
-							set.add(RuntimeGlobals.onChunksLoaded);
 							set.add(RuntimeGlobals.require);
+							set.add(RuntimeGlobals.startupEntrypoint);
+							set.add(RuntimeGlobals.externalInstallChunk);
 						}
 					}
 				);
@@ -39,7 +45,7 @@ class ModuleChunkFormatPlugin {
 				hooks.renderChunk.tap(
 					"ModuleChunkFormatPlugin",
 					(modules, renderContext) => {
-						const { chunk, chunkGraph } = renderContext;
+						const { chunk, chunkGraph, runtimeTemplate } = renderContext;
 						const hotUpdateChunk =
 							chunk instanceof HotUpdateChunk ? chunk : null;
 						const source = new ConcatSource();
@@ -68,9 +74,84 @@ class ModuleChunkFormatPlugin {
 								chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
 							);
 							if (entries.length > 0) {
-								throw new Error(
-									"Entry modules in chunk is not implemented for module chunk format yet"
+								const runtimeChunk = entries[0][1].getRuntimeChunk();
+								const currentOutputName = compilation
+									.getPath(
+										getChunkFilenameTemplate(chunk, compilation.outputOptions),
+										{
+											chunk,
+											contentHashType: "javascript"
+										}
+									)
+									.split("/");
+								const runtimeOutputName = compilation
+									.getPath(
+										getChunkFilenameTemplate(
+											runtimeChunk,
+											compilation.outputOptions
+										),
+										{
+											chunk: runtimeChunk,
+											contentHashType: "javascript"
+										}
+									)
+									.split("/");
+
+								// remove filename, we only need the directory
+								const outputFilename = currentOutputName.pop();
+
+								// remove common parts
+								while (
+									currentOutputName.length > 0 &&
+									runtimeOutputName.length > 0 &&
+									currentOutputName[0] === runtimeOutputName[0]
+								) {
+									currentOutputName.shift();
+									runtimeOutputName.shift();
+								}
+
+								// create final path
+								const runtimePath =
+									(currentOutputName.length > 0
+										? "../".repeat(currentOutputName.length)
+										: "./") + runtimeOutputName.join("/");
+
+								const entrySource = new ConcatSource();
+								entrySource.add(source);
+								entrySource.add(";\n\n// load runtime\n");
+								entrySource.add(
+									`import __webpack_require__ from ${JSON.stringify(
+										runtimePath
+									)};\n`
+								);
+								entrySource.add(
+									`import * as __webpack_self_exports__ from ${JSON.stringify(
+										"./" + outputFilename
+									)};\n`
+								);
+								entrySource.add(
+									`${RuntimeGlobals.externalInstallChunk}(__webpack_self_exports__);\n`
+								);
+								const startupSource = new RawSource(
+									generateEntryStartup(
+										chunkGraph,
+										runtimeTemplate,
+										entries,
+										chunk,
+										false
+									)
+								);
+								entrySource.add(
+									hooks.renderStartup.call(
+										startupSource,
+										entries[entries.length - 1][0],
+										{
+											...renderContext,
+											inlined: false
+										}
+									)
 								);
+								return entrySource;
 							}
 						}
 						return source;
@@ -82,11 +163,10 @@ class ModuleChunkFormatPlugin {
 						if (chunk.hasRuntime()) return;
 						hash.update("ModuleChunkFormatPlugin");
 						hash.update("1");
-						// TODO
-						// const entries = Array.from(
-						// 	chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-						// );
-						// updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
+						const entries = Array.from(
+							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
+						);
+						updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
 					}
 				);
 			}

package/lib/esm/ModuleChunkLoadingPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const RuntimeGlobals = require("../RuntimeGlobals");
+const ExportWebpackRequireRuntimeModule = require("./ExportWebpackRequireRuntimeModule");
 const ModuleChunkLoadingRuntimeModule = require("./ModuleChunkLoadingRuntimeModule");
 
 /** @typedef {import("../Compiler")} Compiler */
@@ -45,9 +46,21 @@ class ModuleChunkLoadingPlugin {
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.baseURI)
 					.tap("ModuleChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.externalInstallChunk)
+					.tap("ModuleChunkLoadingPlugin", handler);
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.onChunksLoaded)
 					.tap("ModuleChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.externalInstallChunk)
+					.tap("ModuleChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						compilation.addRuntimeModule(
+							chunk,
+							new ExportWebpackRequireRuntimeModule()
+						);
+					});
 
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.ensureChunkHandlers)