@zenfs/core 1.11.4 → 2.0.0

package/dist/backends/port/rpc.d.ts

@@ -1,77 +0,0 @@
-import type { TransferListItem } from 'node:worker_threads';
-import type { WithOptional } from 'utilium';
-import type { ErrnoErrorJSON } from '../../internal/error.js';
-import type { Backend, FilesystemOf } from '../backend.js';
-import type { PortFS } from './fs.js';
-import { type StatsLike } from '../../stats.js';
-type _MessageEvent<T = any> = T | {
-    data: T;
-};
-/** @internal */
-export interface Port {
-    postMessage(value: unknown, transfer?: TransferListItem[]): void;
-    on?(event: 'message' | 'online', listener: (value: unknown) => void): this;
-    off?(event: 'message', listener: (value: unknown) => void): this;
-    addEventListener?(type: 'message', listener: (ev: _MessageEvent) => void): void;
-    removeEventListener?(type: 'message', listener: (ev: _MessageEvent) => void): void;
-}
-export interface Options {
-    /**
-     * The target port that you want to connect to, or the current port if in a port context.
-     */
-    port: Port;
-    /**
-     * How long to wait for a request to complete
-     */
-    timeout?: number;
-}
-/**
- * An RPC message
- */
-export interface Message {
-    _zenfs: true;
-    id: string;
-    method: string;
-    stack: string;
-}
-export interface Request extends Message {
-    args: unknown[];
-}
-interface _ResponseWithError extends Message {
-    error: true;
-    value: WithOptional<ErrnoErrorJSON, 'code' | 'errno'>;
-}
-interface _ResponseWithValue<T> extends Message {
-    error: false;
-    value: Awaited<T> extends File ? FileData : Awaited<T>;
-}
-interface _ResponseRead extends Message {
-    error: false;
-    method: 'read';
-    value: Uint8Array;
-}
-export type Response<T = unknown> = _ResponseWithError | _ResponseWithValue<T> | _ResponseRead;
-export interface FileData {
-    path: string;
-    flag: string;
-    stats: StatsLike<number>;
-}
-export type { FileData as File };
-export declare function isMessage(arg: unknown): arg is Message;
-type _Executor = Parameters<ConstructorParameters<typeof Promise<any>>[0]>;
-export interface Executor {
-    resolve: _Executor[0];
-    reject: _Executor[1];
-    fs?: PortFS;
-}
-export declare function request<const TRequest extends Request, TValue>(request: Omit<TRequest, 'id' | 'stack' | '_zenfs'>, { port, timeout, fs }?: Partial<Options> & {
-    fs?: PortFS;
-}): Promise<TValue>;
-export declare function handleResponse<const TResponse extends Response>(response: TResponse): void;
-export declare function attach<T extends Message>(port: Port, handler: (message: T) => unknown): void;
-export declare function detach<T extends Message>(port: Port, handler: (message: T) => unknown): void;
-export declare function catchMessages<T extends Backend>(port: Port): (fs: FilesystemOf<T>) => Promise<void>;
-/**
- * @internal
- */
-export declare function waitOnline(port: Port): Promise<void>;

package/dist/backends/port/rpc.js

