yarfl/es/initializeState.js

Yet Another Redux Forms Library

var __assign = (this && this.__assign) || Object.assign || function(t) {
    for (var s, i = 1, n = arguments.length; i < n; i++) {
        s = arguments[i];
        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
            t[p] = s[p];
    }
    return t;
};
import creatorFactory from './actions/creatorFactory';
import { camelCase, firstDefined, kebabCase, titleCase, } from './helpers/utils';
import { validatorFactory } from './helpers/validator';
import { createNewField } from './reducers/arrayReducer';
import { formShowErrorsReducer, formValidateReducer } from './reducers/formReducer';
import { FieldType, } from './typings';
export var initializeFormState = function (config, isAsync) {
    if (isAsync === void 0) { isAsync = false; }
    var name = config.name, _a = config.extra, extra = _a === void 0 ? {} : _a, _b = config.action, action = _b === void 0 ? '' : _b, _c = config.method, method = _c === void 0 ? 'POST' : _c;
    var fields = initFields(config.fields, config.addDefaults);
    var state = {
        action: action,
        name: name,
        method: method,
        fields: fields,
        isAsync: isAsync,
        extra: extra,
    };
    return initHooks(config, state);
};
var initHooks = function (config, state) {
    var showErrorsOnInit = config.showErrorsOnInit, validateOnInit = config.validateOnInit;
    if (showErrorsOnInit) {
        var _a = creatorFactory(config), showFormErrors = _a.showFormErrors, validateForm = _a.validateForm;
        var showErrorsAction = showFormErrors(true);
        var updated = formShowErrorsReducer(config)(state, showErrorsAction);
        var validator = validatorFactory(config)(state);
        var validateAction = validateForm(validator);
        return formValidateReducer(config)(updated, validateAction);
    }
    if (validateOnInit) {
        var validator = validatorFactory(config)(state);
        var validateAction = creatorFactory(config).validateForm(validator);
        return formValidateReducer(config)(state, validateAction);
    }
    return state;
};
var initFields = function (fields, addDefaults) {
    if (addDefaults === void 0) { addDefaults = true; }
    var entries = Object.entries(fields);
    return entries.map(function (_a) {
        var key = _a[0], field = _a[1];
        var _b;
        return (_b = {}, _b[key] = initField(key, field, addDefaults), _b);
    })
        .reduce(function (prev, curr) { return (__assign({}, prev, curr)); });
};
var initField = function (key, field, addDefaults) {
    var common = {
        key: key,
        focused: false,
        touched: false,
        changed: false,
        showErrors: false,
        extra: field.extra || {},
    };
    if (field.fields) {
        var fields = initFields(field.fields);
        if (field.multiple) {
            return __assign({}, common, { fieldType: FieldType.Array, default: fields, fields: [createNewField(key, fields, 0)] });
        }
        return __assign({}, common, { fields: fields, fieldType: FieldType.Parent });
    }
    var errors = [];
    if (!addDefaults) {
        return __assign({}, common, { value: '', rules: '', errors: errors }, field);
    }
    var rules = firstDefined(field.rules, '');
    var name = firstDefined(field.name, key);
    var autoComplete = firstDefined(field.autoComplete, name);
    var id = firstDefined(field.id, kebabCase(name));
    var label = firstDefined(field.label, titleCase(name));
    var placeholder = firstDefined(field.placeholder, label);
    var disabled = firstDefined(!!field.disabled, false);
    var autoFocus = firstDefined(!!field.autoFocus, false);
    var multiple = field.multiple;
    var value = firstDefined(field.value, field.default, multiple ? [] : '');
    var dfault = firstDefined(field.default, multiple ? [] : '');
    var type = firstDefined(field.type, inputType(value));
    var options = field.options
        ? optionMapper(field.options, id, name, key, type)
        : undefined;
    var props = __assign({}, common, { fieldType: FieldType.Simple, value: type === 'checkbox' ? !!value : value, default: dfault, initial: value, rules: rules,
        name: name,
        id: id,
        type: type,
        label: label,
        placeholder: placeholder,
        disabled: disabled,
        autoFocus: autoFocus,
        autoComplete: autoComplete,
        errors: errors });
    return (options ? __assign({}, props, { options: options, multiple: multiple }) : props);
};
var optionMapper = function (options, id, name, key, type) {
    if (!options.length) {
        return [];
    }
    var optionType = typeof options[0];
    if (optionType !== 'object' && optionType !== 'string')
        throw new Error("'options' for field '" + key + "' must be defined as an array of strings or objects ({ value, label })");
    // 'selected' for option elements and 'checked' for radio buttons and checkboxes
    return options.map(function (opt) {
        var _a = typeof opt === 'string' ? { value: opt, label: opt } : opt, value = _a.value, label = _a.label;
        return {
            type: type,
            value: value,
            label: label,
            name: camelCase(name + " " + value),
            id: kebabCase(id + " " + value),
        };
    });
};
var inputType = function (test) {
    switch (typeof test) {
        case 'string':
            return 'text';
        case 'number':
            return 'number';
        case 'boolean':
            return 'checkbox';
        default:
            return 'text';
    }
};
//# sourceMappingURL=initializeState.js.map