rev-dep 0.2.1 → 1.0.0-alpha.1

package/README.md

@@ -81,14 +81,14 @@ Available options are
 #### `find` Function
 
 ```js
-import { find } from 'rev-dep'
+import { find } from "rev-dep";
 
 const path = find({
-  entryPoints: ['index.js'],
-  filePath: 'utils.js'
-})
+  entryPoints: ["index.js"],
+  filePath: "utils.js",
+});
 
-console.log(path)
+console.log(path);
 ```
 
 #### `find` Options
@@ -111,6 +111,94 @@ If you installed `rev-dep` **globally**, you will have appropriate compiler inst
 
 For example, to support `*.ts` and `*.tsx` implicit extensions in globally installed `rev-dep`, you have to also install globally `typescript` package (see [source](https://github.com/sverweij/dependency-cruiser/blob/96e34d0cf158034f2b7c8cafe9cec72dd74d8c45/src/extract/transpile/typescript-wrap.js))
 
+## CLI reference
+
+<!-- cli-docs-start -->
+
+### Command `resolve`
+
+Checks if a filePath is required from entryPoint(s) and prints the resolution path
+
+#### Usage
+
+```sh
+rev-dep resolve <filePath> [entryPoints...] [options]
+```
+
+#### Arguments
+
+- `filePath` - Path to a file that should be resolved in entry points (**required**),\* `entryPoints...` - List of entry points to look for file (_optional_)
+
+#### Options
+
+- `-wc, --webpackConfig <path>` - path to webpack config to enable webpack aliases support (_optional_)
+- `--cwd <path>` - path to a directory that should be used as a resolution root (_optional_)
+- `--rr reexportRewire <value>` - resolve actual dependencies for "export \* from" statements (_optional_)
+- `-i include <globs...>` - A list of globs to determine files included in entry points search (_optional_)
+- `-e exclude <globs...>` - A list of globs to determine files excluded in entry points search (_optional_)
+- `-cs, --compactSummary` - print a compact summary of reverse resolution with a count of found paths (_optional_)
+- `-a, --all` - finds all paths combination of a given dependency. Might work very slow or crash for some projects due to heavy usage of RAM (_optional_)
+
+### Command `entry-points`
+
+Print list of entry points in current directory
+
+#### Usage
+
+```sh
+rev-dep entry-points [options]
+```
+
+#### Options
+
+- `-wc, --webpackConfig <path>` - path to webpack config to enable webpack aliases support (_optional_)
+- `--cwd <path>` - path to a directory that should be used as a resolution root (_optional_)
+- `--rr reexportRewire <value>` - resolve actual dependencies for "export \* from" statements (_optional_)
+- `-i include <globs...>` - A list of globs to determine files included in entry points search (_optional_)
+- `-e exclude <globs...>` - A list of globs to determine files excluded in entry points search (_optional_)
+- `-pdc, --printDependenciesCount` - print count of entry point dependencies (_optional_)
+- `-c, --count` - print just count of found entry points (_optional_)
+
+### Command `files`
+
+Get list of files required by entry point
+
+#### Usage
+
+```sh
+rev-dep files <entryPoint> [options]
+```
+
+#### Arguments
+
+- `entryPoint` - Path to entry point (**required**)
+
+#### Options
+
+- `-wc, --webpackConfig <path>` - path to webpack config to enable webpack aliases support (_optional_)
+- `--cwd <path>` - path to a directory that should be used as a resolution root (_optional_)
+- `--rr reexportRewire <value>` - resolve actual dependencies for "export \* from" statements (_optional_)
+- `-c, --count` - print only count of entry point dependencies (_optional_)
+
+### Command `docs`
+
+Generate documentation of available commands into md file.
+
+#### Usage
+
+```sh
+rev-dep docs <outputPath> [options]
+```
+
+#### Arguments
+
+- `outputPath` - path to output \*.md file (**required**)
+
+#### Options
+
+- `-hl, --headerLevel <value>` - Initial header level (_optional_)
+<!-- cli-docs-end -->
+
 ## Contributing
 
 Project is open to contributions, just rise an issue if you have some ideas about features or you noticed a bug. After discussion we can approach implementation :)

package/bin.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('./dist/cli');

package/dist/cli/commonOptions.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.excludeOption = exports.includeOption = exports.reexportRewireOption = exports.cwdOption = exports.webpackConfigOption = void 0;
+exports.webpackConfigOption = [
+    '-wc, --webpackConfig <path>',
+    'path to webpack config to enable webpack aliases support'
+];
+exports.cwdOption = [
+    '--cwd <path>',
+    'path to a directory that should be used as a resolution root',
+    process.cwd()
+];
+exports.reexportRewireOption = [
+    '--rr reexportRewire <value>',
+    'resolve actual dependencies for "export * from" statements'
+];
+exports.includeOption = [
+    '-i include <globs...>',
+    'A list of globs to determine files included in entry points search'
+];
+exports.excludeOption = [
+    '-e exclude <globs...>',
+    'A list of globs to determine files excluded in entry points search'
+];

package/dist/cli/createCommands.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommands = void 0;
+const resolve_1 = __importDefault(require("./resolve"));
+const docs_1 = __importDefault(require("./docs"));
+const entryPoints_1 = __importDefault(require("./entryPoints"));
+const files_1 = __importDefault(require("./files"));
+function createCommands(program) {
+    (0, resolve_1.default)(program);
+    (0, entryPoints_1.default)(program);
+    (0, files_1.default)(program);
+    (0, docs_1.default)(program);
+}
+exports.createCommands = createCommands;

package/dist/cli/docs/generate.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const createCommands_1 = require("../createCommands");
+const template_1 = __importDefault(require("./template"));
+function createCommandsInspector() {
+    let currentCommand = null;
+    const commands = [];
+    const parseOption = (data, description, defaultValue, required) => {
+        const argRegex = /(<|\[).+?(>|\])/g;
+        const argument = data.match(argRegex);
+        const [shortName, longName] = data
+            .replace(argRegex, '')
+            .trim()
+            .split(/,\s+/);
+        return {
+            shortName,
+            longName,
+            argument: argument !== null && argument.length > 0 ? argument[0] : undefined,
+            description,
+            defaultValue,
+            required
+        };
+    };
+    return {
+        command(cmd) {
+            if (currentCommand !== null) {
+                commands.push(currentCommand);
+            }
+            const [name, ...args] = cmd.split(/\s+/);
+            currentCommand = {
+                name,
+                arguments: args.map((arg) => ({
+                    nameRaw: arg,
+                    name: arg.substring(1, arg.length - 1),
+                    required: arg.charAt(0) === '<'
+                })),
+                options: []
+            };
+            return this;
+        },
+        description(description, argDescription) {
+            if (currentCommand !== null) {
+                currentCommand.description = description;
+                if (argDescription !== undefined) {
+                    currentCommand.arguments.forEach((arg) => {
+                        //eslint-disable-next-line
+                        if (argDescription.hasOwnProperty(arg.name)) {
+                            arg.description = argDescription[arg.name];
+                        }
+                    });
+                }
+            }
+            return this;
+        },
+        option(data, description, defaultValue) {
+            if (currentCommand !== null) {
+                currentCommand.options.push(parseOption(data, description, defaultValue, false));
+            }
+            return this;
+        },
+        requiredOption(data, description, defaultValue) {
+            if (currentCommand !== null) {
+                currentCommand.options.push(parseOption(data, description, defaultValue, true));
+            }
+            return this;
+        },
+        action() {
+            return this;
+        },
+        getCommands() {
+            if (currentCommand !== null) {
+                commands.push(currentCommand);
+            }
+            return commands;
+        }
+    };
+}
+function generate(output, initialHeaderLevel) {
+    const commandInspector = createCommandsInspector();
+    //@ts-ignore
+    (0, createCommands_1.createCommands)(commandInspector);
+    const commands = commandInspector.getCommands();
+    const document = (0, template_1.default)(commands, initialHeaderLevel);
+    fs_1.default.writeFileSync(output, document);
+}
+exports.default = generate;

package/dist/cli/docs/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const generate_1 = __importDefault(require("./generate"));
+function create(program) {
+    program
+        .command('docs <outputPath>')
+        .description('Generate documentation of available commands into md file.', {
+        outputPath: 'path to output *.md file'
+    })
+        .option('-hl, --headerLevel <value>', 'Initial header level', '3')
+        .action((outputPath, options) => {
+        (0, generate_1.default)(outputPath, parseInt(options.headerLevel));
+    });
+}
+exports.default = create;

package/dist/cli/docs/template.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dedent_1 = __importDefault(require("dedent"));
+const programName = 'rev-dep';
+const header = (level, ...text) => '#'.repeat(level) + ' ' + text.join(' ');
+const code = (...text) => '`' + text.join(' ') + '`';
+const codeBlock = (...text) => '```sh\n' + text.join(' ') + '\n```';
+const requiredStr = '**required**';
+const optionalStr = '_optional_';
+const filterFalsy = (array) => array.filter((val) => val);
+function template(commands, headerLevel) {
+    return (0, dedent_1.default)(commands
+        .map((cmd) => {
+        return `
+      ${header(headerLevel, 'Command', code(cmd.name))}
+
+      ${cmd.description || 'Description not available'}
+
+      ${header(headerLevel + 1, 'Usage')}
+
+      ${codeBlock(...filterFalsy([
+            programName,
+            cmd.name,
+            ...cmd.arguments.map((arg) => arg.nameRaw),
+            cmd.options.length > 0 ? '[options]' : undefined
+        ]))}
+      ${cmd.arguments.length > 0 ? header(headerLevel + 1, 'Arguments') : ''}
+
+      ${cmd.arguments.map(({ name, required, description }) => (0, dedent_1.default) `
+        * ${code(name)} - ${description} (${required ? requiredStr : optionalStr})
+      `)}
+      
+      ${cmd.options.length > 0 ? header(headerLevel + 1, 'Options') : ''}
+
+      ${cmd.options
+            .map(({ shortName, longName, argument, required, description }) => (0, dedent_1.default) `
+        * ${code(filterFalsy([shortName, longName]).join(', ') +
+            (argument ? ` ${argument}` : ''))} - ${description} (${required ? requiredStr : optionalStr})
+      `)
+            .join('\n')}
+
+    `;
+    })
+        .join('\n'));
+}
+exports.default = template;

package/dist/cli/entryPoints/index.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commonOptions_1 = require("../commonOptions");
+const getEntryPoints_1 = require("../../lib/getEntryPoints");
+const buildDepsGraph_1 = require("../../lib/buildDepsGraph");
+const utils_1 = require("../../lib/utils");
+function createEntryPoints(program) {
+    program
+        .command('entry-points')
+        .description('Print list of entry points in current directory')
+        .option(...commonOptions_1.webpackConfigOption)
+        .option(...commonOptions_1.cwdOption)
+        .option(...commonOptions_1.reexportRewireOption)
+        .option(...commonOptions_1.includeOption)
+        .option(...commonOptions_1.excludeOption)
+        .option('-pdc, --printDependenciesCount', 'print count of entry point dependencies', false)
+        .option('-c, --count', 'print just count of found entry points', false)
+        .action(async (data) => {
+        const { webpackConfig: webpackConfigPath, cwd, printDependenciesCount, include, exclude, count } = data;
+        const [entryPoints, depsTree] = await (0, getEntryPoints_1.getEntryPoints)({
+            cwd: (0, utils_1.resolvePath)(cwd),
+            webpackConfigPath,
+            exclude,
+            include
+        });
+        let depsCount = null;
+        if (printDependenciesCount) {
+            depsCount = entryPoints
+                .map((0, buildDepsGraph_1.buildGraphDpdm)(depsTree))
+                .map(([_, __, vertices]) => vertices.size);
+        }
+        if (count) {
+            console.log('Found', entryPoints.length, 'entry points.');
+            return;
+        }
+        if (entryPoints.length === 0) {
+            console.log('No results found');
+            return;
+        }
+        entryPoints.forEach((pathName, idx) => {
+            if (depsCount !== null) {
+                console.log(pathName, depsCount[idx]);
+            }
+            else {
+                console.log(pathName);
+            }
+        });
+    });
+}
+exports.default = createEntryPoints;

package/dist/cli/entryPoints/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cli/files/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commonOptions_1 = require("../commonOptions");
+const utils_1 = require("../../lib/utils");
+const getDepsTree_1 = require("../../lib/getDepsTree");
+function createFiles(program) {
+    program
+        .command('files <entryPoint>')
+        .description('Get list of files required by entry point', {
+        entryPoint: 'Path to entry point'
+    })
+        .option(...commonOptions_1.webpackConfigOption)
+        .option(...commonOptions_1.cwdOption)
+        .option(...commonOptions_1.reexportRewireOption)
+        .option('-c, --count', 'print only count of entry point dependencies', false)
+        .action(async (entryPoint, data) => {
+        const { webpackConfig: webpackConfigPath, cwd, count } = data;
+        const sanitizedEntryPoints = (0, utils_1.sanitizeUserEntryPoints)([entryPoint]);
+        const depsTree = await (0, getDepsTree_1.getDepsTree)((0, utils_1.resolvePath)(cwd), sanitizedEntryPoints, webpackConfigPath);
+        const filePaths = Object.keys(depsTree);
+        if (filePaths.length === 0) {
+            console.log('No results found');
+            return;
+        }
+        if (count) {
+            console.log(filePaths.length);
+        }
+        else {
+            filePaths.forEach((filePath) => console.log(filePath));
+        }
+    });
+}
+exports.default = createFiles;

package/dist/cli/files/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cli/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+//eslint-disable-next-line
+const pkg = require('../../package.json');
+const createCommands_1 = require("./createCommands");
+const program = new commander_1.Command('rev-dep');
+program.version(pkg.version, '-v, --version');
+(0, createCommands_1.createCommands)(program);
+program.parse(process.argv);

package/dist/cli/resolve/formatResults.js

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatResults = void 0;
+const colors = __importStar(require("colorette"));
+const pathToString = (str, filePath, indentation) => {
+    return `${str ? `${str}\n` : ''}${' '.repeat(indentation)} ➞ ${filePath}`;
+};
+const join = (...args) => args.join(' ') + '\n';
+function formatResults({ results, filePath, entryPoints, compactSummary }) {
+    let formatted = '';
+    const hasAnyResults = results.some((paths) => paths.length > 0);
+    if (!hasAnyResults) {
+        formatted = join('No results found for', filePath, 'in', entryPoints);
+        return formatted;
+    }
+    if (compactSummary) {
+        formatted += join('Results:\n');
+        const maxEntryLength = entryPoints.reduce((maxLength, entryPoint) => {
+            return entryPoint.length > maxLength ? entryPoint.length : maxLength;
+        }, 0);
+        let total = 0;
+        entryPoints.forEach((entry, index) => {
+            formatted += join(`${entry.padEnd(maxEntryLength)} :`, results[index].length);
+            total += results[index].length;
+        });
+        formatted += join('\nTotal:', total);
+    }
+    else {
+        results.forEach((entryPointResults, index) => {
+            if (entryPointResults.length > 0) {
+                formatted += join(colors.bold(entryPoints[index]), ':', '\n');
+                entryPointResults.forEach((path, resultsIndex) => {
+                    const isLast = resultsIndex === entryPointResults.length - 1;
+                    formatted += join(path.reduce(pathToString, ''), isLast ? '' : '\n');
+                });
+                if (index < results.length - 1 && entryPointResults.length > 0) {
+                    formatted += join('_'.repeat(process.stdout.columns)) + '\n';
+                }
+            }
+        });
+    }
+    return formatted;
+}
+exports.formatResults = formatResults;

package/dist/cli/resolve/index.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const find_1 = require("../../lib/find");
+const formatResults_1 = require("./formatResults");
+const utils_1 = require("../../lib/utils");
+const commonOptions_1 = require("../commonOptions");
+function createResolve(program) {
+    program
+        .command('resolve <filePath> [entryPoints...]')
+        .description('Checks if a filePath is required from entryPoint(s) and prints the resolution path', {
+        filePath: 'Path to a file that should be resolved in entry points',
+        'entryPoints...': 'List of entry points to look for file'
+    })
+        .option(...commonOptions_1.webpackConfigOption)
+        .option(...commonOptions_1.cwdOption)
+        .option(...commonOptions_1.reexportRewireOption)
+        .option(...commonOptions_1.includeOption)
+        .option(...commonOptions_1.excludeOption)
+        .option('-cs, --compactSummary', 'print a compact summary of reverse resolution with a count of found paths')
+        .option('-a, --all', 'finds all paths combination of a given dependency. Might work very slow or crash for some projects due to heavy usage of RAM', false)
+        .action(async (filePath, entryPoints, data) => {
+        const { compactSummary, webpackConfig, all, cwd, exclude, include } = data;
+        const sanitizedEntryPoints = (0, utils_1.sanitizeUserEntryPoints)(entryPoints);
+        const [results, resolveEntryPoints] = await (0, find_1.resolve)({
+            entryPoints: sanitizedEntryPoints,
+            filePath,
+            webpackConfig,
+            all,
+            cwd: (0, utils_1.resolvePath)(cwd),
+            exclude,
+            include
+        });
+        const formatted = (0, formatResults_1.formatResults)({
+            results,
+            entryPoints: resolveEntryPoints,
+            compactSummary,
+            filePath
+        });
+        console.log(formatted);
+    });
+}
+exports.default = createResolve;

package/dist/cli/resolve/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/buildDepsGraph.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGraphDpdm = void 0;
+const buildGraphDpdm = (deps, filePath) => (entryPoint) => {
+    const vertices = new Map();
+    let fileNode = null;
+    const inner = (path, visited = new Set(), depth = 1, parent = null) => {
+        const vertex = vertices.get(path);
+        if (vertex) {
+            vertex.parents.push(parent);
+            return vertex;
+        }
+        const localVisited = new Set(visited);
+        if (localVisited.has(path)) {
+            // console.error('CIRCULAR DEP', ...localVisited.values(), path)
+            return {
+                path: 'CIRCULAR',
+                parents: parent ? [parent] : [],
+                children: []
+            };
+        }
+        localVisited.add(path);
+        const dep = deps[path];
+        if (dep === undefined) {
+            throw new Error(`Dependency '${path}' not found!`);
+        }
+        const node = {
+            parents: parent ? [parent] : [],
+            path
+        };
+        node.children = (dep || [])
+            .map((d) => d.id)
+            .filter((path) => path !== null && !path.includes('node_modules'))
+            .map((path) => inner(path, localVisited, depth + 1, node));
+        vertices.set(path, node);
+        if (path === filePath) {
+            fileNode = node;
+        }
+        return node;
+    };
+    return [inner(entryPoint), fileNode, vertices];
+};
+exports.buildGraphDpdm = buildGraphDpdm;

package/dist/lib/cleanupDpdmDeps.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupDpdmDeps = void 0;
+const is_builtin_module_1 = __importDefault(require("is-builtin-module"));
+const cleanupDpdmDeps = (deps) => {
+    const newDeps = {};
+    Object.entries(deps).forEach(([id, dependencies]) => {
+        if (!(0, is_builtin_module_1.default)(id) &&
+            !id.includes('node_modules') &&
+            dependencies !== null) {
+            newDeps[id] = dependencies
+                .filter(({ id }) => id && !id.includes('node_modules'))
+                .map(({ id, request }) => ({
+                id,
+                request
+            }));
+        }
+    });
+    return newDeps;
+};
+exports.cleanupDpdmDeps = cleanupDpdmDeps;

package/dist/lib/find.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolve = void 0;
+const buildDepsGraph_1 = require("./buildDepsGraph");
+const getDepsTree_1 = require("./getDepsTree");
+const getEntryPoints_1 = require("./getEntryPoints");
+const utils_1 = require("./utils");
+const resolvePathsToRoot = (node, all = false, resolvedPaths = [[]]) => {
+    const newPaths = resolvedPaths.map((resolvedPath) => [
+        node.path,
+        ...resolvedPath
+    ]);
+    if (node.parents.length === 0) {
+        return newPaths;
+    }
+    if (all) {
+        return node.parents
+            .map((parentPath) => resolvePathsToRoot(parentPath, all, newPaths))
+            .flat(1);
+    }
+    return resolvePathsToRoot(node.parents[0], false, newPaths);
+};
+const resolve = async ({ entryPoints: _entryPoints, filePath, webpackConfig, cwd = process.cwd(), all, include, exclude }) => {
+    let deps, entryPoints;
+    if (_entryPoints.length > 0) {
+        entryPoints = _entryPoints;
+        deps = await (0, getDepsTree_1.getDepsTree)(cwd, entryPoints, webpackConfig);
+    }
+    else {
+        ;
+        [entryPoints, deps] = await (0, getEntryPoints_1.getEntryPoints)({ cwd, exclude, include });
+    }
+    const cleanedEntryPoints = entryPoints.map(utils_1.removeInitialDot);
+    const cleanedFilePath = (0, utils_1.removeInitialDot)(filePath);
+    const forest = cleanedEntryPoints.map((0, buildDepsGraph_1.buildGraphDpdm)(deps, cleanedFilePath));
+    const resolvedPaths = forest.reduce((allPaths, [_, fileNode]) => {
+        if (!fileNode) {
+            return [...allPaths, []];
+        }
+        const pathsForTree = resolvePathsToRoot(fileNode, all);
+        return [...allPaths, pathsForTree];
+    }, []);
+    return [resolvedPaths, entryPoints];
+};
+exports.resolve = resolve;

package/dist/lib/getDepsSetWebpack.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDepsSetWebpack = void 0;
+const dependency_cruiser_1 = require("dependency-cruiser");
+const utils_1 = require("./utils");
+// eslint-disable-next-line
+const resolveWebpackConfig = require('dependency-cruiser/config-utl/extract-webpack-resolve-config');
+const normalizeDepsTree = (modules) => {
+    const normalized = {};
+    const nonResolvableDeps = [];
+    modules.forEach((mod) => {
+        const { source, dependencies } = mod;
+        if (!nonResolvableDeps.includes(source)) {
+            normalized[source] = dependencies
+                .filter(({ couldNotResolve, resolved: id }) => {
+                if (couldNotResolve) {
+                    nonResolvableDeps.push(id);
+                }
+                return !couldNotResolve;
+            })
+                .map(({ resolved, module }) => ({
+                id: resolved,
+                request: module
+            }));
+        }
+    });
+    return normalized;
+};
+const getDepsSetWebpack = (entryPoints, webpackConfigPath, cwd, skipRegex) => {
+    const skip = skipRegex || '(node_modules|/__tests__|/__test__|/__mockContent__|.scss)';
+    const webpackResolveOptions = webpackConfigPath
+        ? resolveWebpackConfig((0, utils_1.createResolveAbsolutePath)(cwd)(webpackConfigPath))
+        : null;
+    const result = (0, dependency_cruiser_1.cruise)(entryPoints, {
+        //@ts-ignore
+        exclude: skip,
+        //@ts-ignore
+        doNotFollow: { path: skip },
+        tsPreCompilationDeps: true,
+        baseDir: cwd
+    }, webpackResolveOptions);
+    return normalizeDepsTree(result.output.modules);
+};
+exports.getDepsSetWebpack = getDepsSetWebpack;

package/dist/lib/getDepsTree.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDepsTree = void 0;
+const getDepsSetWebpack_1 = require("./getDepsSetWebpack");
+const dpdm_1 = require("dpdm");
+const cleanupDpdmDeps_1 = require("./cleanupDpdmDeps");
+async function getDepsTree(cwd, entryPoints, webpackConfigPath) {
+    let deps;
+    if (webpackConfigPath) {
+        deps = (0, getDepsSetWebpack_1.getDepsSetWebpack)(entryPoints, webpackConfigPath, cwd);
+    }
+    else {
+        // dpdm does not support custom search directory :/
+        const oldProcessCwd = process.cwd;
+        process.cwd = () => cwd;
+        deps = (0, cleanupDpdmDeps_1.cleanupDpdmDeps)(await (0, dpdm_1.parseDependencyTree)(entryPoints, {
+            context: cwd
+        }));
+        process.cwd = oldProcessCwd;
+    }
+    return deps;
+}
+exports.getDepsTree = getDepsTree;

package/dist/lib/getEntryPoints.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEntryPoints = exports.findEntryPointsInDepsTree = exports.getDirectoriesForEntryPointsSearch = void 0;
+const minimatch_1 = __importDefault(require("minimatch"));
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const utils_1 = require("./utils");
+const getDepsTree_1 = require("./getDepsTree");
+const ignore_1 = __importDefault(require("ignore"));
+const getDirectoriesForEntryPointsSearch = async (dir) => {
+    const entries = await promises_1.default.readdir(dir);
+    const directories = await (0, utils_1.asyncFilter)(entries, async (pathName) => {
+        if (pathName === 'node_modules' || pathName.startsWith('.')) {
+            return false;
+        }
+        const stat = await promises_1.default.lstat(path_1.default.resolve(dir, pathName));
+        return stat.isDirectory();
+    });
+    const joinedWithDir = directories.map((pathName) => path_1.default.join(dir, pathName));
+    return [
+        ...joinedWithDir,
+        ...(await Promise.all(joinedWithDir.map(exports.getDirectoriesForEntryPointsSearch))).flat(1)
+    ];
+};
+exports.getDirectoriesForEntryPointsSearch = getDirectoriesForEntryPointsSearch;
+const findEntryPointsInDepsTree = (deps, exclude = [], include = undefined) => {
+    const referencedIds = new Set();
+    Object.values(deps).forEach((entry) => {
+        if (entry !== null) {
+            entry.forEach(({ id }) => referencedIds.add(id));
+        }
+    });
+    return Object.keys(deps)
+        .filter((id) => /\.(ts|tsx|mjs|js|jsx)$/.test(id) &&
+        !/node_modules/.test(id) &&
+        !referencedIds.has(id))
+        .filter((id) => exclude.reduce((result, pattern) => result && !(0, minimatch_1.default)(id, pattern), true))
+        .filter((id) => include
+        ? include.reduce((result, pattern) => result || (0, minimatch_1.default)(id, pattern), false)
+        : true)
+        .sort();
+};
+exports.findEntryPointsInDepsTree = findEntryPointsInDepsTree;
+const getEntryPoints = async ({ cwd, exclude, include, webpackConfigPath }) => {
+    const dirs = await (0, exports.getDirectoriesForEntryPointsSearch)(cwd);
+    const globs = dirs
+        .map((dirName) => path_1.default.relative(cwd, dirName))
+        .map((dirName) => `${dirName}/*`);
+    const globsWithRoot = ['*', ...globs];
+    const depsTree = await (0, getDepsTree_1.getDepsTree)(cwd, globsWithRoot, webpackConfigPath);
+    const possibleEntryPoints = (0, exports.findEntryPointsInDepsTree)(depsTree, exclude, include);
+    const ignoreInstance = (0, ignore_1.default)();
+    let gitignore = '';
+    try {
+        gitignore = (await promises_1.default.readFile(path_1.default.join(cwd, '.gitignore'))).toString();
+        const lines = gitignore.split('\n');
+        const nonCommentedNonEmptyLines = lines
+            .filter((line) => !/^(\s*)#/.test(line))
+            .filter((line) => !/^(\s*)$/.test(line));
+        gitignore = nonCommentedNonEmptyLines.join('\n');
+    }
+    catch (e) {
+        e;
+    }
+    ignoreInstance.add(gitignore);
+    return [ignoreInstance.filter(possibleEntryPoints), depsTree];
+};
+exports.getEntryPoints = getEntryPoints;

package/dist/lib/getMaxDepthInGraph.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMaxDepth = void 0;
+const getMaxDepth = (depth = 1, path = [], vertices = new Map()) => {
+    return (tree) => {
+        const depthFromCache = vertices.get(tree.path);
+        if (depthFromCache) {
+            return depthFromCache;
+        }
+        const newPath = [...path, tree.path];
+        if (tree.children.length === 0) {
+            return [depth, newPath];
+        }
+        const results = tree.children.map((0, exports.getMaxDepth)(depth + 1, newPath, vertices));
+        const maxChildDepth = Math.max(...results.map(([depth]) => depth));
+        const itemWithMaxDepth = results.find(([depth]) => depth === maxChildDepth);
+        vertices.set(tree.path, itemWithMaxDepth);
+        return itemWithMaxDepth;
+    };
+};
+exports.getMaxDepth = getMaxDepth;

package/dist/lib/getMaxDepthInGrapth.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMaxDepth = void 0;
+const getMaxDepth = (depth = 1, path = [], vertices = new Map()) => {
+    return (tree) => {
+        const depthFromCache = vertices.get(tree.path);
+        if (depthFromCache) {
+            return depthFromCache;
+        }
+        const newPath = [...path, tree.path];
+        if (tree.children.length === 0) {
+            return [depth, newPath];
+        }
+        const results = tree.children.map((0, exports.getMaxDepth)(depth + 1, newPath, vertices));
+        const maxChildDepth = Math.max(...results.map(([depth]) => depth));
+        const itemWithMaxDepth = results.find(([depth]) => depth === maxChildDepth);
+        vertices.set(tree.path, itemWithMaxDepth);
+        return itemWithMaxDepth;
+    };
+};
+exports.getMaxDepth = getMaxDepth;

package/dist/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/utils.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePath = exports.sanitizeUserEntryPoints = exports.asyncFilter = exports.createResolveAbsolutePath = exports.removeInitialDot = void 0;
+const path_1 = __importDefault(require("path"));
+const glob_escape_1 = __importDefault(require("glob-escape"));
+const removeInitialDot = (path) => path.replace(/^\.\//, '');
+exports.removeInitialDot = removeInitialDot;
+const createResolveAbsolutePath = (cwd) => (p) => (typeof p === 'string' ? path_1.default.resolve(cwd, p) : p);
+exports.createResolveAbsolutePath = createResolveAbsolutePath;
+const asyncFilter = async (arr, predicate) => {
+    const results = await Promise.all(arr.map(predicate));
+    return arr.filter((_v, index) => results[index]);
+};
+exports.asyncFilter = asyncFilter;
+const sanitizeUserEntryPoints = (entryPoints) => {
+    const globEscapedEntryPoints = entryPoints.map(glob_escape_1.default);
+    return globEscapedEntryPoints;
+};
+exports.sanitizeUserEntryPoints = sanitizeUserEntryPoints;
+const resolvePath = (p) => {
+    if (!p || path_1.default.isAbsolute(p)) {
+        return p;
+    }
+    return path_1.default.resolve(p);
+};
+exports.resolvePath = resolvePath;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "rev-dep",
-  "version": "0.2.1",
+  "version": "1.0.0-alpha.1",
   "description": "Reverse dependency resolution tool built with dependency-cruiser",
-  "main": "find.js",
-  "bin": "cli.js",
+  "main": "lib/find.js",
+  "bin": "bin.js",
   "files": [
-    "find.js",
-    "cli.js",
-    "getDepsSet.js"
+    "dist/**",
+    "lib/**",
+    "bin.js"
   ],
   "author": "Jakub Mazurek @jayu",
   "license": "MIT",
@@ -20,26 +20,40 @@
     "node": ">=10"
   },
   "scripts": {
-    "lint": "eslint *.js",
-    "lint:fix": "eslint --fix *.js",
-    "format": "prettier --check *.js",
-    "format:fix": "prettier --write *.js",
-    "cli": "node cli.js",
+    "lint": "eslint --ext .js,.ts src",
+    "lint:fix": "yarn lint --fix",
+    "docs-gen": "node ./scripts/addDocsToReadme.js",
+    "dev": "node bin",
     "test": "jest",
-    "release": "release-it"
+    "release": "release-it",
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "@types/dedent": "^0.7.0",
+    "colorette": "^2.0.16",
     "commander": "^6.1.0",
-    "dependency-cruiser": "9.23.0"
+    "dedent": "^0.7.0",
+    "dependency-cruiser": "9.23.0",
+    "dpdm": "^3.8.0",
+    "glob-escape": "^0.0.2",
+    "ignore": "^5.2.0",
+    "is-builtin-module": "^3.1.0",
+    "minimatch": "^5.0.1"
   },
   "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^5.16.0",
+    "@typescript-eslint/parser": "^5.16.0",
     "eslint": "^7.11.0",
-    "eslint-config-prettier": "^6.13.0",
+    "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-jest": "^24.1.0",
     "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^4.0.0",
     "jest": "^26.5.3",
     "mock-fs": "^4.13.0",
     "prettier": "^2.1.2",
-    "release-it": "^14.2.1"
+    "release-it": "^14.2.1",
+    "typescript": "^4.6.2"
   }
 }