@@ -1,100 +0,0 @@
-import { Errno, ErrnoError } from '../../internal/error.js';
-import { LazyFile } from '../../internal/file.js';
-import { err, info } from '../../internal/log.js';
-import { Stats } from '../../stats.js';
-import { handleRequest } from './fs.js';
-function isFileData(value) {
-    return typeof value == 'object' && value != null && 'path' in value && 'flag' in value;
-}
-// general types
-export function isMessage(arg) {
-    return typeof arg == 'object' && arg != null && '_zenfs' in arg && !!arg._zenfs;
-}
-const executors = new Map();
-export function request(request, { port, timeout = 1000, fs } = {}) {
-    const stack = '\n' + new Error().stack.slice('Error:'.length);
-    if (!port)
-        throw err(new ErrnoError(Errno.EINVAL, 'Can not make an RPC request without a port'));
-    return new Promise((resolve, reject) => {
-        const id = Math.random().toString(16).slice(10);
-        executors.set(id, { resolve, reject, fs });
-        port.postMessage({ ...request, _zenfs: true, id, stack });
-        const _ = setTimeout(() => {
-            const error = err(new ErrnoError(Errno.EIO, 'RPC Failed', typeof request.args[0] == 'string' ? request.args[0] : '', request.method), {
-                fs,
-            });
-            error.stack += stack;
-            reject(error);
-            if (typeof _ == 'object')
-                _.unref();
-        }, timeout);
-    });
-}
-export function handleResponse(response) {
-    if (!isMessage(response)) {
-        return;
-    }
-    const { id, value, error, stack } = response;
-    if (!executors.has(id)) {
-        const error = err(new ErrnoError(Errno.EIO, 'Invalid RPC id:' + id));
-        error.stack += stack;
-        throw error;
-    }
-    const { resolve, reject, fs } = executors.get(id);
-    if (error) {
-        const e = ErrnoError.fromJSON({ code: 'EIO', errno: Errno.EIO, ...value });
-        e.stack += stack;
-        reject(e);
-        executors.delete(id);
-        return;
-    }
-    if (isFileData(value)) {
-        const { path, flag, stats } = value;
-        const file = new LazyFile(fs, path, flag, new Stats(stats));
-        resolve(file);
-        executors.delete(id);
-        return;
-    }
-    resolve(value);
-    executors.delete(id);
-    return;
-}
-export function attach(port, handler) {
-    if (!port)
-        throw err(new ErrnoError(Errno.EINVAL, 'Cannot attach to non-existent port'));
-    info('Attached handler to port: ' + handler.name);
-    port['on' in port ? 'on' : 'addEventListener']('message', (message) => {
-        handler(typeof message == 'object' && message !== null && 'data' in message ? message.data : message);
-    });
-}
-export function detach(port, handler) {
-    if (!port)
-        throw err(new ErrnoError(Errno.EINVAL, 'Cannot detach from non-existent port'));
-    info('Detached handler from port: ' + handler.name);
-    port['off' in port ? 'off' : 'removeEventListener']('message', (message) => {
-        handler(typeof message == 'object' && message !== null && 'data' in message ? message.data : message);
-    });
-}
-export function catchMessages(port) {
-    const events = [];
-    const handler = events.push.bind(events);
-    attach(port, handler);
-    return async function (fs) {
-        detach(port, handler);
-        for (const event of events) {
-            const request = 'data' in event ? event.data : event;
-            await handleRequest(port, fs, request);
-        }
-    };
-}
-/**
- * @internal
- */
-export async function waitOnline(port) {
-    if (!('on' in port))
-        return; // Only need to wait in Node.js
-    const online = Promise.withResolvers();
-    setTimeout(online.reject, 500);
-    port.on('online', online.resolve);
-    await online.promise;
-}

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

@@ -1,20 +0,0 @@
-import type { AsyncMap, SyncMapStore } from './map.js';
-import { SyncMapTransaction } from './map.js';
-import type { Store } from './store.js';
-/**
- * @category Stores and Transactions
- * @deprecated Use `MapStore` instead.
- */
-export type SimpleSyncStore = SyncMapStore;
-/**
- * @category Stores and Transactions
- * @deprecated Use `AsyncMapStore` instead.
- */
-export type SimpleAsyncStore = AsyncMap & Store;
-/**
- * @category Stores and Transactions
- * @deprecated Use `MapTransaction` instead.
- */
-export declare class SimpleTransaction extends SyncMapTransaction {
-    constructor(store: SyncMapStore);
-}

package/dist/backends/store/simple.js

@@ -1,13 +0,0 @@
-import { log_deprecated } from '../../internal/log.js';
-import { SyncMapTransaction } from './map.js';
-/**
- * @category Stores and Transactions
- * @deprecated Use `MapTransaction` instead.
- */
-export class SimpleTransaction extends SyncMapTransaction {
-    constructor(store) {
-        log_deprecated('SimpleTransaction');
-        super(store);
-    }
-}
-/* node:coverage enable */

package/dist/internal/file.d.ts

