@zenfs/core 0.0.12 → 0.2.0

package/dist/emulation/callbacks.js

@@ -1,5 +1,6 @@
 import { ApiError, ErrorCode } from '../ApiError.js';
-import { nop, normalizeMode } from './shared.js';
+import { BigIntStats } from '../stats.js';
+import { fd2file, nop, normalizeMode } from './shared.js';
 import * as promises from './promises.js';
 import { R_OK } from './constants.js';
 import { decode, encode } from '../utils.js';
@@ -16,13 +17,10 @@ export function rename(oldPath, newPath, cb = nop) {
         .then(() => cb())
         .catch(cb);
 }
+rename;
 /**
  * Test whether or not the given path exists by checking with the file system.
  * Then call the callback argument with either true or false.
- * @example Sample invocation
- *   fs.exists('/etc/passwd', function (exists) {
- *     util.debug(exists ? "it's there" : "no passwd!");
- *   });
  * @param path
  * @param callback
  */
@@ -32,30 +30,23 @@ export function exists(path, cb = nop) {
         .then(cb)
         .catch(() => cb(false));
 }
-/**
- * Asynchronous `stat`.
- * @param path
- * @param callback
- */
-export function stat(path, cb = nop) {
+exists;
+export function stat(path, options, callback = nop) {
+    callback = typeof options == 'function' ? options : callback;
     promises
-        .stat(path)
-        .then(stats => cb(null, stats))
-        .catch(cb);
+        .stat(path, typeof options != 'function' ? options : {})
+        .then(stats => callback(null, stats))
+        .catch(callback);
 }
-/**
- * Asynchronous `lstat`.
- * `lstat()` is identical to `stat()`, except that if path is a symbolic link,
- * then the link itself is stat-ed, not the file that it refers to.
- * @param path
- * @param callback
- */
-export function lstat(path, cb = nop) {
+stat;
+export function lstat(path, options, callback = nop) {
+    callback = typeof options == 'function' ? options : callback;
     promises
-        .lstat(path)
-        .then(stats => cb(null, stats))
-        .catch(cb);
+        .lstat(path, typeof options != 'function' ? options : {})
+        .then(stats => callback(null, stats))
+        .catch(callback);
 }
+lstat;
 export function truncate(path, arg2 = 0, cb = nop) {
     cb = typeof arg2 === 'function' ? arg2 : cb;
     const len = typeof arg2 === 'number' ? arg2 : 0;
@@ -64,6 +55,7 @@ export function truncate(path, arg2 = 0, cb = nop) {
         .then(() => cb())
         .catch(cb);
 }
+truncate;
 /**
  * Asynchronous `unlink`.
  * @param path
@@ -75,79 +67,96 @@ export function unlink(path, cb = nop) {
         .then(() => cb())
         .catch(cb);
 }
+unlink;
 export function open(path, flag, arg2, cb = nop) {
     const mode = normalizeMode(arg2, 0o644);
     cb = typeof arg2 === 'function' ? arg2 : cb;
     promises
         .open(path, flag, mode)
-        .then(fd => cb(null, fd))
+        .then(handle => cb(null, handle.fd))
         .catch(cb);
 }
-export function readFile(filename, arg2 = {}, cb = nop) {
-    cb = typeof arg2 === 'function' ? arg2 : cb;
-    promises.readFile(filename, typeof arg2 === 'function' ? null : arg2);
+open;
+export function readFile(filename, options, cb = nop) {
+    cb = typeof options === 'function' ? options : cb;
+    promises
+        .readFile(filename, typeof options === 'function' ? null : options)
+        .then(data => cb(null, data))
+        .catch(cb);
 }
-export function writeFile(filename, data, arg3 = {}, cb = nop) {
+readFile;
+export function writeFile(filename, data, arg3, cb = nop) {
     cb = typeof arg3 === 'function' ? arg3 : cb;
-    promises.writeFile(filename, data, typeof arg3 === 'function' ? undefined : arg3);
+    promises
+        .writeFile(filename, data, typeof arg3 != 'function' ? arg3 : null)
+        .then(() => cb(null))
+        .catch(cb);
 }
+writeFile;
 export function appendFile(filename, data, arg3, cb = nop) {
     cb = typeof arg3 === 'function' ? arg3 : cb;
     promises.appendFile(filename, data, typeof arg3 === 'function' ? null : arg3);
 }
-/**
- * Asynchronous `fstat`.
- * `fstat()` is identical to `stat()`, except that the file to be stat-ed is
- * specified by the file descriptor `fd`.
- * @param fd
- * @param callback
- */
-export function fstat(fd, cb = nop) {
-    promises
-        .fstat(fd)
-        .then(stats => cb(null, stats))
+appendFile;
+export function fstat(fd, options, cb = nop) {
+    cb = typeof options == 'function' ? options : cb;
+    fd2file(fd)
+        .stat()
+        .then(stats => cb(null, (typeof options == 'object' && options?.bigint ? BigIntStats.clone(stats) : stats)))
         .catch(cb);
 }
+fstat;
 /**
  * Asynchronous close.
  * @param fd
  * @param callback
  */
 export function close(fd, cb = nop) {
-    promises
-        .close(fd)
+    new promises.FileHandle(fd)
+        .close()
         .then(() => cb())
         .catch(cb);
 }
-export function ftruncate(fd, arg2, cb = nop) {
-    const length = typeof arg2 === 'number' ? arg2 : 0;
-    cb = typeof arg2 === 'function' ? arg2 : cb;
-    promises.ftruncate(fd, length);
+close;
+export function ftruncate(fd, lenOrCB, cb = nop) {
+    const length = typeof lenOrCB === 'number' ? lenOrCB : 0;
+    cb = typeof lenOrCB === 'function' ? lenOrCB : cb;
+    const file = fd2file(fd);
+    if (length < 0) {
+        throw new ApiError(ErrorCode.EINVAL);
+    }
+    file.truncate(length)
+        .then(() => cb())
+        .catch(cb);
 }
+ftruncate;
 /**
  * Asynchronous fsync.
  * @param fd
  * @param callback
  */
 export function fsync(fd, cb = nop) {
-    promises
-        .fsync(fd)
+    fd2file(fd)
+        .sync()
         .then(() => cb())
         .catch(cb);
 }
+fsync;
 /**
  * Asynchronous fdatasync.
  * @param fd
  * @param callback
  */
 export function fdatasync(fd, cb = nop) {
-    promises
-        .fdatasync(fd)
+    fd2file(fd)
+        .datasync()
         .then(() => cb())
         .catch(cb);
 }
+fdatasync;
 export function write(fd, arg2, arg3, arg4, arg5, cb = nop) {
     let buffer, offset, length, position = null, encoding;
+    const handle = new promises.FileHandle(fd);
     if (typeof arg2 === 'string') {
         // Signature 1: (fd, string, [position?, [encoding?]], cb?)
         encoding = 'utf8';
@@ -172,9 +181,9 @@ export function write(fd, arg2, arg3, arg4, arg5, cb = nop) {
         offset = 0;
         length = buffer.length;
         const _cb = cb;
-        promises
-            .write(fd, buffer, offset, length, position)
-            .then(bytesWritten => _cb(null, bytesWritten, decode(buffer)))
+        handle
+            .write(buffer, offset, length, position)
+            .then(({ bytesWritten }) => _cb(null, bytesWritten, decode(buffer)))
             .catch(_cb);
     }
     else {
@@ -184,12 +193,13 @@ export function write(fd, arg2, arg3, arg4, arg5, cb = nop) {
         length = arg4;
         position = typeof arg5 === 'number' ? arg5 : null;
         const _cb = (typeof arg5 === 'function' ? arg5 : cb);
-        promises
-            .write(fd, buffer, offset, length, position)
-            .then(bytesWritten => _cb(null, bytesWritten, buffer))
+        handle
+            .write(buffer, offset, length, position)
+            .then(({ bytesWritten }) => _cb(null, bytesWritten, buffer))
             .catch(_cb);
     }
 }
+write;
 /**
  * Read data from the file specified by `fd`.
  * @param buffer The buffer that the data will be
@@ -203,11 +213,12 @@ export function write(fd, arg2, arg3, arg4, arg5, cb = nop) {
  * @param callback The number is the number of bytes read
  */
 export function read(fd, buffer, offset, length, position, cb = nop) {
-    promises
-        .read(fd, buffer, offset, length, position)
+    new promises.FileHandle(fd)
+        .read(buffer, offset, length, position)
         .then(({ bytesRead, buffer }) => cb(null, bytesRead, buffer))
         .catch(cb);
 }
+read;
 /**
  * Asynchronous `fchown`.
  * @param fd
@@ -216,11 +227,12 @@ export function read(fd, buffer, offset, length, position, cb = nop) {
  * @param callback
  */
 export function fchown(fd, uid, gid, cb = nop) {
-    promises
-        .fchown(fd, uid, gid)
+    new promises.FileHandle(fd)
+        .chown(uid, gid)
         .then(() => cb())
         .catch(cb);
 }
+fchown;
 /**
  * Asynchronous `fchmod`.
  * @param fd
@@ -228,11 +240,12 @@ export function fchown(fd, uid, gid, cb = nop) {
  * @param callback
  */
 export function fchmod(fd, mode, cb) {
-    promises
-        .fchmod(fd, mode)
+    new promises.FileHandle(fd)
+        .chmod(mode)
         .then(() => cb())
         .catch(cb);
 }
+fchmod;
 /**
  * Change the file timestamps of a file referenced by the supplied file
  * descriptor.
@@ -242,11 +255,12 @@ export function fchmod(fd, mode, cb) {
  * @param callback
  */
 export function futimes(fd, atime, mtime, cb = nop) {
-    promises
-        .futimes(fd, atime, mtime)
+    new promises.FileHandle(fd)
+        .utimes(atime, mtime)
         .then(() => cb())
         .catch(cb);
 }
+futimes;
 /**
  * Asynchronous `rmdir`.
  * @param path
@@ -258,6 +272,7 @@ export function rmdir(path, cb = nop) {
         .then(() => cb())
         .catch(cb);
 }
+rmdir;
 /**
  * Asynchronous `mkdir`.
  * @param path
@@ -270,50 +285,47 @@ export function mkdir(path, mode, cb = nop) {
         .then(() => cb())
         .catch(cb);
 }
-/**
- * Asynchronous `readdir`. Reads the contents of a directory.
- * The callback gets two arguments `(err, files)` where `files` is an array of
- * the names of the files in the directory excluding `'.'` and `'..'`.
- * @param path
- * @param callback
- */
-export function readdir(path, cb = nop) {
+mkdir;
+export function readdir(path, _options, cb = nop) {
+    cb = typeof _options == 'function' ? _options : cb;
+    const options = typeof _options != 'function' ? _options : {};
     promises
-        .readdir(path)
+        .readdir(path, options)
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         .then(entries => cb(null, entries))
         .catch(cb);
 }
+readdir;
 /**
  * Asynchronous `link`.
- * @param srcpath
- * @param dstpath
+ * @param existing
+ * @param newpath
  * @param callback
  */
-export function link(srcpath, dstpath, cb = nop) {
+export function link(existing, newpath, cb = nop) {
     promises
-        .link(srcpath, dstpath)
+        .link(existing, newpath)
         .then(() => cb())
         .catch(cb);
 }
-export function symlink(srcpath, dstpath, arg3, cb = nop) {
-    const type = typeof arg3 === 'string' ? arg3 : 'file';
-    cb = typeof arg3 === 'function' ? arg3 : cb;
+link;
+export function symlink(target, path, typeOrCB, cb = nop) {
+    const type = typeof typeOrCB === 'string' ? typeOrCB : 'file';
+    cb = typeof typeOrCB === 'function' ? typeOrCB : cb;
     promises
-        .symlink(srcpath, dstpath, typeof arg3 === 'function' ? null : arg3)
+        .symlink(target, path, type)
         .then(() => cb())
         .catch(cb);
 }
-/**
- * Asynchronous readlink.
- * @param path
- * @param callback
- */
-export function readlink(path, cb = nop) {
+symlink;
+export function readlink(path, options, callback = nop) {
+    callback = typeof options == 'function' ? options : callback;
     promises
         .readlink(path)
-        .then(result => cb(null, result))
-        .catch(cb);
+        .then(result => callback(null, result))
+        .catch(callback);
 }
+readlink;
 /**
  * Asynchronous `chown`.
  * @param path
@@ -327,6 +339,7 @@ export function chown(path, uid, gid, cb = nop) {
         .then(() => cb())
         .catch(cb);
 }
+chown;
 /**
  * Asynchronous `lchown`.
  * @param path
@@ -340,6 +353,7 @@ export function lchown(path, uid, gid, cb = nop) {
         .then(() => cb())
         .catch(cb);
 }
+lchown;
 /**
  * Asynchronous `chmod`.
  * @param path
@@ -352,6 +366,7 @@ export function chmod(path, mode, cb = nop) {
         .then(() => cb())
         .catch(cb);
 }
+chmod;
 /**
  * Asynchronous `lchmod`.
  * @param path
@@ -364,6 +379,7 @@ export function lchmod(path, mode, cb = nop) {
         .then(() => cb())
         .catch(cb);
 }
+lchmod;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  * @param path
@@ -377,6 +393,7 @@ export function utimes(path, atime, mtime, cb = nop) {
         .then(() => cb())
         .catch(cb);
 }
+utimes;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  * @param path
@@ -390,14 +407,15 @@ export function lutimes(path, atime, mtime, cb = nop) {
         .then(() => cb())
         .catch(cb);
 }
+lutimes;
 export function realpath(path, arg2, cb = nop) {
-    const cache = typeof arg2 === 'object' ? arg2 : {};
     cb = typeof arg2 === 'function' ? arg2 : cb;
     promises
         .realpath(path, typeof arg2 === 'function' ? null : arg2)
         .then(result => cb(null, result))
         .catch(cb);
 }
+realpath;
 export function access(path, arg2, cb = nop) {
     const mode = typeof arg2 === 'number' ? arg2 : R_OK;
     cb = typeof arg2 === 'function' ? arg2 : cb;
@@ -406,6 +424,7 @@ export function access(path, arg2, cb = nop) {
         .then(() => cb())
         .catch(cb);
 }
+access;
 export function watchFile(filename, arg2, listener = nop) {
     throw new ApiError(ErrorCode.ENOTSUP);
 }
@@ -421,3 +440,21 @@ export function createReadStream(path, options) {
 export function createWriteStream(path, options) {
     throw new ApiError(ErrorCode.ENOTSUP);
 }
+export function rm(path) {
+    new ApiError(ErrorCode.ENOTSUP);
+}
+export function mkdtemp(path) {
+    new ApiError(ErrorCode.ENOTSUP);
+}
+export function copyFile(src, dest, flags, callback) {
+    new ApiError(ErrorCode.ENOTSUP);
+}
+export function readv(path) {
+    new ApiError(ErrorCode.ENOTSUP);
+}
+export function writev(fd, buffers, position, cb) {
+    throw new ApiError(ErrorCode.ENOTSUP);
+}
+export function opendir(path) {
+    throw new ApiError(ErrorCode.ENOTSUP);
+}

package/dist/emulation/constants.js

@@ -68,7 +68,7 @@ export const O_DIRECT = 0o40000;
 export const O_NONBLOCK = 0o4000;
 // File Type Constants
 /** Constant for fs.Stats mode property for determining a file's type. Bit mask used to extract the file type code. */
-export const S_IFMT = 0o170000;
+export const S_IFMT = 0xf000;
 /** Constant for fs.Stats mode property for determining a file's type. File type constant for a regular file. */
 export const S_IFREG = 0o100000;
 /** Constant for fs.Stats mode property for determining a file's type. File type constant for a directory. */

package/dist/emulation/dir.d.ts

@@ -0,0 +1,55 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Dirent as _Dirent, Dir as _Dir } from 'fs';
+import { NoArgCallback, TwoArgCallback } from '../filesystem.js';
+import { Stats } from '../stats.js';
+export declare class Dirent implements _Dirent {
+    name: string;
+    protected stats: Stats;
+    constructor(name: string, stats: Stats);
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isSymbolicLink(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+}
+/**
+ * A class representing a directory stream.
+ */
+export declare class Dir implements _Dir {
+    readonly path: string;
+    protected closed: boolean;
+    protected checkClosed(): void;
+    protected _entries: Dirent[];
+    constructor(path: string);
+    /**
+     * Asynchronously close the directory's underlying resource handle.
+     * Subsequent reads will result in errors.
+     */
+    close(): Promise<void>;
+    close(cb: NoArgCallback): void;
+    /**
+     * Synchronously close the directory's underlying resource handle.
+     * Subsequent reads will result in errors.
+     */
+    closeSync(): void;
+    protected _read(): Promise<Dirent | null>;
+    /**
+     * Asynchronously read the next directory entry via `readdir(3)` as an `Dirent`.
+     * After the read is completed, a value is returned that will be resolved with an `Dirent`, or `null` if there are no more directory entries to read.
+     * Directory entries returned by this function are in no particular order as provided by the operating system's underlying directory mechanisms.
+     */
+    read(): Promise<Dirent | null>;
+    read(cb: TwoArgCallback<Dirent | null>): void;
+    /**
+     * Synchronously read the next directory entry via `readdir(3)` as a `Dirent`.
+     * If there are no more directory entries to read, null will be returned.
+     * Directory entries returned by this function are in no particular order as provided by the operating system's underlying directory mechanisms.
+     */
+    readSync(): Dirent | null;
+    /**
+     * Asynchronously iterates over the directory via `readdir(3)` until all entries have been read.
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<Dirent>;
+}

package/dist/emulation/dir.js

@@ -0,0 +1,104 @@
+import { readdir } from './promises.js';
+import { ApiError, ErrorCode } from '../ApiError.js';
+import { readdirSync } from './sync.js';
+export class Dirent {
+    constructor(name, stats) {
+        this.name = name;
+        this.stats = stats;
+    }
+    isFile() {
+        return this.stats.isFile();
+    }
+    isDirectory() {
+        return this.stats.isDirectory();
+    }
+    isBlockDevice() {
+        return this.stats.isBlockDevice();
+    }
+    isCharacterDevice() {
+        return this.stats.isCharacterDevice();
+    }
+    isSymbolicLink() {
+        return this.stats.isSymbolicLink();
+    }
+    isFIFO() {
+        return this.stats.isFIFO();
+    }
+    isSocket() {
+        return this.stats.isSocket();
+    }
+}
+/**
+ * A class representing a directory stream.
+ */
+export class Dir {
+    checkClosed() {
+        if (this.closed) {
+            throw new ApiError(ErrorCode.EBADF, 'Can not use closed Dir');
+        }
+    }
+    constructor(path) {
+        this.path = path;
+        this.closed = false;
+    }
+    close(cb) {
+        this.closed = true;
+        if (!cb) {
+            return Promise.resolve();
+        }
+        cb();
+    }
+    /**
+     * Synchronously close the directory's underlying resource handle.
+     * Subsequent reads will result in errors.
+     */
+    closeSync() {
+        this.closed = true;
+    }
+    async _read() {
+        if (!this._entries) {
+            this._entries = await readdir(this.path, { withFileTypes: true });
+        }
+        if (this._entries.length == 0) {
+            return null;
+        }
+        return this._entries.shift();
+    }
+    read(cb) {
+        if (!cb) {
+            return this._read();
+        }
+        this._read().then(value => cb(null, value));
+    }
+    /**
+     * Synchronously read the next directory entry via `readdir(3)` as a `Dirent`.
+     * If there are no more directory entries to read, null will be returned.
+     * 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 });
+        }
+        if (this._entries.length == 0) {
+            return null;
+        }
+        return this._entries.shift();
+    }
+    /**
+     * 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 };
+            },
+        };
+    }
+}

package/dist/emulation/fs.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
 import * as fs_mock from './index.js';
 import type * as fs_node from 'node:fs';
-type ZenFSModule = typeof fs_node & typeof fs_mock;
-declare const fs: ZenFSModule;
+declare const fs: typeof fs_node & typeof fs_mock;
 export * from './index.js';
 export default fs;

package/dist/emulation/fs.js

@@ -1,5 +1,4 @@
 import * as fs_mock from './index.js';
-// @ts-expect-error 2322
 const fs = fs_mock;
 export * from './index.js';
 export default fs;

package/dist/emulation/index.d.ts

@@ -2,4 +2,7 @@ export * from './callbacks.js';
 export * from './sync.js';
 export * as promises from './promises.js';
 export * as constants from './constants.js';
+export * from './streams.js';
+export * from './dir.js';
 export { initialize, getMount, getMounts, mount, umount, _toUnixTimestamp } from './shared.js';
+export { Stats, BigIntStats } from '../stats.js';

package/dist/emulation/index.js

@@ -2,4 +2,7 @@ export * from './callbacks.js';
 export * from './sync.js';
 export * as promises from './promises.js';
 export * as constants from './constants.js';
+export * from './streams.js';
+export * from './dir.js';
 export { initialize, getMount, getMounts, mount, umount, _toUnixTimestamp } from './shared.js';
+export { Stats, BigIntStats } from '../stats.js';