@zenfs/core 1.3.6 → 1.4.0

package/src/mixins/mutexed.ts

@@ -1,257 +0,0 @@
-import { ErrnoError } from '../error.js';
-import type { File } from '../file.js';
-import type { FileSystem, FileSystemMetadata } from '../filesystem.js';
-import '../polyfills.js';
-import type { Stats } from '../stats.js';
-import type { Concrete } from '../utils.js';
-
-export class MutexLock {
-	protected current = Promise.withResolvers<void>();
-
-	protected _isLocked: boolean = true;
-	public get isLocked(): boolean {
-		return this._isLocked;
-	}
-
-	public constructor(protected readonly previous?: MutexLock) {}
-
-	public async done(): Promise<void> {
-		await this.previous?.done();
-		await this.current.promise;
-	}
-
-	public unlock(): void {
-		this.current.resolve();
-		this._isLocked = false;
-	}
-
-	public [Symbol.dispose](): void {
-		this.unlock();
-	}
-}
-
-/**
- * @hidden
- */
-export class _MutexedFS<T extends FileSystem> implements FileSystem {
-	/**
-	 * @internal
-	 */
-	public _fs!: T;
-
-	public async ready(): Promise<void> {
-		return await this._fs.ready();
-	}
-
-	public metadata(): FileSystemMetadata {
-		return this._fs.metadata();
-	}
-
-	/**
-	 * The current locks
-	 */
-	private currentLock?: MutexLock;
-
-	/**
-	 * Adds a lock for a path
-	 */
-	protected addLock(): MutexLock {
-		const lock = new MutexLock(this.currentLock);
-		this.currentLock = lock;
-		return lock;
-	}
-
-	/**
-	 * Locks `path` asynchronously.
-	 * If the path is currently locked, waits for it to be unlocked.
-	 * @internal
-	 */
-	public async lock(path: string, syscall: string): Promise<MutexLock> {
-		const previous = this.currentLock;
-		const lock = this.addLock();
-		const stack = new Error().stack;
-		setTimeout(() => {
-			if (lock.isLocked) {
-				const error = ErrnoError.With('EDEADLK', path, syscall);
-				error.stack += stack?.slice('Error'.length);
-				throw error;
-			}
-		}, 5000);
-		await previous?.done();
-		return lock;
-	}
-
-	/**
-	 * Locks `path` asynchronously.
-	 * If the path is currently locked, an error will be thrown
-	 * @internal
-	 */
-	public lockSync(path: string, syscall: string): MutexLock {
-		if (this.currentLock?.isLocked) {
-			throw ErrnoError.With('EBUSY', path, syscall);
-		}
-
-		return this.addLock();
-	}
-
-	/**
-	 * Whether `path` is locked
-	 * @internal
-	 */
-	public get isLocked(): boolean {
-		return !!this.currentLock?.isLocked;
-	}
-
-	/* eslint-disable @typescript-eslint/no-unused-vars */
-	public async rename(oldPath: string, newPath: string): Promise<void> {
-		using _ = await this.lock(oldPath, 'rename');
-		await this._fs.rename(oldPath, newPath);
-	}
-
-	public renameSync(oldPath: string, newPath: string): void {
-		using _ = this.lockSync(oldPath, 'rename');
-		return this._fs.renameSync(oldPath, newPath);
-	}
-
-	public async stat(path: string): Promise<Stats> {
-		using _ = await this.lock(path, 'stat');
-		return await this._fs.stat(path);
-	}
-
-	public statSync(path: string): Stats {
-		using _ = this.lockSync(path, 'stat');
-		return this._fs.statSync(path);
-	}
-
-	public async openFile(path: string, flag: string): Promise<File> {
-		using _ = await this.lock(path, 'openFile');
-		const file = await this._fs.openFile(path, flag);
-		file.fs = this;
-		return file;
-	}
-
-	public openFileSync(path: string, flag: string): File {
-		using _ = this.lockSync(path, 'openFile');
-		const file = this._fs.openFileSync(path, flag);
-		file.fs = this;
-		return file;
-	}
-
-	public async createFile(path: string, flag: string, mode: number): Promise<File> {
-		using _ = await this.lock(path, 'createFile');
-		const file = await this._fs.createFile(path, flag, mode);
-		file.fs = this;
-		return file;
-	}
-
-	public createFileSync(path: string, flag: string, mode: number): File {
-		using _ = this.lockSync(path, 'createFile');
-		const file = this._fs.createFileSync(path, flag, mode);
-		file.fs = this;
-		return file;
-	}
-
-	public async unlink(path: string): Promise<void> {
-		using _ = await this.lock(path, 'unlink');
-		await this._fs.unlink(path);
-	}
-
-	public unlinkSync(path: string): void {
-		using _ = this.lockSync(path, 'unlink');
-		return this._fs.unlinkSync(path);
-	}
-
-	public async rmdir(path: string): Promise<void> {
-		using _ = await this.lock(path, 'rmdir');
-		await this._fs.rmdir(path);
-	}
-
-	public rmdirSync(path: string): void {
-		using _ = this.lockSync(path, 'rmdir');
-		return this._fs.rmdirSync(path);
-	}
-
-	public async mkdir(path: string, mode: number): Promise<void> {
-		using _ = await this.lock(path, 'mkdir');
-		await this._fs.mkdir(path, mode);
-	}
-
-	public mkdirSync(path: string, mode: number): void {
-		using _ = this.lockSync(path, 'mkdir');
-		return this._fs.mkdirSync(path, mode);
-	}
-
-	public async readdir(path: string): Promise<string[]> {
-		using _ = await this.lock(path, 'readdir');
-		return await this._fs.readdir(path);
-	}
-
-	public readdirSync(path: string): string[] {
-		using _ = this.lockSync(path, 'readdir');
-		return this._fs.readdirSync(path);
-	}
-
-	public async exists(path: string): Promise<boolean> {
-		using _ = await this.lock(path, 'exists');
-		return await this._fs.exists(path);
-	}
-
-	public existsSync(path: string): boolean {
-		using _ = this.lockSync(path, 'exists');
-		return this._fs.existsSync(path);
-	}
-
-	public async link(srcpath: string, dstpath: string): Promise<void> {
-		using _ = await this.lock(srcpath, 'link');
-		await this._fs.link(srcpath, dstpath);
-	}
-
-	public linkSync(srcpath: string, dstpath: string): void {
-		using _ = this.lockSync(srcpath, 'link');
-		return this._fs.linkSync(srcpath, dstpath);
-	}
-
-	public async sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void> {
-		using _ = await this.lock(path, 'sync');
-		await this._fs.sync(path, data, stats);
-	}
-
-	public syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void {
-		using _ = this.lockSync(path, 'sync');
-		return this._fs.syncSync(path, data, stats);
-	}
-	/* eslint-enable @typescript-eslint/no-unused-vars */
-}
-
-/**
- * This serializes access to an underlying async filesystem.
- * For example, on an OverlayFS instance with an async lower
- * directory operations like rename and rmdir may involve multiple
- * requests involving both the upper and lower file systems -- they
- * are not executed in a single atomic step. OverlayFS uses this
- * to avoid having to reason about the correctness of
- * multiple requests interleaving.
- *
- * @privateRemarks
- * Instead of extending the passed class, `MutexedFS` stores it internally.
- * This is to avoid a deadlock caused when a method calls another one
- * The problem is discussed extensively in [#78](https://github.com/zen-fs/core/issues/78)
- * Instead of extending `FileSystem`,
- * `MutexedFS` implements it in order to make sure all of the methods are passed through
- *
- * @todo Change `using _` to `using void` pending https://github.com/tc39/proposal-discard-binding
- * @internal
- */
-export function Mutexed<const T extends Concrete<typeof FileSystem>>(
-	FS: T
-): typeof _MutexedFS<InstanceType<T>> & {
-	new (...args: ConstructorParameters<T>): _MutexedFS<InstanceType<T>>;
-} {
-	class MutexedFS extends _MutexedFS<InstanceType<T>> {
-		public constructor(...args: ConstructorParameters<T>) {
-			super();
-			this._fs = new FS(...args) as InstanceType<T>;
-		}
-	}
-	return MutexedFS;
-}

