simple-squiggle

watchEventSource.js (8546B)

---

 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
 "use strict";
 
 const fs = require("fs");
 const path = require("path");
 const { EventEmitter } = require("events");
 const reducePlan = require("./reducePlan");
 
 const IS_OSX = require("os").platform() === "darwin";
 const IS_WIN = require("os").platform() === "win32";
 const SUPPORTS_RECURSIVE_WATCHING = IS_OSX || IS_WIN;
 
 const watcherLimit =
 	+process.env.WATCHPACK_WATCHER_LIMIT || (IS_OSX ? 2000 : 10000);
 
 const recursiveWatcherLogging = !!process.env
 	.WATCHPACK_RECURSIVE_WATCHER_LOGGING;
 
 let isBatch = false;
 let watcherCount = 0;
 
 /** @type {Map<Watcher, string>} */
 const pendingWatchers = new Map();
 
 /** @type {Map<string, RecursiveWatcher>} */
 const recursiveWatchers = new Map();
 
 /** @type {Map<string, DirectWatcher>} */
 const directWatchers = new Map();
 
 /** @type {Map<Watcher, RecursiveWatcher | DirectWatcher>} */
 const underlyingWatcher = new Map();
 
 class DirectWatcher {
 	constructor(filePath) {
 		this.filePath = filePath;
 		this.watchers = new Set();
 		this.watcher = undefined;
 		try {
 			const watcher = fs.watch(filePath);
 			this.watcher = watcher;
 			watcher.on("change", (type, filename) => {
 				for (const w of this.watchers) {
 					w.emit("change", type, filename);
 				}
 			});
 			watcher.on("error", error => {
 				for (const w of this.watchers) {
 					w.emit("error", error);
 				}
 			});
 		} catch (err) {
 			process.nextTick(() => {
 				for (const w of this.watchers) {
 					w.emit("error", err);
 				}
 			});
 		}
 		watcherCount++;
 	}
 
 	add(watcher) {
 		underlyingWatcher.set(watcher, this);
 		this.watchers.add(watcher);
 	}
 
 	remove(watcher) {
 		this.watchers.delete(watcher);
 		if (this.watchers.size === 0) {
 			directWatchers.delete(this.filePath);
 			watcherCount--;
 			if (this.watcher) this.watcher.close();
 		}
 	}
 
 	getWatchers() {
 		return this.watchers;
 	}
 }
 
 class RecursiveWatcher {
 	constructor(rootPath) {
 		this.rootPath = rootPath;
 		/** @type {Map<Watcher, string>} */
 		this.mapWatcherToPath = new Map();
 		/** @type {Map<string, Set<Watcher>>} */
 		this.mapPathToWatchers = new Map();
 		this.watcher = undefined;
 		try {
 			const watcher = fs.watch(rootPath, {
 				recursive: true
 			});
 			this.watcher = watcher;
 			watcher.on("change", (type, filename) => {
 				if (!filename) {
 					if (recursiveWatcherLogging) {
 						process.stderr.write(
 							`[watchpack] dispatch ${type} event in recursive watcher (${
 								this.rootPath
 							}) to all watchers\n`
 						);
 					}
 					for (const w of this.mapWatcherToPath.keys()) {
 						w.emit("change", type);
 					}
 				} else {
 					const dir = path.dirname(filename);
 					const watchers = this.mapPathToWatchers.get(dir);
 					if (recursiveWatcherLogging) {
 						process.stderr.write(
 							`[watchpack] dispatch ${type} event in recursive watcher (${
 								this.rootPath
 							}) for '${filename}' to ${
 								watchers ? watchers.size : 0
 							} watchers\n`
 						);
 					}
 					if (watchers === undefined) return;
 					for (const w of watchers) {
 						w.emit("change", type, path.basename(filename));
 					}
 				}
 			});
 			watcher.on("error", error => {
 				for (const w of this.mapWatcherToPath.keys()) {
 					w.emit("error", error);
 				}
 			});
 		} catch (err) {
 			process.nextTick(() => {
 				for (const w of this.mapWatcherToPath.keys()) {
 					w.emit("error", err);
 				}
 			});
 		}
 		watcherCount++;
 		if (recursiveWatcherLogging) {
 			process.stderr.write(
 				`[watchpack] created recursive watcher at ${rootPath}\n`
 			);
 		}
 	}
 
 	add(filePath, watcher) {
 		underlyingWatcher.set(watcher, this);
 		const subpath = filePath.slice(this.rootPath.length + 1) || ".";
 		this.mapWatcherToPath.set(watcher, subpath);
 		const set = this.mapPathToWatchers.get(subpath);
 		if (set === undefined) {
 			const newSet = new Set();
 			newSet.add(watcher);
 			this.mapPathToWatchers.set(subpath, newSet);
 		} else {
 			set.add(watcher);
 		}
 	}
 
 	remove(watcher) {
 		const subpath = this.mapWatcherToPath.get(watcher);
 		if (!subpath) return;
 		this.mapWatcherToPath.delete(watcher);
 		const set = this.mapPathToWatchers.get(subpath);
 		set.delete(watcher);
 		if (set.size === 0) {
 			this.mapPathToWatchers.delete(subpath);
 		}
 		if (this.mapWatcherToPath.size === 0) {
 			recursiveWatchers.delete(this.rootPath);
 			watcherCount--;
 			if (this.watcher) this.watcher.close();
 			if (recursiveWatcherLogging) {
 				process.stderr.write(
 					`[watchpack] closed recursive watcher at ${this.rootPath}\n`
 				);
 			}
 		}
 	}
 
 	getWatchers() {
 		return this.mapWatcherToPath;
 	}
 }
 
 class Watcher extends EventEmitter {
 	close() {
 		if (pendingWatchers.has(this)) {
 			pendingWatchers.delete(this);
 			return;
 		}
 		const watcher = underlyingWatcher.get(this);
 		watcher.remove(this);
 		underlyingWatcher.delete(this);
 	}
 }
 
 const createDirectWatcher = filePath => {
 	const existing = directWatchers.get(filePath);
 	if (existing !== undefined) return existing;
 	const w = new DirectWatcher(filePath);
 	directWatchers.set(filePath, w);
 	return w;
 };
 
 const createRecursiveWatcher = rootPath => {
 	const existing = recursiveWatchers.get(rootPath);
 	if (existing !== undefined) return existing;
 	const w = new RecursiveWatcher(rootPath);
 	recursiveWatchers.set(rootPath, w);
 	return w;
 };
 
 const execute = () => {
 	/** @type {Map<string, Watcher[] | Watcher>} */
 	const map = new Map();
 	const addWatcher = (watcher, filePath) => {
 		const entry = map.get(filePath);
 		if (entry === undefined) {
 			map.set(filePath, watcher);
 		} else if (Array.isArray(entry)) {
 			entry.push(watcher);
 		} else {
 			map.set(filePath, [entry, watcher]);
 		}
 	};
 	for (const [watcher, filePath] of pendingWatchers) {
 		addWatcher(watcher, filePath);
 	}
 	pendingWatchers.clear();
 
 	// Fast case when we are not reaching the limit
 	if (!SUPPORTS_RECURSIVE_WATCHING || watcherLimit - watcherCount >= map.size) {
 		// Create watchers for all entries in the map
 		for (const [filePath, entry] of map) {
 			const w = createDirectWatcher(filePath);
 			if (Array.isArray(entry)) {
 				for (const item of entry) w.add(item);
 			} else {
 				w.add(entry);
 			}
 		}
 		return;
 	}
 
 	// Reconsider existing watchers to improving watch plan
 	for (const watcher of recursiveWatchers.values()) {
 		for (const [w, subpath] of watcher.getWatchers()) {
 			addWatcher(w, path.join(watcher.rootPath, subpath));
 		}
 	}
 	for (const watcher of directWatchers.values()) {
 		for (const w of watcher.getWatchers()) {
 			addWatcher(w, watcher.filePath);
 		}
 	}
 
 	// Merge map entries to keep watcher limit
 	// Create a 10% buffer to be able to enter fast case more often
 	const plan = reducePlan(map, watcherLimit * 0.9);
 
 	// Update watchers for all entries in the map
 	for (const [filePath, entry] of plan) {
 		if (entry.size === 1) {
 			for (const [watcher, filePath] of entry) {
 				const w = createDirectWatcher(filePath);
 				const old = underlyingWatcher.get(watcher);
 				if (old === w) continue;
 				w.add(watcher);
 				if (old !== undefined) old.remove(watcher);
 			}
 		} else {
 			const filePaths = new Set(entry.values());
 			if (filePaths.size > 1) {
 				const w = createRecursiveWatcher(filePath);
 				for (const [watcher, watcherPath] of entry) {
 					const old = underlyingWatcher.get(watcher);
 					if (old === w) continue;
 					w.add(watcherPath, watcher);
 					if (old !== undefined) old.remove(watcher);
 				}
 			} else {
 				for (const filePath of filePaths) {
 					const w = createDirectWatcher(filePath);
 					for (const watcher of entry.keys()) {
 						const old = underlyingWatcher.get(watcher);
 						if (old === w) continue;
 						w.add(watcher);
 						if (old !== undefined) old.remove(watcher);
 					}
 				}
 			}
 		}
 	}
 };
 
 exports.watch = filePath => {
 	const watcher = new Watcher();
 	// Find an existing watcher
 	const directWatcher = directWatchers.get(filePath);
 	if (directWatcher !== undefined) {
 		directWatcher.add(watcher);
 		return watcher;
 	}
 	let current = filePath;
 	for (;;) {
 		const recursiveWatcher = recursiveWatchers.get(current);
 		if (recursiveWatcher !== undefined) {
 			recursiveWatcher.add(filePath, watcher);
 			return watcher;
 		}
 		const parent = path.dirname(current);
 		if (parent === current) break;
 		current = parent;
 	}
 	// Queue up watcher for creation
 	pendingWatchers.set(watcher, filePath);
 	if (!isBatch) execute();
 	return watcher;
 };
 
 exports.batch = fn => {
 	isBatch = true;
 	try {
 		fn();
 	} finally {
 		isBatch = false;
 		execute();
 	}
 };
 
 exports.getNumberOfWatchers = () => {
 	return watcherCount;
 };