webpack/lib/node/NodeWatchFileSystem.js

/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/

"use strict";

const Watchpack = require("watchpack");

/** @typedef {import("../../declarations/WebpackOptions").WatchOptions} WatchOptions */
/** @typedef {import("../FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
/** @typedef {import("../util/fs").WatchFileSystem} WatchFileSystem */
/** @typedef {import("../util/fs").WatchMethod} WatchMethod */
/** @typedef {import("../util/fs").Watcher} Watcher */

class NodeWatchFileSystem {
	constructor(inputFileSystem) {
		this.inputFileSystem = inputFileSystem;
		this.watcherOptions = {
			aggregateTimeout: 0
		};
		this.watcher = new Watchpack(this.watcherOptions);
	}

	/**
	 * @param {Iterable<string>} files watched files
	 * @param {Iterable<string>} directories watched directories
	 * @param {Iterable<string>} missing watched exitance entries
	 * @param {number} startTime timestamp of start time
	 * @param {WatchOptions} options options object
	 * @param {function(Error=, Map<string, FileSystemInfoEntry>, Map<string, FileSystemInfoEntry>, Set<string>, Set<string>): void} callback aggregated callback
	 * @param {function(string, number): void} callbackUndelayed callback when the first change was detected
	 * @returns {Watcher} a watcher
	 */
	watch(
		files,
		directories,
		missing,
		startTime,
		options,
		callback,
		callbackUndelayed
	) {
		if (!files || typeof files[Symbol.iterator] !== "function") {
			throw new Error("Invalid arguments: 'files'");
		}
		if (!directories || typeof directories[Symbol.iterator] !== "function") {
			throw new Error("Invalid arguments: 'directories'");
		}
		if (!missing || typeof missing[Symbol.iterator] !== "function") {
			throw new Error("Invalid arguments: 'missing'");
		}
		if (typeof callback !== "function") {
			throw new Error("Invalid arguments: 'callback'");
		}
		if (typeof startTime !== "number" && startTime) {
			throw new Error("Invalid arguments: 'startTime'");
		}
		if (typeof options !== "object") {
			throw new Error("Invalid arguments: 'options'");
		}
		if (typeof callbackUndelayed !== "function" && callbackUndelayed) {
			throw new Error("Invalid arguments: 'callbackUndelayed'");
		}
		const oldWatcher = this.watcher;
		this.watcher = new Watchpack(options);

		if (callbackUndelayed) {
			this.watcher.once("change", callbackUndelayed);
		}

		let fileMap, directoryMap;
		this.watcher.once("aggregated", (changes, removals) => {
			if (this.inputFileSystem && this.inputFileSystem.purge) {
				const fs = this.inputFileSystem;
				for (const item of changes) {
					fs.purge(item);
				}
				for (const item of removals) {
					fs.purge(item);
				}
			}
			fileMap = new Map();
			directoryMap = new Map();
			this.watcher.getTimeInfoEntries(fileMap, directoryMap);
			callback(null, fileMap, directoryMap, changes, removals);
		});

		this.watcher.watch({ files, directories, missing, startTime });

		if (oldWatcher) {
			oldWatcher.close();
		}
		return {
			close: () => {
				if (this.watcher) {
					this.watcher.close();
					this.watcher = null;
				}
			},
			pause: () => {
				if (this.watcher) {
					this.watcher.pause();
				}
			},
			getAggregatedRemovals: () => {
				const items = this.watcher && this.watcher.aggregatedRemovals;
				if (items && this.inputFileSystem && this.inputFileSystem.purge) {
					const fs = this.inputFileSystem;
					for (const item of items) {
						fs.purge(item);
					}
				}
				return items;
			},
			getAggregatedChanges: () => {
				const items = this.watcher && this.watcher.aggregatedChanges;
				if (items && this.inputFileSystem && this.inputFileSystem.purge) {
					const fs = this.inputFileSystem;
					for (const item of items) {
						fs.purge(item);
					}
				}
				return items;
			},
			getFileTimeInfoEntries: () => {
				if (fileMap) return fileMap;
				if (this.watcher) {
					this.watcher.getTimeInfoEntries(
						(fileMap = new Map()),
						(directoryMap = new Map())
					);
					return fileMap;
				}
				return new Map();
			},
			getContextTimeInfoEntries: () => {
				if (directoryMap) return directoryMap;
				if (this.watcher) {
					this.watcher.getTimeInfoEntries(
						(fileMap = new Map()),
						(directoryMap = new Map())
					);
					return directoryMap;
				}
				return new Map();
			}
		};
	}
}

module.exports = NodeWatchFileSystem;