@zenfs/core 1.0.10 → 1.1.0

package/dist/filesystem.d.ts

@@ -10,7 +10,7 @@ export interface FileSystemMetadata {
      */
     name: string;
     /**
-     * Wheter the FS is readonly or not
+     * Whether the FS is readonly or not
      */
     readonly: boolean;
     /**
@@ -52,11 +52,10 @@ export interface FileSystemMetadata {
     type: number;
 }
 /**
- * Structure for a filesystem. All ZenFS backends must extend this.
- *
- * This class includes default implementations for `exists` and `existsSync`
- *
+ * 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 declare abstract class FileSystem {
     /**
@@ -71,99 +70,48 @@ export declare abstract class FileSystem {
     _disableSync?: boolean;
     constructor(...args: any[]);
     ready(): Promise<void>;
-    /**
-     * Asynchronous rename.
-     */
     abstract rename(oldPath: string, newPath: string): Promise<void>;
-    /**
-     * Synchronous rename.
-     */
     abstract renameSync(oldPath: string, newPath: string): void;
-    /**
-     * Asynchronous `stat`.
-     */
     abstract stat(path: string): Promise<Stats>;
-    /**
-     * Synchronous `stat`.
-     */
     abstract statSync(path: string): Stats;
     /**
-     * Opens the file at `path` with the given flag. The file must exist.
+     * Opens the file at `path` with `flag`. The file must exist.
      * @param path The path to open.
      * @param flag The flag to use when opening the file.
      */
     abstract openFile(path: string, flag: string): Promise<File>;
     /**
-     * Opens the file at `path` with the given flag. The file must exist.
+     * Opens the file at `path` with `flag`. The file must exist.
      * @param path The path to open.
      * @param flag The flag to use when opening the file.
-     * @return A File object corresponding to the opened file.
      */
     abstract openFileSync(path: string, flag: string): File;
     /**
-     * Create the file at `path` with the given mode. Then, open it with the given flag.
+     * Create the file at `path` with `mode`. Then, open it with `flag`.
      */
     abstract createFile(path: string, flag: string, mode: number): Promise<File>;
     /**
-     * Create the file at `path` with the given mode. Then, open it with the given flag.
+     * Create the file at `path` with `mode`. Then, open it with `flag`.
      */
     abstract createFileSync(path: string, flag: string, mode: number): File;
-    /**
-     * Asynchronous `unlink`.
-     */
     abstract unlink(path: string): Promise<void>;
-    /**
-     * Synchronous `unlink`.
-     */
     abstract unlinkSync(path: string): void;
-    /**
-     * Asynchronous `rmdir`.
-     */
     abstract rmdir(path: string): Promise<void>;
-    /**
-     * Synchronous `rmdir`.
-     */
     abstract rmdirSync(path: string): void;
-    /**
-     * Asynchronous `mkdir`.
-     * @param mode Mode to make the directory using.
-     */
     abstract mkdir(path: string, mode: number): Promise<void>;
-    /**
-     * Synchronous `mkdir`.
-     * @param mode Mode to make the directory using.
-     */
     abstract mkdirSync(path: string, mode: number): void;
-    /**
-     * Asynchronous `readdir`. Reads the contents of a directory.
-     */
     abstract readdir(path: string): Promise<string[]>;
-    /**
-     * Synchronous `readdir`. Reads the contents of a directory.
-     */
     abstract readdirSync(path: string): string[];
     /**
-     * Test whether or not the given path exists.
+     * Test whether or not `path` exists.
      */
     exists(path: string): Promise<boolean>;
     /**
-     * Test whether or not the given path exists.
+     * Test whether or not `path` exists.
      */
     existsSync(path: string): boolean;
-    /**
-     * Asynchronous `link`.
-     */
     abstract link(target: string, link: string): Promise<void>;
-    /**
-     * Synchronous `link`.
-     */
     abstract linkSync(target: string, link: string): void;
-    /**
-     * Synchronize the data and stats for path asynchronously
-     */
     abstract sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
-    /**
-     * Synchronize the data and stats for path synchronously
-     */
     abstract syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
 }

package/dist/filesystem.js

