@zenfs/core 0.9.6 → 0.9.7

package/src/file.ts

@@ -181,12 +181,12 @@ export abstract class File {
 	/**
 	 * Get the current file position.
 	 */
-	public abstract position?: number;
+	public abstract position: number;
 
 	/**
 	 * The path to the file
 	 */
-	public abstract readonly path?: string;
+	public abstract readonly path: string;
 
 	/**
 	 * Asynchronous `stat`.
@@ -241,7 +241,7 @@ export abstract class File {
 	 *   the current position.
 	 * @returns Promise resolving to the new length of the buffer
 	 */
-	public abstract write(buffer: Uint8Array, offset?: number, length?: number, position?: number): Promise<number>;
+	public abstract write(buffer: Uint8Array, offset?: number, length?: number, position?: number | null): Promise<number>;
 
 	/**
 	 * Write buffer to the file.
@@ -255,7 +255,7 @@ export abstract class File {
 	 *   data should be written. If position is null, the data will be written at
 	 *   the current position.
 	 */
-	public abstract writeSync(buffer: Uint8Array, offset?: number, length?: number, position?: number): number;
+	public abstract writeSync(buffer: Uint8Array, offset?: number, length?: number, position?: number | null): number;
 
 	/**
 	 * Read data from the file.
@@ -468,7 +468,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 * Asynchronous truncate.
 	 * @param len
 	 */
-	public truncate(len: number): Promise<void> {
+	public async truncate(len: number): Promise<void> {
 		this.truncateSync(len);
 		if (isSynchronous(this.flag)) {
 			return this.sync();
@@ -515,7 +515,9 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 *   the current position.
 	 */
 	public async write(buffer: Uint8Array, offset: number = 0, length: number = this.stats.size, position: number = 0): Promise<number> {
-		return this.writeSync(buffer, offset, length, position);
+		const bytesWritten = this.writeSync(buffer, offset, length, position);
+		await this.sync();
+		return bytesWritten;
 	}
 
 	/**
@@ -541,7 +543,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 		if (endFp > this.stats.size) {
 			this.stats.size = endFp;
 			if (endFp > this._buffer.byteLength) {
-				if (this._buffer.buffer.resizable && this._buffer.buffer.maxByteLength <= endFp) {
+				if (this._buffer.buffer.resizable && this._buffer.buffer.maxByteLength! <= endFp) {
 					this._buffer.buffer.resize(endFp);
 				} else {
 					// Extend the buffer!
@@ -594,7 +596,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 *   position.
 	 * @returns number of bytes written
 	 */
-	public readSync(buffer: ArrayBufferView, offset: number = 0, length: number = this.stats.size, position: number = 0): number {
+	public readSync(buffer: ArrayBufferView, offset: number = 0, length: number = this.stats.size, position?: number): number {
 		if (!isReadable(this.flag)) {
 			throw new ApiError(ErrorCode.EPERM, 'File not opened with a readable mode.');
 		}
@@ -610,7 +612,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 			// No copy/read. Return immediatly for better performance
 			return bytesRead;
 		}
-		new Uint8Array(buffer.buffer).set(this._buffer.slice(position, end), offset);
+		new Uint8Array(buffer.buffer, 0, length).set(this._buffer.slice(position, end), offset);
 		return bytesRead;
 	}
 

package/src/filesystem.ts

@@ -5,7 +5,7 @@ import { join } from './emulation/path.js';
 import { PreloadFile, parseFlag, type File } from './file.js';
 import type { Stats } from './stats.js';
 
-export type FileContents = Uint8Array | string;
+export type FileContents = ArrayBufferView | string;
 
 /**
  * Metadata about a FileSystem
@@ -218,7 +218,8 @@ declare abstract class SyncFileSystem extends FileSystem {
 /**
  * Implements the asynchronous API in terms of the synchronous API.
  */
-export function Sync<T extends abstract new (...args) => FileSystem>(FS: T): (abstract new (...args) => SyncFileSystem) & T {
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function Sync<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => SyncFileSystem) & T {
 	abstract class _SyncFileSystem extends FS implements SyncFileSystem {
 		public async exists(path: string, cred: Cred): Promise<boolean> {
 			return this.existsSync(path, cred);
@@ -290,7 +291,8 @@ declare abstract class AsyncFileSystem extends FileSystem {
 	syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
 }
 
-type AsyncMethods = ExtractProperties<FileSystem, (...args) => Promise<unknown>>;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AsyncMethods = ExtractProperties<FileSystem, (...args: any[]) => Promise<unknown>>;
 
 /**
  * @internal
@@ -311,7 +313,8 @@ type AsyncOperation = {
  *   the synchronous store, if desired.
  *
  */
-export function Async<T extends abstract new (...args) => FileSystem>(FS: T): (abstract new (...args) => AsyncFileSystem) & T {
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function Async<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => AsyncFileSystem) & T {
 	abstract class _AsyncFileSystem extends FS implements AsyncFileSystem {
 		/**
 		 * Queue of pending asynchronous operations.
@@ -323,7 +326,7 @@ export function Async<T extends abstract new (...args) => FileSystem>(FS: T): (a
 
 		public queueDone(): Promise<void> {
 			return new Promise(resolve => {
-				const check = () => (this._queueRunning ? setTimeout(check) : resolve());
+				const check = (): unknown => (this._queueRunning ? setTimeout(check) : resolve());
 				check();
 			});
 		}
@@ -440,7 +443,7 @@ export function Async<T extends abstract new (...args) => FileSystem>(FS: T): (a
 				return;
 			}
 
-			const [method, ...args] = this._queue.shift();
+			const [method, ...args] = this._queue.shift()!;
 			// @ts-expect-error 2556 (since ...args is not correctly picked up as being a tuple)
 			await this[method](...args);
 			await this._next();
@@ -482,7 +485,8 @@ declare abstract class ReadonlyFileSystem extends FileSystem {
 /**
  * Implements the non-readonly methods to throw `EROFS`
  */
-export function Readonly<T extends abstract new (...args) => FileSystem>(FS: T): (abstract new (...args) => ReadonlyFileSystem) & T {
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function Readonly<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => ReadonlyFileSystem) & T {
 	abstract class _ReadonlyFileSystem extends FS implements ReadonlyFileSystem {
 		public metadata(): FileSystemMetadata {
 			return { ...super.metadata(), readonly: true };

package/src/mutex.ts

@@ -8,9 +8,9 @@ export class Mutex {
 	public lock(path: string): Promise<void> {
 		return new Promise(resolve => {
 			if (this._locks.has(path)) {
-				this._locks.get(path).push(resolve);
+				this._locks.get(path)!.push(resolve);
 			} else {
-				this._locks.set(path, []);
+				this._locks.set(path, [resolve]);
 			}
 		});
 	}
@@ -20,7 +20,7 @@ export class Mutex {
 			throw new Error('unlock of a non-locked mutex');
 		}
 
-		const next = this._locks.get(path).shift();
+		const next = this._locks.get(path)?.shift();
 		/* 
 			don't unlock - we want to queue up next for the
 			end of the current task execution, but we don't

package/src/stats.ts

@@ -120,7 +120,7 @@ export abstract class StatsCommon<T extends number | bigint> implements Node.Sta
 	/**
 	 * Some file systems stash data on stats objects.
 	 */
-	public fileData?: Uint8Array = null;
+	public fileData?: Uint8Array;
 
 	/**
 	 * time of last access, in milliseconds since epoch
@@ -185,15 +185,16 @@ export abstract class StatsCommon<T extends number | bigint> implements Node.Sta
 	 */
 	constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode, ino }: Partial<StatsLike> = {}) {
 		const currentTime = Date.now();
-		const resolveT = (val: number | bigint, _default: number) => <T>(typeof val == this._typename ? val : this._convert(typeof val == this._typename_inverse ? val : _default));
+		const resolveT = (val: number | bigint | undefined, _default: number) =>
+			<T>(typeof val == this._typename ? val : this._convert(typeof val == this._typename_inverse ? val! : _default));
 		this.atimeMs = resolveT(atimeMs, currentTime);
 		this.mtimeMs = resolveT(mtimeMs, currentTime);
 		this.ctimeMs = resolveT(ctimeMs, currentTime);
 		this.birthtimeMs = resolveT(birthtimeMs, currentTime);
 		this.uid = resolveT(uid, 0);
 		this.gid = resolveT(gid, 0);
-		this.size = this._convert(size);
-		this.ino = this._convert(ino);
+		this.size = resolveT(size, 0);
+		this.ino = resolveT(ino, 0);
 		const itemType: FileType = Number(mode) & S_IFMT || FileType.FILE;
 
 		if (mode) {
@@ -312,6 +313,19 @@ export abstract class StatsCommon<T extends number | bigint> implements Node.Sta
 			this.gid = this._convert(gid);
 		}
 	}
+
+	public get atimeNs(): bigint {
+		return BigInt(this.atimeMs);
+	}
+	public get mtimeNs(): bigint {
+		return BigInt(this.mtimeMs);
+	}
+	public get ctimeNs(): bigint {
+		return BigInt(this.ctimeMs);
+	}
+	public get birthtimeNs(): bigint {
+		return BigInt(this.birthtimeMs);
+	}
 }
 
 /**
@@ -341,11 +355,6 @@ Stats satisfies typeof Node.Stats;
 export class BigIntStats extends StatsCommon<bigint> implements Node.BigIntStats, StatsLike {
 	protected _isBigint = true;
 
-	public atimeNs: bigint;
-	public mtimeNs: bigint;
-	public ctimeNs: bigint;
-	public birthtimeNs: bigint;
-
 	/**
 	 * Clone a stats object.
 	 * @deprecated use `new BigIntStats(stats)`
@@ -357,34 +366,34 @@ export class BigIntStats extends StatsCommon<bigint> implements Node.BigIntStats
 
 export class StatsFs implements Node.StatsFsBase<number> {
 	/** Type of file system. */
-	public type: number;
+	public type: number = 0;
 	/**  Optimal transfer block size. */
-	public bsize: number;
+	public bsize: number = 0;
 	/**  Total data blocks in file system. */
-	public blocks: number;
+	public blocks: number = 0;
 	/** Free blocks in file system. */
-	public bfree: number;
+	public bfree: number = 0;
 	/** Available blocks for unprivileged users */
-	public bavail: number;
+	public bavail: number = 0;
 	/** Total file nodes in file system. */
-	public files: number;
+	public files: number = 0;
 	/** Free file nodes in file system. */
-	public ffree: number;
+	public ffree: number = 0;
 }
 
 export class BigIntStatsFs implements Node.StatsFsBase<bigint> {
 	/** Type of file system. */
-	public type: bigint;
+	public type: bigint = 0n;
 	/**  Optimal transfer block size. */
-	public bsize: bigint;
+	public bsize: bigint = 0n;
 	/**  Total data blocks in file system. */
-	public blocks: bigint;
+	public blocks: bigint = 0n;
 	/** Free blocks in file system. */
-	public bfree: bigint;
+	public bfree: bigint = 0n;
 	/** Available blocks for unprivileged users */
-	public bavail: bigint;
+	public bavail: bigint = 0n;
 	/** Total file nodes in file system. */
-	public files: bigint;
+	public files: bigint = 0n;
 	/** Free file nodes in file system. */
-	public ffree: bigint;
+	public ffree: bigint = 0n;
 }

package/src/utils.ts

@@ -114,7 +114,7 @@ export function levenshtein(a: string, b: string): number {
 /**
  * @hidden
  */
-export const setImmediate = typeof globalThis.setImmediate == 'function' ? globalThis.setImmediate : cb => setTimeout(cb, 0);
+export const setImmediate = typeof globalThis.setImmediate == 'function' ? globalThis.setImmediate : (cb: () => unknown) => setTimeout(cb, 0);
 
 /**
  * Encodes a string into a buffer
@@ -173,7 +173,7 @@ export function encodeDirListing(data: Record<string, bigint>): Uint8Array {
 
 export type Callback<Args extends unknown[] = []> = (e?: ApiError, ...args: OptionalTuple<Args>) => unknown;
 
-import type { EncodingOption, OpenMode, WriteFileOptions } from 'node:fs';
+import type { EncodingOption, OpenMode, PathLike, WriteFileOptions } from 'node:fs';
 
 /**
  * converts Date or number to a integer UNIX timestamp
@@ -238,7 +238,8 @@ export function normalizeTime(time: string | number | Date): Date {
  * Normalizes a path
  * @internal
  */
-export function normalizePath(p: string): string {
+export function normalizePath(p: PathLike): string {
+	p = p.toString();
 	// Node doesn't allow null characters in paths.
 	if (p.includes('\x00')) {
 		throw new ApiError(ErrorCode.EINVAL, 'Path must be a string without null bytes.');
@@ -258,21 +259,21 @@ export function normalizePath(p: string): string {
  * @internal
  */
 export function normalizeOptions(
-	options?: WriteFileOptions | (EncodingOption & { flag?: OpenMode }),
-	encoding: BufferEncoding = 'utf8',
-	flag?: string,
+	options: WriteFileOptions | (EncodingOption & { flag?: OpenMode }) | undefined,
+	encoding: BufferEncoding | null = 'utf8',
+	flag: string,
 	mode: number = 0
-): { encoding: BufferEncoding; flag: string; mode: number } {
+): { encoding?: BufferEncoding | null; flag: string; mode: number } {
 	if (typeof options != 'object' || options === null) {
 		return {
-			encoding: typeof options == 'string' ? options : encoding,
+			encoding: typeof options == 'string' ? options : encoding ?? null,
 			flag,
 			mode,
 		};
 	}
 
 	return {
-		encoding: typeof options?.encoding == 'string' ? options.encoding : encoding,
+		encoding: typeof options?.encoding == 'string' ? options.encoding : encoding ?? null,
 		flag: typeof options?.flag == 'string' ? options.flag : flag,
 		mode: normalizeMode('mode' in options ? options?.mode : null, mode),
 	};

package/tsconfig.json

@@ -5,7 +5,8 @@
 		"outDir": "dist",
 		"lib": ["ESNext"],
 		"moduleResolution": "NodeNext",
-		"declaration": true
+		"declaration": true,
+		"strict": true
 	},
 	"include": ["src/**/*"],
 	"exclude": ["node_modules"]