@zenfs/core 0.3.1 → 0.3.3

package/dist/FileIndex.d.ts

@@ -154,7 +154,7 @@ export declare class IndexDirInode<T> extends IndexInode<T> {
     remove(p: string): IndexInode<T> | null;
 }
 declare const FileIndexFS_base: (abstract new (...args: any[]) => {
-    readonly metadata: import("./filesystem.js").FileSystemMetadata;
+    metadata(): import("./filesystem.js").FileSystemMetadata;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
     createFile(path: string, flag: FileFlag, mode: number, cred: Cred): Promise<import("./file.js").File>;
@@ -180,12 +180,12 @@ export declare abstract class FileIndexFS<TIndex> extends FileIndexFS_base {
     readdir(path: string): Promise<string[]>;
     readdirSync(path: string): string[];
     protected abstract statFileInode(inode: IndexFileInode<TIndex>): Promise<Stats>;
-    protected abstract fileForFileInode(inode: IndexFileInode<TIndex>): Promise<NoSyncFile<this>>;
     protected abstract statFileInodeSync(inode: IndexFileInode<TIndex>): Stats;
-    protected abstract fileForFileInodeSync(inode: IndexFileInode<TIndex>): NoSyncFile<this>;
+    protected abstract fileForFileInode(inode: IndexFileInode<TIndex>, path: string, flag: FileFlag): Promise<NoSyncFile<this>>;
+    protected abstract fileForFileInodeSync(inode: IndexFileInode<TIndex>, path: string, flag: FileFlag): NoSyncFile<this>;
 }
 declare const SyncFileIndexFS_base: (abstract new (...args: any[]) => {
-    readonly metadata: import("./filesystem.js").FileSystemMetadata;
+    metadata(): import("./filesystem.js").FileSystemMetadata;
     ready(): Promise<any>;
     exists(path: string, cred: Cred): Promise<boolean>;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
@@ -212,10 +212,10 @@ declare const SyncFileIndexFS_base: (abstract new (...args: any[]) => {
 }) & (abstract new (index: ListingTree) => FileIndexFS<unknown>);
 export declare abstract class SyncFileIndexFS<TIndex> extends SyncFileIndexFS_base {
     protected statFileInode(inode: IndexFileInode<TIndex>): Promise<Stats>;
-    protected fileForFileInode(inode: IndexFileInode<TIndex>): Promise<NoSyncFile<this>>;
+    protected fileForFileInode(inode: IndexFileInode<TIndex>, path: string, flag: FileFlag): Promise<NoSyncFile<this>>;
 }
 declare const AsyncFileIndexFS_base: (abstract new (...args: any[]) => {
-    readonly metadata: import("./filesystem.js").FileSystemMetadata;
+    metadata(): import("./filesystem.js").FileSystemMetadata;
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
     statSync(path: string, cred: Cred): Stats;
     createFileSync(path: string, flag: FileFlag, mode: number, cred: Cred): import("./file.js").File;

package/dist/FileIndex.js

@@ -346,7 +346,7 @@ export class FileIndexFS extends Readonly(FileSystem) {
             const stats = inode.stats;
             return new NoSyncFile(this, path, flag, stats, stats.fileData);
         }
-        return this.fileForFileInode(inode);
+        return this.fileForFileInode(inode, path, flag);
     }
     openFileSync(path, flag, cred) {
         if (flag.isWriteable()) {
@@ -365,7 +365,7 @@ export class FileIndexFS extends Readonly(FileSystem) {
             const stats = inode.stats;
             return new NoSyncFile(this, path, flag, stats, stats.fileData);
         }
-        return this.fileForFileInodeSync(inode);
+        return this.fileForFileInodeSync(inode, path, flag);
     }
     async readdir(path) {
         // Check if it exists.
@@ -394,8 +394,8 @@ export class SyncFileIndexFS extends Sync((FileIndexFS)) {
     async statFileInode(inode) {
         return this.statFileInodeSync(inode);
     }
-    async fileForFileInode(inode) {
-        return this.fileForFileInodeSync(inode);
+    async fileForFileInode(inode, path, flag) {
+        return this.fileForFileInodeSync(inode, path, flag);
     }
 }
 export class AsyncFileIndexFS extends Async((FileIndexFS)) {

package/dist/backends/AsyncMirror.d.ts

@@ -13,23 +13,21 @@ declare class MirrorFile extends PreloadFile<AsyncMirrorFS> {
     close(): Promise<void>;
     closeSync(): void;
 }
-export declare namespace AsyncMirror {
+/**
+ * Configuration options for the AsyncMirror file system.
+ */
+export interface AsyncMirrorOptions {
+    /**
+     * The synchronous file system to mirror the asynchronous file system to.
+     */
+    sync: FileSystem;
     /**
-     * Configuration options for the AsyncMirror file system.
+     * The asynchronous file system to mirror.
      */
-    interface Options {
-        /**
-         * The synchronous file system to mirror the asynchronous file system to.
-         */
-        sync: FileSystem;
-        /**
-         * The asynchronous file system to mirror.
-         */
-        async: FileSystem;
-    }
+    async: FileSystem;
 }
 declare const AsyncMirrorFS_base: (abstract new (...args: any[]) => {
-    readonly metadata: FileSystemMetadata;
+    metadata(): FileSystemMetadata;
     ready(): Promise<any>;
     exists(path: string, cred: Cred): Promise<boolean>;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
@@ -43,6 +41,9 @@ declare const AsyncMirrorFS_base: (abstract new (...args: any[]) => {
     link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
     sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
+    /**
+     * Queue of pending asynchronous operations.
+     */
     statSync(path: string, cred: Cred): Stats;
     openFileSync(path: string, flag: FileFlag, cred: Cred): File;
     createFileSync(path: string, flag: FileFlag, mode: number, cred: Cred): File;
@@ -85,8 +86,8 @@ export declare class AsyncMirrorFS extends AsyncMirrorFS_base {
      * @param sync The synchronous file system to mirror the asynchronous file system to.
      * @param async The asynchronous file system to mirror.
      */
-    constructor({ sync, async }: AsyncMirror.Options);
-    get metadata(): FileSystemMetadata;
+    constructor({ sync, async }: AsyncMirrorOptions);
+    metadata(): FileSystemMetadata;
     syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
     openFileSync(path: string, flag: FileFlag, cred: Cred): File;
     createFileSync(path: string, flag: FileFlag, mode: number, cred: Cred): MirrorFile;

package/dist/backends/AsyncMirror.js

@@ -63,13 +63,12 @@ export class AsyncMirrorFS extends Sync(FileSystem) {
         this._async = async;
         this._ready = this._initialize();
     }
-    // @ts-expect-error 2611
-    get metadata() {
+    metadata() {
         return {
-            ...super.metadata,
+            ...super.metadata(),
             name: AsyncMirrorFS.name,
             synchronous: true,
-            supportsProperties: this._sync.metadata.supportsProperties && this._async.metadata.supportsProperties,
+            supportsProperties: this._sync.metadata().supportsProperties && this._async.metadata().supportsProperties,
         };
     }
     syncSync(path, data, stats) {
@@ -232,7 +231,7 @@ export const AsyncMirror = {
             type: 'object',
             description: 'The synchronous file system to mirror the asynchronous file system to.',
             validator: async (v) => {
-                if (!v?.metadata.synchronous) {
+                if (!v?.metadata().synchronous) {
                     throw new ApiError(ErrorCode.EINVAL, `'sync' option must be a file system that supports synchronous operations`);
                 }
             },

package/dist/backends/AsyncStore.d.ts

@@ -62,14 +62,14 @@ export interface AsyncRWTransaction extends AsyncROTransaction {
      */
     abort(): Promise<void>;
 }
-export declare class AsyncFile extends PreloadFile<AsyncStoreFileSystem> {
-    constructor(_fs: AsyncStoreFileSystem, _path: string, _flag: FileFlag, _stat: Stats, contents?: Uint8Array);
+export declare class AsyncFile extends PreloadFile<AsyncStoreFS> {
+    constructor(_fs: AsyncStoreFS, _path: string, _flag: FileFlag, _stat: Stats, contents?: Uint8Array);
     sync(): Promise<void>;
     syncSync(): void;
     close(): Promise<void>;
     closeSync(): void;
 }
-export interface AsyncStoreFileSystemOptions {
+export interface AsyncStoreOptions {
     /**
      * Promise that resolves to the store
      */
@@ -79,8 +79,8 @@ export interface AsyncStoreFileSystemOptions {
      */
     cacheSize?: number;
 }
-declare const AsyncStoreFileSystem_base: (abstract new (...args: any[]) => {
-    readonly metadata: FileSystemMetadata;
+declare const AsyncStoreFS_base: (abstract new (...args: any[]) => {
+    metadata(): FileSystemMetadata;
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
     statSync(path: string, cred: Cred): Stats;
     createFileSync(path: string, flag: FileFlag, mode: number, cred: Cred): File;
@@ -96,13 +96,13 @@ declare const AsyncStoreFileSystem_base: (abstract new (...args: any[]) => {
  * An "Asynchronous key-value file system". Stores data to/retrieves data from
  * an underlying asynchronous key-value store.
  */
-export declare class AsyncStoreFileSystem extends AsyncStoreFileSystem_base {
+export declare class AsyncStoreFS extends AsyncStoreFS_base {
     protected store: AsyncStore;
     private _cache?;
     protected _ready: Promise<this>;
     ready(): Promise<this>;
-    get metadata(): FileSystemMetadata;
-    constructor({ store, cacheSize }: AsyncStoreFileSystemOptions);
+    metadata(): FileSystemMetadata;
+    constructor({ store, cacheSize }: AsyncStoreOptions);
     /**
      * Initializes the file system. Typically called by subclasses' async
      * constructors.

package/dist/backends/AsyncStore.js

@@ -69,14 +69,13 @@ export class AsyncFile extends PreloadFile {
  * An "Asynchronous key-value file system". Stores data to/retrieves data from
  * an underlying asynchronous key-value store.
  */
-export class AsyncStoreFileSystem extends Async(FileSystem) {
+export class AsyncStoreFS extends Async(FileSystem) {
     ready() {
         return this._ready;
     }
-    // @ts-expect-error 2611
-    get metadata() {
+    metadata() {
         return {
-            ...super.metadata,
+            ...super.metadata(),
             name: this.store.name,
         };
     }

package/dist/backends/InMemory.js

@@ -1,4 +1,4 @@
-import { SimpleSyncRWTransaction, SyncStoreFileSystem } from './SyncStore.js';
+import { SimpleSyncRWTransaction, SyncStoreFS } from './SyncStore.js';
 /**
  * A simple in-memory store
  */
@@ -43,6 +43,6 @@ export const InMemory = {
         },
     },
     create({ name }) {
-        return new SyncStoreFileSystem({ store: new InMemoryStore(name) });
+        return new SyncStoreFS({ store: new InMemoryStore(name) });
     },
 };

package/dist/backends/Locked.d.ts

@@ -17,7 +17,7 @@ export declare class LockedFS<T extends FileSystem> implements FileSystem {
     private _mu;
     constructor(fs: T);
     ready(): Promise<this>;
-    get metadata(): FileSystemMetadata;
+    metadata(): FileSystemMetadata;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
     stat(p: string, cred: Cred): Promise<Stats>;

package/dist/backends/Locked.js

@@ -17,10 +17,10 @@ export class LockedFS {
         await this.fs.ready();
         return this;
     }
-    get metadata() {
+    metadata() {
         return {
-            ...this.fs.metadata,
-            name: 'Locked<' + this.fs.metadata.name + '>',
+            ...this.fs.metadata(),
+            name: 'Locked<' + this.fs.metadata().name + '>',
         };
     }
     async rename(oldPath, newPath, cred) {

package/dist/backends/Overlay.d.ts

@@ -37,7 +37,7 @@ export declare class UnlockedOverlayFS extends FileSystem {
     private _deleteLogError?;
     private _ready;
     constructor({ writable, readable }: OverlayOptions);
-    get metadata(): FileSystemMetadata;
+    metadata(): FileSystemMetadata;
     getOverlayedFileSystems(): OverlayOptions;
     sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
     syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;

package/dist/backends/Overlay.js

@@ -64,17 +64,17 @@ export class UnlockedOverlayFS extends FileSystem {
         this._deleteLogUpdateNeeded = false;
         this._writable = writable;
         this._readable = readable;
-        if (this._writable.metadata.readonly) {
+        if (this._writable.metadata().readonly) {
             throw new ApiError(ErrorCode.EINVAL, 'Writable file system must be writable.');
         }
         this._ready = this._initialize();
     }
-    get metadata() {
+    metadata() {
         return {
-            ...super.metadata,
+            ...super.metadata(),
             name: OverlayFS.name,
-            synchronous: this._readable.metadata.synchronous && this._writable.metadata.synchronous,
-            supportsProperties: this._readable.metadata.supportsProperties && this._writable.metadata.supportsProperties,
+            synchronous: this._readable.metadata().synchronous && this._writable.metadata().synchronous,
+            supportsProperties: this._readable.metadata().supportsProperties && this._writable.metadata().supportsProperties,
         };
     }
     getOverlayedFileSystems() {

package/dist/backends/SyncStore.d.ts

@@ -106,21 +106,21 @@ export declare class SimpleSyncRWTransaction implements SyncRWTransaction {
      */
     protected markModified(ino: Ino): void;
 }
-export interface SyncStoreFileSystemOptions {
+export interface SyncStoreOptions {
     /**
      * The actual key-value store to read from/write to.
      */
     store: SyncStore;
 }
-export declare class SyncStoreFile extends PreloadFile<SyncStoreFileSystem> {
-    constructor(_fs: SyncStoreFileSystem, _path: string, _flag: FileFlag, _stat: Stats, contents?: Uint8Array);
+export declare class SyncStoreFile extends PreloadFile<SyncStoreFS> {
+    constructor(_fs: SyncStoreFS, _path: string, _flag: FileFlag, _stat: Stats, contents?: Uint8Array);
     sync(): Promise<void>;
     syncSync(): void;
     close(): Promise<void>;
     closeSync(): void;
 }
-declare const SyncStoreFileSystem_base: (abstract new (...args: any[]) => {
-    readonly metadata: FileSystemMetadata;
+declare const SyncStoreFS_base: (abstract new (...args: any[]) => {
+    metadata(): FileSystemMetadata;
     ready(): Promise<any>;
     exists(path: string, cred: Cred): Promise<boolean>;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
@@ -154,10 +154,10 @@ declare const SyncStoreFileSystem_base: (abstract new (...args: any[]) => {
  * @todo Introduce Node ID caching.
  * @todo Check modes.
  */
-export declare class SyncStoreFileSystem extends SyncStoreFileSystem_base {
+export declare class SyncStoreFS extends SyncStoreFS_base {
     protected store: SyncStore;
-    constructor(options: SyncStoreFileSystemOptions);
-    get metadata(): FileSystemMetadata;
+    constructor(options: SyncStoreOptions);
+    metadata(): FileSystemMetadata;
     /**
      * Delete all contents stored in the file system.
      */

package/dist/backends/SyncStore.js

@@ -105,17 +105,16 @@ export class SyncStoreFile extends PreloadFile {
  * @todo Introduce Node ID caching.
  * @todo Check modes.
  */
-export class SyncStoreFileSystem extends Sync(FileSystem) {
+export class SyncStoreFS extends Sync(FileSystem) {
     constructor(options) {
         super();
         this.store = options.store;
         // INVARIANT: Ensure that the root exists.
         this.makeRootDirectory();
     }
-    // @ts-expect-error 2611
-    get metadata() {
+    metadata() {
         return {
-            ...super.metadata,
+            ...super.metadata(),
             name: this.store.name,
         };
     }