@zenfs/core 1.11.4 → 2.1.0

package/dist/backends/backend.d.ts

@@ -1,6 +1,9 @@
 import type { RequiredKeys } from 'utilium';
 import type { FileSystem } from '../internal/filesystem.js';
-type OptionType = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function' | (abstract new (...args: any[]) => any);
+type OptionType = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function' | string | ((arg: any) => boolean) | {
+    [Symbol.hasInstance](instance: any): boolean;
+    toString(): string;
+};
 /**
  * Resolves the type of Backend.options from the options interface
  * @category Backends and Configuration
@@ -8,24 +11,17 @@ type OptionType = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undef
 export type OptionsConfig<T> = {
     [K in keyof T]: {
         /**
-         * The basic JavaScript type(s) for this option.
+         * The type of the option. Can be a:
+         * - string given by `typeof`
+         * - string that is the name of the class (e.g. `'Map'`)
+         * - object with a `Symbol.hasInstance` property
+         * - function that returns a boolean
          */
         type: OptionType | readonly OptionType[];
-        /**
-         * Description of the option. Used in error messages and documentation.
-         * @deprecated
-         */
-        description?: string;
         /**
          * Whether or not the option is required (optional can be set to null or undefined). Defaults to false.
          */
         required: K extends RequiredKeys<T> ? true : false;
-        /**
-         * A custom validation function to check if the option is valid.
-         * When async, resolves if valid and rejects if not.
-         * When sync, it will throw an error if not valid.
-         */
-        validator?(opt: T[K]): void | Promise<void>;
     };
 };
 /**
@@ -64,7 +60,7 @@ export interface Backend<FS extends FileSystem = FileSystem, TOptions extends ob
      * 'false' if the API is unavailable
      *
      */
-    isAvailable?(): boolean | Promise<boolean>;
+    isAvailable?(config: TOptions): boolean | Promise<boolean>;
 }
 /**
  * Gets the options type of a backend
@@ -83,12 +79,20 @@ export type FilesystemOf<T extends Backend> = T extends Backend<infer FS> ? FS :
  * @internal
  */
 export declare function isBackend(arg: unknown): arg is Backend;
+/**
+ * Use a function as the type of an option, but don't treat it as a class.
+ *
+ * Optionally sets the name of a function, useful for error messages.
+ * @category Backends and Configuration
+ * @internal
+ */
+export declare function _fnOpt<const T>(name: string | null | undefined, fn: (arg: T) => boolean): (arg: T) => boolean;
 /**
  * Checks that `options` object is valid for the file system options.
  * @category Backends and Configuration
  * @internal
  */
-export declare function checkOptions<T extends Backend>(backend: T, options: Record<string, unknown>): Promise<void>;
+export declare function checkOptions<T extends Backend>(backend: T, options: Record<string, unknown>): void;
 /**
  * Specifies a file system backend type and its options.
  *

package/dist/backends/backend.js

@@ -1,5 +1,6 @@
-import { Errno, ErrnoError } from '../internal/error.js';
-import { debug, err } from '../internal/log.js';
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-redundant-type-constituents */
+import { withErrno } from 'kerium';
+import { debug, err } from 'kerium/log';
 /**
  * @category Backends and Configuration
  * @internal
@@ -7,38 +8,54 @@ import { debug, err } from '../internal/log.js';
 export function isBackend(arg) {
     return arg != null && typeof arg == 'object' && 'create' in arg && typeof arg.create == 'function';
 }
+/**
+ * Use a function as the type of an option, but don't treat it as a class.
+ *
+ * Optionally sets the name of a function, useful for error messages.
+ * @category Backends and Configuration
+ * @internal
+ */
+export function _fnOpt(name, fn) {
+    Object.defineProperty(fn, 'prototype', { value: undefined });
+    if (name)
+        Object.defineProperty(fn, 'name', { value: name });
+    return fn;
+}
 /**
  * Checks that `options` object is valid for the file system options.
  * @category Backends and Configuration
  * @internal
  */
