@zenfs/core 0.16.4 → 0.17.1

package/src/emulation/dir.ts

@@ -57,15 +57,22 @@ export class Dir implements _Dir {
 
 	protected _entries: Dirent[] = [];
 
-	constructor(public readonly path: string) {}
+	/**
+	 * @internal
+	 */
+	public async _loadEntries() {
+		this._entries ??= await readdir(this.path, { withFileTypes: true });
+	}
+
+	public constructor(public readonly path: string) {}
 
 	/**
 	 * Asynchronously close the directory's underlying resource handle.
 	 * Subsequent reads will result in errors.
 	 */
-	close(): Promise<void>;
-	close(cb: Callback): void;
-	close(cb?: Callback): void | Promise<void> {
+	public close(): Promise<void>;
+	public close(cb: Callback): void;
+	public close(cb?: Callback): void | Promise<void> {
 		this.closed = true;
 		if (!cb) {
 			return Promise.resolve();
@@ -77,14 +84,12 @@ export class Dir implements _Dir {
 	 * Synchronously close the directory's underlying resource handle.
 	 * Subsequent reads will result in errors.
 	 */
-	closeSync(): void {
+	public closeSync(): void {
 		this.closed = true;
 	}
 
 	protected async _read(): Promise<Dirent | null> {
-		if (!this._entries) {
-			this._entries = await readdir(this.path, { withFileTypes: true });
-		}
+		await this._loadEntries();
 		if (!this._entries.length) {
 			return null;
 		}
@@ -96,9 +101,9 @@ export class Dir implements _Dir {
 	 * After the read is completed, a value is returned that will be resolved with an `Dirent`, or `null` if there are no more directory entries to read.
 	 * Directory entries returned by this function are in no particular order as provided by the operating system's underlying directory mechanisms.
 	 */
-	read(): Promise<Dirent | null>;
-	read(cb: Callback<[Dirent | null]>): void;
-	read(cb?: Callback<[Dirent | null]>): void | Promise<Dirent | null> {
+	public read(): Promise<Dirent | null>;
+	public read(cb: Callback<[Dirent | null]>): void;
+	public read(cb?: Callback<[Dirent | null]>): void | Promise<Dirent | null> {
 		if (!cb) {
 			return this._read();
 		}
@@ -111,10 +116,8 @@ export class Dir implements _Dir {
 	 * If there are no more directory entries to read, null will be returned.
 	 * Directory entries returned by this function are in no particular order as provided by the operating system's underlying directory mechanisms.
 	 */
-	readSync(): Dirent | null {
-		if (!this._entries) {
-			this._entries = readdirSync(this.path, { withFileTypes: true });
-		}
+	public readSync(): Dirent | null {
+		this._entries ??= readdirSync(this.path, { withFileTypes: true });
 		if (!this._entries.length) {
 			return null;
 		}
@@ -124,7 +127,7 @@ export class Dir implements _Dir {
 	/**
 	 * Asynchronously iterates over the directory via `readdir(3)` until all entries have been read.
 	 */
-	[Symbol.asyncIterator](): AsyncIterableIterator<Dirent> {
+	public [Symbol.asyncIterator](): AsyncIterableIterator<Dirent> {
 		const _this = this;
 
 		return {

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 {
@@ -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;
 
@@ -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;
 }
 

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();
+	}
 }
 
 /**