rev-dep 1.3.0 → 1.4.0

package/README.md

@@ -378,12 +378,12 @@ Checks if a filePath is required from entryPoint(s) and prints the resolution pa
 #### Usage
 
 ```sh
-rev-dep resolve <filePath> [entryPoints...] [options]
+rev-dep resolve <filePathOrNodeModuleName> [entryPoints...] [options]
 ```
 
 #### Arguments
 
-- `filePath` - Path to a file that should be resolved in entry points (**required**)
+- `filePathOrNodeModuleName` - undefined (**required**)
 - `entryPoints...` - List of entry points to look for file (_optional_)
 
 #### Options
@@ -395,6 +395,7 @@ rev-dep resolve <filePath> [entryPoints...] [options]
 - `-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_)
+- `-inm --includeNodeModules` - Whether to include node modules in dependency graph. Has to be provided to resolve node module. (_optional_)
 - `-iti --ignoreTypesImports` - Use this flag to not follow type imports when resolving modules (_optional_)
 
 ### Command `entry-points`

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

@@ -1,9 +1,9 @@
 import { InputParams } from './types';
 declare type Results = Array<Array<Array<string>>>;
-export declare function formatResults({ results, filePath, entryPoints, compactSummary }: {
+export declare function formatResults({ results, filePathOrNodeModuleName, entryPoints, compactSummary }: {
     results: Results;
     compactSummary: InputParams['compactSummary'];
     entryPoints: string[];
-    filePath: string;
+    filePathOrNodeModuleName: string;
 }): string;
 export {};

package/dist/cli/resolve/formatResults.js

@@ -29,11 +29,11 @@ const pathToString = (str, filePath, indentation) => {
     return `${str ? `${str}\n` : ''}${' '.repeat(indentation)} ➞ ${filePath}`;
 };
 const join = (...args) => args.join(' ') + '\n';
-function formatResults({ results, filePath, entryPoints, compactSummary }) {
+function formatResults({ results, filePathOrNodeModuleName, entryPoints, compactSummary }) {
     let formatted = '';
     const hasAnyResults = results.some((paths) => paths.length > 0);
     if (!hasAnyResults) {
-        formatted = join('No results found for', filePath, 'in the following entry points list:\n' + entryPoints.join('\n'));
+        formatted = join('No results found for', filePathOrNodeModuleName, 'in the following entry points list:\n' + entryPoints.join('\n'));
         return formatted;
     }
     if (compactSummary) {

package/dist/cli/resolve/index.js

@@ -6,7 +6,7 @@ const utils_1 = require("../../lib/utils");
 const commonOptions_1 = require("../commonOptions");
 function createResolve(program) {
     program
-        .command('resolve <filePath> [entryPoints...]')
+        .command('resolve <filePathOrNodeModuleName> [entryPoints...]')
         .description('Checks if a filePath is required from entryPoint(s) and prints the resolution path', {
         filePath: 'Path to a file that should be resolved in entry points',
         'entryPoints...': 'List of entry points to look for file'
@@ -19,25 +19,27 @@ function createResolve(program) {
         .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('-inm --includeNodeModules', 'Whether to include node modules in dependency graph. Has to be provided to resolve node module.', true)
         .option(...commonOptions_1.ignoreTypesImports)
-        .action(async (filePath, entryPoints, data) => {
-        const { compactSummary, webpackConfig, all, cwd, exclude, include, notTraversePaths, ignoreTypesImports } = data;
+        .action(async (filePathOrNodeModuleName, entryPoints, data) => {
+        const { compactSummary, webpackConfig, all, cwd, exclude, include, notTraversePaths, ignoreTypesImports, includeNodeModules } = data;
         const [results, resolveEntryPoints] = await (0, resolve_1.resolve)({
             entryPoints,
-            filePath,
+            filePathOrNodeModuleName,
             webpackConfig,
             all,
             cwd: (0, utils_1.resolvePath)(cwd),
             exclude,
             include,
             notTraversePaths,
-            ignoreTypesImports
+            ignoreTypesImports,
+            includeNodeModules
         });
         const formatted = (0, formatResults_1.formatResults)({
             results,
             entryPoints: resolveEntryPoints,
             compactSummary,
-            filePath
+            filePathOrNodeModuleName
         });
         console.log(formatted);
     });

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

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

package/dist/lib/buildDepsGraph.d.ts

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

package/dist/lib/buildDepsGraph.js

@@ -5,9 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildDepsGraph = void 0;
 const minimatch_1 = __importDefault(require("minimatch"));
-const buildDepsGraph = (deps, filePath, notTraversePath) => (entryPoint) => {
+const buildDepsGraph = (deps, filePathOrNodeModuleName, notTraversePath) => (entryPoint) => {
     const vertices = new Map();
-    let fileNode = null;
+    let fileOrNodeModuleNode = null;
     const inner = (path, visited = new Set(), depth = 1, parent = null) => {
         const vertex = vertices.get(path);
         if (vertex) {
@@ -39,11 +39,11 @@ const buildDepsGraph = (deps, filePath, notTraversePath) => (entryPoint) => {
             !(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) {
-            fileNode = node;
+        if (path === filePathOrNodeModuleName) {
+            fileOrNodeModuleNode = node;
         }
         return node;
     };
-    return [inner(entryPoint), fileNode, vertices];
+    return [inner(entryPoint), fileOrNodeModuleNode, vertices];
 };
 exports.buildDepsGraph = buildDepsGraph;

package/dist/lib/cleanupDpdmDeps.js

@@ -8,6 +8,7 @@ const is_builtin_module_1 = __importDefault(require("is-builtin-module"));
 const cleanupDpdmDeps = (deps, includeNodeModules = false) => {
     const newDeps = {};
     Object.entries(deps).forEach(([id, dependencies]) => {
+        const nodeModules = [];
         if (!(0, is_builtin_module_1.default)(id) &&
             !id.includes('node_modules') &&
             dependencies !== null) {
@@ -15,10 +16,22 @@ const cleanupDpdmDeps = (deps, includeNodeModules = false) => {
                 .filter(({ id }) => id &&
                 (includeNodeModules || !id.includes('node_modules')) &&
                 !(0, is_builtin_module_1.default)(id))
-                .map(({ id, request }) => ({
-                id,
-                request
-            }));
+                .map(({ id, request }) => {
+                const shouldAddNodeModule = includeNodeModules && (id === null || id === void 0 ? void 0 : id.includes('node_modules'));
+                const idToAdd = shouldAddNodeModule ? request : id;
+                if (shouldAddNodeModule && idToAdd) {
+                    nodeModules.push(idToAdd);
+                }
+                return {
+                    id: idToAdd,
+                    request
+                };
+            });
+        }
+        if (includeNodeModules) {
+            nodeModules.forEach((nodeModuleName) => {
+                newDeps[nodeModuleName] = [];
+            });
         }
     });
     return newDeps;

package/dist/lib/getEntryPoints.d.ts

@@ -8,10 +8,11 @@ export declare const findEntryPointsInDepsTreeAndFilterOutIgnoredFiles: ({ cwd,
     include: string[] | undefined;
     cwd: string;
 }) => Promise<string[]>;
-export declare const getEntryPoints: ({ cwd, exclude, include, webpackConfigPath, ignoreTypesImports }: {
+export declare const getEntryPoints: ({ cwd, exclude, include, webpackConfigPath, ignoreTypesImports, includeNodeModules }: {
     cwd: string;
     exclude?: string[] | undefined;
     include?: string[] | undefined;
     webpackConfigPath?: string | undefined;
     ignoreTypesImports?: boolean | undefined;
+    includeNodeModules?: boolean | undefined;
 }) => Promise<[string[], MinimalDependencyTree]>;

package/dist/lib/getEntryPoints.js

@@ -70,13 +70,13 @@ const findEntryPointsInDepsTreeAndFilterOutIgnoredFiles = async ({ cwd, depsTree
     return entryPointsWithoutIgnoredFiles;
 };
 exports.findEntryPointsInDepsTreeAndFilterOutIgnoredFiles = findEntryPointsInDepsTreeAndFilterOutIgnoredFiles;
-const getEntryPoints = async ({ cwd, exclude, include, webpackConfigPath, ignoreTypesImports }) => {
+const getEntryPoints = async ({ cwd, exclude, include, webpackConfigPath, ignoreTypesImports, includeNodeModules }) => {
     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 depsTree = await (0, getDepsTree_1.getDepsTree)(cwd, globsWithRoot, webpackConfigPath, ignoreTypesImports, includeNodeModules);
     const entryPointsWithoutIgnoredFiles = await (0, exports.findEntryPointsInDepsTreeAndFilterOutIgnoredFiles)({ cwd, include, exclude, depsTree });
     return [entryPointsWithoutIgnoredFiles, depsTree];
 };

package/dist/lib/resolve.d.ts

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

package/dist/lib/resolve.js

@@ -27,12 +27,12 @@ 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, notTraversePaths, ignoreTypesImports }) => {
+const resolve = async ({ entryPoints: _entryPoints, filePathOrNodeModuleName, webpackConfig, cwd = process.cwd(), all, include, exclude, notTraversePaths, ignoreTypesImports, includeNodeModules }) => {
     let deps, entryPoints;
     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, ignoreTypesImports);
+        deps = await (0, getDepsTree_1.getDepsTree)(cwd, sanitizedEntryPoints, webpackConfig, ignoreTypesImports, includeNodeModules);
     }
     else {
         ;
@@ -41,12 +41,13 @@ const resolve = async ({ entryPoints: _entryPoints, filePath, webpackConfig, cwd
             exclude,
             include,
             webpackConfigPath: webpackConfig,
-            ignoreTypesImports
+            ignoreTypesImports,
+            includeNodeModules
         });
     }
     const cleanedEntryPoints = entryPoints.map(utils_1.removeInitialDot);
-    const cleanedFilePath = (0, utils_1.removeInitialDot)(filePath);
-    const forest = cleanedEntryPoints.map((0, buildDepsGraph_1.buildDepsGraph)(deps, cleanedFilePath, notTraversePaths));
+    const cleanedFilePathOrNodeModuleName = (0, utils_1.removeInitialDot)(filePathOrNodeModuleName);
+    const forest = cleanedEntryPoints.map((0, buildDepsGraph_1.buildDepsGraph)(deps, cleanedFilePathOrNodeModuleName, notTraversePaths));
     const resolvedPaths = forest.reduce((allPaths, [_, fileNode]) => {
         if (!fileNode) {
             return [...allPaths, []];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rev-dep",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Dependency debugging tool for JavaScript and TypeScript projects",
   "main": "dist/module.js",
   "bin": "bin.js",