tiny-readdir 1.3.0 → 2.0.0

package/.editorconfig

@@ -8,6 +8,3 @@ indent_size = 2
 indent_style = space
 insert_final_newline = true
 trim_trailing_whitespace = true
-
-[*.md]
-trim_trailing_whitespace = false

package/dist/index.d.ts

@@ -1,9 +1,3 @@
-import { Options, Result } from './types';
+import type { Options, Result } from './types';
 declare const readdir: (rootPath: string, options?: Options | undefined) => Promise<Result>;
-declare const _default: typeof readdir & {
-  default: typeof readdir;
-}
-declare namespace _default {
-  export type type = readdir;
-}
-export = _default;
+export default readdir;

package/dist/index.js

@@ -1,74 +1,88 @@
-"use strict";
 /* IMPORT */
-const fs = require("fs");
-const path = require("path");
-const promise_concurrency_limiter_1 = require("promise-concurrency-limiter");
+import fs from 'node:fs';
+import path from 'node:path';
+import Limiter from 'promise-concurrency-limiter';
 /* HELPERS */
-const limiter = new promise_concurrency_limiter_1.default({ concurrency: 500 });
-/* TINY READDIR */
+const limiter = new Limiter({ concurrency: 500 });
+/* MAIN */
 const readdir = (rootPath, options) => {
-    var _a, _b, _c, _d;
-    const followSymlinks = (_a = options === null || options === void 0 ? void 0 : options.followSymlinks) !== null && _a !== void 0 ? _a : false, maxDepth = (_b = options === null || options === void 0 ? void 0 : options.depth) !== null && _b !== void 0 ? _b : Infinity, isIgnored = (_c = options === null || options === void 0 ? void 0 : options.ignore) !== null && _c !== void 0 ? _c : (() => false), signal = (_d = options === null || options === void 0 ? void 0 : options.signal) !== null && _d !== void 0 ? _d : { aborted: false }, directories = [], files = [], symlinks = [], resultEmpty = { directories: [], files: [], symlinks: [] }, result = { directories, files, symlinks };
-    const handleDirectory = (subPath, depth) => {
+    const followSymlinks = options?.followSymlinks ?? false;
+    const maxDepth = options?.depth ?? Infinity;
+    const isIgnored = options?.ignore ?? (() => false);
+    const signal = options?.signal ?? { aborted: false };
+    const directories = [];
+    const files = [];
+    const symlinks = [];
+    const map = {};
+    const visited = new Set();
+    const resultEmpty = { directories: [], files: [], symlinks: [], map: {} };
+    const result = { directories, files, symlinks, map };
+    const handleDirectory = (dirmap, subPath, depth) => {
+        if (visited.has(subPath))
+            return;
+        dirmap.directories.push(subPath);
         directories.push(subPath);
+        visited.add(subPath);
         if (depth >= maxDepth)
             return;
-        return limiter.add(() => populateResult(subPath, depth + 1));
+        return limiter.add(() => populateResultFromPath(subPath, depth + 1));
     };
-    const handleFile = (subPath) => {
+    const handleFile = (dirmap, subPath) => {
+        if (visited.has(subPath))
+            return;
+        dirmap.files.push(subPath);
         files.push(subPath);
+        visited.add(subPath);
     };
-    const handleSymlink = (subPath, depth) => {
+    const handleSymlink = (dirmap, subPath, depth) => {
+        if (visited.has(subPath))
+            return;
+        dirmap.symlinks.push(subPath);
         symlinks.push(subPath);
+        visited.add(subPath);
         if (!followSymlinks)
             return;
         if (depth >= maxDepth)
             return;
-        return limiter.add(async () => {
-            try {
-                const realPath = await fs.promises.realpath(subPath), stat = await fs.promises.stat(realPath);
-                await handleStat(realPath, stat, depth + 1);
-            }
-            catch (_a) { }
-        });
+        return limiter.add(() => populateResultFromSymlink(subPath, depth + 1));
     };
-    const handleStat = (rootPath, stat, depth) => {
+    const handleStat = (dirmap, rootPath, stat, depth) => {
         if (signal.aborted)
             return;
         if (isIgnored(rootPath))
             return;
         if (stat.isDirectory()) {
-            return handleDirectory(rootPath, depth);
+            return handleDirectory(dirmap, rootPath, depth);
         }
         else if (stat.isFile()) {
-            return handleFile(rootPath);
+            return handleFile(dirmap, rootPath);
         }
         else if (stat.isSymbolicLink()) {
-            return handleSymlink(rootPath, depth);
+            return handleSymlink(dirmap, rootPath, depth);
         }
     };
-    const handleDirent = (rootPath, dirent, depth) => {
+    const handleDirent = (dirmap, rootPath, dirent, depth) => {
         if (signal.aborted)
             return;
-        const subPath = path.resolve(rootPath, dirent.name);
+        const subPath = `${rootPath}${path.sep}${dirent.name}`;
         if (isIgnored(subPath))
             return;
         if (dirent.isDirectory()) {
-            return handleDirectory(subPath, depth);
+            return handleDirectory(dirmap, subPath, depth);
         }
         else if (dirent.isFile()) {
-            return handleFile(subPath);
+            return handleFile(dirmap, subPath);
         }
         else if (dirent.isSymbolicLink()) {
-            return handleSymlink(subPath, depth);
+            return handleSymlink(dirmap, subPath, depth);
         }
     };
-    const handleDirents = (rootPath, dirents, depth) => {
+    const handleDirents = (dirmap, rootPath, dirents, depth) => {
         return Promise.all(dirents.map((dirent) => {
-            return handleDirent(rootPath, dirent, depth);
+            return handleDirent(dirmap, rootPath, dirent, depth);
         }));
     };
-    const populateResult = async (rootPath, depth) => {
+    const populateResultFromPath = async (rootPath, depth) => {
         if (signal.aborted)
             return;
         if (depth > maxDepth)
@@ -76,12 +90,24 @@ const readdir = (rootPath, options) => {
         const dirents = await fs.promises.readdir(rootPath, { withFileTypes: true }).catch(() => []);
         if (signal.aborted)
             return;
+        const dirmap = map[rootPath] = { directories: [], files: [], symlinks: [] };
         if (!dirents.length)
             return;
-        await handleDirents(rootPath, dirents, depth);
+        await handleDirents(dirmap, rootPath, dirents, depth);
+    };
+    const populateResultFromSymlink = async (rootPath, depth) => {
+        try {
+            const realPath = await fs.promises.realpath(rootPath);
+            const stat = await fs.promises.stat(realPath);
+            const dirmap = map[rootPath] = { directories: [], files: [], symlinks: [] };
+            await handleStat(dirmap, realPath, stat, depth);
+        }
+        catch { }
     };
     const getResult = async (rootPath, depth = 1) => {
-        await populateResult(rootPath, depth);
+        rootPath = path.normalize(rootPath);
+        visited.add(rootPath);
+        await populateResultFromPath(rootPath, depth);
         if (signal.aborted)
             return resultEmpty;
         return result;
@@ -89,6 +115,4 @@ const readdir = (rootPath, options) => {
     return getResult(rootPath);
 };
 /* EXPORT */
-module.exports = readdir;
-module.exports.default = readdir;
-Object.defineProperty(module.exports, "__esModule", { value: true });
+export default readdir;

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-declare type Promisable<T> = T | Promise<T>;
+declare type Promisable<T> = Promise<T> | T;
 declare type Options = {
     depth?: number;
     followSymlinks?: boolean;
@@ -7,9 +7,15 @@ declare type Options = {
         aborted: boolean;
     };
 };
-declare type Result = {
+declare type ResultDirectory = {
     directories: string[];
     files: string[];
     symlinks: string[];
 };
-export { Promisable, Options, Result };
+declare type ResultDirectories = {
+    [path: string]: ResultDirectory;
+};
+declare type Result = ResultDirectory & {
+    map: ResultDirectories;
+};
+export type { Promisable, Options, ResultDirectory, ResultDirectories, Result };

package/dist/types.js

@@ -1,3 +1,2 @@
-"use strict";
 /* HELPERS */
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/package.json

@@ -1,26 +1,19 @@
 {
   "name": "tiny-readdir",
+  "repository": "github:fabiospampinato/tiny-readdir",
   "description": "A simple promisified recursive readdir function.",
-  "version": "1.3.0",
+  "version": "2.0.0",
+  "type": "module",
   "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "exports": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "scripts": {
-    "clean": "rimraf dist",
-    "compile": "tsc --skipLibCheck && tstei",
-    "compile:watch": "tsc --skipLibCheck --watch",
-    "prepublishOnly": "npm run clean && npm run compile"
-  },
-  "bugs": {
-    "url": "https://github.com/fabiospampinato/tiny-readdir/issues"
-  },
-  "license": "MIT",
-  "author": {
-    "name": "Fabio Spampinato",
-    "email": "spampinabio@gmail.com"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/fabiospampinato/tiny-readdir.git"
+    "clean": "tsex clean",
+    "compile": "tsex compile",
+    "compile:watch": "tsex compile --watch",
+    "test": "tsex test",
+    "test:watch": "tsex test --watch",
+    "prepublishOnly": "npm run clean && npm run compile && npm run test"
   },
   "keywords": [
     "readdir",
@@ -29,16 +22,13 @@
     "simple",
     "tiny"
   ],
-  "engines": {
-    "node": ">= 10.12.0"
-  },
   "dependencies": {
-    "promise-concurrency-limiter": "^1.0.0"
+    "promise-concurrency-limiter": "^2.0.0"
   },
   "devDependencies": {
-    "@types/node": "^14.14.9",
-    "rimraf": "^3.0.2",
-    "typescript": "^4.1.2",
-    "typescript-transform-export-interop": "^1.0.2"
+    "@types/node": "^17.0.23",
+    "fava": "^0.0.6",
+    "tsex": "^1.1.1",
+    "typescript": "^4.6.3"
   }
 }

package/src/index.ts

@@ -1,69 +1,72 @@
 
 /* IMPORT */
 
-import * as fs from 'fs';
-import * as path from 'path';
+import fs from 'node:fs';
+import path from 'node:path';
 import Limiter from 'promise-concurrency-limiter';
-import {Promisable, Options, Result} from './types';
+import type {Promisable, Options, ResultDirectory, ResultDirectories, Result} from './types';
 
 /* HELPERS */
 
 const limiter = new Limiter ({ concurrency: 500 });
 
-/* TINY READDIR */
+/* MAIN */
 
 const readdir = ( rootPath: string, options?: Options ): Promise<Result> => {
 
-  const followSymlinks = options?.followSymlinks ?? false,
-        maxDepth = options?.depth ?? Infinity,
-        isIgnored = options?.ignore ?? (() => false),
-        signal = options?.signal ?? { aborted: false },
-        directories: string[] = [],
-        files: string[] = [],
-        symlinks: string[] = [],
-        resultEmpty: Result = { directories: [], files: [], symlinks: [] },
-        result: Result = { directories, files, symlinks };
+  const followSymlinks = options?.followSymlinks ?? false;
+  const maxDepth = options?.depth ?? Infinity;
+  const isIgnored = options?.ignore ?? (() => false);
+  const signal = options?.signal ?? { aborted: false };
+  const directories: string[] = [];
+  const files: string[] = [];
+  const symlinks: string[] = [];
+  const map: ResultDirectories = {};
+  const visited = new Set<string> ();
+  const resultEmpty: Result = { directories: [], files: [], symlinks: [], map: {} };
+  const result: Result = { directories, files, symlinks, map };
 
-  const handleDirectory = ( subPath: string, depth: number ): Promisable<void> => {
+  const handleDirectory = ( dirmap: ResultDirectory, subPath: string, depth: number ): Promisable<void> => {
 
+    if ( visited.has ( subPath ) ) return;
+
+    dirmap.directories.push ( subPath );
     directories.push ( subPath );
+    visited.add ( subPath );
 
     if ( depth >= maxDepth ) return;
 
-    return limiter.add ( () => populateResult ( subPath, depth + 1 ) );
+    return limiter.add ( () => populateResultFromPath ( subPath, depth + 1 ) );
 
   };
 
-  const handleFile = ( subPath: string ): void => {
+  const handleFile = ( dirmap: ResultDirectory, subPath: string ): void => {
+
+    if ( visited.has ( subPath ) ) return;
 
+    dirmap.files.push ( subPath );
     files.push ( subPath );
+    visited.add ( subPath );
 
   };
 
-  const handleSymlink = ( subPath: string, depth: number ): Promisable<void> => {
+  const handleSymlink = ( dirmap: ResultDirectory, subPath: string, depth: number ): Promisable<void> => {
+
+    if ( visited.has ( subPath ) ) return;
 
+    dirmap.symlinks.push ( subPath );
     symlinks.push ( subPath );
+    visited.add ( subPath );
 
     if ( !followSymlinks ) return;
 
     if ( depth >= maxDepth ) return;
 
-    return limiter.add ( async () => {
-
-      try {
-
-        const realPath = await fs.promises.realpath ( subPath ),
-              stat = await fs.promises.stat ( realPath );
-
-        await handleStat ( realPath, stat, depth + 1 );
-
-      } catch {}
-
-    });
+    return limiter.add ( () => populateResultFromSymlink ( subPath, depth + 1 ) );
 
   };
 
-  const handleStat = ( rootPath: string, stat: fs.Stats, depth: number ): Promisable<void> => {
+  const handleStat = ( dirmap: ResultDirectory, rootPath: string, stat: fs.Stats, depth: number ): Promisable<void> => {
 
     if ( signal.aborted ) return;
 
@@ -71,55 +74,55 @@ const readdir = ( rootPath: string, options?: Options ): Promise<Result> => {
 
     if ( stat.isDirectory () ) {
 
-      return handleDirectory ( rootPath, depth );
+      return handleDirectory ( dirmap, rootPath, depth );
 
     } else if ( stat.isFile () ) {
 
-      return handleFile ( rootPath );
+      return handleFile ( dirmap, rootPath );
 
     } else if ( stat.isSymbolicLink () ) {
 
-      return handleSymlink ( rootPath, depth );
+      return handleSymlink ( dirmap, rootPath, depth );
 
     }
 
   };
 
-  const handleDirent = ( rootPath: string, dirent: fs.Dirent, depth: number ): Promisable<void> => {
+  const handleDirent = ( dirmap: ResultDirectory, rootPath: string, dirent: fs.Dirent, depth: number ): Promisable<void> => {
 
     if ( signal.aborted ) return;
 
-    const subPath = path.resolve ( rootPath, dirent.name );
+    const subPath = `${rootPath}${path.sep}${dirent.name}`;
 
     if ( isIgnored ( subPath ) ) return;
 
     if ( dirent.isDirectory () ) {
 
-      return handleDirectory ( subPath, depth );
+      return handleDirectory ( dirmap, subPath, depth );
 
     } else if ( dirent.isFile () ) {
 
-      return handleFile ( subPath );
+      return handleFile ( dirmap, subPath );
 
     } else if ( dirent.isSymbolicLink () ) {
 
-      return handleSymlink ( subPath, depth );
+      return handleSymlink ( dirmap, subPath, depth );
 
     }
 
   };
 
-  const handleDirents = ( rootPath: string, dirents: fs.Dirent[], depth: number ): Promise<void[]> => {
+  const handleDirents = ( dirmap: ResultDirectory, rootPath: string, dirents: fs.Dirent[], depth: number ): Promise<void[]> => {
 
     return Promise.all ( dirents.map ( ( dirent ): Promisable<void> => {
 
-      return handleDirent ( rootPath, dirent, depth );
+      return handleDirent ( dirmap, rootPath, dirent, depth );
 
     }));
 
   };
 
-  const populateResult = async ( rootPath: string, depth: number ): Promise<void> => {
+  const populateResultFromPath = async ( rootPath: string, depth: number ): Promise<void> => {
 
     if ( signal.aborted ) return;
 
@@ -129,15 +132,35 @@ const readdir = ( rootPath: string, options?: Options ): Promise<Result> => {
 
     if ( signal.aborted ) return;
 
+    const dirmap = map[rootPath] = { directories: [], files: [], symlinks: [] };
+
     if ( !dirents.length ) return;
 
-    await handleDirents ( rootPath, dirents, depth );
+    await handleDirents ( dirmap, rootPath, dirents, depth );
+
+  };
+
+  const populateResultFromSymlink = async ( rootPath: string, depth: number ): Promise<void> => {
+
+    try {
+
+      const realPath = await fs.promises.realpath ( rootPath );
+      const stat = await fs.promises.stat ( realPath );
+      const dirmap = map[rootPath] = { directories: [], files: [], symlinks: [] };
+
+      await handleStat ( dirmap, realPath, stat, depth );
+
+    } catch {}
 
   };
 
   const getResult = async ( rootPath: string, depth: number = 1 ): Promise<Result> => {
 
-    await populateResult ( rootPath, depth );
+    rootPath = path.normalize ( rootPath );
+
+    visited.add ( rootPath );
+
+    await populateResultFromPath ( rootPath, depth );
 
     if ( signal.aborted ) return resultEmpty;
 

package/src/types.ts

@@ -1,9 +1,9 @@
 
 /* HELPERS */
 
-type Promisable<T> = T | Promise<T>;
+type Promisable<T> = Promise<T> | T;
 
-/* TYPES */
+/* MAIN */
 
 type Options = {
   depth?: number,
@@ -12,12 +12,20 @@ type Options = {
   signal?: { aborted: boolean }
 };
 
-type Result = {
+type ResultDirectory = {
   directories: string[],
   files: string[],
   symlinks: string[]
 };
 
+type ResultDirectories = {
+  [path: string]: ResultDirectory
+};
+
+type Result = ResultDirectory & {
+  map: ResultDirectories
+};
+
 /* EXPORT */
 
-export {Promisable, Options, Result};
+export type {Promisable, Options, ResultDirectory, ResultDirectories, Result};

package/test/index.js

@@ -0,0 +1,100 @@
+
+/* IMPORT */
+
+import {describe} from 'fava';
+import fs from 'node:fs';
+import path from 'node:path';
+import readdir from '../dist/index.js';
+
+/* MAIN */
+
+describe ( 'Tiny Readdir', it => {
+
+  it ( 'works', 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],
+      files: [file1aPath, file1bPath, file2Path, fileDeep1Path],
+      symlinks: [symlink1FromPath, symlink2FromPath],
+      map: {
+        [root1Path]: {
+          directories: [folder1Path, folder2Path],
+          files: [],
+          symlinks: [symlink1FromPath]
+        },
+        [root2Path]: {
+          directories: [],
+          files: [],
+          symlinks: [symlink2FromPath]
+        },
+        [folder1Path]: {
+          directories: [folder1DeepPath],
+          files: [file1aPath, file1bPath],
+          symlinks: []
+        },
+        [folder2Path]: {
+          directories: [],
+          files: [file2Path],
+          symlinks: []
+        },
+        [folder1DeepPath]: {
+          directories: [],
+          files: [fileDeep1Path],
+          symlinks: []
+        },
+        [symlink1FromPath]: {
+          directories: [root2Path],
+          files: [],
+          symlinks: []
+        },
+        [symlink2FromPath]: {
+          directories: [],
+          files: [],
+          symlinks: []
+        }
+      }
+    };
+
+    try {
+
+      const result = await readdir ( root1Path, { followSymlinks: true } );
+
+      t.deepEqual ( result, expected );
+
+    } finally {
+
+      fs.rmSync ( root1Path, { recursive: true } );
+      fs.rmSync ( root2Path, { recursive: true } );
+
+    }
+
+  });
+
+});

package/tsconfig.json

@@ -1,28 +1,3 @@
 {
-  "compilerOptions": {
-    "alwaysStrict": true,
-    "declaration": true,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
-    "forceConsistentCasingInFileNames": true,
-    "inlineSourceMap": false,
-    "jsx": "react",
-    "lib": ["dom", "scripthost", "es2015", "es2016", "es2017", "es2018", "es2019", "es2020"],
-    "module": "commonjs",
-    "moduleResolution": "node",
-    "newLine": "LF",
-    "noFallthroughCasesInSwitch": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": false,
-    "outDir": "dist",
-    "pretty": true,
-    "strictNullChecks": true,
-    "target": "es2018"
-  },
-  "include": [
-    "src"
-  ],
-  "exclude": [
-    "node_modules"
-  ]
+  "extends": "tsex/tsconfig.json"
 }

package/.github/FUNDING.yml

@@ -1,2 +0,0 @@
-github: fabiospampinato
-custom: 'https://www.paypal.me/fabiospampinato'