fix: Output qualified type identifiers correctly

Also improves flow types

Author: danez

.eslintrc.js

@@ -20,11 +20,7 @@ module.exports = {
   },
   globals: {
     ASTNode: true,
-    FlowTypeDescriptor: true,
-    Handler: true,
     NodePath: true,
-    PropDescriptor: true,
-    PropTypeDescriptor: true,
-    Resolver: true
+    Recast: true
   }
 }

flow-typed/react-docgen.js

@@ -20,7 +20,7 @@
   },
   "main": "dist/main.js",
   "scripts": {
-    "build": "rimraf dist/ && babel src/ --out-dir dist/ --ignore __tests__,__mocks__",
+    "build": "rimraf dist/ && babel src/ --out-dir dist/ --ignore __tests__,__mocks__,src/types.js",
     "lint": "eslint . --report-unused-disable-directives",
     "fix": "eslint . --fix --report-unused-disable-directives",
     "prepublish": "yarn build",

package.json

@@ -10,19 +10,21 @@
  *
  */
 
+import type { PropDescriptor } from './types';
+
 export type DocumentationObject = {
-  props?: Object,
-  context?: Object,
-  childContext?: Object,
+  props?: { [string]: PropDescriptor },
+  context?: { [string]: PropDescriptor },
+  childContext?: { [string]: PropDescriptor },
   composes?: Array<string>,
 };
 
 class Documentation {
-  _props: Object;
-  _context: Object;
-  _childContext: Object;
+  _props: Map<string, PropDescriptor>;
+  _context: Map<string, PropDescriptor>;
+  _childContext: Map<string, PropDescriptor>;
   _composes: Set<string>;
-  _data: Object;
+  _data: Map<string, any>;
 
   constructor() {
     this._props = new Map();

src/Documentation.js

@@ -16,6 +16,7 @@ import * as AllResolver from './resolver';
 import * as utils from './utils';
 import type { Options } from './babelParser';
 import type { DocumentationObject } from './Documentation';
+import type { Handler, Resolver } from './types';
 
 const defaultResolver = AllResolver.findExportedComponentDefinition;
 const defaultHandlers = [

src/main.js

@@ -14,6 +14,7 @@ import postProcessDocumentation from './utils/postProcessDocumentation';
 
 import buildParser, { type Options } from './babelParser';
 import recast from 'recast';
+import type { Handler, Resolver } from './types';
 
 const ERROR_MISSING_DEFINITION = 'No suitable component definition found.';
 

src/parse.js

@@ -0,0 +1,104 @@
+/*
+ *  Copyright (c) 2015, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ *
+ */
+
+import type Documentation from './Documentation';
+
+export type PropTypeDescriptor = {
+  name:
+    | 'arrayOf'
+    | 'custom'
+    | 'enum'
+    | 'array'
+    | 'bool'
+    | 'func'
+    | 'number'
+    | 'object'
+    | 'string'
+    | 'any'
+    | 'element'
+    | 'node'
+    | 'symbol'
+    | 'objectOf'
+    | 'shape'
+    | 'union',
+  value?: any,
+  raw?: string,
+  computed?: boolean,
+  // These are only needed for shape types.
+  // Consider consolidating PropTypeDescriptor and PropDescriptor
+  description?: string,
+  required?: boolean,
+};
+
+export type FlowBaseType = {
+  required?: boolean,
+  nullable?: boolean,
+  alias?: string,
+};
+
+export type FlowSimpleType = FlowBaseType & {|
+  name: string,
+  raw?: string,
+|};
+
+export type FlowLiteralType = FlowBaseType & {
+  name: 'literal',
+  value: string,
+};
+
+export type FlowElementsType = FlowBaseType & {
+  name: string,
+  raw: string,
+  elements: Array<FlowTypeDescriptor>,
+};
+
+export type FlowFunctionSignatureType = FlowBaseType & {
+  name: 'signature',
+  type: 'function',
+  raw: string,
+  signature: {
+    arguments: Array<{ name: string, type: FlowTypeDescriptor }>,
+    return: FlowTypeDescriptor,
+  },
+};
+
+export type FlowObjectSignatureType = FlowBaseType & {
+  name: 'signature',
+  type: 'object',
+  raw: string,
+  signature: {
+    properties: Array<{
+      key: string | FlowTypeDescriptor,
+      value: FlowTypeDescriptor,
+    }>,
+    constructor?: FlowTypeDescriptor,
+  },
+};
+
+export type FlowTypeDescriptor =
+  | FlowSimpleType
+  | FlowLiteralType
+  | FlowElementsType
+  | FlowFunctionSignatureType
+  | FlowObjectSignatureType;
+
+export type PropDescriptor = {
+  type?: PropTypeDescriptor,
+  flowType?: FlowTypeDescriptor,
+  required?: boolean,
+  defaultValue?: any,
+  description?: string,
+};
+
+export type Handler = (documentation: Documentation, path: NodePath) => void;
+export type Resolver = (
+  node: ASTNode,
+  recast: Recast,
+) => ?NodePath | ?Array<NodePath>;

src/types.js

@@ -399,6 +399,44 @@ describe('getFlowType', () => {
     });
   });
 
+  it('handles qualified type identifiers', () => {
+    const typePath = statement(`
+      var x: MyType.x = {};
+
+      type MyType = { a: string, b: ?xyz };
+    `)
+      .get('declarations', 0)
+      .get('id')
+      .get('typeAnnotation')
+      .get('typeAnnotation');
+
+    expect(getFlowType(typePath)).toEqual({
+      name: 'MyType.x',
+    });
+  });
+
+  it('handles qualified type identifiers with params', () => {
+    const typePath = statement(`
+      var x: MyType.x<any> = {};
+
+      type MyType = { a: string, b: ?xyz };
+    `)
+      .get('declarations', 0)
+      .get('id')
+      .get('typeAnnotation')
+      .get('typeAnnotation');
+
+    expect(getFlowType(typePath)).toEqual({
+      name: 'MyType.x',
+      raw: 'MyType.x<any>',
+      elements: [
+        {
+          name: 'any',
+        },
+      ],
+    });
+  });
+
   describe('React types', () => {
     function test(type, expected) {
       const typePath = statement(`