tiny-readdir 2.7.3 → 2.7.4

package/dist/index.js

@@ -170,7 +170,7 @@ const readdir = (rootPath, options) => {
             });
         });
     };
-    const getResult = async (rootPath, depth = 1) => {
+    const populateResultFromRoot = async (rootPath, depth = 1) => {
         rootPath = path.normalize(rootPath);
         visited.add(rootPath);
         populateResultFromPath(rootPath, depth);
@@ -179,7 +179,7 @@ const readdir = (rootPath, options) => {
             return resultEmpty;
         return result;
     };
-    return getResult(rootPath);
+    return populateResultFromRoot(rootPath);
 };
 /* EXPORT */
 export default readdir;

package/package.json

@@ -2,7 +2,8 @@
   "name": "tiny-readdir",
   "repository": "github:fabiospampinato/tiny-readdir",
   "description": "A simple promisified recursive readdir function.",
-  "version": "2.7.3",
+  "license": "MIT",
+  "version": "2.7.4",
   "type": "module",
   "main": "dist/index.js",
   "exports": "./dist/index.js",
@@ -23,12 +24,12 @@
     "tiny"
   ],
   "dependencies": {
-    "promise-make-counter": "^1.0.1"
+    "promise-make-counter": "^1.0.2"
   },
   "devDependencies": {
-    "@types/node": "^18.19.39",
+    "@types/node": "^18.19.70",
     "fava": "^0.3.4",
     "tsex": "^4.0.2",
-    "typescript": "^5.5.2"
+    "typescript": "^5.7.3"
   }
 }

package/readme.md

@@ -5,7 +5,7 @@ A simple promisified recursive readdir function.
 ## Install
 
 ```sh
-npm install --save tiny-readdir
+npm install tiny-readdir
 ```
 
 ## Usage
@@ -13,8 +13,9 @@ npm install --save tiny-readdir
 ```ts
 import readdir from 'tiny-readdir';
 
-const aborter = new AbortController ();
+// Let's recursively read into a directory
 
+const aborter = new AbortController ();
 const result = await readdir ( '/foo/bar', {
   depth: 20, // Maximum depth to look at
   limit: 1_000_000, // Maximum number of files explored, useful as a stop gap in some edge cases
@@ -24,10 +25,18 @@ const result = await readdir ( '/foo/bar', {
   onDirents: dirents => console.log ( dirents ) // Optional callback that will be called as soon as new dirents are available, useful for example for discovering ".gitignore" files while searching
 });
 
+// This is how we would abort the reactive read after 10s
+
+setTimeout ( () => aborter.abort (), 10_000 ); // Aborting if it's going to take longer than 10s
+
+// This is the basic information we'll get
+
 result.directories; // => Array of absolute paths pointing to directories
 result.files; // => Array of absolute paths pointing to files
 result.symlinks; // => Array of absolute paths pointing to symlinks
 
+// This is more advanced information we'll get, which is useful in some cases
+
 result.directoriesNames; // => Set of directories names found
 result.filesNames; // => Set of files name found
 result.symlinksNames; // => Set of symlinks names found
@@ -35,8 +44,6 @@ result.symlinksNames; // => Set of symlinks names found
 result.directoriesNamesToPaths; // => Record of directories names found to their paths
 result.filesNamesToPaths; // => Record of files names found to their paths
 result.symlinksNamesToPaths; // => Record of symlinks names found to their paths
-
-setTimeout ( () => aborter.abort (), 10_000 ); // Aborting if it's going to take longer than 10s
 ```
 
 ## License

package/.editorconfig

@@ -1,10 +0,0 @@
-
-root = true
-
-[*]
-charset = utf-8
-end_of_line = lf
-indent_size = 2
-indent_style = space
-insert_final_newline = true
-trim_trailing_whitespace = true

package/src/constants.ts

@@ -1,16 +0,0 @@
-
-/* IMPORT */
-
-import type {Callback} from './types';
-
-/* MAIN */
-
-const NOOP_PROMISE_LIKE = {
-  then: ( fn: Callback ) => {
-    fn ();
-  }
-};
-
-/* EXPORT */
-
-export {NOOP_PROMISE_LIKE};

package/src/index.ts

