webpack 5.59.0 → 5.94.0

package/lib/WebpackOptionsApply.js

@@ -35,6 +35,7 @@ const ResolverCachePlugin = require("./cache/ResolverCachePlugin");
 
 const CommonJsPlugin = require("./dependencies/CommonJsPlugin");
 const HarmonyModulesPlugin = require("./dependencies/HarmonyModulesPlugin");
+const ImportMetaContextPlugin = require("./dependencies/ImportMetaContextPlugin");
 const ImportMetaPlugin = require("./dependencies/ImportMetaPlugin");
 const ImportPlugin = require("./dependencies/ImportPlugin");
 const LoaderPlugin = require("./dependencies/LoaderPlugin");
@@ -56,6 +57,8 @@ const { cleverMerge } = require("./util/cleverMerge");
 
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */
 
 class WebpackOptionsApply extends OptionsApply {
 	constructor() {
@@ -68,13 +71,13 @@ class WebpackOptionsApply extends OptionsApply {
 	 * @returns {WebpackOptions} options object
 	 */
 	process(options, compiler) {
-		compiler.outputPath = options.output.path;
+		compiler.outputPath = /** @type {string} */ (options.output.path);
 		compiler.recordsInputPath = options.recordsInputPath || null;
 		compiler.recordsOutputPath = options.recordsOutputPath || null;
 		compiler.name = options.name;
 
 		if (options.externals) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ExternalsPlugin = require("./ExternalsPlugin");
 			new ExternalsPlugin(options.externalsType, options.externals).apply(
 				compiler
@@ -86,17 +89,17 @@ class WebpackOptionsApply extends OptionsApply {
 			new NodeTargetPlugin().apply(compiler);
 		}
 		if (options.externalsPresets.electronMain) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
 			new ElectronTargetPlugin("main").apply(compiler);
 		}
 		if (options.externalsPresets.electronPreload) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
 			new ElectronTargetPlugin("preload").apply(compiler);
 		}
 		if (options.externalsPresets.electronRenderer) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
 			new ElectronTargetPlugin("renderer").apply(compiler);
 		}
@@ -106,23 +109,69 @@ class WebpackOptionsApply extends OptionsApply {
 			!options.externalsPresets.electronPreload &&
 			!options.externalsPresets.electronRenderer
 		) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
 			new ElectronTargetPlugin().apply(compiler);
 		}
 		if (options.externalsPresets.nwjs) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ExternalsPlugin = require("./ExternalsPlugin");
 			new ExternalsPlugin("node-commonjs", "nw.gui").apply(compiler);
 		}
 		if (options.externalsPresets.webAsync) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ExternalsPlugin = require("./ExternalsPlugin");
