run npm install to generate a package lock

node_modules/tiny-readdir/dist/index.js

@@ -0,0 +1,185 @@
+/* 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 } 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 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 { promise, increment, decrement } = makeCounterPromise();
+    let foundPaths = 0;
+    const handleDirectory = (dirmap, subPath, name, 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;
+        if (foundPaths >= maxPaths)
+            return;
+        populateResultFromPath(subPath, depth + 1);
+    };
+    const handleFile = (dirmap, subPath, name) => {
+        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) => {
+        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, rootPath, name, stat, depth) => {
+        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, 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))
+            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, rootPath, dirents, depth) => {
+        for (let i = 0, l = dirents.length; i < l; i++) {
+            handleDirent(dirmap, rootPath, dirents[i], depth);
+        }
+    };
+    const populateResultFromPath = (rootPath, depth) => {
+        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, depth) => {
+        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, depth = 1) => {
+        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;