vscode-fs 0.0.10 → 0.1.1

package/dist/index.cjs

@@ -1,416 +1,16 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-let vscode_uri = require("vscode-uri");
+const require_node = require('./node-BV_ucnay.cjs');
 
-//#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, trash, glob, watch, stream] = await Promise.all([
-		import("node:fs"),
-		import("trash").then((m) => m.default),
-		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) await 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: options?.ignore,
-				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;
+    return require_node.FileSystemError;
   }
 });
-exports.FileSystemProviderErrorCode = FileSystemProviderErrorCode;
-exports.FileType = FileType;
-exports.RelativePattern = RelativePattern;
-exports.WriteableFlags = WriteableFlags;
-exports.createFileSystemError = createFileSystemError;
-exports.createNodeFileSystem = createNodeFileSystem;
-exports.toFileSystemError = toFileSystemError;
+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;