rev-dep 1.0.0-alpha.0 → 1.0.0-alpha.3

package/README.md

@@ -117,7 +117,7 @@ For example, to support `*.ts` and `*.tsx` implicit extensions in globally insta
 
 ### Command `resolve`
 
-Description not available
+Checks if a filePath is required from entryPoint(s) and prints the resolution path
 
 #### Usage
 
@@ -127,18 +127,58 @@ rev-dep resolve <filePath> [entryPoints...] [options]
 
 #### Arguments
 
-- `filePath` - undefined (**required**),\* `entryPoints...` - undefined (_optional_)
+- `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_)
-- `--verbose` - print current action information (_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_)
-- `-tc, --typescriptConfig <path>` - path to TypeScript config to enable TS aliases support (_optional_)
-- `-md, --maxDepth <maxDepth>` - max depth of the dependency tree (_optional_)
-- `-pmd, --printMaxDepth` - print max depth in the tree (_optional_)
-- `-pdc, --printDependentCount` - print count of entry point dependencies (_optional_)
-- `-co, --checkOnly` - finds only one path to entry point instead of all (_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`
 

package/babel.js

@@ -0,0 +1 @@
+module.exports = require('./dist/babel/index.js')

package/dist/babel/index.js

@@ -0,0 +1,274 @@
+"use strict";
+/*eslint-disable @typescript-eslint/no-var-requires */
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path = require('path');
+const fs = require('fs');
+const parser = require('@babel/parser');
+const template = require('@babel/template').default;
+const utils_1 = require("../lib/utils");
+const SKIP = Symbol('SKIP');
+module.exports = function plugin({ types }, { tsConfigPath = (0, utils_1.findTsConfig)() }) {
+    const tsConfig = require(tsConfigPath);
+    const aliases = tsConfig.compilerOptions.paths;
+    const aliasesKeys = Object.keys(aliases);
+    const aliasesRegexes = Object.keys(aliases).map((alias) => {
+        return new RegExp(`^${alias.replace('*', '(.)+')}$`);
+    });
+    const cache = new Map();
+    const getFile = (original, paths) => {
+        if (paths.length === 0) {
+            throw new Error('Cannot resolve import ' + original);
+        }
+        const path = paths[0];
+        try {
+            return [path, fs.readFileSync(path).toString()];
+        }
+        catch (e) {
+            return getFile(original, paths.slice(1));
+        }
+    };
+    const isPathRelativeOrAliased = (path) => {
+        const aliasRegexIdx = aliasesRegexes.findIndex((aliasRegex) => aliasRegex.test(path));
+        const isRelative = path.startsWith('./') || path.startsWith('../');
+        return aliasRegexIdx > -1 || isRelative;
+    };
+    const cacheKey = (identifier, filePath) => `${identifier}-${filePath}`;
+    const lookup = (identifier, filePath, cwd) => {
+        const cached = cache.get(cacheKey(identifier, filePath));
+        if (cached) {
+            return cached;
+        }
+        const withExtension = /(\.ts|\.tsx)$/.test(filePath)
+            ? [filePath]
+            : [
+                `${filePath}.ts`,
+                `${filePath}.tsx`,
+                `${filePath}/index.ts`,
+                `${filePath}/index.tsx`,
+                `${filePath}.js`,
+                `${filePath}.jsx`,
+                `${filePath}/index.js`,
+                `${filePath}/index.jsx`
+            ];
+        const [resolvedFilePath, file] = getFile(filePath, withExtension);
+        const ast = parser.parse(file, {
+            sourceType: 'module',
+            plugins: [
+                'jsx',
+                'typescript',
+                'objectRestSpread',
+                'classProperties',
+                'asyncGenerators',
+                'decorators-legacy'
+            ]
+        });
+        /**
+         * {
+         *  identifier?: string,
+         *  source: string
+         * }
+         */
+        const toLookup = [];
+        let resolvedAs = null;
+        ast.program.body.forEach((declaration) => {
+            var _a;
+            if (resolvedAs === null) {
+                if (types.isExportNamedDeclaration(declaration)) {
+                    if (types.isVariableDeclaration(declaration.declaration)) {
+                        const hasIdentifier = declaration.declaration.declarations.find((declarator) => {
+                            return declarator.id.name === identifier;
+                        });
+                        if (hasIdentifier) {
+                            resolvedAs = {
+                                type: 'named',
+                                identifier,
+                                source: filePath
+                            };
+                        }
+                    }
+                    else if (types.isFunctionDeclaration(declaration.declaration) ||
+                        types.isClassDeclaration(declaration.declaration)) {
+                        if (declaration.declaration.id.name === identifier) {
+                            resolvedAs = {
+                                type: 'named',
+                                identifier,
+                                source: filePath
+                            };
+                        }
+                    }
+                    else {
+                        const source = (_a = declaration.source) === null || _a === void 0 ? void 0 : _a.value;
+                        declaration.specifiers.forEach((specifier) => {
+                            if (types.isExportSpecifier(specifier)) {
+                                if (specifier.exported.name === identifier) {
+                                    if (specifier.local.name === 'default' && source) {
+                                        resolvedAs = {
+                                            type: 'default',
+                                            identifier,
+                                            source: getModulePath(source, resolvedFilePath, cwd)
+                                        };
+                                    }
+                                    else if (source === undefined) {
+                                        resolvedAs = {
+                                            type: 'named',
+                                            identifier,
+                                            source: filePath
+                                        };
+                                    }
+                                    else if (isPathRelativeOrAliased(source)) {
+                                        toLookup.push({
+                                            identifier: specifier.exported.local,
+                                            source: getModulePath(source, resolvedFilePath, cwd)
+                                        });
+                                    }
+                                }
+                            }
+                        });
+                    }
+                }
+                else if (types.isExportAllDeclaration(declaration) &&
+                    isPathRelativeOrAliased(declaration.source.value)) {
+                    toLookup.push({
+                        identifier,
+                        source: getModulePath(declaration.source.value, resolvedFilePath, cwd)
+                    });
+                }
+            }
+        });
+        if (resolvedAs) {
+            return resolvedAs;
+        }
+        const nestedResult = toLookup
+            .map(({ identifier, source }) => lookup(identifier, source, cwd))
+            .filter(Boolean);
+        return nestedResult[0];
+    };
+    const getModulePath = (sourcePath, fileName, cwd) => {
+        var _a;
+        const aliasRegexIdx = aliasesRegexes.findIndex((aliasRegex) => aliasRegex.test(sourcePath));
+        const relativeFileName = node_path.relative(cwd, fileName);
+        const aliasKey = aliasesKeys[aliasRegexIdx];
+        const alias = (_a = aliases[aliasKey]) === null || _a === void 0 ? void 0 : _a[0];
+        let modulePath = '';
+        if (alias) {
+            let relative = alias;
+            if (aliasKey.endsWith('*')) {
+                const aliasKeyPrefix = aliasKey.replace('*', '');
+                relative = alias.replace('*', sourcePath.replace(aliasKeyPrefix, ''));
+            }
+            modulePath = node_path.resolve(cwd, relative);
+        }
+        else {
+            // we need ../ to skip current file name
+            modulePath = node_path.resolve(relativeFileName, '../' + sourcePath);
+        }
+        return modulePath;
+    };
+    return {
+        visitor: {
+            ImportDeclaration(path, { filename, cwd }) {
+                const sourceRelative = (source) => {
+                    const rel = node_path.relative(node_path.dirname(filename), source);
+                    return rel.startsWith('.') ? rel : './' + rel;
+                };
+                const node = path.node;
+                const source = node.source;
+                if (source.type !== 'StringLiteral') {
+                    return;
+                }
+                const shouldSkip = node[SKIP] || !isPathRelativeOrAliased(source.value);
+                if (shouldSkip) {
+                    return;
+                }
+                const modulePath = getModulePath(source.value, filename, cwd);
+                const defaultSpecifier = node.specifiers.find((specifier) => specifier.type === 'ImportDefaultSpecifier');
+                const namespaceSpecifier = node.specifiers.find((specifier) => specifier.type === 'ImportNamespaceSpecifier');
+                const specifiers = node.specifiers.filter((specifier) => specifier.type === 'ImportSpecifier');
+                const results = specifiers.map((specifier) => {
+                    const importedName = specifier.imported.name;
+                    const result = lookup(importedName, modulePath, cwd);
+                    if (!result) {
+                        return {
+                            identifier: importedName,
+                            local: specifier.local.name,
+                            source: source.value
+                        };
+                    }
+                    cache.set(cacheKey(importedName, modulePath), result);
+                    return {
+                        ...result,
+                        source: sourceRelative(result.source),
+                        local: specifier.local.name
+                    };
+                });
+                const defaultResult = defaultSpecifier
+                    ? lookup('default', modulePath, cwd)
+                    : null;
+                if (defaultResult) {
+                    cache.set(cacheKey('default', modulePath), defaultResult);
+                }
+                const buildNamed = template(`
+          import { %%IMPORT_NAME%% } from %%SOURCE%%;
+        `);
+                const buildNamedWithAlias = template(`
+          import { %%IMPORTED_NAME%% as %%LOCAL_NAME%% } from %%SOURCE%%;
+        `);
+                const buildDefault = template(`
+          import %%IMPORT_NAME%% from %%SOURCE%%;
+        `);
+                const buildNamespace = template(`
+          import * as %%IMPORT_NAME%% from %%SOURCE%%;
+        `);
+                const defaultImport = defaultResult
+                    ? [
+                        buildDefault({
+                            IMPORT_NAME: types.identifier(defaultSpecifier.local.name),
+                            SOURCE: types.stringLiteral(sourceRelative(defaultResult.source))
+                        })
+                    ]
+                    : defaultSpecifier
+                        ? [
+                            buildDefault({
+                                IMPORT_NAME: types.identifier(defaultSpecifier.local.name),
+                                SOURCE: types.stringLiteral(source.value)
+                            })
+                        ]
+                        : [];
+                const namespaceImport = namespaceSpecifier
+                    ? [
+                        buildNamespace({
+                            IMPORT_NAME: types.identifier(namespaceSpecifier.local.name),
+                            SOURCE: types.stringLiteral(source.value)
+                        })
+                    ]
+                    : [];
+                const named = results.map(({ type, identifier, local, source }) => {
+                    if (type === 'default') {
+                        return buildDefault({
+                            IMPORT_NAME: types.identifier(identifier),
+                            SOURCE: types.stringLiteral(source)
+                        });
+                    }
+                    else if (identifier !== local) {
+                        return buildNamedWithAlias({
+                            IMPORTED_NAME: types.identifier(identifier),
+                            LOCAL_NAME: types.identifier(local),
+                            SOURCE: types.stringLiteral(source)
+                        });
+                    }
+                    else {
+                        return buildNamed({
+                            IMPORT_NAME: types.identifier(identifier),
+                            SOURCE: types.stringLiteral(source)
+                        });
+                    }
+                });
+                const newImports = [...namespaceImport, ...defaultImport, ...named].map((node) => {
+                    node[SKIP] = true;
+                    return node;
+                });
+                path.replaceWithMultiple(newImports);
+            }
+        }
+    };
+};

