@teambit/dependencies 1.0.330 → 1.0.331

package/files-dependency-builder/fixtures/precinct/styles.css

@@ -0,0 +1,6 @@
+/* @bit-no-check */
+
+@import "foo.css";
+@import url("baz.css");
+@value a from 'bla.css';
+@value a, b as x from url(another.css);

package/files-dependency-builder/fixtures/precinct/styles.less

@@ -0,0 +1,4 @@
+/* @bit-no-check */
+@import "_foo";
+@import "_bar.css";
+@import "baz.less";

package/files-dependency-builder/fixtures/precinct/styles.sass

@@ -0,0 +1,2 @@
+/* @bit-no-check */
+@import _foo

package/files-dependency-builder/fixtures/precinct/styles.scss

@@ -0,0 +1,3 @@
+/* @bit-no-check */
+@import "_foo";
+@import "baz.scss";

package/files-dependency-builder/fixtures/precinct/styles.styl

@@ -0,0 +1,5 @@
+/* @bit-no-check */
+@import "mystyles"
+@import "styles2.styl"
+@require "styles3.styl";
+@require "styles4";

package/files-dependency-builder/fixtures/precinct/typescript.ts

@@ -0,0 +1,8 @@
+// import * as fs from 'fs';
+// import { square, diag } from 'lib';
+// import foo from './bar';
+// import './my-module.js'; // Import a module for side-effects only
+// import zip = require('./ZipCodeValidator'); // needed when importing a module using `export =` syntax
+
+// console.log(square(11)); // 121
+// console.log(diag(4, 3)); // 5

package/files-dependency-builder/fixtures/precinct/unparseable.js

@@ -0,0 +1,6 @@
+// // @bit-no-check
+// {
+// 	"very invalid": "javascript",
+// 	"this", "is actually json",
+// 	"But" not even valid json.
+// }

package/files-dependency-builder/generate-tree-madge.ts

