@zenfs/core 0.12.7 → 0.12.8

package/dist/filesystem.d.ts

@@ -64,6 +64,12 @@ export declare abstract class FileSystem {
      * Get metadata about the current file system
      */
     metadata(): FileSystemMetadata;
+    /**
+     * Whether the sync cache should be disabled.
+     * Only affects async things.
+     * @internal @protected
+     */
+    _disableSync?: boolean;
     constructor();
     ready(): Promise<void>;
     /**
@@ -186,18 +192,11 @@ declare abstract class SyncFS extends FileSystem {
 export declare function Sync<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => SyncFS) & T;
 /**
  * @internal
- * Note: `_*` should be treated like protected.
- * Protected can't be used because of TS quirks however.
  */
 declare abstract class AsyncFS extends FileSystem {
     /**
-     * @access protected
-     * @hidden
-     */
-    _disableSync: boolean;
-    /**
-     * @access protected
-     * @hidden
+     * protected can't be used because of TS quirks.
+     * @hidden @protected
      */
     abstract _sync?: FileSystem;
     queueDone(): Promise<void>;

package/dist/filesystem.js

@@ -16,12 +16,12 @@ export class FileSystem {
      */
     metadata() {
         return {
-            name: this.constructor.name,
+            name: this.constructor.name.toLowerCase(),
             readonly: false,
             totalSpace: 0,
             freeSpace: 0,
             noResizableBuffers: false,
-            noAsyncCache: false,
+            noAsyncCache: this._disableSync ?? false,
             type: ZenFsType,
         };
     }
@@ -114,7 +114,6 @@ export function Async(FS) {
              */
             this._queue = [];
             this._isInitialized = false;
-            this._disableSync = false;
         }
         get _queueRunning() {
             return !!this._queue.length;
@@ -141,12 +140,6 @@ export function Async(FS) {
                 throw e;
             }
         }
-        metadata() {
-            return {
-                ...super.metadata(),
-                noAsyncCache: this._disableSync,
-            };
-        }
         checkSync(path, syscall) {
             if (this._disableSync) {
                 throw new ErrnoError(Errno.ENOTSUP, 'Sync caching has been disabled for this async file system', path, syscall);

package/package.json

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

package/src/backends/store/fs.ts

@@ -20,33 +20,21 @@ const maxInodeAllocTries = 5;
  * @internal
  */
 export class StoreFS<T extends Store = Store> extends FileSystem {
-	protected get store(): T {
-		if (!this._store) {
-			throw new ErrnoError(Errno.ENODATA, 'No store attached');
-		}
-		return this._store;
-	}
-
-	protected _store?: T;
-
 	private _initialized: boolean = false;
 
 	public async ready(): Promise<void> {
-		await super.ready();
 		if (this._initialized) {
 			return;
 		}
+		await this.makeRootDirectory();
 		this._initialized = true;
-		this._store = await this.$store;
 	}
 
-	constructor(private $store: T | Promise<T>) {
+	constructor(protected store: T) {
 		super();
-
-		if (!($store instanceof Promise)) {
-			this._store = $store;
-			this._initialized = true;
+		if (!this._disableSync) {
 			this.makeRootDirectorySync();
+			this._initialized = true;
 		}
 	}
 
@@ -59,6 +47,7 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 
 	/**
 	 * Delete all contents stored in the file system.
+	 * @deprecated
 	 */
 	public async empty(): Promise<void> {
 		await this.store.clear();
@@ -68,6 +57,7 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 
 	/**
 	 * Delete all contents stored in the file system.
+	 * @deprecated
 	 */
 	public emptySync(): void {
 		this.store.clearSync();

package/src/backends/store/simple.ts

@@ -1,5 +1,5 @@
 import type { Ino } from '../../inode.js';
-import { type Store, SyncTransaction } from './store.js';
+import { SyncTransaction, type Store } from './store.js';
 
 /**
  * An interface for simple synchronous stores that don't have special support for transactions and such.
@@ -69,7 +69,7 @@ export abstract class SimpleAsyncStore implements SimpleSyncStore {
  * @see SimpleSyncStore
  * @see SimpleAsyncStore
  */
-export class SimpleTransaction extends SyncTransaction {
+export class SimpleTransaction extends SyncTransaction<SimpleSyncStore> {
 	/**
 	 * Stores data in the keys we modify prior to modifying them.
 	 * Allows us to roll back commits.
@@ -80,8 +80,10 @@ export class SimpleTransaction extends SyncTransaction {
 	 */
 	protected modifiedKeys: Set<Ino> = new Set();
 
-	constructor(protected store: SimpleSyncStore) {
-		super();
+	protected declare store: SimpleSyncStore;
+
+	constructor(store: SimpleSyncStore) {
+		super(store);
 	}
 
 	public getSync(ino: Ino): Uint8Array {

package/src/backends/store/store.ts

@@ -8,7 +8,7 @@ export interface Store {
 	/**
 	 * The name of the store.
 	 */
-	name: string;
+	readonly name: string;
 
 	/**
 	 * Syncs the store
@@ -32,9 +32,11 @@ export interface Store {
 }
 
 /**
- * A transaction for a synchronous store.
+ * A transaction for a store.
  */
-export abstract class Transaction {
+export abstract class Transaction<T extends Store = Store> {
+	constructor(protected store: T) {}
+
 	protected aborted: boolean = false;
 
 	/**
@@ -123,7 +125,7 @@ export abstract class Transaction {
 /**
  * Transaction that implements asynchronous operations with synchronous ones
  */
-export abstract class SyncTransaction extends Transaction {
+export abstract class SyncTransaction<T extends Store = Store> extends Transaction<T> {
 	public async get(ino: Ino): Promise<Uint8Array> {
 		return this.getSync(ino);
 	}
@@ -143,21 +145,24 @@ export abstract class SyncTransaction extends Transaction {
 
 /**
  * Transaction that only supports asynchronous operations
- * @todo Add caching
  */
-export abstract class AsyncTransaction extends Transaction {
-	public getSync(ino: Ino): Uint8Array {
+export abstract class AsyncTransaction<T extends Store = Store> extends Transaction<T> {
+	public getSync(): Uint8Array {
 		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.getSync');
 	}
-	public setSync(ino: bigint, data: Uint8Array): void {
+
+	public setSync(): void {
 		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.setSync');
 	}
-	public removeSync(ino: bigint): void {
+
+	public removeSync(): void {
 		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.removeSync');
 	}
+
 	public commitSync(): void {
 		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.commitSync');
 	}
+
 	public abortSync(): void {
 		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.abortSync');
 	}

package/src/filesystem.ts

@@ -80,16 +80,23 @@ export abstract class FileSystem {
 	 */
 	public metadata(): FileSystemMetadata {
 		return {
-			name: this.constructor.name,
+			name: this.constructor.name.toLowerCase(),
 			readonly: false,
 			totalSpace: 0,
 			freeSpace: 0,
 			noResizableBuffers: false,
-			noAsyncCache: false,
+			noAsyncCache: this._disableSync ?? false,
 			type: ZenFsType,
 		};
 	}
 
+	/**
+	 * Whether the sync cache should be disabled.
+	 * Only affects async things.
+	 * @internal @protected
+	 */
+	_disableSync?: boolean;
+
 	public constructor() {}
 
 	public async ready(): Promise<void> {}
@@ -293,18 +300,11 @@ export function Sync<T extends abstract new (...args: any[]) => FileSystem>(FS:
 
 /**
  * @internal
- * Note: `_*` should be treated like protected.
- * Protected can't be used because of TS quirks however.
  */
 declare abstract class AsyncFS extends FileSystem {
 	/**
-	 * @access protected
-	 * @hidden
-	 */
-	_disableSync: boolean;
-	/**
-	 * @access protected
-	 * @hidden
+	 * protected can't be used because of TS quirks.
+	 * @hidden @protected
 	 */
 	abstract _sync?: FileSystem;
 	public queueDone(): Promise<void>;
@@ -362,8 +362,6 @@ export function Async<T extends abstract new (...args: any[]) => FileSystem>(FS:
 
 		private _isInitialized: boolean = false;
 
-		_disableSync: boolean = false;
-
 		abstract _sync?: FileSystem;
 
 		public async ready(): Promise<void> {
@@ -384,13 +382,6 @@ export function Async<T extends abstract new (...args: any[]) => FileSystem>(FS:
 			}
 		}
 
-		public metadata(): FileSystemMetadata {
-			return {
-				...super.metadata(),
-				noAsyncCache: this._disableSync,
-			};
-		}
-
 		protected checkSync(path?: string, syscall?: string): asserts this is { _sync: FileSystem } {
 			if (this._disableSync) {
 				throw new ErrnoError(Errno.ENOTSUP, 'Sync caching has been disabled for this async file system', path, syscall);