@zenfs/core 0.12.7 → 0.12.9

package/dist/backends/index/fs.d.ts

@@ -20,6 +20,7 @@ declare const IndexFS_base: (abstract new (...args: any[]) => {
     linkSync(srcpath: string, dstpath: string, cred: Cred): void;
     sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
     syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
+    _disableSync?: boolean | undefined;
     ready(): Promise<void>;
     stat(path: string, cred: Cred): Promise<Stats>;
     statSync(path: string, cred: Cred): Stats;

package/dist/backends/memory.js

@@ -33,6 +33,8 @@ export const InMemory = {
         },
     },
     create({ name }) {
-        return new StoreFS(new InMemoryStore(name));
+        const fs = new StoreFS(new InMemoryStore(name));
+        fs.checkRootSync();
+        return fs;
     },
 };

package/dist/backends/port/fs.d.ts

@@ -41,7 +41,6 @@ export declare class PortFile extends File {
 type FSMethods = ExtractProperties<FileSystem, (...args: any[]) => Promise<any> | FileSystemMetadata>;
 type FSMethod = keyof FSMethods;
 declare const PortFS_base: (abstract new (...args: any[]) => {
-    _disableSync: boolean;
     _sync?: FileSystem | undefined;
     queueDone(): Promise<void>;
     metadata(): FileSystemMetadata;
@@ -56,16 +55,14 @@ declare const PortFS_base: (abstract new (...args: any[]) => {
     readdirSync(path: string, cred: Cred): string[];
     linkSync(srcpath: string, dstpath: string, cred: Cred): void;
     syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
+    _disableSync?: boolean | undefined;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
     stat(path: string, cred: Cred): Promise<Stats>;
     openFile(path: string, flag: string, cred: Cred): Promise<File>;
     createFile(path: string, flag: string, mode: number, cred: Cred): Promise<File>;
     unlink(path: string, cred: Cred): Promise<void>;
     rmdir(path: string, cred: Cred): Promise<void>;
-    mkdir(path: string, mode: number, cred: Cred): Promise<void>; /**
-     * Constructs a new PortFS instance that connects with ZenFS running on
-     * the specified port.
-     */
+    mkdir(path: string, mode: number, cred: Cred): Promise<void>;
     readdir(path: string, cred: Cred): Promise<string[]>;
     exists(path: string, cred: Cred): Promise<boolean>;
     existsSync(path: string, cred: Cred): boolean;

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

@@ -13,19 +13,19 @@ import type { Store, Transaction } from './store.js';
  * @internal
  */
 export declare class StoreFS<T extends Store = Store> extends FileSystem {
-    private $store;
-    protected get store(): T;
-    protected _store?: T;
+    protected store: T;
     private _initialized;
     ready(): Promise<void>;
-    constructor($store: T | Promise<T>);
+    constructor(store: T);
     metadata(): FileSystemMetadata;
     /**
      * Delete all contents stored in the file system.
+     * @deprecated
      */
     empty(): Promise<void>;
     /**
      * Delete all contents stored in the file system.
+     * @deprecated
      */
     emptySync(): void;
     /**
@@ -62,11 +62,11 @@ export declare class StoreFS<T extends Store = Store> extends FileSystem {
     /**
      * Checks if the root directory exists. Creates it if it doesn't.
      */
-    private makeRootDirectory;
+    checkRoot(): Promise<void>;
     /**
      * Checks if the root directory exists. Creates it if it doesn't.
      */
-    protected makeRootDirectorySync(): void;
+    checkRootSync(): void;
     /**
      * Helper function for findINode.
      * @param parent The parent directory of the file we are attempting to find.

package/dist/backends/store/fs.js

@@ -16,29 +16,17 @@ const maxInodeAllocTries = 5;
  * @internal
  */
 export class StoreFS extends FileSystem {
-    get store() {
-        if (!this._store) {
-            throw new ErrnoError(Errno.ENODATA, 'No store attached');
-        }
-        return this._store;
-    }
     async ready() {
-        await super.ready();
         if (this._initialized) {
             return;
         }
+        await this.checkRoot();
         this._initialized = true;
-        this._store = await this.$store;
     }
-    constructor($store) {
+    constructor(store) {
         super();
-        this.$store = $store;
+        this.store = store;
         this._initialized = false;
-        if (!($store instanceof Promise)) {
-            this._store = $store;
-            this._initialized = true;
-            this.makeRootDirectorySync();
-        }
     }
     metadata() {
         return {
@@ -48,19 +36,21 @@ export class StoreFS extends FileSystem {
     }
     /**
      * Delete all contents stored in the file system.
+     * @deprecated
      */
     async empty() {
         await this.store.clear();
         // Root always exists.
-        await this.makeRootDirectory();
+        await this.checkRoot();
     }
     /**
      * Delete all contents stored in the file system.
+     * @deprecated
      */
     emptySync() {
         this.store.clearSync();
         // Root always exists.
-        this.makeRootDirectorySync();
+        this.checkRootSync();
     }
     /**
      * @todo Make rename compatible with the cache.
@@ -381,7 +371,7 @@ export class StoreFS extends FileSystem {
     /**
      * Checks if the root directory exists. Creates it if it doesn't.
      */
-    async makeRootDirectory() {
+    async checkRoot() {
         const tx = this.store.transaction();
         if (await tx.get(rootIno)) {
             return;
@@ -397,7 +387,7 @@ export class StoreFS extends FileSystem {
     /**
      * Checks if the root directory exists. Creates it if it doesn't.
      */
-    makeRootDirectorySync() {
+    checkRootSync() {
         const tx = this.store.transaction();
         if (tx.getSync(rootIno)) {
             return;

package/dist/backends/store/simple.d.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.
  */
@@ -32,8 +32,7 @@ export declare abstract class SimpleAsyncStore implements SimpleSyncStore {
  * @see SimpleSyncStore
  * @see SimpleAsyncStore
  */
-export declare class SimpleTransaction extends SyncTransaction {
-    protected store: SimpleSyncStore;
+export declare class SimpleTransaction extends SyncTransaction<SimpleSyncStore> {
     /**
      * Stores data in the keys we modify prior to modifying them.
      * Allows us to roll back commits.
@@ -43,6 +42,7 @@ export declare class SimpleTransaction extends SyncTransaction {
      * List of keys modified in this transaction, if any.
      */
     protected modifiedKeys: Set<Ino>;
+    protected store: SimpleSyncStore;
     constructor(store: SimpleSyncStore);
     getSync(ino: Ino): Uint8Array;
     setSync(ino: Ino, data: Uint8Array): void;

package/dist/backends/store/simple.js

@@ -44,8 +44,7 @@ export class SimpleAsyncStore {
  */
 export class SimpleTransaction extends SyncTransaction {
     constructor(store) {
-        super();
-        this.store = store;
+        super(store);
         /**
          * Stores data in the keys we modify prior to modifying them.
          * Allows us to roll back commits.

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

@@ -6,7 +6,7 @@ export interface Store {
     /**
      * The name of the store.
      */
-    name: string;
+    readonly name: string;
     /**
      * Syncs the store
      */
@@ -25,9 +25,11 @@ export interface Store {
     transaction(): Transaction;
 }
 /**
- * A transaction for a synchronous store.
+ * A transaction for a store.
  */
-export declare abstract class Transaction {
+export declare abstract class Transaction<T extends Store = Store> {
+    protected store: T;
+    constructor(store: T);
     protected aborted: boolean;
     /**
      * Retrieves the data at the given key.
@@ -91,7 +93,7 @@ export declare abstract class Transaction {
 /**
  * Transaction that implements asynchronous operations with synchronous ones
  */
-export declare abstract class SyncTransaction extends Transaction {
+export declare abstract class SyncTransaction<T extends Store = Store> extends Transaction<T> {
     get(ino: Ino): Promise<Uint8Array>;
     set(ino: bigint, data: Uint8Array): Promise<void>;
     remove(ino: Ino): Promise<void>;
@@ -100,12 +102,11 @@ export declare abstract class SyncTransaction extends Transaction {
 }
 /**
  * Transaction that only supports asynchronous operations
- * @todo Add caching
  */
-export declare abstract class AsyncTransaction extends Transaction {
-    getSync(ino: Ino): Uint8Array;
-    setSync(ino: bigint, data: Uint8Array): void;
-    removeSync(ino: bigint): void;
+export declare abstract class AsyncTransaction<T extends Store = Store> extends Transaction<T> {
+    getSync(): Uint8Array;
+    setSync(): void;
+    removeSync(): void;
     commitSync(): void;
     abortSync(): void;
 }

package/dist/backends/store/store.js

@@ -1,9 +1,10 @@
 import { ErrnoError } from '../../error.js';
 /**
- * A transaction for a synchronous store.
+ * A transaction for a store.
  */
 export class Transaction {
-    constructor() {
+    constructor(store) {
+        this.store = store;
         this.aborted = false;
     }
     async [Symbol.asyncDispose]() {
@@ -41,16 +42,15 @@ export class SyncTransaction extends Transaction {
 }
 /**
  * Transaction that only supports asynchronous operations
- * @todo Add caching
  */
 export class AsyncTransaction extends Transaction {
-    getSync(ino) {
+    getSync() {
         throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.getSync');
     }
-    setSync(ino, data) {
+    setSync() {
         throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.setSync');
     }
-    removeSync(ino) {
+    removeSync() {
         throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.removeSync');
     }
     commitSync() {