package/src/mixins/readonly.ts

@@ -1,96 +0,0 @@
-import { Errno, ErrnoError } from '../error.js';
-import type { File } from '../file.js';
-import type { FileSystem, FileSystemMetadata } from '../filesystem.js';
-import type { Stats } from '../stats.js';
-import type { Mixin } from './shared.js';
-
-/**
- * Implements the non-readonly methods to throw `EROFS`
- */
-/* eslint-disable @typescript-eslint/require-await */
-export function Readonly<T extends typeof FileSystem>(
-	FS: T
-): Mixin<
-	T,
-	{
-		metadata(): FileSystemMetadata;
-		rename(oldPath: string, newPath: string): Promise<void>;
-		renameSync(oldPath: string, newPath: string): void;
-		createFile(path: string, flag: string, mode: number): Promise<File>;
-		createFileSync(path: string, flag: string, mode: number): File;
-		unlink(path: string): Promise<void>;
-		unlinkSync(path: string): void;
-		rmdir(path: string): Promise<void>;
-		rmdirSync(path: string): void;
-		mkdir(path: string, mode: number): Promise<void>;
-		mkdirSync(path: string, mode: number): void;
-		link(srcpath: string, dstpath: string): Promise<void>;
-		linkSync(srcpath: string, dstpath: string): void;
-		sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
-		syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
-	}
-> {
-	abstract class ReadonlyFS extends FS {
-		public metadata(): FileSystemMetadata {
-			return { ...super.metadata(), readonly: true };
-		}
-
-		public async rename(): Promise<void> {
-			throw new ErrnoError(Errno.EROFS);
-		}
-
-		public renameSync(): void {
-			throw new ErrnoError(Errno.EROFS);
-		}
-
-		public async createFile(): Promise<File> {
-			throw new ErrnoError(Errno.EROFS);
-		}
-
-		public createFileSync(): File {
-			throw new ErrnoError(Errno.EROFS);
-		}
-
-		public async unlink(): Promise<void> {
-			throw new ErrnoError(Errno.EROFS);
-		}
-
-		public unlinkSync(): void {
-			throw new ErrnoError(Errno.EROFS);
-		}
-
-		public async rmdir(): Promise<void> {
-			throw new ErrnoError(Errno.EROFS);
-		}
-
-		public rmdirSync(): void {
-			throw new ErrnoError(Errno.EROFS);
-		}
-
-		public async mkdir(): Promise<void> {
-			throw new ErrnoError(Errno.EROFS);
-		}
-
-		public mkdirSync(): void {
-			throw new ErrnoError(Errno.EROFS);
-		}
-
-		public async link(): Promise<void> {
-			throw new ErrnoError(Errno.EROFS);
-		}
-
-		public linkSync(): void {
-			throw new ErrnoError(Errno.EROFS);
-		}
-
-		public async sync(): Promise<void> {
-			throw new ErrnoError(Errno.EROFS);
-		}
-
-		public syncSync(): void {
-			throw new ErrnoError(Errno.EROFS);
-		}
-	}
-	return ReadonlyFS;
-}
-/* eslint-enable @typescript-eslint/require-await */

