tiny-readdir 2.7.4 → 3.1.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,45 +5,30 @@ 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;
     const maxPaths = options?.limit ?? Infinity;
     const ignore = options?.ignore ?? [];
     const ignores = castArray(ignore).map(ignore => isFunction(ignore) ? ignore : (targetPath) => ignore.test(targetPath));
-    const isIgnored = (targetPath) => ignores.some(ignore => ignore(targetPath));
+    const isIgnored = (targetPath, targetContext) => ignores.some(ignore => ignore(targetPath, targetContext));
     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,42 +61,42 @@ 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))
+        if (isIgnored(rootPath, stat))
             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;
         const name = dirent.name;
         const subPath = `${rootPath}${separator}${name}`;
-        if (isIgnored(subPath))
+        if (isIgnored(subPath, dirent))
             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,9 +133,7 @@ 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();
             });
         });

package/dist/types.d.ts

@@ -1,7 +1,7 @@
 type Callback = () => void;
 type ArrayMaybe<T> = T[] | T;
 type PromiseMaybe<T> = Promise<T> | T;
-type Dirent = {
+type DirentLike = {
     isFile: () => boolean;
     isDirectory: () => boolean;
     isBlockDevice: () => boolean;
@@ -9,6 +9,8 @@ type Dirent = {
     isSymbolicLink: () => boolean;
     isFIFO: () => boolean;
     isSocket: () => boolean;
+};
+type Dirent = DirentLike & {
     name: string;
     path: string;
 };
@@ -16,27 +18,15 @@ type Options = {
     depth?: number;
     limit?: number;
     followSymlinks?: boolean;
-    ignore?: ArrayMaybe<((targetPath: string) => boolean) | RegExp>;
+    ignore?: ArrayMaybe<((targetPath: string, targetContext: DirentLike) => boolean) | RegExp>;
     signal?: {
         aborted: boolean;
     };
     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, DirentLike, Dirent, Options, Result };

package/package.json

@@ -3,18 +3,21 @@
   "repository": "github:fabiospampinato/tiny-readdir",
   "description": "A simple promisified recursive readdir function.",
   "license": "MIT",
-  "version": "2.7.4",
+  "version": "3.1.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:watch": "tsex test --watch",
-    "prepublishOnly": "tsex prepare"
+    "prepublishOnly": "npm run compile && node test/index.js"
   },
   "keywords": [
     "readdir",
@@ -27,9 +30,10 @@
     "promise-make-counter": "^1.0.2"
   },
   "devDependencies": {
-    "@types/node": "^18.19.70",
-    "fava": "^0.3.4",
+    "@types/node": "^18.19.130",
+    "benchloop": "^2.1.1",
+    "fava": "^0.3.5",
     "tsex": "^4.0.2",
-    "typescript": "^5.7.3"
+    "typescript": "^5.9.3"
   }
 }

package/readme.md

@@ -20,30 +20,20 @@ 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
   followSymlinks: true, // Whether to follow symlinks or not
-  ignore: targetPath => /node_modules/.test ( targetPath ), // Function that if returns true will ignore this particular file or a directory and its descendants
+  ignore: ( targetPath, targetContext ) => /node_modules/.test ( targetPath ), // Function that if returns true will ignore this particular file or a directory and its descendants
   signal: aborter.signal, // Optional abort signal, useful for aborting potentially expensive operations
   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
+// This is how we would abort the recursive 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
+// This is what the result object will look like
 
 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
-
-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