| 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 |
1
17
16
1
1
1
1
6
2
6
29
17
17
17
17
1
16
1
1
1
1
1
1
27
27
27
27
27
7
7
20
27
10
10
10
10
10
10
10
10
9
9
10
10
10
27
1
12
| /**
* React Mixin
*
* 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: [ReactMixin({
* storeA: store => ({
* foo: store.state.a,
* }),
* storeB: store => ({
* bar: store.state.b,
* })
* }]
* });
*/
"use strict";
var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
var _defineProperty = function (obj, key, value) { return Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); };
var _toArray = function (arr) { return Array.isArray(arr) ? arr : Array.from(arr); };
var PropTypes = require("react").PropTypes;
var Flux = require("../Flux").Flux;
var assign = _interopRequire(require("object-assign"));
module.exports = function () {
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._flux_listeners = {};
this.flux = this.props.flux || this.context.flux;
if (!(this.flux instanceof Flux)) {
// TODO: print the actual class name here
throw new Error("ReactMixin: Could not find Flux instance. Ensure that your component " + "has either `this.context.flux` or `this.props.flux`.");
}
return (_ref = this).connectToStores.apply(_ref, _toArray(args));
},
componentWillUnmount: function componentWillUnmount() {
for (var key in this._flux_listeners) {
Iif (!this._flux_listeners.hasOwnProperty(key)) continue;
var store = this.flux.getStore(key);
Iif (typeof store === "undefined") continue;
var listener = this._flux_listeners[key];
store.removeListener("change", listener);
}
},
/**
* 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, every
* store uses the default state getter.
*
* 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 ? defaultStateGetter : arguments[1];
var initialState = {};
// Ensure that stateGetterMap is an object
if (typeof stateGetterMap === "string") {
var key = stateGetterMap;
stateGetterMap = _defineProperty({}, key, stateGetter);
} else Iif (Array.isArray(stateGetterMap)) {
stateGetterMap.reduce(function (result, key) {
result[key] = stateGetter;
return result;
}, {});
}
for (var key in stateGetterMap) {
(function (key) {
var store = _this.flux.getStore(key);
Iif (typeof store === "undefined") throw new Error("connectToStores(): Store with key '" + key + "' does not exist.");
var storeStateGetter = stateGetterMap[key];
if (storeStateGetter === null) storeStateGetter = defaultStateGetter;
storeStateGetter = storeStateGetter.bind(_this);
var initialStoreState = storeStateGetter(store);
var listener = function () {
var state = storeStateGetter(store);
_this.setState(state);
};
store.addListener("change", listener);
assign(_this._flux_listeners, _defineProperty({}, key, listener));
assign(initialState, initialStoreState);
})(key);
}
return initialState;
}
};
};
function defaultStateGetter(store) {
return store.state;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["src/addons/ReactMixin.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,YAAY,CAAC;;;;;;;;IAEJ,SAAS,WAAQ,OAAO,EAAxB,SAAS;IACT,IAAI,WAAQ,SAAS,EAArB,IAAI;IACN,MAAM,2BAAM,eAAe;;iBAGnB,YAAkB;oCAAN,IAAI;AAAJ,QAAI;;;AAE7B,SAAO;;AAEL,gBAAY,EAAE;AACZ,UAAI,EAAE,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,EACjC;;AAED,qBAAiB,EAAE;AACjB,UAAI,EAAE,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,EACjC;;AAED,mBAAe,EAAA,2BAAG;AAChB,aAAO;AACL,YAAI,EAAE,IAAI,CAAC,IAAI;OAChB,CAAC;KACH;;AAED,mBAAe,EAAA,2BAAG;;AAChB,UAAI,CAAC,eAAe,GAAG,EAAE,CAAC;AAC1B,UAAI,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;;AAEjD,UAAI,EAAE,IAAI,CAAC,IAAI,YAAY,IAAI,CAAA,AAAC,EAAE;;AAEhC,cAAM,IAAI,KAAK,CACb,gIAC0D,CAC3D,CAAC;OACH;;AAED,aAAO,QAAA,IAAI,EAAC,eAAe,MAAA,gBAAI,IAAI,EAAC,CAAC;KACtC;;AAED,wBAAoB,EAAA,gCAAG;AACrB,WAAK,IAAI,GAAG,IAAI,IAAI,CAAC,eAAe,EAAE;AACpC,YAAI,CAAC,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,SAAS;;AAExD,YAAI,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;AACpC,YAAI,OAAO,KAAK,KAAK,WAAW,EAAE,SAAS;;AAE3C,YAAI,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;;AAEzC,aAAK,CAAC,cAAc,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;OAC1C;KACF;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BD,mBAAe,EAAA,2BAAwD;;UAAvD,cAAc,gCAAG,EAAE;UAAE,WAAW,gCAAG,kBAAkB;AACnE,UAAI,YAAY,GAAG,EAAE,CAAC;;;AAGtB,UAAI,OAAO,cAAc,KAAK,QAAQ,EAAE;AACtC,YAAI,GAAG,GAAG,cAAc,CAAC;;AAEzB,sBAAc,uBACX,GAAG,EAAG,WAAW,CACnB,CAAC;OACH,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE;AACxC,sBAAc,CAAC,MAAM,CAAC,UAAC,MAAM,EAAE,GAAG,EAAK;AACrC,gBAAM,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC;AAC1B,iBAAO,MAAM,CAAC;SACf,EAAE,EAAE,CAAC,CAAC;OACR;;AAED,WAAK,IAAI,GAAG,IAAI,cAAc,EAAE;mBAAvB,GAAG;AACV,cAAI,KAAK,GAAG,MAAK,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;;AAEpC,cAAI,OAAO,KAAK,KAAK,WAAW,EAAE,MAAM,IAAI,KAAK,yCACT,GAAG,uBAC1C,CAAC;;AAEF,cAAI,gBAAgB,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC;;AAE3C,cAAI,gBAAgB,KAAK,IAAI,EAAE,gBAAgB,GAAG,kBAAkB,CAAC;;AAErE,0BAAgB,GAAG,gBAAgB,CAAC,IAAI,OAAM,CAAC;;AAE/C,cAAI,iBAAiB,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;;AAEhD,cAAI,QAAQ,GAAG,YAAM;AACnB,gBAAI,KAAK,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;AACpC,kBAAK,QAAQ,CAAC,KAAK,CAAC,CAAC;WACtB,CAAC;;AAEF,eAAK,CAAC,WAAW,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;;AAEtC,gBAAM,CAAC,MAAK,eAAe,sBACxB,GAAG,EAAG,QAAQ,EACf,CAAC;;AAEH,gBAAM,CAAC,YAAY,EAAE,iBAAiB,CAAC,CAAC;WA1BjC,GAAG;OA2BX;;AAED,aAAO,YAAY,CAAC;KACrB;;GAEF,CAAA;CAEF;;AAED,SAAS,kBAAkB,CAAC,KAAK,EAAE;AACjC,SAAO,KAAK,CAAC,KAAK,CAAC;CACpB","file":"src/addons/ReactMixin.js","sourcesContent":["/**\n * React Mixin\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: [ReactMixin({\n *     storeA: store => ({\n *       foo: store.state.a,\n *     }),\n *     storeB: store => ({\n *       bar: store.state.b,\n *     })\n *   }]\n * });\n */\n\n'use strict';\n\nimport { PropTypes } from 'react';\nimport { Flux } from '../Flux';\nimport assign from 'object-assign';\n\n\nexport default function(...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._flux_listeners = {};\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          `ReactMixin: 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._flux_listeners) {\n        if (!this._flux_listeners.hasOwnProperty(key)) continue;\n\n        let store = this.flux.getStore(key);\n        if (typeof store === 'undefined') continue;\n\n        let listener = this._flux_listeners[key];\n\n        store.removeListener('change', listener);\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, every\n     * store uses the default state getter.\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 = defaultStateGetter) {\n      let initialState = {};\n\n      // Ensure that stateGetterMap is an object\n      if (typeof stateGetterMap === 'string') {\n        let key = stateGetterMap;\n\n        stateGetterMap = {\n          [key]: stateGetter,\n        };\n      } else if (Array.isArray(stateGetterMap)) {\n        stateGetterMap.reduce((result, key) => {\n          result[key] = stateGetter;\n          return result;\n        }, {});\n      }\n\n      for (let key in stateGetterMap) {\n        let store = this.flux.getStore(key);\n\n        if (typeof store === 'undefined') throw new Error(\n          `connectToStores(): Store with key '${key}' does not exist.`\n        );\n\n        let storeStateGetter = stateGetterMap[key];\n\n        if (storeStateGetter === null) storeStateGetter = defaultStateGetter;\n\n        storeStateGetter = storeStateGetter.bind(this);\n\n        let initialStoreState = storeStateGetter(store);\n\n        let listener = () => {\n          let state = storeStateGetter(store);\n          this.setState(state);\n        };\n\n        store.addListener('change', listener);\n\n        assign(this._flux_listeners, {\n          [key]: listener,\n        });\n\n        assign(initialState, initialStoreState);\n      }\n\n      return initialState;\n    }\n\n  }\n\n};\n\nfunction defaultStateGetter(store) {\n  return store.state;\n}\n"]} |