@zenfs/core 1.0.8 → 1.0.10

package/dist/backends/overlay.d.ts

@@ -79,8 +79,8 @@ export declare class UnmutexedOverlayFS extends FileSystem {
      * - Ensures p is on writable before proceeding. Throws an error if it doesn't exist.
      * - Calls f to perform operation on writable.
      */
-    private operateOnWritable;
-    private operateOnWritableAsync;
+    private copyForWriteSync;
+    private copyForWrite;
     /**
      * Copy from readable to writable storage.
      * PRECONDITION: File does not exist on writable storage.
@@ -89,8 +89,8 @@ export declare class UnmutexedOverlayFS extends FileSystem {
     private copyToWritable;
 }
 declare const OverlayFS_base: {
-    new (): import("../mixins/mutexed.js").__MutexedFS<UnmutexedOverlayFS>;
-} & (new (args_0: OverlayOptions) => import("../mixins/mutexed.js").__MutexedFS<UnmutexedOverlayFS>);
+    new (): import("../mixins/mutexed.js")._MutexedFS<UnmutexedOverlayFS>;
+} & (new (args_0: OverlayOptions) => import("../mixins/mutexed.js")._MutexedFS<UnmutexedOverlayFS>);
 /**
  * OverlayFS makes a read-only filesystem writable by storing writes on a second,
  * writable file system. Deletes are persisted via metadata stored on the writable

package/dist/backends/overlay.js

@@ -1,3 +1,48 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        function next() {
+            while (env.stack.length) {
+                var rec = env.stack.pop();
+                try {
+                    var result = rec.dispose && rec.dispose.call(rec.value);
+                    if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { dirname } from '../emulation/path.js';
 import { Errno, ErrnoError } from '../error.js';
 import { PreloadFile, parseFlag } from '../file.js';
@@ -47,14 +92,14 @@ export class UnmutexedOverlayFS extends FileSystem {
         };
     }
     async sync(path, data, stats) {
-        await this.createParentDirectories(path);
+        await this.copyForWrite(path);
         if (!(await this.writable.exists(path))) {
             await this.writable.createFile(path, 'w', 0o644);
         }
         await this.writable.sync(path, data, stats);
     }
     syncSync(path, data, stats) {
-        this.createParentDirectoriesSync(path);
+        this.copyForWriteSync(path);
         this.writable.syncSync(path, data, stats);
     }
     /**
@@ -92,6 +137,7 @@ export class UnmutexedOverlayFS extends FileSystem {
         this.checkInitialized();
         this.checkPath(oldPath);
         this.checkPath(newPath);
+        await this.copyForWrite(oldPath);
         try {
             await this.writable.rename(oldPath, newPath);
         }
@@ -105,6 +151,7 @@ export class UnmutexedOverlayFS extends FileSystem {
         this.checkInitialized();
         this.checkPath(oldPath);
         this.checkPath(newPath);
+        this.copyForWriteSync(oldPath);
         try {
             this.writable.renameSync(oldPath, newPath);
         }
@@ -124,7 +171,7 @@ export class UnmutexedOverlayFS extends FileSystem {
                 throw ErrnoError.With('ENOENT', path, 'stat');
             }
             const oldStat = new Stats(await this.readable.stat(path));
-            // Make the oldStat's mode writable. Preserve the topmost part of the mode, which specifies the type
+            // Make the oldStat's mode writable.
             oldStat.mode |= 0o222;
             return oldStat;
         }
@@ -139,7 +186,7 @@ export class UnmutexedOverlayFS extends FileSystem {
                 throw ErrnoError.With('ENOENT', path, 'stat');
             }
             const oldStat = new Stats(this.readable.statSync(path));
-            // Make the oldStat's mode writable. Preserve the topmost part of the mode, which specifies the type.
+            // Make the oldStat's mode writable.
             oldStat.mode |= 0o222;
             return oldStat;
         }
@@ -150,7 +197,7 @@ export class UnmutexedOverlayFS extends FileSystem {
         }
         // Create an OverlayFile.
         const file = await this.readable.openFile(path, parseFlag('r'));
-        const stats = new Stats(await file.stat());
+        const stats = await file.stat();
         const { buffer } = await file.read(new Uint8Array(stats.size));
         return new PreloadFile(this, path, flag, stats, buffer);
     }
@@ -160,7 +207,7 @@ export class UnmutexedOverlayFS extends FileSystem {
         }
         // Create an OverlayFile.
         const file = this.readable.openFileSync(path, parseFlag('r'));
-        const stats = new Stats(file.statSync());
+        const stats = file.statSync();
         const data = new Uint8Array(stats.size);
         file.readSync(data);
         return new PreloadFile(this, path, flag, stats, data);
@@ -177,10 +224,12 @@ export class UnmutexedOverlayFS extends FileSystem {
     }
     async link(srcpath, dstpath) {
         this.checkInitialized();
+        await this.copyForWrite(srcpath);
         await this.writable.link(srcpath, dstpath);
     }
     linkSync(srcpath, dstpath) {
         this.checkInitialized();
+        this.copyForWriteSync(srcpath);
         this.writable.linkSync(srcpath, dstpath);
     }
     async unlink(path) {
@@ -219,15 +268,14 @@ export class UnmutexedOverlayFS extends FileSystem {
         if (await this.writable.exists(path)) {
             await this.writable.rmdir(path);
         }
-        if (await this.exists(path)) {
-            // Check if directory is empty.
-            if ((await this.readdir(path)).length > 0) {
-                throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
-            }
-            else {
-                await this.deletePath(path);
-            }
+        if (!(await this.exists(path))) {
+            return;
         }
+        // Check if directory is empty.
+        if ((await this.readdir(path)).length) {
+            throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
+        }
+        await this.deletePath(path);
     }
     rmdirSync(path) {
         this.checkInitialized();
@@ -237,15 +285,14 @@ export class UnmutexedOverlayFS extends FileSystem {
         if (this.writable.existsSync(path)) {
             this.writable.rmdirSync(path);
         }
-        if (this.existsSync(path)) {
-            // Check if directory is empty.
-            if (this.readdirSync(path).length > 0) {
-                throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
-            }
-            else {
-                void this.deletePath(path);
-            }
+        if (!this.existsSync(path)) {
+            return;
         }
+        // Check if directory is empty.
+        if (this.readdirSync(path).length) {
+            throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
+        }
+        void this.deletePath(path);
     }
     async mkdir(path, mode) {
         this.checkInitialized();
@@ -403,19 +450,23 @@ export class UnmutexedOverlayFS extends FileSystem {
      * - Ensures p is on writable before proceeding. Throws an error if it doesn't exist.
      * - Calls f to perform operation on writable.
      */
-    operateOnWritable(path) {
+    copyForWriteSync(path) {
         if (!this.existsSync(path)) {
-            throw ErrnoError.With('ENOENT', path, 'operateOnWriteable');
+            throw ErrnoError.With('ENOENT', path, 'copyForWrite');
+        }
+        if (!this.writable.existsSync(dirname(path))) {
+            this.createParentDirectoriesSync(path);
         }
         if (!this.writable.existsSync(path)) {
-            // File is on readable storage. Copy to writable storage before
-            // changing its mode.
             this.copyToWritableSync(path);
         }
     }
-    async operateOnWritableAsync(path) {
+    async copyForWrite(path) {
         if (!(await this.exists(path))) {
-            throw ErrnoError.With('ENOENT', path, 'operateOnWritable');
+            throw ErrnoError.With('ENOENT', path, 'copyForWrite');
+        }
+        if (!(await this.writable.exists(dirname(path)))) {
+            await this.createParentDirectories(path);
         }
         if (!(await this.writable.exists(path))) {
             return this.copyToWritable(path);
@@ -426,32 +477,50 @@ export class UnmutexedOverlayFS extends FileSystem {
      * PRECONDITION: File does not exist on writable storage.
      */
     copyToWritableSync(path) {
-        const stats = this.statSync(path);
-        if (stats.isDirectory()) {
-            this.writable.mkdirSync(path, stats.mode);
-            return;
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const stats = this.statSync(path);
+            if (stats.isDirectory()) {
+                this.writable.mkdirSync(path, stats.mode);
+                return;
+            }
+            const data = new Uint8Array(stats.size);
+            const readable = __addDisposableResource(env_1, this.readable.openFileSync(path, 'r'), false);
+            readable.readSync(data);
+            const writable = __addDisposableResource(env_1, this.writable.createFileSync(path, 'w', stats.mode | 0o222), false);
+            writable.writeSync(data);
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
         }
-        const data = new Uint8Array(stats.size);
-        const readable = this.readable.openFileSync(path, parseFlag('r'));
-        readable.readSync(data);
-        readable.closeSync();
-        const writable = this.writable.openFileSync(path, parseFlag('w'));
-        writable.writeSync(data);
-        writable.closeSync();
     }
     async copyToWritable(path) {
-        const stats = await this.stat(path);
-        if (stats.isDirectory()) {
-            await this.writable.mkdir(path, stats.mode);
-            return;
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const stats = await this.stat(path);
+            if (stats.isDirectory()) {
+                await this.writable.mkdir(path, stats.mode);
+                return;
+            }
+            const data = new Uint8Array(stats.size);
+            const readable = __addDisposableResource(env_2, await this.readable.openFile(path, 'r'), true);
+            await readable.read(data);
+            const writable = __addDisposableResource(env_2, await this.writable.createFile(path, 'w', stats.mode | 0o222), true);
+            await writable.write(data);
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            const result_1 = __disposeResources(env_2);
+            if (result_1)
+                await result_1;
         }
-        const data = new Uint8Array(stats.size);
-        const readable = await this.readable.openFile(path, parseFlag('r'));
-        await readable.read(data);
-        await readable.close();
-        const writable = await this.writable.openFile(path, parseFlag('w'));
-        await writable.write(data);
-        await writable.close();
     }
 }
 /**

package/dist/mixins/mutexed.d.ts

@@ -16,7 +16,7 @@ export declare class MutexLock {
 /**
  * @hidden
  */
-export declare class __MutexedFS<T extends FileSystem> implements FileSystem {
+export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
     /**
      * @internal
      */
@@ -90,6 +90,6 @@ export declare class __MutexedFS<T extends FileSystem> implements FileSystem {
  * @todo Change `using _` to `using void` pending https://github.com/tc39/proposal-discard-binding
  * @internal
  */
-export declare function Mutexed<const T extends Concrete<typeof FileSystem>>(FS: T): typeof __MutexedFS<InstanceType<T>> & {
-    new (...args: ConstructorParameters<T>): __MutexedFS<InstanceType<T>>;
+export declare function Mutexed<const T extends Concrete<typeof FileSystem>>(FS: T): typeof _MutexedFS<InstanceType<T>> & {
+    new (...args: ConstructorParameters<T>): _MutexedFS<InstanceType<T>>;
 };

package/dist/mixins/mutexed.js

@@ -69,7 +69,7 @@ export class MutexLock {
 /**
  * @hidden
  */
-export class __MutexedFS {
+export class _MutexedFS {
     async ready() {
         return await this._fs.ready();
     }
@@ -109,7 +109,7 @@ export class __MutexedFS {
      * @internal
      */
     lockSync(path, syscall) {
-        if (this.currentLock) {
+        if (this.currentLock?.isLocked) {
             throw ErrnoError.With('EBUSY', path, syscall);
         }
         return this.addLock();
@@ -459,7 +459,7 @@ export class __MutexedFS {
  * @internal
  */
 export function Mutexed(FS) {
-    class MutexedFS extends __MutexedFS {
+    class MutexedFS extends _MutexedFS {
         constructor(...args) {
             super();
             this._fs = new FS(...args);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.0.8",
+	"version": "1.0.10",
 	"description": "A filesystem, anywhere",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

package/src/backends/overlay.ts

@@ -75,7 +75,7 @@ export class UnmutexedOverlayFS extends FileSystem {
 	}
 
 	public async sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void> {
-		await this.createParentDirectories(path);
+		await this.copyForWrite(path);
 		if (!(await this.writable.exists(path))) {
 			await this.writable.createFile(path, 'w', 0o644);
 		}
@@ -83,7 +83,7 @@ export class UnmutexedOverlayFS extends FileSystem {
 	}
 
 	public syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void {
-		this.createParentDirectoriesSync(path);
+		this.copyForWriteSync(path);
 		this.writable.syncSync(path, data, stats);
 	}
 
@@ -126,6 +126,8 @@ export class UnmutexedOverlayFS extends FileSystem {
 		this.checkPath(oldPath);
 		this.checkPath(newPath);
 
+		await this.copyForWrite(oldPath);
+
 		try {
 			await this.writable.rename(oldPath, newPath);
 		} catch (e) {
@@ -140,6 +142,8 @@ export class UnmutexedOverlayFS extends FileSystem {
 		this.checkPath(oldPath);
 		this.checkPath(newPath);
 
+		this.copyForWriteSync(oldPath);
+
 		try {
 			this.writable.renameSync(oldPath, newPath);
 		} catch (e) {
@@ -158,7 +162,7 @@ export class UnmutexedOverlayFS extends FileSystem {
 				throw ErrnoError.With('ENOENT', path, 'stat');
 			}
 			const oldStat = new Stats(await this.readable.stat(path));
-			// Make the oldStat's mode writable. Preserve the topmost part of the mode, which specifies the type
+			// Make the oldStat's mode writable.
 			oldStat.mode |= 0o222;
 			return oldStat;
 		}
@@ -173,7 +177,7 @@ export class UnmutexedOverlayFS extends FileSystem {
 				throw ErrnoError.With('ENOENT', path, 'stat');
 			}
 			const oldStat = new Stats(this.readable.statSync(path));
-			// Make the oldStat's mode writable. Preserve the topmost part of the mode, which specifies the type.
+			// Make the oldStat's mode writable.
 			oldStat.mode |= 0o222;
 			return oldStat;
 		}
@@ -185,7 +189,7 @@ export class UnmutexedOverlayFS extends FileSystem {
 		}
 		// Create an OverlayFile.
 		const file = await this.readable.openFile(path, parseFlag('r'));
-		const stats = new Stats(await file.stat());
+		const stats = await file.stat();
 		const { buffer } = await file.read(new Uint8Array(stats.size));
 		return new PreloadFile(this, path, flag, stats, buffer);
 	}
@@ -196,7 +200,7 @@ export class UnmutexedOverlayFS extends FileSystem {
 		}
 		// Create an OverlayFile.
 		const file = this.readable.openFileSync(path, parseFlag('r'));
-		const stats = new Stats(file.statSync());
+		const stats = file.statSync();
 		const data = new Uint8Array(stats.size);
 		file.readSync(data);
 		return new PreloadFile(this, path, flag, stats, data);
@@ -216,11 +220,13 @@ export class UnmutexedOverlayFS extends FileSystem {
 
 	public async link(srcpath: string, dstpath: string): Promise<void> {
 		this.checkInitialized();
+		await this.copyForWrite(srcpath);
 		await this.writable.link(srcpath, dstpath);
 	}
 
 	public linkSync(srcpath: string, dstpath: string): void {
 		this.checkInitialized();
+		this.copyForWriteSync(srcpath);
 		this.writable.linkSync(srcpath, dstpath);
 	}
 
@@ -266,14 +272,14 @@ export class UnmutexedOverlayFS extends FileSystem {
 		if (await this.writable.exists(path)) {
 			await this.writable.rmdir(path);
 		}
-		if (await this.exists(path)) {
-			// Check if directory is empty.
-			if ((await this.readdir(path)).length > 0) {
-				throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
-			} else {
-				await this.deletePath(path);
-			}
+		if (!(await this.exists(path))) {
+			return;
+		}
+		// Check if directory is empty.
+		if ((await this.readdir(path)).length) {
+			throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
 		}
+		await this.deletePath(path);
 	}
 
 	public rmdirSync(path: string): void {
@@ -284,14 +290,14 @@ export class UnmutexedOverlayFS extends FileSystem {
 		if (this.writable.existsSync(path)) {
 			this.writable.rmdirSync(path);
 		}
-		if (this.existsSync(path)) {
-			// Check if directory is empty.
-			if (this.readdirSync(path).length > 0) {
-				throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
-			} else {
-				void this.deletePath(path);
-			}
+		if (!this.existsSync(path)) {
+			return;
 		}
+		// Check if directory is empty.
+		if (this.readdirSync(path).length) {
+			throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
+		}
+		void this.deletePath(path);
 	}
 
 	public async mkdir(path: string, mode: number): Promise<void> {
@@ -463,20 +469,25 @@ export class UnmutexedOverlayFS extends FileSystem {
 	 * - Ensures p is on writable before proceeding. Throws an error if it doesn't exist.
 	 * - Calls f to perform operation on writable.
 	 */
-	private operateOnWritable(path: string): void {
+	private copyForWriteSync(path: string): void {
 		if (!this.existsSync(path)) {
-			throw ErrnoError.With('ENOENT', path, 'operateOnWriteable');
+			throw ErrnoError.With('ENOENT', path, 'copyForWrite');
+		}
+		if (!this.writable.existsSync(dirname(path))) {
+			this.createParentDirectoriesSync(path);
 		}
 		if (!this.writable.existsSync(path)) {
-			// File is on readable storage. Copy to writable storage before
-			// changing its mode.
 			this.copyToWritableSync(path);
 		}
 	}
 
-	private async operateOnWritableAsync(path: string): Promise<void> {
+	private async copyForWrite(path: string): Promise<void> {
 		if (!(await this.exists(path))) {
-			throw ErrnoError.With('ENOENT', path, 'operateOnWritable');
+			throw ErrnoError.With('ENOENT', path, 'copyForWrite');
+		}
+
+		if (!(await this.writable.exists(dirname(path)))) {
+			await this.createParentDirectories(path);
 		}
 
 		if (!(await this.writable.exists(path))) {
@@ -496,12 +507,10 @@ export class UnmutexedOverlayFS extends FileSystem {
 		}
 
 		const data = new Uint8Array(stats.size);
-		const readable = this.readable.openFileSync(path, parseFlag('r'));
+		using readable = this.readable.openFileSync(path, 'r');
 		readable.readSync(data);
-		readable.closeSync();
-		const writable = this.writable.openFileSync(path, parseFlag('w'));
+		using writable = this.writable.createFileSync(path, 'w', stats.mode | 0o222);
 		writable.writeSync(data);
-		writable.closeSync();
 	}
 
 	private async copyToWritable(path: string): Promise<void> {
@@ -512,12 +521,10 @@ export class UnmutexedOverlayFS extends FileSystem {
 		}
 
 		const data = new Uint8Array(stats.size);
-		const readable = await this.readable.openFile(path, parseFlag('r'));
+		await using readable = await this.readable.openFile(path, 'r');
 		await readable.read(data);
-		await readable.close();
-		const writable = await this.writable.openFile(path, parseFlag('w'));
+		await using writable = await this.writable.createFile(path, 'w', stats.mode | 0o222);
 		await writable.write(data);
-		await writable.close();
 	}
 }
 

package/src/mixins/mutexed.ts

@@ -33,7 +33,7 @@ export class MutexLock {
 /**
  * @hidden
  */
-export class __MutexedFS<T extends FileSystem> implements FileSystem {
+export class _MutexedFS<T extends FileSystem> implements FileSystem {
 	/**
 	 * @internal
 	 */
@@ -87,7 +87,7 @@ export class __MutexedFS<T extends FileSystem> implements FileSystem {
 	 * @internal
 	 */
 	public lockSync(path: string, syscall: string): MutexLock {
-		if (this.currentLock) {
+		if (this.currentLock?.isLocked) {
 			throw ErrnoError.With('EBUSY', path, syscall);
 		}
 
@@ -244,10 +244,10 @@ export class __MutexedFS<T extends FileSystem> implements FileSystem {
  */
 export function Mutexed<const T extends Concrete<typeof FileSystem>>(
 	FS: T
-): typeof __MutexedFS<InstanceType<T>> & {
-	new (...args: ConstructorParameters<T>): __MutexedFS<InstanceType<T>>;
+): typeof _MutexedFS<InstanceType<T>> & {
+	new (...args: ConstructorParameters<T>): _MutexedFS<InstanceType<T>>;
 } {
-	class MutexedFS extends __MutexedFS<InstanceType<T>> {
+	class MutexedFS extends _MutexedFS<InstanceType<T>> {
 		public constructor(...args: ConstructorParameters<T>) {
 			super();
 			this._fs = new FS(...args) as InstanceType<T>;