@zenfs/core 1.8.7 → 1.8.8

package/dist/mixins/async.js

@@ -66,21 +66,21 @@ import { join } from '../vfs/path.js';
  */
 export function Async(FS) {
     class AsyncFS extends FS {
-        get _queueRunning() {
-            return !!this._queue.length;
+        async done() {
+            await this._promise;
         }
         queueDone() {
-            return new Promise(resolve => {
-                const check = () => (this._queueRunning ? setTimeout(check) : resolve());
-                check();
-            });
+            return this.done();
+        }
+        _async(promise) {
+            if (!this._promise) {
+                this._promise = promise;
+                return;
+            }
+            this._promise = this._promise.then(() => promise);
         }
         constructor(...args) {
             super(...args);
-            /**
-             * Queue of pending asynchronous operations.
-             */
-            this._queue = [];
             this._isInitialized = false;
             this._patchAsync();
         }
@@ -124,7 +124,7 @@ export function Async(FS) {
         renameSync(oldPath, newPath) {
             this.checkSync(oldPath, 'rename');
             this._sync.renameSync(oldPath, newPath);
-            this.queue('rename', oldPath, newPath);
+            this._async(this.rename(oldPath, newPath));
         }
         statSync(path) {
             this.checkSync(path, 'stat');
@@ -133,7 +133,7 @@ export function Async(FS) {
         createFileSync(path, flag, mode, options) {
             this.checkSync(path, 'createFile');
             this._sync.createFileSync(path, flag, mode, options);
-            this.queue('createFile', path, flag, mode, options);
+            this._async(this.createFile(path, flag, mode, options));
             return this.openFileSync(path, flag);
         }
         openFileSync(path, flag) {
@@ -144,17 +144,17 @@ export function Async(FS) {
         unlinkSync(path) {
             this.checkSync(path, 'unlinkSync');
             this._sync.unlinkSync(path);
-            this.queue('unlink', path);
+            this._async(this.unlink(path));
         }
         rmdirSync(path) {
             this.checkSync(path, 'rmdir');
             this._sync.rmdirSync(path);
-            this.queue('rmdir', path);
+            this._async(this.rmdir(path));
         }
         mkdirSync(path, mode, options) {
             this.checkSync(path, 'mkdir');
             this._sync.mkdirSync(path, mode, options);
-            this.queue('mkdir', path, mode, options);
+            this._async(this.mkdir(path, mode, options));
         }
         readdirSync(path) {
             this.checkSync(path, 'readdir');
@@ -163,12 +163,12 @@ export function Async(FS) {
         linkSync(srcpath, dstpath) {
             this.checkSync(srcpath, 'link');
             this._sync.linkSync(srcpath, dstpath);
-            this.queue('link', srcpath, dstpath);
+            this._async(this.link(srcpath, dstpath));
         }
         syncSync(path, data, stats) {
             this.checkSync(path, 'sync');
             this._sync.syncSync(path, data, stats);
-            this.queue('sync', path, data, stats);
+            this._async(this.sync(path, data, stats));
         }
         existsSync(path) {
             this.checkSync(path, 'exists');
@@ -181,7 +181,7 @@ export function Async(FS) {
         writeSync(path, buffer, offset) {
             this.checkSync(path, 'write');
             this._sync.writeSync(path, buffer, offset);
-            this.queue('write', path, buffer, offset);
+            this._async(this.write(path, buffer, offset));
         }
         /**
          * @internal
@@ -219,25 +219,6 @@ export function Async(FS) {
             }
             await Promise.all(promises);
         }
-        /**
-         * @internal
-         */
-        async _next() {
-            if (!this._queueRunning) {
-                return;
-            }
-            const [method, ...args] = this._queue.shift();
-            // @ts-expect-error 2556 (since ...args is not correctly picked up as being a tuple)
-            await this[method](...args);
-            await this._next();
-        }
-        /**
-         * @internal
-         */
-        queue(...op) {
-            this._queue.push(op);
-            void this._next();
-        }
         /**
          * @internal
          * Patch all async methods to also call their synchronous counterparts unless called from the queue
@@ -263,7 +244,7 @@ export function Async(FS) {
                 this[key] = async (...args) => {
                     var _a, _b;
                     const result = await originalMethod.apply(this, args);
-                    if (new Error().stack.includes(`at async ${this.constructor.name}._next`) || !this._isInitialized)
+                    if (new Error().stack.includes(`at <computed> [as ${key}]`) || !this._isInitialized)
                         return result;
                     try {
                         // @ts-expect-error 2556

package/dist/mixins/sync.js

@@ -37,6 +37,12 @@ export function Sync(FS) {
         async sync(path, data, stats) {
             return this.syncSync(path, data, stats);
         }
+        async read(path, buffer, offset, end) {
+            return this.readSync(path, buffer, offset, end);
+        }
+        async write(path, buffer, offset) {
+            return this.writeSync(path, buffer, offset);
+        }
     }
     return SyncFS;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.8.7",
+	"version": "1.8.8",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",

package/tests/fs/write.test.ts

@@ -29,7 +29,7 @@ suite('write', () => {
 
 		await handle.close();
 
-		assert((await fs.promises.readFile(fn)).equals(expected));
+		assert.deepEqual(await fs.promises.readFile(fn), expected);
 
 		await fs.promises.unlink(fn);
 	});