webpack 5.59.0 → 5.94.0

package/lib/Watching.js

@@ -11,11 +11,16 @@ const Stats = require("./Stats");
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
+/** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./logging/Logger").Logger} Logger */
+/** @typedef {import("./util/fs").TimeInfoEntries} TimeInfoEntries */
+/** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
+/** @typedef {import("./util/fs").Watcher} Watcher */
 
 /**
  * @template T
  * @callback Callback
- * @param {Error=} err
+ * @param {Error | null} err
  * @param {T=} result
  */
 
@@ -40,16 +45,19 @@ class Watching {
 		this._onChange = () => {};
 		this._onInvalid = () => {};
 		if (typeof watchOptions === "number") {
+			/** @type {WatchOptions} */
 			this.watchOptions = {
 				aggregateTimeout: watchOptions
 			};
 		} else if (watchOptions && typeof watchOptions === "object") {
+			/** @type {WatchOptions} */
 			this.watchOptions = { ...watchOptions };
 		} else {
+			/** @type {WatchOptions} */
 			this.watchOptions = {};
 		}
 		if (typeof this.watchOptions.aggregateTimeout !== "number") {
-			this.watchOptions.aggregateTimeout = 200;
+			this.watchOptions.aggregateTimeout = 20;
 		}
 		this.compiler = compiler;
 		this.running = false;
@@ -58,9 +66,9 @@ class Watching {
 		this._needRecords = true;
 		this.watcher = undefined;
 		this.pausedWatcher = undefined;
-		/** @type {Set<string>} */
+		/** @type {Set<string> | undefined} */
 		this._collectedChangedFiles = undefined;
-		/** @type {Set<string>} */
+		/** @type {Set<string> | undefined} */
 		this._collectedRemovedFiles = undefined;
 		this._done = this._done.bind(this);
 		process.nextTick(() => {
@@ -69,8 +77,8 @@ class Watching {
 	}
 
 	/**
-	 * @param {ReadonlySet<string>} changedFiles changed files
-	 * @param {ReadonlySet<string>} removedFiles removed files
+	 * @param {ReadonlySet<string>=} changedFiles changed files
+	 * @param {ReadonlySet<string>=} removedFiles removed files
 	 */
 	_mergeWithCollected(changedFiles, removedFiles) {
 		if (!changedFiles) return;
@@ -80,18 +88,20 @@ class Watching {
 		} else {
 			for (const file of changedFiles) {
 				this._collectedChangedFiles.add(file);
-				this._collectedRemovedFiles.delete(file);
+				/** @type {Set<string>} */
+				(this._collectedRemovedFiles).delete(file);
 			}
-			for (const file of removedFiles) {
+			for (const file of /** @type {ReadonlySet<string>} */ (removedFiles)) {
 				this._collectedChangedFiles.delete(file);
-				this._collectedRemovedFiles.add(file);
+				/** @type {Set<string>} */
+				(this._collectedRemovedFiles).add(file);
 			}
 		}
 	}
 
 	/**
-	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore">=} fileTimeInfoEntries info for files
-	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore">=} contextTimeInfoEntries info for directories
+	 * @param {TimeInfoEntries=} fileTimeInfoEntries info for files
+	 * @param {TimeInfoEntries=} contextTimeInfoEntries info for directories
 	 * @param {ReadonlySet<string>=} changedFiles changed files
 	 * @param {ReadonlySet<string>=} removedFiles removed files
 	 * @returns {void}
@@ -109,30 +119,44 @@ class Watching {
 			this.lastWatcherStartTime = Date.now();
 		}
 		this.compiler.fsStartTime = Date.now();
-		this._mergeWithCollected(
-			changedFiles ||
-				(this.pausedWatcher &&
+		if (
+			changedFiles &&
+			removedFiles &&
+			fileTimeInfoEntries &&
+			contextTimeInfoEntries
+		) {
+			this._mergeWithCollected(changedFiles, removedFiles);
+			this.compiler.fileTimestamps = fileTimeInfoEntries;
+			this.compiler.contextTimestamps = contextTimeInfoEntries;
+		} else if (this.pausedWatcher) {
+			if (this.pausedWatcher.getInfo) {
+				const {
+					changes,
+					removals,
+					fileTimeInfoEntries,
+					contextTimeInfoEntries
+				} = this.pausedWatcher.getInfo();
+				this._mergeWithCollected(changes, removals);
+				this.compiler.fileTimestamps = fileTimeInfoEntries;
+				this.compiler.contextTimestamps = contextTimeInfoEntries;
+			} else {
+				this._mergeWithCollected(
 					this.pausedWatcher.getAggregatedChanges &&
-					this.pausedWatcher.getAggregatedChanges()),
-			(this.compiler.removedFiles =
-				removedFiles ||
-				(this.pausedWatcher &&
+						this.pausedWatcher.getAggregatedChanges(),
 					this.pausedWatcher.getAggregatedRemovals &&
-					this.pausedWatcher.getAggregatedRemovals()))
-		);
-
+						this.pausedWatcher.getAggregatedRemovals()
+				);
+				this.compiler.fileTimestamps =
+					this.pausedWatcher.getFileTimeInfoEntries();
+				this.compiler.contextTimestamps =
+					this.pausedWatcher.getContextTimeInfoEntries();
+			}
+		}
 		this.compiler.modifiedFiles = this._collectedChangedFiles;
 		this._collectedChangedFiles = undefined;
 		this.compiler.removedFiles = this._collectedRemovedFiles;
 		this._collectedRemovedFiles = undefined;
 
-		this.compiler.fileTimestamps =
-			fileTimeInfoEntries ||
-			(this.pausedWatcher && this.pausedWatcher.getFileTimeInfoEntries());
-		this.compiler.contextTimestamps =
-			contextTimeInfoEntries ||
-			(this.pausedWatcher && this.pausedWatcher.getContextTimeInfoEntries());
-
 		const run = () => {
 			if (this.compiler.idle) {
 				return this.compiler.cache.endIdle(err => {
@@ -153,8 +177,16 @@ class Watching {
 			this._invalidReported = false;
 			this.compiler.hooks.watchRun.callAsync(this.compiler, err => {
 				if (err) return this._done(err);
-				const onCompiled = (err, compilation) => {
-					if (err) return this._done(err, compilation);
+				/**
+				 * @param {Error | null} err error
+				 * @param {Compilation=} _compilation compilation
+				 * @returns {void}
+				 */
+				const onCompiled = (err, _compilation) => {
+					if (err) return this._done(err, _compilation);
+
+					const compilation = /** @type {Compilation} */ (_compilation);
+
 					if (this.invalid) return this._done(null, compilation);
 
 					if (this.compiler.hooks.shouldEmit.call(compilation) === false) {
@@ -177,7 +209,9 @@ class Watching {
 								if (compilation.hooks.needAdditionalPass.call()) {
 									compilation.needAdditionalPass = true;
 
-									compilation.startTime = this.startTime;
+									compilation.startTime = /** @type {number} */ (
+										this.startTime
+									);
 									compilation.endTime = Date.now();
 									logger.time("done hook");
 									const stats = new Stats(compilation);
@@ -214,22 +248,29 @@ class Watching {
 	}
 
 	/**
-	 * @param {Error=} err an optional error
+	 * @param {(Error | null)=} err an optional error
 	 * @param {Compilation=} compilation the compilation
 	 * @returns {void}
 	 */
 	_done(err, compilation) {
 		this.running = false;
 
-		const logger = compilation && compilation.getLogger("webpack.Watching");
+		const logger =
+			/** @type {Logger} */
+			(compilation && compilation.getLogger("webpack.Watching"));
 
-		let stats = null;
+		/** @type {Stats | undefined} */
+		let stats;
 
+		/**
+		 * @param {Error} err error
+		 * @param {Callback<void>[]=} cbs callbacks
+		 */
 		const handleError = (err, cbs) => {
 			this.compiler.hooks.failed.call(err);
 			this.compiler.cache.beginIdle();
 			this.compiler.idle = true;
-			this.handler(err, stats);
+			this.handler(err, /** @type {Stats} */ (stats));
 			if (!cbs) {
 				cbs = this.callbacks;
 				this.callbacks = [];
@@ -260,7 +301,7 @@ class Watching {
 		}
 
 		if (compilation) {
-			compilation.startTime = this.startTime;
+			compilation.startTime = /** @type {number} */ (this.startTime);
 			compilation.endTime = Date.now();
 			stats = new Stats(compilation);
 		}
@@ -270,13 +311,14 @@ class Watching {
 		const cbs = this.callbacks;
 		this.callbacks = [];
 		logger.time("done hook");
-		this.compiler.hooks.done.callAsync(stats, err => {
+		this.compiler.hooks.done.callAsync(/** @type {Stats} */ (stats), err => {
 			logger.timeEnd("done hook");
 			if (err) return handleError(err, cbs);
 			this.handler(null, stats);
 			logger.time("storeBuildDependencies");
 			this.compiler.cache.storeBuildDependencies(
-				compilation.buildDependencies,
+				/** @type {Compilation} */
+				(compilation).buildDependencies,
 				err => {
 					logger.timeEnd("storeBuildDependencies");
 					if (err) return handleError(err, cbs);
@@ -287,14 +329,17 @@ class Watching {
 					process.nextTick(() => {
 						if (!this.closed) {
 							this.watch(
-								compilation.fileDependencies,
-								compilation.contextDependencies,
-								compilation.missingDependencies
+								/** @type {Compilation} */
+								(compilation).fileDependencies,
+								/** @type {Compilation} */
+								(compilation).contextDependencies,
+								/** @type {Compilation} */
+								(compilation).missingDependencies
 							);
 						}
 					});
 					for (const cb of cbs) cb(null);
-					this.compiler.hooks.afterDone.call(stats);
+					this.compiler.hooks.afterDone.call(/** @type {Stats} */ (stats));
 				}
 			);
 		});
@@ -308,43 +353,45 @@ class Watching {
 	 */
 	watch(files, dirs, missing) {
 		this.pausedWatcher = null;
-		this.watcher = this.compiler.watchFileSystem.watch(
-			files,
-			dirs,
-			missing,
-			this.lastWatcherStartTime,
-			this.watchOptions,
-			(
-				err,
-				fileTimeInfoEntries,
-				contextTimeInfoEntries,
-				changedFiles,
-				removedFiles
-			) => {
-				if (err) {
-					this.compiler.modifiedFiles = undefined;
-					this.compiler.removedFiles = undefined;
-					this.compiler.fileTimestamps = undefined;
-					this.compiler.contextTimestamps = undefined;
-					this.compiler.fsStartTime = undefined;
-					return this.handler(err);
-				}
-				this._invalidate(
+		this.watcher =
+			/** @type {WatchFileSystem} */
+			(this.compiler.watchFileSystem).watch(
+				files,
+				dirs,
+				missing,
+				/** @type {number} */ (this.lastWatcherStartTime),
+				this.watchOptions,
+				(
+					err,
 					fileTimeInfoEntries,
 					contextTimeInfoEntries,
 					changedFiles,
 					removedFiles
-				);
-				this._onChange();
-			},
-			(fileName, changeTime) => {
-				if (!this._invalidReported) {
-					this._invalidReported = true;
-					this.compiler.hooks.invalid.call(fileName, changeTime);
+				) => {
+					if (err) {
+						this.compiler.modifiedFiles = undefined;
+						this.compiler.removedFiles = undefined;
+						this.compiler.fileTimestamps = undefined;
+						this.compiler.contextTimestamps = undefined;
+						this.compiler.fsStartTime = undefined;
+						return this.handler(err);
+					}
+					this._invalidate(
+						fileTimeInfoEntries,
+						contextTimeInfoEntries,
+						changedFiles,
+						removedFiles
+					);
+					this._onChange();
+				},
+				(fileName, changeTime) => {
+					if (!this._invalidReported) {
+						this._invalidReported = true;
+						this.compiler.hooks.invalid.call(fileName, changeTime);
+					}
+					this._onInvalid();
 				}
-				this._onInvalid();
-			}
-		);
+			);
 	}
 
 	/**
@@ -363,6 +410,13 @@ class Watching {
 		this._invalidate();
 	}
 
+	/**
+	 * @param {TimeInfoEntries=} fileTimeInfoEntries info for files
+	 * @param {TimeInfoEntries=} contextTimeInfoEntries info for directories
+	 * @param {ReadonlySet<string>=} changedFiles changed files
+	 * @param {ReadonlySet<string>=} removedFiles removed files
+	 * @returns {void}
+	 */
 	_invalidate(
 		fileTimeInfoEntries,
 		contextTimeInfoEntries,
@@ -409,6 +463,10 @@ class Watching {
 			}
 			return;
 		}
+		/**
+		 * @param {WebpackError | null} err error if any
+		 * @param {Compilation=} compilation compilation if any
+		 */
 		const finalCallback = (err, compilation) => {
 			this.running = false;
 			this.compiler.running = false;
@@ -419,9 +477,14 @@ class Watching {
 			this.compiler.fileTimestamps = undefined;
 			this.compiler.contextTimestamps = undefined;
 			this.compiler.fsStartTime = undefined;
+			/**
+			 * @param {WebpackError | null} err error if any
+			 */
 			const shutdown = err => {
 				this.compiler.hooks.watchClose.call();
-				const closeCallbacks = this._closeCallbacks;
+				const closeCallbacks =
+					/** @type {Callback<void>[]} */
+					(this._closeCallbacks);
 				this._closeCallbacks = undefined;
 				for (const cb of closeCallbacks) cb(err);
 			};
@@ -457,7 +520,7 @@ class Watching {
 			this.invalid = true;
 			this._done = finalCallback;
 		} else {
-			finalCallback();
+			finalCallback(null);
 		}
 	}
 }

package/lib/WebpackError.js

@@ -11,6 +11,8 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
 class WebpackError extends Error {
 	/**
@@ -20,16 +22,17 @@ class WebpackError extends Error {
 	constructor(message) {
 		super(message);
 
+		/** @type {string=} */
 		this.details = undefined;
-		/** @type {Module} */
+		/** @type {(Module | null)=} */
 		this.module = undefined;
-		/** @type {DependencyLocation} */
+		/** @type {DependencyLocation=} */
 		this.loc = undefined;
-		/** @type {boolean} */
+		/** @type {boolean=} */
 		this.hideStack = undefined;
-		/** @type {Chunk} */
+		/** @type {Chunk=} */
 		this.chunk = undefined;
-		/** @type {string} */
+		/** @type {string=} */
 		this.file = undefined;
 	}
 
@@ -37,6 +40,9 @@ class WebpackError extends Error {
 		return this.stack + (this.details ? `\n${this.details}` : "");
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize({ write }) {
 		write(this.name);
 		write(this.message);
@@ -46,6 +52,9 @@ class WebpackError extends Error {
 		write(this.hideStack);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize({ read }) {
 		this.name = read();
 		this.message = read();

package/lib/WebpackIsIncludedPlugin.js

@@ -6,15 +6,24 @@
 "use strict";
 
 const IgnoreErrorModuleFactory = require("./IgnoreErrorModuleFactory");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("./ModuleTypeConstants");
 const WebpackIsIncludedDependency = require("./dependencies/WebpackIsIncludedDependency");
 const {
 	toConstantDependency
 } = require("./javascript/JavascriptParserHelpers");
 
-/** @typedef {import("enhanced-resolve/lib/Resolver")} Resolver */
+/** @typedef {import("enhanced-resolve").Resolver} Resolver */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("./javascript/JavascriptParser").Range} Range */
+
+const PLUGIN_NAME = "WebpackIsIncludedPlugin";
 
 class WebpackIsIncludedPlugin {
 	/**
@@ -23,7 +32,7 @@ class WebpackIsIncludedPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"WebpackIsIncludedPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					WebpackIsIncludedDependency,
@@ -41,7 +50,7 @@ class WebpackIsIncludedPlugin {
 				const handler = parser => {
 					parser.hooks.call
 						.for("__webpack_is_included__")
-						.tap("WebpackIsIncludedPlugin", expr => {
+						.tap(PLUGIN_NAME, expr => {
 							if (
 								expr.type !== "CallExpression" ||
 								expr.arguments.length !== 1 ||
@@ -54,29 +63,29 @@ class WebpackIsIncludedPlugin {
 							if (!request.isString()) return;
 
 							const dep = new WebpackIsIncludedDependency(
-								request.string,
-								expr.range
+								/** @type {string} */ (request.string),
+								/** @type {Range} */ (expr.range)
 							);
-							dep.loc = expr.loc;
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addDependency(dep);
 							return true;
 						});
 					parser.hooks.typeof
 						.for("__webpack_is_included__")
 						.tap(
-							"WebpackIsIncludedPlugin",
+							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("function"))
 						);
 				};
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("WebpackIsIncludedPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("WebpackIsIncludedPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("WebpackIsIncludedPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
 			}
 		);
 	}