@@ -1,10 +1,9 @@
 import { ZenFsType } from './stats.js';
 /**
- * Structure for a filesystem. All ZenFS backends must extend this.
- *
- * This class includes default implementations for `exists` and `existsSync`
- *
+ * 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 {
     /**
@@ -25,7 +24,7 @@ export class FileSystem {
     constructor(...args) { }
     async ready() { }
     /**
-     * Test whether or not the given path exists.
+     * Test whether or not `path` exists.
      */
     async exists(path) {
         try {
@@ -37,7 +36,7 @@ export class FileSystem {
         }
     }
     /**
-     * Test whether or not the given path exists.
+     * Test whether or not `path` exists.
      */
     existsSync(path) {
         try {

package/dist/index.d.ts

@@ -10,6 +10,8 @@ export * from './backends/store/store.js';
 export * from './backends/backend.js';
 export * from './config.js';
 export * from './credentials.js';
+export * from './devices.js';
+export { default as devices } from './devices.js';
 export * from './file.js';
 export * from './filesystem.js';
 export * from './inode.js';

package/dist/index.js

@@ -10,6 +10,8 @@ export * from './backends/store/store.js';
 export * from './backends/backend.js';
 export * from './config.js';
 export * from './credentials.js';
+export * from './devices.js';
+export { default as devices } from './devices.js';
 export * from './file.js';
 export * from './filesystem.js';
 export * from './inode.js';

package/dist/inode.d.ts

@@ -4,11 +4,6 @@ import { Stats, type StatsLike } from './stats.js';
  * This will be helpful if in the future inode numbers/IDs are changed to strings or numbers.
  */
 export type Ino = bigint;
-/**
- * Max 32-bit integer
- * @hidden
- */
-export declare const size_max: number;
 /**
  * Room inode
  * @hidden

package/dist/inode.js

@@ -38,11 +38,6 @@ var __setFunctionName = (this && this.__setFunctionName) || function (f, name, p
 };
 import { Stats } from './stats.js';
 import { types as t, struct, sizeof, serialize, deserialize } from 'utilium';
-/**
- * Max 32-bit integer
- * @hidden
- */
-export const size_max = 2 ** 32 - 1;
 /**
  * Room inode
  * @hidden

package/dist/mixins/async.d.ts

@@ -1,13 +1,11 @@
 import { type File } from '../file.js';
 import type { FileSystem } from '../filesystem.js';
 import type { Stats } from '../stats.js';
-import type { _AsyncFSMethods, Mixin } from './shared.js';
-/**
- * @internal
- */
+import type { AsyncFSMethods, Mixin } from './shared.js';
+/** @internal */
 export type AsyncOperation = {
-    [K in keyof _AsyncFSMethods]: [K, ...Parameters<FileSystem[K]>];
-}[keyof _AsyncFSMethods];
+    [K in keyof AsyncFSMethods]: [K, ...Parameters<FileSystem[K]>];
+}[keyof AsyncFSMethods];
 /**
  * Async() implements synchronous methods on an asynchronous file system
  *

package/dist/mixins/async.js

@@ -1,7 +1,7 @@
 var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
     if (value !== null && value !== void 0) {
         if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose;
+        var dispose, inner;
         if (async) {
             if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
             dispose = value[Symbol.asyncDispose];
@@ -9,8 +9,10 @@ var __addDisposableResource = (this && this.__addDisposableResource) || function
         if (dispose === void 0) {
             if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
             dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
         }
         if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
         env.stack.push({ value: value, dispose: dispose, async: async });
     }
     else if (async) {

package/dist/mixins/mutexed.d.ts

@@ -75,15 +75,15 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
  * This serializes access to an underlying async filesystem.
  * For example, on an OverlayFS instance with an async lower
  * directory operations like rename and rmdir may involve multiple
- * requests involving both the upper and lower filesystems -- they
+ * requests involving both the upper and lower file systems -- they
  * are not executed in a single atomic step. OverlayFS uses this
  * to avoid having to reason about the correctness of
  * multiple requests interleaving.
  *
- * Note:
+ * @privateRemarks
  * Instead of extending the passed class, `MutexedFS` stores it internally.
- * This is to avoid a deadlock caused when a mathod calls another one
- * The problem is discussed extensivly in [#78](https://github.com/zen-fs/core/issues/78)
+ * This is to avoid a deadlock caused when a method calls another one
+ * The problem is discussed extensively in [#78](https://github.com/zen-fs/core/issues/78)
  * Instead of extending `FileSystem`,
  * `MutexedFS` implements it in order to make sure all of the methods are passed through
  *

package/dist/mixins/mutexed.js

@@ -1,7 +1,7 @@
 var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
     if (value !== null && value !== void 0) {
         if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose;
+        var dispose, inner;
         if (async) {
             if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
             dispose = value[Symbol.asyncDispose];
@@ -9,8 +9,10 @@ var __addDisposableResource = (this && this.__addDisposableResource) || function
         if (dispose === void 0) {
             if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
             dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
         }
         if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
         env.stack.push({ value: value, dispose: dispose, async: async });
     }
     else if (async) {
@@ -443,15 +445,15 @@ export class _MutexedFS {
  * This serializes access to an underlying async filesystem.
  * For example, on an OverlayFS instance with an async lower
  * directory operations like rename and rmdir may involve multiple
- * requests involving both the upper and lower filesystems -- they
+ * requests involving both the upper and lower file systems -- they
  * are not executed in a single atomic step. OverlayFS uses this
  * to avoid having to reason about the correctness of
  * multiple requests interleaving.
  *
- * Note:
+ * @privateRemarks
  * Instead of extending the passed class, `MutexedFS` stores it internally.
- * This is to avoid a deadlock caused when a mathod calls another one
- * The problem is discussed extensivly in [#78](https://github.com/zen-fs/core/issues/78)
+ * This is to avoid a deadlock caused when a method calls another one
+ * The problem is discussed extensively in [#78](https://github.com/zen-fs/core/issues/78)
  * Instead of extending `FileSystem`,
  * `MutexedFS` implements it in order to make sure all of the methods are passed through
  *

package/dist/mixins/readonly.js

@@ -8,47 +8,46 @@ export function Readonly(FS) {
         metadata() {
             return { ...super.metadata(), readonly: true };
         }
-        /* eslint-disable @typescript-eslint/no-unused-vars */
-        async rename(oldPath, newPath) {
+        async rename() {
             throw new ErrnoError(Errno.EROFS);
         }
-        renameSync(oldPath, newPath) {
+        renameSync() {
             throw new ErrnoError(Errno.EROFS);
         }
-        async createFile(path, flag, mode) {
+        async createFile() {
             throw new ErrnoError(Errno.EROFS);
         }
-        createFileSync(path, flag, mode) {
+        createFileSync() {
             throw new ErrnoError(Errno.EROFS);
         }
-        async unlink(path) {
+        async unlink() {
             throw new ErrnoError(Errno.EROFS);
         }
-        unlinkSync(path) {
+        unlinkSync() {
             throw new ErrnoError(Errno.EROFS);
         }
-        async rmdir(path) {
+        async rmdir() {
             throw new ErrnoError(Errno.EROFS);
         }
-        rmdirSync(path) {
+        rmdirSync() {
             throw new ErrnoError(Errno.EROFS);
         }
-        async mkdir(path, mode) {
+        async mkdir() {
             throw new ErrnoError(Errno.EROFS);
         }
-        mkdirSync(path, mode) {
+        mkdirSync() {
             throw new ErrnoError(Errno.EROFS);
         }
-        async link(srcpath, dstpath) {
+        async link() {
             throw new ErrnoError(Errno.EROFS);
         }
-        linkSync(srcpath, dstpath) {
+        linkSync() {
             throw new ErrnoError(Errno.EROFS);
         }
-        async sync(path, data, stats) {
+        async sync() {
             throw new ErrnoError(Errno.EROFS);
         }
-        syncSync(path, data, stats) {
+        syncSync() {
             throw new ErrnoError(Errno.EROFS);
         }
     }

package/dist/mixins/shared.d.ts

@@ -2,16 +2,16 @@ import type { ExtractProperties } from 'utilium';
 import type { FileSystem } from '../filesystem.js';
 /**
  * `TBase` with `TMixin` mixed-in.
- * @internal @experimental
+ * @internal
  */
 export type Mixin<TBase extends typeof FileSystem, TMixin> = (abstract new (...args: any[]) => TMixin) & TBase;
 /**
- * Asynchronous `FileSystem` methods. This is a convience type.
- * @hidden
+ * Asynchronous `FileSystem` methods. This is a convenience type.
+ * @internal
  */
-export type _AsyncFSMethods = ExtractProperties<FileSystem, (...args: any[]) => Promise<unknown>>;
+export type AsyncFSMethods = ExtractProperties<FileSystem, (...args: any[]) => Promise<unknown>>;
 /**
- * Concrete `FileSystem`. This is a convience type.
+ * Concrete `FileSystem`. This is a convenience type.
  * @internal
  */
 export type ConcreteFS = ExtractProperties<FileSystem, any>;

package/dist/mixins/sync.d.ts

@@ -1,6 +1,6 @@
 import type { FileSystem } from '../filesystem.js';
-import type { Mixin, _AsyncFSMethods } from './shared.js';
+import type { Mixin, AsyncFSMethods } from './shared.js';
 /**
  * Implements the asynchronous API in terms of the synchronous API.
  */
-export declare function Sync<T extends typeof FileSystem>(FS: T): Mixin<T, _AsyncFSMethods>;
+export declare function Sync<T extends typeof FileSystem>(FS: T): Mixin<T, AsyncFSMethods>;

package/dist/stats.d.ts

@@ -1,14 +1,10 @@
-/// <reference types="node" resolution-mode="require"/>
 import type * as Node from 'fs';
 import { type Credentials } from './credentials.js';
 import { S_IFDIR, S_IFLNK, S_IFREG } from './emulation/constants.js';
 /**
- * Indicates the type of the given file. Applied to 'mode'.
+ * Indicates the type of a file. Applied to 'mode'.
  */
 export type FileType = typeof S_IFREG | typeof S_IFDIR | typeof S_IFLNK;
-/**
- *
- */
 export interface StatsLike<T extends number | bigint = number | bigint> {
     /**
      * Size of the item in bytes.
@@ -17,35 +13,34 @@ export interface StatsLike<T extends number | bigint = 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: T;
     /**
-     * time of last access, in milliseconds since epoch
+     * Time of last access, since epoch
      */
     atimeMs: T;
     /**
-     * time of last modification, in milliseconds since epoch
+     * Time of last modification, since epoch
      */
     mtimeMs: T;
     /**
-     * time of last time file status was changed, in milliseconds since epoch
+     * Time of last time file status was changed, since epoch
      */
     ctimeMs: T;
     /**
-     * time of file creation, in milliseconds since epoch
+     * Time of file creation, since epoch
      */
     birthtimeMs: T;
     /**
-     * the id of the user that owns the file
+     * The id of the user that owns the file
      */
     uid: T;
     /**
-     * the id of the group that owns the file
+     * The id of the group that owns the file
      */
     gid: T;
     /**
-     * the ino
+     * Inode number
      */
     ino: T;
 }
@@ -67,27 +62,27 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
      */
     dev: T;
     /**
-     * inode number
+     * Inode number
      */
     ino: T;
     /**
-     * device ID (if special file)
+     * Device ID (if special file)
      */
     rdev: T;
     /**
-     * number of hard links
+     * Number of hard links
      */
     nlink: T;
     /**
-     * blocksize for file system I/O
+     * Block size for file system I/O
      */
     blksize: T;
     /**
-     * user ID of owner
+     * User ID of owner
      */
     uid: T;
     /**
-     * group ID of owner
+     * Group ID of owner
      */
     gid: T;
     /**
@@ -95,25 +90,25 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
      */
     fileData?: Uint8Array;
     /**
-     * time of last access, in milliseconds since epoch
+     * Time of last access, since epoch
      */
     atimeMs: T;
     get atime(): Date;
     set atime(value: Date);
     /**
-     * time of last modification, in milliseconds since epoch
+     * Time of last modification, since epoch
      */
     mtimeMs: T;
     get mtime(): Date;
     set mtime(value: Date);
     /**
-     * time of last time file status was changed, in milliseconds since epoch
+     * Time of last time file status was changed, since epoch
      */
     ctimeMs: T;
     get ctime(): Date;
     set ctime(value: Date);
     /**
-     * time of file creation, in milliseconds since epoch
+     * Time of file creation, since epoch
      */
     birthtimeMs: T;
     get birthtime(): Date;
@@ -127,17 +122,8 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
      * Creates a new stats instance from a stats-like object. Can be used to copy stats (note)
      */
     constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode, ino }?: Partial<StatsLike>);
-    /**
-     * @returns true if this item is a file.
-     */
     isFile(): boolean;
-    /**
-     * @returns True if this item is a directory.
-     */
     isDirectory(): boolean;
-    /**
-     * @returns true if this item is a symbolic link
-     */
     isSymbolicLink(): boolean;
     isSocket(): boolean;
     isBlockDevice(): boolean;
@@ -156,8 +142,8 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
      */
     cred(uid?: number, gid?: number): Credentials;
     /**
-     * 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.
+     * Change the mode of the file.
+     * We use this helper function to prevent messing up the type of the file.
      * @internal
      */
     chmod(mode: number): void;
@@ -197,9 +183,7 @@ export declare class BigIntStats extends StatsCommon<bigint> implements Node.Big
  * @internal
  */
 export declare function isStatsEqual<T extends number | bigint>(left: StatsCommon<T>, right: StatsCommon<T>): boolean;
-/**
- * @internal
- */
+/** @internal */
 export declare const ZenFsType = 525687744115;
 /**
  * @hidden

package/dist/stats.js

@@ -1,6 +1,5 @@
 import { credentials } from './credentials.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';
+import { S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK, S_IRWXG, S_IRWXO, S_IRWXU, size_max } from './emulation/constants.js';
 /**
  * Provides information about a particular entry in the file system.
  * Common code used by both Stats and BigIntStats.
@@ -45,27 +44,27 @@ export class StatsCommon {
          */
         this.dev = this._convert(0);
         /**
-         * inode number
+         * Inode number
          */
         this.ino = this._convert(0);
         /**
-         * device ID (if special file)
+         * Device ID (if special file)
          */
         this.rdev = this._convert(0);
         /**
-         * number of hard links
+         * Number of hard links
          */
         this.nlink = this._convert(1);
         /**
-         * blocksize for file system I/O
+         * Block size for file system I/O
          */
         this.blksize = this._convert(4096);
         /**
-         * user ID of owner
+         * User ID of owner
          */
         this.uid = this._convert(0);
         /**
-         * group ID of owner
+         * Group ID of owner
          */
         this.gid = this._convert(0);
         const now = Date.now();
@@ -82,25 +81,15 @@ export class StatsCommon {
             this.mode = (this.mode | this._convert(S_IFREG));
         }
     }
-    /**
-     * @returns true if this item is a file.
-     */
     isFile() {
         return (this.mode & S_IFMT) === S_IFREG;
     }
-    /**
-     * @returns True if this item is a directory.
-     */
     isDirectory() {
         return (this.mode & S_IFMT) === S_IFDIR;
     }
-    /**
-     * @returns true if this item is a symbolic link
-     */
     isSymbolicLink() {
         return (this.mode & S_IFMT) === S_IFLNK;
     }
-    // Currently unsupported
     isSocket() {
         return (this.mode & S_IFMT) === S_IFSOCK;
     }
@@ -143,8 +132,8 @@ 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.
+     * Change the mode of the file.
+     * We use this helper function to prevent messing up the type of the file.
      * @internal
      */
     chmod(mode) {
@@ -212,9 +201,7 @@ export class BigIntStats extends StatsCommon {
 export function isStatsEqual(left, right) {
     return left.size == right.size && +left.atime == +right.atime && +left.mtime == +right.mtime && +left.ctime == +right.ctime && left.mode == right.mode;
 }
-/**
- * @internal
- */
+/** @internal */
 export const ZenFsType = 0x7a656e6673; // 'z' 'e' 'n' 'f' 's'
 /**
  * @hidden