@zenfs/core 0.12.1 → 0.12.2

package/dist/emulation/async.d.ts

@@ -4,7 +4,7 @@
 import { Buffer } from 'buffer';
 import type * as fs from 'node:fs';
 import type { FileContents } from '../filesystem.js';
-import { BigIntStats, type BigIntStatsFs, type Stats, type StatsFs } from '../stats.js';
+import { BigIntStats, type Stats } from '../stats.js';
 import { type Callback } from '../utils.js';
 import { Dirent, type Dir } from './dir.js';
 import * as promises from './promises.js';
@@ -441,12 +441,12 @@ export declare function opendir(path: fs.PathLike, cb: Callback<[Dir]>): void;
 export declare function opendir(path: fs.PathLike, options: fs.OpenDirOptions, cb: Callback<[Dir]>): void;
 export declare function cp(source: fs.PathLike, destination: fs.PathLike, callback: Callback): void;
 export declare function cp(source: fs.PathLike, destination: fs.PathLike, opts: fs.CopyOptions, callback: Callback): void;
-export declare function statfs(path: fs.PathLike, callback: Callback<[StatsFs]>): void;
+export declare function statfs(path: fs.PathLike, callback: Callback<[fs.StatsFs]>): void;
 export declare function statfs(path: fs.PathLike, options: fs.StatFsOptions & {
     bigint?: false;
-}, callback: Callback<[StatsFs]>): void;
+}, callback: Callback<[fs.StatsFs]>): void;
 export declare function statfs(path: fs.PathLike, options: fs.StatFsOptions & {
     bigint: true;
-}, callback: Callback<[BigIntStatsFs]>): void;
+}, callback: Callback<[fs.BigIntStatsFs]>): void;
 export declare function openAsBlob(path: fs.PathLike, options?: fs.OpenAsBlobOptions): Promise<Blob>;
 export {};

package/dist/emulation/index.d.ts

@@ -5,4 +5,4 @@ export * as constants from './constants.js';
 export * from './streams.js';
 export * from './dir.js';
 export { mountObject, mounts, mount, umount } from './shared.js';
-export { Stats, BigIntStats, StatsFs } from '../stats.js';
+export { Stats, StatsFs, BigIntStatsFs } from '../stats.js';

package/dist/emulation/index.js

@@ -5,4 +5,4 @@ export * as constants from './constants.js';
 export * from './streams.js';
 export * from './dir.js';
 export { mountObject, mounts, mount, umount } from './shared.js';
-export { Stats, BigIntStats, StatsFs } from '../stats.js';
+export { Stats, StatsFs, BigIntStatsFs } from '../stats.js';

package/dist/emulation/promises.d.ts

@@ -14,7 +14,7 @@ import type { ReadableStream as TReadableStream } from 'node:stream/web';
 import type { Interface as ReadlineInterface } from 'readline';
 import { File } from '../file.js';
 import type { FileContents } from '../filesystem.js';
-import { BigIntStats, type BigIntStatsFs, type Stats, type StatsFs } from '../stats.js';
+import { BigIntStats, type Stats } from '../stats.js';
 import { Dir, Dirent } from './dir.js';
 import { ReadStream, WriteStream } from './streams.js';
 export * as constants from './constants.js';
@@ -437,8 +437,8 @@ export declare function cp(source: fs.PathLike, destination: fs.PathLike, opts?:
  */
 export declare function statfs(path: fs.PathLike, opts?: fs.StatFsOptions & {
     bigint?: false;
-}): Promise<StatsFs>;
+}): Promise<fs.StatsFs>;
 export declare function statfs(path: fs.PathLike, opts: fs.StatFsOptions & {
     bigint: true;
-}): Promise<BigIntStatsFs>;
-export declare function statfs(path: fs.PathLike, opts?: fs.StatFsOptions): Promise<StatsFs | BigIntStatsFs>;
+}): Promise<fs.BigIntStatsFs>;
+export declare function statfs(path: fs.PathLike, opts?: fs.StatFsOptions): Promise<fs.StatsFs | fs.BigIntStatsFs>;

