tiny-readdir 2.7.3 → 3.0.0

package/dist/index.d.ts

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

package/dist/index.js

@@ -5,7 +5,6 @@ import makeCounterPromise from 'promise-make-counter';
 import { NOOP_PROMISE_LIKE } from './constants.js';
 import { castArray, isFunction } from './utils.js';
 /* MAIN */
-//TODO: Streamline the type of dirmaps
 const readdir = (rootPath, options) => {
     const followSymlinks = options?.followSymlinks ?? false;
     const maxDepth = options?.depth ?? Infinity;
@@ -16,34 +15,20 @@ const readdir = (rootPath, options) => {
     const signal = options?.signal ?? { aborted: false };
     const onDirents = options?.onDirents || (() => { });
     const directories = [];
-    const directoriesNames = new Set();
-    const directoriesNamesToPaths = {};
     const files = [];
-    const filesNames = new Set();
-    const filesNamesToPaths = {};
     const symlinks = [];
-    const symlinksNames = new Set();
-    const symlinksNamesToPaths = {};
-    const map = {};
     const visited = new Set();
-    const resultEmpty = { directories: [], directoriesNames: new Set(), directoriesNamesToPaths: {}, files: [], filesNames: new Set(), filesNamesToPaths: {}, symlinks: [], symlinksNames: new Set(), symlinksNamesToPaths: {}, map: {} };
-    const result = { directories, directoriesNames, directoriesNamesToPaths, files, filesNames, filesNamesToPaths, symlinks, symlinksNames, symlinksNamesToPaths, map };
+    const resultEmpty = { directories: [], files: [], symlinks: [] };
+    const result = { directories, files, symlinks };
     const { promise, increment, decrement } = makeCounterPromise();
     let foundPaths = 0;
-    const handleDirectory = (dirmap, subPath, name, depth) => {
+    const handleDirectory = (subPath, depth) => {
         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;
@@ -51,36 +36,22 @@ const readdir = (rootPath, options) => {
             return;
         populateResultFromPath(subPath, depth + 1);
     };
-    const handleFile = (dirmap, subPath, name) => {
+    const handleFile = (subPath) => {
         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, subPath, name, depth) => {
+    const handleSymlink = (subPath, depth) => {
         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;
@@ -90,22 +61,22 @@ const readdir = (rootPath, options) => {
             return;
         populateResultFromSymlink(subPath, depth + 1);
     };
-    const handleStat = (dirmap, rootPath, name, stat, depth) => {
+    const handleStat = (rootPath, stat, depth) => {
         if (signal.aborted)
             return;
         if (isIgnored(rootPath))
             return;
         if (stat.isDirectory()) {
-            handleDirectory(dirmap, rootPath, name, depth);
+            handleDirectory(rootPath, depth);
         }
         else if (stat.isFile()) {
-            handleFile(dirmap, rootPath, name);
+            handleFile(rootPath);
         }
         else if (stat.isSymbolicLink()) {
-            handleSymlink(dirmap, rootPath, name, depth);
+            handleSymlink(rootPath, depth);
         }
     };
-    const handleDirent = (dirmap, rootPath, dirent, depth) => {
+    const handleDirent = (rootPath, dirent, depth) => {
         if (signal.aborted)
             return;
         const separator = (rootPath === path.sep) ? '' : path.sep;
@@ -114,18 +85,18 @@ const readdir = (rootPath, options) => {
         if (isIgnored(subPath))
             return;
         if (dirent.isDirectory()) {
-            handleDirectory(dirmap, subPath, name, depth);
+            handleDirectory(subPath, depth);
         }
         else if (dirent.isFile()) {
-            handleFile(dirmap, subPath, name);
+            handleFile(subPath);
         }
         else if (dirent.isSymbolicLink()) {
-            handleSymlink(dirmap, subPath, name, depth);
+            handleSymlink(subPath, depth);
         }
     };
-    const handleDirents = (dirmap, rootPath, dirents, depth) => {
+    const handleDirents = (rootPath, dirents, depth) => {
         for (let i = 0, l = dirents.length; i < l; i++) {
-            handleDirent(dirmap, rootPath, dirents[i], depth);
+            handleDirent(rootPath, dirents[i], depth);
         }
     };
     const populateResultFromPath = (rootPath, depth) => {
@@ -145,8 +116,7 @@ const readdir = (rootPath, options) => {
                 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);
+                handleDirents(rootPath, dirents, depth);
                 decrement();
             });
         });
@@ -163,14 +133,12 @@ const readdir = (rootPath, options) => {
                     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);
+                handleStat(realPath, stat, depth);
                 decrement();
             });
         });
     };
-    const getResult = async (rootPath, depth = 1) => {
+    const populateResultFromRoot = async (rootPath, depth = 1) => {
         rootPath = path.normalize(rootPath);
         visited.add(rootPath);
         populateResultFromPath(rootPath, depth);
@@ -179,7 +147,7 @@ const readdir = (rootPath, options) => {
             return resultEmpty;
         return result;
     };
-    return getResult(rootPath);
+    return populateResultFromRoot(rootPath);
 };
 /* EXPORT */
 export default readdir;

package/dist/types.d.ts

@@ -22,21 +22,9 @@ type Options = {
     };
     onDirents?: (dirents: Dirent[]) => PromiseMaybe<undefined>;
 };
-type ResultDirectory = {
+type Result = {
     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 type { Callback, PromiseMaybe, Dirent, Options, ResultDirectory, ResultDirectories, Result };
+export type { Callback, PromiseMaybe, Dirent, Options, Result };

package/package.json

@@ -2,18 +2,22 @@
   "name": "tiny-readdir",
   "repository": "github:fabiospampinato/tiny-readdir",
   "description": "A simple promisified recursive readdir function.",
-  "version": "2.7.3",
+  "license": "MIT",
+  "version": "3.0.0",
   "type": "module",
   "main": "dist/index.js",
   "exports": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
+    "benchmark": "tsex benchmark",
+    "benchmark:watch": "tsex benchmark --watch",
+    "benchmark:prepare": "cd tasks && git clone https://github.com/babel/babel.git",
     "clean": "tsex clean",
     "compile": "tsex compile",
     "compile:watch": "tsex compile --watch",
-    "test": "tsex test",
+    "test": "node test/index.js",
     "test:watch": "tsex test --watch",
-    "prepublishOnly": "tsex prepare"
+    "prepublishOnly": "npm run compile && npm run test"
   },
   "keywords": [
     "readdir",
@@ -23,12 +27,13 @@
     "tiny"
   ],
   "dependencies": {
-    "promise-make-counter": "^1.0.1"
+    "promise-make-counter": "^1.0.2"
   },
   "devDependencies": {
-    "@types/node": "^18.19.39",
-    "fava": "^0.3.4",
+    "@types/node": "^18.19.130",
+    "benchloop": "^2.1.1",
+    "fava": "^0.3.5",
     "tsex": "^4.0.2",
-    "typescript": "^5.5.2"
+    "typescript": "^5.9.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,15 @@ 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
 });
 
-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 how we would abort the reactive read after 10s
 
-result.directoriesNames; // => Set of directories names found
-result.filesNames; // => Set of files name found
-result.symlinksNames; // => Set of symlinks names found
+setTimeout ( () => aborter.abort (), 10_000 ); // 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
+// This is the result object will look like
 
-setTimeout ( () => aborter.abort (), 10_000 ); // Aborting if it's going to take longer than 10s
+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
 ```
 
 ## 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"
-}