rev-dep 1.1.0 → 1.3.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,28 @@ 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 `node-modules`
+
+Get list of node modules required by entry point
+
+#### Usage
+
+```sh
+rev-dep node-modules <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_)
+- `-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/createCommands.js

@@ -8,10 +8,12 @@ const resolve_1 = __importDefault(require("./resolve"));
 const docs_1 = __importDefault(require("./docs"));
 const entryPoints_1 = __importDefault(require("./entryPoints"));
 const files_1 = __importDefault(require("./files"));
+const nodeModules_1 = __importDefault(require("./nodeModules"));
 function createCommands(program) {
     (0, resolve_1.default)(program);
     (0, entryPoints_1.default)(program);
     (0, files_1.default)(program);
+    (0, nodeModules_1.default)(program);
     (0, docs_1.default)(program);
 }
 exports.createCommands = createCommands;

package/dist/cli/entryPoints/index.js

@@ -15,13 +15,15 @@ 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) {

package/dist/cli/files/index.js

@@ -1,8 +1,7 @@
 "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");
+const getFilesForEntryPoint_1 = require("../../lib/getFilesForEntryPoint");
 function createFiles(program) {
     program
         .command('files <entryPoint>')
@@ -13,11 +12,15 @@ 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 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);
+        const { webpackConfig: webpackConfigPath, cwd, count, ignoreTypesImports } = data;
+        const filePaths = await (0, getFilesForEntryPoint_1.getFilesForEntryPoint)({
+            cwd,
+            entryPoint,
+            webpackConfigPath,
+            ignoreTypesImports
+        });
         if (filePaths.length === 0) {
             console.log('No results found');
             return;

package/dist/cli/nodeModules/index.d.ts

@@ -0,0 +1,2 @@
+import commander from 'commander';
+export default function createNodeModules(program: commander.Command): void;

package/dist/cli/nodeModules/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commonOptions_1 = require("../commonOptions");
+const getNodeModulesForEntryPoint_1 = require("../../lib/getNodeModulesForEntryPoint");
+function createNodeModules(program) {
+    program
+        .command('node-modules <entryPoint>')
+        .description('Get list of node modules required by entry point', {
+        entryPoint: 'Path to entry point'
+    })
+        .option(...commonOptions_1.webpackConfigOption)
+        .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, ignoreTypesImports } = data;
+        const uniqueNodeModuleImports = await (0, getNodeModulesForEntryPoint_1.getNodeModulesForEntryPoint)({
+            cwd,
+            entryPoint,
+            webpackConfigPath,
+            ignoreTypesImports
+        });
+        if (uniqueNodeModuleImports.length === 0) {
+            console.log('No results found');
+            return;
+        }
+        if (count) {
+            console.log(uniqueNodeModuleImports.length);
+        }
+        else {
+            uniqueNodeModuleImports.forEach((nodeModuleName) => console.log(nodeModuleName));
+        }
+    });
+}
+exports.default = createNodeModules;

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

@@ -0,0 +1,3 @@
+export declare type InputParams = {
+    count?: boolean;
+};

package/dist/cli/nodeModules/types.js

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

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/cleanupDpdmDeps.d.ts

@@ -1,3 +1,3 @@
 import { DependencyTree } from 'dpdm';
 import { MinimalDependencyTree } from './types';
-export declare const cleanupDpdmDeps: (deps: MinimalDependencyTree | DependencyTree) => MinimalDependencyTree;
+export declare const cleanupDpdmDeps: (deps: MinimalDependencyTree | DependencyTree, includeNodeModules?: boolean) => MinimalDependencyTree;

package/dist/lib/cleanupDpdmDeps.js