package/dist/cli/commonOptions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.reexportRewireOption = exports.cwdOption = exports.webpackConfigOption = void 0;
+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'
@@ -11,6 +11,14 @@ exports.cwdOption = [
     process.cwd()
 ];
 exports.reexportRewireOption = [
-    '--rr reexportRewire <value>',
+    '-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/entryPoints/index.js

@@ -3,6 +3,7 @@ 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')
@@ -10,19 +11,32 @@ function createEntryPoints(program) {
         .option(...commonOptions_1.webpackConfigOption)
         .option(...commonOptions_1.cwdOption)
         .option(...commonOptions_1.reexportRewireOption)
-        .option('-pdc, --printDependentCount', 'print count of entry point dependencies', false)
+        .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, printDependentCount } = data;
+        const { webpackConfig: webpackConfigPath, cwd, printDependenciesCount, include, exclude, count } = data;
         const [entryPoints, depsTree] = await (0, getEntryPoints_1.getEntryPoints)({
-            cwd,
-            webpackConfigPath
+            cwd: (0, utils_1.resolvePath)(cwd),
+            webpackConfigPath,
+            exclude,
+            include
         });
         let depsCount = null;
-        if (printDependentCount) {
+        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]);

package/dist/cli/files/index.js

@@ -6,7 +6,9 @@ const getDepsTree_1 = require("../../lib/getDepsTree");
 function createFiles(program) {
     program
         .command('files <entryPoint>')
-        .description('Get list of files required by entry point')
+        .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)
@@ -14,8 +16,12 @@ function createFiles(program) {
         .action(async (entryPoint, data) => {
         const { webpackConfig: webpackConfigPath, cwd, count } = data;
         const sanitizedEntryPoints = (0, utils_1.sanitizeUserEntryPoints)([entryPoint]);
-        const depsTree = await (0, getDepsTree_1.getDepsTree)(cwd, sanitizedEntryPoints, webpackConfigPath);
+        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);
         }

package/dist/cli/resolve/formatResults.js

@@ -1,6 +1,30 @@
 "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}`;
 };
