webpack 5.102.1 → 5.104.0

package/lib/ManifestPlugin.js

@@ -0,0 +1,235 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Haijie Xie @hai-x
+*/
+
+"use strict";
+
+const { RawSource } = require("webpack-sources");
+const Compilation = require("./Compilation");
+const HotUpdateChunk = require("./HotUpdateChunk");
+const createSchemaValidation = require("./util/create-schema-validation");
+
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Chunk").ChunkName} ChunkName */
+/** @typedef {import("./Chunk").ChunkId} ChunkId */
+/** @typedef {import("./Compilation").Asset} Asset */
+/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
+
+/** @typedef {import("../declarations/plugins/ManifestPlugin").ManifestPluginOptions} ManifestPluginOptions */
+/** @typedef {import("../declarations/plugins/ManifestPlugin").ManifestObject} ManifestObject */
+/** @typedef {import("../declarations/plugins/ManifestPlugin").ManifestEntrypoint} ManifestEntrypoint */
+/** @typedef {import("../declarations/plugins/ManifestPlugin").ManifestItem} ManifestItem */
+
+const PLUGIN_NAME = "ManifestPlugin";
+
+const validate = createSchemaValidation(
+	require("../schemas/plugins/ManifestPlugin.check"),
+	() => require("../schemas/plugins/ManifestPlugin.json"),
+	{
+		name: "ManifestPlugin",
+		baseDataPath: "options"
+	}
+);
+
+/**
+ * @param {string} filename filename
+ * @returns {string} extname
+ */
+const extname = (filename) => {
+	const replaced = filename.replace(/\?.*/, "");
+	const split = replaced.split(".");
+	const last = split.pop();
+	if (!last) return "";
+	return last && /^(gz|br|map)$/i.test(last) ? `${split.pop()}.${last}` : last;
+};
+
+class ManifestPlugin {
+	/**
+	 * @param {ManifestPluginOptions} options options
+	 */
+	constructor(options) {
+		validate(options);
+
+		/** @type {ManifestPluginOptions & Required<Omit<ManifestPluginOptions, "filter" | "generate">>} */
+		this.options = {
+			filename: "manifest.json",
+			prefix: "[publicpath]",
+			entrypoints: true,
+			serialize: (manifest) => JSON.stringify(manifest, null, 2),
+			...options
+		};
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+			compilation.hooks.processAssets.tap(
+				{
+					name: PLUGIN_NAME,
+					stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
+				},
+				() => {
+					const hashDigestLength = compilation.outputOptions.hashDigestLength;
+					const publicPath = compilation.getPath(
+						compilation.outputOptions.publicPath
+					);
+
+					/**
+					 * @param {string | string[]} value value
+					 * @returns {RegExp} regexp to remove hash
+					 */
+					const createHashRegExp = (value) =>
+						new RegExp(
+							`(?:\\.${Array.isArray(value) ? `(${value.join("|")})` : value})(?=\\.)`,
+							"gi"
+						);
+
+					/**
+					 * @param {string} name name
+					 * @param {AssetInfo | null} info asset info
+					 * @returns {string} hash removed name
+					 */
+					const removeHash = (name, info) => {
+						// Handles hashes that match configured `hashDigestLength`
+						// i.e. index.XXXX.html -> index.html (html-webpack-plugin)
+						if (hashDigestLength <= 0) return name;
+						const reg = createHashRegExp(`[a-f0-9]{${hashDigestLength},32}`);
+						return name.replace(reg, "");
+					};
+
+					/**
+					 * @param {Chunk} chunk chunk
+					 * @returns {ChunkName | ChunkId} chunk name or chunk id
+					 */
+					const getName = (chunk) => {
+						if (chunk.name) return chunk.name;
+
+						return chunk.id;
+					};
+
+					/** @type {ManifestObject} */
+					let manifest = {};
+
+					if (this.options.entrypoints) {
+						/** @type {ManifestObject["entrypoints"]} */
+						const entrypoints = {};
+
+						for (const [name, entrypoint] of compilation.entrypoints) {
+							const imports = [];
+
+							for (const chunk of entrypoint.chunks) {
+								for (const file of chunk.files) {
+									const name = getName(chunk);
+
+									imports.push(name ? `${name}.${extname(file)}` : file);
+								}
+							}
+
+							/** @type {ManifestEntrypoint} */
+							const item = { imports };
+							const parents = entrypoint
+								.getParents()
+								.map((item) => /** @type {string} */ (item.name));
+
+							if (parents.length > 0) {
+								item.parents = parents;
+							}
+
+							entrypoints[name] = item;
+						}
+
+						manifest.entrypoints = entrypoints;
+					}
+
+					/** @type {ManifestObject["assets"]} */
+					const assets = {};
+
+					/** @type {Set<string>} */
+					const added = new Set();
+
+					/**
+					 * @param {string} file file
+					 * @param {string=} usedName usedName
+					 * @returns {void}
+					 */
+					const handleFile = (file, usedName) => {
+						if (added.has(file)) return;
+						added.add(file);
+
+						const asset = compilation.getAsset(file);
+						if (!asset) return;
+						const sourceFilename = asset.info.sourceFilename;
+						const name =
+							usedName ||
+							sourceFilename ||
+							// Fallback for unofficial plugins, just remove hash from filename
+							removeHash(file, asset.info);
+
+						const prefix = this.options.prefix.replace(
+							/\[publicpath\]/gi,
+							() => (publicPath === "auto" ? "/" : publicPath)
+						);
+						/** @type {ManifestItem} */
+						const item = { file: prefix + file };
+
+						if (sourceFilename) {
+							item.src = sourceFilename;
+						}
+
+						if (this.options.filter) {
+							const needKeep = this.options.filter(item);
+
+							if (!needKeep) {
+								return;
+							}
+						}
+
+						assets[name] = item;
+					};
+
+					for (const chunk of compilation.chunks) {
+						if (chunk instanceof HotUpdateChunk) continue;
+
+						for (const auxiliaryFile of chunk.auxiliaryFiles) {
+							handleFile(auxiliaryFile);
+						}
+
+						const name = getName(chunk);
+
+						for (const file of chunk.files) {
+							handleFile(file, name ? `${name}.${extname(file)}` : file);
+						}
+					}
+
+					for (const asset of compilation.getAssets()) {
+						if (asset.info.hotModuleReplacement) {
+							continue;
+						}
+
+						handleFile(asset.name);
+					}
+
+					manifest.assets = assets;
+
+					if (this.options.generate) {
+						manifest = this.options.generate(manifest);
+					}
+
+					compilation.emitAsset(
+						this.options.filename,
+						new RawSource(this.options.serialize(manifest)),
+						{ manifest: true }
+					);
+				}
+			);
+		});
+	}
+}
+
+module.exports = ManifestPlugin;