package/dist/emulation/promises.js

@@ -1,12 +1,12 @@
 import { Buffer } from 'buffer';
-import { ErrnoError, Errno } from '../error.js';
+import { Errno, ErrnoError } from '../error.js';
 import { ActionType, isAppendable, isReadable, isWriteable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
 import { BigIntStats, FileType } from '../stats.js';
 import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
-import { cred, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
+import { _statfs, cred, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
 import { ReadStream, WriteStream } from './streams.js';
 export * as constants from './constants.js';
 export class FileHandle {
@@ -386,54 +386,40 @@ async function _open(path, _flag, _mode = 0o644, resolveSymlinks) {
     const mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
     path = resolveSymlinks && (await exists(path)) ? await realpath(path) : path;
     const { fs, path: resolved } = resolveMount(path);
-    try {
-        switch (pathExistsAction(flag)) {
+    if (!(await fs.exists(path, cred))) {
+        switch (pathNotExistsAction(flag)) {
+            case ActionType.CREATE:
+                // Ensure parent exists.
+                const parentStats = await fs.stat(dirname(resolved), cred);
+                if (parentStats && !parentStats.isDirectory()) {
+                    throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
+                }
+                return new FileHandle(await fs.createFile(resolved, flag, mode, cred));
             case ActionType.THROW:
-                throw ErrnoError.With('EEXIST', path, '_open');
-            case ActionType.TRUNCATE:
-                /*
+                throw ErrnoError.With('ENOENT', path, '_open');
+            default:
+                throw new ErrnoError(Errno.EINVAL, 'Invalid file flag');
+        }
+    }
+    switch (pathExistsAction(flag)) {
+        case ActionType.THROW:
+            throw ErrnoError.With('EEXIST', path, '_open');
+        case ActionType.TRUNCATE:
+            /*
                     In a previous implementation, we deleted the file and
                     re-created it. However, this created a race condition if another
                     asynchronous request was trying to read the file, as the file
                     would not exist for a small period of time.
                 */
-                const file = await fs.openFile(resolved, flag, cred);
-                await file.truncate(0);
-                await file.sync();
-                return new FileHandle(file);
-            case ActionType.NOP:
-                // Must await so thrown errors are caught by the catch below
-                return new FileHandle(await fs.openFile(resolved, flag, cred));
-            default:
-                throw new ErrnoError(Errno.EINVAL, 'Invalid file flag');
-        }
-    }
-    catch (_) {
-        const original = _;
-        if (original.code != 'ENOENT') {
-            throw original;
-        }
-        try {
-            switch (pathNotExistsAction(flag)) {
-                case ActionType.CREATE:
-                    // Ensure parent exists.
-                    const parentStats = await fs.stat(dirname(resolved), cred);
-                    if (parentStats && !parentStats.isDirectory()) {
-                        throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
-                    }
-                    return new FileHandle(await fs.createFile(resolved, flag, mode, cred));
-                case ActionType.THROW:
-                    throw ErrnoError.With('ENOENT', path, '_open');
-                default:
-                    throw new ErrnoError(Errno.EINVAL, 'Invalid file flag');
-            }
-        }
-        catch (_) {
-            const ex = _;
-            ex.stack += '\n<original>\n';
-            ex.stack += original.stack;
-            throw ex;
-        }
+            const file = await fs.openFile(resolved, flag, cred);
+            await file.truncate(0);
+            await file.sync();
+            return new FileHandle(file);
+        case ActionType.NOP:
+            // Must await so thrown errors are caught by the catch below
+            return new FileHandle(await fs.openFile(resolved, flag, cred));
+        default:
+            throw new ErrnoError(Errno.EINVAL, 'Invalid file flag');
     }
 }
 /**
@@ -859,5 +845,7 @@ export async function cp(source, destination, opts) {
 }
 cp;
 export async function statfs(path, opts) {
-    throw ErrnoError.With('ENOSYS', path.toString(), 'statfs');
+    path = normalizePath(path);
+    const { fs } = resolveMount(path);
+    return _statfs(fs, opts?.bigint);
 }

package/dist/emulation/shared.d.ts

@@ -1,3 +1,5 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { BigIntStatsFs, StatsFs } from 'node:fs';
 import { Cred } from '../cred.js';
 import type { File } from '../file.js';
 import { FileSystem } from '../filesystem.js';
@@ -35,3 +37,7 @@ export declare function resolveMount(path: string): {
 export declare function fixPaths(text: string, paths: Record<string, string>): string;
 export declare function fixError<E extends Error>(e: E, paths: Record<string, string>): E;
 export declare function mountObject(mounts: MountObject): void;
+/**
+ * @hidden
+ */
+export declare function _statfs<const T extends boolean>(fs: FileSystem, bigint?: T): T extends true ? BigIntStatsFs : StatsFs;

package/dist/emulation/shared.js

@@ -1,7 +1,9 @@
 // Utilities and shared data
-import { ErrnoError, Errno } from '../error.js';
 import { InMemory } from '../backends/memory.js';
 import { rootCred } from '../cred.js';
+import { Errno, ErrnoError } from '../error.js';
+import { size_max } from '../inode.js';
+import { ZenFsType } from '../stats.js';
 import { normalizePath } from '../utils.js';
 import { resolve } from './path.js';
 // credentials
@@ -100,3 +102,19 @@ export function mountObject(mounts) {
         mount(point, fs);
     }
 }
+/**
+ * @hidden
+ */
+export function _statfs(fs, bigint) {
+    const md = fs.metadata();
+    const bs = md.blockSize || 4096;
+    return {
+        type: (bigint ? BigInt : Number)(md.type || ZenFsType),
+        bsize: (bigint ? BigInt : Number)(bs),
+        ffree: (bigint ? BigInt : Number)(md.freeNodes || size_max),
+        files: (bigint ? BigInt : Number)(md.totalNodes || size_max),
+        bavail: (bigint ? BigInt : Number)(md.freeSpace / bs),
+        bfree: (bigint ? BigInt : Number)(md.freeSpace / bs),
+        blocks: (bigint ? BigInt : Number)(md.totalSpace / bs),
+    };
+}

package/dist/emulation/sync.d.ts

@@ -4,7 +4,7 @@
 import { Buffer } from 'buffer';
 import type * as fs from 'node:fs';
 import { FileContents } from '../filesystem.js';
-import { BigIntStats, type BigIntStatsFs, type Stats, type StatsFs } from '../stats.js';
+import { BigIntStats, type Stats } from '../stats.js';
 import { Dir, Dirent } from './dir.js';
 /**
  * Synchronous rename.
@@ -368,8 +368,8 @@ export declare function cpSync(source: fs.PathLike, destination: fs.PathLike, op
  */
 export declare function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions & {
     bigint?: false;
-}): StatsFs;
+}): fs.StatsFs;
 export declare function statfsSync(path: fs.PathLike, options: fs.StatFsOptions & {
     bigint: true;
-}): BigIntStatsFs;
-export declare function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions): StatsFs | BigIntStatsFs;
+}): fs.BigIntStatsFs;
+export declare function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions): fs.StatsFs | fs.BigIntStatsFs;

