combine-reducers-global-state/lib/index.js

Like combineReducers that comes with redux but with global state passed through to individual reducers

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = combineReducers;
function checkReducersValidity(reducers) {
  var _iteratorNormalCompletion = true;
  var _didIteratorError = false;
  var _iteratorError = undefined;

  try {
    for (var _iterator = Object.keys(reducers)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
      var key = _step.value;

      var reducer = reducers[key];
      var _type = '@@combine-reducers-global-state/RANDOM_ACTION_' + Math.random().toString(36).substring(7).split('').join('.');

      if (reducer(undefined, { type: _type }) === undefined) {
        throw new Error('Reducer "' + key + '" must return initial state when passed undefined state.');
      }
    }
  } catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion && _iterator.return) {
        _iterator.return();
      }
    } finally {
      if (_didIteratorError) {
        throw _iteratorError;
      }
    }
  }
}

function combineReducers(reducers) {
  var finalReducers = {};
  var _iteratorNormalCompletion2 = true;
  var _didIteratorError2 = false;
  var _iteratorError2 = undefined;

  try {
    for (var _iterator2 = Object.keys(reducers)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
      var key = _step2.value;

      if (typeof reducers[key] === 'function') {
        finalReducers[key] = reducers[key];
      }
    }
  } catch (err) {
    _didIteratorError2 = true;
    _iteratorError2 = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion2 && _iterator2.return) {
        _iterator2.return();
      }
    } finally {
      if (_didIteratorError2) {
        throw _iteratorError2;
      }
    }
  }

  var error = void 0;
  try {
    checkReducersValidity(finalReducers);
  } catch (e) {
    error = e;
  }

  var finalReducerKeys = Object.keys(finalReducers);

  return function combination() {
    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var action = arguments[1];
    var globalState = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : state;

    if (error) throw error;

    var hasChanged = false;
    var nextState = {};
    var _iteratorNormalCompletion3 = true;
    var _didIteratorError3 = false;
    var _iteratorError3 = undefined;

    try {
      for (var _iterator3 = finalReducerKeys[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
        var key = _step3.value;

        var reducer = finalReducers[key];
        var previousStateForKey = state[key];
        var nextStateForKey = reducer(previousStateForKey, action, globalState);
        nextState[key] = nextStateForKey;
        hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
      }
    } catch (err) {
      _didIteratorError3 = true;
      _iteratorError3 = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion3 && _iterator3.return) {
          _iterator3.return();
        }
      } finally {
        if (_didIteratorError3) {
          throw _iteratorError3;
        }
      }
    }

    return hasChanged ? nextState : state;
  };
}
module.exports = exports['default'];