package/lib/Module.js

@@ -9,7 +9,11 @@ const util = require("util");
 const ChunkGraph = require("./ChunkGraph");
 const DependenciesBlock = require("./DependenciesBlock");
 const ModuleGraph = require("./ModuleGraph");
-const { JS_TYPES } = require("./ModuleSourceTypesConstants");
+const {
+	JAVASCRIPT_TYPE,
+	UNKNOWN_TYPE
+} = require("./ModuleSourceTypeConstants");
+const { JAVASCRIPT_TYPES } = require("./ModuleSourceTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const { first } = require("./util/SetHelpers");
 const { compareChunksById } = require("./util/comparators");
@@ -24,12 +28,14 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("./Compilation").FileSystemDependencies} FileSystemDependencies */
 /** @typedef {import("./Compilation").UnsafeCacheData} UnsafeCacheData */
 /** @typedef {import("./ConcatenationScope")} ConcatenationScope */
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("./DependencyTemplate").CssData} CssData */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./ModuleSourceTypeConstants").AllTypes} AllTypes */
 /** @typedef {import("./FileSystemInfo")} FileSystemInfo */
 /** @typedef {import("./FileSystemInfo").Snapshot} Snapshot */
 /** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
@@ -39,6 +45,8 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../declarations/WebpackOptions").CssParserExportType} CssParserExportType */
+
 /**
  * @template T
  * @typedef {import("./InitFragment")<T>} InitFragment
@@ -68,7 +76,9 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {string=} type the type of source that should be generated
  */
 
-/** @typedef {ReadonlySet<string>} SourceTypes */
+/** @typedef {AllTypes} KnownSourceType */
+/** @typedef {KnownSourceType | string} SourceType */
+/** @typedef {ReadonlySet<SourceType>} SourceTypes */
 
 // TODO webpack 6: compilation will be required in CodeGenerationContext
 /**
@@ -78,6 +88,7 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {ModuleGraph} moduleGraph the module graph
  * @property {ChunkGraph} chunkGraph the chunk graph
  * @property {RuntimeSpec} runtime the runtimes code should be generated for
+ * @property {RuntimeSpec[]} runtimes all runtimes code should be generated for
  * @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
@@ -101,7 +112,7 @@ const makeSerializable = require("./util/makeSerializable");
 
 /**
  * @typedef {object} CodeGenerationResult
- * @property {Map<string, Source>} sources the resulting sources for all source types
+ * @property {Map<SourceType, Source>} sources the resulting sources for all source types
  * @property {CodeGenerationResultData=} data the resulting data for all source types
  * @property {ReadOnlyRuntimeRequirements | null} runtimeRequirements the runtime requirements
  * @property {string=} hash a hash of the code generation result (will be automatically calculated from sources and runtimeRequirements if not provided)
@@ -116,6 +127,7 @@ const makeSerializable = require("./util/makeSerializable");
 /**
  * @typedef {object} KnownBuildMeta
  * @property {("default" | "namespace" | "flagged" | "dynamic")=} exportsType
+ * @property {CssParserExportType=} exportType
  * @property {(false | "redirect" | "redirect-warn")=} defaultObject
  * @property {boolean=} strictHarmonyModule
  * @property {boolean=} treatAsCommonJs
@@ -123,12 +135,10 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {boolean=} sideEffectFree
  * @property {boolean=} isCSSModule
  * @property {Record<string, string>=} jsIncompatibleExports
- * @property {Record<string, string>=} exportsFinalName
- * @property {string=} factoryExportsBinding
+ * @property {Map<RuntimeSpec, Record<string, string>>=} exportsFinalNameByRuntime
+ * @property {Map<RuntimeSpec, string>=} exportsSourceByRuntime
  */
 