package/src/mixins/shared.ts

@@ -1,25 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/*
-	Code shared by various mixins
-*/
-
-import type { ExtractProperties } from 'utilium';
-import type { FileSystem } from '../filesystem.js';
-
-/**
- * `TBase` with `TMixin` mixed-in.
- * @internal
- */
-export type Mixin<TBase extends typeof FileSystem, TMixin> = (abstract new (...args: any[]) => TMixin) & TBase;
-
-/**
- * Asynchronous `FileSystem` methods. This is a convenience type.
- * @internal
- */
-export type AsyncFSMethods = ExtractProperties<FileSystem, (...args: any[]) => Promise<unknown>>;
-
-/**
- * Concrete `FileSystem`. This is a convenience type.
- * @internal
- */
-export type ConcreteFS = ExtractProperties<FileSystem, any>;

package/src/mixins/sync.ts

@@ -1,58 +0,0 @@
-import type { File } from '../file.js';
-import type { FileSystem } from '../filesystem.js';
-import type { Stats } from '../stats.js';
-import type { Mixin, AsyncFSMethods } from './shared.js';
-
-/**
- * Implements the asynchronous API in terms of the synchronous API.
- */
-/* eslint-disable @typescript-eslint/require-await */
-export function Sync<T extends typeof FileSystem>(FS: T): Mixin<T, AsyncFSMethods> {
-	abstract class SyncFS extends FS implements AsyncFSMethods {
-		public async exists(path: string): Promise<boolean> {
-			return this.existsSync(path);
-		}
-
-		public async rename(oldPath: string, newPath: string): Promise<void> {
-			return this.renameSync(oldPath, newPath);
-		}
-
-		public async stat(path: string): Promise<Stats> {
-			return this.statSync(path);
-		}
-
-		public async createFile(path: string, flag: string, mode: number): Promise<File> {
-			return this.createFileSync(path, flag, mode);
-		}
-
-		public async openFile(path: string, flag: string): Promise<File> {
-			return this.openFileSync(path, flag);
-		}
-
-		public async unlink(path: string): Promise<void> {
-			return this.unlinkSync(path);
-		}
-
-		public async rmdir(path: string): Promise<void> {
-			return this.rmdirSync(path);
-		}
-
-		public async mkdir(path: string, mode: number): Promise<void> {
-			return this.mkdirSync(path, mode);
-		}
-
-		public async readdir(path: string): Promise<string[]> {
-			return this.readdirSync(path);
-		}
-
-		public async link(srcpath: string, dstpath: string): Promise<void> {
-			return this.linkSync(srcpath, dstpath);
-		}
-
-		public async sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void> {
-			return this.syncSync(path, data, stats);
-		}
-	}
-	return SyncFS;
-}
-/* eslint-enable @typescript-eslint/require-await */

package/src/polyfills.ts

@@ -1,21 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/unbound-method
-Promise.withResolvers ??= function <T>(): PromiseWithResolvers<T> {
-	let _resolve: ((value: T | PromiseLike<T>) => void) | undefined,
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		_reject: ((reason?: any) => void) | undefined;
-	const promise = new Promise<T>((resolve, reject) => {
-		_resolve = resolve;
-		_reject = reject;
-	});
-	return { promise, resolve: _resolve!, reject: _reject! };
-};
-
-/*
-	A polyfill for when these symbols are undefined.
-	For some reason, NodeJS does not polyfill them in a VM context.
-	Since jest uses a VM context for ESM, these need to be here.
-*/
-// @ts-expect-error 2540
-Symbol['dispose'] ??= Symbol('Symbol.dispose');
-// @ts-expect-error 2540
-Symbol['asyncDispose'] ??= Symbol('Symbol.asyncDispose');