@@ -1,257 +0,0 @@
-
-/* IMPORT */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import makeCounterPromise from 'promise-make-counter';
-import {NOOP_PROMISE_LIKE} from './constants';
-import {castArray, isFunction} from './utils';
-import type {Dirent, Options, ResultDirectory, ResultDirectories, Result} from './types';
-
-/* MAIN */
-
-//TODO: Streamline the type of dirmaps
-
-const readdir = ( rootPath: string, options?: Options ): Promise<Result> => {
-
-  const followSymlinks = options?.followSymlinks ?? false;
-  const maxDepth = options?.depth ?? Infinity;
-  const maxPaths = options?.limit ?? Infinity;
-  const ignore = options?.ignore ?? [];
-  const ignores = castArray ( ignore ).map ( ignore => isFunction ( ignore ) ? ignore : ( targetPath: string ) => ignore.test ( targetPath ) );
-  const isIgnored = ( targetPath: string ) => ignores.some ( ignore => ignore ( targetPath ) );
-  const signal = options?.signal ?? { aborted: false };
-  const onDirents = options?.onDirents || (() => {});
-  const directories: string[] = [];
-  const directoriesNames: Set<string> = new Set ();
-  const directoriesNamesToPaths: Record<string, string[]> = {};
-  const files: string[] = [];
-  const filesNames: Set<string> = new Set ();
-  const filesNamesToPaths: Record<string, string[]> = {};
-  const symlinks: string[] = [];
-  const symlinksNames: Set<string> = new Set ();
-  const symlinksNamesToPaths: Record<string, string[]> = {};
-  const map: ResultDirectories = {};
-  const visited = new Set<string> ();
-  const resultEmpty: Result = { directories: [], directoriesNames: new Set (), directoriesNamesToPaths: {}, files: [], filesNames: new Set (), filesNamesToPaths: {}, symlinks: [], symlinksNames: new Set (), symlinksNamesToPaths: {}, map: {} };
-  const result: Result = { directories, directoriesNames, directoriesNamesToPaths, files, filesNames, filesNamesToPaths, symlinks, symlinksNames, symlinksNamesToPaths, map };
-  const {promise, increment, decrement} = makeCounterPromise ();
-
-  let foundPaths = 0;
-
-  const handleDirectory = ( dirmap: ResultDirectory, subPath: string, name: string, depth: number ): void => {
-
-    if ( visited.has ( subPath ) ) return;
-
-    if ( foundPaths >= maxPaths ) return;
-
-    foundPaths += 1;
-    dirmap.directories.push ( subPath );
-    dirmap.directoriesNames.add ( name );
-    // dirmap.directoriesNamesToPaths.propertyIsEnumerable(name) || ( dirmap.directoriesNamesToPaths[name] = [] );
-    // dirmap.directoriesNamesToPaths[name].push ( subPath );
-    directories.push ( subPath );
-    directoriesNames.add ( name );
-    directoriesNamesToPaths.propertyIsEnumerable(name) || ( directoriesNamesToPaths[name] = [] );
-    directoriesNamesToPaths[name].push ( subPath );
-    visited.add ( subPath );
-
-    if ( depth >= maxDepth ) return;
-
-    if ( foundPaths >= maxPaths ) return;
-
-    populateResultFromPath ( subPath, depth + 1 );
-
-  };
-
-  const handleFile = ( dirmap: ResultDirectory, subPath: string, name: string ): void => {
-
-    if ( visited.has ( subPath ) ) return;
-
-    if ( foundPaths >= maxPaths ) return;
-
-    foundPaths += 1;
-    dirmap.files.push ( subPath );
-    dirmap.filesNames.add ( name );
-    // dirmap.filesNamesToPaths.propertyIsEnumerable(name) ||  ( dirmap.filesNamesToPaths[name] = [] );
-    // dirmap.filesNamesToPaths[name].push ( subPath );
-    files.push ( subPath );
-    filesNames.add ( name );
-    filesNamesToPaths.propertyIsEnumerable(name) || ( filesNamesToPaths[name] = [] );
-    filesNamesToPaths[name].push ( subPath );
-    visited.add ( subPath );
-
-  };
-
-  const handleSymlink = ( dirmap: ResultDirectory, subPath: string, name: string, depth: number ): void => {
-
-    if ( visited.has ( subPath ) ) return;
-
-    if ( foundPaths >= maxPaths ) return;
-
-    foundPaths += 1;
-    dirmap.symlinks.push ( subPath );
-    dirmap.symlinksNames.add ( name );
-    // dirmap.symlinksNamesToPaths.propertyIsEnumerable(name) || ( dirmap.symlinksNamesToPaths[name] = [] );
-    // dirmap.symlinksNamesToPaths[name].push ( subPath );
-    symlinks.push ( subPath );
-    symlinksNames.add ( name );
-    symlinksNamesToPaths.propertyIsEnumerable(name) || ( symlinksNamesToPaths[name] = [] );
-    symlinksNamesToPaths[name].push ( subPath );
-    visited.add ( subPath );
-
-    if ( !followSymlinks ) return;
-
-    if ( depth >= maxDepth ) return;
-
-    if ( foundPaths >= maxPaths ) return;
-
-    populateResultFromSymlink ( subPath, depth + 1 );
-
-  };
-
-  const handleStat = ( dirmap: ResultDirectory, rootPath: string, name: string, stat: fs.Stats, depth: number ): void => {
-
-    if ( signal.aborted ) return;
-
-    if ( isIgnored ( rootPath ) ) return;
-
-    if ( stat.isDirectory () ) {
-
-      handleDirectory ( dirmap, rootPath, name, depth );
-
-    } else if ( stat.isFile () ) {
-
-      handleFile ( dirmap, rootPath, name );
-
-    } else if ( stat.isSymbolicLink () ) {
-
-      handleSymlink ( dirmap, rootPath, name, depth );
-
-    }
-
-  };
-
-  const handleDirent = ( dirmap: ResultDirectory, rootPath: string, dirent: fs.Dirent, depth: number ): void => {
-
-    if ( signal.aborted ) return;
-
-    const separator = ( rootPath === path.sep ) ? '' : path.sep;
-    const name = dirent.name;
-    const subPath = `${rootPath}${separator}${name}`;
-
-    if ( isIgnored ( subPath ) ) return;
-
-    if ( dirent.isDirectory () ) {
-
-      handleDirectory ( dirmap, subPath, name, depth );
-
-    } else if ( dirent.isFile () ) {
-
-      handleFile ( dirmap, subPath, name );
-
-    } else if ( dirent.isSymbolicLink () ) {
-
-      handleSymlink ( dirmap, subPath, name, depth );
-
-    }
-
-  };
-
-  const handleDirents = ( dirmap: ResultDirectory, rootPath: string, dirents: fs.Dirent[], depth: number ): void => {
-
-    for ( let i = 0, l = dirents.length; i < l; i++ ) {
-
-      handleDirent ( dirmap, rootPath, dirents[i], depth );
-
-    }
-
-  };
-
-  const populateResultFromPath = ( rootPath: string, depth: number ): void => {
-
-    if ( signal.aborted ) return;
-
-    if ( depth > maxDepth ) return;
-
-    if ( foundPaths >= maxPaths ) return;
-
-    increment ();
-
-    fs.readdir ( rootPath, { withFileTypes: true }, ( error, dirents ) => {
-
-      if ( error ) return decrement ();
-
-      if ( signal.aborted ) return decrement ();
-
-      if ( !dirents.length ) return decrement ();
-
-      const promise = onDirents ( dirents ) || NOOP_PROMISE_LIKE;
-
-      promise.then ( () => {
-
-        const dirmap = map[rootPath] = { directories: [], directoriesNames: new Set (), directoriesNamesToPaths: {}, files: [], filesNames: new Set (), filesNamesToPaths: {}, symlinks: [], symlinksNames: new Set (), symlinksNamesToPaths: {} };
-
-        handleDirents ( dirmap, rootPath, dirents, depth );
-
-        decrement ();
-
-      });
-
-    });
-
-  };
-
-  const populateResultFromSymlink = ( rootPath: string, depth: number ): void => {
-
-    increment ();
-
-    fs.realpath ( rootPath, ( error, realPath ) => {
-
-      if ( error ) return decrement ();
-
-      if ( signal.aborted ) return decrement ();
-
-      fs.stat ( realPath, ( error, stat ) => {
-
-        if ( error ) return decrement ();
-
-        if ( signal.aborted ) return decrement ();
-
-        const name = path.basename ( realPath );
-        const dirmap = map[rootPath] = { directories: [], directoriesNames: new Set (), directoriesNamesToPaths: {}, files: [], filesNames: new Set (), filesNamesToPaths: {}, symlinks: [], symlinksNames: new Set (), symlinksNamesToPaths: {} };
-
-        handleStat ( dirmap, realPath, name, stat, depth );
-
-        decrement ();
-
-      });
-
-    });
-
-  };
-
-  const getResult = async ( rootPath: string, depth: number = 1 ): Promise<Result> => {
-
-    rootPath = path.normalize ( rootPath );
-
-    visited.add ( rootPath );
-
-    populateResultFromPath ( rootPath, depth );
-
-    await promise;
-
-    if ( signal.aborted ) return resultEmpty;
-
-    return result;
-
-  };
-
-  return getResult ( rootPath );
-
-};
-
-/* EXPORT */
-
-export default readdir;
-export type {Dirent, Options, ResultDirectory, ResultDirectories, Result};

