@talend/react-cmf/lib/store.js

A framework built on top of best react libraries

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _redux = require("redux");
var _reduxBatchedActions = require("redux-batched-actions");
var _nestedCombineReducers = require("nested-combine-reducers");
var _reduxThunk = _interopRequireDefault(require("redux-thunk"));
var _invariant = _interopRequireDefault(require("invariant"));
var _reducers = _interopRequireDefault(require("./reducers"));
var _http = _interopRequireDefault(require("./middlewares/http"));
var _cmf = _interopRequireDefault(require("./middlewares/cmf"));
var _onError = _interopRequireDefault(require("./onError"));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
/**
 * This module is here to help app to create the redux store
 * @module react-cmf/lib/store
 */

/**
 * @typedef {Object} Store
 */

const preReducers = [];
const enhancers = [];
const middlewares = [_reduxThunk.default, _cmf.default, _onError.default.middleware];
if (window) {
  // eslint-disable-next-line no-underscore-dangle
  if (window.__REDUX_DEVTOOLS_EXTENSION__) {
    // eslint-disable-next-line no-underscore-dangle
    enhancers.push(window.__REDUX_DEVTOOLS_EXTENSION__());
  } else if (window.devToolsExtension) {
    enhancers.push(window.devToolsExtension());
  }
}
let defaultHttpMiddlewareOverwrite = false;

/**
 * setHttpMiddleware overwrites the default http middleware
 * httpMiddleware NEED to be executed before cmfMiddleware
 *
 * @param middleware a http middleware
 */
function setHttpMiddleware(middleware) {
  const cmfMiddlewareIndex = middlewares.indexOf(_cmf.default);
  middlewares.splice(cmfMiddlewareIndex - 1, 0, middleware);
  defaultHttpMiddlewareOverwrite = true;
}
function addPreReducer(reducers) {
  if (typeof reducers === 'function') {
    preReducers.push(reducers);
  } else if (Array.isArray(reducers)) {
    preReducers.push(...reducers);
  }
}
function preApplyReducer(reducer) {
  if (preReducers.length === 0) {
    return reducer;
  }
  const newReducer = (state, action) => {
    const newState = preReducers.reduce((accumulatedState, r) => r(accumulatedState, action), state);
    return reducer(newState, action);
  };
  return newReducer;
}

/**
 * Return the CMF reducer
 * @param  {function|Object} appReducer [description]
 * @return {function}            [description]
 */
function getReducer(appReducer) {
  let reducerObject = {};
  if (appReducer) {
    if (typeof appReducer === 'object') {
      reducerObject = {
        ...appReducer
      };
    } else if (typeof appReducer === 'function') {
      reducerObject = {
        app: appReducer
      };
    }
  } else {
    (0, _invariant.default)(true, 'Are you sure you want to bootstrap an app without reducers ?');
  }
  if (!reducerObject.cmf) {
    reducerObject.cmf = _reducers.default;
  }
  return (0, _reduxBatchedActions.enableBatching)(preApplyReducer((0, _nestedCombineReducers.nestedCombineReducers)(reducerObject, _redux.combineReducers)));
}

/**
 * return the array of all middleware needed for CMF to run
 * @param {array|function} middleware
 * @returns {array} of middlewares
 */
function getMiddlewares(middleware) {
  if (Array.isArray(middleware)) {
    middleware.forEach(mid => {
      if (middlewares.indexOf(mid) === -1) {
        middlewares.push(mid);
      }
    });
  } else if (middleware) {
    middlewares.push(middleware);
  }
  if (!defaultHttpMiddlewareOverwrite) {
    setHttpMiddleware((0, _http.default)());
  }
  return middlewares;
}

/**
 * helper to create the store with all the things needed by CMF
 * the store look like this:
 * - root
 * |- app (with appReducer)
 * |- cmf (for the internals)
 *
 * @param  {function} appReducer   the reducer for your app.
 * @param  {any} preloadedState if you want to create your state tree with initial values.
 *                              This is usefull for server side renderring
 * @param  {function} enhancer     The store enhancer
 * @param  {Array|function} middleware   redux middleware: http://redux.js.org/docs/api/applyMiddleware.html
 * @return {Object}              The created store
 */
function initialize(appReducer, preloadedState, enhancer, middleware) {
  const reducer = getReducer(appReducer);
  if (typeof enhancer === 'function') {
    enhancers.push(enhancer);
  }
  const middles = getMiddlewares(middleware);
  const store = (0, _redux.compose)((0, _redux.applyMiddleware)(...middles), ...enhancers)(_redux.createStore)(reducer, preloadedState);
  return store;
}
var _default = exports.default = {
  addPreReducer,
  setHttpMiddleware,
  initialize,
  // for testing purepose only
  getReducer,
  getMiddlewares
};
//# sourceMappingURL=store.js.map