nitro-nightly 3.0.1-20260106-202835-5325b208 → 3.0.1-20260106-205209-b085a480

package/dist/_libs/chokidar.mjs

@@ -1,11 +1,244 @@
-import { n as __exportAll } from "../_rolldown.mjs";
-import { t as readdirp } from "./readdirp.mjs";
+import { n as __exportAll } from "../_common.mjs";
 import { stat, unwatchFile, watch, watchFile } from "node:fs";
 import { lstat, open, readdir, realpath, stat as stat$1 } from "node:fs/promises";
 import { type } from "node:os";
 import * as sp from "node:path";
+import { join, relative, resolve, sep } from "node:path";
 import { EventEmitter } from "node:events";
+import { Readable } from "node:stream";
 
+//#region node_modules/.pnpm/readdirp@5.0.0/node_modules/readdirp/index.js
+const EntryTypes = {
+	FILE_TYPE: "files",
+	DIR_TYPE: "directories",
+	FILE_DIR_TYPE: "files_directories",
+	EVERYTHING_TYPE: "all"
+};
+const defaultOptions = {
+	root: ".",
+	fileFilter: (_entryInfo) => true,
+	directoryFilter: (_entryInfo) => true,
+	type: EntryTypes.FILE_TYPE,
+	lstat: false,
+	depth: 2147483648,
+	alwaysStat: false,
+	highWaterMark: 4096
+};
+Object.freeze(defaultOptions);
+const RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+const NORMAL_FLOW_ERRORS = new Set([
+	"ENOENT",
+	"EPERM",
+	"EACCES",
+	"ELOOP",
+	RECURSIVE_ERROR_CODE
+]);
+const ALL_TYPES = [
+	EntryTypes.DIR_TYPE,
+	EntryTypes.EVERYTHING_TYPE,
+	EntryTypes.FILE_DIR_TYPE,
+	EntryTypes.FILE_TYPE
+];
+const DIR_TYPES = new Set([
+	EntryTypes.DIR_TYPE,
+	EntryTypes.EVERYTHING_TYPE,
+	EntryTypes.FILE_DIR_TYPE
+]);
+const FILE_TYPES = new Set([
+	EntryTypes.EVERYTHING_TYPE,
+	EntryTypes.FILE_DIR_TYPE,
+	EntryTypes.FILE_TYPE
+]);
+const isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+const wantBigintFsStats = process.platform === "win32";
+const emptyFn = (_entryInfo) => true;
+const normalizeFilter = (filter) => {
+	if (filter === void 0) return emptyFn;
+	if (typeof filter === "function") return filter;
+	if (typeof filter === "string") {
+		const fl = filter.trim();
+		return (entry) => entry.basename === fl;
+	}
+	if (Array.isArray(filter)) {
+		const trItems = filter.map((item) => item.trim());
+		return (entry) => trItems.some((f) => entry.basename === f);
+	}
+	return emptyFn;
+};
+/** Readable readdir stream, emitting new files as they're being listed. */
+var ReaddirpStream = class extends Readable {
+	parents;
+	reading;
+	parent;
+	_stat;
+	_maxDepth;
+	_wantsDir;
+	_wantsFile;
+	_wantsEverything;
+	_root;
+	_isDirent;
+	_statsProp;
+	_rdOptions;
+	_fileFilter;
+	_directoryFilter;
+	constructor(options = {}) {
+		super({
+			objectMode: true,
+			autoDestroy: true,
+			highWaterMark: options.highWaterMark
+		});
+		const opts = {
+			...defaultOptions,
+			...options
+		};
+		const { root, type: type$1 } = opts;
+		this._fileFilter = normalizeFilter(opts.fileFilter);
+		this._directoryFilter = normalizeFilter(opts.directoryFilter);
+		const statMethod = opts.lstat ? lstat : stat$1;
+		if (wantBigintFsStats) this._stat = (path$1) => statMethod(path$1, { bigint: true });
+		else this._stat = statMethod;
+		this._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
+		this._wantsDir = type$1 ? DIR_TYPES.has(type$1) : false;
+		this._wantsFile = type$1 ? FILE_TYPES.has(type$1) : false;
+		this._wantsEverything = type$1 === EntryTypes.EVERYTHING_TYPE;
+		this._root = resolve(root);
+		this._isDirent = !opts.alwaysStat;
+		this._statsProp = this._isDirent ? "dirent" : "stats";
+		this._rdOptions = {
+			encoding: "utf8",
+			withFileTypes: this._isDirent
+		};
+		this.parents = [this._exploreDir(root, 1)];
+		this.reading = false;
+		this.parent = void 0;
+	}
+	async _read(batch) {
+		if (this.reading) return;
+		this.reading = true;
+		try {
+			while (!this.destroyed && batch > 0) {
+				const par = this.parent;
+				const fil = par && par.files;
+				if (fil && fil.length > 0) {
+					const { path: path$1, depth } = par;
+					const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path$1));
+					const awaited = await Promise.all(slice);
+					for (const entry of awaited) {
+						if (!entry) continue;
+						if (this.destroyed) return;
+						const entryType = await this._getEntryType(entry);
+						if (entryType === "directory" && this._directoryFilter(entry)) {
+							if (depth <= this._maxDepth) this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+							if (this._wantsDir) {
+								this.push(entry);
+								batch--;
+							}
+						} else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+							if (this._wantsFile) {
+								this.push(entry);
+								batch--;
+							}
+						}
+					}
+				} else {
+					const parent = this.parents.pop();
+					if (!parent) {
+						this.push(null);
+						break;
+					}
+					this.parent = await parent;
+					if (this.destroyed) return;
+				}
+			}
+		} catch (error) {
+			this.destroy(error);
+		} finally {
+			this.reading = false;
+		}
+	}
+	async _exploreDir(path$1, depth) {
+		let files;
+		try {
+			files = await readdir(path$1, this._rdOptions);
+		} catch (error) {
+			this._onError(error);
+		}
+		return {
+			files,
+			depth,
+			path: path$1
+		};
+	}
+	async _formatEntry(dirent, path$1) {
+		let entry;
+		const basename$1 = this._isDirent ? dirent.name : dirent;
+		try {
+			const fullPath = resolve(join(path$1, basename$1));
+			entry = {
+				path: relative(this._root, fullPath),
+				fullPath,
+				basename: basename$1
+			};
+			entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+		} catch (err) {
+			this._onError(err);
+			return;
+		}
+		return entry;
+	}
+	_onError(err) {
+		if (isNormalFlowError(err) && !this.destroyed) this.emit("warn", err);
+		else this.destroy(err);
+	}
+	async _getEntryType(entry) {
+		if (!entry && this._statsProp in entry) return "";
+		const stats = entry[this._statsProp];
+		if (stats.isFile()) return "file";
+		if (stats.isDirectory()) return "directory";
+		if (stats && stats.isSymbolicLink()) {
+			const full = entry.fullPath;
+			try {
+				const entryRealPath = await realpath(full);
+				const entryRealPathStats = await lstat(entryRealPath);
+				if (entryRealPathStats.isFile()) return "file";
+				if (entryRealPathStats.isDirectory()) {
+					const len = entryRealPath.length;
+					if (full.startsWith(entryRealPath) && full.substr(len, 1) === sep) {
+						const recursiveError = /* @__PURE__ */ new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+						recursiveError.code = RECURSIVE_ERROR_CODE;
+						return this._onError(recursiveError);
+					}
+					return "directory";
+				}
+			} catch (error) {
+				this._onError(error);
+				return "";
+			}
+		}
+	}
+	_includeAsFile(entry) {
+		const stats = entry && entry[this._statsProp];
+		return stats && this._wantsEverything && !stats.isDirectory();
+	}
+};
+/**
+* Streaming version: Reads all files and directories in given root recursively.
+* Consumes ~constant small amount of RAM.
+* @param root Root directory
+* @param options Options to specify root (start directory), filters and recursion depth
+*/
+function readdirp(root, options = {}) {
+	let type$1 = options.entryType || options.type;
+	if (type$1 === "both") type$1 = EntryTypes.FILE_DIR_TYPE;
+	if (type$1) options.type = type$1;
+	if (!root) throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+	else if (typeof root !== "string") throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+	else if (type$1 && !ALL_TYPES.includes(type$1)) throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+	options.root = root;
+	return new ReaddirpStream(options);
+}
+
+//#endregion
 //#region node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/handler.js
 const STR_DATA = "data";
 const STR_END = "end";