@teambit/dependencies 1.0.330 → 1.0.331

package/files-dependency-builder/precinct/index.spec.ts

@@ -0,0 +1,342 @@
+import { expect } from 'chai';
+import { DependencyDetector } from '../detector-hook';
+
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const rewire = require('rewire');
+const sinon = require('sinon');
+
+const fixtures = '../fixtures/precinct';
+const fixturesFullPath = path.resolve(__dirname, fixtures);
+const exampleASTPath = path.join(fixtures, 'exampleAST');
+// eslint-disable-next-line import/no-dynamic-require, global-require
+const ast = require(exampleASTPath);
+
+const precinctNonWired = rewire('./');
+const precinct = precinctNonWired.default;
+
+function read(filename) {
+  return fs.readFileSync(path.join(fixturesFullPath, filename), 'utf8');
+}
+
+describe('node-precinct', () => {
+  it('accepts an AST', () => {
+    const deps = precinct(ast);
+    const depsKeys = Object.keys(deps);
+    assert(depsKeys.length === 1);
+  });
+
+  it('dangles off a given ast', () => {
+    precinct(ast);
+    assert.deepEqual(precinct.ast, ast);
+  });
+
+  it('dangles off the parsed ast from a .js file', () => {
+    precinct(read('amd.js'));
+    assert.ok(precinct.ast);
+    assert.notDeepEqual(precinct.ast, ast);
+  });
+
+  it('dangles off the parsed ast from a scss detective', () => {
+    precinct(read('styles.scss'), 'scss');
+    assert.notDeepEqual(precinct.ast, {});
+  });
+
+  it('dangles off the parsed ast from a sass detective', () => {
+    precinct(read('styles.sass'), 'sass');
+    assert.notDeepEqual(precinct.ast, {});
+  });
+
+  it('grabs dependencies of amd modules', () => {
+    const amd = precinct(read('amd.js'));
+    assert(amd.indexOf('./a') !== -1);
+    assert(amd.indexOf('./b') !== -1);
+    assert(amd.length === 2);
+  });
+
+  it('grabs dependencies of commonjs modules', () => {
+    const cjs = precinct(read('commonjs.js'));
+    expect(cjs).to.have.property('./a');
+    expect(cjs).to.have.property('./b');
+    assert(Object.keys(cjs).length === 2);
+  });
+
+  it('grabs dependencies of es6 modules', () => {
+    const cjs = precinct(`import { square, diag } from 'lib';
+console.log(square(11)); // 121
+console.log(diag(4, 3)); // 5`);
+    expect(cjs).to.have.property('lib');
+    assert(Object.keys(cjs).length === 1);
+  });
+
+  it('grabs dependencies of es6 modules with embedded jsx', () => {
+    const cjs = precinct(`import { square, diag } from 'lib';
+const tmpl = <jsx />;`);
+    expect(cjs).to.have.property('lib');
+    assert(Object.keys(cjs).length === 1);
+  });
+
+  it('grabs dependencies of es6 modules with embedded es7', () => {
+    const cjs = precinct(`import { square, diag } from 'lib';
+async function foo() {}`);
+    expect(cjs).to.have.property('lib');
+    assert(Object.keys(cjs).length === 1);
+  });
+
+  it('throws errors of es6 modules with syntax errors', () => {
+    const precinctFunc = () =>
+      precinct(`import { square, diag } from 'lib' // error, semicolon
+console.log(square(11)); // 121
+console.log(diag(4, 3); // 5, error, missing paren`);
+    expect(precinctFunc).to.throw();
+  });
+
+  // this is for supporting PostCSS dialect. The implementation is not merged to this project.
+  // see the following PR of node-precinct: https://github.com/dependents/node-precinct/pull/40
+  it.skip('grabs dependencies of css files', () => {
+    const css = precinct(read('styles.css'), 'css');
+    expect(css).to.have.property('foo.css');
+    expect(css).to.have.property('baz.css');
+    expect(css).to.have.property('bla.css');
+    expect(css).to.have.property('another.css');
+  });
+
+  it('grabs dependencies of scss files', function () {
+    const scss = precinct(read('styles.scss'), 'scss');
+    assert.deepEqual(scss, ['_foo', 'baz.scss']);
+  });
+
+  it('grabs dependencies of sass files', () => {
+    const sass = precinct(read('styles.sass'), 'sass');
+    assert.deepEqual(sass, ['_foo']);
+  });
+
+  it('grabs dependencies of stylus files', () => {
+    const result = precinct(read('styles.styl'), 'stylus');
+    const expected = ['mystyles', 'styles2.styl', 'styles3.styl', 'styles4'];
+
+    assert.deepEqual(result, expected);
+  });
+
+  it('grabs dependencies of less files', () => {
+    const result = precinct(read('styles.less'), 'less');
+    const expected = ['_foo', '_bar.css', 'baz.less'];
+
+    assert.deepEqual(result, expected);
+  });
+  // todo: fix this one once we have a way to ignore some component files from compiling/parsing altogether
+  // uncomment typescript.ts
+  it.skip('grabs dependencies of typescript files', () => {
+    const result = precinct(read('typescript.ts'), 'ts');
+    const expected = ['fs', 'lib', './bar', './my-module.js', './ZipCodeValidator'];
+
+    assert.deepEqual(Object.keys(result), expected);
+  });
+
+  it('throws errors of typescript modules with syntax errors', () => {
+    const precinctFunc = () =>
+      precinct(`import { square, diag } from 'lib';
+console.log(diag(4, 3); // error, missing bracket
+`);
+    expect(precinctFunc).to.throw();
+  });
+
+  it('supports the object form of type configuration', () => {
+    const result = precinct(read('styles.styl'), { type: 'stylus' });
+    const expected = ['mystyles', 'styles2.styl', 'styles3.styl', 'styles4'];
+
+    assert.deepEqual(result, expected);
+  });
+
+  it('yields no dependencies for es6 modules with no imports', () => {
+    const cjs = precinct(`export const sqrt = Math.sqrt;
+export function square(x) {
+  return x * x;
+}
+export function diag(x, y) {
+  return sqrt(square(x) + square(y));
+}
+`);
+    assert.equal(Object.keys(cjs).length, 0);
+  });
+
+  it('yields no dependencies for non-modules', () => {
+    const none = precinct(`var a = new window.Foo();`);
+    assert.equal(Object.keys(none).length, 0);
+  });
+
+  it('throw on unparsable .js files', () => {
+    assert.throws(() => {
+      precinct(`{
+	"very invalid": "javascript",
+	"this", "is actually json",
+	"But" not even valid json.
+}
+`);
+    }, SyntaxError);
+  });
+
+  it('does not blow up when parsing a gruntfile #2', () => {
+    assert.doesNotThrow(() => {
+      precinct(read('Gruntfile.js'));
+    });
+  });
+
+  describe('paperwork', () => {
+    // todo: currently it doesn't work because we set it with bit-no-check
+    it.skip('returns the dependencies for the given filepath', () => {
+      assert.ok(Object.keys(precinct.paperwork(`${fixturesFullPath}/es6.js`)).length);
+      assert.ok(Object.keys(precinct.paperwork(`${fixturesFullPath}/styles.scss`)).length);
+      // todo: uncomment the next line and typescript.ts file once we have a way to ignore some component files from compiling/parsing altogether
+      // assert.ok(Object.keys(precinct.paperwork(`${fixturesFullPath}/typescript.ts`)).length);
+      assert.ok(Object.keys(precinct.paperwork(`${fixturesFullPath}/styles.css`)).length);
+    });
+
+    it('throws if the file cannot be found', () => {
+      assert.throws(() => {
+        precinct.paperwork('foo');
+      });
+    });
+
+    it('filters out core modules if options.includeCore is false', () => {
+      const deps = precinct.paperwork(`${fixturesFullPath}/coreModules.js`, {
+        includeCore: false,
+      });
+
+      assert(!deps.length);
+    });
+
+    // todo: currently it doesn't work because we set it with bit-no-check
+    it.skip('does not filter out core modules by default', () => {
+      const deps = precinct.paperwork(`${fixturesFullPath}/coreModules.js`);
+      assert(Object.keys(deps).length);
+    });
+
+    // todo: currently it doesn't work because we set it with bit-no-check
+    it.skip('supports passing detective configuration', () => {
+      const config = {
+        amd: {
+          skipLazyLoaded: true,
+        },
+      };
+
+      const deps = precinct.paperwork(`${fixturesFullPath}/amd.js`, {
+        includeCore: false,
+        amd: config.amd,
+      });
+      assert.deepEqual(deps, ['./a', './b']);
+    });
+
+    it('supports passing env detectors', () => {
+      const detector: DependencyDetector = {
+        detect: (fileContent: string) => {
+          return fileContent.indexOf('foo') === -1 ? [] : ['foo'];
+        },
+        isSupported: ({ ext }) => {
+          return ext === '.foo';
+        },
+        type: 'foo',
+      };
+      const result = precinct.paperwork(`${fixturesFullPath}/foo.foo`, {
+        envDetectors: [detector],
+      });
+      assert.deepEqual(result, []);
+
+      const result2 = precinct.paperwork(`${fixturesFullPath}/bar.foo`, {
+        envDetectors: [detector],
+      });
+      assert.deepEqual(result2, ['foo']);
+    });
+
+    describe('when given detective configuration', () => {
+      // This test case doesn't fit the current implementation of precinct.
+      it.skip('still does not filter out core module by default', () => {
+        const stub = sinon.stub().returns([]);
+        const revert = precinctNonWired.__set__('precinct', stub);
+
+        precinct.paperwork(`${fixturesFullPath}/amd.js`, {
+          amd: {
+            skipLazyLoaded: true,
+          },
+        });
+
+        assert.equal(stub.args[0][1].includeCore, true);
+        revert();
+      });
+    });
+  });
+
+  describe('when given a configuration object', () => {
+    it('passes amd config to the amd detective', () => {
+      const config = {
+        amd: {
+          skipLazyLoaded: true,
+        },
+      };
+
+      const deps = precinct(read('amd.js'), config);
+      assert.deepEqual(deps, ['./a', './b']);
+    });
+
+    describe('that sets mixedImports for es6', () => {
+      describe('for a file identified as es6', () => {
+        it('returns both the commonjs and es6 dependencies', () => {
+          const deps = precinct(
+            `import foo from './foo';
+var bar = require('./bar');`,
+            {
+              es6: {
+                mixedImports: true,
+              },
+            }
+          );
+
+          assert.equal(Object.keys(deps).length, 2);
+        });
+      });
+
+      describe('for a file identified as cjs', () => {
+        it('returns both the commonjs and es6 dependencies', () => {
+          const deps = precinct(
+            `var bar = require('./bar');
+import foo from './foo';`,
+            {
+              es6: {
+                mixedImports: true,
+              },
+            }
+          );
+
+          assert.equal(Object.keys(deps).length, 2);
+        });
+      });
+    });
+  });
+
+  describe('when lazy exported dependencies in CJS', () => {
+    it('grabs those lazy dependencies', () => {
+      const cjs = precinct(read('cjsExportLazy.js'));
+      expect(cjs).to.have.property('./amd');
+      expect(cjs).to.have.property('./es6');
+      expect(cjs).to.have.property('./es7');
+      assert.equal(Object.keys(cjs).length, 3);
+    });
+  });
+
+  describe('when given an es6 file', () => {
+    describe('that uses CJS imports for lazy dependencies', () => {
+      it('grabs the lazy imports', () => {
+        const es6 = precinct(read('es6MixedExportLazy.js'), {
+          es6: {
+            mixedImports: true,
+          },
+        });
+        expect(es6).to.have.property('./amd');
+        expect(es6).to.have.property('./es6');
+        expect(es6).to.have.property('./es7');
+        assert.equal(Object.keys(es6).length, 3);
+      });
+    });
+  });
+});

