rev-dep 1.0.0-alpha.2 → 1.0.0-alpha.3

package/README.md

@@ -133,9 +133,9 @@ 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_)
+- `-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_)
 - `-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 +153,9 @@ 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_)
+- `-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_)
 - `-pdc, --printDependenciesCount` - print count of entry point dependencies (_optional_)
 - `-c, --count` - print just count of found entry points (_optional_)
 
@@ -177,7 +177,7 @@ rev-dep files <entryPoint> [options]
 
 - `-wc, --webpackConfig <path>` - path to webpack config to enable webpack aliases support (_optional_)
 - `--cwd <path>` - path to a directory that should be used as a resolution root (_optional_)
-- `--rr reexportRewire <value>` - resolve actual dependencies for "export \* from" statements (_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/dist/babel/index.js

@@ -1,11 +1,13 @@
 "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 }) {
+module.exports = function plugin({ types }, { tsConfigPath = (0, utils_1.findTsConfig)() }) {
     const tsConfig = require(tsConfigPath);
     const aliases = tsConfig.compilerOptions.paths;
     const aliasesKeys = Object.keys(aliases);
@@ -164,11 +166,6 @@ module.exports = function plugin({ types }, { tsConfigPath }) {
     };
     return {
         visitor: {
-            Program: {
-                enter(_, { filename }) {
-                    //console.log(filename);
-                }
-            },
             ImportDeclaration(path, { filename, cwd }) {
                 const sourceRelative = (source) => {
                     const rel = node_path.relative(node_path.dirname(filename), source);

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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rev-dep",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.3",
   "description": "Reverse dependency resolution tool built with dependency-cruiser",
   "main": "lib/find.js",
   "bin": "bin.js",

package/dist/babel/reexport-rewire.js

@@ -1,277 +0,0 @@
-"use strict";
-/*eslint-disable @typescript-eslint/no-var-requires */
-const node_path = require('path');
-const fs = require('fs');
-const parser = require('@babel/parser');
-const template = require('@babel/template').default;
-const SKIP = Symbol('SKIP');
-module.exports = function plugin({ types }, { tsConfigPath }) {
-    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: {
-            Program: {
-                enter(_, { filename }) {
-                    //console.log(filename);
-                }
-            },
-            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/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;