redux-injectable-reducer/lib.js

Redux store capable of lazily injecting parts of the state tree. Useful for large single page applications that utilize bundle splitting.

'use strict';

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

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _redux = require('redux');

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

var BUFFER = '@@rootReducer/BUFFER';

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

  var nextState = state;

  if (action.type === BUFFER) {
    nextState = action.payload.reduce(function (prev, key) {
      if (prev[key]) return prev;
      return _extends({}, prev, _defineProperty({}, key, []));
    }, nextState);
  }

  return Object.keys(nextState).reduce(function (prev, key) {
    return _extends({}, prev, _defineProperty({}, key, [].concat(_toConsumableArray(prev[key]), [action])));
  }, nextState);
};

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

    var buffer = bufferReducer(state.__buffer, action);

    var nextState = Object.keys(reducers).reduce(function (prev, key) {
      return !buffer[key] ? prev : _extends({}, prev, _defineProperty({}, key, buffer[key].splice(0).reduce(reducers[key], prev[key])));
    }, state);

    return _extends({}, nextState, {
      __buffer: buffer
    });
  };
};

var configureStore = exports.configureStore = function configureStore() {
  for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  var reducers = {};

  var store = _redux.createStore.apply(undefined, [createRootReducer(reducers)].concat(args));

  var replaceReducer = function replaceReducer() {
    throw new Error('cannot replace root reducer');
  };

  var inject = function inject(injectedReducers) {
    var keys = Object.keys(injectedReducers);

    var nextReducers = keys.reduce(function (prev, key) {
      var reducer = injectedReducers[key];
      if (typeof reducer !== 'function') throw new Error('\'' + key + '\' is not a function');
      if (prev[key] === reducer) return prev;
      if (prev[key]) throw new Error('cannot replace ' + key + ' reducer');
      return _extends({}, prev, _defineProperty({}, key, reducer));
    }, reducers);

    store.dispatch({
      type: BUFFER,
      payload: keys
    });

    if (nextReducers !== reducers) {
      reducers = nextReducers;
      store.replaceReducer(createRootReducer(reducers));
    }
  };

  return _extends({}, store, {
    replaceReducer: replaceReducer,
    inject: inject
  });
};