├── index.js
├── .styleci.yml
├── .gitignore
├── .npmignore
├── .travis.yml
├── .flowconfig
├── tests
    ├── fixtures
    │   ├── InvalidFunctionalComponent.js
    │   ├── ValidFunctionalComponent.js
    │   ├── TestClassComponent.js
    │   ├── ValidClassComponent.js
    │   ├── injectFooHocFunctionalComponent.js
    │   ├── injectFooFactoryFunctionalComponent.js
    │   ├── TestFunctionalComponent.js
    │   ├── injectFooFactoryClassComponent.js
    │   └── injectFooHocClassComponent.js
    └── index.js
├── package.json
├── LICENSE
├── index.js.flow
├── README.md
└── yarn.lock


/index.js:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/.styleci.yml:
--------------------------------------------------------------------------------
1 | preset: psr2
2 | 


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


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | /node_modules
2 | /xeno
3 | /tests
4 | *.log


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | 
3 | node_js:
4 |   - 6.0
5 | 
6 | sudo: false


--------------------------------------------------------------------------------
/.flowconfig:
--------------------------------------------------------------------------------
 1 | [ignore]
 2 | .*/node_modules/
 3 | 
 4 | [lints]
 5 | all=error
 6 | 
 7 | [options]
 8 | include_warnings=true
 9 | suppress_comment=\\(.\\|\n\\)*\\$FlowExpectError
10 | suppress_comment=\\(.\\|\n\\)*\\$FlowExpectErrorTestClassComponent
11 | suppress_comment=\\(.\\|\n\\)*\\$FlowExpectErrorTestFunctionalComponent
12 | 


--------------------------------------------------------------------------------
/tests/fixtures/InvalidFunctionalComponent.js:
--------------------------------------------------------------------------------
1 | // @flow
2 | import * as React from 'react';
3 | 
4 | // This is an invalid functional component. HigherOrderComponents shouldn't accept this as input
5 | const InvalidFunctionalComponent = (props: {string1: string, number1: number}) => 'hi';
6 | 
7 | export default InvalidFunctionalComponent;


--------------------------------------------------------------------------------
/tests/fixtures/ValidFunctionalComponent.js:
--------------------------------------------------------------------------------
 1 | // @flow
 2 | import * as React from 'react';
 3 | 
 4 | type Props = {string1: string, number1: number};
 5 | 
 6 | // This is a valid functional react component that we'll use to test our HigherOrderComponents later
 7 | const ValidFunctionalComponent = (props: Props) => <div />;
 8 | 
 9 | export default ValidFunctionalComponent;
10 | 


--------------------------------------------------------------------------------
/tests/fixtures/TestClassComponent.js:
--------------------------------------------------------------------------------
 1 | // @flow
 2 | import * as React from 'react';
 3 | 
 4 | export type Props = {
 5 |   foo: number,
 6 |   bar: number,
 7 |   baz: number,
 8 | };
 9 | 
10 | class TestClassComponent extends React.Component<Props, void> {
11 |   static defaultProps = {
12 |     foo: 3,
13 |     bar: 3,
14 |   };
15 |   render = () => null;
16 | };
17 | 
18 | export default TestClassComponent;


--------------------------------------------------------------------------------
/tests/fixtures/ValidClassComponent.js:
--------------------------------------------------------------------------------
 1 | // @flow
 2 | import * as React from 'react';
 3 | 
 4 | // This is a valid class-based component. We'll use it to test HigherOrderComponents later
 5 | class ValidClassComponent extends React.Component<{string1: string, number1: number}, void> {
 6 |   static defaultProps = {number1: 10}
 7 | 
 8 |   render() {
 9 |     return <div />;
10 |   }
11 | };
12 | 
13 | export default ValidClassComponent;
14 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "react-flow-types",
 3 |   "version": "0.2.0-beta.6",
 4 |   "description": "A small collection of flow type definitions for working with React components",
 5 |   "main": "index.js",
 6 |   "scripts": {
 7 |     "test": "flow"
 8 |   },
 9 |   "keywords": [],