@@ -10,10 +34,10 @@ function formatResults({ results, filePath, entryPoints, compactSummary }) {
     const hasAnyResults = results.some((paths) => paths.length > 0);
     if (!hasAnyResults) {
         formatted = join('No results found for', filePath, 'in', entryPoints);
-        return;
+        return formatted;
     }
-    formatted += join('Results:\n');
     if (compactSummary) {
+        formatted += join('Results:\n');
         const maxEntryLength = entryPoints.reduce((maxLength, entryPoint) => {
             return entryPoint.length > maxLength ? entryPoint.length : maxLength;
         }, 0);
@@ -26,11 +50,15 @@ function formatResults({ results, filePath, entryPoints, compactSummary }) {
     }
     else {
         results.forEach((entryPointResults, index) => {
-            entryPointResults.forEach((path) => {
-                formatted += join(path.reduce(pathToString, ''), '\n');
-            });
-            if (index < results.length - 1 && entryPointResults.length > 0) {
-                formatted += join('_'.repeat(process.stdout.columns));
+            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';
+                }
             }
         });
     }

package/dist/cli/resolve/index.js

@@ -3,27 +3,36 @@ 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')
+        .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('-wc, --webpackConfig <path>', 'path to webpack config to enable webpack aliases support')
-        .option('-pmd, --printMaxDepth', 'print max depth in the tree', false)
-        .option('-a, --all', 'finds all paths combination of a given dependency. Might work very slow and tend to crash for some projects', false)
+        .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, printMaxDepth, all } = data;
+        const { compactSummary, webpackConfig, all, cwd, exclude, include } = data;
         const sanitizedEntryPoints = (0, utils_1.sanitizeUserEntryPoints)(entryPoints);
