@zenfs/core 1.2.2 → 1.2.3

package/dist/backends/store/simple.d.ts

@@ -4,6 +4,7 @@ import { SyncTransaction, type Store } from './store.js';
  * An interface for simple synchronous stores that don't have special support for transactions and such.
  */
 export interface SimpleSyncStore extends Store {
+    keys(): Iterable<Ino>;
     get(ino: Ino): Uint8Array | undefined;
     set(ino: Ino, data: Uint8Array): void;
     delete(ino: Ino): void;
@@ -17,6 +18,7 @@ export declare abstract class SimpleAsyncStore implements SimpleSyncStore {
     protected cache: Map<Ino, Uint8Array>;
     protected queue: Set<Promise<unknown>>;
     protected abstract entries(): Promise<Iterable<[Ino, Uint8Array]>>;
+    keys(): Iterable<Ino>;
     get(ino: Ino): Uint8Array | undefined;
     set(ino: Ino, data: Uint8Array): void;
     protected abstract _set(ino: Ino, data: Uint8Array): Promise<void>;
@@ -43,6 +45,7 @@ export declare class SimpleTransaction extends SyncTransaction<SimpleSyncStore>
      */
     protected modifiedKeys: Set<Ino>;
     protected store: SimpleSyncStore;
+    keysSync(): Iterable<Ino>;
     getSync(ino: Ino): Uint8Array;
     setSync(ino: Ino, data: Uint8Array): void;
     removeSync(ino: Ino): void;

package/dist/backends/store/simple.js

@@ -8,6 +8,9 @@ export class SimpleAsyncStore {
         this.cache = new Map();
         this.queue = new Set();
     }
+    keys() {
+        return this.cache.keys();
+    }
     get(ino) {
         return this.cache.get(ino);
     }
@@ -55,6 +58,9 @@ export class SimpleTransaction extends SyncTransaction {
          */
         this.modifiedKeys = new Set();
     }
+    keysSync() {
+        return this.store.keys();
+    }
     getSync(ino) {
         const val = this.store.get(ino);
         this.stashOldValue(ino, val);

package/dist/backends/store/store.d.ts

@@ -32,9 +32,17 @@ export declare abstract class Transaction<T extends Store = Store> {
     protected store: T;
     constructor(store: T);
     /**
-     * Whether the transaction was commited or aborted
+     * Whether the transaction was committed or aborted
      */
     protected done: boolean;
+    /**
+     * Gets all of the keys
+     */
+    abstract keys(): Promise<Iterable<Ino>>;
+    /**
+     * Gets all of the keys
+     */
+    abstract keysSync(): Iterable<Ino>;
     /**
      * Retrieves the data at `ino`.
      * @param ino The key to look under for data.
@@ -92,6 +100,7 @@ export declare abstract class Transaction<T extends Store = Store> {
  * Transaction that implements asynchronous operations with synchronous ones
  */
 export declare abstract class SyncTransaction<T extends Store = Store> extends Transaction<T> {
+    keys(): Promise<Iterable<Ino>>;
     get(ino: Ino): Promise<Uint8Array>;
     set(ino: bigint, data: Uint8Array): Promise<void>;
     remove(ino: Ino): Promise<void>;
@@ -102,9 +111,10 @@ export declare abstract class SyncTransaction<T extends Store = Store> extends T
  * Transaction that only supports asynchronous operations
  */
 export declare abstract class AsyncTransaction<T extends Store = Store> extends Transaction<T> {
-    getSync(): Uint8Array;
-    setSync(): void;
-    removeSync(): void;
-    commitSync(): void;
-    abortSync(): void;
+    keysSync(): never;
+    getSync(): never;
+    setSync(): never;
+    removeSync(): never;
+    commitSync(): never;
+    abortSync(): never;
 }

package/dist/backends/store/store.js

@@ -7,7 +7,7 @@ export class Transaction {
     constructor(store) {
         this.store = store;
         /**
-         * Whether the transaction was commited or aborted
+         * Whether the transaction was committed or aborted
          */
         this.done = false;
     }
@@ -29,6 +29,9 @@ export class Transaction {
  */
 export class SyncTransaction extends Transaction {
     /* eslint-disable @typescript-eslint/require-await */
+    async keys() {
+        return this.keysSync();
+    }
     async get(ino) {
         return this.getSync(ino);
     }
@@ -49,6 +52,9 @@ export class SyncTransaction extends Transaction {
  * Transaction that only supports asynchronous operations
  */
 export class AsyncTransaction extends Transaction {
+    keysSync() {
+        throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.keysSync');
+    }
     getSync() {
         throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.getSync');
     }

package/dist/mixins/async.js

@@ -45,6 +45,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
+import { StoreFS } from '../backends/store/fs.js';
 import { join } from '../emulation/path.js';
 import { Errno, ErrnoError } from '../error.js';
 import { parseFlag, PreloadFile } from '../file.js';
@@ -84,6 +85,18 @@ export function Async(FS) {
             }
             this.checkSync();
             await this._sync.ready();
+            // optimization: for 2 storeFS', we copy at a lower abstraction level.
+            if (this._sync instanceof StoreFS && this instanceof StoreFS) {
+                const sync = this._sync['store'].transaction();
+                const async = this['store'].transaction();
+                const promises = [];
+                for (const key of sync.keysSync()) {
+                    promises.push(async.set(key, sync.getSync(key)));
+                }
+                await Promise.all(promises);
+                this._isInitialized = true;
+                return;
+            }
             try {
                 await this.crossCopy('/');
                 this._isInitialized = true;
@@ -187,10 +200,11 @@ export function Async(FS) {
                 const stats = await this.stat(path);
                 this._sync.mkdirSync(path, stats.mode);
             }
-            const files = await this.readdir(path);
-            for (const file of files) {
-                await this.crossCopy(join(path, file));
+            const promises = [];
+            for (const file of await this.readdir(path)) {
+                promises.push(this.crossCopy(join(path, file)));
             }
+            await Promise.all(promises);
         }
         /**
          * @internal

package/package.json

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

package/src/backends/store/simple.ts

@@ -5,6 +5,7 @@ import { SyncTransaction, type Store } from './store.js';
  * An interface for simple synchronous stores that don't have special support for transactions and such.
  */
 export interface SimpleSyncStore extends Store {
+	keys(): Iterable<Ino>;
 	get(ino: Ino): Uint8Array | undefined;
 	set(ino: Ino, data: Uint8Array): void;
 	delete(ino: Ino): void;
@@ -23,6 +24,10 @@ export abstract class SimpleAsyncStore implements SimpleSyncStore {
 
 	protected abstract entries(): Promise<Iterable<[Ino, Uint8Array]>>;
 
+	public keys(): Iterable<Ino> {
+		return this.cache.keys();
+	}
+
 	public get(ino: Ino): Uint8Array | undefined {
 		return this.cache.get(ino);
 	}
@@ -82,6 +87,10 @@ export class SimpleTransaction extends SyncTransaction<SimpleSyncStore> {
 
 	protected declare store: SimpleSyncStore;
 
+	public keysSync(): Iterable<Ino> {
+		return this.store.keys();
+	}
+
 	public getSync(ino: Ino): Uint8Array {
 		const val = this.store.get(ino);
 		this.stashOldValue(ino, val);

package/src/backends/store/store.ts

@@ -39,10 +39,20 @@ export abstract class Transaction<T extends Store = Store> {
 	public constructor(protected store: T) {}
 
 	/**
-	 * Whether the transaction was commited or aborted
+	 * Whether the transaction was committed or aborted
 	 */
 	protected done: boolean = false;
 
+	/**
+	 * Gets all of the keys
+	 */
+	public abstract keys(): Promise<Iterable<Ino>>;
+
+	/**
+	 * Gets all of the keys
+	 */
+	public abstract keysSync(): Iterable<Ino>;
+
 	/**
 	 * Retrieves the data at `ino`.
 	 * @param ino The key to look under for data.
@@ -125,6 +135,9 @@ export abstract class Transaction<T extends Store = Store> {
  */
 export abstract class SyncTransaction<T extends Store = Store> extends Transaction<T> {
 	/* eslint-disable @typescript-eslint/require-await */
+	public async keys(): Promise<Iterable<Ino>> {
+		return this.keysSync();
+	}
 	public async get(ino: Ino): Promise<Uint8Array> {
 		return this.getSync(ino);
 	}
@@ -151,23 +164,27 @@ export abstract class SyncTransaction<T extends Store = Store> extends Transacti
  * Transaction that only supports asynchronous operations
  */
 export abstract class AsyncTransaction<T extends Store = Store> extends Transaction<T> {
-	public getSync(): Uint8Array {
+	public keysSync(): never {
+		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.keysSync');
+	}
+
+	public getSync(): never {
 		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.getSync');
 	}
 
-	public setSync(): void {
+	public setSync(): never {
 		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.setSync');
 	}
 
-	public removeSync(): void {
+	public removeSync(): never {
 		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.removeSync');
 	}
 
-	public commitSync(): void {
+	public commitSync(): never {
 		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.commitSync');
 	}
 
-	public abortSync(): void {
+	public abortSync(): never {
 		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.abortSync');
 	}
 }

package/src/mixins/async.ts

@@ -1,3 +1,5 @@
+import { StoreFS } from '../backends/store/fs.js';
+import type { Store } from '../backends/store/store.js';
 import { join } from '../emulation/path.js';
 import { Errno, ErrnoError } from '../error.js';
 import { parseFlag, PreloadFile, type File } from '../file.js';
@@ -72,6 +74,22 @@ export function Async<T extends typeof FileSystem>(
 
 			await this._sync.ready();
 
+			// optimization: for 2 storeFS', we copy at a lower abstraction level.
+			if (this._sync instanceof StoreFS && this instanceof StoreFS) {
+				const sync = (this._sync as StoreFS<Store>)['store'].transaction();
+				const async = (this as StoreFS<Store>)['store'].transaction();
+
+				const promises = [];
+				for (const key of sync.keysSync()) {
+					promises.push(async.set(key, sync.getSync(key)));
+				}
+
+				await Promise.all(promises);
+
+				this._isInitialized = true;
+				return;
+			}
+
 			try {
 				await this.crossCopy('/');
 				this._isInitialized = true;
@@ -175,10 +193,11 @@ export function Async<T extends typeof FileSystem>(
 				const stats = await this.stat(path);
 				this._sync.mkdirSync(path, stats.mode);
 			}
-			const files = await this.readdir(path);
-			for (const file of files) {
-				await this.crossCopy(join(path, file));
+			const promises = [];
+			for (const file of await this.readdir(path)) {
+				promises.push(this.crossCopy(join(path, file)));
 			}
+			await Promise.all(promises);
 		}
 
 		/**