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

package/README.md

@@ -1,16 +1,51 @@
 <h3 align="center">
-  <code>rev🠄dep</code>
+  <code>rev⭠dep</code>
 </h3>
 
 <p align="center">
-  A small tool for JavaScript project discovery
+  Dependency debugging tool for JavaScript and TypeScript projects
 </p>
 
 ---
 
 <img alt="rev-dep version" src="https://img.shields.io/npm/v/rev-dep"> <img alt="rev-dep license" src="https://img.shields.io/npm/l/rev-dep"> <img alt="rev-dep PRs welcome" src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square">
 
-## Installation
+## About
+
+The tool was created help with daily dev struggles by answering these questions:
+
+- What entry points my codebase have
+- Which entry points uses a given file
+- Which dependencies a given file has
+
+This helps to debug project dependencies, plan refactoring, optimize bundles or plan code splitting.
+
+It's especially useful in JS world without TypeScript or tests coverage.
+
+It also helps to identify and eliminate dead files, understand the complexity of the file dependencies
+
+[Jump to CLI reference](#CLI-reference)
+
+[`export * from` problem](#Export-from-problem)
+
+### Use cases
+
+- You plan to refactor some file and you wonder which entry points are affected
+- You are wondering wether a given source file is used
+- You wonder if there are any dead files in your project
+- You want to identify all dead files at once
+- You want to verify if a given entry point imports only the required files
+- You want to optimize the amount of files imported by an entry point
+
+### How about dependency or bundle graphs?
+
+There are tool that can output nice, visual representation of project dependencies like [webpack-bundle-analyzer](https://www.npmjs.com/package/webpack-bundle-analyzer) or [dependency-cruiser](https://www.npmjs.com/package/dependency-cruiser) (_which btw rev-dep uses for non-TS codebases_)
+
+While graphs can be useful to identify major problems like too big bundle size or to visualize mess in your deps, it's hard to take any action based on them (_at least it was hard for me_ 🤷‍♂️)
+
+`rev-dep` visualize dependencies as lists, so it's really easy to see where to cut the line to solve the problem.
+
+## Getting Started
 
 ### Install globally to use as CLI tool
 
@@ -28,59 +63,31 @@ or
 
 `npm install rev-dep`
 
-## Example
+## Recipes
 
-For this repo
+### How to identify where a file is used in the project?
 
-```sh
-rev-dep resolve getDepsSet.js cli.js
-```
+### How to check if a file is used in the project?
 
-will output
+### How to identify dead files in the project?
 
-```
-Results:
-
- ➞ cli.js
-  ➞ find.js
-   ➞ getDepsSet.js
-```
-
-Which says that `getDepsSet.js` file is used in `cli.js` entry point and is required through `find.js`
-
-## About
-
-The tool was created to determine places in the project where a particular file is used, to test wether the refactoring do not break functionalities.
-
-It's especially useful in JS world without TypeScript or tests coverage.
+### How to check which files are imported by a given file?
 
-Except the reverse dependency resolution path, it can print statistics about how many times a particular module is required in the project, which might be helpful for code-splitting planning.
+### How to reduce amount of files imported by entry point?
 
 ## Usage
 
-Project can be used as a CLI tool or as a regular JS module
+Project can be used as a CLI tool or as a module
 
 ### CLI Tool
 
-Avaliable commands:
-
-#### `resolve`
-
-```sh
-rev-dep resolve <filePath> <entryPoints...>
-```
-
-Available options are
-
-- `-cs or --compactSummary` - instead of file paths print a compact summary of reverse resolution with a count of found paths
-- `--verbose` - log currently performed operation
-- `-wc, --webpackConfig <path>` - path to webpack config to enable webpack aliases support
+For CLI usage see [CLI reference](#CLI-reference)
 
 ### Module
 
 #### `find` Function
 
-```js
+```ts
 import { find } from "rev-dep";
 
 const path = find({
@@ -91,25 +98,18 @@ const path = find({
 console.log(path);
 ```
 
-#### `find` Options
-
-- `entryPoints (Array)` - Array of entry points to build a tree for search. Usually it will be one entry point, but project can have many of them, eg. next.js application. **Required**
-- `filePath (String)` - A file that we want to find path for. **Required**
-- `skipRegex (String | RegExp)` - If a file path matches the pattern, we stop to traverse it's dependencies and do not include that file in the search tree. _Optional_, default: `'(node_modules|/__tests__|/__test__|/__mockContent__|.scss)'`
-- `verbose (Boolean)` - when set to true, will print current operation performed by find function. _Optional_, default: `false`
-- `cwd` - root for resolved files, must be an absolute path. _Optional_, default: `process.cwd()`
-- `webpackConfig (String)` - path to webpack config to enable webpack aliases support
-
-### Additional setup may be required
-
-#### Resolving implicit file extensions
+#### `find` Function
 
-A vast amount of JS/TS projects are configured in a way that allows (or even forces) to skip file extensions in import statements. Rev-dep is strongly based on [dependency-cruiser](https://github.com/sverweij/dependency-cruiser) which by default support implicit file extensions for `*.js, *.cjs, *.mjs, *.jsx` files (check [source](https://github.com/sverweij/dependency-cruiser/blob/96e34d0cf158034f2b7c8cafe9cec72dd74d8c45/src/extract/transpile/meta.js)).
-In order to resolve implicit extensions for other JS based languages it look for available corresponding compiler in `package.json`. If compiler is available, then extension is supported.
+```ts
+import { find } from "rev-dep";
 
-If you installed `rev-dep` **globally**, you will have appropriate compiler installed **globally** as well. If you use it as a module, your project has to have compiler in it's package.json.
+const path = find({
+  entryPoints: ["index.js"],
+  filePath: "utils.js",
+});
 
-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))
+console.log(path);
+```
 
 ## CLI reference
 
@@ -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`
@@ -199,6 +196,59 @@ rev-dep docs <outputPath> [options]
 - `-hl, --headerLevel <value>` - Initial header level (_optional_)
 <!-- cli-docs-end -->
 
+## Export from problem
+
+`rev-dep` attempts to also solve `export * from` by a babel plugin that can be used as follows
+
+```js
+// babel.config.js
+module.exports = {
+  plugins: [
+    'rev-dep/babel'
+  ]
+};
+```
+
+The plugins is currently **experimental** and might not work for all codebases!
+
+It helps by rewiring paths to re-exported modules
+
+```ts
+// file.ts
+import { add } from "./utils";
+
+// utils/index.ts
+
+export * from "./math";
+export * from "./otherModule";
+export * from "./anotherModule";
+
+// utils/math.ts
+
+export const add = () => {};
+```
+
+And for `file.ts` it would rewire the import like this
+
+```ts
+// file.ts
+import { add } from "./utils/math";
+```
+
+So as a result, we don't implicitly require `./otherModule` and `./anotherModule` which we will not use anyway
+
+### Benefits
+
+I don't have solid evidence for this, but I think it reduced RAM usage of the dev server I worked with (_blitz.js_). It crashed less often due to reaching heap size limit.
+
+But for sure it reduced bundle size, _slightly_, but still 😀
+
+It all depends on the the project dependencies structure.
+
+By using the babel plugin you will reduce a risk of problems like implicitly importing `front-end` modules on the `server` or similar while still being able to benefit from short import paths.
+
+Once I got an incident that, after a rebase with main branch, my project stopped compiling due to the problem caused by `export * from`. I spend a few hours debugging that, very frustrating.
+
 ## 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 :)
@@ -207,16 +257,20 @@ Project is open to contributions, just rise an issue if you have some ideas abou
 
 1. Clone repo
 2. Install deps using `yarn`
-3. Run tests using `yarn test --watch`
+3. Run `yarn build:watch`
 4. Code!
 
-For testing purpose you can install CLI tool from the file system using
+For testing purpose use
+
+`yarn dev [command] --cwd path/to/some/codebase`
+
+or you can install CLI tool from the file system using
 
-`yarn global add file:ABSOLUTE_PATH_TO_REPO`
+`yarn global add $PWD`
 
-or just
+and then just run
 
-`yarn global add file:$(echo $PWD)`
+`rev-dep`
 
 ## Made with 🧠 by [@jayu](https://github.com/jayu)
 

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

@@ -1,6 +1,6 @@
 {
   "name": "rev-dep",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.5",
   "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;