nitro-nightly 3.0.1-20260106-130706-e20c92d9 → 3.0.1-20260106-202835-5325b208

package/dist/_libs/chokidar.mjs

@@ -1,244 +1,11 @@
 import { n as __exportAll } from "../_rolldown.mjs";
+import { t as readdirp } from "./readdirp.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";

package/dist/_libs/commondir.mjs

@@ -0,0 +1,22 @@
+import { r as __require, t as __commonJSMin } from "../_rolldown.mjs";
+
+//#region node_modules/.pnpm/commondir@1.0.1/node_modules/commondir/index.js
+var require_commondir = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var path = __require("path");
+	module.exports = function(basedir, relfiles) {
+		if (relfiles) var files = relfiles.map(function(r) {
+			return path.resolve(basedir, r);
+		});
+		else var files = basedir;
+		var res = files.slice(1).reduce(function(ps, file) {
+			if (!file.match(/^([A-Za-z]:)?\/|\\/)) throw new Error("relative path without a basedir");
+			var xs = file.split(/\/+|\\+/);
+			for (var i = 0; ps[i] === xs[i] && i < Math.min(ps.length, xs.length); i++);
+			return ps.slice(0, i);
+		}, files[0].split(/\/+|\\+/));
+		return res.length > 1 ? res.join("/") : "/";
+	};
+}));
+
+//#endregion
+export { require_commondir as t };