yarfl/es/reducers/fieldReducer.js

Yet Another Redux Forms Library

import types from '../actions/types';
import { checkActionForInputValue, checkActionForKey, } from '../helpers/checkers';
import { mergeIn, mergeUp, parseKey, selectField, setInWithKey, setInWithPath, throwError, } from '../helpers/utils';
export var createFieldReducer = function (config) {
    return function (state, action) {
        var type = action.type;
        switch (type) {
            case types.FIELD_UPDATE:
            case types.FIELD_FOCUSED:
            case types.FIELD_BLURRED:
            case types.FIELD_CLEAR:
            case types.FIELD_RESET:
            case types.FIELD_VALIDATE:
            case types.FIELD_SHOW_ERRORS:
                break;
            default:
                return state;
        }
        var actionWithKey = checkActionForKey(action);
        switch (type) {
            case types.FIELD_UPDATE:
                var actionWithInputValue = checkActionForInputValue(action);
                return createUpdateFieldReducer(config)(state, actionWithInputValue);
            case types.FIELD_FOCUSED:
                return createFocusFieldReducer()(state, actionWithKey);
            case types.FIELD_BLURRED:
                return createBlurFieldReducer()(state, actionWithKey);
            case types.FIELD_CLEAR:
                return createClearFieldReducer()(state, actionWithKey);
            case types.FIELD_RESET:
                return createResetFieldReducer()(state, actionWithKey);
            case types.FIELD_VALIDATE:
                // TODO
                return createValidateFieldReducer()(state, actionWithKey);
            case types.FIELD_SHOW_ERRORS:
                // TODO
                return createShowFieldErrorsReducer()(state, actionWithKey);
            default:
                return state;
        }
    };
};
var parseValue = function (config) { return function (state) { return function (key, value) {
    var typeOfValue = typeof value;
    var _a = (selectField(config, key, true) || {}).setter, setter = _a === void 0 ? false : _a;
    if (setter) {
        return setter(value);
    }
    if (typeOfValue === 'number') {
        return value;
    }
    // TODO: make fields part of the state
    var hasTypeNumber = selectField(state, key).type === 'number';
    if (!hasTypeNumber) {
        return value;
    }
    var autoParseNumbers = config.autoParseNumbers;
    if (!autoParseNumbers) {
        return value;
    }
    if (typeOfValue === 'string') {
        return parseFloat(value);
    }
    if (typeOfValue === 'boolean') {
        return value ? 1 : 0;
    }
    return throwError("Could not parse value for " + key + " to number. A value of type " + typeOfValue + " was given.");
}; }; };
export var createUpdateFieldReducer = function (config) {
    return function (state, action) {
        var key = action.key, value = action.value;
        var fieldPath = parseKey(key);
        var parsedValue = parseValue(config)(state)(key, value);
        var updatedValue = setInWithKey(state, key, 'value', parsedValue);
        return fieldPath.length > 1
            ? mergeUp(updatedValue, key, {
                changed: true,
                touched: true,
            })
            : mergeIn(updatedValue, key, {
                changed: true,
                touched: true,
            });
    };
};
var createFocusFieldReducer = function () {
    return function (state, action) {
        var key = checkActionForKey(action).key;
        return key.includes('.') ?
            mergeUp(state, key, { focused: true }) :
            setInWithPath(state, ['fields', key, 'focused'], true);
    };
};
var createBlurFieldReducer = function () {
    return function (state, action) {
        var key = action.key;
        return key.includes('.')
            ? mergeUp(state, key, {
                focused: false,
                touched: true,
            })
            : mergeIn(state, key, {
                focused: false,
                touched: true,
            });
    };
};
export var createClearFieldReducer = function () {
    return function (state, action) {
        var key = action.key;
        var _a = selectField(state, key), multiple = _a.multiple, initial = _a.initial, changed = _a.changed;
        var value = multiple ? [] : '';
        return mergeIn(state, key, {
            value: value,
            changed: changed || value !== initial,
        });
    };
};
export var createResetFieldReducer = function () {
    return function (state, action) {
        var key = action.key;
        var dfault = selectField(state, key).default;
        var valueUpdated = setInWithKey(state, key, 'value', dfault);
        return key.includes('.')
            ? mergeUp(valueUpdated, key, {
                changed: false,
                touched: false,
                showErrors: false,
            })
            : mergeIn(valueUpdated, key, {
                changed: false,
                touched: false,
                showErrors: false,
            });
    };
};
export var createValidateFieldReducer = function () { return function (state, action) {
    var key = action.key, validator = action.validator;
    var fieldErrors = validator.errors.get(key);
    return setInWithKey(state, key, 'errors', fieldErrors);
}; };
export var createShowFieldErrorsReducer = function () { return function (state, action) {
    var key = action.key, showErrors = action.showErrors;
    return setInWithKey(state, key, 'showErrors', showErrors);
}; };
//# sourceMappingURL=fieldReducer.js.map