@zenfs/core 1.6.17 → 1.7.0

package/dist/backends/backend.js

@@ -1,4 +1,4 @@
-import { ErrnoError, Errno } from '../error.js';
+import { Errno, ErrnoError } from '../error.js';
 /** @internal */
 export function isBackend(arg) {
     return arg != null && typeof arg == 'object' && 'create' in arg && typeof arg.create == 'function';

package/dist/backends/fetch.d.ts

@@ -1,7 +1,7 @@
 import type { FileSystemMetadata } from '../filesystem.js';
 import type { Stats } from '../stats.js';
-import { IndexFS } from './file_index.js';
 import type { IndexData } from './file_index.js';
+import { IndexFS } from './file_index.js';
 /**
  * Configuration options for FetchFS.
  */

package/dist/backends/file_index.js

@@ -1,12 +1,12 @@
 /* Note: this file is named file_index.ts because Typescript has special behavior regarding index.ts which can't be disabled. */
 import { isJSON } from 'utilium';
-import { basename, dirname } from '../emulation/path.js';
 import { Errno, ErrnoError } from '../error.js';
 import { NoSyncFile, isWriteable } from '../file.js';
 import { FileSystem } from '../filesystem.js';
 import { Readonly } from '../mixins/readonly.js';
 import { Stats } from '../stats.js';
 import { decodeUTF8, encodeUTF8 } from '../utils.js';
+import { basename, dirname } from '../vfs/path.js';
 export const version = 1;
 /**
  * An index of files

package/dist/backends/index.d.ts

@@ -0,0 +1,11 @@
+export * from './backend.js';
+export * from './fetch.js';
+export * from './file_index.js';
+export * from './memory.js';
+export * from './overlay.js';
+export * from './passthrough.js';
+export * from './port/fs.js';
+export * from './store/fs.js';
+export * from './store/inode.js';
+export * from './store/simple.js';
+export * from './store/store.js';

package/dist/backends/index.js

@@ -0,0 +1,11 @@
+export * from './backend.js';
+export * from './fetch.js';
+export * from './file_index.js';
+export * from './memory.js';
+export * from './overlay.js';
+export * from './passthrough.js';
+export * from './port/fs.js';
+export * from './store/fs.js';
+export * from './store/inode.js';
+export * from './store/simple.js';
+export * from './store/store.js';

package/dist/backends/overlay.d.ts

@@ -1,7 +1,7 @@
 import type { File } from '../file.js';
-import type { FileSystemMetadata } from '../filesystem.js';
-import { FileSystem } from '../filesystem.js';
+import type { CreationOptions, FileSystemMetadata } from '../filesystem.js';
 import type { Stats } from '../stats.js';
+import { FileSystem } from '../filesystem.js';
 /**
  * Configuration options for OverlayFS instances.
  */
@@ -51,16 +51,16 @@ export declare class UnmutexedOverlayFS extends FileSystem {
     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;
+    createFile(path: string, flag: string, mode: number, options: CreationOptions): Promise<File>;
+    createFileSync(path: string, flag: string, mode: number, options: CreationOptions): File;
     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): Promise<void>;
-    mkdirSync(path: string, mode: number): void;
+    mkdir(path: string, mode: number, options: CreationOptions): Promise<void>;
+    mkdirSync(path: string, mode: number, options: CreationOptions): void;
     readdir(path: string): Promise<string[]>;
     readdirSync(path: string): string[];
     private deletePath;

package/dist/backends/overlay.js

@@ -50,12 +50,12 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { dirname } from '../emulation/path.js';
 import { Errno, ErrnoError } from '../error.js';
 import { PreloadFile, parseFlag } from '../file.js';
 import { FileSystem } from '../filesystem.js';
 import { Mutexed } from '../mixins/mutexed.js';
 import { decodeUTF8, encodeUTF8 } from '../utils.js';
+import { dirname } from '../vfs/path.js';
 /** @internal */
 const deletionLogPath = '/.deleted';
 /**
@@ -98,7 +98,7 @@ export class UnmutexedOverlayFS extends FileSystem {
     async sync(path, data, stats) {
         await this.copyForWrite(path);
         if (!(await this.writable.exists(path))) {
-            await this.writable.createFile(path, 'w', 0o644);
+            await this.writable.createFile(path, 'w', 0o644, stats);
         }
         await this.writable.sync(path, data, stats);
     }
@@ -216,14 +216,14 @@ export class UnmutexedOverlayFS extends FileSystem {
         file.readSync(data);
         return new PreloadFile(this, path, flag, stats, data);
     }
-    async createFile(path, flag, mode) {
+    async createFile(path, flag, mode, options) {
         this.checkInitialized();
-        await this.writable.createFile(path, flag, mode);
+        await this.writable.createFile(path, flag, mode, options);
         return this.openFile(path, flag);
     }
-    createFileSync(path, flag, mode) {
+    createFileSync(path, flag, mode, options) {
         this.checkInitialized();
-        this.writable.createFileSync(path, flag, mode);
+        this.writable.createFileSync(path, flag, mode, options);
         return this.openFileSync(path, flag);
     }
     async link(srcpath, dstpath) {
@@ -298,23 +298,23 @@ export class UnmutexedOverlayFS extends FileSystem {
         }
         void this.deletePath(path);
     }
-    async mkdir(path, mode) {
+    async mkdir(path, mode, options) {
         this.checkInitialized();
         if (await this.exists(path)) {
             throw ErrnoError.With('EEXIST', path, 'mkdir');
         }
         // The below will throw should any of the parent directories fail to exist on _writable.
         await this.createParentDirectories(path);
-        await this.writable.mkdir(path, mode);
+        await this.writable.mkdir(path, mode, options);
     }
-    mkdirSync(path, mode) {
+    mkdirSync(path, mode, options) {
         this.checkInitialized();
         if (this.existsSync(path)) {
             throw ErrnoError.With('EEXIST', path, 'mkdir');
         }
         // The below will throw should any of the parent directories fail to exist on _writable.
         this.createParentDirectoriesSync(path);
-        this.writable.mkdirSync(path, mode);
+        this.writable.mkdirSync(path, mode, options);
     }
     async readdir(path) {
         this.checkInitialized();
@@ -426,7 +426,8 @@ export class UnmutexedOverlayFS extends FileSystem {
             parent = dirname(parent);
         }
         for (const path of toCreate.reverse()) {
-            this.writable.mkdirSync(path, this.statSync(path).mode);
+            const { uid, gid, mode } = this.statSync(path);
+            this.writable.mkdirSync(path, mode, { uid, gid });
         }
     }
     /**
@@ -441,8 +442,8 @@ export class UnmutexedOverlayFS extends FileSystem {
             parent = dirname(parent);
         }
         for (const path of toCreate.reverse()) {
-            const stats = await this.stat(path);
-            await this.writable.mkdir(path, stats.mode);
+            const { uid, gid, mode } = await this.stat(path);
+            await this.writable.mkdir(path, mode, { uid, gid });
         }
     }
     /**
@@ -481,13 +482,13 @@ export class UnmutexedOverlayFS extends FileSystem {
         try {
             const stats = this.statSync(path);
             if (stats.isDirectory()) {
-                this.writable.mkdirSync(path, stats.mode);
+                this.writable.mkdirSync(path, stats.mode, stats);
                 return;
             }
             const data = new Uint8Array(stats.size);
             const readable = __addDisposableResource(env_1, this.readable.openFileSync(path, 'r'), false);
             readable.readSync(data);
-            const writable = __addDisposableResource(env_1, this.writable.createFileSync(path, 'w', stats.mode | 0o222), false);
+            const writable = __addDisposableResource(env_1, this.writable.createFileSync(path, 'w', stats.mode | 0o222, stats), false);
             writable.writeSync(data);
         }
         catch (e_1) {
@@ -503,13 +504,13 @@ export class UnmutexedOverlayFS extends FileSystem {
         try {
             const stats = await this.stat(path);
             if (stats.isDirectory()) {
-                await this.writable.mkdir(path, stats.mode);
+                await this.writable.mkdir(path, stats.mode, stats);
                 return;
             }
             const data = new Uint8Array(stats.size);
             const readable = __addDisposableResource(env_2, await this.readable.openFile(path, 'r'), true);
             await readable.read(data);
-            const writable = __addDisposableResource(env_2, await this.writable.createFile(path, 'w', stats.mode | 0o222), true);
+            const writable = __addDisposableResource(env_2, await this.writable.createFile(path, 'w', stats.mode | 0o222, stats), true);
             await writable.write(data);
         }
         catch (e_2) {

package/dist/backends/passthrough.d.ts

@@ -0,0 +1,118 @@
+import type * as fs from 'node:fs';
+import { FileSystem } from '../filesystem.js';
+import { Stats } from '../stats.js';
+import { File } from '../file.js';
+export type NodeFS = typeof fs;
+export interface PassthroughOptions {
+    fs: NodeFS;
+    prefix?: string;
+}
+export declare class PassthroughFS extends FileSystem {
+    readonly nodeFS: NodeFS;
+    readonly prefix: string;
+    constructor(nodeFS: NodeFS, prefix: string);
+    path(path: string): string;
+    error(err: unknown, path: string): never;
+    /**
+     * Rename a file or directory.
+     */
+    rename(oldPath: string, newPath: string): Promise<void>;
+    /**
+     * Rename a file or directory synchronously.
+     */
+    renameSync(oldPath: string, newPath: string): void;
+    /**
+     * Get file statistics.
+     */
+    stat(path: string): Promise<Stats>;
+    /**
+     * Get file statistics synchronously.
+     */
+    statSync(path: string): Stats;
+    /**
+     * Open a file.
+     */
+    openFile(path: string, flag: string): Promise<File>;
+    /**
+     * Open a file synchronously.
+     */
+    openFileSync(path: string, flag: string): File;
+    /**
+     * Unlink (delete) a file.
+     */
+    unlink(path: string): Promise<void>;
+    /**
+     * Unlink (delete) a file synchronously.
+     */
+    unlinkSync(path: string): void;
+    /**
+     * Create a directory.
+     */
+    mkdir(path: string, mode: number): Promise<void>;
+    /**
+     * Create a directory synchronously.
+     */
+    mkdirSync(path: string, mode: number): void;
+    /**
+     * Read the contents of a directory.
+     */
+    readdir(path: string): Promise<string[]>;
+    /**
+     * Read the contents of a directory synchronously.
+     */
+    readdirSync(path: string): string[];
+    /**
+     * Create a file.
+     */
+    createFile(path: string, flag: string, mode: number): Promise<File>;
+    /**
+     * Create a file synchronously.
+     */
+    createFileSync(path: string, flag: string, mode: number): File;
+    /**
+     * Remove a directory.
+     */
+    rmdir(path: string): Promise<void>;
+    /**
+     * Remove a directory synchronously.
+     */
+    rmdirSync(path: string): void;
+    /**
+     * Synchronize data to the file system.
+     */
+    sync(path: string, data: Uint8Array, stats: Stats): Promise<void>;
+    /**
+     * Synchronize data to the file system synchronously.
+     */
+    syncSync(path: string, data: Uint8Array, stats: Stats): void;
+    /**
+     * Create a hard link.
+     */
+    link(target: string, link: string): Promise<void>;
+    /**
+     * Create a hard link synchronously.
+     */
+    linkSync(target: string, link: string): void;
+}
+declare const _Passthrough: {
+    readonly name: "Passthrough";
+    readonly options: {
+        readonly fs: {
+            readonly type: "object";
+            readonly required: true;
+        };
+        readonly prefix: {
+            readonly type: "string";
+            readonly required: false;
+        };
+    };
+    readonly create: ({ fs, prefix }: PassthroughOptions) => PassthroughFS;
+};
+type _Passthrough = typeof _Passthrough;
+export interface Passthrough extends _Passthrough {
+}
+/**
+ * A file system that passes through to another FS
+ */
+export declare const Passthrough: Passthrough;
+export {};

