Support shorthand props.

Author: milesj

src/__tests__/data/StatelessShorthandDefaultProps.tsx

@@ -0,0 +1,23 @@
+import * as React from 'react';
+
+export interface StatelessShorthandDefaultPropsProps {
+  /** regularProp description */
+  regularProp: string;
+  /** shorthandProp description */
+  shorthandProp?: number;
+  /** onCallback description */
+  onCallback?: () => void;
+}
+
+/** StatelessShorthandDefaultProps description */
+export const StatelessShorthandDefaultProps: React.SFC<
+  StatelessShorthandDefaultPropsProps
+> = props => <div />;
+
+const shorthandProp = 123;
+
+StatelessShorthandDefaultProps.defaultProps = {
+  regularProp: 'foo',
+  shorthandProp,
+  onCallback() {}
+};

src/__tests__/parser.ts

@@ -364,9 +364,34 @@ describe('parser', () => {
       check('StatelessWithReferencedDefaultProps', expectation);
     });
 
-    // it('supports spread props', () => {
-    //   check('StatelessWithSpreadDefaultProps', expectation);
-    // });
+    it('should parse props with shorthands', () => {
+      check('StatelessShorthandDefaultProps', {
+        StatelessShorthandDefaultProps: {
+          onCallback: {
+            defaultValue: null,
+            description: 'onCallback description',
+            required: false,
+            type: '() => void'
+          },
+          regularProp: {
+            defaultValue: 'foo',
+            description: 'regularProp description',
+            required: true,
+            type: 'string'
+          },
+          shorthandProp: {
+            defaultValue: '123',
+            description: 'shorthandProp description',
+            required: false,
+            type: 'number'
+          }
+        }
+      });
+    });
+
+    it('supports spread props', () => {
+      check('StatelessWithSpreadDefaultProps', expectation);
+    });
   });
 
   it('should parse functional component component defined as function', () => {

src/__tests__/testUtils.ts

@@ -19,7 +19,7 @@ export interface ExpectedProp {
   type: string;
   required?: boolean;
   description?: string;
-  defaultValue?: string;
+  defaultValue?: string | null;
 }
 
 export function fixturePath(componentName: string) {

src/parser.ts

@@ -447,7 +447,9 @@ class Parser {
       let propMap = {};
 
       if (properties) {
-        propMap = getPropMap(properties as ts.NodeArray<ts.PropertyAssignment>);
+        propMap = this.getPropMap(properties as ts.NodeArray<
+          ts.PropertyAssignment
+        >);
       }
 
       return propMap;
@@ -458,7 +460,7 @@ class Parser {
         if (right) {
           const { properties } = right as ts.ObjectLiteralExpression;
           if (properties) {
-            propMap = getPropMap(properties as ts.NodeArray<
+            propMap = this.getPropMap(properties as ts.NodeArray<
               ts.PropertyAssignment
             >);
           }
@@ -468,6 +470,80 @@ class Parser {
     }
     return {};
   }
+
+  public getLiteralValueFromPropertyAssignment(
+    property: ts.PropertyAssignment
+  ): string | null {
+    let { initializer } = property;
+
+    // Shorthand properties, so inflect their actual value
+    if (!initializer) {
+      if (ts.isShorthandPropertyAssignment(property)) {
+        const symbol = this.checker.getShorthandAssignmentValueSymbol(property);
+        const decl =
+          symbol && (symbol.valueDeclaration as ts.VariableDeclaration);
+
+        if (decl && decl.initializer) {
+          initializer = decl.initializer!;
+        }
+      }
+    }
+
+    if (!initializer) {
+      return null;
+    }
+
+    // Literal values
+    switch (initializer.kind) {
+      case ts.SyntaxKind.FalseKeyword:
+        return 'false';
+      case ts.SyntaxKind.TrueKeyword:
+        return 'true';
+      case ts.SyntaxKind.StringLiteral:
+        return (initializer as ts.StringLiteral).text.trim();
+      case ts.SyntaxKind.PrefixUnaryExpression:
+        return initializer.getFullText().trim();
+      case ts.SyntaxKind.NumericLiteral:
+        return `${(initializer as ts.NumericLiteral).text}`;
+      case ts.SyntaxKind.NullKeyword:
+        return 'null';
+      case ts.SyntaxKind.Identifier:
+        // can potentially find other identifiers in the source and map those in the future
+        return (initializer as ts.Identifier).text === 'undefined'
+          ? 'undefined'
+          : null;
+      case ts.SyntaxKind.ObjectLiteralExpression:
+        // return the source text for an object literal
+        return (initializer as ts.ObjectLiteralExpression).getText();
+      default:
+        return null;
+    }
+  }
+
+  public getPropMap(
+    properties: ts.NodeArray<ts.PropertyAssignment>
+  ): StringIndexedObject<string> {
+    const propMap = properties.reduce(
+      (acc, property) => {
+        if (ts.isSpreadAssignment(property) || !property.name) {
+          return acc;
+        }
+
+        const literalValue = this.getLiteralValueFromPropertyAssignment(
+          property
+        );
+        const propertyName = getPropertyName(property.name);
+
+        if (typeof literalValue === 'string' && propertyName !== null) {
+          acc[propertyName] = literalValue;
+        }
+
+        return acc;
+      },
+      {} as StringIndexedObject<string>
+    );
+    return propMap;
+  }
 }
 
 function statementIsClassDeclaration(
@@ -490,29 +566,6 @@ function statementIsStateless(statement: ts.Statement): boolean {
   return false;
 }
 
-function getPropMap(
-  properties: ts.NodeArray<ts.PropertyAssignment>
-): StringIndexedObject<string> {
-  const propMap = properties.reduce(
-    (acc, property) => {
-      if (ts.isSpreadAssignment(property) || !property.name) {
-        return acc;
-      }
-
-      const literalValue = getLiteralValueFromPropertyAssignment(property);
-      const propertyName = getPropertyName(property.name);
-
-      if (typeof literalValue === 'string' && propertyName !== null) {
-        acc[propertyName] = literalValue;
-      }
-
-      return acc;
-    },
-    {} as StringIndexedObject<string>
-  );
-  return propMap;
-}
-
 function getPropertyName(name: ts.PropertyName): string | null {
   switch (name.kind) {
     case ts.SyntaxKind.NumericLiteral:
@@ -526,36 +579,6 @@ function getPropertyName(name: ts.PropertyName): string | null {
   }
 }
 
-function getLiteralValueFromPropertyAssignment(
-  property: ts.PropertyAssignment
-): string | null {
-  const { initializer } = property;
-  switch (initializer.kind) {
-    case ts.SyntaxKind.FalseKeyword:
-      return 'false';
-    case ts.SyntaxKind.TrueKeyword:
-      return 'true';
-    case ts.SyntaxKind.StringLiteral:
-      return (initializer as ts.StringLiteral).text.trim();
-    case ts.SyntaxKind.PrefixUnaryExpression:
-      return initializer.getFullText().trim();
-    case ts.SyntaxKind.NumericLiteral:
-      return `${(initializer as ts.NumericLiteral).text}`;
-    case ts.SyntaxKind.NullKeyword:
-      return 'null';
-    case ts.SyntaxKind.Identifier:
-      // can potentially find other identifiers in the source and map those in the future
-      return (initializer as ts.Identifier).text === 'undefined'
-        ? 'undefined'
-        : null;
-    case ts.SyntaxKind.ObjectLiteralExpression:
-      // return the source text for an object literal
-      return (initializer as ts.ObjectLiteralExpression).getText();
-    default:
-      return null;
-  }
-}
-
 function formatTag(tag: ts.JSDocTagInfo) {
   let result = '@' + tag.name;
   if (tag.text) {