@@ -1,359 +0,0 @@
-import { Stats, type StatsLike } from '../stats.js';
-import type { FileSystem, StreamOptions } from './filesystem.js';
-import '../polyfills.js';
-/**
- * @internal @hidden
- */
-export declare function parseFlag(flag: string | number): string;
-/**
- * @internal @hidden
- */
-export declare function flagToString(flag: number): string;
-/**
- * @internal @hidden
- */
-export declare function flagToNumber(flag: string): number;
-/**
- * Parses a flag as a mode (W_OK, R_OK, and/or X_OK)
- * @param flag the flag to parse
- * @internal @hidden
- */
-export declare function flagToMode(flag: string): number;
-/** @hidden */
-export declare function isReadable(flag: string): boolean;
-/** @hidden */
-export declare function isWriteable(flag: string): boolean;
-/** @hidden */
-export declare function isTruncating(flag: string): boolean;
-/** @hidden */
-export declare function isAppendable(flag: string): boolean;
-/** @hidden */
-export declare function isSynchronous(flag: string): boolean;
-/** @hidden */
-export declare function isExclusive(flag: string): boolean;
-/** @hidden */
-export interface FileReadResult<T extends ArrayBufferView> {
-    bytesRead: number;
-    buffer: T;
-}
-/**
- * @category Internals
- */
-export declare abstract class File<FS extends FileSystem = FileSystem> {
-    /**
-     * @internal
-     * The file system that created the file
-     */
-    fs: FS;
-    readonly path: string;
-    constructor(
-    /**
-     * @internal
-     * The file system that created the file
-     */
-    fs: FS, path: string);
-    /**
-     * Get the current file position.
-     */
-    abstract position: number;
-    abstract stat(): Promise<Stats>;
-    abstract statSync(): Stats;
-    abstract close(): Promise<void>;
-    abstract closeSync(): void;
-    [Symbol.asyncDispose](): Promise<void>;
-    [Symbol.dispose](): void;
-    abstract truncate(len: number): Promise<void>;
-    abstract truncateSync(len: number): void;
-    abstract sync(): Promise<void>;
-    abstract syncSync(): void;
-    /**
-     * Write buffer to the file.
-     * @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.
-     * @returns Promise resolving to the new length of the buffer
-     */
-    abstract write(buffer: Uint8Array, offset?: number, length?: number, position?: number): Promise<number>;
-    /**
-     * Write buffer to the file.
-     * @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.
-     */
-    abstract writeSync(buffer: Uint8Array, offset?: number, length?: number, position?: number): number;
-    /**
-     * Read data from the file.
-     * @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.
-     * @returns Promise resolving to the new length of the buffer
-     */
-    abstract read<TBuffer extends ArrayBufferView>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<FileReadResult<TBuffer>>;
-    /**
-     * Read data from the file.
-     * @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.
-     */
-    abstract readSync(buffer: ArrayBufferView, offset?: number, length?: number, position?: number): number;
-    /**
-     * Default implementation maps to `sync`.
-     */
-    datasync(): Promise<void>;
-    /**
-     * Default implementation maps to `syncSync`.
-     */
-    datasyncSync(): void;
-    abstract chown(uid: number, gid: number): Promise<void>;
-    abstract chownSync(uid: number, gid: number): void;
-    abstract chmod(mode: number): Promise<void>;
-    abstract chmodSync(mode: number): void;
-    /**
-     * Change the file timestamps of the file.
-     */
-    abstract utimes(atime: number, mtime: number): Promise<void>;
-    /**
-     * Change the file timestamps of the file.
-     */
-    abstract utimesSync(atime: number, mtime: number): void;
-    /**
-     * Create a stream for reading the file.
-     */
-    streamRead(options: StreamOptions): ReadableStream;
-    /**
-     * Create a stream for writing the file.
-     */
-    streamWrite(options: StreamOptions): WritableStream;
-}
-/**
- * An implementation of `File` that operates completely in-memory.
- * `PreloadFile`s are backed by a `Uint8Array`.
- * @category Internals
- */
-export declare class PreloadFile<FS extends FileSystem> extends File<FS> {
-    readonly flag: string;
-    readonly stats: Stats;
-    /**
-     * A buffer containing the entire contents of the file.
-     */
-    protected _buffer: Uint8Array;
-    /**
-     * Current position
-     */
-    protected _position: number;
-    /**
-     * Whether the file has changes which have not been written to the FS
-     */
-    protected dirty: boolean;
-    /**
-     * Whether the file is open or closed
-     */
-    protected closed: boolean;
-    /**
-     * Creates a file with `path` and, optionally, the given contents.
-     * Note that, if contents is specified, it will be mutated by the file.
-     */
-    constructor(fs: FS, path: string, flag: string, stats: Stats, 
-    /**
-     * A buffer containing the entire contents of the file.
-     */
-    _buffer?: Uint8Array);
-    /**
-     * Get the underlying buffer for this file. Mutating not recommended and will mess up dirty tracking.
-     */
-    get buffer(): Uint8Array;
-    /**
-     * Get the current file position.
-     *
-     * We emulate the following bug mentioned in the Node documentation:
-     *
-     * On Linux, positional writes don't work when the file is opened in append mode.
-     * The kernel ignores the position argument and always appends the data to the end of the file.
-     * @returns The current file position.
-     */
-    get position(): number;
-    set position(value: number);
-    sync(): Promise<void>;
-    syncSync(): void;
-    close(): Promise<void>;
-    closeSync(): void;
-    /**
-     * Cleans up. This will *not* sync the file data to the FS
-     */
-    protected dispose(force?: boolean): void;
-    stat(): Promise<Stats>;
-    statSync(): Stats;
-    protected _truncate(length: number): void;
-    truncate(length: number): Promise<void>;
-    truncateSync(length: number): void;
-    protected _write(buffer: Uint8Array, offset?: number, length?: number, position?: number): number;
-    /**
-     * Write buffer to the file.
-     * @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.
-     */
-    write(buffer: Uint8Array, offset?: number, length?: number, position?: number): Promise<number>;
-    /**
-     * Write buffer to the file.
-     * @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.
-     * @returns bytes written
-     */
-    writeSync(buffer: Uint8Array, offset?: number, length?: number, position?: number): number;
-    protected _read(buffer: ArrayBufferView, offset?: number, length?: number, position?: number): number;
-    /**
-     * Read data from the file.
-     * @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.
-     */
-    read<TBuffer extends ArrayBufferView>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<{
-        bytesRead: number;
-        buffer: TBuffer;
-    }>;
-    /**
-     * Read data from the file.
-     * @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.
-     * @returns number of bytes written
-     */
-    readSync(buffer: ArrayBufferView, offset?: number, length?: number, position?: number): number;
-    chmod(mode: number): Promise<void>;
-    chmodSync(mode: number): void;
-    chown(uid: number, gid: number): Promise<void>;
-    chownSync(uid: number, gid: number): void;
-    utimes(atime: number, mtime: number): Promise<void>;
-    utimesSync(atime: number, mtime: number): void;
-}
-/**
- * For the file systems which do not sync to anything.
- * @category Internals
- * @deprecated
- */
-export declare class NoSyncFile<T extends FileSystem> extends PreloadFile<T> {
-    constructor(...args: ConstructorParameters<typeof PreloadFile<T>>);
-    sync(): Promise<void>;
-    syncSync(): void;
-    close(): Promise<void>;
-    closeSync(): void;
-}
-/**
- * An implementation of `File` that uses the FS
- * @category Internals
- */
-export declare class LazyFile<FS extends FileSystem> extends File<FS> {
-    readonly flag: string;
-    readonly stats: StatsLike<number>;
-    protected _buffer?: Uint8Array;
-    /**
-     * Current position
-     */
-    protected _position: number;
-    /**
-     * Get the current file position.
-     *
-     * We emulate the following bug mentioned in the Node documentation:
-     *
-     * On Linux, positional writes don't work when the file is opened in append mode.
-     * The kernel ignores the position argument and always appends the data to the end of the file.
-     * @returns The current file position.
-     */
-    get position(): number;
-    set position(value: number);
-    /**
-     * Whether the file has changes which have not been written to the FS
-     */
-    protected dirty: boolean;
-    /**
-     * Whether the file is open or closed
-     */
-    protected closed: boolean;
-    /**
-     * Creates a file with `path` and, optionally, the given contents.
-     * Note that, if contents is specified, it will be mutated by the file.
-     */
-    constructor(fs: FS, path: string, flag: string, stats: StatsLike<number>);
-    sync(): Promise<void>;
-    syncSync(): void;
-    close(): Promise<void>;
-    closeSync(): void;
-    /**
-     * Cleans up. This will *not* sync the file data to the FS
-     */
-    protected dispose(force?: boolean): void;
-    stat(): Promise<Stats>;
-    statSync(): Stats;
-    truncate(length: number): Promise<void>;
-    truncateSync(length: number): void;
-    protected prepareWrite(buffer: Uint8Array, offset: number, length: number, position: number): Uint8Array;
-    /**
-     * Write buffer to the file.
-     * @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.
-     */
-    write(buffer: Uint8Array, offset?: number, length?: number, position?: number): Promise<number>;
-    /**
-     * Write buffer to the file.
-     * @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.
-     * @returns bytes written
-     */
-    writeSync(buffer: Uint8Array, offset?: number, length?: number, position?: number): number;
-    /**
-     * Computes position information for reading
-     */
-    protected prepareRead(length: number, position: number): number;
-    /**
-     * Read data from the file.
-     * @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 unset, data will be read from the current file position.
-     */
-    read<TBuffer extends ArrayBufferView>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<{
-        bytesRead: number;
-        buffer: TBuffer;
-    }>;
-    /**
-     * Read data from the file.
-     * @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.
-     * @returns number of bytes written
-     */
-    readSync(buffer: ArrayBufferView, offset?: number, length?: number, position?: number): number;
-    chmod(mode: number): Promise<void>;
-    chmodSync(mode: number): void;
-    chown(uid: number, gid: number): Promise<void>;
-    chownSync(uid: number, gid: number): void;
-    utimes(atime: number, mtime: number): Promise<void>;
-    utimesSync(atime: number, mtime: number): void;
-}