package/dist/emulation/sync.js

@@ -1,23 +1,12 @@
 import { Buffer } from 'buffer';
-import { ErrnoError, Errno } from '../error.js';
+import { Errno, ErrnoError } from '../error.js';
 import { ActionType, isAppendable, isReadable, isWriteable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
 import { BigIntStats, FileType } from '../stats.js';
 import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import { COPYFILE_EXCL, F_OK, S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK } from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
-import { cred, fd2file, fdMap, fixError, file2fd, mounts, resolveMount } from './shared.js';
-function wrap(...[name, resolveSymlinks, path, ...args]) {
-    path = normalizePath(path);
-    const { fs, path: resolvedPath } = resolveMount(resolveSymlinks && existsSync(path) ? realpathSync(path) : path);
-    try {
-        // @ts-expect-error 2556 (since ...args is not correctly picked up as being a tuple)
-        return fs[name](resolvedPath, ...args);
-    }
-    catch (e) {
-        throw fixError(e, { [resolvedPath]: path });
-    }
-}
+import { _statfs, cred, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
 /**
  * Synchronous rename.
  * @param oldPath
@@ -60,13 +49,27 @@ export function existsSync(path) {
 }
 existsSync;
 export function statSync(path, options) {
-    const stats = wrap('statSync', true, path.toString(), cred);
-    return options?.bigint ? new BigIntStats(stats) : stats;
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+    try {
+        const stats = fs.statSync(resolved, cred);
+        return options?.bigint ? new BigIntStats(stats) : stats;
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 statSync;
 export function lstatSync(path, options) {
-    const stats = wrap('statSync', false, path.toString(), cred);
-    return options?.bigint ? new BigIntStats(stats) : stats;
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(path);
+    try {
+        const stats = fs.statSync(resolved, cred);
+        return options?.bigint ? new BigIntStats(stats) : stats;
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 lstatSync;
 /**
@@ -89,44 +92,37 @@ truncateSync;
  * @param path
  */
 export function unlinkSync(path) {
-    return wrap('unlinkSync', false, path.toString(), cred);
-}
-unlinkSync;
-function _openSync(_path, _flag, _mode, resolveSymlinks = true) {
-    const path = normalizePath(_path), mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
-    // Check if the path exists, and is a file.
-    let stats;
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(path);
     try {
-        stats = wrap('statSync', resolveSymlinks, path, cred);
+        return fs.unlinkSync(resolved, cred);
     }
-    catch (_) {
-        const original = _;
-        if (original.code != 'ENOENT') {
-            throw original;
-        }
-        try {
-            // File does not exist.
-            switch (pathNotExistsAction(flag)) {
-                case ActionType.CREATE:
-                    // Ensure parent exists.
-                    const parentStats = wrap('statSync', resolveSymlinks, dirname(path), cred);
-                    if (!parentStats.isDirectory()) {
-                        throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
-                    }
-                    return wrap('createFileSync', resolveSymlinks, path, flag, mode, cred);
-                case ActionType.THROW:
-                    throw ErrnoError.With('ENOENT', path, '_open');
-                default:
-                    throw new ErrnoError(Errno.EINVAL, 'Invalid FileFlag object.');
-            }
-        }
-        catch (_) {
-            const ex = _;
-            ex.stack += '\n<original>\n';
-            ex.stack += original.stack;
-            throw ex;
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
+}
+unlinkSync;
+function _openSync(path, _flag, _mode, resolveSymlinks = true) {
+    path = normalizePath(path);
+    const mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
+    path = resolveSymlinks && existsSync(path) ? realpathSync(path) : path;
+    const { fs, path: resolved } = resolveMount(path);
+    if (!fs.existsSync(resolved, cred)) {
+        switch (pathNotExistsAction(flag)) {
+            case ActionType.CREATE:
+                // Ensure parent exists.
+                const parentStats = fs.statSync(dirname(resolved), cred);
+                if (!parentStats.isDirectory()) {
+                    throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
+                }
+                return fs.createFileSync(resolved, flag, mode, cred);
+            case ActionType.THROW:
+                throw ErrnoError.With('ENOENT', path, '_open');
+            default:
+                throw new ErrnoError(Errno.EINVAL, 'Invalid FileFlag object.');
         }
     }
+    const stats = fs.statSync(resolved, cred);
     if (!stats.hasAccess(mode, cred)) {
         throw ErrnoError.With('EACCES', path, '_open');
     }
@@ -136,16 +132,16 @@ function _openSync(_path, _flag, _mode, resolveSymlinks = true) {
             throw ErrnoError.With('EEXIST', path, '_open');
         case ActionType.TRUNCATE:
             // Delete file.
-            wrap('unlinkSync', resolveSymlinks, path, cred);
+            fs.unlinkSync(resolved, cred);
             /*
                 Create file. Use the same mode as the old file.
                 Node itself modifies the ctime when this occurs, so this action
                 will preserve that behavior if the underlying file system
                 supports those properties.
             */
-            return wrap('createFileSync', resolveSymlinks, path, flag, stats.mode, cred);
+            return fs.createFileSync(resolved, flag, stats.mode, cred);
         case ActionType.NOP:
-            return wrap('openFileSync', resolveSymlinks, path, flag, cred);
+            return fs.openFileSync(resolved, flag, cred);
         default:
             throw new ErrnoError(Errno.EINVAL, 'Invalid FileFlag object.');
     }
@@ -367,18 +363,39 @@ futimesSync;
  * @param path
  */
 export function rmdirSync(path) {
-    return wrap('rmdirSync', true, path.toString(), cred);
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+    try {
+        fs.rmdirSync(resolved, cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 rmdirSync;
 export function mkdirSync(path, options) {
-    const mode = typeof options == 'number' || typeof options == 'string' ? options : options?.mode;
+    const mode = normalizeMode(typeof options == 'number' || typeof options == 'string' ? options : options?.mode, 0o777);
     const recursive = typeof options == 'object' && options?.recursive;
-    wrap('mkdirSync', true, path.toString(), normalizeMode(mode, 0o777), cred);
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+    try {
+        return fs.mkdirSync(resolved, mode, cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 mkdirSync;
 export function readdirSync(path, options) {
     path = normalizePath(path);
-    const entries = wrap('readdirSync', true, path, cred);
+    const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+    let entries;
+    try {
+        entries = fs.readdirSync(resolved, cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
     for (const mount of mounts.keys()) {
         if (!mount.startsWith(path)) {
             continue;
@@ -408,8 +425,15 @@ readdirSync;
  * @param newpath
  */
 export function linkSync(existing, newpath) {
+    existing = normalizePath(existing);
     newpath = normalizePath(newpath);
-    return wrap('linkSync', false, existing.toString(), newpath.toString(), cred);
+    const { fs, path: resolved } = resolveMount(existing);
+    try {
+        return fs.linkSync(resolved, newpath, cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: existing });
+    }
 }
 linkSync;
 /**
@@ -685,5 +709,7 @@ export function cpSync(source, destination, opts) {
 }
 cpSync;
 export function statfsSync(path, options) {
-    throw ErrnoError.With('ENOSYS', path.toString(), 'statfs');
+    path = normalizePath(path);
+    const { fs } = resolveMount(path);
+    return _statfs(fs, options?.bigint);
 }

package/dist/file.d.ts

@@ -204,7 +204,7 @@ export declare class PreloadFile<FS extends FileSystem> extends File {
     readonly stats: Stats;
     protected _buffer: Uint8Array;
     protected _position: number;
-    protected _dirty: boolean;
+    protected dirty: boolean;
     /**
      * Creates a file with the given path and, optionally, the given contents. Note
      * that, if contents is specified, it will be mutated by the file!
@@ -259,14 +259,14 @@ export declare class PreloadFile<FS extends FileSystem> extends File {
     statSync(): Stats;
     /**
      * Asynchronous truncate.
-     * @param len
+     * @param length
      */
-    truncate(len: number): Promise<void>;
+    truncate(length: number): Promise<void>;
     /**
      * Synchronous truncate.
-     * @param len
+     * @param length
      */
-    truncateSync(len: number): void;
+    truncateSync(length: number): void;
     /**
      * Write buffer to the file.
      * Note that it is unsafe to use fs.write multiple times on the same file
@@ -345,11 +345,6 @@ export declare class PreloadFile<FS extends FileSystem> extends File {
     chownSync(uid: number, gid: number): void;
     utimes(atime: Date, mtime: Date): Promise<void>;
     utimesSync(atime: Date, mtime: Date): void;
-    protected isDirty(): boolean;
-    /**
-     * Resets the dirty bit. Should only be called after a sync has completed successfully.
-     */
-    protected resetDirty(): void;
     _setType(type: FileType): Promise<void>;
     _setTypeSync(type: FileType): void;
 }