@teambit/dependencies 1.0.330 → 1.0.331

package/dist/files-dependency-builder/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_buildTree","data","require","_precinct","_interopRequireDefault","e","__esModule","default"],"sources":["index.ts"],"sourcesContent":["import { getDependencyTree } from './build-tree';\n// @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!\nimport getDependenciesFromSource from './precinct';\n\nexport { getDependencyTree, getDependenciesFromSource };\n"],"mappings":";;;;;;;;;;;;;;;;;AAAA,SAAAA,WAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,UAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA,SAAAE,UAAA;EAAA,MAAAF,IAAA,GAAAG,sBAAA,CAAAF,OAAA;EAAAC,SAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAAmD,SAAAG,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA","ignoreList":[]}

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

@@ -0,0 +1,34 @@
+import { ResolvedPackageData } from '../resolve-pkg-data';
+import { Missing } from './generate-tree-madge';
+export type MissingGroupItem = {
+    originFile: string;
+    packages?: string[];
+    files?: string[];
+};
+export type FoundPackages = {
+    packages: {
+        [packageName: string]: string;
+    };
+    components: ResolvedPackageData[];
+};
+export declare class MissingHandler {
+    private missing;
+    private componentDir;
+    private workspacePath;
+    constructor(missing: Missing, componentDir: string, 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;
+    };
+    private processMissingGroup;
+    /**
+     * 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;
+}

package/dist/files-dependency-builder/missing-handler.js

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MissingHandler = void 0;
+function _legacy() {
+  const data = require("@teambit/legacy.utils");
+  _legacy = function () {
+    return data;
+  };
+  return data;
+}
+function _resolvePkgData() {
+  const data = require("../resolve-pkg-data");
+  _resolvePkgData = function () {
+    return data;
+  };
+  return data;
+}
+function _generateTreeMadge() {
+  const data = require("./generate-tree-madge");
+  _generateTreeMadge = function () {
+    return data;
+  };
+  return data;
+}
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+class MissingHandler {
+  constructor(missing, componentDir, workspacePath) {
+    this.missing = missing;
+    this.componentDir = componentDir;
+    this.workspacePath = workspacePath;
+  }
+
+  /**
+   * Run over each entry in the missing array and transform the missing from list of paths
+   * to object with missing types
+   */
+  groupAndFindMissing() {
+    const missingGroups = this.groupMissingByType();
+    missingGroups.forEach(group => {
+      if (group.packages) group.packages = group.packages.map(_legacy().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 = {
+      packages: {},
+      components: []
+    };
+    missingGroups.forEach(group => this.processMissingGroup(group, foundPackages));
+    return {
+      missingGroups,
+      foundPackages
+    };
+  }
+  processMissingGroup(group, foundPackages) {
+    if (!group.packages) return;
+    const missingPackages = [];
+    group.packages.forEach(packageName => {
+      // Don't try to resolve the same package twice
+      if (missingPackages.includes(packageName)) return;
+      const resolvedPath = (0, _legacy().resolvePackagePath)(packageName, this.componentDir, this.workspacePath);
+      if (!resolvedPath) {
+        missingPackages.push(packageName);
+        return;
+      }
+      const resolvedPackageData = (0, _resolvePkgData().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
+   */
+  groupMissingByType() {
+    const byPathType = item => item.startsWith('.') ? 'files' : 'packages';
+    return Object.keys(this.missing).map(key => Object.assign({
+      originFile: (0, _generateTreeMadge().processPath)(key, {}, this.componentDir)
+    }, (0, _lodash().groupBy)(this.missing[key], byPathType)));
+  }
+}
+exports.MissingHandler = MissingHandler;
+
+//# sourceMappingURL=missing-handler.js.map

package/dist/files-dependency-builder/missing-handler.js.map

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

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

@@ -0,0 +1,20 @@
+/**
+ * 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 { Specifier } from '@teambit/legacy/dist/consumer/component/dependencies/dependency';
+export type PathMapDependency = {
+    importSource: string;
+    resolvedDep: string;
+    importSpecifiers?: Specifier[];
+};
+/**
+ * PathMap is used to get the ImportSpecifiers from dependency-tree library
+ */
+export type PathMapItem = {
+    file: string;
+    dependencies: PathMapDependency[];
+};
+export declare function convertPathMapToRelativePaths(pathMap: PathMapItem[], baseDir: string): PathMapItem[];

package/dist/files-dependency-builder/path-map.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertPathMapToRelativePaths = convertPathMapToRelativePaths;
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function _generateTreeMadge() {
+  const data = require("./generate-tree-madge");
+  _generateTreeMadge = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * 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.
+ */
+
+/**
+ * PathMap is used to get the ImportSpecifiers from dependency-tree library
+ */
+
+function convertPathMapToRelativePaths(pathMap, baseDir) {
+  const pathCache = {};
+  return pathMap.map(file => {
+    const newFile = (0, _lodash().clone)(file);
+    newFile.file = (0, _generateTreeMadge().processPath)(file.file, pathCache, baseDir);
+    newFile.dependencies = file.dependencies.map(dependency => {
+      const newDependency = (0, _lodash().clone)(dependency);
+      newDependency.resolvedDep = (0, _generateTreeMadge().processPath)(dependency.resolvedDep, pathCache, baseDir);
+      return newDependency;
+    });
+    return newFile;
+  });
+}
+
+//# sourceMappingURL=path-map.js.map

package/dist/files-dependency-builder/path-map.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_lodash","data","require","_generateTreeMadge","convertPathMapToRelativePaths","pathMap","baseDir","pathCache","map","file","newFile","clone","processPath","dependencies","dependency","newDependency","resolvedDep"],"sources":["path-map.ts"],"sourcesContent":["/**\n * Path Map is the extra data about the files and the dependencies, such as ImportSpecifiers and\n * custom-resolve-modules used.\n * The data is retrieved by dependency-tree which collects them from the various detectives.\n * It is used to update the final tree.\n */\n\nimport { clone } from 'lodash';\nimport { processPath } from './generate-tree-madge';\nimport { Specifier } from '@teambit/legacy/dist/consumer/component/dependencies/dependency';\n\nexport type PathMapDependency = {\n  importSource: string; // dependency path as it has been received from dependency-tree lib\n  resolvedDep: string; // path relative to consumer root (after convertPathMapToRelativePaths() )\n  importSpecifiers?: Specifier[]; // relevant for ES6 and TS\n};\n\n/**\n * PathMap is used to get the ImportSpecifiers from dependency-tree library\n */\nexport type PathMapItem = {\n  file: string; // path relative to consumer root (after convertPathMapToRelativePaths() )\n  dependencies: PathMapDependency[];\n};\n\nexport function convertPathMapToRelativePaths(pathMap: PathMapItem[], baseDir: string): PathMapItem[] {\n  const pathCache = {};\n  return pathMap.map((file: PathMapItem) => {\n    const newFile = clone(file);\n    newFile.file = processPath(file.file, pathCache, baseDir);\n    newFile.dependencies = file.dependencies.map((dependency) => {\n      const newDependency = clone(dependency);\n      newDependency.resolvedDep = processPath(dependency.resolvedDep, pathCache, baseDir);\n      return newDependency;\n    });\n    return newFile;\n  });\n}\n"],"mappings":";;;;;;AAOA,SAAAA,QAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,OAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,mBAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,kBAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AARA;AACA;AACA;AACA;AACA;AACA;;AAYA;AACA;AACA;;AAMO,SAASG,6BAA6BA,CAACC,OAAsB,EAAEC,OAAe,EAAiB;EACpG,MAAMC,SAAS,GAAG,CAAC,CAAC;EACpB,OAAOF,OAAO,CAACG,GAAG,CAAEC,IAAiB,IAAK;IACxC,MAAMC,OAAO,GAAG,IAAAC,eAAK,EAACF,IAAI,CAAC;IAC3BC,OAAO,CAACD,IAAI,GAAG,IAAAG,gCAAW,EAACH,IAAI,CAACA,IAAI,EAAEF,SAAS,EAAED,OAAO,CAAC;IACzDI,OAAO,CAACG,YAAY,GAAGJ,IAAI,CAACI,YAAY,CAACL,GAAG,CAAEM,UAAU,IAAK;MAC3D,MAAMC,aAAa,GAAG,IAAAJ,eAAK,EAACG,UAAU,CAAC;MACvCC,aAAa,CAACC,WAAW,GAAG,IAAAJ,gCAAW,EAACE,UAAU,CAACE,WAAW,EAAET,SAAS,EAAED,OAAO,CAAC;MACnF,OAAOS,aAAa;IACtB,CAAC,CAAC;IACF,OAAOL,OAAO;EAChB,CAAC,CAAC;AACJ","ignoreList":[]}

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

@@ -0,0 +1,22 @@
+import { DependencyDetector } from '../detector-hook';
+type Options = {
+    envDetectors?: DependencyDetector[];
+    useContent?: boolean;
+    includeCore?: boolean;
+    type?: string;
+    [lang: string]: any;
+};
+type BuiltinDeps = string[] | Record<string, any>;
+/**
+ * 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[]}
+ */
+declare const precinct: {
+    (content: string | object, options?: string | Options): BuiltinDeps;
+    paperwork: (filename: string, options?: Options) => string[];
+};
+export default precinct;

package/dist/files-dependency-builder/precinct/index.js

@@ -0,0 +1,306 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _fsExtra() {
+  const data = _interopRequireDefault(require("fs-extra"));
+  _fsExtra = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _module() {
+  const data = require("module");
+  _module = function () {
+    return data;
+  };
+  return data;
+}
+function _moduleDefinition() {
+  const data = _interopRequireDefault(require("module-definition"));
+  _moduleDefinition = function () {
+    return data;
+  };
+  return data;
+}
+function _nodeSourceWalk() {
+  const data = _interopRequireDefault(require("node-source-walk"));
+  _nodeSourceWalk = function () {
+    return data;
+  };
+  return data;
+}
+function _detectiveAmd() {
+  const data = _interopRequireDefault(require("detective-amd"));
+  _detectiveAmd = function () {
+    return data;
+  };
+  return data;
+}
+function _detectiveStylus() {
+  const data = _interopRequireDefault(require("detective-stylus"));
+  _detectiveStylus = function () {
+    return data;
+  };
+  return data;
+}
+function _nodeDepsDetectors() {
+  const data = _interopRequireDefault(require("@teambit/node.deps-detectors.detective-es6"));
+  _nodeDepsDetectors = function () {
+    return data;
+  };
+  return data;
+}
+function _stylingDepsDetectors() {
+  const data = _interopRequireDefault(require("@teambit/styling.deps-detectors.detective-css"));
+  _stylingDepsDetectors = function () {
+    return data;
+  };
+  return data;
+}
+function _stylingDepsDetectors2() {
+  const data = _interopRequireDefault(require("@teambit/styling.deps-detectors.detective-less"));
+  _stylingDepsDetectors2 = function () {
+    return data;
+  };
+  return data;
+}
+function _stylingDepsDetectors3() {
+  const data = _interopRequireDefault(require("@teambit/styling.deps-detectors.detective-sass"));
+  _stylingDepsDetectors3 = function () {
+    return data;
+  };
+  return data;
+}
+function _stylingDepsDetectors4() {
+  const data = _interopRequireDefault(require("@teambit/styling.deps-detectors.detective-scss"));
+  _stylingDepsDetectors4 = function () {
+    return data;
+  };
+  return data;
+}
+function _typescriptDepsDetectors() {
+  const data = _interopRequireDefault(require("@teambit/typescript.deps-detectors.detective-typescript"));
+  _typescriptDepsDetectors = function () {
+    return data;
+  };
+  return data;
+}
+function _detectorHook() {
+  const data = require("../detector-hook");
+  _detectorHook = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * this file had been forked from https://github.com/dependents/node-precinct
+ */
+
+// @ts-ignore we currently have @types/node as v12, and this is available > 16. once updated, remove the ts-ignore
+
+/**
+ * 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.
+ */
+
+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 = {
+  css: _stylingDepsDetectors().default,
+  sass: _stylingDepsDetectors3().default,
+  less: _stylingDepsDetectors2().default,
+  scss: _stylingDepsDetectors4().default,
+  stylus: _detectiveStylus().default,
+  ts: _typescriptDepsDetectors().default,
+  commonjs: _nodeDepsDetectors().default,
+  es6: _nodeDepsDetectors().default,
+  amd: _detectiveAmd().default
+};
+const debug = require('debug')('precinct');
+const detectorHook = new (_detectorHook().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 => {
+  const ext = _path().default.extname(filename);
+  const content = _fsExtra().default.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, options) => {
+  const {
+    ext
+  } = fileInfo;
+  const normalizedOptions = options || {};
+
+  // from env detectors
+  if (options?.envDetectors) {
+    for (const detector of options.envDetectors) {
+      if (detector.isSupported({
+        ext
+      })) {
+        fileInfo.type = detector.type || '';
+        return detector.detect;
+      }
+    }
+  }
+
+  // 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;
+      return detector.detect;
+    }
+  }
+  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, options) => {
+  if (!jsExt.includes(fileInfo.ext)) {
+    return undefined;
+  }
+  if (typeof fileInfo.content !== 'object') {
+    const walker = new (_nodeSourceWalk().default)();
+    try {
+      fileInfo.ast = walker.parse(fileInfo.content);
+    } catch (e) {
+      debug('could not parse content: %s', e.message);
+      throw e;
+    }
+  }
+  const useContent = options?.useContent;
+  const type = useContent ? _moduleDefinition().default.fromSource(fileInfo.content) : _moduleDefinition().default.fromSource(fileInfo.ast);
+  const detector = typeToDetective[type];
+  fileInfo.type = type;
+  return detector;
+};
+
+/**
+ * Normalize the deps into an array.
+ */
+const normalizeDeps = (deps, includeCore) => {
+  const normalizedDeps = Array.isArray(deps) ? deps : Object.keys(deps);
+  return includeCore ? normalizedDeps : normalizedDeps.filter(d => !(0, _module().isBuiltin)(d));
+};
+const getDepsFromFile = (filename, options) => {
+  const normalizedOptions = 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, options) => {
+  // Legacy form backCompat where type was the second parameter
+  const normalizedOptions = typeof options === 'string' ? {
+    type: options
+  } : options || {};
+  const type = normalizedOptions.type || '';
+  debug('options given: ', normalizedOptions);
+  const 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;
+var _default = exports.default = precinct;
+
+//# sourceMappingURL=index.js.map

package/dist/files-dependency-builder/precinct/index.js.map

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

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

@@ -0,0 +1 @@
+export {};