@zenfs/core 0.12.1 → 0.12.3

package/dist/file.js

@@ -1,21 +1,7 @@
-import { ErrnoError, Errno } from './error.js';
 import { O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_SYNC, O_TRUNC, O_WRONLY, S_IFMT } from './emulation/constants.js';
+import { Errno, ErrnoError } from './error.js';
 import { size_max } from './inode.js';
 import { Stats } from './stats.js';
-/**
- * @hidden
- */
-export var ActionType;
-(function (ActionType) {
-    // Indicates that the code should not do anything.
-    ActionType[ActionType["NOP"] = 0] = "NOP";
-    // Indicates that the code should throw an exception.
-    ActionType[ActionType["THROW"] = 1] = "THROW";
-    // Indicates that the code should truncate the file, but only if it is a file.
-    ActionType[ActionType["TRUNCATE"] = 2] = "TRUNCATE";
-    // Indicates that the code should create the file.
-    ActionType[ActionType["CREATE"] = 3] = "CREATE";
-})(ActionType || (ActionType = {}));
 const validFlags = ['r', 'r+', 'rs', 'rs+', 'w', 'wx', 'w+', 'wx+', 'a', 'ax', 'a+', 'ax+'];
 export function parseFlag(flag) {
     if (typeof flag === 'number') {
@@ -117,21 +103,6 @@ export function isSynchronous(flag) {
 export function isExclusive(flag) {
     return flag.indexOf('x') !== -1;
 }
-export function pathExistsAction(flag) {
-    if (isExclusive(flag)) {
-        return ActionType.THROW;
-    }
-    if (isTruncating(flag)) {
-        return ActionType.TRUNCATE;
-    }
-    return ActionType.NOP;
-}
-export function pathNotExistsAction(flag) {
-    if ((isWriteable(flag) || isAppendable(flag)) && flag !== 'r+') {
-        return ActionType.CREATE;
-    }
-    return ActionType.THROW;
-}
 export class File {
     [Symbol.asyncDispose]() {
         return this.close();
@@ -191,7 +162,7 @@ export class PreloadFile extends File {
         this.stats = stats;
         this._buffer = _buffer;
         this._position = 0;
-        this._dirty = false;
+        this.dirty = false;
         /*
             Note:
             This invariant is *not* maintained once the file starts getting modified.
@@ -203,7 +174,7 @@ export class PreloadFile extends File {
         if (isReadable(this.flag)) {
             throw new Error(`Size mismatch: buffer length ${_buffer.byteLength}, stats size ${this.stats.size}`);
         }
-        this._dirty = true;
+        this.dirty = true;
     }
     /**
      * Get the underlying buffer for this file. Mutating not recommended and will mess up dirty tracking.
@@ -234,18 +205,18 @@ export class PreloadFile extends File {
         this._position = newPos;
     }
     async sync() {
-        if (!this.isDirty()) {
+        if (!this.dirty) {
             return;
         }
         await this.fs.sync(this.path, this._buffer, this.stats);
-        this._dirty = false;
+        this.dirty = false;
     }
     syncSync() {
-        if (!this.isDirty()) {
+        if (!this.dirty) {
             return;
         }
         this.fs.syncSync(this.path, this._buffer, this.stats);
-        this._dirty = false;
+        this.dirty = false;
     }
     async close() {
         await this.sync();
@@ -267,39 +238,32 @@ export class PreloadFile extends File {
     }
     /**
      * Asynchronous truncate.
-     * @param len
+     * @param length
      */
-    async truncate(len) {
-        this.truncateSync(len);
-        if (isSynchronous(this.flag)) {
-            return this.sync();
-        }
+    async truncate(length) {
+        this.truncateSync(length);
+        return this.sync();
     }
     /**
      * Synchronous truncate.
-     * @param len
+     * @param length
      */
-    truncateSync(len) {
-        this._dirty = true;
+    truncateSync(length) {
+        this.dirty = true;
         if (!isWriteable(this.flag)) {
             throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
         }
         this.stats.mtimeMs = Date.now();
-        if (len > this._buffer.length) {
-            const buf = new Uint8Array(len - this._buffer.length);
-            // Write will set stats.size for us.
-            this.writeSync(buf, 0, buf.length, this._buffer.length);
-            if (isSynchronous(this.flag)) {
-                this.syncSync();
-            }
+        if (length > this._buffer.length) {
+            const data = new Uint8Array(length - this._buffer.length);
+            // Write will set stats.size and handle syncing.
+            this.writeSync(data, 0, data.length, this._buffer.length);
             return;
         }
-        this.stats.size = len;
-        // Truncate buffer to 'len'.
-        this._buffer = this._buffer.subarray(0, len);
-        if (isSynchronous(this.flag)) {
-            this.syncSync();
-        }
+        this.stats.size = length;
+        // Truncate.
+        this._buffer = this._buffer.slice(0, length);
+        this.syncSync();
     }
     /**
      * Write buffer to the file.
@@ -313,7 +277,7 @@ export class PreloadFile extends File {
      *   data should be written. If position is null, the data will be written at
      *   the current position.
      */
-    async write(buffer, offset = 0, length = this.stats.size, position = 0) {
+    async write(buffer, offset = 0, length = this.stats.size, position = this.position) {
         const bytesWritten = this.writeSync(buffer, offset, length, position);
         await this.sync();
         return bytesWritten;
@@ -331,9 +295,8 @@ export class PreloadFile extends File {
      *   the current position.
      * @returns bytes written
      */
-    writeSync(buffer, offset = 0, length = this.stats.size, position = 0) {
-        this._dirty = true;
-        position ?? (position = this.position);
+    writeSync(buffer, offset = 0, length = this.stats.size, position = this.position) {
+        this.dirty = true;
         if (!isWriteable(this.flag)) {
             throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
         }
@@ -356,11 +319,8 @@ export class PreloadFile extends File {
         this._buffer.set(slice, position);
         const bytesWritten = slice.byteLength;
         this.stats.mtimeMs = Date.now();
-        if (isSynchronous(this.flag)) {
-            this.syncSync();
-            return bytesWritten;
-        }
         this.position = position + bytesWritten;
+        this.syncSync();
         return bytesWritten;
     }
     /**
@@ -392,6 +352,7 @@ export class PreloadFile extends File {
         if (!isReadable(this.flag)) {
             throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode.');
         }
+        this.dirty = true;
         position ?? (position = this.position);
         let end = position + length;
         if (end > this.stats.size) {
@@ -400,6 +361,7 @@ export class PreloadFile extends File {
         this.stats.atimeMs = Date.now();
         this._position = end;
         const bytesRead = end - position;
+        this.syncSync();
         if (bytesRead == 0) {
             // No copy/read. Return immediatly for better performance
             return bytesRead;
@@ -419,7 +381,7 @@ export class PreloadFile extends File {
      * @param mode
      */
     chmodSync(mode) {
-        this._dirty = true;
+        this.dirty = true;
         this.stats.chmod(mode);
         this.syncSync();
     }
@@ -437,7 +399,7 @@ export class PreloadFile extends File {
      * @param gid
      */
     chownSync(uid, gid) {
-        this._dirty = true;
+        this.dirty = true;
         this.stats.chown(uid, gid);
         this.syncSync();
     }
@@ -445,27 +407,18 @@ export class PreloadFile extends File {
         this.utimesSync(atime, mtime);
     }
     utimesSync(atime, mtime) {
-        this._dirty = true;
+        this.dirty = true;
         this.stats.atime = atime;
         this.stats.mtime = mtime;
         this.syncSync();
     }
-    isDirty() {
-        return this._dirty;
-    }
-    /**
-     * Resets the dirty bit. Should only be called after a sync has completed successfully.
-     */
-    resetDirty() {
-        this._dirty = false;
-    }
     _setType(type) {
-        this._dirty = true;
+        this.dirty = true;
         this.stats.mode = (this.stats.mode & ~S_IFMT) | type;
         return this.sync();
     }
     _setTypeSync(type) {
-        this._dirty = true;
+        this.dirty = true;
         this.stats.mode = (this.stats.mode & ~S_IFMT) | type;
         this.syncSync();
     }

package/dist/filesystem.d.ts

@@ -1,6 +1,6 @@
 import { type Cred } from './cred.js';
 import { type File } from './file.js';
-import type { Stats } from './stats.js';
+import { type Stats } from './stats.js';
 export type FileContents = ArrayBufferView | string;
 /**
  * Metadata about a FileSystem
@@ -34,27 +34,40 @@ export interface FileSystemMetadata {
      * @default false
      */
     noAsyncCache: boolean;
+    /**
+     * The optimal block size to use with the file system
+     * @default 4096
+     */
+    blockSize?: number;
+    /**
+     * Total number of (file) nodes available
+     */
+    totalNodes?: number;
+    /**
+     * Number of free (file) nodes available
+     */
+    freeNodes?: number;
+    /**
+     * The type of the FS
+     */
+    type: number;
 }
 /**
  * Structure for a filesystem. All ZenFS backends must extend this.
  *
- * This class includes some default implementations
+ * This class includes default implementations for `exists` and `existsSync`
  *
- * Assume the following about arguments passed to each API method:
- *
- * - Every path is an absolute path. `.`, `..`, and other items are resolved into an absolute form.
- * - All arguments are present. Any optional arguments at the Node API level have been passed in with their default values.
+ * If you are extending this class, note that every path is an absolute path and all arguments are present.
  */
 export declare abstract class FileSystem {
     /**
      * Get metadata about the current file system
      */
     metadata(): FileSystemMetadata;
-    constructor(options?: object);
+    constructor();
     ready(): Promise<void>;
     /**
-     * Asynchronous rename. No arguments other than a possible exception
-     * are given to the completion callback.
+     * Asynchronous rename.
      */
     abstract rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
     /**
@@ -70,26 +83,24 @@ export declare abstract class FileSystem {
      */
     abstract statSync(path: string, cred: Cred): Stats;
     /**
-     * Opens the file at path p with the given flag. The file must exist.
-     * @param p The path to open.
+     * Opens the file at `path` with the given flag. The file must exist.
+     * @param path The path to open.
      * @param flag The flag to use when opening the file.
      */
     abstract openFile(path: string, flag: string, cred: Cred): Promise<File>;
     /**
-     * Opens the file at path p with the given flag. The file must exist.
-     * @param p The path to open.
+     * Opens the file at `path` with the given flag. The file must exist.
+     * @param path The path to open.
      * @param flag The flag to use when opening the file.
      * @return A File object corresponding to the opened file.
      */
     abstract openFileSync(path: string, flag: string, cred: Cred): File;
     /**
-     * Create the file at path p with the given mode. Then, open it with the given
-     * flag.
+     * Create the file at `path` with the given mode. Then, open it with the given flag.
      */
     abstract createFile(path: string, flag: string, mode: number, cred: Cred): Promise<File>;
     /**
-     * Create the file at path p with the given mode. Then, open it with the given
-     * flag.
+     * Create the file at `path` with the given mode. Then, open it with the given flag.
      */
     abstract createFileSync(path: string, flag: string, mode: number, cred: Cred): File;
     /**
@@ -110,21 +121,16 @@ export declare abstract class FileSystem {
     abstract rmdirSync(path: string, cred: Cred): void;
     /**
      * Asynchronous `mkdir`.
-     * @param mode Mode to make the directory using. Can be ignored if
-     *   the filesystem doesn't support permissions.
+     * @param mode Mode to make the directory using.
      */
     abstract mkdir(path: string, mode: number, cred: Cred): Promise<void>;
     /**
      * Synchronous `mkdir`.
-     * @param mode Mode to make the directory using. Can be ignored if
-     *   the filesystem doesn't support permissions.
+     * @param mode Mode to make the directory using.
      */
     abstract mkdirSync(path: string, mode: number, cred: Cred): void;
     /**
      * 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 `'..'`.
      */
     abstract readdir(path: string, cred: Cred): Promise<string[]>;
     /**
@@ -211,13 +217,11 @@ declare abstract class AsyncFS extends FileSystem {
 /**
  * Async() implements synchronous methods on an asynchronous file system
  *
- * Implementing classes must define a protected _sync property for the synchronous file system used as a cache.
- * by:
- *
- * - Performing operations over the in-memory copy, while asynchronously pipelining them
- *   to the backing store.
- * - During application loading, the contents of the async file system can be reloaded into
- *   the synchronous store, if desired.
+ * 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 eloaded into the synchronous store.
  *
  */
 export declare function Async<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => AsyncFS) & T;

package/dist/filesystem.js

@@ -2,15 +2,13 @@ import { ErrnoError, Errno } from './error.js';
 import { rootCred } from './cred.js';
 import { join } from './emulation/path.js';
 import { PreloadFile, parseFlag } from './file.js';
+import { ZenFsType } from './stats.js';
 /**
  * Structure for a filesystem. All ZenFS backends must extend this.
  *
- * This class includes some default implementations
+ * This class includes default implementations for `exists` and `existsSync`
  *
- * Assume the following about arguments passed to each API method:
- *
- * - Every path is an absolute path. `.`, `..`, and other items are resolved into an absolute form.
- * - All arguments are present. Any optional arguments at the Node API level have been passed in with their default values.
+ * If you are extending this class, note that every path is an absolute path and all arguments are present.
  */
 export class FileSystem {
     /**
@@ -24,10 +22,10 @@ export class FileSystem {
             freeSpace: 0,
             noResizableBuffers: false,
             noAsyncCache: false,
+            type: ZenFsType,
         };
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    constructor(options) { }
+    constructor() { }
     async ready() { }
     /**
      * Test whether or not the given path exists by checking with the file system.
@@ -99,13 +97,11 @@ export function Sync(FS) {
 /**
  * Async() implements synchronous methods on an asynchronous file system
  *
- * Implementing classes must define a protected _sync property for the synchronous file system used as a cache.
- * by:
- *
- * - Performing operations over the in-memory copy, while asynchronously pipelining them
- *   to the backing store.
- * - During application loading, the contents of the async file system can be reloaded into
- *   the synchronous store, if desired.
+ * 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 eloaded into the synchronous store.
  *
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/stats.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
 import type * as Node from 'fs';
-import { Cred } from './cred.js';
+import type { Cred } from './cred.js';
 /**
  * Indicates the type of the given file. Applied to 'mode'.
  */
@@ -57,11 +57,9 @@ export interface StatsLike<T extends number | bigint = number | bigint> {
  * Common code used by both Stats and BigIntStats.
  */
 export declare abstract class StatsCommon<T extends number | bigint> implements Node.StatsBase<T>, StatsLike {
-    protected abstract _isBigint: boolean;
-    protected get _typename(): string;
-    protected get _typename_inverse(): string;
+    protected abstract _isBigint: T extends bigint ? true : false;
     protected _convert(arg: number | bigint | string | boolean): T;
-    blocks: T;
+    get blocks(): T;
     /**
      * Unix-style file mode (e.g. 0o644) that includes the type of the item.
      * Type of the item can be FILE, DIRECTORY, SYMLINK, or SOCKET
@@ -184,27 +182,26 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
  * Attribute descriptions are from `man 2 stat'
  * @see http://nodejs.org/api/fs.html#fs_class_fs_stats
  * @see http://man7.org/linux/man-pages/man2/stat.2.html
+ * @internal
  */
 export declare class Stats extends StatsCommon<number> implements Node.Stats, StatsLike {
-    protected _isBigint: boolean;
-    /**
-     * Clones the stats object.
-     * @deprecated use `new Stats(stats)`
-     */
-    static clone(stats: Stats): Stats;
+    protected _isBigint: false;
 }
 /**
  * Stats with bigint
  * @todo Implement with bigint instead of wrapping Stats
+ * @internal
  */
 export declare class BigIntStats extends StatsCommon<bigint> implements Node.BigIntStats, StatsLike {
-    protected _isBigint: boolean;
-    /**
-     * Clone a stats object.
-     * @deprecated use `new BigIntStats(stats)`
-     */
-    static clone(stats: BigIntStats | Stats): BigIntStats;
+    protected _isBigint: true;
 }
+/**
+ * @internal
+ */
+export declare const ZenFsType = 525687744115;
+/**
+ * @hidden
+ */
 export declare class StatsFs implements Node.StatsFsBase<number> {
     /** Type of file system. */
     type: number;
@@ -221,6 +218,9 @@ export declare class StatsFs implements Node.StatsFsBase<number> {
     /** Free file nodes in file system. */
     ffree: number;
 }
+/**
+ * @hidden
+ */
 export declare class BigIntStatsFs implements Node.StatsFsBase<bigint> {
     /** Type of file system. */
     type: bigint;

package/dist/stats.js

@@ -1,4 +1,5 @@
-import { S_IFDIR, S_IFLNK, S_IFMT, S_IFREG, S_IRWXG, S_IRWXO, S_IRWXU } from './emulation/constants.js';
+import { S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK, S_IRWXG, S_IRWXO, S_IRWXU } from './emulation/constants.js';
+import { size_max } from './inode.js';
 /**
  * Indicates the type of the given file. Applied to 'mode'.
  */
@@ -13,15 +14,12 @@ export var FileType;
  * Common code used by both Stats and BigIntStats.
  */
 export class StatsCommon {
-    get _typename() {
-        return this._isBigint ? 'bigint' : 'number';
-    }
-    get _typename_inverse() {
-        return this._isBigint ? 'number' : 'bigint';
-    }
     _convert(arg) {
         return (this._isBigint ? BigInt(arg) : Number(arg));
     }
+    get blocks() {
+        return this._convert(Math.ceil(Number(this.size) / 512));
+    }
     get atime() {
         return new Date(Number(this.atimeMs));
     }
@@ -78,16 +76,15 @@ export class StatsCommon {
          * group ID of owner
          */
         this.gid = this._convert(0);
-        const currentTime = Date.now();
-        const resolveT = (val, _default) => typeof val == this._typename ? val : this._convert(typeof val == this._typename_inverse ? val : _default);
-        this.atimeMs = resolveT(atimeMs, currentTime);
-        this.mtimeMs = resolveT(mtimeMs, currentTime);
-        this.ctimeMs = resolveT(ctimeMs, currentTime);
-        this.birthtimeMs = resolveT(birthtimeMs, currentTime);
-        this.uid = resolveT(uid, 0);
-        this.gid = resolveT(gid, 0);
-        this.size = resolveT(size, 0);
-        this.ino = resolveT(ino, 0);
+        const now = Date.now();
+        this.atimeMs = this._convert(atimeMs ?? now);
+        this.mtimeMs = this._convert(mtimeMs ?? now);
+        this.ctimeMs = this._convert(ctimeMs ?? now);
+        this.birthtimeMs = this._convert(birthtimeMs ?? now);
+        this.uid = this._convert(uid ?? 0);
+        this.gid = this._convert(gid ?? 0);
+        this.size = this._convert(size ?? 0);
+        this.ino = this._convert(ino ?? 0);
         const itemType = Number(mode) & S_IFMT || FileType.FILE;
         if (mode) {
             this.mode = this._convert(mode);
@@ -102,8 +99,6 @@ export class StatsCommon {
                     this.mode = this._convert(0o777);
             }
         }
-        // number of 512B blocks allocated
-        this.blocks = this._convert(Math.ceil(Number(size) / 512));
         // Check if mode also includes top-most bits, which indicate the file's type.
         if ((this.mode & S_IFMT) == 0) {
             this.mode = (this.mode | this._convert(itemType));
@@ -129,16 +124,16 @@ export class StatsCommon {
     }
     // Currently unsupported
     isSocket() {
-        return false;
+        return (this.mode & S_IFMT) === S_IFSOCK;
     }
     isBlockDevice() {
-        return false;
+        return (this.mode & S_IFMT) === S_IFBLK;
     }
     isCharacterDevice() {
-        return false;
+        return (this.mode & S_IFMT) === S_IFCHR;
     }
     isFIFO() {
-        return false;
+        return (this.mode & S_IFMT) === S_IFIFO;
     }
     /**
      * Checks if a given user/group has access to this item
@@ -194,16 +189,16 @@ export class StatsCommon {
         }
     }
     get atimeNs() {
-        return BigInt(this.atimeMs);
+        return BigInt(this.atimeMs) * 1000n;
     }
     get mtimeNs() {
-        return BigInt(this.mtimeMs);
+        return BigInt(this.mtimeMs) * 1000n;
     }
     get ctimeNs() {
-        return BigInt(this.ctimeMs);
+        return BigInt(this.ctimeMs) * 1000n;
     }
     get birthtimeNs() {
-        return BigInt(this.birthtimeMs);
+        return BigInt(this.birthtimeMs) * 1000n;
     }
 }
 /**
@@ -212,44 +207,39 @@ export class StatsCommon {
  * Attribute descriptions are from `man 2 stat'
  * @see http://nodejs.org/api/fs.html#fs_class_fs_stats
  * @see http://man7.org/linux/man-pages/man2/stat.2.html
+ * @internal
  */
 export class Stats extends StatsCommon {
     constructor() {
         super(...arguments);
         this._isBigint = false;
     }
-    /**
-     * Clones the stats object.
-     * @deprecated use `new Stats(stats)`
-     */
-    static clone(stats) {
-        return new Stats(stats);
-    }
 }
 Stats;
 /**
  * Stats with bigint
  * @todo Implement with bigint instead of wrapping Stats
+ * @internal
  */
 export class BigIntStats extends StatsCommon {
     constructor() {
         super(...arguments);
         this._isBigint = true;
     }
-    /**
-     * Clone a stats object.
-     * @deprecated use `new BigIntStats(stats)`
-     */
-    static clone(stats) {
-        return new BigIntStats(stats);
-    }
 }
+/**
+ * @internal
+ */
+export const ZenFsType = 0x7a656e6673; // 'z' 'e' 'n' 'f' 's'
+/**
+ * @hidden
+ */
 export class StatsFs {
     constructor() {
         /** Type of file system. */
-        this.type = 0;
+        this.type = 0x7a656e6673;
         /**  Optimal transfer block size. */
-        this.bsize = 0;
+        this.bsize = 4096;
         /**  Total data blocks in file system. */
         this.blocks = 0;
         /** Free blocks in file system. */
@@ -257,17 +247,20 @@ export class StatsFs {
         /** Available blocks for unprivileged users */
         this.bavail = 0;
         /** Total file nodes in file system. */
-        this.files = 0;
+        this.files = size_max;
         /** Free file nodes in file system. */
-        this.ffree = 0;
+        this.ffree = size_max;
     }
 }
+/**
+ * @hidden
+ */
 export class BigIntStatsFs {
     constructor() {
         /** Type of file system. */
-        this.type = 0n;
+        this.type = 0x7a656e6673n;
         /**  Optimal transfer block size. */
-        this.bsize = 0n;
+        this.bsize = 4096n;
         /**  Total data blocks in file system. */
         this.blocks = 0n;
         /** Free blocks in file system. */
@@ -275,8 +268,8 @@ export class BigIntStatsFs {
         /** Available blocks for unprivileged users */
         this.bavail = 0n;
         /** Total file nodes in file system. */
-        this.files = 0n;
+        this.files = BigInt(size_max);
         /** Free file nodes in file system. */
-        this.ffree = 0n;
+        this.ffree = BigInt(size_max);
     }
 }