tiny-readdir 2.2.0 → 2.3.0

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;
@@ -11,46 +11,56 @@ const readdir = (rootPath, options) => {
     const isIgnored = isFunction(ignore) ? ignore : (targetPath) => ignore.test(targetPath);
     const signal = options?.signal ?? { aborted: false };
     const directories = [];
+    const directoriesNames = new Set();
     const files = [];
+    const filesNames = new Set();
     const symlinks = [];
+    const symlinksNames = new Set();
     const map = {};
     const visited = new Set();
-    const resultEmpty = { directories: [], files: [], symlinks: [], map: {} };
-    const result = { directories, files, symlinks, map };
+    const resultEmpty = { directories: [], directoriesNames: new Set(), files: [], filesNames: new Set(), symlinks: [], symlinksNames: new Set(), map: {} };
+    const result = { directories, directoriesNames, files, filesNames, symlinks, symlinksNames, map };
+    const { promise, increment, decrement } = makeCounterPromise();
     let foundPaths = 0;
-    const handleDirectory = (dirmap, subPath, depth) => {
+    const handleDirectory = (dirmap, subPath, name, depth) => {
         if (visited.has(subPath))
             return;
         if (foundPaths >= maxPaths)
             return;
         foundPaths += 1;
         dirmap.directories.push(subPath);
+        dirmap.directoriesNames.add(name);
         directories.push(subPath);
+        directoriesNames.add(name);
         visited.add(subPath);
         if (depth >= maxDepth)
             return;
         if (foundPaths >= maxPaths)
             return;
-        return populateResultFromPath(subPath, depth + 1);
+        populateResultFromPath(subPath, depth + 1);
     };
-    const handleFile = (dirmap, subPath) => {
+    const handleFile = (dirmap, subPath, name) => {
         if (visited.has(subPath))
             return;
         if (foundPaths >= maxPaths)
             return;
         foundPaths += 1;
         dirmap.files.push(subPath);
+        dirmap.filesNames.add(name);
         files.push(subPath);
+        filesNames.add(name);
         visited.add(subPath);
     };
-    const handleSymlink = (dirmap, subPath, depth) => {
+    const handleSymlink = (dirmap, subPath, name, depth) => {
         if (visited.has(subPath))
             return;
         if (foundPaths >= maxPaths)
             return;
         foundPaths += 1;
         dirmap.symlinks.push(subPath);
+        dirmap.symlinksNames.add(name);
         symlinks.push(subPath);
+        symlinksNames.add(name);
         visited.add(subPath);
         if (!followSymlinks)
             return;
@@ -58,73 +68,90 @@ const readdir = (rootPath, options) => {
             return;
         if (foundPaths >= maxPaths)
             return;
-        return populateResultFromSymlink(subPath, depth + 1);
+        populateResultFromSymlink(subPath, depth + 1);
     };
-    const handleStat = (dirmap, rootPath, stat, depth) => {
+    const handleStat = (dirmap, rootPath, name, stat, depth) => {
         if (signal.aborted)
             return;
         if (isIgnored(rootPath))
             return;
         if (stat.isDirectory()) {
-            return handleDirectory(dirmap, rootPath, depth);
+            handleDirectory(dirmap, rootPath, name, depth);
         }
         else if (stat.isFile()) {
-            return handleFile(dirmap, rootPath);
+            handleFile(dirmap, rootPath, name);
         }
         else if (stat.isSymbolicLink()) {
-            return handleSymlink(dirmap, rootPath, depth);
+            handleSymlink(dirmap, rootPath, name, depth);
         }
     };
     const handleDirent = (dirmap, rootPath, dirent, depth) => {
         if (signal.aborted)
             return;
         const separator = (rootPath === path.sep) ? '' : path.sep;
-        const subPath = `${rootPath}${separator}${dirent.name}`;
+        const name = dirent.name;
+        const subPath = `${rootPath}${separator}${name}`;
         if (isIgnored(subPath))
             return;
         if (dirent.isDirectory()) {
-            return handleDirectory(dirmap, subPath, depth);
+            handleDirectory(dirmap, subPath, name, depth);
         }
         else if (dirent.isFile()) {
-            return handleFile(dirmap, subPath);
+            handleFile(dirmap, subPath, name);
         }
         else if (dirent.isSymbolicLink()) {
-            return handleSymlink(dirmap, subPath, depth);
+            handleSymlink(dirmap, subPath, name, 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: [], directoriesNames: new Set(), files: [], filesNames: new Set(), symlinks: [], symlinksNames: new Set() };
+            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 name = path.basename(realPath);
+                const dirmap = map[rootPath] = { directories: [], directoriesNames: new Set(), files: [], filesNames: new Set(), symlinks: [], symlinksNames: new Set() };
+                handleStat(dirmap, realPath, name, 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;
@@ -10,8 +10,11 @@ type Options = {
 };
 type ResultDirectory = {
     directories: string[];
+    directoriesNames: Set<string>;
     files: string[];
+    filesNames: Set<string>;
     symlinks: string[];
+    symlinksNames: Set<string>;
 };
 type ResultDirectories = {
     [path: string]: ResultDirectory;
@@ -19,4 +22,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.3.0",
   "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/readme.md

@@ -27,6 +27,10 @@ console.log ( result.directories ); // => Array of absolute paths pointing to di
 console.log ( result.files ); // => Array of absolute paths pointing to files
 console.log ( result.symlinks ); // => Array of absolute paths pointing to symlinks
 
+console.log ( result.directoriesNames ); // => Set of directories names found
+console.log ( result.filesNames ); // => Set of files name found
+console.log ( result.symlinksNames ); // => Set of symlinks names found
+
 setTimeout ( () => aborter.abort (), 10000 ); // Aborting if it's going to take longer than 10s
 ```
 

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 */
 
@@ -17,16 +17,20 @@ const readdir = ( rootPath: string, options?: Options ): Promise<Result> => {
   const isIgnored = isFunction ( ignore ) ? ignore : ( targetPath: string ) => ignore.test ( targetPath );
   const signal = options?.signal ?? { aborted: false };
   const directories: string[] = [];
+  const directoriesNames: Set<string> = new Set ();
   const files: string[] = [];
+  const filesNames: Set<string> = new Set ();
   const symlinks: string[] = [];
+  const symlinksNames: Set<string> = new Set ();
   const map: ResultDirectories = {};
   const visited = new Set<string> ();
-  const resultEmpty: Result = { directories: [], files: [], symlinks: [], map: {} };
-  const result: Result = { directories, files, symlinks, map };
+  const resultEmpty: Result = { directories: [], directoriesNames: new Set (), files: [], filesNames: new Set (), symlinks: [], symlinksNames: new Set (), map: {} };
+  const result: Result = { directories, directoriesNames, files, filesNames, symlinks, symlinksNames, 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, name: string, depth: number ): void => {
 
     if ( visited.has ( subPath ) ) return;
 
@@ -34,18 +38,20 @@ const readdir = ( rootPath: string, options?: Options ): Promise<Result> => {
 
     foundPaths += 1;
     dirmap.directories.push ( subPath );
+    dirmap.directoriesNames.add ( name );
     directories.push ( subPath );
+    directoriesNames.add ( name );
     visited.add ( subPath );
 
     if ( depth >= maxDepth ) return;
 
     if ( foundPaths >= maxPaths ) return;
 
-    return populateResultFromPath ( subPath, depth + 1 );
+    populateResultFromPath ( subPath, depth + 1 );
 
   };
 
-  const handleFile = ( dirmap: ResultDirectory, subPath: string ): void => {
+  const handleFile = ( dirmap: ResultDirectory, subPath: string, name: string ): void => {
 
     if ( visited.has ( subPath ) ) return;
 
@@ -53,12 +59,14 @@ const readdir = ( rootPath: string, options?: Options ): Promise<Result> => {
 
     foundPaths += 1;
     dirmap.files.push ( subPath );
+    dirmap.filesNames.add ( name );
     files.push ( subPath );
+    filesNames.add ( name );
     visited.add ( subPath );
 
   };
 
-  const handleSymlink = ( dirmap: ResultDirectory, subPath: string, depth: number ): Promisable<void> => {
+  const handleSymlink = ( dirmap: ResultDirectory, subPath: string, name: string, depth: number ): void => {
 
     if ( visited.has ( subPath ) ) return;
 
@@ -66,7 +74,9 @@ const readdir = ( rootPath: string, options?: Options ): Promise<Result> => {
 
     foundPaths += 1;
     dirmap.symlinks.push ( subPath );
+    dirmap.symlinksNames.add ( name );
     symlinks.push ( subPath );
+    symlinksNames.add ( name );
     visited.add ( subPath );
 
     if ( !followSymlinks ) return;
@@ -75,11 +85,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, name: string, stat: fs.Stats, depth: number ): void => {
 
     if ( signal.aborted ) return;
 
@@ -87,56 +97,57 @@ const readdir = ( rootPath: string, options?: Options ): Promise<Result> => {
 
     if ( stat.isDirectory () ) {
 
-      return handleDirectory ( dirmap, rootPath, depth );
+      handleDirectory ( dirmap, rootPath, name, depth );
 
     } else if ( stat.isFile () ) {
 
-      return handleFile ( dirmap, rootPath );
+      handleFile ( dirmap, rootPath, name );
 
     } else if ( stat.isSymbolicLink () ) {
 
-      return handleSymlink ( dirmap, rootPath, depth );
+      handleSymlink ( dirmap, rootPath, name, 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;
 
     const separator = ( rootPath === path.sep ) ? '' : path.sep;
-    const subPath = `${rootPath}${separator}${dirent.name}`;
+    const name = dirent.name;
+    const subPath = `${rootPath}${separator}${name}`;
 
     if ( isIgnored ( subPath ) ) return;
 
     if ( dirent.isDirectory () ) {
 
-      return handleDirectory ( dirmap, subPath, depth );
+      handleDirectory ( dirmap, subPath, name, depth );
 
     } else if ( dirent.isFile () ) {
 
-      return handleFile ( dirmap, subPath );
+      handleFile ( dirmap, subPath, name );
 
     } else if ( dirent.isSymbolicLink () ) {
 
-      return handleSymlink ( dirmap, subPath, depth );
+      handleSymlink ( dirmap, subPath, name, 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 +155,52 @@ 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 ();
+
+      if ( signal.aborted ) return decrement ();
 
-    const dirmap = map[rootPath] = { directories: [], files: [], symlinks: [] };
+      if ( !dirents.length ) return decrement ();
 
-    if ( !dirents.length ) return;
+      const dirmap = map[rootPath] = { directories: [], directoriesNames: new Set (), files: [], filesNames: new Set (), symlinks: [], symlinksNames: new Set () };
 
-    await handleDirents ( dirmap, rootPath, dirents, depth );
+      handleDirents ( dirmap, rootPath, dirents, depth );
+
+      decrement ();
+
+    });
 
   };
 
   const populateResultFromSymlink = async ( rootPath: string, depth: number ): Promise<void> => {
 
-    try {
+    increment ();
+
+    fs.realpath ( rootPath, ( error, realPath ) => {
+
+      if ( error ) return decrement ();
 
-      const realPath = await fs.promises.realpath ( rootPath );
-      const stat = await fs.promises.stat ( realPath );
-      const dirmap = map[rootPath] = { directories: [], files: [], symlinks: [] };
+      if ( signal.aborted ) return decrement ();
 
-      await handleStat ( dirmap, realPath, stat, depth );
+      fs.stat ( realPath, async ( error, stat ) => {
 
-    } catch {}
+        if ( error ) return decrement ();
+
+        if ( signal.aborted ) return decrement ();
+
+        const name = path.basename ( realPath );
+        const dirmap = map[rootPath] = { directories: [], directoriesNames: new Set (), files: [], filesNames: new Set (), symlinks: [], symlinksNames: new Set () };
+
+        handleStat ( dirmap, realPath, name, stat, depth );
+
+        decrement ();
+
+      });
+
+    });
 
   };
 
@@ -176,7 +210,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 */
 
@@ -15,8 +15,11 @@ type Options = {
 
 type ResultDirectory = {
   directories: string[],
+  directoriesNames: Set<string>,
   files: string[],
-  symlinks: string[]
+  filesNames: Set<string>,
+  symlinks: string[],
+  symlinksNames: Set<string>
 };
 
 type ResultDirectories = {
@@ -29,4 +32,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}

@@ -6,6 +6,10 @@ import fs from 'node:fs';
 import path from 'node:path';
 import readdir from '../dist/index.js';
 
+/* HELPERS */
+
+const toBasename = filePath => path.basename ( filePath );
+
 /* MAIN */
 
 describe ( 'Tiny Readdir', it => {
@@ -41,43 +45,67 @@ describe ( 'Tiny Readdir', it => {
 
     const expected = {
       directories: [folder1Path, folder2Path, folder1DeepPath, root2Path],
+      directoriesNames: new Set ( [folder1Path, folder2Path, folder1DeepPath, root2Path].map ( toBasename ) ),
       files: [file1aPath, file1bPath, file2Path, fileDeep1Path],
+      filesNames: new Set ( [file1aPath, file1bPath, file2Path, fileDeep1Path].map ( toBasename ) ),
       symlinks: [symlink1FromPath, symlink2FromPath],
+      symlinksNames: new Set ( [symlink1FromPath, symlink2FromPath].map ( toBasename ) ),
       map: {
         [root1Path]: {
           directories: [folder1Path, folder2Path],
+          directoriesNames: new Set ( [folder1Path, folder2Path].map ( toBasename ) ),
           files: [],
-          symlinks: [symlink1FromPath]
+          filesNames: new Set (),
+          symlinks: [symlink1FromPath],
+          symlinksNames: new Set ( [symlink1FromPath].map ( toBasename ) )
         },
         [root2Path]: {
           directories: [],
+          directoriesNames: new Set (),
           files: [],
-          symlinks: [symlink2FromPath]
+          filesNames: new Set (),
+          symlinks: [symlink2FromPath],
+          symlinksNames: new Set ( [symlink2FromPath].map ( toBasename ) )
         },
         [folder1Path]: {
           directories: [folder1DeepPath],
+          directoriesNames: new Set ( [folder1DeepPath].map ( toBasename ) ),
           files: [file1aPath, file1bPath],
-          symlinks: []
+          filesNames: new Set ( [file1aPath, file1bPath].map ( toBasename ) ),
+          symlinks: [],
+          symlinksNames: new Set ()
         },
         [folder2Path]: {
           directories: [],
+          directoriesNames: new Set (),
           files: [file2Path],
-          symlinks: []
+          filesNames: new Set ( [file2Path].map ( toBasename ) ),
+          symlinks: [],
+          symlinksNames: new Set ()
         },
         [folder1DeepPath]: {
           directories: [],
+          directoriesNames: new Set (),
           files: [fileDeep1Path],
-          symlinks: []
+          filesNames: new Set ( [fileDeep1Path].map ( toBasename ) ),
+          symlinks: [],
+          symlinksNames: new Set ()
         },
         [symlink1FromPath]: {
           directories: [root2Path],
+          directoriesNames: new Set ( [root2Path].map ( toBasename ) ),
           files: [],
-          symlinks: []
+          filesNames: new Set (),
+          symlinks: [],
+          symlinksNames: new Set ()
         },
         [symlink2FromPath]: {
           directories: [],
+          directoriesNames: new Set (),
           files: [],
-          symlinks: []
+          filesNames: new Set (),
+          symlinks: [],
+          symlinksNames: new Set ()
         }
       }
     };
@@ -128,23 +156,35 @@ describe ( 'Tiny Readdir', it => {
 
     const expected = {
       directories: [folder1Path, folder2Path],
+      directoriesNames: new Set ( [folder1Path, folder2Path].map ( toBasename ) ),
       files: [],
+      filesNames: new Set (),
       symlinks: [symlink1FromPath],
+      symlinksNames: new Set ( [symlink1FromPath].map ( toBasename ) ),
       map: {
         [root1Path]: {
           directories: [folder1Path, folder2Path],
+          directoriesNames: new Set ( [folder1Path, folder2Path].map ( toBasename ) ),
           files: [],
-          symlinks: [symlink1FromPath]
+          filesNames: new Set (),
+          symlinks: [symlink1FromPath],
+          symlinksNames: new Set ( [symlink1FromPath].map ( toBasename ) )
         },
         [folder1Path]: {
           directories: [],
+          directoriesNames: new Set (),
           files: [],
-          symlinks: []
+          filesNames: new Set (),
+          symlinks: [],
+          symlinksNames: new Set ()
         },
         [folder2Path]: {
           directories: [],
+          directoriesNames: new Set (),
           files: [],
-          symlinks: []
+          filesNames: new Set (),
+          symlinks: [],
+          symlinksNames: new Set ()
         }
       }
     };
@@ -164,4 +204,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 ();