rev-dep 1.0.0-alpha.1 → 1.0.0-alpha.4

package/README.md

@@ -133,9 +133,8 @@ rev-dep resolve <filePath> [entryPoints...] [options]
 
 - `-wc, --webpackConfig <path>` - path to webpack config to enable webpack aliases support (_optional_)
 - `--cwd <path>` - path to a directory that should be used as a resolution root (_optional_)
-- `--rr reexportRewire <value>` - resolve actual dependencies for "export \* from" statements (_optional_)
-- `-i include <globs...>` - A list of globs to determine files included in entry points search (_optional_)
-- `-e exclude <globs...>` - A list of globs to determine files excluded in entry points search (_optional_)
+- `-i --include <globs...>` - A list of globs to determine files included in entry points search (_optional_)
+- `-e --exclude <globs...>` - A list of globs to determine files excluded in entry points search (_optional_)
 - `-cs, --compactSummary` - print a compact summary of reverse resolution with a count of found paths (_optional_)
 - `-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_)
 
@@ -153,9 +152,8 @@ rev-dep entry-points [options]
 
 - `-wc, --webpackConfig <path>` - path to webpack config to enable webpack aliases support (_optional_)
 - `--cwd <path>` - path to a directory that should be used as a resolution root (_optional_)
-- `--rr reexportRewire <value>` - resolve actual dependencies for "export \* from" statements (_optional_)
-- `-i include <globs...>` - A list of globs to determine files included in entry points search (_optional_)
-- `-e exclude <globs...>` - A list of globs to determine files excluded in entry points search (_optional_)
+- `-i --include <globs...>` - A list of globs to determine files included in entry points search (_optional_)
+- `-e --exclude <globs...>` - A list of globs to determine files excluded in entry points search (_optional_)
 - `-pdc, --printDependenciesCount` - print count of entry point dependencies (_optional_)
 - `-c, --count` - print just count of found entry points (_optional_)
 
@@ -177,7 +175,6 @@ 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_)
-- `--rr reexportRewire <value>` - resolve actual dependencies for "export \* from" statements (_optional_)
 - `-c, --count` - print only count of entry point dependencies (_optional_)
 
 ### Command `docs`

package/babel.js

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

package/dist/babel/index.js

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

package/dist/cli/commonOptions.js

@@ -11,14 +11,14 @@ exports.cwdOption = [
     process.cwd()
 ];
 exports.reexportRewireOption = [
-    '--rr reexportRewire <value>',
+    '-rr --reexportRewire <value>',
     'resolve actual dependencies for "export * from" statements'
 ];
 exports.includeOption = [
-    '-i include <globs...>',
+    '-i --include <globs...>',
     'A list of globs to determine files included in entry points search'
 ];
 exports.excludeOption = [
-    '-e exclude <globs...>',
+    '-e --exclude <globs...>',
     'A list of globs to determine files excluded in entry points search'
 ];

package/dist/cli/entryPoints/index.js

@@ -10,7 +10,7 @@ function createEntryPoints(program) {
         .description('Print list of entry points in current directory')
         .option(...commonOptions_1.webpackConfigOption)
         .option(...commonOptions_1.cwdOption)
-        .option(...commonOptions_1.reexportRewireOption)
+        // .option(...reexportRewireOption)
         .option(...commonOptions_1.includeOption)
         .option(...commonOptions_1.excludeOption)
         .option('-pdc, --printDependenciesCount', 'print count of entry point dependencies', false)

package/dist/cli/files/index.js

@@ -11,7 +11,7 @@ function createFiles(program) {
     })
         .option(...commonOptions_1.webpackConfigOption)
         .option(...commonOptions_1.cwdOption)
-        .option(...commonOptions_1.reexportRewireOption)
+        // .option(...reexportRewireOption)
         .option('-c, --count', 'print only count of entry point dependencies', false)
         .action(async (entryPoint, data) => {
         const { webpackConfig: webpackConfigPath, cwd, count } = data;

package/dist/cli/resolve/index.js

@@ -13,16 +13,15 @@ function createResolve(program) {
     })
         .option(...commonOptions_1.webpackConfigOption)
         .option(...commonOptions_1.cwdOption)
-        .option(...commonOptions_1.reexportRewireOption)
+        // .option(...reexportRewireOption)
         .option(...commonOptions_1.includeOption)
         .option(...commonOptions_1.excludeOption)
         .option('-cs, --compactSummary', 'print a compact summary of reverse resolution with a count of found paths')
         .option('-a, --all', 'finds all paths combination of a given dependency. Might work very slow or crash for some projects due to heavy usage of RAM', false)
         .action(async (filePath, entryPoints, data) => {
         const { compactSummary, webpackConfig, all, cwd, exclude, include } = data;
-        const sanitizedEntryPoints = (0, utils_1.sanitizeUserEntryPoints)(entryPoints);
         const [results, resolveEntryPoints] = await (0, find_1.resolve)({
-            entryPoints: sanitizedEntryPoints,
+            entryPoints,
             filePath,
             webpackConfig,
             all,

package/dist/lib/cleanupDpdmDeps.js

@@ -12,7 +12,7 @@ const cleanupDpdmDeps = (deps) => {
             !id.includes('node_modules') &&
             dependencies !== null) {
             newDeps[id] = dependencies
-                .filter(({ id }) => id && !id.includes('node_modules'))
+                .filter(({ id }) => id && !id.includes('node_modules') && !(0, is_builtin_module_1.default)(id))
                 .map(({ id, request }) => ({
                 id,
                 request

package/dist/lib/find.js

@@ -24,7 +24,8 @@ const resolve = async ({ entryPoints: _entryPoints, filePath, webpackConfig, cwd
     let deps, entryPoints;
     if (_entryPoints.length > 0) {
         entryPoints = _entryPoints;
-        deps = await (0, getDepsTree_1.getDepsTree)(cwd, entryPoints, webpackConfig);
+        const sanitizedEntryPoints = (0, utils_1.sanitizeUserEntryPoints)(entryPoints);
+        deps = await (0, getDepsTree_1.getDepsTree)(cwd, sanitizedEntryPoints, webpackConfig);
     }
     else {
         ;

package/dist/lib/getEntryPoints.js

@@ -10,6 +10,7 @@ const promises_1 = __importDefault(require("fs/promises"));
 const utils_1 = require("./utils");
 const getDepsTree_1 = require("./getDepsTree");
 const ignore_1 = __importDefault(require("ignore"));
+const glob_escape_1 = __importDefault(require("glob-escape"));
 const getDirectoriesForEntryPointsSearch = async (dir) => {
     const entries = await promises_1.default.readdir(dir);
     const directories = await (0, utils_1.asyncFilter)(entries, async (pathName) => {
@@ -48,7 +49,7 @@ const getEntryPoints = async ({ cwd, exclude, include, webpackConfigPath }) => {
     const dirs = await (0, exports.getDirectoriesForEntryPointsSearch)(cwd);
     const globs = dirs
         .map((dirName) => path_1.default.relative(cwd, dirName))
-        .map((dirName) => `${dirName}/*`);
+        .map((dirName) => `${(0, glob_escape_1.default)(dirName)}/*`);
     const globsWithRoot = ['*', ...globs];
     const depsTree = await (0, getDepsTree_1.getDepsTree)(cwd, globsWithRoot, webpackConfigPath);
     const possibleEntryPoints = (0, exports.findEntryPointsInDepsTree)(depsTree, exclude, include);

package/dist/lib/utils.js

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

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "rev-dep",
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0-alpha.4",
   "description": "Reverse dependency resolution tool built with dependency-cruiser",
   "main": "lib/find.js",
   "bin": "bin.js",
   "files": [
     "dist/**",
     "lib/**",
-    "bin.js"
+    "bin.js",
+    "babel.js"
   ],
   "author": "Jakub Mazurek @jayu",
   "license": "MIT",
@@ -31,6 +32,8 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "@babel/parser": "^7.17.8",
+    "@babel/template": "^7.16.7",
     "@types/dedent": "^0.7.0",
     "colorette": "^2.0.16",
     "commander": "^6.1.0",
@@ -43,6 +46,7 @@
     "minimatch": "^5.0.1"
   },
   "devDependencies": {
+    "@babel/types": "^7.17.0",
     "@typescript-eslint/eslint-plugin": "^5.16.0",
     "@typescript-eslint/parser": "^5.16.0",
     "eslint": "^7.11.0",

package/dist/lib/getMaxDepthInGrapth.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMaxDepth = void 0;
-const getMaxDepth = (depth = 1, path = [], vertices = new Map()) => {
-    return (tree) => {
-        const depthFromCache = vertices.get(tree.path);
-        if (depthFromCache) {
-            return depthFromCache;
-        }
-        const newPath = [...path, tree.path];
-        if (tree.children.length === 0) {
-            return [depth, newPath];
-        }
-        const results = tree.children.map((0, exports.getMaxDepth)(depth + 1, newPath, vertices));
-        const maxChildDepth = Math.max(...results.map(([depth]) => depth));
-        const itemWithMaxDepth = results.find(([depth]) => depth === maxChildDepth);
-        vertices.set(tree.path, itemWithMaxDepth);
-        return itemWithMaxDepth;
-    };
-};
-exports.getMaxDepth = getMaxDepth;