@zenfs/core 1.8.8 → 1.9.1

package/dist/{backends/store → internal}/file_index.d.ts

@@ -13,8 +13,7 @@ export declare const version = 1;
  * An index of files
  * @internal
  */
-export declare class Index extends Map<string, Readonly<Inode>> {
-    protected _directories?: Map<string, Record<string, number>>;
+export declare class Index extends Map<string, Inode> {
     /**
      * Converts the index to JSON
      */
@@ -23,7 +22,18 @@ export declare class Index extends Map<string, Readonly<Inode>> {
      * Converts the index to a string
      */
     toString(): string;
+    pathOf(id: number): string | undefined;
+    getByID(id: number): Inode | undefined;
+    entryByID(id: number): {
+        path: string;
+        inode: Inode;
+    } | undefined;
     directoryEntries(path: string): Record<string, number>;
+    /**
+     * Get the next available ID in the index
+     * @internal
+     */
+    _alloc(): number;
     /**
      * Gets a list of entries for each directory in the index.
      * Use
@@ -32,7 +42,7 @@ export declare class Index extends Map<string, Readonly<Inode>> {
     /**
      * Loads the index from JSON data
      */
-    fromJSON(json: IndexData): void;
+    fromJSON(json: IndexData): this;
     /**
      * Parses an index from a string
      */

package/dist/{backends/store → internal}/file_index.js

@@ -1,8 +1,8 @@
 /* Note: this file is named file_index.ts because Typescript has special behavior regarding index.ts which can't be disabled. */
 import { isJSON, randomInt } from 'utilium';
-import { Errno, ErrnoError } from '../../error.js';
-import { S_IFDIR, S_IFMT, size_max } from '../../vfs/constants.js';
-import { basename, dirname } from '../../vfs/path.js';
+import { S_IFDIR, S_IFMT, size_max } from '../vfs/constants.js';
+import { basename, dirname } from '../vfs/path.js';
+import { Errno, ErrnoError } from './error.js';
 import { Inode } from './inode.js';
 export const version = 1;
 /**
@@ -25,6 +25,22 @@ export class Index extends Map {
     toString() {
         return JSON.stringify(this.toJSON());
     }
+    pathOf(id) {
+        for (const [path, inode] of this) {
+            if (inode.ino == id || inode.data == id)
+                return path;
+        }
+    }
+    getByID(id) {
+        var _a;
+        return (_a = this.entryByID(id)) === null || _a === void 0 ? void 0 : _a.inode;
+    }
+    entryByID(id) {
+        for (const [path, inode] of this) {
+            if (inode.ino == id || inode.data == id)
+                return { path, inode };
+        }
+    }
     directoryEntries(path) {
         const node = this.get(path);
         if (!node)
@@ -39,6 +55,13 @@ export class Index extends Map {
         }
         return entries;
     }
+    /**
+     * Get the next available ID in the index
+     * @internal
+     */
+    _alloc() {
+        return Math.max(...[...this.values()].flatMap(i => [i.ino, i.data])) + 1;
+    }
     /**
      * Gets a list of entries for each directory in the index.
      * Use
@@ -72,14 +95,14 @@ export class Index extends Map {
                 node.ino = 0;
             this.set(path, new Inode(node));
         }
+        return this;
     }
     /**
      * Parses an index from a string
      */
     static parse(data) {
-        if (!isJSON(data)) {
+        if (!isJSON(data))
             throw new ErrnoError(Errno.EINVAL, 'Invalid JSON');
-        }
         const json = JSON.parse(data);
         const index = new Index();
         index.fromJSON(json);

package/dist/{filesystem.d.ts → internal/filesystem.d.ts}

@@ -1,29 +1,51 @@
+import type { ConstMap } from 'utilium';
+import type { Stats, StatsLike } from '../stats.js';
 import type { File } from './file.js';
-import type { Stats, StatsLike } from './stats.js';
-export type FileContents = ArrayBufferView | string;
+/**
+ * Usage information about a file system
+ */
+export interface UsageInfo {
+    /**
+     * The total space
+     */
+    totalSpace: number;
+    /**
+     * The available space
+     */
+    freeSpace: number;
+    /**
+     * The optimal block size to use with the file system
+     * @default 4096
+     */
+    blockSize?: number;
+    /**
+     * Total number of nodes available
+     */
+    totalNodes?: number;
+    /**
+     * Number of free nodes available
+     */
+    freeNodes?: number;
+}
 /**
  * Metadata about a FileSystem
+ * @deprecated
  */
-export interface FileSystemMetadata {
+export interface FileSystemMetadata extends UsageInfo {
     /**
      * The name of the FS
+     * @deprecated Use `FileSystem#name`
      */
     name: string;
     /**
      * Whether the FS is readonly or not
+     * @deprecated Use `FileSystem#attributes
      */
     readonly: boolean;
-    /**
-     * The total space
-     */
-    totalSpace: number;
-    /**
-     * The available space
-     */
-    freeSpace: number;
     /**
      * If set, disables File from using a resizable array buffer.
      * @default false
+     * @deprecated Use `FileSystem#attributes`
      */
     noResizableBuffers: boolean;
     /**
@@ -31,32 +53,45 @@ export interface FileSystemMetadata {
      * This means *sync operations will not work*.
      * It has no affect on sync file systems.
      * @default false
+     * @deprecated Use `FileSystem#attributes
      */
     noAsyncCache: boolean;
     /**
-     * The optimal block size to use with the file system
-     * @default 4096
+     * The type of the FS
      */
-    blockSize?: number;
+    type: number;
     /**
-     * Total number of (file) nodes available
+     * Various features the file system supports.
+     * @deprecated Use `FileSystem#attributes`
      */
-    totalNodes?: number;
-    /**
-     * Number of free (file) nodes available
+    features?: unknown[];
+}
+/**
+ * Attributes that control how the file system interacts with the VFS.
+ * No options are set by default.
+ */
+export type FileSystemAttributes = {
+    /** The FS supports setuid and setgid when creating files and directories. */
+    setid: void;
+    /** If set, disables `PreloadFile` from using a resizable array buffer. */
+    no_buffer_resize: void;
+    /**
+     * If set disables async file systems from preloading their contents.
+     * This means *sync operations will not work* (unless the contents are cached)
+     * It has no affect on sync file systems.
      */
-    freeNodes?: number;
+    no_async: void;
     /**
-     * The type of the FS
+     * Currently unused. In the future, this will disable caching.
+     * Not recommended due to performance impact.
      */
-    type: number;
+    no_cache: void;
     /**
-     * Various features the file system supports.
-     * These are used by the VFS for optimizations.
-     * - setid:	The FS supports setuid and setgid when creating files and directories.
+     * If set, the file system should not be written to.
+     * This should be set for read-only file systems.
      */
-    features?: ('setid' | '')[];
-}
+    no_write: void;
+};
 /**
  * Options used when creating files and directories.
  * This weird naming and such is to preserve backward compatibility.
@@ -96,16 +131,48 @@ export interface PureCreationOptions extends CreationOptions {
  */
 export declare abstract class FileSystem {
     /**
-     * Get metadata about the current file system
+     * A unique ID for this kind of file system.
+     * Currently unused internally, but could be used for partition tables or something
      */
-    metadata(): FileSystemMetadata;
+    readonly id: number;
+    /**
+     * The name for this file system.
+     * For example, tmpfs for an in memory one
+     */
+    readonly name: string;
+    label?: string;
     /**
-     * Whether the sync cache should be disabled.
-     * Only affects async things.
+     * The last place this file system was mounted
      * @internal @protected
      */
-    _disableSync?: boolean;
-    constructor(...args: any[]);
+    _mountPoint?: string;
+    /**
+     * @see FileSystemAttributes
+     */
+    readonly attributes: ConstMap<FileSystemAttributes>;
+    constructor(
+    /**
+     * A unique ID for this kind of file system.
+     * Currently unused internally, but could be used for partition tables or something
+     */
+    id: number, 
+    /**
+     * The name for this file system.
+     * For example, tmpfs for an in memory one
+     */
+    name: string);
+    toString(): string;
+    /**
+     * Default implementation.
+     * @todo Implement
+     * @experimental
+     */
+    usage(): UsageInfo;
+    /**
+     * Get metadata about the current file system
+     * @deprecated
+     */
+    metadata(): FileSystemMetadata;
     ready(): Promise<void>;
     abstract rename(oldPath: string, newPath: string): Promise<void>;
     abstract renameSync(oldPath: string, newPath: string): void;

package/dist/internal/filesystem.js

@@ -0,0 +1,83 @@
+/**
+ * Provides a consistent and easy to use internal API.
+ * Default implementations for `exists` and `existsSync` are included.
+ * If you are extending this class, note that every path is an absolute path and all arguments are present.
+ * @internal
+ */
+export class FileSystem {
+    constructor(
+    /**
+     * A unique ID for this kind of file system.
+     * Currently unused internally, but could be used for partition tables or something
+     */
+    id, 
+    /**
+     * The name for this file system.
+     * For example, tmpfs for an in memory one
+     */
+    name) {
+        this.id = id;
+        this.name = name;
+        /**
+         * @see FileSystemAttributes
+         */
+        this.attributes = new Map();
+    }
+    toString() {
+        var _a;
+        return `${this.name} ${(_a = this.label) !== null && _a !== void 0 ? _a : ''} (${this._mountPoint ? 'mounted on ' + this._mountPoint : 'unmounted'})`;
+    }
+    /**
+     * Default implementation.
+     * @todo Implement
+     * @experimental
+     */
+    usage() {
+        return {
+            totalSpace: 0,
+            freeSpace: 0,
+        };
+    }
+    /* node:coverage disable */
+    /**
+     * Get metadata about the current file system
+     * @deprecated
+     */
+    metadata() {
+        return {
+            ...this.usage(),
+            name: this.name,
+            readonly: this.attributes.has('no_write'),
+            noResizableBuffers: this.attributes.has('no_buffer_resize'),
+            noAsyncCache: this.attributes.has('no_async'),
+            features: Array.from(this.attributes.keys()),
+            type: this.id,
+        };
+    }
+    /* node:coverage enable */
+    async ready() { }
+    /**
+     * Test whether or not `path` exists.
+     */
+    async exists(path) {
+        try {
+            await this.stat(path);
+            return true;
+        }
+        catch (e) {
+            return e.code != 'ENOENT';
+        }
+    }
+    /**
+     * Test whether or not `path` exists.
+     */
+    existsSync(path) {
+        try {
+            this.statSync(path);
+            return true;
+        }
+        catch (e) {
+            return e.code != 'ENOENT';
+        }
+    }
+}

package/dist/internal/index.d.ts

@@ -0,0 +1,9 @@
+export * from './credentials.js';
+export * from './devices.js';
+export * from './error.js';
+export * from './file_index.js';
+export * from './file.js';
+export * from './filesystem.js';
+export * from './index_fs.js';
+export * from './inode.js';
+export * as log from './log.js';

package/dist/internal/index.js

@@ -0,0 +1,9 @@
+export * from './credentials.js';
+export * from './devices.js';
+export * from './error.js';
+export * from './file_index.js';
+export * from './file.js';
+export * from './filesystem.js';
+export * from './index_fs.js';
+export * from './inode.js';
+export * as log from './log.js';

package/dist/internal/index_fs.d.ts

@@ -0,0 +1,56 @@
+import { Stats } from '../stats.js';
+import { type File } from './file.js';
+import { Index } from './file_index.js';
+import { FileSystem, type CreationOptions, type PureCreationOptions } from './filesystem.js';
+import { Inode, type InodeLike } from './inode.js';
+/**
+ * Uses an `Index` for metadata.
+ */
+export declare abstract class IndexFS extends FileSystem {
+    readonly index: Index;
+    constructor(id: number, name: string, index?: Index);
+    /**
+     * @deprecated
+     */
+    reloadFiles(): never;
+    /**
+     * @deprecated
+     */
+    reloadFilesSync(): never;
+    /**
+     * Finds all the paths in the index that need to be moved for a rename
+     */
+    private pathsForRename;
+    rename(oldPath: string, newPath: string): Promise<void>;
+    renameSync(oldPath: string, newPath: string): void;
+    stat(path: string): Promise<Stats>;
+    statSync(path: string): Stats;
+    openFile(path: string, flag: string): Promise<File>;
+    openFileSync(path: string, flag: string): File;
+    protected _remove(path: string, isUnlink: boolean): void;
+    protected abstract remove(path: string): Promise<void>;
+    protected abstract removeSync(path: string): void;
+    unlink(path: string): Promise<void>;
+    unlinkSync(path: string): void;
+    rmdir(path: string): Promise<void>;
+    rmdirSync(path: string): void;
+    protected create(path: string, options: PureCreationOptions): Inode;
+    createFile(path: string, flag: string, mode: number, options: CreationOptions): Promise<File>;
+    createFileSync(path: string, flag: string, mode: number, options: CreationOptions): File;
+    mkdir(path: string, mode: number, options: CreationOptions): Promise<void>;
+    mkdirSync(path: string, mode: number, options: CreationOptions): void;
+    link(target: string, link: string): Promise<void>;
+    linkSync(target: string, link: string): void;
+    readdir(path: string): Promise<string[]>;
+    readdirSync(path: string): string[];
+    /**
+     * Optional hook for implementations to support updating metadata
+     */
+    protected syncMetadata?(path: string, metadata: Readonly<InodeLike>): Promise<void>;
+    sync(path: string, data?: Uint8Array, stats?: Readonly<InodeLike>): Promise<void>;
+    /**
+     * Optional hook for implementations to support updating metadata
+     */
+    protected syncMetadataSync?(path: string, metadata: Readonly<InodeLike>): void;
+    syncSync(path: string, data?: Uint8Array, stats?: Readonly<InodeLike>): void;
+}

package/dist/internal/index_fs.js

@@ -0,0 +1,188 @@
+/* eslint-disable @typescript-eslint/require-await */
+import { _throw } from 'utilium';
+import { Stats } from '../stats.js';
+import { S_IFDIR, S_IFMT, S_IFREG, S_ISGID, S_ISUID } from '../vfs/constants.js';
+import { dirname, join, relative } from '../vfs/path.js';
+import { ErrnoError } from './error.js';
+import { LazyFile } from './file.js';
+import { Index } from './file_index.js';
+import { FileSystem } from './filesystem.js';
+import { Inode } from './inode.js';
+/**
+ * Uses an `Index` for metadata.
+ */
+export class IndexFS extends FileSystem {
+    constructor(id, name, index = new Index()) {
+        super(id, name);
+        this.index = index;
+    }
+    /* node:coverage disable */
+    /**
+     * @deprecated
+     */
+    reloadFiles() {
+        throw ErrnoError.With('ENOTSUP');
+    }
+    /**
+     * @deprecated
+     */
+    reloadFilesSync() {
+        throw ErrnoError.With('ENOTSUP');
+    }
+    /* node:coverage enable */
+    /**
+     * Finds all the paths in the index that need to be moved for a rename
+     */
+    pathsForRename(oldPath, newPath) {
+        if (newPath === oldPath)
+            return [];
+        if (!this.index.has(oldPath))
+            throw ErrnoError.With('ENOENT', oldPath, 'rename');
+        if ((dirname(newPath) + '/').startsWith(oldPath + '/'))
+            throw ErrnoError.With('EBUSY', dirname(oldPath), 'rename');
+        const toRename = [];
+        for (const [from, inode] of this.index.entries()) {
+            const rel = relative(oldPath, from);
+            if (rel.startsWith('..'))
+                continue;
+            let to = join(newPath, rel);
+            if (to.endsWith('/'))
+                to = to.slice(0, -1);
+            toRename.push({ from, to, inode });
+        }
+        return toRename;
+    }
+    async rename(oldPath, newPath) {
+        for (const { from, to, inode } of this.pathsForRename(oldPath, newPath)) {
+            const data = new Uint8Array(inode.size);
+            await this.read(from, data, 0, inode.size);
+            this.index.delete(from);
+            this.index.set(to, inode);
+            await this.write(to, data, 0);
+        }
+    }
+    renameSync(oldPath, newPath) {
+        for (const { from, to, inode } of this.pathsForRename(oldPath, newPath)) {
+            const data = new Uint8Array(inode.size);
+            this.readSync(from, data, 0, inode.size);
+            this.index.delete(from);
+            this.index.set(to, inode);
+            this.writeSync(to, data, 0);
+        }
+    }
+    async stat(path) {
+        const inode = this.index.get(path);
+        if (!inode)
+            throw ErrnoError.With('ENOENT', path, 'stat');
+        return new Stats(inode);
+    }
+    statSync(path) {
+        const inode = this.index.get(path);
+        if (!inode)
+            throw ErrnoError.With('ENOENT', path, 'stat');
+        return new Stats(inode);
+    }
+    async openFile(path, flag) {
+        var _a;
+        const stats = (_a = this.index.get(path)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', path, 'openFile'));
+        return new LazyFile(this, path, flag, stats);
+    }
+    openFileSync(path, flag) {
+        var _a;
+        const stats = (_a = this.index.get(path)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', path, 'openFile'));
+        return new LazyFile(this, path, flag, stats);
+    }
+    _remove(path, isUnlink) {
+        const syscall = isUnlink ? 'unlink' : 'rmdir';
+        const inode = this.index.get(path);
+        if (!inode)
+            throw ErrnoError.With('ENOENT', path, syscall);
+        const isDir = (inode.mode & S_IFMT) == S_IFDIR;
+        if (!isDir && !isUnlink)
+            throw ErrnoError.With('ENOTDIR', path, syscall);
+        if (isDir && isUnlink)
+            throw ErrnoError.With('EISDIR', path, syscall);
+        this.index.delete(path);
+    }
+    async unlink(path) {
+        this._remove(path, true);
+        await this.remove(path);
+    }
+    unlinkSync(path) {
+        this._remove(path, true);
+        this.removeSync(path);
+    }
+    async rmdir(path) {
+        this._remove(path, false);
+        await this.remove(path);
+    }
+    rmdirSync(path) {
+        this._remove(path, false);
+        this.removeSync(path);
+    }
+    create(path, options) {
+        const syscall = (options.mode & S_IFMT) == S_IFDIR ? 'mkdir' : 'createFile';
+        if (this.index.has(path))
+            throw ErrnoError.With('EEXIST', path, syscall);
+        const parent = this.index.get(dirname(path));
+        if (!parent)
+            throw ErrnoError.With('ENOENT', dirname(path), syscall);
+        const id = this.index._alloc();
+        const inode = new Inode({
+            ino: id,
+            data: id + 1,
+            mode: options.mode,
+            size: 0,
+            uid: parent.mode & S_ISUID ? parent.uid : options.uid,
+            gid: parent.mode & S_ISGID ? parent.gid : options.gid,
+        });
+        this.index.set(path, inode);
+        return inode;
+    }
+    async createFile(path, flag, mode, options) {
+        const node = this.create(path, { mode: mode | S_IFREG, ...options });
+        return new LazyFile(this, path, flag, node.toStats());
+    }
+    createFileSync(path, flag, mode, options) {
+        const node = this.create(path, { mode: mode | S_IFREG, ...options });
+        return new LazyFile(this, path, flag, node.toStats());
+    }
+    async mkdir(path, mode, options) {
+        this.create(path, { mode: mode | S_IFDIR, ...options });
+    }
+    mkdirSync(path, mode, options) {
+        this.create(path, { mode: mode | S_IFDIR, ...options });
+    }
+    link(target, link) {
+        throw ErrnoError.With('ENOSYS', link, 'link');
+    }
+    linkSync(target, link) {
+        throw ErrnoError.With('ENOSYS', link, 'link');
+    }
+    async readdir(path) {
+        return Object.keys(this.index.directoryEntries(path));
+    }
+    readdirSync(path) {
+        return Object.keys(this.index.directoryEntries(path));
+    }
+    async sync(path, data, stats) {
+        var _a;
+        const inode = this.index.get(path);
+        if (!inode)
+            throw ErrnoError.With('ENOENT', path, 'sync');
+        if (inode.update(stats))
+            await ((_a = this.syncMetadata) === null || _a === void 0 ? void 0 : _a.call(this, path, stats));
+        if (data)
+            await this.write(path, data, 0);
+    }
+    syncSync(path, data, stats) {
+        var _a;
+        const inode = this.index.get(path);
+        if (!inode)
+            throw ErrnoError.With('ENOENT', path, 'sync');
+        if (inode.update(stats))
+            (_a = this.syncMetadataSync) === null || _a === void 0 ? void 0 : _a.call(this, path, stats);
+        if (data)
+            this.writeSync(path, data, 0);
+    }
+}

package/dist/{backends/store → internal}/inode.d.ts

@@ -1,4 +1,4 @@
-import { Stats, type StatsLike } from '../../stats.js';
+import { Stats, type StatsLike } from '../stats.js';
 /**
  * Root inode
  * @hidden
@@ -39,6 +39,7 @@ export declare class Inode implements InodeLike {
     flags: number;
     /** For future use */
     __padding: number;
+    toString(): string;
     toJSON(): InodeLike;
     /**
      * Handy function that converts the Inode to a Node Stats object.
@@ -56,3 +57,7 @@ export declare class Inode implements InodeLike {
      */
     update(data?: Partial<Readonly<InodeLike>>): boolean;
 }
+/**
+ * @internal @hidden
+ */
+export declare const __inode_sz: number;