@zenfs/core 0.12.0 → 0.12.2

package/dist/file.js

@@ -183,7 +183,7 @@ export class PreloadFile extends File {
     /**
      * Path to the file
      */
-    path, flag, stats, _buffer = new Uint8Array(new ArrayBuffer(0, { maxByteLength: size_max }))) {
+    path, flag, stats, _buffer = new Uint8Array(new ArrayBuffer(0, fs.metadata().noResizableBuffers ? {} : { maxByteLength: size_max }))) {
         super();
         this.fs = fs;
         this.path = path;
@@ -191,7 +191,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 +203,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 +234,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 +267,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.
@@ -332,21 +325,21 @@ export class PreloadFile extends File {
      * @returns bytes written
      */
     writeSync(buffer, offset = 0, length = this.stats.size, position = 0) {
-        this._dirty = true;
+        this.dirty = true;
         position ?? (position = this.position);
         if (!isWriteable(this.flag)) {
             throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
         }
-        const endFp = position + length;
-        if (endFp > this.stats.size) {
-            this.stats.size = endFp;
-            if (endFp > this._buffer.byteLength) {
-                if (this._buffer.buffer.resizable && this._buffer.buffer.maxByteLength <= endFp) {
-                    this._buffer.buffer.resize(endFp);
+        const end = position + length;
+        if (end > this.stats.size) {
+            this.stats.size = end;
+            if (end > this._buffer.byteLength) {
+                if (this._buffer.buffer.resizable && this._buffer.buffer.maxByteLength <= end) {
+                    this._buffer.buffer.resize(end);
                 }
                 else {
                     // Extend the buffer!
-                    const newBuffer = new Uint8Array(new ArrayBuffer(endFp, { maxByteLength: size_max }));
+                    const newBuffer = new Uint8Array(new ArrayBuffer(end, this.fs.metadata().noResizableBuffers ? {} : { maxByteLength: size_max }));
                     newBuffer.set(this._buffer);
                     this._buffer = newBuffer;
                 }
@@ -356,11 +349,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 +382,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 +391,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 +411,7 @@ export class PreloadFile extends File {
      * @param mode
      */
     chmodSync(mode) {
-        this._dirty = true;
+        this.dirty = true;
         this.stats.chmod(mode);
         this.syncSync();
     }
@@ -437,7 +429,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 +437,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

@@ -22,6 +22,35 @@ export interface FileSystemMetadata {
      * The available space
      */
     freeSpace: number;
+    /**
+     * If set, disables File from using a resizable array buffer.
+     * @default false
+     */
+    noResizableBuffers: boolean;
+    /**
+     * If set, disables caching on async file systems.
+     * This means *sync operations will not work*.
+     * It has no affect on sync file systems.
+     * @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.
@@ -35,10 +64,15 @@ export interface FileSystemMetadata {
  */
 export declare abstract class FileSystem {
     /**
-     * Get metadata about the current file syste,
+     * Numeric type, used for statfs
+     * @internal @protected
+     */
+    _type?: number;
+    /**
+     * 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
@@ -168,12 +202,20 @@ declare abstract class SyncFS extends FileSystem {
 export declare function Sync<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => SyncFS) & T;
 /**
  * @internal
+ * Note: `_*` should be treated like protected.
+ * Protected can't be used because of TS quirks however.
  */
 declare abstract class AsyncFS extends FileSystem {
     /**
+     * @access protected
+     * @hidden
+     */
+    _disableSync: boolean;
+    /**
+     * @access protected
      * @hidden
      */
-    abstract _sync: FileSystem;
+    abstract _sync?: FileSystem;
     queueDone(): Promise<void>;
     metadata(): FileSystemMetadata;
     ready(): Promise<void>;

package/dist/filesystem.js

@@ -14,7 +14,7 @@ import { PreloadFile, parseFlag } from './file.js';
  */
 export class FileSystem {
     /**
-     * Get metadata about the current file syste,
+     * Get metadata about the current file system
      */
     metadata() {
         return {
@@ -22,11 +22,12 @@ export class FileSystem {
             readonly: false,
             totalSpace: 0,
             freeSpace: 0,
+            noResizableBuffers: false,
+            noAsyncCache: false,
+            type: this._type,
         };
     }
-    constructor(options) {
-        // unused
-    }
+    constructor() { }
     async ready() { }
     /**
      * Test whether or not the given path exists by checking with the file system.
@@ -37,7 +38,7 @@ export class FileSystem {
             return true;
         }
         catch (e) {
-            return false;
+            return e.code != 'ENOENT';
         }
     }
     /**
@@ -49,7 +50,7 @@ export class FileSystem {
             return true;
         }
         catch (e) {
-            return false;
+            return e.code != 'ENOENT';
         }
     }
 }
@@ -117,6 +118,7 @@ export function Async(FS) {
              */
             this._queue = [];
             this._isInitialized = false;
+            this._disableSync = false;
         }
         get _queueRunning() {
             return !!this._queue.length;
@@ -128,11 +130,12 @@ export function Async(FS) {
             });
         }
         async ready() {
-            await this._sync.ready();
             await super.ready();
-            if (this._isInitialized) {
+            if (this._isInitialized || this._disableSync) {
                 return;
             }
+            this.checkSync();
+            await this._sync.ready();
             try {
                 await this.crossCopy('/');
                 this._isInitialized = true;
@@ -142,19 +145,37 @@ export function Async(FS) {
                 throw e;
             }
         }
+        metadata() {
+            return {
+                ...super.metadata(),
+                noAsyncCache: this._disableSync,
+            };
+        }
+        checkSync(path, syscall) {
+            if (this._disableSync) {
+                throw new ErrnoError(Errno.ENOTSUP, 'Sync caching has been disabled for this async file system', path, syscall);
+            }
+            if (!this._sync) {
+                throw new ErrnoError(Errno.ENOTSUP, 'No sync cache is attached to this async file system', path, syscall);
+            }
+        }
         renameSync(oldPath, newPath, cred) {
+            this.checkSync(oldPath, 'rename');
             this._sync.renameSync(oldPath, newPath, cred);
             this.queue('rename', oldPath, newPath, cred);
         }
         statSync(path, cred) {
+            this.checkSync(path, 'stat');
             return this._sync.statSync(path, cred);
         }
         createFileSync(path, flag, mode, cred) {
+            this.checkSync(path, 'createFile');
             this._sync.createFileSync(path, flag, mode, cred);
             this.queue('createFile', path, flag, mode, cred);
             return this.openFileSync(path, flag, cred);
         }
         openFileSync(path, flag, cred) {
+            this.checkSync(path, 'openFile');
             const file = this._sync.openFileSync(path, flag, cred);
             const stats = file.statSync();
             const buffer = new Uint8Array(stats.size);
@@ -162,35 +183,43 @@ export function Async(FS) {
             return new PreloadFile(this, path, flag, stats, buffer);
         }
         unlinkSync(path, cred) {
+            this.checkSync(path, 'unlinkSync');
             this._sync.unlinkSync(path, cred);
             this.queue('unlink', path, cred);
         }
         rmdirSync(path, cred) {
+            this.checkSync(path, 'rmdir');
             this._sync.rmdirSync(path, cred);
             this.queue('rmdir', path, cred);
         }
         mkdirSync(path, mode, cred) {
+            this.checkSync(path, 'mkdir');
             this._sync.mkdirSync(path, mode, cred);
             this.queue('mkdir', path, mode, cred);
         }
         readdirSync(path, cred) {
+            this.checkSync(path, 'readdir');
             return this._sync.readdirSync(path, cred);
         }
         linkSync(srcpath, dstpath, cred) {
+            this.checkSync(srcpath, 'link');
             this._sync.linkSync(srcpath, dstpath, cred);
             this.queue('link', srcpath, dstpath, cred);
         }
         syncSync(path, data, stats) {
+            this.checkSync(path, 'sync');
             this._sync.syncSync(path, data, stats);
             this.queue('sync', path, data, stats);
         }
         existsSync(path, cred) {
+            this.checkSync(path, 'exists');
             return this._sync.existsSync(path, cred);
         }
         /**
          * @internal
          */
         async crossCopy(path) {
+            this.checkSync(path, 'crossCopy');
             const stats = await this.stat(path, rootCred);
             if (stats.isDirectory()) {
                 if (path !== '/') {

package/dist/stats.d.ts

@@ -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);
     }
 }