@zenfs/core 0.9.3 → 0.9.5

package/dist/filesystem.d.ts

@@ -39,7 +39,7 @@ export declare abstract class FileSystem {
      */
     metadata(): FileSystemMetadata;
     constructor(options?: object);
-    abstract ready(): Promise<this>;
+    ready(): Promise<this>;
     /**
      * Asynchronous rename. No arguments other than a possible exception
      * are given to the completion callback.
@@ -174,6 +174,7 @@ declare abstract class AsyncFileSystem extends FileSystem {
      * @hidden
      */
     abstract _sync: FileSystem;
+    queueDone(): Promise<void>;
     metadata(): FileSystemMetadata;
     ready(): Promise<this>;
     renameSync(oldPath: string, newPath: string, cred: Cred): void;

package/dist/filesystem.js

@@ -27,6 +27,9 @@ export class FileSystem {
     constructor(options) {
         // unused
     }
+    async ready() {
+        return this;
+    }
     /**
      * Test whether or not the given path exists by checking with the file system.
      */
@@ -57,9 +60,6 @@ export class FileSystem {
  */
 export function Sync(FS) {
     class _SyncFileSystem extends FS {
-        async ready() {
-            return this;
-        }
         async exists(path, cred) {
             return this.existsSync(path, cred);
         }
@@ -116,11 +116,20 @@ export function Async(FS) {
              * Queue of pending asynchronous operations.
              */
             this._queue = [];
-            this._queueRunning = false;
             this._isInitialized = false;
         }
+        get _queueRunning() {
+            return !!this._queue.length;
+        }
+        queueDone() {
+            return new Promise(resolve => {
+                const check = () => (this._queueRunning ? setTimeout(check) : resolve());
+                check();
+            });
+        }
         async ready() {
             await this._sync.ready();
+            await super.ready();
             if (this._isInitialized) {
                 return this;
             }
@@ -195,12 +204,11 @@ export function Async(FS) {
             }
             else {
                 const asyncFile = await this.openFile(p, parseFlag('r'), rootCred);
-                const syncFile = this._sync.createFileSync(p, parseFlag('w'), stats.mode, rootCred);
+                const syncFile = this._sync.createFileSync(p, parseFlag('w'), stats.mode, stats.cred());
                 try {
-                    const { size } = await asyncFile.stat();
-                    const buffer = new Uint8Array(size);
+                    const buffer = new Uint8Array(stats.size);
                     await asyncFile.read(buffer);
-                    syncFile.writeSync(buffer);
+                    syncFile.writeSync(buffer, 0, stats.size);
                 }
                 finally {
                     await asyncFile.close();
@@ -212,8 +220,7 @@ export function Async(FS) {
          * @internal
          */
         async _next() {
-            if (this._queue.length == 0) {
-                this._queueRunning = false;
+            if (!this._queueRunning) {
                 return;
             }
             const [method, ...args] = this._queue.shift();
@@ -226,10 +233,6 @@ export function Async(FS) {
          */
         queue(...op) {
             this._queue.push(op);
-            if (this._queueRunning) {
-                return;
-            }
-            this._queueRunning = true;
             this._next();
         }
     }

package/dist/stats.d.ts

@@ -47,6 +47,10 @@ export interface StatsLike {
      * the id of the group that owns the file
      */
     gid: number | bigint;
+    /**
+     * the ino
+     */
+    ino: number | bigint;
 }
 /**
  * Provides information about a particular entry in the file system.
@@ -127,7 +131,7 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
     /**
      * Creates a new stats instance from a stats-like object. Can be used to copy stats (note)
      */
-    constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode }?: Partial<StatsLike>);
+    constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode, ino }?: Partial<StatsLike>);
     /**
      * @returns true if this item is a file.
      */

package/dist/stats.js

@@ -49,7 +49,7 @@ export class StatsCommon {
     /**
      * Creates a new stats instance from a stats-like object. Can be used to copy stats (note)
      */
-    constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode } = {}) {
+    constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode, ino } = {}) {
         /**
          * ID of device containing file
          */
@@ -91,6 +91,7 @@ export class StatsCommon {
         this.uid = resolveT(uid, 0);
         this.gid = resolveT(gid, 0);
         this.size = this._convert(size);
+        this.ino = this._convert(ino);
         const itemType = Number(mode) & S_IFMT || FileType.FILE;
         if (mode) {
             this.mode = this._convert(mode);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "0.9.3",
+	"version": "0.9.5",
 	"description": "A filesystem in your browser",
 	"main": "dist/index.js",
 	"types": "src/index.ts",

package/src/backends/AsyncStore.ts

@@ -132,10 +132,15 @@ export interface AsyncStoreOptions {
  */
 export class AsyncStoreFS extends Async(FileSystem) {
 	protected store: AsyncStore;
-	private _cache?: LRUCache<string, Ino>;
+	protected _cache?: LRUCache<string, Ino>;
+	private _initialized: boolean = false;
 	_sync: FileSystem;
 
-	public async ready() {
+	public async ready(): Promise<this> {
+		if (this._initialized) {
+			return this;
+		}
+		this._initialized = true;
 		if (this._options.lruCacheSize > 0) {
 			this._cache = new LRUCache(this._options.lruCacheSize);
 		}
@@ -165,7 +170,7 @@ export class AsyncStoreFS extends Async(FileSystem) {
 			this._cache.reset();
 		}
 		await this.store.clear();
-		// INVARIANT: Root always exists.
+		// Root always exists.
 		await this.makeRootDirectory();
 	}
 
@@ -173,6 +178,7 @@ export class AsyncStoreFS extends Async(FileSystem) {
 	 * @todo Make rename compatible with the cache.
 	 */
 	public async rename(oldPath: string, newPath: string, cred: Cred): Promise<void> {
+		await this.queueDone();
 		const c = this._cache;
 		if (this._cache) {
 			// Clear and disable cache during renaming process.
@@ -255,6 +261,7 @@ export class AsyncStoreFS extends Async(FileSystem) {
 	}
 
 	public async stat(p: string, cred: Cred): Promise<Stats> {
+		await this.queueDone();
 		const tx = this.store.beginTransaction();
 		const inode = await this.findINode(tx, p);
 		if (!inode) {
@@ -268,6 +275,7 @@ export class AsyncStoreFS extends Async(FileSystem) {
 	}
 
 	public async createFile(p: string, flag: string, mode: number, cred: Cred): Promise<PreloadFile<this>> {
+		await this.queueDone();
 		const tx = this.store.beginTransaction(),
 			data = new Uint8Array(0),
 			newFile = await this.commitNewFile(tx, p, FileType.FILE, mode, cred, data);
@@ -276,6 +284,7 @@ export class AsyncStoreFS extends Async(FileSystem) {
 	}
 
 	public async openFile(p: string, flag: string, cred: Cred): Promise<PreloadFile<this>> {
+		await this.queueDone();
 		const tx = this.store.beginTransaction(),
 			node = await this.findINode(tx, p),
 			data = await tx.get(node.ino);
@@ -289,10 +298,12 @@ export class AsyncStoreFS extends Async(FileSystem) {
 	}
 
 	public async unlink(p: string, cred: Cred): Promise<void> {
+		await this.queueDone();
 		return this.removeEntry(p, false, cred);
 	}
 
 	public async rmdir(p: string, cred: Cred): Promise<void> {
+		await this.queueDone();
 		// Check first if directory is empty.
 		const list = await this.readdir(p, cred);
 		if (list.length > 0) {
@@ -302,12 +313,14 @@ export class AsyncStoreFS extends Async(FileSystem) {
 	}
 
 	public async mkdir(p: string, mode: number, cred: Cred): Promise<void> {
+		await this.queueDone();
 		const tx = this.store.beginTransaction(),
 			data = encode('{}');
 		await this.commitNewFile(tx, p, FileType.DIRECTORY, mode, cred, data);
 	}
 
 	public async readdir(p: string, cred: Cred): Promise<string[]> {
+		await this.queueDone();
 		const tx = this.store.beginTransaction();
 		const node = await this.findINode(tx, p);
 		if (!node.toStats().hasAccess(R_OK, cred)) {
@@ -321,6 +334,7 @@ export class AsyncStoreFS extends Async(FileSystem) {
 	 * @todo Ensure mtime updates properly, and use that to determine if a data update is required.
 	 */
 	public async sync(p: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void> {
+		await this.queueDone();
 		const tx = this.store.beginTransaction(),
 			// We use the _findInode helper because we actually need the INode id.
 			fileInodeId = await this._findINode(tx, dirname(p), basename(p)),
@@ -342,6 +356,7 @@ export class AsyncStoreFS extends Async(FileSystem) {
 	}
 
 	public async link(existing: string, newpath: string, cred: Cred): Promise<void> {
+		await this.queueDone();
 		const tx = this.store.beginTransaction(),
 			existingDir: string = dirname(existing),
 			existingDirNode = await this.findINode(tx, existingDir);
@@ -382,14 +397,13 @@ export class AsyncStoreFS extends Async(FileSystem) {
 	 */
 	private async makeRootDirectory(): Promise<void> {
 		const tx = this.store.beginTransaction();
-		if ((await tx.get(rootIno)) === undefined) {
+		if (!(await tx.get(rootIno))) {
 			// Create new inode. o777, owned by root:root
-			const dirInode = new Inode();
-			dirInode.mode = 0o777 | FileType.DIRECTORY;
-			// If the root doesn't exist, the first random ID shouldn't exist,
-			// either.
-			await tx.put(dirInode.ino, encode('{}'), false);
-			await tx.put(rootIno, dirInode.data, false);
+			const inode = new Inode();
+			inode.mode = 0o777 | FileType.DIRECTORY;
+			// If the root doesn't exist, the first random ID shouldn't exist either.
+			await tx.put(inode.ino, encode('{}'), false);
+			await tx.put(rootIno, inode.data, false);
 			await tx.commit();
 		}
 	}

package/src/filesystem.ts

@@ -59,7 +59,9 @@ export abstract class FileSystem {
 		// unused
 	}
 
-	public abstract ready(): Promise<this>;
+	public async ready(): Promise<this> {
+		return this;
+	}
 
 	/**
 	 * Asynchronous rename. No arguments other than a possible exception
@@ -218,10 +220,6 @@ declare abstract class SyncFileSystem extends FileSystem {
  */
 export function Sync<T extends abstract new (...args) => FileSystem>(FS: T): (abstract new (...args) => SyncFileSystem) & T {
 	abstract class _SyncFileSystem extends FS implements SyncFileSystem {
-		public async ready(): Promise<this> {
-			return this;
-		}
-
 		public async exists(path: string, cred: Cred): Promise<boolean> {
 			return this.existsSync(path, cred);
 		}
@@ -277,6 +275,7 @@ declare abstract class AsyncFileSystem extends FileSystem {
 	 * @hidden
 	 */
 	abstract _sync: FileSystem;
+	queueDone(): Promise<void>;
 	metadata(): FileSystemMetadata;
 	ready(): Promise<this>;
 	renameSync(oldPath: string, newPath: string, cred: Cred): void;
@@ -318,13 +317,24 @@ export function Async<T extends abstract new (...args) => FileSystem>(FS: T): (a
 		 * Queue of pending asynchronous operations.
 		 */
 		private _queue: AsyncOperation[] = [];
-		private _queueRunning: boolean = false;
+		private get _queueRunning(): boolean {
+			return !!this._queue.length;
+		}
+
+		public queueDone(): Promise<void> {
+			return new Promise(resolve => {
+				const check = () => (this._queueRunning ? setTimeout(check) : resolve());
+				check();
+			});
+		}
+
 		private _isInitialized: boolean = false;
 
 		abstract _sync: FileSystem;
 
 		public async ready(): Promise<this> {
 			await this._sync.ready();
+			await super.ready();
 			if (this._isInitialized) {
 				return this;
 			}
@@ -410,12 +420,11 @@ export function Async<T extends abstract new (...args) => FileSystem>(FS: T): (a
 				}
 			} else {
 				const asyncFile = await this.openFile(p, parseFlag('r'), rootCred);
-				const syncFile = this._sync.createFileSync(p, parseFlag('w'), stats.mode, rootCred);
+				const syncFile = this._sync.createFileSync(p, parseFlag('w'), stats.mode, stats.cred());
 				try {
-					const { size } = await asyncFile.stat();
-					const buffer = new Uint8Array(size);
+					const buffer = new Uint8Array(stats.size);
 					await asyncFile.read(buffer);
-					syncFile.writeSync(buffer);
+					syncFile.writeSync(buffer, 0, stats.size);
 				} finally {
 					await asyncFile.close();
 					syncFile.closeSync();
@@ -427,12 +436,11 @@ export function Async<T extends abstract new (...args) => FileSystem>(FS: T): (a
 		 * @internal
 		 */
 		private async _next(): Promise<void> {
-			if (this._queue.length == 0) {
-				this._queueRunning = false;
+			if (!this._queueRunning) {
 				return;
 			}
 
-			const [method, ...args] = this._queue.shift()!;
+			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();
@@ -443,11 +451,6 @@ export function Async<T extends abstract new (...args) => FileSystem>(FS: T): (a
 		 */
 		private queue(...op: AsyncOperation) {
 			this._queue.push(op);
-			if (this._queueRunning) {
-				return;
-			}
-
-			this._queueRunning = true;
 			this._next();
 		}
 	}

package/src/stats.ts

@@ -49,6 +49,10 @@ export interface StatsLike {
 	 * the id of the group that owns the file
 	 */
 	gid: number | bigint;
+	/**
+	 * the ino
+	 */
+	ino: number | bigint;
 }
 
 /**
@@ -179,7 +183,7 @@ export abstract class StatsCommon<T extends number | bigint> implements Node.Sta
 	/**
 	 * Creates a new stats instance from a stats-like object. Can be used to copy stats (note)
 	 */
-	constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode }: Partial<StatsLike> = {}) {
+	constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode, ino }: Partial<StatsLike> = {}) {
 		const currentTime = Date.now();
 		const resolveT = (val: number | bigint, _default: number) => <T>(typeof val == this._typename ? val : this._convert(typeof val == this._typename_inverse ? val : _default));
 		this.atimeMs = resolveT(atimeMs, currentTime);
@@ -189,6 +193,7 @@ export abstract class StatsCommon<T extends number | bigint> implements Node.Sta
 		this.uid = resolveT(uid, 0);
 		this.gid = resolveT(gid, 0);
 		this.size = this._convert(size);
+		this.ino = this._convert(ino);
 		const itemType: FileType = Number(mode) & S_IFMT || FileType.FILE;
 
 		if (mode) {