Code coverage report for lib/addons/ReactFluxComponent.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3
 
1
 
1
 
1
 
1
 
 
 
 
 
 
5
 
 
 
9
9
 
4
4
 
 
 
 
4
 
 
 
 
 
 
 
 
1
 
/**
 * React Flux Component
 *
 * Component form of ReactMixin. Uses ReactMixin as part of its implementation,
 * so requires a flux instance to be provided as either context or a prop.
 *
 * Like ReactMixin, children are given access to the flux instance via
 * `context.flux`. Use this near the top of your app hierarchy and all children
 * will have easy access to the flux instance (including, of course, other
 * Flux components!):
 *
 * <FluxComponent flux={flux}>
 *    ...the rest of your app
 * </FluxComponent>
 *
 * Now any child can access the flux instance again like this:
 *
 * <FluxComponent>
 *    ...children
 * </FluxComponent>
 *
 * We don't need the flux prop this time because flux is already part of
 * the context.
 *
 * Additionally, immediate children are given a `flux` prop.
 *
 * The component has an optional prop `connectToStores`, which is -- you guessed
 * it -- passed directly to ReactMixin's `connectToStores()` function and
 * set as the initial state. The component's state is injected as props to
 * child components.
 *
 * The practical upshot of all this is that ReactMixin, state changes, and
 * context are now simply implementation details. Among other things, this means
 * you can write your components as plain ES6 classes. Here's an example:
 *
 * class ParentComponent extends React.Component {
 *
 *   render() {
 *     <FluxComponent connectToStore="fooStore">
 *       <ChildComponent />
 *     </FluxComponent>
 *   }
 *
 * }
 *
 * ChildComponent in this example has prop `flux` containing the flux instance,
 * and props that sync with each of the state keys of fooStore.
 */
 
"use strict";
 
var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
 
var React = _interopRequire(require("react/addons"));
 
var ReactMixin = _interopRequire(require("./ReactMixin"));
 
var assign = _interopRequire(require("object-assign"));
 
var ReactFluxComponent = React.createClass({
  displayName: "ReactFluxComponent",
 
 
  mixins: [ReactMixin()],
 
  getInitialState: function getInitialState() {
    return this.connectToStores(this.props.connectToStores);
  },
 
  render: function render() {
    var _this = this;
    if (!this.props.children) return null;
 
    var children = React.Children.map(this.props.children, function (child) {
      return React.addons.cloneWithProps(child, assign({
        key: child.key || undefined,
        flux: _this.flux }, _this.state));
    });
 
    return React.createElement(
      "span",
      null,
      children
    );
  }
 
});
 
module.exports = ReactFluxComponent;
//# sourceMappingURL=data:application/json;base64,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