package/cli.js

@@ -1,66 +0,0 @@
-#!/usr/bin/env node
-
-const package = require('./package.json')
-const { Command } = require('commander')
-
-const { find } = require('./find')
-const program = new Command('rev-dep')
-program.version(package.version, '-v, --version')
-
-const pathToString = (str, f, i) => {
-  return `${str ? `${str}\n` : ''}${' '.repeat(i)} ➞ ${f}`
-}
-
-program
-  .command('resolve <filePath> <entryPoints...>')
-  .option(
-    '-cs, --compactSummary',
-    'print a compact summary of reverse resolution with a count of found paths'
-  )
-  .option('--verbose', 'print current action information')
-  .option(
-    '-wc, --webpackConfig <path>',
-    'path to webpack config to enable webpack aliases support'
-  )
-  .option(
-    '-tc, --typescriptConfig <path>',
-    'path to TypeScript config to enable TS aliases support'
-  )
-  .action((filePath, entryPoints, data) => {
-    const { compactSummary, verbose, webpackConfig, typescriptConfig } = data
-    const results = find({
-      entryPoints,
-      filePath,
-      verbose,
-      webpackConfig,
-      typescriptConfig
-    })
-    const hasAnyResults = results.some((paths) => paths.length > 0)
-    if (!hasAnyResults) {
-      console.log('No results found for', filePath, 'in', entryPoints)
-      return
-    }
-    console.log('Results:\n')
-    if (compactSummary) {
-      const maxEntryLength = entryPoints.reduce((maxLength, entryPoint) => {
-        return entryPoint.length > maxLength ? entryPoint.length : maxLength
-      }, 0)
-      let total = 0
-      entryPoints.forEach((entry, index) => {
-        console.log(`${entry.padEnd(maxEntryLength)} :`, results[index].length)
-        total += results[index].length
-      })
-      console.log('\nTotal:', total)
-    } else {
-      results.forEach((entryPointResults, index) => {
-        entryPointResults.forEach((path) => {
-          console.log(path.reduce(pathToString, ''))
-        })
-        if (index < results.length - 1) {
-          console.log('_'.repeat(process.stdout.columns))
-        }
-      })
-    }
-  })
-
-program.parse(process.argv)

