webpack 5.51.2 → 5.54.0

package/lib/InitFragment.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const { ConcatSource } = require("webpack-sources");
+const makeSerializable = require("./util/makeSerializable");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("./Generator").GenerateContext} GenerateContext */
@@ -123,8 +124,30 @@ class InitFragment {
 			return source;
 		}
 	}
+
+	serialize(context) {
+		const { write } = context;
+
+		write(this.content);
+		write(this.stage);
+		write(this.position);
+		write(this.key);
+		write(this.endContent);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+
+		this.content = read();
+		this.stage = read();
+		this.position = read();
+		this.key = read();
+		this.endContent = read();
+	}
 }
 
+makeSerializable(InitFragment, "webpack/lib/InitFragment");
+
 InitFragment.prototype.merge = undefined;
 
 InitFragment.STAGE_CONSTANTS = 10;

package/lib/JavascriptMetaInfoPlugin.js

@@ -28,7 +28,12 @@ class JavascriptMetaInfoPlugin {
 					parser.hooks.call.for("eval").tap("JavascriptMetaInfoPlugin", () => {
 						parser.state.module.buildInfo.moduleConcatenationBailout = "eval()";
 						parser.state.module.buildInfo.usingEval = true;
-						InnerGraph.bailout(parser.state);
+						const currentSymbol = InnerGraph.getTopLevelSymbol(parser.state);
+						if (currentSymbol) {
+							InnerGraph.addUsage(parser.state, null, currentSymbol);
+						} else {
+							InnerGraph.bailout(parser.state);
+						}
 					});
 					parser.hooks.finish.tap("JavascriptMetaInfoPlugin", () => {
 						let topLevelDeclarations =

package/lib/MemCache.js

@@ -0,0 +1,45 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const WeakTupleMap = require("./util/WeakTupleMap");
+
+class MemCache {
+	constructor() {
+		this._cache = new WeakTupleMap();
+	}
+
+	/**
+	 * @template {any[]} T
+	 * @template V
+	 * @param {T} args arguments
+	 * @returns {V | undefined} cached value
+	 */
+	get(...args) {
+		return this._cache.get(...args);
+	}
+
+	/**
+	 * @template {[...any[], any]} T
+	 * @param {T} args arguments
+	 * @returns {void}
+	 */
+	set(...args) {
+		this._cache.set(...args);
+	}
+
+	/**
+	 * @template {[...any[], (...args: any[]) => V]} T
+	 * @template V
+	 * @param {T} args arguments
+	 * @returns {V} computed value or cached
+	 */
+	provide(...args) {
+		return this._cache.provide(...args);
+	}
+}
+
+module.exports = MemCache;

package/lib/ModuleFilenameHelpers.js

@@ -8,6 +8,11 @@
 const createHash = require("./util/createHash");
 const memoize = require("./util/memoize");
 
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {typeof import("./util/Hash")} Hash */
+
 const ModuleFilenameHelpers = exports;
 
 // TODO webpack 6: consider removing these
@@ -53,9 +58,9 @@ const getBefore = (strFn, token) => {
 	};
 };
 
-const getHash = strFn => {
+const getHash = (strFn, hashFunction) => {
 	return () => {
-		const hash = createHash("md4");
+		const hash = createHash(hashFunction);
 		hash.update(strFn());
 		const digest = /** @type {string} */ (hash.digest("hex"));
 		return digest.substr(0, 4);
@@ -91,10 +96,20 @@ const lazyObject = obj => {
 
 const REGEXP = /\[\\*([\w-]+)\\*\]/gi;
 
+/**
+ *
+ * @param {Module | string} module the module
+ * @param {TODO} options options
+ * @param {Object} contextInfo context info
+ * @param {RequestShortener} contextInfo.requestShortener requestShortener
+ * @param {ChunkGraph} contextInfo.chunkGraph chunk graph
+ * @param {string | Hash} contextInfo.hashFunction the hash function to use
+ * @returns {string} the filename
+ */
 ModuleFilenameHelpers.createFilename = (
-	module,
+	module = "",
 	options,
-	{ requestShortener, chunkGraph }
+	{ requestShortener, chunkGraph, hashFunction = "md4" }
 ) => {
 	const opts = {
 		namespace: "",
@@ -111,13 +126,12 @@ ModuleFilenameHelpers.createFilename = (
 	let identifier;
 	let moduleId;
 	let shortIdentifier;
-	if (module === undefined) module = "";
 	if (typeof module === "string") {
 		shortIdentifier = memoize(() => requestShortener.shorten(module));
 		identifier = shortIdentifier;
 		moduleId = () => "";
 		absoluteResourcePath = () => module.split("!").pop();
-		hash = getHash(identifier);
+		hash = getHash(identifier, hashFunction);
 	} else {
 		shortIdentifier = memoize(() =>
 			module.readableIdentifier(requestShortener)
@@ -125,7 +139,7 @@ ModuleFilenameHelpers.createFilename = (
 		identifier = memoize(() => requestShortener.shorten(module.identifier()));
 		moduleId = () => chunkGraph.getModuleId(module);
 		absoluteResourcePath = () => module.identifier().split("!").pop();
-		hash = getHash(identifier);
+		hash = getHash(identifier, hashFunction);
 	}
 	const resource = memoize(() => shortIdentifier().split("!").pop());
 

package/lib/NodeStuffInWebError.js

@@ -0,0 +1,34 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+const makeSerializable = require("./util/makeSerializable");
+
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+
+class NodeStuffInWebError extends WebpackError {
+	/**
+	 * @param {DependencyLocation} loc loc
+	 * @param {string} expression expression
+	 * @param {string} description description
+	 */
+	constructor(loc, expression, description) {
+		super(
+			`${JSON.stringify(
+				expression
+			)} has been used, it will be undefined in next major version.
+${description}`
+		);
+
+		this.name = "NodeStuffInWebError";
+		this.loc = loc;
+	}
+}
+
+makeSerializable(NodeStuffInWebError, "webpack/lib/NodeStuffInWebError");
+
+module.exports = NodeStuffInWebError;

package/lib/NodeStuffPlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const NodeStuffInWebError = require("./NodeStuffInWebError");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const CachedConstDependency = require("./dependencies/CachedConstDependency");
 const ConstDependency = require("./dependencies/ConstDependency");
@@ -44,7 +45,8 @@ class NodeStuffPlugin {
 						localOptions = { ...localOptions, ...parserOptions.node };
 					}
 
-					if (localOptions.global) {
+					if (localOptions.global !== false) {
+						const withWarning = localOptions.global === "warn";
 						parser.hooks.expression
 							.for("global")
 							.tap("NodeStuffPlugin", expr => {
@@ -55,10 +57,21 @@ class NodeStuffPlugin {
 								);
 								dep.loc = expr.loc;
 								parser.state.module.addPresentationalDependency(dep);
+
+								// TODO webpack 6 remove
+								if (withWarning) {
+									parser.state.module.addWarning(
+										new NodeStuffInWebError(
+											dep.loc,
+											"global",
+											"The global namespace object is Node.js feature and doesn't present in browser."
+										)
+									);
+								}
 							});
 					}
 
-					const setModuleConstant = (expressionName, fn) => {
+					const setModuleConstant = (expressionName, fn, warning) => {
 						parser.hooks.expression
 							.for(expressionName)
 							.tap("NodeStuffPlugin", expr => {
@@ -69,22 +82,41 @@ class NodeStuffPlugin {
 								);
 								dep.loc = expr.loc;
 								parser.state.module.addPresentationalDependency(dep);
+
+								// TODO webpack 6 remove
+								if (warning) {
+									parser.state.module.addWarning(
+										new NodeStuffInWebError(dep.loc, expressionName, warning)
+									);
+								}
+
 								return true;
 							});
 					};
 
-					const setConstant = (expressionName, value) =>
-						setModuleConstant(expressionName, () => value);
+					const setConstant = (expressionName, value, warning) =>
+						setModuleConstant(expressionName, () => value, warning);
 
 					const context = compiler.context;
 					if (localOptions.__filename) {
-						if (localOptions.__filename === "mock") {
-							setConstant("__filename", "/index.js");
-						} else if (localOptions.__filename === true) {
-							setModuleConstant("__filename", module =>
-								relative(compiler.inputFileSystem, context, module.resource)
-							);
+						switch (localOptions.__filename) {
+							case "mock":
+								setConstant("__filename", "/index.js");
+								break;
+							case "warn-mock":
+								setConstant(
+									"__filename",
+									"/index.js",
+									"The __filename is Node.js feature and doesn't present in browser."
+								);
+								break;
+							case true:
+								setModuleConstant("__filename", module =>
+									relative(compiler.inputFileSystem, context, module.resource)
+								);
+								break;
 						}
+
 						parser.hooks.evaluateIdentifier
 							.for("__filename")
 							.tap("NodeStuffPlugin", expr => {
@@ -94,13 +126,24 @@ class NodeStuffPlugin {
 							});
 					}
 					if (localOptions.__dirname) {
-						if (localOptions.__dirname === "mock") {
-							setConstant("__dirname", "/");
-						} else if (localOptions.__dirname === true) {
-							setModuleConstant("__dirname", module =>
-								relative(compiler.inputFileSystem, context, module.context)
-							);
+						switch (localOptions.__dirname) {
+							case "mock":
+								setConstant("__dirname", "/");
+								break;
+							case "warn-mock":
+								setConstant(
+									"__dirname",
+									"/",
+									"The __dirname is Node.js feature and doesn't present in browser."
+								);
+								break;
+							case true:
+								setModuleConstant("__dirname", module =>
+									relative(compiler.inputFileSystem, context, module.context)
+								);
+								break;
 						}
+
 						parser.hooks.evaluateIdentifier
 							.for("__dirname")
 							.tap("NodeStuffPlugin", expr => {

package/lib/NormalModuleFactory.js

@@ -540,15 +540,18 @@ class NormalModuleFactory extends ModuleFactory {
 						for (const loader of preLoaders) allLoaders.push(loader);
 						let type = settings.type;
 						if (!type) {
-							const resource =
-								(matchResourceData && matchResourceData.resource) ||
-								resourceData.resource;
+							let resource;
 							let match;
 							if (
-								typeof resource === "string" &&
+								matchResourceData &&
+								typeof (resource = matchResourceData.resource) === "string" &&
 								(match = /\.webpack\[([^\]]+)\]$/.exec(resource))
 							) {
 								type = match[1];
+								matchResourceData.resource = matchResourceData.resource.slice(
+									0,
+									-type.length - 10
+								);
 							} else {
 								type = "javascript/auto";
 							}

package/lib/SourceMapDevToolPlugin.js

@@ -297,7 +297,8 @@ class SourceMapDevToolPlugin {
 													},
 													{
 														requestShortener,
-														chunkGraph
+														chunkGraph,
+														hashFunction: compilation.outputOptions.hashFunction
 													}
 												)
 											);
@@ -358,7 +359,8 @@ class SourceMapDevToolPlugin {
 									},
 									{
 										requestShortener,
-										chunkGraph
+										chunkGraph,
+										hashFunction: compilation.outputOptions.hashFunction
 									}
 								);
 								hasName = usedNamesSet.has(sourceName);
@@ -442,7 +444,9 @@ class SourceMapDevToolPlugin {
 										const sourceMapContentHash =
 											usesContentHash &&
 											/** @type {string} */ (
-												createHash("md4").update(sourceMapString).digest("hex")
+												createHash(compilation.outputOptions.hashFunction)
+													.update(sourceMapString)
+													.digest("hex")
 											);
 										const pathParams = {
 											chunk,

package/lib/WebpackOptionsApply.js

@@ -305,9 +305,7 @@ class WebpackOptionsApply extends OptionsApply {
 			new RequireJsStuffPlugin().apply(compiler);
 		}
 		new CommonJsPlugin().apply(compiler);
-		new LoaderPlugin({
-			enableExecuteModule: options.experiments.executeModule
-		}).apply(compiler);
+		new LoaderPlugin({}).apply(compiler);
 		if (options.node !== false) {
 			const NodeStuffPlugin = require("./NodeStuffPlugin");
 			new NodeStuffPlugin(options.node).apply(compiler);
@@ -433,7 +431,9 @@ class WebpackOptionsApply extends OptionsApply {
 						"hashed",
 						"deterministic"
 					).apply(compiler);
-					new HashedModuleIdsPlugin().apply(compiler);
+					new HashedModuleIdsPlugin({
+						hashFunction: options.output.hashFunction
+					}).apply(compiler);
 					break;
 				}
 				case "deterministic": {
@@ -544,6 +544,14 @@ class WebpackOptionsApply extends OptionsApply {
 						const MemoryCachePlugin = require("./cache/MemoryCachePlugin");
 						new MemoryCachePlugin().apply(compiler);
 					}
+					if (cacheOptions.cacheUnaffected) {
+						if (!options.experiments.cacheUnaffected) {
+							throw new Error(
+								"'cache.cacheUnaffected: true' is only allowed when 'experiments.cacheUnaffected' is enabled"
+							);
+						}
+						compiler.moduleMemCaches = new WeakMap();
+					}
 					break;
 				}
 				case "filesystem": {
@@ -563,6 +571,14 @@ class WebpackOptionsApply extends OptionsApply {
 							maxGenerations: cacheOptions.maxMemoryGenerations
 						}).apply(compiler);
 					}
+					if (cacheOptions.memoryCacheUnaffected) {
+						if (!options.experiments.cacheUnaffected) {
+							throw new Error(
+								"'cache.memoryCacheUnaffected: true' is only allowed when 'experiments.cacheUnaffected' is enabled"
+							);
+						}
+						compiler.moduleMemCaches = new WeakMap();
+					}
 					switch (cacheOptions.store) {
 						case "pack": {
 							const IdleFileCachePlugin = require("./cache/IdleFileCachePlugin");