@zenfs/core 1.11.4 → 2.1.0

package/tests/setup/port.ts

@@ -1,3 +1,4 @@
+import { after } from 'node:test';
 import { MessageChannel } from 'node:worker_threads';
 import { InMemory, Port, configureSingle, fs, resolveMountConfig, resolveRemoteMount } from '../../dist/index.js';
 import { copySync, data } from '../setup.js';
@@ -5,7 +6,7 @@ import { copySync, data } from '../setup.js';
 const { port1: localPort, port2: remotePort } = new MessageChannel();
 
 fs.umount('/');
-const tmpfs = await resolveMountConfig({ backend: InMemory, name: 'tmp' });
+const tmpfs = await resolveMountConfig({ backend: InMemory, label: 'tmp' });
 
 fs.mount('/', tmpfs);
 copySync(data, fs);
@@ -13,3 +14,8 @@ copySync(data, fs);
 await resolveRemoteMount(remotePort, tmpfs);
 
 await configureSingle({ backend: Port, port: localPort });
+
+after(() => {
+	localPort.close();
+	remotePort.close();
+});

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

@@ -1,84 +0,0 @@
-import type { ExtractProperties } from 'utilium';
-import type { Inode, InodeLike } from '../..//internal/inode.js';
-import type { MountConfiguration } from '../../config.js';
-import type { File } from '../../internal/file.js';
-import type { CreationOptions, UsageInfo } from '../../internal/filesystem.js';
-import type { Backend, FilesystemOf } from '../backend.js';
-import { FileSystem } from '../../internal/filesystem.js';
-import { Stats } from '../../stats.js';
-import * as RPC from './rpc.js';
-type FSMethods = ExtractProperties<FileSystem, (...args: any[]) => Promise<any> | UsageInfo>;
-type FSMethod = keyof FSMethods;
-export type FSRequest<TMethod extends FSMethod = FSMethod> = RPC.Message & {
-    [M in TMethod]: {
-        method: M;
-        args: Parameters<FSMethods[M]>;
-    };
-}[TMethod];
-declare const PortFS_base: import("../../index.js").Mixin<typeof FileSystem, import("../../mixins/async.js").AsyncMixin>;
-/**
- * PortFS lets you access an FS instance that is running in a port, or the other way around.
- *
- * Note that *direct* synchronous operations are not permitted on the PortFS,
- * regardless of the configuration option of the remote FS.
- */
-export declare class PortFS extends PortFS_base {
-    readonly options: RPC.Options;
-    readonly port: RPC.Port;
-    /**`
-     * @hidden
-     */
-    _sync: import("../index.js").StoreFS<import("../memory.js").InMemoryStore>;
-    /**
-     * Constructs a new PortFS instance that connects with the FS running on `options.port`.
-     */
-    constructor(options: RPC.Options);
-    protected rpc<const T extends FSMethod>(method: T, ...args: Parameters<FSMethods[T]>): Promise<Awaited<ReturnType<FSMethods[T]>>>;
-    ready(): Promise<void>;
-    rename(oldPath: string, newPath: string): Promise<void>;
-    stat(path: string): Promise<Stats>;
-    sync(path: string, data: Uint8Array | undefined, stats: Readonly<InodeLike | Inode>): Promise<void>;
-    openFile(path: string, flag: string): Promise<File>;
-    createFile(path: string, flag: string, mode: number, options: CreationOptions): Promise<File>;
-    unlink(path: string): Promise<void>;
-    rmdir(path: string): Promise<void>;
-    mkdir(path: string, mode: number, options: CreationOptions): Promise<void>;
-    readdir(path: string): Promise<string[]>;
-    exists(path: string): Promise<boolean>;
-    link(srcpath: string, dstpath: string): Promise<void>;
-    read(path: string, buffer: Uint8Array, offset: number, length: number): Promise<void>;
-    write(path: string, buffer: Uint8Array, offset: number): Promise<void>;
-}
-/** @internal */
-export declare function handleRequest(port: RPC.Port, fs: FileSystem & {
-    _descriptors?: Map<number, File>;
-}, request: FSRequest): Promise<void>;
-export declare function attachFS(port: RPC.Port, fs: FileSystem): void;
-export declare function detachFS(port: RPC.Port, fs: FileSystem): void;
-declare const _Port: {
-    name: string;
-    options: {
-        port: {
-            type: "object";
-            required: true;
-            validator(port: RPC.Port): void;
-        };
-        timeout: {
-            type: "number";
-            required: false;
-        };
-    };
-    create(options: RPC.Options): PortFS;
-};
-type _Port = typeof _Port;
-export interface Port extends _Port {
-}
-/**
- * @category Backends and Configuration
- */
-export declare const Port: Port;
-/**
- * @category Backends and Configuration
- */
-export declare function resolveRemoteMount<T extends Backend>(port: RPC.Port, config: MountConfiguration<T>, _depth?: number): Promise<FilesystemOf<T>>;
-export {};