-			new ExternalsPlugin("import", /^(https?:\/\/|std:)/).apply(compiler);
+			new ExternalsPlugin("import", ({ request, dependencyType }, callback) => {
+				if (dependencyType === "url") {
+					if (/^(\/\/|https?:\/\/|#)/.test(request))
+						return callback(null, `asset ${request}`);
+				} else if (options.experiments.css && dependencyType === "css-import") {
+					if (/^(\/\/|https?:\/\/|#)/.test(request))
+						return callback(null, `css-import ${request}`);
+				} else if (
+					options.experiments.css &&
+					/^(\/\/|https?:\/\/|std:)/.test(request)
+				) {
+					if (/^\.css(\?|$)/.test(request))
+						return callback(null, `css-import ${request}`);
+					return callback(null, `import ${request}`);
+				}
+				callback();
+			}).apply(compiler);
 		} else if (options.externalsPresets.web) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			const ExternalsPlugin = require("./ExternalsPlugin");
+			new ExternalsPlugin("module", ({ request, dependencyType }, callback) => {
+				if (dependencyType === "url") {
+					if (/^(\/\/|https?:\/\/|#)/.test(request))
+						return callback(null, `asset ${request}`);
+				} else if (options.experiments.css && dependencyType === "css-import") {
+					if (/^(\/\/|https?:\/\/|#)/.test(request))
+						return callback(null, `css-import ${request}`);
+				} else if (/^(\/\/|https?:\/\/|std:)/.test(request)) {
+					if (options.experiments.css && /^\.css((\?)|$)/.test(request))
+						return callback(null, `css-import ${request}`);
+					return callback(null, `module ${request}`);
+				}
+				callback();
+			}).apply(compiler);
+		} else if (options.externalsPresets.node && options.experiments.css) {
+			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ExternalsPlugin = require("./ExternalsPlugin");
-			new ExternalsPlugin("module", /^(https?:\/\/|std:)/).apply(compiler);
+			new ExternalsPlugin("module", ({ request, dependencyType }, callback) => {
+				if (dependencyType === "url") {
+					if (/^(\/\/|https?:\/\/|#)/.test(request))
+						return callback(null, `asset ${request}`);
+				} else if (dependencyType === "css-import") {
+					if (/^(\/\/|https?:\/\/|#)/.test(request))
+						return callback(null, `css-import ${request}`);
+				} else if (/^(\/\/|https?:\/\/|std:)/.test(request)) {
+					if (/^\.css(\?|$)/.test(request))
+						return callback(null, `css-import ${request}`);
+					return callback(null, `module ${request}`);
+				}
+				callback();
+			}).apply(compiler);
 		}
 
 		new ChunkPrefetchPreloadPlugin().apply(compiler);
@@ -146,27 +195,39 @@ class WebpackOptionsApply extends OptionsApply {
 				}
 				default:
 					throw new Error(
-						"Unsupported chunk format '" + options.output.chunkFormat + "'."
+						`Unsupported chunk format '${options.output.chunkFormat}'.`
 					);
 			}
 		}
 
-		if (options.output.enabledChunkLoadingTypes.length > 0) {
-			for (const type of options.output.enabledChunkLoadingTypes) {
+		const enabledChunkLoadingTypes =
+			/** @type {NonNullable<WebpackOptions["output"]["enabledChunkLoadingTypes"]>} */
+			(options.output.enabledChunkLoadingTypes);
+
+		if (enabledChunkLoadingTypes.length > 0) {
+			for (const type of enabledChunkLoadingTypes) {
 				const EnableChunkLoadingPlugin = require("./javascript/EnableChunkLoadingPlugin");
 				new EnableChunkLoadingPlugin(type).apply(compiler);
 			}
 		}
 
-		if (options.output.enabledWasmLoadingTypes.length > 0) {
-			for (const type of options.output.enabledWasmLoadingTypes) {
+		const enabledWasmLoadingTypes =
+			/** @type {NonNullable<WebpackOptions["output"]["enabledWasmLoadingTypes"]>} */
+			(options.output.enabledWasmLoadingTypes);
+
+		if (enabledWasmLoadingTypes.length > 0) {
+			for (const type of enabledWasmLoadingTypes) {
 				const EnableWasmLoadingPlugin = require("./wasm/EnableWasmLoadingPlugin");
 				new EnableWasmLoadingPlugin(type).apply(compiler);
 			}
 		}
 
-		if (options.output.enabledLibraryTypes.length > 0) {
-			for (const type of options.output.enabledLibraryTypes) {
+		const enabledLibraryTypes =
+			/** @type {NonNullable<WebpackOptions["output"]["enabledLibraryTypes"]>} */
+			(options.output.enabledLibraryTypes);
+
+		if (enabledLibraryTypes.length > 0) {
+			for (const type of enabledLibraryTypes) {
 				const EnableLibraryPlugin = require("./library/EnableLibraryPlugin");
 				new EnableLibraryPlugin(type).apply(compiler);
 			}
@@ -203,9 +264,9 @@ class WebpackOptionsApply extends OptionsApply {
 					fallbackModuleFilenameTemplate:
 						options.output.devtoolFallbackModuleFilenameTemplate,
 					append: hidden ? false : undefined,
-					module: moduleMaps ? true : cheap ? false : true,
-					columns: cheap ? false : true,
-					noSources: noSources,
+					module: moduleMaps ? true : !cheap,
+					columns: !cheap,
+					noSources,
 					namespace: options.output.devtoolNamespace
 				}).apply(compiler);
 			} else if (options.devtool.includes("eval")) {
@@ -232,7 +293,15 @@ class WebpackOptionsApply extends OptionsApply {
 					"library type \"module\" is only allowed when 'experiments.outputModule' is enabled"
 				);
 			}
-			if (options.externalsType === "module") {
+			if (options.output.enabledLibraryTypes.includes("modern-module")) {
+				throw new Error(
+					"library type \"modern-module\" is only allowed when 'experiments.outputModule' is enabled"
+				);
+			}
+			if (
+				options.externalsType === "module" ||
+				options.externalsType === "module-import"
+			) {
 				throw new Error(
 					"'externalsType: \"module\"' is only allowed when 'experiments.outputModule' is enabled"
 				);
@@ -253,23 +322,31 @@ class WebpackOptionsApply extends OptionsApply {
 			}).apply(compiler);
 		}
 
+		if (options.experiments.css) {
+			const CssModulesPlugin = require("./css/CssModulesPlugin");
+			new CssModulesPlugin().apply(compiler);
+		}
+
 		if (options.experiments.lazyCompilation) {
 			const LazyCompilationPlugin = require("./hmr/LazyCompilationPlugin");
 			const lazyOptions =
 				typeof options.experiments.lazyCompilation === "object"
 					? options.experiments.lazyCompilation
-					: null;
+					: {};
 			new LazyCompilationPlugin({
 				backend:
-					(lazyOptions && lazyOptions.backend) ||
-					require("./hmr/lazyCompilationBackend"),
-				client:
-					(lazyOptions && lazyOptions.client) ||
-					require.resolve(
-						`../hot/lazy-compilation-${
-							options.externalsPresets.node ? "node" : "web"
-						}.js`
-					),
+					typeof lazyOptions.backend === "function"
+						? lazyOptions.backend
+						: require("./hmr/lazyCompilationBackend")({
+								...lazyOptions.backend,
+								client:
+									(lazyOptions.backend && lazyOptions.backend.client) ||
+									require.resolve(
+										`../hot/lazy-compilation-${
+											options.externalsPresets.node ? "node" : "web"
+										}.js`
+									)
+							}),
 				entries: !lazyOptions || lazyOptions.entries !== false,
 				imports: !lazyOptions || lazyOptions.imports !== false,
 				test: (lazyOptions && lazyOptions.test) || undefined
@@ -283,7 +360,11 @@ class WebpackOptionsApply extends OptionsApply {
 		}
 
 		new EntryOptionPlugin().apply(compiler);
-		compiler.hooks.entryOption.call(options.context, options.entry);
+		compiler.hooks.entryOption.call(
+			/** @type {string} */
+			(options.context),
+			options.entry
+		);
 
 		new RuntimePlugin().apply(compiler);
 
@@ -308,7 +389,9 @@ class WebpackOptionsApply extends OptionsApply {
 			const NodeStuffPlugin = require("./NodeStuffPlugin");
 			new NodeStuffPlugin(options.node).apply(compiler);
 		}
-		new APIPlugin().apply(compiler);
+		new APIPlugin({
+			module: options.output.module
+		}).apply(compiler);
 		new ExportsInfoApiPlugin().apply(compiler);
 		new WebpackIsIncludedPlugin().apply(compiler);
 		new ConstPlugin().apply(compiler);
@@ -317,13 +400,15 @@ class WebpackOptionsApply extends OptionsApply {
 		new RequireEnsurePlugin().apply(compiler);
 		new RequireContextPlugin().apply(compiler);
 		new ImportPlugin().apply(compiler);
+		new ImportMetaContextPlugin().apply(compiler);
 		new SystemPlugin().apply(compiler);
 		new ImportMetaPlugin().apply(compiler);
 		new URLPlugin().apply(compiler);
 		new WorkerPlugin(
 			options.output.workerChunkLoading,
 			options.output.workerWasmLoading,
-			options.output.module
+			options.output.module,
+			options.output.workerPublicPath
 		).apply(compiler);
 
 		new DefaultStatsFactoryPlugin().apply(compiler);
@@ -391,7 +476,10 @@ class WebpackOptionsApply extends OptionsApply {
 		}
 		if (options.optimization.runtimeChunk) {
 			const RuntimeChunkPlugin = require("./optimize/RuntimeChunkPlugin");
-			new RuntimeChunkPlugin(options.optimization.runtimeChunk).apply(compiler);
+			new RuntimeChunkPlugin(
+				/** @type {{ name?: (entrypoint: { name: string }) => string }} */
+				(options.optimization.runtimeChunk)
+			).apply(compiler);
 		}
 		if (!options.optimization.emitOnErrors) {
 			const NoEmitOnErrorsPlugin = require("./NoEmitOnErrorsPlugin");
@@ -471,7 +559,7 @@ class WebpackOptionsApply extends OptionsApply {
 					break;
 				}
 				case "size": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 					const OccurrenceChunkIdsPlugin = require("./ids/OccurrenceChunkIdsPlugin");
 					new OccurrenceChunkIdsPlugin({
 						prioritiseInitial: true
@@ -479,7 +567,7 @@ class WebpackOptionsApply extends OptionsApply {
 					break;
 				}
 				case "total-size": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 					const OccurrenceChunkIdsPlugin = require("./ids/OccurrenceChunkIdsPlugin");
 					new OccurrenceChunkIdsPlugin({
 						prioritiseInitial: false
@@ -502,7 +590,7 @@ class WebpackOptionsApply extends OptionsApply {
 			for (const minimizer of options.optimization.minimizer) {
 				if (typeof minimizer === "function") {
 					minimizer.call(compiler, compiler);
-				} else if (minimizer !== "...") {
+				} else if (minimizer !== "..." && minimizer) {
 					minimizer.apply(compiler);
 				}
 			}
@@ -523,22 +611,28 @@ class WebpackOptionsApply extends OptionsApply {
 
 		const AddManagedPathsPlugin = require("./cache/AddManagedPathsPlugin");
 		new AddManagedPathsPlugin(
-			options.snapshot.managedPaths,
-			options.snapshot.immutablePaths
+			/** @type {NonNullable<WebpackOptions["snapshot"]["managedPaths"]>} */
+			(options.snapshot.managedPaths),
+			/** @type {NonNullable<WebpackOptions["snapshot"]["managedPaths"]>} */
+			(options.snapshot.immutablePaths),
+			/** @type {NonNullable<WebpackOptions["snapshot"]["managedPaths"]>} */
+			(options.snapshot.unmanagedPaths)
 		).apply(compiler);
 
 		if (options.cache && typeof options.cache === "object") {
 			const cacheOptions = options.cache;
 			switch (cacheOptions.type) {
 				case "memory": {
-					if (isFinite(cacheOptions.maxGenerations)) {
-						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					if (Number.isFinite(cacheOptions.maxGenerations)) {
+						// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 						const MemoryWithGcCachePlugin = require("./cache/MemoryWithGcCachePlugin");
 						new MemoryWithGcCachePlugin({
-							maxGenerations: cacheOptions.maxGenerations
+							maxGenerations:
+								/** @type {number} */
+								(cacheOptions.maxGenerations)
 						}).apply(compiler);
 					} else {
-						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+						// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 						const MemoryCachePlugin = require("./cache/MemoryCachePlugin");
 						new MemoryCachePlugin().apply(compiler);
 					}
@@ -554,16 +648,17 @@ class WebpackOptionsApply extends OptionsApply {
 				}
 				case "filesystem": {
 					const AddBuildDependenciesPlugin = require("./cache/AddBuildDependenciesPlugin");
+					// eslint-disable-next-line guard-for-in
 					for (const key in cacheOptions.buildDependencies) {
 						const list = cacheOptions.buildDependencies[key];
 						new AddBuildDependenciesPlugin(list).apply(compiler);
 					}
-					if (!isFinite(cacheOptions.maxMemoryGenerations)) {
-						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					if (!Number.isFinite(cacheOptions.maxMemoryGenerations)) {
+						// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 						const MemoryCachePlugin = require("./cache/MemoryCachePlugin");
 						new MemoryCachePlugin().apply(compiler);
 					} else if (cacheOptions.maxMemoryGenerations !== 0) {
-						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+						// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 						const MemoryWithGcCachePlugin = require("./cache/MemoryWithGcCachePlugin");
 						new MemoryWithGcCachePlugin({
 							maxGenerations: cacheOptions.maxMemoryGenerations
@@ -584,18 +679,23 @@ class WebpackOptionsApply extends OptionsApply {
 							new IdleFileCachePlugin(
 								new PackFileCacheStrategy({
 									compiler,
-									fs: compiler.intermediateFileSystem,
-									context: options.context,
-									cacheLocation: cacheOptions.cacheLocation,
+									fs:
+										/** @type {IntermediateFileSystem} */
+										(compiler.intermediateFileSystem),
+									context: /** @type {string} */ (options.context),
+									cacheLocation:
+										/** @type {string} */
+										(cacheOptions.cacheLocation),
 									version: cacheOptions.version,
 									logger: compiler.getInfrastructureLogger(
 										"webpack.cache.PackFileCacheStrategy"
 									),
 									snapshot: options.snapshot,
-									maxAge: cacheOptions.maxAge,
+									maxAge: /** @type {number} */ (cacheOptions.maxAge),
 									profile: cacheOptions.profile,
 									allowCollectingMemory: cacheOptions.allowCollectingMemory,
-									compression: cacheOptions.compression
+									compression: cacheOptions.compression,
+									readonly: cacheOptions.readonly
 								}),
 								cacheOptions.idleTimeout,
 								cacheOptions.idleTimeoutForInitialStore,
@@ -628,14 +728,18 @@ class WebpackOptionsApply extends OptionsApply {
 			.for("normal")
 			.tap("WebpackOptionsApply", resolveOptions => {
 				resolveOptions = cleverMerge(options.resolve, resolveOptions);
-				resolveOptions.fileSystem = compiler.inputFileSystem;
+				resolveOptions.fileSystem =
+					/** @type {InputFileSystem} */
+					(compiler.inputFileSystem);
 				return resolveOptions;
 			});
 		compiler.resolverFactory.hooks.resolveOptions
 			.for("context")
 			.tap("WebpackOptionsApply", resolveOptions => {
 				resolveOptions = cleverMerge(options.resolve, resolveOptions);
-				resolveOptions.fileSystem = compiler.inputFileSystem;
+				resolveOptions.fileSystem =
+					/** @type {InputFileSystem} */
+					(compiler.inputFileSystem);
 				resolveOptions.resolveToContext = true;
 				return resolveOptions;
 			});
@@ -643,7 +747,9 @@ class WebpackOptionsApply extends OptionsApply {
 			.for("loader")
 			.tap("WebpackOptionsApply", resolveOptions => {
 				resolveOptions = cleverMerge(options.resolveLoader, resolveOptions);
-				resolveOptions.fileSystem = compiler.inputFileSystem;
+				resolveOptions.fileSystem =
+					/** @type {InputFileSystem} */
+					(compiler.inputFileSystem);
 				return resolveOptions;
 			});
 		compiler.hooks.afterResolvers.call(compiler);

package/lib/WebpackOptionsDefaulter.js

@@ -8,11 +8,18 @@
 const { applyWebpackOptionsDefaults } = require("./config/defaults");
 const { getNormalizedWebpackOptions } = require("./config/normalization");
 
+/** @typedef {import("./config/normalization").WebpackOptions} WebpackOptions */
+/** @typedef {import("./config/normalization").WebpackOptionsNormalized} WebpackOptionsNormalized */
+
 class WebpackOptionsDefaulter {
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @returns {WebpackOptionsNormalized} normalized webpack options
+	 */
 	process(options) {
-		options = getNormalizedWebpackOptions(options);
-		applyWebpackOptionsDefaults(options);
-		return options;
+		const normalizedOptions = getNormalizedWebpackOptions(options);
+		applyWebpackOptionsDefaults(normalizedOptions);
+		return normalizedOptions;
 	}
 }