vscode-fs 0.1.0 → 0.1.2

package/dist/vscode.mjs

@@ -1,6 +1,343 @@
-import { t as createNodeFileSystem } from "./node-FE5EZXEu.mjs";
 import * as vscode from "vscode";
-
+import { URI, Utils } from "vscode-uri";
+//#region src/types.ts
+/**
+* Enumeration of file types. The types `File` and `Directory` can also be
+* a symbolic links, in that case use `FileType.File | FileType.SymbolicLink` and
+* `FileType.Directory | FileType.SymbolicLink`.
+*/
+let FileType = /* @__PURE__ */ function(FileType) {
+	/**
+	* The file type is unknown.
+	*/
+	FileType[FileType["Unknown"] = 0] = "Unknown";
+	/**
+	* A regular file.
+	*/
+	FileType[FileType["File"] = 1] = "File";
+	/**
+	* A directory.
+	*/
+	FileType[FileType["Directory"] = 2] = "Directory";
+	/**
+	* A symbolic link to a file.
+	*/
+	FileType[FileType["SymbolicLink"] = 64] = "SymbolicLink";
+	return FileType;
+}({});
+let FileSystemError;
+(function(_FileSystemError) {
+	function isFileSystemError(error) {
+		return error instanceof FileSystemErrorImpl;
+	}
+	_FileSystemError.isFileSystemError = isFileSystemError;
+})(FileSystemError || (FileSystemError = {}));
+let FileSystemProviderErrorCode = /* @__PURE__ */ function(FileSystemProviderErrorCode) {
+	FileSystemProviderErrorCode["FileExists"] = "EntryExists";
+	FileSystemProviderErrorCode["FileNotFound"] = "EntryNotFound";
+	FileSystemProviderErrorCode["FileNotADirectory"] = "EntryNotADirectory";
+	FileSystemProviderErrorCode["FileIsADirectory"] = "EntryIsADirectory";
+	FileSystemProviderErrorCode["FileExceedsStorageQuota"] = "EntryExceedsStorageQuota";
+	FileSystemProviderErrorCode["FileTooLarge"] = "EntryTooLarge";
+	FileSystemProviderErrorCode["FileWriteLocked"] = "EntryWriteLocked";
+	FileSystemProviderErrorCode["NoPermissions"] = "NoPermissions";
+	FileSystemProviderErrorCode["Unavailable"] = "Unavailable";
+	FileSystemProviderErrorCode["Unknown"] = "Unknown";
+	return FileSystemProviderErrorCode;
+}({});
+//#endregion
+//#region src/error.ts
+var FileSystemErrorImpl = class FileSystemErrorImpl extends Error {
+	static create(error, code) {
+		const providerError = new FileSystemErrorImpl(error.toString(), code);
+		this.markAsFileSystemProviderError(providerError, code);
+		return providerError;
+	}
+	static markAsFileSystemProviderError(error, code) {
+		error.name = code ? `${code} (FileSystemError)` : `FileSystemError`;
+		return error;
+	}
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+	}
+};
+function createFileSystemError(error, code) {
+	return FileSystemErrorImpl.create(error, code);
+}
+function toFileSystemError(error) {
+	let resultError = error;
+	let code;
+	switch (error.code) {
+		case "ENOENT":
+			code = FileSystemProviderErrorCode.FileNotFound;
+			break;
+		case "EISDIR":
+			code = FileSystemProviderErrorCode.FileIsADirectory;
+			break;
+		case "ENOTDIR":
+			code = FileSystemProviderErrorCode.FileNotADirectory;
+			break;
+		case "EEXIST":
+			code = FileSystemProviderErrorCode.FileExists;
+			break;
+		case "EPERM":
+		case "EACCES":
+			code = FileSystemProviderErrorCode.NoPermissions;
+			break;
+		case "ERR_UNC_HOST_NOT_ALLOWED":
+			resultError = `${error.message}. Please update the 'security.allowedUNCHosts' setting if you want to allow this host.`;
+			code = FileSystemProviderErrorCode.Unknown;
+			break;
+		default: code = FileSystemProviderErrorCode.Unknown;
+	}
+	return createFileSystemError(resultError, code);
+}
+//#endregion
+//#region src/node.ts
+function isErrnoException(err) {
+	return err !== null && typeof err === "object" && "code" in err;
+}
+function toFileType(stats) {
+	if (stats.isFile()) return FileType.File;
+	if (stats.isDirectory()) return FileType.Directory;
+	if (stats.isSymbolicLink()) return FileType.SymbolicLink;
+	return FileType.Unknown;
+}
+async function wrap(fn) {
+	try {
+		return await fn();
+	} catch (error) {
+		if (FileSystemError.isFileSystemError(error)) throw error;
+		throw toFileSystemError(error);
+	}
+}
+function joinPath(basePath, ...segments) {
+	return Utils.joinPath(URI.file(basePath), ...segments).fsPath;
+}
+async function createNodeFileSystem() {
+	const [fs, glob, watch, stream] = await Promise.all([
+		import("node:fs"),
+		import("tinyglobby").then((m) => m.glob),
+		import("chokidar").then((m) => m.watch),
+		import("node:stream")
+	]);
+	async function resolveFileType(path) {
+		const lstats = await fs.promises.lstat(path);
+		if (!lstats.isSymbolicLink()) return {
+			type: toFileType(lstats),
+			stats: lstats
+		};
+		let targetStats = null;
+		try {
+			targetStats = await fs.promises.stat(path);
+		} catch {}
+		const baseType = targetStats ? toFileType(targetStats) : FileType.Unknown;
+		const stats = targetStats ?? lstats;
+		return {
+			type: baseType | FileType.SymbolicLink,
+			stats
+		};
+	}
+	async function getEntryType(dirPath, entry) {
+		if (!entry.isSymbolicLink()) return toFileType(entry);
+		try {
+			return toFileType(await fs.promises.stat(joinPath(dirPath, entry.name))) | FileType.SymbolicLink;
+		} catch {
+			return FileType.SymbolicLink;
+		}
+	}
+	async function ensureTargetNotExists(path) {
+		try {
+			await fs.promises.access(path, fs.constants.F_OK);
+			throw createFileSystemError(`File exists: ${path}`, FileSystemProviderErrorCode.FileExists);
+		} catch (err) {
+			if (isErrnoException(err) && err.code !== "ENOENT") throw err;
+		}
+	}
+	async function copyRecursive(sourcePath, targetPath, overwrite) {
+		const stats = await fs.promises.stat(sourcePath);
+		if (stats.isFile()) {
+			const mode = overwrite ? void 0 : fs.constants.COPYFILE_EXCL;
+			await fs.promises.copyFile(sourcePath, targetPath, mode);
+			return;
+		}
+		if (stats.isDirectory()) {
+			if (!overwrite) await ensureTargetNotExists(targetPath);
+			await fs.promises.mkdir(targetPath, { recursive: true });
+			const entries = await fs.promises.readdir(sourcePath, { withFileTypes: true });
+			for (const entry of entries) await copyRecursive(joinPath(sourcePath, entry.name), joinPath(targetPath, entry.name), overwrite);
+			return;
+		}
+		throw createFileSystemError(`Unsupported file type: ${sourcePath}`, FileSystemProviderErrorCode.Unknown);
+	}
+	function pathToUris(pathToUris) {
+		return pathToUris.map((path) => URI.file(path));
+	}
+	return {
+		stat: (uri) => wrap(async () => {
+			const { type, stats } = await resolveFileType(uri.fsPath);
+			return {
+				type,
+				ctime: stats.birthtime.getTime(),
+				mtime: stats.mtime.getTime(),
+				size: stats.size
+			};
+		}),
+		readDirectory: (uri) => wrap(async () => {
+			const entries = await fs.promises.readdir(uri.fsPath, { withFileTypes: true });
+			return Promise.all(entries.map(async (entry) => [entry.name, await getEntryType(uri.fsPath, entry)]));
+		}),
+		createDirectory: (uri) => wrap(async () => {
+			await fs.promises.mkdir(uri.fsPath, { recursive: true });
+		}),
+		readFile: (uri) => wrap(() => fs.promises.readFile(uri.fsPath)),
+		writeFile: (uri, content) => wrap(() => fs.promises.writeFile(uri.fsPath, content)),
+		delete: (uri, options) => wrap(async () => {
+			if (options?.useTrash === true) await import("trash").then((m) => m.default).then((trash) => trash(uri.fsPath));
+			else await fs.promises.rm(uri.fsPath, { recursive: options?.recursive ?? false });
+		}),
+		rename: (source, target, options) => wrap(async () => {
+			if (options?.overwrite === false) await ensureTargetNotExists(target.fsPath);
+			await fs.promises.rename(source.fsPath, target.fsPath);
+		}),
+		copy: (source, target, options) => wrap(async () => {
+			const overwrite = options?.overwrite !== false;
+			await copyRecursive(source.fsPath, target.fsPath, overwrite);
+		}),
+		isFile: async (uri) => {
+			try {
+				const { type, stats } = await resolveFileType(uri.fsPath);
+				if (type !== FileType.File) return false;
+				return {
+					type,
+					ctime: stats.birthtime.getTime(),
+					mtime: stats.mtime.getTime(),
+					size: stats.size
+				};
+			} catch {
+				return false;
+			}
+		},
+		isDirectory: async (uri) => {
+			try {
+				const { type, stats } = await resolveFileType(uri.fsPath);
+				if (type !== FileType.Directory) return false;
+				return {
+					type,
+					ctime: stats.birthtime.getTime(),
+					mtime: stats.mtime.getTime(),
+					size: stats.size
+				};
+			} catch {
+				return false;
+			}
+		},
+		isSymbolicLink: async (uri) => {
+			try {
+				const { type, stats } = await resolveFileType(uri.fsPath);
+				if (type !== FileType.SymbolicLink) return false;
+				return {
+					type,
+					ctime: stats.birthtime.getTime(),
+					mtime: stats.mtime.getTime(),
+					size: stats.size
+				};
+			} catch {
+				return false;
+			}
+		},
+		exists: async (uri) => {
+			try {
+				const { type, stats } = await resolveFileType(uri.fsPath);
+				return {
+					type,
+					ctime: stats.birthtime.getTime(),
+					mtime: stats.mtime.getTime(),
+					size: stats.size
+				};
+			} catch {
+				return false;
+			}
+		},
+		glob: async (pattern, options) => {
+			return pathToUris(await glob(pattern.pattern, {
+				absolute: true,
+				cwd: pattern.baseUri.fsPath,
+				onlyFiles: options?.onlyFiles,
+				onlyDirectories: options?.onlyDirectories,
+				followSymbolicLinks: options?.followSymbolicLinks,
+				ignore: Array.isArray(options?.ignore) ? options?.ignore : options?.ignore ? options?.ignore.pattern : [],
+				dot: options?.dot,
+				expandDirectories: options?.expandDirectories,
+				extglob: options?.extglob,
+				deep: options?.deep,
+				fs
+			}));
+		},
+		createWatcher: async (pattern, options) => {
+			const watcher = watch(pattern.pattern, { cwd: pattern.baseUri.fsPath });
+			return new Promise((resolve) => {
+				watcher.on("ready", () => {
+					const fileSystemWatcher = new NodeFileSystemWatcherImpl(watcher, options);
+					if (options?.ignoreChangeEvents !== true) watcher.on("add", (path) => fileSystemWatcher.onDidCreateListeners.forEach((listener) => listener(URI.file(path))));
+					if (options?.ignoreChangeEvents !== true) watcher.on("change", (path) => fileSystemWatcher.onDidChangeListeners.forEach((listener) => listener(URI.file(path))));
+					if (options?.ignoreDeleteEvents !== true) watcher.on("unlink", (path) => fileSystemWatcher.onDidDeleteListeners.forEach((listener) => listener(URI.file(path))));
+					resolve(fileSystemWatcher);
+				});
+			});
+		},
+		createWritableStream: async (uri, options) => {
+			const writableStream = fs.createWriteStream(uri.fsPath, {
+				...options,
+				encoding: options?.encoding,
+				flags: options?.flags
+			});
+			return stream.Writable.toWeb(writableStream);
+		},
+		createReadableStream: async (uri) => {
+			const readableStream = fs.createReadStream(uri.fsPath);
+			return stream.Readable.toWeb(readableStream);
+		}
+	};
+}
+var NodeFileSystemWatcherImpl = class {
+	constructor(watcher, options) {
+		this.watcher = watcher;
+		this.options = options;
+	}
+	get ignoreChangeEvents() {
+		return this.options?.ignoreChangeEvents ?? false;
+	}
+	get ignoreCreateEvents() {
+		return this.options?.ignoreCreateEvents ?? false;
+	}
+	get ignoreDeleteEvents() {
+		return this.options?.ignoreDeleteEvents ?? false;
+	}
+	get isDisposed() {
+		return this.watcher.closed;
+	}
+	onDidCreateListeners = /* @__PURE__ */ new Set();
+	onDidChangeListeners = /* @__PURE__ */ new Set();
+	onDidDeleteListeners = /* @__PURE__ */ new Set();
+	onDidCreate(listener) {
+		this.onDidCreateListeners.add(listener);
+		return { dispose: () => this.onDidCreateListeners.delete(listener) };
+	}
+	onDidChange(listener) {
+		this.onDidChangeListeners.add(listener);
+		return { dispose: () => this.onDidChangeListeners.delete(listener) };
+	}
+	onDidDelete(listener) {
+		this.onDidDeleteListeners.add(listener);
+		return { dispose: () => this.onDidDeleteListeners.delete(listener) };
+	}
+	dispose() {
+		this.watcher.close();
+	}
+};
+//#endregion
 //#region src/vscode.ts
 async function createVSCodeFileSystem() {
 	const nodeFileSystem = createNodeFileSystem();
@@ -10,7 +347,7 @@ async function createVSCodeFileSystem() {
 		createDirectory: async (uri) => await vscode.workspace.fs.createDirectory(uri),
 		readFile: async (uri) => await vscode.workspace.fs.readFile(uri),
 		writeFile: async (uri, content) => await vscode.workspace.fs.writeFile(uri, content),
-		delete: async (uri) => await vscode.workspace.fs.delete(uri),
+		delete: async (uri, options) => await vscode.workspace.fs.delete(uri, options),
 		rename: async (source, target, options) => await vscode.workspace.fs.rename(source, target, options),
 		copy: async (source, target, options) => await vscode.workspace.fs.copy(source, target, options),
 		isDirectory: async (uri) => await vscode.workspace.fs.stat(uri).then((stat) => stat.type === vscode.FileType.Directory ? stat : false, () => false),
@@ -32,6 +369,5 @@ async function createVSCodeFileSystem() {
 		createReadableStream: async (uri) => (await nodeFileSystem).createReadableStream(uri)
 	};
 }
-
 //#endregion
-export { createVSCodeFileSystem };
+export { createVSCodeFileSystem };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vscode-fs",
   "type": "module",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "VSCode like simple、serializable and cross-platform file system utilities.",
   "author": "Naily Zero <zero@naily.cc> (https://naily.cc)",
   "license": "MIT",
@@ -65,10 +65,10 @@
     "@types/node": "^25.3.2",
     "@types/vscode": "^1.109.0",
     "naily-eslint-config": "^0.0.1",
-    "tsdown": "0.21.0-beta.2"
+    "vite-plus": "^0.1.10"
   },
   "scripts": {
-    "build": "tsdown --dts --format esm,cjs src/index.ts src/vscode.ts --deps.neverBundle vscode",
+    "build": "vp pack",
     "test": "vitest --coverage --ui",
     "lint": "eslint ."
   }