fix(defaultProps): Resolve local spreads in defaultProps

Author: danez

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

@@ -40,6 +40,23 @@ Object {
 }
 `;
 
+exports[`defaultPropsHandler ClassDeclaration with static defaultProps should resolve local spreads 1`] = `
+Object {
+  "bar": Object {
+    "defaultValue": Object {
+      "computed": false,
+      "value": "\\"foo\\"",
+    },
+  },
+  "foo": Object {
+    "defaultValue": Object {
+      "computed": false,
+      "value": "\\"bar\\"",
+    },
+  },
+}
+`;
+
 exports[`defaultPropsHandler ClassExpression with static defaultProps should find prop default values that are literals 1`] = `
 Object {
   "abc": Object {
@@ -69,6 +86,23 @@ Object {
 }
 `;
 
+exports[`defaultPropsHandler Functional components with default params resolves local spreads 1`] = `
+Object {
+  "bar": Object {
+    "defaultValue": Object {
+      "computed": false,
+      "value": "\\"foo\\"",
+    },
+  },
+  "foo": Object {
+    "defaultValue": Object {
+      "computed": false,
+      "value": "\\"bar\\"",
+    },
+  },
+}
+`;
+
 exports[`defaultPropsHandler Functional components with default params should find default props that are literals 1`] = `
 Object {
   "abc": Object {
@@ -197,6 +231,23 @@ Object {
 }
 `;
 
+exports[`defaultPropsHandler ObjectExpression resolves local spreads 1`] = `
+Object {
+  "bar": Object {
+    "defaultValue": Object {
+      "computed": false,
+      "value": "\\"foo\\"",
+    },
+  },
+  "foo": Object {
+    "defaultValue": Object {
+      "computed": false,
+      "value": "\\"bar\\"",
+    },
+  },
+}
+`;
+
 exports[`defaultPropsHandler ObjectExpression should find prop default values that are literals 1`] = `
 Object {
   "abc": Object {

src/handlers/__tests__/defaultPropsHandler-test.js

@@ -75,6 +75,26 @@ describe('defaultPropsHandler', () => {
       );
       expect(documentation.descriptors).toMatchSnapshot();
     });
+
+    it('resolves local spreads', () => {
+      const src = `
+        const other = { bar: "foo" };
+
+        ({
+          getDefaultProps: function() {
+            return {
+              foo: "bar",
+              ...other,
+            };
+          }
+        })
+      `;
+      defaultPropsHandler(
+        documentation,
+        parse(src).get('body', 1, 'expression'),
+      );
+      expect(documentation.descriptors).toMatchSnapshot();
+    });
   });
 
   describe('ClassDeclaration with static defaultProps', () => {
@@ -93,6 +113,21 @@ describe('defaultPropsHandler', () => {
       expect(documentation.descriptors).toMatchSnapshot();
     });
 
+    it('should resolve local spreads', () => {
+      const src = `
+        const other = { bar: "foo" };
+
+        class Foo {
+          static defaultProps = {
+            foo: "bar",
+            ...other
+          };
+        }
+      `;
+      defaultPropsHandler(documentation, parse(src).get('body', 1));
+      expect(documentation.descriptors).toMatchSnapshot();
+    });
+
     it('should find prop default values that are imported variables', () => {
       const src = `
         import ImportedComponent from './ImportedComponent';
@@ -177,6 +212,19 @@ describe('defaultPropsHandler', () => {
       expect(documentation.descriptors).toMatchSnapshot();
     });
 
+    it('resolves local spreads', () => {
+      const src = `
+        const other = { bar: "foo" };
+        var Foo = (props) => <div />
+        Foo.defaultProps = { foo: "bar", ...other };
+      `;
+      defaultPropsHandler(
+        documentation,
+        parse(src).get('body', 1, 'declarations', 0, 'init'),
+      );
+      expect(documentation.descriptors).toMatchSnapshot();
+    });
+
     it('should work with aliases', () => {
       const src = `
         ({

src/handlers/defaultPropsHandler.js

@@ -90,25 +90,35 @@ function getDefaultValuesFromProps(
   isStateless: boolean,
 ) {
   properties
-    .filter(propertyPath => t.Property.check(propertyPath.node))
     // Don't evaluate property if component is functional and the node is not an AssignmentPattern
     .filter(
       propertyPath =>
         !isStateless ||
         t.AssignmentPattern.check(propertyPath.get('value').node),
     )
     .forEach(propertyPath => {
-      const propName = getPropertyName(propertyPath);
-      if (!propName) return;
+      if (t.Property.check(propertyPath.node)) {
+        const propName = getPropertyName(propertyPath);
+        if (!propName) return;
 
-      const propDescriptor = documentation.getPropDescriptor(propName);
-      const defaultValue = getDefaultValue(
-        isStateless
-          ? propertyPath.get('value', 'right')
-          : propertyPath.get('value'),
-      );
-      if (defaultValue) {
-        propDescriptor.defaultValue = defaultValue;
+        const propDescriptor = documentation.getPropDescriptor(propName);
+        const defaultValue = getDefaultValue(
+          isStateless
+            ? propertyPath.get('value', 'right')
+            : propertyPath.get('value'),
+        );
+        if (defaultValue) {
+          propDescriptor.defaultValue = defaultValue;
+        }
+      } else if (t.SpreadElement.check(propertyPath.node)) {
+        const resolvedValuePath = resolveToValue(propertyPath.get('argument'));
+        if (t.ObjectExpression.check(resolvedValuePath.node)) {
+          getDefaultValuesFromProps(
+            resolvedValuePath.get('properties'),
+            documentation,
+            isStateless,
+          );
+        }
       }
     });
 }