anew/lib/store/combineStores.js

React and Redux Framework with additional power.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = combineStores;

var _redux = require('redux');

var _invariant = require('invariant');

var _invariant2 = _interopRequireDefault(_invariant);

var _combineReducers = require('./utils/combineReducers');

var _combineReducers2 = _interopRequireDefault(_combineReducers);

var _createBatch = require('./utils/createBatch');

var _createBatch2 = _interopRequireDefault(_createBatch);

var _createBatchMiddleware = require('./utils/createBatchMiddleware');

var _createBatchMiddleware2 = _interopRequireDefault(_createBatchMiddleware);

var _createCombinedReducer = require('./utils/createCombinedReducer');

var _createCombinedReducer2 = _interopRequireDefault(_createCombinedReducer);

var _createReduxAnewProps = require('./utils/createReduxAnewProps');

var _createReduxAnewProps2 = _interopRequireDefault(_createReduxAnewProps);

var _createSetState = require('./utils/createSetState');

var _createSetState2 = _interopRequireDefault(_createSetState);

var _createPersistStore = require('./utils/createPersistStore');

var _createPersistStore2 = _interopRequireDefault(_createPersistStore);

var _validateFunctionProperty = require('./utils/validateFunctionProperty');

var _validateFunctionProperty2 = _interopRequireDefault(_validateFunctionProperty);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }

function combineStores(_ref) {
  var _ref$name = _ref.name,
      name = _ref$name === undefined ? 'combinedStore' : _ref$name,
      _ref$stores = _ref.stores,
      stores = _ref$stores === undefined ? [] : _ref$stores,
      persist = _ref.persist,
      enhancer = _ref.enhancer;

  (0, _validateFunctionProperty2.default)(name, 'store combination');

  /**
   * Create Object to preserve reference
   */
  var anewStore = {
    name: name,
    state: {},
    reducers: {},
    batches: []

    /**
     * State Setter with anewStore as the context
     */
  };anewStore.setState = (0, _createSetState2.default)(anewStore);

  /**
   * Combine Redux Store
   */
  var reduxReducer = (0, _combineReducers2.default)(anewStore, stores, persist);

  /**
   * Generate Combined Anew Store
   */
  var anewReducer = (0, _createCombinedReducer2.default)(anewStore, reduxReducer);

  /**
   * Create getBatches for early reference
   */
  var getBatches = function getBatches() {
    return anewStore.batches;
  };

  /**
   * Create Batch Middleware with reference to batches
   */
  var createWithMiddlewares = (0, _redux.applyMiddleware)((0, _createBatchMiddleware2.default)(getBatches))(_redux.createStore);

  /**
   * Redux Store
   * @type { Object }
   */
  var store = createWithMiddlewares(anewReducer, anewStore.state, enhancer);
  var reduxStore = persist ? (0, _createPersistStore2.default)(store) : store;

  /**
   * Create anew specific store props
   * @type { Object }
   */
  reduxStore.anew = (0, _createReduxAnewProps2.default)(anewStore, anewReducer),

  /**
   * Update getBatches Reference
   */
  getBatches = function getBatches() {
    return reduxStore.anew.getBatches();
  };

  /**
   * Extend Dispatcher to include reducers, effects, and batch
   *
   * This must be redefined to update reference to the new combined
   * reduxStore object.
   */
  reduxStore.dispatch.reducers = {};
  reduxStore.dispatch.effects = {};
  reduxStore.dispatch.actions = {};
  reduxStore.dispatch.batch = (0, _createBatch2.default)(reduxStore, 'combined');

  /**
   * Populate dispatch reducers and effects
   * and update redux dispatch reference
   */

  var _loop = function _loop(i, storesLen) {
    var store = stores[i];

    var getState = store.getState,
        name = store.anew.name,
        _store$dispatch = store.dispatch,
        reducers = _store$dispatch.reducers,
        effects = _store$dispatch.effects,
        actions = _store$dispatch.actions,
        _store$dispatch$batch = _store$dispatch.batch,
        done = _store$dispatch$batch.done,
        batches = _objectWithoutProperties(_store$dispatch$batch, ['done']);

    var getStoreState = function getStoreState() {
      return reduxStore.getState()[name];
    };

    /**
     * Merge into combined store
     */
    reduxStore.dispatch.reducers[name] = reducers;
    reduxStore.dispatch.effects[name] = effects;
    reduxStore.dispatch.actions[name] = actions;
    reduxStore.dispatch.batch[name] = batches;
    reduxStore.getState[name] = getStoreState;

    /**
     * Update each store references
     */
    store.subscribe = reduxStore.subscribe;
    store.anew.getBatches = function () {
      return reduxStore.anew.getBatches();
    };
    store.dispatch = function (action) {
      return reduxStore.dispatch(action);
    };
    store.getState = getStoreState;

    /**
     * Redefine replace reducer
     */
    store.replaceReducer = function replaceReducer(nextReducer) {
      if (typeof nextReducer !== 'function') {
        throw new Error('Expected the nextReducer to be a function.');
      }

      anewStore.reducers[name] = nextReducer;
      reduxReducer = (0, _combineReducers2.default)(anewStore.reducers);

      reduxStore.dispatch({ type: '@@anew:RESET' });
    };

    /**
     * Reassign reducers, effects, and batch to maintain dispatch
     * object's shape per store.
     */
    store.dispatch.persistor = reduxStore.persistor;
    store.dispatch.reducers = reducers;
    store.dispatch.effects = effects;
    store.dispatch.actions = actions;
    store.dispatch.batch = batches;
    store.dispatch.batch.done = done;

    /**
     * Reassign selectors to maintian getState
     * object's shape per store
     */
    reduxStore.getState[name] = Object.assign(reduxStore.getState[name], getState);
    store.getState = Object.assign(store.getState, getState);

    /**
     * Assign Core
     */
    store.anew.core = reduxStore;
  };

  for (var i = 0, storesLen = stores.length; i < storesLen; i++) {
    _loop(i, storesLen);
  }

  return reduxStore;
}