webpack 5.33.0 → 5.35.0

package/lib/BannerPlugin.js

@@ -5,18 +5,25 @@
 
 "use strict";
 
-const { validate } = require("schema-utils");
 const { ConcatSource } = require("webpack-sources");
 const Compilation = require("./Compilation");
 const ModuleFilenameHelpers = require("./ModuleFilenameHelpers");
 const Template = require("./Template");
-
-const schema = require("../schemas/plugins/BannerPlugin.json");
+const createSchemaValidation = require("./util/create-schema-validation");
 
 /** @typedef {import("../declarations/plugins/BannerPlugin").BannerPluginArgument} BannerPluginArgument */
 /** @typedef {import("../declarations/plugins/BannerPlugin").BannerPluginOptions} BannerPluginOptions */
 /** @typedef {import("./Compiler")} Compiler */
 
+const validate = createSchemaValidation(
+	require("../schemas/plugins/BannerPlugin.check.js"),
+	() => require("../schemas/plugins/BannerPlugin.json"),
+	{
+		name: "Banner Plugin",
+		baseDataPath: "options"
+	}
+);
+
 const wrapComment = str => {
 	if (!str.includes("\n")) {
 		return Template.toComment(str);
@@ -40,10 +47,7 @@ class BannerPlugin {
 			};
 		}
 
-		validate(schema, options, {
-			name: "Banner Plugin",
-			baseDataPath: "options"
-		});
+		validate(options);
 
 		this.options = options;
 

package/lib/ChunkGraph.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const util = require("util");
+const Entrypoint = require("./Entrypoint");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
 const { first } = require("./util/SetHelpers");
 const SortableSet = require("./util/SortableSet");
@@ -31,7 +32,6 @@ const {
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./Entrypoint")} Entrypoint */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./RuntimeModule")} RuntimeModule */
@@ -1042,16 +1042,22 @@ class ChunkGraph {
 	 * @returns {Iterable<Chunk>} iterable of chunks
 	 */
 	getChunkEntryDependentChunksIterable(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
 		/** @type {Set<Chunk>} */
 		const set = new Set();
-		for (const chunkGroup of cgc.entryModules.values()) {
-			for (const c of chunkGroup.chunks) {
-				if (c !== chunk && !c.hasRuntime()) {
-					set.add(c);
+		for (const chunkGroup of chunk.groupsIterable) {
+			if (chunkGroup instanceof Entrypoint) {
+				const entrypointChunk = chunkGroup.getEntrypointChunk();
+				const cgc = this._getChunkGraphChunk(entrypointChunk);
+				for (const chunkGroup of cgc.entryModules.values()) {
+					for (const c of chunkGroup.chunks) {
+						if (c !== chunk && c !== entrypointChunk && !c.hasRuntime()) {
+							set.add(c);
+						}
+					}
 				}
 			}
 		}
+
 		return set;
 	}
 

package/lib/CleanPlugin.js

@@ -6,11 +6,10 @@
 "use strict";
 
 const asyncLib = require("neo-async");
-const { validate } = require("schema-utils");
 const { SyncBailHook } = require("tapable");
 const Compilation = require("../lib/Compilation");
+const createSchemaValidation = require("./util/create-schema-validation");
 const { join } = require("./util/fs");
-const memoize = require("./util/memoize");
 const processAsyncTree = require("./util/processAsyncTree");
 
 /** @typedef {import("../declarations/WebpackOptions").CleanOptions} CleanOptions */
@@ -26,13 +25,20 @@ const processAsyncTree = require("./util/processAsyncTree");
  * @property {SyncBailHook<[string], boolean>} keep when returning true the file/directory will be kept during cleaning, returning false will clean it and ignore the following plugins and config
  */
 
-const getSchema = memoize(() => {
-	const { definitions } = require("../schemas/WebpackOptions.json");
-	return {
-		definitions,
-		oneOf: [{ $ref: "#/definitions/CleanOptions" }]
-	};
-});
+const validate = createSchemaValidation(
+	undefined,
+	() => {
+		const { definitions } = require("../schemas/WebpackOptions.json");
+		return {
+			definitions,
+			oneOf: [{ $ref: "#/definitions/CleanOptions" }]
+		};
+	},
+	{
+		name: "Clean Plugin",
+		baseDataPath: "options"
+	}
+);
 
 /**
  * @param {OutputFileSystem} fs filesystem
@@ -255,13 +261,9 @@ class CleanPlugin {
 		return hooks;
 	}
 
-	/** @param {CleanOptions} [options] options */
+	/** @param {CleanOptions} options options */
 	constructor(options = {}) {
-		validate(getSchema(), options, {
-			name: "Clean Plugin",
-			baseDataPath: "options"
-		});
-
+		validate(options);
 		this.options = { dry: false, ...options };
 	}
 

package/lib/Compilation.js

@@ -4035,7 +4035,7 @@ This prevents using hashes of each other and should be avoided.`);
 
 				const entrypoint = new Entrypoint({
 					runtime,
-					chunkLoading: "none",
+					chunkLoading: false,
 					...options.entryOptions
 				});
 				chunkGraph.connectChunkAndEntryModule(chunk, module, entrypoint);

package/lib/DllPlugin.js

@@ -8,22 +8,26 @@
 const DllEntryPlugin = require("./DllEntryPlugin");
 const FlagAllModulesAsUsedPlugin = require("./FlagAllModulesAsUsedPlugin");
 const LibManifestPlugin = require("./LibManifestPlugin");
-
-const { validate } = require("schema-utils");
-const schema = require("../schemas/plugins/DllPlugin.json");
+const createSchemaValidation = require("./util/create-schema-validation");
 
 /** @typedef {import("../declarations/plugins/DllPlugin").DllPluginOptions} DllPluginOptions */
 /** @typedef {import("./Compiler")} Compiler */
 
+const validate = createSchemaValidation(
+	require("../schemas/plugins/DllPlugin.check.js"),
+	() => require("../schemas/plugins/DllPlugin.json"),
+	{
+		name: "Dll Plugin",
+		baseDataPath: "options"
+	}
+);
+
 class DllPlugin {
 	/**
 	 * @param {DllPluginOptions} options options object
 	 */
 	constructor(options) {
-		validate(schema, options, {
-			name: "Dll Plugin",
-			baseDataPath: "options"
-		});
+		validate(options);
 		this.options = {
 			...options,
 			entryOnly: options.entryOnly !== false

package/lib/DllReferencePlugin.js

@@ -10,24 +10,28 @@ const DelegatedModuleFactoryPlugin = require("./DelegatedModuleFactoryPlugin");
 const ExternalModuleFactoryPlugin = require("./ExternalModuleFactoryPlugin");
 const WebpackError = require("./WebpackError");
 const DelegatedSourceDependency = require("./dependencies/DelegatedSourceDependency");
+const createSchemaValidation = require("./util/create-schema-validation");
 const makePathsRelative = require("./util/identifier").makePathsRelative;
 
-const { validate } = require("schema-utils");
-const schema = require("../schemas/plugins/DllReferencePlugin.json");
-
 /** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
 /** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptions} DllReferencePluginOptions */
 /** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptionsManifest} DllReferencePluginOptionsManifest */
 
+const validate = createSchemaValidation(
+	require("../schemas/plugins/DllReferencePlugin.check.js"),
+	() => require("../schemas/plugins/DllReferencePlugin.json"),
+	{
+		name: "Dll Reference Plugin",
+		baseDataPath: "options"
+	}
+);
+
 class DllReferencePlugin {
 	/**
 	 * @param {DllReferencePluginOptions} options options object
 	 */
 	constructor(options) {
-		validate(schema, options, {
-			name: "Dll Reference Plugin",
-			baseDataPath: "options"
-		});
+		validate(options);
 		this.options = options;
 		/** @type {WeakMap<Object, {path: string, data: DllReferencePluginOptionsManifest?, error: Error?}>} */
 		this._compilationData = new WeakMap();

package/lib/FileSystemInfo.js

@@ -77,6 +77,92 @@ const DONE_ITERATOR_RESULT = new Set().keys().next();
 // Tsh = Timestamp + Hash
 // Tshs = Timestamp + Hash combinations
 
+class SnapshotIterator {
+	constructor(next) {
+		this.next = next;
+	}
+}
+
+class SnapshotIterable {
+	constructor(snapshot, getMaps) {
+		this.snapshot = snapshot;
+		this.getMaps = getMaps;
+	}
+
+	[Symbol.iterator]() {
+		let state = 0;
+		/** @type {IterableIterator<string>} */
+		let it;
+		/** @type {(Snapshot) => (Map<string, any> | Set<string>)[]} */
+		let getMaps;
+		/** @type {(Map<string, any> | Set<string>)[]} */
+		let maps;
+		/** @type {Snapshot} */
+		let snapshot;
+		let queue;
+		return new SnapshotIterator(() => {
+			for (;;) {
+				switch (state) {
+					case 0:
+						snapshot = this.snapshot;
+						getMaps = this.getMaps;
+						maps = getMaps(snapshot);
+						state = 1;
+					/* falls through */
+					case 1:
+						if (maps.length > 0) {
+							const map = maps.pop();
+							if (map !== undefined) {
+								it = map.keys();
+								state = 2;
+							} else {
+								break;
+							}
+						} else {
+							state = 3;
+							break;
+						}
+					/* falls through */
+					case 2: {
+						const result = it.next();
+						if (!result.done) return result;
+						state = 1;
+						break;
+					}
+					case 3: {
+						const children = snapshot.children;
+						if (children !== undefined) {
+							if (children.size === 1) {
+								// shortcut for a single child
+								// avoids allocation of queue
+								for (const child of children) snapshot = child;
+								maps = getMaps(snapshot);
+								state = 1;
+								break;
+							}
+							if (queue === undefined) queue = [];
+							for (const child of children) {
+								queue.push(child);
+							}
+						}
+						if (queue !== undefined && queue.length > 0) {
+							snapshot = queue.pop();
+							maps = getMaps(snapshot);
+							state = 1;
+							break;
+						} else {
+							state = 4;
+						}
+					}
+					/* falls through */
+					case 4:
+						return DONE_ITERATOR_RESULT;
+				}
+			}
+		});
+	}
+}
+
 class Snapshot {
 	constructor() {
 		this._flags = 0;
@@ -283,63 +369,7 @@ class Snapshot {
 	 * @returns {Iterable<string>} iterable
 	 */
 	_createIterable(getMaps) {
-		let snapshot = this;
-		return {
-			[Symbol.iterator]() {
-				let state = 0;
-				/** @type {IterableIterator<string>} */
-				let it;
-				let maps = getMaps(snapshot);
-				const queue = [];
-				return {
-					next() {
-						for (;;) {
-							switch (state) {
-								case 0:
-									if (maps.length > 0) {
-										const map = maps.pop();
-										if (map !== undefined) {
-											it = map.keys();
-											state = 1;
-										} else {
-											break;
-										}
-									} else {
-										state = 2;
-										break;
-									}
-								/* falls through */
-								case 1: {
-									const result = it.next();
-									if (!result.done) return result;
-									state = 0;
-									break;
-								}
-								case 2: {
-									const children = snapshot.children;
-									if (children !== undefined) {
-										for (const child of children) {
-											queue.push(child);
-										}
-									}
-									if (queue.length > 0) {
-										snapshot = queue.pop();
-										maps = getMaps(snapshot);
-										state = 0;
-										break;
-									} else {
-										state = 3;
-									}
-								}
-								/* falls through */
-								case 3:
-									return DONE_ITERATOR_RESULT;
-							}
-						}
-					}
-				};
-			}
-		};
+		return new SnapshotIterable(this, getMaps);
 	}
 
 	/**
@@ -1219,7 +1249,7 @@ class FileSystemInfo {
 						return callback();
 					}
 					resolveResults.set(key, undefined);
-					resolveContext(context, path, resolverContext, (err, result) => {
+					resolveContext(context, path, resolverContext, (err, _, result) => {
 						if (err) {
 							if (expected === false) {
 								resolveResults.set(key, false);
@@ -1229,11 +1259,12 @@ class FileSystemInfo {
 							err.message += `\nwhile resolving '${path}' in ${context} to a directory`;
 							return callback(err);
 						}
-						resolveResults.set(key, result);
+						const resultPath = result.path;
+						resolveResults.set(key, resultPath);
 						push({
 							type: RBDT_DIRECTORY,
 							context: undefined,
-							path: result,
+							path: resultPath,
 							expected: undefined,
 							issuer: job
 						});
@@ -1246,14 +1277,16 @@ class FileSystemInfo {
 						return callback();
 					}
 					resolveResults.set(key, undefined);
-					resolve(context, path, resolverContext, (err, result) => {
+					resolve(context, path, resolverContext, (err, _, result) => {
 						if (typeof expected === "string") {
-							if (result === expected) {
-								resolveResults.set(key, result);
+							if (!err && result && result.path === expected) {
+								resolveResults.set(key, result.path);
 							} else {
 								invalidResolveResults.add(key);
 								this.logger.warn(
-									`Resolving '${path}' in ${context} for build dependencies doesn't lead to expected result '${expected}', but to '${result}' instead. Resolving dependencies are ignored for this path.\n${pathToString(
+									`Resolving '${path}' in ${context} for build dependencies doesn't lead to expected result '${expected}', but to '${
+										err || (result && result.path)
+									}' instead. Resolving dependencies are ignored for this path.\n${pathToString(
 										job
 									)}`
 								);
@@ -1270,11 +1303,12 @@ class FileSystemInfo {
 								)}`;
 								return callback(err);
 							}
-							resolveResults.set(key, result);
+							const resultPath = result.path;
+							resolveResults.set(key, resultPath);
 							push({
 								type: RBDT_FILE,
 								context: undefined,
-								path: result,
+								path: resultPath,
 								expected: undefined,
 								issuer: job
 							});
@@ -1616,38 +1650,42 @@ class FileSystemInfo {
 				const [type, context, path] = key.split("\n");
 				switch (type) {
 					case "d":
-						resolveContext(context, path, {}, (err, result) => {
+						resolveContext(context, path, {}, (err, _, result) => {
 							if (expectedResult === false)
 								return callback(err ? undefined : INVALID);
 							if (err) return callback(err);
-							if (result !== expectedResult) return callback(INVALID);
+							const resultPath = result.path;
+							if (resultPath !== expectedResult) return callback(INVALID);
 							callback();
 						});
 						break;
 					case "f":
-						resolveCjs(context, path, {}, (err, result) => {
+						resolveCjs(context, path, {}, (err, _, result) => {
 							if (expectedResult === false)
 								return callback(err ? undefined : INVALID);
 							if (err) return callback(err);
-							if (result !== expectedResult) return callback(INVALID);
+							const resultPath = result.path;
+							if (resultPath !== expectedResult) return callback(INVALID);
 							callback();
 						});
 						break;
 					case "c":
-						resolveCjsAsChild(context, path, {}, (err, result) => {
+						resolveCjsAsChild(context, path, {}, (err, _, result) => {
 							if (expectedResult === false)
 								return callback(err ? undefined : INVALID);
 							if (err) return callback(err);
-							if (result !== expectedResult) return callback(INVALID);
+							const resultPath = result.path;
+							if (resultPath !== expectedResult) return callback(INVALID);
 							callback();
 						});
 						break;
 					case "e":
-						resolveEsm(context, path, {}, (err, result) => {
+						resolveEsm(context, path, {}, (err, _, result) => {
 							if (expectedResult === false)
 								return callback(err ? undefined : INVALID);
 							if (err) return callback(err);
-							if (result !== expectedResult) return callback(INVALID);
+							const resultPath = result.path;
+							if (resultPath !== expectedResult) return callback(INVALID);
 							callback();
 						});
 						break;

package/lib/IgnorePlugin.js

@@ -5,22 +5,27 @@
 
 "use strict";
 
-const { validate } = require("schema-utils");
-const schema = require("../schemas/plugins/IgnorePlugin.json");
+const createSchemaValidation = require("./util/create-schema-validation");
 
 /** @typedef {import("../declarations/plugins/IgnorePlugin").IgnorePluginOptions} IgnorePluginOptions */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./NormalModuleFactory").ResolveData} ResolveData */
 
+const validate = createSchemaValidation(
+	require("../schemas/plugins/IgnorePlugin.check.js"),
+	() => require("../schemas/plugins/IgnorePlugin.json"),
+	{
+		name: "Ignore Plugin",
+		baseDataPath: "options"
+	}
+);
+
 class IgnorePlugin {
 	/**
 	 * @param {IgnorePluginOptions} options IgnorePlugin options
 	 */
 	constructor(options) {
-		validate(schema, options, {
-			name: "Ignore Plugin",
-			baseDataPath: "options"
-		});
+		validate(options);
 		this.options = options;
 
 		/** @private @type {Function} */

package/lib/LoaderOptionsPlugin.js

@@ -7,22 +7,25 @@
 
 const ModuleFilenameHelpers = require("./ModuleFilenameHelpers");
 const NormalModule = require("./NormalModule");
-
-const { validate } = require("schema-utils");
-const schema = require("../schemas/plugins/LoaderOptionsPlugin.json");
+const createSchemaValidation = require("./util/create-schema-validation");
 
 /** @typedef {import("../declarations/plugins/LoaderOptionsPlugin").LoaderOptionsPluginOptions} LoaderOptionsPluginOptions */
 /** @typedef {import("./Compiler")} Compiler */
 
+const validate = createSchemaValidation(
+	require("../schemas/plugins/LoaderOptionsPlugin.check.js"),
+	() => require("../schemas/plugins/LoaderOptionsPlugin.json"),
+	{
+		name: "Loader Options Plugin",
+		baseDataPath: "options"
+	}
+);
 class LoaderOptionsPlugin {
 	/**
 	 * @param {LoaderOptionsPluginOptions} options options object
 	 */
 	constructor(options = {}) {
-		validate(schema, options, {
-			name: "Loader Options Plugin",
-			baseDataPath: "options"
-		});
+		validate(options);
 		if (typeof options !== "object") options = {};
 		if (!options.test) {
 			options.test = {

package/lib/NormalModule.js

@@ -8,7 +8,6 @@
 const parseJson = require("json-parse-better-errors");
 const { getContext, runLoaders } = require("loader-runner");
 const querystring = require("querystring");
-const { validate } = require("schema-utils");
 const { HookMap, SyncHook, AsyncSeriesBailHook } = require("tapable");
 const {
 	CachedSource,
@@ -68,6 +67,7 @@ const memoize = require("./util/memoize");
 const getInvalidDependenciesModuleWarning = memoize(() =>
 	require("./InvalidDependenciesModuleWarning")
 );
+const getValidate = memoize(() => require("schema-utils").validate);
 
 const ABSOLUTE_PATH_REGEX = /^([a-zA-Z]:\\|\\\\|\/)/;
 
@@ -499,7 +499,7 @@ class NormalModule extends Module {
 					if (schema.title && (match = /^(.+) (.+)$/.exec(schema.title))) {
 						[, name, baseDataPath] = match;
 					}
-					validate(schema, options, {
+					getValidate()(schema, options, {
 						name,
 						baseDataPath
 					});

package/lib/ProgressPlugin.js

@@ -5,17 +5,24 @@
 
 "use strict";
 
-const { validate } = require("schema-utils");
-const schema = require("../schemas/plugins/ProgressPlugin.json");
 const Compiler = require("./Compiler");
 const MultiCompiler = require("./MultiCompiler");
 const NormalModule = require("./NormalModule");
+const createSchemaValidation = require("./util/create-schema-validation");
 const { contextify } = require("./util/identifier");
 
 /** @typedef {import("../declarations/plugins/ProgressPlugin").HandlerFunction} HandlerFunction */
 /** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginArgument} ProgressPluginArgument */
 /** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginOptions} ProgressPluginOptions */
 
+const validate = createSchemaValidation(
+	require("../schemas/plugins/ProgressPlugin.check.js"),
+	() => require("../schemas/plugins/ProgressPlugin.json"),
+	{
+		name: "Progress Plugin",
+		baseDataPath: "options"
+	}
+);
 const median3 = (a, b, c) => {
 	return a + b + c - Math.max(a, b, c) - Math.min(a, b, c);
 };
@@ -115,10 +122,7 @@ class ProgressPlugin {
 			};
 		}
 
-		validate(schema, options, {
-			name: "Progress Plugin",
-			baseDataPath: "options"
-		});
+		validate(options);
 		options = { ...ProgressPlugin.defaultOptions, ...options };
 
 		this.profile = options.profile;

package/lib/RuntimePlugin.js

@@ -179,7 +179,9 @@ class RuntimePlugin {
 					const { publicPath: globalPublicPath, scriptType } = outputOptions;
 					const entryOptions = chunk.getEntryOptions();
 					const publicPath =
-						(entryOptions && entryOptions.publicPath) || globalPublicPath;
+						entryOptions && entryOptions.publicPath !== undefined
+							? entryOptions.publicPath
+							: globalPublicPath;
 
 					if (publicPath === "auto") {
 						const module = new AutoPublicPathRuntimeModule();

package/lib/SourceMapDevToolPlugin.js

@@ -6,18 +6,16 @@
 "use strict";
 
 const asyncLib = require("neo-async");
-const { validate } = require("schema-utils");
 const { ConcatSource, RawSource } = require("webpack-sources");
 const Compilation = require("./Compilation");
 const ModuleFilenameHelpers = require("./ModuleFilenameHelpers");
 const ProgressPlugin = require("./ProgressPlugin");
 const SourceMapDevToolModuleOptionsPlugin = require("./SourceMapDevToolModuleOptionsPlugin");
+const createSchemaValidation = require("./util/create-schema-validation");
 const createHash = require("./util/createHash");
 const { relative, dirname } = require("./util/fs");
 const { absolutify } = require("./util/identifier");
 
-const schema = require("../schemas/plugins/SourceMapDevToolPlugin.json");
-
 /** @typedef {import("source-map").RawSourceMap} SourceMap */
 /** @typedef {import("webpack-sources").MapOptions} MapOptions */
 /** @typedef {import("webpack-sources").Source} Source */
@@ -30,6 +28,14 @@ const schema = require("../schemas/plugins/SourceMapDevToolPlugin.json");
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./util/Hash")} Hash */
 
+const validate = createSchemaValidation(
+	require("../schemas/plugins/SourceMapDevToolPlugin.check.js"),
+	() => require("../schemas/plugins/SourceMapDevToolPlugin.json"),
+	{
+		name: "SourceMap DevTool Plugin",
+		baseDataPath: "options"
+	}
+);
 /**
  * @typedef {object} SourceMapTask
  * @property {Source} asset
@@ -110,10 +116,7 @@ class SourceMapDevToolPlugin {
 	 * @throws {Error} throws error, if got more than 1 arguments
 	 */
 	constructor(options = {}) {
-		validate(schema, options, {
-			name: "SourceMap DevTool Plugin",
-			baseDataPath: "options"
-		});
+		validate(options);
 
 		/** @type {string | false} */
 		this.sourceMapFilename = options.filename;