@@ -5,14 +5,16 @@ var __importDefault = (this && this.__importDefault) || function (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 cleanupDpdmDeps = (deps, includeNodeModules = false) => {
     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') && !(0, is_builtin_module_1.default)(id))
+                .filter(({ id }) => id &&
+                (includeNodeModules || !id.includes('node_modules')) &&
+                !(0, is_builtin_module_1.default)(id))
                 .map(({ id, request }) => ({
                 id,
                 request

package/dist/lib/getDepsTree.d.ts

@@ -1 +1 @@
-export declare function getDepsTree(cwd: string, entryPoints: string[], webpackConfigPath?: string, ignoreTypesImports?: boolean): Promise<import("./types").MinimalDependencyTree>;
+export declare function getDepsTree(cwd: string, entryPoints: string[], webpackConfigPath?: string, ignoreTypesImports?: boolean, includeNodeModules?: 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, ignoreTypesImports = false) {
+async function getDepsTree(cwd, entryPoints, webpackConfigPath, ignoreTypesImports = false, includeNodeModules = false) {
     let deps;
     if (webpackConfigPath) {
         deps = (0, getDepsSetWebpack_1.getDepsSetWebpack)(entryPoints, webpackConfigPath, cwd);
@@ -16,7 +16,7 @@ async function getDepsTree(cwd, entryPoints, webpackConfigPath, ignoreTypesImpor
         deps = (0, cleanupDpdmDeps_1.cleanupDpdmDeps)(await (0, dpdm_1.parseDependencyTree)(entryPoints, {
             context: cwd,
             transform: ignoreTypesImports
-        }));
+        }), includeNodeModules);
         process.cwd = oldProcessCwd;
     }
     return deps;

package/dist/lib/getEntryPoints.d.ts

@@ -1,6 +1,13 @@
 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 prepareIgnoreInstance: (cwd: string) => Promise<import("ignore").Ignore>;
+export declare const findEntryPointsInDepsTreeAndFilterOutIgnoredFiles: ({ cwd, depsTree, include, exclude }: {
+    depsTree: MinimalDependencyTree;
+    exclude: string[] | undefined;
+    include: string[] | undefined;
+    cwd: string;
+}) => Promise<string[]>;
 export declare const getEntryPoints: ({ cwd, exclude, include, webpackConfigPath, ignoreTypesImports }: {
     cwd: string;
     exclude?: string[] | undefined;

package/dist/lib/getEntryPoints.js

@@ -3,7 +3,7 @@ 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;
+exports.getEntryPoints = exports.findEntryPointsInDepsTreeAndFilterOutIgnoredFiles = exports.prepareIgnoreInstance = 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"));
@@ -45,14 +45,7 @@ const findEntryPointsInDepsTree = (deps, exclude = [], include = undefined) => {
         .sort();
 };
 exports.findEntryPointsInDepsTree = findEntryPointsInDepsTree;
-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, ignoreTypesImports);
-    const possibleEntryPoints = (0, exports.findEntryPointsInDepsTree)(depsTree, exclude, include);
+const prepareIgnoreInstance = async (cwd) => {
     const ignoreInstance = (0, ignore_1.default)();
     let gitignore = '';
     try {
@@ -67,6 +60,24 @@ const getEntryPoints = async ({ cwd, exclude, include, webpackConfigPath, ignore
         e;
     }
     ignoreInstance.add(gitignore);
-    return [ignoreInstance.filter(possibleEntryPoints), depsTree];
+    return ignoreInstance;
+};
+exports.prepareIgnoreInstance = prepareIgnoreInstance;
+const findEntryPointsInDepsTreeAndFilterOutIgnoredFiles = async ({ cwd, depsTree, include = undefined, exclude = [] }) => {
+    const possibleEntryPoints = (0, exports.findEntryPointsInDepsTree)(depsTree, exclude, include).sort();
+    const ignoreInstance = await (0, exports.prepareIgnoreInstance)(cwd);
+    const entryPointsWithoutIgnoredFiles = ignoreInstance.filter(possibleEntryPoints);
+    return entryPointsWithoutIgnoredFiles;
+};
+exports.findEntryPointsInDepsTreeAndFilterOutIgnoredFiles = findEntryPointsInDepsTreeAndFilterOutIgnoredFiles;
+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, ignoreTypesImports);
+    const entryPointsWithoutIgnoredFiles = await (0, exports.findEntryPointsInDepsTreeAndFilterOutIgnoredFiles)({ cwd, include, exclude, depsTree });
+    return [entryPointsWithoutIgnoredFiles, depsTree];
 };
 exports.getEntryPoints = getEntryPoints;

package/dist/lib/getFilesForEntryPoint.d.ts

@@ -0,0 +1,8 @@
+import { MinimalDependencyTree } from './types';
+export declare function getFilesForEntryPoint({ cwd, entryPoint, webpackConfigPath, ignoreTypesImports, depsTree: initDepsTree }: {
+    cwd: string;
+    entryPoint: string;
+    ignoreTypesImports: boolean;
+    webpackConfigPath?: string;
+    depsTree?: MinimalDependencyTree;
+}): Promise<string[]>;

package/dist/lib/getFilesForEntryPoint.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFilesForEntryPoint = void 0;
+const utils_1 = require("./utils");
+const getDepsTree_1 = require("./getDepsTree");
+async function getFilesForEntryPoint({ cwd, entryPoint, webpackConfigPath, ignoreTypesImports, depsTree: initDepsTree }) {
+    const sanitizedEntryPoints = (0, utils_1.sanitizeUserEntryPoints)([entryPoint]);
+    const depsTree = initDepsTree !== null && initDepsTree !== void 0 ? initDepsTree : (await (0, getDepsTree_1.getDepsTree)((0, utils_1.resolvePath)(cwd), sanitizedEntryPoints, webpackConfigPath, ignoreTypesImports));
+    const filePaths = Object.keys(depsTree);
+    return filePaths.sort();
+}
+exports.getFilesForEntryPoint = getFilesForEntryPoint;

package/dist/lib/getNodeModulesForEntryPoint.d.ts

@@ -0,0 +1,8 @@
+import { MinimalDependencyTree } from './types';
+export declare function getNodeModulesForEntryPoint({ cwd, entryPoint, webpackConfigPath, ignoreTypesImports, depsTree: initDepsTree }: {
+    cwd: string;
+    entryPoint: string;
+    ignoreTypesImports: boolean;
+    webpackConfigPath?: string;
+    depsTree?: MinimalDependencyTree;
+}): Promise<(string | undefined)[]>;

package/dist/lib/getNodeModulesForEntryPoint.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNodeModulesForEntryPoint = void 0;
+const utils_1 = require("./utils");
+const getDepsTree_1 = require("./getDepsTree");
+async function getNodeModulesForEntryPoint({ cwd, entryPoint, webpackConfigPath, ignoreTypesImports, depsTree: initDepsTree }) {
+    const sanitizedEntryPoints = (0, utils_1.sanitizeUserEntryPoints)([entryPoint]);
+    const depsTree = initDepsTree !== null && initDepsTree !== void 0 ? initDepsTree : (await (0, getDepsTree_1.getDepsTree)((0, utils_1.resolvePath)(cwd), sanitizedEntryPoints, webpackConfigPath, ignoreTypesImports, true));
+    const nodeModuleImports = Object.values(depsTree)
+        .filter((depsTree) => depsTree !== null)
+        .flat(2)
+        .filter((dep) => (dep === null || dep === void 0 ? void 0 : dep.id) && dep.id.includes('node_modules'))
+        .map((dep) => dep === null || dep === void 0 ? void 0 : dep.request)
+        .filter(Boolean);
+    const uniqueNodeModuleImports = [...new Set(nodeModuleImports)].sort();
+    return uniqueNodeModuleImports;
+}
+exports.getNodeModulesForEntryPoint = getNodeModulesForEntryPoint;

package/dist/lib/resolve.d.ts

@@ -1,3 +1,4 @@
+import { MinimalDependencyTree } from './types';
 declare type ResolveParams = {
     entryPoints?: string[];
     filePath: string;
@@ -9,5 +10,5 @@ declare type ResolveParams = {
     notTraversePaths?: string[];
     ignoreTypesImports?: boolean;
 };
-export declare const resolve: ({ entryPoints: _entryPoints, filePath, webpackConfig, cwd, all, include, exclude, notTraversePaths, ignoreTypesImports }: ResolveParams) => Promise<[string[][][], string[]]>;
+export declare const resolve: ({ entryPoints: _entryPoints, filePath, webpackConfig, cwd, all, include, exclude, notTraversePaths, ignoreTypesImports }: ResolveParams) => Promise<[string[][][], string[], MinimalDependencyTree]>;
 export {};

package/dist/lib/resolve.js

@@ -54,6 +54,6 @@ const resolve = async ({ entryPoints: _entryPoints, filePath, webpackConfig, cwd
         const pathsForTree = resolvePathsToRoot(fileNode, all);
         return [...allPaths, pathsForTree];
     }, []);
-    return [resolvedPaths, entryPoints];
+    return [resolvedPaths, entryPoints, deps];
 };
 exports.resolve = resolve;

package/dist/lib/types.d.ts

@@ -1,10 +1,12 @@
-import { Dependency } from 'dpdm';
 export declare type Node = {
     path: string;
     children: Node[];
     parents: Node[];
 };
-export declare type MinimalDependency = Pick<Dependency, 'id' | 'request'>;
+export declare type MinimalDependency = {
+    id: string | null;
+    request: string;
+};
 export declare type MinimalDependencyTree = {
     [key: string]: readonly MinimalDependency[] | null;
 };

package/dist/module.d.ts

@@ -1,2 +1,5 @@
 export { resolve } from './lib/resolve';
-export { getEntryPoints } from './lib/getEntryPoints';
+export { getEntryPoints, findEntryPointsInDepsTreeAndFilterOutIgnoredFiles, findEntryPointsInDepsTree } from './lib/getEntryPoints';
+export { getFilesForEntryPoint } from './lib/getFilesForEntryPoint';
+export { getNodeModulesForEntryPoint } from './lib/getNodeModulesForEntryPoint';
+export * from './lib/types';

package/dist/module.js

@@ -1,7 +1,28 @@
 "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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEntryPoints = exports.resolve = void 0;
+exports.getNodeModulesForEntryPoint = exports.getFilesForEntryPoint = exports.findEntryPointsInDepsTree = exports.findEntryPointsInDepsTreeAndFilterOutIgnoredFiles = exports.getEntryPoints = exports.resolve = void 0;
 var resolve_1 = require("./lib/resolve");
 Object.defineProperty(exports, "resolve", { enumerable: true, get: function () { return resolve_1.resolve; } });
 var getEntryPoints_1 = require("./lib/getEntryPoints");
 Object.defineProperty(exports, "getEntryPoints", { enumerable: true, get: function () { return getEntryPoints_1.getEntryPoints; } });
+Object.defineProperty(exports, "findEntryPointsInDepsTreeAndFilterOutIgnoredFiles", { enumerable: true, get: function () { return getEntryPoints_1.findEntryPointsInDepsTreeAndFilterOutIgnoredFiles; } });
+Object.defineProperty(exports, "findEntryPointsInDepsTree", { enumerable: true, get: function () { return getEntryPoints_1.findEntryPointsInDepsTree; } });
+var getFilesForEntryPoint_1 = require("./lib/getFilesForEntryPoint");
+Object.defineProperty(exports, "getFilesForEntryPoint", { enumerable: true, get: function () { return getFilesForEntryPoint_1.getFilesForEntryPoint; } });
+var getNodeModulesForEntryPoint_1 = require("./lib/getNodeModulesForEntryPoint");
+Object.defineProperty(exports, "getNodeModulesForEntryPoint", { enumerable: true, get: function () { return getNodeModulesForEntryPoint_1.getNodeModulesForEntryPoint; } });
+__exportStar(require("./lib/types"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rev-dep",
-  "version": "1.1.0",
+  "version": "1.3.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": [

package/dist/supersupersupersupersupersupersupersupersupersupersupersupersupersupersupersupersupersupersupersupersupersupersupersupersupersupersupersuperLongPath.ts

@@ -1 +0,0 @@
-const a = 5