@zenfs/core 0.12.4 → 0.12.6

package/dist/emulation/dir.d.ts

@@ -7,6 +7,7 @@ export declare class Dirent implements _Dirent {
     protected stats: Stats;
     get name(): string;
     constructor(path: string, stats: Stats);
+    get parentPath(): string;
     isFile(): boolean;
     isDirectory(): boolean;
     isBlockDevice(): boolean;

package/dist/emulation/dir.js

@@ -10,6 +10,9 @@ export class Dirent {
         this.path = path;
         this.stats = stats;
     }
+    get parentPath() {
+        return this.path;
+    }
     isFile() {
         return this.stats.isFile();
     }

package/dist/emulation/watchers.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { EventEmitter } from 'eventemitter3';
+import type { EventEmitter as NodeEventEmitter } from 'node:events';
+import type * as fs from 'node:fs';
+declare class Watcher<TEvents extends Record<string, unknown[]> = Record<string, unknown[]>> extends EventEmitter<TEvents> implements NodeEventEmitter {
+    off<T extends EventEmitter.EventNames<TEvents>>(event: T, fn?: ((...args: any[]) => void) | undefined, context?: any, once?: boolean | undefined): this;
+    removeListener<T extends EventEmitter.EventNames<TEvents>>(event: T, fn?: ((...args: any[]) => void) | undefined, context?: any, once?: boolean | undefined): this;
+    setMaxListeners(): never;
+    getMaxListeners(): never;
+    prependListener(): never;
+    prependOnceListener(): never;
+    rawListeners(): never;
+    ref(): this;
+    unref(): this;
+}
+export declare class FSWatcher extends Watcher<{
+    change: [eventType: string, filename: string | Buffer];
+    close: [];
+    error: [error: Error];
+}> implements fs.FSWatcher {
+    close(): void;
+}
+export declare class StatWatcher extends Watcher implements fs.StatWatcher {
+}
+export {};

package/dist/emulation/watchers.js

@@ -0,0 +1,38 @@
+import { EventEmitter } from 'eventemitter3';
+import { ErrnoError } from '../error.js';
+class Watcher extends EventEmitter {
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    off(event, fn, context, once) {
+        return super.off(event, fn, context, once);
+    }
+    removeListener(event, fn, context, once) {
+        return super.removeListener(event, fn, context, once);
+    }
+    /* eslint-enable @typescript-eslint/no-explicit-any */
+    setMaxListeners() {
+        throw ErrnoError.With('ENOTSUP');
+    }
+    getMaxListeners() {
+        throw ErrnoError.With('ENOTSUP');
+    }
+    prependListener() {
+        throw ErrnoError.With('ENOTSUP');
+    }
+    prependOnceListener() {
+        throw ErrnoError.With('ENOTSUP');
+    }
+    rawListeners() {
+        throw ErrnoError.With('ENOTSUP');
+    }
+    ref() {
+        return this;
+    }
+    unref() {
+        return this;
+    }
+}
+export class FSWatcher extends Watcher {
+    close() { }
+}
+export class StatWatcher extends Watcher {
+}

package/dist/file.d.ts

@@ -246,6 +246,7 @@ export declare class PreloadFile<FS extends FileSystem> extends File {
      * Synchronous `stat`.
      */
     statSync(): Stats;
+    protected _truncate(length: number): void;
     /**
      * Asynchronous truncate.
      * @param length
@@ -256,6 +257,7 @@ export declare class PreloadFile<FS extends FileSystem> extends File {
      * @param length
      */
     truncateSync(length: number): void;
+    protected _write(buffer: Uint8Array, offset?: number, length?: number, position?: number): number;
     /**
      * Write buffer to the file.
      * Note that it is unsafe to use fs.write multiple times on the same file
@@ -283,6 +285,7 @@ export declare class PreloadFile<FS extends FileSystem> extends File {
      * @returns bytes written
      */
     writeSync(buffer: Uint8Array, offset?: number, length?: number, position?: number): number;
+    protected _read(buffer: ArrayBufferView, offset?: number, length?: number, position?: number): number;
     /**
      * Read data from the file.
      * @param buffer The buffer that the data will be

package/dist/file.js

@@ -236,34 +236,63 @@ export class PreloadFile extends File {
     statSync() {
         return new Stats(this.stats);
     }
+    _truncate(length) {
+        this.dirty = true;
+        if (!isWriteable(this.flag)) {
+            throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
+        }
+        this.stats.mtimeMs = Date.now();
+        if (length > this._buffer.length) {
+            const data = new Uint8Array(length - this._buffer.length);
+            // Write will set stats.size and handle syncing.
+            this.writeSync(data, 0, data.length, this._buffer.length);
+            return;
+        }
+        this.stats.size = length;
+        // Truncate.
+        this._buffer = this._buffer.slice(0, length);
+    }
     /**
      * Asynchronous truncate.
      * @param length
      */
     async truncate(length) {
-        this.truncateSync(length);
-        return this.sync();
+        this._truncate(length);
+        await this.sync();
     }
     /**
      * Synchronous truncate.
      * @param length
      */
     truncateSync(length) {
+        this._truncate(length);
+        this.syncSync();
+    }
+    _write(buffer, offset = 0, length = this.stats.size, position = this.position) {
         this.dirty = true;
         if (!isWriteable(this.flag)) {
             throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
         }
-        this.stats.mtimeMs = Date.now();
-        if (length > this._buffer.length) {
-            const data = new Uint8Array(length - this._buffer.length);
-            // Write will set stats.size and handle syncing.
-            this.writeSync(data, 0, data.length, this._buffer.length);
-            return;
+        const end = position + length;
+        if (end > this.stats.size) {
+            this.stats.size = end;
+            if (end > this._buffer.byteLength) {
+                if (this._buffer.buffer.resizable && this._buffer.buffer.maxByteLength <= end) {
+                    this._buffer.buffer.resize(end);
+                }
+                else {
+                    // Extend the buffer!
+                    const newBuffer = new Uint8Array(new ArrayBuffer(end, this.fs.metadata().noResizableBuffers ? {} : { maxByteLength: size_max }));
+                    newBuffer.set(this._buffer);
+                    this._buffer = newBuffer;
+                }
+            }
         }
-        this.stats.size = length;
-        // Truncate.
-        this._buffer = this._buffer.slice(0, length);
-        this.syncSync();
+        const slice = buffer.slice(offset, offset + length);
+        this._buffer.set(slice, position);
+        this.stats.mtimeMs = Date.now();
+        this.position = position + slice.byteLength;
+        return slice.byteLength;
     }
     /**
      * Write buffer to the file.
@@ -277,8 +306,8 @@ export class PreloadFile extends File {
      *   data should be written. If position is null, the data will be written at
      *   the current position.
      */
-    async write(buffer, offset = 0, length = this.stats.size, position = this.position) {
-        const bytesWritten = this.writeSync(buffer, offset, length, position);
+    async write(buffer, offset, length, position) {
+        const bytesWritten = this._write(buffer, offset, length, position);
         await this.sync();
         return bytesWritten;
     }
@@ -296,32 +325,29 @@ export class PreloadFile extends File {
      * @returns bytes written
      */
     writeSync(buffer, offset = 0, length = this.stats.size, position = this.position) {
-        this.dirty = true;
-        if (!isWriteable(this.flag)) {
-            throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
+        const bytesWritten = this._write(buffer, offset, length, position);
+        this.syncSync();
+        return bytesWritten;
+    }
+    _read(buffer, offset = 0, length = this.stats.size, position) {
+        if (!isReadable(this.flag)) {
+            throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode.');
         }
-        const end = position + length;
+        this.dirty = true;
+        position ?? (position = this.position);
+        let end = position + length;
         if (end > this.stats.size) {
-            this.stats.size = end;
-            if (end > this._buffer.byteLength) {
-                if (this._buffer.buffer.resizable && this._buffer.buffer.maxByteLength <= end) {
-                    this._buffer.buffer.resize(end);
-                }
-                else {
-                    // Extend the buffer!
-                    const newBuffer = new Uint8Array(new ArrayBuffer(end, this.fs.metadata().noResizableBuffers ? {} : { maxByteLength: size_max }));
-                    newBuffer.set(this._buffer);
-                    this._buffer = newBuffer;
-                }
-            }
+            end = position + Math.max(this.stats.size - position, 0);
         }
-        const slice = buffer.slice(offset, offset + length);
-        this._buffer.set(slice, position);
-        const bytesWritten = slice.byteLength;
-        this.stats.mtimeMs = Date.now();
-        this.position = position + bytesWritten;
-        this.syncSync();
-        return bytesWritten;
+        this.stats.atimeMs = Date.now();
+        this._position = end;
+        const bytesRead = end - position;
+        if (bytesRead == 0) {
+            // No copy/read. Return immediatly for better performance
+            return bytesRead;
+        }
+        new Uint8Array(buffer.buffer, offset, length).set(this._buffer.slice(position, end));
+        return bytesRead;
     }
     /**
      * Read data from the file.
@@ -334,8 +360,10 @@ export class PreloadFile extends File {
      *   in the file. If position is null, data will be read from the current file
      *   position.
      */
-    async read(buffer, offset = 0, length = this.stats.size, position = 0) {
-        return { bytesRead: this.readSync(buffer, offset, length, position), buffer };
+    async read(buffer, offset, length, position) {
+        const bytesRead = this._read(buffer, offset, length, position);
+        await this.sync();
+        return { bytesRead, buffer };
     }
     /**
      * Read data from the file.
@@ -348,25 +376,9 @@ export class PreloadFile extends File {
      *   position.
      * @returns number of bytes written
      */
-    readSync(buffer, offset = 0, length = this.stats.size, position) {
-        if (!isReadable(this.flag)) {
-            throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode.');
-        }
-        this.dirty = true;
-        position ?? (position = this.position);
-        let end = position + length;
-        if (end > this.stats.size) {
-            end = position + Math.max(this.stats.size - position, 0);
-        }
-        this.stats.atimeMs = Date.now();
-        this._position = end;
-        const bytesRead = end - position;
-        this.syncSync();
-        if (bytesRead == 0) {
-            // No copy/read. Return immediatly for better performance
-            return bytesRead;
-        }
-        new Uint8Array(buffer.buffer, offset, length).set(this._buffer.slice(position, end));
+    readSync(buffer, offset, length, position) {
+        const bytesRead = this._read(buffer, offset, length, position);
+        this.statSync();
         return bytesRead;
     }
     /**
@@ -374,7 +386,9 @@ export class PreloadFile extends File {
      * @param mode the mode
      */
     async chmod(mode) {
-        this.chmodSync(mode);
+        this.dirty = true;
+        this.stats.chmod(mode);
+        await this.sync();
     }
     /**
      * Synchronous `fchmod`.
@@ -391,7 +405,9 @@ export class PreloadFile extends File {
      * @param gid
      */
     async chown(uid, gid) {
-        this.chownSync(uid, gid);
+        this.dirty = true;
+        this.stats.chown(uid, gid);
+        await this.sync();
     }
     /**
      * Synchronous `fchown`.
@@ -404,7 +420,10 @@ export class PreloadFile extends File {
         this.syncSync();
     }
     async utimes(atime, mtime) {
-        this.utimesSync(atime, mtime);
+        this.dirty = true;
+        this.stats.atime = atime;
+        this.stats.mtime = mtime;
+        await this.sync();
     }
     utimesSync(atime, mtime) {
         this.dirty = true;
@@ -412,10 +431,10 @@ export class PreloadFile extends File {
         this.stats.mtime = mtime;
         this.syncSync();
     }
-    _setType(type) {
+    async _setType(type) {
         this.dirty = true;
         this.stats.mode = (this.stats.mode & ~S_IFMT) | type;
-        return this.sync();
+        await this.sync();
     }
     _setTypeSync(type) {
         this.dirty = true;

package/package.json

@@ -1,9 +1,9 @@
 {
 	"name": "@zenfs/core",
-	"version": "0.12.4",
+	"version": "0.12.6",
 	"description": "A filesystem in your browser",
 	"main": "dist/index.js",
-	"types": "src/index.ts",
+	"types": "dist/index.d.ts",
 	"keywords": [
 		"filesystem",
 		"node",
@@ -46,9 +46,10 @@
 		"prepublishOnly": "npm run build"
 	},
 	"dependencies": {
-		"@types/node": "^20.12.5",
+		"@types/node": "^20.12.12",
 		"@types/readable-stream": "^4.0.10",
 		"buffer": "^6.0.3",
+		"eventemitter3": "^5.0.1",
 		"minimatch": "^9.0.3",
 		"readable-stream": "^4.5.2",
 		"utilium": "^0.4.0"

package/src/emulation/dir.ts

@@ -16,6 +16,10 @@ export class Dirent implements _Dirent {
 		protected stats: Stats
 	) {}
 
+	get parentPath(): string {
+		return this.path;
+	}
+
 	isFile(): boolean {
 		return this.stats.isFile();
 	}

package/src/emulation/watchers.ts

@@ -0,0 +1,57 @@
+import { EventEmitter } from 'eventemitter3';
+import type { EventEmitter as NodeEventEmitter } from 'node:events';
+import type * as fs from 'node:fs';
+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 {
+		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 {
+		return super.removeListener<T>(event, fn as EventEmitter.EventListener<TEvents, T>, context, once);
+	}
+	/* eslint-enable @typescript-eslint/no-explicit-any */
+
+	public setMaxListeners(): never {
+		throw ErrnoError.With('ENOTSUP');
+	}
+
+	public getMaxListeners(): never {
+		throw ErrnoError.With('ENOTSUP');
+	}
+
+	public prependListener(): never {
+		throw ErrnoError.With('ENOTSUP');
+	}
+
+	public prependOnceListener(): never {
+		throw ErrnoError.With('ENOTSUP');
+	}
+
+	public rawListeners(): never {
+		throw ErrnoError.With('ENOTSUP');
+	}
+
+	public ref(): this {
+		return this;
+	}
+
+	public unref(): this {
+		return this;
+	}
+}
+
+export class FSWatcher
+	extends Watcher<{
+		change: [eventType: string, filename: string | Buffer];
+		close: [];
+		error: [error: Error];
+	}>
+	implements fs.FSWatcher
+{
+	public close(): void {}
+}
+
+export class StatWatcher extends Watcher implements fs.StatWatcher {}

package/src/file.ts

@@ -439,13 +439,30 @@ export class PreloadFile<FS extends FileSystem> extends File {
 		return new Stats(this.stats);
 	}
 
+	protected _truncate(length: number): void {
+		this.dirty = true;
+		if (!isWriteable(this.flag)) {
+			throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
+		}
+		this.stats.mtimeMs = Date.now();
+		if (length > this._buffer.length) {
+			const data = new Uint8Array(length - this._buffer.length);
+			// Write will set stats.size and handle syncing.
+			this.writeSync(data, 0, data.length, this._buffer.length);
+			return;
+		}
+		this.stats.size = length;
+		// Truncate.
+		this._buffer = this._buffer.slice(0, length);
+	}
+
 	/**
 	 * Asynchronous truncate.
 	 * @param length
 	 */
 	public async truncate(length: number): Promise<void> {
-		this.truncateSync(length);
-		return this.sync();
+		this._truncate(length);
+		await this.sync();
 	}
 
 	/**
@@ -453,21 +470,35 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 * @param length
 	 */
 	public truncateSync(length: number): void {
+		this._truncate(length);
+		this.syncSync();
+	}
+
+	protected _write(buffer: Uint8Array, offset: number = 0, length: number = this.stats.size, position: number = this.position): number {
 		this.dirty = true;
 		if (!isWriteable(this.flag)) {
 			throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
 		}
-		this.stats.mtimeMs = Date.now();
-		if (length > this._buffer.length) {
-			const data = new Uint8Array(length - this._buffer.length);
-			// Write will set stats.size and handle syncing.
-			this.writeSync(data, 0, data.length, this._buffer.length);
-			return;
+		const end = position + length;
+
+		if (end > this.stats.size) {
+			this.stats.size = end;
+			if (end > this._buffer.byteLength) {
+				if (this._buffer.buffer.resizable && this._buffer.buffer.maxByteLength! <= end) {
+					this._buffer.buffer.resize(end);
+				} else {
+					// Extend the buffer!
+					const newBuffer = new Uint8Array(new ArrayBuffer(end, this.fs.metadata().noResizableBuffers ? {} : { maxByteLength: size_max }));
+					newBuffer.set(this._buffer);
+					this._buffer = newBuffer;
+				}
+			}
 		}
-		this.stats.size = length;
-		// Truncate.
-		this._buffer = this._buffer.slice(0, length);
-		this.syncSync();
+		const slice = buffer.slice(offset, offset + length);
+		this._buffer.set(slice, position);
+		this.stats.mtimeMs = Date.now();
+		this.position = position + slice.byteLength;
+		return slice.byteLength;
 	}
 
 	/**
@@ -482,8 +513,8 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 *   data should be written. If position is null, the data will be written at
 	 *   the current position.
 	 */
-	public async write(buffer: Uint8Array, offset: number = 0, length: number = this.stats.size, position: number = this.position): Promise<number> {
-		const bytesWritten = this.writeSync(buffer, offset, length, position);
+	public async write(buffer: Uint8Array, offset?: number, length?: number, position?: number): Promise<number> {
+		const bytesWritten = this._write(buffer, offset, length, position);
 		await this.sync();
 		return bytesWritten;
 	}
@@ -502,32 +533,30 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 * @returns bytes written
 	 */
 	public writeSync(buffer: Uint8Array, offset: number = 0, length: number = this.stats.size, position: number = this.position): number {
-		this.dirty = true;
-		if (!isWriteable(this.flag)) {
-			throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
-		}
-		const end = position + length;
+		const bytesWritten = this._write(buffer, offset, length, position);
+		this.syncSync();
+		return bytesWritten;
+	}
 
+	protected _read(buffer: ArrayBufferView, offset: number = 0, length: number = this.stats.size, position?: number): number {
+		if (!isReadable(this.flag)) {
+			throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode.');
+		}
+		this.dirty = true;
+		position ??= this.position;
+		let end = position + length;
 		if (end > this.stats.size) {
-			this.stats.size = end;
-			if (end > this._buffer.byteLength) {
-				if (this._buffer.buffer.resizable && this._buffer.buffer.maxByteLength! <= end) {
-					this._buffer.buffer.resize(end);
-				} else {
-					// Extend the buffer!
-					const newBuffer = new Uint8Array(new ArrayBuffer(end, this.fs.metadata().noResizableBuffers ? {} : { maxByteLength: size_max }));
-					newBuffer.set(this._buffer);
-					this._buffer = newBuffer;
-				}
-			}
+			end = position + Math.max(this.stats.size - position, 0);
 		}
-		const slice = buffer.slice(offset, offset + length);
-		this._buffer.set(slice, position);
-		const bytesWritten = slice.byteLength;
-		this.stats.mtimeMs = Date.now();
-		this.position = position + bytesWritten;
-		this.syncSync();
-		return bytesWritten;
+		this.stats.atimeMs = Date.now();
+		this._position = end;
+		const bytesRead = end - position;
+		if (bytesRead == 0) {
+			// No copy/read. Return immediatly for better performance
+			return bytesRead;
+		}
+		new Uint8Array(buffer.buffer, offset, length).set(this._buffer.slice(position, end));
+		return bytesRead;
 	}
 
 	/**
@@ -541,13 +570,10 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 *   in the file. If position is null, data will be read from the current file
 	 *   position.
 	 */
-	public async read<TBuffer extends ArrayBufferView>(
-		buffer: TBuffer,
-		offset: number = 0,
-		length: number = this.stats.size,
-		position: number = 0
-	): Promise<{ bytesRead: number; buffer: TBuffer }> {
-		return { bytesRead: this.readSync(buffer, offset, length, position), buffer };
+	public async read<TBuffer extends ArrayBufferView>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<{ bytesRead: number; buffer: TBuffer }> {
+		const bytesRead = this._read(buffer, offset, length, position);
+		await this.sync();
+		return { bytesRead, buffer };
 	}
 
 	/**
@@ -561,25 +587,9 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 *   position.
 	 * @returns number of bytes written
 	 */
-	public readSync(buffer: ArrayBufferView, offset: number = 0, length: number = this.stats.size, position?: number): number {
-		if (!isReadable(this.flag)) {
-			throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode.');
-		}
-		this.dirty = true;
-		position ??= this.position;
-		let end = position + length;
-		if (end > this.stats.size) {
-			end = position + Math.max(this.stats.size - position, 0);
-		}
-		this.stats.atimeMs = Date.now();
-		this._position = end;
-		const bytesRead = end - position;
-		this.syncSync();
-		if (bytesRead == 0) {
-			// No copy/read. Return immediatly for better performance
-			return bytesRead;
-		}
-		new Uint8Array(buffer.buffer, offset, length).set(this._buffer.slice(position, end));
+	public readSync(buffer: ArrayBufferView, offset?: number, length?: number, position?: number): number {
+		const bytesRead = this._read(buffer, offset, length, position);
+		this.statSync();
 		return bytesRead;
 	}
 
@@ -588,7 +598,9 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 * @param mode the mode
 	 */
 	public async chmod(mode: number): Promise<void> {
-		this.chmodSync(mode);
+		this.dirty = true;
+		this.stats.chmod(mode);
+		await this.sync();
 	}
 
 	/**
@@ -607,7 +619,9 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 * @param gid
 	 */
 	public async chown(uid: number, gid: number): Promise<void> {
-		this.chownSync(uid, gid);
+		this.dirty = true;
+		this.stats.chown(uid, gid);
+		await this.sync();
 	}
 
 	/**
@@ -622,7 +636,10 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	}
 
 	public async utimes(atime: Date, mtime: Date): Promise<void> {
-		this.utimesSync(atime, mtime);
+		this.dirty = true;
+		this.stats.atime = atime;
+		this.stats.mtime = mtime;
+		await this.sync();
 	}
 
 	public utimesSync(atime: Date, mtime: Date): void {
@@ -632,10 +649,10 @@ export class PreloadFile<FS extends FileSystem> extends File {
 		this.syncSync();
 	}
 
-	public _setType(type: FileType): Promise<void> {
+	public async _setType(type: FileType): Promise<void> {
 		this.dirty = true;
 		this.stats.mode = (this.stats.mode & ~S_IFMT) | type;
-		return this.sync();
+		await this.sync();
 	}
 
 	public _setTypeSync(type: FileType): void {