Fix sudo handling for MySQL socket directory permissions in migrate commands
🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
root
454
node_modules/watchpack/lib/DirectoryWatcher.js
generated
vendored
Executable file → Normal file
454
node_modules/watchpack/lib/DirectoryWatcher.js
generated
vendored
Executable file → Normal file
@@ -4,12 +4,23 @@
|
||||
*/
|
||||
"use strict";
|
||||
|
||||
const EventEmitter = require("events").EventEmitter;
|
||||
const fs = require("graceful-fs");
|
||||
const { EventEmitter } = require("events");
|
||||
const path = require("path");
|
||||
const fs = require("graceful-fs");
|
||||
|
||||
const watchEventSource = require("./watchEventSource");
|
||||
|
||||
/** @typedef {import("./index").IgnoredFunction} IgnoredFunction */
|
||||
/** @typedef {import("./index").EventType} EventType */
|
||||
/** @typedef {import("./index").TimeInfoEntries} TimeInfoEntries */
|
||||
/** @typedef {import("./index").Entry} Entry */
|
||||
/** @typedef {import("./index").ExistanceOnlyTimeEntry} ExistanceOnlyTimeEntry */
|
||||
/** @typedef {import("./index").OnlySafeTimeEntry} OnlySafeTimeEntry */
|
||||
/** @typedef {import("./index").EventMap} EventMap */
|
||||
/** @typedef {import("./getWatcherManager").WatcherManager} WatcherManager */
|
||||
/** @typedef {import("./watchEventSource").Watcher} EventSourceWatcher */
|
||||
|
||||
/** @type {ExistanceOnlyTimeEntry} */
|
||||
const EXISTANCE_ONLY_TIME_ENTRY = Object.freeze({});
|
||||
|
||||
let FS_ACCURACY = 2000;
|
||||
@@ -17,45 +28,130 @@ let FS_ACCURACY = 2000;
|
||||
const IS_OSX = require("os").platform() === "darwin";
|
||||
const IS_WIN = require("os").platform() === "win32";
|
||||
|
||||
const WATCHPACK_POLLING = process.env.WATCHPACK_POLLING;
|
||||
const { WATCHPACK_POLLING } = process.env;
|
||||
const FORCE_POLLING =
|
||||
// @ts-expect-error avoid additional checks
|
||||
`${+WATCHPACK_POLLING}` === WATCHPACK_POLLING
|
||||
? +WATCHPACK_POLLING
|
||||
: !!WATCHPACK_POLLING && WATCHPACK_POLLING !== "false";
|
||||
: Boolean(WATCHPACK_POLLING) && WATCHPACK_POLLING !== "false";
|
||||
|
||||
/**
|
||||
* @param {string} str string
|
||||
* @returns {string} lower cased string
|
||||
*/
|
||||
function withoutCase(str) {
|
||||
return str.toLowerCase();
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {number} times times
|
||||
* @param {() => void} callback callback
|
||||
* @returns {() => void} result
|
||||
*/
|
||||
function needCalls(times, callback) {
|
||||
return function() {
|
||||
return function needCallsCallback() {
|
||||
if (--times === 0) {
|
||||
return callback();
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {Entry} entry entry
|
||||
*/
|
||||
function fixupEntryAccuracy(entry) {
|
||||
if (entry.accuracy > FS_ACCURACY) {
|
||||
entry.safeTime = entry.safeTime - entry.accuracy + FS_ACCURACY;
|
||||
entry.accuracy = FS_ACCURACY;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {number=} mtime mtime
|
||||
*/
|
||||
function ensureFsAccuracy(mtime) {
|
||||
if (!mtime) return;
|
||||
if (FS_ACCURACY > 1 && mtime % 1 !== 0) FS_ACCURACY = 1;
|
||||
else if (FS_ACCURACY > 10 && mtime % 10 !== 0) FS_ACCURACY = 10;
|
||||
else if (FS_ACCURACY > 100 && mtime % 100 !== 0) FS_ACCURACY = 100;
|
||||
else if (FS_ACCURACY > 1000 && mtime % 1000 !== 0) FS_ACCURACY = 1000;
|
||||
}
|
||||
|
||||
/**
|
||||
* @typedef {object} FileWatcherEvents
|
||||
* @property {(type: EventType) => void} initial-missing initial missing event
|
||||
* @property {(mtime: number, type: EventType, initial: boolean) => void} change change event
|
||||
* @property {(type: EventType) => void} remove remove event
|
||||
* @property {() => void} closed closed event
|
||||
*/
|
||||
|
||||
/**
|
||||
* @typedef {object} DirectoryWatcherEvents
|
||||
* @property {(type: EventType) => void} initial-missing initial missing event
|
||||
* @property {((file: string, mtime: number, type: EventType, initial: boolean) => void)} change change event
|
||||
* @property {(type: EventType) => void} remove remove event
|
||||
* @property {() => void} closed closed event
|
||||
*/
|
||||
|
||||
/**
|
||||
* @template {EventMap} T
|
||||
* @extends {EventEmitter<{ [K in keyof T]: Parameters<T[K]> }>}
|
||||
*/
|
||||
class Watcher extends EventEmitter {
|
||||
constructor(directoryWatcher, filePath, startTime) {
|
||||
/**
|
||||
* @param {DirectoryWatcher} directoryWatcher a directory watcher
|
||||
* @param {string} target a target to watch
|
||||
* @param {number=} startTime start time
|
||||
*/
|
||||
constructor(directoryWatcher, target, startTime) {
|
||||
super();
|
||||
this.directoryWatcher = directoryWatcher;
|
||||
this.path = filePath;
|
||||
this.path = target;
|
||||
this.startTime = startTime && +startTime;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {number} mtime mtime
|
||||
* @param {boolean} initial true when initial, otherwise false
|
||||
* @returns {boolean} true of start time less than mtile, otherwise false
|
||||
*/
|
||||
checkStartTime(mtime, initial) {
|
||||
const startTime = this.startTime;
|
||||
const { startTime } = this;
|
||||
if (typeof startTime !== "number") return !initial;
|
||||
return startTime <= mtime;
|
||||
}
|
||||
|
||||
close() {
|
||||
// @ts-expect-error bad typing in EventEmitter
|
||||
this.emit("closed");
|
||||
}
|
||||
}
|
||||
|
||||
/** @typedef {Set<string>} InitialScanRemoved */
|
||||
|
||||
/**
|
||||
* @typedef {object} WatchpackEvents
|
||||
* @property {(target: string, mtime: string, type: EventType, initial: boolean) => void} change change event
|
||||
* @property {() => void} closed closed event
|
||||
*/
|
||||
|
||||
/**
|
||||
* @typedef {object} DirectoryWatcherOptions
|
||||
* @property {boolean=} followSymlinks true when need to resolve symlinks and watch symlink and real file, otherwise false
|
||||
* @property {IgnoredFunction=} ignored ignore some files from watching (glob pattern or regexp)
|
||||
* @property {number | boolean=} poll true when need to enable polling mode for watching, otherwise false
|
||||
*/
|
||||
|
||||
/**
|
||||
* @extends {EventEmitter<{ [K in keyof WatchpackEvents]: Parameters<WatchpackEvents[K]> }>}
|
||||
*/
|
||||
class DirectoryWatcher extends EventEmitter {
|
||||
constructor(watcherManager, directoryPath, options) {
|
||||
/**
|
||||
* @param {WatcherManager} watcherManager a watcher manager
|
||||
* @param {string} directoryPath directory path
|
||||
* @param {DirectoryWatcherOptions=} options options
|
||||
*/
|
||||
constructor(watcherManager, directoryPath, options = {}) {
|
||||
super();
|
||||
if (FORCE_POLLING) {
|
||||
options.poll = FORCE_POLLING;
|
||||
@@ -65,28 +161,35 @@ class DirectoryWatcher extends EventEmitter {
|
||||
this.path = directoryPath;
|
||||
// safeTime is the point in time after which reading is safe to be unchanged
|
||||
// timestamp is a value that should be compared with another timestamp (mtime)
|
||||
/** @type {Map<string, { safeTime: number, timestamp: number }} */
|
||||
/** @type {Map<string, Entry>} */
|
||||
this.files = new Map();
|
||||
/** @type {Map<string, number>} */
|
||||
this.filesWithoutCase = new Map();
|
||||
/** @type {Map<string, Watcher<DirectoryWatcherEvents> | boolean>} */
|
||||
this.directories = new Map();
|
||||
this.lastWatchEvent = 0;
|
||||
this.initialScan = true;
|
||||
this.ignored = options.ignored || (() => false);
|
||||
this.nestedWatching = false;
|
||||
/** @type {number | false} */
|
||||
this.polledWatching =
|
||||
typeof options.poll === "number"
|
||||
? options.poll
|
||||
: options.poll
|
||||
? 5007
|
||||
: false;
|
||||
? 5007
|
||||
: false;
|
||||
/** @type {undefined | NodeJS.Timeout} */
|
||||
this.timeout = undefined;
|
||||
/** @type {null | InitialScanRemoved} */
|
||||
this.initialScanRemoved = new Set();
|
||||
/** @type {undefined | number} */
|
||||
this.initialScanFinished = undefined;
|
||||
/** @type {Map<string, Set<Watcher>>} */
|
||||
/** @type {Map<string, Set<Watcher<DirectoryWatcherEvents> | Watcher<FileWatcherEvents>>>} */
|
||||
this.watchers = new Map();
|
||||
/** @type {Watcher<FileWatcherEvents> | null} */
|
||||
this.parentWatcher = null;
|
||||
this.refs = 0;
|
||||
/** @type {Map<string, boolean>} */
|
||||
this._activeEvents = new Map();
|
||||
this.closed = false;
|
||||
this.scanning = false;
|
||||
@@ -100,19 +203,22 @@ class DirectoryWatcher extends EventEmitter {
|
||||
createWatcher() {
|
||||
try {
|
||||
if (this.polledWatching) {
|
||||
this.watcher = {
|
||||
/** @type {EventSourceWatcher} */
|
||||
(this.watcher) = /** @type {EventSourceWatcher} */ ({
|
||||
close: () => {
|
||||
if (this.timeout) {
|
||||
clearTimeout(this.timeout);
|
||||
this.timeout = undefined;
|
||||
}
|
||||
}
|
||||
};
|
||||
},
|
||||
});
|
||||
} else {
|
||||
if (IS_OSX) {
|
||||
this.watchInParentDirectory();
|
||||
}
|
||||
this.watcher = watchEventSource.watch(this.path);
|
||||
this.watcher =
|
||||
/** @type {EventSourceWatcher} */
|
||||
(watchEventSource.watch(this.path));
|
||||
this.watcher.on("change", this.onWatchEvent.bind(this));
|
||||
this.watcher.on("error", this.onWatcherError.bind(this));
|
||||
}
|
||||
@@ -121,6 +227,11 @@ class DirectoryWatcher extends EventEmitter {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @template {(watcher: Watcher<EventMap>) => void} T
|
||||
* @param {string} path path
|
||||
* @param {T} fn function
|
||||
*/
|
||||
forEachWatcher(path, fn) {
|
||||
const watchers = this.watchers.get(withoutCase(path));
|
||||
if (watchers !== undefined) {
|
||||
@@ -130,20 +241,28 @@ class DirectoryWatcher extends EventEmitter {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string} itemPath an item path
|
||||
* @param {boolean} initial true when initial, otherwise false
|
||||
* @param {EventType} type even type
|
||||
*/
|
||||
setMissing(itemPath, initial, type) {
|
||||
if (this.initialScan) {
|
||||
this.initialScanRemoved.add(itemPath);
|
||||
/** @type {InitialScanRemoved} */
|
||||
(this.initialScanRemoved).add(itemPath);
|
||||
}
|
||||
|
||||
const oldDirectory = this.directories.get(itemPath);
|
||||
if (oldDirectory) {
|
||||
if (this.nestedWatching) oldDirectory.close();
|
||||
if (this.nestedWatching) {
|
||||
/** @type {Watcher<DirectoryWatcherEvents>} */
|
||||
(oldDirectory).close();
|
||||
}
|
||||
this.directories.delete(itemPath);
|
||||
|
||||
this.forEachWatcher(itemPath, w => w.emit("remove", type));
|
||||
this.forEachWatcher(itemPath, (w) => w.emit("remove", type));
|
||||
if (!initial) {
|
||||
this.forEachWatcher(this.path, w =>
|
||||
w.emit("change", itemPath, null, type, initial)
|
||||
this.forEachWatcher(this.path, (w) =>
|
||||
w.emit("change", itemPath, null, type, initial),
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -152,30 +271,38 @@ class DirectoryWatcher extends EventEmitter {
|
||||
if (oldFile) {
|
||||
this.files.delete(itemPath);
|
||||
const key = withoutCase(itemPath);
|
||||
const count = this.filesWithoutCase.get(key) - 1;
|
||||
const count = /** @type {number} */ (this.filesWithoutCase.get(key)) - 1;
|
||||
if (count <= 0) {
|
||||
this.filesWithoutCase.delete(key);
|
||||
this.forEachWatcher(itemPath, w => w.emit("remove", type));
|
||||
this.forEachWatcher(itemPath, (w) => w.emit("remove", type));
|
||||
} else {
|
||||
this.filesWithoutCase.set(key, count);
|
||||
}
|
||||
|
||||
if (!initial) {
|
||||
this.forEachWatcher(this.path, w =>
|
||||
w.emit("change", itemPath, null, type, initial)
|
||||
this.forEachWatcher(this.path, (w) =>
|
||||
w.emit("change", itemPath, null, type, initial),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
setFileTime(filePath, mtime, initial, ignoreWhenEqual, type) {
|
||||
/**
|
||||
* @param {string} target a target to set file time
|
||||
* @param {number} mtime mtime
|
||||
* @param {boolean} initial true when initial, otherwise false
|
||||
* @param {boolean} ignoreWhenEqual true to ignore when equal, otherwise false
|
||||
* @param {EventType} type type
|
||||
*/
|
||||
setFileTime(target, mtime, initial, ignoreWhenEqual, type) {
|
||||
const now = Date.now();
|
||||
|
||||
if (this.ignored(filePath)) return;
|
||||
if (this.ignored(target)) return;
|
||||
|
||||
const old = this.files.get(filePath);
|
||||
const old = this.files.get(target);
|
||||
|
||||
let safeTime, accuracy;
|
||||
let safeTime;
|
||||
let accuracy;
|
||||
if (initial) {
|
||||
safeTime = Math.min(now, mtime) + FS_ACCURACY;
|
||||
accuracy = FS_ACCURACY;
|
||||
@@ -194,14 +321,14 @@ class DirectoryWatcher extends EventEmitter {
|
||||
|
||||
if (ignoreWhenEqual && old && old.timestamp === mtime) return;
|
||||
|
||||
this.files.set(filePath, {
|
||||
this.files.set(target, {
|
||||
safeTime,
|
||||
accuracy,
|
||||
timestamp: mtime
|
||||
timestamp: mtime,
|
||||
});
|
||||
|
||||
if (!old) {
|
||||
const key = withoutCase(filePath);
|
||||
const key = withoutCase(target);
|
||||
const count = this.filesWithoutCase.get(key);
|
||||
this.filesWithoutCase.set(key, (count || 0) + 1);
|
||||
if (count !== undefined) {
|
||||
@@ -213,27 +340,33 @@ class DirectoryWatcher extends EventEmitter {
|
||||
this.doScan(false);
|
||||
}
|
||||
|
||||
this.forEachWatcher(filePath, w => {
|
||||
this.forEachWatcher(target, (w) => {
|
||||
if (!initial || w.checkStartTime(safeTime, initial)) {
|
||||
w.emit("change", mtime, type);
|
||||
}
|
||||
});
|
||||
} else if (!initial) {
|
||||
this.forEachWatcher(filePath, w => w.emit("change", mtime, type));
|
||||
this.forEachWatcher(target, (w) => w.emit("change", mtime, type));
|
||||
}
|
||||
this.forEachWatcher(this.path, w => {
|
||||
this.forEachWatcher(this.path, (w) => {
|
||||
if (!initial || w.checkStartTime(safeTime, initial)) {
|
||||
w.emit("change", filePath, safeTime, type, initial);
|
||||
w.emit("change", target, safeTime, type, initial);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string} directoryPath directory path
|
||||
* @param {number} birthtime birthtime
|
||||
* @param {boolean} initial true when initial, otherwise false
|
||||
* @param {EventType} type even type
|
||||
*/
|
||||
setDirectory(directoryPath, birthtime, initial, type) {
|
||||
if (this.ignored(directoryPath)) return;
|
||||
if (directoryPath === this.path) {
|
||||
if (!initial) {
|
||||
this.forEachWatcher(this.path, w =>
|
||||
w.emit("change", directoryPath, birthtime, type, initial)
|
||||
this.forEachWatcher(this.path, (w) =>
|
||||
w.emit("change", directoryPath, birthtime, type, initial),
|
||||
);
|
||||
}
|
||||
} else {
|
||||
@@ -247,19 +380,14 @@ class DirectoryWatcher extends EventEmitter {
|
||||
this.directories.set(directoryPath, true);
|
||||
}
|
||||
|
||||
let safeTime;
|
||||
if (initial) {
|
||||
safeTime = Math.min(now, birthtime) + FS_ACCURACY;
|
||||
} else {
|
||||
safeTime = now;
|
||||
}
|
||||
const safeTime = initial ? Math.min(now, birthtime) + FS_ACCURACY : now;
|
||||
|
||||
this.forEachWatcher(directoryPath, w => {
|
||||
this.forEachWatcher(directoryPath, (w) => {
|
||||
if (!initial || w.checkStartTime(safeTime, false)) {
|
||||
w.emit("change", birthtime, type);
|
||||
}
|
||||
});
|
||||
this.forEachWatcher(this.path, w => {
|
||||
this.forEachWatcher(this.path, (w) => {
|
||||
if (!initial || w.checkStartTime(safeTime, initial)) {
|
||||
w.emit("change", directoryPath, safeTime, type, initial);
|
||||
}
|
||||
@@ -268,43 +396,57 @@ class DirectoryWatcher extends EventEmitter {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string} directoryPath directory path
|
||||
*/
|
||||
createNestedWatcher(directoryPath) {
|
||||
const watcher = this.watcherManager.watchDirectory(directoryPath, 1);
|
||||
watcher.on("change", (filePath, mtime, type, initial) => {
|
||||
this.forEachWatcher(this.path, w => {
|
||||
watcher.on("change", (target, mtime, type, initial) => {
|
||||
this.forEachWatcher(this.path, (w) => {
|
||||
if (!initial || w.checkStartTime(mtime, initial)) {
|
||||
w.emit("change", filePath, mtime, type, initial);
|
||||
w.emit("change", target, mtime, type, initial);
|
||||
}
|
||||
});
|
||||
});
|
||||
this.directories.set(directoryPath, watcher);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {boolean} flag true when nested, otherwise false
|
||||
*/
|
||||
setNestedWatching(flag) {
|
||||
if (this.nestedWatching !== !!flag) {
|
||||
this.nestedWatching = !!flag;
|
||||
if (this.nestedWatching !== Boolean(flag)) {
|
||||
this.nestedWatching = Boolean(flag);
|
||||
if (this.nestedWatching) {
|
||||
for (const directory of this.directories.keys()) {
|
||||
this.createNestedWatcher(directory);
|
||||
}
|
||||
} else {
|
||||
for (const [directory, watcher] of this.directories) {
|
||||
watcher.close();
|
||||
/** @type {Watcher<DirectoryWatcherEvents>} */
|
||||
(watcher).close();
|
||||
this.directories.set(directory, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
watch(filePath, startTime) {
|
||||
const key = withoutCase(filePath);
|
||||
/**
|
||||
* @param {string} target a target to watch
|
||||
* @param {number=} startTime start time
|
||||
* @returns {Watcher<DirectoryWatcherEvents> | Watcher<FileWatcherEvents>} watcher
|
||||
*/
|
||||
watch(target, startTime) {
|
||||
const key = withoutCase(target);
|
||||
let watchers = this.watchers.get(key);
|
||||
if (watchers === undefined) {
|
||||
watchers = new Set();
|
||||
this.watchers.set(key, watchers);
|
||||
}
|
||||
this.refs++;
|
||||
const watcher = new Watcher(this, filePath, startTime);
|
||||
const watcher =
|
||||
/** @type {Watcher<DirectoryWatcherEvents> | Watcher<FileWatcherEvents>} */
|
||||
(new Watcher(this, target, startTime));
|
||||
watcher.on("closed", () => {
|
||||
if (--this.refs <= 0) {
|
||||
this.close();
|
||||
@@ -313,12 +455,12 @@ class DirectoryWatcher extends EventEmitter {
|
||||
watchers.delete(watcher);
|
||||
if (watchers.size === 0) {
|
||||
this.watchers.delete(key);
|
||||
if (this.path === filePath) this.setNestedWatching(false);
|
||||
if (this.path === target) this.setNestedWatching(false);
|
||||
}
|
||||
});
|
||||
watchers.add(watcher);
|
||||
let safeTime;
|
||||
if (filePath === this.path) {
|
||||
if (target === this.path) {
|
||||
this.setNestedWatching(true);
|
||||
safeTime = this.lastWatchEvent;
|
||||
for (const entry of this.files.values()) {
|
||||
@@ -326,7 +468,7 @@ class DirectoryWatcher extends EventEmitter {
|
||||
safeTime = Math.max(safeTime, entry.safeTime);
|
||||
}
|
||||
} else {
|
||||
const entry = this.files.get(filePath);
|
||||
const entry = this.files.get(target);
|
||||
if (entry) {
|
||||
fixupEntryAccuracy(entry);
|
||||
safeTime = entry.safeTime;
|
||||
@@ -335,38 +477,47 @@ class DirectoryWatcher extends EventEmitter {
|
||||
}
|
||||
}
|
||||
if (safeTime) {
|
||||
if (safeTime >= startTime) {
|
||||
if (startTime && safeTime >= startTime) {
|
||||
process.nextTick(() => {
|
||||
if (this.closed) return;
|
||||
if (filePath === this.path) {
|
||||
watcher.emit(
|
||||
if (target === this.path) {
|
||||
/** @type {Watcher<DirectoryWatcherEvents>} */
|
||||
(watcher).emit(
|
||||
"change",
|
||||
filePath,
|
||||
target,
|
||||
safeTime,
|
||||
"watch (outdated on attach)",
|
||||
true
|
||||
true,
|
||||
);
|
||||
} else {
|
||||
watcher.emit(
|
||||
/** @type {Watcher<FileWatcherEvents>} */
|
||||
(watcher).emit(
|
||||
"change",
|
||||
safeTime,
|
||||
"watch (outdated on attach)",
|
||||
true
|
||||
true,
|
||||
);
|
||||
}
|
||||
});
|
||||
}
|
||||
} else if (this.initialScan) {
|
||||
if (this.initialScanRemoved.has(filePath)) {
|
||||
if (
|
||||
/** @type {InitialScanRemoved} */
|
||||
(this.initialScanRemoved).has(target)
|
||||
) {
|
||||
process.nextTick(() => {
|
||||
if (this.closed) return;
|
||||
watcher.emit("remove");
|
||||
});
|
||||
}
|
||||
} else if (
|
||||
filePath !== this.path &&
|
||||
!this.directories.has(filePath) &&
|
||||
watcher.checkStartTime(this.initialScanFinished, false)
|
||||
target !== this.path &&
|
||||
!this.directories.has(target) &&
|
||||
watcher.checkStartTime(
|
||||
/** @type {number} */
|
||||
(this.initialScanFinished),
|
||||
false,
|
||||
)
|
||||
) {
|
||||
process.nextTick(() => {
|
||||
if (this.closed) return;
|
||||
@@ -376,6 +527,10 @@ class DirectoryWatcher extends EventEmitter {
|
||||
return watcher;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {EventType} eventType event type
|
||||
* @param {string=} filename filename
|
||||
*/
|
||||
onWatchEvent(eventType, filename) {
|
||||
if (this.closed) return;
|
||||
if (!filename) {
|
||||
@@ -387,15 +542,15 @@ class DirectoryWatcher extends EventEmitter {
|
||||
return;
|
||||
}
|
||||
|
||||
const filePath = path.join(this.path, filename);
|
||||
if (this.ignored(filePath)) return;
|
||||
const target = path.join(this.path, filename);
|
||||
if (this.ignored(target)) return;
|
||||
|
||||
if (this._activeEvents.get(filename) === undefined) {
|
||||
this._activeEvents.set(filename, false);
|
||||
const checkStats = () => {
|
||||
if (this.closed) return;
|
||||
this._activeEvents.set(filename, false);
|
||||
fs.lstat(filePath, (err, stats) => {
|
||||
fs.lstat(target, (err, stats) => {
|
||||
if (this.closed) return;
|
||||
if (this._activeEvents.get(filename) === true) {
|
||||
process.nextTick(checkStats);
|
||||
@@ -411,35 +566,28 @@ class DirectoryWatcher extends EventEmitter {
|
||||
err.code !== "EBUSY"
|
||||
) {
|
||||
this.onStatsError(err);
|
||||
} else {
|
||||
if (filename === path.basename(this.path)) {
|
||||
// This may indicate that the directory itself was removed
|
||||
if (!fs.existsSync(this.path)) {
|
||||
this.onDirectoryRemoved("stat failed");
|
||||
}
|
||||
}
|
||||
} else if (
|
||||
filename === path.basename(this.path) && // This may indicate that the directory itself was removed
|
||||
!fs.existsSync(this.path)
|
||||
) {
|
||||
this.onDirectoryRemoved("stat failed");
|
||||
}
|
||||
}
|
||||
this.lastWatchEvent = Date.now();
|
||||
if (!stats) {
|
||||
this.setMissing(filePath, false, eventType);
|
||||
this.setMissing(target, false, eventType);
|
||||
} else if (stats.isDirectory()) {
|
||||
this.setDirectory(
|
||||
filePath,
|
||||
+stats.birthtime || 1,
|
||||
false,
|
||||
eventType
|
||||
);
|
||||
this.setDirectory(target, +stats.birthtime || 1, false, eventType);
|
||||
} else if (stats.isFile() || stats.isSymbolicLink()) {
|
||||
if (stats.mtime) {
|
||||
ensureFsAccuracy(stats.mtime);
|
||||
ensureFsAccuracy(+stats.mtime);
|
||||
}
|
||||
this.setFileTime(
|
||||
filePath,
|
||||
target,
|
||||
+stats.mtime || +stats.ctime || 1,
|
||||
false,
|
||||
false,
|
||||
eventType
|
||||
eventType,
|
||||
);
|
||||
}
|
||||
});
|
||||
@@ -450,25 +598,42 @@ class DirectoryWatcher extends EventEmitter {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {unknown=} err error
|
||||
*/
|
||||
onWatcherError(err) {
|
||||
if (this.closed) return;
|
||||
if (err) {
|
||||
if (err.code !== "EPERM" && err.code !== "ENOENT") {
|
||||
console.error("Watchpack Error (watcher): " + err);
|
||||
if (
|
||||
/** @type {NodeJS.ErrnoException} */
|
||||
(err).code !== "EPERM" &&
|
||||
/** @type {NodeJS.ErrnoException} */
|
||||
(err).code !== "ENOENT"
|
||||
) {
|
||||
// eslint-disable-next-line no-console
|
||||
console.error(`Watchpack Error (watcher): ${err}`);
|
||||
}
|
||||
this.onDirectoryRemoved("watch error");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {Error | NodeJS.ErrnoException=} err error
|
||||
*/
|
||||
onStatsError(err) {
|
||||
if (err) {
|
||||
console.error("Watchpack Error (stats): " + err);
|
||||
// eslint-disable-next-line no-console
|
||||
console.error(`Watchpack Error (stats): ${err}`);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {Error | NodeJS.ErrnoException=} err error
|
||||
*/
|
||||
onScanError(err) {
|
||||
if (err) {
|
||||
console.error("Watchpack Error (initial scan): " + err);
|
||||
// eslint-disable-next-line no-console
|
||||
console.error(`Watchpack Error (initial scan): ${err}`);
|
||||
}
|
||||
this.onScanFinished();
|
||||
}
|
||||
@@ -482,18 +647,21 @@ class DirectoryWatcher extends EventEmitter {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string} reason a reason
|
||||
*/
|
||||
onDirectoryRemoved(reason) {
|
||||
if (this.watcher) {
|
||||
this.watcher.close();
|
||||
this.watcher = null;
|
||||
}
|
||||
this.watchInParentDirectory();
|
||||
const type = `directory-removed (${reason})`;
|
||||
const type = /** @type {EventType} */ (`directory-removed (${reason})`);
|
||||
for (const directory of this.directories.keys()) {
|
||||
this.setMissing(directory, null, type);
|
||||
this.setMissing(directory, false, type);
|
||||
}
|
||||
for (const file of this.files.keys()) {
|
||||
this.setMissing(file, null, type);
|
||||
this.setMissing(file, false, type);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -505,7 +673,8 @@ class DirectoryWatcher extends EventEmitter {
|
||||
if (path.dirname(parentDir) === parentDir) return;
|
||||
|
||||
this.parentWatcher = this.watcherManager.watchFile(this.path, 1);
|
||||
this.parentWatcher.on("change", (mtime, type) => {
|
||||
/** @type {Watcher<FileWatcherEvents>} */
|
||||
(this.parentWatcher).on("change", (mtime, type) => {
|
||||
if (this.closed) return;
|
||||
|
||||
// On non-osx platforms we don't need this watcher to detect
|
||||
@@ -520,17 +689,21 @@ class DirectoryWatcher extends EventEmitter {
|
||||
this.doScan(false);
|
||||
|
||||
// directory was created so we emit an event
|
||||
this.forEachWatcher(this.path, w =>
|
||||
w.emit("change", this.path, mtime, type, false)
|
||||
this.forEachWatcher(this.path, (w) =>
|
||||
w.emit("change", this.path, mtime, type, false),
|
||||
);
|
||||
}
|
||||
});
|
||||
this.parentWatcher.on("remove", () => {
|
||||
/** @type {Watcher<FileWatcherEvents>} */
|
||||
(this.parentWatcher).on("remove", () => {
|
||||
this.onDirectoryRemoved("parent directory removed");
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {boolean} initial true when initial, otherwise false
|
||||
*/
|
||||
doScan(initial) {
|
||||
if (this.scanning) {
|
||||
if (this.scanAgain) {
|
||||
@@ -564,7 +737,7 @@ class DirectoryWatcher extends EventEmitter {
|
||||
if (watcher.checkStartTime(this.initialScanFinished, false)) {
|
||||
watcher.emit(
|
||||
"initial-missing",
|
||||
"scan (parent directory missing in initial scan)"
|
||||
"scan (parent directory missing in initial scan)",
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -579,7 +752,7 @@ class DirectoryWatcher extends EventEmitter {
|
||||
return;
|
||||
}
|
||||
const itemPaths = new Set(
|
||||
items.map(item => path.join(this.path, item.normalize("NFC")))
|
||||
items.map((item) => path.join(this.path, item.normalize("NFC"))),
|
||||
);
|
||||
for (const file of this.files.keys()) {
|
||||
if (!itemPaths.has(file)) {
|
||||
@@ -613,7 +786,7 @@ class DirectoryWatcher extends EventEmitter {
|
||||
if (watcher.checkStartTime(this.initialScanFinished, false)) {
|
||||
watcher.emit(
|
||||
"initial-missing",
|
||||
"scan (missing in initial scan)"
|
||||
"scan (missing in initial scan)",
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -639,7 +812,7 @@ class DirectoryWatcher extends EventEmitter {
|
||||
// TODO https://github.com/libuv/libuv/pull/4566
|
||||
(err2.code === "EINVAL" && IS_WIN)
|
||||
) {
|
||||
this.setMissing(itemPath, initial, "scan (" + err2.code + ")");
|
||||
this.setMissing(itemPath, initial, `scan (${err2.code})`);
|
||||
} else {
|
||||
this.onScanError(err2);
|
||||
}
|
||||
@@ -648,23 +821,25 @@ class DirectoryWatcher extends EventEmitter {
|
||||
}
|
||||
if (stats.isFile() || stats.isSymbolicLink()) {
|
||||
if (stats.mtime) {
|
||||
ensureFsAccuracy(stats.mtime);
|
||||
ensureFsAccuracy(+stats.mtime);
|
||||
}
|
||||
this.setFileTime(
|
||||
itemPath,
|
||||
+stats.mtime || +stats.ctime || 1,
|
||||
initial,
|
||||
true,
|
||||
"scan (file)"
|
||||
"scan (file)",
|
||||
);
|
||||
} else if (
|
||||
stats.isDirectory() &&
|
||||
(!initial || !this.directories.has(itemPath))
|
||||
) {
|
||||
this.setDirectory(
|
||||
itemPath,
|
||||
+stats.birthtime || 1,
|
||||
initial,
|
||||
"scan (dir)",
|
||||
);
|
||||
} else if (stats.isDirectory()) {
|
||||
if (!initial || !this.directories.has(itemPath))
|
||||
this.setDirectory(
|
||||
itemPath,
|
||||
+stats.birthtime || 1,
|
||||
initial,
|
||||
"scan (dir)"
|
||||
);
|
||||
}
|
||||
itemFinished();
|
||||
});
|
||||
@@ -674,6 +849,9 @@ class DirectoryWatcher extends EventEmitter {
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* @returns {Record<string, number>} times
|
||||
*/
|
||||
getTimes() {
|
||||
const obj = Object.create(null);
|
||||
let safeTime = this.lastWatchEvent;
|
||||
@@ -684,7 +862,9 @@ class DirectoryWatcher extends EventEmitter {
|
||||
}
|
||||
if (this.nestedWatching) {
|
||||
for (const w of this.directories.values()) {
|
||||
const times = w.directoryWatcher.getTimes();
|
||||
const times =
|
||||
/** @type {Watcher<DirectoryWatcherEvents>} */
|
||||
(w).directoryWatcher.getTimes();
|
||||
for (const file of Object.keys(times)) {
|
||||
const time = times[file];
|
||||
safeTime = Math.max(safeTime, time);
|
||||
@@ -696,7 +876,7 @@ class DirectoryWatcher extends EventEmitter {
|
||||
if (!this.initialScan) {
|
||||
for (const watchers of this.watchers.values()) {
|
||||
for (const watcher of watchers) {
|
||||
const path = watcher.path;
|
||||
const { path } = watcher;
|
||||
if (!Object.prototype.hasOwnProperty.call(obj, path)) {
|
||||
obj[path] = null;
|
||||
}
|
||||
@@ -706,6 +886,11 @@ class DirectoryWatcher extends EventEmitter {
|
||||
return obj;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {TimeInfoEntries} fileTimestamps file timestamps
|
||||
* @param {TimeInfoEntries} directoryTimestamps directory timestamps
|
||||
* @returns {number} safe time
|
||||
*/
|
||||
collectTimeInfoEntries(fileTimestamps, directoryTimestamps) {
|
||||
let safeTime = this.lastWatchEvent;
|
||||
for (const [file, entry] of this.files) {
|
||||
@@ -717,23 +902,25 @@ class DirectoryWatcher extends EventEmitter {
|
||||
for (const w of this.directories.values()) {
|
||||
safeTime = Math.max(
|
||||
safeTime,
|
||||
w.directoryWatcher.collectTimeInfoEntries(
|
||||
/** @type {Watcher<DirectoryWatcherEvents>} */
|
||||
(w).directoryWatcher.collectTimeInfoEntries(
|
||||
fileTimestamps,
|
||||
directoryTimestamps
|
||||
)
|
||||
directoryTimestamps,
|
||||
),
|
||||
);
|
||||
}
|
||||
fileTimestamps.set(this.path, EXISTANCE_ONLY_TIME_ENTRY);
|
||||
directoryTimestamps.set(this.path, {
|
||||
safeTime
|
||||
safeTime,
|
||||
});
|
||||
} else {
|
||||
for (const dir of this.directories.keys()) {
|
||||
// No additional info about this directory
|
||||
// but maybe another DirectoryWatcher has info
|
||||
fileTimestamps.set(dir, EXISTANCE_ONLY_TIME_ENTRY);
|
||||
if (!directoryTimestamps.has(dir))
|
||||
if (!directoryTimestamps.has(dir)) {
|
||||
directoryTimestamps.set(dir, EXISTANCE_ONLY_TIME_ENTRY);
|
||||
}
|
||||
}
|
||||
fileTimestamps.set(this.path, EXISTANCE_ONLY_TIME_ENTRY);
|
||||
directoryTimestamps.set(this.path, EXISTANCE_ONLY_TIME_ENTRY);
|
||||
@@ -741,7 +928,7 @@ class DirectoryWatcher extends EventEmitter {
|
||||
if (!this.initialScan) {
|
||||
for (const watchers of this.watchers.values()) {
|
||||
for (const watcher of watchers) {
|
||||
const path = watcher.path;
|
||||
const { path } = watcher;
|
||||
if (!fileTimestamps.has(path)) {
|
||||
fileTimestamps.set(path, null);
|
||||
}
|
||||
@@ -760,7 +947,8 @@ class DirectoryWatcher extends EventEmitter {
|
||||
}
|
||||
if (this.nestedWatching) {
|
||||
for (const w of this.directories.values()) {
|
||||
w.close();
|
||||
/** @type {Watcher<DirectoryWatcherEvents>} */
|
||||
(w).close();
|
||||
}
|
||||
this.directories.clear();
|
||||
}
|
||||
@@ -774,18 +962,4 @@ class DirectoryWatcher extends EventEmitter {
|
||||
|
||||
module.exports = DirectoryWatcher;
|
||||
module.exports.EXISTANCE_ONLY_TIME_ENTRY = EXISTANCE_ONLY_TIME_ENTRY;
|
||||
|
||||
function fixupEntryAccuracy(entry) {
|
||||
if (entry.accuracy > FS_ACCURACY) {
|
||||
entry.safeTime = entry.safeTime - entry.accuracy + FS_ACCURACY;
|
||||
entry.accuracy = FS_ACCURACY;
|
||||
}
|
||||
}
|
||||
|
||||
function ensureFsAccuracy(mtime) {
|
||||
if (!mtime) return;
|
||||
if (FS_ACCURACY > 1 && mtime % 1 !== 0) FS_ACCURACY = 1;
|
||||
else if (FS_ACCURACY > 10 && mtime % 10 !== 0) FS_ACCURACY = 10;
|
||||
else if (FS_ACCURACY > 100 && mtime % 100 !== 0) FS_ACCURACY = 100;
|
||||
else if (FS_ACCURACY > 1000 && mtime % 1000 !== 0) FS_ACCURACY = 1000;
|
||||
}
|
||||
module.exports.Watcher = Watcher;
|
||||
|
||||
25
node_modules/watchpack/lib/LinkResolver.js
generated
vendored
Executable file → Normal file
25
node_modules/watchpack/lib/LinkResolver.js
generated
vendored
Executable file → Normal file
@@ -15,12 +15,13 @@ if (process.platform === "win32") EXPECTED_ERRORS.add("UNKNOWN");
|
||||
|
||||
class LinkResolver {
|
||||
constructor() {
|
||||
/** @type {Map<string, readonly string[]>} */
|
||||
this.cache = new Map();
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string} file path to file or directory
|
||||
* @returns {string[]} array of file and all symlinks contributed in the resolving process (first item is the resolved file)
|
||||
* @returns {readonly string[]} array of file and all symlinks contributed in the resolving process (first item is the resolved file)
|
||||
*/
|
||||
resolve(file) {
|
||||
const cacheEntry = this.cache.get(file);
|
||||
@@ -65,17 +66,18 @@ class LinkResolver {
|
||||
for (let i = 1; i < parentResolved.length; i++) {
|
||||
resultSet.add(parentResolved[i]);
|
||||
}
|
||||
result = Object.freeze(Array.from(resultSet));
|
||||
result = Object.freeze([...resultSet]);
|
||||
} else if (parentResolved.length > 1) {
|
||||
// we have links in the parent but not for the link content location
|
||||
result = parentResolved.slice();
|
||||
result = [...parentResolved];
|
||||
// eslint-disable-next-line prefer-destructuring
|
||||
result[0] = linkResolved[0];
|
||||
// add the link
|
||||
result.push(realFile);
|
||||
Object.freeze(result);
|
||||
} else if (linkResolved.length > 1) {
|
||||
// we can return the link content location result
|
||||
result = linkResolved.slice();
|
||||
result = [...linkResolved];
|
||||
// add the link
|
||||
result.push(realFile);
|
||||
Object.freeze(result);
|
||||
@@ -86,17 +88,21 @@ class LinkResolver {
|
||||
// the resolve real location
|
||||
linkResolved[0],
|
||||
// add the link
|
||||
realFile
|
||||
realFile,
|
||||
]);
|
||||
}
|
||||
this.cache.set(file, result);
|
||||
return result;
|
||||
} catch (e) {
|
||||
if (!EXPECTED_ERRORS.has(e.code)) {
|
||||
throw e;
|
||||
} catch (err) {
|
||||
if (
|
||||
/** @type {NodeJS.ErrnoException} */
|
||||
(err).code &&
|
||||
!EXPECTED_ERRORS.has(/** @type {NodeJS.ErrnoException} */ (err).code)
|
||||
) {
|
||||
throw err;
|
||||
}
|
||||
// no link
|
||||
const result = parentResolved.slice();
|
||||
const result = [...parentResolved];
|
||||
result[0] = realFile;
|
||||
Object.freeze(result);
|
||||
this.cache.set(file, result);
|
||||
@@ -104,4 +110,5 @@ class LinkResolver {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = LinkResolver;
|
||||
|
||||
42
node_modules/watchpack/lib/getWatcherManager.js
generated
vendored
Executable file → Normal file
42
node_modules/watchpack/lib/getWatcherManager.js
generated
vendored
Executable file → Normal file
@@ -7,12 +7,29 @@
|
||||
const path = require("path");
|
||||
const DirectoryWatcher = require("./DirectoryWatcher");
|
||||
|
||||
/** @typedef {import("./index").EventMap} EventMap */
|
||||
/** @typedef {import("./DirectoryWatcher").DirectoryWatcherOptions} DirectoryWatcherOptions */
|
||||
/** @typedef {import("./DirectoryWatcher").DirectoryWatcherEvents} DirectoryWatcherEvents */
|
||||
/** @typedef {import("./DirectoryWatcher").FileWatcherEvents} FileWatcherEvents */
|
||||
/**
|
||||
* @template {EventMap} T
|
||||
* @typedef {import("./DirectoryWatcher").Watcher<T>} Watcher
|
||||
*/
|
||||
|
||||
class WatcherManager {
|
||||
constructor(options) {
|
||||
/**
|
||||
* @param {DirectoryWatcherOptions=} options options
|
||||
*/
|
||||
constructor(options = {}) {
|
||||
this.options = options;
|
||||
/** @type {Map<string, DirectoryWatcher>} */
|
||||
this.directoryWatchers = new Map();
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string} directory a directory
|
||||
* @returns {DirectoryWatcher} a directory watcher
|
||||
*/
|
||||
getDirectoryWatcher(directory) {
|
||||
const watcher = this.directoryWatchers.get(directory);
|
||||
if (watcher === undefined) {
|
||||
@@ -26,23 +43,34 @@ class WatcherManager {
|
||||
return watcher;
|
||||
}
|
||||
|
||||
watchFile(p, startTime) {
|
||||
const directory = path.dirname(p);
|
||||
if (directory === p) return null;
|
||||
return this.getDirectoryWatcher(directory).watch(p, startTime);
|
||||
/**
|
||||
* @param {string} file file
|
||||
* @param {number=} startTime start time
|
||||
* @returns {Watcher<FileWatcherEvents> | null} watcher or null if file has no directory
|
||||
*/
|
||||
watchFile(file, startTime) {
|
||||
const directory = path.dirname(file);
|
||||
if (directory === file) return null;
|
||||
return this.getDirectoryWatcher(directory).watch(file, startTime);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string} directory directory
|
||||
* @param {number=} startTime start time
|
||||
* @returns {Watcher<DirectoryWatcherEvents>} watcher
|
||||
*/
|
||||
watchDirectory(directory, startTime) {
|
||||
return this.getDirectoryWatcher(directory).watch(directory, startTime);
|
||||
}
|
||||
}
|
||||
|
||||
const watcherManagers = new WeakMap();
|
||||
|
||||
/**
|
||||
* @param {object} options options
|
||||
* @param {DirectoryWatcherOptions} options options
|
||||
* @returns {WatcherManager} the watcher manager
|
||||
*/
|
||||
module.exports = options => {
|
||||
module.exports = (options) => {
|
||||
const watcherManager = watcherManagers.get(options);
|
||||
if (watcherManager !== undefined) return watcherManager;
|
||||
const newWatcherManager = new WatcherManager(options);
|
||||
|
||||
554
node_modules/watchpack/lib/index.js
generated
vendored
Normal file
554
node_modules/watchpack/lib/index.js
generated
vendored
Normal file
@@ -0,0 +1,554 @@
|
||||
/*
|
||||
MIT License http://www.opensource.org/licenses/mit-license.php
|
||||
Author Tobias Koppers @sokra
|
||||
*/
|
||||
"use strict";
|
||||
|
||||
const { EventEmitter } = require("events");
|
||||
const globToRegExp = require("glob-to-regexp");
|
||||
const LinkResolver = require("./LinkResolver");
|
||||
const getWatcherManager = require("./getWatcherManager");
|
||||
const watchEventSource = require("./watchEventSource");
|
||||
|
||||
/** @typedef {import("./getWatcherManager").WatcherManager} WatcherManager */
|
||||
/** @typedef {import("./DirectoryWatcher")} DirectoryWatcher */
|
||||
/** @typedef {import("./DirectoryWatcher").DirectoryWatcherEvents} DirectoryWatcherEvents */
|
||||
/** @typedef {import("./DirectoryWatcher").FileWatcherEvents} FileWatcherEvents */
|
||||
|
||||
// eslint-disable-next-line jsdoc/reject-any-type
|
||||
/** @typedef {Record<string, (...args: any[]) => any>} EventMap */
|
||||
|
||||
/**
|
||||
* @template {EventMap} T
|
||||
* @typedef {import("./DirectoryWatcher").Watcher<T>} Watcher
|
||||
*/
|
||||
|
||||
/** @typedef {(item: string) => boolean} IgnoredFunction */
|
||||
/** @typedef {string[] | RegExp | string | IgnoredFunction} Ignored */
|
||||
|
||||
/**
|
||||
* @typedef {object} WatcherOptions
|
||||
* @property {boolean=} followSymlinks true when need to resolve symlinks and watch symlink and real file, otherwise false
|
||||
* @property {Ignored=} ignored ignore some files from watching (glob pattern or regexp)
|
||||
* @property {number | boolean=} poll true when need to enable polling mode for watching, otherwise false
|
||||
*/
|
||||
|
||||
/** @typedef {WatcherOptions & { aggregateTimeout?: number }} WatchOptions */
|
||||
|
||||
/**
|
||||
* @typedef {object} NormalizedWatchOptions
|
||||
* @property {boolean} followSymlinks true when need to resolve symlinks and watch symlink and real file, otherwise false
|
||||
* @property {IgnoredFunction} ignored ignore some files from watching (glob pattern or regexp)
|
||||
* @property {number | boolean=} poll true when need to enable polling mode for watching, otherwise false
|
||||
*/
|
||||
|
||||
/** @typedef {`scan (${string})` | "change" | "rename" | `watch ${string}` | `directory-removed ${string}`} EventType */
|
||||
/** @typedef {{ safeTime: number, timestamp: number, accuracy: number }} Entry */
|
||||
/** @typedef {{ safeTime: number }} OnlySafeTimeEntry */
|
||||
// eslint-disable-next-line jsdoc/ts-no-empty-object-type
|
||||
/** @typedef {{}} ExistanceOnlyTimeEntry */
|
||||
/** @typedef {Map<string, Entry | OnlySafeTimeEntry | ExistanceOnlyTimeEntry | null>} TimeInfoEntries */
|
||||
/** @typedef {Set<string>} Changes */
|
||||
/** @typedef {Set<string>} Removals */
|
||||
/** @typedef {{ changes: Changes, removals: Removals }} Aggregated */
|
||||
/** @typedef {{ files?: Iterable<string>, directories?: Iterable<string>, missing?: Iterable<string>, startTime?: number }} WatchMethodOptions */
|
||||
/** @typedef {Record<string, number>} Times */
|
||||
|
||||
/**
|
||||
* @param {MapIterator<WatchpackFileWatcher> | MapIterator<WatchpackDirectoryWatcher>} watchers watchers
|
||||
* @param {Set<DirectoryWatcher>} set set
|
||||
*/
|
||||
function addWatchersToSet(watchers, set) {
|
||||
for (const ww of watchers) {
|
||||
const w = ww.watcher;
|
||||
if (!set.has(w.directoryWatcher)) {
|
||||
set.add(w.directoryWatcher);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string} ignored ignored
|
||||
* @returns {string | undefined} resolved global to regexp
|
||||
*/
|
||||
const stringToRegexp = (ignored) => {
|
||||
if (ignored.length === 0) {
|
||||
return;
|
||||
}
|
||||
const { source } = globToRegExp(ignored, { globstar: true, extended: true });
|
||||
return `${source.slice(0, -1)}(?:$|\\/)`;
|
||||
};
|
||||
|
||||
/**
|
||||
* @param {Ignored=} ignored ignored
|
||||
* @returns {(item: string) => boolean} ignored to function
|
||||
*/
|
||||
const ignoredToFunction = (ignored) => {
|
||||
if (Array.isArray(ignored)) {
|
||||
const stringRegexps = ignored.map((i) => stringToRegexp(i)).filter(Boolean);
|
||||
if (stringRegexps.length === 0) {
|
||||
return () => false;
|
||||
}
|
||||
const regexp = new RegExp(stringRegexps.join("|"));
|
||||
return (item) => regexp.test(item.replace(/\\/g, "/"));
|
||||
} else if (typeof ignored === "string") {
|
||||
const stringRegexp = stringToRegexp(ignored);
|
||||
if (!stringRegexp) {
|
||||
return () => false;
|
||||
}
|
||||
const regexp = new RegExp(stringRegexp);
|
||||
return (item) => regexp.test(item.replace(/\\/g, "/"));
|
||||
} else if (ignored instanceof RegExp) {
|
||||
return (item) => ignored.test(item.replace(/\\/g, "/"));
|
||||
} else if (typeof ignored === "function") {
|
||||
return ignored;
|
||||
} else if (ignored) {
|
||||
throw new Error(`Invalid option for 'ignored': ${ignored}`);
|
||||
} else {
|
||||
return () => false;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @param {WatchOptions} options options
|
||||
* @returns {NormalizedWatchOptions} normalized options
|
||||
*/
|
||||
const normalizeOptions = (options) => ({
|
||||
followSymlinks: Boolean(options.followSymlinks),
|
||||
ignored: ignoredToFunction(options.ignored),
|
||||
poll: options.poll,
|
||||
});
|
||||
|
||||
const normalizeCache = new WeakMap();
|
||||
/**
|
||||
* @param {WatchOptions} options options
|
||||
* @returns {NormalizedWatchOptions} normalized options
|
||||
*/
|
||||
const cachedNormalizeOptions = (options) => {
|
||||
const cacheEntry = normalizeCache.get(options);
|
||||
if (cacheEntry !== undefined) return cacheEntry;
|
||||
const normalized = normalizeOptions(options);
|
||||
normalizeCache.set(options, normalized);
|
||||
return normalized;
|
||||
};
|
||||
|
||||
class WatchpackFileWatcher {
|
||||
/**
|
||||
* @param {Watchpack} watchpack watchpack
|
||||
* @param {Watcher<FileWatcherEvents>} watcher watcher
|
||||
* @param {string | string[]} files files
|
||||
*/
|
||||
constructor(watchpack, watcher, files) {
|
||||
/** @type {string[]} */
|
||||
this.files = Array.isArray(files) ? files : [files];
|
||||
this.watcher = watcher;
|
||||
watcher.on("initial-missing", (type) => {
|
||||
for (const file of this.files) {
|
||||
if (!watchpack._missing.has(file)) {
|
||||
watchpack._onRemove(file, file, type);
|
||||
}
|
||||
}
|
||||
});
|
||||
watcher.on("change", (mtime, type, _initial) => {
|
||||
for (const file of this.files) {
|
||||
watchpack._onChange(file, mtime, file, type);
|
||||
}
|
||||
});
|
||||
watcher.on("remove", (type) => {
|
||||
for (const file of this.files) {
|
||||
watchpack._onRemove(file, file, type);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string | string[]} files files
|
||||
*/
|
||||
update(files) {
|
||||
if (!Array.isArray(files)) {
|
||||
if (this.files.length !== 1) {
|
||||
this.files = [files];
|
||||
} else if (this.files[0] !== files) {
|
||||
this.files[0] = files;
|
||||
}
|
||||
} else {
|
||||
this.files = files;
|
||||
}
|
||||
}
|
||||
|
||||
close() {
|
||||
this.watcher.close();
|
||||
}
|
||||
}
|
||||
|
||||
class WatchpackDirectoryWatcher {
|
||||
/**
|
||||
* @param {Watchpack} watchpack watchpack
|
||||
* @param {Watcher<DirectoryWatcherEvents>} watcher watcher
|
||||
* @param {string} directories directories
|
||||
*/
|
||||
constructor(watchpack, watcher, directories) {
|
||||
/** @type {string[]} */
|
||||
this.directories = Array.isArray(directories) ? directories : [directories];
|
||||
this.watcher = watcher;
|
||||
watcher.on("initial-missing", (type) => {
|
||||
for (const item of this.directories) {
|
||||
watchpack._onRemove(item, item, type);
|
||||
}
|
||||
});
|
||||
watcher.on("change", (file, mtime, type, _initial) => {
|
||||
for (const item of this.directories) {
|
||||
watchpack._onChange(item, mtime, file, type);
|
||||
}
|
||||
});
|
||||
watcher.on("remove", (type) => {
|
||||
for (const item of this.directories) {
|
||||
watchpack._onRemove(item, item, type);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string | string[]} directories directories
|
||||
*/
|
||||
update(directories) {
|
||||
if (!Array.isArray(directories)) {
|
||||
if (this.directories.length !== 1) {
|
||||
this.directories = [directories];
|
||||
} else if (this.directories[0] !== directories) {
|
||||
this.directories[0] = directories;
|
||||
}
|
||||
} else {
|
||||
this.directories = directories;
|
||||
}
|
||||
}
|
||||
|
||||
close() {
|
||||
this.watcher.close();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @typedef {object} WatchpackEvents
|
||||
* @property {(file: string, mtime: number, type: EventType) => void} change change event
|
||||
* @property {(file: string, type: EventType) => void} remove remove event
|
||||
* @property {(changes: Changes, removals: Removals) => void} aggregated aggregated event
|
||||
*/
|
||||
|
||||
/**
|
||||
* @extends {EventEmitter<{ [K in keyof WatchpackEvents]: Parameters<WatchpackEvents[K]> }>}
|
||||
*/
|
||||
class Watchpack extends EventEmitter {
|
||||
/**
|
||||
* @param {WatchOptions=} options options
|
||||
*/
|
||||
constructor(options = {}) {
|
||||
super();
|
||||
if (!options) options = {};
|
||||
/** @type {WatchOptions} */
|
||||
this.options = options;
|
||||
this.aggregateTimeout =
|
||||
typeof options.aggregateTimeout === "number"
|
||||
? options.aggregateTimeout
|
||||
: 200;
|
||||
/** @type {NormalizedWatchOptions} */
|
||||
this.watcherOptions = cachedNormalizeOptions(options);
|
||||
/** @type {WatcherManager} */
|
||||
this.watcherManager = getWatcherManager(this.watcherOptions);
|
||||
/** @type {Map<string, WatchpackFileWatcher>} */
|
||||
this.fileWatchers = new Map();
|
||||
/** @type {Map<string, WatchpackDirectoryWatcher>} */
|
||||
this.directoryWatchers = new Map();
|
||||
/** @type {Set<string>} */
|
||||
this._missing = new Set();
|
||||
this.startTime = undefined;
|
||||
this.paused = false;
|
||||
/** @type {Changes} */
|
||||
this.aggregatedChanges = new Set();
|
||||
/** @type {Removals} */
|
||||
this.aggregatedRemovals = new Set();
|
||||
/** @type {undefined | NodeJS.Timeout} */
|
||||
this.aggregateTimer = undefined;
|
||||
this._onTimeout = this._onTimeout.bind(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* @overload
|
||||
* @param {Iterable<string>} arg1 files
|
||||
* @param {Iterable<string>} arg2 directories
|
||||
* @param {number=} arg3 startTime
|
||||
* @returns {void}
|
||||
*/
|
||||
/**
|
||||
* @overload
|
||||
* @param {WatchMethodOptions} arg1 watch options
|
||||
* @returns {void}
|
||||
*/
|
||||
/**
|
||||
* @param {Iterable<string> | WatchMethodOptions} arg1 files
|
||||
* @param {Iterable<string>=} arg2 directories
|
||||
* @param {number=} arg3 startTime
|
||||
* @returns {void}
|
||||
*/
|
||||
watch(arg1, arg2, arg3) {
|
||||
/** @type {Iterable<string> | undefined} */
|
||||
let files;
|
||||
/** @type {Iterable<string> | undefined} */
|
||||
let directories;
|
||||
/** @type {Iterable<string> | undefined} */
|
||||
let missing;
|
||||
/** @type {number | undefined} */
|
||||
let startTime;
|
||||
if (!arg2) {
|
||||
({
|
||||
files = [],
|
||||
directories = [],
|
||||
missing = [],
|
||||
startTime,
|
||||
} = /** @type {WatchMethodOptions} */ (arg1));
|
||||
} else {
|
||||
files = /** @type {Iterable<string>} */ (arg1);
|
||||
directories = /** @type {Iterable<string>} */ (arg2);
|
||||
missing = [];
|
||||
startTime = /** @type {number} */ (arg3);
|
||||
}
|
||||
this.paused = false;
|
||||
const { fileWatchers, directoryWatchers } = this;
|
||||
const { ignored } = this.watcherOptions;
|
||||
/**
|
||||
* @param {string} path path
|
||||
* @returns {boolean} true when need to filter, otherwise false
|
||||
*/
|
||||
const filter = (path) => !ignored(path);
|
||||
/**
|
||||
* @template K, V
|
||||
* @param {Map<K, V | V[]>} map map
|
||||
* @param {K} key key
|
||||
* @param {V} item item
|
||||
*/
|
||||
const addToMap = (map, key, item) => {
|
||||
const list = map.get(key);
|
||||
if (list === undefined) {
|
||||
map.set(key, item);
|
||||
} else if (Array.isArray(list)) {
|
||||
list.push(item);
|
||||
} else {
|
||||
map.set(key, [list, item]);
|
||||
}
|
||||
};
|
||||
const fileWatchersNeeded = new Map();
|
||||
const directoryWatchersNeeded = new Map();
|
||||
/** @type {Set<string>} */
|
||||
const missingFiles = new Set();
|
||||
if (this.watcherOptions.followSymlinks) {
|
||||
const resolver = new LinkResolver();
|
||||
for (const file of files) {
|
||||
if (filter(file)) {
|
||||
for (const innerFile of resolver.resolve(file)) {
|
||||
if (file === innerFile || filter(innerFile)) {
|
||||
addToMap(fileWatchersNeeded, innerFile, file);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const file of missing) {
|
||||
if (filter(file)) {
|
||||
for (const innerFile of resolver.resolve(file)) {
|
||||
if (file === innerFile || filter(innerFile)) {
|
||||
missingFiles.add(file);
|
||||
addToMap(fileWatchersNeeded, innerFile, file);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const dir of directories) {
|
||||
if (filter(dir)) {
|
||||
let first = true;
|
||||
for (const innerItem of resolver.resolve(dir)) {
|
||||
if (filter(innerItem)) {
|
||||
addToMap(
|
||||
first ? directoryWatchersNeeded : fileWatchersNeeded,
|
||||
innerItem,
|
||||
dir,
|
||||
);
|
||||
}
|
||||
first = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (const file of files) {
|
||||
if (filter(file)) {
|
||||
addToMap(fileWatchersNeeded, file, file);
|
||||
}
|
||||
}
|
||||
for (const file of missing) {
|
||||
if (filter(file)) {
|
||||
missingFiles.add(file);
|
||||
addToMap(fileWatchersNeeded, file, file);
|
||||
}
|
||||
}
|
||||
for (const dir of directories) {
|
||||
if (filter(dir)) {
|
||||
addToMap(directoryWatchersNeeded, dir, dir);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Close unneeded old watchers
|
||||
// and update existing watchers
|
||||
for (const [key, w] of fileWatchers) {
|
||||
const needed = fileWatchersNeeded.get(key);
|
||||
if (needed === undefined) {
|
||||
w.close();
|
||||
fileWatchers.delete(key);
|
||||
} else {
|
||||
w.update(needed);
|
||||
fileWatchersNeeded.delete(key);
|
||||
}
|
||||
}
|
||||
for (const [key, w] of directoryWatchers) {
|
||||
const needed = directoryWatchersNeeded.get(key);
|
||||
if (needed === undefined) {
|
||||
w.close();
|
||||
directoryWatchers.delete(key);
|
||||
} else {
|
||||
w.update(needed);
|
||||
directoryWatchersNeeded.delete(key);
|
||||
}
|
||||
}
|
||||
// Create new watchers and install handlers on these watchers
|
||||
watchEventSource.batch(() => {
|
||||
for (const [key, files] of fileWatchersNeeded) {
|
||||
const watcher = this.watcherManager.watchFile(key, startTime);
|
||||
if (watcher) {
|
||||
fileWatchers.set(key, new WatchpackFileWatcher(this, watcher, files));
|
||||
}
|
||||
}
|
||||
for (const [key, directories] of directoryWatchersNeeded) {
|
||||
const watcher = this.watcherManager.watchDirectory(key, startTime);
|
||||
if (watcher) {
|
||||
directoryWatchers.set(
|
||||
key,
|
||||
new WatchpackDirectoryWatcher(this, watcher, directories),
|
||||
);
|
||||
}
|
||||
}
|
||||
});
|
||||
this._missing = missingFiles;
|
||||
this.startTime = startTime;
|
||||
}
|
||||
|
||||
close() {
|
||||
this.paused = true;
|
||||
if (this.aggregateTimer) clearTimeout(this.aggregateTimer);
|
||||
for (const w of this.fileWatchers.values()) w.close();
|
||||
for (const w of this.directoryWatchers.values()) w.close();
|
||||
this.fileWatchers.clear();
|
||||
this.directoryWatchers.clear();
|
||||
}
|
||||
|
||||
pause() {
|
||||
this.paused = true;
|
||||
if (this.aggregateTimer) clearTimeout(this.aggregateTimer);
|
||||
}
|
||||
|
||||
/**
|
||||
* @returns {Record<string, number>} times
|
||||
*/
|
||||
getTimes() {
|
||||
/** @type {Set<DirectoryWatcher>} */
|
||||
const directoryWatchers = new Set();
|
||||
addWatchersToSet(this.fileWatchers.values(), directoryWatchers);
|
||||
addWatchersToSet(this.directoryWatchers.values(), directoryWatchers);
|
||||
/** @type {Record<string, number>} */
|
||||
const obj = Object.create(null);
|
||||
for (const w of directoryWatchers) {
|
||||
const times = w.getTimes();
|
||||
for (const file of Object.keys(times)) obj[file] = times[file];
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
|
||||
/**
|
||||
* @returns {TimeInfoEntries} time info entries
|
||||
*/
|
||||
getTimeInfoEntries() {
|
||||
/** @type {TimeInfoEntries} */
|
||||
const map = new Map();
|
||||
this.collectTimeInfoEntries(map, map);
|
||||
return map;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {TimeInfoEntries} fileTimestamps file timestamps
|
||||
* @param {TimeInfoEntries} directoryTimestamps directory timestamps
|
||||
*/
|
||||
collectTimeInfoEntries(fileTimestamps, directoryTimestamps) {
|
||||
/** @type {Set<DirectoryWatcher>} */
|
||||
const allWatchers = new Set();
|
||||
addWatchersToSet(this.fileWatchers.values(), allWatchers);
|
||||
addWatchersToSet(this.directoryWatchers.values(), allWatchers);
|
||||
for (const w of allWatchers) {
|
||||
w.collectTimeInfoEntries(fileTimestamps, directoryTimestamps);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @returns {Aggregated} aggregated info
|
||||
*/
|
||||
getAggregated() {
|
||||
if (this.aggregateTimer) {
|
||||
clearTimeout(this.aggregateTimer);
|
||||
this.aggregateTimer = undefined;
|
||||
}
|
||||
const changes = this.aggregatedChanges;
|
||||
const removals = this.aggregatedRemovals;
|
||||
this.aggregatedChanges = new Set();
|
||||
this.aggregatedRemovals = new Set();
|
||||
return { changes, removals };
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string} item item
|
||||
* @param {number} mtime mtime
|
||||
* @param {string} file file
|
||||
* @param {EventType} type type
|
||||
*/
|
||||
_onChange(item, mtime, file, type) {
|
||||
file = file || item;
|
||||
if (!this.paused) {
|
||||
this.emit("change", file, mtime, type);
|
||||
if (this.aggregateTimer) clearTimeout(this.aggregateTimer);
|
||||
this.aggregateTimer = setTimeout(this._onTimeout, this.aggregateTimeout);
|
||||
}
|
||||
this.aggregatedRemovals.delete(item);
|
||||
this.aggregatedChanges.add(item);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string} item item
|
||||
* @param {string} file file
|
||||
* @param {EventType} type type
|
||||
*/
|
||||
_onRemove(item, file, type) {
|
||||
file = file || item;
|
||||
if (!this.paused) {
|
||||
this.emit("remove", file, type);
|
||||
if (this.aggregateTimer) clearTimeout(this.aggregateTimer);
|
||||
this.aggregateTimer = setTimeout(this._onTimeout, this.aggregateTimeout);
|
||||
}
|
||||
this.aggregatedChanges.delete(item);
|
||||
this.aggregatedRemovals.add(item);
|
||||
}
|
||||
|
||||
_onTimeout() {
|
||||
this.aggregateTimer = undefined;
|
||||
const changes = this.aggregatedChanges;
|
||||
const removals = this.aggregatedRemovals;
|
||||
this.aggregatedChanges = new Set();
|
||||
this.aggregatedRemovals = new Set();
|
||||
this.emit("aggregated", changes, removals);
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = Watchpack;
|
||||
44
node_modules/watchpack/lib/reducePlan.js
generated
vendored
Executable file → Normal file
44
node_modules/watchpack/lib/reducePlan.js
generated
vendored
Executable file → Normal file
@@ -8,48 +8,48 @@ const path = require("path");
|
||||
|
||||
/**
|
||||
* @template T
|
||||
* @typedef {Object} TreeNode
|
||||
* @property {string} filePath
|
||||
* @property {TreeNode} parent
|
||||
* @property {TreeNode[]} children
|
||||
* @property {number} entries
|
||||
* @property {boolean} active
|
||||
* @property {T[] | T | undefined} value
|
||||
* @typedef {object} TreeNode
|
||||
* @property {string} target target
|
||||
* @property {TreeNode<T>} parent parent
|
||||
* @property {TreeNode<T>[]} children children
|
||||
* @property {number} entries number of entries
|
||||
* @property {boolean} active true when active, otherwise false
|
||||
* @property {T[] | T | undefined} value value
|
||||
*/
|
||||
|
||||
/**
|
||||
* @template T
|
||||
* @param {Map<string, T[] | T} plan
|
||||
* @param {number} limit
|
||||
* @param {Map<string, T[] | T>} plan plan
|
||||
* @param {number} limit limit
|
||||
* @returns {Map<string, Map<T, string>>} the new plan
|
||||
*/
|
||||
module.exports = (plan, limit) => {
|
||||
const treeMap = new Map();
|
||||
// Convert to tree
|
||||
for (const [filePath, value] of plan) {
|
||||
treeMap.set(filePath, {
|
||||
filePath,
|
||||
for (const [target, value] of plan) {
|
||||
treeMap.set(target, {
|
||||
target,
|
||||
parent: undefined,
|
||||
children: undefined,
|
||||
entries: 1,
|
||||
active: true,
|
||||
value
|
||||
value,
|
||||
});
|
||||
}
|
||||
let currentCount = treeMap.size;
|
||||
// Create parents and calculate sum of entries
|
||||
for (const node of treeMap.values()) {
|
||||
const parentPath = path.dirname(node.filePath);
|
||||
if (parentPath !== node.filePath) {
|
||||
const parentPath = path.dirname(node.target);
|
||||
if (parentPath !== node.target) {
|
||||
let parent = treeMap.get(parentPath);
|
||||
if (parent === undefined) {
|
||||
parent = {
|
||||
filePath: parentPath,
|
||||
target: parentPath,
|
||||
parent: undefined,
|
||||
children: [node],
|
||||
entries: node.entries,
|
||||
active: false,
|
||||
value: undefined
|
||||
value: undefined,
|
||||
};
|
||||
treeMap.set(parentPath, parent);
|
||||
node.parent = parent;
|
||||
@@ -71,7 +71,7 @@ module.exports = (plan, limit) => {
|
||||
while (currentCount > limit) {
|
||||
// Select node that helps reaching the limit most effectively without overmerging
|
||||
const overLimit = currentCount - limit;
|
||||
let bestNode = undefined;
|
||||
let bestNode;
|
||||
let bestCost = Infinity;
|
||||
for (const node of treeMap.values()) {
|
||||
if (node.entries <= 1 || !node.children || !node.parent) continue;
|
||||
@@ -95,7 +95,7 @@ module.exports = (plan, limit) => {
|
||||
bestNode.active = true;
|
||||
bestNode.entries = 1;
|
||||
currentCount -= reduction;
|
||||
let parent = bestNode.parent;
|
||||
let { parent } = bestNode;
|
||||
while (parent) {
|
||||
parent.entries -= reduction;
|
||||
parent = parent.parent;
|
||||
@@ -120,10 +120,10 @@ module.exports = (plan, limit) => {
|
||||
if (node.value) {
|
||||
if (Array.isArray(node.value)) {
|
||||
for (const item of node.value) {
|
||||
map.set(item, node.filePath);
|
||||
map.set(item, node.target);
|
||||
}
|
||||
} else {
|
||||
map.set(node.value, node.filePath);
|
||||
map.set(node.value, node.target);
|
||||
}
|
||||
}
|
||||
if (node.children) {
|
||||
@@ -132,7 +132,7 @@ module.exports = (plan, limit) => {
|
||||
}
|
||||
}
|
||||
}
|
||||
newPlan.set(rootNode.filePath, map);
|
||||
newPlan.set(rootNode.target, map);
|
||||
}
|
||||
return newPlan;
|
||||
};
|
||||
|
||||
152
node_modules/watchpack/lib/watchEventSource.js
generated
vendored
Executable file → Normal file
152
node_modules/watchpack/lib/watchEventSource.js
generated
vendored
Executable file → Normal file
@@ -4,22 +4,28 @@
|
||||
*/
|
||||
"use strict";
|
||||
|
||||
const { EventEmitter } = require("events");
|
||||
const fs = require("fs");
|
||||
const path = require("path");
|
||||
const { EventEmitter } = require("events");
|
||||
const reducePlan = require("./reducePlan");
|
||||
|
||||
/** @typedef {import("fs").FSWatcher} FSWatcher */
|
||||
/** @typedef {import("./index").EventType} EventType */
|
||||
|
||||
const IS_OSX = require("os").platform() === "darwin";
|
||||
const IS_WIN = require("os").platform() === "win32";
|
||||
|
||||
const SUPPORTS_RECURSIVE_WATCHING = IS_OSX || IS_WIN;
|
||||
|
||||
// Use 20 for OSX to make `FSWatcher.close` faster
|
||||
// https://github.com/nodejs/node/issues/29949
|
||||
const watcherLimit =
|
||||
// @ts-expect-error avoid additional checks
|
||||
+process.env.WATCHPACK_WATCHER_LIMIT || (IS_OSX ? 20 : 10000);
|
||||
|
||||
const recursiveWatcherLogging = !!process.env
|
||||
.WATCHPACK_RECURSIVE_WATCHER_LOGGING;
|
||||
const recursiveWatcherLogging = Boolean(
|
||||
process.env.WATCHPACK_RECURSIVE_WATCHER_LOGGING,
|
||||
);
|
||||
|
||||
let isBatch = false;
|
||||
let watcherCount = 0;
|
||||
@@ -36,12 +42,24 @@ const directWatchers = new Map();
|
||||
/** @type {Map<Watcher, RecursiveWatcher | DirectWatcher>} */
|
||||
const underlyingWatcher = new Map();
|
||||
|
||||
/**
|
||||
* @param {string} filePath file path
|
||||
* @returns {NodeJS.ErrnoException} new error with file path in the message
|
||||
*/
|
||||
function createEPERMError(filePath) {
|
||||
const error = new Error(`Operation not permitted: ${filePath}`);
|
||||
const error =
|
||||
/** @type {NodeJS.ErrnoException} */
|
||||
(new Error(`Operation not permitted: ${filePath}`));
|
||||
error.code = "EPERM";
|
||||
return error;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {FSWatcher} watcher watcher
|
||||
* @param {string} filePath a file path
|
||||
* @param {(type: "rename" | "change", filename: string) => void} handleChangeEvent function to handle change
|
||||
* @returns {(type: "rename" | "change", filename: string) => void} handler of change event
|
||||
*/
|
||||
function createHandleChangeEvent(watcher, filePath, handleChangeEvent) {
|
||||
return (type, filename) => {
|
||||
// TODO: After Node.js v22, fs.watch(dir) and deleting a dir will trigger the rename change event.
|
||||
@@ -64,9 +82,13 @@ function createHandleChangeEvent(watcher, filePath, handleChangeEvent) {
|
||||
}
|
||||
|
||||
class DirectWatcher {
|
||||
/**
|
||||
* @param {string} filePath file path
|
||||
*/
|
||||
constructor(filePath) {
|
||||
this.filePath = filePath;
|
||||
this.watchers = new Set();
|
||||
/** @type {FSWatcher | undefined} */
|
||||
this.watcher = undefined;
|
||||
try {
|
||||
const watcher = fs.watch(filePath);
|
||||
@@ -79,10 +101,10 @@ class DirectWatcher {
|
||||
for (const w of this.watchers) {
|
||||
w.emit("change", type, filename);
|
||||
}
|
||||
}
|
||||
},
|
||||
);
|
||||
watcher.on("change", handleChangeEvent);
|
||||
watcher.on("error", error => {
|
||||
watcher.on("error", (error) => {
|
||||
for (const w of this.watchers) {
|
||||
w.emit("error", error);
|
||||
}
|
||||
@@ -97,11 +119,17 @@ class DirectWatcher {
|
||||
watcherCount++;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {Watcher} watcher a watcher
|
||||
*/
|
||||
add(watcher) {
|
||||
underlyingWatcher.set(watcher, this);
|
||||
this.watchers.add(watcher);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {Watcher} watcher a watcher
|
||||
*/
|
||||
remove(watcher) {
|
||||
this.watchers.delete(watcher);
|
||||
if (this.watchers.size === 0) {
|
||||
@@ -116,31 +144,36 @@ class DirectWatcher {
|
||||
}
|
||||
}
|
||||
|
||||
/** @typedef {Set<Watcher>} WatcherSet */
|
||||
|
||||
class RecursiveWatcher {
|
||||
/**
|
||||
* @param {string} rootPath a root path
|
||||
*/
|
||||
constructor(rootPath) {
|
||||
this.rootPath = rootPath;
|
||||
/** @type {Map<Watcher, string>} */
|
||||
this.mapWatcherToPath = new Map();
|
||||
/** @type {Map<string, Set<Watcher>>} */
|
||||
/** @type {Map<string, WatcherSet>} */
|
||||
this.mapPathToWatchers = new Map();
|
||||
this.watcher = undefined;
|
||||
try {
|
||||
const watcher = fs.watch(rootPath, {
|
||||
recursive: true
|
||||
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`
|
||||
`[watchpack] dispatch ${type} event in recursive watcher (${this.rootPath}) to all watchers\n`,
|
||||
);
|
||||
}
|
||||
for (const w of this.mapWatcherToPath.keys()) {
|
||||
w.emit("change", type);
|
||||
w.emit("change", /** @type {EventType} */ (type));
|
||||
}
|
||||
} else {
|
||||
const dir = path.dirname(filename);
|
||||
const dir = path.dirname(/** @type {string} */ (filename));
|
||||
const watchers = this.mapPathToWatchers.get(dir);
|
||||
if (recursiveWatcherLogging) {
|
||||
process.stderr.write(
|
||||
@@ -148,16 +181,20 @@ class RecursiveWatcher {
|
||||
this.rootPath
|
||||
}) for '${filename}' to ${
|
||||
watchers ? watchers.size : 0
|
||||
} watchers\n`
|
||||
} watchers\n`,
|
||||
);
|
||||
}
|
||||
if (watchers === undefined) return;
|
||||
for (const w of watchers) {
|
||||
w.emit("change", type, path.basename(filename));
|
||||
w.emit(
|
||||
"change",
|
||||
/** @type {EventType} */ (type),
|
||||
path.basename(/** @type {string} */ (filename)),
|
||||
);
|
||||
}
|
||||
}
|
||||
});
|
||||
watcher.on("error", error => {
|
||||
watcher.on("error", (error) => {
|
||||
for (const w of this.mapWatcherToPath.keys()) {
|
||||
w.emit("error", error);
|
||||
}
|
||||
@@ -172,11 +209,15 @@ class RecursiveWatcher {
|
||||
watcherCount++;
|
||||
if (recursiveWatcherLogging) {
|
||||
process.stderr.write(
|
||||
`[watchpack] created recursive watcher at ${rootPath}\n`
|
||||
`[watchpack] created recursive watcher at ${rootPath}\n`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string} filePath a file path
|
||||
* @param {Watcher} watcher a watcher
|
||||
*/
|
||||
add(filePath, watcher) {
|
||||
underlyingWatcher.set(watcher, this);
|
||||
const subpath = filePath.slice(this.rootPath.length + 1) || ".";
|
||||
@@ -191,11 +232,14 @@ class RecursiveWatcher {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {Watcher} watcher a watcher
|
||||
*/
|
||||
remove(watcher) {
|
||||
const subpath = this.mapWatcherToPath.get(watcher);
|
||||
if (!subpath) return;
|
||||
this.mapWatcherToPath.delete(watcher);
|
||||
const set = this.mapPathToWatchers.get(subpath);
|
||||
const set = /** @type {WatcherSet} */ (this.mapPathToWatchers.get(subpath));
|
||||
set.delete(watcher);
|
||||
if (set.size === 0) {
|
||||
this.mapPathToWatchers.delete(subpath);
|
||||
@@ -206,7 +250,7 @@ class RecursiveWatcher {
|
||||
if (this.watcher) this.watcher.close();
|
||||
if (recursiveWatcherLogging) {
|
||||
process.stderr.write(
|
||||
`[watchpack] closed recursive watcher at ${this.rootPath}\n`
|
||||
`[watchpack] closed recursive watcher at ${this.rootPath}\n`,
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -217,19 +261,37 @@ class RecursiveWatcher {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @typedef {object} WatcherEvents
|
||||
* @property {(eventType: EventType, filename?: string) => void} change change event
|
||||
* @property {(err: unknown) => void} error error event
|
||||
*/
|
||||
|
||||
/**
|
||||
* @extends {EventEmitter<{ [K in keyof WatcherEvents]: Parameters<WatcherEvents[K]> }>}
|
||||
*/
|
||||
class Watcher extends EventEmitter {
|
||||
constructor() {
|
||||
super();
|
||||
}
|
||||
|
||||
close() {
|
||||
if (pendingWatchers.has(this)) {
|
||||
pendingWatchers.delete(this);
|
||||
return;
|
||||
}
|
||||
const watcher = underlyingWatcher.get(this);
|
||||
watcher.remove(this);
|
||||
/** @type {RecursiveWatcher | DirectWatcher} */
|
||||
(watcher).remove(this);
|
||||
underlyingWatcher.delete(this);
|
||||
}
|
||||
}
|
||||
|
||||
const createDirectWatcher = filePath => {
|
||||
/**
|
||||
* @param {string} filePath a file path
|
||||
* @returns {DirectWatcher} a directory watcher
|
||||
*/
|
||||
const createDirectWatcher = (filePath) => {
|
||||
const existing = directWatchers.get(filePath);
|
||||
if (existing !== undefined) return existing;
|
||||
const w = new DirectWatcher(filePath);
|
||||
@@ -237,7 +299,11 @@ const createDirectWatcher = filePath => {
|
||||
return w;
|
||||
};
|
||||
|
||||
const createRecursiveWatcher = rootPath => {
|
||||
/**
|
||||
* @param {string} rootPath a root path
|
||||
* @returns {RecursiveWatcher} a recursive watcher
|
||||
*/
|
||||
const createRecursiveWatcher = (rootPath) => {
|
||||
const existing = recursiveWatchers.get(rootPath);
|
||||
if (existing !== undefined) return existing;
|
||||
const w = new RecursiveWatcher(rootPath);
|
||||
@@ -248,6 +314,10 @@ const createRecursiveWatcher = rootPath => {
|
||||
const execute = () => {
|
||||
/** @type {Map<string, Watcher[] | Watcher>} */
|
||||
const map = new Map();
|
||||
/**
|
||||
* @param {Watcher} watcher a watcher
|
||||
* @param {string} filePath a file path
|
||||
*/
|
||||
const addWatcher = (watcher, filePath) => {
|
||||
const entry = map.get(filePath);
|
||||
if (entry === undefined) {
|
||||
@@ -328,7 +398,30 @@ const execute = () => {
|
||||
}
|
||||
};
|
||||
|
||||
exports.watch = filePath => {
|
||||
module.exports.Watcher = Watcher;
|
||||
|
||||
/**
|
||||
* @param {() => void} fn a function
|
||||
*/
|
||||
module.exports.batch = (fn) => {
|
||||
isBatch = true;
|
||||
try {
|
||||
fn();
|
||||
} finally {
|
||||
isBatch = false;
|
||||
execute();
|
||||
}
|
||||
};
|
||||
|
||||
module.exports.createHandleChangeEvent = createHandleChangeEvent;
|
||||
|
||||
module.exports.getNumberOfWatchers = () => watcherCount;
|
||||
|
||||
/**
|
||||
* @param {string} filePath a file path
|
||||
* @returns {Watcher} watcher
|
||||
*/
|
||||
module.exports.watch = (filePath) => {
|
||||
const watcher = new Watcher();
|
||||
// Find an existing watcher
|
||||
const directWatcher = directWatchers.get(filePath);
|
||||
@@ -353,19 +446,4 @@ exports.watch = filePath => {
|
||||
return watcher;
|
||||
};
|
||||
|
||||
exports.batch = fn => {
|
||||
isBatch = true;
|
||||
try {
|
||||
fn();
|
||||
} finally {
|
||||
isBatch = false;
|
||||
execute();
|
||||
}
|
||||
};
|
||||
|
||||
exports.getNumberOfWatchers = () => {
|
||||
return watcherCount;
|
||||
};
|
||||
|
||||
exports.createHandleChangeEvent = createHandleChangeEvent;
|
||||
exports.watcherLimit = watcherLimit;
|
||||
module.exports.watcherLimit = watcherLimit;
|
||||
|
||||
391
node_modules/watchpack/lib/watchpack.js
generated
vendored
Executable file → Normal file
391
node_modules/watchpack/lib/watchpack.js
generated
vendored
Executable file → Normal file
@@ -1,393 +1,8 @@
|
||||
/*
|
||||
MIT License http://www.opensource.org/licenses/mit-license.php
|
||||
Author Tobias Koppers @sokra
|
||||
Author Alexander Akait @akexander-akait
|
||||
*/
|
||||
"use strict";
|
||||
|
||||
const getWatcherManager = require("./getWatcherManager");
|
||||
const LinkResolver = require("./LinkResolver");
|
||||
const EventEmitter = require("events").EventEmitter;
|
||||
const globToRegExp = require("glob-to-regexp");
|
||||
const watchEventSource = require("./watchEventSource");
|
||||
|
||||
const EMPTY_ARRAY = [];
|
||||
const EMPTY_OPTIONS = {};
|
||||
|
||||
function addWatchersToSet(watchers, set) {
|
||||
for (const ww of watchers) {
|
||||
const w = ww.watcher;
|
||||
if (!set.has(w.directoryWatcher)) {
|
||||
set.add(w.directoryWatcher);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const stringToRegexp = ignored => {
|
||||
if (ignored.length === 0) {
|
||||
return;
|
||||
}
|
||||
const source = globToRegExp(ignored, { globstar: true, extended: true })
|
||||
.source;
|
||||
return source.slice(0, source.length - 1) + "(?:$|\\/)";
|
||||
};
|
||||
|
||||
const ignoredToFunction = ignored => {
|
||||
if (Array.isArray(ignored)) {
|
||||
const stringRegexps = ignored.map(i => stringToRegexp(i)).filter(Boolean);
|
||||
if (stringRegexps.length === 0) {
|
||||
return () => false;
|
||||
}
|
||||
const regexp = new RegExp(stringRegexps.join("|"));
|
||||
return x => regexp.test(x.replace(/\\/g, "/"));
|
||||
} else if (typeof ignored === "string") {
|
||||
const stringRegexp = stringToRegexp(ignored);
|
||||
if (!stringRegexp) {
|
||||
return () => false;
|
||||
}
|
||||
const regexp = new RegExp(stringRegexp);
|
||||
return x => regexp.test(x.replace(/\\/g, "/"));
|
||||
} else if (ignored instanceof RegExp) {
|
||||
return x => ignored.test(x.replace(/\\/g, "/"));
|
||||
} else if (ignored instanceof Function) {
|
||||
return ignored;
|
||||
} else if (ignored) {
|
||||
throw new Error(`Invalid option for 'ignored': ${ignored}`);
|
||||
} else {
|
||||
return () => false;
|
||||
}
|
||||
};
|
||||
|
||||
const normalizeOptions = options => {
|
||||
return {
|
||||
followSymlinks: !!options.followSymlinks,
|
||||
ignored: ignoredToFunction(options.ignored),
|
||||
poll: options.poll
|
||||
};
|
||||
};
|
||||
|
||||
const normalizeCache = new WeakMap();
|
||||
const cachedNormalizeOptions = options => {
|
||||
const cacheEntry = normalizeCache.get(options);
|
||||
if (cacheEntry !== undefined) return cacheEntry;
|
||||
const normalized = normalizeOptions(options);
|
||||
normalizeCache.set(options, normalized);
|
||||
return normalized;
|
||||
};
|
||||
|
||||
class WatchpackFileWatcher {
|
||||
constructor(watchpack, watcher, files) {
|
||||
this.files = Array.isArray(files) ? files : [files];
|
||||
this.watcher = watcher;
|
||||
watcher.on("initial-missing", type => {
|
||||
for (const file of this.files) {
|
||||
if (!watchpack._missing.has(file))
|
||||
watchpack._onRemove(file, file, type);
|
||||
}
|
||||
});
|
||||
watcher.on("change", (mtime, type) => {
|
||||
for (const file of this.files) {
|
||||
watchpack._onChange(file, mtime, file, type);
|
||||
}
|
||||
});
|
||||
watcher.on("remove", type => {
|
||||
for (const file of this.files) {
|
||||
watchpack._onRemove(file, file, type);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
update(files) {
|
||||
if (!Array.isArray(files)) {
|
||||
if (this.files.length !== 1) {
|
||||
this.files = [files];
|
||||
} else if (this.files[0] !== files) {
|
||||
this.files[0] = files;
|
||||
}
|
||||
} else {
|
||||
this.files = files;
|
||||
}
|
||||
}
|
||||
|
||||
close() {
|
||||
this.watcher.close();
|
||||
}
|
||||
}
|
||||
|
||||
class WatchpackDirectoryWatcher {
|
||||
constructor(watchpack, watcher, directories) {
|
||||
this.directories = Array.isArray(directories) ? directories : [directories];
|
||||
this.watcher = watcher;
|
||||
watcher.on("initial-missing", type => {
|
||||
for (const item of this.directories) {
|
||||
watchpack._onRemove(item, item, type);
|
||||
}
|
||||
});
|
||||
watcher.on("change", (file, mtime, type) => {
|
||||
for (const item of this.directories) {
|
||||
watchpack._onChange(item, mtime, file, type);
|
||||
}
|
||||
});
|
||||
watcher.on("remove", type => {
|
||||
for (const item of this.directories) {
|
||||
watchpack._onRemove(item, item, type);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
update(directories) {
|
||||
if (!Array.isArray(directories)) {
|
||||
if (this.directories.length !== 1) {
|
||||
this.directories = [directories];
|
||||
} else if (this.directories[0] !== directories) {
|
||||
this.directories[0] = directories;
|
||||
}
|
||||
} else {
|
||||
this.directories = directories;
|
||||
}
|
||||
}
|
||||
|
||||
close() {
|
||||
this.watcher.close();
|
||||
}
|
||||
}
|
||||
|
||||
class Watchpack extends EventEmitter {
|
||||
constructor(options) {
|
||||
super();
|
||||
if (!options) options = EMPTY_OPTIONS;
|
||||
this.options = options;
|
||||
this.aggregateTimeout =
|
||||
typeof options.aggregateTimeout === "number"
|
||||
? options.aggregateTimeout
|
||||
: 200;
|
||||
this.watcherOptions = cachedNormalizeOptions(options);
|
||||
this.watcherManager = getWatcherManager(this.watcherOptions);
|
||||
this.fileWatchers = new Map();
|
||||
this.directoryWatchers = new Map();
|
||||
this._missing = new Set();
|
||||
this.startTime = undefined;
|
||||
this.paused = false;
|
||||
this.aggregatedChanges = new Set();
|
||||
this.aggregatedRemovals = new Set();
|
||||
this.aggregateTimer = undefined;
|
||||
this._onTimeout = this._onTimeout.bind(this);
|
||||
}
|
||||
|
||||
watch(arg1, arg2, arg3) {
|
||||
let files, directories, missing, startTime;
|
||||
if (!arg2) {
|
||||
({
|
||||
files = EMPTY_ARRAY,
|
||||
directories = EMPTY_ARRAY,
|
||||
missing = EMPTY_ARRAY,
|
||||
startTime
|
||||
} = arg1);
|
||||
} else {
|
||||
files = arg1;
|
||||
directories = arg2;
|
||||
missing = EMPTY_ARRAY;
|
||||
startTime = arg3;
|
||||
}
|
||||
this.paused = false;
|
||||
const fileWatchers = this.fileWatchers;
|
||||
const directoryWatchers = this.directoryWatchers;
|
||||
const ignored = this.watcherOptions.ignored;
|
||||
const filter = path => !ignored(path);
|
||||
const addToMap = (map, key, item) => {
|
||||
const list = map.get(key);
|
||||
if (list === undefined) {
|
||||
map.set(key, item);
|
||||
} else if (Array.isArray(list)) {
|
||||
list.push(item);
|
||||
} else {
|
||||
map.set(key, [list, item]);
|
||||
}
|
||||
};
|
||||
const fileWatchersNeeded = new Map();
|
||||
const directoryWatchersNeeded = new Map();
|
||||
const missingFiles = new Set();
|
||||
if (this.watcherOptions.followSymlinks) {
|
||||
const resolver = new LinkResolver();
|
||||
for (const file of files) {
|
||||
if (filter(file)) {
|
||||
for (const innerFile of resolver.resolve(file)) {
|
||||
if (file === innerFile || filter(innerFile)) {
|
||||
addToMap(fileWatchersNeeded, innerFile, file);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const file of missing) {
|
||||
if (filter(file)) {
|
||||
for (const innerFile of resolver.resolve(file)) {
|
||||
if (file === innerFile || filter(innerFile)) {
|
||||
missingFiles.add(file);
|
||||
addToMap(fileWatchersNeeded, innerFile, file);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const dir of directories) {
|
||||
if (filter(dir)) {
|
||||
let first = true;
|
||||
for (const innerItem of resolver.resolve(dir)) {
|
||||
if (filter(innerItem)) {
|
||||
addToMap(
|
||||
first ? directoryWatchersNeeded : fileWatchersNeeded,
|
||||
innerItem,
|
||||
dir
|
||||
);
|
||||
}
|
||||
first = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (const file of files) {
|
||||
if (filter(file)) {
|
||||
addToMap(fileWatchersNeeded, file, file);
|
||||
}
|
||||
}
|
||||
for (const file of missing) {
|
||||
if (filter(file)) {
|
||||
missingFiles.add(file);
|
||||
addToMap(fileWatchersNeeded, file, file);
|
||||
}
|
||||
}
|
||||
for (const dir of directories) {
|
||||
if (filter(dir)) {
|
||||
addToMap(directoryWatchersNeeded, dir, dir);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Close unneeded old watchers
|
||||
// and update existing watchers
|
||||
for (const [key, w] of fileWatchers) {
|
||||
const needed = fileWatchersNeeded.get(key);
|
||||
if (needed === undefined) {
|
||||
w.close();
|
||||
fileWatchers.delete(key);
|
||||
} else {
|
||||
w.update(needed);
|
||||
fileWatchersNeeded.delete(key);
|
||||
}
|
||||
}
|
||||
for (const [key, w] of directoryWatchers) {
|
||||
const needed = directoryWatchersNeeded.get(key);
|
||||
if (needed === undefined) {
|
||||
w.close();
|
||||
directoryWatchers.delete(key);
|
||||
} else {
|
||||
w.update(needed);
|
||||
directoryWatchersNeeded.delete(key);
|
||||
}
|
||||
}
|
||||
// Create new watchers and install handlers on these watchers
|
||||
watchEventSource.batch(() => {
|
||||
for (const [key, files] of fileWatchersNeeded) {
|
||||
const watcher = this.watcherManager.watchFile(key, startTime);
|
||||
if (watcher) {
|
||||
fileWatchers.set(key, new WatchpackFileWatcher(this, watcher, files));
|
||||
}
|
||||
}
|
||||
for (const [key, directories] of directoryWatchersNeeded) {
|
||||
const watcher = this.watcherManager.watchDirectory(key, startTime);
|
||||
if (watcher) {
|
||||
directoryWatchers.set(
|
||||
key,
|
||||
new WatchpackDirectoryWatcher(this, watcher, directories)
|
||||
);
|
||||
}
|
||||
}
|
||||
});
|
||||
this._missing = missingFiles;
|
||||
this.startTime = startTime;
|
||||
}
|
||||
|
||||
close() {
|
||||
this.paused = true;
|
||||
if (this.aggregateTimer) clearTimeout(this.aggregateTimer);
|
||||
for (const w of this.fileWatchers.values()) w.close();
|
||||
for (const w of this.directoryWatchers.values()) w.close();
|
||||
this.fileWatchers.clear();
|
||||
this.directoryWatchers.clear();
|
||||
}
|
||||
|
||||
pause() {
|
||||
this.paused = true;
|
||||
if (this.aggregateTimer) clearTimeout(this.aggregateTimer);
|
||||
}
|
||||
|
||||
getTimes() {
|
||||
const directoryWatchers = new Set();
|
||||
addWatchersToSet(this.fileWatchers.values(), directoryWatchers);
|
||||
addWatchersToSet(this.directoryWatchers.values(), directoryWatchers);
|
||||
const obj = Object.create(null);
|
||||
for (const w of directoryWatchers) {
|
||||
const times = w.getTimes();
|
||||
for (const file of Object.keys(times)) obj[file] = times[file];
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
|
||||
getTimeInfoEntries() {
|
||||
const map = new Map();
|
||||
this.collectTimeInfoEntries(map, map);
|
||||
return map;
|
||||
}
|
||||
|
||||
collectTimeInfoEntries(fileTimestamps, directoryTimestamps) {
|
||||
const allWatchers = new Set();
|
||||
addWatchersToSet(this.fileWatchers.values(), allWatchers);
|
||||
addWatchersToSet(this.directoryWatchers.values(), allWatchers);
|
||||
const safeTime = { value: 0 };
|
||||
for (const w of allWatchers) {
|
||||
w.collectTimeInfoEntries(fileTimestamps, directoryTimestamps, safeTime);
|
||||
}
|
||||
}
|
||||
|
||||
getAggregated() {
|
||||
if (this.aggregateTimer) {
|
||||
clearTimeout(this.aggregateTimer);
|
||||
this.aggregateTimer = undefined;
|
||||
}
|
||||
const changes = this.aggregatedChanges;
|
||||
const removals = this.aggregatedRemovals;
|
||||
this.aggregatedChanges = new Set();
|
||||
this.aggregatedRemovals = new Set();
|
||||
return { changes, removals };
|
||||
}
|
||||
|
||||
_onChange(item, mtime, file, type) {
|
||||
file = file || item;
|
||||
if (!this.paused) {
|
||||
this.emit("change", file, mtime, type);
|
||||
if (this.aggregateTimer) clearTimeout(this.aggregateTimer);
|
||||
this.aggregateTimer = setTimeout(this._onTimeout, this.aggregateTimeout);
|
||||
}
|
||||
this.aggregatedRemovals.delete(item);
|
||||
this.aggregatedChanges.add(item);
|
||||
}
|
||||
|
||||
_onRemove(item, file, type) {
|
||||
file = file || item;
|
||||
if (!this.paused) {
|
||||
this.emit("remove", file, type);
|
||||
if (this.aggregateTimer) clearTimeout(this.aggregateTimer);
|
||||
this.aggregateTimer = setTimeout(this._onTimeout, this.aggregateTimeout);
|
||||
}
|
||||
this.aggregatedChanges.delete(item);
|
||||
this.aggregatedRemovals.add(item);
|
||||
}
|
||||
|
||||
_onTimeout() {
|
||||
this.aggregateTimer = undefined;
|
||||
const changes = this.aggregatedChanges;
|
||||
const removals = this.aggregatedRemovals;
|
||||
this.aggregatedChanges = new Set();
|
||||
this.aggregatedRemovals = new Set();
|
||||
this.emit("aggregated", changes, removals);
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = Watchpack;
|
||||
// TODO remove this file in the next major release
|
||||
module.exports = require("./index");
|
||||
|
||||
Reference in New Issue
Block a user