rev-dep 1.0.7 → 1.2.0

package/README.md

@@ -394,6 +394,8 @@ rev-dep resolve <filePath> [entryPoints...] [options]
 - `-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_)
+- `-ntp --notTraversePaths <paths...>` - Specify file paths relative to resolution root, that should not be traversed when finding dependency path (_optional_)
+- `-iti --ignoreTypesImports` - Use this flag to not follow type imports when resolving modules (_optional_)
 
 ### Command `entry-points`
 
@@ -413,6 +415,7 @@ rev-dep entry-points [options]
 - `-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_)
+- `-iti --ignoreTypesImports` - Use this flag to not follow type imports when resolving modules (_optional_)
 
 ### Command `files`
 
@@ -433,6 +436,7 @@ rev-dep files <entryPoint> [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_)
 - `-c, --count` - print only count of entry point dependencies (_optional_)
+- `-iti --ignoreTypesImports` - Use this flag to not follow type imports when resolving modules (_optional_)
 
 ### Command `docs`
 

package/dist/babel/index.js

@@ -7,13 +7,38 @@ const parser = require('@babel/parser');
 const template = require('@babel/template').default;
 const utils_1 = require("../lib/utils");
 const SKIP = Symbol('SKIP');
+/**
+ *
+ * TODO
+ * - support imports from baseUrl from TS config
+ * - persist the original import alias
+ * - group named imports from the same file
+ * - handle type imports properly - we don't preserve the import was a type import
+ * - If that has to be used as a codemod, we have to refactor to make sure we don't change structure of other parts of the code and we preserve imports order
+ */
 module.exports = function plugin({ types }, { tsConfigPath = (0, utils_1.findTsConfig)() }) {
-    const tsConfig = require(tsConfigPath);
+    const root = tsConfigPath.replace('/tsconfig.json', '');
+    const tsConfigContent = fs.readFileSync(tsConfigPath).toString();
+    const tsConfigContentCleaned = tsConfigContent
+        // remove comments
+        .replace(/^(\s)*\/\//gm, '')
+        .replace(/\/\*.+?\*\//gm, '');
+    const tsConfig = JSON.parse(tsConfigContentCleaned);
     const aliases = tsConfig.compilerOptions.paths;
     const aliasesKeys = Object.keys(aliases);
     const aliasesRegexes = Object.keys(aliases).map((alias) => {
         return new RegExp(`^${alias.replace('*', '(.)+')}$`);
     });
+    let baseUrlDirs = [];
+    const baseUrl = tsConfig.compilerOptions.baseUrl;
+    if (baseUrl) {
+        const baseDirPath = node_path.join(root, baseUrl);
+        const dirNames = fs
+            .readdirSync(baseDirPath, { withFileTypes: true })
+            .filter((dirent) => dirent.isDirectory())
+            .map((dirent) => dirent.name + '/');
+        baseUrlDirs = dirNames;
+    }
     const cache = new Map();
     const getFile = (original, paths) => {
         if (paths.length === 0) {
@@ -27,10 +52,12 @@ module.exports = function plugin({ types }, { tsConfigPath = (0, utils_1.findTsC
             return getFile(original, paths.slice(1));
         }
     };
-    const isPathRelativeOrAliased = (path) => {
+    const isPathNotANodeModule = (path) => {
         const aliasRegexIdx = aliasesRegexes.findIndex((aliasRegex) => aliasRegex.test(path));
         const isRelative = path.startsWith('./') || path.startsWith('../');
-        return aliasRegexIdx > -1 || isRelative;
+        const isAbsolute = path.startsWith('/');
+        const isBaseUrlPath = baseUrlDirs.some((dir) => path.startsWith(dir));
+        return aliasRegexIdx > -1 || isRelative || isAbsolute || isBaseUrlPath;
     };
     const cacheKey = (identifier, filePath) => `${identifier}-${filePath}`;
     const lookup = (identifier, filePath, cwd) => {
@@ -71,10 +98,22 @@ module.exports = function plugin({ types }, { tsConfigPath = (0, utils_1.findTsC
         const toLookup = [];
         let resolvedAs = null;
         ast.program.body.forEach((declaration) => {
-            var _a;
+            var _a, _b, _c;
             if (resolvedAs === null) {
                 if (types.isExportNamedDeclaration(declaration)) {
-                    if (types.isVariableDeclaration(declaration.declaration)) {
+                    if (((_a = declaration.declaration) === null || _a === void 0 ? void 0 : _a.type.startsWith('TS')) &&
+                        ((_b = declaration.declaration) === null || _b === void 0 ? void 0 : _b.type.endsWith('Declaration'))) {
+                        const typeName = declaration.declaration.id.name;
+                        if (typeName === identifier) {
+                            resolvedAs = {
+                                // This should be 'type' of something else, but ESLint would handle that
+                                type: 'named',
+                                identifier,
+                                source: filePath
+                            };
+                        }
+                    }
+                    else if (types.isVariableDeclaration(declaration.declaration)) {
                         const hasIdentifier = declaration.declaration.declarations.find((declarator) => {
                             return declarator.id.name === identifier;
                         });
@@ -97,7 +136,7 @@ module.exports = function plugin({ types }, { tsConfigPath = (0, utils_1.findTsC
                         }
                     }
                     else {
-                        const source = (_a = declaration.source) === null || _a === void 0 ? void 0 : _a.value;
+                        const source = (_c = declaration.source) === null || _c === void 0 ? void 0 : _c.value;
                         declaration.specifiers.forEach((specifier) => {
                             if (types.isExportSpecifier(specifier)) {
                                 if (specifier.exported.name === identifier) {
@@ -115,9 +154,9 @@ module.exports = function plugin({ types }, { tsConfigPath = (0, utils_1.findTsC
                                             source: filePath
                                         };
                                     }
-                                    else if (isPathRelativeOrAliased(source)) {
+                                    else if (isPathNotANodeModule(source)) {
                                         toLookup.push({
-                                            identifier: specifier.exported.local,
+                                            identifier: specifier.local.name,
                                             source: getModulePath(source, resolvedFilePath, cwd)
                                         });
                                     }
@@ -127,7 +166,7 @@ module.exports = function plugin({ types }, { tsConfigPath = (0, utils_1.findTsC
                     }
                 }
                 else if (types.isExportAllDeclaration(declaration) &&
-                    isPathRelativeOrAliased(declaration.source.value)) {
+                    isPathNotANodeModule(declaration.source.value)) {
                     toLookup.push({
                         identifier,
                         source: getModulePath(declaration.source.value, resolvedFilePath, cwd)
@@ -149,6 +188,7 @@ module.exports = function plugin({ types }, { tsConfigPath = (0, utils_1.findTsC
         const relativeFileName = node_path.relative(cwd, fileName);
         const aliasKey = aliasesKeys[aliasRegexIdx];
         const alias = (_a = aliases[aliasKey]) === null || _a === void 0 ? void 0 : _a[0];
+        const isAbsoluteToBaseDir = baseUrlDirs.some((baseUrlDir) => sourcePath.startsWith(baseUrlDir));
         let modulePath = '';
         if (alias) {
             let relative = alias;
@@ -158,35 +198,43 @@ module.exports = function plugin({ types }, { tsConfigPath = (0, utils_1.findTsC
             }
             modulePath = node_path.resolve(cwd, relative);
         }
+        else if (isAbsoluteToBaseDir) {
+            modulePath = node_path.join(cwd, sourcePath);
+        }
         else {
             // we need ../ to skip current file name
-            modulePath = node_path.resolve(relativeFileName, '../' + sourcePath);
+            modulePath = node_path.join(cwd, relativeFileName, '../' + sourcePath);
         }
         return modulePath;
     };
     return {
         visitor: {
-            ImportDeclaration(path, { filename, cwd }) {
+            Program() {
+                // console.log('Cache size', cache.size)
+            },
+            ImportDeclaration(path, { filename }) {
                 const sourceRelative = (source) => {
                     const rel = node_path.relative(node_path.dirname(filename), source);
-                    return rel.startsWith('.') ? rel : './' + rel;
+                    const whatever = rel.startsWith('.') ? rel : './' + rel;
+                    // remove file extension
+                    return whatever.replace(/\.(ts|js|tsx|jsx|cjs|mjs)$/, '');
                 };
                 const node = path.node;
                 const source = node.source;
                 if (source.type !== 'StringLiteral') {
                     return;
                 }
-                const shouldSkip = node[SKIP] || !isPathRelativeOrAliased(source.value);
+                const shouldSkip = node[SKIP] || !isPathNotANodeModule(source.value);
                 if (shouldSkip) {
                     return;
                 }
-                const modulePath = getModulePath(source.value, filename, cwd);
+                const modulePath = getModulePath(source.value, filename, root);
                 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);
+                    const result = lookup(importedName, modulePath, root);
                     if (!result) {
                         return {
                             identifier: importedName,
@@ -202,7 +250,7 @@ module.exports = function plugin({ types }, { tsConfigPath = (0, utils_1.findTsC
                     };
                 });
                 const defaultResult = defaultSpecifier
-                    ? lookup('default', modulePath, cwd)
+                    ? lookup('default', modulePath, root)
                     : null;
                 if (defaultResult) {
                     cache.set(cacheKey('default', modulePath), defaultResult);

package/dist/babel/transform.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/babel/transform.js

@@ -0,0 +1,52 @@
+"use strict";
+/*eslint-disable @typescript-eslint/no-var-requires */
+const { getFilesList } = require('@codeque/core');
+const babelCore = require('@babel/core');
+const fs = require('fs');
+const path = require('path');
+const rootPath = process.argv[2];
+const inputFilePath = process.argv[3];
+if (!rootPath) {
+    console.error('Please provide correct transformation root');
+    process.exit(1);
+}
+;
+(async () => {
+    const root = path.resolve(rootPath);
+    const resolvedInputFilePath = inputFilePath
+        ? path.join(root, inputFilePath)
+        : undefined;
+    console.log('root', root);
+    const filesList = resolvedInputFilePath
+        ? [path.resolve(resolvedInputFilePath)]
+        : await getFilesList({
+            searchRoot: root,
+            extensionTester: /\.(ts|tsx)$/
+        });
+    const errors = [];
+    let progressCount = 0;
+    for (const filePath of filesList) {
+        try {
+            const fileName = path.parse(filePath).name;
+            const result = babelCore.transformFileSync(filePath, {
+                plugins: [
+                    ['./babel.js', { tsConfigPath: path.join(root, 'tsconfig.json') }]
+                ],
+                parserOpts: {
+                    plugins: ['typescript', 'jsx']
+                },
+                filename: fileName
+            });
+            fs.writeFileSync(filePath, result.code);
+            progressCount++;
+            if (progressCount % 100 === 0) {
+                console.log(`${progressCount}+${errors.length}/${filesList.length}`);
+            }
+        }
+        catch (e) {
+            errors.push(e);
+        }
+    }
+    console.log(errors);
+    console.log(`Done: ${progressCount}/${filesList.length}; Failed: ${errors.length}`);
+})();

package/dist/cli/commonOptions.d.ts

@@ -1,5 +1,5 @@
 declare type OptionMeta2 = [string, string];
-declare type OptionMeta3 = [string, string, string];
+declare type OptionMeta3 = [string, string, string | boolean];
 export declare const webpackConfigOption: OptionMeta2;
 export declare type WebpackConfigOptionType = {
     webpackConfig?: string;
@@ -20,4 +20,8 @@ export declare const excludeOption: OptionMeta2;
 export declare type ExcludeOptionType = {
     exclude?: string[];
 };
+export declare const ignoreTypesImports: OptionMeta3;
+export declare type IgnoreTypesImportsOptionType = {
+    ignoreTypesImports: boolean;
+};
 export {};

package/dist/cli/commonOptions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.excludeOption = exports.includeOption = exports.reexportRewireOption = exports.cwdOption = exports.webpackConfigOption = void 0;
+exports.ignoreTypesImports = 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'
@@ -22,3 +22,8 @@ exports.excludeOption = [
     '-e --exclude <globs...>',
     'A list of globs to determine files excluded in entry points search'
 ];
+exports.ignoreTypesImports = [
+    '-iti --ignoreTypesImports',
+    'Use this flag to not follow type imports when resolving modules',
+    false
+];

package/dist/cli/entryPoints/index.js

@@ -15,18 +15,20 @@ function createEntryPoints(program) {
         .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)
+        .option(...commonOptions_1.ignoreTypesImports)
         .action(async (data) => {
-        const { webpackConfig: webpackConfigPath, cwd, printDependenciesCount, include, exclude, count } = data;
+        const { webpackConfig: webpackConfigPath, cwd, printDependenciesCount, include, exclude, count, ignoreTypesImports } = data;
         const [entryPoints, depsTree] = await (0, getEntryPoints_1.getEntryPoints)({
             cwd: (0, utils_1.resolvePath)(cwd),
             webpackConfigPath,
             exclude,
-            include
+            include,
+            ignoreTypesImports
         });
         let depsCount = null;
         if (printDependenciesCount) {
             depsCount = entryPoints
-                .map((0, buildDepsGraph_1.buildGraphDpdm)(depsTree))
+                .map((0, buildDepsGraph_1.buildDepsGraph)(depsTree))
                 .map(([_, __, vertices]) => vertices.size);
         }
         if (count) {

package/dist/cli/files/index.js

@@ -13,10 +13,11 @@ function createFiles(program) {
         .option(...commonOptions_1.cwdOption)
         // .option(...reexportRewireOption)
         .option('-c, --count', 'print only count of entry point dependencies', false)
+        .option(...commonOptions_1.ignoreTypesImports)
         .action(async (entryPoint, data) => {
-        const { webpackConfig: webpackConfigPath, cwd, count } = data;
+        const { webpackConfig: webpackConfigPath, cwd, count, ignoreTypesImports } = data;
         const sanitizedEntryPoints = (0, utils_1.sanitizeUserEntryPoints)([entryPoint]);
-        const depsTree = await (0, getDepsTree_1.getDepsTree)((0, utils_1.resolvePath)(cwd), sanitizedEntryPoints, webpackConfigPath);
+        const depsTree = await (0, getDepsTree_1.getDepsTree)((0, utils_1.resolvePath)(cwd), sanitizedEntryPoints, webpackConfigPath, ignoreTypesImports);
         const filePaths = Object.keys(depsTree);
         if (filePaths.length === 0) {
             console.log('No results found');

package/dist/cli/resolve/index.js

@@ -18,8 +18,10 @@ function createResolve(program) {
         .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)
+        .option('-ntp --notTraversePaths <paths...>', 'Specify file paths relative to resolution root, that should not be traversed when finding dependency path')
+        .option(...commonOptions_1.ignoreTypesImports)
         .action(async (filePath, entryPoints, data) => {
-        const { compactSummary, webpackConfig, all, cwd, exclude, include } = data;
+        const { compactSummary, webpackConfig, all, cwd, exclude, include, notTraversePaths, ignoreTypesImports } = data;
         const [results, resolveEntryPoints] = await (0, resolve_1.resolve)({
             entryPoints,
             filePath,
@@ -27,7 +29,9 @@ function createResolve(program) {
             all,
             cwd: (0, utils_1.resolvePath)(cwd),
             exclude,
-            include
+            include,
+            notTraversePaths,
+            ignoreTypesImports
         });
         const formatted = (0, formatResults_1.formatResults)({
             results,

package/dist/cli/resolve/types.d.ts

@@ -6,4 +6,5 @@ export declare type InputParams = {
     printMaxDepth?: boolean;
     printDependentCount?: boolean;
     all: boolean;
+    notTraversePaths?: string[];
 };

package/dist/lib/buildDepsGraph.d.ts

@@ -1,2 +1,2 @@
 import { Node, MinimalDependencyTree } from './types';
-export declare const buildGraphDpdm: (deps: MinimalDependencyTree, filePath?: string | undefined) => (entryPoint: string) => [Node, Node | null, Map<string, Node>];
+export declare const buildDepsGraph: (deps: MinimalDependencyTree, filePath?: string | undefined, notTraversePath?: string[] | undefined) => (entryPoint: string) => [Node, Node | null, Map<string, Node>];

package/dist/lib/buildDepsGraph.js

@@ -1,7 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildGraphDpdm = void 0;
-const buildGraphDpdm = (deps, filePath) => (entryPoint) => {
+exports.buildDepsGraph = void 0;
+const minimatch_1 = __importDefault(require("minimatch"));
+const buildDepsGraph = (deps, filePath, notTraversePath) => (entryPoint) => {
     const vertices = new Map();
     let fileNode = null;
     const inner = (path, visited = new Set(), depth = 1, parent = null) => {
@@ -30,7 +34,9 @@ const buildGraphDpdm = (deps, filePath) => (entryPoint) => {
         };
         node.children = (dep || [])
             .map((d) => d.id)
-            .filter((path) => path !== null && !path.includes('node_modules'))
+            .filter((path) => path !== null &&
+            !path.includes('node_modules') &&
+            !(notTraversePath === null || notTraversePath === void 0 ? void 0 : notTraversePath.some((pathToNotTraverse) => (0, minimatch_1.default)(path, pathToNotTraverse))))
             .map((path) => inner(path, localVisited, depth + 1, node));
         vertices.set(path, node);
         if (path === filePath) {
@@ -40,4 +46,4 @@ const buildGraphDpdm = (deps, filePath) => (entryPoint) => {
     };
     return [inner(entryPoint), fileNode, vertices];
 };
-exports.buildGraphDpdm = buildGraphDpdm;
+exports.buildDepsGraph = buildDepsGraph;

package/dist/lib/getDepsTree.d.ts

@@ -1 +1 @@
-export declare function getDepsTree(cwd: string, entryPoints: string[], webpackConfigPath?: string): Promise<import("./types").MinimalDependencyTree>;
+export declare function getDepsTree(cwd: string, entryPoints: string[], webpackConfigPath?: string, ignoreTypesImports?: boolean): Promise<import("./types").MinimalDependencyTree>;

package/dist/lib/getDepsTree.js

@@ -4,7 +4,7 @@ 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) {
+async function getDepsTree(cwd, entryPoints, webpackConfigPath, ignoreTypesImports = false) {
     let deps;
     if (webpackConfigPath) {
         deps = (0, getDepsSetWebpack_1.getDepsSetWebpack)(entryPoints, webpackConfigPath, cwd);
@@ -14,7 +14,8 @@ async function getDepsTree(cwd, entryPoints, webpackConfigPath) {
         const oldProcessCwd = process.cwd;
         process.cwd = () => cwd;
         deps = (0, cleanupDpdmDeps_1.cleanupDpdmDeps)(await (0, dpdm_1.parseDependencyTree)(entryPoints, {
-            context: cwd
+            context: cwd,
+            transform: ignoreTypesImports
         }));
         process.cwd = oldProcessCwd;
     }

package/dist/lib/getEntryPoints.d.ts

@@ -1,9 +1,10 @@
 import { MinimalDependencyTree } from './types';
 export declare const getDirectoriesForEntryPointsSearch: (dir: string) => Promise<string[]>;
 export declare const findEntryPointsInDepsTree: (deps: MinimalDependencyTree, exclude?: string[], include?: string[] | undefined) => string[];
-export declare const getEntryPoints: ({ cwd, exclude, include, webpackConfigPath }: {
+export declare const getEntryPoints: ({ cwd, exclude, include, webpackConfigPath, ignoreTypesImports }: {
     cwd: string;
     exclude?: string[] | undefined;
     include?: string[] | undefined;
     webpackConfigPath?: string | undefined;
+    ignoreTypesImports?: boolean | undefined;
 }) => Promise<[string[], MinimalDependencyTree]>;

package/dist/lib/getEntryPoints.js

@@ -35,7 +35,7 @@ const findEntryPointsInDepsTree = (deps, exclude = [], include = undefined) => {
         }
     });
     return Object.keys(deps)
-        .filter((id) => /\.(ts|tsx|mjs|js|jsx)$/.test(id) &&
+        .filter((id) => /\.(ts|tsx|mjs|cjs|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))
@@ -45,13 +45,13 @@ const findEntryPointsInDepsTree = (deps, exclude = [], include = undefined) => {
         .sort();
 };
 exports.findEntryPointsInDepsTree = findEntryPointsInDepsTree;
-const getEntryPoints = async ({ cwd, exclude, include, webpackConfigPath }) => {
+const getEntryPoints = async ({ cwd, exclude, include, webpackConfigPath, ignoreTypesImports }) => {
     const dirs = await (0, exports.getDirectoriesForEntryPointsSearch)(cwd);
     const globs = dirs
         .map((dirName) => path_1.default.relative(cwd, dirName))
         .map((dirName) => `${(0, glob_escape_1.default)(dirName)}/*`);
     const globsWithRoot = ['*', ...globs];
-    const depsTree = await (0, getDepsTree_1.getDepsTree)(cwd, globsWithRoot, webpackConfigPath);
+    const depsTree = await (0, getDepsTree_1.getDepsTree)(cwd, globsWithRoot, webpackConfigPath, ignoreTypesImports);
     const possibleEntryPoints = (0, exports.findEntryPointsInDepsTree)(depsTree, exclude, include);
     const ignoreInstance = (0, ignore_1.default)();
     let gitignore = '';

package/dist/lib/resolve.d.ts

@@ -1,11 +1,13 @@
 declare type ResolveParams = {
-    entryPoints: string[];
+    entryPoints?: string[];
     filePath: string;
     webpackConfig?: string;
     cwd?: string;
     all: boolean;
     exclude?: string[];
     include?: string[];
+    notTraversePaths?: string[];
+    ignoreTypesImports?: boolean;
 };
-export declare const resolve: ({ entryPoints: _entryPoints, filePath, webpackConfig, cwd, all, include, exclude }: ResolveParams) => Promise<[string[][][], string[]]>;
+export declare const resolve: ({ entryPoints: _entryPoints, filePath, webpackConfig, cwd, all, include, exclude, notTraversePaths, ignoreTypesImports }: ResolveParams) => Promise<[string[][][], string[]]>;
 export {};

package/dist/lib/resolve.js

@@ -27,20 +27,26 @@ const resolvePathsToRoot = (node, all = false, resolvedPaths = [[]]) => {
     }
     return resolvePathsToRoot(node.parents[0], false, newPaths);
 };
-const resolve = async ({ entryPoints: _entryPoints, filePath, webpackConfig, cwd = process.cwd(), all, include, exclude }) => {
+const resolve = async ({ entryPoints: _entryPoints, filePath, webpackConfig, cwd = process.cwd(), all, include, exclude, notTraversePaths, ignoreTypesImports }) => {
     let deps, entryPoints;
-    if (_entryPoints.length > 0) {
+    if (_entryPoints && (_entryPoints === null || _entryPoints === void 0 ? void 0 : _entryPoints.length) > 0) {
         entryPoints = _entryPoints;
         const sanitizedEntryPoints = (0, utils_1.sanitizeUserEntryPoints)(entryPoints);
-        deps = await (0, getDepsTree_1.getDepsTree)(cwd, sanitizedEntryPoints, webpackConfig);
+        deps = await (0, getDepsTree_1.getDepsTree)(cwd, sanitizedEntryPoints, webpackConfig, ignoreTypesImports);
     }
     else {
         ;
-        [entryPoints, deps] = await (0, getEntryPoints_1.getEntryPoints)({ cwd, exclude, include });
+        [entryPoints, deps] = await (0, getEntryPoints_1.getEntryPoints)({
+            cwd,
+            exclude,
+            include,
+            webpackConfigPath: webpackConfig,
+            ignoreTypesImports
+        });
     }
     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 forest = cleanedEntryPoints.map((0, buildDepsGraph_1.buildDepsGraph)(deps, cleanedFilePath, notTraversePaths));
     const resolvedPaths = forest.reduce((allPaths, [_, fileNode]) => {
         if (!fileNode) {
             return [...allPaths, []];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rev-dep",
-  "version": "1.0.7",
+  "version": "1.2.0",
   "description": "Dependency debugging tool for JavaScript and TypeScript projects",
   "main": "dist/module.js",
   "bin": "bin.js",
@@ -33,8 +33,10 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "@babel/core": "^7.20.12",
     "@babel/parser": "^7.17.8",
     "@babel/template": "^7.16.7",
+    "@codeque/core": "^0.4.0",
     "@types/dedent": "^0.7.0",
     "colorette": "^2.0.16",
     "commander": "^6.1.0",
@@ -58,7 +60,7 @@
     "jest": "^26.5.3",
     "mock-fs": "^4.13.0",
     "prettier": "^2.1.2",
-    "release-it": "^14.2.1",
+    "release-it": "16.2.1",
     "typescript": "^4.6.2"
   },
   "keywords": [