├── .gitignore
├── CHANGELOG.md
├── LICENSE
├── README.md
├── flow-react.js
├── index.js
└── package.json


/.gitignore:
--------------------------------------------------------------------------------
1 | *.log
2 | node_modules
3 | gen


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # Changelog
 2 | 
 3 | > **Tags:**
 4 | > - [New Feature]
 5 | > - [Bug Fix]
 6 | > - [Breaking Change]
 7 | > - [Documentation]
 8 | > - [Internal]
 9 | > - [Polish]
10 | > - [Experimental]
11 | 
12 | **Note**: Gaps between patch versions are faulty/broken releases.
13 | **Note**: A feature tagged as Experimental is in a high state of flux, you're at risk of it changing without notice.
14 | 
15 | ## 0.1.1
16 | 
17 | - **New Feature**
18 |   - add support for `FunctionComponent`s (@gcanti)
19 | 
20 | ## 0.1.0
21 | 
22 | Initial release


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 Giulio Canti
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | Advanced static type checking for react using Flow
  2 | 
  3 | # Motivation
  4 | 
  5 | I consider JSX pretty handy but *not critical*.
  6 | 
  7 | What I consider critical instead is the possibility to statically type check as much as I can and currently the possibilities of Flow are kind of limited when it comes to react.
  8 | 
  9 | For example there's no way to add constraints to `this.props.children` (e.g. The component `A` must accept exactly 2 children: the first one must be an instance of component `B`, the second one must be an instance of component `C` or a `string` )
 10 | 
 11 | Another example are higher order components, even if it's a popular pattern in the community, currently Flow doesn't play well with HOCs (https://github.com/facebook/flow/issues/1964).
 12 | 
 13 | Leaving the comfort of JSX is not a light heartedly decision but it's worth noting this kind of type checking is opt-in, you can mix and match JSX (relatively unsafe) with the vdom builder `v` (safer).
 14 | 
 15 | **Example**
 16 | 
 17 | Requirement. The `Button` component must have a label property and must not have any children
 18 | 
 19 | ```js
 20 | import { v, Component } from 'flow-react'
 21 | import type { Vdom } from 'flow-react'
 22 | 
 23 | class Button extends Component<{ label: string }> {
 24 |   render() {
 25 |     return v('button', null, this.props.label)
 26 |   }
 27 | }
 28 | 
 29 | const btn = v(Button, { label: 'Click me' })
 30 | v(Button, {}) // error: property `label` not found
 31 | v(Button, { label: 'Click me' }, 'hello') // error
 32 | //                               ^^^^^^^ string. This type is incompatible with Children = void
 33 | ```
 34 | 
 35 | Requirement. The `ButtonWrapper` component must not have any properties and must have a single child which must be an instance of the `Button` component
 36 | 
 37 | ```js
 38 | class ButtonWrapper extends Component<$Shape<{}>, Vdom<Button>> {
 39 |   render() {
 40 |     return v('div', null, this.props.children)
 41 |   }
 42 | }
 43 | 
 44 | v(ButtonWrapper, {}, btn) // ok
 45 | v(ButtonWrapper, { a: 1 }, btn) // error: property `a` not found
 46 | v(ButtonWrapper, {}, 'hello') // error
 47 | //                   ^^^^^^^ string. This type is incompatible with React$Element
 48 | (ButtonWrapper, {}, [btn, btn]) // error
 49 | //                  ^^^^^^^^^^ array literal. This type is incompatible with React$Element
 50 | ```
 51 | 
 52 | Using JSX in the `render` method is fine, but calling a component with JSX can be unsafe
 53 | 
 54 | ```js
 55 | class ButtonWrapper extends Component<$Shape<{}>, Vdom<Button>> {
 56 |   render() {
 57 |     // JSX (unsafe)
 58 |     return <div>{this.props.children}</div>
 59 |   }
 60 | }
 61 | 
 62 | // v(ButtonWrapper, {}, 'hello') // <= using the v builder is safe
 63 | //                      ^^^^^^^ string. This type is incompatible with React$Element
 64 | <ButtonWrapper>hello</ButtonWrapper> // <= this is unsafe, no errors!
 65 | ```
 66 | 
 67 | # Setup
 68 | 
 69 | ```sh
 70 | npm install flow-react --save
 71 | ```
 72 | 
 73 | # API
 74 | 
 75 | ## Exports
 76 | 
 77 | ### Component (class)
 78 | 
 79 | `Component<P: Object = {}, C = void, S = void, D = void>`
 80 | 
 81 | where
 82 | 
 83 | - `P` = Props
 84 | - `C` = Children
 85 | - `S` = State
 86 | - `D` = DefaultProps
 87 | 
 88 | ### v (function)
 89 | 
 90 | ```js
 91 | type Tags = 'a' | 'abbr' | 'address' | /* etc... */ ;
 92 | 
 93 | v<T: Tags>(type: T, props?: Object | null, children?: any): Vdom<T>
 94 | v<P, C, S, D, T: Component<P, C, S, D>>(type: Class<T>, props: Object, children: C): Vdom<T>
 95 | ```
 96 | 
 97 | ## Types
 98 | 
 99 | ### $Strict
100 | 
101 | Useful to tighten up your props
102 | 
103 | Example
104 | 
105 | ```js
106 | import type { $Strict } from 'flow-react'
107 | 
108 | class A extends Component<{ a: number }> {}
109 | v(A, { a: 1 })       // ok
110 | v(A, { a: 1, b: 1 }) // ok
111 | 
112 | class A extends Component<$Strict<{ a: number }>> {}
113 | v(A, { a: 1 })       // ok
114 | v(A, { a: 1, b: 1 }) // error
115 | ```
116 | 
117 | ### Vdom
118 | 
119 | `Vdom<T>`
120 | 
121 | where
122 | 
123 | - `T` = string | your react component
124 | 
125 | ### Vdom shortcuts
126 | 
127 | One for each `Tags` member
128 | 
129 | Example
130 | 
131 | ```js
132 | import type { Div } from 'flow-react'
133 | 
134 | export class A extends Component<{}, Div> {} // <= same as Vdom<'div'>
135 | v(A, {}, v('div'))
136 | // v(A, {}, v('a')) // error
137 | ```
138 | 
139 | # Usage
140 | 
141 | **Note**. Add `./node_modules/flow-react/flow-react.js` to your libdefs.
142 | 
143 | ```js
144 | import { h, Component } from 'flow-react'
145 | import type { Vdom } from 'flow-react'
146 | import ReactDOM from 'react-dom'
147 | 
148 | // default for props = {}
149 | export class C1 extends Component {}
150 | v(C1, {})
151 | // v(C1, {}, 'hello') // error
152 | // v(C1) // error
153 | // v(C1, null) // error
154 | // v(C1, undefined) // error
155 | // const C1$prime: Class<Component<{a: number}>> = C1 // error
156 | const C1$prime: Class<Component<*>> = C1
157 | // v(C1$prime, {}, 'hello') // error
158 | 
159 | export class C2 extends Component<{a: number, b?: number}> {}
160 | v(C2, {a: 1})
161 | v(C2, {a: 1, b: 2})
162 | // v(C1, {a: 1}, 'hello') // error
163 | // v(C1) // error
164 | // v(C1, null) // error
165 | // v(C1, undefined) // error
166 | 
167 | // strictness: use $Shape<P>
168 | export class C3 extends Component<$Shape<{a: number}>> {}
169 | v(C3, {a: 1})
170 | // v(C3, {a: 1, b: 2}) // error
171 | 
172 | // child
173 | export class C4 extends Component<{}, string> {}
174 | v(C4, {}, 'a')
175 | // v(C4, {}, 1) // error
176 | 
177 | // children
178 | export class C5 extends Component<{}, Array<string>> {}
179 | v(C5, {}, ['a', 'b'])
180 | // v(C5, {}, ['a', 1]) // error
181 | 
182 | // tagged children
183 | export class C6 extends Component<{}, Vdom<'div'>> {}
184 | v(C6, {}, v('div'))
185 | // v(C6, {}, v('a')) // error
186 | 
187 | // function as child
188 | export class C7 extends Component<{}, (x: number) => number> {}
189 | v(C7, {}, (n) => n + 1)
190 | // v(C7, {}, v('div')) // error
191 | 
192 | // component child
193 | export class C8 extends Component<{}, Vdom<C1>> {}
194 | v(C8, {}, v(C1, {}))
195 | // v(C8, {}, v('div')) // error
196 | 
197 | // default props
198 | export class C9 extends Component<{ a: number, b: number }, void, void, { a: number }> {
199 |   static defaultProps = {a: 1}
200 | }
201 | v(C9, { b: 2 })
202 | v(C9, { a: 2, b: 2 })
203 | // v(C9, {}) // error
204 | 
205 | // state
206 | export class C10 extends Component<{ a: number }, void, { a: number }> {
207 |   constructor(props: { a: number }) {
208 |     super(props)
209 |     this.state = { a: props.a }
210 |     // this.state = { a: 's' } // error
211 |   }
212 |   componentWillMount() {
213 |     this.setState({ a: 4 })
214 |     // this.setState({ a: 's' }) // error
215 |   }
216 | }
217 | 
218 | // HOC
219 | function hoc<P1: Object, P2: Object>(c: Class<Component<P1, *, *, *>>, f: (_: P2) => P1): Class<Component<P2>> {
220 |   return class C extends Component<P2> {
221 |     render() {
222 |       return v(c, f(this.props))
223 |     }
224 |   }
225 | }
226 | 
227 | function fn(props: {b: string}): {a: number} {
228 |   return { a: props.b.length }
229 | }
230 | 
231 | export class C11 extends Component<{a: number}> {}
232 | 
233 | // const C12 = hoc(C9, fn) // error
234 | const C12 = hoc(C11, fn)
235 | 
236 | v(C12, { b: 'hello' })
237 | ```
238 | 
239 | 


--------------------------------------------------------------------------------
/flow-react.js:
--------------------------------------------------------------------------------
  1 | declare module 'flow-react' {
  2 | 
  3 |   /*
  4 | 
  5 |     helper to narrow down component props
  6 | 
  7 |     Example:
  8 | 
  9 |     class A extends Component<$Strict<{ a: number }>> {}
 10 | 
 11 |     v(A, { a: 1 })       // ok
 12 |     v(A, { a: 1, b: 2 }) // error
 13 | 
 14 |   */
 15 |   declare type $Strict<T> = T & $Shape<T>;
 16 | 
 17 |   /*
 18 | 
 19 |     Refinement of React$Element in order to retain the type of the vdom builder
 20 | 
 21 |   */
 22 |   declare type Vdom<Builder, Config = any> =
 23 |     & React$Element<Config>
 24 |     & { __flow_react_type: Builder }
 25 |     ;
 26 | 
 27 |   /*
 28 | 
 29 |     Refinement of React$Component in order to add type checkinf for children
 30 | 
 31 |     Note. Props, Children, State, DefaultProps have defaults.
 32 | 
 33 |   */
 34 |   declare class Component<Props: Object = {}, Children = void, State = void, DefaultProps = void> extends React$Component<DefaultProps, Props, State> {
 35 |     static defaultProps: $Abstract<DefaultProps>;
 36 |     props: Props & { children: Children };
 37 |     state: State;
 38 |   }
 39 | 
 40 |   declare class PureComponent<Props: Object = {}, Children = void, DefaultProps = void> extends Component<Props, Children, DefaultProps, void> {}
 41 | 
 42 |   declare type Tags =
 43 |     | 'a'
 44 |     | 'abbr'
 45 |     | 'address'
 46 |     | 'area'
 47 |     | 'article'
 48 |     | 'aside'
 49 |     | 'audio'
 50 |     | 'b'
 51 |     | 'base'
 52 |     | 'bdi'
 53 |     | 'bdo'
 54 |     | 'big'
 55 |     | 'blockquote'
 56 |     | 'body'
 57 |     | 'br'
 58 |     | 'button'
 59 |     | 'canvas'
 60 |     | 'caption'
 61 |     | 'cite'
 62 |     | 'code'
 63 |     | 'col'
 64 |     | 'colgroup'
 65 |     | 'data'
 66 |     | 'datalist'
 67 |     | 'dd'
 68 |     | 'del'
 69 |     | 'details'
 70 |     | 'dfn'
 71 |     | 'dialog'
 72 |     | 'div'
 73 |     | 'dl'
 74 |     | 'dt'
 75 |     | 'em'
 76 |     | 'embed'
 77 |     | 'fieldset'
 78 |     | 'figcaption'
 79 |     | 'figure'
 80 |     | 'footer'
 81 |     | 'form'
 82 |     | 'h1'
 83 |     | 'h2'
 84 |     | 'h3'
 85 |     | 'h4'
 86 |     | 'h5'
 87 |     | 'h6'
 88 |     | 'head'
 89 |     | 'header'
 90 |     | 'hgroup'
 91 |     | 'hr'
 92 |     | 'html'
 93 |     | 'i'
 94 |     | 'iframe'
 95 |     | 'img'
 96 |     | 'input'
 97 |     | 'ins'
 98 |     | 'kbd'
 99 |     | 'keygen'
100 |     | 'label'
101 |     | 'legend'
102 |     | 'li'
103 |     | 'link'
104 |     | 'main'
105 |     | 'map'
106 |     | 'mark'
107 |     | 'menu'
108 |     | 'menuitem'
109 |     | 'meta'
110 |     | 'meter'
111 |     | 'nav'
112 |     | 'noscript'
113 |     | 'object'
114 |     | 'ol'
115 |     | 'optgroup'
116 |     | 'option'
117 |     | 'output'
118 |     | 'p'
119 |     | 'param'
120 |     | 'picture'
121 |     | 'pre'
122 |     | 'progress'
123 |     | 'q'
124 |     | 'rp'
125 |     | 'rt'
126 |     | 'ruby'
127 |     | 's'
128 |     | 'samp'
129 |     | 'script'
130 |     | 'section'
131 |     | 'select'
132 |     | 'small'
133 |     | 'source'
134 |     | 'span'
135 |     | 'strong'
136 |     | 'style'
137 |     | 'sub'
138 |     | 'summary'
139 |     | 'sup'
140 |     | 'table'
141 |     | 'tbody'
142 |     | 'td'
143 |     | 'textarea'
144 |     | 'tfoot'
145 |     | 'th'
146 |     | 'thead'
147 |     | 'time'
148 |     | 'title'
149 |     | 'tr'
150 |     | 'track'
151 |     | 'u'
152 |     | 'ul'
153 |     | 'var'
154 |     | 'video'
155 |     | 'wbr'
156 |     | 'circle'
157 |     | 'clipPath'
158 |     | 'defs'
159 |     | 'ellipse'
160 |     | 'g'
161 |     | 'image'
162 |     | 'line'
163 |     | 'linearGradient'
164 |     | 'mask'
165 |     | 'path'
166 |     | 'pattern'
167 |     | 'polygon'
168 |     | 'polyline'
169 |     | 'radialGradient'
170 |     | 'rect'
171 |     | 'stop'
172 |     | 'svg'
173 |     | 'text'
174 |     | 'tspan'
175 |     ;
176 | 
177 |   declare function v<Builder: Tags>(
178 |     type: Builder,
179 |     props?: Object | null,
180 |     children?: any,
181 |     ...rest: Array<void> // enforce no more arguments
182 |   ): Vdom<Builder>;
183 | 
184 |   declare type FunctionComponent<Props> = (props: Props) => ?React$Element<any>;
185 | 
186 |   declare function v<Props, Builder: FunctionComponent<Props>>(
187 |     type: Builder,
188 |     props: Props,
189 |     children?: any,
190 |     ...rest: Array<void> // enforce no more arguments
191 |   ): Vdom<Builder>;
192 | 
193 |   declare function v<Props, Children, State, DefaultProps, Builder: Component<Props, Children, State, DefaultProps>>(
194 |     type: Class<Builder> & Class<Component<*, *, *, *>>,
195 |     props: $Diff<Props, DefaultProps> & {}, // <= prevent null otherwise $Diff will throw away type checking
196 |     children: Children,
197 |     ...rest: Array<void> // enforce no more arguments
198 |   ): Vdom<Builder>;
199 | 
200 |   declare type A = Vdom<'a'>;
201 |   declare type Abbr = Vdom<'abbr'>;
202 |   declare type Address = Vdom<'address'>;
203 |   declare type Area = Vdom<'area'>;
204 |   declare type Article = Vdom<'article'>;
205 |   declare type Aside = Vdom<'aside'>;
206 |   declare type Audio = Vdom<'audio'>;
207 |   declare type B = Vdom<'b'>;
208 |   declare type Base = Vdom<'base'>;
209 |   declare type Bdi = Vdom<'bdi'>;
210 |   declare type Bdo = Vdom<'bdo'>;
211 |   declare type Big = Vdom<'big'>;
212 |   declare type Blockquote = Vdom<'blockquote'>;
213 |   declare type Body = Vdom<'body'>;
214 |   declare type Br = Vdom<'br'>;
215 |   declare type Button = Vdom<'button'>;
216 |   declare type Canvas = Vdom<'canvas'>;
217 |   declare type Caption = Vdom<'caption'>;
218 |   declare type Cite = Vdom<'cite'>;
219 |   declare type Code = Vdom<'code'>;
220 |   declare type Col = Vdom<'col'>;
221 |   declare type Colgroup = Vdom<'colgroup'>;
222 |   declare type Data = Vdom<'data'>;
223 |   declare type Datalist = Vdom<'datalist'>;
224 |   declare type Dd = Vdom<'dd'>;
225 |   declare type Del = Vdom<'del'>;
226 |   declare type Details = Vdom<'details'>;
227 |   declare type Dfn = Vdom<'dfn'>;
228 |   declare type Dialog = Vdom<'dialog'>;
229 |   declare type Div = Vdom<'div'>;
230 |   declare type Dl = Vdom<'dl'>;
231 |   declare type Dt = Vdom<'dt'>;
232 |   declare type Em = Vdom<'em'>;
233 |   declare type Embed = Vdom<'embed'>;
234 |   declare type Fieldset = Vdom<'fieldset'>;
235 |   declare type Figcaption = Vdom<'figcaption'>;
236 |   declare type Figure = Vdom<'figure'>;
237 |   declare type Footer = Vdom<'footer'>;
238 |   declare type Form = Vdom<'form'>;
239 |   declare type H1 = Vdom<'h1'>;
240 |   declare type H2 = Vdom<'h2'>;
241 |   declare type H3 = Vdom<'h3'>;
242 |   declare type H4 = Vdom<'h4'>;
243 |   declare type H5 = Vdom<'h5'>;
244 |   declare type H6 = Vdom<'h6'>;
245 |   declare type Head = Vdom<'head'>;
246 |   declare type Header = Vdom<'header'>;
247 |   declare type Hgroup = Vdom<'hgroup'>;
248 |   declare type Hr = Vdom<'hr'>;
249 |   declare type Html = Vdom<'html'>;
250 |   declare type I = Vdom<'i'>;
251 |   declare type Iframe = Vdom<'iframe'>;
252 |   declare type Img = Vdom<'img'>;
253 |   declare type Input = Vdom<'input'>;
254 |   declare type Ins = Vdom<'ins'>;
255 |   declare type Kbd = Vdom<'kbd'>;
256 |   declare type Keygen = Vdom<'keygen'>;
257 |   declare type Label = Vdom<'label'>;
258 |   declare type Legend = Vdom<'legend'>;
259 |   declare type Li = Vdom<'li'>;
260 |   declare type Link = Vdom<'link'>;
261 |   declare type Main = Vdom<'main'>;
262 |   declare type Map = Vdom<'map'>;
263 |   declare type Mark = Vdom<'mark'>;
264 |   declare type Menu = Vdom<'menu'>;
265 |   declare type Menuitem = Vdom<'menuitem'>;
266 |   declare type Meta = Vdom<'meta'>;
267 |   declare type Meter = Vdom<'meter'>;
268 |   declare type Nav = Vdom<'nav'>;
269 |   declare type Noscript = Vdom<'noscript'>;
270 |   declare type Object = Vdom<'object'>;
271 |   declare type Ol = Vdom<'ol'>;
272 |   declare type Optgroup = Vdom<'optgroup'>;
273 |   declare type Option = Vdom<'option'>;
274 |   declare type Output = Vdom<'output'>;
275 |   declare type P = Vdom<'p'>;
276 |   declare type Param = Vdom<'param'>;
277 |   declare type Picture = Vdom<'picture'>;
278 |   declare type Pre = Vdom<'pre'>;
279 |   declare type Progress = Vdom<'progress'>;
280 |   declare type Q = Vdom<'q'>;
281 |   declare type Rp = Vdom<'rp'>;
282 |   declare type Rt = Vdom<'rt'>;
283 |   declare type Ruby = Vdom<'ruby'>;
284 |   declare type S = Vdom<'s'>;
285 |   declare type Samp = Vdom<'samp'>;
286 |   declare type Script = Vdom<'script'>;
287 |   declare type Section = Vdom<'section'>;
288 |   declare type Select = Vdom<'select'>;
289 |   declare type Small = Vdom<'small'>;
290 |   declare type Source = Vdom<'source'>;
291 |   declare type Span = Vdom<'span'>;
292 |   declare type Strong = Vdom<'strong'>;
293 |   declare type Style = Vdom<'style'>;
294 |   declare type Sub = Vdom<'sub'>;
295 |   declare type Summary = Vdom<'summary'>;
296 |   declare type Sup = Vdom<'sup'>;
297 |   declare type Table = Vdom<'table'>;
298 |   declare type Tbody = Vdom<'tbody'>;
299 |   declare type Td = Vdom<'td'>;
300 |   declare type Textarea = Vdom<'textarea'>;
301 |   declare type Tfoot = Vdom<'tfoot'>;
302 |   declare type Th = Vdom<'th'>;
303 |   declare type Thead = Vdom<'thead'>;
304 |   declare type Time = Vdom<'time'>;
305 |   declare type Title = Vdom<'title'>;
306 |   declare type Tr = Vdom<'tr'>;
307 |   declare type Track = Vdom<'track'>;
308 |   declare type U = Vdom<'u'>;
309 |   declare type Ul = Vdom<'ul'>;
310 |   declare type Var = Vdom<'var'>;
311 |   declare type Video = Vdom<'video'>;
312 |   declare type Wbr = Vdom<'wbr'>;
313 |   declare type Circle = Vdom<'circle'>;
314 |   declare type ClipPath = Vdom<'clipPath'>;
315 |   declare type Defs = Vdom<'defs'>;
316 |   declare type Ellipse = Vdom<'ellipse'>;
317 |   declare type G = Vdom<'g'>;
318 |   declare type Image = Vdom<'image'>;
319 |   declare type Line = Vdom<'line'>;
320 |   declare type LinearGradient = Vdom<'linearGradient'>;
321 |   declare type Mask = Vdom<'mask'>;
322 |   declare type Path = Vdom<'path'>;
323 |   declare type Pattern = Vdom<'pattern'>;
324 |   declare type Polygon = Vdom<'polygon'>;
325 |   declare type Polyline = Vdom<'polyline'>;
326 |   declare type RadialGradient = Vdom<'radialGradient'>;
327 |   declare type Rect = Vdom<'rect'>;
328 |   declare type Stop = Vdom<'stop'>;
329 |   declare type Svg = Vdom<'svg'>;
330 |   declare type Text = Vdom<'text'>;
331 |   declare type Tspan = Vdom<'tspan'>;
332 | 
333 | }


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
 1 | var React = require('react');
 2 | 
 3 | function v(type, props, children) {
 4 |   return React.createElement.apply(null, [type, props].concat(children))
 5 | }
 6 | 
 7 | module.exports = {
 8 |   Component: React.Component,
 9 |   PureComponent: React.PureComponent,
10 |   v: v
11 | };


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "flow-react",
 3 |   "version": "0.1.1",
 4 |   "description": "Advanced type checking for react using Flow",
 5 |   "main": "index.js",
 6 |   "files": [
 7 |     "index.js",
 8 |     "flow-react.js"
 9 |   ],
10 |   "scripts": {
11 |   },
12 |   "repository": {
13 |     "type": "git",
14 |     "url": "https://github.com/gcanti/flow-react.git"
15 |   },
16 |   "author": "Giulio Canti <giulio.canti@gmail.com>",
17 |   "license": "MIT",
18 |   "bugs": {
19 |     "url": "https://github.com/gcanti/flow-react/issues"
20 |   },
21 |   "homepage": "https://github.com/gcanti/flow-react",
22 |   "devDependencies": {
23 |   },
24 |   "tags": [
25 |     "flow",
26 |     "flowtype",
27 |     "type checking",
28 |     "react"
29 |   ],
30 |   "keywords": [
31 |     "flow",
32 |     "flowtype",
33 |     "type checking",
34 |     "react"
35 |   ]
36 | }
37 | 


--------------------------------------------------------------------------------