10 |   "author": "Aria Minaei (aria.minaei@gmail.com)",
11 |   "license": "MIT",
12 |   "devDependencies": {
13 |     "flow-bin": "^0.57.3",
14 |     "react": "^15.4.2",
15 |     "react-dom": "^15.4.2"
16 |   }
17 | }
18 | 


--------------------------------------------------------------------------------
/tests/fixtures/injectFooHocFunctionalComponent.js:
--------------------------------------------------------------------------------
 1 | // @flow
 2 | import * as React from 'react';
 3 | import type {
 4 |   HigherOrderComponent,
 5 | } from '../../index';
 6 | 
 7 | type RequiredProps = {};
 8 | 
 9 | type ProvidedProps = {foo: number};
10 | 
11 | const injectFooHocFunctionalComponent = (): HigherOrderComponent<RequiredProps, ProvidedProps> => (C: any): any => {
12 |   return (props: RequiredProps) => <C {...props} foo={3} />;
13 | };
14 | 
15 | export default injectFooHocFunctionalComponent;


--------------------------------------------------------------------------------
/tests/fixtures/injectFooFactoryFunctionalComponent.js:
--------------------------------------------------------------------------------
 1 | // @flow
 2 | import * as React from 'react';
 3 | import type {
 4 |   HigherOrderComponent,
 5 | } from '../../index';
 6 | 
 7 | type RequiredProps = {};
 8 | 
 9 | type ProvidedProps = {foo: number};
10 | 
11 | const injectFooFactoryFunctionalComponent: HigherOrderComponent<RequiredProps, ProvidedProps> = (C: any): any => {
12 |   return (props: RequiredProps) => <C {...props} foo={3} />;
13 | };
14 | 
15 | export default injectFooFactoryFunctionalComponent;
16 | 


--------------------------------------------------------------------------------
/tests/fixtures/TestFunctionalComponent.js:
--------------------------------------------------------------------------------
 1 | // @flow
 2 | import * as React from 'react';
 3 | import type { ComponentWithDefaultProps } from '../../index';
 4 | 
 5 | export type Props = {
 6 |   foo: number,
 7 |   bar: number,
 8 |   baz: number,
 9 | };
10 | 
11 | const TestFunctionalComponent = (props: Props) => { return null; };
12 | 
13 | TestFunctionalComponent.defaultProps = {
14 |   foo: 3,
15 |   bar: 3,
16 | };
17 | 
18 | export default (TestFunctionalComponent: ComponentWithDefaultProps<{foo: number, bar: number}, Props>);
19 | 


--------------------------------------------------------------------------------
/tests/fixtures/injectFooFactoryClassComponent.js:
--------------------------------------------------------------------------------
 1 | // @flow
 2 | import * as React from 'react';
 3 | import type {
 4 |   HigherOrderComponent,
 5 | } from '../../index';
 6 | 
 7 | type RequiredProps = {};
 8 | 
 9 | type ProvidedProps = {foo: number};
10 | 
11 | const injectFooFactoryClassComponent: HigherOrderComponent<RequiredProps, ProvidedProps> = (C: any): any => {
12 |   class FooInjector extends React.Component<RequiredProps> {
13 |     render() {
14 |       return <C {...this.props} foo={3} />;
15 |     }
16 |   }
17 | 
18 |   return FooInjector
19 | };
20 | 
21 | export default injectFooFactoryClassComponent;


--------------------------------------------------------------------------------
/tests/fixtures/injectFooHocClassComponent.js:
--------------------------------------------------------------------------------
 1 | // @flow
 2 | import * as React from 'react';
 3 | import type {
 4 |   HigherOrderComponent,
 5 | } from '../../index';
 6 | 
 7 | type Options = {
 8 |   foo: 'bar'
 9 | }
