webpack 5.95.0 → 5.96.1

package/lib/ExternalModuleFactoryPlugin.js

@@ -9,10 +9,12 @@ const util = require("util");
 const ExternalModule = require("./ExternalModule");
 const ContextElementDependency = require("./dependencies/ContextElementDependency");
 const CssImportDependency = require("./dependencies/CssImportDependency");
+const CssUrlDependency = require("./dependencies/CssUrlDependency");
 const HarmonyImportDependency = require("./dependencies/HarmonyImportDependency");
 const ImportDependency = require("./dependencies/ImportDependency");
 const { resolveByProperty, cachedSetProperty } = require("./util/cleverMerge");
 
+/** @typedef {import("../declarations/WebpackOptions").ExternalItemFunctionData} ExternalItemFunctionData */
 /** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
 /** @typedef {import("./Compilation").DepConstructor} DepConstructor */
 /** @typedef {import("./ExternalModule").DependencyMeta} DependencyMeta */
@@ -24,6 +26,12 @@ const EMPTY_RESOLVE_OPTIONS = {};
 
 // TODO webpack 6 remove this
 const callDeprecatedExternals = util.deprecate(
+	/**
+	 * @param {TODO} externalsFunction externals function
+	 * @param {string} context context
+	 * @param {string} request request
+	 * @param {(err: Error | null | undefined, value: ExternalValue | undefined, ty: ExternalType | undefined) => void} cb cb
+	 */
 	(externalsFunction, context, request, cb) => {
 		// eslint-disable-next-line no-useless-call
 		externalsFunction.call(null, context, request, cb);
@@ -35,15 +43,16 @@ const callDeprecatedExternals = util.deprecate(
 const cache = new WeakMap();
 
 /**
- * @param {object} obj obj
+ * @template {object} T
+ * @param {T} obj obj
  * @param {TODO} layer layer
- * @returns {object} result
+ * @returns {Omit<T, "byLayer">} result
  */
 const resolveLayer = (obj, layer) => {
-	let map = cache.get(obj);
+	let map = cache.get(/** @type {object} */ (obj));
 	if (map === undefined) {
 		map = new Map();
-		cache.set(obj, map);
+		cache.set(/** @type {object} */ (obj), map);
 	} else {
 		const cacheEntry = map.get(layer);
 		if (cacheEntry !== undefined) return cacheEntry;
@@ -53,8 +62,8 @@ const resolveLayer = (obj, layer) => {
 	return result;
 };
 
-/** @typedef {string|string[]|boolean|Record<string, string|string[]>} ExternalValue */
-/** @typedef {string|undefined} ExternalType */
+/** @typedef {string | string[] | boolean | Record<string, string | string[]>} ExternalValue */
+/** @typedef {string | undefined} ExternalType */
 
 class ExternalModuleFactoryPlugin {
 	/**
@@ -117,6 +126,8 @@ class ExternalModuleFactoryPlugin {
 						}
 					}
 
+					const resolvedType = /** @type {string} */ (type || globalType);
+
 					// TODO make it pluggable/add hooks to `ExternalModule` to allow output modules own externals?
 					/** @type {DependencyMeta | undefined} */
 					let dependencyMeta;
@@ -145,12 +156,18 @@ class ExternalModuleFactoryPlugin {
 						};
 					}
 
+					if (
+						resolvedType === "asset" &&
+						dependency instanceof CssUrlDependency
+					) {
+						dependencyMeta = { sourceType: "css-url" };
+					}
+
 					callback(
 						null,
 						new ExternalModule(
 							externalConfig,
-							/** @type {string} */
-							(type || globalType),
+							resolvedType,
 							dependency.request,
 							dependencyMeta
 						)
@@ -204,6 +221,12 @@ class ExternalModuleFactoryPlugin {
 							return handleExternal(dependency.request, undefined, callback);
 						}
 					} else if (typeof externals === "function") {
+						/**
+						 * @param {Error | null | undefined} err err
+						 * @param {ExternalValue=} value value
+						 * @param {ExternalType=} type type
+						 * @returns {void}
+						 */
 						const cb = (err, value, type) => {
 							if (err) return callback(err);
 							if (value !== undefined) {
@@ -250,7 +273,8 @@ class ExternalModuleFactoryPlugin {
 												context,
 												request,
 												resolveContext,
-												callback
+												/** @type {TODO} */
+												(callback)
 											);
 										} else {
 											return new Promise((resolve, reject) => {

package/lib/FileSystemInfo.js

@@ -3631,8 +3631,7 @@ class FileSystemInfo {
 		this._readContext(
 			{
 				path,
-				fromImmutablePath: () =>
-					/** @type {ContextHash} */ (/** @type {unknown} */ ("")),
+				fromImmutablePath: () => /** @type {ContextHash | ""} */ (""),
 				fromManagedItem: info => info || "",
 				fromSymlink: (file, target, callback) => {
 					callback(
@@ -3773,18 +3772,23 @@ class FileSystemInfo {
 			this._readContext(
 				{
 					path,
-					fromImmutablePath: () => null,
+					fromImmutablePath: () =>
+						/** @type {ContextTimestampAndHash | null} */ (null),
 					fromManagedItem: info => ({
 						safeTime: 0,
 						timestampHash: info,
 						hash: info || ""
 					}),
 					fromSymlink: (file, target, callback) => {
-						callback(null, {
-							timestampHash: target,
-							hash: target,
-							symlinks: new Set([target])
-						});
+						callback(
+							null,
+							/** @type {TODO} */
+							({
+								timestampHash: target,
+								hash: target,
+								symlinks: new Set([target])
+							})
+						);
 					},
 					fromFile: (file, stat, callback) => {
 						this._getFileTimestampAndHash(file, callback);

package/lib/Generator.js

@@ -14,6 +14,7 @@
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
 /** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
+/** @typedef {import("./Module").SourceTypes} SourceTypes */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./NormalModule")} NormalModule */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
@@ -55,7 +56,7 @@ class Generator {
 	/**
 	 * @abstract
 	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
+	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
 		const AbstractMethodError = require("./AbstractMethodError");
@@ -79,7 +80,7 @@ class Generator {
 	 * @abstract
 	 * @param {NormalModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * @returns {Source | null} generated code
 	 */
 	generate(
 		module,
@@ -119,7 +120,7 @@ class ByTypeGenerator extends Generator {
 
 	/**
 	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
+	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
 		return this._types;
@@ -139,7 +140,7 @@ class ByTypeGenerator extends Generator {
 	/**
 	 * @param {NormalModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * @returns {Source | null} generated code
 	 */
 	generate(module, generateContext) {
 		const type = generateContext.type;

package/lib/HotModuleReplacementPlugin.js

@@ -44,6 +44,7 @@ const {
 
 /** @typedef {import("estree").CallExpression} CallExpression */
 /** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").SpreadElement} SpreadElement */
 /** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputNormalized */
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./Chunk").ChunkId} ChunkId */
@@ -60,8 +61,8 @@ const {
 
 /**
  * @typedef {object} HMRJavascriptParserHooks
- * @property {SyncBailHook<[TODO, string[]], void>} hotAcceptCallback
- * @property {SyncBailHook<[TODO, string[]], void>} hotAcceptWithoutCallback
+ * @property {SyncBailHook<[Expression | SpreadElement, string[]], void>} hotAcceptCallback
+ * @property {SyncBailHook<[CallExpression, string[]], void>} hotAcceptWithoutCallback
  */
 
 /** @typedef {{ updatedChunkIds: Set<ChunkId>, removedChunkIds: Set<ChunkId>, removedModules: Set<Module>, filename: string, assetInfo: AssetInfo }} HotUpdateMainContentByRuntimeItem */
@@ -133,10 +134,9 @@ class HotModuleReplacementPlugin {
 				/** @type {BuildInfo} */
 				(module.buildInfo).moduleConcatenationBailout =
 					"Hot Module Replacement";
+
 				if (expr.arguments.length >= 1) {
-					const arg = parser.evaluateExpression(
-						/** @type {Expression} */ (expr.arguments[0])
-					);
+					const arg = parser.evaluateExpression(expr.arguments[0]);
 					/** @type {BasicEvaluatedExpression[]} */
 					let params = [];
 					if (arg.isString()) {
@@ -686,7 +686,9 @@ class HotModuleReplacementPlugin {
 								if (backCompat)
 									ChunkGraph.setChunkGraphForChunk(hotUpdateChunk, chunkGraph);
 								hotUpdateChunk.id = chunkId;
-								hotUpdateChunk.runtime = newRuntime;
+								hotUpdateChunk.runtime = currentChunk
+									? currentChunk.runtime
+									: newRuntime;
 								if (currentChunk) {
 									for (const group of currentChunk.groupsIterable)
 										hotUpdateChunk.addGroup(group);

package/lib/IgnorePlugin.js

@@ -5,6 +5,8 @@
 
 "use strict";
 
+const RawModule = require("./RawModule");
+const EntryDependency = require("./dependencies/EntryDependency");
 const createSchemaValidation = require("./util/create-schema-validation");
 
 /** @typedef {import("../declarations/plugins/IgnorePlugin").IgnorePluginOptions} IgnorePluginOptions */
@@ -73,7 +75,23 @@ class IgnorePlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.normalModuleFactory.tap("IgnorePlugin", nmf => {
-			nmf.hooks.beforeResolve.tap("IgnorePlugin", this.checkIgnore);
+			nmf.hooks.beforeResolve.tap("IgnorePlugin", resolveData => {
+				const result = this.checkIgnore(resolveData);
+
+				if (
+					result === false &&
+					resolveData.dependencies.length > 0 &&
+					resolveData.dependencies[0] instanceof EntryDependency
+				) {
+					resolveData.ignoredModule = new RawModule(
+						"",
+						"ignored-entry-module",
+						"(ignored-entry-module)"
+					);
+				}
+
+				return result;
+			});
 		});
 		compiler.hooks.contextModuleFactory.tap("IgnorePlugin", cmf => {
 			cmf.hooks.beforeResolve.tap("IgnorePlugin", this.checkIgnore);

package/lib/LoaderOptionsPlugin.js

@@ -69,7 +69,9 @@ class LoaderOptionsPlugin {
 							if (key === "include" || key === "exclude" || key === "test") {
 								continue;
 							}
-							context[key] = options[key];
+
+							/** @type {any} */
+							(context)[key] = options[key];
 						}
 					}
 				}

package/lib/Module.js

@@ -9,6 +9,7 @@ const util = require("util");
 const ChunkGraph = require("./ChunkGraph");
 const DependenciesBlock = require("./DependenciesBlock");
 const ModuleGraph = require("./ModuleGraph");
+const { JS_TYPES } = require("./ModuleSourceTypesConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const { first } = require("./util/SetHelpers");
 const { compareChunksById } = require("./util/comparators");
@@ -23,7 +24,6 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("./Compilation").ValueCacheVersion} ValueCacheVersion */
 /** @typedef {import("./ConcatenationScope")} ConcatenationScope */
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
@@ -56,6 +56,8 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {string=} type the type of source that should be generated
  */
 
+/** @typedef {ReadonlySet<string>} SourceTypes */
+
 // TODO webpack 6: compilation will be required in CodeGenerationContext
 /**
  * @typedef {object} CodeGenerationContext
@@ -67,7 +69,7 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {ConcatenationScope=} concatenationScope when in concatenated module, information about other concatenated modules
  * @property {CodeGenerationResults | undefined} codeGenerationResults code generation results of other modules (need to have a codeGenerationDependency to use that)
  * @property {Compilation=} compilation the compilation
- * @property {ReadonlySet<string>=} sourceTypes source types
+ * @property {SourceTypes=} sourceTypes source types
  */
 
 /**
@@ -114,18 +116,20 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {LazySet<string>=} contextDependencies
  * @property {LazySet<string>=} missingDependencies
  * @property {LazySet<string>=} buildDependencies
- * @property {(Map<string, ValueCacheVersion>)=} valueDependencies
+ * @property {ValueCacheVersions=} valueDependencies
  * @property {TODO=} hash
  * @property {Record<string, Source>=} assets
  * @property {Map<string, AssetInfo | undefined>=} assetsInfo
  * @property {(Snapshot | null)=} snapshot
  */
 
+/** @typedef {Map<string, string | Set<string>>} ValueCacheVersions */
+
 /**
  * @typedef {object} NeedBuildContext
  * @property {Compilation} compilation
  * @property {FileSystemInfo} fileSystemInfo
- * @property {Map<string, string | Set<string>>} valueCacheVersions
+ * @property {ValueCacheVersions} valueCacheVersions
  */
 
 /** @typedef {KnownBuildMeta & Record<string, any>} BuildMeta */
@@ -136,8 +140,6 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {boolean=} sideEffectFree
  */
 
-/** @typedef {Set<string>} SourceTypes */
-
 /** @typedef {{ factoryMeta: FactoryMeta | undefined, resolveOptions: ResolveOptions | undefined }} UnsafeCacheData */
 
 const EMPTY_RESOLVE_OPTIONS = {};
@@ -145,7 +147,6 @@ const EMPTY_RESOLVE_OPTIONS = {};
 let debugId = 1000;
 
 const DEFAULT_TYPES_UNKNOWN = new Set(["unknown"]);
-const DEFAULT_TYPES_JS = new Set(["javascript"]);
 
 const deprecatedNeedRebuild = util.deprecate(
 	/**
@@ -873,7 +874,7 @@ class Module extends DependenciesBlock {
 		if (this.source === Module.prototype.source) {
 			return DEFAULT_TYPES_UNKNOWN;
 		}
-		return DEFAULT_TYPES_JS;
+		return JS_TYPES;
 	}
 
 	/**

package/lib/ModuleSourceTypesConstants.js

@@ -0,0 +1,100 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/**
+ * @type {ReadonlySet<never>}
+ */
+const NO_TYPES = new Set();
+
+/**
+ * @type {ReadonlySet<"asset">}
+ */
+const ASSET_TYPES = new Set(["asset"]);
+
+/**
+ * @type {ReadonlySet<"asset" | "javascript" | "asset">}
+ */
+const ASSET_AND_JS_TYPES = new Set(["asset", "javascript"]);
+
+/**
+ * @type {ReadonlySet<"css-url" | "asset">}
+ */
+const ASSET_AND_CSS_URL_TYPES = new Set(["asset", "css-url"]);
+
+/**
+ * @type {ReadonlySet<"javascript" | "css-url" | "asset">}
+ */
+const ASSET_AND_JS_AND_CSS_URL_TYPES = new Set([
+	"asset",
+	"javascript",
+	"css-url"
+]);
+
+/**
+ * @type {ReadonlySet<"javascript">}
+ */
+const JS_TYPES = new Set(["javascript"]);
+
+/**
+ * @type {ReadonlySet<"javascript" | "css-url">}
+ */
+const JS_AND_CSS_URL_TYPES = new Set(["javascript", "css-url"]);
+
+/**
+ * @type {ReadonlySet<"css">}
+ */
+const CSS_TYPES = new Set(["css"]);
+
+/**
+ * @type {ReadonlySet<"css-url">}
+ */
+const CSS_URL_TYPES = new Set(["css-url"]);
+/**
+ * @type {ReadonlySet<"css-import">}
+ */
+const CSS_IMPORT_TYPES = new Set(["css-import"]);
+
+/**
+ * @type {ReadonlySet<"webassembly">}
+ */
+const WEBASSEMBLY_TYPES = new Set(["webassembly"]);
+
+/**
+ * @type {ReadonlySet<"runtime">}
+ */
+const RUNTIME_TYPES = new Set(["runtime"]);
+
+/**
+ * @type {ReadonlySet<"remote" | "share-init">}
+ */
+const REMOTE_AND_SHARE_INIT_TYPES = new Set(["remote", "share-init"]);
+
+/**
+ * @type {ReadonlySet<"consume-shared">}
+ */
+const CONSUME_SHARED_TYPES = new Set(["consume-shared"]);
+
+/**
+ * @type {ReadonlySet<"share-init">}
+ */
+const SHARED_INIT_TYPES = new Set(["share-init"]);
+
+module.exports.NO_TYPES = NO_TYPES;
+module.exports.JS_TYPES = JS_TYPES;
+module.exports.JS_AND_CSS_URL_TYPES = JS_AND_CSS_URL_TYPES;
+module.exports.ASSET_TYPES = ASSET_TYPES;
+module.exports.ASSET_AND_JS_TYPES = ASSET_AND_JS_TYPES;
+module.exports.ASSET_AND_CSS_URL_TYPES = ASSET_AND_CSS_URL_TYPES;
+module.exports.ASSET_AND_JS_AND_CSS_URL_TYPES = ASSET_AND_JS_AND_CSS_URL_TYPES;
+module.exports.CSS_TYPES = CSS_TYPES;
+module.exports.CSS_URL_TYPES = CSS_URL_TYPES;
+module.exports.CSS_IMPORT_TYPES = CSS_IMPORT_TYPES;
+module.exports.WEBASSEMBLY_TYPES = WEBASSEMBLY_TYPES;
+module.exports.RUNTIME_TYPES = RUNTIME_TYPES;
+module.exports.REMOTE_AND_SHARE_INIT_TYPES = REMOTE_AND_SHARE_INIT_TYPES;
+module.exports.CONSUME_SHARED_TYPES = CONSUME_SHARED_TYPES;
+module.exports.SHARED_INIT_TYPES = SHARED_INIT_TYPES;

package/lib/NormalModule.js

@@ -65,12 +65,13 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./Module").KnownBuildInfo} KnownBuildInfo */
 /** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
 /** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./Module").SourceTypes} SourceTypes */
+/** @typedef {import("./Generator").SourceTypes} SourceTypes */
 /** @typedef {import("./Module").UnsafeCacheData} UnsafeCacheData */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("./ModuleTypeConstants").JavaScriptModuleTypes} JavaScriptModuleTypes */
 /** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
+/** @typedef {import("./NormalModuleFactory").ResourceDataWithData} ResourceDataWithData */
 /** @typedef {import("./Parser")} Parser */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./ResolverFactory").ResolveContext} ResolveContext */
@@ -777,10 +778,10 @@ class NormalModule extends Module {
 			webpack: true,
 			sourceMap: Boolean(this.useSourceMap),
 			mode: options.mode || "production",
-			hashFunction: options.output.hashFunction,
-			hashDigest: options.output.hashDigest,
-			hashDigestLength: options.output.hashDigestLength,
-			hashSalt: options.output.hashSalt,
+			hashFunction: /** @type {TODO} */ (options.output.hashFunction),
+			hashDigest: /** @type {string} */ (options.output.hashDigest),
+			hashDigestLength: /** @type {number} */ (options.output.hashDigestLength),
+			hashSalt: /** @type {string} */ (options.output.hashSalt),
 			_module: this,
 			_compilation: compilation,
 			_compiler: compilation.compiler,
@@ -951,7 +952,7 @@ class NormalModule extends Module {
 				/** @type {LoaderContext<any>} */ (loaderContext)
 			);
 		} catch (err) {
-			processResult(err);
+			processResult(/** @type {Error} */ (err));
 			return;
 		}
 
@@ -965,6 +966,11 @@ class NormalModule extends Module {
 				resource: this.resource,
 				loaders: this.loaders,
 				context: loaderContext,
+				/**
+				 * @param {LoaderContext<TODO>} loaderContext the loader context
+				 * @param {string} resourcePath the resource Path
+				 * @param {(err: Error | null, result?: string | Buffer) => void} callback callback
+				 */
 				processResource: (loaderContext, resourcePath, callback) => {
 					const resource = loaderContext.resource;
 					const scheme = getScheme(resource);
@@ -1601,24 +1607,28 @@ class NormalModule extends Module {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {TODO} Module
+	 */
 	static deserialize(context) {
 		const obj = new NormalModule({
 			// will be deserialized by Module
-			layer: null,
+			layer: /** @type {EXPECTED_ANY} */ (null),
 			type: "",
 			// will be filled by updateCacheModule
 			resource: "",
 			context: "",
-			request: null,
-			userRequest: null,
-			rawRequest: null,
-			loaders: null,
-			matchResource: null,
-			parser: null,
-			parserOptions: null,
-			generator: null,
-			generatorOptions: null,
-			resolveOptions: null
+			request: /** @type {EXPECTED_ANY} */ (null),
+			userRequest: /** @type {EXPECTED_ANY} */ (null),
+			rawRequest: /** @type {EXPECTED_ANY} */ (null),
+			loaders: /** @type {EXPECTED_ANY} */ (null),
+			matchResource: /** @type {EXPECTED_ANY} */ (null),
+			parser: /** @type {EXPECTED_ANY} */ (null),
+			parserOptions: /** @type {EXPECTED_ANY} */ (null),
+			generator: /** @type {EXPECTED_ANY} */ (null),
+			generatorOptions: /** @type {EXPECTED_ANY} */ (null),
+			resolveOptions: /** @type {EXPECTED_ANY} */ (null)
 		});
 		obj.deserialize(context);
 		return obj;