@zenfs/core 0.16.0 → 0.16.1

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

@@ -6,9 +6,17 @@ import type { Cred } from '../../cred.js';
 import { File } from '../../file.js';
 import { FileSystem, type FileSystemMetadata } from '../../filesystem.js';
 import { Stats, type FileType } from '../../stats.js';
+import type { Backend, FilesystemOf } from '../backend.js';
 import * as RPC from './rpc.js';
+import { type MountConfiguration } from '../../config.js';
 type FileMethods = Omit<ExtractProperties<File, (...args: any[]) => Promise<any>>, typeof Symbol.asyncDispose>;
 type FileMethod = keyof FileMethods;
+interface FileRequest<TMethod extends FileMethod = FileMethod> extends RPC.Request {
+    fd: number;
+    scope: 'file';
+    method: TMethod;
+    args: Parameters<FileMethods[TMethod]>;
+}
 export declare class PortFile extends File {
     readonly fs: PortFS;
     readonly fd: number;
@@ -40,6 +48,11 @@ export declare class PortFile extends File {
 }
 type FSMethods = ExtractProperties<FileSystem, (...args: any[]) => Promise<any> | FileSystemMetadata>;
 type FSMethod = keyof FSMethods;
+interface FSRequest<TMethod extends FSMethod = FSMethod> extends RPC.Request {
+    scope: 'fs';
+    method: TMethod;
+    args: Parameters<FSMethods[TMethod]>;
+}
 declare const PortFS_base: import("../../filesystem.js").Mixin<typeof FileSystem, {
     _sync?: FileSystem | undefined;
     queueDone(): Promise<void>;
@@ -88,6 +101,14 @@ export declare class PortFS extends PortFS_base {
     exists(path: string, cred: Cred): Promise<boolean>;
     link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
 }
+/**
+ * @internal
+ */
+export type FileOrFSRequest = FSRequest | FileRequest;
+/**
+ * @internal
+ */
+export declare function handleRequest(port: RPC.Port, fs: FileSystem, request: FileOrFSRequest): Promise<void>;
 export declare function attachFS(port: RPC.Port, fs: FileSystem): void;
 export declare function detachFS(port: RPC.Port, fs: FileSystem): void;
 export declare const Port: {
@@ -108,4 +129,5 @@ export declare const Port: {
     isAvailable(): Promise<boolean>;
     create(options: RPC.Options): PortFS;
 };
+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

@@ -4,6 +4,7 @@ import { Async, FileSystem } from '../../filesystem.js';
 import { Stats } from '../../stats.js';
 import { InMemory } from '../memory.js';
 import * as RPC from './rpc.js';
+import { resolveMountConfig } from '../../config.js';
 export class PortFile extends File {
     constructor(fs, fd, path, position) {
         super();
@@ -159,7 +160,10 @@ export class PortFS extends Async(FileSystem) {
 }
 let nextFd = 0;
 const descriptors = new Map();
-async function handleRequest(port, fs, request) {
+/**
+ * @internal
+ */
+export async function handleRequest(port, fs, request) {
     if (!RPC.isMessage(request)) {
         return;
     }
@@ -233,3 +237,10 @@ export const Port = {
         return new PortFS(options);
     },
 };
+export async function resolveRemoteMount(port, config, _depth = 0) {
+    const stopAndReplay = RPC.catchMessages(port);
+    const fs = await resolveMountConfig(config, _depth);
+    attachFS(port, fs);
+    stopAndReplay(fs);
+    return fs;
+}

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

@@ -1,5 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
 import { type ErrnoErrorJSON } from '../../error.js';
+import type { Backend, FilesystemOf } from '../backend.js';
 import { type PortFS } from './fs.js';
 type _MessageEvent<T = any> = T | {
     data: T;
@@ -62,3 +63,4 @@ export declare function request<const TRequest extends Request, TValue>(request:
 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>) => void;

package/dist/backends/port/rpc.js

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Errno, ErrnoError } from '../../error.js';
-import { PortFile } from './fs.js';
+import { handleRequest, PortFile } from './fs.js';
 function isFileData(value) {
     return typeof value == 'object' && value != null && 'fd' in value && 'path' in value && 'position' in value;
 }
@@ -72,3 +72,15 @@ export function detach(port, handler) {
         handler('data' in message ? message.data : message);
     });
 }
+export function catchMessages(port) {
+    const events = [];
+    const handler = events.push.bind(events);
+    attach(port, handler);
+    return function (fs) {
+        detach(port, handler);
+        for (const event of events) {
+            const request = 'data' in event ? event.data : event;
+            handleRequest(port, fs, request);
+        }
+    };
+}