@zenfs/core 1.0.10 → 1.0.11

package/dist/backends/store/store.d.ts

@@ -36,42 +36,36 @@ export declare abstract class Transaction<T extends Store = Store> {
      */
     protected done: boolean;
     /**
-     * Retrieves the data at the given key.
+     * Retrieves the data at `ino`.
      * @param ino The key to look under for data.
      */
     abstract get(ino: Ino): Promise<Uint8Array>;
     /**
-     * Retrieves the data at the given key. Throws an error if an error occurs
-     * or if the key does not exist.
+     * Retrieves the data at `ino`.
+     * Throws an error if an error occurs or if the key does not exist.
      * @param ino The key to look under for data.
      * @return The data stored under the key, or undefined if not present.
      */
     abstract getSync(ino: Ino): Uint8Array;
     /**
-     * Adds the data to the store under the given key. Overwrites any existing
-     * data.
+     * Adds the data to the store under `ino`. Overwrites any existing data.
      * @param ino The key to add the data under.
      * @param data The data to add to the store.
-     * @param overwrite If 'true', overwrite any existing data. If 'false',
-     *   avoids writing the data if the key exists.
      */
     abstract set(ino: Ino, data: Uint8Array): Promise<void>;
     /**
-     * Adds the data to the store under the given key.
+     * Adds the data to the store under `ino`.
      * @param ino The key to add the data under.
      * @param data The data to add to the store.
-     * @param overwrite If 'true', overwrite any existing data. If 'false',
-     *   avoids storing the data if the key exists.
-     * @return True if storage succeeded, false otherwise.
      */
     abstract setSync(ino: Ino, data: Uint8Array): void;
     /**
-     * Deletes the data at the given key.
+     * Deletes the data at `ino`.
      * @param ino The key to delete from the store.
      */
     abstract remove(ino: Ino): Promise<void>;
     /**
-     * Deletes the data at the given key.
+     * Deletes the data at `ino`.
      * @param ino The key to delete from the store.
      */
     abstract removeSync(ino: Ino): void;

package/dist/config.d.ts

@@ -5,10 +5,10 @@ import type { AbsolutePath } from './emulation/path.js';
  */
 export type MountConfiguration<T extends Backend> = FilesystemOf<T> | BackendConfiguration<T> | T;
 /**
- * Retrieve a file system with the given configuration.
+ * Retrieve a file system with `configuration`.
  * @see MountConfiguration
  */
-export declare function resolveMountConfig<T extends Backend>(config: MountConfiguration<T>, _depth?: number): Promise<FilesystemOf<T>>;
+export declare function resolveMountConfig<T extends Backend>(configuration: MountConfiguration<T>, _depth?: number): Promise<FilesystemOf<T>>;
 export interface ConfigMounts {
     [K: AbsolutePath]: Backend;
 }
@@ -34,9 +34,9 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
 /**
  * Configures ZenFS with single mount point /
  */
-export declare function configureSingle<T extends Backend>(config: MountConfiguration<T>): Promise<void>;
+export declare function configureSingle<T extends Backend>(configuration: MountConfiguration<T>): Promise<void>;
 /**
- * Configures ZenFS with the given configuration
+ * Configures ZenFS with `configuration`
  * @see Configuration
  */
-export declare function configure<T extends ConfigMounts>(config: Partial<Configuration<T>>): Promise<void>;
+export declare function configure<T extends ConfigMounts>(configuration: Partial<Configuration<T>>): Promise<void>;

package/dist/config.js

@@ -7,23 +7,23 @@ function isMountConfig(arg) {
     return isBackendConfig(arg) || isBackend(arg) || arg instanceof FileSystem;
 }
 /**
- * Retrieve a file system with the given configuration.
+ * Retrieve a file system with `configuration`.
  * @see MountConfiguration
  */
-export async function resolveMountConfig(config, _depth = 0) {
-    if (typeof config !== 'object' || config == null) {
+export async function resolveMountConfig(configuration, _depth = 0) {
+    if (typeof configuration !== 'object' || configuration == null) {
         throw new ErrnoError(Errno.EINVAL, 'Invalid options on mount configuration');
     }
-    if (!isMountConfig(config)) {
+    if (!isMountConfig(configuration)) {
         throw new ErrnoError(Errno.EINVAL, 'Invalid mount configuration');
     }
-    if (config instanceof FileSystem) {
-        return config;
+    if (configuration instanceof FileSystem) {
+        return configuration;
     }
-    if (isBackend(config)) {
-        config = { backend: config };
+    if (isBackend(configuration)) {
+        configuration = { backend: configuration };
     }
-    for (const [key, value] of Object.entries(config)) {
+    for (const [key, value] of Object.entries(configuration)) {
         if (key == 'backend') {
             continue;
         }
@@ -33,48 +33,48 @@ export async function resolveMountConfig(config, _depth = 0) {
         if (_depth > 10) {
             throw new ErrnoError(Errno.EINVAL, 'Invalid configuration, too deep and possibly infinite');
         }
-        config[key] = await resolveMountConfig(value, ++_depth);
+        configuration[key] = await resolveMountConfig(value, ++_depth);
     }
-    const { backend } = config;
+    const { backend } = configuration;
     if (!(await backend.isAvailable())) {
         throw new ErrnoError(Errno.EPERM, 'Backend not available: ' + backend.name);
     }
-    await checkOptions(backend, config);
-    const mount = (await backend.create(config));
-    mount._disableSync = config.disableAsyncCache || false;
+    await checkOptions(backend, configuration);
+    const mount = (await backend.create(configuration));
+    mount._disableSync = configuration.disableAsyncCache || false;
     await mount.ready();
     return mount;
 }
 /**
  * Configures ZenFS with single mount point /
  */
-export async function configureSingle(config) {
-    if (!isBackendConfig(config)) {
+export async function configureSingle(configuration) {
+    if (!isBackendConfig(configuration)) {
         throw new TypeError('Invalid single mount point configuration');
     }
-    const resolved = await resolveMountConfig(config);
+    const resolved = await resolveMountConfig(configuration);
     fs.umount('/');
     fs.mount('/', resolved);
 }
 /**
- * Configures ZenFS with the given configuration
+ * Configures ZenFS with `configuration`
  * @see Configuration
  */
-export async function configure(config) {
-    const uid = 'uid' in config ? config.uid || 0 : 0;
-    const gid = 'gid' in config ? config.gid || 0 : 0;
+export async function configure(configuration) {
+    const uid = 'uid' in configuration ? configuration.uid || 0 : 0;
+    const gid = 'gid' in configuration ? configuration.gid || 0 : 0;
     Object.assign(credentials, { uid, gid, suid: uid, sgid: gid, euid: uid, egid: gid });
-    if (!config.mounts) {
+    if (!configuration.mounts) {
         return;
     }
-    for (const [point, mountConfig] of Object.entries(config.mounts)) {
+    for (const [point, mountConfig] of Object.entries(configuration.mounts)) {
         if (!point.startsWith('/')) {
             throw new ErrnoError(Errno.EINVAL, 'Mount points must have absolute paths');
         }
         if (isBackendConfig(mountConfig)) {
-            mountConfig.disableAsyncCache ?? (mountConfig.disableAsyncCache = config.disableAsyncCache || false);
+            mountConfig.disableAsyncCache ?? (mountConfig.disableAsyncCache = configuration.disableAsyncCache || false);
         }
-        config.mounts[point] = await resolveMountConfig(mountConfig);
+        configuration.mounts[point] = await resolveMountConfig(mountConfig);
     }
-    fs.mountObject(config.mounts);
+    fs.mountObject(configuration.mounts);
 }

package/dist/emulation/async.d.ts

@@ -1,8 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import { Buffer } from 'buffer';
 import type * as fs from 'node:fs';
 import type { FileContents } from '../filesystem.js';
@@ -14,26 +9,15 @@ import * as promises from './promises.js';
 import { ReadStream, WriteStream } from './streams.js';
 import { FSWatcher } from './watchers.js';
 /**
- * Asynchronous rename. No arguments other than a possible exception are given
- * to the completion callback.
- * @param oldPath
- * @param newPath
- * @param callback
+ * Asynchronous rename. No arguments other than a possible exception are given to the completion callback.
  */
 export declare function rename(oldPath: fs.PathLike, newPath: fs.PathLike, cb?: Callback): void;
 /**
- * Test whether or not the given path exists by checking with the file system.
+ * Test whether or not `path` exists by checking with the file system.
  * Then call the callback argument with either true or false.
- * @param path
- * @param callback
  * @deprecated Use {@link stat} or {@link access} instead.
  */
 export declare function exists(path: fs.PathLike, cb?: (exists: boolean) => unknown): void;
-/**
- * Asynchronous `stat`.
- * @param path
- * @param callback
- */
 export declare function stat(path: fs.PathLike, callback: Callback<[Stats]>): void;
 export declare function stat(path: fs.PathLike, options: {
     bigint?: false;
@@ -46,8 +30,6 @@ export declare function stat(path: fs.PathLike, options: fs.StatOptions, callbac
  * Asynchronous `lstat`.
  * `lstat()` is identical to `stat()`, except that if path is a symbolic link,
  * then the link itself is stat-ed, not the file that it refers to.
- * @param path
- * @param callback
  */
 export declare function lstat(path: fs.PathLike, callback: Callback<[Stats]>): void;
 export declare function lstat(path: fs.PathLike, options: fs.StatOptions & {
@@ -57,23 +39,13 @@ export declare function lstat(path: fs.PathLike, options: fs.StatOptions & {
     bigint: true;
 }, callback: Callback<[BigIntStats]>): void;
 export declare function lstat(path: fs.PathLike, options: fs.StatOptions, callback: Callback<[Stats | BigIntStats]>): void;
-/**
- * Asynchronous `truncate`.
- * @param path
- * @param len
- * @param callback
- */
 export declare function truncate(path: fs.PathLike, cb?: Callback): void;
 export declare function truncate(path: fs.PathLike, len: number, cb?: Callback): void;
-/**
- * Asynchronous `unlink`.
- * @param path
- * @param callback
- */
 export declare function unlink(path: fs.PathLike, cb?: Callback): void;
 /**
  * Asynchronous file open.
  * Exclusive mode ensures that path is newly created.
+ * Mode defaults to `0644`
  *
  * `flags` can be:
  *
@@ -91,20 +63,14 @@ export declare function unlink(path: fs.PathLike, cb?: Callback): void;
  * * `'ax+'` - Like 'a+' but opens the file in exclusive mode.
  *
  * @see http://www.manpagez.com/man/2/open/
- * @param path
- * @param flags
- * @param mode defaults to `0644`
- * @param callback
  */
 export declare function open(path: fs.PathLike, flag: string, cb?: Callback<[number]>): void;
 export declare function open(path: fs.PathLike, flag: string, mode: number | string, cb?: Callback<[number]>): void;
 /**
  * Asynchronously reads the entire contents of a file.
- * @param filename
- * @param options
- * @option options encoding The string encoding for the file contents. Defaults to `null`.
- * @option options flag Defaults to `'r'`.
- * @param callback If no encoding is specified, then the raw buffer is returned.
+ * @option encoding The string encoding for the file contents. Defaults to `null`.
+ * @option flag Defaults to `'r'`.
+ * @param cb If no encoding is specified, then the raw buffer is returned.
  */
 export declare function readFile(filename: fs.PathLike, cb: Callback<[Uint8Array]>): void;
 export declare function readFile(filename: fs.PathLike, options: {
@@ -120,13 +86,9 @@ export declare function readFile(filename: fs.PathLike, options: {
  *
  * The encoding option is ignored if data is a buffer.
  *
- * @param filename
- * @param data
- * @param options
  * @option encoding Defaults to `'utf8'`.
  * @option mode Defaults to `0644`.
  * @option flag Defaults to `'w'`.
- * @param callback
  */
 export declare function writeFile(filename: fs.PathLike, data: FileContents, cb?: Callback): void;
 export declare function writeFile(filename: fs.PathLike, data: FileContents, encoding?: BufferEncoding, cb?: Callback): void;
@@ -135,13 +97,9 @@ export declare function writeFile(filename: fs.PathLike, data: FileContents, opt
  * Asynchronously append data to a file, creating the file if it not yet
  * exists.
  *
- * @param filename
- * @param data
- * @param options
  * @option encoding Defaults to `'utf8'`.
  * @option mode Defaults to `0644`.
  * @option flag Defaults to `'a'`.
- * @param callback
  */
 export declare function appendFile(filename: fs.PathLike, data: FileContents, cb?: Callback): void;
 export declare function appendFile(filename: fs.PathLike, data: FileContents, options?: fs.EncodingOption & {
@@ -151,10 +109,7 @@ export declare function appendFile(filename: fs.PathLike, data: FileContents, op
 export declare function appendFile(filename: fs.PathLike, data: FileContents, encoding?: BufferEncoding, cb?: Callback): void;
 /**
  * Asynchronous `fstat`.
- * `fstat()` is identical to `stat()`, except that the file to be stat-ed is
- * specified by the file descriptor `fd`.
- * @param fd
- * @param callback
+ * `fstat()` is identical to `stat()`, except that the file to be stat-ed is specified by the file descriptor `fd`.
  */
 export declare function fstat(fd: number, cb: Callback<[Stats]>): void;
 export declare function fstat(fd: number, options: fs.StatOptions & {
@@ -163,45 +118,20 @@ export declare function fstat(fd: number, options: fs.StatOptions & {
 export declare function fstat(fd: number, options: fs.StatOptions & {
     bigint: true;
 }, cb: Callback<[BigIntStats]>): void;
-/**
- * Asynchronous close.
- * @param fd
- * @param callback
- */
 export declare function close(fd: number, cb?: Callback): void;
-/**
- * Asynchronous ftruncate.
- * @param fd
- * @param len
- * @param callback
- */
 export declare function ftruncate(fd: number, cb?: Callback): void;
 export declare function ftruncate(fd: number, len?: number, cb?: Callback): void;
-/**
- * Asynchronous fsync.
- * @param fd
- * @param callback
- */
 export declare function fsync(fd: number, cb?: Callback): void;
-/**
- * Asynchronous fdatasync.
- * @param fd
- * @param callback
- */
 export declare function fdatasync(fd: number, cb?: Callback): void;
 /**
  * Write buffer to the file specified by `fd`.
- * Note that it is unsafe to use fs.write multiple times on the same file
- * without waiting for the callback.
- * @param fd
- * @param buffer Uint8Array containing the data to write to
- *   the file.
+ * Note that it is unsafe to use fs.write multiple times on the same file without waiting for the callback.
+ * @param buffer Uint8Array containing the data to write to the file.
  * @param offset Offset in the buffer to start reading data from.
  * @param length The amount of bytes to write to the file.
- * @param position Offset from the beginning of the file where this
- *   data should be written. If position is null, the data will be written at
- *   the current position.
- * @param callback The number specifies the number of bytes written into the file.
+ * @param position Offset from the beginning of the file where this data should be written.
+ * If position is null, the data will be written at the current position.
+ * @param cb The number specifies the number of bytes written into the file.
  */
 export declare function write(fd: number, buffer: Uint8Array, offset: number, length: number, cb?: Callback<[number, Uint8Array]>): void;
 export declare function write(fd: number, buffer: Uint8Array, offset: number, length: number, position?: number, cb?: Callback<[number, Uint8Array]>): void;
@@ -210,60 +140,30 @@ export declare function write(fd: number, data: FileContents, position?: number,
 export declare function write(fd: number, data: FileContents, position: number | null, encoding: BufferEncoding, cb?: Callback<[number, string]>): void;
 /**
  * Read data from the file specified by `fd`.
- * @param buffer The buffer that the data will be
- *   written to.
- * @param offset The offset within the buffer where writing will
- *   start.
+ * @param buffer The buffer that the data will be written to.
+ * @param offset The offset within the buffer where writing will start.
  * @param length An integer specifying the number of bytes to read.
- * @param position An integer specifying where to begin reading from
- *   in the file. If position is null, data will be read from the current file
- *   position.
- * @param callback The number is the number of bytes read
+ * @param position An integer specifying where to begin reading from in the file.
+ * If position is null, data will be read from the current file position.
+ * @param cb The number is the number of bytes read
  */
 export declare function read(fd: number, buffer: Uint8Array, offset: number, length: number, position?: number, cb?: Callback<[number, Uint8Array]>): void;
-/**
- * Asynchronous `fchown`.
- * @param fd
- * @param uid
- * @param gid
- * @param callback
- */
 export declare function fchown(fd: number, uid: number, gid: number, cb?: Callback): void;
-/**
- * Asynchronous `fchmod`.
- * @param fd
- * @param mode
- * @param callback
- */
 export declare function fchmod(fd: number, mode: string | number, cb: Callback): void;
 /**
- * Change the file timestamps of a file referenced by the supplied file
- * descriptor.
- * @param fd
- * @param atime
- * @param mtime
- * @param callback
+ * Change the file timestamps of a file referenced by the supplied file descriptor.
  */
 export declare function futimes(fd: number, atime: number | Date, mtime: number | Date, cb?: Callback): void;
-/**
- * Asynchronous `rmdir`.
- * @param path
- * @param callback
- */
 export declare function rmdir(path: fs.PathLike, cb?: Callback): void;
 /**
  * Asynchronous `mkdir`.
- * @param path
  * @param mode defaults to `0777`
- * @param callback
  */
 export declare function mkdir(path: fs.PathLike, mode?: fs.Mode, cb?: Callback): void;
 /**
  * Asynchronous `readdir`. Reads the contents of a directory.
  * The callback gets two arguments `(err, files)` where `files` is an array of
  * the names of the files in the directory excluding `'.'` and `'..'`.
- * @param path
- * @param callback
  */
 export declare function readdir(path: fs.PathLike, cb: Callback<[string[]]>): void;
 export declare function readdir(path: fs.PathLike, options: {
@@ -272,92 +172,37 @@ export declare function readdir(path: fs.PathLike, options: {
 export declare function readdir(path: fs.PathLike, options: {
     withFileTypes: true;
 }, cb: Callback<[Dirent[]]>): void;
-/**
- * Asynchronous `link`.
- * @param existing
- * @param newpath
- * @param callback
- */
 export declare function link(existing: fs.PathLike, newpath: fs.PathLike, cb?: Callback): void;
 /**
  * Asynchronous `symlink`.
  * @param target target path
  * @param path link path
- * @param type can be either `'dir'` or `'file'` (default is `'file'`)
- * @param callback
+ * Type defaults to file
  */
 export declare function symlink(target: fs.PathLike, path: fs.PathLike, cb?: Callback): void;
 export declare function symlink(target: fs.PathLike, path: fs.PathLike, type?: fs.symlink.Type, cb?: Callback): void;
-/**
- * Asynchronous readlink.
- * @param path
- * @param callback
- */
 export declare function readlink(path: fs.PathLike, callback: Callback<[string]> & any): void;
 export declare function readlink(path: fs.PathLike, options: fs.BufferEncodingOption, callback: Callback<[Uint8Array]>): void;
 export declare function readlink(path: fs.PathLike, options: fs.EncodingOption, callback: Callback<[string | Uint8Array]>): void;
 export declare function readlink(path: fs.PathLike, options: fs.EncodingOption, callback: Callback<[string]>): void;
-/**
- * Asynchronous `chown`.
- * @param path
- * @param uid
- * @param gid
- * @param callback
- */
 export declare function chown(path: fs.PathLike, uid: number, gid: number, cb?: Callback): void;
-/**
- * Asynchronous `lchown`.
- * @param path
- * @param uid
- * @param gid
- * @param callback
- */
 export declare function lchown(path: fs.PathLike, uid: number, gid: number, cb?: Callback): void;
-/**
- * Asynchronous `chmod`.
- * @param path
- * @param mode
- * @param callback
- */
 export declare function chmod(path: fs.PathLike, mode: number | string, cb?: Callback): void;
-/**
- * Asynchronous `lchmod`.
- * @param path
- * @param mode
- * @param callback
- */
 export declare function lchmod(path: fs.PathLike, mode: number | string, cb?: Callback): void;
 /**
  * Change file timestamps of the file referenced by the supplied path.
- * @param path
- * @param atime
- * @param mtime
- * @param callback
  */
 export declare function utimes(path: fs.PathLike, atime: number | Date, mtime: number | Date, cb?: Callback): void;
 /**
  * Change file timestamps of the file referenced by the supplied path.
- * @param path
- * @param atime
- * @param mtime
- * @param callback
  */
 export declare function lutimes(path: fs.PathLike, atime: number | Date, mtime: number | Date, cb?: Callback): void;
 /**
  * Asynchronous `realpath`. The callback gets two arguments
  * `(err, resolvedPath)`. May use `process.cwd` to resolve relative paths.
- *
- * @param path
- * @param callback
  */
 export declare function realpath(path: fs.PathLike, cb?: Callback<[string]>): void;
 export declare function realpath(path: fs.PathLike, options: fs.EncodingOption, cb: Callback<[string]>): void;
-/**
- * Asynchronous `access`.
- * @param path
- * @param mode
- * @param callback
- */
 export declare function access(path: fs.PathLike, cb: Callback): void;
 export declare function access(path: fs.PathLike, mode: number, cb: Callback): void;
 /**
@@ -425,7 +270,7 @@ interface WriteStreamOptions extends StreamOptions {
  * @param options Options for the ReadStream and file opening (e.g., `encoding`, `highWaterMark`, `mode`).
  * @returns A ReadStream object for interacting with the file's contents.
  */
-export declare function createReadStream(path: fs.PathLike, _options?: BufferEncoding | ReadStreamOptions): ReadStream;
+export declare function createReadStream(path: fs.PathLike, options?: BufferEncoding | ReadStreamOptions): ReadStream;
 /**
  * Opens a file in write mode and creates a Node.js-like WriteStream.
  *
@@ -433,7 +278,7 @@ export declare function createReadStream(path: fs.PathLike, _options?: BufferEnc
  * @param options Options for the WriteStream and file opening (e.g., `encoding`, `highWaterMark`, `mode`).
  * @returns A WriteStream object for writing to the file.
  */
-export declare function createWriteStream(path: fs.PathLike, _options?: BufferEncoding | WriteStreamOptions): WriteStream;
+export declare function createWriteStream(path: fs.PathLike, options?: BufferEncoding | WriteStreamOptions): WriteStream;
 export declare function rm(path: fs.PathLike, callback: Callback): void;
 export declare function rm(path: fs.PathLike, options: fs.RmOptions, callback: Callback): void;
 /**