Code coverage report for lib/addons/FluxComponent.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
91
92
93
94
95
96
97
98
99
100
101
102
103
 
 
3
 
44
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
1
 
1
 
1
 
 
 
 
 
 
10
 
 
 
16
16
16
16
 
16
 
 
 
 
20
 
 
20
5
15
14
14
 
1
 
 
 
 
 
 
 
 
 
1
 
"use strict";
 
var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
 
var _objectWithoutProperties = function (obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; Iif (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; };
 
/**
 * Flux Component
 *
 * Component form of fluxMixin. Uses fluxMixin as part of its implementation,
 * so requires a flux instance to be provided as either context or a prop.
 *
 * Like fluxMixin, 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 fluxMixin'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 fluxMixin, 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.
 */
 
var React = _interopRequire(require("react/addons"));
 
var fluxMixin = _interopRequire(require("./fluxMixin"));
 
var assign = _interopRequire(require("object-assign"));
 
var FluxComponent = React.createClass({
  displayName: "FluxComponent",
 
 
  mixins: [fluxMixin()],
 
  getInitialState: function getInitialState() {
    return this.connectToStores(this.props.connectToStores);
  },
 
  wrapChild: function wrapChild(child) {
    var _props = this.props;
    var children = _props.children;
    var connectToStores = _props.connectToStores;
    var props = _objectWithoutProperties(_props, ["children", "connectToStores"]);
 
    return React.addons.cloneWithProps(child, assign({
      flux: this.flux }, this.state, props));
  },
 
  render: function render() {
    var children = this.props.children;
 
 
    if (!children) {
      return null;
    }if (!Array.isArray(children)) {
      var child = children;
      return this.wrapChild(child);
    } else {
      return React.createElement(
        "span",
        null,
        React.Children.map(children, this.wrapChild)
      );
    }
  }
 
});
 
module.exports = FluxComponent;
//# sourceMappingURL=data:application/json;base64,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