@zenfs/core 0.1.0 → 0.2.0

package/dist/inode.d.ts

@@ -1,21 +1,42 @@
 import { Stats } from './stats.js';
+export type Ino = bigint;
+export declare const size_max: number;
+/**
+ * @internal
+ */
+export declare const rootIno: Ino;
+/**
+ * Generate 4 random bits at a time
+ *
+ * @internal
+ */
+export declare function randomIno(): Ino;
 /**
  * Generic inode definition that can easily be serialized.
  */
-export default class Inode {
-    id: string;
-    size: number;
-    mode: number;
-    atime: number;
-    mtime: number;
-    ctime: number;
-    uid: number;
-    gid: number;
-    /**
-     * Converts the buffer into an Inode.
-     */
-    static Deserialize(data: ArrayBufferLike | ArrayBufferView): Inode;
-    constructor(id: string, size: number, mode: number, atime: number, mtime: number, ctime: number, uid: number, gid: number);
+export declare class Inode {
+    readonly buffer: ArrayBufferLike;
+    get data(): Uint8Array;
+    protected view: DataView;
+    constructor(buffer?: ArrayBufferLike);
+    get ino(): Ino;
+    set ino(value: Ino);
+    get size(): number;
+    set size(value: number);
+    get mode(): number;
+    set mode(value: number);
+    get nlink(): number;
+    set nlink(value: number);
+    get uid(): number;
+    set uid(value: number);
+    get gid(): number;
+    set gid(value: number);
+    get atime(): number;
+    set atime(value: number);
+    get mtime(): number;
+    set mtime(value: number);
+    get ctime(): number;
+    set ctime(value: number);
     /**
      * Handy function that converts the Inode to a Node Stats object.
      */
@@ -23,11 +44,7 @@ export default class Inode {
     /**
      * Get the size of this Inode, in bytes.
      */
-    getSize(): number;
-    /**
-     * Writes the inode into the start of the buffer.
-     */
-    serialize(data?: ArrayBufferLike | ArrayBufferView): Uint8Array;
+    sizeof(): number;
     /**
      * Updates the Inode using information from the stats object. Used by file
      * systems at sync time, e.g.:
@@ -38,13 +55,5 @@ export default class Inode {
      *   file system.
      * @return True if any changes have occurred.
      */
-    update(stats: Stats): boolean;
-    /**
-     * @return [Boolean] True if this item is a file.
-     */
-    isFile(): boolean;
-    /**
-     * @return [Boolean] True if this item is a directory.
-     */
-    isDirectory(): boolean;
+    update(stats: Readonly<Stats>): boolean;
 }

package/dist/inode.js

@@ -1,54 +1,125 @@
+import { S_IFMT } from './emulation/constants.js';
 import { Stats, FileType } from './stats.js';
-import { decode, encode } from './utils.js';
+var Offset;
+(function (Offset) {
+    Offset[Offset["ino"] = 0] = "ino";
+    Offset[Offset["size"] = 8] = "size";
+    Offset[Offset["mode"] = 12] = "mode";
+    Offset[Offset["nlink"] = 14] = "nlink";
+    Offset[Offset["uid"] = 18] = "uid";
+    Offset[Offset["gid"] = 22] = "gid";
+    Offset[Offset["atime"] = 26] = "atime";
+    Offset[Offset["mtime"] = 34] = "mtime";
+    Offset[Offset["ctime"] = 42] = "ctime";
+})(Offset || (Offset = {}));
+export const size_max = 2 ** 32 - 1;
+/**
+ * @internal
+ */
+export const rootIno = 0n;
+/**
+ * Generates a random 32 bit integer, then converts to a hex string
+ */
+function _random() {
+    return Math.round(Math.random() * 2 ** 32).toString(16);
+}
+/**
+ * Generate 4 random bits at a time
+ *
+ * @internal
+ */
+export function randomIno() {
+    return BigInt('0x' + _random() + _random());
+}
 /**
  * Generic inode definition that can easily be serialized.
  */
-export default class Inode {
-    /**
-     * Converts the buffer into an Inode.
-     */
-    static Deserialize(data) {
-        const view = new DataView('buffer' in data ? data.buffer : data);
-        return new Inode(decode(view.buffer.slice(38)), view.getUint32(0, true), view.getUint16(4, true), view.getFloat64(6, true), view.getFloat64(14, true), view.getFloat64(22, true), view.getUint32(30, true), view.getUint32(34, true));
-    }
-    constructor(id, size, mode, atime, mtime, ctime, uid, gid) {
-        this.id = id;
-        this.size = size;
-        this.mode = mode;
-        this.atime = atime;
-        this.mtime = mtime;
-        this.ctime = ctime;
-        this.uid = uid;
-        this.gid = gid;
+export class Inode {
+    get data() {
+        return new Uint8Array(this.buffer);
+    }
+    constructor(buffer) {
+        const setDefaults = !buffer;
+        buffer ?? (buffer = new ArrayBuffer(50));
+        this.view = new DataView(buffer);
+        this.buffer = buffer;
+        if (!setDefaults) {
+            return;
+        }
+        // set defaults on a fresh inode
+        this.ino = randomIno();
+        this.nlink = 1;
+        this.size = 4096;
+        const now = Date.now();
+        this.atime = now;
+        this.mtime = now;
+        this.ctime = now;
+    }
+    get ino() {
+        return this.view.getBigUint64(Offset.ino, true);
+    }
+    set ino(value) {
+        this.view.setBigUint64(Offset.ino, value, true);
+    }
+    get size() {
+        return this.view.getUint32(Offset.size, true);
+    }
+    set size(value) {
+        this.view.setUint32(Offset.size, value, true);
+    }
+    get mode() {
+        return this.view.getUint16(Offset.mode, true);
+    }
+    set mode(value) {
+        this.view.setUint16(Offset.mode, value, true);
+    }
+    get nlink() {
+        return this.view.getUint32(Offset.nlink, true);
+    }
+    set nlink(value) {
+        this.view.setUint32(Offset.nlink, value, true);
+    }
+    get uid() {
+        return this.view.getUint32(Offset.uid, true);
+    }
+    set uid(value) {
+        this.view.setUint32(Offset.uid, value, true);
+    }
+    get gid() {
+        return this.view.getUint32(Offset.gid, true);
+    }
+    set gid(value) {
+        this.view.setUint32(Offset.gid, value, true);
+    }
+    get atime() {
+        return this.view.getFloat64(Offset.atime, true);
+    }
+    set atime(value) {
+        this.view.setFloat64(Offset.atime, value, true);
+    }
+    get mtime() {
+        return this.view.getFloat64(Offset.mtime, true);
+    }
+    set mtime(value) {
+        this.view.setFloat64(Offset.mtime, value, true);
+    }
+    get ctime() {
+        return this.view.getFloat64(Offset.ctime, true);
+    }
+    set ctime(value) {
+        this.view.setFloat64(Offset.ctime, value, true);
     }
     /**
      * Handy function that converts the Inode to a Node Stats object.
      */
     toStats() {
-        return new Stats((this.mode & 0xf000) === FileType.DIRECTORY ? FileType.DIRECTORY : FileType.FILE, this.size, this.mode, this.atime, this.mtime, this.ctime, this.uid, this.gid);
+        return new Stats((this.mode & S_IFMT) === FileType.DIRECTORY ? FileType.DIRECTORY : FileType.FILE, this.size, this.mode, this.atime, this.mtime, this.ctime, this.uid, this.gid);
     }
     /**
      * Get the size of this Inode, in bytes.
      */
-    getSize() {
-        // ASSUMPTION: ID is 1 byte per char.
-        return 38 + this.id.length;
-    }
-    /**
-     * Writes the inode into the start of the buffer.
-     */
-    serialize(data = new Uint8Array(this.getSize())) {
-        const view = new DataView('buffer' in data ? data.buffer : data);
-        view.setUint32(0, this.size, true);
-        view.setUint16(4, this.mode, true);
-        view.setFloat64(6, this.atime, true);
-        view.setFloat64(14, this.mtime, true);
-        view.setFloat64(22, this.ctime, true);
-        view.setUint32(30, this.uid, true);
-        view.setUint32(34, this.gid, true);
-        const buffer = new Uint8Array(view.buffer);
-        buffer.set(encode(this.id), 38);
-        return buffer;
+    sizeof() {
+        return this.buffer.byteLength;
     }
     /**
      * Updates the Inode using information from the stats object. Used by file
@@ -70,19 +141,8 @@ export default class Inode {
             this.mode = stats.mode;
             hasChanged = true;
         }
-        const atimeMs = stats.atime.getTime();
-        if (this.atime !== atimeMs) {
-            this.atime = atimeMs;
-            hasChanged = true;
-        }
-        const mtimeMs = stats.mtime.getTime();
-        if (this.mtime !== mtimeMs) {
-            this.mtime = mtimeMs;
-            hasChanged = true;
-        }
-        const ctimeMs = stats.ctime.getTime();
-        if (this.ctime !== ctimeMs) {
-            this.ctime = ctimeMs;
+        if (this.nlink !== stats.nlink) {
+            this.nlink = stats.nlink;
             hasChanged = true;
         }
         if (this.uid !== stats.uid) {
@@ -93,20 +153,18 @@ export default class Inode {
             this.uid = stats.uid;
             hasChanged = true;
         }
+        if (this.atime !== stats.atimeMs) {
+            this.atime = stats.atimeMs;
+            hasChanged = true;
+        }
+        if (this.mtime !== stats.mtimeMs) {
+            this.mtime = stats.mtimeMs;
+            hasChanged = true;
+        }
+        if (this.ctime !== stats.ctimeMs) {
+            this.ctime = stats.ctimeMs;
+            hasChanged = true;
+        }
         return hasChanged;
     }
-    // XXX: Copied from Stats. Should reconcile these two into something more
-    //      compact.
-    /**
-     * @return [Boolean] True if this item is a file.
-     */
-    isFile() {
-        return (this.mode & 0xf000) === FileType.FILE;
-    }
-    /**
-     * @return [Boolean] True if this item is a directory.
-     */
-    isDirectory() {
-        return (this.mode & 0xf000) === FileType.DIRECTORY;
-    }
 }

package/dist/stats.d.ts

@@ -13,7 +13,6 @@ export declare enum FileType {
  * Common code used by both Stats and BigIntStats
  */
 export declare abstract class StatsCommon<T extends number | bigint> implements Node.StatsBase<T> {
-    static Deserialize(data: ArrayBufferLike | ArrayBufferView): StatsCommon<number> | StatsCommon<bigint>;
     protected abstract _isBigint: boolean;
     protected get _typename(): string;
     protected get _typename_inverse(): string;
@@ -51,16 +50,20 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
     /**
      * Some file systems stash data on stats objects.
      */
-    fileData: Uint8Array | null;
+    fileData?: Uint8Array;
     atimeMs: T;
-    mtimeMs: T;
-    ctimeMs: T;
-    birthtimeMs: T;
-    size: T;
     get atime(): Date;
+    set atime(value: Date);
+    mtimeMs: T;
     get mtime(): Date;
+    set mtime(value: Date);
+    ctimeMs: T;
     get ctime(): Date;
+    set ctime(value: Date);
+    birthtimeMs: T;
     get birthtime(): Date;
+    set birthtime(value: Date);
+    size: T;
     /**
      * Provides information about a particular entry in the file system.
      * @param itemType Type of the item (FILE, DIRECTORY, SYMLINK, or SOCKET)
@@ -75,45 +78,48 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
      * @param birthtimeMs time of file creation, in milliseconds since epoch
      */
     constructor(itemType?: FileType, size?: number | bigint, mode?: number | bigint, atimeMs?: number | bigint, mtimeMs?: number | bigint, ctimeMs?: number | bigint, uid?: number | bigint, gid?: number | bigint, birthtimeMs?: number | bigint);
-    abstract serialize(): Uint8Array;
     /**
-     * @return [Boolean] True if this item is a file.
+     * @returns true if this item is a file.
      */
     isFile(): boolean;
     /**
-     * @return [Boolean] True if this item is a directory.
+     * @returns True if this item is a directory.
      */
     isDirectory(): boolean;
     /**
-     * @return [Boolean] True if this item is a symbolic link (only valid through lstat)
+     * @returns true if this item is a symbolic link
      */
     isSymbolicLink(): boolean;
+    isSocket(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isFIFO(): boolean;
     /**
      * Checks if a given user/group has access to this item
      * @param mode The request access as 4 bits (unused, read, write, execute)
      * @param uid The requesting UID
      * @param gid The requesting GID
-     * @returns [Boolean] True if the request has access, false if the request does not
+     * @returns True if the request has access, false if the request does not
+     * @internal
      */
     hasAccess(mode: number, cred: Cred): boolean;
     /**
      * Convert the current stats object into a cred object
+     * @internal
      */
     getCred(uid?: number, gid?: number): Cred;
     /**
      * Change the mode of the file. We use this helper function to prevent messing
      * up the type of the file, which is encoded in mode.
+     * @internal
      */
     chmod(mode: number): void;
     /**
      * Change the owner user/group of the file.
      * This function makes sure it is a valid UID/GID (that is, a 32 unsigned int)
+     * @internal
      */
     chown(uid: number | bigint, gid: number | bigint): void;
-    isSocket(): boolean;
-    isBlockDevice(): boolean;
-    isCharacterDevice(): boolean;
-    isFIFO(): boolean;
 }
 /**
  * Implementation of Node's `Stats`.
@@ -128,8 +134,6 @@ export declare class Stats extends StatsCommon<number> implements Node.Stats {
      * Clones the stats object.
      */
     static clone(s: Stats): Stats;
-    static Deserialize(data: ArrayBufferLike | ArrayBufferView): Stats;
-    serialize(): Uint8Array;
 }
 /**
  * Stats with bigint
@@ -145,6 +149,4 @@ export declare class BigIntStats extends StatsCommon<bigint> implements Node.Big
      * Clone a stats object.
      */
     static clone(s: BigIntStats | Stats): BigIntStats;
-    static Deserialize(data: ArrayBufferLike | ArrayBufferView): Stats;
-    serialize(): Uint8Array;
 }

package/dist/stats.js

@@ -13,10 +13,6 @@ export var FileType;
  * Common code used by both Stats and BigIntStats
  */
 export class StatsCommon {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    static Deserialize(data) {
-        throw new ReferenceError('Called static abstract method: StatsCommon.Deserialize()');
-    }
     get _typename() {
         return this._isBigint ? 'bigint' : 'number';
     }
@@ -29,15 +25,27 @@ export class StatsCommon {
     get atime() {
         return new Date(Number(this.atimeMs));
     }
+    set atime(value) {
+        this.atimeMs = this._convert(value.getTime());
+    }
     get mtime() {
         return new Date(Number(this.mtimeMs));
     }
+    set mtime(value) {
+        this.mtimeMs = this._convert(value.getTime());
+    }
     get ctime() {
         return new Date(Number(this.ctimeMs));
     }
+    set ctime(value) {
+        this.ctimeMs = this._convert(value.getTime());
+    }
     get birthtime() {
         return new Date(Number(this.birthtimeMs));
     }
+    set birthtime(value) {
+        this.birthtimeMs = this._convert(value.getTime());
+    }
     /**
      * Provides information about a particular entry in the file system.
      * @param itemType Type of the item (FILE, DIRECTORY, SYMLINK, or SOCKET)
@@ -108,36 +116,49 @@ export class StatsCommon {
         }
         // 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.
+        // 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));
         }
     }
     /**
-     * @return [Boolean] True if this item is a file.
+     * @returns true if this item is a file.
      */
     isFile() {
         return (this.mode & S_IFMT) === S_IFREG;
     }
     /**
-     * @return [Boolean] True if this item is a directory.
+     * @returns True if this item is a directory.
      */
     isDirectory() {
         return (this.mode & S_IFMT) === S_IFDIR;
     }
     /**
-     * @return [Boolean] True if this item is a symbolic link (only valid through lstat)
+     * @returns true if this item is a symbolic link
      */
     isSymbolicLink() {
         return (this.mode & S_IFMT) === S_IFLNK;
     }
+    // Currently unsupported
+    isSocket() {
+        return false;
+    }
+    isBlockDevice() {
+        return false;
+    }
+    isCharacterDevice() {
+        return false;
+    }
+    isFIFO() {
+        return false;
+    }
     /**
      * Checks if a given user/group has access to this item
      * @param mode The request access as 4 bits (unused, read, write, execute)
      * @param uid The requesting UID
      * @param gid The requesting GID
-     * @returns [Boolean] True if the request has access, false if the request does not
+     * @returns True if the request has access, false if the request does not
+     * @internal
      */
     hasAccess(mode, cred) {
         if (cred.euid === 0 || cred.egid === 0) {
@@ -159,12 +180,13 @@ export class StatsCommon {
         /*
         Result = 0b0xxx (read, write, execute)
         If any bits are set that means the request does not have that permission.
-    */
+        */
         const result = uMode & gMode & wMode;
         return !result;
     }
     /**
      * Convert the current stats object into a cred object
+     * @internal
      */
     getCred(uid = Number(this.uid), gid = Number(this.gid)) {
         return new Cred(uid, gid, Number(this.uid), Number(this.gid), uid, gid);
@@ -172,6 +194,7 @@ export class StatsCommon {
     /**
      * Change the mode of the file. We use this helper function to prevent messing
      * up the type of the file, which is encoded in mode.
+     * @internal
      */
     chmod(mode) {
         this.mode = this._convert((this.mode & S_IFMT) | mode);
@@ -179,6 +202,7 @@ export class StatsCommon {
     /**
      * Change the owner user/group of the file.
      * This function makes sure it is a valid UID/GID (that is, a 32 unsigned int)
+     * @internal
      */
     chown(uid, gid) {
         uid = Number(uid);
@@ -190,19 +214,6 @@ export class StatsCommon {
             this.gid = this._convert(gid);
         }
     }
-    // We don't support the following types of files.
-    isSocket() {
-        return false;
-    }
-    isBlockDevice() {
-        return false;
-    }
-    isCharacterDevice() {
-        return false;
-    }
-    isFIFO() {
-        return false;
-    }
 }
 /**
  * Implementation of Node's `Stats`.
@@ -222,22 +233,6 @@ export class Stats extends StatsCommon {
     static clone(s) {
         return new Stats(s.mode & S_IFMT, s.size, s.mode & ~S_IFMT, s.atimeMs, s.mtimeMs, s.ctimeMs, s.uid, s.gid, s.birthtimeMs);
     }
-    static Deserialize(data) {
-        const view = new DataView('buffer' in data ? data.buffer : data);
-        const size = view.getUint32(0, true), mode = view.getUint32(4, true), atime = view.getFloat64(8, true), mtime = view.getFloat64(16, true), ctime = view.getFloat64(24, true), uid = view.getUint32(32, true), gid = view.getUint32(36, true);
-        return new Stats(mode & S_IFMT, size, mode & ~S_IFMT, atime, mtime, ctime, uid, gid);
-    }
-    serialize() {
-        const data = new Uint8Array(32), view = new DataView(data.buffer);
-        view.setUint32(0, this.size, true);
-        view.setUint32(4, this.mode, true);
-        view.setFloat64(8, this.atime.getTime(), true);
-        view.setFloat64(16, this.mtime.getTime(), true);
-        view.setFloat64(24, this.ctime.getTime(), true);
-        view.setUint32(32, this.uid, true);
-        view.setUint32(36, this.gid, true);
-        return data;
-    }
 }
 Stats;
 /**
@@ -255,21 +250,5 @@ export class BigIntStats extends StatsCommon {
     static clone(s) {
         return new BigIntStats(Number(s.mode) & S_IFMT, BigInt(s.size), BigInt(s.mode) & BigInt(~S_IFMT), BigInt(s.atimeMs), BigInt(s.mtimeMs), BigInt(s.ctimeMs), BigInt(s.uid), BigInt(s.gid), BigInt(s.birthtimeMs));
     }
-    static Deserialize(data) {
-        const view = new DataView('buffer' in data ? data.buffer : data);
-        const size = view.getBigUint64(0, true), mode = view.getBigUint64(4, true), atime = view.getFloat64(8, true), mtime = view.getFloat64(16, true), ctime = view.getFloat64(24, true), uid = view.getBigUint64(32, true), gid = view.getBigUint64(36, true);
-        return new Stats(Number(mode) & S_IFMT, size, mode & BigInt(~S_IFMT), atime, mtime, ctime, uid, gid);
-    }
-    serialize() {
-        const data = new Uint8Array(32), view = new DataView(data.buffer);
-        view.setBigUint64(0, this.size, true);
-        view.setBigUint64(4, this.mode, true);
-        view.setFloat64(8, this.atime.getTime(), true);
-        view.setFloat64(16, this.mtime.getTime(), true);
-        view.setFloat64(24, this.ctime.getTime(), true);
-        view.setBigUint64(32, this.uid, true);
-        view.setBigUint64(36, this.gid, true);
-        return data;
-    }
 }
 BigIntStats;

package/dist/utils.d.ts

@@ -1,20 +1,28 @@
 /// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 /**
  * Grab bag of utility functions used across the code.
  */
 import { FileSystem } from './filesystem.js';
 import { Cred } from './cred.js';
-import type { BaseBackendConstructor } from './backends/backend.js';
+import type { TextDecoder as _TextDecoder, TextEncoder as _TextEncoder } from 'node:util';
+declare global {
+    function setImmediate(callback: () => unknown): void;
+    function atob(data: string): string;
+    function btoa(data: string): string;
+    const TextDecoder: typeof _TextDecoder;
+    const TextEncoder: typeof _TextEncoder;
+}
 /**
  * Synchronous recursive makedir.
  * @internal
  */
 export declare function mkdirpSync(p: string, mode: number, cred: Cred, fs: FileSystem): void;
 /**
- * Checks that the given options object is valid for the file system options.
+ * Calculates levenshtein distance.
  * @internal
  */
-export declare function checkOptions(backend: BaseBackendConstructor, opts: object): Promise<void>;
+export declare function levenshtein(a: string, b: string): number;
 /** Waits n ms.  */
 export declare function wait(ms: number): Promise<void>;
 /**
@@ -25,15 +33,24 @@ export declare function toPromise(fn: (...fnArgs: unknown[]) => unknown): (...ar
 /**
  * @internal
  */
-export declare const setImmediate: (callback: () => unknown) => void;
+export declare const setImmediate: typeof globalThis.setImmediate | ((cb: any) => NodeJS.Timeout);
+/**
+ * Encodes a string into a buffer
+ * @internal
+ */
+export declare function encode(input: string, encoding?: BufferEncoding): Uint8Array;
+/**
+ * Decodes a string from a buffer
+ * @internal
+ */
+export declare function decode(input?: Uint8Array, encoding?: BufferEncoding): string;
 /**
+ * Decodes a directory listing
  * @internal
  */
-export declare const ROOT_NODE_ID: string;
-export declare function encode(input: string, encoding?: string): Uint8Array;
-export declare function decode(input?: NodeJS.ArrayBufferView | ArrayBuffer, encoding?: string): string;
+export declare function decodeDirListing(data: Uint8Array): Record<string, bigint>;
 /**
- * Generates a random ID.
+ * Encodes a directory listing
  * @internal
  */
-export declare function randomUUID(): string;
+export declare function encodeDirListing(data: Record<string, bigint>): Uint8Array;