@zenfs/core 1.9.2 → 1.9.4

package/dist/mixins/readonly.js

@@ -1,6 +1,7 @@
 import { Errno, ErrnoError } from '../internal/error.js';
 /**
  * Implements the non-readonly methods to throw `EROFS`
+ * @category Internals
  */
 /* eslint-disable @typescript-eslint/require-await */
 export function Readonly(FS) {

package/dist/mixins/shared.d.ts

@@ -2,6 +2,7 @@ import type { ExtractProperties } from 'utilium';
 import type { FileSystem } from '../internal/filesystem.js';
 /**
  * `TBase` with `TMixin` mixed-in.
+ * @category Internals
  * @internal
  */
 export type Mixin<TBase extends typeof FileSystem, TMixin> = (abstract new (...args: any[]) => TMixin) & TBase;
@@ -19,11 +20,13 @@ export type _AsyncFSKeys = {
 }[_SyncFSKeys];
 /**
  * Asynchronous `FileSystem` methods. This is a convenience type for all of the async operations.
+ * @category Internals
  * @internal
  */
 export type AsyncFSMethods = Pick<FileSystem, _AsyncFSKeys>;
 /**
  * Concrete `FileSystem`. This is a convenience type.
+ * @category Internals
  * @internal
  */
 export type ConcreteFS = ExtractProperties<FileSystem, any>;

package/dist/mixins/sync.d.ts

@@ -2,5 +2,6 @@ import type { FileSystem } from '../internal/filesystem.js';
 import type { AsyncFSMethods, Mixin } from './shared.js';
 /**
  * Implements the asynchronous API in terms of the synchronous API.
+ * @category Internals
  */
 export declare function Sync<T extends abstract new (...args: any[]) => FileSystem>(FS: T): Mixin<T, AsyncFSMethods>;

package/dist/mixins/sync.js

@@ -1,5 +1,6 @@
 /**
  * Implements the asynchronous API in terms of the synchronous API.
+ * @category Internals
  */
 /* eslint-disable @typescript-eslint/require-await */
 export function Sync(FS) {

package/dist/vfs/promises.d.ts

@@ -6,7 +6,7 @@ import type { Interface as ReadlineInterface } from 'readline';
 import type { V_Context } from '../context.js';
 import type { File } from '../internal/file.js';
 import type { Stats } from '../stats.js';
-import type { FileContents, InternalOptions, NullEnc, ReaddirOptions, ReaddirOptsI, ReaddirOptsU } from './types.js';
+import type { FileContents, NullEnc, ReaddirOptions, ReaddirOptsI, ReaddirOptsU } from './types.js';
 import { Buffer } from 'buffer';
 import '../polyfills.js';
 import { BigIntStats } from '../stats.js';
@@ -304,7 +304,7 @@ export declare function access(this: V_Context, path: fs.PathLike, mode?: number
  * Asynchronous `rm`. Removes files or directories (recursively).
  * @param path The path to the file or directory to remove.
  */
-export declare function rm(this: V_Context, path: fs.PathLike, options?: fs.RmOptions & InternalOptions): Promise<void>;
+export declare function rm(this: V_Context, path: fs.PathLike, options?: fs.RmOptions): Promise<void>;
 /**
  * Asynchronous `mkdtemp`. Creates a unique temporary directory.
  * @param prefix The directory prefix.

package/dist/vfs/promises.js

@@ -57,7 +57,6 @@ import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWrit
 import '../polyfills.js';
 import { BigIntStats } from '../stats.js';
 import { decodeUTF8, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
-import * as cache from './cache.js';
 import { config } from './config.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
@@ -459,7 +458,7 @@ export async function unlink(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     try {
-        if (config.checkAccess && !(await (cache.stats.getAsync(path) || fs.stat(resolved))).hasAccess(constants.W_OK, this)) {
+        if (config.checkAccess && !(await fs.stat(resolved)).hasAccess(constants.W_OK, this)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         await fs.unlink(resolved);
@@ -484,37 +483,35 @@ async function applySetId(file, uid, gid) {
  * Opens a file. This helper handles the complexity of file flags.
  * @internal
  */
-async function _open(path, opt) {
+async function _open($, path, opt) {
     var _a;
     path = normalizePath(path);
     const mode = normalizeMode(opt.mode, 0o644), flag = parseFlag(opt.flag);
-    path = opt.preserveSymlinks ? path : await realpath.call(this, path);
-    const { fs, path: resolved } = resolveMount(path, this);
-    const stats = await fs.stat(resolved).catch(() => null);
+    const { fullPath: realpath, fs, path: resolved, stats } = await _resolve($, path.toString(), opt.preserveSymlinks);
     if (!stats) {
         if ((!isWriteable(flag) && !isAppendable(flag)) || flag == 'r+') {
-            throw ErrnoError.With('ENOENT', path, '_open');
+            throw ErrnoError.With('ENOENT', realpath, '_open');
         }
         // Create the file
         const parentStats = await fs.stat(dirname(resolved));
-        if (config.checkAccess && !parentStats.hasAccess(constants.W_OK, this)) {
-            throw ErrnoError.With('EACCES', dirname(path), '_open');
+        if (config.checkAccess && !parentStats.hasAccess(constants.W_OK, $)) {
+            throw ErrnoError.With('EACCES', dirname(realpath), '_open');
         }
         if (!parentStats.isDirectory()) {
-            throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
+            throw ErrnoError.With('ENOTDIR', dirname(realpath), '_open');
         }
-        const { euid: uid, egid: gid } = (_a = this === null || this === void 0 ? void 0 : this.credentials) !== null && _a !== void 0 ? _a : credentials;
+        const { euid: uid, egid: gid } = (_a = $ === null || $ === void 0 ? void 0 : $.credentials) !== null && _a !== void 0 ? _a : credentials;
         const file = await fs.createFile(resolved, flag, mode, { uid, gid });
         await applySetId(file, uid, gid);
-        return new FileHandle(file, this);
+        return new FileHandle(file, $);
     }
-    if (config.checkAccess && !stats.hasAccess(flagToMode(flag), this)) {
-        throw ErrnoError.With('EACCES', path, '_open');
+    if (config.checkAccess && !stats.hasAccess(flagToMode(flag), $)) {
+        throw ErrnoError.With('EACCES', realpath, '_open');
     }
     if (isExclusive(flag)) {
-        throw ErrnoError.With('EEXIST', path, '_open');
+        throw ErrnoError.With('EEXIST', realpath, '_open');
     }
-    const handle = new FileHandle(await fs.openFile(resolved, flag), this);
+    const handle = new FileHandle(await fs.openFile(resolved, flag), $);
     /*
         In a previous implementation, we deleted the file and
         re-created it. However, this created a race condition if another
@@ -533,7 +530,7 @@ async function _open(path, opt) {
  * @param mode Mode to use to open the file. Can be ignored if the filesystem doesn't support permissions.
  */
 export async function open(path, flag = 'r', mode = 0o644) {
-    return await _open.call(this, path, { flag, mode });
+    return await _open(this, path, { flag, mode });
 }
 open;
 export async function readFile(path, _options) {
@@ -625,7 +622,7 @@ export async function rmdir(path) {
     path = await realpath.call(this, path);
     const { fs, path: resolved } = resolveMount(path, this);
     try {
-        const stats = await (cache.stats.getAsync(path) || fs.stat(resolved));
+        const stats = await fs.stat(resolved);
         if (!stats) {
             throw ErrnoError.With('ENOENT', path, 'rmdir');
         }
@@ -688,9 +685,7 @@ export async function readdir(path, options) {
         throw fixError(e, { [resolved]: path });
     };
     const { fs, path: resolved } = resolveMount(path, this);
-    const _stats = cache.stats.getAsync(path) || fs.stat(resolved).catch(handleError);
-    cache.stats.setAsync(path, _stats);
-    const stats = await _stats;
+    const stats = await fs.stat(resolved).catch(handleError);
     if (!stats) {
         throw ErrnoError.With('ENOENT', path, 'readdir');
     }
@@ -705,9 +700,7 @@ export async function readdir(path, options) {
     const addEntry = async (entry) => {
         let entryStats;
         if ((options === null || options === void 0 ? void 0 : options.recursive) || (options === null || options === void 0 ? void 0 : options.withFileTypes)) {
-            const _entryStats = cache.stats.getAsync(join(path, entry)) || fs.stat(join(resolved, entry)).catch(handleError);
-            cache.stats.setAsync(join(path, entry), _entryStats);
-            entryStats = await _entryStats;
+            entryStats = await fs.stat(join(resolved, entry)).catch(handleError);
         }
         if (options === null || options === void 0 ? void 0 : options.withFileTypes) {
             values.push(new Dirent(entry, entryStats));
@@ -720,7 +713,7 @@ export async function readdir(path, options) {
         }
         if (!(options === null || options === void 0 ? void 0 : options.recursive) || !(entryStats === null || entryStats === void 0 ? void 0 : entryStats.isDirectory()))
             return;
-        for (const subEntry of await readdir.call(this, join(path, entry), { ...options, _isIndirect: true })) {
+        for (const subEntry of await readdir.call(this, join(path, entry), options)) {
             if (subEntry instanceof Dirent) {
                 subEntry.path = join(entry, subEntry.path);
                 values.push(subEntry);
@@ -735,9 +728,6 @@ export async function readdir(path, options) {
         }
     };
     await Promise.all(entries.map(addEntry));
-    if (!(options === null || options === void 0 ? void 0 : options._isIndirect)) {
-        cache.stats.clear();
-    }
     return values;
 }
 readdir;
@@ -781,7 +771,7 @@ export async function symlink(target, path, type = 'file') {
         if (await exists.call(this, path)) {
             throw ErrnoError.With('EEXIST', path.toString(), 'symlink');
         }
-        const handle = __addDisposableResource(env_5, await _open.call(this, path, { flag: 'w+', mode: 0o644, preserveSymlinks: true }), true);
+        const handle = __addDisposableResource(env_5, await _open(this, path, { flag: 'w+', mode: 0o644, preserveSymlinks: true }), true);
         await handle.writeFile(target.toString());
         await handle.file.chmod(constants.S_IFLNK);
     }
@@ -799,7 +789,7 @@ symlink;
 export async function readlink(path, options) {
     const env_6 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_6, await _open.call(this, normalizePath(path), { flag: 'r', mode: 0o644, preserveSymlinks: true }), true);
+        const handle = __addDisposableResource(env_6, await _open(this, normalizePath(path), { flag: 'r', mode: 0o644, preserveSymlinks: true }), true);
         const value = await handle.readFile();
         const encoding = typeof options == 'object' ? options === null || options === void 0 ? void 0 : options.encoding : options;
         // always defaults to utf-8 to avoid wrangler (cloudflare) worker "unknown encoding" exception
@@ -836,7 +826,7 @@ chown;
 export async function lchown(path, uid, gid) {
     const env_8 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_8, await _open.call(this, path, {
+        const handle = __addDisposableResource(env_8, await _open(this, path, {
             flag: 'r+',
             mode: 0o644,
             preserveSymlinks: true,
@@ -875,7 +865,7 @@ chmod;
 export async function lchmod(path, mode) {
     const env_10 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_10, await _open.call(this, path, {
+        const handle = __addDisposableResource(env_10, await _open(this, path, {
             flag: 'r+',
             mode: 0o644,
             preserveSymlinks: true,
@@ -920,7 +910,7 @@ utimes;
 export async function lutimes(path, atime, mtime) {
     const env_12 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_12, await _open.call(this, path, {
+        const handle = __addDisposableResource(env_12, await _open(this, path, {
             flag: 'r+',
             mode: 0o644,
             preserveSymlinks: true,
@@ -939,52 +929,64 @@ export async function lutimes(path, atime, mtime) {
     }
 }
 lutimes;
-export async function realpath(path, options) {
-    path = normalizePath(path);
-    const ctx_path = ((this === null || this === void 0 ? void 0 : this.root) || '') + path;
-    if (cache.paths.hasAsync(ctx_path))
-        return cache.paths.getAsync(ctx_path);
+/**
+ * Resolves the mount and real path for a path.
+ * Additionally, any stats fetched will be returned for de-duplication
+ * @internal @hidden
+ */
+async function _resolve($, path, preserveSymlinks) {
+    if (preserveSymlinks) {
+        const resolved = resolveMount(path, $);
+        const stats = await resolved.fs.stat(resolved.path).catch(() => undefined);
+        return { ...resolved, fullPath: path, stats };
+    }
     /* Try to resolve it directly. If this works,
     that means we don't need to perform any resolution for parent directories. */
     try {
-        const { fs, path: resolvedPath } = resolveMount(path, this);
+        const resolved = resolveMount(path, $);
         // Stat it to make sure it exists
-        const stats = await fs.stat(resolvedPath);
-        let real = path.toString();
-        if (stats.isSymbolicLink()) {
-            const target = resolve(dirname(resolvedPath), (await readlink.call(this, resolvedPath, options)).toString());
-            real = cache.paths.get(((this === null || this === void 0 ? void 0 : this.root) || '') + target) || (await realpath.call(this, target));
-            cache.paths.set(ctx_path, real);
+        const stats = await resolved.fs.stat(resolved.path);
+        if (!stats.isSymbolicLink()) {
+            return { ...resolved, fullPath: path, stats };
         }
-        cache.paths.set(path.toString(), real);
-        return real;
+        const target = resolve(dirname(path), (await readlink.call($, path)).toString());
+        return await _resolve($, target);
     }
     catch {
         // Go the long way
     }
     const { base, dir } = parse(path);
-    const realDir = dir == '/' ? '/' : await (cache.paths.getAsync(((this === null || this === void 0 ? void 0 : this.root) || '') + dir) || realpath.call(this, dir));
-    const lpath = join(realDir, base);
-    const { fs, path: resolvedPath } = resolveMount(lpath, this);
+    const realDir = dir == '/' ? '/' : await realpath.call($, dir);
+    const maybePath = join(realDir, base);
+    const resolved = resolveMount(maybePath, $);
     try {
-        const _stats = cache.stats.getAsync(lpath) || fs.stat(resolvedPath);
-        cache.stats.setAsync(lpath, _stats);
-        if (!(await _stats).isSymbolicLink()) {
-            cache.paths.set(path, lpath);
-            return lpath;
+        const stats = await resolved.fs.stat(resolved.path);
+        if (!stats.isSymbolicLink()) {
+            return { ...resolved, fullPath: maybePath, stats };
         }
-        const target = resolve(realDir, (await readlink.call(this, lpath)).toString());
-        const real = cache.paths.getAsync(((this === null || this === void 0 ? void 0 : this.root) || '') + target) || realpath.call(this, target);
-        cache.paths.setAsync(ctx_path, real);
-        return await real;
+        const target = resolve(realDir, (await readlink.call($, maybePath)).toString());
+        const real = await realpath.call($, target);
+        return { ...resolved, fullPath: real, stats };
     }
     catch (e) {
         if (e.code == 'ENOENT') {
-            return path;
+            return { ...resolved, fullPath: path };
         }
-        throw fixError(e, { [resolvedPath]: lpath });
+        throw fixError(e, { [resolved.path]: maybePath });
     }
 }
+export async function realpath(path, options) {
+    var _a;
+    const encoding = typeof options == 'string' ? options : ((_a = options === null || options === void 0 ? void 0 : options.encoding) !== null && _a !== void 0 ? _a : 'utf8');
+    path = normalizePath(path);
+    const { fullPath } = await _resolve(this, path);
+    if (encoding == 'utf8' || encoding == 'utf-8')
+        return fullPath;
+    const buf = Buffer.from(fullPath, 'utf-8');
+    if (encoding == 'buffer')
+        return buf;
+    return buf.toString(encoding);
+}
 realpath;
 export function watch(filename, options = {}) {
     const watcher = new FSWatcher(this, filename.toString(), typeof options !== 'string' ? options : { encoding: options });
@@ -1038,23 +1040,18 @@ access;
  */
 export async function rm(path, options) {
     path = normalizePath(path);
-    const stats = await (cache.stats.getAsync(path) ||
-        lstat.call(this, path).catch((error) => {
-            if (error.code == 'ENOENT' && (options === null || options === void 0 ? void 0 : options.force))
-                return undefined;
-            throw error;
-        }));
-    if (!stats) {
+    const stats = await lstat.call(this, path).catch((error) => {
+        if (error.code == 'ENOENT' && (options === null || options === void 0 ? void 0 : options.force))
+            return undefined;
+        throw error;
+    });
+    if (!stats)
         return;
-    }
-    cache.stats.set(path, stats);
     switch (stats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
             if (options === null || options === void 0 ? void 0 : options.recursive) {
-                for (const entry of await readdir.call(this, path, {
-                    _isIndirect: true,
-                })) {
-                    await rm.call(this, join(path, entry), { ...options, _isIndirect: true });
+                for (const entry of (await readdir.call(this, path))) {
+                    await rm.call(this, join(path, entry), options);
                 }
             }
             await rmdir.call(this, path);
@@ -1068,12 +1065,8 @@ export async function rm(path, options) {
         case constants.S_IFIFO:
         case constants.S_IFSOCK:
         default:
-            cache.stats.clear();
             throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
     }
-    if (!(options === null || options === void 0 ? void 0 : options._isIndirect)) {
-        cache.stats.clear();
-    }
 }
 rm;
 export async function mkdtemp(prefix, options) {

package/dist/vfs/shared.d.ts

@@ -1,6 +1,7 @@
 import type * as fs from 'node:fs';
 import type { File } from '../internal/file.js';
 import type { FileSystem } from '../internal/filesystem.js';
+import type { Stats } from '../stats.js';
 import { type BoundContext, type V_Context } from '../context.js';
 import { ErrnoError } from '../internal/error.js';
 import { type AbsolutePath } from './path.js';
@@ -22,16 +23,19 @@ export declare function fd2file(fd: number): File;
 export type MountObject = Record<AbsolutePath, FileSystem>;
 /**
  * The map of mount points
+ * @category Backends and Configuration
  * @internal
  */
 export declare const mounts: Map<string, FileSystem>;
 /**
  * Mounts the file system at `mountPoint`.
+ * @category Backends and Configuration
  * @internal
  */
 export declare function mount(mountPoint: string, fs: FileSystem): void;
 /**
  * Unmounts the file system at `mountPoint`.
+ * @category Backends and Configuration
  */
 export declare function umount(mountPoint: string): void;
 /**
@@ -43,6 +47,15 @@ export interface ResolvedMount {
     mountPoint: string;
     root: string;
 }
+/**
+ * @internal @hidden
+ */
+export interface ResolvedPath extends ResolvedMount {
+    /** The real, absolute path */
+    fullPath: string;
+    /** Stats */
+    stats?: Stats;
+}
 /**
  * Gets the internal `FileSystem` for the path, then returns it along with the path relative to the FS' root
  * @internal @hidden
@@ -69,7 +82,7 @@ export declare function _statfs<const T extends boolean>(fs: FileSystem, bigint?
 /**
  * Change the root path
  * @param inPlace if true, this changes the root for the current context instead of creating a new one (if associated with a context).
- * @experimental
+ * @category Backends and Configuration
  */
 export declare function chroot(this: V_Context, path: string, inPlace?: false): BoundContext;
 export declare function chroot<T extends V_Context>(this: T, path: string, inPlace: true): T;

package/dist/vfs/shared.js

@@ -4,10 +4,8 @@ import { bindContext } from '../context.js';
 import { Errno, ErrnoError } from '../internal/error.js';
 import { alert, debug, err, info, log_deprecated, notice, warn } from '../internal/log.js';
 import { normalizePath } from '../utils.js';
-import { paths as pathCache } from './cache.js';
 import { size_max } from './constants.js';
 import { join, resolve } from './path.js';
-import { ZenFsType } from '../stats.js';
 // descriptors
 /**
  * @internal @hidden
@@ -33,6 +31,7 @@ export function fd2file(fd) {
 }
 /**
  * The map of mount points
+ * @category Backends and Configuration
  * @internal
  */
 export const mounts = new Map();
@@ -40,6 +39,7 @@ export const mounts = new Map();
 mount('/', InMemory.create({ name: 'root' }));
 /**
  * Mounts the file system at `mountPoint`.
+ * @category Backends and Configuration
  * @internal
  */
 export function mount(mountPoint, fs) {
@@ -53,10 +53,10 @@ export function mount(mountPoint, fs) {
     mounts.set(mountPoint, fs);
     info(`Mounted ${fs.name} on ${mountPoint}`);
     debug(`${fs.name} attributes: ${[...fs.attributes].map(([k, v]) => (v !== undefined && v !== null ? k + '=' + v : v)).join(', ')}`);
-    pathCache.clear();
 }
 /**
  * Unmounts the file system at `mountPoint`.
+ * @category Backends and Configuration
  */
 export function umount(mountPoint) {
     if (mountPoint[0] != '/')
@@ -67,7 +67,6 @@ export function umount(mountPoint) {
         return;
     }
     mounts.delete(mountPoint);
-    pathCache.clear();
     notice('Unmounted ' + mountPoint);
 }
 /**
@@ -82,9 +81,8 @@ export function resolveMount(path, ctx) {
         // We know path is normalized, so it would be a substring of the mount point.
         if (_isParentOf(mountPoint, path)) {
             path = path.slice(mountPoint.length > 1 ? mountPoint.length : 0); // Resolve the path relative to the mount point
-            if (path === '') {
+            if (path === '')
                 path = root;
-            }
             return { fs, path, mountPoint, root };
         }
     }

package/dist/vfs/sync.d.ts

@@ -1,7 +1,7 @@
 import type * as fs from 'node:fs';
 import type { V_Context } from '../context.js';
 import type { Stats } from '../stats.js';
-import type { FileContents, InternalOptions, NullEnc, ReaddirOptions, ReaddirOptsI, ReaddirOptsU } from './types.js';
+import type { FileContents, NullEnc, ReaddirOptions, ReaddirOptsI, ReaddirOptsU } from './types.js';
 import { Buffer } from 'buffer';
 import { BigIntStats } from '../stats.js';
 import { Dir, Dirent } from './dir.js';
@@ -155,7 +155,7 @@ export declare function accessSync(this: V_Context, path: fs.PathLike, mode?: nu
  * Synchronous `rm`. Removes files or directories (recursively).
  * @param path The path to the file or directory to remove.
  */
-export declare function rmSync(this: V_Context, path: fs.PathLike, options?: fs.RmOptions & InternalOptions): void;
+export declare function rmSync(this: V_Context, path: fs.PathLike, options?: fs.RmOptions): void;
 /**
  * Synchronous `mkdtemp`. Creates a unique temporary directory.
  * @param prefix The directory prefix.