-        const results = await (0, find_1.resolve)({
+        const [results, resolveEntryPoints] = await (0, find_1.resolve)({
             entryPoints: sanitizedEntryPoints,
             filePath,
             webpackConfig,
-            printMaxDepth,
-            all
+            all,
+            cwd: (0, utils_1.resolvePath)(cwd),
+            exclude,
+            include
         });
         const formatted = (0, formatResults_1.formatResults)({
             results,
-            entryPoints,
+            entryPoints: resolveEntryPoints,
             compactSummary,
             filePath
         });

package/dist/lib/cleanupDpdmDeps.js

@@ -1,12 +1,18 @@
 "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 (!id.includes('node_modules') && dependencies !== null) {
+        if (!(0, is_builtin_module_1.default)(id) &&
+            !id.includes('node_modules') &&
+            dependencies !== null) {
             newDeps[id] = dependencies
-                .filter(({ id }) => id && !id.includes('node_modules'))
+                .filter(({ id }) => id && !id.includes('node_modules') && !(0, is_builtin_module_1.default)(id))
                 .map(({ id, request }) => ({
                 id,
                 request

package/dist/lib/find.js

@@ -4,7 +4,6 @@ exports.resolve = void 0;
 const buildDepsGraph_1 = require("./buildDepsGraph");
 const getDepsTree_1 = require("./getDepsTree");
 const getEntryPoints_1 = require("./getEntryPoints");
-const getMaxDepthInGrapth_1 = require("./getMaxDepthInGrapth");
 const utils_1 = require("./utils");
 const resolvePathsToRoot = (node, all = false, resolvedPaths = [[]]) => {
     const newPaths = resolvedPaths.map((resolvedPath) => [
@@ -21,7 +20,7 @@ const resolvePathsToRoot = (node, all = false, resolvedPaths = [[]]) => {
     }
     return resolvePathsToRoot(node.parents[0], false, newPaths);
 };
-const resolve = async ({ entryPoints: _entryPoints, filePath, webpackConfig, cwd = process.cwd(), printMaxDepth, all }) => {
+const resolve = async ({ entryPoints: _entryPoints, filePath, webpackConfig, cwd = process.cwd(), all, include, exclude }) => {
     let deps, entryPoints;
     if (_entryPoints.length > 0) {
         entryPoints = _entryPoints;
@@ -29,16 +28,11 @@ const resolve = async ({ entryPoints: _entryPoints, filePath, webpackConfig, cwd
     }
     else {
         ;
-        [entryPoints, deps] = await (0, getEntryPoints_1.getEntryPoints)({ cwd });
+        [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));
-    if (printMaxDepth) {
-        forest.forEach(([tree]) => {
-            console.log('Max depth', ...(0, getMaxDepthInGrapth_1.getMaxDepth)()(tree));
-        });
-    }
     const resolvedPaths = forest.reduce((allPaths, [_, fileNode]) => {
         if (!fileNode) {
             return [...allPaths, []];
@@ -46,6 +40,6 @@ const resolve = async ({ entryPoints: _entryPoints, filePath, webpackConfig, cwd
         const pathsForTree = resolvePathsToRoot(fileNode, all);
         return [...allPaths, pathsForTree];
     }, []);
-    return resolvedPaths;
+    return [resolvedPaths, entryPoints];
 };
 exports.resolve = resolve;

package/dist/lib/getDepsTree.js

@@ -5,11 +5,19 @@ const getDepsSetWebpack_1 = require("./getDepsSetWebpack");
 const dpdm_1 = require("dpdm");
 const cleanupDpdmDeps_1 = require("./cleanupDpdmDeps");
 async function getDepsTree(cwd, entryPoints, webpackConfigPath) {
-    const deps = webpackConfigPath
-        ? (0, getDepsSetWebpack_1.getDepsSetWebpack)(entryPoints, webpackConfigPath, cwd)
-        : (0, cleanupDpdmDeps_1.cleanupDpdmDeps)(await (0, dpdm_1.parseDependencyTree)(entryPoints, {
+    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

@@ -9,6 +9,8 @@ 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 glob_escape_1 = __importDefault(require("glob-escape"));
 const getDirectoriesForEntryPointsSearch = async (dir) => {
     const entries = await promises_1.default.readdir(dir);
     const directories = await (0, utils_1.asyncFilter)(entries, async (pathName) => {
@@ -25,7 +27,7 @@ const getDirectoriesForEntryPointsSearch = async (dir) => {
     ];
 };
 exports.getDirectoriesForEntryPointsSearch = getDirectoriesForEntryPointsSearch;
-const findEntryPointsInDepsTree = (deps, exclude = []) => {
+const findEntryPointsInDepsTree = (deps, exclude = [], include = undefined) => {
     const referencedIds = new Set();
     Object.values(deps).forEach((entry) => {
         if (entry !== null) {
@@ -36,17 +38,35 @@ const findEntryPointsInDepsTree = (deps, exclude = []) => {
         .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) => 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, webpackConfigPath }) => {
+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}/*`);
+        .map((dirName) => `${(0, glob_escape_1.default)(dirName)}/*`);
     const globsWithRoot = ['*', ...globs];
     const depsTree = await (0, getDepsTree_1.getDepsTree)(cwd, globsWithRoot, webpackConfigPath);
-    const possibleEntryPoints = (0, exports.findEntryPointsInDepsTree)(depsTree, exclude);
-    return [possibleEntryPoints, depsTree];
+    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/utils.js

@@ -3,8 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sanitizeUserEntryPoints = exports.asyncFilter = exports.createResolveAbsolutePath = exports.removeInitialDot = void 0;
+exports.findTsConfig = exports.resolvePath = exports.sanitizeUserEntryPoints = exports.asyncFilter = exports.createResolveAbsolutePath = exports.removeInitialDot = void 0;
 const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
 const glob_escape_1 = __importDefault(require("glob-escape"));
 const removeInitialDot = (path) => path.replace(/^\.\//, '');
 exports.removeInitialDot = removeInitialDot;
@@ -20,3 +21,24 @@ const sanitizeUserEntryPoints = (entryPoints) => {
     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;
+const findTsConfig = (cwd = process.cwd()) => {
+    try {
+        const tsconfig = path_1.default.join(cwd, 'tsconfig.json');
+        const stat = fs_1.default.statSync(tsconfig);
+        if (stat.isFile()) {
+            return tsconfig;
+        }
+    }
+    catch {
+        /**/
+    }
+    return undefined;
+};
+exports.findTsConfig = findTsConfig;

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "rev-dep",
-  "version": "1.0.0-alpha.0",
+  "version": "1.0.0-alpha.3",
   "description": "Reverse dependency resolution tool built with dependency-cruiser",
   "main": "lib/find.js",
   "bin": "bin.js",
   "files": [
     "dist/**",
     "lib/**",
-    "bin.js"
+    "bin.js",
+    "babel.js"
   ],
   "author": "Jakub Mazurek @jayu",
   "license": "MIT",
@@ -31,15 +32,21 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "@babel/parser": "^7.17.8",
+    "@babel/template": "^7.16.7",
     "@types/dedent": "^0.7.0",
+    "colorette": "^2.0.16",
     "commander": "^6.1.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": {
+    "@babel/types": "^7.17.0",
     "@typescript-eslint/eslint-plugin": "^5.16.0",
     "@typescript-eslint/parser": "^5.16.0",
     "eslint": "^7.11.0",