vscode-fs 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -1,16 +1,411 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_node = require('./node-B6PykMfK.cjs');
-
-Object.defineProperty(exports, 'FileSystemError', {
-  enumerable: true,
-  get: function () {
-    return require_node.FileSystemError;
-  }
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let vscode_uri = require("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;
+}({});
+/**
+* The flags to use for the file.
+*/
+let WriteableFlags = /* @__PURE__ */ function(WriteableFlags) {
+	/**
+	* Append to the file.
+	*/
+	WriteableFlags["Append"] = "a";
+	return WriteableFlags;
+}({});
+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;
+}({});
+/**
+* A relative pattern is a helper to construct glob patterns that are matched
+* relatively to a base file path. The base path can either be an absolute file
+* path as string or uri or a {@link WorkspaceFolder workspace folder}, which is the
+* preferred way of creating the relative pattern.
+*/
+var RelativePattern = class {
+	/**
+	* A base file path to which this pattern will be matched against relatively. The
+	* file path must be absolute, should not have any trailing path separators and
+	* not include any relative segments (`.` or `..`).
+	*/
+	baseUri;
+	/**
+	* A file glob pattern like `*.{ts,js}` that will be matched on file paths
+	* relative to the base path.
+	*
+	* Example: Given a base of `/home/work/folder` and a file path of `/home/work/folder/index.js`,
+	* the file glob pattern will match on `index.js`.
+	*/
+	pattern;
+	/**
+	* Creates a new relative pattern object with a base file path and pattern to match. This pattern
+	* will be matched on file paths relative to the base.
+	*
+	* Example:
+	* ```ts
+	* const folder = vscode.workspace.workspaceFolders?.[0];
+	* if (folder) {
+	*
+	*   // Match any TypeScript file in the root of this workspace folder
+	*   const pattern1 = new vscode.RelativePattern(folder, '*.ts');
+	*
+	*   // Match any TypeScript file in `someFolder` inside this workspace folder
+	*   const pattern2 = new vscode.RelativePattern(folder, 'someFolder/*.ts');
+	* }
+	* ```
+	*
+	* @param base A base to which this pattern will be matched against relatively. It is recommended
+	* to pass in a {@link WorkspaceFolder workspace folder} if the pattern should match inside the workspace.
+	* Otherwise, a uri or string should only be used if the pattern is for a file path outside the workspace.
+	* @param pattern A file glob pattern like `*.{ts,js}` that will be matched on paths relative to the base.
+	*/
+	constructor(base, pattern) {
+		this.baseUri = base;
+		this.pattern = pattern;
+	}
+};
+//#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 vscode_uri.Utils.joinPath(vscode_uri.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) => vscode_uri.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(vscode_uri.URI.file(path))));
+					if (options?.ignoreChangeEvents !== true) watcher.on("change", (path) => fileSystemWatcher.onDidChangeListeners.forEach((listener) => listener(vscode_uri.URI.file(path))));
+					if (options?.ignoreDeleteEvents !== true) watcher.on("unlink", (path) => fileSystemWatcher.onDidDeleteListeners.forEach((listener) => listener(vscode_uri.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
+Object.defineProperty(exports, "FileSystemError", {
+	enumerable: true,
+	get: function() {
+		return FileSystemError;
+	}
 });
-exports.FileSystemProviderErrorCode = require_node.FileSystemProviderErrorCode;
-exports.FileType = require_node.FileType;
-exports.RelativePattern = require_node.RelativePattern;
-exports.WriteableFlags = require_node.WriteableFlags;
-exports.createFileSystemError = require_node.createFileSystemError;
-exports.createNodeFileSystem = require_node.createNodeFileSystem;
-exports.toFileSystemError = require_node.toFileSystemError;
+exports.FileSystemProviderErrorCode = FileSystemProviderErrorCode;
+exports.FileType = FileType;
+exports.RelativePattern = RelativePattern;
+exports.WriteableFlags = WriteableFlags;
+exports.createFileSystemError = createFileSystemError;
+exports.createNodeFileSystem = createNodeFileSystem;
+exports.toFileSystemError = toFileSystemError;