rev-dep 1.3.0 → 1.5.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/babel/babelParsingOptions.d.ts

@@ -0,0 +1,5 @@
+export declare const babelParsingOptions: {
+    errorRecovery: boolean;
+    sourceType: string;
+    plugins: string[];
+};

package/dist/babel/babelParsingOptions.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.babelParsingOptions = void 0;
+exports.babelParsingOptions = {
+    errorRecovery: true,
+    sourceType: 'module',
+    plugins: [
+        'jsx',
+        'typescript',
+        'objectRestSpread',
+        'classProperties',
+        'asyncGenerators',
+        'decorators-legacy'
+    ]
+};

package/dist/babel/groupBy.d.ts

@@ -0,0 +1 @@
+export function groupBy(arr: any, property: any): any;

package/dist/babel/groupBy.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupBy = void 0;
+function groupBy(arr, property) {
+    return arr.reduce((result, obj) => {
+        const key = obj[property];
+        if (!result[key]) {
+            result[key] = [];
+        }
+        result[key].push(obj);
+        return result;
+    }, {});
+}
+exports.groupBy = groupBy;

package/dist/babel/index.js

@@ -4,19 +4,24 @@ 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 template_1 = require("./template");
 const SKIP = Symbol('SKIP');
+const babelParsingOptions_1 = require("./babelParsingOptions");
+const groupBy_1 = require("./groupBy");
 /**
  *
  * 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
+ * + 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
+ * +- group named imports from the same file
+ * + support imports from baseUrl from TS config -> relative | baseUrl | alias
+ * +  persist the original import alias
+ * + allow for a list of files to rewire
+ * + use cache for not resolved modules as well
+ * + handle type imports properly - we don't preserve the import was a type import
+ * + do not touch imports that don't need changes
  */
