Add factory around importer that takes args, rename to makeFsImporter

Author: phated

src/__tests__/main-test.js

@@ -216,7 +216,8 @@ describe('main', () => {
     });
   });
 
-  // Fixures uses the resolveImports importer even though it is not the default
+  // Fixures uses the filesystem importer for easier e2e tests
+  // even though it is not the default
   describe('fixtures', () => {
     const fixturePath = path.join(__dirname, 'fixtures');
     const fileNames = fs.readdirSync(fixturePath);
@@ -228,7 +229,7 @@ describe('main', () => {
         let result;
         expect(() => {
           result = parse(fileContent, null, null, {
-            importer: importers.resolveImports,
+            importer: importers.makeFsImporter(),
             filename: filePath,
             babelrc: false,
           });

src/importer/index.js

@@ -8,6 +8,6 @@
  */
 
 import ignoreImports from './ignoreImports';
-import resolveImports from './resolveImports';
+import makeFsImporter from './makeFsImporter';
 
-export { ignoreImports, resolveImports };
+export { ignoreImports, makeFsImporter };

src/importer/makeFsImporter.js

@@ -0,0 +1,148 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ */
+
+import { namedTypes as t, NodePath } from 'ast-types';
+import { traverseShallow } from '../utils/traverse';
+import resolve from 'resolve';
+import { dirname } from 'path';
+import buildParser, { type Options } from '../babelParser';
+import fs from 'fs';
+
+function defaultLookupModule(filename, basedir) {
+  return resolve.sync(filename, {
+    basedir,
+    extensions: ['.js', '.jsx', '.mjs', '.ts', '.tsx'],
+  });
+}
+
+// Factory for the resolveImports importer
+export default function makeFsImporter(
+  lookupModule: (
+    filename: string,
+    basedir: string,
+  ) => string = defaultLookupModule,
+  cache: Map<string, NodePath> = new Map(),
+) {
+  return resolveImportedValue;
+
+  function resolveImportedValue(
+    path: NodePath,
+    name: string,
+    seen: Set<string> = new Set(),
+  ) {
+    // Bail if no filename was provided for the current source file.
+    // Also never traverse into react itself.
+    const source = path.node.source.value;
+    const options = getOptions(path);
+    if (!options || !options.filename || source === 'react') {
+      return null;
+    }
+
+    // Resolve the imported module using the Node resolver
+    const basedir = dirname(options.filename);
+    let resolvedSource;
+
+    try {
+      resolvedSource = lookupModule(source, basedir);
+    } catch (err) {
+      return null;
+    }
+
+    // Prevent recursive imports
+    if (seen.has(resolvedSource)) {
+      return null;
+    }
+
+    seen.add(resolvedSource);
+
+    let nextPath = cache.get(resolvedSource);
+    if (!nextPath) {
+      // Read and parse the code
+      const src = fs.readFileSync(resolvedSource, 'utf8');
+      const parseOptions: Options = {
+        ...options,
+        parserOptions: {},
+        filename: resolvedSource,
+      };
+
+      const parser = buildParser(parseOptions);
+      const ast = parser.parse(src);
+      ast.__src = src;
+      nextPath = new NodePath(ast).get('program');
+      cache.set(resolvedSource, nextPath);
+    }
+
+    return findExportedValue(nextPath, name, seen);
+  }
+
+  // Find the root Program node, which we attached our options too in babelParser.js
+  function getOptions(path: NodePath): Options {
+    while (!t.Program.check(path.node)) {
+      path = path.parentPath;
+    }
+
+    return path.node.options || {};
+  }
+
+  // Traverses the program looking for an export that matches the requested name
+  function findExportedValue(programPath, name, seen) {
+    let resultPath: ?NodePath = null;
+
+    traverseShallow(programPath, {
+      visitExportNamedDeclaration(path: NodePath) {
+        const { declaration, specifiers, source } = path.node;
+        if (declaration && declaration.id && declaration.id.name === name) {
+          resultPath = path.get('declaration');
+        } else if (declaration && declaration.declarations) {
+          path.get('declaration', 'declarations').each((declPath: NodePath) => {
+            const decl = declPath.node;
+            // TODO: ArrayPattern and ObjectPattern
+            if (
+              t.Identifier.check(decl.id) &&
+              decl.id.name === name &&
+              decl.init
+            ) {
+              resultPath = declPath.get('init');
+            }
+          });
+        } else if (specifiers) {
+          path.get('specifiers').each((specifierPath: NodePath) => {
+            if (specifierPath.node.exported.name === name) {
+              if (source) {
+                const local = specifierPath.node.local.name;
+                resultPath = resolveImportedValue(path, local, seen);
+              } else {
+                resultPath = specifierPath.get('local');
+              }
+            }
+          });
+        }
+
+        return false;
+      },
+      visitExportDefaultDeclaration(path: NodePath) {
+        if (name === 'default') {
+          resultPath = path.get('declaration');
+        }
+
+        return false;
+      },
+      visitExportAllDeclaration(path: NodePath) {
+        const resolvedPath = resolveImportedValue(path, name, seen);
+        if (resolvedPath) {
+          resultPath = resolvedPath;
+        }
+
+        return false;
+      },
+    });
+
+    return resultPath;
+  }
+}