webpack 5.97.1 → 5.104.1

package/lib/javascript/JavascriptParserHelpers.js

@@ -10,56 +10,18 @@ const ConstDependency = require("../dependencies/ConstDependency");
 const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 
 /** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("estree").Node} Node */
 /** @typedef {import("estree").SourceLocation} SourceLocation */
 /** @typedef {import("./JavascriptParser")} JavascriptParser */
 /** @typedef {import("./JavascriptParser").Range} Range */
+/** @typedef {import("./BasicEvaluatedExpression").GetMembers} GetMembers */
 
-/**
- * @param {JavascriptParser} parser the parser
- * @param {string} value the const value
- * @param {(string[] | null)=} runtimeRequirements runtime requirements
- * @returns {function(Expression): true} plugin function
- */
-module.exports.toConstantDependency = (parser, value, runtimeRequirements) =>
-	function constDependency(expr) {
-		const dep = new ConstDependency(
-			value,
-			/** @type {Range} */ (expr.range),
-			runtimeRequirements
-		);
-		dep.loc = /** @type {SourceLocation} */ (expr.loc);
-		parser.state.module.addPresentationalDependency(dep);
-		return true;
-	};
-
-/**
- * @param {string} value the string value
- * @returns {function(Expression): BasicEvaluatedExpression} plugin function
- */
-module.exports.evaluateToString = value =>
-	function stringExpression(expr) {
-		return new BasicEvaluatedExpression()
-			.setString(value)
-			.setRange(/** @type {Range} */ (expr.range));
-	};
-
-/**
- * @param {number} value the number value
- * @returns {function(Expression): BasicEvaluatedExpression} plugin function
- */
-module.exports.evaluateToNumber = value =>
-	function stringExpression(expr) {
-		return new BasicEvaluatedExpression()
-			.setNumber(value)
-			.setRange(/** @type {Range} */ (expr.range));
-	};
+module.exports.approve = () => true;
 
 /**
  * @param {boolean} value the boolean value
- * @returns {function(Expression): BasicEvaluatedExpression} plugin function
+ * @returns {(expression: Expression) => BasicEvaluatedExpression} plugin function
  */
