@zenfs/core 0.12.1 → 0.12.3

package/dist/utils.d.ts

@@ -2,9 +2,9 @@
 /// <reference types="node" resolution-mode="require"/>
 import type { OptionalTuple } from 'utilium';
 import { ErrnoError } from './error.js';
-import { Cred } from './cred.js';
+import type { Cred } from './cred.js';
 import { type AbsolutePath } from './emulation/path.js';
-import { FileSystem } from './filesystem.js';
+import type { FileSystem } from './filesystem.js';
 import type * as fs from 'node:fs';
 declare global {
     function atob(data: string): string;

package/license.md

@@ -1,6 +1,6 @@
-Copyright (c) 2023-2024 James P. and other ZenFS contributors.
-
+Copyright (c) James P. and other ZenFS contributors.
 Copyright (c) 2013-2023 John Vilk and other BrowserFS contributors.
+Copyright (c) Joyent, Inc. and other Node contributors for `test/fixtures/node`.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
@@ -19,27 +19,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-
-This license applies to all parts of ZenFS, except for the following items:
-
--   The test fixtures located in `test/fixtures/node`. Their license follows:
-    """
-    Copyright Joyent, Inc. and other Node contributors. All rights reserved.
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to
-    deal in the Software without restriction, including without limitation the
-    rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-    sell copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in
-    all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-    IN THE SOFTWARE.
-    """

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "0.12.1",
+	"version": "0.12.3",
 	"description": "A filesystem in your browser",
 	"main": "dist/index.js",
 	"types": "src/index.ts",
@@ -38,7 +38,7 @@
 	"scripts": {
 		"format": "prettier --write .",
 		"format:check": "prettier --check .",
-		"lint": "eslint src tests && tsc -p tsconfig.json --noEmit",
+		"lint": "tsc -p tsconfig.json --noEmit && eslint src tests",
 		"test": "npm run build && tsc -p tests/tsconfig.json --noEmit && cross-env NODE_OPTIONS=--experimental-vm-modules npx jest",
 		"build": "node scripts/build.js --globalName=ZenFS --entry src/index.ts",
 		"build:docs": "typedoc --out docs --name ZenFS src/index.ts",

package/readme.md

@@ -4,7 +4,7 @@ ZenFS is a file system that emulates the [NodeJS filesystem API](http://nodejs.o
 
 It works using a system of backends, which are used by ZenFS to store and retrieve data. ZenFS can also integrate with other tools.
 
-ZenFS is a fork of [BrowserFS](https://github.com/jvilk/BrowserFS). If you are using ZenFS in a research paper, you may want to [cite BrowserFS](https://github.com/jvilk/BrowserFS?tab=readme-ov-file#citing).
+ZenFS is a fork of [BrowserFS](https://github.com/jvilk/BrowserFS). If you are using ZenFS in a research paper, you may want to [cite BrowserFS](https://github.com/jvilk/BrowserFS#citing).
 
 ## Backends
 

package/src/backends/backend.ts

@@ -1,6 +1,6 @@
 import type { RequiredKeys } from 'utilium';
 import { ErrnoError, Errno } from '../error.js';
-import { FileSystem } from '../filesystem.js';
+import type { FileSystem } from '../filesystem.js';
 import { levenshtein } from '../utils.js';
 
 type OptionType = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function';

package/src/backends/fetch.ts

@@ -1,6 +1,6 @@
 import { Errno, ErrnoError } from '../error.js';
 import type { FileSystemMetadata } from '../filesystem.js';
-import { Stats } from '../stats.js';
+import type { Stats } from '../stats.js';
 import type { Backend } from './backend.js';
 import { IndexFS } from './index/fs.js';
 import type { IndexData } from './index/index.js';

package/src/backends/index/fs.ts

@@ -4,7 +4,8 @@ import { NoSyncFile, isWriteable, flagToMode } from '../../file.js';
 import { Readonly, FileSystem } from '../../filesystem.js';
 import type { Stats } from '../../stats.js';
 import { decode } from '../../utils.js';
-import { Index, IndexData } from './index.js';
+import type { IndexData } from './index.js';
+import { Index } from './index.js';
 
 export abstract class IndexFS extends Readonly(FileSystem) {
 	protected index: Index = new Index();

package/src/backends/index/index.ts

@@ -1,6 +1,7 @@
 import { isJSON } from 'utilium';
 import { Errno, ErrnoError } from '../../error.js';
-import { Stats, StatsLike } from '../../stats.js';
+import type { StatsLike } from '../../stats.js';
+import { Stats } from '../../stats.js';
 import { encode } from '../../utils.js';
 import { basename, dirname } from '../../emulation/path.js';
 

package/src/backends/overlay.ts

@@ -1,10 +1,13 @@
-import { FileSystem, FileSystemMetadata } from '../filesystem.js';
+import type { FileSystemMetadata } from '../filesystem.js';
+import { FileSystem } from '../filesystem.js';
 import { ErrnoError, Errno } from '../error.js';
-import { File, PreloadFile, parseFlag } from '../file.js';
+import type { File } from '../file.js';
+import { PreloadFile, parseFlag } from '../file.js';
 import { Stats } from '../stats.js';
 import { LockedFS } from './locked.js';
 import { dirname } from '../emulation/path.js';
-import { Cred, rootCred } from '../cred.js';
+import type { Cred } from '../cred.js';
+import { rootCred } from '../cred.js';
 import { decode, encode } from '../utils.js';
 import type { Backend } from './backend.js';
 /**
@@ -201,7 +204,7 @@ export class UnlockedOverlayFS extends FileSystem {
 		}
 		// Create an OverlayFile.
 		const file = this._readable.openFileSync(path, parseFlag('r'), cred);
-		const stats = Stats.clone(file.statSync());
+		const stats = new Stats(file.statSync());
 		const data = new Uint8Array(stats.size);
 		file.readSync(data);
 		return new PreloadFile(this, path, flag, stats, data);

package/src/backends/port/fs.ts

@@ -38,12 +38,16 @@ export class PortFile extends File {
 		);
 	}
 
+	protected _throwNoSync(syscall: string): never {
+		throw new ErrnoError(Errno.ENOTSUP, 'Syncrohnous operations not support on PortFile', this.path, syscall);
+	}
+
 	public stat(): Promise<Stats> {
 		return this.rpc('stat');
 	}
 
 	public statSync(): Stats {
-		throw ErrnoError.With('ENOSYS', this.path, 'PortFile.stat');
+		this._throwNoSync('stat');
 	}
 
 	public truncate(len: number): Promise<void> {
@@ -51,7 +55,7 @@ export class PortFile extends File {
 	}
 
 	public truncateSync(): void {
-		throw ErrnoError.With('ENOSYS', this.path, 'PortFile.truncate');
+		this._throwNoSync('truncate');
 	}
 
 	public write(buffer: Uint8Array, offset?: number, length?: number, position?: number): Promise<number> {
@@ -59,7 +63,7 @@ export class PortFile extends File {
 	}
 
 	public writeSync(): number {
-		throw ErrnoError.With('ENOSYS', this.path, 'PortFile.write');
+		this._throwNoSync('write');
 	}
 
 	public async read<TBuffer extends NodeJS.ArrayBufferView>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<FileReadResult<TBuffer>> {
@@ -68,7 +72,7 @@ export class PortFile extends File {
 	}
 
 	public readSync(): number {
-		throw ErrnoError.With('ENOSYS', this.path, 'PortFile.read');
+		this._throwNoSync('read');
 	}
 
 	public chown(uid: number, gid: number): Promise<void> {
@@ -76,7 +80,7 @@ export class PortFile extends File {
 	}
 
 	public chownSync(): void {
-		throw ErrnoError.With('ENOSYS', this.path, 'PortFile.chown');
+		this._throwNoSync('chown');
 	}
 
 	public chmod(mode: number): Promise<void> {
@@ -84,7 +88,7 @@ export class PortFile extends File {
 	}
 
 	public chmodSync(): void {
-		throw ErrnoError.With('ENOSYS', this.path, 'PortFile.chmod');
+		this._throwNoSync('chmod');
 	}
 
 	public utimes(atime: Date, mtime: Date): Promise<void> {
@@ -92,7 +96,7 @@ export class PortFile extends File {
 	}
 
 	public utimesSync(): void {
-		throw ErrnoError.With('ENOSYS', this.path, 'PortFile.utimes');
+		this._throwNoSync('utimes');
 	}
 
 	public _setType(type: FileType): Promise<void> {
@@ -100,7 +104,7 @@ export class PortFile extends File {
 	}
 
 	public _setTypeSync(): void {
-		throw ErrnoError.With('ENOSYS', this.path, 'PortFile._setType');
+		this._throwNoSync('_setType');
 	}
 
 	public close(): Promise<void> {
@@ -108,7 +112,7 @@ export class PortFile extends File {
 	}
 
 	public closeSync(): void {
-		throw ErrnoError.With('ENOSYS', this.path, 'PortFile.close');
+		this._throwNoSync('close');
 	}
 
 	public sync(): Promise<void> {
@@ -116,7 +120,7 @@ export class PortFile extends File {
 	}
 
 	public syncSync(): void {
-		throw ErrnoError.With('ENOSYS', this.path, 'PortFile.sync');
+		this._throwNoSync('sync');
 	}
 }
 

package/src/config.ts

@@ -18,7 +18,7 @@ function isMountConfig<T extends Backend>(arg: unknown): arg is MountConfigurati
 
 /**
  * Retrieve a file system with the given configuration.
- * @param config A BackendConfig object.
+ * @see MountConfiguration
  */
 export async function resolveMountConfig<T extends Backend>(config: MountConfiguration<T>, _depth = 0): Promise<FilesystemOf<T>> {
 	if (typeof config !== 'object' || config == null) {

package/src/cred.ts

@@ -1,6 +1,7 @@
 /**
  * Credentials used for various operations.
- * Similar to Linux's cred struct. See https://github.com/torvalds/linux/blob/master/include/linux/cred.h
+ * Similar to Linux's cred struct.
+ * @see https://github.com/torvalds/linux/blob/master/include/linux/cred.h
  */
 export interface Cred {
 	uid: number;

package/src/emulation/async.ts

@@ -2,10 +2,11 @@ import { Buffer } from 'buffer';
 import type * as fs from 'node:fs';
 import { ErrnoError, Errno } from '../error.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 { nop, normalizeMode, type Callback } from '../utils.js';
 import { R_OK } from './constants.js';
-import { Dirent, type Dir } from './dir.js';
+import type { Dirent } from './dir.js';
+import { type Dir } from './dir.js';
 import * as promises from './promises.js';
 import { fd2file } from './shared.js';
 import { ReadStream, WriteStream } from './streams.js';
@@ -882,14 +883,14 @@ export function cp(source: fs.PathLike, destination: fs.PathLike, opts: fs.CopyO
 }
 cp satisfies Omit<typeof fs.cp, '__promisify__'>;
 
-export function statfs(path: fs.PathLike, callback: Callback<[StatsFs]>): void;
-export function statfs(path: fs.PathLike, options: fs.StatFsOptions & { bigint?: false }, callback: Callback<[StatsFs]>): void;
-export function statfs(path: fs.PathLike, options: fs.StatFsOptions & { bigint: true }, callback: Callback<[BigIntStatsFs]>): void;
-export function statfs(path: fs.PathLike, options?: fs.StatFsOptions | Callback<[StatsFs]>, callback: Callback<[StatsFs]> | Callback<[BigIntStatsFs]> = nop): void {
+export function statfs(path: fs.PathLike, callback: Callback<[fs.StatsFs]>): void;
+export function statfs(path: fs.PathLike, options: fs.StatFsOptions & { bigint?: false }, callback: Callback<[fs.StatsFs]>): void;
+export function statfs(path: fs.PathLike, options: fs.StatFsOptions & { bigint: true }, callback: Callback<[fs.BigIntStatsFs]>): void;
+export function statfs(path: fs.PathLike, options?: fs.StatFsOptions | Callback<[fs.StatsFs]>, callback: Callback<[fs.StatsFs]> | Callback<[fs.BigIntStatsFs]> = nop): void {
 	callback = typeof options === 'function' ? options : callback;
 	promises
 		.statfs(path, typeof options === 'function' ? undefined : options)
-		.then(result => (callback as Callback<[StatsFs | BigIntStatsFs]>)(undefined, result))
+		.then(result => (callback as Callback<[fs.StatsFs | fs.BigIntStatsFs]>)(undefined, result))
 		.catch(callback);
 }
 statfs satisfies Omit<typeof fs.statfs, '__promisify__'>;

package/src/emulation/index.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/src/emulation/promises.ts

@@ -6,15 +6,16 @@ import type { Stream } from 'node:stream';
 import type { ReadableStream as TReadableStream } from 'node:stream/web';
 import type { Interface as ReadlineInterface } from 'readline';
 import type { ReadableStreamController } from 'stream/web';
-import { ErrnoError, Errno } from '../error.js';
-import { ActionType, File, isAppendable, isReadable, isWriteable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
+import { Errno, ErrnoError } from '../error.js';
+import type { File } from '../file.js';
+import { isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
 import type { FileContents } from '../filesystem.js';
-import { BigIntStats, FileType, type BigIntStatsFs, type Stats, type StatsFs } from '../stats.js';
+import { BigIntStats, FileType, type Stats } 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';
 
@@ -110,7 +111,7 @@ export class FileHandle implements promises.FileHandle {
 			throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
 		}
 		const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding!) : data;
-		await this.file.write(encodedData, 0, encodedData.length, null);
+		await this.file.write(encodedData, 0, encodedData.length);
 	}
 
 	/**
@@ -491,53 +492,36 @@ async function _open(path: fs.PathLike, _flag: fs.OpenMode, _mode: fs.Mode = 0o6
 	path = resolveSymlinks && (await exists(path)) ? await realpath(path) : path;
 	const { fs, path: resolved } = resolveMount(path);
 
-	try {
-		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: 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');
+	if (!(await fs.exists(path, cred))) {
+		if ((!isWriteable(flag) && !isAppendable(flag)) || flag == 'r+') {
+			throw ErrnoError.With('ENOENT', path, '_open');
 		}
-	} catch (_) {
-		const original = _ as ErrnoError;
-		if (original.code != 'ENOENT') {
-			throw original;
-		}
-		try {
-			switch (pathNotExistsAction(flag)) {
-				case ActionType.CREATE:
-					// Ensure parent exists.
-					const parentStats: Stats = 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 = _ as ErrnoError;
-			ex.stack += '\n<original>\n';
-			ex.stack += (original as Error).stack;
-			throw ex;
+		// Create the file
+		const parentStats: Stats = 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));
+	}
+
+	if (isExclusive(flag)) {
+		throw ErrnoError.With('EEXIST', path, '_open');
+	}
+
+	if (!isTruncating(flag)) {
+		return new FileHandle(await fs.openFile(resolved, flag, cred));
 	}
+
+	/* 
+		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: File = await fs.openFile(resolved, flag, cred);
+	await file.truncate(0);
+	await file.sync();
+	return new FileHandle(file);
 }
 
 /**
@@ -1072,9 +1056,11 @@ cp satisfies typeof promises.cp;
  * @since v18.15.0
  * @return Fulfills with an {fs.StatFs} for the file system.
  */
-export async function statfs(path: fs.PathLike, opts?: fs.StatFsOptions & { bigint?: false }): Promise<StatsFs>;
-export async function statfs(path: fs.PathLike, opts: fs.StatFsOptions & { bigint: true }): Promise<BigIntStatsFs>;
-export async function statfs(path: fs.PathLike, opts?: fs.StatFsOptions): Promise<StatsFs | BigIntStatsFs>;
-export async function statfs(path: fs.PathLike, opts?: fs.StatFsOptions): Promise<StatsFs | BigIntStatsFs> {
-	throw ErrnoError.With('ENOSYS', path.toString(), 'statfs');
+export async function statfs(path: fs.PathLike, opts?: fs.StatFsOptions & { bigint?: false }): Promise<fs.StatsFs>;
+export async function statfs(path: fs.PathLike, opts: fs.StatFsOptions & { bigint: true }): Promise<fs.BigIntStatsFs>;
+export async function statfs(path: fs.PathLike, opts?: fs.StatFsOptions): Promise<fs.StatsFs | fs.BigIntStatsFs>;
+export async function statfs(path: fs.PathLike, opts?: fs.StatFsOptions): Promise<fs.StatsFs | fs.BigIntStatsFs> {
+	path = normalizePath(path);
+	const { fs } = resolveMount(path);
+	return _statfs(fs, opts?.bigint);
 }

package/src/emulation/shared.ts

@@ -1,10 +1,13 @@
 // Utilities and shared data
 
-import { ErrnoError, Errno } from '../error.js';
+import type { BigIntStatsFs, StatsFs } from 'node:fs';
 import { InMemory } from '../backends/memory.js';
-import { Cred, rootCred } from '../cred.js';
+import type { Cred } from '../cred.js';
+import { rootCred } from '../cred.js';
+import { Errno, ErrnoError } from '../error.js';
 import type { File } from '../file.js';
-import { FileSystem } from '../filesystem.js';
+import type { FileSystem } from '../filesystem.js';
+import { size_max } from '../inode.js';
 import { normalizePath } from '../utils.js';
 import { resolve, type AbsolutePath } from './path.js';
 
@@ -117,3 +120,21 @@ export function mountObject(mounts: MountObject): void {
 		mount(point, fs);
 	}
 }
+
+/**
+ * @hidden
+ */
+export function _statfs<const T extends boolean>(fs: FileSystem, bigint?: T): T extends true ? BigIntStatsFs : StatsFs {
+	const md = fs.metadata();
+	const bs = md.blockSize || 4096;
+
+	return {
+		type: (bigint ? BigInt : Number)(md.type),
+		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),
+	} as T extends true ? BigIntStatsFs : StatsFs;
+}

package/src/emulation/streams.ts

@@ -1,6 +1,6 @@
 import type * as Node from 'fs';
 import { Readable, Writable } from 'readable-stream';
-import { Callback } from '../utils.js';
+import type { Callback } from '../utils.js';
 import { ErrnoError, Errno } from '../error.js';
 
 export class ReadStream extends Readable implements Node.ReadStream {