Source: store.js

  1. /**
  2.  * This module is here to help app to create the redux store
  3.  * @module react-cmf/lib/store
  4.  */
  5. import { combineReducers, createStore, applyMiddleware, compose } from 'redux';
  6. import { enableBatching } from 'redux-batched-actions';
  7. import { nestedCombineReducers } from 'nested-combine-reducers';
  8. import thunk from 'redux-thunk';
  9. import invariant from 'invariant';
  11. import cmfReducers from './reducers';
  12. import httpMiddleware from './middlewares/http';
  13. import cmfMiddleware from './middlewares/cmf';
  14. import onError from './onError';
  16. /**
  17.  * @typedef {Object} Store
  18.  */
  20. const preReducers = [];
  21. const enhancers = [];
  22. const middlewares = [thunk, cmfMiddleware, onError.middleware];
  24. if (window) {
  25. 	// eslint-disable-next-line no-underscore-dangle
  26. 	if (window.__REDUX_DEVTOOLS_EXTENSION__) {
  27. 		// eslint-disable-next-line no-underscore-dangle
  28. 		enhancers.push(window.__REDUX_DEVTOOLS_EXTENSION__());
  29. 	} else if (window.devToolsExtension) {
  30. 		enhancers.push(window.devToolsExtension());
  31. 	}
  32. }
  34. let defaultHttpMiddlewareOverwrite = false;
  36. /**
  37.  * setHttpMiddleware overwrites the default http middleware
  38.  * httpMiddleware NEED to be executed before cmfMiddleware
  39.  *
  40.  * @param middleware a http middleware
  41.  */
  42. function setHttpMiddleware(middleware) {
  43. 	const cmfMiddlewareIndex = middlewares.indexOf(cmfMiddleware);
  44. 	middlewares.splice(cmfMiddlewareIndex - 1, 0, middleware);
  45. 	defaultHttpMiddlewareOverwrite = true;
  46. }
  48. function addPreReducer(reducers) {
  49. 	if (typeof reducers === 'function') {
  50. 		preReducers.push(reducers);
  51. 	} else if (Array.isArray(reducers)) {
  52. 		preReducers.push(...reducers);
  53. 	}
  54. }
  56. function preApplyReducer(reducer) {
  57. 	if (preReducers.length === 0) {
  58. 		return reducer;
  59. 	}
  60. 	const newReducer = (state, action) => {
  61. 		const newState = preReducers.reduce(
  62. 			(accumulatedState, r) => r(accumulatedState, action),
  63. 			state,
  64. 		);
  65. 		return reducer(newState, action);
  66. 	};
  67. 	return newReducer;
  68. }
  70. /**
  71.  * Return the CMF reducer
  72.  * @param  {function|Object} appReducer [description]
  73.  * @return {function}            [description]
  74.  */
  75. function getReducer(appReducer) {
  76. 	let reducerObject = {};
  77. 	if (appReducer) {
  78. 		if (typeof appReducer === 'object') {
  79. 			reducerObject = { ...appReducer };
  80. 		} else if (typeof appReducer === 'function') {
  81. 			reducerObject = { app: appReducer };
  82. 		}
  83. 	} else {
  84. 		invariant(true, 'Are you sure you want to bootstrap an app without reducers ?');
  85. 	}
  86. 	if (!reducerObject.cmf) {
  87. 		reducerObject.cmf = cmfReducers;
  88. 	}
  90. 	return enableBatching(preApplyReducer(nestedCombineReducers(reducerObject, combineReducers)));
  91. }
  93. /**
  94.  * return the array of all middleware needed for CMF to run
  95.  * @param {array|function} middleware
  96.  * @returns {array} of middlewares
  97.  */
  98. function getMiddlewares(middleware) {
  99. 	if (Array.isArray(middleware)) {
  100. 		middleware.forEach(mid => {
  101. 			if (middlewares.indexOf(mid) === -1) {
  102. 				middlewares.push(mid);
  103. 			}
  104. 		});
  105. 	} else if (middleware) {
  106. 		middlewares.push(middleware);
  107. 	}
  108. 	if (!defaultHttpMiddlewareOverwrite) {
  109. 		setHttpMiddleware(httpMiddleware());
  110. 	}
  111. 	return middlewares;
  112. }
  114. /**
  115.  * helper to create the store with all the things needed by CMF
  116.  * the store look like this:
  117.  * - root
  118.  * |- app (with appReducer)
  119.  * |- cmf (for the internals)
  120.  *
  121.  * @param  {function} appReducer   the reducer for your app.
  122.  * @param  {any} preloadedState if you want to create your state tree with initial values.
  123.  *                              This is usefull for server side renderring
  124.  * @param  {function} enhancer     The store enhancer
  125.  * @param  {Array|function} middleware   redux middleware: http://redux.js.org/docs/api/applyMiddleware.html
  126.  * @return {Object}              The created store
  127.  */
  128. function initialize(appReducer, preloadedState, enhancer, middleware) {
  129. 	const reducer = getReducer(appReducer);
  130. 	if (typeof enhancer === 'function') {
  131. 		enhancers.push(enhancer);
  132. 	}
  133. 	const middles = getMiddlewares(middleware);
  134. 	const store = compose(applyMiddleware(...middles), ...enhancers)(createStore)(
  135. 		reducer,
  136. 		preloadedState,
  137. 	);
  139. 	return store;
  140. }
  142. export default {
  143. 	addPreReducer,
  144. 	setHttpMiddleware,
  145. 	initialize,
  146. 	// for testing purepose only
  147. 	getReducer,
  148. 	getMiddlewares,
  149. };