-/** @typedef {LazySet<string>} FileSystemDependencies */
-
 /**
  * @typedef {object} KnownBuildInfo
  * @property {boolean=} cacheable
@@ -185,7 +195,8 @@ const EMPTY_RESOLVE_OPTIONS = {};
 
 let debugId = 1000;
 
-const DEFAULT_TYPES_UNKNOWN = new Set(["unknown"]);
+/** @type {SourceTypes} */
+const DEFAULT_TYPES_UNKNOWN = new Set([UNKNOWN_TYPE]);
 
 const deprecatedNeedRebuild = util.deprecate(
 	/**
@@ -836,8 +847,8 @@ class Module extends DependenciesBlock {
 
 	/**
 	 * @deprecated Use needBuild instead
-	 * @param {Map<string, number|null>} fileTimestamps timestamps of files
-	 * @param {Map<string, number|null>} contextTimestamps timestamps of directories
+	 * @param {Map<string, number | null>} fileTimestamps timestamps of files
+	 * @param {Map<string, number | null>} contextTimestamps timestamps of directories
 	 * @returns {boolean} true, if the module needs a rebuild
 	 */
 	needRebuild(fileTimestamps, contextTimestamps) {
@@ -925,7 +936,7 @@ class Module extends DependenciesBlock {
 		if (this.source === Module.prototype.source) {
 			return DEFAULT_TYPES_UNKNOWN;
 		}
-		return JS_TYPES;
+		return JAVASCRIPT_TYPES;
 	}
 
 	/**
@@ -933,10 +944,10 @@ class Module extends DependenciesBlock {
 	 * @deprecated Use codeGeneration() instead
 	 * @param {DependencyTemplates} dependencyTemplates the dependency templates
 	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
-	 * @param {string=} type the type of source that should be generated
+	 * @param {SourceType=} type the type of source that should be generated
 	 * @returns {Source} generated source
 	 */
-	source(dependencyTemplates, runtimeTemplate, type = "javascript") {
+	source(dependencyTemplates, runtimeTemplate, type = JAVASCRIPT_TYPE) {
 		if (this.codeGeneration === Module.prototype.codeGeneration) {
 			const AbstractMethodError = require("./AbstractMethodError");
 
@@ -954,6 +965,7 @@ class Module extends DependenciesBlock {
 			moduleGraph: chunkGraph.moduleGraph,
 			chunkGraph,
 			runtime: undefined,
+			runtimes: [],
 			codeGenerationResults: undefined
 		};
 		const sources = this.codeGeneration(codeGenContext).sources;
@@ -961,7 +973,7 @@ class Module extends DependenciesBlock {
 		return /** @type {Source} */ (
 			type
 				? sources.get(type)
-				: sources.get(/** @type {string} */ (first(this.getSourceTypes())))
+				: sources.get(/** @type {SourceType} */ (first(this.getSourceTypes())))
 		);
 	}
 
@@ -1016,7 +1028,7 @@ class Module extends DependenciesBlock {
 		// Best override this method
 		const sources = new Map();
 		for (const type of this.getSourceTypes()) {
-			if (type !== "unknown") {
+			if (type !== UNKNOWN_TYPE) {
 				sources.set(
 					type,
 					this.source(

package/lib/ModuleBuildError.js

@@ -17,7 +17,7 @@ const makeSerializable = require("./util/makeSerializable");
 class ModuleBuildError extends WebpackError {
 	/**
 	 * @param {string | ErrorWithHideStack} err error thrown
-	 * @param {{from?: string|null}} info additional info
+	 * @param {{from?: string | null}} info additional info
 	 */
 	constructor(err, { from = null } = {}) {
 		let message = "Module build failed";

package/lib/ModuleError.js

@@ -15,7 +15,7 @@ const makeSerializable = require("./util/makeSerializable");
 class ModuleError extends WebpackError {
 	/**
 	 * @param {Error} err error thrown
-	 * @param {{from?: string|null}} info additional info
+	 * @param {{from?: string | null}} info additional info
 	 */
 	constructor(err, { from = null } = {}) {
 		let message = "Module Error";

package/lib/ModuleFilenameHelpers.js

@@ -281,7 +281,7 @@ ModuleFilenameHelpers.createFilename = (
  * @template T
  * @param {T[]} array the array with duplicates to be replaced
  * @param {(duplicateItem: T, duplicateItemIndex: number, numberOfTimesReplaced: number) => T} fn callback function to generate new values for the duplicate items
- * @param {(firstElement:T, nextElement:T) => -1 | 0 | 1=} comparator optional comparator function to sort the duplicate items
+ * @param {(firstElement: T, nextElement: T) => -1 | 0 | 1=} comparator optional comparator function to sort the duplicate items
  * @returns {T[]} the array with duplicates replaced
  * @example
  * ```js

package/lib/ModuleGraph.js

@@ -9,6 +9,7 @@ const util = require("util");
 const ExportsInfo = require("./ExportsInfo");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
 const HarmonyImportDependency = require("./dependencies/HarmonyImportDependency");
+const { ImportPhaseUtils } = require("./dependencies/ImportPhase");
 const SortableSet = require("./util/SortableSet");
 const WeakTupleMap = require("./util/WeakTupleMap");
 const { sortWithSourceOrder } = require("./util/comparators");
@@ -168,6 +169,12 @@ class ModuleGraph {
 		 * @private
 		 */
 		this._dependencySourceOrderMap = new WeakMap();
+
+		/**
+		 * @type {Set<Module>}
+		 * @private
+		 */
+		this._modulesNeedingSort = new Set();
 	}
 
 	/**
@@ -304,17 +311,15 @@ class ModuleGraph {
 		// import { a, b } from "lib" -> a and b have the same source order -> a = b = 1
 		// import { d } from "lib/d" -> d = 2
 		const currentSourceOrder =
-			/** @type { HarmonyImportSideEffectDependency | HarmonyImportSpecifierDependency} */ (
-				dependency
-			).sourceOrder;
+			/** @type {HarmonyImportSideEffectDependency | HarmonyImportSpecifierDependency} */
+			(dependency).sourceOrder;
 
 		// lib/index.js (reexport)
 		// import { a } from "lib/a" -> a = 0
 		// import { b } from "lib/b" -> b = 1
 		const originSourceOrder =
-			/** @type { HarmonyImportSideEffectDependency | HarmonyImportSpecifierDependency} */ (
-				originDependency
-			).sourceOrder;
+			/** @type {HarmonyImportSideEffectDependency | HarmonyImportSpecifierDependency} */
+			(originDependency).sourceOrder;
 		if (
 			typeof currentSourceOrder === "number" &&
 			typeof originSourceOrder === "number"
@@ -329,17 +334,28 @@ class ModuleGraph {
 				sub: originSourceOrder
 			});
 
+			// Save for later batch sorting
+			this._modulesNeedingSort.add(parentModule);
+		}
+	}
+
+	/**
+	 * @returns {void}
+	 */
+	finishUpdateParent() {
+		if (this._modulesNeedingSort.size === 0) {
+			return;
+		}
+		for (const mod of this._modulesNeedingSort) {
 			// If dependencies like HarmonyImportSideEffectDependency and HarmonyImportSpecifierDependency have a SourceOrder,
 			// we sort based on it; otherwise, we preserve the original order.
 			sortWithSourceOrder(
-				parentModule.dependencies,
-				this._dependencySourceOrderMap
+				mod.dependencies,
+				this._dependencySourceOrderMap,
+				(dep, index) => this.setParentDependenciesBlockIndex(dep, index)
 			);
-
-			for (const [index, dep] of parentModule.dependencies.entries()) {
-				this.setParentDependenciesBlockIndex(dep, index);
-			}
 		}
+		this._modulesNeedingSort.clear();
 	}
 
 	/**
@@ -844,7 +860,7 @@ class ModuleGraph {
 			) {
 				continue;
 			}
-			if (connection.dependency.defer) return true;
+			if (ImportPhaseUtils.isDefer(connection.dependency.phase)) return true;
 		}
 		return false;
 	}

package/lib/ModuleGraphConnection.js

@@ -52,8 +52,8 @@ const intersectConnectionStates = (a, b) => {
 
 class ModuleGraphConnection {
 	/**
-	 * @param {Module|null} originModule the referencing module
-	 * @param {Dependency|null} dependency the referencing dependency
+	 * @param {Module | null} originModule the referencing module
+	 * @param {Dependency | null} dependency the referencing dependency
 	 * @param {Module} module the referenced module
 	 * @param {string=} explanation some extra detail
 	 * @param {boolean=} weak the reference is weak