@zenfs/core 2.2.2 → 2.3.0

package/dist/vfs/xattr.js

@@ -16,14 +16,13 @@ function checkName($, name, path, syscall) {
         throw UV('ENOTSUP', syscall, path);
 }
 export async function get(path, name, opt = {}) {
-    var _a;
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     checkName(this, name, path, 'xattr.get');
     const inode = await fs.stat(resolved).catch(rethrow('xattr.get', path));
     if (checkAccess && !hasAccess(this, inode, R_OK))
         throw UV('EACCES', 'xattr.get', path);
-    (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
+    inode.attributes ??= new Attributes();
     const value = inode.attributes.get(name);
     if (!value)
         throw UV('ENODATA', 'xattr.get', path);
@@ -31,7 +30,6 @@ export async function get(path, name, opt = {}) {
     return opt.encoding == 'buffer' || !opt.encoding ? buffer : buffer.toString(opt.encoding);
 }
 export function getSync(path, name, opt = {}) {
-    var _a;
     path = normalizePath(path);
     checkName(this, name, path, 'xattr.get');
     const { fs, path: resolved } = resolveMount(path, this);
@@ -44,7 +42,7 @@ export function getSync(path, name, opt = {}) {
     }
     if (checkAccess && !hasAccess(this, inode, R_OK))
         throw UV('EACCES', 'xattr.get', path);
-    (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
+    inode.attributes ??= new Attributes();
     const value = inode.attributes.get(name);
     if (!value)
         throw UV('ENODATA', 'xattr.get', path);
@@ -60,14 +58,13 @@ export function getSync(path, name, opt = {}) {
  * @param opt Options for the operation
  */
 export async function set(path, name, value, opt = {}) {
-    var _a;
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     checkName(this, name, path, 'xattr.set');
     const inode = await fs.stat(resolved).catch(rethrow('xattr.set', path));
     if (checkAccess && !hasAccess(this, inode, W_OK))
         throw UV('EACCES', 'xattr.set', path);
-    (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
+    inode.attributes ??= new Attributes();
     const attr = inode.attributes.get(name);
     if (opt.create && attr)
         throw UV('EEXIST', 'xattr.set', path);
@@ -85,7 +82,6 @@ export async function set(path, name, value, opt = {}) {
  * @param opt Options for the operation
  */
 export function setSync(path, name, value, opt = {}) {
-    var _a;
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     checkName(this, name, path, 'xattr.set');
@@ -98,7 +94,7 @@ export function setSync(path, name, value, opt = {}) {
     }
     if (checkAccess && !hasAccess(this, inode, W_OK))
         throw UV('EACCES', 'xattr.set', path);
-    (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
+    inode.attributes ??= new Attributes();
     const attr = inode.attributes.get(name);
     if (opt.create && attr)
         throw UV('EEXIST', 'xattr.set', path);
@@ -119,14 +115,13 @@ export function setSync(path, name, value, opt = {}) {
  * @param name Name of the attribute to remove
  */
 export async function remove(path, name) {
-    var _a;
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     checkName(this, name, path, 'xattr.remove');
     const inode = await fs.stat(resolved).catch(rethrow('xattr.remove', path));
     if (checkAccess && !hasAccess(this, inode, W_OK))
         throw UV('EACCES', 'xattr.remove', path);
-    (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
+    inode.attributes ??= new Attributes();
     const attr = inode.attributes.get(name);
     if (!attr)
         throw UV('ENODATA', 'xattr.remove', path);
@@ -140,7 +135,6 @@ export async function remove(path, name) {
  * @param name Name of the attribute to remove
  */
 export function removeSync(path, name) {
-    var _a;
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     checkName(this, name, path, 'xattr.remove');
@@ -153,7 +147,7 @@ export function removeSync(path, name) {
     }
     if (checkAccess && !hasAccess(this, inode, W_OK))
         throw UV('EACCES', 'xattr.remove', path);
-    (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
+    inode.attributes ??= new Attributes();
     const attr = inode.attributes.get(name);
     if (!attr)
         throw UV('ENODATA', 'xattr.remove', path);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "2.2.2",
+	"version": "2.3.0",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -71,7 +71,7 @@
 		"buffer": "^6.0.3",
 		"eventemitter3": "^5.0.1",
 		"kerium": "^1.3.4",
-		"memium": "^0.2.0",
+		"memium": "^0.2.1",
 		"readable-stream": "^4.5.2",
 		"utilium": "^2.3.3"
 	},

package/scripts/test.js

@@ -89,11 +89,12 @@ if (options.ci) ci = await import('./ci.js');
 options.verbose && options.force && console.debug('Forcing tests to exit (--test-force-exit)');
 
 if (options.build) {
-	!options.quiet && console.log('Building...');
+	!options.quiet && process.stdout.write('Building... ');
 	try {
 		execSync('npm run build');
+		console.log('done.');
 	} catch {
-		console.warn('Build failed, continuing without it.');
+		console.warn('failed, continuing without it.');
 	}
 }
 
@@ -141,17 +142,19 @@ async function status(name) {
 		return color(`(${delta} ${unit})`, '2;37');
 	};
 
+	const maybeName = options.verbose ? `: ${name}` : '';
+
 	return {
 		async pass() {
-			if (!options.quiet) console.log(`${color('passed', 32)}: ${name} ${time()}`);
+			if (!options.quiet) console.log(`${color('passed', 32)}${maybeName} ${time()}`);
 			if (options.ci) await ci.completeCheck(name, 'success');
 		},
 		async skip() {
-			if (!options.quiet) console.log(`${color('skipped', 33)}: ${name} ${time()}`);
+			if (!options.quiet) console.log(`${color('skipped', 33)}${maybeName} ${time()}`);
 			if (options.ci) await ci.completeCheck(name, 'skipped');
 		},
 		async fail() {
-			console.error(`${color('failed', '1;31')}: ${name} ${time()}`);
+			console.error(`${color('failed', '1;31')}${maybeName} ${time()}`);
 			if (options.ci) await ci.completeCheck(name, 'failure');
 			process.exitCode = 1;
 			if (options['exit-on-fail']) process.exit();
@@ -163,7 +166,7 @@ if (!options.preserve) rmSync(options.coverage, { force: true, recursive: true }
 mkdirSync(options.coverage, { recursive: true });
 
 if (options.common) {
-	!options.quiet && console.log('Running common tests...');
+	!options.quiet && process.stdout.write('Running common tests...' + (options.verbose ? '\n' : ' '));
 	const { pass, fail } = await status('Common tests');
 	try {
 		execSync(
@@ -187,10 +190,14 @@ for (const setupFile of positionals) {
 	}
 
 	process.env.SETUP = setupFile;
+	process.env.VERBOSE = +options.verbose;
 
 	const name = options['file-names'] && !options.ci ? setupFile : parse(setupFile).name;
 
-	!options.quiet && console.log('Running tests:', name);
+	if (!options.quiet) {
+		if (options.verbose) console.log('Running tests:', name);
+		else process.stdout.write(`Running tests: ${name}... `);
+	}
 
 	const { pass, fail, skip } = await status(name);
 

package/tests/backend/fetch.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import { join } from 'node:path';
-import { suite, test } from 'node:test';
+import { after, suite, test } from 'node:test';
 import { Worker } from 'node:worker_threads';
 import { Fetch, configureSingle, fs, mounts, type FetchFS } from '../../dist/index.js';
 import { baseUrl, defaultEntries, indexPath, whenServerReady } from '../fetch/config.js';
@@ -12,17 +12,15 @@ const server = new Worker(join(import.meta.dirname, '../fetch/server.js'));
 
 await whenServerReady();
 
-await suite('Fetch with `disableAsyncCache`', () => {
-	test('Configuration', async () => {
-		await configureSingle({
-			backend: Fetch,
-			disableAsyncCache: true,
-			remoteWrite: true,
-			baseUrl,
-			index: baseUrl + indexPath,
-		});
-	});
+await configureSingle({
+	backend: Fetch,
+	disableAsyncCache: true,
+	remoteWrite: true,
+	baseUrl,
+	index: baseUrl + indexPath,
+});
 
+suite('Fetch with `disableAsyncCache`', () => {
 	test('Read and write file', async () => {
 		await fs.promises.writeFile('/example', 'test');
 
@@ -45,9 +43,11 @@ await suite('Fetch with `disableAsyncCache`', () => {
 
 	test('Uncached synchronous operations throw', async () => {
 		assert.throws(() => fs.readFileSync('/x.txt', 'utf8'), { code: 'EAGAIN' });
-		await (mounts.get('/') as FetchFS)._asyncDone;
 	});
 });
 
-await server.terminate();
-server.unref();
+after(async () => {
+	await (mounts.get('/') as FetchFS)._asyncDone;
+	await server.terminate();
+	server.unref();
+});

package/tests/backend/port.test.ts

@@ -1,9 +1,9 @@
 import assert from 'node:assert/strict';
-import { suite, test } from 'node:test';
+import { after, suite, test } from 'node:test';
 import { MessageChannel, Worker } from 'node:worker_threads';
-import { Port, attachFS, waitOnline } from '../../dist/backends/port.js';
+import { Port, attachFS } from '../../dist/backends/port.js';
 import type { InMemoryStore, StoreFS } from '../../dist/index.js';
-import { InMemory, configure, configureSingle, fs, resolveMountConfig } from '../../dist/index.js';
+import { InMemory, configure, configureSingle, fs, resolveMountConfig, waitOnline } from '../../dist/index.js';
 import { setupLogs } from '../logs.js';
 setupLogs();
 
@@ -29,16 +29,18 @@ await suite('Timeout', { timeout: 1000 }, () => {
 
 		await assert.rejects(configured, { code: 'EIO', message: /RPC Failed/ });
 	});
-});
 
-timeoutChannel.port1.unref();
+	after(() => {
+		timeoutChannel.port1.unref();
+	});
+});
 
 // Test configuration
 
 const configPort = new Worker(import.meta.dirname + '/config.worker.js');
 await waitOnline(configPort);
 
-await suite('Remote FS with resolveRemoteMount', () => {
+suite('Remote FS with resolveRemoteMount', () => {
 	const content = 'FS is in a port';
 
 	test('Configuration', async () => {
@@ -52,10 +54,12 @@ await suite('Remote FS with resolveRemoteMount', () => {
 	test('Read', async () => {
 		assert.equal(await fs.promises.readFile('/test', 'utf8'), content);
 	});
-});
 
-await configPort.terminate();
-configPort.unref();
+	after(async () => {
+		await configPort.terminate();
+		configPort.unref();
+	});
+});
 
 // Test using a message channel
 
@@ -87,12 +91,14 @@ await suite('FS with MessageChannel', () => {
 	test('readFileSync should throw', () => {
 		assert.throws(() => fs.readFileSync('/test', 'utf8'), { code: 'ENOTSUP' });
 	});
-});
 
-channel.port1.close();
-channel.port2.close();
-channel.port1.unref();
-channel.port2.unref();
+	after(() => {
+		channel.port1.close();
+		channel.port2.close();
+		channel.port1.unref();
+		channel.port2.unref();
+	});
+});
 
 // Test using a worker
 
@@ -112,7 +118,9 @@ await suite('Remote FS', () => {
 	test('Read', async () => {
 		assert.equal(await fs.promises.readFile('/test', 'utf8'), content);
 	});
-});
 
-await remotePort.terminate();
-remotePort.unref();
+	after(async () => {
+		await remotePort.terminate();
+		remotePort.unref();
+	});
+});

package/tests/common/context.test.ts

@@ -3,6 +3,7 @@ import { suite, test } from 'node:test';
 import { canary } from 'utilium';
 import { bindContext } from '../../dist/context.js';
 import * as fs from '../../dist/vfs/index.js';
+import { configure, InMemory } from '../../dist/index.js';
 
 fs.mkdirSync('/ctx');
 const { fs: ctx } = bindContext({ root: '/ctx' });
@@ -58,4 +59,17 @@ suite('Context', () => {
 		await watcher.return!();
 		await promise;
 	});
+
+	test('Path resolution of / with context root and mount point being the same', async () => {
+		// @zenfs/core#226
+		await configure({
+			mounts: { '/bananas': InMemory },
+		});
+
+		const bananas = bindContext({ root: '/bananas' });
+
+		fs.writeFileSync('/bananas/yellow', 'true');
+
+		assert.deepEqual(bananas.fs.readdirSync('/'), ['yellow']);
+	});
 });

package/tests/common/handle.test.ts

@@ -1,14 +1,14 @@
 import assert from 'node:assert/strict';
-import { suite, test } from 'node:test';
+import { after, suite, test } from 'node:test';
 import { wait } from 'utilium';
 import { constants, type FileHandle, open } from '../../dist/vfs/promises.js';
 
 const content = 'The cake is a lie',
 	appended = '\nAnother lie';
 
-await using handle: FileHandle = await open('./test.txt', 'ws+');
+const handle: FileHandle = await open('./test.txt', 'ws+');
 
-await suite('FileHandle', () => {
+suite('FileHandle', () => {
 	test('writeFile', async () => {
 		await handle.writeFile(content);
 		await handle.sync();
@@ -63,3 +63,5 @@ await suite('FileHandle', () => {
 		assert.deepEqual(lines, ['first line', 'second line', 'third line']);
 	});
 });
+
+after(() => handle.close());

package/tests/fetch/run.sh

@@ -6,7 +6,8 @@ SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
 node $SCRIPT_DIR/server.js &
 PID=$!
 
-echo "Waiting for server to start..."
+echo -n "Waiting for server to start..."
+if [ -n "$VERBOSE" ]; then echo; fi
 until nc -z localhost 26514; do
   sleep 0.25
 done

package/tests/fs/scaling.test.ts

@@ -0,0 +1,32 @@
+import assert from 'node:assert/strict';
+import { suite, test } from 'node:test';
+import { fs } from '../common.js';
+
+const n_files = 130;
+const huge_size = 0x1000000;
+
+// Tests for having a lot of various things (number of inodes/files, individual file size, etc.).
+suite('Scaling', () => {
+	test('Lots of inodes/files', async () => {
+		fs.mkdirSync('/n');
+
+		for (let i = 0; i < n_files; i++) {
+			fs.writeFileSync('/n/' + i, i.toString(16));
+		}
+
+		assert.equal(fs.readdirSync('/n').length, n_files);
+
+		const results = [];
+
+		for (let i = 0; i < n_files; i++) {
+			results.push(fs.promises.readFile('/n/' + i, 'utf8').then(val => assert.equal(val, i.toString(16))));
+		}
+
+		await Promise.all(results);
+	});
+
+	test('Singular file size', () => {
+		fs.writeFileSync('/huge', new Uint8Array(huge_size));
+		assert.equal(fs.statSync('/huge').size, huge_size);
+	});
+});

package/tests/fs/watch.test.ts

@@ -9,9 +9,9 @@ await fs.promises.mkdir(testDir);
 await fs.promises.writeFile(testFile, 'Initial content');
 
 /**
- * @todo convert using watcher to void discards pending ES proposal
+ * @todo convert `using watcher = ...` to void discards pending ES proposal
  */
-await suite('Watch', () => {
+suite('Watch', async () => {
 	test('Events emitted on file change', async () => {
 		const { promise, resolve } = Promise.withResolvers<[string, string]>();
 
@@ -155,6 +155,3 @@ await suite('Watch', () => {
 		await promise;
 	});
 });
-
-await fs.promises.rm(testFile);
-await fs.promises.rm(testDir, { recursive: true, force: true });

package/tests/setup/single-buffer.ts

@@ -3,7 +3,7 @@ import { copySync, data } from '../setup.js';
 
 await configureSingle({
 	backend: SingleBuffer,
-	buffer: new ArrayBuffer(0x100000),
+	buffer: new ArrayBuffer(0x1100000),
 });
 
 copySync(data);

package/tests/tsconfig.json

@@ -6,7 +6,8 @@
 		"noEmit": true,
 		"esModuleInterop": true,
 		"allowSyntheticDefaultImports": true,
-		"allowJs": true
+		"allowJs": true,
+		"rootDir": ".."
 	},
-	"include": ["**/*.ts", "*.ts", "**/*.js"]
+	"include": ["**/*.ts", "*.ts", "**/*.js", "../types/uint8array.d.ts"]
 }

package/types/uint8array.d.ts

@@ -0,0 +1,64 @@
+/**
+See:
+https://developer.mozilla.org/Web/JavaScript/Reference/Global_Objects/Uint8Array/toBase64
+https://github.com/microsoft/TypeScript/pull/61696
+https://github.com/microsoft/TypeScript/issues/61695
+
+@todo Remove when TypeScript 5.9 is released
+*/
+
+interface Uint8ArrayConstructor {
+	/**
+	 * Creates a new `Uint8Array` from a base64-encoded string.
+	 * @param string The base64-encoded string.
+	 * @param options If provided, specifies the alphabet and handling of the last chunk.
+	 * @returns A new `Uint8Array` instance.
+	 * @throws {SyntaxError} If the input string contains characters outside the specified alphabet, or if the last
+	 * chunk is inconsistent with the `lastChunkHandling` option.
+	 */
+	fromBase64: (string: string) => Uint8Array;
+
+	/**
+	 * Creates a new `Uint8Array` from a base16-encoded string.
+	 * @returns A new `Uint8Array` instance.
+	 */
+	fromHex: (string: string) => Uint8Array;
+}
+
+interface Uint8Array<TArrayBuffer extends ArrayBufferLike> {
+	/**
+	 * Converts the `Uint8Array` to a base64-encoded string.
+	 * @param options If provided, sets the alphabet and padding behavior used.
+	 * @returns A base64-encoded string.
+	 */
+	toBase64: () => string;
+
+	/**
+	 * Sets the `Uint8Array` from a base64-encoded string.
+	 * @param string The base64-encoded string.
+	 * @param options If provided, specifies the alphabet and handling of the last chunk.
+	 * @returns An object containing the number of bytes read and written.
+	 * @throws {SyntaxError} If the input string contains characters outside the specified alphabet, or if the last
+	 * chunk is inconsistent with the `lastChunkHandling` option.
+	 */
+	setFromBase64?: (string: string) => {
+		read: number;
+		written: number;
+	};
+
+	/**
+	 * Converts the `Uint8Array` to a base16-encoded string.
+	 * @returns A base16-encoded string.
+	 */
+	toHex: () => string;
+
+	/**
+	 * Sets the `Uint8Array` from a base16-encoded string.
+	 * @param string The base16-encoded string.
+	 * @returns An object containing the number of bytes read and written.
+	 */
+	setFromHex?: (string: string) => {
+		read: number;
+		written: number;
+	};
+}