ngrx-forms/esm2015/src/update-function/validate.js

Proper integration of forms in Angular 4 applications using ngrx

import { SetErrorsAction } from '../actions';
import { formStateReducer } from '../reducer';
import { isFormState } from '../state';
import { ensureState } from './util';
export function validate(stateOrFunctionOrFunctionArray, functionOrFunctionArr, ...rest) {
    if (isFormState(stateOrFunctionOrFunctionArray)) {
        const state = stateOrFunctionOrFunctionArray;
        const functionArr = Array.isArray(functionOrFunctionArr) ? functionOrFunctionArr : [functionOrFunctionArr];
        const errors = functionArr.concat(...rest)
            .reduce((agg, validationFn) => Object.assign(agg, validationFn(state.value)), {});
        return formStateReducer(stateOrFunctionOrFunctionArray, new SetErrorsAction(state.id, errors));
    }
    const functionOrFunctionArray = stateOrFunctionOrFunctionArray;
    let updateFnArr = Array.isArray(functionOrFunctionArray) ? functionOrFunctionArray : [functionOrFunctionArray];
    updateFnArr = functionOrFunctionArr === undefined ? updateFnArr : updateFnArr.concat(functionOrFunctionArr);
    return (s) => validate(ensureState(s), updateFnArr.concat(rest));
}
//# sourceMappingURL=data:application/json;base64,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