webpack 5.98.0 → 5.99.0

package/lib/ids/IdHelpers.js

@@ -14,6 +14,7 @@ const numberHash = require("../util/numberHash");
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Module")} Module */
 /** @typedef {typeof import("../util/Hash")} Hash */
+/** @typedef {import("../util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
 
 /**
  * @param {string} str string to hash
@@ -75,7 +76,7 @@ const shortenLongString = (string, delimiter, hashFunction) => {
 /**
  * @param {Module} module the module
  * @param {string} context context directory
- * @param {object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} short module name
  */
 const getShortModuleName = (module, context, associatedObjectForCache) => {
@@ -95,7 +96,7 @@ module.exports.getShortModuleName = getShortModuleName;
  * @param {Module} module the module
  * @param {string} context context directory
  * @param {string | Hash} hashFunction hash function to use
- * @param {object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} long module name
  */
 const getLongModuleName = (
@@ -113,7 +114,7 @@ module.exports.getLongModuleName = getLongModuleName;
 /**
  * @param {Module} module the module
  * @param {string} context context directory
- * @param {object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} full module name
  */
 const getFullModuleName = (module, context, associatedObjectForCache) =>
@@ -126,7 +127,7 @@ module.exports.getFullModuleName = getFullModuleName;
  * @param {string} context context directory
  * @param {string} delimiter delimiter for names
  * @param {string | Hash} hashFunction hash function to use
- * @param {object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} short chunk name
  */
 const getShortChunkName = (
@@ -156,7 +157,7 @@ module.exports.getShortChunkName = getShortChunkName;
  * @param {string} context context directory
  * @param {string} delimiter delimiter for names
  * @param {string | Hash} hashFunction hash function to use
- * @param {object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} short chunk name
  */
 const getLongChunkName = (
@@ -189,7 +190,7 @@ module.exports.getLongChunkName = getLongChunkName;
  * @param {Chunk} chunk the chunk
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {string} context context directory
- * @param {object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} full chunk name
  */
 const getFullChunkName = (
@@ -226,7 +227,7 @@ const addToMapOfItems = (map, key, value) => {
 
 /**
  * @param {Compilation} compilation the compilation
- * @param {function(Module): boolean=} filter filter modules
+ * @param {((module: Module) => boolean)=} filter filter modules
  * @returns {[Set<string>, Module[]]} used module ids as strings and modules without id matching the filter
  */
 const getUsedModuleIdsAndModules = (compilation, filter) => {
@@ -286,11 +287,11 @@ module.exports.getUsedChunkIds = getUsedChunkIds;
 /**
  * @template T
  * @param {Iterable<T>} items list of items to be named
- * @param {function(T): string} getShortName get a short name for an item
- * @param {function(T, string): string} getLongName get a long name for an item
- * @param {function(T, T): -1|0|1} comparator order of items
+ * @param {(item: T) => string} getShortName get a short name for an item
+ * @param {(item: T, name: string) => string} getLongName get a long name for an item
+ * @param {(a: T, b: T) => -1 | 0 | 1} comparator order of items
  * @param {Set<string>} usedIds already used ids, will not be assigned
- * @param {function(T, string): void} assignName assign a name to an item
+ * @param {(item: T, name: string) => void} assignName assign a name to an item
  * @returns {T[]} list of items without a name
  */
 const assignNames = (
@@ -354,9 +355,9 @@ module.exports.assignNames = assignNames;
 /**
  * @template T
  * @param {T[]} items list of items to be named
- * @param {function(T): string} getName get a name for an item
- * @param {function(T, T): -1|0|1} comparator order of items
- * @param {function(T, number): boolean} assignId assign an id to an item
+ * @param {(item: T) => string} getName get a name for an item
+ * @param {(a: T, n: T) => -1 | 0 | 1} comparator order of items
+ * @param {(item: T, id: number) => boolean} assignId assign an id to an item
  * @param {number[]} ranges usable ranges for ids
  * @param {number} expandFactor factor to create more ranges
  * @param {number} extraSpace extra space to allocate, i. e. when some ids are already used

package/lib/ids/SyncModuleIdsPlugin.js

@@ -14,13 +14,17 @@ const { getUsedModuleIdsAndModules } = require("./IdHelpers");
 
 const plugin = "SyncModuleIdsPlugin";
 
+/**
+ * @typedef {object} SyncModuleIdsPluginOptions
+ * @property {string} path path to file
+ * @property {string=} context context for module names
+ * @property {((module: Module) => boolean)=} test selector for modules
+ * @property {"read" | "create" | "merge" | "update"=} mode operation mode (defaults to merge)
+ */
+
 class SyncModuleIdsPlugin {
 	/**
-	 * @param {object} options options
-	 * @param {string} options.path path to file
-	 * @param {string=} options.context context for module names
-	 * @param {function(Module): boolean} options.test selector for modules
-	 * @param {"read" | "create" | "merge" | "update"=} options.mode operation mode (defaults to merge)
+	 * @param {SyncModuleIdsPluginOptions} options options
 	 */
 	constructor({ path, context, test, mode }) {
 		this._path = path;

package/lib/index.js

@@ -64,15 +64,15 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
 
 /**
- * @template {Function} T
- * @param {function(): T} factory factory function
+ * @template {EXPECTED_FUNCTION} T
+ * @param {() => T} factory factory function
  * @returns {T} function
  */
 const lazyFunction = factory => {
 	const fac = memoize(factory);
 	const f = /** @type {any} */ (
 		/**
-		 * @param {...any} args args
+		 * @param {...EXPECTED_ANY} args args
 		 * @returns {T} result
 		 */
 		(...args) => fac()(...args)
@@ -120,13 +120,13 @@ module.exports = mergeExports(fn, {
 		return require("./webpack");
 	},
 	/**
-	 * @returns {function(Configuration | Configuration[]): void} validate fn
+	 * @returns {(configuration: Configuration | Configuration[]) => void} validate fn
 	 */
 	get validate() {
 		const webpackOptionsSchemaCheck = require("../schemas/WebpackOptions.check.js");
 		const getRealValidate = memoize(
 			/**
-			 * @returns {function(Configuration | Configuration[]): void} validate fn
+			 * @returns {(configuration: Configuration | Configuration[]) => void} validate fn
 			 */
 			() => {
 				const validateSchema = require("./validateSchema");

package/lib/javascript/BasicEvaluatedExpression.js

@@ -7,7 +7,7 @@
 
 /** @typedef {import("estree").Node} Node */
 /** @typedef {import("./JavascriptParser").Range} Range */
-/** @typedef {import("./JavascriptParser").VariableInfoInterface} VariableInfoInterface */
+/** @typedef {import("./JavascriptParser").VariableInfo} VariableInfo */
 
 const TypeUnknown = 0;
 const TypeUndefined = 1;
@@ -51,7 +51,7 @@ class BasicEvaluatedExpression {
 		this.quasis = undefined;
 		/** @type {BasicEvaluatedExpression[] | undefined} */
 		this.parts = undefined;
-		/** @type {any[] | undefined} */
+		/** @type {EXPECTED_ANY[] | undefined} */
 		this.array = undefined;
 		/** @type {BasicEvaluatedExpression[] | undefined} */
 		this.items = undefined;
@@ -63,9 +63,9 @@ class BasicEvaluatedExpression {
 		this.postfix = undefined;
 		/** @type {BasicEvaluatedExpression[] | undefined} */
 		this.wrappedInnerExpressions = undefined;
-		/** @type {string | VariableInfoInterface | undefined} */
+		/** @type {string | VariableInfo | undefined} */
 		this.identifier = undefined;
-		/** @type {string | VariableInfoInterface | undefined} */
+		/** @type {string | VariableInfo | undefined} */
 		this.rootInfo = undefined;
 		/** @type {(() => string[]) | undefined} */
 		this.getMembers = undefined;
@@ -386,8 +386,8 @@ class BasicEvaluatedExpression {
 
 	/**
 	 * Set's the value of this expression to a particular identifier and its members.
-	 * @param {string | VariableInfoInterface} identifier identifier to set
-	 * @param {string | VariableInfoInterface} rootInfo root info
+	 * @param {string | VariableInfo} identifier identifier to set
+	 * @param {string | VariableInfo} rootInfo root info
 	 * @param {() => string[]} getMembers members
 	 * @param {() => boolean[]=} getMembersOptionals optional members
 	 * @param {() => Range[]=} getMemberRanges ranges of progressively increasing sub-expressions

package/lib/javascript/JavascriptGenerator.js

@@ -36,7 +36,7 @@ const deprecatedGetInitFragments = util.deprecate(
 	 * @returns {InitFragment<GenerateContext>[]} init fragments
 	 */
 	(template, dependency, templateContext) =>
-		/** @type {DependencyTemplate & { getInitFragments: function(Dependency, DependencyTemplateContext): InitFragment<GenerateContext>[] }} */
+		/** @type {DependencyTemplate & { getInitFragments: (dependency: Dependency, dependencyTemplateContext: DependencyTemplateContext) => InitFragment<GenerateContext>[] }} */
 		(template).getInitFragments(dependency, templateContext),
 	"DependencyTemplate.getInitFragment is deprecated (use apply(dep, source, { initFragments }) instead)",
 	"DEP_WEBPACK_JAVASCRIPT_GENERATOR_GET_INIT_FRAGMENTS"
@@ -110,6 +110,16 @@ class JavascriptGenerator extends Generator {
 		return InitFragment.addToSource(source, initFragments, generateContext);
 	}
 
+	/**
+	 * @param {Error} error the error
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source | null} generated code
+	 */
+	generateError(error, module, generateContext) {
+		return new RawSource(`throw new Error(${JSON.stringify(error.message)});`);
+	}
+
 	/**
 	 * @param {Module} module the module to generate
 	 * @param {InitFragment<GenerateContext>[]} initFragments mutable list of init fragments

package/lib/javascript/JavascriptModulesPlugin.js

@@ -26,6 +26,7 @@ const {
 	JAVASCRIPT_MODULE_TYPE_ESM,
 	WEBPACK_MODULE_TYPE_RUNTIME
 } = require("../ModuleTypeConstants");
+const NormalModule = require("../NormalModule");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const { last, someInIterable } = require("../util/IterableHelpers");
@@ -41,6 +42,7 @@ const {
 } = require("../util/concatenate");
 const createHash = require("../util/createHash");
 const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
+const removeBOM = require("../util/removeBOM");
 const { intersectRuntime } = require("../util/runtime");
 const JavascriptGenerator = require("./JavascriptGenerator");
 const JavascriptParser = require("./JavascriptParser");
@@ -48,13 +50,14 @@ const JavascriptParser = require("./JavascriptParser");
 /** @typedef {import("eslint-scope").Reference} Reference */
 /** @typedef {import("eslint-scope").Scope} Scope */
 /** @typedef {import("eslint-scope").Variable} Variable */
+/** @typedef {import("estree").Program} Program */
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../../declarations/WebpackOptions").Output} OutputOptions */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
 /** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
-/** @typedef {import("../Compilation").ModuleObject} ModuleObject */
+/** @typedef {import("../Compilation").ExecuteModuleObject} ExecuteModuleObject */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../Entrypoint")} Entrypoint */
@@ -248,7 +251,7 @@ class JavascriptModulesPlugin {
 
 	constructor(options = {}) {
 		this.options = options;
-		/** @type {WeakMap<Source, TODO>} */
+		/** @type {WeakMap<Source, { source: Source, needModule:boolean, needExports: boolean, needRequire: boolean, needThisAsExports: boolean, needStrict: boolean | undefined }>} */
 		this._moduleFactoryCache = new WeakMap();
 	}
 
@@ -262,24 +265,45 @@ class JavascriptModulesPlugin {
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
-				normalModuleFactory.hooks.createParser
-					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
-					.tap(PLUGIN_NAME, options => new JavascriptParser("auto"));
-				normalModuleFactory.hooks.createParser
-					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
-					.tap(PLUGIN_NAME, options => new JavascriptParser("script"));
-				normalModuleFactory.hooks.createParser
-					.for(JAVASCRIPT_MODULE_TYPE_ESM)
-					.tap(PLUGIN_NAME, options => new JavascriptParser("module"));
-				normalModuleFactory.hooks.createGenerator
-					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
-					.tap(PLUGIN_NAME, () => new JavascriptGenerator());
-				normalModuleFactory.hooks.createGenerator
-					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
-					.tap(PLUGIN_NAME, () => new JavascriptGenerator());
-				normalModuleFactory.hooks.createGenerator
-					.for(JAVASCRIPT_MODULE_TYPE_ESM)
-					.tap(PLUGIN_NAME, () => new JavascriptGenerator());
+
+				for (const type of [
+					JAVASCRIPT_MODULE_TYPE_AUTO,
+					JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+					JAVASCRIPT_MODULE_TYPE_ESM
+				]) {
+					normalModuleFactory.hooks.createParser
+						.for(type)
+						.tap(PLUGIN_NAME, _options => {
+							switch (type) {
+								case JAVASCRIPT_MODULE_TYPE_AUTO: {
+									return new JavascriptParser("auto");
+								}
+								case JAVASCRIPT_MODULE_TYPE_DYNAMIC: {
+									return new JavascriptParser("script");
+								}
+								case JAVASCRIPT_MODULE_TYPE_ESM: {
+									return new JavascriptParser("module");
+								}
+							}
+						});
+					normalModuleFactory.hooks.createGenerator
+						.for(type)
+						.tap(PLUGIN_NAME, () => new JavascriptGenerator());
+
+					NormalModule.getCompilationHooks(compilation).processResult.tap(
+						PLUGIN_NAME,
+						(result, module) => {
+							if (module.type === type) {
+								const [source, ...rest] = result;
+
+								return [removeBOM(source), ...rest];
+							}
+
+							return result;
+						}
+					);
+				}
+
 				compilation.hooks.renderManifest.tap(PLUGIN_NAME, (result, options) => {
 					const {
 						hash,
@@ -487,7 +511,7 @@ class JavascriptModulesPlugin {
 					);
 
 					const moduleObject =
-						/** @type {ModuleObject} */
+						/** @type {ExecuteModuleObject} */
 						(options.moduleObject);
 
 					try {
@@ -977,7 +1001,7 @@ class JavascriptModulesPlugin {
 			const lastEntryModule =
 				/** @type {Module} */
 				(last(chunkGraph.getChunkEntryModulesIterable(chunk)));
-			/** @type {function(string[], string): Source} */
+			/** @type {(content: string[], name: string) => Source} */
 			const toSource = useSourceMap
 				? (content, name) =>
 						new OriginalSource(Template.asString(content), name)
@@ -1506,7 +1530,7 @@ class JavascriptModulesPlugin {
 		const renamedInlinedModules = new Map();
 		const { runtimeTemplate } = renderContext;
 
-		/** @typedef {{ source: Source, module: Module, ast: any, variables: Set<Variable>, through: Set<Reference>, usedInNonInlined: Set<Variable>, moduleScope: Scope }} Info */
+		/** @typedef {{ source: Source, module: Module, ast: Program, variables: Set<Variable>, through: Set<Reference>, usedInNonInlined: Set<Variable>, moduleScope: Scope }} Info */
 		/** @type {Map<Module, Info>} */
 		const inlinedModulesToInfo = new Map();
 		/** @type {Set<string>} */
@@ -1583,12 +1607,6 @@ class JavascriptModulesPlugin {
 			}
 
 			for (const variable of info.variables) {
-				allUsedNames.add(variable.name);
-				const references = getAllReferences(variable);
-				const allIdentifiers = new Set(
-					references.map(r => r.identifier).concat(variable.identifiers)
-				);
-
 				const usedNamesInScopeInfo = new Map();
 				const ignoredScopes = new Set();
 
@@ -1601,6 +1619,9 @@ class JavascriptModulesPlugin {
 
 				if (allUsedNames.has(name) || usedNames.has(name)) {
 					const references = getAllReferences(variable);
+					const allIdentifiers = new Set(
+						references.map(r => r.identifier).concat(variable.identifiers)
+					);
 					for (const ref of references) {
 						addScopeSymbols(
 							ref.from,
@@ -1635,9 +1656,8 @@ class JavascriptModulesPlugin {
 						}
 						source.replace(r[0], r[1] - 1, newName);
 					}
-				} else {
-					allUsedNames.add(name);
 				}
+				allUsedNames.add(name);
 			}
 
 			renamedInlinedModules.set(m, source);