@zenfs/core 1.9.3 → 1.9.5

package/package.json

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

package/scripts/test.js

@@ -51,7 +51,7 @@ Output:
     -h, --help          Outputs this help message
     -w, --verbose       Output verbose messages
     -q, --quiet         Don't output normal messages
-	-l, --logs <level>  Change the default log level for test output. Level can be a number or string
+    -l, --logs <level>  Change the default log level for test output. Level can be a number or string
     -N, --file-names    Use full file paths for tests from setup files instead of the base name
     -C, --ci            Continuous integration (CI) mode. This interacts with the Github
                         Checks API for better test status. Requires @octokit/action
@@ -166,9 +166,12 @@ if (options.common) {
 	!options.quiet && console.log('Running common tests...');
 	const { pass, fail } = await status('Common tests');
 	try {
-		execSync(`tsx ${options.inspect ? 'inspect' : ''} --test --experimental-test-coverage 'tests/*.test.ts' 'tests/**/!(fs)/*.test.ts'`, {
-			stdio: ['ignore', options.verbose ? 'inherit' : 'ignore', 'inherit'],
-		});
+		execSync(
+			`tsx ${options.inspect ? 'inspect' : ''} ${options.force ? '--test-force-exit' : ''} --test --experimental-test-coverage 'tests/*.test.ts' 'tests/**/!(fs)/*.test.ts'`,
+			{
+				stdio: ['ignore', options.verbose ? 'inherit' : 'ignore', 'inherit'],
+			}
+		);
 		await pass();
 	} catch {
 		await fail();

package/tests/backend/port.test.ts

@@ -2,6 +2,7 @@ import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { MessageChannel, Worker } from 'node:worker_threads';
 import { Port, attachFS } from '../../dist/backends/port/fs.js';
+import { waitOnline } from '../../dist/backends/port/rpc.js';
 import type { InMemoryStore, StoreFS } from '../../dist/index.js';
 import { ErrnoError, InMemory, configure, configureSingle, fs, resolveMountConfig } from '../../dist/index.js';
 
@@ -49,12 +50,13 @@ timeoutChannel.port1.unref();
 // Test configuration
 
 const configPort = new Worker(import.meta.dirname + '/config.worker.js');
+await waitOnline(configPort);
 
 await suite('Remote FS with resolveRemoteMount', () => {
 	const content = 'FS is in a port';
 
 	test('Configuration', async () => {
-		await configureSingle({ backend: Port, port: configPort, timeout: 500 });
+		await configureSingle({ backend: Port, port: configPort, timeout: 100 });
 	});
 
 	test('Write', async () => {
@@ -62,11 +64,11 @@ await suite('Remote FS with resolveRemoteMount', () => {
 	});
 
 	test('Read', async () => {
-		assert((await fs.promises.readFile('/test', 'utf8')) === content);
+		assert.equal(await fs.promises.readFile('/test', 'utf8'), content);
 	});
 });
 
-await configPort?.terminate();
+await configPort.terminate();
 configPort.unref();
 
 // Test using a message channel
@@ -79,7 +81,7 @@ await suite('FS with MessageChannel', () => {
 	test('configuration', async () => {
 		tmpfs = await resolveMountConfig({ backend: InMemory, name: 'tmp' });
 		attachFS(channel.port2, tmpfs);
-		await configureSingle({ backend: Port, port: channel.port1, disableAsyncCache: true, timeout: 250 });
+		await configureSingle({ backend: Port, port: channel.port1, disableAsyncCache: true, timeout: 100 });
 	});
 
 	test('write', async () => {
@@ -88,12 +90,12 @@ await suite('FS with MessageChannel', () => {
 
 	test('remote content', () => {
 		fs.mount('/tmp', tmpfs);
-		assert(fs.readFileSync('/tmp/test', 'utf8') == content);
+		assert.equal(fs.readFileSync('/tmp/test', 'utf8'), content);
 		fs.umount('/tmp');
 	});
 
 	test('read', async () => {
-		assert((await fs.promises.readFile('/test', 'utf8')) === content);
+		assert.equal(await fs.promises.readFile('/test', 'utf8'), content);
 	});
 
 	test('readFileSync should throw', () => {
@@ -101,6 +103,8 @@ await suite('FS with MessageChannel', () => {
 	});
 });
 
+channel.port1.close();
+channel.port2.close();
 channel.port1.unref();
 channel.port2.unref();
 
@@ -112,7 +116,7 @@ await suite('Remote FS', () => {
 	const content = 'FS is in a port';
 
 	test('Configuration', async () => {
-		await configureSingle({ backend: Port, port: remotePort, timeout: 500 });
+		await configureSingle({ backend: Port, port: remotePort, timeout: 100 });
 	});
 
 	test('Write', async () => {
@@ -122,8 +126,6 @@ await suite('Remote FS', () => {
 	test('Read', async () => {
 		assert.equal(await fs.promises.readFile('/test', 'utf8'), content);
 	});
-
-	test('Cleanup', async () => {});
 });
 
 await remotePort.terminate();

package/tests/common/path.test.ts

@@ -1,6 +1,7 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { basename, dirname, extname, join, normalize, resolve } from '../../dist/vfs/path.js';
+import * as fs from '../../dist/vfs/index.js';
 
 suite('Path emulation', () => {
 	test('resolve', () => {
@@ -31,4 +32,15 @@ suite('Path emulation', () => {
 		assert.equal(extname('/path/to/file.txt'), '.txt');
 		assert.equal(extname('/path/to/file'), '');
 	});
+
+	test('file:// URL (string)', () => {
+		fs.writeFileSync('/example.txt', 'Yay');
+		assert.equal(fs.readFileSync('file:///example.txt', 'utf-8'), 'Yay');
+	});
+
+	test('file:// URL (URL)', () => {
+		fs.writeFileSync('/example.txt', 'Yay');
+		const url = new URL('file:///example.txt');
+		assert.equal(fs.readFileSync(url, 'utf-8'), 'Yay');
+	});
 });

package/tests/fs/links.test.ts

@@ -27,6 +27,31 @@ suite('Links', () => {
 		assert.equal(await fs.promises.readFile(target, 'utf-8'), await fs.promises.readFile(symlink, 'utf-8'));
 	});
 
+	test('nested symlinks', async () => {
+		// Create the real directory structure
+		const realDir = '/real-dir';
+		const realFile = '/real-dir/realfile.txt';
+		const fileContent = 'hello world';
+		await fs.promises.mkdir(realDir);
+		await fs.promises.writeFile(realFile, fileContent);
+		// Create first symlink (symlink-dir -> real-dir)
+		const symlinkDir = '/symlink-dir';
+		await fs.promises.symlink(realDir, symlinkDir);
+		const symfile = 'symfile.txt';
+		const symlinkFile = join(realDir, symfile);
+		// Create second symlink (symlink-dir -> real-dir)
+		await fs.promises.symlink(realFile, symlinkFile);
+		// Now access file through nested symlinks
+		const nestedPath = join(symlinkDir, symfile);
+		// Verify realpath resolution
+		const resolvedPath = await fs.promises.realpath(nestedPath);
+		assert.equal(resolvedPath, realFile);
+		// Verify content can be read through nested symlinks
+		const content = await fs.promises.readFile(nestedPath, 'utf8');
+		assert.notEqual(content, '/real-dir/realfile.txt');
+		assert.equal(content, fileContent);
+	});
+
 	test('unlink', async () => {
 		await fs.promises.unlink(symlink);
 		assert(!(await fs.promises.exists(symlink)));

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();