-export async function checkOptions(backend, options) {
+export function checkOptions(backend, options) {
     if (typeof options != 'object' || options === null) {
-        throw err(new ErrnoError(Errno.EINVAL, 'Invalid options'));
+        throw err(withErrno('EINVAL', 'Invalid options'));
     }
     // Check for required options.
     for (const [optName, opt] of Object.entries(backend.options)) {
         const value = options === null || options === void 0 ? void 0 : options[optName];
         if (value === undefined || value === null) {
             if (!opt.required) {
-                debug('Missing non-required option: ' + optName);
+                debug('Using default for option: ' + optName);
                 continue;
             }
-            throw err(new ErrnoError(Errno.EINVAL, 'Missing required option: ' + optName));
-        }
-        const isType = (type, _ = value) => (typeof type == 'function' ? value instanceof type : typeof value === type);
-        if (Array.isArray(opt.type) ? !opt.type.some(v => isType(v)) : !isType(opt.type)) {
-            // The type of the value as a string
-            const type = typeof value == 'object' && 'constructor' in value ? value.constructor.name : typeof value;
-            // The expected type (as a string)
-            const name = (type) => (typeof type == 'function' ? type.name : type);
-            const expected = Array.isArray(opt.type) ? `one of ${opt.type.map(name).join(', ')}` : name(opt.type);
-            throw err(new ErrnoError(Errno.EINVAL, `Incorrect type for "${optName}": ${type} (expected ${expected})`));
+            throw err(withErrno('EINVAL', 'Missing required option: ' + optName));
         }
-        debug('Using custom validator for option: ' + optName);
-        if (opt.validator)
-            await opt.validator(value);
-        // Otherwise: All good!
+        const isType = (type, _ = value) => {
+            var _a;
+            return typeof type == 'function'
+                ? Symbol.hasInstance in type && type.prototype
+                    ? value instanceof type
+                    : type(value)
+                : typeof value === type || ((_a = value === null || value === void 0 ? void 0 : value.constructor) === null || _a === void 0 ? void 0 : _a.name) === type;
+        };
+        if (Array.isArray(opt.type) ? opt.type.some(v => isType(v)) : isType(opt.type))
+            continue;
+        // The type of the value as a string
+        const type = typeof value == 'object' && 'constructor' in value ? value.constructor.name : typeof value;
+        // The expected type (as a string)
+        const name = (type) => (typeof type == 'function' ? (type.name != 'type' ? type.name : type.toString()) : type);
+        const expected = Array.isArray(opt.type) ? `one of ${opt.type.map(name).join(', ')}` : name(opt.type);
+        throw err(withErrno('EINVAL', `Incorrect type for "${optName}": ${type} (expected ${expected})`));
     }
 }
 /**

package/dist/backends/cow.d.ts

@@ -1,10 +1,8 @@
-import type { File } from '../internal/file.js';
 import type { CreationOptions, StreamOptions, UsageInfo } from '../internal/filesystem.js';
 import type { InodeLike } from '../internal/inode.js';
-import type { Stats } from '../stats.js';
-import { FileSystem } from '../internal/filesystem.js';
 import { EventEmitter } from 'eventemitter3';
 import { type MountConfiguration } from '../config.js';
+import { FileSystem } from '../internal/filesystem.js';
 /**
  * Configuration options for CoW.
  * @category Backends and Configuration
@@ -17,16 +15,14 @@ export interface CopyOnWriteOptions {
     /** @see {@link Journal} */
     journal?: Journal;
 }
