Thread importer through resolveToModule

Author: phated

src/handlers/propTypeCompositionHandler.js

@@ -18,8 +18,8 @@ import type { Importer } from '../types';
  * It resolves the path to its module name and adds it to the "composes" entry
  * in the documentation.
  */
-function amendComposes(documentation, path) {
-  const moduleName = resolveToModule(path);
+function amendComposes(documentation, path, importer) {
+  const moduleName = resolveToModule(path, importer);
   if (moduleName) {
     documentation.addComposes(moduleName);
   }
@@ -32,6 +32,7 @@ function processObjectExpression(documentation, path, importer) {
         amendComposes(
           documentation,
           resolveToValue(propertyPath.get('argument'), importer),
+          importer
         );
         break;
     }
@@ -57,7 +58,7 @@ export default function propTypeCompositionHandler(
       processObjectExpression(documentation, propTypesPath, importer);
       break;
     default:
-      amendComposes(documentation, propTypesPath);
+      amendComposes(documentation, propTypesPath, importer);
       break;
   }
 }

src/handlers/propTypeHandler.js

@@ -19,8 +19,8 @@ import resolveToValue from '../utils/resolveToValue';
 import type Documentation from '../Documentation';
 import type { Importer } from '../types';
 
-function isPropTypesExpression(path) {
-  const moduleName = resolveToModule(path);
+function isPropTypesExpression(path, importer) {
+  const moduleName = resolveToModule(path, importer);
   if (moduleName) {
     return isReactModuleName(moduleName) || moduleName === 'ReactPropTypes';
   }
@@ -40,7 +40,7 @@ function amendPropTypes(getDescriptor, path, importer) {
 
         const propDescriptor = getDescriptor(propName);
         const valuePath = propertyPath.get('value');
-        const type = isPropTypesExpression(valuePath)
+        const type = isPropTypesExpression(valuePath, importer)
           ? getPropType(valuePath, importer)
           : { name: 'custom', raw: printValue(valuePath) };
 

src/utils/isReactBuiltinCall.js

@@ -28,7 +28,7 @@ export default function isReactBuiltinCall(
   }
 
   if (match(path.node, { callee: { property: { name } } })) {
-    const module = resolveToModule(path.get('callee', 'object'));
+    const module = resolveToModule(path.get('callee', 'object'), importer);
     return Boolean(module && isReactModuleName(module));
   }
 
@@ -47,7 +47,7 @@ export default function isReactBuiltinCall(
           specifier => specifier.imported && specifier.imported.name === name,
         ))
     ) {
-      const module = resolveToModule(value);
+      const module = resolveToModule(value, importer);
       return Boolean(module && isReactModuleName(module));
     }
   }

src/utils/isReactChildrenElementCall.js

@@ -11,12 +11,13 @@ import { namedTypes as t } from 'ast-types';
 import isReactModuleName from './isReactModuleName';
 import match from './match';
 import resolveToModule from './resolveToModule';
+import type { Importer } from '../types';
 
 /**
  * Returns true if the expression is a function call of the form
  * `React.Children.only(...)`.
  */
-export default function isReactChildrenElementCall(path: NodePath): boolean {
+export default function isReactChildrenElementCall(path: NodePath, importer: Importer): boolean {
   if (t.ExpressionStatement.check(path.node)) {
     path = path.get('expression');
   }
@@ -26,7 +27,7 @@ export default function isReactChildrenElementCall(path: NodePath): boolean {
   }
 
   const calleeObj = path.get('callee', 'object');
-  const module = resolveToModule(calleeObj);
+  const module = resolveToModule(calleeObj, importer);
 
   if (!match(calleeObj, { value: { property: { name: 'Children' } } })) {
     return false;

src/utils/isReactComponentClass.js

@@ -49,7 +49,7 @@ export default function isReactComponentClass(
     match(superClass.node, { property: { name: 'Component' } }) ||
     match(superClass.node, { property: { name: 'PureComponent' } })
   ) {
-    const module = resolveToModule(superClass);
+    const module = resolveToModule(superClass, importer);
     if (module && isReactModuleName(module)) {
       return true;
     }

src/utils/isReactCreateClassCall.js

@@ -20,15 +20,15 @@ import type { Importer } from '../types';
  * createReactClass(...);
  * ```
  */
-function isReactCreateClassCallModular(path: NodePath): boolean {
+function isReactCreateClassCallModular(path: NodePath, importer: Importer): boolean {
   if (t.ExpressionStatement.check(path.node)) {
     path = path.get('expression');
   }
 
   if (!match(path.node, { type: 'CallExpression' })) {
     return false;
   }
-  const module = resolveToModule(path);
+  const module = resolveToModule(path, importer);
   return Boolean(module && module === 'create-react-class');
 }
 
@@ -46,6 +46,6 @@ export default function isReactCreateClassCall(
 ): boolean {
   return (
     isReactBuiltinCall(path, 'createClass', importer) ||
-    isReactCreateClassCallModular(path)
+    isReactCreateClassCallModular(path, importer)
   );
 }

src/utils/isStatelessComponent.js

@@ -32,7 +32,7 @@ function isJSXElementOrReactCall(path, importer: Importer) {
       isReactCreateElementCall(path, importer)) ||
     (path.node.type === 'CallExpression' &&
       isReactCloneElementCall(path, importer)) ||
-    (path.node.type === 'CallExpression' && isReactChildrenElementCall(path))
+    (path.node.type === 'CallExpression' && isReactChildrenElementCall(path, importer))
   );
 }
 

src/utils/resolveToModule.js

@@ -10,32 +10,31 @@
 import { namedTypes as t } from 'ast-types';
 import match from './match';
 import resolveToValue from './resolveToValue';
-import ignoreImports from '../importer/ignoreImports';
+import type { Importer } from '../types';
 
 /**
  * Given a path (e.g. call expression, member expression or identifier),
  * this function tries to find the name of module from which the "root value"
  * was imported.
  */
-export default function resolveToModule(path: NodePath): ?string {
+export default function resolveToModule(path: NodePath, importer: Importer): ?string {
   const node = path.node;
   switch (node.type) {
     case t.VariableDeclarator.name:
       if (node.init) {
-        return resolveToModule(path.get('init'));
+        return resolveToModule(path.get('init'), importer);
       }
       break;
     case t.CallExpression.name:
       if (match(node.callee, { type: t.Identifier.name, name: 'require' })) {
         return node.arguments[0].value;
       }
-      return resolveToModule(path.get('callee'));
+      return resolveToModule(path.get('callee'), importer);
     case t.Identifier.name:
     case t.JSXIdentifier.name: {
-      // TODO: Do we want to resolve imports here?
-      const valuePath = resolveToValue(path, ignoreImports);
+      const valuePath = resolveToValue(path, importer);
       if (valuePath !== path) {
-        return resolveToModule(valuePath);
+        return resolveToModule(valuePath, importer);
       }
       break;
     }
@@ -46,7 +45,7 @@ export default function resolveToModule(path: NodePath): ?string {
         path = path.get('object');
       }
       if (path) {
-        return resolveToModule(path);
+        return resolveToModule(path, importer);
       }
   }