@kmamal/watcher 0.0.2 → 0.0.5

package/README.md

@@ -1,6 +1,2 @@
 # @kmamal/watcher
 
-[![Package](https://img.shields.io/npm/v/%2540kmamal%252Fwatcher)](https://www.npmjs.com/package/@kmamal/watcher)
-[![Dependencies](https://img.shields.io/librariesio/release/npm/@kmamal/watcher)](https://libraries.io/npm/@kmamal%2Fwatcher)
-[![Count](https://badgen.net/bundlephobia/dependency-count/@kmamal/watcher)](https://bundlephobia.com/package/@kmamal/watcher)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

package/package.json

@@ -1,25 +1,26 @@
 {
-  "version": "0.0.2",
+  "version": "0.0.5",
   "name": "@kmamal/watcher",
   "description": "watcher",
   "repository": {
     "type": "git",
-    "url": "git@github.com:kmamal/watcher.git"
+    "url": "git+ssh://git@github.com:kmamal/watcher.git"
   },
   "license": "MIT",
-  "main": "./src/index.js",
-  "exports": {
-    ".": "./src/index.js"
-  },
   "scripts": {
     "test": "npx @kmamal/testing",
     "update-exports": "node ./scripts/update-exports.mjs"
   },
   "dependencies": {
-    "@kmamal/globs": "^0.0.3",
-    "@kmamal/util": "^0.1.13"
+    "@kmamal/async": "0.0.20",
+    "@kmamal/globs": "0.0.4",
+    "@kmamal/util": "0.2.32"
   },
   "devDependencies": {
-    "@kmamal/testing": "^0.0.24"
-  }
+    "@kmamal/testing": "0.0.33"
+  },
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "main": "./src/index.js"
 }

package/src/index.js

@@ -1,138 +1,219 @@
-const Fs = require('fs')
-const Path = require('path')
-const { EventEmitter } = require('events')
+const Fs = require('node:fs')
+const Path = require('node:path')
+const { EventEmitter } = require('node:events')
+
 const { Matcher } = require('@kmamal/globs/matcher')
 const { comm } = require('@kmamal/util/array/comm')
+const { AbortableOpener } = require('@kmamal/async/opener')
 
 class Watcher extends EventEmitter {
-	constructor (glob, options) {
+	constructor () {
 		super()
-		this._cwd = options?.cwd ? Path.resolve(options.cwd) : process.cwd()
-		this._throttling = options?.throttling ?? 100
+		this._cwd = null
+		this._throttling = null
+
+		this._matcher = null
+		this._entries = new Map()
+		this._scheduled = new Map()
+		this._running = new Map()
 
-		this._matcher = new Matcher(glob, options)
-		this._cache = new Map()
-		this._scheduled = new Set()
+		this._opener = new AbortableOpener()
+		this._ac = null
+	}
 
-		const addEntry = async (fsPath, props) => {
-			if (this._cache.has(fsPath)) { return }
-			const stats = props?.stats ?? await Fs.promises.stats()
-			const isDir = props?.isDir ?? stats.isDirectory()
-			const path = props?.path ?? (isDir ? `${fsPath}/` : fsPath)
+	async open (glob, options) {
+		return await this._opener.open(async (ac) => {
+			this._ac = ac
 
-			const watcher = Fs.watch(fsPath, (event, relPath) => {
-				handleChange(isDir ? Path.join(fsPath, relPath) : fsPath)
-			})
+			this._cwd = options?.cwd ? Path.resolve(options.cwd) : process.cwd()
+			this._throttling = options?.throttling ?? 100
+
+			this._matcher = new Matcher(glob, options)
+
+			const fileIterator = this._matcher.getFiles({ includeDirs: true })
+			for await (const { path, stats } of fileIterator) {
+				if (ac.signal.aborted) { break }
+
+				const isDir = stats.isDirectory()
+				const fsPath = isDir ? path.slice(0, -1) : path
+				await this._addEntry(fsPath, { stats, path, isDir, exhaustive: true }, ac.signal)
 
-			let contents
-			if (isDir) {
-				contents = await Fs.promises.readdir(fsPath)
-				contents.sort()
+				if (ac.signal.aborted) { break }
 			}
-			this._cache.set(fsPath, {
-				watcher,
-				ino: stats.ino,
-				mtimeMs: stats.mtimeMs,
-				contents,
+		})
+	}
+
+	async close () {
+		return await this._opener.close(() => {
+			this._ac.abort()
+			this._ac = null
+
+			for (const entry of this._entries.values()) { entry.watcher.close() }
+			for (const timeout of this._scheduled.values()) { clearTimeout(timeout) }
+
+			this._cwd = null
+			this._throttling = null
+
+			this._matcher = null
+			this._entries.clear()
+			this._scheduled.clear()
+			this._running.clear()
+		})
+	}
+
+	async _addEntry (fsPath, props, signal) {
+		const prev = this._running.get(fsPath) ?? Promise.resolve()
+		const next = prev
+			.then(() => signal.aborted ? undefined : this._doAddEntry(fsPath, props, signal))
+			.finally(() => {
+				if (this._running.get(fsPath) === next) { this._running.delete(fsPath) }
 			})
+		this._running.set(fsPath, next)
+		await next
+	}
 
-			const type = isDir ? 'addDir' : 'addFile'
-			this.emit('change', type, path, stats)
+	async _doAddEntry (fsPath, props, signal) {
+		if (this._entries.has(fsPath)) { return }
+		const stats = props?.stats ?? await Fs.promises.stat(fsPath)
+		const isDir = props?.isDir ?? stats.isDirectory()
+		const path = props?.path ?? (isDir ? `${fsPath}/` : fsPath)
 
-			if (isDir && !props?.exhaustive) {
-				const fileIterator = this._matcher.getFiles({
-					cwd: fsPath,
-					includeDirs: true,
-				})
-				for await (const entry of fileIterator) {
-					const { path: childPath, stats: childStats } = entry
-					const childIsDir = childStats.isDirectory()
-					const childFsPath = childIsDir ? childPath.slice(0, -1) : childPath
-					await addEntry(childFsPath, {
-						stats: childStats,
-						path: childPath,
-						isDir: childIsDir,
-						exhaustive: true,
-					})
-				}
+		if (signal.aborted) { return }
+
+		let contents
+		if (isDir) {
+			contents = await Fs.promises.readdir(fsPath)
+			if (signal.aborted) { return }
+			contents.sort()
+		}
+
+		const watcher = Fs.watch(fsPath, (event, relPath) => {
+			if (!relPath) {
+				console.warn(`Watcher: ${event} event on ${fsPath} with no relPath`)
+				return
+			}
+			this._handleChange(isDir ? Path.join(fsPath, relPath) : fsPath, signal)
+		})
+
+		this._entries.set(fsPath, {
+			watcher,
+			ino: stats.ino,
+			mtimeMs: stats.mtimeMs,
+			contents,
+		})
+
+		const type = isDir ? 'addDir' : 'addFile'
+		this.emit('change', type, path, stats)
+
+		if (isDir && !props?.exhaustive) {
+			const fileIterator = this._matcher.getFiles({
+				cwd: fsPath,
+				includeDirs: true,
+			})
+			for await (const entry of fileIterator) {
+				if (signal.aborted) { return }
+
+				const { path: childPath, stats: childStats } = entry
+				const childIsDir = childStats.isDirectory()
+				const childFsPath = childIsDir ? childPath.slice(0, -1) : childPath
+
+				await this._addEntry(childFsPath, {
+					stats: childStats,
+					path: childPath,
+					isDir: childIsDir,
+					exhaustive: true,
+				}, signal)
+				if (signal.aborted) { return }
 			}
 		}
+	}
 
-		const removeEntry = (fsPath, props) => {
-			const entry = props?.entry ?? this._cache.get(fsPath)
-			if (!entry) { return }
-			const isDir = props?.isDir ?? Boolean(entry.contents)
-			const path = props?.isDir ?? (isDir ? `${fsPath}/` : fsPath)
+	_removeEntry (fsPath, props, signal) {
+		const entry = props?.entry ?? this._entries.get(fsPath)
+		if (!entry) { return }
+		const isDir = props?.isDir ?? Boolean(entry.contents)
+		const path = props?.path ?? (isDir ? `${fsPath}/` : fsPath)
 
-			entry.watcher.close()
-			this._cache.delete(fsPath)
+		entry.watcher.close()
+		this._entries.delete(fsPath)
 
-			if (isDir && !props?.exhaustive) {
-				for (const name of entry.contents) {
-					removeEntry(Path.join(fsPath, name))
-				}
+		if (isDir && !props?.exhaustive) {
+			for (const name of entry.contents) {
+				this._removeEntry(Path.join(fsPath, name), undefined, signal)
 			}
-
-			const type = isDir ? 'delDir' : 'delFile'
-			this.emit('change', type, path)
 		}
 
-		const handleChange = (fsPath) => {
-			if (this._scheduled.has(fsPath)) { return }
-			if (!this._matcher.matchesPath(fsPath)) { return }
-			this._scheduled.add(fsPath)
-			setTimeout(() => {
-				this._scheduled.delete(fsPath)
-				_handleChange(fsPath)
-			}, this._throttling)
-		}
+		const type = isDir ? 'delDir' : 'delFile'
+		this.emit('change', type, path)
+	}
 
-		const _handleChange = async (fsPath) => {
-			let entry = this._cache.get(fsPath)
+	_handleChange (fsPath, signal) {
+		if (signal.aborted) { return }
 
-			try {
-				const newStats = await Fs.promises.stat(fsPath)
-				const isDir = newStats.isDirectory()
-				const newPath = isDir ? `${fsPath}/` : fsPath
+		if (this._scheduled.has(fsPath)) { return }
+		if (!this._matcher.matchesPath(fsPath)) { return }
 
-				const wasDir = Boolean(entry?.contents)
-				const oldPath = wasDir ? `${fsPath}/` : fsPath
+		this._scheduled.set(fsPath, setTimeout(() => {
+			this._scheduled.delete(fsPath)
 
-				if (!entry || wasDir !== isDir || entry.ino !== newStats.ino) {
-					if (entry) { removeEntry(fsPath, { entry, path: oldPath, isDir: wasDir }) }
-					entry = addEntry(fsPath, { stats: newStats, path: newPath, isDir })
-					return
-				}
+			const prev = this._running.get(fsPath) ?? Promise.resolve()
+			const next = prev
+				.then(() => signal.aborted ? undefined : this._doHandleChange(fsPath, signal))
+				.finally(() => {
+					if (this._running.get(fsPath) === next) { this._running.delete(fsPath) }
+				})
+			this._running.set(fsPath, next)
+		}, this._throttling))
+	}
 
-				if (entry.mtimeMs >= newStats.mtimeMs) { return }
-
-				if (!isDir) {
-					this.emit('change', 'change', newPath, newStats)
-				} else {
-					const newContents = await Fs.promises.readdir(fsPath)
-					newContents.sort()
-
-					const { a, b } = comm(entry.contents, newContents)
-					for (const name of a) {
-						removeEntry(Path.join(fsPath, name))
-					}
-					for (const name of b) {
-						addEntry(Path.join(fsPath, name))
-					}
-				}
-			} catch (error) {
-				if (entry) { removeEntry(fsPath, { entry }) }
+	async _doHandleChange (fsPath, signal) {
+		if (signal.aborted) { return }
+		const entry = this._entries.get(fsPath)
+
+		try {
+			const newStats = await Fs.promises.stat(fsPath)
+			if (signal.aborted) { return }
+
+			const isDir = newStats.isDirectory()
+			const newPath = isDir ? `${fsPath}/` : fsPath
+
+			const wasDir = Boolean(entry?.contents)
+			const oldPath = wasDir ? `${fsPath}/` : fsPath
+
+			if (!entry || wasDir !== isDir || entry.ino !== newStats.ino) {
+				if (entry) { this._removeEntry(fsPath, { entry, path: oldPath, isDir: wasDir }, signal) }
+				await this._doAddEntry(fsPath, { stats: newStats, path: newPath, isDir }, signal)
+				return
 			}
-		}
 
-		;(async () => {
-			const fileIterator = this._matcher.getFiles({ includeDirs: true })
-			for await (const { path, stats } of fileIterator) {
-				const isDir = stats.isDirectory()
-				const fsPath = isDir ? path.slice(0, -1) : path
-				await addEntry(fsPath, { stats, path, isDir, exhaustive: true })
+			if (entry.mtimeMs >= newStats.mtimeMs) { return }
+			entry.mtimeMs = newStats.mtimeMs
+
+			if (!isDir) {
+				this.emit('change', 'change', newPath, newStats)
 			}
-		})()
+			else {
+				const newContents = await Fs.promises.readdir(fsPath)
+				if (signal.aborted) { return }
+
+				newContents.sort()
+
+				const { a, b } = comm(entry.contents, newContents)
+				for (const name of a) {
+					this._removeEntry(Path.join(fsPath, name), undefined, signal)
+				}
+				for (const name of b) {
+					await this._addEntry(Path.join(fsPath, name), undefined, signal)
+					if (signal.aborted) { return }
+				}
+
+				entry.contents = newContents
+			}
+		}
+		catch (error) {
+			if (error.code !== 'ENOENT') { throw error }
+			if (entry) { this._removeEntry(fsPath, { entry }, signal) }
+		}
 	}
 }