package/files-dependency-builder/precinct/index.ts

@@ -0,0 +1,250 @@
+/**
+ * this file had been forked from https://github.com/dependents/node-precinct
+ */
+import fs from 'fs-extra';
+import path from 'path';
+
+// @ts-ignore we currently have @types/node as v12, and this is available > 16. once updated, remove the ts-ignore
+import { isBuiltin } from 'module';
+
+import getModuleType from 'module-definition';
+import Walker from 'node-source-walk';
+
+import detectiveAmd from 'detective-amd';
+import detectiveStylus from 'detective-stylus';
+
+import detectiveEs6 from '@teambit/node.deps-detectors.detective-es6';
+import detectiveCss from '@teambit/styling.deps-detectors.detective-css';
+import detectiveLess from '@teambit/styling.deps-detectors.detective-less';
+import detectiveSass from '@teambit/styling.deps-detectors.detective-sass';
+import detectiveScss from '@teambit/styling.deps-detectors.detective-scss';
+import detectiveTypeScript from '@teambit/typescript.deps-detectors.detective-typescript';
+
+import { DependencyDetector, DetectorHook } from '../detector-hook';
+
+/**
+ * The file info object.
+ * - `ext` is the file extension.
+ * - `content` is the input file content.
+ * - `type` is the parsed file type from ext or content.
+ * - `ast` is the eventually consumed content by the corresponding detective.
+ */
+type FileInfo = {
+  ext: string;
+  content: string | object;
+  type: string;
+  ast: any;
+};
+
+type Options = {
+  envDetectors?: DependencyDetector[];
+  useContent?: boolean;
+  includeCore?: boolean;
+  type?: string;
+  [lang: string]: any;
+};
+
+type BuiltinDeps = string[] | Record<string, any>;
+type Detective = (fileContent: string | object, options?: any) => BuiltinDeps;
+
+const jsExt = ['.js', '.jsx', '.cjs', '.mjs'];
+
+const extToType = {
+  '.css': 'css',
+  '.sass': 'sass',
+  '.less': 'less',
+  '.scss': 'scss',
+  '.styl': 'stylus',
+  '.mts': 'ts',
+  '.cts': 'ts',
+  '.ts': 'ts',
+  '.tsx': 'ts',
+};
+
+const typeToDetective: Record<string, Detective> = {
+  css: detectiveCss,
+  sass: detectiveSass,
+  less: detectiveLess,
+  scss: detectiveScss,
+  stylus: detectiveStylus,
+  ts: detectiveTypeScript,
+  commonjs: detectiveEs6,
+  es6: detectiveEs6,
+  amd: detectiveAmd,
+};
+
+const debug = require('debug')('precinct');
+
+const detectorHook = new DetectorHook();
+
+const assign = (o1, o2) => {
+  // eslint-disable-next-line
+  for (const key in o2) {
+    // eslint-disable-next-line
+    if (o2.hasOwnProperty(key)) {
+      o1[key] = o2[key];
+    }
+  }
+
+  return o1;
+};
+
+/**
+ * Get file info from the given file path.
+ */
+const getFileInfo = (filename: string): FileInfo => {
+  const ext = path.extname(filename);
+  const content = fs.readFileSync(filename, 'utf8');
+  return {
+    ext,
+    content,
+    // determined later
+    type: '',
+    // initialized with the content
+    ast: content,
+  };
+};
+
+/**
+ * Get the non-JS detective for the given file info.
+ * The type of the file would be determined as well.
+ * Return undefined if no proper detective found, perhaps it's plain
+ * JavaScript or unknown content. We can deal with it later.
+ */
+const getDetector = (fileInfo: FileInfo, options?: Options): Detective | undefined => {
+  const { ext } = fileInfo;
+  const normalizedOptions: Options = options || {};
+
+  // from env detectors
+  if (options?.envDetectors) {
+    for (const detector of options.envDetectors) {
+      if (detector.isSupported({ ext })) {
+        fileInfo.type = detector.type || '';
+        return detector.detect as Detective;
+      }
+    }
+  }
+
+  // from builtin detectors
+  // - check `fileInfo.type` first to support `precinct(content, { type })`
+  const type = fileInfo.type || extToType[ext];
+  if (typeToDetective[type]) {
+    const detective = typeToDetective[type];
+    fileInfo.type = type;
+    // special logic for tsx files
+    if (ext === '.tsx') {
+      if (!normalizedOptions.ts) normalizedOptions.ts = {};
+      normalizedOptions.ts.jsx = true;
+    }
+    return detective;
+  }
+
+  // from global detector hook (legacy)
+  if (detectorHook.isSupported(ext)) {
+    const detector = detectorHook.getDetector(ext);
+    if (detector) {
+      fileInfo.type = ext;
+      typeToDetective[ext] = detector.detect as Detective;
+      return detector.detect as Detective;
+    }
+  }
+
+  return undefined;
+};
+
+/**
+ * Get the JS detective (amd/es6/cjs) for the given file info.
+ * The type and ast of the file would be determined as well.
+ */
+const getJsDetector = (fileInfo: FileInfo, options?: Options): Detective | undefined => {
+  if (!jsExt.includes(fileInfo.ext)) {
+    return undefined;
+  }
+
+  if (typeof fileInfo.content !== 'object') {
+    const walker = new Walker();
+    try {
+      fileInfo.ast = walker.parse(fileInfo.content);
+    } catch (e: any) {
+      debug('could not parse content: %s', e.message);
+      throw e;
+    }
+  }
+
+  const useContent = options?.useContent;
+  const type = useContent ? getModuleType.fromSource(fileInfo.content) : getModuleType.fromSource(fileInfo.ast);
+  const detector = typeToDetective[type];
+  fileInfo.type = type;
+
+  return detector;
+};
+
+/**
+ * Normalize the deps into an array.
+ */
+const normalizeDeps = (deps: BuiltinDeps, includeCore?: boolean): string[] => {
+  const normalizedDeps = Array.isArray(deps) ? deps : Object.keys(deps);
+  return includeCore ? normalizedDeps : normalizedDeps.filter((d) => !isBuiltin(d));
+};
+
+const getDepsFromFile = (filename: string, options?: Options): string[] => {
+  const normalizedOptions: Options = assign({ includeCore: true }, options || {});
+  const fileInfo = getFileInfo(filename);
+  if (
+    typeof fileInfo.content === 'string' &&
+    (fileInfo.content.startsWith('// @bit-no-check') || fileInfo.content.startsWith('/* @bit-no-check'))
+  ) {
+    debug(`skipping file ${filename}, it has a @bit-no-check comment`);
+    return [];
+  }
+
+  const detective = getDetector(fileInfo, normalizedOptions) || getJsDetector(fileInfo, normalizedOptions);
+  if (!detective) {
+    debug(`skipping unsupported file ${filename}`);
+    return [];
+  }
+  debug('module type: ', fileInfo.type);
+
+  const deps = detective(fileInfo.ast, normalizedOptions[fileInfo.type]);
+
+  return normalizeDeps(deps, normalizedOptions?.includeCore);
+};
+
+/**
+ * Finds the list of dependencies for the given file
+ *
+ * @param {String|Object} content - File's content or AST
+ * @param {Object} [options]
+ * @param {String} [options.type] - The type of content being passed in. Useful if you want to use a non-js detective
+ * @return {String[]}
+ */
+// eslint-disable-next-line complexity
+const precinct = (content: string | object, options?: string | Options): BuiltinDeps => {
+  // Legacy form backCompat where type was the second parameter
+  const normalizedOptions: Options = typeof options === 'string' ? { type: options } : options || {};
+  const type = normalizedOptions.type || '';
+
+  debug('options given: ', normalizedOptions);
+
+  const fileInfo: FileInfo = {
+    content,
+    ast: content,
+    ext: type ? '' : '.js',
+    type,
+  };
+
+  const detective = getDetector(fileInfo, normalizedOptions) || getJsDetector(fileInfo, normalizedOptions);
+  if (!detective) {
+    return [];
+  }
+
+  const deps = detective(fileInfo.ast, normalizedOptions[fileInfo.type]);
+  // @ts-ignore
+  precinct.ast = detective.ast || fileInfo.ast;
+
+  return deps;
+};
+
+precinct.paperwork = getDepsFromFile;
+
+export default precinct;

