qa(flow): fix flow errors in parser module

src/parser/parseReactElement.js

@@ -2,6 +2,11 @@
 
 import { Children, Element, isValidElement } from 'react';
 import type { Options } from './../options';
+import {
+  createStringTreeNode,
+  createNumberTreeNode,
+  createReactElementTreeNode,
+} from './../tree';
 import type { TreeNode } from './../tree';
 
 const getReactElementDisplayName = (element: Element<*>): string =>
@@ -34,13 +39,11 @@ const parseReactElement = (
   options: Options
 ): TreeNode => {
   const { displayName: displayNameFn = getReactElementDisplayName } = options;
-  const type = typeof element;
 
-  if (type === 'string' || type === 'number') {
-    return {
-      type,
-      value: element,
-    };
+  if (typeof element === 'string') {
+    return createStringTreeNode(element);
+  } else if (typeof element === 'number') {
+    return createNumberTreeNode(element);
   } else if (!isValidElement(element)) {
     throw new Error(
       `react-element-to-jsx-string: Expected a React.Element, got \`${typeof element}\``
@@ -65,13 +68,12 @@ const parseReactElement = (
     .filter(onlyMeaningfulChildren)
     .map(child => parseReactElement(child, options));
 
-  return {
-    type: 'ReactElement',
+  return createReactElementTreeNode(
     displayName,
     props,
     defaultProps,
-    childrens,
-  };
+    childrens
+  );
 };
 
 export default parseReactElement;

src/tree.js

@@ -1,12 +1,39 @@
 /* @flow */
+/* eslint-disable no-use-before-define */
+
+type PropsType = { [key: string]: any };
+type DefaultPropsType = { [key: string]: any };
 
 export type TreeNode = {|
   type: 'ReactElement' | 'string' | 'number',
 
   value?: string | number,
 
   displayName?: string,
-  props?: { [key: string]: TreeNode },
-  defaultProps?: { [key: string]: TreeNode },
+  props?: PropsType,
+  defaultProps?: DefaultPropsType,
   childrens?: TreeNode[],
 |};
+
+export const createStringTreeNode = (value: string): TreeNode => ({
+  type: 'string',
+  value,
+});
+
+export const createNumberTreeNode = (value: number): TreeNode => ({
+  type: 'number',
+  value,
+});
+
+export const createReactElementTreeNode = (
+  displayName: string,
+  props: PropsType,
+  defaultProps: DefaultPropsType,
+  childrens: TreeNode[] = []
+): TreeNode => ({
+  type: 'ReactElement',
+  displayName,
+  props,
+  defaultProps,
+  childrens,
+});

src/tree.spec.js

@@ -0,0 +1,41 @@
+/* @flow */
+
+import {
+  createStringTreeNode,
+  createNumberTreeNode,
+  createReactElementTreeNode,
+} from './tree';
+
+describe('createStringTreeNode', () => {
+  it('generate a string typed node payload', () => {
+    expect(createStringTreeNode('foo')).toEqual({
+      type: 'string',
+      value: 'foo',
+    });
+  });
+});
+
+describe('createNumberTreeNode', () => {
+  it('generate a number typed node payload', () => {
+    expect(createNumberTreeNode(42)).toEqual({
+      type: 'number',
+      value: 42,
+    });
+  });
+});
+
+describe('createReactElementTreeNode', () => {
+  it('generate a react element typed node payload', () => {
+    expect(
+      createReactElementTreeNode('MyComponent', { foo: 42 }, { bar: 51 }, [
+        'abc',
+      ])
+    ).toEqual({
+      type: 'ReactElement',
+      displayName: 'MyComponent',
+      props: { foo: 42 },
+      defaultProps: { bar: 51 },
+      childrens: ['abc'],
+    });
+  });
+});