@zenfs/core 2.3.10 → 2.3.11

package/dist/internal/index_fs.d.ts

@@ -30,6 +30,8 @@ export declare abstract class IndexFS extends FileSystem {
     protected create(path: string, options: CreationOptions): Inode;
     createFile(path: string, options: CreationOptions): Promise<InodeLike>;
     createFileSync(path: string, options: CreationOptions): InodeLike;
+    protected _mkdir?(path: string, options: CreationOptions): Promise<void>;
+    protected _mkdirSync?(path: string, options: CreationOptions): void;
     mkdir(path: string, options: CreationOptions): Promise<InodeLike>;
     mkdirSync(path: string, options: CreationOptions): InodeLike;
     link(target: string, link: string): Promise<void>;

package/dist/internal/index_fs.js

@@ -38,31 +38,56 @@ export class IndexFS extends FileSystem {
                 to = to.slice(0, -1);
             toRename.push({ from, to, inode });
         }
+        toRename.sort((a, b) => b.from.length - a.from.length);
         return toRename;
     }
     async rename(oldPath, newPath) {
         if (oldPath == newPath)
             return;
-        for (const { from, to, inode } of this.pathsForRename(oldPath, newPath)) {
+        const toRename = this.pathsForRename(oldPath, newPath);
+        const contents = new Map();
+        for (const { from, to, inode } of toRename) {
             const data = new Uint8Array(inode.size);
             await this.read(from, data, 0, inode.size);
+            contents.set(to, data);
             this.index.delete(from);
+            await this.remove(from);
+            if (this.index.has(to))
+                await this.remove(to);
+        }
+        toRename.reverse();
+        for (const { to, inode } of toRename) {
+            const data = contents.get(to);
             this.index.set(to, inode);
-            await this.write(to, data, 0);
+            if ((inode.mode & S_IFMT) == S_IFDIR)
+                await this._mkdir?.(to, inode);
+            else
+                await this.write(to, data, 0);
         }
-        await this.remove(oldPath);
     }
     renameSync(oldPath, newPath) {
         if (oldPath == newPath)
             return;
-        for (const { from, to, inode } of this.pathsForRename(oldPath, newPath)) {
+        const toRename = this.pathsForRename(oldPath, newPath);
+        const contents = new Map();
+        for (const { from, to, inode } of toRename) {
             const data = new Uint8Array(inode.size);
             this.readSync(from, data, 0, inode.size);
+            contents.set(to, data);
             this.index.delete(from);
+            this.removeSync(from);
+            if (this.index.has(to))
+                this.removeSync(to);
+        }
+        toRename.reverse();
+        for (const { to, inode } of toRename) {
+            const data = contents.get(to);
             this.index.set(to, inode);
-            this.writeSync(to, data, 0);
+            if ((inode.mode & S_IFMT) == S_IFDIR)
+                this._mkdirSync?.(to, inode);
+            else
+                this.writeSync(to, data, 0);
         }
-        this.removeSync(oldPath);
     }
     async stat(path) {
         const inode = this.index.get(path);
@@ -148,11 +173,15 @@ export class IndexFS extends FileSystem {
     }
     async mkdir(path, options) {
         options.mode |= S_IFDIR;
-        return this.create(path, options);
+        const inode = this.create(path, options);
+        await this._mkdir?.(path, options);
+        return inode;
     }
     mkdirSync(path, options) {
         options.mode |= S_IFDIR;
-        return this.create(path, options);
+        const inode = this.create(path, options);
+        this._mkdirSync?.(path, options);
+        return inode;
     }
     link(target, link) {
         throw withErrno('ENOSYS');

package/dist/mixins/mutexed.d.ts

@@ -49,7 +49,7 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
      * If the path is currently locked, waits for it to be unlocked.
      * @internal
      */
-    lock(): Promise<MutexLock>;
+    lock(timeout?: number): Promise<MutexLock>;
     /**
      * Locks `path` asynchronously.
      * If the path is currently locked, an error will be thrown

package/dist/mixins/mutexed.js

@@ -135,7 +135,7 @@ export class _MutexedFS {
      * If the path is currently locked, waits for it to be unlocked.
      * @internal
      */
-    async lock() {
+    async lock(timeout = 5000) {
         const previous = this.currentLock;
         const lock = this.addLock();
         const stack = new Error().stack;
@@ -145,7 +145,7 @@ export class _MutexedFS {
                 error.stack += stack?.slice('Error'.length);
                 throw err(error);
             }
-        }, 5000);
+        }, timeout);
         await previous?.done();
         return lock;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "2.3.10",
+	"version": "2.3.11",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -60,7 +60,7 @@
 		"format": "prettier --write .",
 		"format:check": "prettier --check .",
 		"lint": "eslint src tests",
-		"test": "npx zenfs-test --clean; npx zenfs-test -abcfp; tests/fetch/run.sh; npx zenfs-test --report",
+		"test": "npx zenfs-test --clean; npx zenfs-test -abcp; tests/fetch/run.sh; npx zenfs-test --report",
 		"build": "tsc -p tsconfig.json",
 		"build:docs": "typedoc",
 		"dev": "npm run build -- --watch",

package/tests/backend/port.test.ts

@@ -12,7 +12,7 @@ setupLogs();
 const timeoutChannel = new MessageChannel();
 timeoutChannel.port2.unref();
 
-await suite('Timeout', { timeout: 1000 }, () => {
+await suite('Timeout', () => {
 	test('Misconfiguration', async () => {
 		const configured = configure({
 			mounts: {

package/tests/common/mutex.test.ts

@@ -20,11 +20,11 @@ suite('Mutexed FS', () => {
 		let lock1Resolved = false;
 		let lock2Resolved = false;
 
-		const lock1 = fs.lock().then(lock => {
+		const lock1 = fs.lock(100).then(lock => {
 			lock1Resolved = true;
 			lock.unlock();
 		});
-		const lock2 = fs.lock().then(lock => {
+		const lock2 = fs.lock(100).then(lock => {
 			lock2Resolved = true;
 			lock.unlock();
 		});
@@ -50,7 +50,7 @@ suite('Mutexed FS', () => {
 		let x = 1;
 
 		async function foo() {
-			const lock = await fs.lock();
+			const lock = await fs.lock(100);
 			await wait(25);
 			x++;
 			lock.unlock();