package/find.js

@@ -1,82 +0,0 @@
-const path = require('path')
-const getDepsSet = require('./getDepsSet')
-
-const buildTree = (deps) => (entryPoint) => {
-  const inner = (path) => {
-    const dep = deps.find((d) => d.source === path)
-    if (dep === undefined) {
-      throw new Error(`Dependency '${path}' not found!`)
-    }
-
-    return {
-      path,
-      children: dep.dependencies.map((d) => {
-        if (d.circular) {
-          return { path: 'CIRCULAR', children: [] }
-        }
-        return inner(d.resolved)
-      })
-    }
-  }
-  return inner(entryPoint)
-}
-
-const traverse = (file) => (tree) => {
-  if (tree.path === file) {
-    return [[file]]
-  } else {
-    return tree.children
-      .map(traverse(file)) // [ [[]],[[]],[[]] ]
-      .filter((p) => p.length > 0)
-      .map((pathsArr) => pathsArr.filter((p) => p.length > 0))
-      .reduce((flat, subPath) => {
-        return [...flat, ...subPath]
-      }, [])
-      .map((p) => [tree.path, ...p])
-  }
-}
-
-const removeInitialDot = (path) => path.replace(/^\.\//, '')
-
-const _resolveAbsolutePath = (cwd) => (p) => typeof p === 'string' ? path.resolve(cwd, p) : p
-
-const find = ({
-  entryPoints,
-  filePath,
-  skipRegex,
-  verbose,
-  webpackConfig,
-  typescriptConfig,
-  cwd = process.cwd()
-}) => {
-  const resolveAbsolutePath = _resolveAbsolutePath(cwd)
-  const absoluteEntryPoints = entryPoints.map(resolveAbsolutePath)
-
-  if (verbose) {
-    console.log('Entry points:')
-    console.log(absoluteEntryPoints)
-    console.log('Getting dependency set for entry points...')
-  }
-  const deps = getDepsSet(
-    absoluteEntryPoints,
-    skipRegex,
-    resolveAbsolutePath(webpackConfig),
-    resolveAbsolutePath(typescriptConfig)
-  )
-  const cleanedEntryPoints = entryPoints.map(removeInitialDot)
-  const cleanedFilePath = removeInitialDot(filePath)
-  if (verbose) {
-    console.log('Building dependency trees for entry points...')
-  }
-  const forest = cleanedEntryPoints.map(buildTree(deps))
-  if (verbose) {
-    console.log('Finding paths in dependency trees...')
-  }
-  const resolvedPaths = forest.reduce((allPaths, tree) => {
-    const paths = traverse(cleanedFilePath)(tree)
-    return [...allPaths, paths]
-  }, [])
-  return resolvedPaths
-}
-
-module.exports = { find }

package/getDepsSet.js

@@ -1,21 +0,0 @@
-const depcruise = require('dependency-cruiser').cruise
-// eslint-disable-next-line
-const resolveWebpackConfig = require('dependency-cruiser/config-utl/extract-webpack-resolve-config')
-// eslint-disable-next-line
-const resolveTsConfig = require('dependency-cruiser/config-utl/extract-ts-config')
-const getDepsSet = (entryPoints, skipRegex, webpackConfigPath, tsConfigPath) => {
-  const skip =
-    skipRegex || '(node_modules|/__tests__|/__test__|/__mockContent__|.scss)'
-  const webpackResolveOptions = webpackConfigPath ? resolveWebpackConfig(webpackConfigPath) : null
-  const tsConfigOptions = tsConfigPath ? resolveTsConfig(tsConfigPath) : null
-
-  const result = depcruise(entryPoints, {
-    exclude: skip,
-    doNotFollow: { path: skip },
-    tsPreCompilationDeps: true,
-
-  }, webpackResolveOptions, tsConfigOptions)
-  return result.output.modules
-}
-
-module.exports = getDepsSet