Support 'memo(forwardRef(...'

Author: mfazekas

src/handlers/__tests__/__snapshots__/defaultPropsHandler-test.ts.snap

@@ -561,6 +561,17 @@ Object {
 }
 `;
 
+exports[`defaultPropsHandler forwardRef resolves default props when memo used 1`] = `
+Object {
+  "foo": Object {
+    "defaultValue": Object {
+      "computed": false,
+      "value": "'bar'",
+    },
+  },
+}
+`;
+
 exports[`defaultPropsHandler forwardRef resolves defaultProps 1`] = `
 Object {
   "foo": Object {

src/handlers/__tests__/defaultPropsHandler-test.ts

@@ -573,6 +573,19 @@ describe('defaultPropsHandler', () => {
       expect(documentation.descriptors).toMatchSnapshot();
     });
 
+    it('resolves default props when memo used', () => {
+      const src = `
+        import React from 'react';
+        React.memo(React.forwardRef(({ foo = 'bar' }, ref) => <div ref={ref}>{foo}</div>));
+      `;
+      defaultPropsHandler(
+        documentation,
+        parse(src).get('body', 1, 'expression'),
+        noopImporter,
+      );
+      expect(documentation.descriptors).toMatchSnapshot();
+    });
+
     it('resolves imported default props in the parameters', () => {
       const src = `
         import baz from 'baz';

src/handlers/componentDocblockHandler.ts

@@ -5,12 +5,29 @@ import isReactForwardRefCall from '../utils/isReactForwardRefCall';
 import resolveToValue from '../utils/resolveToValue';
 import type { Importer } from '../parse';
 import type { NodePath } from 'ast-types/lib/node-path';
+import isReactBuiltinCall from '../utils/isReactBuiltinCall';
 
 function isClassDefinition(nodePath: NodePath): boolean {
   const node = nodePath.node;
   return t.ClassDeclaration.check(node) || t.ClassExpression.check(node);
 }
 
+function resolveReactHOCs(path: NodePath, importer: Importer) {
+  let actPath = path;
+  let changed = false;
+  do {
+    changed = false;
+    if (isReactForwardRefCall(path, importer)) {
+      actPath = path.get('arguments', 0);
+      changed = true;
+    } else if (isReactBuiltinCall(path, 'memo', importer)) {
+      actPath = path.get('arguments', 0);
+      changed = true;
+    }
+  } while (changed);
+  return actPath;
+}
+
 function getDocblockFromComponent(
   path: NodePath,
   importer: Importer,
@@ -45,10 +62,7 @@ function getDocblockFromComponent(
     }
   }
   if (!description) {
-    const searchPath = isReactForwardRefCall(path, importer)
-      ? path.get('arguments', 0)
-      : path;
-    const inner = resolveToValue(searchPath, importer);
+    const inner = resolveToValue(resolveReactHOCs(path, importer), importer);
     if (inner.node !== path.node) {
       return getDocblockFromComponent(inner, importer);
     }

src/handlers/defaultPropsHandler.ts

@@ -9,6 +9,7 @@ import isReactForwardRefCall from '../utils/isReactForwardRefCall';
 import type Documentation from '../Documentation';
 import type { Importer } from '../parse';
 import type { NodePath } from 'ast-types/lib/node-path';
+import isReactBuiltinCall from '../utils/isReactBuiltinCall';
 
 function getDefaultValue(path: NodePath, importer: Importer) {
   let node = path.node;
@@ -46,12 +47,21 @@ function getStatelessPropsPath(
   componentDefinition: NodePath,
   importer: Importer,
 ): NodePath {
-  const value = resolveToValue(componentDefinition, importer);
-  if (isReactForwardRefCall(value, importer)) {
-    const inner = resolveToValue(value.get('arguments', 0), importer);
-    return inner.get('params', 0);
-  }
-  return value.get('params', 0);
+  let actPath = componentDefinition;
+  let changed = false;
+  do {
+    changed = false;
+    const value = resolveToValue(actPath, importer);
+    if (
+      isReactBuiltinCall(value, 'memo', importer) ||
+      isReactForwardRefCall(value, importer)
+    ) {
+      actPath = resolveToValue(actPath.get('arguments', 0), importer);
+      changed = true;
+    }
+  } while (changed);
+
+  return actPath.get('params', 0);
 }
 
 function getDefaultPropsPath(