@zenfs/core 0.16.4 → 0.17.0

package/dist/config.d.ts

@@ -9,9 +9,9 @@ export type MountConfiguration<T extends Backend> = FilesystemOf<T> | BackendCon
  * @see MountConfiguration
  */
 export declare function resolveMountConfig<T extends Backend>(config: MountConfiguration<T>, _depth?: number): Promise<FilesystemOf<T>>;
-export type ConfigMounts = {
-    [K in AbsolutePath]: Backend;
-};
+export interface ConfigMounts {
+    [K: AbsolutePath]: Backend;
+}
 /**
  * Configuration
  */

package/dist/emulation/async.d.ts

@@ -369,9 +369,6 @@ export declare function watchFile(path: fs.PathLike, options: {
  * @todo Implement
  */
 export declare function unwatchFile(path: fs.PathLike, listener?: (curr: Stats, prev: Stats) => void): void;
-/**
- * @todo Implement
- */
 export declare function watch(path: fs.PathLike, listener?: (event: string, filename: string) => any): fs.FSWatcher;
 export declare function watch(path: fs.PathLike, options: {
     persistent?: boolean;

package/dist/emulation/async.js

@@ -6,6 +6,7 @@ import { R_OK } from './constants.js';
 import * as promises from './promises.js';
 import { fd2file } from './shared.js';
 import { ReadStream, WriteStream } from './streams.js';
+import { FSWatcher } from './watchers.js';
 /**
  * Asynchronous rename. No arguments other than a possible exception are given
  * to the completion callback.
@@ -442,8 +443,11 @@ export function unwatchFile(path, listener = nop) {
     throw ErrnoError.With('ENOSYS', path.toString(), 'unwatchFile');
 }
 unwatchFile;
-export function watch(path, options, listener = nop) {
-    throw ErrnoError.With('ENOSYS', path.toString(), 'watch');
+export function watch(path, options, listener) {
+    const watcher = new FSWatcher(typeof options == 'object' ? options : {});
+    listener = typeof options == 'function' ? options : listener;
+    watcher.on('change', listener || nop);
+    return watcher;
 }
 watch;
 /**

package/dist/emulation/dir.d.ts

@@ -24,6 +24,10 @@ export declare class Dir implements _Dir {
     protected closed: boolean;
     protected checkClosed(): void;
     protected _entries: Dirent[];
+    /**
+     * @internal
+     */
+    _loadEntries(): Promise<void>;
     constructor(path: string);
     /**
      * Asynchronously close the directory's underlying resource handle.

package/dist/emulation/dir.js

@@ -44,6 +44,12 @@ export class Dir {
             throw new ErrnoError(Errno.EBADF, 'Can not use closed Dir');
         }
     }
+    /**
+     * @internal
+     */
+    async _loadEntries() {
+        this._entries ?? (this._entries = await readdir(this.path, { withFileTypes: true }));
+    }
     constructor(path) {
         this.path = path;
         this.closed = false;
@@ -64,9 +70,7 @@ export class Dir {
         this.closed = true;
     }
     async _read() {
-        if (!this._entries) {
-            this._entries = await readdir(this.path, { withFileTypes: true });
-        }
+        await this._loadEntries();
         if (!this._entries.length) {
             return null;
         }
@@ -84,9 +88,7 @@ export class Dir {
      * Directory entries returned by this function are in no particular order as provided by the operating system's underlying directory mechanisms.
      */
     readSync() {
-        if (!this._entries) {
-            this._entries = readdirSync(this.path, { withFileTypes: true });
-        }
+        this._entries ?? (this._entries = readdirSync(this.path, { withFileTypes: true }));
         if (!this._entries.length) {
             return null;
         }

package/dist/emulation/promises.d.ts

@@ -379,9 +379,6 @@ export declare function lutimes(path: fs.PathLike, atime: fs.TimeLike, mtime: fs
  */
 export declare function realpath(path: fs.PathLike, options: fs.BufferEncodingOption): Promise<Buffer>;
 export declare function realpath(path: fs.PathLike, options?: fs.EncodingOption | BufferEncoding): Promise<string>;
-/**
- * @todo Implement
- */
 export declare function watch(filename: fs.PathLike, options?: fs.WatchOptions | BufferEncoding): AsyncIterable<FileChangeInfo<string>>;
 export declare function watch(filename: fs.PathLike, options: fs.WatchOptions | fs.BufferEncodingOption): AsyncIterable<FileChangeInfo<Buffer>>;
 export declare function watch(filename: fs.PathLike, options?: fs.WatchOptions | string): AsyncIterable<FileChangeInfo<string>> | AsyncIterable<FileChangeInfo<Buffer>>;
@@ -417,6 +414,7 @@ export declare function copyFile(src: fs.PathLike, dest: fs.PathLike, mode?: num
  * @param path The path to the directory.
  * @param options Options for opening the directory.
  * @returns A `Dir` object representing the opened directory.
+ * @todo Use options
  */
 export declare function opendir(path: fs.PathLike, options?: fs.OpenDirOptions): Promise<Dir>;
 /**

package/dist/emulation/promises.js

@@ -43,6 +43,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
+/* eslint-disable @typescript-eslint/no-redundant-type-constituents */
 import { Buffer } from 'buffer';
 import { Errno, ErrnoError } from '../error.js';
 import { isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
@@ -54,6 +55,7 @@ import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
 import { _statfs, cred, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
 import { ReadStream, WriteStream } from './streams.js';
+import { FSWatcher } from './watchers.js';
 export * as constants from './constants.js';
 export class FileHandle {
     constructor(fdOrFile) {
@@ -850,7 +852,25 @@ export async function realpath(path, options) {
 }
 realpath;
 export function watch(filename, options = {}) {
-    throw ErrnoError.With('ENOSYS', filename.toString(), 'watch');
+    return {
+        [Symbol.asyncIterator]() {
+            const watcher = new FSWatcher(typeof options != 'string' ? options : { encoding: options });
+            function withDone(done) {
+                return function () {
+                    const event = Promise.withResolvers();
+                    watcher.on('change', (eventType, filename) => {
+                        event.resolve({ value: { eventType, filename }, done });
+                    });
+                    return event.promise;
+                };
+            }
+            return {
+                next: withDone(false),
+                return: withDone(true),
+                throw: withDone(true),
+            };
+        },
+    };
 }
 watch;
 /**
@@ -923,10 +943,13 @@ copyFile;
  * @param path The path to the directory.
  * @param options Options for opening the directory.
  * @returns A `Dir` object representing the opened directory.
+ * @todo Use options
  */
 export async function opendir(path, options) {
     path = normalizePath(path);
-    return new Dir(path);
+    const dir = new Dir(path);
+    await dir._loadEntries();
+    return dir;
 }
 opendir;
 /**

package/dist/emulation/sync.js

@@ -223,7 +223,6 @@ function _readFileSync(fname, flag, resolveSymlinks) {
         // Allocate buffer.
         const data = new Uint8Array(stat.size);
         file.readSync(data, 0, stat.size, 0);
-        file.closeSync();
         return data;
     }
     catch (e_2) {

package/dist/emulation/watchers.d.ts

@@ -5,8 +5,8 @@ import { EventEmitter } from 'eventemitter3';
 import type { EventEmitter as NodeEventEmitter } from 'node:events';
 import type * as fs from 'node:fs';
 declare class Watcher<TEvents extends Record<string, unknown[]> = Record<string, unknown[]>> extends EventEmitter<TEvents> implements NodeEventEmitter {
-    off<T extends EventEmitter.EventNames<TEvents>>(event: T, fn?: ((...args: any[]) => void) | undefined, context?: any, once?: boolean | undefined): this;
-    removeListener<T extends EventEmitter.EventNames<TEvents>>(event: T, fn?: ((...args: any[]) => void) | undefined, context?: any, once?: boolean | undefined): this;
+    off<T extends EventEmitter.EventNames<TEvents>>(event: T, fn?: (...args: any[]) => void, context?: any, once?: boolean): this;
+    removeListener<T extends EventEmitter.EventNames<TEvents>>(event: T, fn?: (...args: any[]) => void, context?: any, once?: boolean): this;
     setMaxListeners(): never;
     getMaxListeners(): never;
     prependListener(): never;
@@ -15,11 +15,16 @@ declare class Watcher<TEvents extends Record<string, unknown[]> = Record<string,
     ref(): this;
     unref(): this;
 }
-export declare class FSWatcher extends Watcher<{
-    change: [eventType: string, filename: string | Buffer];
+/**
+ * @todo Actually emit events
+ */
+export declare class FSWatcher<T extends string | Buffer = string | Buffer> extends Watcher<{
+    change: [eventType: fs.WatchEventType, filename: T];
     close: [];
     error: [error: Error];
 }> implements fs.FSWatcher {
+    readonly options: fs.WatchOptions;
+    constructor(options: fs.WatchOptions);
     close(): void;
 }
 export declare class StatWatcher extends Watcher implements fs.StatWatcher {

package/dist/emulation/watchers.js

@@ -31,7 +31,14 @@ class Watcher extends EventEmitter {
         return this;
     }
 }
+/**
+ * @todo Actually emit events
+ */
 export class FSWatcher extends Watcher {
+    constructor(options) {
+        super();
+        this.options = options;
+    }
     close() { }
 }
 export class StatWatcher extends Watcher {

package/dist/file.d.ts

@@ -179,7 +179,6 @@ export declare abstract class File {
  * An implementation of the File interface that operates on a file that is
  * completely in-memory. PreloadFiles are backed by a Uint8Array.
  *
- * @todo 'close' lever that disables functionality once closed.
  */
 export declare class PreloadFile<FS extends FileSystem> extends File {
     /**
@@ -193,8 +192,18 @@ export declare class PreloadFile<FS extends FileSystem> extends File {
     readonly flag: string;
     readonly stats: Stats;
     protected _buffer: Uint8Array;
+    /**
+     * Current position
+     */
     protected _position: number;
+    /**
+     * Whether the file has changes which have not been written to the FS
+     */
     protected dirty: boolean;
+    /**
+     * Whether the file is open or closed
+     */
+    protected closed: boolean;
     /**
      * Creates a file with the given path and, optionally, the given contents. Note
      * that, if contents is specified, it will be mutated by the file!
@@ -239,6 +248,11 @@ export declare class PreloadFile<FS extends FileSystem> extends File {
     syncSync(): void;
     close(): Promise<void>;
     closeSync(): void;
+    /**
+     * Cleans up
+     * This will *not* sync the file data to the FS
+     */
+    protected dispose(force?: boolean): void;
     /**
      * Asynchronous `stat`.
      */
@@ -340,6 +354,8 @@ export declare class PreloadFile<FS extends FileSystem> extends File {
     utimesSync(atime: Date, mtime: Date): void;
     _setType(type: FileType): Promise<void>;
     _setTypeSync(type: FileType): void;
+    [Symbol.asyncDispose](): Promise<void>;
+    [Symbol.dispose](): void;
 }
 /**
  * For the filesystems which do not sync to anything..

package/dist/file.js

@@ -132,7 +132,6 @@ export class File {
  * An implementation of the File interface that operates on a file that is
  * completely in-memory. PreloadFiles are backed by a Uint8Array.
  *
- * @todo 'close' lever that disables functionality once closed.
  */
 export class PreloadFile extends File {
     /**
@@ -162,8 +161,18 @@ export class PreloadFile extends File {
         this.flag = flag;
         this.stats = stats;
         this._buffer = _buffer;
+        /**
+         * Current position
+         */
         this._position = 0;
+        /**
+         * Whether the file has changes which have not been written to the FS
+         */
         this.dirty = false;
+        /**
+         * Whether the file is open or closed
+         */
+        this.closed = false;
         /*
             Note:
             This invariant is *not* maintained once the file starts getting modified.
@@ -206,6 +215,9 @@ export class PreloadFile extends File {
         this._position = newPos;
     }
     async sync() {
+        if (this.closed) {
+            throw ErrnoError.With('EBADF', this.path, 'File.sync');
+        }
         if (!this.dirty) {
             return;
         }
@@ -213,6 +225,9 @@ export class PreloadFile extends File {
         this.dirty = false;
     }
     syncSync() {
+        if (this.closed) {
+            throw ErrnoError.With('EBADF', this.path, 'File.sync');
+        }
         if (!this.dirty) {
             return;
         }
@@ -220,24 +235,58 @@ export class PreloadFile extends File {
         this.dirty = false;
     }
     async close() {
+        if (this.closed) {
+            throw ErrnoError.With('EBADF', this.path, 'File.close');
+        }
         await this.sync();
+        this.dispose();
     }
     closeSync() {
+        if (this.closed) {
+            throw ErrnoError.With('EBADF', this.path, 'File.close');
+        }
         this.syncSync();
+        this.dispose();
+    }
+    /**
+     * Cleans up
+     * This will *not* sync the file data to the FS
+     */
+    dispose(force) {
+        if (this.closed) {
+            throw ErrnoError.With('EBADF', this.path, 'File.dispose');
+        }
+        if (this.dirty && !force) {
+            throw ErrnoError.With('EBUSY', this.path, 'File.dispose');
+        }
+        // @ts-expect-error 2790
+        delete this._buffer;
+        // @ts-expect-error 2790
+        delete this.stats;
+        this.closed = true;
     }
     /**
      * Asynchronous `stat`.
      */
     stat() {
+        if (this.closed) {
+            throw ErrnoError.With('EBADF', this.path, 'File.stat');
+        }
         return Promise.resolve(new Stats(this.stats));
     }
     /**
      * Synchronous `stat`.
      */
     statSync() {
+        if (this.closed) {
+            throw ErrnoError.With('EBADF', this.path, 'File.stat');
+        }
         return new Stats(this.stats);
     }
     _truncate(length) {
+        if (this.closed) {
+            throw ErrnoError.With('EBADF', this.path, 'File.truncate');
+        }
         this.dirty = true;
         if (!isWriteable(this.flag)) {
             throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
@@ -270,6 +319,9 @@ export class PreloadFile extends File {
         this.syncSync();
     }
     _write(buffer, offset = 0, length = this.stats.size, position = this.position) {
+        if (this.closed) {
+            throw ErrnoError.With('EBADF', this.path, 'File.write');
+        }
         this.dirty = true;
         if (!isWriteable(this.flag)) {
             throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
@@ -331,6 +383,9 @@ export class PreloadFile extends File {
         return bytesWritten;
     }
     _read(buffer, offset = 0, length = this.stats.size, position) {
+        if (this.closed) {
+            throw ErrnoError.With('EBADF', this.path, 'File.read');
+        }
         if (!isReadable(this.flag)) {
             throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode.');
         }
@@ -387,6 +442,9 @@ export class PreloadFile extends File {
      * @param mode the mode
      */
     async chmod(mode) {
+        if (this.closed) {
+            throw ErrnoError.With('EBADF', this.path, 'File.chmod');
+        }
         this.dirty = true;
         this.stats.chmod(mode);
         await this.sync();
@@ -396,6 +454,9 @@ export class PreloadFile extends File {
      * @param mode
      */
     chmodSync(mode) {
+        if (this.closed) {
+            throw ErrnoError.With('EBADF', this.path, 'File.chmod');
+        }
         this.dirty = true;
         this.stats.chmod(mode);
         this.syncSync();
@@ -406,6 +467,9 @@ export class PreloadFile extends File {
      * @param gid
      */
     async chown(uid, gid) {
+        if (this.closed) {
+            throw ErrnoError.With('EBADF', this.path, 'File.chown');
+        }
         this.dirty = true;
         this.stats.chown(uid, gid);
         await this.sync();
@@ -416,32 +480,53 @@ export class PreloadFile extends File {
      * @param gid
      */
     chownSync(uid, gid) {
+        if (this.closed) {
+            throw ErrnoError.With('EBADF', this.path, 'File.chown');
+        }
         this.dirty = true;
         this.stats.chown(uid, gid);
         this.syncSync();
     }
     async utimes(atime, mtime) {
+        if (this.closed) {
+            throw ErrnoError.With('EBADF', this.path, 'File.utimes');
+        }
         this.dirty = true;
         this.stats.atime = atime;
         this.stats.mtime = mtime;
         await this.sync();
     }
     utimesSync(atime, mtime) {
+        if (this.closed) {
+            throw ErrnoError.With('EBADF', this.path, 'File.utimes');
+        }
         this.dirty = true;
         this.stats.atime = atime;
         this.stats.mtime = mtime;
         this.syncSync();
     }
     async _setType(type) {
+        if (this.closed) {
+            throw ErrnoError.With('EBADF', this.path, 'File._setType');
+        }
         this.dirty = true;
         this.stats.mode = (this.stats.mode & ~S_IFMT) | type;
         await this.sync();
     }
     _setTypeSync(type) {
+        if (this.closed) {
+            throw ErrnoError.With('EBADF', this.path, 'File._setType');
+        }
         this.dirty = true;
         this.stats.mode = (this.stats.mode & ~S_IFMT) | type;
         this.syncSync();
     }
+    async [Symbol.asyncDispose]() {
+        await this.close();
+    }
+    [Symbol.dispose]() {
+        this.closeSync();
+    }
 }
 /**
  * For the filesystems which do not sync to anything..

package/dist/filesystem.d.ts

@@ -1,4 +1,3 @@
-import type { ExtractProperties } from 'utilium';
 import { type Cred } from './cred.js';
 import { type File } from './file.js';
 import { type Stats } from './stats.js';
@@ -169,65 +168,3 @@ export declare abstract class FileSystem {
      */
     abstract syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
 }
-/**
- * `TBase` with `TMixin` mixed-in.
- * @internal @experimental
- */
-export type Mixin<TBase extends typeof FileSystem, TMixin> = (abstract new (...args: any[]) => TMixin) & TBase;
-/**
- * Asynchronous `FileSystem` methods. This is a convience type.
- * @internal
- */
-export type _AsyncFSMethods = ExtractProperties<FileSystem, (...args: any[]) => Promise<unknown>>;
-/**
- * Implements the asynchronous API in terms of the synchronous API.
- */
-export declare function Sync<T extends typeof FileSystem>(FS: T): Mixin<T, _AsyncFSMethods>;
-/**
- * Async() implements synchronous methods on an asynchronous file system
- *
- * Implementing classes must define `_sync` for the synchronous file system used as a cache.
- * Synchronous methods on an asynchronous FS are implemented by:
- *	- Performing operations over the in-memory copy,
- * 	while asynchronously pipelining them to the backing store.
- * 	- During loading, the contents of the async file system are preloaded into the synchronous store.
- *
- */
-export declare function Async<T extends typeof FileSystem>(FS: T): Mixin<T, {
-    /**
-     * @internal @protected
-     */
-    _sync?: FileSystem;
-    queueDone(): Promise<void>;
-    ready(): Promise<void>;
-    renameSync(oldPath: string, newPath: string, cred: Cred): void;
-    statSync(path: string, cred: Cred): Stats;
-    createFileSync(path: string, flag: string, mode: number, cred: Cred): File;
-    openFileSync(path: string, flag: string, cred: Cred): File;
-    unlinkSync(path: string, cred: Cred): void;
-    rmdirSync(path: string, cred: Cred): void;
-    mkdirSync(path: string, mode: number, cred: Cred): void;
-    readdirSync(path: string, cred: Cred): string[];
-    linkSync(srcpath: string, dstpath: string, cred: Cred): void;
-    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
-}>;
-/**
- * Implements the non-readonly methods to throw `EROFS`
- */
-export declare function Readonly<T extends typeof FileSystem>(FS: T): Mixin<T, {
-    metadata(): FileSystemMetadata;
-    rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
-    renameSync(oldPath: string, newPath: string, cred: Cred): void;
-    createFile(path: string, flag: string, mode: number, cred: Cred): Promise<File>;
-    createFileSync(path: string, flag: string, mode: number, cred: Cred): File;
-    unlink(path: string, cred: Cred): Promise<void>;
-    unlinkSync(path: string, cred: Cred): void;
-    rmdir(path: string, cred: Cred): Promise<void>;
-    rmdirSync(path: string, cred: Cred): void;
-    mkdir(path: string, mode: number, cred: Cred): Promise<void>;
-    mkdirSync(path: string, mode: number, cred: Cred): void;
-    link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
-    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;
-}>;