@zenfs/core 0.11.2 → 0.12.0

package/src/stats.ts

@@ -14,45 +14,45 @@ export enum FileType {
 /**
  *
  */
-export interface StatsLike {
+export interface StatsLike<T extends number | bigint = number | bigint> {
 	/**
 	 * Size of the item in bytes.
 	 * For directories/symlinks, this is normally the size of the struct that represents the item.
 	 */
-	size: number | bigint;
+	size: T;
 	/**
 	 * Unix-style file mode (e.g. 0o644) that includes the item type
 	 * Type of the item can be FILE, DIRECTORY, SYMLINK, or SOCKET
 	 */
-	mode: number | bigint;
+	mode: T;
 	/**
 	 * time of last access, in milliseconds since epoch
 	 */
-	atimeMs: number | bigint;
+	atimeMs: T;
 	/**
 	 * time of last modification, in milliseconds since epoch
 	 */
-	mtimeMs: number | bigint;
+	mtimeMs: T;
 	/**
 	 * time of last time file status was changed, in milliseconds since epoch
 	 */
-	ctimeMs: number | bigint;
+	ctimeMs: T;
 	/**
 	 * time of file creation, in milliseconds since epoch
 	 */
-	birthtimeMs: number | bigint;
+	birthtimeMs: T;
 	/**
 	 * the id of the user that owns the file
 	 */
-	uid: number | bigint;
+	uid: T;
 	/**
 	 * the id of the group that owns the file
 	 */
-	gid: number | bigint;
+	gid: T;
 	/**
 	 * the ino
 	 */
-	ino: number | bigint;
+	ino: T;
 }
 
 /**

package/dist/backends/Index.d.ts

@@ -1,204 +0,0 @@
-import type { Cred } from '../cred.js';
-import { NoSyncFile } from '../file.js';
-import { FileSystem } from '../filesystem.js';
-import { Stats } from '../stats.js';
-/**
- * @internal
- */
-export type ListingTree = {
-    [key: string]: ListingTree | null;
-};
-/**
- * @internal
- */
-export interface ListingQueueNode<TData> {
-    pwd: string;
-    tree: ListingTree;
-    parent: IndexDirInode<TData>;
-}
-/**
- * A simple class for storing a filesystem index. Assumes that all paths passed
- * to it are *absolute* paths.
- *
- * Can be used as a partial or a full index, although care must be taken if used
- * for the former purpose, especially when directories are concerned.
- *
- * @internal
- */
-export declare class FileIndex<TData> {
-    /**
-     * Static method for constructing indices from a JSON listing.
-     * @param listing Directory listing generated by tools
-     * @return A new FileIndex object.
-     */
-    static FromListing<T>(listing: ListingTree): FileIndex<T>;
-    protected _index: Map<string, IndexDirInode<TData>>;
-    /**
-     * Constructs a new FileIndex.
-     */
-    constructor();
-    files(): IndexFileInode<TData>[];
-    /**
-     * Adds the given absolute path to the index if it is not already in the index.
-     * Creates any needed parent directories.
-     * @param path The path to add to the index.
-     * @param inode The inode for the
-     *   path to add.
-     * @return 'True' if it was added or already exists, 'false' if there
-     *   was an issue adding it (e.g. item in path is a file, item exists but is
-     *   different).
-     * @todo If adding fails and implicitly creates directories, we do not clean up
-     *   the new empty directories.
-     */
-    add(path: string, inode: IndexInode<TData>): boolean;
-    /**
-     * Adds the given absolute path to the index if it is not already in the index.
-     * The path is added without special treatment (no joining of adjacent separators, etc).
-     * Creates any needed parent directories.
-     * @param path The path to add to the index.
-     * @param inode The inode for the path to add.
-     * @return 'True' if it was added or already exists, 'false' if there
-     *   was an issue adding it (e.g. item in path is a file, item exists but is
-     *   different).
-     * @todo If adding fails and implicitly creates directories, we do not clean up the new empty directories.
-     */
-    addFast(path: string, inode: IndexInode<TData>): boolean;
-    /**
-     * Removes the given path. Can be a file or a directory.
-     * @return The removed item,
-     *   or null if it did not exist.
-     */
-    remove(path: string): IndexInode<TData> | void;
-    /**
-     * Retrieves the directory listing of the given path.
-     * @return An array of files in the given path, or 'null' if it does not exist.
-     */
-    ls(path: string): string[] | void;
-    /**
-     * Returns the inode of the given item.
-     * @return Returns null if the item does not exist.
-     */
-    get(path: string): IndexInode<TData> | void | null;
-}
-/**
- * Generic interface for file/directory inodes.
- * Note that Stats objects are what we use for file inodes.
- */
-export declare abstract class IndexInode<TData> {
-    data?: TData | undefined;
-    constructor(data?: TData | undefined);
-    /**
-     * Whether this inode is for a file
-     */
-    abstract isFile(): this is IndexFileInode<TData>;
-    /**
-     * Whether this inode is for a directory
-     */
-    abstract isDirectory(): this is IndexDirInode<TData>;
-    abstract toStats(): Stats;
-}
-/**
- * Inode for a file. Stores an arbitrary (filesystem-specific) data payload.
- */
-export declare class IndexFileInode<TData> extends IndexInode<TData> {
-    isFile(): boolean;
-    isDirectory(): boolean;
-    toStats(): Stats;
-}
-/**
- * Inode for a directory. Currently only contains the directory listing.
- */
-export declare class IndexDirInode<TData> extends IndexInode<TData> {
-    /**
-     * @internal
-     */
-    _listing: Map<string, IndexInode<TData>>;
-    isFile(): boolean;
-    isDirectory(): boolean;
-    /**
-     * Return a Stats object for this inode.
-     * @todo Should probably remove this at some point. This isn't the responsibility of the FileIndex.
-     */
-    get stats(): Stats;
-    /**
-     * Alias of getStats()
-     * @todo Remove this at some point. This isn't the responsibility of the FileIndex.
-     */
-    toStats(): Stats;
-    /**
-     * Returns the directory listing for this directory. Paths in the directory are
-     * relative to the directory's path.
-     * @return The directory listing for this directory.
-     */
-    get listing(): string[];
-    /**
-     * Returns the inode for the indicated item, or null if it does not exist.
-     * @param path Name of item in this directory.
-     */
-    get(path: string): IndexInode<TData> | void;
-    /**
-     * Add the given item to the directory listing. Note that the given inode is
-     * not copied, and will be mutated by the DirInode if it is a DirInode.
-     * @param path Item name to add to the directory listing.
-     * @param inode The inode for the
-     *   item to add to the directory inode.
-     * @return True if it was added, false if it already existed.
-     */
-    add(path: string, inode: IndexInode<TData>): boolean;
-    /**
-     * Removes the given item from the directory listing.
-     * @param path Name of item to remove from the directory listing.
-     * @return Returns the item
-     *   removed, or null if the item did not exist.
-     */
-    remove(path: string): IndexInode<TData> | void;
-}
-declare const IndexFS_base: (abstract new (...args: any[]) => {
-    metadata(): import("../filesystem.js").FileSystemMetadata;
-    rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
-    renameSync(oldPath: string, newPath: string, cred: Cred): void;
-    createFile(path: string, flag: string, mode: number, cred: Cred): Promise<import("../file.js").File>;
-    createFileSync(path: string, flag: string, mode: number, cred: Cred): import("../file.js").File;
-    unlink(path: string, cred: Cred): Promise<void>;
-    unlinkSync(path: string, cred: Cred): void;
-    rmdir(path: string, cred: Cred): Promise<void>;
-    rmdirSync(path: string, cred: Cred): void;
-    mkdir(path: string, mode: number, cred: Cred): Promise<void>;
-    mkdirSync(path: string, mode: number, cred: Cred): void;
-    link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
-    linkSync(srcpath: string, dstpath: string, cred: Cred): void;
-    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
-    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
-    ready(): Promise<void>;
-    stat(path: string, cred: Cred): Promise<Stats>;
-    statSync(path: string, cred: Cred): Stats;
-    openFile(path: string, flag: string, cred: Cred): Promise<import("../file.js").File>;
-    openFileSync(path: string, flag: string, cred: Cred): import("../file.js").File;
-    readdir(path: string, cred: Cred): Promise<string[]>;
-    readdirSync(path: string, cred: Cred): string[];
-    exists(path: string, cred: Cred): Promise<boolean>;
-    existsSync(path: string, cred: Cred): boolean;
-}) & typeof FileSystem;
-export declare abstract class IndexFS<TData> extends IndexFS_base {
-    protected _index: FileIndex<TData>;
-    constructor(index: ListingTree);
-    stat(path: string): Promise<Stats>;
-    statSync(path: string): Stats;
-    openFile(path: string, flag: string, cred: Cred): Promise<NoSyncFile<this>>;
-    openFileSync(path: string, flag: string, cred: Cred): NoSyncFile<this>;
-    readdir(path: string): Promise<string[]>;
-    readdirSync(path: string): string[];
-    protected abstract statFileInode(inode: IndexFileInode<TData>, path: string): Promise<Stats>;
-    protected abstract statFileInodeSync(inode: IndexFileInode<TData>, path: string): Stats;
-    protected abstract openFileInode(inode: IndexFileInode<TData>, path: string, flag: string): Promise<NoSyncFile<this>>;
-    protected abstract openFileInodeSync(inode: IndexFileInode<TData>, path: string, flag: string): NoSyncFile<this>;
-}
-export declare abstract class SyncIndexFS<TData> extends IndexFS<TData> {
-    protected statFileInode(inode: IndexFileInode<TData>, path: string): Promise<Stats>;
-    protected openFileInode(inode: IndexFileInode<TData>, path: string, flag: string): Promise<NoSyncFile<this>>;
-}
-export declare abstract class AsyncIndexFS<TData> extends IndexFS<TData> {
-    protected statFileInodeSync(inode: IndexFileInode<TData>, path: string): Stats;
-    protected openFileInodeSync(inode: IndexFileInode<TData>, path: string, flag: string): NoSyncFile<this>;
-}
-export {};

package/dist/backends/Index.js

@@ -1,410 +0,0 @@
-import { ErrnoError, Errno } from '../error.js';
-import { basename, dirname, join } from '../emulation/path.js';
-import { NoSyncFile, flagToMode, isWriteable } from '../file.js';
-import { FileSystem, Readonly } from '../filesystem.js';
-import { FileType, Stats } from '../stats.js';
-/**
- * A simple class for storing a filesystem index. Assumes that all paths passed
- * to it are *absolute* paths.
- *
- * Can be used as a partial or a full index, although care must be taken if used
- * for the former purpose, especially when directories are concerned.
- *
- * @internal
- */
-export class FileIndex {
-    /**
-     * Static method for constructing indices from a JSON listing.
-     * @param listing Directory listing generated by tools
-     * @return A new FileIndex object.
-     */
-    static FromListing(listing) {
-        const index = new FileIndex();
-        // Add a root DirNode.
-        const rootInode = new IndexDirInode();
-        index._index.set('/', rootInode);
-        const queue = [{ pwd: '', tree: listing, parent: rootInode }];
-        while (queue.length > 0) {
-            let inode;
-            const { tree, pwd, parent } = queue.pop();
-            for (const node in tree) {
-                if (!Object.hasOwn(tree, node)) {
-                    continue;
-                }
-                const children = tree[node];
-                if (children) {
-                    const path = pwd + '/' + node;
-                    inode = new IndexDirInode();
-                    index._index.set(path, inode);
-                    queue.push({ pwd: path, tree: children, parent: inode });
-                }
-                else {
-                    // This inode doesn't have correct size information, noted with -1.
-                    inode = new IndexFileInode(new Stats({ mode: FileType.FILE | 0o555 }));
-                }
-                if (!parent) {
-                    continue;
-                }
-                parent._listing.set(node, inode);
-            }
-        }
-        return index;
-    }
-    /**
-     * Constructs a new FileIndex.
-     */
-    constructor() {
-        // Maps directory paths to directory inodes, which contain files.
-        this._index = new Map();
-        // _index is a single-level key,value store that maps *directory* paths to
-        // DirInodes. File information is only contained in DirInodes themselves.
-        // Create the root directory.
-        this.add('/', new IndexDirInode());
-    }
-    files() {
-        const files = [];
-        for (const dir of this._index.values()) {
-            for (const file of dir.listing) {
-                const item = dir.get(file);
-                if (!item) {
-                    continue;
-                }
-                if (!item.isFile()) {
-                    continue;
-                }
-                files.push(item);
-            }
-        }
-        return files;
-    }
-    /**
-     * Adds the given absolute path to the index if it is not already in the index.
-     * Creates any needed parent directories.
-     * @param path The path to add to the index.
-     * @param inode The inode for the
-     *   path to add.
-     * @return 'True' if it was added or already exists, 'false' if there
-     *   was an issue adding it (e.g. item in path is a file, item exists but is
-     *   different).
-     * @todo If adding fails and implicitly creates directories, we do not clean up
-     *   the new empty directories.
-     */
-    add(path, inode) {
-        if (!inode) {
-            throw new ErrnoError(Errno.EINVAL, 'Inode must be specified', path, 'FileIndex.add');
-        }
-        if (!path.startsWith('/')) {
-            throw new ErrnoError(Errno.EINVAL, 'Path not absolute', path, 'FileIndex.add');
-        }
-        // Check if it already exists.
-        if (this._index.has(path)) {
-            return this._index.get(path) === inode;
-        }
-        const dirpath = dirname(path);
-        const hasParent = this._index.has(dirpath);
-        const parent = hasParent ? this._index.get(dirpath) : new IndexDirInode();
-        // Try to add to its parent directory first.
-        if (!hasParent && path != '/') {
-            if (!this.add(dirpath, parent)) {
-                return false;
-            }
-        }
-        // Add to parent.
-        if (path != '/' && !parent.add(basename(path), inode)) {
-            return false;
-        }
-        // If a directory, add to the index.
-        if (inode.isDirectory()) {
-            this._index.set(path, inode);
-        }
-        return true;
-    }
-    /**
-     * Adds the given absolute path to the index if it is not already in the index.
-     * The path is added without special treatment (no joining of adjacent separators, etc).
-     * Creates any needed parent directories.
-     * @param path The path to add to the index.
-     * @param inode The inode for the path to add.
-     * @return 'True' if it was added or already exists, 'false' if there
-     *   was an issue adding it (e.g. item in path is a file, item exists but is
-     *   different).
-     * @todo If adding fails and implicitly creates directories, we do not clean up the new empty directories.
-     */
-    addFast(path, inode) {
-        const parentPath = dirname(path);
-        const itemName = basename(path);
-        // Try to add to its parent directory first.
-        let parent = this._index.get(parentPath);
-        if (!parent) {
-            // Create parent.
-            parent = new IndexDirInode();
-            this.addFast(parentPath, parent);
-        }
-        if (!parent.add(itemName, inode)) {
-            return false;
-        }
-        // If adding a directory, add to the index as well.
-        if (inode.isDirectory()) {
-            this._index.set(path, inode);
-        }
-        return true;
-    }
-    /**
-     * Removes the given path. Can be a file or a directory.
-     * @return The removed item,
-     *   or null if it did not exist.
-     */
-    remove(path) {
-        const dirpath = dirname(path);
-        // Try to remove it from its parent directory first.
-        const parent = this._index.get(dirpath);
-        if (!parent) {
-            return;
-        }
-        // Remove from parent.
-        const inode = parent.remove(basename(path));
-        if (!inode) {
-            return;
-        }
-        if (!inode.isDirectory()) {
-            return inode;
-        }
-        // If a directory, remove from the index, and remove children.
-        const children = inode.listing;
-        for (const child of children) {
-            this.remove(join(path, child));
-        }
-        // Remove the directory from the index, unless it's the root.
-        if (path != '/') {
-            this._index.delete(path);
-        }
-    }
-    /**
-     * Retrieves the directory listing of the given path.
-     * @return An array of files in the given path, or 'null' if it does not exist.
-     */
-    ls(path) {
-        return this._index.get(path)?.listing;
-    }
-    /**
-     * Returns the inode of the given item.
-     * @return Returns null if the item does not exist.
-     */
-    get(path) {
-        const dirpath = dirname(path);
-        // Retrieve from its parent directory.
-        const parent = this._index.get(dirpath);
-        // Root case
-        if (dirpath == path) {
-            return parent;
-        }
-        return parent?.get(basename(path));
-    }
-}
-/**
- * Generic interface for file/directory inodes.
- * Note that Stats objects are what we use for file inodes.
- */
-export class IndexInode {
-    constructor(data) {
-        this.data = data;
-    }
-}
-/**
- * Inode for a file. Stores an arbitrary (filesystem-specific) data payload.
- */
-export class IndexFileInode extends IndexInode {
-    isFile() {
-        return true;
-    }
-    isDirectory() {
-        return false;
-    }
-    toStats() {
-        return new Stats({ mode: FileType.FILE | 0o666, size: 4096 });
-    }
-}
-/**
- * Inode for a directory. Currently only contains the directory listing.
- */
-export class IndexDirInode extends IndexInode {
-    constructor() {
-        super(...arguments);
-        /**
-         * @internal
-         */
-        this._listing = new Map();
-    }
-    isFile() {
-        return false;
-    }
-    isDirectory() {
-        return true;
-    }
-    /**
-     * Return a Stats object for this inode.
-     * @todo Should probably remove this at some point. This isn't the responsibility of the FileIndex.
-     */
-    get stats() {
-        return new Stats({ mode: FileType.DIRECTORY | 0o555, size: 4096 });
-    }
-    /**
-     * Alias of getStats()
-     * @todo Remove this at some point. This isn't the responsibility of the FileIndex.
-     */
-    toStats() {
-        return this.stats;
-    }
-    /**
-     * Returns the directory listing for this directory. Paths in the directory are
-     * relative to the directory's path.
-     * @return The directory listing for this directory.
-     */
-    get listing() {
-        return [...this._listing.keys()];
-    }
-    /**
-     * Returns the inode for the indicated item, or null if it does not exist.
-     * @param path Name of item in this directory.
-     */
-    get(path) {
-        return this._listing.get(path);
-    }
-    /**
-     * Add the given item to the directory listing. Note that the given inode is
-     * not copied, and will be mutated by the DirInode if it is a DirInode.
-     * @param path Item name to add to the directory listing.
-     * @param inode The inode for the
-     *   item to add to the directory inode.
-     * @return True if it was added, false if it already existed.
-     */
-    add(path, inode) {
-        if (this._listing.has(path)) {
-            return false;
-        }
-        this._listing.set(path, inode);
-        return true;
-    }
-    /**
-     * Removes the given item from the directory listing.
-     * @param path Name of item to remove from the directory listing.
-     * @return Returns the item
-     *   removed, or null if the item did not exist.
-     */
-    remove(path) {
-        const item = this._listing.get(path);
-        if (!item) {
-            return;
-        }
-        this._listing.delete(path);
-        return item;
-    }
-}
-export class IndexFS extends Readonly(FileSystem) {
-    constructor(index) {
-        super();
-        this._index = FileIndex.FromListing(index);
-    }
-    async stat(path) {
-        const inode = this._index.get(path);
-        if (!inode) {
-            throw ErrnoError.With('ENOENT', path, 'stat');
-        }
-        if (inode.isDirectory()) {
-            return inode.stats;
-        }
-        if (inode.isFile()) {
-            return this.statFileInode(inode, path);
-        }
-        throw new ErrnoError(Errno.EINVAL, 'Invalid inode.');
-    }
-    statSync(path) {
-        const inode = this._index.get(path);
-        if (!inode) {
-            throw ErrnoError.With('ENOENT', path, 'stat');
-        }
-        if (inode.isDirectory()) {
-            return inode.stats;
-        }
-        if (inode.isFile()) {
-            return this.statFileInodeSync(inode, path);
-        }
-        throw new ErrnoError(Errno.EINVAL, 'Invalid inode.');
-    }
-    async openFile(path, flag, cred) {
-        if (isWriteable(flag)) {
-            // You can't write to files on this file system.
-            throw new ErrnoError(Errno.EPERM, path);
-        }
-        // Check if the path exists, and is a file.
-        const inode = this._index.get(path);
-        if (!inode) {
-            throw ErrnoError.With('ENOENT', path, 'openFile');
-        }
-        if (!inode.toStats().hasAccess(flagToMode(flag), cred)) {
-            throw ErrnoError.With('EACCES', path, 'openFile');
-        }
-        if (inode.isDirectory()) {
-            const stats = inode.stats;
-            return new NoSyncFile(this, path, flag, stats, stats.fileData);
-        }
-        return this.openFileInode(inode, path, flag);
-    }
-    openFileSync(path, flag, cred) {
-        if (isWriteable(flag)) {
-            // You can't write to files on this file system.
-            throw new ErrnoError(Errno.EPERM, path);
-        }
-        // Check if the path exists, and is a file.
-        const inode = this._index.get(path);
-        if (!inode) {
-            throw ErrnoError.With('ENOENT', path, 'openFile');
-        }
-        if (!inode.toStats().hasAccess(flagToMode(flag), cred)) {
-            throw ErrnoError.With('EACCES', path, 'openFile');
-        }
-        if (inode.isDirectory()) {
-            const stats = inode.stats;
-            return new NoSyncFile(this, path, flag, stats, stats.fileData);
-        }
-        return this.openFileInodeSync(inode, path, flag);
-    }
-    async readdir(path) {
-        // Check if it exists.
-        const inode = this._index.get(path);
-        if (!inode) {
-            throw ErrnoError.With('ENOENT', path, 'readdir');
-        }
-        if (inode.isDirectory()) {
-            return inode.listing;
-        }
-        throw ErrnoError.With('ENOTDIR', path, 'readdir');
-    }
-    readdirSync(path) {
-        // Check if it exists.
-        const inode = this._index.get(path);
-        if (!inode) {
-            throw ErrnoError.With('ENOENT', path, 'readdir');
-        }
-        if (inode.isDirectory()) {
-            return inode.listing;
-        }
-        throw ErrnoError.With('ENOTDIR', path, 'readdir');
-    }
-}
-export class SyncIndexFS extends IndexFS {
-    async statFileInode(inode, path) {
-        return this.statFileInodeSync(inode, path);
-    }
-    async openFileInode(inode, path, flag) {
-        return this.openFileInodeSync(inode, path, flag);
-    }
-}
-export class AsyncIndexFS extends IndexFS {
-    statFileInodeSync(inode, path) {
-        throw ErrnoError.With('ENOSYS', path, 'AsyncIndexFS.statFileInodeSync');
-    }
-    openFileInodeSync(inode, path, flag) {
-        throw ErrnoError.With('ENOSYS', path, 'AsyncIndexFS.openFileInodeSync');
-    }
-}