-module.exports = function plugin({ types }, { tsConfigPath = (0, utils_1.findTsConfig)() }) {
+module.exports = function plugin({ types }, { tsConfigPath = (0, utils_1.findTsConfig)(), cache = new Map(), includeBarrelExportFiles, excludeBarrelExportFiles = [] }) {
     const root = tsConfigPath.replace('/tsconfig.json', '');
     const tsConfigContent = fs.readFileSync(tsConfigPath).toString();
     const tsConfigContentCleaned = tsConfigContent
@@ -26,9 +31,21 @@ module.exports = function plugin({ types }, { tsConfigPath = (0, utils_1.findTsC
     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('*', '(.)+')}$`);
-    });
+    const makeRegExpFromAliasExpression = (aliasExpression) => {
+        return new RegExp(`^${aliasExpression.replace('*', '(.+)')}$`);
+    };
+    const aliasesRegexes = Object.keys(aliases).map(makeRegExpFromAliasExpression);
+    // TODO we assume that only one aliased path can exist
+    const aliasedPathRegExps = Object.values(aliases).map(([fistAliasedPath]) => makeRegExpFromAliasExpression(fistAliasedPath));
+    const interpolateAliasWithPath = (aliasKey, aliasedPathRegExp, resolvedSourcePathRelativeToBaseUrl) => {
+        const [_, ...groups] = aliasedPathRegExp.exec(resolvedSourcePathRelativeToBaseUrl);
+        const aliasParts = aliasKey.split('*');
+        const interpolatedAlias = aliasParts.reduce((mergedPath, aliasPart, idx) => {
+            var _a;
+            return `${mergedPath}${aliasPart}${(_a = groups[idx]) !== null && _a !== void 0 ? _a : ''}`;
+        }, '');
+        return interpolatedAlias;
+    };
     let baseUrlDirs = [];
     const baseUrl = tsConfig.compilerOptions.baseUrl;
     if (baseUrl) {
@@ -39,10 +56,10 @@ module.exports = function plugin({ types }, { tsConfigPath = (0, utils_1.findTsC
             .map((dirent) => dirent.name + '/');
         baseUrlDirs = dirNames;
     }
-    const cache = new Map();
     const getFile = (original, paths) => {
         if (paths.length === 0) {
-            throw new Error('Cannot resolve import ' + original);
+            console.warn('Cannot resolve import ' + original);
+            return null;
         }
         const path = paths[0];
         try {
@@ -52,18 +69,18 @@ module.exports = function plugin({ types }, { tsConfigPath = (0, utils_1.findTsC
             return getFile(original, paths.slice(1));
         }
     };
-    const isPathNotANodeModule = (path) => {
+    const shouldPathBeAnalyzed = (path) => {
         const aliasRegexIdx = aliasesRegexes.findIndex((aliasRegex) => aliasRegex.test(path));
         const isRelative = path.startsWith('./') || path.startsWith('../');
         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 getCacheKey = (identifier, filePath) => `${identifier}-${filePath}`;
     const lookup = (identifier, filePath, cwd) => {
-        const cached = cache.get(cacheKey(identifier, filePath));
+        const cached = cache.get(getCacheKey(identifier, filePath));
         if (cached) {
-            return cached;
+            return { ...cached, isCached: true };
         }
         const withExtension = /(\.ts|\.tsx)$/.test(filePath)
             ? [filePath]
@@ -77,117 +94,124 @@ module.exports = function plugin({ types }, { tsConfigPath = (0, utils_1.findTsC
                 `${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, _b, _c;
-            if (resolvedAs === null) {
-                if (types.isExportNamedDeclaration(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
-                            };
+        const fileInfo = getFile(filePath, withExtension);
+        if (!fileInfo) {
+            return { resolvedAs: null, visitedFiles: [] };
+        }
+        const [resolvedFilePath, file] = fileInfo;
+        try {
+            const ast = parser.parse(file, babelParsingOptions_1.babelParsingOptions);
+            /**
+             * {
+             *  identifier?: string,
+             *  source: string
+             * }
+             */
+            const toLookup = [];
+            let resolvedAs = null;
+            ast.program.body.forEach((declaration) => {
+                var _a, _b, _c;
+                if (resolvedAs === null) {
+                    if (types.isExportNamedDeclaration(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;
-                        });
-                        if (hasIdentifier) {
-                            resolvedAs = {
-                                type: 'named',
-                                identifier,
-                                source: filePath
-                            };
+                        else 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 if (types.isFunctionDeclaration(declaration.declaration) ||
+                            types.isClassDeclaration(declaration.declaration)) {
+                            if (declaration.declaration.id.name === identifier) {
+                                resolvedAs = {
+                                    type: 'named',
+                                    identifier,
+                                    source: filePath
+                                };
+                            }
                         }
-                    }
-                    else {
-                        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) {
-                                    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 (isPathNotANodeModule(source)) {
-                                        toLookup.push({
-                                            identifier: specifier.local.name,
-                                            source: getModulePath(source, resolvedFilePath, cwd)
-                                        });
+                        else {
+                            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) {
+                                        if (specifier.local.name === 'default' && source) {
+                                            resolvedAs = {
+                                                type: 'default',
+                                                identifier,
+                                                source: getModulePath(source, resolvedFilePath, cwd)
+                                            };
+                                        }
+                                        else if (source === undefined) {
+                                            // Here we could check if identifier comes from import statement, and if so, lookup deeper
+                                            resolvedAs = {
+                                                type: 'named',
+                                                identifier,
+                                                source: filePath
+                                            };
+                                        }
+                                        else if (shouldPathBeAnalyzed(source)) {
+                                            toLookup.push({
+                                                identifier: specifier.local.name,
+                                                source: getModulePath(source, resolvedFilePath, cwd)
+                                            });
+                                        }
                                     }
                                 }
-                            }
+                            });
+                        }
+                    }
+                    else if (types.isExportAllDeclaration(declaration) &&
+                        shouldPathBeAnalyzed(declaration.source.value)) {
+                        toLookup.push({
+                            identifier,
+                            source: getModulePath(declaration.source.value, resolvedFilePath, cwd)
                         });
                     }
                 }
-                else if (types.isExportAllDeclaration(declaration) &&
-                    isPathNotANodeModule(declaration.source.value)) {
-                    toLookup.push({
-                        identifier,
-                        source: getModulePath(declaration.source.value, resolvedFilePath, cwd)
-                    });
-                }
+            });
+            if (resolvedAs) {
+                return { resolvedAs, visitedFiles: [resolvedAs.source] };
             }
-        });
-        if (resolvedAs) {
-            return resolvedAs;
+            const nestedResult = toLookup
+                .map(({ identifier, source }) => lookup(identifier, source, cwd))
+                .filter((lookUpResult) => lookUpResult.resolvedAs !== null);
+            if (nestedResult[0]) {
+                return {
+                    resolvedAs: nestedResult[0].resolvedAs,
+                    visitedFiles: [resolvedFilePath, ...nestedResult[0].visitedFiles]
+                };
+            }
+            return { resolvedAs: null, visitedFiles: [] };
+        }
+        catch (e) {
+            console.log('Lookup parse error', filePath, e);
+            process.exit(0);
         }
-        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];
+        const alias = (_a = aliases[aliasKey]) === null || _a === void 0 ? void 0 : _a[0]; // TODO we assume that only one aliased path can exist in config
         const isAbsoluteToBaseDir = baseUrlDirs.some((baseUrlDir) => sourcePath.startsWith(baseUrlDir));
         let modulePath = '';
         if (alias) {
@@ -207,115 +231,214 @@ module.exports = function plugin({ types }, { tsConfigPath = (0, utils_1.findTsC
         }
         return modulePath;
     };
+    const getImportKind = (sourcePath) => {
+        const aliasRegexIdx = aliasesRegexes.findIndex((aliasRegex) => aliasRegex.test(sourcePath));
+        const isRelative = sourcePath.startsWith('./') || sourcePath.startsWith('../');
+        const isBaseUrlPath = baseUrlDirs.some((dir) => sourcePath.startsWith(dir));
+        if (aliasRegexIdx > -1) {
+            return 'aliased';
+        }
+        if (isRelative) {
+            return 'relative';
+        }
+        if (isBaseUrlPath) {
+            return 'baseUrl';
+        }
+        throw new Error('Could not determine import kind');
+    };
     return {
         visitor: {
             Program() {
                 // console.log('Cache size', cache.size)
             },
-            ImportDeclaration(path, { filename }) {
-                const sourceRelative = (source) => {
-                    const rel = node_path.relative(node_path.dirname(filename), source);
+            ImportDeclaration(path, state) {
+                const filename = state.filename;
+                const getImportSourceFormatted = (resolvedSourcePath, importKind) => {
+                    const baseDirPath = node_path.join(root, baseUrl);
+                    if (importKind === 'baseUrl') {
+                        const relativeToBaseUrl = node_path.relative(baseDirPath, resolvedSourcePath);
+                        return relativeToBaseUrl;
+                    }
+                    if (importKind === 'aliased') {
+                        const originalSource = path.node.source.value;
+                        const currentAliasIdx = aliasesRegexes.findIndex((aliasRegex) => aliasRegex.test(originalSource));
+                        const resolvedSourcePathRelativeToBaseUrl = resolvedSourcePath
+                            .replace(baseDirPath, '')
+                            .replace(/^\//, '');
+                        // Try to use current alias if it matches new path
+                        if (currentAliasIdx > -1) {
+                            const aliasKey = aliasesKeys[currentAliasIdx];
+                            const aliasedPathRegExp = aliasedPathRegExps[currentAliasIdx];
+                            if (aliasedPathRegExp.test(resolvedSourcePathRelativeToBaseUrl)) {
+                                return interpolateAliasWithPath(aliasKey, aliasedPathRegExp, resolvedSourcePathRelativeToBaseUrl);
+                            }
+                        }
+                        // Try finding matching alias
+                        const newMatchingAliasIndex = aliasedPathRegExps.findIndex((aliasedPathRegexp) => aliasedPathRegexp.test(resolvedSourcePathRelativeToBaseUrl));
+                        if (newMatchingAliasIndex > -1) {
+                            const aliasKey = aliasesKeys[newMatchingAliasIndex];
+                            const aliasedPathRegExp = aliasedPathRegExps[newMatchingAliasIndex];
+                            return interpolateAliasWithPath(aliasKey, aliasedPathRegExp, resolvedSourcePathRelativeToBaseUrl);
+                        }
+                    }
+                    const rel = node_path.relative(node_path.dirname(filename), resolvedSourcePath);
                     const whatever = rel.startsWith('.') ? rel : './' + rel;
                     // remove file extension
                     return whatever.replace(/\.(ts|js|tsx|jsx|cjs|mjs)$/, '');
                 };
                 const node = path.node;
+                const isTypeImport = node.importKind === 'type';
                 const source = node.source;
                 if (source.type !== 'StringLiteral') {
                     return;
                 }
-                const shouldSkip = node[SKIP] || !isPathNotANodeModule(source.value);
+                const shouldSkip = node[SKIP] || !shouldPathBeAnalyzed(source.value);
                 if (shouldSkip) {
                     return;
                 }
+                const importKind = getImportKind(source.value);
                 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 defaultSpecifier = node.specifiers.find((specifier) => specifier.type === 'ImportDefaultSpecifier' // import $$ from '$$'
+                );
+                const namespaceSpecifier = node.specifiers.find((specifier) => specifier.type === 'ImportNamespaceSpecifier' // import * as $$ from '$$'
+                );
+                const specifiers = node.specifiers.filter((specifier) => specifier.type === 'ImportSpecifier' // import { $$ } from '$$'
+                );
                 const results = specifiers.map((specifier) => {
                     const importedName = specifier.imported.name;
                     const result = lookup(importedName, modulePath, root);
-                    if (!result) {
-                        return {
+                    if (!(result === null || result === void 0 ? void 0 : result.isCached)) {
+                        const cacheKey = getCacheKey(importedName, modulePath);
+                        // console.log('resolved not cached', cacheKey, result)
+                        const originalImport = {
+                            identifier: importedName,
+                            local: specifier.local.name,
+                            source: source.value // cannot cache non absolute path
+                        };
+                        const originalImportToCache = {
                             identifier: importedName,
                             local: specifier.local.name,
-                            source: source.value
+                            source: modulePath
                         };
+                        const originalResolution = {
+                            resolvedAs: originalImportToCache,
+                            visitedFiles: []
+                        };
+                        if (!result.resolvedAs) {
+                            cache.set(cacheKey, originalResolution);
+                            return originalImport;
+                        }
+                        if (includeBarrelExportFiles &&
+                            !includeBarrelExportFiles.some((fileThatHasToBeVisited) => result.visitedFiles.includes(fileThatHasToBeVisited))) {
+                            cache.set(cacheKey, originalResolution);
+                            return originalImport;
+                        }
+                        if (excludeBarrelExportFiles.some((fileThatCannotBeVisited) => result.visitedFiles.includes(fileThatCannotBeVisited))) {
+                            cache.set(cacheKey, originalResolution);
+                            return originalImport;
+                        }
+                        cache.set(cacheKey, result);
                     }
-                    cache.set(cacheKey(importedName, modulePath), result);
                     return {
-                        ...result,
-                        source: sourceRelative(result.source),
+                        ...result.resolvedAs,
+                        source: getImportSourceFormatted(result.resolvedAs.source, importKind),
                         local: specifier.local.name
                     };
                 });
                 const defaultResult = defaultSpecifier
                     ? lookup('default', modulePath, root)
                     : null;
-                if (defaultResult) {
-                    cache.set(cacheKey('default', modulePath), defaultResult);
+                if (defaultResult && !defaultResult.isCached) {
+                    const cacheKey = getCacheKey('default', modulePath);
+                    const originalImportToCache = {
+                        source: modulePath
+                    };
+                    const originalResolution = {
+                        resolvedAs: originalImportToCache,
+                        visitedFiles: []
+                    };
+                    if (!defaultResult.resolvedAs) {
+                        cache.set(cacheKey, originalResolution);
+                    }
+                    else if (includeBarrelExportFiles &&
+                        !includeBarrelExportFiles.some((fileThatHasToBeVisited) => defaultResult.visitedFiles.includes(fileThatHasToBeVisited))) {
+                        cache.set(cacheKey, originalResolution);
+                    }
+                    else if (excludeBarrelExportFiles.some((fileThatCannotBeVisited) => defaultResult.visitedFiles.includes(fileThatCannotBeVisited))) {
+                        cache.set(cacheKey, originalResolution);
+                    }
+                    else {
+                        cache.set(cacheKey, defaultResult);
+                    }
                 }
-                const buildNamed = template(`
-          import { %%IMPORT_NAME%% } from %%SOURCE%%;
+                const buildNamed = (0, template_1.template)(`
+          import { %%IMPORT_NAME%% } from '%%SOURCE%%';
         `);
-                const buildNamedWithAlias = template(`
-          import { %%IMPORTED_NAME%% as %%LOCAL_NAME%% } from %%SOURCE%%;
+                const buildNamedWithAlias = (0, template_1.template)(`
+          import { %%IMPORTED_NAME%% as %%LOCAL_NAME%% } from '%%SOURCE%%';
         `);
-                const buildDefault = template(`
-          import %%IMPORT_NAME%% from %%SOURCE%%;
+                const buildDefault = (0, template_1.template)(`
+          import %%IMPORT_NAME%% from '%%SOURCE%%';
         `);
-                const buildNamespace = template(`
-          import * as %%IMPORT_NAME%% from %%SOURCE%%;
+                const buildNamespace = (0, template_1.template)(`
+          import * as %%IMPORT_NAME%% from '%%SOURCE%%';
         `);
-                const defaultImport = defaultResult
+                const defaultImport = (defaultResult === null || defaultResult === void 0 ? void 0 : defaultResult.resolvedAs)
                     ? [
                         buildDefault({
-                            IMPORT_NAME: types.identifier(defaultSpecifier.local.name),
-                            SOURCE: types.stringLiteral(sourceRelative(defaultResult.source))
+                            IMPORT_NAME: defaultSpecifier.local.name,
+                            SOURCE: getImportSourceFormatted(defaultResult.resolvedAs.source, importKind)
                         })
                     ]
                     : defaultSpecifier
                         ? [
                             buildDefault({
-                                IMPORT_NAME: types.identifier(defaultSpecifier.local.name),
-                                SOURCE: types.stringLiteral(source.value)
+                                IMPORT_NAME: defaultSpecifier.local.name,
+                                SOURCE: source.value
                             })
                         ]
                         : [];
                 const namespaceImport = namespaceSpecifier
                     ? [
                         buildNamespace({
-                            IMPORT_NAME: types.identifier(namespaceSpecifier.local.name),
-                            SOURCE: types.stringLiteral(source.value)
+                            IMPORT_NAME: namespaceSpecifier.local.name,
+                            SOURCE: 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 importsFromNamedGroupedBySource = Object.values((0, groupBy_1.groupBy)(results, 'source'));
+                const named = importsFromNamedGroupedBySource.map((imports) => {
+                    const source = imports[0].source;
+                    const defaultImport = imports.find(({ type }) => type === 'default');
+                    const nonDefault = imports.filter(({ type }) => type !== 'default');
+                    const defaultPart = defaultImport
+                        ? `${defaultImport.identifier}`
+                        : null;
+                    const nonDefaultPart = nonDefault.length > 0
+                        ? nonDefault
+                            .map(({ identifier, local }) => identifier !== local
+                            ? `${identifier} as ${local}`
+                            : identifier)
+                            .join(', ')
+                        : null;
+                    return `import ${isTypeImport ? 'type ' : ''}${defaultPart ? `${defaultPart}${nonDefaultPart ? ', ' : ''}` : ''}${nonDefaultPart ? `{ ${nonDefaultPart} }` : ''} from '${source}';`;
                 });
                 const newImports = [...namespaceImport, ...defaultImport, ...named].map((node) => {
-                    node[SKIP] = true;
                     return node;
                 });
-                path.replaceWithMultiple(newImports);
+                if (!state.file.metadata) {
+                    state.file.metadata = {};
+                }
+                if (!state.file.metadata[filename]) {
+                    state.file.metadata[filename] = [];
+                }
+                const modification = {
+                    modificationCode: newImports.join('\n'),
+                    start: path.node.start,
+                    end: path.node.end,
+                    loc: path.node.loc
+                };
+                state.file.metadata[filename].push(modification);
             }
         }
     };

package/dist/babel/processCodeTextModificationsArray.d.ts

@@ -0,0 +1,30 @@
+export declare type CodeModification = {
+    modificationCode: string;
+};
+export declare type CodeChange = CodeModification;
+export declare type CodeChangeWithLocation = CodeModification & MatchPosition;
+export declare type MatchPosition = {
+    start: number;
+    end: number;
+    loc: Location;
+};
+declare type ModifyCodeAsTextParams = {
+    code: string;
+    modificationCode?: string;
+    alreadyChangedCodes?: string[];
+    location: Pick<MatchPosition, 'start' | 'end'>;
+};
+declare type ProcessCodeModificationsArrayParams = {
+    code: string;
+    changes: CodeChangeWithLocation[];
+};
+export declare const regExpTest: (regExp: RegExp, text: string) => boolean;
+export declare function modifyCodeAsText({ code, modificationCode, location }: ModifyCodeAsTextParams): {
+    fileCode: string;
+    locationsChange: {
+        from: number;
+        to: number;
+    };
+};
+export declare function processTextCodeModificationsArray({ code, changes }: ProcessCodeModificationsArrayParams): string;
+export {};

package/dist/babel/processCodeTextModificationsArray.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processTextCodeModificationsArray = exports.modifyCodeAsText = exports.regExpTest = void 0;
+const regExpTest = (regExp, text) => {
+    if (!text) {
+        return false;
+    }
+    const matches = text.match(regExp);
+    return matches !== null && matches.length > 0;
+};
+exports.regExpTest = regExpTest;
+function modifyCodeAsText({ code, modificationCode, location }) {
+    let fileCode = code;
+    const codeBeforeMatch = fileCode.slice(0, location.start);
+    const codeAfterMatch = fileCode.slice(location.end);
+    const replacedCodeLength = location.end - location.start;
+    const replacementCodeLength = modificationCode.length;
+    const locationsChange = {
+        from: location.end,
+        to: location.end + replacementCodeLength - replacedCodeLength
+    };
+    fileCode = `${codeBeforeMatch}${modificationCode}${codeAfterMatch}`;
+    return { fileCode, locationsChange };
+}
+exports.modifyCodeAsText = modifyCodeAsText;
+function processTextCodeModificationsArray({ code, changes }) {
+    let modifiedCode = code;
+    /**
+     * Include only changes that are unique by it's location.
+     * Remove changes that are inside range of other changes
+     */
+    const pendingChanges = changes.filter((change, changeIdx) => !changes.some((otherChange, otherChangeIdx) => otherChangeIdx !== changeIdx &&
+        otherChange.start <= change.start &&
+        otherChange.end >= change.end &&
+        // insert changes has the same start and end to distinguish them from anchor node, that might have other changes attached
+        change.start !== change.end));
+    while (pendingChanges.length > 0) {
+        const change = pendingChanges.shift();
+        const { locationsChange, fileCode } = modifyCodeAsText({
+            code: modifiedCode,
+            modificationCode: change.modificationCode,
+            location: { start: change.start, end: change.end }
+        });
+        modifiedCode = fileCode;
+        pendingChanges.forEach((pendingChange) => {
+            if (pendingChange.start >= locationsChange.from) {
+                const diff = locationsChange.to - locationsChange.from;
+                pendingChange.end += diff;
+                pendingChange.start += diff;
+            }
+        });
+    }
+    return modifiedCode;
+}
+exports.processTextCodeModificationsArray = processTextCodeModificationsArray;

package/dist/babel/template.d.ts

@@ -0,0 +1 @@
+export declare function template(template: string): (params: Record<string, string>) => string;

package/dist/babel/template.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.template = void 0;
+function template(template) {
+    return (params) => {
+        let code = template.trim();
+        Object.entries(params).forEach(([key, value]) => {
+            code = code.replace(new RegExp(`%%${key}%%`, 'g'), value);
+        });
+        return code;
+    };
+}
+exports.template = template;

package/dist/babel/transform.d.ts

@@ -1 +1,6 @@
-export {};
+export function transform({ rootPath, inputFilePath, includeBarrelExportFiles, excludeBarrelExportFiles }: {
+    rootPath: any;
+    inputFilePath: any;
+    includeBarrelExportFiles: any;
+    excludeBarrelExportFiles: any;
+}): Promise<void>;

package/dist/babel/transform.js

@@ -1,17 +1,15 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transform = void 0;
 /*eslint-disable @typescript-eslint/no-var-requires */
 const { getFilesList } = require('@codeque/core');
 const babelCore = require('@babel/core');
+const parser = require('@babel/parser');
 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 babelParsingOptions_1 = require("./babelParsingOptions");
+const processCodeTextModificationsArray_1 = require("./processCodeTextModificationsArray");
+const transform = async ({ rootPath, inputFilePath, includeBarrelExportFiles, excludeBarrelExportFiles }) => {
     const root = path.resolve(rootPath);
     const resolvedInputFilePath = inputFilePath
         ? path.join(root, inputFilePath)
@@ -25,19 +23,34 @@ if (!rootPath) {
         });
     const errors = [];
     let progressCount = 0;
+    let cache = new Map();
     for (const filePath of filesList) {
         try {
             const fileName = path.parse(filePath).name;
+            const fileContent = fs.readFileSync(filePath).toString();
             const result = babelCore.transformFileSync(filePath, {
                 plugins: [
-                    ['./babel.js', { tsConfigPath: path.join(root, 'tsconfig.json') }]
+                    [
+                        './babel.js',
+                        {
+                            tsConfigPath: path.join(root, 'tsconfig.json'),
+                            cache,
+                            includeBarrelExportFiles,
+                            excludeBarrelExportFiles
+                        }
+                    ]
                 ],
-                parserOpts: {
-                    plugins: ['typescript', 'jsx']
-                },
+                parserOpts: babelParsingOptions_1.babelParsingOptions,
                 filename: fileName
             });
-            fs.writeFileSync(filePath, result.code);
+            const changes = result.metadata[filePath];
+            if ((changes === null || changes === void 0 ? void 0 : changes.length) > 0) {
+                const resultCode = (0, processCodeTextModificationsArray_1.processTextCodeModificationsArray)({
+                    code: fileContent,
+                    changes
+                });
+                fs.writeFileSync(filePath, resultCode);
+            }
             progressCount++;
             if (progressCount % 100 === 0) {
                 console.log(`${progressCount}+${errors.length}/${filesList.length}`);
@@ -49,4 +62,5 @@ if (!rootPath) {
     }
     console.log(errors);
     console.log(`Done: ${progressCount}/${filesList.length}; Failed: ${errors.length}`);
-})();
+};
+exports.transform = transform;

package/dist/babel/transformCli.d.ts

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

package/dist/babel/transformCli.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rootPath = process.argv[2];
+const inputFilePath = process.argv[3];
+const transform_1 = require("./transform");
+if (!rootPath) {
+    console.error('Please provide correct transformation root');
+    process.exit(1);
+}
+const run = async () => {
+    const startTime = new Date().getTime();
+    await (0, transform_1.transform)({
+        rootPath,
+        inputFilePath
+    });
+    console.log('Operation time: ', (new Date().getTime() - startTime) / 1000);
+};
+run();

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.5.0",
   "description": "Dependency debugging tool for JavaScript and TypeScript projects",
   "main": "dist/module.js",
   "bin": "bin.js",