@@ -0,0 +1,200 @@
+// most of the functions in this file were taken from the Madge project: https://github.com/pahen/madge
+// reasons for not using Madge directly: 1) it has issues with TypeScript on Windows. 2) it has issues with tsx files
+
+import os from 'os';
+import path from 'path';
+
+import dependencyTree from './dependency-tree';
+import { PathLinuxRelative } from '@teambit/toolbox.path.path';
+
+/**
+ * Check if running on Windows.
+ * @type {Boolean}
+ */
+const isWin = os.platform() === 'win32';
+
+/**
+ * Check if path is from NPM folder
+ * @param  {String} path
+ * @return {Boolean}
+ */
+function isNpmPathFunc(pathStr) {
+  return pathStr.indexOf('node_modules') >= 0;
+}
+
+/**
+ * Sort tree.
+ * @param  {Object} tree
+ * @return {Object}
+ */
+function sort(tree) {
+  return Object.keys(tree)
+    .sort()
+    .reduce((acc, id) => {
+      acc[id] = tree[id].sort();
+      return acc;
+    }, {});
+}
+
+/**
+ * Exclude modules from tree using RegExp.
+ * @param  {Object} tree
+ * @param  {Array} excludeRegExp
+ * @return {Object}
+ */
+function exclude(tree, excludeRegExp) {
+  const regExpList = excludeRegExp.map((re) => new RegExp(re));
+
+  function regExpFilter(id) {
+    return regExpList.findIndex((regexp) => regexp.test(id)) < 0;
+  }
+
+  return Object.keys(tree)
+    .filter(regExpFilter)
+    .reduce((acc, id) => {
+      acc[id] = tree[id].filter(regExpFilter);
+      return acc;
+    }, {});
+}
+
+/**
+ * Process absolute path and return a shorter one.
+ * @param  {String} absPath
+ * @param  {Object} cache
+ * @param  {String} baseDir
+ * @return {String}
+ */
+export function processPath(absPath, cache, baseDir) {
+  if (cache[absPath]) {
+    return cache[absPath];
+  }
+
+  let relPath = path.relative(baseDir, absPath);
+
+  if (isWin) {
+    relPath = relPath.replace(/\\/g, '/');
+  }
+
+  cache[absPath] = relPath;
+
+  return relPath;
+}
+
+/**
+ * Convert deep tree produced by dependency-tree to a
+ * shallow (one level deep) tree used by madge.
+ * @param  {Object} depTree
+ * @param  {Object} tree
+ * @param  {Object} pathCache
+ * @param  {String} baseDir
+ * @return {Object}
+ */
+function convertTreePaths(depTree, pathCache, baseDir) {
+  const tree = {};
+  Object.keys(depTree).forEach((file) => {
+    tree[processPath(file, pathCache, baseDir)] = depTree[file].map((d) => processPath(d, pathCache, baseDir));
+  });
+
+  return tree;
+}
+
+// e.g. { 'index.ts': ['foo.ts', '../node_modules/react/index.js'] }
+// all paths are normalized to Linux
+export type MadgeTree = { [relativePath: string]: PathLinuxRelative[] };
+
+// e.g. { '/tmp/workspace': ['lodash', 'underscore'] };
+export type Missing = { [absolutePath: string]: string[] };
+
+type GenerateTreeResults = {
+  madgeTree: MadgeTree;
+  skipped: Missing;
+  pathMap: any;
+  errors: { [filePath: string]: Error };
+};
+
+/**
+ * Generate the tree from the given files
+ * @param  {Array} files
+ * @param config
+ * @return {Object}
+ */
+export default function generateTree(files: string[] = [], config): GenerateTreeResults {
+  const depTree = {};
+  const nonExistent = {};
+  const npmPaths = {};
+  const pathCache = {};
+  const pathMap = [];
+  const errors = {};
+
+  files.forEach((file) => {
+    if (depTree[file]) {
+      return;
+    }
+
+    const detective = config.detectiveOptions;
+    try {
+      const dependencyTreeResult = dependencyTree({
+        filename: file,
+        directory: config.baseDir,
+        requireConfig: config.requireConfig,
+        webpackConfig: config.webpackConfig,
+        resolveConfig: config.resolveConfig,
+        visited: config.visited,
+        errors,
+        filter: (dependencyFilePath, traversedFilePath) => {
+          let dependencyFilterRes = true;
+          const isNpmPath = isNpmPathFunc(dependencyFilePath);
+
+          if (config.dependencyFilter) {
+            dependencyFilterRes = config.dependencyFilter(dependencyFilePath, traversedFilePath, config.baseDir);
+          }
+
+          if (config.includeNpm && isNpmPath) {
+            (npmPaths[traversedFilePath] = npmPaths[traversedFilePath] || []).push(dependencyFilePath);
+          }
+
+          return !isNpmPath && (dependencyFilterRes || dependencyFilterRes === undefined);
+        },
+        detective,
+        nonExistent,
+        pathMap,
+        cacheProjectAst: config.cacheProjectAst,
+        envDetectors: config.envDetectors,
+      });
+      Object.assign(depTree, dependencyTreeResult);
+    } catch (err: any) {
+      errors[file] = err;
+    }
+  });
+
+  let tree = convertTreePaths(depTree, pathCache, config.baseDir);
+
+  // rename errors keys from absolute paths to relative paths
+  Object.keys(errors).forEach((file) => {
+    const relativeFile = processPath(file, pathCache, config.baseDir);
+    if (relativeFile !== file) {
+      errors[relativeFile] = errors[file];
+      delete errors[file];
+    }
+  });
+
+  Object.keys(npmPaths).forEach((npmKey) => {
+    const id = processPath(npmKey, pathCache, config.baseDir);
+    // a file might not be in the tree if it has errors or errors found with its parents
+    if (!tree[id]) return;
+    npmPaths[npmKey].forEach((npmPath) => {
+      tree[id].push(processPath(npmPath, pathCache, config.baseDir));
+    });
+  });
+
+  if (config.excludeRegExp) {
+    tree = exclude(tree, config.excludeRegExp);
+  }
+
+  return {
+    madgeTree: sort(tree),
+    skipped: nonExistent,
+    pathMap,
+    errors,
+  };
+}

package/files-dependency-builder/index.ts

@@ -0,0 +1,5 @@
+import { getDependencyTree } from './build-tree';
+// @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+import getDependenciesFromSource from './precinct';
+
+export { getDependencyTree, getDependenciesFromSource };

package/files-dependency-builder/missing-handler.ts