10 | 
11 | type RequiredProps = {};
12 | 
13 | type ProvidedProps = {foo: number};
14 | 
15 | const injectFooHocClassComponent = (options: Options): HigherOrderComponent<RequiredProps, ProvidedProps> => (C: any): any => {
16 |   class FooInjector extends React.Component<RequiredProps> {
17 |     render() {
18 |       return <C {...this.props} foo={3} />;
19 |     }
20 |   }
21 | 
22 |   return FooInjector
23 | };
24 | 
25 | export default injectFooHocClassComponent;


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2017 Nord Software Oy.
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 6 | this software and associated documentation files (the "Software"), to deal in
 7 | the Software without restriction, including without limitation the rights to
 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | 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, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


--------------------------------------------------------------------------------
/index.js.flow:
--------------------------------------------------------------------------------
 1 | // @flow
 2 | import * as React from 'react';
 3 | 
 4 | export type ClassComponent<Props, State> =
 5 |   Class<React.Component<Props, State>>;
 6 | 
 7 | export type ClassComponentWithDefaultProps<DefaultProps, Props, State> =
 8 |   ClassComponent<Props, State> & {defaultProps: DefaultProps};
 9 | 
10 | export type ComponentWithDefaultProps<DefaultProps, Props> =
11 |   React.ComponentType<Props> & {defaultProps: DefaultProps};
12 | 
13 | /**
14 |  * Here is a generic type for HOCs:
15 |  *
16 |  * It takes two type parameters: RequiredProps and ProvidedProps
17 |  *
18 |  * RequiredProps: The final wrapped component will need RequiredProps, in addition to its own props
19 |  * ProvidedProps: The final wrapped component will not need ProvidedProps, because the HOC will provide them to the inner component
20 |  */
21 | 
22 | export type HigherOrderComponent<RequiredProps, ProvidedProps> =
23 |   & (
24 |     <Props, DefaultProps>(component: ComponentWithDefaultProps<DefaultProps, ProvidedProps & Props>) =>
25 |       React.ComponentType<
26 |         // Merge in RequiredProps
27 |         & RequiredProps
28 |         // Props, with diffed-out default props. Make sure to merge with ProvidedProps to work with
29 |         // $Diff constraints in nested HoCs.
30 |         & $Diff<ProvidedProps & Props, DefaultProps & ProvidedProps>
31 |         // Force props to be in the shape of all potential props (effectively allows properly-typed
32 |         // overrides of DefaultProps)
33 |         & $Shape<RequiredProps & DefaultProps & Props>
34 |       >
35 |     )
36 |   & (<Props>(component: React.StatelessFunctionalComponent<ProvidedProps & Props>) => React.ComponentType<RequiredProps & Props>)
37 |   & (<Props>(component: React.ComponentType<ProvidedProps & Props>) => React.ComponentType<RequiredProps & Props>)
38 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # react-flow-types
 2 | 
 3 | [![Build Status](https://travis-ci.org/digiaonline/react-flow-types.svg?branch=develop)](https://travis-ci.org/digiaonline/react-flow-types)
 4 | [![npm downloads](https://img.shields.io/npm/dt/react-flow-types.svg)](https://www.npmjs.com/package/react-flow-types)
 5 | [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/nordsoftware/react-flow-types/master/LICENSE)
 6 | 
 7 | ## Note
 8 | 
 9 | Most of the types that used to be in this package now have equivalents in [flow@0.53](https://github.com/facebook/flow/releases/tag/v0.53.0), so I'm deprecating them. The most important type that still remains is `HigherOrderComponent`. If you come up with more useful types for react, feel free to submit a PR :)
10 | 
11 | ## Usage
12 | 
13 | ```
14 | $ npm install --save-dev react-flow-types
15 | ```
16 | 
17 | ### `HigherOrderComponent<RequiredProps, ProvidedProps>`
18 | 
19 | The generic type of a higher-order component. A `HigherOrderComponent` always *provides* a set of props to the inner component, and *requires* another set of props to be passed to it.
20 | 
21 | Example:
22 | 
23 | ```javascript
24 | import type {HigherOrderComponent} from 'react-flow-types'
25 | 
26 | type RequiredProps = {
27 |   name: string,
28 | }
29 | 
30 | type ProvidedProps = {
31 |   input: {
32 |     value: mixed,
33 |     onChange: Function,
34 |   },
35 | }
36 | 
37 | // The hoc:
38 | const asField = (): HigherOrderComponent<RequiredProps, ProvidedProps> => (component): any => {
39 |   const FinalComponent = ({name, ...rest}) =>
40 |     <ReduxFormField name={name} component={component} props={rest} />;
41 | 
42 |   hoistNonReactStatics(FinalComponent, component)
43 | 
44 |   FinalComponent.displayName =
45 |     `asField(${component.displayName || component.name || 'Component'})`
46 | 
47 |   return FinalComponent
48 | }
49 | 
50 | const Input = ({input}) => <input type="text" {...input} />
51 | const WrapperInput = asField(Input)
52 | 
53 | const element = <WrappedInput name="email" />
54 | ```
55 | 


--------------------------------------------------------------------------------
/yarn.lock:
--------------------------------------------------------------------------------
  1 | # THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
  2 | # yarn lockfile v1
  3 | 
  4 | 
  5 | asap@~2.0.3:
  6 |   version "2.0.5"
  7 |   resolved "https://registry.yarnpkg.com/asap/-/asap-2.0.5.tgz#522765b50c3510490e52d7dcfe085ef9ba96958f"
  8 | 
  9 | core-js@^1.0.0:
 10 |   version "1.2.7"
 11 |   resolved "https://registry.yarnpkg.com/core-js/-/core-js-1.2.7.tgz#652294c14651db28fa93bd2d5ff2983a4f08c636"
 12 | 
 13 | encoding@^0.1.11:
 14 |   version "0.1.12"
 15 |   resolved "https://registry.yarnpkg.com/encoding/-/encoding-0.1.12.tgz#538b66f3ee62cd1ab51ec323829d1f9480c74beb"
 16 |   dependencies:
 17 |     iconv-lite "~0.4.13"
 18 | 
 19 | fbjs@^0.8.1, fbjs@^0.8.4:
 20 |   version "0.8.9"
 21 |   resolved "https://registry.yarnpkg.com/fbjs/-/fbjs-0.8.9.tgz#180247fbd347dcc9004517b904f865400a0c8f14"
 22 |   dependencies:
 23 |     core-js "^1.0.0"
 24 |     isomorphic-fetch "^2.1.1"
 25 |     loose-envify "^1.0.0"
 26 |     object-assign "^4.1.0"
 27 |     promise "^7.1.1"
 28 |     setimmediate "^1.0.5"
 29 |     ua-parser-js "^0.7.9"
 30 | 
 31 | flow-bin@^0.57.3:
 32 |   version "0.57.3"
 33 |   resolved "https://registry.yarnpkg.com/flow-bin/-/flow-bin-0.57.3.tgz#843fb80a821b6d0c5847f7bb3f42365ffe53b27b"
 34 | 
 35 | iconv-lite@~0.4.13:
 36 |   version "0.4.15"
 37 |   resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.15.tgz#fe265a218ac6a57cfe854927e9d04c19825eddeb"
 38 | 
 39 | is-stream@^1.0.1:
 40 |   version "1.1.0"
 41 |   resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-1.1.0.tgz#12d4a3dd4e68e0b79ceb8dbc84173ae80d91ca44"
 42 | 
 43 | isomorphic-fetch@^2.1.1:
 44 |   version "2.2.1"
 45 |   resolved "https://registry.yarnpkg.com/isomorphic-fetch/-/isomorphic-fetch-2.2.1.tgz#611ae1acf14f5e81f729507472819fe9733558a9"
 46 |   dependencies:
 47 |     node-fetch "^1.0.1"
 48 |     whatwg-fetch ">=0.10.0"
 49 | 
 50 | js-tokens@^3.0.0:
 51 |   version "3.0.1"
 52 |   resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-3.0.1.tgz#08e9f132484a2c45a30907e9dc4d5567b7f114d7"
 53 | 
 54 | loose-envify@^1.0.0, loose-envify@^1.1.0:
 55 |   version "1.3.1"
 56 |   resolved "https://registry.yarnpkg.com/loose-envify/-/loose-envify-1.3.1.tgz#d1a8ad33fa9ce0e713d65fdd0ac8b748d478c848"
 57 |   dependencies:
 58 |     js-tokens "^3.0.0"
 59 | 
 60 | node-fetch@^1.0.1:
 61 |   version "1.6.3"
 62 |   resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-1.6.3.tgz#dc234edd6489982d58e8f0db4f695029abcd8c04"
 63 |   dependencies:
 64 |     encoding "^0.1.11"
 65 |     is-stream "^1.0.1"
 66 | 
 67 | object-assign@^4.1.0:
 68 |   version "4.1.1"
 69 |   resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
 70 | 
 71 | promise@^7.1.1:
 72 |   version "7.1.1"
 73 |   resolved "https://registry.yarnpkg.com/promise/-/promise-7.1.1.tgz#489654c692616b8aa55b0724fa809bb7db49c5bf"
 74 |   dependencies:
 75 |     asap "~2.0.3"
 76 | 
 77 | react-dom@^15.4.2:
 78 |   version "15.4.2"
 79 |   resolved "https://registry.yarnpkg.com/react-dom/-/react-dom-15.4.2.tgz#015363f05b0a1fd52ae9efdd3a0060d90695208f"
 80 |   dependencies:
 81 |     fbjs "^0.8.1"
 82 |     loose-envify "^1.1.0"
 83 |     object-assign "^4.1.0"
 84 | 
 85 | react@^15.4.2:
 86 |   version "15.4.2"
 87 |   resolved "https://registry.yarnpkg.com/react/-/react-15.4.2.tgz#41f7991b26185392ba9bae96c8889e7e018397ef"
 88 |   dependencies:
 89 |     fbjs "^0.8.4"
 90 |     loose-envify "^1.1.0"
 91 |     object-assign "^4.1.0"
 92 | 
 93 | setimmediate@^1.0.5:
 94 |   version "1.0.5"
 95 |   resolved "https://registry.yarnpkg.com/setimmediate/-/setimmediate-1.0.5.tgz#290cbb232e306942d7d7ea9b83732ab7856f8285"
 96 | 
 97 | ua-parser-js@^0.7.9:
 98 |   version "0.7.12"
 99 |   resolved "https://registry.yarnpkg.com/ua-parser-js/-/ua-parser-js-0.7.12.tgz#04c81a99bdd5dc52263ea29d24c6bf8d4818a4bb"
100 | 
101 | whatwg-fetch@>=0.10.0:
102 |   version "2.0.2"
103 |   resolved "https://registry.yarnpkg.com/whatwg-fetch/-/whatwg-fetch-2.0.2.tgz#fe294d1d89e36c5be8b3195057f2e4bc74fc980e"
104 | 


--------------------------------------------------------------------------------
/tests/index.js:
--------------------------------------------------------------------------------
  1 | // @flow
  2 | import * as React from 'react';
  3 | import type {
  4 |   HigherOrderComponent,
  5 |   ClassComponentWithDefaultProps,
  6 | } from '../index';
  7 | import InvalidFunctionalComponent from './fixtures/InvalidFunctionalComponent';
  8 | import ValidClassComponent from './fixtures/ValidClassComponent';
  9 | import ValidFunctionalComponent from './fixtures/ValidFunctionalComponent';
 10 | import TestClassComponent from './fixtures/TestClassComponent';
 11 | import TestFunctionalComponent from './fixtures/TestFunctionalComponent';
 12 | import injectFooFactoryFunctionalComponent from './fixtures/injectFooFactoryFunctionalComponent';
 13 | import injectFooHocFunctionalComponent from './fixtures/injectFooHocFunctionalComponent';
 14 | import injectFooFactoryClassComponent from './fixtures/injectFooFactoryClassComponent';
 15 | import injectFooHocClassComponent from './fixtures/injectFooHocClassComponent';
 16 | 
 17 | 
 18 | // tests for ClassComponentWithDefaultProps
 19 | (function(){
 20 |   // should pass
 21 |   (ValidClassComponent: ClassComponentWithDefaultProps<{number1: number}, {string1: string, number1: number}, void>);
 22 | 
 23 |   // $FlowExpectError
 24 |   (ValidClassComponent: ClassComponentWithDefaultProps<{number1: string}, {string1: string, number1: number}, void>);
 25 | 
 26 |   // $FlowExpectError
 27 |   (ValidClassComponent: ClassComponentWithDefaultProps<{}, {string1: string, number1: number}, void>);
 28 | 
 29 |   // $FlowExpectError
 30 |   (ValidClassComponent: ClassComponentWithDefaultProps<{number1: number}, {number1: number}, void>);
 31 | 
 32 |   (class extends React.PureComponent<{b: string}, {c: string}> {static defaultProps = {a: 'foo'}} :ClassComponentWithDefaultProps<{a: string}, {b: string}, {c: string}>)
 33 | })();
 34 | 
 35 | // Now, the tests for HigherOrderComponent:
 36 | (function() {
 37 |   // Let's start with only the ProvidedProps part:
 38 |   declare var provideString1: HigherOrderComponent<{}, {string1: string}>;
 39 | 
 40 |   (function(){
 41 |     // ... and test it with our functional component:
 42 |     const ProvideString1OfValidFunctionalComponent = provideString1(ValidFunctionalComponent);
 43 | 
 44 |     // should pass:
 45 |     (<ProvideString1OfValidFunctionalComponent number1={10} />: React.Element<any>);
 46 |   })();
 47 | 
 48 |   (function(){
 49 |     // Now with the class-based component:
 50 |     const ProvideString1OfValidClassComponent = provideString1(ValidClassComponent);
 51 | 
 52 |     // should pass:
 53 |     (<ProvideString1OfValidClassComponent />: React.Element<any>);
 54 | 
 55 |     // $FlowExpectError
 56 |     (<ProvideString1OfValidClassComponent number1="foo" />: React.Element<any>);
 57 |   })();
 58 | 
 59 |   // now both ProvidedProps and RequiredProps:
 60 |   declare var provideString1AndRequireObject1: HigherOrderComponent<{object1: Object}, {string1: string}>;
 61 | 
 62 |   (function(){
 63 |     // with the functional component:
 64 |     const ProvideString1AndRequireObject1OfValidFunctionalComponent = provideString1AndRequireObject1(ValidFunctionalComponent);
 65 | 
 66 |     // should pass:
 67 |     <ProvideString1AndRequireObject1OfValidFunctionalComponent object1={{}} number1={10} />;
 68 | 
 69 |     // $FlowExpectError
 70 |     <ProvideString1AndRequireObject1OfValidFunctionalComponent number1={10} />;
 71 |   })();
 72 | 
 73 |   (function(){
 74 |     // with the class component:
 75 |     const ProvideString1AndRequireObject1OfValidClassComponent = provideString1AndRequireObject1(ValidClassComponent);
 76 | 
 77 |     // should pass:
 78 |     <ProvideString1AndRequireObject1OfValidClassComponent object1={{}} />;
 79 | 
 80 |     // $FlowExpectError
 81 |     <ProvideString1AndRequireObject1OfValidClassComponent />;
 82 |   })();
 83 | 
 84 |   // Composition:
 85 |   (function(){
 86 |     declare var provideNumber1AndRequireNumber2: HigherOrderComponent<{number2: number}, {number1: number}>;
 87 |     declare var requireNumber3: HigherOrderComponent<{number3: number}, {}>;
 88 |     const ComposedComponent = provideString1(provideNumber1AndRequireNumber2(requireNumber3(ValidFunctionalComponent)));
 89 | 
 90 |     <ComposedComponent number2={1} number3={1} />;
 91 | 
 92 |     // $FlowExpectError
 93 |     <ComposedComponent number1={1} number3={1} />;
 94 |     // $FlowExpectError
 95 |     <ComposedComponent number1={1} number2={1} />;
 96 | 
 97 |     // using ramda's compose:
 98 |     type FN<A,R> = (a: A) => R;
 99 |     declare var compose:
100 |       ((end: void) => (<T>(x: T) => T)) &
101 |       (<A,B>(m1: FN<A,B>, end: void) => FN<A,B>) &
102 |       (<A,B,C>(m1: FN<B,C>, m2: FN<A,B>, end: void) => FN<A,C>) &
103 |       (<A,B,C,D>(m1: FN<C,D>, m2: FN<B,C>, m3: FN<A,B>, end: void) => FN<A,D>) &
104 |       (<A,B,C,D,E>(m1: FN<D,E>, m2: FN<C,D>, m3: FN<B,C>, m4: FN<A,B>, end: void) => FN<A,E>) &
105 |       (<A,B,C,D,E,F>(m1: FN<E,F>, m2: FN<D,E>, m3: FN<C,D>, m4: FN<B,C>, m5: FN<A,B>, end: void) => FN<A,F>) &
106 |       (<A,B,C,D,E,F,G>(m1: FN<F,G>, m2: FN<E,F>, m3: FN<D,E>, m4: FN<C,D>, m5: FN<B,C>, m6: FN<A,B>, end: void) => FN<A,G>) &
107 |       (<A,B,C,D,E,F,G,H>(m1: FN<G,H>, m2: FN<F,G>, m3: FN<E,F>, m4: FN<D,E>, m5: FN<C,D>, m6: FN<B,C>, m7: FN<A,B>, end: void) => FN<A,H>) &
108 |       (<A,B,C,D,E,F,G,H,J>(m1: FN<G,J>, m2: FN<G,H>, m3: FN<F,G>, m4: FN<E,F>, m5: FN<D,E>, m6: FN<C,D>, m7: FN<B,C>, m8: FN<A,B>, end: void) => FN<A,J>) &
109 |       (<A,B,C,D,E,F,G,H,J,K>(m1: FN<J,K>, m2: FN<G,J>, m3: FN<G,H>, m4: FN<F,G>, m5: FN<E,F>, m6: FN<D,E>, m7: FN<C,D>, m8: FN<B,C>, m9: FN<A,B>, end: void) => FN<A,K>) &
110 |       (<A,B,C,D,E,F,G,H,J,K,L>(m1: FN<K,L>, m2: FN<J,K>, m3: FN<G,J>, m4: FN<G,H>, m5: FN<F,G>, m6: FN<E,F>, m7: FN<D,E>, m8: FN<C,D>, m9: FN<B,C>, m10: FN<A,B>, end: void) => FN<A,L>) &
111 |       (<A,R>(...funcs: Array<FN<A,R>>) => FN<A,R>);
112 | 
113 |       const ComposedComponent2 = compose(
114 |         requireNumber3,
115 |         provideNumber1AndRequireNumber2,
116 |         provideString1,
117 |       )(ValidFunctionalComponent);
118 | 
119 |       <ComposedComponent2 number1={1} number2={1} number3={1} />;
120 | 
121 |       <ComposedComponent2 number2={1} number3={1} />;
122 | 
123 |       // $FlowExpectError
124 |       <ComposedComponent2 number1={1} number3={1} />;
125 |       // $FlowExpectError
126 |       <ComposedComponent2 number1={1} number2={1} />;
127 |   })();
128 | 
129 | 
130 |   (function(){
131 |     // -----------------------------------
132 |     // target: TestClassComponent
133 |     const InjectedFooClassFactoryFunctionalComponent = injectFooFactoryFunctionalComponent(TestClassComponent);
134 |     <InjectedFooClassFactoryFunctionalComponent baz={10} />;
135 |     // $FlowExpectErrorTestClassComponent
136 |     <InjectedFooClassFactoryFunctionalComponent foo="asdf" bar={3} baz={10} />;
137 | 
138 | 
139 |     const InjectedFooClassHocFunctional = injectFooHocFunctionalComponent()(TestClassComponent);
140 |     <InjectedFooClassHocFunctional baz={10} />;
141 |     // $FlowExpectErrorTestClassComponent
142 |     <InjectedFooClassHocFunctional foo="asdf" bar={3} baz={10} />;
143 | 
144 | 
145 |     const InjectedFooClassFactoryClassComponent = injectFooFactoryClassComponent(TestClassComponent);
146 |     <InjectedFooClassFactoryClassComponent baz={10} />;
147 |     // $FlowExpectErrorTestClassComponent
148 |     <InjectedFooClassFactoryClassComponent foo="asdf" bar={3} baz={10} />;
149 | 
150 | 
151 |     const InjectedFooClassHocClassComponent = injectFooHocClassComponent({foo: 'bar'})(TestClassComponent);
152 |     <InjectedFooClassHocClassComponent baz={10} />;
153 |     // $FlowExpectErrorTestClassComponent
154 |     <InjectedFooClassHocClassComponent foo="asdf" bar={3} baz={10} />;
155 |   })();
156 | 
157 | 
158 |   (function(){
159 |     // -----------------------------------
160 |     // target: TestFunctionalComponent
161 |     const InjectedFooFunctionFactoryFunctionalComponent = injectFooFactoryFunctionalComponent(TestFunctionalComponent);
162 |     <InjectedFooFunctionFactoryFunctionalComponent baz={10} />;
163 |     // $FlowExpectErrorTestFunctionalComponent
164 |     <InjectedFooFunctionFactoryFunctionalComponent foo="asdf" bar={3} baz={10} />;
165 | 
166 | 
167 |     const InjectedFooFunctionHocFunctional = injectFooHocFunctionalComponent()(TestFunctionalComponent);
168 |     <InjectedFooFunctionHocFunctional baz={10} />;
169 |     // $FlowExpectErrorTestFunctionalComponent
170 |     <InjectedFooFunctionHocFunctional foo="asdf" bar={3} baz={10} />;
171 | 
172 | 
173 |     const InjectedFooFunctionFactoryClassComponent = injectFooFactoryClassComponent(TestFunctionalComponent);
174 |     <InjectedFooFunctionFactoryClassComponent baz={10} />;
175 |     // $FlowExpectErrorTestFunctionalComponent
176 |     <InjectedFooFunctionFactoryClassComponent foo="asdf" bar={3} baz={10} />;
177 | 
178 | 
179 |     const InjectedFooFunctionHocClassComponent = injectFooHocClassComponent({foo: 'bar'})(TestFunctionalComponent);
180 |     <InjectedFooFunctionHocClassComponent baz={10} />;
181 |     // $FlowExpectErrorTestFunctionalComponent
182 |     <InjectedFooFunctionHocClassComponent foo="asdf" bar={3} baz={10} />;
183 |   })();
184 | 
185 |   (function(){
186 |     // Ensure components have injected props defined.
187 |     declare var provideString2: HigherOrderComponent<{}, {string2: string}>;
188 |     // $FlowExpectError
189 |     const ProvideString1OfValidClassComponent = provideString2(ValidClassComponent);
190 |   })();
191 | })();
192 | 


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