@zenfs/core 0.0.12 → 0.2.0

package/dist/index.js

@@ -1,20 +1,11 @@
 /**
  * ZenFS's main module. This is exposed in the browser via the ZenFS global.
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import fs from './emulation/fs.js';
+import * as fs from './emulation/index.js';
 import { FileSystem } from './filesystem.js';
 import { backends } from './backends/index.js';
-import { ErrorCode, ApiError } from './ApiError.js';
 import { Cred } from './cred.js';
+import { isBackend, resolveBackendConfig } from './backends/backend.js';
 import { setCred } from './emulation/shared.js';
 /**
  * Initializes ZenFS with the given file systems.
@@ -23,76 +14,32 @@ export function initialize(mounts, uid = 0, gid = 0) {
     setCred(new Cred(uid, gid, uid, gid, uid, gid));
     return fs.initialize(mounts);
 }
-function _configure(config) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if ('fs' in config || config instanceof FileSystem) {
-            // single FS
-            config = { '/': config };
-        }
-        for (let [point, value] of Object.entries(config)) {
-            if (typeof value == 'number') {
-                //should never happen
-                continue;
-            }
-            point = point.toString(); // so linting stops complaining that point should be declared with const, which can't be done since value is assigned to
-            if (value instanceof FileSystem) {
-                continue;
-            }
-            if (typeof value == 'string') {
-                value = { fs: value };
-            }
-            config[point] = yield getFileSystem(value);
-        }
-        return initialize(config);
-    });
-}
-export function configure(config, cb) {
-    // Promise version
-    if (typeof cb != 'function') {
-        return _configure(config);
+/**
+ * Creates filesystems with the given configuration, and initializes ZenFS with it.
+ * See the Configuration type for more info on the configuration object.
+ */
+export async function configure(config) {
+    if ('backend' in config || config instanceof FileSystem) {
+        // single FS
+        config = { '/': config };
     }
-    // Callback version
-    _configure(config)
-        .then(() => cb())
-        .catch(err => cb(err));
-    return;
-}
-function _getFileSystem({ fs: fsName, options = {} }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!fsName) {
-            throw new ApiError(ErrorCode.EPERM, 'Missing "fs" property on configuration object.');
+    for (let [point, value] of Object.entries(config)) {
+        if (typeof value == 'number') {
+            //should never happen
+            continue;
         }
-        if (typeof options !== 'object' || options === null) {
-            throw new ApiError(ErrorCode.EINVAL, 'Invalid "options" property on configuration object.');
+        if (value instanceof FileSystem) {
+            continue;
         }
-        const props = Object.keys(options).filter(k => k != 'fs');
-        for (const prop of props) {
-            const opt = options[prop];
-            if (opt === null || typeof opt !== 'object' || !('fs' in opt)) {
-                continue;
-            }
-            const fs = yield _getFileSystem(opt);
-            options[prop] = fs;
+        if (typeof value == 'string') {
+            value = { backend: backends[value] };
         }
-        const fsc = backends[fsName];
-        if (!fsc) {
-            throw new ApiError(ErrorCode.EPERM, `File system ${fsName} is not available in ZenFS.`);
+        if (isBackend(value)) {
+            value = { backend: value };
         }
-        else {
-            return fsc.Create(options);
-        }
-    });
-}
-export function getFileSystem(config, cb) {
-    // Promise version
-    if (typeof cb != 'function') {
-        return _getFileSystem(config);
+        config[point] = await resolveBackendConfig(value);
     }
-    // Callback version
-    _getFileSystem(config)
-        .then(fs => cb(null, fs))
-        .catch(err => cb(err));
-    return;
+    return initialize(config);
 }
 export * from './backends/index.js';
 export * from './backends/AsyncStore.js';

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

@@ -1,5 +1,5 @@
 /// <reference types="node" resolution-mode="require"/>
-import type { StatsBase } from 'fs';
+import type * as Node from 'fs';
 import { Cred } from './cred.js';
 /**
  * Indicates the type of the given file. Applied to 'mode'.
@@ -10,37 +10,60 @@ export declare enum FileType {
     SYMLINK
 }
 /**
- * Implementation of Node's `Stats`.
- *
- * 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
+ * Common code used by both Stats and BigIntStats
  */
-export declare class Stats implements StatsBase<number> {
-    static Deserialize(data: ArrayBufferLike | ArrayBufferView): Stats;
+export declare abstract class StatsCommon<T extends number | bigint> implements Node.StatsBase<T> {
+    protected abstract _isBigint: boolean;
+    protected get _typename(): string;
+    protected get _typename_inverse(): string;
+    protected _convert(arg: number | bigint | string | boolean): T;
+    blocks: T;
+    mode: T;
     /**
-     * Clones the stats object.
+     * ID of device containing file
      */
-    static clone(s: Stats): Stats;
-    blocks: number;
-    mode: number;
-    dev: number;
-    ino: number;
-    rdev: number;
-    nlink: number;
-    blksize: number;
-    uid: number;
-    gid: number;
-    fileData: Uint8Array | null;
-    atimeMs: number;
-    mtimeMs: number;
-    ctimeMs: number;
-    birthtimeMs: number;
-    size: number;
+    dev: T;
+    /**
+     * inode number
+     */
+    ino: T;
+    /**
+     * device ID (if special file)
+     */
+    rdev: T;
+    /**
+     * number of hard links
+     */
+    nlink: T;
+    /**
+     * blocksize for file system I/O
+     */
+    blksize: T;
+    /**
+     * user ID of owner
+     */
+    uid: T;
+    /**
+     * group ID of owner
+     */
+    gid: T;
+    /**
+     * Some file systems stash data on stats objects.
+     */
+    fileData?: Uint8Array;
+    atimeMs: 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)
@@ -54,44 +77,76 @@ export declare class Stats implements StatsBase<number> {
      * @param gid the id of the group that owns the file
      * @param birthtimeMs time of file creation, in milliseconds since epoch
      */
-    constructor(itemType: FileType, size: number, mode?: number, atimeMs?: number, mtimeMs?: number, ctimeMs?: number, uid?: number, gid?: number, birthtimeMs?: number);
-    serialize(): Uint8Array;
+    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);
     /**
-     * @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, gid: number): void;
-    isSocket(): boolean;
-    isBlockDevice(): boolean;
-    isCharacterDevice(): boolean;
-    isFIFO(): boolean;
+    chown(uid: number | bigint, gid: number | bigint): void;
+}
+/**
+ * Implementation of Node's `Stats`.
+ *
+ * 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
+ */
+export declare class Stats extends StatsCommon<number> implements Node.Stats {
+    protected _isBigint: boolean;
+    /**
+     * Clones the stats object.
+     */
+    static clone(s: Stats): Stats;
+}
+/**
+ * Stats with bigint
+ * @todo Implement with bigint instead of wrapping Stats
+ */
+export declare class BigIntStats extends StatsCommon<bigint> implements Node.BigIntStats {
+    protected _isBigint: boolean;
+    atimeNs: bigint;
+    mtimeNs: bigint;
+    ctimeNs: bigint;
+    birthtimeNs: bigint;
+    /**
+     * Clone a stats object.
+     */
+    static clone(s: BigIntStats | Stats): BigIntStats;
 }