@zenfs/core/dist/devices.d.ts

A filesystem, anywhere

import type { FileReadResult } from 'node:fs/promises';
import { InMemoryStore } from './backends/memory.js';
import { StoreFS } from './backends/store/fs.js';
import { File } from './file.js';
import type { StatsLike } from './stats.js';
import { Stats } from './stats.js';
import type { Ino } from './inode.js';
/**
 * A device
 * @todo Maybe add major/minor number or some other device information, like a UUID?
 * @experimental
 */
export interface Device {
    /**
     * The device's driver
     */
    driver: DeviceDriver;
    /**
     * Which inode the device is assigned
     */
    ino: Ino;
}
/**
 * A device driver
 * @experimental
 */
export interface DeviceDriver {
    /**
     * The name of the device driver
     */
    name: string;
    /**
     * Whether the device is buffered (a "block" device) or unbuffered (a "character" device)
     */
    isBuffered: boolean;
    /**
     * Synchronously read from the device
     */
    read(file: DeviceFile, buffer: ArrayBufferView, offset?: number, length?: number, position?: number): number;
    /**
     * Synchronously write to the device
     */
    write(file: DeviceFile, buffer: Uint8Array, offset: number, length: number, position?: number): number;
    /**
     * Sync the device
     */
    sync?(file: DeviceFile): void;
    /**
     * Close the device
     */
    close?(file: DeviceFile): void;
}
/**
 * The base class for device files
 * This class only does some simple things:
 * It implements `truncate` using `write` and it has non-device methods throw.
 * It is up to device drivers to implement the rest of the functionality.
 * @experimental
 */
export declare class DeviceFile extends File {
    fs: DeviceFS;
    readonly device: Device;
    position: number;
    constructor(fs: DeviceFS, path: string, device: Device);
    get driver(): DeviceDriver;
    protected get stats(): Partial<StatsLike>;
    stat(): Promise<Stats>;
    statSync(): Stats;
    readSync(buffer: ArrayBufferView, offset?: number, length?: number, position?: number): number;
    read<TBuffer extends NodeJS.ArrayBufferView>(buffer: TBuffer, offset?: number, length?: number): Promise<FileReadResult<TBuffer>>;
    writeSync(buffer: Uint8Array, offset?: number, length?: number, position?: number): number;
    write(buffer: Uint8Array, offset?: number, length?: number, position?: number): Promise<number>;
    truncate(length: number): Promise<void>;
    truncateSync(length: number): void;
    closeSync(): void;
    close(): Promise<void>;
    syncSync(): void;
    sync(): Promise<void>;
    chown(): Promise<void>;
    chownSync(): void;
    chmod(): Promise<void>;
    chmodSync(): void;
    utimes(): Promise<void>;
    utimesSync(): void;
    _setType(): Promise<void>;
    _setTypeSync(): void;
}
/**
 * @experimental
 */
export declare class DeviceFS extends StoreFS<InMemoryStore> {
    protected readonly devices: Map<string, Device>;
    createDevice(path: string, driver: DeviceDriver): Device;
    constructor();
    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): Promise<File>;
    createFileSync(path: string, flag: string, mode: number): File;
    unlink(path: string): Promise<void>;
    unlinkSync(path: string): void;
    rmdir(path: string): Promise<void>;
    rmdirSync(path: string): void;
    mkdir(path: string, mode: number): Promise<void>;
    mkdirSync(path: string, mode: number): void;
    readdir(path: string): Promise<string[]>;
    readdirSync(path: string): string[];
    link(target: string, link: string): Promise<void>;
    linkSync(target: string, link: string): void;
    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
}
/**
 * Simulates the `/dev/null` device.
 * - Reads return 0 bytes (EOF).
 * - Writes discard data, advancing the file position.
 * @experimental
 */
export declare const nullDevice: DeviceDriver;
/**
 * Simulates the `/dev/zero` device
 * Provides an infinite stream of zeroes when read.
 * Discards any data written to it.
 *
 * - Reads fill the buffer with zeroes.
 * - Writes discard data but update the file position.
 * - Provides basic file metadata, treating it as a character device.
 * @experimental
 */
export declare const zeroDevice: DeviceDriver;
/**
 * Simulates the `/dev/full` device.
 * - Reads behave like `/dev/zero` (returns zeroes).
 * - Writes always fail with ENOSPC (no space left on device).
 * @experimental
 */
export declare const fullDevice: DeviceDriver;
/**
 * Simulates the `/dev/random` device.
 * - Reads return random bytes.
 * - Writes discard data, advancing the file position.
 * @experimental
 */
export declare const randomDevice: DeviceDriver;
/**
 * Shortcuts for importing.
 * @experimental
 */
declare const _default: {
    null: DeviceDriver;
    zero: DeviceDriver;
    full: DeviceDriver;
    random: DeviceDriver;
};
export default _default;