tiny-readdir 2.2.0 → 2.2.1

package/dist/index.js

@@ -1,7 +1,7 @@
 /* IMPORT */
 import fs from 'node:fs';
 import path from 'node:path';
-import { isFunction } from './utils.js';
+import { isFunction, makeCounterPromise } from './utils.js';
 /* MAIN */
 const readdir = (rootPath, options) => {
     const followSymlinks = options?.followSymlinks ?? false;
@@ -17,6 +17,7 @@ const readdir = (rootPath, options) => {
     const visited = new Set();
     const resultEmpty = { directories: [], files: [], symlinks: [], map: {} };
     const result = { directories, files, symlinks, map };
+    const { promise, increment, decrement } = makeCounterPromise();
     let foundPaths = 0;
     const handleDirectory = (dirmap, subPath, depth) => {
         if (visited.has(subPath))
@@ -31,7 +32,7 @@ const readdir = (rootPath, options) => {
             return;
         if (foundPaths >= maxPaths)
             return;
-        return populateResultFromPath(subPath, depth + 1);
+        populateResultFromPath(subPath, depth + 1);
     };
     const handleFile = (dirmap, subPath) => {
         if (visited.has(subPath))
@@ -58,7 +59,7 @@ const readdir = (rootPath, options) => {
             return;
         if (foundPaths >= maxPaths)
             return;
-        return populateResultFromSymlink(subPath, depth + 1);
+        populateResultFromSymlink(subPath, depth + 1);
     };
     const handleStat = (dirmap, rootPath, stat, depth) => {
         if (signal.aborted)
@@ -66,13 +67,13 @@ const readdir = (rootPath, options) => {
         if (isIgnored(rootPath))
             return;
         if (stat.isDirectory()) {
-            return handleDirectory(dirmap, rootPath, depth);
+            handleDirectory(dirmap, rootPath, depth);
         }
         else if (stat.isFile()) {
-            return handleFile(dirmap, rootPath);
+            handleFile(dirmap, rootPath);
         }
         else if (stat.isSymbolicLink()) {
-            return handleSymlink(dirmap, rootPath, depth);
+            handleSymlink(dirmap, rootPath, depth);
         }
     };
     const handleDirent = (dirmap, rootPath, dirent, depth) => {
@@ -83,48 +84,63 @@ const readdir = (rootPath, options) => {
         if (isIgnored(subPath))
             return;
         if (dirent.isDirectory()) {
-            return handleDirectory(dirmap, subPath, depth);
+            handleDirectory(dirmap, subPath, depth);
         }
         else if (dirent.isFile()) {
-            return handleFile(dirmap, subPath);
+            handleFile(dirmap, subPath);
         }
         else if (dirent.isSymbolicLink()) {
-            return handleSymlink(dirmap, subPath, depth);
+            handleSymlink(dirmap, subPath, depth);
         }
     };
     const handleDirents = (dirmap, rootPath, dirents, depth) => {
-        return Promise.all(dirents.map((dirent) => {
-            return handleDirent(dirmap, rootPath, dirent, depth);
-        }));
+        for (let i = 0, l = dirents.length; i < l; i++) {
+            handleDirent(dirmap, rootPath, dirents[i], depth);
+        }
     };
-    const populateResultFromPath = async (rootPath, depth) => {
+    const populateResultFromPath = (rootPath, depth) => {
         if (signal.aborted)
             return;
         if (depth > maxDepth)
             return;
         if (foundPaths >= maxPaths)
             return;
-        const dirents = await fs.promises.readdir(rootPath, { withFileTypes: true }).catch(() => []);
-        if (signal.aborted)
-            return;
-        const dirmap = map[rootPath] = { directories: [], files: [], symlinks: [] };
-        if (!dirents.length)
-            return;
-        await handleDirents(dirmap, rootPath, dirents, depth);
+        increment();
+        fs.readdir(rootPath, { withFileTypes: true }, (error, dirents) => {
+            if (error)
+                return decrement();
+            if (signal.aborted)
+                return decrement();
+            if (!dirents.length)
+                return decrement();
+            const dirmap = map[rootPath] = { directories: [], files: [], symlinks: [] };
+            handleDirents(dirmap, rootPath, dirents, depth);
+            decrement();
+        });
     };
     const populateResultFromSymlink = async (rootPath, depth) => {
-        try {
-            const realPath = await fs.promises.realpath(rootPath);
-            const stat = await fs.promises.stat(realPath);
-            const dirmap = map[rootPath] = { directories: [], files: [], symlinks: [] };
-            await handleStat(dirmap, realPath, stat, depth);
-        }
-        catch { }
+        increment();
+        fs.realpath(rootPath, (error, realPath) => {
+            if (error)
+                return decrement();
+            if (signal.aborted)
+                return decrement();
+            fs.stat(realPath, async (error, stat) => {
+                if (error)
+                    return decrement();
+                if (signal.aborted)
+                    return decrement();
+                const dirmap = map[rootPath] = { directories: [], files: [], symlinks: [] };
+                handleStat(dirmap, realPath, stat, depth);
+                decrement();
+            });
+        });
     };
     const getResult = async (rootPath, depth = 1) => {
         rootPath = path.normalize(rootPath);
         visited.add(rootPath);
-        await populateResultFromPath(rootPath, depth);
+        populateResultFromPath(rootPath, depth);
+        await promise;
         if (signal.aborted)
             return resultEmpty;
         return result;

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-type Promisable<T> = Promise<T> | T;
+type Callback = () => void;
 type Options = {
     depth?: number;
     limit?: number;
@@ -19,4 +19,4 @@ type ResultDirectories = {
 type Result = ResultDirectory & {
     map: ResultDirectories;
 };
-export type { Promisable, Options, ResultDirectory, ResultDirectories, Result };
+export type { Callback, Options, ResultDirectory, ResultDirectories, Result };

package/dist/utils.d.ts

@@ -1,2 +1,8 @@
+import type { Callback } from './types';
 declare const isFunction: (value: unknown) => value is Function;
-export { isFunction };
+declare const makeCounterPromise: () => {
+    promise: Promise<void>;
+    increment: Callback;
+    decrement: Callback;
+};
+export { isFunction, makeCounterPromise };

package/dist/utils.js

@@ -1,6 +1,22 @@
+/* IMPORT */
+import makeNakedPromise from 'promise-make-naked';
 /* MAIN */
 const isFunction = (value) => {
     return (typeof value === 'function');
 };
+const makeCounterPromise = () => {
+    const { promise, resolve } = makeNakedPromise();
+    let counter = 0;
+    const increment = () => {
+        counter += 1;
+    };
+    const decrement = () => {
+        counter -= 1;
+        if (counter)
+            return;
+        resolve();
+    };
+    return { promise, increment, decrement };
+};
 /* EXPORT */
-export { isFunction };
+export { isFunction, makeCounterPromise };

package/package.json

@@ -2,7 +2,7 @@
   "name": "tiny-readdir",
   "repository": "github:fabiospampinato/tiny-readdir",
   "description": "A simple promisified recursive readdir function.",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "type": "module",
   "main": "dist/index.js",
   "exports": "./dist/index.js",
@@ -11,10 +11,9 @@
     "clean": "tsex clean",
     "compile": "tsex compile",
     "compile:watch": "tsex compile --watch",
-    "test": "npm run test:native && npm run test:yielding",
-    "test:native": "fava '**/native.js'",
-    "test:yielding": "node test/yielding.js",
-    "prepublishOnly": "npm run clean && npm run compile && npm run test"
+    "test": "tsex test",
+    "test:watch": "tsex test --watch",
+    "prepublishOnly": "tsex prepare"
   },
   "keywords": [
     "readdir",
@@ -23,10 +22,13 @@
     "simple",
     "tiny"
   ],
+  "dependencies": {
+    "promise-make-naked": "^2.1.1"
+  },
   "devDependencies": {
-    "@types/node": "^18.11.9",
-    "fava": "^0.0.7",
-    "tsex": "^1.1.3",
-    "typescript": "^4.9.3"
+    "@types/node": "^20.4.8",
+    "fava": "^0.2.1",
+    "tsex": "^3.0.1",
+    "typescript": "^5.1.6"
   }
 }

package/src/index.ts

@@ -3,8 +3,8 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
-import {isFunction} from './utils';
-import type {Promisable, Options, ResultDirectory, ResultDirectories, Result} from './types';
+import {isFunction, makeCounterPromise} from './utils';
+import type {Options, ResultDirectory, ResultDirectories, Result} from './types';
 
 /* MAIN */
 
@@ -23,10 +23,11 @@ const readdir = ( rootPath: string, options?: Options ): Promise<Result> => {
   const visited = new Set<string> ();
   const resultEmpty: Result = { directories: [], files: [], symlinks: [], map: {} };
   const result: Result = { directories, files, symlinks, map };
+  const {promise, increment, decrement} = makeCounterPromise ();
 
   let foundPaths = 0;
 
-  const handleDirectory = ( dirmap: ResultDirectory, subPath: string, depth: number ): Promisable<void> => {
+  const handleDirectory = ( dirmap: ResultDirectory, subPath: string, depth: number ): void => {
 
     if ( visited.has ( subPath ) ) return;
 
@@ -41,7 +42,7 @@ const readdir = ( rootPath: string, options?: Options ): Promise<Result> => {
 
     if ( foundPaths >= maxPaths ) return;
 
-    return populateResultFromPath ( subPath, depth + 1 );
+    populateResultFromPath ( subPath, depth + 1 );
 
   };
 
@@ -58,7 +59,7 @@ const readdir = ( rootPath: string, options?: Options ): Promise<Result> => {
 
   };
 
-  const handleSymlink = ( dirmap: ResultDirectory, subPath: string, depth: number ): Promisable<void> => {
+  const handleSymlink = ( dirmap: ResultDirectory, subPath: string, depth: number ): void => {
 
     if ( visited.has ( subPath ) ) return;
 
@@ -75,11 +76,11 @@ const readdir = ( rootPath: string, options?: Options ): Promise<Result> => {
 
     if ( foundPaths >= maxPaths ) return;
 
-    return populateResultFromSymlink ( subPath, depth + 1 );
+    populateResultFromSymlink ( subPath, depth + 1 );
 
   };
 
-  const handleStat = ( dirmap: ResultDirectory, rootPath: string, stat: fs.Stats, depth: number ): Promisable<void> => {
+  const handleStat = ( dirmap: ResultDirectory, rootPath: string, stat: fs.Stats, depth: number ): void => {
 
     if ( signal.aborted ) return;
 
@@ -87,21 +88,21 @@ const readdir = ( rootPath: string, options?: Options ): Promise<Result> => {
 
     if ( stat.isDirectory () ) {
 
-      return handleDirectory ( dirmap, rootPath, depth );
+      handleDirectory ( dirmap, rootPath, depth );
 
     } else if ( stat.isFile () ) {
 
-      return handleFile ( dirmap, rootPath );
+      handleFile ( dirmap, rootPath );
 
     } else if ( stat.isSymbolicLink () ) {
 
-      return handleSymlink ( dirmap, rootPath, depth );
+      handleSymlink ( dirmap, rootPath, depth );
 
     }
 
   };
 
-  const handleDirent = ( dirmap: ResultDirectory, rootPath: string, dirent: fs.Dirent, depth: number ): Promisable<void> => {
+  const handleDirent = ( dirmap: ResultDirectory, rootPath: string, dirent: fs.Dirent, depth: number ): void => {
 
     if ( signal.aborted ) return;
 
@@ -112,31 +113,31 @@ const readdir = ( rootPath: string, options?: Options ): Promise<Result> => {
 
     if ( dirent.isDirectory () ) {
 
-      return handleDirectory ( dirmap, subPath, depth );
+      handleDirectory ( dirmap, subPath, depth );
 
     } else if ( dirent.isFile () ) {
 
-      return handleFile ( dirmap, subPath );
+      handleFile ( dirmap, subPath );
 
     } else if ( dirent.isSymbolicLink () ) {
 
-      return handleSymlink ( dirmap, subPath, depth );
+      handleSymlink ( dirmap, subPath, depth );
 
     }
 
   };
 
-  const handleDirents = ( dirmap: ResultDirectory, rootPath: string, dirents: fs.Dirent[], depth: number ): Promise<void[]> => {
+  const handleDirents = ( dirmap: ResultDirectory, rootPath: string, dirents: fs.Dirent[], depth: number ): void => {
 
-    return Promise.all ( dirents.map ( ( dirent ): Promisable<void> => {
+    for ( let i = 0, l = dirents.length; i < l; i++ ) {
 
-      return handleDirent ( dirmap, rootPath, dirent, depth );
+      handleDirent ( dirmap, rootPath, dirents[i], depth );
 
-    }));
+    }
 
   };
 
-  const populateResultFromPath = async ( rootPath: string, depth: number ): Promise<void> => {
+  const populateResultFromPath = ( rootPath: string, depth: number ): void => {
 
     if ( signal.aborted ) return;
 
@@ -144,29 +145,51 @@ const readdir = ( rootPath: string, options?: Options ): Promise<Result> => {
 
     if ( foundPaths >= maxPaths ) return;
 
-    const dirents = await fs.promises.readdir ( rootPath, { withFileTypes: true } ).catch ( () => [] );
+    increment ();
 
-    if ( signal.aborted ) return;
+    fs.readdir ( rootPath, { withFileTypes: true }, ( error, dirents ) => {
+
+      if ( error ) return decrement ();
 
-    const dirmap = map[rootPath] = { directories: [], files: [], symlinks: [] };
+      if ( signal.aborted ) return decrement ();
 
-    if ( !dirents.length ) return;
+      if ( !dirents.length ) return decrement ();
+
+      const dirmap = map[rootPath] = { directories: [], files: [], symlinks: [] };
 
-    await handleDirents ( dirmap, rootPath, dirents, depth );
+      handleDirents ( dirmap, rootPath, dirents, depth );
+
+      decrement ();
+
+    });
 
   };
 
   const populateResultFromSymlink = async ( rootPath: string, depth: number ): Promise<void> => {
 
-    try {
+    increment ();
 
-      const realPath = await fs.promises.realpath ( rootPath );
-      const stat = await fs.promises.stat ( realPath );
-      const dirmap = map[rootPath] = { directories: [], files: [], symlinks: [] };
+    fs.realpath ( rootPath, ( error, realPath ) => {
+
+      if ( error ) return decrement ();
 
-      await handleStat ( dirmap, realPath, stat, depth );
+      if ( signal.aborted ) return decrement ();
 
-    } catch {}
+      fs.stat ( realPath, async ( error, stat ) => {
+
+        if ( error ) return decrement ();
+
+        if ( signal.aborted ) return decrement ();
+
+        const dirmap = map[rootPath] = { directories: [], files: [], symlinks: [] };
+
+        handleStat ( dirmap, realPath, stat, depth );
+
+        decrement ();
+
+      });
+
+    });
 
   };
 
@@ -176,7 +199,9 @@ const readdir = ( rootPath: string, options?: Options ): Promise<Result> => {
 
     visited.add ( rootPath );
 
-    await populateResultFromPath ( rootPath, depth );
+    populateResultFromPath ( rootPath, depth );
+
+    await promise;
 
     if ( signal.aborted ) return resultEmpty;
 

package/src/types.ts

@@ -1,7 +1,7 @@
 
 /* HELPERS */
 
-type Promisable<T> = Promise<T> | T;
+type Callback = () => void;
 
 /* MAIN */
 
@@ -29,4 +29,4 @@ type Result = ResultDirectory & {
 
 /* EXPORT */
 
-export type {Promisable, Options, ResultDirectory, ResultDirectories, Result};
+export type {Callback, Options, ResultDirectory, ResultDirectories, Result};

package/src/utils.ts

@@ -1,4 +1,9 @@
 
+/* IMPORT */
+
+import makeNakedPromise from 'promise-make-naked';
+import type {Callback} from './types';
+
 /* MAIN */
 
 const isFunction = ( value: unknown ): value is Function => {
@@ -7,6 +12,32 @@ const isFunction = ( value: unknown ): value is Function => {
 
 };
 
+const makeCounterPromise = (): { promise: Promise<void>, increment: Callback, decrement: Callback } => {
+
+  const {promise, resolve} = makeNakedPromise<void> ();
+
+  let counter = 0;
+
+  const increment = (): void => {
+
+    counter += 1;
+
+  };
+
+  const decrement = (): void => {
+
+    counter -= 1;
+
+    if ( counter ) return;
+
+    resolve ();
+
+  };
+
+  return { promise, increment, decrement };
+
+};
+
 /* EXPORT */
 
-export {isFunction};
+export {isFunction, makeCounterPromise};

package/test/{native.js → index.js}

@@ -164,4 +164,38 @@ describe ( 'Tiny Readdir', it => {
 
   });
 
+  it ( 'does not freeze the main thread', async t => {
+
+    return new Promise ( resolve => {
+
+      let count = 0;
+      let start = Date.now ();
+
+      const aborter = new AbortController ();
+      const signal = aborter.signal;
+
+      const intervalId = setInterval ( () => {
+        count += 1;
+        console.log ( 'tick', count );
+        if ( count !== 100 ) return;
+        clearInterval ( intervalId );
+        const end = Date.now ();
+        const elapsed = end - start;
+        console.log ( 'elapsed', elapsed );
+        console.log ( elapsed );
+        if ( elapsed > 1500 ) {
+          t.fail ();
+        } else {
+          t.pass ();
+        }
+        aborter.abort ();
+        resolve ();
+      }, 10 );
+
+      readdir ( '/', { signal } );
+
+    });
+
+  });
+
 });

package/test/yielding.js

@@ -1,35 +0,0 @@
-
-/* IMPORT */
-
-import readdir from '../dist/index.js';
-
-/* MAIN */
-
-const main = async () => {
-
-  let count = 0;
-  let start = Date.now ();
-
-  setInterval ( () => {
-    count += 1;
-    console.log ( 'tick', count );
-    if ( count < 100 ) return;
-    const end = Date.now ();
-    const elapsed = end - start;
-    console.log ( 'elapsed', elapsed );
-    if ( elapsed > 1500 ) {
-      process.exit ( 1 ); // Fail
-    } else {
-      process.exit ( 0 ); // Success
-    }
-  }, 10 );
-
-  await readdir ( '/' );
-
-  process.exit ( 1 ); // Fail
-
-};
-
-/* RUNNING */
-
-await main ();