redux-formo/dist/Field/reducers/index.js

An alternate forms framework for Redux+React.

'use strict';

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

var _constants$INITIALISE;

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 _constants = require('../constants');

var constants = _interopRequireWildcard(_constants);

var _mapValues = require('../../util/mapValues');

var _mapValues2 = _interopRequireDefault(_mapValues);

var _initialise = require('../../Field/reducers/initialise');

var _initialise2 = _interopRequireDefault(_initialise);

var _destroy = require('../../Form/reducers/destroy');

var _destroy2 = _interopRequireDefault(_destroy);

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

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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

/**
 * Mark a field as focused
 * @param   {object}  state           The field state
 * @returns {{active: boolean}}
 */
function focus(state) {
  return _extends({}, state, {
    active: true
  });
}

/**
 * Mark a field as blurred
 * @param   {object}  state           The field state
 * @returns {{active: boolean}}
 */
function blur(state) {
  return _extends({}, state, {
    active: false
  });
}

/**
 * Update the value of a field
 * @param   {object}  state           The field state
 * @param   {object}  action
 * @param   {string}  action.payload  The field value
 * @returns {{value: string}}
 */
function change(state, action) {
  return _extends({}, state, {
    value: action.payload
  });
}

/**
 * Start filtering the value of a field
 * @param   {object}  state           The field state
 * @returns {{filtering: boolean}}
 */
function startFiltering(state) {
  return _extends({}, state, {
    filtering: true
  });
}

/**
 * Finish filtering the value of a field
 * @param   {object}  state           The field state
 * @param   {object}  action
 * @param   {string}  action.payload  The field value
 * @returns {{filtering: boolean, filtered: boolean, value: string}}
 */
function finishFiltering(state, action) {
  return _extends({}, state, {
    filtering: false,
    filtered: true,
    value: action.payload
  });
}

/**
 * Error filtering the value of a field
 * @param   {object}  state           The field state
 * @param   {object}  action
 * @param   {string}  action.payload  The field error
 * @returns {{filtering: boolean, error: string}}
 */
function errorFiltering(state, action) {
  return _extends({}, state, {
    filtering: false,
    error: (action.payload && action.payload.message ? action.payload.message : String(action.payload)) || 'An unknown error occurred whilst filtering'
  });
}

/**
 * Validate the value of a field
 * @param   {object}  state           The field state
 * @param   {object}  action
 * @param   {string}  action.status
 * @param   {string}  [action.payload]
 * @returns {{filtering: boolean, [filtered]: boolean, [value]: string}}
 */
function filter(state, action) {

  switch (action.status) {

    case 'start':
      return startFiltering(state);

    case 'finish':
      return finishFiltering(state, action);

    case 'error':
      return errorFiltering(state, action);

    default:
      return state;

  }
}

/**
 * Start validating the value of a field
 * @param   {object}  state           The field state
 * @returns {{filtering: {boolean}}}
 */
function startValidating(state) {
  return _extends({}, state, {
    validating: true
  });
}

/**
 * Finish validating the value of a field
 * @param   {object}  state           The field state
 * @param   {object}  action
 * @param   {string}  action.payload  The field status
 * @returns {{validating: boolean, validated: boolean, error: string, valid: boolean, [validValue]: string}}
 */
function finishValidating(state, action) {
  var valid = action.payload === true;
  return _extends({}, state, {
    validating: false,
    validated: true,
    error: valid ? undefined : action.payload, //eslint-disable-line no-undefined
    valid: valid,
    lastValidValue: state.value
  });
}

/**
 * Error validating the value of a field
 * @param   {object}  state           The field state
 * @param   {object}  action
 * @param   {string}  action.payload  The field error
 * @returns {{validating: boolean, error: string}}
 */
function errorValidating(state, action) {
  return _extends({}, state, {
    validating: false,
    error: (action.payload && action.payload.message ? action.payload.message : String(action.payload)) || 'An unknown error occurred whilst validating',
    valid: false
  });
}

/**
 * Validate the value of a field
 * @param   {object}  state           The field state
 * @param   {object}  action
 * @param   {boolean} action.status
 * @param   {string}  [action.payload]
 * @returns {{validating: boolean, [validated]: boolean, [error]: string, [valid]: boolean, [validValue]: string}}
 */
function validate(state, action) {

  switch (action.status) {

    case 'start':
      return startValidating(state);

    case 'finish':
      return finishValidating(state, action);

    case 'error':
      return errorValidating(state, action);

    default:
      return state;

  }
}

function createFormReducer(fn) {
  return function (state, action) {
    var form = action.meta.form;

    var formState = state[form] || {},
        newFormState = fn(formState, action);
    return _extends({}, state, _defineProperty({}, form, _extends({}, formState, newFormState)));
  };
}

function createFieldReducer(fn) {
  return createFormReducer(function (state, action) {
    var field = action.meta.field;

    var fieldState = state.fields && state.fields[field] || {},
        newFieldState = fn(fieldState, action);
    return _extends({}, state, { fields: _extends({}, state.fields, _defineProperty({}, field, _extends({}, fieldState, newFieldState))) });
  });
}

exports.default = (_constants$INITIALISE = {}, _defineProperty(_constants$INITIALISE, constants.INITIALISE, createFieldReducer(_initialise2.default)), _defineProperty(_constants$INITIALISE, constants.FOCUS, createFieldReducer(focus)), _defineProperty(_constants$INITIALISE, constants.BLUR, createFieldReducer(blur)), _defineProperty(_constants$INITIALISE, constants.CHANGE, createFieldReducer(change)), _defineProperty(_constants$INITIALISE, constants.FILTER, createFieldReducer(filter)), _defineProperty(_constants$INITIALISE, constants.VALIDATE, createFieldReducer(validate)), _constants$INITIALISE);
//# sourceMappingURL=index.js.map