redux-ducks/lib/index.js

Redux toolset for isolating state as defined by ducks-modular-redux proposal.

'use strict';

Object.defineProperty(exports, '__esModule', {
  value: true
});

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; };

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 UNMOUNT_DUCKS_STATE = '@@UNOUNT_DUCKS_STATE@@';
var MOUNT_DUCKS_STATE = '@@MOUNT_DUCKS_STATE@@';

var isFunction = function isFunction(any) {
  return typeof any === 'function';
};

var isObject = function isObject(any) {
  return typeof any === 'object';
};

var wrapDispatchForDucksAction = function wrapDispatchForDucksAction(dispatch, duckId) {
  return function (dispatchable) {
    if (isFunction(dispatchable)) {
      return dispatch(function (thunkedDispatch) {
        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
          args[_key - 1] = arguments[_key];
        }

        return dispatchable.apply(undefined, [wrapDispatchForDucksAction(thunkedDispatch, duckId)].concat(args));
      });
    } else if (isObject(dispatchable)) {
      return dispatch(_extends({}, dispatchable, { duckId: duckId }));
    } else {
      console.warn('Currently, only Objects and Functions are allowed to be dispatched as Ducks actions');

      return dispatch(dispatchable);
    }
  };
};

var ducksRootReducer = function ducksRootReducer(action, ducksState, ducksReducers) {
  if (action.duckId) {
    var duckState = ducksReducers.reduce(function (current, partialReducer) {
      return partialReducer(current, action);
    }, ducksState[action.duckId]);

    return _extends({}, ducksState, _defineProperty({}, action.duckId, duckState));
  } else if (action.type === UNMOUNT_DUCKS_STATE) {
    // TODO: sanity check
    var ducksStateCopy = _extends({}, ducksState);
    delete ducksStateCopy[action.payload];

    return ducksStateCopy;
  } else {
    return ducksState;
  }
};

var bindDucksActionCreator = function bindDucksActionCreator(actionCreator, dispatch, duckId) {
  return function () {
    var dispatchable = actionCreator.apply(undefined, arguments);

    return wrapDispatchForDucksAction(dispatch, duckId)(dispatchable);
  };
};

var buildDucksReducer = function buildDucksReducer(reducer) {
  return function () {
    for (var _len2 = arguments.length, ducksReducers = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
      ducksReducers[_key2] = arguments[_key2];
    }

    return function (appState, action) {
      if (appState === undefined) appState = { ducks: {}, state: undefined };
      return {
        ducks: ducksRootReducer(action, appState.ducks, ducksReducers),
        state: reducer(appState.state, action)
      };
    };
  };
};

var unmountDucksState = function unmountDucksState() {
  return { type: UNMOUNT_DUCKS_STATE };
};

var mountDucksState = function mountDucksState() {
  return { type: MOUNT_DUCKS_STATE };
};

exports.bindDucksActionCreator = bindDucksActionCreator;
exports.buildDucksReducer = buildDucksReducer;
exports.unmountDucksState = unmountDucksState;
exports.mountDucksState = mountDucksState;