package/files-dependency-builder/types/dependency-tree-type.ts

@@ -0,0 +1,46 @@
+import { ImportSpecifier } from '@teambit/legacy/dist/consumer/component/dependencies/dependency';
+import { ResolvedPackageData } from '../../resolve-pkg-data';
+import { DependencyDetector } from '../detector-hook';
+import { isEmpty } from 'lodash';
+
+export type FileObject = {
+  file: string;
+  importSpecifiers?: ImportSpecifier[];
+  importSource?: string;
+};
+
+type MissingType = 'files' | 'packages';
+
+export class DependenciesTreeItem {
+  files: FileObject[] = [];
+  packages: { [packageName: string]: string } = {}; // pkgName: pkgVersion
+  unidentifiedPackages: string[] = [];
+  components: ResolvedPackageData[] = [];
+  error?: Error; // error.code is either PARSING_ERROR or RESOLVE_ERROR
+  missing?: { [key in MissingType]: string[] };
+
+  isEmpty() {
+    return (
+      !this.files.length &&
+      isEmpty(this.packages) &&
+      !this.unidentifiedPackages.length &&
+      !this.components.length &&
+      !this.error &&
+      !this.missing
+    );
+  }
+}
+
+export type DependenciesTree = {
+  [filePath: string]: DependenciesTreeItem;
+};
+
+export type DependencyTreeParams = {
+  componentDir: string;
+  workspacePath: string;
+  filePaths: string[];
+  visited?: Record<string, any>;
+  cacheResolvedDependencies?: Record<string, any>;
+  cacheProjectAst?: Record<string, any>;
+  envDetectors?: DependencyDetector[] | null;
+};

package/files-dependency-builder/types/index.ts

@@ -0,0 +1,3 @@
+/* THIS IS A BIT-AUTO-GENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. */
+
+module.exports = require('./dependency-tree-type');