-/**
- *  @hidden @deprecated use `CopyOnWriteOptions`
- */
-export type OverlayOptions = CopyOnWriteOptions;
 declare const journalOperations: readonly ["delete"];
 /**
+ * @category Internals
  * @internal
  */
 export type JournalOperation = (typeof journalOperations)[number];
 /**
+ * @category Internals
  * @internal
  */
 export interface JournalEntry {
@@ -35,6 +31,7 @@ export interface JournalEntry {
 }
 /**
  * Tracks various operations for the CoW backend
+ * @category Internals
  * @internal
  */
 export declare class Journal extends EventEmitter<{
@@ -54,6 +51,7 @@ export declare class Journal extends EventEmitter<{
 /**
  * Using a readable file system as a base, writes are done to a writable file system.
  * @internal
+ * @category Internals
  */
 export declare class CopyOnWriteFS extends FileSystem {
     /** The file system that initially populates this file system. */
@@ -75,28 +73,28 @@ export declare class CopyOnWriteFS extends FileSystem {
      * @todo Consider trying to track information on the writable as well
      */
     usage(): UsageInfo;
-    sync(path: string, data: Uint8Array, stats: Readonly<InodeLike>): Promise<void>;
-    syncSync(path: string, data: Uint8Array, stats: Readonly<InodeLike>): void;
+    sync(): Promise<void>;
+    syncSync(): void;
     read(path: string, buffer: Uint8Array, offset: number, end: number): Promise<void>;
     readSync(path: string, buffer: Uint8Array, offset: number, end: number): void;
     write(path: string, buffer: Uint8Array, offset: number): Promise<void>;
     writeSync(path: string, buffer: Uint8Array, offset: number): void;
     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;
-    createFile(path: string, flag: string, mode: number, options: CreationOptions): Promise<File>;
-    createFileSync(path: string, flag: string, mode: number, options: CreationOptions): File;
+    stat(path: string): Promise<InodeLike>;
+    statSync(path: string): InodeLike;
+    touch(path: string, metadata: InodeLike): Promise<void>;
+    touchSync(path: string, metadata: InodeLike): void;
+    createFile(path: string, options: CreationOptions): Promise<InodeLike>;
+    createFileSync(path: string, options: CreationOptions): InodeLike;
     link(srcpath: string, dstpath: string): Promise<void>;
     linkSync(srcpath: string, dstpath: string): void;
     unlink(path: string): Promise<void>;
     unlinkSync(path: string): void;
     rmdir(path: string): Promise<void>;
     rmdirSync(path: string): void;
-    mkdir(path: string, mode: number, options: CreationOptions): Promise<void>;
-    mkdirSync(path: string, mode: number, options: CreationOptions): void;
+    mkdir(path: string, options: CreationOptions): Promise<InodeLike>;
+    mkdirSync(path: string, options: CreationOptions): InodeLike;
     readdir(path: string): Promise<string[]>;
     readdirSync(path: string): string[];
     streamRead(path: string, options: StreamOptions): ReadableStream;
@@ -125,11 +123,6 @@ export declare class CopyOnWriteFS extends FileSystem {
     private copyToWritableSync;
     private copyToWritable;
 }
-/**
- * @hidden @deprecated use `CopyOnWriteFS`
- */
-export declare class OverlayFS extends CopyOnWriteFS {
-}
 declare const _CopyOnWrite: {
     readonly name: "CopyOnWrite";
     readonly options: {
@@ -149,21 +142,18 @@ declare const _CopyOnWrite: {
     readonly create: (options: CopyOnWriteOptions) => Promise<CopyOnWriteFS>;
 };
 type _CopyOnWrite = typeof _CopyOnWrite;
-export interface CopyOnWrite extends _CopyOnWrite {
-}
 /**
  * Overlay makes a read-only filesystem writable by storing writes on a second, writable file system.
  * Deletes are persisted via metadata stored on the writable file system.
  * @category Backends and Configuration
- * @internal
  */
-export declare const CopyOnWrite: CopyOnWrite;
-export interface Overlay extends _CopyOnWrite {
+export interface CopyOnWrite extends _CopyOnWrite {
 }
 /**
- * @deprecated Use `CopyOnWrite`
+ * Overlay makes a read-only filesystem writable by storing writes on a second, writable file system.
+ * Deletes are persisted via metadata stored on the writable file system.
  * @category Backends and Configuration
- * @internal @hidden
+ * @internal
  */
-export declare const Overlay: Overlay;
+export declare const CopyOnWrite: CopyOnWrite;
 export {};