| 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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216 |
2
1
1
1
1
1
1
7
4
7
50
27
27
27
27
27
27
1
26
2
2
2
2
2
2
24
3
3
3
49
20
45
45
45
45
19
19
19
45
8
8
8
8
8
8
8
8
37
2
2
2
2
2
2
2
4
4
4
35
7
7
7
7
7
7
7
45
1
17
14
13
13
1
15
1
3
6
| "use strict";
var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
module.exports = fluxMixin;
/**
* fluxMixin
*
* Exports a function that creates a React component mixin. The mixin exposes
* a Flux instance as `this.flux`. This requires that flux be passed as either
* context or as a prop (prop takes precedence). Children also are given access
* to flux instance as `context.flux`.
*
* It also adds the method `connectToStores()`, which ensures that the component
* state stays in sync with the specified Flux stores. See the inline docs
* of `connectToStores` for details.
*
* Any arguments passed to the mixin creator are passed to `connectToStores()`
* and used as the return value of `getInitialState()`. This lets you handle
* all of the state initialization and updates in a single place, while removing
* the burden of manually adding and removing store listeners.
*
* @example
* let Component = React.createClass({
* mixins: [fluxMixin({
* storeA: store => ({
* foo: store.state.a,
* }),
* storeB: store => ({
* bar: store.state.b,
* })
* }]
* });
*/
var PropTypes = require("react").PropTypes;
var Flux = require("../Flux").Flux;
var assign = _interopRequire(require("object-assign"));
var shallowEqual = _interopRequire(require("react/lib/shallowEqual"));
function fluxMixin() {
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
return {
contextTypes: {
flux: PropTypes.instanceOf(Flux) },
childContextTypes: {
flux: PropTypes.instanceOf(Flux) },
getChildContext: function getChildContext() {
return {
flux: this.flux
};
},
getInitialState: function getInitialState() {
var _ref;
this._fluxStateGetters = [];
this._fluxListeners = {};
this._fluxDidSyncStoreState = false;
this.flux = this.props.flux || this.context.flux;
if (!(this.flux instanceof Flux)) {
// TODO: print the actual class name here
throw new Error("fluxMixin: Could not find Flux instance. Ensure that your component " + "has either `this.context.flux` or `this.props.flux`.");
}
return (_ref = this).connectToStores.apply(_ref, args);
},
componentWillUnmount: function componentWillUnmount() {
for (var key in this._fluxListeners) {
Iif (!this._fluxListeners.hasOwnProperty(key)) continue;
var store = this.flux.getStore(key);
Iif (typeof store === "undefined") continue;
var listener = this._fluxListeners[key];
store.removeListener("change", listener);
}
},
componentDidUpdate: function componentDidUpdate(prevProps) {
if (!shallowEqual(prevProps, this.props)) {
this.updateStores();
}
},
updateStores: function updateStores() {
var state = this.getStoreState();
this.setState(state);
},
getStoreState: function getStoreState() {
return this._fluxStateGetters.reduce(function (result, stateGetter) {
return assign(result, stateGetter.getter(stateGetter.stores));
}, {});
},
/**
* Connect component to stores, get the combined initial state, and
* subscribe to future changes. There are three ways to call it. The
* simplest is to pass a single store key and, optionally, a state getter.
* The state getter is a function that takes the store as a parameter and
* returns the state that should be passed to the component's `setState()`.
* If no state getter is specified, the default getter is used, which simply
* returns the entire store state.
*
* The second form accepts an array of store keys. With this form, the state
* getter is called once with an array of store instances (in the same order
* as the store keys). the default getter performance a reduce on the entire
* state for each store.
*
* The last form accepts an object of store keys mapped to state getters. As
* a shortcut, you can pass `null` as a state getter to use the default
* state getter.
*
* Returns the combined initial state of all specified stores.
*
* This way you can write all the initialization and update logic in a single
* location, without having to mess with adding/removing listeners.
*
* @type {string|array|object} stateGetterMap - map of keys to getters
* @returns {object} Combined initial state of stores
*/
connectToStores: function connectToStores() {
var _this = this;
var stateGetterMap = arguments[0] === undefined ? {} : arguments[0];
var stateGetter = arguments[1] === undefined ? null : arguments[1];
var getStore = function (key) {
var store = _this.flux.getStore(key);
Iif (typeof store === "undefined") {
throw new Error("connectToStores(): Store with key '" + key + "' does not exist.");
}
return store;
};
if (typeof stateGetterMap === "string") {
var key = stateGetterMap;
var store = getStore(key);
var getter = stateGetter || defaultStateGetter;
getter = getter.bind(this);
this._fluxStateGetters.push({ stores: store, getter: getter });
var listener = createStoreListener(this, store, getter).bind(this);
store.addListener("change", listener);
this._fluxListeners[key] = listener;
} else if (Array.isArray(stateGetterMap)) {
(function () {
var stores = stateGetterMap.map(getStore);
var getter = stateGetter || defaultReduceStateGetter;
getter = getter.bind(_this);
_this._fluxStateGetters.push({ stores: stores, getter: getter });
var listener = createStoreListener(_this, stores, getter).bind(_this);
stateGetterMap.forEach(function (key, index) {
var store = stores[index];
store.addListener("change", listener);
_this._fluxListeners[key] = listener;
});
})();
} else {
for (var key in stateGetterMap) {
var store = getStore(key);
var getter = stateGetterMap[key] || defaultStateGetter;
getter = getter.bind(this);
this._fluxStateGetters.push({ stores: store, getter: getter });
var listener = createStoreListener(this, store, getter).bind(this);
store.addListener("change", listener);
this._fluxListeners[key] = listener;
}
}
return this.getStoreState();
}
};
}
function createStoreListener(component, store, storeStateGetter) {
return function () {
if (this.isMounted()) {
var state = storeStateGetter(store);
this.setState(state);
}
};
}
function defaultStateGetter(store) {
return store.state;
}
function defaultReduceStateGetter(stores) {
return stores.reduce(function (result, store) {
return assign(result, store.state);
}, {});
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["src/addons/fluxMixin.js"],"names":[],"mappings":"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","file":"lib/addons/fluxMixin.js","sourcesContent":["/**\n * fluxMixin\n *\n * Exports a function that creates a React component mixin. The mixin exposes\n * a Flux instance as `this.flux`. This requires that flux be passed as either\n * context or as a prop (prop takes precedence). Children also are given access\n * to flux instance as `context.flux`.\n *\n * It also adds the method `connectToStores()`, which ensures that the component\n * state stays in sync with the specified Flux stores. See the inline docs\n * of `connectToStores` for details.\n *\n * Any arguments passed to the mixin creator are passed to `connectToStores()`\n * and used as the return value of `getInitialState()`. This lets you handle\n * all of the state initialization and updates in a single place, while removing\n * the burden of manually adding and removing store listeners.\n *\n * @example\n * let Component = React.createClass({\n *   mixins: [fluxMixin({\n *     storeA: store => ({\n *       foo: store.state.a,\n *     }),\n *     storeB: store => ({\n *       bar: store.state.b,\n *     })\n *   }]\n * });\n */\n\nimport { PropTypes } from 'react';\nimport { Flux } from '../Flux';\nimport assign from 'object-assign';\nimport shallowEqual from 'react/lib/shallowEqual';\n\nexport default function fluxMixin(...args) {\n\n  return {\n\n    contextTypes: {\n      flux: PropTypes.instanceOf(Flux),\n    },\n\n    childContextTypes: {\n      flux: PropTypes.instanceOf(Flux),\n    },\n\n    getChildContext() {\n      return {\n        flux: this.flux\n      };\n    },\n\n    getInitialState() {\n      this._fluxStateGetters = [];\n      this._fluxListeners = {};\n      this._fluxDidSyncStoreState = false;\n      this.flux = this.props.flux || this.context.flux;\n\n      if (!(this.flux instanceof Flux)) {\n        // TODO: print the actual class name here\n        throw new Error(\n          `fluxMixin: Could not find Flux instance. Ensure that your component `\n        + `has either \\`this.context.flux\\` or \\`this.props.flux\\`.`\n        );\n      }\n\n      return this.connectToStores(...args);\n    },\n\n    componentWillUnmount() {\n      for (let key in this._fluxListeners) {\n        if (!this._fluxListeners.hasOwnProperty(key)) continue;\n\n        let store = this.flux.getStore(key);\n        if (typeof store === 'undefined') continue;\n\n        let listener = this._fluxListeners[key];\n\n        store.removeListener('change', listener);\n      }\n    },\n\n    componentDidUpdate(prevProps) {\n      if (!shallowEqual(prevProps, this.props)) {\n        this.updateStores();\n      }\n    },\n\n    updateStores() {\n      let state = this.getStoreState();\n      this.setState(state);\n    },\n\n    getStoreState() {\n      return this._fluxStateGetters.reduce(\n        (result, stateGetter) => assign(result, stateGetter.getter(stateGetter.stores)),\n        {}\n      );\n    },\n\n    /**\n     * Connect component to stores, get the combined initial state, and\n     * subscribe to future changes. There are three ways to call it. The\n     * simplest is to pass a single store key and, optionally, a state getter.\n     * The state getter is a function that takes the store as a parameter and\n     * returns the state that should be passed to the component's `setState()`.\n     * If no state getter is specified, the default getter is used, which simply\n     * returns the entire store state.\n     *\n     * The second form accepts an array of store keys. With this form, the state\n     * getter is called once with an array of store instances (in the same order\n     * as the store keys). the default getter performance a reduce on the entire\n     * state for each store.\n     *\n     * The last form accepts an object of store keys mapped to state getters. As\n     * a shortcut, you can pass `null` as a state getter to use the default\n     * state getter.\n     *\n     * Returns the combined initial state of all specified stores.\n     *\n     * This way you can write all the initialization and update logic in a single\n     * location, without having to mess with adding/removing listeners.\n     *\n     * @type {string|array|object} stateGetterMap - map of keys to getters\n     * @returns {object} Combined initial state of stores\n     */\n    connectToStores(stateGetterMap = {}, stateGetter = null) {\n      let getStore = (key) => {\n        let store = this.flux.getStore(key);\n\n        if (typeof store === 'undefined') {\n          throw new Error(\n            `connectToStores(): Store with key '${key}' does not exist.`\n          );\n        }\n\n        return store;\n      };\n\n      if (typeof stateGetterMap === 'string') {\n        let key = stateGetterMap;\n        let store = getStore(key);\n        let getter = stateGetter || defaultStateGetter;\n\n        getter = getter.bind(this);\n\n        this._fluxStateGetters.push({ stores: store, getter });\n        let listener = createStoreListener(this, store, getter)\n            .bind(this);\n\n        store.addListener('change', listener);\n        this._fluxListeners[key] = listener;\n      } else if (Array.isArray(stateGetterMap)) {\n        let stores = stateGetterMap.map(getStore);\n        let getter = stateGetter || defaultReduceStateGetter;\n\n        getter = getter.bind(this);\n\n        this._fluxStateGetters.push({ stores, getter });\n\n        let listener = createStoreListener(this, stores, getter)\n            .bind(this);\n\n        stateGetterMap.forEach((key, index) => {\n          let store = stores[index];\n          store.addListener('change', listener);\n          this._fluxListeners[key] = listener;\n        });\n\n      } else {\n        for (let key in stateGetterMap) {\n          let store = getStore(key);\n          let getter = stateGetterMap[key] || defaultStateGetter;\n\n          getter = getter.bind(this);\n\n          this._fluxStateGetters.push({ stores: store, getter });\n\n          let listener = createStoreListener(this, store, getter)\n            .bind(this);\n\n          store.addListener('change', listener);\n          this._fluxListeners[key] = listener;\n        }\n      }\n\n      return this.getStoreState();\n    }\n\n  };\n\n};\n\nfunction createStoreListener(component, store, storeStateGetter) {\n  return function() {\n    if (this.isMounted()) {\n      let state = storeStateGetter(store);\n      this.setState(state);\n    }\n  };\n}\n\nfunction defaultStateGetter(store) {\n  return store.state;\n}\n\nfunction defaultReduceStateGetter(stores) {\n  return stores.reduce(\n    (result, store) => assign(result, store.state),\n    {}\n  );\n}\n"]} |