package/src/types.ts

@@ -1,55 +0,0 @@
-
-/* HELPERS */
-
-type Callback = () => void;
-
-type ArrayMaybe<T> = T[] | T;
-
-type PromiseMaybe<T> = Promise<T> | T;
-
-/* MAIN */
-
-type Dirent = {
-  isFile: () => boolean,
-  isDirectory: () => boolean,
-  isBlockDevice: () => boolean,
-  isCharacterDevice: () => boolean,
-  isSymbolicLink: () => boolean,
-  isFIFO: () => boolean,
-  isSocket: () => boolean,
-  name: string,
-  path: string
-};
-
-type Options = {
-  depth?: number,
-  limit?: number,
-  followSymlinks?: boolean,
-  ignore?: ArrayMaybe<(( targetPath: string ) => boolean) | RegExp>,
-  signal?: { aborted: boolean },
-  onDirents?: ( dirents: Dirent[] ) => PromiseMaybe<undefined>
-};
-
-type ResultDirectory = {
-  directories: string[],
-  directoriesNames: Set<string>,
-  directoriesNamesToPaths: Record<string, string[]>,
-  files: string[],
-  filesNames: Set<string>,
-  filesNamesToPaths: Record<string, string[]>,
-  symlinks: string[],
-  symlinksNames: Set<string>,
-  symlinksNamesToPaths: Record<string, string[]>
-};
-
-type ResultDirectories = {
-  [path: string]: ResultDirectory
-};
-
-type Result = ResultDirectory & {
-  map: ResultDirectories
-};
-
-/* EXPORT */
-
-export type {Callback, PromiseMaybe, Dirent, Options, ResultDirectory, ResultDirectories, Result};