-module.exports.evaluateToBoolean = value =>
+module.exports.evaluateToBoolean = (value) =>
 	function booleanExpression(expr) {
 		return new BasicEvaluatedExpression()
 			.setBoolean(value)
@@ -69,9 +31,9 @@ module.exports.evaluateToBoolean = value =>
 /**
  * @param {string} identifier identifier
  * @param {string} rootInfo rootInfo
- * @param {function(): string[]} getMembers getMembers
- * @param {boolean|null=} truthy is truthy, null if nullish
- * @returns {function(Expression): BasicEvaluatedExpression} callback
+ * @param {GetMembers} getMembers getMembers
+ * @param {boolean | null=} truthy is truthy, null if nullish
+ * @returns {(expression: Expression) => BasicEvaluatedExpression} callback
  */
 module.exports.evaluateToIdentifier = (
 	identifier,
@@ -99,10 +61,32 @@ module.exports.evaluateToIdentifier = (
 		return evaluatedExpression;
 	};
 
+/**
+ * @param {number} value the number value
+ * @returns {(expression: Expression) => BasicEvaluatedExpression} plugin function
+ */
+module.exports.evaluateToNumber = (value) =>
+	function stringExpression(expr) {
+		return new BasicEvaluatedExpression()
+			.setNumber(value)
+			.setRange(/** @type {Range} */ (expr.range));
+	};
+
+/**
+ * @param {string} value the string value
+ * @returns {(expression: Expression) => BasicEvaluatedExpression} plugin function
+ */
+module.exports.evaluateToString = (value) =>
+	function stringExpression(expr) {
+		return new BasicEvaluatedExpression()
+			.setString(value)
+			.setRange(/** @type {Range} */ (expr.range));
+	};
+
 /**
  * @param {JavascriptParser} parser the parser
  * @param {string} message the message
- * @returns {function(Expression): boolean | undefined} callback to handle unsupported expression
+ * @returns {(expression: Expression) => boolean | undefined} callback to handle unsupported expression
  */
 module.exports.expressionIsUnsupported = (parser, message) =>
 	function unsupportedExpression(expr) {
@@ -125,4 +109,21 @@ module.exports.expressionIsUnsupported = (parser, message) =>
 
 module.exports.skipTraversal = () => true;
 
-module.exports.approve = () => true;
+/**
+ * @param {JavascriptParser} parser the parser
+ * @param {string} value the const value
+ * @param {(string[] | null)=} runtimeRequirements runtime requirements
+ * @returns {(expression: Expression) => true} plugin function
+ */
+module.exports.toConstantDependency = (parser, value, runtimeRequirements) =>
+	function constDependency(expr) {
+		const dep = new ConstDependency(
+			value,
+			/** @type {Range} */
+			(expr.range),
+			runtimeRequirements
+		);
+		dep.loc = /** @type {SourceLocation} */ (expr.loc);
+		parser.state.module.addPresentationalDependency(dep);
+		return true;
+	};

package/lib/javascript/StartupHelpers.js

@@ -13,14 +13,11 @@ const { getAllChunks } = require("./ChunkHelpers");
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Chunk").ChunkId} ChunkId */
-/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../ChunkGraph").ModuleId} ModuleId */
 /** @typedef {import("../Entrypoint")} Entrypoint */
 /** @typedef {import("../ChunkGraph").EntryModuleWithChunkGroup} EntryModuleWithChunkGroup */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {(string|number)[]} EntryItem */
 
 const EXPORT_PREFIX = `var ${RuntimeGlobals.exports} = `;
 
@@ -54,7 +51,7 @@ module.exports.generateEntryStartup = (
 	 * @param {ModuleId} id id
 	 * @returns {string} fn to execute
 	 */
-	const runModule = id => `__webpack_exec__(${JSON.stringify(id)})`;
+	const runModule = (id) => `__webpack_exec__(${JSON.stringify(id)})`;
 	/**
 	 * @param {Chunks} chunks chunks
 	 * @param {ModuleIds} moduleIds module ids
@@ -74,7 +71,7 @@ module.exports.generateEntryStartup = (
 					passive
 						? RuntimeGlobals.onChunksLoaded
 						: RuntimeGlobals.startupEntrypoint
-				}(0, ${JSON.stringify(Array.from(chunks, c => c.id))}, ${fn});`
+				}(0, ${JSON.stringify(Array.from(chunks, (c) => c.id))}, ${fn});`
 			);
 			if (final && passive) {
 				runtime.push(`${EXPORT_PREFIX}${RuntimeGlobals.onChunksLoaded}();`);
@@ -88,6 +85,9 @@ module.exports.generateEntryStartup = (
 	let currentModuleIds;
 
 	for (const [module, entrypoint] of entries) {
+		if (!chunkGraph.getModuleSourceTypes(module).has("javascript")) {
+			continue;
+		}
 		const runtimeChunk =
 			/** @type {Entrypoint} */
 			(entrypoint).getRuntimeChunk();
@@ -130,6 +130,24 @@ module.exports.generateEntryStartup = (
 	return Template.asString(runtime);
 };
 
+/**
+ * @param {Chunk} chunk the chunk
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {(chunk: Chunk, chunkGraph: ChunkGraph) => boolean} filterFn filter function
+ * @returns {Set<ChunkId>} initially fulfilled chunk ids
+ */
+module.exports.getInitialChunkIds = (chunk, chunkGraph, filterFn) => {
+	/** @type {Set<ChunkId>} */
+	const initialChunkIds = new Set(chunk.ids);
+	for (const c of chunk.getAllInitialChunks()) {
+		if (c === chunk || filterFn(c, chunkGraph)) continue;
+		for (const id of /** @type {ChunkId[]} */ (c.ids)) {
+			initialChunkIds.add(id);
+		}
+	}
+	return initialChunkIds;
+};
+
 /**
  * @param {Hash} hash the hash to update
  * @param {ChunkGraph} chunkGraph chunkGraph
@@ -158,20 +176,3 @@ module.exports.updateHashForEntryStartup = (
 		}
 	}
 };
-
-/**
- * @param {Chunk} chunk the chunk
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {function(Chunk, ChunkGraph): boolean} filterFn filter function
- * @returns {Set<number | string>} initially fulfilled chunk ids
- */
-module.exports.getInitialChunkIds = (chunk, chunkGraph, filterFn) => {
-	const initialChunkIds = new Set(chunk.ids);
-	for (const c of chunk.getAllInitialChunks()) {
-		if (c === chunk || filterFn(c, chunkGraph)) continue;
-		for (const id of /** @type {ChunkId[]} */ (c.ids)) {
-			initialChunkIds.add(id);
-		}
-	}
-	return initialChunkIds;
-};

package/lib/json/JsonData.js

@@ -10,16 +10,16 @@ const { register } = require("../util/serialization");
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("./JsonModulesPlugin").RawJsonData} RawJsonData */
+/** @typedef {import("../util/fs").JsonValue} JsonValue */
 
 class JsonData {
 	/**
-	 * @param {Buffer | RawJsonData} data JSON data
+	 * @param {Buffer | JsonValue} data JSON data
 	 */
 	constructor(data) {
 		/** @type {Buffer | undefined} */
 		this._buffer = undefined;
-		/** @type {RawJsonData | undefined} */
+		/** @type {JsonValue | undefined} */
 		this._data = undefined;
 		if (Buffer.isBuffer(data)) {
 			this._buffer = data;
@@ -29,7 +29,7 @@ class JsonData {
 	}
 
 	/**
-	 * @returns {RawJsonData|undefined} Raw JSON data
+	 * @returns {JsonValue | undefined} Raw JSON data
 	 */
 	get() {
 		if (this._data === undefined && this._buffer !== undefined) {

package/lib/json/JsonGenerator.js

@@ -9,59 +9,68 @@ const { RawSource } = require("webpack-sources");
 const ConcatenationScope = require("../ConcatenationScope");
 const { UsageState } = require("../ExportsInfo");
 const Generator = require("../Generator");
-const { JS_TYPES } = require("../ModuleSourceTypesConstants");
+const { JAVASCRIPT_TYPES } = require("../ModuleSourceTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").JsonGeneratorOptions} JsonGeneratorOptions */
 /** @typedef {import("../ExportsInfo")} ExportsInfo */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
+/** @typedef {import("../Module").SourceType} SourceType */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("./JsonData")} JsonData */
-/** @typedef {import("./JsonModulesPlugin").RawJsonData} RawJsonData */
+/** @typedef {import("../util/fs").JsonArray} JsonArray */
+/** @typedef {import("../util/fs").JsonObject} JsonObject */
+/** @typedef {import("../util/fs").JsonValue} JsonValue */
 
 /**
- * @param {RawJsonData} data Raw JSON data
- * @returns {undefined|string} stringified data
+ * @param {JsonValue} data Raw JSON data
+ * @returns {undefined | string} stringified data
  */
-const stringifySafe = data => {
+const stringifySafe = (data) => {
 	const stringified = JSON.stringify(data);
 	if (!stringified) {
 		return; // Invalid JSON
 	}
 
-	return stringified.replace(/\u2028|\u2029/g, str =>
+	return stringified.replace(/\u2028|\u2029/g, (str) =>
 		str === "\u2029" ? "\\u2029" : "\\u2028"
 	); // invalid in JavaScript but valid JSON
 };
 
 /**
- * @param {RawJsonData} data Raw JSON data (always an object or array)
+ * @param {JsonObject | JsonArray} data Raw JSON data (always an object or array)
  * @param {ExportsInfo} exportsInfo exports info
  * @param {RuntimeSpec} runtime the runtime
- * @returns {RawJsonData} reduced data
+ * @returns {JsonObject | JsonArray} reduced data
  */
 const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
-	if (exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused)
+	if (exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused) {
 		return data;
+	}
 	const isArray = Array.isArray(data);
-	/** @type {RawJsonData} */
+	/** @type {JsonObject | JsonArray} */
 	const reducedData = isArray ? [] : {};
 	for (const key of Object.keys(data)) {
 		const exportInfo = exportsInfo.getReadOnlyExportInfo(key);
 		const used = exportInfo.getUsed(runtime);
 		if (used === UsageState.Unused) continue;
 
-		/** @type {RawJsonData} */
+		// The real type is `JsonObject | JsonArray`, but typescript doesn't work `Object.keys(['string', 'other-string', 'etc'])` properly
+		const newData = /** @type {JsonObject} */ (data)[key];
 		const value =
-			used === UsageState.OnlyPropertiesUsed && exportInfo.exportsInfo
-				? createObjectForExportsInfo(data[key], exportInfo.exportsInfo, runtime)
-				: data[key];
+			used === UsageState.OnlyPropertiesUsed &&
+			exportInfo.exportsInfo &&
+			typeof newData === "object" &&
+			newData
+				? createObjectForExportsInfo(newData, exportInfo.exportsInfo, runtime)
+				: newData;
 
 		const name = /** @type {string} */ (exportInfo.getUsedName(key, runtime));
-		/** @type {Record<string, RawJsonData>} */ (reducedData)[name] = value;
+		/** @type {JsonObject} */
+		(reducedData)[name] = value;
 	}
 	if (isArray) {
 		const arrayLengthWhenUsed =
@@ -71,8 +80,11 @@ const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
 				: undefined;
 
 		let sizeObjectMinusArray = 0;
-		for (let i = 0; i < reducedData.length; i++) {
-			if (reducedData[i] === undefined) {
+		const reducedDataLength =
+			/** @type {JsonArray} */
+			(reducedData).length;
+		for (let i = 0; i < reducedDataLength; i++) {
+			if (/** @type {JsonArray} */ (reducedData)[i] === undefined) {
 				sizeObjectMinusArray -= 2;
 			} else {
 				sizeObjectMinusArray += `${i}`.length + 3;
@@ -82,23 +94,25 @@ const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
 			sizeObjectMinusArray +=
 				`${arrayLengthWhenUsed}`.length +
 				8 -
-				(arrayLengthWhenUsed - reducedData.length) * 2;
+				(arrayLengthWhenUsed - reducedDataLength) * 2;
 		}
-		if (sizeObjectMinusArray < 0)
+		if (sizeObjectMinusArray < 0) {
 			return Object.assign(
 				arrayLengthWhenUsed === undefined
 					? {}
 					: { length: arrayLengthWhenUsed },
 				reducedData
 			);
+		}
 		/** @type {number} */
 		const generatedLength =
 			arrayLengthWhenUsed !== undefined
-				? Math.max(arrayLengthWhenUsed, reducedData.length)
-				: reducedData.length;
+				? Math.max(arrayLengthWhenUsed, reducedDataLength)
+				: reducedDataLength;
 		for (let i = 0; i < generatedLength; i++) {
-			if (reducedData[i] === undefined) {
-				reducedData[i] = 0;
+			if (/** @type {JsonArray} */ (reducedData)[i] === undefined) {
+				/** @type {JsonArray} */
+				(reducedData)[i] = 0;
 			}
 		}
 	}
@@ -106,21 +120,29 @@ const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
 };
 
 class JsonGenerator extends Generator {
+	/**
+	 * @param {JsonGeneratorOptions} options options
+	 */
+	constructor(options) {
+		super();
+		this.options = options;
+	}
+
 	/**
 	 * @param {NormalModule} module fresh module
 	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
-		return JS_TYPES;
+		return JAVASCRIPT_TYPES;
 	}
 
 	/**
 	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
+	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
 	 */
 	getSize(module, type) {
-		/** @type {RawJsonData | undefined} */
+		/** @type {JsonValue | undefined} */
 		const data =
 			module.buildInfo &&
 			module.buildInfo.jsonData &&
@@ -153,7 +175,7 @@ class JsonGenerator extends Generator {
 			concatenationScope
 		}
 	) {
-		/** @type {RawJsonData | undefined} */
+		/** @type {JsonValue | undefined} */
 		const data =
 			module.buildInfo &&
 			module.buildInfo.jsonData &&
@@ -166,7 +188,7 @@ class JsonGenerator extends Generator {
 			);
 		}
 		const exportsInfo = moduleGraph.getExportsInfo(module);
-		/** @type {RawJsonData} */
+		/** @type {JsonValue} */
 		const finalJson =
 			typeof data === "object" &&
 			data &&
@@ -176,13 +198,15 @@ class JsonGenerator extends Generator {
 		// Use JSON because JSON.parse() is much faster than JavaScript evaluation
 		const jsonStr = /** @type {string} */ (stringifySafe(finalJson));
 		const jsonExpr =
-			jsonStr.length > 20 && typeof finalJson === "object"
+			this.options.JSONParse &&
+			jsonStr.length > 20 &&
+			typeof finalJson === "object"
 				? `/*#__PURE__*/JSON.parse('${jsonStr.replace(/[\\']/g, "\\$&")}')`
-				: jsonStr;
+				: jsonStr.replace(/"__proto__":/g, '["__proto__"]:');
 		/** @type {string} */
 		let content;
 		if (concatenationScope) {
-			content = `${runtimeTemplate.supportsConst() ? "const" : "var"} ${
+			content = `${runtimeTemplate.renderConst()} ${
 				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
 			} = ${jsonExpr};`;
 			concatenationScope.registerNamespaceExport(
@@ -194,6 +218,16 @@ class JsonGenerator extends Generator {
 		}
 		return new RawSource(content);
 	}
+
+	/**
+	 * @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)});`);
+	}
 }
 
 module.exports = JsonGenerator;

package/lib/json/JsonModulesPlugin.js

@@ -11,17 +11,25 @@ const JsonGenerator = require("./JsonGenerator");
 const JsonParser = require("./JsonParser");
 
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {Record<string, any>} RawJsonData */
 
 const validate = createSchemaValidation(
-	require("../../schemas/plugins/JsonModulesPluginParser.check.js"),
-	() => require("../../schemas/plugins/JsonModulesPluginParser.json"),
+	require("../../schemas/plugins/json/JsonModulesPluginParser.check"),
+	() => require("../../schemas/plugins/json/JsonModulesPluginParser.json"),
 	{
 		name: "Json Modules Plugin",
 		baseDataPath: "parser"
 	}
 );
 
+const validateGenerator = createSchemaValidation(
+	require("../../schemas/plugins/json/JsonModulesPluginGenerator.check"),
+	() => require("../../schemas/plugins/json/JsonModulesPluginGenerator.json"),
+	{
+		name: "Json Modules Plugin",
+		baseDataPath: "generator"
+	}
+);
+
 const PLUGIN_NAME = "JsonModulesPlugin";
 
 /**
@@ -40,14 +48,16 @@ class JsonModulesPlugin {
 			(compilation, { normalModuleFactory }) => {
 				normalModuleFactory.hooks.createParser
 					.for(JSON_MODULE_TYPE)
-					.tap(PLUGIN_NAME, parserOptions => {
+					.tap(PLUGIN_NAME, (parserOptions) => {
 						validate(parserOptions);
-
 						return new JsonParser(parserOptions);
 					});
 				normalModuleFactory.hooks.createGenerator
 					.for(JSON_MODULE_TYPE)
-					.tap(PLUGIN_NAME, () => new JsonGenerator());
+					.tap(PLUGIN_NAME, (generatorOptions) => {
+						validateGenerator(generatorOptions);
+						return new JsonGenerator(generatorOptions);
+					});
 			}
 		);
 	}

package/lib/json/JsonParser.js

@@ -15,7 +15,9 @@ const JsonData = require("./JsonData");
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
-/** @typedef {import("./JsonModulesPlugin").RawJsonData} RawJsonData */
+/** @typedef {import("../util/fs").JsonValue} JsonValue */
+
+/** @typedef {(input: string) => Buffer | JsonValue} ParseFn */
 
 const getParseJson = memoize(() => require("json-parse-even-better-errors"));
 
@@ -35,15 +37,15 @@ class JsonParser extends Parser {
 	 */
 	parse(source, state) {
 		if (Buffer.isBuffer(source)) {
-			source = source.toString("utf-8");
+			source = source.toString("utf8");
 		}
 
-		/** @type {NonNullable<JsonModulesPluginParserOptions["parse"]>} */
+		/** @type {ParseFn} */
 		const parseFn =
 			typeof this.options.parse === "function"
 				? this.options.parse
 				: getParseJson();
-		/** @type {Buffer | RawJsonData | undefined} */
+		/** @type {Buffer | JsonValue | undefined} */
 		let data;
 		try {
 			data =
@@ -52,18 +54,31 @@ class JsonParser extends Parser {
 					: parseFn(source[0] === "\uFEFF" ? source.slice(1) : source);
 		} catch (err) {
 			throw new Error(
-				`Cannot parse JSON: ${/** @type {Error} */ (err).message}`
+				`Cannot parse JSON: ${/** @type {Error} */ (err).message}`,
+				{ cause: err }
 			);
 		}
-		const jsonData = new JsonData(/** @type {Buffer | RawJsonData} */ (data));
+		const jsonData = new JsonData(/** @type {Buffer | JsonValue} */ (data));
 		const buildInfo = /** @type {BuildInfo} */ (state.module.buildInfo);
 		buildInfo.jsonData = jsonData;
 		buildInfo.strict = true;
 		const buildMeta = /** @type {BuildMeta} */ (state.module.buildMeta);
 		buildMeta.exportsType = "default";
 		buildMeta.defaultObject =
-			typeof data === "object" ? "redirect-warn" : false;
-		state.module.addDependency(new JsonExportsDependency(jsonData));
+			typeof data === "object"
+				? this.options.namedExports === false
+					? false
+					: this.options.namedExports === true
+						? "redirect"
+						: "redirect-warn"
+				: false;
+		state.module.addDependency(
+			new JsonExportsDependency(
+				jsonData,
+				/** @type {number} */
+				(this.options.exportsDepth)
+			)
+		);
 		return state;
 	}
 }