import fs from 'fs' import fsPromise from 'fs/promises' import path from 'path' import events from 'events' import hasNativeRecursive from './has-native-recursive.mjs' import * as is from './is.mjs' export const EVENT_UPDATE = 'update'; export const EVENT_REMOVE = 'remove'; const TYPE_FILE = 'file' const TYPE_DIRECTORY = 'directory' function unique(arr) { return arr.filter(function(v, i, self) { return self.indexOf(v) === i; }); } export default class Watcher extends events.EventEmitter { constructor(path, options = null, fn = null, { fs: fsoverwrite } = {}) { super() this.ac = new AbortController() events.setMaxListeners(2000, this.ac.signal) this._fs = fsoverwrite || fs this._cache = [] this._cacheTimeout = null this.listeners = [] this.closed = false let paths = path if (is.buffer(paths)) { paths = paths.toString() } if (!is.array(paths)) { paths = [paths] } paths = unique(paths) this.options = options || {} this.fn = fn || null this.originalPaths = paths if (is.func(this.options)) { this.fn = this.options this.options = {} } this._verifyOptions(paths) } isClosed() { return this.closed } close() { this.closed = true this.ac.abort() this._cache = this.listeners = [] this.emitAsync('close') } emitAsync(name, ...args) { process.nextTick(() => this.emit(name, ...args)) } _verifyOptions(paths) { for (let path of paths) { if (!is.exists(path)) { this.emitAsync('error', new Error(path + ' does not exist.')) } } if (this.options.encoding) { if (this.options.encoding && this.options.encoding !== 'buffer' && !Buffer.isEncoding(this.options.encoding)) { throw new Error('Unknown encoding: ' + this.options.encoding); } } else { this.options.encoding = 'utf8' } if (this.options.delay !== 0 && !this.options.delay) { this.options.delay = 200 } if (is.func(this.fn)) { this.on('change', this.fn) } if (this.options.manualRecursive !== true) { hasNativeRecursive(nativeRecursive => { this.supportsNativeRecursive = nativeRecursive this.options.manualRecursive = !nativeRecursive this._startListeners(paths) }, { quickCheck: this.options.quickNativeCheck || true }) } else { this._startListeners(paths) } } _startListeners(paths) { Promise.all(paths.map(path => this.safeAdd(path))) .then( () => this.emit('ready'), err => this.emit('error', err), ) } getWatcherOrNull(name) { for (let check of this.listeners) { if (check.path === name) { return check } } return null } shouldSkip(name) { return this.options.skip ? (is.func(this.options.skip) && this.options.skip.call(this, name)) || (is.regExp(this.options.skip) && this.options.skip.test(name)) : false } shouldNotify(name) { return this.options.filter ? (is.func(this.options.filter) && this.options.filter.call(this, name)) || (is.regExp(this.options.filter) && this.options.filter.test(name)) : true } closeWatch(orgItem) { let item = orgItem if (typeof item === 'string') { item = this.getWatcherOrNull(item) } if (!item) { return } if (item.watcher) { item.watcher.close() } this._emitEvent(item, EVENT_REMOVE, item.path) let index = this.listeners.indexOf(item) if (index < 0) return this.listeners.splice(index, 1) } _emitEvent(item, evt, name) { if (item.type === TYPE_FILE && !is.samePath(name, item.filename)) return if (item.type === TYPE_DIRECTORY && this.shouldSkip(name)) return if (!this.shouldNotify(name)) return if (item.flag) { item.flag = '' return } let outputName = name if (this.options.encoding !== 'utf8') { outputName = Buffer.from(outputName) if (this.options.encoding !== 'buffer') { outputName = outputName.toString(this.options.encoding) } } if (!this.options.delay) { this.emit('change', evt, outputName) this.emit('changed', evt, outputName) return } this._cache.push([evt, name, outputName]) if (this._cacheTimeout) return this._cacheTimeout = setTimeout(() => { let cache = this._filterCache(this._cache) this._cache = [] this._cacheTimeout = null for (let event of cache) { try { this.emit('change', event[0], event[2]) } catch (err) { this.emit('error', err) } } this.emit('changed') }, this.options.delay) } _filterCache(cache) { let setFound = new Set() let out = cache.reverse().filter(([evt, name]) => { if (setFound.has(name)) return false setFound.add(name) return true }).reverse() return out } _watcherSink(item, rawEvt, rawName, c) { if (this.closed) return let name = path.join(item.path, rawName || '') let evt = is.exists(name) ? EVENT_UPDATE : EVENT_REMOVE if (this.options.recursive && this.options.manualRecursive && item.type === TYPE_DIRECTORY) { if (evt === EVENT_REMOVE) { this.closeWatch(name) return } else { if (is.directory(name) && this.getWatcherOrNull(name) === null) { this.safeAdd(name, TYPE_DIRECTORY) } } } this._emitEvent(item, evt, name) } _pathToItem(name, type) { if (type === TYPE_FILE) { let parent = path.join(name, '../') return { path: parent, type: TYPE_FILE, filename: name, watcher: null, flag: '', } } else { return { path: name, type: TYPE_DIRECTORY, watcher: null, flag: '', } } } _watcherError(item, err) { if (this.closed) return if (is.windows() && err.code === 'EPERM') { this.closeWatch(item) item.flag = 'windows-error' } else { self.emit('error', err) } } safeAdd(name, orgType) { let type = orgType if (!type) { type = is.file(name) ? TYPE_FILE : TYPE_DIRECTORY } if (this.shouldSkip(name)) { return } let item = this._pathToItem(name, type) let options = { encoding: 'utf8', signal: this.ac.signal, } if (!this.options.manualRecursive && item.type !== TYPE_FILE && this.options.recursive) { options.recursive = true } try { item.watcher = this._fs.watch(item.path, options) } catch (err) { this.emitAsync('error', err) } if (!item.watcher) return this.listeners.push(item) item.watcher.on('error', this._watcherError.bind(this, item)) item.watcher.on('change', this._watcherSink.bind(this, item)) if (options.recursive || item.type === TYPE_FILE) return return fsPromise.readdir(item.path, { withFileTypes: true }) .then(directories => directories.filter(dir => dir.isDirectory())) .then(directories => { return Promise.all(directories.map(dir => this.safeAdd(path.join(item.path, dir.name), TYPE_DIRECTORY))) }) } }