@zenfs/core 1.9.2 → 1.9.4

package/dist/vfs/sync.js

@@ -56,7 +56,6 @@ import { Errno, ErrnoError } from '../internal/error.js';
 import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../internal/file.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';
@@ -154,7 +153,7 @@ export function unlinkSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     try {
-        if (config.checkAccess && !(cache.stats.get(path) || fs.statSync(resolved)).hasAccess(constants.W_OK, this)) {
+        if (config.checkAccess && !fs.statSync(resolved).hasAccess(constants.W_OK, this)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         fs.unlinkSync(resolved);
@@ -426,7 +425,7 @@ export function rmdirSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(realpathSync.call(this, path), this);
     try {
-        const stats = cache.stats.get(path) || fs.statSync(resolved);
+        const stats = fs.statSync(resolved);
         if (!stats.isDirectory()) {
             throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
         }
@@ -484,8 +483,7 @@ export function readdirSync(path, options) {
     const { fs, path: resolved } = resolveMount(realpathSync.call(this, path), this);
     let entries;
     try {
-        const stats = cache.stats.get(path) || fs.statSync(resolved);
-        cache.stats.set(path, stats);
+        const stats = fs.statSync(resolved);
         if (config.checkAccess && !stats.hasAccess(constants.R_OK, this)) {
             throw ErrnoError.With('EACCES', resolved, 'readdir');
         }
@@ -500,8 +498,7 @@ export function readdirSync(path, options) {
     // Iterate over entries and handle recursive case if needed
     const values = [];
     for (const entry of entries) {
-        const entryStat = cache.stats.get(join(path, entry)) || fs.statSync(join(resolved, entry));
-        cache.stats.set(join(path, entry), entryStat);
+        const entryStat = fs.statSync(join(resolved, entry));
         if (options === null || options === void 0 ? void 0 : options.withFileTypes) {
             values.push(new Dirent(entry, entryStat));
         }
@@ -513,7 +510,7 @@ export function readdirSync(path, options) {
         }
         if (!entryStat.isDirectory() || !(options === null || options === void 0 ? void 0 : options.recursive))
             continue;
-        for (const subEntry of readdirSync.call(this, join(path, entry), { ...options, _isIndirect: true })) {
+        for (const subEntry of readdirSync.call(this, join(path, entry), options)) {
             if (subEntry instanceof Dirent) {
                 subEntry.path = join(entry, subEntry.path);
                 values.push(subEntry);
@@ -526,9 +523,6 @@ export function readdirSync(path, options) {
             }
         }
     }
-    if (!(options === null || options === void 0 ? void 0 : options._isIndirect)) {
-        cache.stats.clear();
-    }
     return values;
 }
 readdirSync;
@@ -627,52 +621,64 @@ export function lutimesSync(path, atime, mtime) {
     closeSync(fd);
 }
 lutimesSync;
-export function realpathSync(path, options) {
-    path = normalizePath(path);
-    const ctx_path = ((this === null || this === void 0 ? void 0 : this.root) || '') + path;
-    if (cache.paths.has(ctx_path))
-        return cache.paths.get(ctx_path);
+/**
+ * Resolves the mount and real path for a path.
+ * Additionally, any stats fetched will be returned for de-duplication
+ * @internal @hidden
+ */
+function _resolveSync($, path, preserveSymlinks) {
+    if (preserveSymlinks) {
+        const resolved = resolveMount(path, $);
+        const stats = resolved.fs.statSync(resolved.path);
+        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 = fs.statSync(resolvedPath);
-        let real = path;
-        if (stats.isSymbolicLink()) {
-            const target = resolve(dirname(resolvedPath), readlinkSync.call(this, resolvedPath, options).toString());
-            real = cache.paths.get(((this === null || this === void 0 ? void 0 : this.root) || '') + target) || realpathSync.call(this, target);
-            cache.paths.set(ctx_path, real);
+        const stats = resolved.fs.statSync(resolved.path);
+        if (!stats.isSymbolicLink()) {
+            return { ...resolved, fullPath: path, stats };
         }
-        cache.paths.set(path, real);
-        return real;
+        const target = resolve(dirname(path), readlinkSync.call($, path).toString());
+        return _resolveSync($, target);
     }
     catch {
         // Go the long way
     }
     const { base, dir } = parse(path);
-    const realDir = dir == '/' ? '/' : cache.paths.get(((this === null || this === void 0 ? void 0 : this.root) || '') + dir) || realpathSync.call(this, dir);
-    const lpath = join(realDir, base);
-    const { fs, path: resolvedPath } = resolveMount(lpath, this);
+    const realDir = dir == '/' ? '/' : realpathSync.call($, dir);
+    const maybePath = join(realDir, base);
+    const resolved = resolveMount(maybePath, $);
     try {
-        const stats = cache.stats.get(lpath) || fs.statSync(resolvedPath);
-        cache.stats.set(lpath, stats);
+        const stats = resolved.fs.statSync(resolved.path);
         if (!stats.isSymbolicLink()) {
-            cache.paths.set(path, lpath);
-            return lpath;
+            return { ...resolved, fullPath: maybePath, stats };
         }
-        const target = resolve(realDir, readlinkSync.call(this, lpath, options).toString());
-        const real = cache.paths.get(((this === null || this === void 0 ? void 0 : this.root) || '') + target) || realpathSync.call(this, target);
-        cache.paths.set(ctx_path, real);
-        return real;
+        const target = resolve(realDir, readlinkSync.call($, maybePath).toString());
+        const real = realpathSync.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 function realpathSync(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 } = _resolveSync(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);
+}
 realpathSync;
 export function accessSync(path, mode = 0o600) {
     if (!config.checkAccess)
@@ -690,21 +696,19 @@ export function rmSync(path, options) {
     path = normalizePath(path);
     let stats;
     try {
-        stats = cache.stats.get(path) || lstatSync.bind(this)(path);
+        stats = lstatSync.bind(this)(path);
     }
     catch (error) {
         if (error.code != 'ENOENT' || !(options === null || options === void 0 ? void 0 : options.force))
             throw error;
     }
-    if (!stats) {
+    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 readdirSync.call(this, path, { _isIndirect: true })) {
-                    rmSync.call(this, join(path, entry), { ...options, _isIndirect: true });
+                for (const entry of readdirSync.call(this, path)) {
+                    rmSync.call(this, join(path, entry), options);
                 }
             }
             rmdirSync.call(this, path);
@@ -718,12 +722,8 @@ export function rmSync(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();
-    }
 }
 rmSync;
 export function mkdtempSync(prefix, options) {

package/dist/vfs/types.d.ts

@@ -1,17 +1,5 @@
 import type * as fs from 'node:fs';
 export type FileContents = ArrayBufferView | string;
-/**
- * Options used for caching, among other things.
- * @internal @hidden *UNSTABLE*
- */
-export interface InternalOptions {
-    /**
-     * If true, then this readdir was called from another function.
-     * In this case, don't clear the cache when done.
-     * @internal *UNSTABLE*
-     */
-    _isIndirect?: boolean;
-}
 /**
  * @internal @hidden Used for the internal `_open` functions
  */
@@ -27,7 +15,7 @@ export interface OpenOptions {
      */
     allowDirectory?: boolean;
 }
-export interface ReaddirOptions extends InternalOptions {
+export interface ReaddirOptions {
     withFileTypes?: boolean;
     recursive?: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.9.2",
+	"version": "1.9.4",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",

package/readme.md

@@ -1,3 +1,7 @@
+---
+title: Overview
+---
+
 # ZenFS
 
 ZenFS is a cross-platform library that emulates the [NodeJS filesystem API](http://nodejs.org/api/fs.html). It works using a system of backends, which are used by ZenFS to store and retrieve data. ZenFS can also integrate with other tools.

package/tests/backend/fetch.test.ts

@@ -2,7 +2,7 @@ import assert from 'node:assert/strict';
 import { join } from 'node:path';
 import { suite, test } from 'node:test';
 import { Worker } from 'node:worker_threads';
-import { Fetch, configureSingle, fs } from '../../dist/index.js';
+import { Fetch, configureSingle, fs, mounts, type FetchFS } from '../../dist/index.js';
 import { baseUrl, defaultEntries, indexPath, whenServerReady } from '../fetch/config.js';
 
 const server = new Worker(join(import.meta.dirname, '../fetch/server.js'));
@@ -40,8 +40,9 @@ await suite('Fetch with `disableAsyncCache`', () => {
 		assert.deepEqual(entries, [...defaultEntries, 'example', 'duck']);
 	});
 
-	test('Uncached synchronous operations throw', () => {
+	test('Uncached synchronous operations throw', async () => {
 		assert.throws(() => fs.readFileSync('/x.txt', 'utf8'), { code: 'EAGAIN' });
+		await (mounts.get('/') as FetchFS)._asyncDone;
 	});
 });
 

package/dist/vfs/cache.d.ts

@@ -1,46 +0,0 @@
-import type { Stats } from '../stats.js';
-/**
- * Used for caching data
- * @internal
- */
-export declare class Cache<T> {
-    isEnabled: boolean;
-    protected sync: Map<string, T>;
-    protected async: Map<string, Promise<T>>;
-    /**
-     * Whether the data exists in the cache
-     */
-    has(path: string): boolean;
-    /**
-     * Gets data from the cache, if is exists and the cache is enabled.
-     */
-    get(path: string): T | undefined;
-    /**
-     * Adds data if the cache is enabled
-     */
-    set(path: string, value: T): void;
-    /**
-     * Whether the data exists in the cache
-     */
-    hasAsync(path: string): boolean;
-    /**
-     * Gets data from the cache, if it exists and the cache is enabled.
-     */
-    getAsync(path: string): Promise<T> | undefined;
-    /**
-     * Adds data if the cache is enabled
-     */
-    setAsync(path: string, value: Promise<T>): void;
-    /**
-     * Clears the cache if it is enabled
-     */
-    clear(): void;
-}
-/**
- * Used to cache
- */
-export declare const stats: Cache<Stats>;
-/**
- * Used to cache realpath lookups
- */
-export declare const paths: Cache<string>;

package/dist/vfs/cache.js

@@ -1,75 +0,0 @@
-/* Experimental caching */
-/**
- * Used for caching data
- * @internal
- */
-export class Cache {
-    constructor() {
-        this.isEnabled = false;
-        this.sync = new Map();
-        this.async = new Map();
-    }
-    /**
-     * Whether the data exists in the cache
-     */
-    has(path) {
-        return this.isEnabled && this.sync.has(path);
-    }
-    /**
-     * Gets data from the cache, if is exists and the cache is enabled.
-     */
-    get(path) {
-        if (!this.isEnabled)
-            return;
-        return this.sync.get(path);
-    }
-    /**
-     * Adds data if the cache is enabled
-     */
-    set(path, value) {
-        if (!this.isEnabled)
-            return;
-        this.sync.set(path, value);
-        this.async.set(path, Promise.resolve(value));
-    }
-    /**
-     * Whether the data exists in the cache
-     */
-    hasAsync(path) {
-        return this.isEnabled && this.async.has(path);
-    }
-    /**
-     * Gets data from the cache, if it exists and the cache is enabled.
-     */
-    getAsync(path) {
-        if (!this.isEnabled)
-            return;
-        return this.async.get(path);
-    }
-    /**
-     * Adds data if the cache is enabled
-     */
-    setAsync(path, value) {
-        if (!this.isEnabled)
-            return;
-        this.async.set(path, value);
-        void value.then(v => this.sync.set(path, v));
-    }
-    /**
-     * Clears the cache if it is enabled
-     */
-    clear() {
-        if (!this.isEnabled)
-            return;
-        this.sync.clear();
-        this.async.clear();
-    }
-}
-/**
- * Used to cache
- */
-export const stats = new Cache();
-/**
- * Used to cache realpath lookups
- */
-export const paths = new Cache();