package/src/utils.ts

@@ -1,18 +0,0 @@
-
-/* MAIN */
-
-const castArray = <T> ( value: T[] | T ): T[] => {
-
-  return Array.isArray ( value ) ? value : [value];
-
-};
-
-const isFunction = ( value: unknown ): value is Function => {
-
-  return ( typeof value === 'function' );
-
-};
-
-/* EXPORT */
-
-export {castArray, isFunction};

package/test/index.js

@@ -1,291 +0,0 @@
-
-/* IMPORT */
-
-import {describe} from 'fava';
-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 => {
-
-  it ( 'finds folders, files and symlinks', async t => {
-
-    const cwdPath = process.cwd ();
-    const root1Path = path.join ( cwdPath, 'test', 'root1' );
-    const root2Path = path.join ( cwdPath, 'test', 'root2' );
-    const folder1Path = path.join ( root1Path, 'folder1' );
-    const folder2Path = path.join ( root1Path, 'folder2' );
-    const folder1DeepPath = path.join ( folder1Path, 'deep' );
-    const file1aPath = path.join ( folder1Path, 'file1a.txt' );
-    const file1bPath = path.join ( folder1Path, 'file1b.txt' );
-    const file2Path = path.join ( folder2Path, 'file2.txt' );
-    const fileDeep1Path = path.join ( folder1DeepPath, 'file1.txt' );
-    const symlink1FromPath = path.join ( root1Path, 'symlink' );
-    const symlink1ToPath = root2Path;
-    const symlink2FromPath = path.join ( root2Path, 'symlink' );
-    const symlink2ToPath = root1Path;
-
-    fs.mkdirSync ( root1Path );
-    fs.mkdirSync ( root2Path );
-    fs.mkdirSync ( folder1Path );
-    fs.mkdirSync ( folder2Path );
-    fs.mkdirSync ( folder1DeepPath );
-    fs.writeFileSync ( file1aPath, '' );
-    fs.writeFileSync ( file1bPath, '' );
-    fs.writeFileSync ( file2Path, '' );
-    fs.writeFileSync ( fileDeep1Path, '' );
-    fs.symlinkSync ( symlink1ToPath, symlink1FromPath );
-    fs.symlinkSync ( symlink2ToPath, symlink2FromPath );
-
-    const expected = {
-      directories: [folder1Path, folder2Path, folder1DeepPath, root2Path],
-      directoriesNames: new Set ( [folder1Path, folder2Path, folder1DeepPath, root2Path].map ( toBasename ) ),
-      directoriesNamesToPaths: { folder1: [folder1Path], folder2: [folder2Path], deep: [folder1DeepPath], root2: [root2Path] },
-      files: [file1aPath, file1bPath, file2Path, fileDeep1Path],
-      filesNames: new Set ( [file1aPath, file1bPath, file2Path, fileDeep1Path].map ( toBasename ) ),
-      filesNamesToPaths: { 'file1a.txt': [file1aPath], 'file1b.txt': [file1bPath], 'file2.txt': [file2Path], 'file1.txt': [fileDeep1Path] },
-      symlinks: [symlink1FromPath, symlink2FromPath],
-      symlinksNames: new Set ( [symlink1FromPath, symlink2FromPath].map ( toBasename ) ),
-      symlinksNamesToPaths: { symlink: [symlink1FromPath, symlink2FromPath] },
-      map: {
-        [root1Path]: {
-          directories: [folder1Path, folder2Path],
-          directoriesNames: new Set ( [folder1Path, folder2Path].map ( toBasename ) ),
-          directoriesNamesToPaths: {},
-          files: [],
-          filesNames: new Set (),
-          filesNamesToPaths: {},
-          symlinks: [symlink1FromPath],
-          symlinksNames: new Set ( [symlink1FromPath].map ( toBasename ) ),
-          symlinksNamesToPaths: {}
-        },
-        [root2Path]: {
-          directories: [],
-          directoriesNames: new Set (),
-          directoriesNamesToPaths: {},
-          files: [],
-          filesNames: new Set (),
-          filesNamesToPaths: {},
-          symlinks: [symlink2FromPath],
-          symlinksNames: new Set ( [symlink2FromPath].map ( toBasename ) ),
-          symlinksNamesToPaths: {}
-        },
-        [folder1Path]: {
-          directories: [folder1DeepPath],
-          directoriesNames: new Set ( [folder1DeepPath].map ( toBasename ) ),
-          directoriesNamesToPaths: {},
-          files: [file1aPath, file1bPath],
-          filesNames: new Set ( [file1aPath, file1bPath].map ( toBasename ) ),
-          filesNamesToPaths: {},
-          symlinks: [],
-          symlinksNames: new Set (),
-          symlinksNamesToPaths: {}
-        },
-        [folder2Path]: {
-          directories: [],
-          directoriesNames: new Set (),
-          directoriesNamesToPaths: {},
-          files: [file2Path],
-          filesNames: new Set ( [file2Path].map ( toBasename ) ),
-          filesNamesToPaths: {},
-          symlinks: [],
-          symlinksNames: new Set (),
-          symlinksNamesToPaths: {}
-        },
-        [folder1DeepPath]: {
-          directories: [],
-          directoriesNames: new Set (),
-          directoriesNamesToPaths: {},
-          files: [fileDeep1Path],
-          filesNames: new Set ( [fileDeep1Path].map ( toBasename ) ),
-          filesNamesToPaths: {},
-          symlinks: [],
-          symlinksNames: new Set (),
-          symlinksNamesToPaths: {}
-        },
-        [symlink1FromPath]: {
-          directories: [root2Path],
-          directoriesNames: new Set ( [root2Path].map ( toBasename ) ),
-          directoriesNamesToPaths: {},
-          files: [],
-          filesNames: new Set (),
-          filesNamesToPaths: {},
-          symlinks: [],
-          symlinksNames: new Set (),
-          symlinksNamesToPaths: {}
-        },
-        [symlink2FromPath]: {
-          directories: [],
-          directoriesNames: new Set (),
-          directoriesNamesToPaths: {},
-          files: [],
-          filesNames: new Set (),
-          filesNamesToPaths: {},
-          symlinks: [],
-          symlinksNames: new Set (),
-          symlinksNamesToPaths: {}
-        }
-      }
-    };
-
-    try {
-
-      const result = await readdir ( root1Path, { followSymlinks: true } );
-
-      t.deepEqual ( result, expected );
-
-    } finally {
-
-      fs.rmSync ( root1Path, { recursive: true } );
-      fs.rmSync ( root2Path, { recursive: true } );
-
-    }
-
-  });
-
-  it ( 'supports a depth option', async t => {
-
-    const cwdPath = process.cwd ();
-
-    const {files: files0} = await readdir ( cwdPath, { depth: 0 } );
-    const {files: files1} = await readdir ( cwdPath, { depth: 1 } );
-    const {files: filesInfinity} = await readdir ( cwdPath, { depth: Infinity } );
-
-    t.true ( files0.length === 0 );
-    t.true ( files1.length > 0 && files1.length < 10 );
-    t.true ( filesInfinity.length > 100 );
-
-  });
-
-  it ( 'supports a limit option', async t => {
-
-    const cwdPath = process.cwd ();
-    const root1Path = path.join ( cwdPath, 'test', 'root1' );
-    const root2Path = path.join ( cwdPath, 'test', 'root2' );
-    const folder1Path = path.join ( root1Path, 'folder1' );
-    const folder2Path = path.join ( root1Path, 'folder2' );
-    const folder1DeepPath = path.join ( folder1Path, 'deep' );
-    const file1aPath = path.join ( folder1Path, 'file1a.txt' );
-    const file1bPath = path.join ( folder1Path, 'file1b.txt' );
-    const file2Path = path.join ( folder2Path, 'file2.txt' );
-    const fileDeep1Path = path.join ( folder1DeepPath, 'file1.txt' );
-    const symlink1FromPath = path.join ( root1Path, 'symlink' );
-    const symlink1ToPath = root2Path;
-    const symlink2FromPath = path.join ( root2Path, 'symlink' );
-    const symlink2ToPath = root1Path;
-
-    fs.mkdirSync ( root1Path );
-    fs.mkdirSync ( root2Path );
-    fs.mkdirSync ( folder1Path );
-    fs.mkdirSync ( folder2Path );
-    fs.mkdirSync ( folder1DeepPath );
-    fs.writeFileSync ( file1aPath, '' );
-    fs.writeFileSync ( file1bPath, '' );
-    fs.writeFileSync ( file2Path, '' );
-    fs.writeFileSync ( fileDeep1Path, '' );
-    fs.symlinkSync ( symlink1ToPath, symlink1FromPath );
-    fs.symlinkSync ( symlink2ToPath, symlink2FromPath );
-
-    const expected = {
-      directories: [folder1Path, folder2Path],
-      directoriesNames: new Set ( [folder1Path, folder2Path].map ( toBasename ) ),
-      directoriesNamesToPaths: { folder1: [folder1Path], folder2: [folder2Path] },
-      files: [],
-      filesNames: new Set (),
-      filesNamesToPaths: {},
-      symlinks: [symlink1FromPath],
-      symlinksNames: new Set ( [symlink1FromPath].map ( toBasename ) ),
-      symlinksNamesToPaths: { symlink: [symlink1FromPath] },
-      map: {
-        [root1Path]: {
-          directories: [folder1Path, folder2Path],
-          directoriesNames: new Set ( [folder1Path, folder2Path].map ( toBasename ) ),
-          directoriesNamesToPaths: {},
-          files: [],
-          filesNames: new Set (),
-          filesNamesToPaths: {},
-          symlinks: [symlink1FromPath],
-          symlinksNames: new Set ( [symlink1FromPath].map ( toBasename ) ),
-          symlinksNamesToPaths: {}
-        },
-        [folder1Path]: {
-          directories: [],
-          directoriesNames: new Set (),
-          directoriesNamesToPaths: {},
-          files: [],
-          filesNames: new Set (),
-          filesNamesToPaths: {},
-          symlinks: [],
-          symlinksNames: new Set (),
-          symlinksNamesToPaths: {}
-        },
-        [folder2Path]: {
-          directories: [],
-          directoriesNames: new Set (),
-          directoriesNamesToPaths: {},
-          files: [],
-          filesNames: new Set (),
-          filesNamesToPaths: {},
-          symlinks: [],
-          symlinksNames: new Set (),
-          symlinksNamesToPaths: {}
-        }
-      }
-    };
-
-    try {
-
-      const result = await readdir ( root1Path, { limit: 3, followSymlinks: true } );
-
-      t.deepEqual ( result, expected );
-
-    } finally {
-
-      fs.rmSync ( root1Path, { recursive: true } );
-      fs.rmSync ( root2Path, { recursive: true } );
-
-    }
-
-  });
-
-  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/tsconfig.json

@@ -1,3 +0,0 @@
-{
-  "extends": "tsex/tsconfig.json"
-}