package/dist/backends/port/fs.js

@@ -1,151 +0,0 @@
-import { pick } from 'utilium';
-import { resolveMountConfig } from '../../config.js';
-import { Errno, ErrnoError } from '../../internal/error.js';
-import { FileSystem } from '../../internal/filesystem.js';
-import { err, info } from '../../internal/log.js';
-import { Async } from '../../mixins/async.js';
-import { Stats } from '../../stats.js';
-import { InMemory } from '../memory.js';
-import * as RPC from './rpc.js';
-/**
- * PortFS lets you access an FS instance that is running in a port, or the other way around.
- *
- * Note that *direct* synchronous operations are not permitted on the PortFS,
- * regardless of the configuration option of the remote FS.
- */
-export class PortFS extends Async(FileSystem) {
-    /**
-     * Constructs a new PortFS instance that connects with the FS running on `options.port`.
-     */
-    constructor(options) {
-        super(0x706f7274, 'portfs');
-        this.options = options;
-        /**`
-         * @hidden
-         */
-        this._sync = InMemory.create({ name: 'tmpfs:port' });
-        this.port = options.port;
-        RPC.attach(this.port, RPC.handleResponse);
-    }
-    rpc(method, ...args) {
-        return RPC.request({ method, args }, {
-            ...this.options,
-            fs: this,
-        });
-    }
-    async ready() {
-        await this.rpc('ready');
-        await super.ready();
-    }
-    rename(oldPath, newPath) {
-        return this.rpc('rename', oldPath, newPath);
-    }
-    async stat(path) {
-        return new Stats(await this.rpc('stat', path));
-    }
-    sync(path, data, stats) {
-        stats = 'toJSON' in stats ? stats.toJSON() : stats;
-        return this.rpc('sync', path, data, stats);
-    }
-    openFile(path, flag) {
-        return this.rpc('openFile', path, flag);
-    }
-    createFile(path, flag, mode, options) {
-        return this.rpc('createFile', path, flag, mode, options);
-    }
-    unlink(path) {
-        return this.rpc('unlink', path);
-    }
-    rmdir(path) {
-        return this.rpc('rmdir', path);
-    }
-    mkdir(path, mode, options) {
-        return this.rpc('mkdir', path, mode, options);
-    }
-    readdir(path) {
-        return this.rpc('readdir', path);
-    }
-    exists(path) {
-        return this.rpc('exists', path);
-    }
-    link(srcpath, dstpath) {
-        return this.rpc('link', srcpath, dstpath);
-    }
-    async read(path, buffer, offset, length) {
-        const _buf = (await this.rpc('read', path, buffer, offset, length));
-        buffer.set(_buf);
-    }
-    write(path, buffer, offset) {
-        return this.rpc('write', path, buffer, offset);
-    }
-}
-/** @internal */
-export async function handleRequest(port, fs, request) {
-    if (!RPC.isMessage(request))
-        return;
-    const { method, args, id, stack } = request;
-    let value, error = false;
-    try {
-        // @ts-expect-error 2556
-        value = await fs[method](...args);
-        switch (method) {
-            case 'openFile':
-            case 'createFile': {
-                value = {
-                    path: args[0],
-                    flag: args[1],
-                    stats: await fs.stat(args[0]),
-                };
-                break;
-            }
-            case 'read':
-                value = args[1];
-                break;
-        }
-    }
-    catch (e) {
-        value = e instanceof ErrnoError ? e.toJSON() : pick(e, 'message', 'stack');
-        error = true;
-    }
-    port.postMessage({ _zenfs: true, id, error, method, stack, value });
-}
-export function attachFS(port, fs) {
-    RPC.attach(port, request => handleRequest(port, fs, request));
-}
-export function detachFS(port, fs) {
-    RPC.detach(port, request => handleRequest(port, fs, request));
-}
-const _Port = {
-    name: 'Port',
-    options: {
-        port: {
-            type: 'object',
-            required: true,
-            validator(port) {
-                // Check for a `postMessage` function.
-                if (typeof (port === null || port === void 0 ? void 0 : port.postMessage) != 'function') {
-                    throw err(new ErrnoError(Errno.EINVAL, 'option must be a port'));
-                }
-            },
-        },
-        timeout: { type: 'number', required: false },
-    },
-    create(options) {
-        return new PortFS(options);
-    },
-};
-/**
- * @category Backends and Configuration
- */
-export const Port = _Port;
-/**
- * @category Backends and Configuration
- */
-export async function resolveRemoteMount(port, config, _depth = 0) {
-    const stopAndReplay = RPC.catchMessages(port);
-    const fs = await resolveMountConfig(config, _depth);
-    attachFS(port, fs);
-    await stopAndReplay(fs);
-    info('Resolved remote mount: ' + fs.toString());
-    return fs;
-}

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 */