redux-modules/lib/createModule/index.js

A library for defining clear, boilerplate free Redux reducers.

'use strict';

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

var _snakeCase2 = require('lodash/snakeCase');

var _snakeCase3 = _interopRequireDefault(_snakeCase2);

var _map2 = require('lodash/map');

var _map3 = _interopRequireDefault(_map2);

var _identity2 = require('lodash/identity');

var _identity3 = _interopRequireDefault(_identity2);

var _get2 = require('lodash/get');

var _get3 = _interopRequireDefault(_get2);

var _forEach2 = require('lodash/forEach');

var _forEach3 = _interopRequireDefault(_forEach2);

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

exports.default = createModule;

var _createAction = require('./createAction');

var _createAction2 = _interopRequireDefault(_createAction);

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

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 applyReducerEnhancer(reducer, enhancer) {
  if (typeof enhancer === 'function') {
    return enhancer(reducer);
  }
  return reducer;
}

function formatType(actionName) {
  return (0, _snakeCase3.default)(actionName).toUpperCase();
}

function parseTransformation(transformation, actionName) {
  if (typeof actionName !== 'string') {
    throw new Error('`transformations` value must be an object');
  }

  var type = formatType(actionName);

  if (typeof transformation === 'function') {
    return {
      actionName: actionName,
      reducer: transformation,
      type: type
    };
  }
  return _extends({
    actionName: actionName,
    type: type
  }, transformation);
}

function createModule(_ref) {
  var _ref$composes = _ref.composes,
      composes = _ref$composes === undefined ? [] : _ref$composes,
      initialState = _ref.initialState,
      _ref$middleware = _ref.middleware,
      moduleMiddleware = _ref$middleware === undefined ? [] : _ref$middleware,
      name = _ref.name,
      reducerEnhancer = _ref.reducerEnhancer,
      selector = _ref.selector,
      transformations = _ref.transformations;

  var parsedTransformations = (0, _map3.default)(transformations, parseTransformation);
  var actions = {};
  var constants = {};
  var reducerMap = {};
  (0, _forEach3.default)(parsedTransformations, function (_ref2) {
    var actionName = _ref2.actionName,
        _ref2$middleware = _ref2.middleware,
        middleware = _ref2$middleware === undefined ? [] : _ref2$middleware,
        _ref2$namespaced = _ref2.namespaced,
        namespaced = _ref2$namespaced === undefined ? true : _ref2$namespaced,
        reducer = _ref2.reducer,
        type = _ref2.type;

    var finalMiddleware = [].concat(_toConsumableArray(middleware), _toConsumableArray(moduleMiddleware));
    var constant = namespaced ? name + '/' + type : type;
    actions[actionName] = (0, _createAction2.default)(constant, finalMiddleware);
    constants[actionName] = constant;
    reducerMap[constant] = reducer;
  });
  function finalReducer() {
    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
    var action = arguments[1];

    var localReducer = (0, _get3.default)(reducerMap, action.type, _identity3.default);
    return [localReducer].concat(_toConsumableArray(composes)).reduce(function (newState, currentReducer) {
      return currentReducer(newState, action);
    }, state);
  }
  return {
    actions: actions,
    constants: constants,
    name: name,
    reducer: applyReducerEnhancer(finalReducer, reducerEnhancer),
    selector: selector
  };
}