tiny-readdir 2.7.2 → 2.7.4

package/dist/constants.d.ts

@@ -1,4 +1,4 @@
-import type { Callback } from './types';
+import type { Callback } from './types.js';
 declare const NOOP_PROMISE_LIKE: {
     then: (fn: Callback) => void;
 };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import type { Dirent, Options, ResultDirectory, ResultDirectories, Result } from './types';
+import type { Dirent, Options, ResultDirectory, ResultDirectories, Result } from './types.js';
 declare const readdir: (rootPath: string, options?: Options) => Promise<Result>;
 export default readdir;
 export type { Dirent, Options, ResultDirectory, ResultDirectories, Result };

package/dist/index.js

@@ -1,10 +1,11 @@
 /* IMPORT */
 import fs from 'node:fs';
 import path from 'node:path';
+import makeCounterPromise from 'promise-make-counter';
 import { NOOP_PROMISE_LIKE } from './constants.js';
-import { castArray, isFunction, makeCounterPromise } from './utils.js';
+import { castArray, isFunction } from './utils.js';
 /* MAIN */
-//TODO: Streamline the type of dirnmaps
+//TODO: Streamline the type of dirmaps
 const readdir = (rootPath, options) => {
     const followSymlinks = options?.followSymlinks ?? false;
     const maxDepth = options?.depth ?? Infinity;
@@ -150,14 +151,14 @@ const readdir = (rootPath, options) => {
             });
         });
     };
-    const populateResultFromSymlink = async (rootPath, depth) => {
+    const populateResultFromSymlink = (rootPath, depth) => {
         increment();
         fs.realpath(rootPath, (error, realPath) => {
             if (error)
                 return decrement();
             if (signal.aborted)
                 return decrement();
-            fs.stat(realPath, async (error, stat) => {
+            fs.stat(realPath, (error, stat) => {
                 if (error)
                     return decrement();
                 if (signal.aborted)
@@ -169,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);
@@ -178,7 +179,7 @@ const readdir = (rootPath, options) => {
             return resultEmpty;
         return result;
     };
-    return getResult(rootPath);
+    return populateResultFromRoot(rootPath);
 };
 /* EXPORT */
 export default readdir;

package/dist/utils.d.ts

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

package/dist/utils.js

@@ -1,5 +1,3 @@
-/* IMPORT */
-import makeNakedPromise from 'promise-make-naked';
 /* MAIN */
 const castArray = (value) => {
     return Array.isArray(value) ? value : [value];
@@ -7,24 +5,5 @@ const castArray = (value) => {
 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();
-    };
-    const init = () => {
-        increment();
-        queueMicrotask(decrement);
-    };
-    init();
-    return { promise, increment, decrement };
-};
 /* EXPORT */
-export { castArray, isFunction, makeCounterPromise };
+export { castArray, isFunction };

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.2",
+  "license": "MIT",
+  "version": "2.7.4",
   "type": "module",
   "main": "dist/index.js",
   "exports": "./dist/index.js",
@@ -23,12 +24,12 @@
     "tiny"
   ],
   "dependencies": {
-    "promise-make-naked": "^2.1.1"
+    "promise-make-counter": "^1.0.2"
   },
   "devDependencies": {
-    "@types/node": "^20.4.8",
-    "fava": "^0.2.1",
-    "tsex": "^3.0.1",
-    "typescript": "^5.1.6"
+    "@types/node": "^18.19.70",
+    "fava": "^0.3.4",
+    "tsex": "^4.0.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,19 +25,25 @@ 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
 });
 
-console.log ( result.directories ); // => Array of absolute paths pointing to directories
-console.log ( result.files ); // => Array of absolute paths pointing to files
-console.log ( result.symlinks ); // => Array of absolute paths pointing to symlinks
+// 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
 
-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
+// This is more advanced information we'll get, which is useful in some cases
 
-console.log ( result.directoriesNamesToPaths ); // => Record of directories names found to their paths
-console.log ( result.filesNamesToPaths ); // => Record of files names found to their paths
-console.log ( result.symlinksNamesToPaths ); // => Record of symlinks names found to their paths
+result.directoriesNames; // => Set of directories names found
+result.filesNames; // => Set of files name found
+result.symlinksNames; // => Set of symlinks names found
 
-setTimeout ( () => aborter.abort (), 10000 ); // Aborting if it's going to take longer than 10s
+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
 ```
 
 ## 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,256 +0,0 @@
-
-/* IMPORT */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import {NOOP_PROMISE_LIKE} from './constants';
-import {castArray, isFunction, makeCounterPromise} from './utils';
-import type {Dirent, Options, ResultDirectory, ResultDirectories, Result} from './types';
-
-/* MAIN */
-
-//TODO: Streamline the type of dirnmaps
-
-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 = async ( rootPath: string, depth: number ): Promise<void> => {
-
-    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 (), 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,59 +0,0 @@
-
-/* IMPORT */
-
-import makeNakedPromise from 'promise-make-naked';
-import type {Callback} from './types';
-
-/* 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' );
-
-};
-
-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 ();
-
-  };
-
-  const init = (): void => { // Accounting for no increment/decrement calls
-
-    increment ();
-
-    queueMicrotask ( decrement );
-
-  };
-
-  init ();
-
-  return { promise, increment, decrement };
-
-};
-
-/* EXPORT */
-
-export {castArray, isFunction, makeCounterPromise};

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"
-}