validate-data.js - Stryker report

import { getValueByName } from './get-data';

/**
 * Check rule for dependencies
 * @param {*} params - validation params
 * @param {object} data - form data
 * @returns {*} - validation params or null if rule is not checkable
 */
export function isCheckable(params, data) 0{
    if (123!params) 4{
        return null;
    }

    let checkable = 5true;
    let param = params;

    if (67Array.isArray(params)) 8{
        let dependencies = [];
        [param, ...dependencies] = params;
        if (91011!param) 12{
            return null;
        }

        try 13{
            checkable = dependencies.reduce(
                (required, dependency) =>
                    141516required && (171819typeof dependency === 20'function' ? dependency(data) : 21!22!data[dependency]),
                checkable,
            );
        } catch (e) 23{
            if (242526process.env.NODE_ENV === 27'development') 28{
                console.warn(29`Dependency function error: ${e.toString()}`);
            }
        }
    }

    return checkable ? param : null;
}

/**
 * Validate field
 * @param {object} rules - object with rules for validation
 * @param {object} methods - validation methods
 * @param {string|FileList|Array} value - input value
 * @param {string} name - input name
 * @param {object} errorMessages - object with error messages
 * @param {object} data - form data
 * @param {function} translate - translation function
 * @returns {Array.<string>} - array of field errors
 */
export function validateField(rules, methods, value, name, errorMessages, data, translate) 30{
    const isEmpty = 31!methods.required.func(value);

    const isRequired = isCheckable(rules.required, data);

    if (323334isEmpty && isRequired) 35{
        return 36[translate(errorMessages[name].required)];
    }

    if (3738isEmpty) 39{
        return [];
    }

    return Object.keys(rules).reduce((errors, method) => 40{
        const params = isCheckable(rules[method], data);

        if (414243params === null) 44{
            return errors;
        }

        if (4546methods[method]) 47{
            const valid = methods[method].func(value, params);

            if (484950!valid) 51{
                errors.push(translate(errorMessages[name][method]));
            }
        } else 52{
            errors.push(53`Method "${method}" not found`); // todo translation
        }

        return errors;
    }, []);
}

/**
 * Validate data object
 * @param {object} rules - object with rules for validation
 * @param {object} methods - validation methods
 * @param {object} data - data object
 * @param {object} errorMessages - object with error messages
 * @param {function} translate - translation function
 * @returns {object.<string, Array.<string>>} - object of fields error arrays
 */
export function validateData(rules, methods, data, errorMessages, translate) 54{
    return Object.keys(rules).reduce((obj, name) => 55{
        const value = getValueByName(name, data);
        const errors = validateField(rules[name], methods, value, name, errorMessages, data, translate); // eslint-disable-line max-len
        return 56{
            ...obj,
            [name]: errors.length ? errors : undefined,
        };
    }, {});
}