@zenfs/core 1.1.0 → 1.1.1

package/dist/emulation/promises.d.ts

@@ -265,6 +265,11 @@ export declare function readdir(path: fs.PathLike, options: fs.ObjectEncodingOpt
     withFileTypes: true;
     recursive?: boolean;
 }): Promise<Dirent[]>;
+export declare function readdir(path: fs.PathLike, options?: {
+    withFileTypes?: boolean;
+    recursive?: boolean;
+    encoding?: BufferEncoding | 'buffer' | null;
+} | BufferEncoding | 'buffer' | null): Promise<string[] | Dirent[] | Buffer[]>;
 export declare function link(targetPath: fs.PathLike, linkPath: fs.PathLike): Promise<void>;
 /**
  * `symlink`.

package/dist/emulation/promises.js

@@ -51,7 +51,7 @@ import { Errno, ErrnoError } from '../error.js';
 import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
 import '../polyfills.js';
 import { BigIntStats } from '../stats.js';
-import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import { decodeUTF8, 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';
@@ -627,19 +627,16 @@ export async function mkdir(path, options) {
 }
 mkdir;
 export async function readdir(path, options) {
+    options = typeof options === 'object' ? options : { encoding: options };
     path = normalizePath(path);
     if (!(await stat(path)).hasAccess(constants.R_OK)) {
         throw ErrnoError.With('EACCES', path, 'readdir');
     }
     path = (await exists(path)) ? await realpath(path) : path;
     const { fs, path: resolved } = resolveMount(path);
-    let entries;
-    try {
-        entries = await fs.readdir(resolved);
-    }
-    catch (e) {
+    const entries = await fs.readdir(resolved).catch((e) => {
         throw fixError(e, { [resolved]: path });
-    }
+    });
     for (const point of mounts.keys()) {
         if (point.startsWith(path)) {
             const entry = point.slice(path.length);
@@ -652,12 +649,37 @@ export async function readdir(path, options) {
     }
     const values = [];
     for (const entry of entries) {
-        values.push(typeof options == 'object' && options?.withFileTypes ? new Dirent(entry, await stat(join(path, entry))) : entry);
+        const fullPath = join(path, entry);
+        const stats = options?.recursive || options?.withFileTypes ? await stat(fullPath) : null;
+        if (options?.withFileTypes) {
+            values.push(new Dirent(entry, stats));
+        }
+        else if (options?.encoding === 'buffer') {
+            values.push(Buffer.from(entry));
+        }
+        else {
+            values.push(entry);
+        }
+        if (!options?.recursive || !stats?.isDirectory()) {
+            continue;
+        }
+        for (const subEntry of await readdir(fullPath, options)) {
+            if (subEntry instanceof Dirent) {
+                subEntry.path = join(entry, subEntry.path);
+                values.push(subEntry);
+            }
+            else if (Buffer.isBuffer(subEntry)) {
+                // Convert Buffer to string, prefix with the full path
+                values.push(Buffer.from(join(entry, decodeUTF8(subEntry))));
+            }
+            else {
+                values.push(join(entry, subEntry));
+            }
+        }
     }
     return values;
 }
 readdir;
-// SYMLINK METHODS
 export async function link(targetPath, linkPath) {
     targetPath = normalizePath(targetPath);
     if (!(await stat(dirname(targetPath))).hasAccess(constants.R_OK)) {

package/dist/emulation/sync.d.ts

@@ -128,6 +128,11 @@ export declare function readdirSync(path: fs.PathLike, options?: (fs.ObjectEncod
     withFileTypes?: false;
     recursive?: boolean;
 }) | BufferEncoding | null): string[] | Buffer[];
+export declare function readdirSync(path: fs.PathLike, options?: {
+    withFileTypes?: boolean;
+    recursive?: boolean;
+    encoding?: BufferEncoding | 'buffer' | null;
+} | BufferEncoding | 'buffer' | null): string[] | Dirent[] | Buffer[];
 export declare function linkSync(targetPath: fs.PathLike, linkPath: fs.PathLike): void;
 /**
  * Synchronous `symlink`.

package/dist/emulation/sync.js

@@ -49,7 +49,7 @@ import { Buffer } from 'buffer';
 import { Errno, ErrnoError } from '../error.js';
 import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
 import { BigIntStats } from '../stats.js';
-import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import { decodeUTF8, 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';
@@ -431,6 +431,7 @@ export function mkdirSync(path, options) {
 }
 mkdirSync;
 export function readdirSync(path, options) {
+    options = typeof options === 'object' ? options : { encoding: options };
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
     let entries;
@@ -454,15 +455,36 @@ export function readdirSync(path, options) {
         }
         entries.push(entry);
     }
-    return entries.map((entry) => {
-        if (typeof options == 'object' && options?.withFileTypes) {
-            return new Dirent(entry, statSync(join(path.toString(), entry)));
+    // Iterate over entries and handle recursive case if needed
+    const values = [];
+    for (const entry of entries) {
+        const fullPath = join(path, entry);
+        const entryStat = statSync(fullPath);
+        if (options?.withFileTypes) {
+            values.push(new Dirent(entry, entryStat));
         }
-        if (options == 'buffer' || (typeof options == 'object' && options?.encoding == 'buffer')) {
-            return Buffer.from(entry);
+        else if (options?.encoding === 'buffer') {
+            values.push(Buffer.from(entry));
         }
-        return entry;
-    });
+        else {
+            values.push(entry);
+        }
+        if (!entryStat.isDirectory() || !options?.recursive)
+            continue;
+        for (const subEntry of readdirSync(fullPath, options)) {
+            if (subEntry instanceof Dirent) {
+                subEntry.path = join(entry, subEntry.path);
+                values.push(subEntry);
+            }
+            else if (Buffer.isBuffer(subEntry)) {
+                values.push(Buffer.from(join(entry, decodeUTF8(subEntry))));
+            }
+            else {
+                values.push(join(entry, subEntry));
+            }
+        }
+    }
+    return values;
 }
 readdirSync;
 // SYMLINK METHODS

package/package.json

@@ -1,7 +1,11 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.1.0",
+	"version": "1.1.1",
 	"description": "A filesystem, anywhere",
+	"funding": {
+		"type": "individual",
+		"url": "https://github.com/sponsors/james-pre"
+	},
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"keywords": [

package/src/emulation/promises.ts

@@ -13,7 +13,7 @@ import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWrit
 import type { FileContents } from '../filesystem.js';
 import '../polyfills.js';
 import { BigIntStats, type Stats } from '../stats.js';
-import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import { decodeUTF8, 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';
@@ -692,22 +692,28 @@ export async function readdir(
 	options?: (fs.ObjectEncodingOptions & { withFileTypes?: false; recursive?: boolean }) | BufferEncoding | null
 ): Promise<string[] | Buffer[]>;
 export async function readdir(path: fs.PathLike, options: fs.ObjectEncodingOptions & { withFileTypes: true; recursive?: boolean }): Promise<Dirent[]>;
+export async function readdir(
+	path: fs.PathLike,
+	options?: { withFileTypes?: boolean; recursive?: boolean; encoding?: BufferEncoding | 'buffer' | null } | BufferEncoding | 'buffer' | null
+): Promise<string[] | Dirent[] | Buffer[]>;
 export async function readdir(
 	path: fs.PathLike,
 	options?: { withFileTypes?: boolean; recursive?: boolean; encoding?: BufferEncoding | 'buffer' | null } | BufferEncoding | 'buffer' | null
 ): Promise<string[] | Dirent[] | Buffer[]> {
+	options = typeof options === 'object' ? options : { encoding: options };
 	path = normalizePath(path);
+
 	if (!(await stat(path)).hasAccess(constants.R_OK)) {
 		throw ErrnoError.With('EACCES', path, 'readdir');
 	}
+
 	path = (await exists(path)) ? await realpath(path) : path;
 	const { fs, path: resolved } = resolveMount(path);
-	let entries: string[];
-	try {
-		entries = await fs.readdir(resolved);
-	} catch (e) {
+
+	const entries = await fs.readdir(resolved).catch((e: Error) => {
 		throw fixError(e as Error, { [resolved]: path });
-	}
+	});
+
 	for (const point of mounts.keys()) {
 		if (point.startsWith(path)) {
 			const entry = point.slice(path.length);
@@ -718,16 +724,41 @@ export async function readdir(
 			entries.push(entry);
 		}
 	}
-	const values: (string | Dirent)[] = [];
+
+	const values: (string | Dirent | Buffer)[] = [];
 	for (const entry of entries) {
-		values.push(typeof options == 'object' && options?.withFileTypes ? new Dirent(entry, await stat(join(path, entry))) : entry);
+		const fullPath = join(path, entry);
+
+		const stats = options?.recursive || options?.withFileTypes ? await stat(fullPath) : null;
+		if (options?.withFileTypes) {
+			values.push(new Dirent(entry, stats!));
+		} else if (options?.encoding === 'buffer') {
+			values.push(Buffer.from(entry));
+		} else {
+			values.push(entry);
+		}
+
+		if (!options?.recursive || !stats?.isDirectory()) {
+			continue;
+		}
+
+		for (const subEntry of await readdir(fullPath, options)) {
+			if (subEntry instanceof Dirent) {
+				subEntry.path = join(entry, subEntry.path);
+				values.push(subEntry);
+			} else if (Buffer.isBuffer(subEntry)) {
+				// Convert Buffer to string, prefix with the full path
+				values.push(Buffer.from(join(entry, decodeUTF8(subEntry))));
+			} else {
+				values.push(join(entry, subEntry));
+			}
+		}
 	}
+
 	return values as string[] | Dirent[];
 }
 readdir satisfies typeof promises.readdir;
 
-// SYMLINK METHODS
-
 export async function link(targetPath: fs.PathLike, linkPath: fs.PathLike): Promise<void> {
 	targetPath = normalizePath(targetPath);
 	if (!(await stat(dirname(targetPath))).hasAccess(constants.R_OK)) {

package/src/emulation/sync.ts

@@ -5,7 +5,7 @@ import type { File } from '../file.js';
 import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
 import type { FileContents } from '../filesystem.js';
 import { BigIntStats, type Stats } from '../stats.js';
-import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import { decodeUTF8, 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';
@@ -437,10 +437,15 @@ export function readdirSync(path: fs.PathLike, options?: { recursive?: boolean;
 export function readdirSync(path: fs.PathLike, options: { recursive?: boolean; encoding: 'buffer'; withFileTypes?: false } | 'buffer'): Buffer[];
 export function readdirSync(path: fs.PathLike, options: { recursive?: boolean; withFileTypes: true }): Dirent[];
 export function readdirSync(path: fs.PathLike, options?: (fs.ObjectEncodingOptions & { withFileTypes?: false; recursive?: boolean }) | BufferEncoding | null): string[] | Buffer[];
+export function readdirSync(
+	path: fs.PathLike,
+	options?: { withFileTypes?: boolean; recursive?: boolean; encoding?: BufferEncoding | 'buffer' | null } | BufferEncoding | 'buffer' | null
+): string[] | Dirent[] | Buffer[];
 export function readdirSync(
 	path: fs.PathLike,
 	options?: { recursive?: boolean; encoding?: BufferEncoding | 'buffer' | null; withFileTypes?: boolean } | BufferEncoding | 'buffer' | null
 ): string[] | Dirent[] | Buffer[] {
+	options = typeof options === 'object' ? options : { encoding: options };
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
 	let entries: string[];
@@ -452,6 +457,7 @@ export function readdirSync(
 	} catch (e) {
 		throw fixError(e as Error, { [resolved]: path });
 	}
+
 	for (const mount of mounts.keys()) {
 		if (!mount.startsWith(path)) {
 			continue;
@@ -463,17 +469,35 @@ export function readdirSync(
 		}
 		entries.push(entry);
 	}
-	return entries.map((entry: string) => {
-		if (typeof options == 'object' && options?.withFileTypes) {
-			return new Dirent(entry, statSync(join(path.toString(), entry)));
-		}
 
-		if (options == 'buffer' || (typeof options == 'object' && options?.encoding == 'buffer')) {
-			return Buffer.from(entry);
+	// Iterate over entries and handle recursive case if needed
+	const values: (string | Dirent | Buffer)[] = [];
+	for (const entry of entries) {
+		const fullPath = join(path, entry);
+		const entryStat = statSync(fullPath);
+
+		if (options?.withFileTypes) {
+			values.push(new Dirent(entry, entryStat));
+		} else if (options?.encoding === 'buffer') {
+			values.push(Buffer.from(entry));
+		} else {
+			values.push(entry);
+		}
+		if (!entryStat.isDirectory() || !options?.recursive) continue;
+
+		for (const subEntry of readdirSync(fullPath, options)) {
+			if (subEntry instanceof Dirent) {
+				subEntry.path = join(entry, subEntry.path);
+				values.push(subEntry);
+			} else if (Buffer.isBuffer(subEntry)) {
+				values.push(Buffer.from(join(entry, decodeUTF8(subEntry))));
+			} else {
+				values.push(join(entry, subEntry));
+			}
 		}
+	}
 
-		return entry;
-	}) as string[] | Dirent[] | Buffer[];
+	return values as string[] | Dirent[] | Buffer[];
 }
 readdirSync satisfies typeof fs.readdirSync;