@zenfs/core 0.17.0 → 0.18.0

package/dist/config.js

@@ -1,6 +1,6 @@
 import { checkOptions, isBackend, isBackendConfig } from './backends/backend.js';
+import { credentials } from './credentials.js';
 import * as fs from './emulation/index.js';
-import { setCred } from './emulation/shared.js';
 import { Errno, ErrnoError } from './error.js';
 import { FileSystem } from './filesystem.js';
 function isMountConfig(arg) {
@@ -63,7 +63,7 @@ export async function configureSingle(config) {
 export async function configure(config) {
     const uid = 'uid' in config ? config.uid || 0 : 0;
     const gid = 'gid' in config ? config.gid || 0 : 0;
-    setCred({ uid, gid, suid: uid, sgid: gid, euid: uid, egid: gid });
+    Object.assign(credentials, { uid, gid, suid: uid, sgid: gid, euid: uid, egid: gid });
     if (!config.mounts) {
         return;
     }

package/dist/{cred.d.ts → credentials.d.ts}

@@ -3,7 +3,7 @@
  * Similar to Linux's cred struct.
  * @see https://github.com/torvalds/linux/blob/master/include/linux/cred.h
  */
-export interface Cred {
+export interface Credentials {
     uid: number;
     gid: number;
     suid: number;
@@ -11,4 +11,5 @@ export interface Cred {
     euid: number;
     egid: number;
 }
-export declare const rootCred: Cred;
+export declare const credentials: Credentials;
+export declare const rootCredentials: Credentials;

package/dist/credentials.js

@@ -0,0 +1,16 @@
+export const credentials = {
+    uid: 0,
+    gid: 0,
+    suid: 0,
+    sgid: 0,
+    euid: 0,
+    egid: 0,
+};
+export const rootCredentials = {
+    uid: 0,
+    gid: 0,
+    suid: 0,
+    sgid: 0,
+    euid: 0,
+    egid: 0,
+};

package/dist/emulation/async.d.ts

@@ -7,9 +7,10 @@ import type { FileContents } from '../filesystem.js';
 import { BigIntStats, type Stats } from '../stats.js';
 import { type Callback } from '../utils.js';
 import type { Dirent } from './dir.js';
-import { type Dir } from './dir.js';
+import type { Dir } from './dir.js';
 import * as promises from './promises.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.
@@ -358,7 +359,15 @@ export declare function realpath(path: fs.PathLike, options: fs.EncodingOption,
 export declare function access(path: fs.PathLike, cb: Callback): void;
 export declare function access(path: fs.PathLike, mode: number, cb: Callback): void;
 /**
- * @todo Implement
+ * Watch for changes on a file. The callback listener will be called each time the file is accessed.
+ *
+ * The `options` argument may be omitted. If provided, it should be an object with a `persistent` boolean and an `interval` number specifying the polling interval in milliseconds.
+ *
+ * When a change is detected, the `listener` callback is called with the current and previous `Stats` objects.
+ *
+ * @param path The path to the file to watch.
+ * @param options Optional options object specifying `persistent` and `interval`.
+ * @param listener The callback listener to be called when the file changes.
  */
 export declare function watchFile(path: fs.PathLike, listener: (curr: Stats, prev: Stats) => void): void;
 export declare function watchFile(path: fs.PathLike, options: {
@@ -366,13 +375,19 @@ export declare function watchFile(path: fs.PathLike, options: {
     interval?: number;
 }, listener: (curr: Stats, prev: Stats) => void): void;
 /**
- * @todo Implement
+ * Stop watching for changes on a file.
+ *
+ * If the `listener` is specified, only that particular listener is removed.
+ * If no `listener` is specified, all listeners are removed, and the file is no longer watched.
+ *
+ * @param path The path to the file to stop watching.
+ * @param listener Optional listener to remove.
  */
 export declare function unwatchFile(path: fs.PathLike, listener?: (curr: Stats, prev: Stats) => void): void;
-export declare function watch(path: fs.PathLike, listener?: (event: string, filename: string) => any): fs.FSWatcher;
+export declare function watch(path: fs.PathLike, listener?: (event: string, filename: string) => any): FSWatcher;
 export declare function watch(path: fs.PathLike, options: {
     persistent?: boolean;
-}, listener?: (event: string, filename: string) => any): fs.FSWatcher;
+}, listener?: (event: string, filename: string) => any): FSWatcher;
 interface StreamOptions {
     flags?: string;
     encoding?: BufferEncoding;

package/dist/emulation/async.js

@@ -1,12 +1,13 @@
 import { Buffer } from 'buffer';
-import { ErrnoError, Errno } from '../error.js';
+import { Errno, ErrnoError } from '../error.js';
 import { BigIntStats } from '../stats.js';
-import { nop, normalizeMode } from '../utils.js';
+import { normalizeMode, normalizePath } from '../utils.js';
 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';
+import { FSWatcher, StatWatcher } from './watchers.js';
+const nop = () => { };
 /**
  * Asynchronous rename. No arguments other than a possible exception are given
  * to the completion callback.
@@ -432,19 +433,66 @@ export function access(path, cbMode, cb = nop) {
         .catch(cb);
 }
 access;
-export function watchFile(path, optsListener, listener = nop) {
-    throw ErrnoError.With('ENOSYS', path.toString(), 'watchFile');
+const statWatchers = new Map();
+export function watchFile(path, optsListener, listener) {
+    const normalizedPath = normalizePath(path.toString());
+    const options = typeof optsListener != 'function' ? optsListener : {};
+    if (typeof optsListener === 'function') {
+        listener = optsListener;
+    }
+    if (!listener) {
+        throw new ErrnoError(Errno.EINVAL, 'No listener specified', path.toString(), 'watchFile');
+    }
+    if (statWatchers.has(normalizedPath)) {
+        const entry = statWatchers.get(normalizedPath);
+        if (entry) {
+            entry.listeners.add(listener);
+        }
+        return;
+    }
+    const watcher = new StatWatcher(normalizedPath, options);
+    watcher.on('change', (curr, prev) => {
+        const entry = statWatchers.get(normalizedPath);
+        if (!entry) {
+            return;
+        }
+        for (const listener of entry.listeners) {
+            listener(curr, prev);
+        }
+    });
+    statWatchers.set(normalizedPath, { watcher, listeners: new Set() });
 }
 watchFile;
 /**
- * @todo Implement
+ * Stop watching for changes on a file.
+ *
+ * If the `listener` is specified, only that particular listener is removed.
+ * If no `listener` is specified, all listeners are removed, and the file is no longer watched.
+ *
+ * @param path The path to the file to stop watching.
+ * @param listener Optional listener to remove.
  */
 export function unwatchFile(path, listener = nop) {
-    throw ErrnoError.With('ENOSYS', path.toString(), 'unwatchFile');
+    const normalizedPath = normalizePath(path.toString());
+    const entry = statWatchers.get(normalizedPath);
+    if (entry) {
+        if (listener && listener !== nop) {
+            entry.listeners.delete(listener);
+        }
+        else {
+            // If no listener is specified, remove all listeners
+            entry.listeners.clear();
+        }
+        if (entry.listeners.size === 0) {
+            // No more listeners, stop the watcher
+            entry.watcher.stop();
+            statWatchers.delete(normalizedPath);
+        }
+    }
 }
 unwatchFile;
 export function watch(path, options, listener) {
-    const watcher = new FSWatcher(typeof options == 'object' ? options : {});
+    const watcher = new FSWatcher(normalizePath(path), typeof options == 'object' ? options : {});
     listener = typeof options == 'function' ? options : listener;
     watcher.on('change', listener || nop);
     return watcher;
@@ -482,7 +530,7 @@ export function createReadStream(path, _options) {
             handle
                 ?.close()
                 .then(() => callback(error))
-                .catch(callback);
+                .catch(nop);
         },
     });
     stream.path = path.toString();

package/dist/emulation/dir.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" resolution-mode="require"/>
-import type { Dirent as _Dirent, Dir as _Dir } from 'fs';
-import type { Callback } from '../utils.js';
+import type { Dir as _Dir, Dirent as _Dirent } from 'fs';
 import type { Stats } from '../stats.js';
+import type { Callback } from '../utils.js';
 export declare class Dirent implements _Dirent {
     path: string;
     protected stats: Stats;
@@ -23,11 +23,7 @@ export declare class Dir implements _Dir {
     readonly path: string;
     protected closed: boolean;
     protected checkClosed(): void;
-    protected _entries: Dirent[];
-    /**
-     * @internal
-     */
-    _loadEntries(): Promise<void>;
+    protected _entries?: Dirent[];
     constructor(path: string);
     /**
      * Asynchronously close the directory's underlying resource handle.
@@ -54,6 +50,7 @@ export declare class Dir implements _Dir {
      * Directory entries returned by this function are in no particular order as provided by the operating system's underlying directory mechanisms.
      */
     readSync(): Dirent | null;
+    next(): Promise<IteratorResult<Dirent>>;
     /**
      * Asynchronously iterates over the directory via `readdir(3)` until all entries have been read.
      */

package/dist/emulation/dir.js

@@ -1,7 +1,7 @@
+import { Errno, ErrnoError } from '../error.js';
+import { basename } from './path.js';
 import { readdir } from './promises.js';
-import { ErrnoError, Errno } from '../error.js';
 import { readdirSync } from './sync.js';
-import { basename } from './path.js';
 export class Dirent {
     get name() {
         return basename(this.path);
@@ -44,16 +44,9 @@ 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;
-        this._entries = [];
     }
     close(cb) {
         this.closed = true;
@@ -70,11 +63,12 @@ export class Dir {
         this.closed = true;
     }
     async _read() {
-        await this._loadEntries();
+        this.checkClosed();
+        this._entries ?? (this._entries = await readdir(this.path, { withFileTypes: true }));
         if (!this._entries.length) {
             return null;
         }
-        return this._entries.shift() || null;
+        return this._entries.shift() ?? null;
     }
     read(cb) {
         if (!cb) {
@@ -88,27 +82,25 @@ 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() {
+        this.checkClosed();
         this._entries ?? (this._entries = readdirSync(this.path, { withFileTypes: true }));
         if (!this._entries.length) {
             return null;
         }
-        return this._entries.shift() || null;
+        return this._entries.shift() ?? null;
+    }
+    async next() {
+        const value = await this._read();
+        if (value) {
+            return { done: false, value };
+        }
+        await this.close();
+        return { done: true, value: undefined };
     }
     /**
      * Asynchronously iterates over the directory via `readdir(3)` until all entries have been read.
      */
     [Symbol.asyncIterator]() {
-        const _this = this;
-        return {
-            [Symbol.asyncIterator]: this[Symbol.asyncIterator],
-            async next() {
-                const value = await _this._read();
-                if (value != null) {
-                    return { done: false, value };
-                }
-                await _this.close();
-                return { done: true, value: undefined };
-            },
-        };
+        return this;
     }
 }

package/dist/emulation/promises.d.ts

@@ -314,10 +314,10 @@ export declare function readdir(path: fs.PathLike, options: fs.ObjectEncodingOpt
 }): Promise<Dirent[]>;
 /**
  * `link`.
- * @param existing
- * @param newpath
+ * @param targetPath
+ * @param linkPath
  */
-export declare function link(existing: fs.PathLike, newpath: fs.PathLike): Promise<void>;
+export declare function link(targetPath: fs.PathLike, linkPath: fs.PathLike): Promise<void>;
 /**
  * `symlink`.
  * @param target target path