package/dist/backends/passthrough.js

@@ -0,0 +1,337 @@
+import { FileSystem } from '../filesystem.js';
+import { ErrnoError } from '../error.js';
+import { Stats } from '../stats.js';
+import { File } from '../file.js';
+import { join, resolve } from '../vfs/path.js';
+class PassthroughFile extends File {
+    constructor(fs, path, fd) {
+        super(fs, path);
+        this.fd = fd;
+        this.node = fs.nodeFS;
+        this.nodePath = fs.path(path);
+    }
+    error(err) {
+        const error = err;
+        return ErrnoError.With(error.code, this.path, error.syscall);
+    }
+    get position() {
+        // Placeholder: Implement proper position tracking if needed.
+        return 0;
+    }
+    async stat() {
+        const { resolve, reject, promise } = Promise.withResolvers();
+        this.node.fstat(this.fd, (err, stats) => (err ? reject(this.error(err)) : resolve(new Stats(stats))));
+        return promise;
+    }
+    statSync() {
+        return new Stats(this.node.fstatSync(this.fd));
+    }
+    close() {
+        const { resolve, reject, promise } = Promise.withResolvers();
+        this.node.close(this.fd, err => (err ? reject(this.error(err)) : resolve()));
+        return promise;
+    }
+    closeSync() {
+        this.node.closeSync(this.fd);
+    }
+    async truncate(len) {
+        await this.node.promises.truncate(this.nodePath, len);
+    }
+    truncateSync(len) {
+        this.node.ftruncateSync(this.fd, len);
+    }
+    async sync() {
+        const { resolve, reject, promise } = Promise.withResolvers();
+        this.node.fsync(this.fd, err => (err ? reject(this.error(err)) : resolve()));
+        return promise;
+    }
+    syncSync() {
+        this.node.fsyncSync(this.fd);
+    }
+    async write(buffer, offset, length, position) {
+        const { resolve, reject, promise } = Promise.withResolvers();
+        this.node.write(this.fd, buffer, offset, length, position, (err, written) => (err ? reject(this.error(err)) : resolve(written)));
+        return promise;
+    }
+    writeSync(buffer, offset, length, position) {
+        return this.node.writeSync(this.fd, buffer, offset, length, position);
+    }
+    async read(buffer, offset = 0, length, position = null) {
+        const { resolve, reject, promise } = Promise.withResolvers();
+        this.node.read(this.fd, buffer, offset, length || (await this.stat()).size, position, (err, bytesRead, buffer) => err ? reject(this.error(err)) : resolve({ bytesRead, buffer }));
+        return promise;
+    }
+    readSync(buffer, offset = 0, length = this.statSync().size, position = null) {
+        return this.node.readSync(this.fd, buffer, offset, length, position);
+    }
+    async chmod(mode) {
+        await this.node.promises.chmod(this.nodePath, mode);
+    }
+    chmodSync(mode) {
+        this.node.fchmodSync(this.fd, mode);
+    }
+    async chown(uid, gid) {
+        await this.node.promises.chown(this.nodePath, uid, gid);
+    }
+    chownSync(uid, gid) {
+        this.node.fchownSync(this.fd, uid, gid);
+    }
+    async utimes(atime, mtime) {
+        await this.node.promises.utimes(this.nodePath, atime, mtime);
+    }
+    utimesSync(atime, mtime) {
+        this.node.futimesSync(this.fd, atime, mtime);
+    }
+}
+export class PassthroughFS extends FileSystem {
+    constructor(nodeFS, prefix) {
+        super();
+        this.nodeFS = nodeFS;
+        this.prefix = prefix;
+    }
+    path(path) {
+        return join(this.prefix, path.slice(1));
+    }
+    error(err, path) {
+        const error = err;
+        throw ErrnoError.With(error.code, path, error.syscall);
+    }
+    /**
+     * Rename a file or directory.
+     */
+    async rename(oldPath, newPath) {
+        try {
+            await this.nodeFS.promises.rename(this.path(oldPath), this.path(newPath));
+        }
+        catch (err) {
+            this.error(err, oldPath);
+        }
+    }
+    /**
+     * Rename a file or directory synchronously.
+     */
+    renameSync(oldPath, newPath) {
+        try {
+            this.nodeFS.renameSync(this.path(oldPath), this.path(newPath));
+        }
+        catch (err) {
+            this.error(err, oldPath);
+        }
+    }
+    /**
+     * Get file statistics.
+     */
+    async stat(path) {
+        try {
+            return new Stats(await this.nodeFS.promises.stat(this.path(path)));
+        }
+        catch (err) {
+            this.error(err, path);
+        }
+    }
+    /**
+     * Get file statistics synchronously.
+     */
+    statSync(path) {
+        try {
+            return new Stats(this.nodeFS.statSync(this.path(path)));
+        }
+        catch (err) {
+            this.error(err, path);
+        }
+    }
+    /**
+     * Open a file.
+     */
+    async openFile(path, flag) {
+        try {
+            const { fd } = await this.nodeFS.promises.open(this.path(path), flag);
+            return new PassthroughFile(this, path, fd);
+        }
+        catch (err) {
+            this.error(err, path);
+        }
+    }
+    /**
+     * Open a file synchronously.
+     */
+    openFileSync(path, flag) {
+        try {
+            const fd = this.nodeFS.openSync(this.path(path), flag);
+            return new PassthroughFile(this, path, fd);
+        }
+        catch (err) {
+            this.error(err, path);
+        }
+    }
+    /**
+     * Unlink (delete) a file.
+     */
+    async unlink(path) {
+        try {
+            await this.nodeFS.promises.unlink(this.path(path));
+        }
+        catch (err) {
+            this.error(err, path);
+        }
+    }
+    /**
+     * Unlink (delete) a file synchronously.
+     */
+    unlinkSync(path) {
+        try {
+            this.nodeFS.unlinkSync(this.path(path));
+        }
+        catch (err) {
+            this.error(err, path);
+        }
+    }
+    /**
+     * Create a directory.
+     */
+    async mkdir(path, mode) {
+        try {
+            await this.nodeFS.promises.mkdir(this.path(path), { mode });
+        }
+        catch (err) {
+            this.error(err, path);
+        }
+    }
+    /**
+     * Create a directory synchronously.
+     */
+    mkdirSync(path, mode) {
+        try {
+            this.nodeFS.mkdirSync(this.path(path), { mode });
+        }
+        catch (err) {
+            this.error(err, path);
+        }
+    }
+    /**
+     * Read the contents of a directory.
+     */
+    async readdir(path) {
+        try {
+            return await this.nodeFS.promises.readdir(this.path(path));
+        }
+        catch (err) {
+            this.error(err, path);
+        }
+    }
+    /**
+     * Read the contents of a directory synchronously.
+     */
+    readdirSync(path) {
+        try {
+            return this.nodeFS.readdirSync(this.path(path));
+        }
+        catch (err) {
+            this.error(err, path);
+        }
+    }
+    /**
+     * Create a file.
+     */
+    async createFile(path, flag, mode) {
+        try {
+            const { fd } = await this.nodeFS.promises.open(this.path(path), flag, mode);
+            return new PassthroughFile(this, path, fd);
+        }
+        catch (err) {
+            this.error(err, path);
+        }
+    }
+    /**
+     * Create a file synchronously.
+     */
+    createFileSync(path, flag, mode) {
+        try {
+            const fd = this.nodeFS.openSync(this.path(path), flag, mode);
+            return new PassthroughFile(this, path, fd);
+        }
+        catch (err) {
+            this.error(err, path);
+        }
+    }
+    /**
+     * Remove a directory.
+     */
+    async rmdir(path) {
+        try {
+            await this.nodeFS.promises.rmdir(this.path(path));
+        }
+        catch (err) {
+            this.error(err, path);
+        }
+    }
+    /**
+     * Remove a directory synchronously.
+     */
+    rmdirSync(path) {
+        try {
+            this.nodeFS.rmdirSync(this.path(path));
+        }
+        catch (err) {
+            this.error(err, path);
+        }
+    }
+    /**
+     * Synchronize data to the file system.
+     */
+    async sync(path, data, stats) {
+        try {
+            await this.nodeFS.promises.writeFile(this.path(path), data);
+        }
+        catch (err) {
+            this.error(err, path);
+        }
+    }
+    /**
+     * Synchronize data to the file system synchronously.
+     */
+    syncSync(path, data, stats) {
+        try {
+            this.nodeFS.writeFileSync(this.path(path), data);
+        }
+        catch (err) {
+            this.error(err, path);
+        }
+    }
+    /**
+     * Create a hard link.
+     */
+    async link(target, link) {
+        try {
+            await this.nodeFS.promises.link(this.path(target), this.path(link));
+        }
+        catch (err) {
+            this.error(err, target);
+        }
+    }
+    /**
+     * Create a hard link synchronously.
+     */
+    linkSync(target, link) {
+        try {
+            this.nodeFS.linkSync(this.path(target), this.path(link));
+        }
+        catch (err) {
+            this.error(err, target);
+        }
+    }
+}
+const _Passthrough = {
+    name: 'Passthrough',
+    options: {
+        fs: { type: 'object', required: true },
+        prefix: { type: 'string', required: false },
+    },
+    create({ fs, prefix = '/' }) {
+        return new PassthroughFS(fs, resolve(prefix));
+    },
+};
+/**
+ * A file system that passes through to another FS
+ */
+export const Passthrough = _Passthrough;