@zenfs/core 0.16.3 → 0.17.0

package/src/emulation/promises.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-redundant-type-constituents */
 import { Buffer } from 'buffer';
 import type * as fs from 'node:fs';
 import type * as promises from 'node:fs/promises';
@@ -18,6 +19,7 @@ import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
 import { _statfs, cred, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
 import { ReadStream, WriteStream } from './streams.js';
+import { FSWatcher } from './watchers.js';
 export * as constants from './constants.js';
 
 export class FileHandle implements promises.FileHandle {
@@ -514,7 +516,7 @@ async function _open(path: fs.PathLike, _flag: fs.OpenMode, _mode: fs.Mode = 0o6
 		return new FileHandle(await fs.openFile(resolved, flag, cred));
 	}
 
-	/* 
+	/*
 		In a previous implementation, we deleted the file and
 		re-created it. However, this created a race condition if another
 		asynchronous request was trying to read the file, as the file
@@ -870,14 +872,31 @@ export async function realpath(path: fs.PathLike, options?: fs.EncodingOption |
 }
 realpath satisfies typeof promises.realpath;
 
-/**
- * @todo Implement
- */
 export function watch(filename: fs.PathLike, options?: fs.WatchOptions | BufferEncoding): AsyncIterable<FileChangeInfo<string>>;
 export function watch(filename: fs.PathLike, options: fs.WatchOptions | fs.BufferEncodingOption): AsyncIterable<FileChangeInfo<Buffer>>;
 export function watch(filename: fs.PathLike, options?: fs.WatchOptions | string): AsyncIterable<FileChangeInfo<string>> | AsyncIterable<FileChangeInfo<Buffer>>;
-export function watch(filename: fs.PathLike, options: fs.WatchOptions | string = {}): AsyncIterable<FileChangeInfo<string>> | AsyncIterable<FileChangeInfo<Buffer>> {
-	throw ErrnoError.With('ENOSYS', filename.toString(), 'watch');
+export function watch<T extends string | Buffer>(filename: fs.PathLike, options: fs.WatchOptions | string = {}): AsyncIterable<FileChangeInfo<T>> {
+	return {
+		[Symbol.asyncIterator](): AsyncIterator<FileChangeInfo<T>> {
+			const watcher = new FSWatcher<T>(typeof options != 'string' ? options : { encoding: options as BufferEncoding | 'buffer' });
+
+			function withDone(done: boolean) {
+				return function () {
+					const event = Promise.withResolvers<IteratorResult<FileChangeInfo<T>>>();
+					watcher.on('change', (eventType, filename) => {
+						event.resolve({ value: { eventType, filename }, done });
+					});
+					return event.promise;
+				};
+			}
+
+			return {
+				next: withDone(false),
+				return: withDone(true),
+				throw: withDone(true),
+			};
+		},
+	};
 }
 watch satisfies typeof promises.watch;
 
@@ -907,7 +926,7 @@ export async function rm(path: fs.PathLike, options?: fs.RmOptions) {
 		case constants.S_IFDIR:
 			if (options?.recursive) {
 				for (const entry of await readdir(path)) {
-					await rm(join(path, entry));
+					await rm(join(path, entry), options);
 				}
 			}
 
@@ -970,10 +989,13 @@ copyFile satisfies typeof promises.copyFile;
  * @param path The path to the directory.
  * @param options Options for opening the directory.
  * @returns A `Dir` object representing the opened directory.
+ * @todo Use options
  */
 export async function opendir(path: fs.PathLike, options?: fs.OpenDirOptions): Promise<Dir> {
 	path = normalizePath(path);
-	return new Dir(path);
+	const dir = new Dir(path);
+	await dir._loadEntries();
+	return dir;
 }
 opendir satisfies typeof promises.opendir;
 

package/src/emulation/sync.ts

@@ -4,7 +4,7 @@ import { Errno, ErrnoError } from '../error.js';
 import type { File } from '../file.js';
 import { isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
 import type { FileContents } from '../filesystem.js';
-import { BigIntStats, FileType, type Stats } from '../stats.js';
+import { BigIntStats, type Stats } from '../stats.js';
 import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import { COPYFILE_EXCL, F_OK, S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK } from './constants.js';
 import { Dir, Dirent } from './dir.js';
@@ -199,7 +199,6 @@ function _readFileSync(fname: string, flag: string, resolveSymlinks: boolean): U
 	// Allocate buffer.
 	const data = new Uint8Array(stat.size);
 	file.readSync(data, 0, stat.size, 0);
-	file.closeSync();
 	return data;
 }
 
@@ -731,7 +730,7 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions): void {
 		case S_IFDIR:
 			if (options?.recursive) {
 				for (const entry of readdirSync(path)) {
-					rmSync(join(path, entry));
+					rmSync(join(path, entry), options);
 				}
 			}
 

package/src/emulation/watchers.ts

@@ -5,11 +5,11 @@ import { ErrnoError } from '../error.js';
 
 class Watcher<TEvents extends Record<string, unknown[]> = Record<string, unknown[]>> extends EventEmitter<TEvents> implements NodeEventEmitter {
 	/* eslint-disable @typescript-eslint/no-explicit-any */
-	public off<T extends EventEmitter.EventNames<TEvents>>(event: T, fn?: ((...args: any[]) => void) | undefined, context?: any, once?: boolean | undefined): this {
+	public off<T extends EventEmitter.EventNames<TEvents>>(event: T, fn?: (...args: any[]) => void, context?: any, once?: boolean): this {
 		return super.off<T>(event, fn as EventEmitter.EventListener<TEvents, T>, context, once);
 	}
 
-	public removeListener<T extends EventEmitter.EventNames<TEvents>>(event: T, fn?: ((...args: any[]) => void) | undefined, context?: any, once?: boolean | undefined): this {
+	public removeListener<T extends EventEmitter.EventNames<TEvents>>(event: T, fn?: (...args: any[]) => void, context?: any, once?: boolean): this {
 		return super.removeListener<T>(event, fn as EventEmitter.EventListener<TEvents, T>, context, once);
 	}
 	/* eslint-enable @typescript-eslint/no-explicit-any */
@@ -43,14 +43,20 @@ class Watcher<TEvents extends Record<string, unknown[]> = Record<string, unknown
 	}
 }
 
-export class FSWatcher
+/**
+ * @todo Actually emit events
+ */
+export class FSWatcher<T extends string | Buffer = string | Buffer>
 	extends Watcher<{
-		change: [eventType: string, filename: string | Buffer];
+		change: [eventType: fs.WatchEventType, filename: T];
 		close: [];
 		error: [error: Error];
 	}>
 	implements fs.FSWatcher
 {
+	public constructor(public readonly options: fs.WatchOptions) {
+		super();
+	}
 	public close(): void {}
 }
 

package/src/file.ts

@@ -323,11 +323,23 @@ export abstract class File {
  * An implementation of the File interface that operates on a file that is
  * completely in-memory. PreloadFiles are backed by a Uint8Array.
  *
- * @todo 'close' lever that disables functionality once closed.
  */
 export class PreloadFile<FS extends FileSystem> extends File {
+	/**
+	 * Current position
+	 */
 	protected _position: number = 0;
+
+	/**
+	 * Whether the file has changes which have not been written to the FS
+	 */
 	protected dirty: boolean = false;
+
+	/**
+	 * Whether the file is open or closed
+	 */
+	protected closed: boolean = false;
+
 	/**
 	 * Creates a file with the given path and, optionally, the given contents. Note
 	 * that, if contents is specified, it will be mutated by the file!
@@ -403,6 +415,9 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	}
 
 	public async sync(): Promise<void> {
+		if (this.closed) {
+			throw ErrnoError.With('EBADF', this.path, 'File.sync');
+		}
 		if (!this.dirty) {
 			return;
 		}
@@ -411,6 +426,9 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	}
 
 	public syncSync(): void {
+		if (this.closed) {
+			throw ErrnoError.With('EBADF', this.path, 'File.sync');
+		}
 		if (!this.dirty) {
 			return;
 		}
@@ -419,17 +437,48 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	}
 
 	public async close(): Promise<void> {
+		if (this.closed) {
+			throw ErrnoError.With('EBADF', this.path, 'File.close');
+		}
 		await this.sync();
+		this.dispose();
 	}
 
 	public closeSync(): void {
+		if (this.closed) {
+			throw ErrnoError.With('EBADF', this.path, 'File.close');
+		}
 		this.syncSync();
+		this.dispose();
+	}
+
+	/**
+	 * Cleans up
+	 * This will *not* sync the file data to the FS
+	 */
+	protected dispose(force?: boolean): void {
+		if (this.closed) {
+			throw ErrnoError.With('EBADF', this.path, 'File.dispose');
+		}
+		if (this.dirty && !force) {
+			throw ErrnoError.With('EBUSY', this.path, 'File.dispose');
+		}
+
+		// @ts-expect-error 2790
+		delete this._buffer;
+		// @ts-expect-error 2790
+		delete this.stats;
+
+		this.closed = true;
 	}
 
 	/**
 	 * Asynchronous `stat`.
 	 */
 	public stat(): Promise<Stats> {
+		if (this.closed) {
+			throw ErrnoError.With('EBADF', this.path, 'File.stat');
+		}
 		return Promise.resolve(new Stats(this.stats));
 	}
 
@@ -437,10 +486,16 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 * Synchronous `stat`.
 	 */
 	public statSync(): Stats {
+		if (this.closed) {
+			throw ErrnoError.With('EBADF', this.path, 'File.stat');
+		}
 		return new Stats(this.stats);
 	}
 
 	protected _truncate(length: number): void {
+		if (this.closed) {
+			throw ErrnoError.With('EBADF', this.path, 'File.truncate');
+		}
 		this.dirty = true;
 		if (!isWriteable(this.flag)) {
 			throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
@@ -476,6 +531,9 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	}
 
 	protected _write(buffer: Uint8Array, offset: number = 0, length: number = this.stats.size, position: number = this.position): number {
+		if (this.closed) {
+			throw ErrnoError.With('EBADF', this.path, 'File.write');
+		}
 		this.dirty = true;
 		if (!isWriteable(this.flag)) {
 			throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
@@ -540,6 +598,9 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	}
 
 	protected _read(buffer: ArrayBufferView, offset: number = 0, length: number = this.stats.size, position?: number): number {
+		if (this.closed) {
+			throw ErrnoError.With('EBADF', this.path, 'File.read');
+		}
 		if (!isReadable(this.flag)) {
 			throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode.');
 		}
@@ -599,6 +660,9 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 * @param mode the mode
 	 */
 	public async chmod(mode: number): Promise<void> {
+		if (this.closed) {
+			throw ErrnoError.With('EBADF', this.path, 'File.chmod');
+		}
 		this.dirty = true;
 		this.stats.chmod(mode);
 		await this.sync();
@@ -609,6 +673,9 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 * @param mode
 	 */
 	public chmodSync(mode: number): void {
+		if (this.closed) {
+			throw ErrnoError.With('EBADF', this.path, 'File.chmod');
+		}
 		this.dirty = true;
 		this.stats.chmod(mode);
 		this.syncSync();
@@ -620,6 +687,9 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 * @param gid
 	 */
 	public async chown(uid: number, gid: number): Promise<void> {
+		if (this.closed) {
+			throw ErrnoError.With('EBADF', this.path, 'File.chown');
+		}
 		this.dirty = true;
 		this.stats.chown(uid, gid);
 		await this.sync();
@@ -631,12 +701,18 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 * @param gid
 	 */
 	public chownSync(uid: number, gid: number): void {
+		if (this.closed) {
+			throw ErrnoError.With('EBADF', this.path, 'File.chown');
+		}
 		this.dirty = true;
 		this.stats.chown(uid, gid);
 		this.syncSync();
 	}
 
 	public async utimes(atime: Date, mtime: Date): Promise<void> {
+		if (this.closed) {
+			throw ErrnoError.With('EBADF', this.path, 'File.utimes');
+		}
 		this.dirty = true;
 		this.stats.atime = atime;
 		this.stats.mtime = mtime;
@@ -644,6 +720,9 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	}
 
 	public utimesSync(atime: Date, mtime: Date): void {
+		if (this.closed) {
+			throw ErrnoError.With('EBADF', this.path, 'File.utimes');
+		}
 		this.dirty = true;
 		this.stats.atime = atime;
 		this.stats.mtime = mtime;
@@ -651,16 +730,30 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	}
 
 	public async _setType(type: FileType): Promise<void> {
+		if (this.closed) {
+			throw ErrnoError.With('EBADF', this.path, 'File._setType');
+		}
 		this.dirty = true;
 		this.stats.mode = (this.stats.mode & ~S_IFMT) | type;
 		await this.sync();
 	}
 
 	public _setTypeSync(type: FileType): void {
+		if (this.closed) {
+			throw ErrnoError.With('EBADF', this.path, 'File._setType');
+		}
 		this.dirty = true;
 		this.stats.mode = (this.stats.mode & ~S_IFMT) | type;
 		this.syncSync();
 	}
+
+	public async [Symbol.asyncDispose]() {
+		await this.close();
+	}
+
+	public [Symbol.dispose]() {
+		this.closeSync();
+	}
 }
 
 /**