@teambit/dependencies 1.0.330 → 1.0.331

package/dist/resolve-pkg-data.js

@@ -0,0 +1,157 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolvePackageData = resolvePackageData;
+function _componentId() {
+  const data = require("@teambit/component-id");
+  _componentId = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _readPkgUp() {
+  const data = _interopRequireDefault(require("read-pkg-up"));
+  _readPkgUp = function () {
+    return data;
+  };
+  return data;
+}
+function _constants() {
+  const data = require("@teambit/legacy/dist/constants");
+  _constants = function () {
+    return data;
+  };
+  return data;
+}
+function _packageJsonFile() {
+  const data = _interopRequireDefault(require("@teambit/legacy/dist/consumer/component/package-json-file"));
+  _packageJsonFile = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy() {
+  const data = require("@teambit/legacy.utils");
+  _legacy = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * find data such as name/version/component-id from the package.json of a component and its dependent.
+ * the version from the dependent may have range (such as ~ or ^).
+ * the version from the dependency is an exact version.
+ * for a package that is not bit-component, we're interested in the range because that's how it was
+ * set in the first place and changing it to an exact version result in the component modified.
+ * for a bit-component, we're interested in the exact version because this is the version that gets
+ * entered into "dependency" field, which not supports range. (when a component is installed via
+ * npm, it can be saved into the package.json with range: ^, ~).
+ */
+function resolvePackageData(dependentDir, packageFullPath) {
+  const packageData = {
+    fullPath: packageFullPath,
+    name: '',
+    componentId: undefined
+  };
+  enrichDataFromDependent(packageData, dependentDir);
+  enrichDataFromDependency(packageData);
+  if (!packageData.name) {
+    // data was not found in dependent nor in dependency
+    return undefined;
+  }
+  return packageData;
+}
+function enrichDataFromDependent(packageData, dependentDir) {
+  const NODE_MODULES = 'node_modules';
+  // @todo: currently, the "normalize" makes sure that the package.json is valid, however, due to a
+  // bug, when importing snaps not from hub, it saves them in .dependencies and generate pkg.json
+  // with version that has the hash, which is invalid. later, this .dependencies will be gone.
+  const packageJsonInfo = _readPkgUp().default.sync({
+    cwd: dependentDir,
+    normalize: false
+  });
+  if (!packageJsonInfo) {
+    return;
+  }
+  const dependentPackageJson = packageJsonInfo.packageJson;
+  const packageFullPath = packageData.fullPath;
+  // The +1 is for the / after the node_modules, we didn't enter it into the NODE_MODULES const because it makes problems on windows
+  const packageRelativePath = packageFullPath.substring(packageFullPath.lastIndexOf(NODE_MODULES) + NODE_MODULES.length + 1, packageFullPath.length);
+  const packageName = (0, _legacy().resolvePackageNameByPath)(packageRelativePath);
+  const packageVersion = dependentPackageJson.dependencies?.packageName || dependentPackageJson.devDependencies?.packageName || dependentPackageJson.peerDependencies?.packageName;
+  if (packageVersion) {
+    packageData.dependentPackageJsonPath = packageJsonInfo.path;
+    packageData.name = packageName;
+    packageData.versionUsedByDependent = packageVersion;
+  }
+}
+function enrichDataFromDependency(packageData) {
+  // Get the package relative path to the node_modules dir
+  const packageDir = resolvePackageDirFromFilePath(packageData.fullPath);
+
+  // don't propagate here since loading a package.json of another folder and taking the version from it will result wrong version
+  // This for example happen in the following case:
+  // if you have 2 authored component which one dependent on the other
+  // we will look for the package.json on the dependency but won't find it
+  // if we propagate we will take the version from the root's package json which has nothing with the component version
+  const packageJsonFile = _packageJsonFile().default.loadSync(packageDir);
+  const packageInfo = packageJsonFile.packageJsonObject;
+
+  // the version can be empty when creating the package.json for author, or when using custom-module-resolution
+  // that's fine, we still need the component-id in this case.
+  if (!packageInfo || !packageInfo.name) {
+    return;
+  }
+  packageData.packageJsonPath = _path().default.join(packageDir, _constants().PACKAGE_JSON);
+  packageData.packageJsonContent = packageInfo;
+  packageData.name = packageInfo.name;
+  packageData.concreteVersion = packageInfo.version;
+  if (packageInfo.componentId) {
+    const scope = packageInfo.componentId.scope;
+    if (packageInfo.exported === false) {
+      // @ts-ignore
+      delete packageInfo.componentId.scope;
+    }
+    const componentId = _componentId().ComponentID.fromObject(packageInfo.componentId, scope);
+    packageData.componentId = componentId;
+    if (packageData.componentId.hasVersion() && packageInfo.version) {
+      // if packageInfo.version is not defined, it's coming from the workspace and the package.json is auto-generated
+      // during bit-link. ignore the componentId.version in this case, it's not up do date.
+      // otherwise, use it, because if it's a snap, the component-version is the snap. the pkg version is 0.0.0-snap.
+      packageData.concreteVersion = packageData.componentId.version;
+    }
+  }
+}
+
+/**
+ * given the full path of a package file, returns the root dir of the package, so then we could
+ * find the package.json in that directory.
+ *
+ * example of a normal package:
+ * absolutePackageFilePath: /user/workspace/node_modules/lodash.isboolean/index.js
+ * returns: /user/workspace/node_modules/lodash.isboolean
+ *
+ * example of a scoped package:
+ * absolutePackageFilePath: /user/workspace/node_modules/@babel/core/lib/index.js
+ * returns: /user/workspace/node_modules/@babel/core
+ */
+function resolvePackageDirFromFilePath(absolutePackageFilePath) {
+  const NODE_MODULES = 'node_modules';
+  const indexOfLastNodeModules = absolutePackageFilePath.lastIndexOf(NODE_MODULES) + NODE_MODULES.length + 1;
+  const pathInsideNodeModules = absolutePackageFilePath.substring(indexOfLastNodeModules);
+  const packageName = (0, _legacy().resolvePackageNameByPath)(pathInsideNodeModules);
+  const pathUntilNodeModules = absolutePackageFilePath.substring(0, indexOfLastNodeModules);
+  return pathUntilNodeModules + packageName;
+}
+
+//# sourceMappingURL=resolve-pkg-data.js.map

package/dist/resolve-pkg-data.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_componentId","data","require","_path","_interopRequireDefault","_readPkgUp","_constants","_packageJsonFile","_legacy","e","__esModule","default","resolvePackageData","dependentDir","packageFullPath","packageData","fullPath","name","componentId","undefined","enrichDataFromDependent","enrichDataFromDependency","NODE_MODULES","packageJsonInfo","readPkgUp","sync","cwd","normalize","dependentPackageJson","packageJson","packageRelativePath","substring","lastIndexOf","length","packageName","resolvePackageNameByPath","packageVersion","dependencies","devDependencies","peerDependencies","dependentPackageJsonPath","path","versionUsedByDependent","packageDir","resolvePackageDirFromFilePath","packageJsonFile","PackageJsonFile","loadSync","packageInfo","packageJsonObject","packageJsonPath","join","PACKAGE_JSON","packageJsonContent","concreteVersion","version","scope","exported","ComponentID","fromObject","hasVersion","absolutePackageFilePath","indexOfLastNodeModules","pathInsideNodeModules","pathUntilNodeModules"],"sources":["resolve-pkg-data.ts"],"sourcesContent":["import { ComponentID } from '@teambit/component-id';\nimport path from 'path';\nimport readPkgUp from 'read-pkg-up';\nimport { PACKAGE_JSON } from '@teambit/legacy/dist/constants';\nimport PackageJsonFile from '@teambit/legacy/dist/consumer/component/package-json-file';\nimport { PathLinuxAbsolute, PathOsBased, PathOsBasedAbsolute } from '@teambit/toolbox.path.path';\nimport { resolvePackageNameByPath } from '@teambit/legacy.utils';\n\nexport interface ResolvedPackageData {\n  fullPath: PathOsBasedAbsolute; // package path\n  packageJsonPath?: PathOsBased;\n  packageJsonContent?: Record<string, any>;\n  dependentPackageJsonPath?: PathOsBased;\n  name: string; // package name\n  concreteVersion?: string; // version from the package.json of the package itself\n  versionUsedByDependent?: string; // version from the dependent package.json\n  componentId?: ComponentID; // component id in case it's a bit component\n}\n\n/**\n * find data such as name/version/component-id from the package.json of a component and its dependent.\n * the version from the dependent may have range (such as ~ or ^).\n * the version from the dependency is an exact version.\n * for a package that is not bit-component, we're interested in the range because that's how it was\n * set in the first place and changing it to an exact version result in the component modified.\n * for a bit-component, we're interested in the exact version because this is the version that gets\n * entered into \"dependency\" field, which not supports range. (when a component is installed via\n * npm, it can be saved into the package.json with range: ^, ~).\n */\nexport function resolvePackageData(\n  dependentDir: string,\n  packageFullPath: PathLinuxAbsolute\n): ResolvedPackageData | undefined {\n  const packageData: ResolvedPackageData = {\n    fullPath: packageFullPath,\n    name: '',\n    componentId: undefined,\n  };\n  enrichDataFromDependent(packageData, dependentDir);\n  enrichDataFromDependency(packageData);\n  if (!packageData.name) {\n    // data was not found in dependent nor in dependency\n    return undefined;\n  }\n  return packageData;\n}\n\nfunction enrichDataFromDependent(packageData: ResolvedPackageData, dependentDir: string) {\n  const NODE_MODULES = 'node_modules';\n  // @todo: currently, the \"normalize\" makes sure that the package.json is valid, however, due to a\n  // bug, when importing snaps not from hub, it saves them in .dependencies and generate pkg.json\n  // with version that has the hash, which is invalid. later, this .dependencies will be gone.\n  const packageJsonInfo = readPkgUp.sync({ cwd: dependentDir, normalize: false });\n  if (!packageJsonInfo) {\n    return;\n  }\n  const dependentPackageJson = packageJsonInfo.packageJson;\n  const packageFullPath = packageData.fullPath;\n  // The +1 is for the / after the node_modules, we didn't enter it into the NODE_MODULES const because it makes problems on windows\n  const packageRelativePath = packageFullPath.substring(\n    packageFullPath.lastIndexOf(NODE_MODULES) + NODE_MODULES.length + 1,\n    packageFullPath.length\n  );\n\n  const packageName = resolvePackageNameByPath(packageRelativePath);\n  const packageVersion =\n    dependentPackageJson.dependencies?.packageName ||\n    dependentPackageJson.devDependencies?.packageName ||\n    dependentPackageJson.peerDependencies?.packageName;\n  if (packageVersion) {\n    packageData.dependentPackageJsonPath = packageJsonInfo.path;\n    packageData.name = packageName;\n    packageData.versionUsedByDependent = packageVersion;\n  }\n}\n\nfunction enrichDataFromDependency(packageData: ResolvedPackageData) {\n  // Get the package relative path to the node_modules dir\n  const packageDir = resolvePackageDirFromFilePath(packageData.fullPath);\n\n  // don't propagate here since loading a package.json of another folder and taking the version from it will result wrong version\n  // This for example happen in the following case:\n  // if you have 2 authored component which one dependent on the other\n  // we will look for the package.json on the dependency but won't find it\n  // if we propagate we will take the version from the root's package json which has nothing with the component version\n  const packageJsonFile = PackageJsonFile.loadSync(packageDir);\n  const packageInfo = packageJsonFile.packageJsonObject;\n\n  // the version can be empty when creating the package.json for author, or when using custom-module-resolution\n  // that's fine, we still need the component-id in this case.\n  if (!packageInfo || !packageInfo.name) {\n    return;\n  }\n  packageData.packageJsonPath = path.join(packageDir, PACKAGE_JSON);\n  packageData.packageJsonContent = packageInfo;\n  packageData.name = packageInfo.name;\n  packageData.concreteVersion = packageInfo.version;\n  if (packageInfo.componentId) {\n    const scope = packageInfo.componentId.scope as string;\n    if (packageInfo.exported === false) {\n      // @ts-ignore\n      delete packageInfo.componentId.scope;\n    }\n    const componentId = ComponentID.fromObject(packageInfo.componentId, scope);\n    packageData.componentId = componentId;\n    if (packageData.componentId.hasVersion() && packageInfo.version) {\n      // if packageInfo.version is not defined, it's coming from the workspace and the package.json is auto-generated\n      // during bit-link. ignore the componentId.version in this case, it's not up do date.\n      // otherwise, use it, because if it's a snap, the component-version is the snap. the pkg version is 0.0.0-snap.\n      packageData.concreteVersion = packageData.componentId.version;\n    }\n  }\n}\n\n/**\n * given the full path of a package file, returns the root dir of the package, so then we could\n * find the package.json in that directory.\n *\n * example of a normal package:\n * absolutePackageFilePath: /user/workspace/node_modules/lodash.isboolean/index.js\n * returns: /user/workspace/node_modules/lodash.isboolean\n *\n * example of a scoped package:\n * absolutePackageFilePath: /user/workspace/node_modules/@babel/core/lib/index.js\n * returns: /user/workspace/node_modules/@babel/core\n */\nfunction resolvePackageDirFromFilePath(absolutePackageFilePath: string): string {\n  const NODE_MODULES = 'node_modules';\n  const indexOfLastNodeModules = absolutePackageFilePath.lastIndexOf(NODE_MODULES) + NODE_MODULES.length + 1;\n  const pathInsideNodeModules = absolutePackageFilePath.substring(indexOfLastNodeModules);\n  const packageName = resolvePackageNameByPath(pathInsideNodeModules);\n  const pathUntilNodeModules = absolutePackageFilePath.substring(0, indexOfLastNodeModules);\n  return pathUntilNodeModules + packageName;\n}\n"],"mappings":"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","ignoreList":[]}

package/files-dependency-builder/build-tree.spec.ts

@@ -0,0 +1,130 @@
+import { expect } from 'chai';
+import path from 'path';
+
+import * as buildTree from './build-tree';
+
+const fixtures = `fixtures`;
+const precinctFixtures = path.join(fixtures, 'precinct');
+const buildTreeFixtures = path.join(fixtures, 'build-tree');
+
+describe('buildTree', () => {
+  describe('getDependencyTree', () => {
+    const filePaths: string[] = [];
+    let visited: any;
+    const dependencyTreeParams = {
+      componentDir: __dirname,
+      workspacePath: __dirname,
+      filePaths,
+      visited,
+    };
+    it('when no files are passed should return an empty tree', async () => {
+      const results = await buildTree.getDependencyTree(dependencyTreeParams);
+      expect(results).to.deep.equal({ tree: {} });
+    });
+    it('when unsupported files are passed should return them with no dependencies', async () => {
+      dependencyTreeParams.filePaths = [`${fixtures}/unsupported-file.pdf`];
+      const results = await buildTree.getDependencyTree(dependencyTreeParams);
+      expect(results.tree[`${fixtures}/unsupported-file.pdf`].isEmpty()).to.be.true;
+    });
+    it('when supported and unsupported files are passed should return them all', async () => {
+      dependencyTreeParams.filePaths = [`${fixtures}/unsupported-file.pdf`, `${precinctFixtures}/es6.js`];
+      const results = await buildTree.getDependencyTree(dependencyTreeParams);
+      expect(results.tree).to.have.property(`${fixtures}/unsupported-file.pdf`);
+      expect(results.tree).to.have.property(`${fixtures}/precinct/es6.js`);
+    });
+    // todo: fix this one and one below once we have a way to ignore some component files from compiling/parsing altogether
+    // uncomment unparseable.js
+    it.skip('when a js file has parsing error it should add the file to the tree with the error instance', async () => {
+      dependencyTreeParams.filePaths = [`${precinctFixtures}/unparseable.js`];
+      const results = await buildTree.getDependencyTree(dependencyTreeParams);
+      const unParsedFile = `${fixtures}/precinct/unparseable.js`;
+      expect(results.tree).to.have.property(unParsedFile);
+      expect(results.tree[unParsedFile]).to.have.property('error');
+      expect(results.tree[unParsedFile].error).to.be.instanceof(Error);
+    });
+    it.skip('when a js file has parsing error and it retrieved from the cache it should add the file to the tree with the error instance', async () => {
+      dependencyTreeParams.filePaths = [`${precinctFixtures}/unparseable.js`];
+      dependencyTreeParams.visited = {};
+      const results = await buildTree.getDependencyTree(dependencyTreeParams);
+      const unParsedFile = `${fixtures}/precinct/unparseable.js`;
+      expect(results.tree).to.have.property(unParsedFile);
+      expect(results.tree[unParsedFile]).to.have.property('error');
+      expect(results.tree[unParsedFile].error).to.be.instanceof(Error);
+
+      // second time, this time it fetches from the cache (visited object)
+      const resultsCached = await buildTree.getDependencyTree(dependencyTreeParams);
+      expect(resultsCached.tree).to.have.property(unParsedFile);
+      expect(resultsCached.tree[unParsedFile]).to.have.property('error');
+      expect(resultsCached.tree[unParsedFile].error).to.be.instanceof(Error);
+    });
+    // todo: fix this one once we have a way to ignore some component files from compiling/parsing altogether
+    // uncomment fixtures/build-tree/unparsed.js file
+    describe.skip('when a dependency of dependency has parsing error', () => {
+      let results;
+      before(async () => {
+        dependencyTreeParams.filePaths = [`${buildTreeFixtures}/a.js`, `${buildTreeFixtures}/b.js`];
+        results = await buildTree.getDependencyTree(dependencyTreeParams);
+      });
+      it('should add all the files to the tree', async () => {
+        expect(results.tree).to.have.property(`${fixtures}/build-tree/a.js`);
+        expect(results.tree).to.have.property(`${fixtures}/build-tree/b.js`);
+        expect(results.tree).to.have.property(`${fixtures}/build-tree/unparsed.js`);
+      });
+      it('should not add the error to the files without parsing error', () => {
+        expect(results.tree[`${fixtures}/build-tree/a.js`].error).to.be.undefined;
+        expect(results.tree[`${fixtures}/build-tree/b.js`].error).to.be.undefined;
+      });
+      it('should add the parsing error to the un-parsed file', () => {
+        expect(results.tree[`${fixtures}/build-tree/unparsed.js`]).to.have.property('error');
+        expect(results.tree[`${fixtures}/build-tree/unparsed.js`].error).to.be.instanceof(Error);
+      });
+    });
+    // todo: fix this one once we have a way to ignore some component files from compiling/parsing altogether
+    // uncomment fixtures/missing-deps.js file
+    describe.skip('missing dependencies', () => {
+      let results;
+      const missingDepsFile = 'fixtures/missing-deps.js';
+      before(async () => {
+        dependencyTreeParams.filePaths = [missingDepsFile];
+        results = await buildTree.getDependencyTree(dependencyTreeParams);
+        expect(results.tree).to.have.property(`${fixtures}/missing-deps.js`);
+        expect(results.tree[`${fixtures}/missing-deps.js`]).to.have.property('missing');
+      });
+      it('it should add the missing dependency to the missing section in the tree', async () => {
+        expect(results.tree[`${fixtures}/missing-deps.js`].missing).to.have.property('files');
+        expect(results.tree[`${fixtures}/missing-deps.js`].missing.files[0]).to.equal('../non-exist-dep');
+      });
+      it('it should add the missing package to the missing section in the tree', async () => {
+        expect(results.tree[`${fixtures}/missing-deps.js`].missing).to.have.property('packages');
+        expect(results.tree[`${fixtures}/missing-deps.js`].missing.packages[0]).to.equal('non-exist-package');
+      });
+    });
+    describe('tree shaking with cycle', () => {
+      describe('when a file imports from itself', () => {
+        let results;
+        before(async () => {
+          dependencyTreeParams.filePaths = [`${buildTreeFixtures}/tree-shaking-cycle/self-cycle.js`];
+          results = await buildTree.getDependencyTree(dependencyTreeParams);
+        });
+        it('should not throw an error and should remove itself from the dependencies files', () => {
+          const file = `${fixtures}/build-tree/tree-shaking-cycle/self-cycle.js`;
+          expect(results.tree[file].files).to.be.an('array').and.empty;
+        });
+      });
+      // probably not relevant anymore.
+      describe.skip('cycle with multiple files', () => {
+        let results;
+        before(async () => {
+          dependencyTreeParams.filePaths = [`${buildTreeFixtures}/tree-shaking-cycle/foo.js`];
+          results = await buildTree.getDependencyTree(dependencyTreeParams);
+        });
+        it('should not recognize the cycle dependencies as link files', () => {
+          const file = `${fixtures}/build-tree/tree-shaking-cycle/foo.js`;
+          expect(results.tree[file].files).to.be.an('array').and.have.lengthOf(1);
+          const indexDep = results.tree[file].files[0];
+          expect(indexDep.file).to.equal(`${fixtures}/build-tree/tree-shaking-cycle/index.js`);
+        });
+      });
+    });
+  });
+});

package/files-dependency-builder/build-tree.ts

@@ -0,0 +1,185 @@
+import { clone, isEmpty, set } from 'lodash';
+import path from 'path';
+import { resolvePackageData } from '../resolve-pkg-data';
+import generateTree, { MadgeTree } from './generate-tree-madge';
+import { FoundPackages, MissingGroupItem, MissingHandler } from './missing-handler';
+import { convertPathMapToRelativePaths, PathMapItem } from './path-map';
+import { DependencyTreeParams, FileObject, DependenciesTree, DependenciesTreeItem } from './types/dependency-tree-type';
+
+/**
+ * Gets a list of dependencies and group them by types (files, components, packages)
+ * It's also transform the node package dependencies from array of paths to object in this format:
+ * {dependencyName: version} (like in package.json)
+ *
+ * componentDir is the root of working directory (used for node packages version calculation)
+ */
+function groupDependencyList(dependenciesPaths: string[], componentDir: string): DependenciesTreeItem {
+  const resultGroups = new DependenciesTreeItem();
+  const isPackage = (str: string) => str.includes('node_modules/');
+  dependenciesPaths.forEach((dependencyPath) => {
+    if (!isPackage(dependencyPath)) {
+      resultGroups.files.push({ file: dependencyPath });
+      return;
+    }
+    const resolvedPackage = resolvePackageData(componentDir, path.join(componentDir, dependencyPath));
+    if (!resolvedPackage) {
+      // package doesn't have package.json, probably it's a custom-resolve-module dep file
+      resultGroups.unidentifiedPackages.push(dependencyPath);
+      return;
+    }
+
+    // If the package is a component add it to the components list
+    if (resolvedPackage.componentId) {
+      resultGroups.components.push(resolvedPackage);
+      return;
+    }
+    const version = resolvedPackage.versionUsedByDependent || resolvedPackage.concreteVersion;
+    const packageWithVersion = {
+      [resolvedPackage.name]: version,
+    };
+    Object.assign(resultGroups.packages, packageWithVersion);
+  });
+
+  return resultGroups;
+}
+
+/**
+ * Run over each entry in the tree and transform the dependencies from list of paths
+ * to object with dependencies types
+ *
+ * @returns new tree with grouped dependencies
+ */
+function MadgeTreeToDependenciesTree(tree: MadgeTree, componentDir: string): DependenciesTree {
+  const result: DependenciesTree = {};
+  Object.keys(tree).forEach((filePath) => {
+    if (tree[filePath] && !isEmpty(tree[filePath])) {
+      result[filePath] = groupDependencyList(tree[filePath], componentDir);
+    } else {
+      result[filePath] = new DependenciesTreeItem();
+    }
+  });
+
+  return result;
+}
+
+/**
+ * add extra data such as custom-resolve and link-files from pathMap
+ */
+function updateTreeWithPathMap(tree: DependenciesTree, pathMapAbsolute: PathMapItem[], baseDir: string): void {
+  if (!pathMapAbsolute.length) return;
+  const pathMap = convertPathMapToRelativePaths(pathMapAbsolute, baseDir);
+  Object.keys(tree).forEach((filePath: string) => {
+    const treeFiles = tree[filePath].files;
+    if (!treeFiles.length) return; // file has no dependency
+    const mainFilePathMap = pathMap.find((file) => file.file === filePath);
+    if (!mainFilePathMap) throw new Error(`updateTreeWithPathMap: PathMap is missing for ${filePath}`);
+    // a file might have a cycle dependency with itself, remove it from the dependencies.
+    tree[filePath].files = treeFiles.filter((dependency) => dependency.file !== filePath);
+    tree[filePath].files.forEach((fileObject: FileObject) => {
+      const dependencyPathMap = mainFilePathMap.dependencies.find((file) => file.resolvedDep === fileObject.file);
+      if (!dependencyPathMap) {
+        throw new Error(`updateTreeWithPathMap: dependencyPathMap is missing for ${fileObject.file}`);
+      }
+      fileObject.importSource = dependencyPathMap.importSource;
+      if (dependencyPathMap.importSpecifiers && dependencyPathMap.importSpecifiers.length) {
+        const depImportSpecifiers = dependencyPathMap.importSpecifiers.map((importSpecifier) => {
+          return {
+            mainFile: importSpecifier,
+          };
+        });
+        fileObject.importSpecifiers = depImportSpecifiers;
+      }
+      return fileObject;
+    });
+  });
+}
+
+function mergeManuallyFoundPackagesToTree(
+  foundPackages: FoundPackages,
+  missingGroups: MissingGroupItem[],
+  tree: DependenciesTree
+) {
+  if (isEmpty(foundPackages.components) && isEmpty(foundPackages.packages)) return;
+  // Merge manually found packages (by groupMissing()) with the packages found by Madge (generate-tree-madge)
+  Object.keys(foundPackages.packages).forEach((pkg) => {
+    // locate package in groups(contains missing)
+    missingGroups.forEach((fileDep: MissingGroupItem) => {
+      if (fileDep.packages && fileDep.packages.includes(pkg)) {
+        fileDep.packages = fileDep.packages.filter((packageName) => packageName !== pkg);
+        set(tree[fileDep.originFile], ['packages', pkg], foundPackages.packages[pkg]);
+      }
+    });
+  });
+  foundPackages.components.forEach((component) => {
+    missingGroups.forEach((fileDep: MissingGroupItem) => {
+      if (fileDep.packages && fileDep.packages.includes(component.name)) {
+        fileDep.packages = fileDep.packages.filter((packageName) => packageName !== component.name);
+        (tree[fileDep.originFile] ||= new DependenciesTreeItem()).components.push(component);
+      }
+    });
+  });
+}
+
+function mergeMissingToTree(missingGroups, tree: DependenciesTree) {
+  if (isEmpty(missingGroups)) return;
+  missingGroups.forEach((missing) => {
+    const missingCloned = clone(missing);
+    delete missingCloned.originFile;
+    (tree[missing.originFile] ||= new DependenciesTreeItem()).missing = missingCloned;
+  });
+}
+
+function mergeErrorsToTree(errors, tree: DependenciesTree) {
+  if (isEmpty(errors)) return;
+  Object.keys(errors).forEach((file) => {
+    (tree[file] ||= new DependenciesTreeItem()).error = errors[file];
+  });
+}
+
+/**
+ * Function for fetching dependency tree of file or dir
+ * @param baseDir working directory
+ * @param workspacePath
+ * @param filePaths path of the file to calculate the dependencies
+ */
+export async function getDependencyTree({
+  componentDir, // component rootDir
+  workspacePath,
+  filePaths,
+  visited = {},
+  cacheProjectAst,
+  envDetectors,
+}: DependencyTreeParams): Promise<{ tree: DependenciesTree }> {
+  const config = {
+    baseDir: componentDir,
+    includeNpm: true,
+    requireConfig: null,
+    webpackConfig: null,
+    visited,
+    nonExistent: [],
+    cacheProjectAst,
+    envDetectors,
+  };
+  // This is important because without this, madge won't know to resolve files if we run the
+  // CMD not from the root dir
+  const fullPaths = filePaths.map((filePath) => {
+    if (filePath.startsWith(componentDir)) {
+      return filePath;
+    }
+    return path.resolve(componentDir, filePath);
+  });
+  const { madgeTree, skipped, pathMap, errors } = generateTree(fullPaths, config);
+  const tree: DependenciesTree = MadgeTreeToDependenciesTree(madgeTree, componentDir);
+  const { missingGroups, foundPackages } = new MissingHandler(
+    skipped,
+    componentDir,
+    workspacePath
+  ).groupAndFindMissing();
+
+  if (foundPackages) mergeManuallyFoundPackagesToTree(foundPackages, missingGroups, tree);
+  if (errors) mergeErrorsToTree(errors, tree);
+  if (missingGroups) mergeMissingToTree(missingGroups, tree);
+  if (pathMap) updateTreeWithPathMap(tree, pathMap, componentDir);
+
+  return { tree };
+}

package/files-dependency-builder/dependency-tree/Config.ts

@@ -0,0 +1,68 @@
+/**
+ * this file had been forked from https://github.com/dependents/node-dependency-tree
+ */
+
+const path = require('path');
+const debug = require('debug')('tree');
+
+export default function Config(options) {
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  this.filename = options.filename;
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  this.directory = options.directory || options.root;
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  this.visited = options.visited || {};
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  this.errors = options.errors || {};
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  this.nonExistent = options.nonExistent || [];
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  this.isListForm = options.isListForm;
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  this.requireConfig = options.config || options.requireConfig;
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  this.webpackConfig = options.webpackConfig;
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  this.detectiveConfig = options.detective || options.detectiveConfig || {};
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  this.pathMap = options.pathMap || [];
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  this.resolveConfig = options.resolveConfig;
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  this.cacheProjectAst = options.cacheProjectAst;
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  this.envDetectors = options.envDetectors;
+
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  this.filter = options.filter;
+
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  if (!this.filename) {
+    throw new Error('filename not given');
+  }
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  if (!this.directory) {
+    throw new Error('directory not given');
+  }
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  if (this.filter && typeof this.filter !== 'function') {
+    throw new Error('filter must be a function');
+  }
+
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  debug(`given filename: ${this.filename}`);
+
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  this.filename = path.resolve(process.cwd(), this.filename);
+
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  debug(`resolved filename: ${this.filename}`);
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  debug('visited: ', this.visited);
+}
+
+Config.prototype.clone = function () {
+  return new Config(this);
+};