@@ -0,0 +1,76 @@
+import { resolvePackageNameByPath, resolvePackagePath } from '@teambit/legacy.utils';
+import { ResolvedPackageData, resolvePackageData } from '../resolve-pkg-data';
+import { processPath, Missing } from './generate-tree-madge';
+import { groupBy } from 'lodash';
+
+export type MissingGroupItem = { originFile: string; packages?: string[]; files?: string[] };
+export type FoundPackages = {
+  packages: { [packageName: string]: string };
+  components: ResolvedPackageData[];
+};
+
+export class MissingHandler {
+  constructor(private missing: Missing, private componentDir: string, private workspacePath: string) {}
+
+  /**
+   * Run over each entry in the missing array and transform the missing from list of paths
+   * to object with missing types
+   */
+  groupAndFindMissing(): { missingGroups: MissingGroupItem[]; foundPackages: FoundPackages } {
+    const missingGroups: MissingGroupItem[] = this.groupMissingByType();
+    missingGroups.forEach((group: MissingGroupItem) => {
+      if (group.packages) group.packages = group.packages.map(resolvePackageNameByPath);
+    });
+    // This is a hack to solve problems that madge has with packages for type script files
+    // It see them as missing even if they are exists
+    const foundPackages: FoundPackages = {
+      packages: {},
+      components: [],
+    };
+    missingGroups.forEach((group) => this.processMissingGroup(group, foundPackages));
+
+    return { missingGroups, foundPackages };
+  }
+
+  private processMissingGroup(group: MissingGroupItem, foundPackages: FoundPackages) {
+    if (!group.packages) return;
+    const missingPackages: string[] = [];
+    group.packages.forEach((packageName) => {
+      // Don't try to resolve the same package twice
+      if (missingPackages.includes(packageName)) return;
+      const resolvedPath = resolvePackagePath(packageName, this.componentDir, this.workspacePath);
+      if (!resolvedPath) {
+        missingPackages.push(packageName);
+        return;
+      }
+      const resolvedPackageData = resolvePackageData(this.componentDir, resolvedPath);
+      if (!resolvedPackageData) {
+        missingPackages.push(packageName);
+        return;
+      }
+      // if the package is actually a component add it to the components list
+      if (resolvedPackageData.componentId) {
+        foundPackages.components.push(resolvedPackageData);
+      } else {
+        const version = resolvedPackageData.versionUsedByDependent || resolvedPackageData.concreteVersion;
+        if (!version) throw new Error(`unable to find the version for a package ${packageName}`);
+        const packageWithVersion = {
+          [resolvedPackageData.name]: version,
+        };
+        Object.assign(foundPackages.packages, packageWithVersion);
+      }
+    });
+  }
+
+  /**
+   * Group missing dependencies by types (files, packages)
+   * @param {Array} missing list of missing paths to group
+   * @returns {Function} function which group the dependencies
+   */
+  private groupMissingByType(): MissingGroupItem[] {
+    const byPathType = (item) => (item.startsWith('.') ? 'files' : 'packages');
+    return Object.keys(this.missing).map((key) =>
+      Object.assign({ originFile: processPath(key, {}, this.componentDir) }, groupBy(this.missing[key], byPathType))
+    );
+  }
+}

package/files-dependency-builder/path-map.ts

@@ -0,0 +1,38 @@
+/**
+ * Path Map is the extra data about the files and the dependencies, such as ImportSpecifiers and
+ * custom-resolve-modules used.
+ * The data is retrieved by dependency-tree which collects them from the various detectives.
+ * It is used to update the final tree.
+ */
+
+import { clone } from 'lodash';
+import { processPath } from './generate-tree-madge';
+import { Specifier } from '@teambit/legacy/dist/consumer/component/dependencies/dependency';
+
+export type PathMapDependency = {
+  importSource: string; // dependency path as it has been received from dependency-tree lib
+  resolvedDep: string; // path relative to consumer root (after convertPathMapToRelativePaths() )
+  importSpecifiers?: Specifier[]; // relevant for ES6 and TS
+};
+
+/**
+ * PathMap is used to get the ImportSpecifiers from dependency-tree library
+ */
+export type PathMapItem = {
+  file: string; // path relative to consumer root (after convertPathMapToRelativePaths() )
+  dependencies: PathMapDependency[];
+};
+
+export function convertPathMapToRelativePaths(pathMap: PathMapItem[], baseDir: string): PathMapItem[] {
+  const pathCache = {};
+  return pathMap.map((file: PathMapItem) => {
+    const newFile = clone(file);
+    newFile.file = processPath(file.file, pathCache, baseDir);
+    newFile.dependencies = file.dependencies.map((dependency) => {
+      const newDependency = clone(dependency);
+      newDependency.resolvedDep = processPath(dependency.resolvedDep, pathCache, baseDir);
+      return newDependency;
+    });
+    return newFile;
+  });
+}