rev-dep 0.3.0 → 1.0.0-alpha.2

package/README.md

@@ -81,14 +81,14 @@ Available options are
 #### `find` Function
 
 ```js
-import { find } from 'rev-dep'
+import { find } from "rev-dep";
 
 const path = find({
-  entryPoints: ['index.js'],
-  filePath: 'utils.js'
-})
+  entryPoints: ["index.js"],
+  filePath: "utils.js",
+});
 
-console.log(path)
+console.log(path);
 ```
 
 #### `find` Options
@@ -111,6 +111,94 @@ If you installed `rev-dep` **globally**, you will have appropriate compiler inst
 
 For example, to support `*.ts` and `*.tsx` implicit extensions in globally installed `rev-dep`, you have to also install globally `typescript` package (see [source](https://github.com/sverweij/dependency-cruiser/blob/96e34d0cf158034f2b7c8cafe9cec72dd74d8c45/src/extract/transpile/typescript-wrap.js))
 
+## CLI reference
+
+<!-- cli-docs-start -->
+
+### Command `resolve`
+
+Checks if a filePath is required from entryPoint(s) and prints the resolution path
+
+#### Usage
+
+```sh
+rev-dep resolve <filePath> [entryPoints...] [options]
+```
+
+#### Arguments
+
+- `filePath` - Path to a file that should be resolved in entry points (**required**),\* `entryPoints...` - List of entry points to look for file (_optional_)
+
+#### 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_)
+- `-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_)
+
+### Command `entry-points`
+
+Print list of entry points in current directory
+
+#### Usage
+
+```sh
+rev-dep entry-points [options]
+```
+
+#### 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_)
+- `-pdc, --printDependenciesCount` - print count of entry point dependencies (_optional_)
+- `-c, --count` - print just count of found entry points (_optional_)
+
+### Command `files`
+
+Get list of files required by entry point
+
+#### Usage
+
+```sh
+rev-dep files <entryPoint> [options]
+```
+
+#### Arguments
+
+- `entryPoint` - Path to entry point (**required**)
+
+#### Options
+
+- `-wc, --webpackConfig <path>` - path to webpack config to enable webpack aliases support (_optional_)
+- `--cwd <path>` - path to a directory that should be used as a resolution root (_optional_)
+- `--rr reexportRewire <value>` - resolve actual dependencies for "export \* from" statements (_optional_)
+- `-c, --count` - print only count of entry point dependencies (_optional_)
+
+### Command `docs`
+
+Generate documentation of available commands into md file.
+
+#### Usage
+
+```sh
+rev-dep docs <outputPath> [options]
+```
+
+#### Arguments
+
+- `outputPath` - path to output \*.md file (**required**)
+
+#### Options
+
+- `-hl, --headerLevel <value>` - Initial header level (_optional_)
+<!-- cli-docs-end -->
+
 ## Contributing
 
 Project is open to contributions, just rise an issue if you have some ideas about features or you noticed a bug. After discussion we can approach implementation :)

package/babel.js

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

package/bin.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('./dist/cli');

package/dist/babel/index.js

@@ -0,0 +1,277 @@
+"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/babel/reexport-rewire.js

@@ -0,0 +1,277 @@
+"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);
+            }
+        }
+    };
+};