@reactables/forms 0.4.0-alpha.0

package/dist/index.js

@@ -0,0 +1,763 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@reactables/core');
+var operators = require('rxjs/operators');
+var rxjs = require('rxjs');
+var isEqual = require('lodash.isequal');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var isEqual__default = /*#__PURE__*/_interopDefaultLegacy(isEqual);
+
+var Controls = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+var required = function (value) {
+    if (Array.isArray(value)) {
+        return { required: !Boolean(value.length) };
+    }
+    if (typeof value === 'string' || typeof value === 'object') {
+        return { required: !Boolean(value) };
+    }
+    if (typeof value === 'number') {
+        return { required: !(value !== undefined && value !== null) };
+    }
+    return { required: false };
+};
+var email = function (value) {
+    return value && !/^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/g.test(value) ? { email: true } : { email: false };
+};
+var phoneNumber = function (value) {
+    return value && !/^(\+\d{1,2}\s)?\(?\d{3}\)?[\s.-]\d{3}[\s.-]\d{4}$/.test(value)
+        ? { phoneNumber: true }
+        : { phoneNumber: false };
+};
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  required: required,
+  email: email,
+  phoneNumber: phoneNumber
+});
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(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;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+var getValueFromControlConfig = function (controlConfig) {
+    var controls = controlConfig.controls;
+    if (controls && !(controls instanceof Array)) {
+        var result = {};
+        for (var key in controlConfig.controls) {
+            var control = controlConfig.controls[key];
+            result[key] = getValueFromControlConfig(control);
+        }
+        return result;
+    }
+    else if (controls && controls instanceof Array) {
+        var configs = controlConfig.controls;
+        var result = configs
+            ? configs.map(function (controlConfig) { return getValueFromControlConfig(controlConfig); })
+            : [];
+        return result;
+    }
+    else {
+        return controlConfig.initialValue;
+    }
+};
+
+var getFormKey = function (controlRef) {
+    return controlRef.length ? controlRef.join('.') : 'root';
+};
+
+var generateKey = function (length) {
+    var result = '';
+    var characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    var charactersLength = characters.length;
+    var counter = 0;
+    while (counter < length) {
+        result += characters.charAt(Math.floor(Math.random() * charactersLength));
+        counter += 1;
+    }
+    return result;
+};
+
+// Includes the original control of interest unless excludeSelf === true
+var getDescendantControls = function (controlRef, form, excludeSelf) {
+    if (excludeSelf === void 0) { excludeSelf = false; }
+    var result = Object.entries(form)
+        .filter(function (_a) {
+        var key = _a[0];
+        if (!controlRef.length)
+            return true;
+        var childRef = key.split('.');
+        return controlRef.every(function (refKey, index) {
+            return refKey == childRef[index];
+        });
+    })
+        .map(function (entry) { return entry[1]; });
+    return result.filter(function (control) {
+        return excludeSelf ? getFormKey(control.controlRef) !== getFormKey(controlRef) : true;
+    });
+};
+
+var syncValidate = function (form) {
+    // First check each control for its own validation
+    var baseValidation = Object.entries(form).reduce(function (acc, _a) {
+        var _b;
+        var _c;
+        var key = _a[0], control = _a[1];
+        var validatorErrors = ((_c = control.config.validators) === null || _c === void 0 ? void 0 : _c.reduce(function (acc, validator) { return (__assign(__assign({}, acc), validator(control.value))); }, {})) || {};
+        var validatorsValid = !Object.values(validatorErrors).some(function (err) { return err; });
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = __assign(__assign({}, control), { validatorErrors: validatorErrors, validatorsValid: validatorsValid }), _b));
+    }, {});
+    // Then check each controls children to see if there are errors
+    var validated = Object.entries(baseValidation).reduce(function (acc, _a) {
+        var _b;
+        var key = _a[0], control = _a[1];
+        var validatorsValid = getDescendantControls(control.controlRef, baseValidation).every(function (_a) {
+            var validatorsValid = _a.validatorsValid;
+            return validatorsValid;
+        });
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = __assign(__assign({}, control), { validatorsValid: validatorsValid }), _b));
+    }, {});
+    return validated;
+};
+
+var buildState = function (config, form, controlRef) {
+    var _a;
+    if (form === void 0) { form = { root: null }; }
+    if (controlRef === void 0) { controlRef = []; }
+    var value = getValueFromControlConfig(config);
+    var control = {
+        pristineValue: value,
+        dirty: false,
+        touched: false,
+        value: value,
+        controlRef: controlRef,
+        validatorErrors: {},
+        validatorsValid: null,
+        config: config,
+        key: generateKey(5)
+    };
+    var newForm = __assign(__assign({}, form), (_a = {}, _a[getFormKey(controlRef)] = control, _a));
+    var controls = config.controls;
+    // Adding controls for Form Group
+    if (controls && !(controls instanceof Array)) {
+        newForm = Object.entries(config.controls).reduce(function (acc, _a) {
+            var key = _a[0], controlConfig = _a[1];
+            return buildState(controlConfig, acc, controlRef.concat(key));
+        }, newForm);
+    }
+    else if (controls && controls instanceof Array) {
+        // Adding controls for Form Array
+        newForm = config.controls.reduce(function (acc, controlConfig, index) { return buildState(controlConfig, acc, controlRef.concat(index)); }, newForm);
+    }
+    return syncValidate(newForm);
+};
+var buildFormState = function (config, form, controlRef) {
+    if (form === void 0) { form = { root: null }; }
+    if (controlRef === void 0) { controlRef = []; }
+    return {
+        form: buildState(config, form, controlRef),
+        action: null
+    };
+};
+
+var getControl = function (controlRef, form) {
+    return form[getFormKey(controlRef)];
+};
+
+// Includes the original control of interest unless excludeSelf === true
+var getAncestorControls = function (controlRef, form, excludeSelf) {
+    if (excludeSelf === void 0) { excludeSelf = false; }
+    var formControls = controlRef.reduce(function (acc, key) {
+        var currentRef = acc.currentRef.concat(key);
+        var formControls = acc.formControls.concat(getControl(currentRef, form));
+        return {
+            currentRef: currentRef,
+            formControls: formControls
+        };
+    }, {
+        currentRef: [],
+        formControls: []
+    }).formControls;
+    var root = form['root'];
+    var result = [root].concat(formControls);
+    return result.filter(function (control) {
+        return excludeSelf ? getFormKey(control.controlRef) !== getFormKey(controlRef) : true;
+    });
+};
+
+var getControlBranch = function (controlRef, form) {
+    var ancestors = getAncestorControls(controlRef, form);
+    var childControls = getDescendantControls(controlRef, form).slice(1);
+    return ancestors.concat(childControls);
+};
+
+var getScopedEffectsForControl = function (formControl) {
+    var config = formControl.config, key = formControl.key;
+    var asyncValidators = config.asyncValidators;
+    var scopedEffects = [];
+    if (asyncValidators && asyncValidators.length) {
+        scopedEffects = asyncValidators.reduce(function (acc, validator, validatorIndex) {
+            var effect = function (actions$) {
+                return actions$.pipe(operators.map(function (_a) {
+                    var control = _a.payload;
+                    return control;
+                }), validator, operators.map(function (errors) { return ({
+                    type: 'asyncValidationResponseSuccess',
+                    payload: {
+                        key: key,
+                        errors: errors,
+                        validatorIndex: validatorIndex
+                    }
+                }); }));
+            };
+            return acc.concat(effect);
+        }, []);
+    }
+    return scopedEffects;
+};
+var getAsyncValidationActions = function (formControls) {
+    return formControls.reduce(function (acc, control) {
+        var effects = getScopedEffectsForControl(control);
+        if (!effects.length)
+            return acc;
+        var action = { type: 'asyncValidation', payload: control };
+        return acc.concat(action);
+    }, []);
+};
+
+var buildHub2Source = function (rx) {
+    var hub1StateMapped$ = rx.state$.pipe(operators.map(function (payload) { return ({ type: 'formChange', payload: payload }); }));
+    var sourceForHub2$ = hub1StateMapped$.pipe(operators.mergeMap(function (formChangeAction) {
+        var _a = formChangeAction.payload, form = _a.form, action = _a.action;
+        var newForm = form;
+        var controlsToCheck;
+        switch (action === null || action === void 0 ? void 0 : action.type) {
+            case 'updateValues':
+                controlsToCheck = getControlBranch(action.payload.controlRef, newForm);
+                break;
+            case 'addControl':
+                var changedControl = getControl(action.payload.controlRef, newForm);
+                if (Array.isArray(changedControl.config.controls)) {
+                    var index = changedControl.value.length - 1;
+                    var ref = action.payload.controlRef.concat(index);
+                    controlsToCheck = getControlBranch(ref, newForm);
+                    break;
+                }
+                else {
+                    controlsToCheck = getControlBranch(action.payload.controlRef, newForm);
+                    break;
+                }
+            case 'removeControl':
+                controlsToCheck = getAncestorControls(action.payload.slice(0, -1), newForm);
+                break;
+            case 'resetControl':
+                controlsToCheck = getControlBranch(action.payload, newForm);
+                break;
+            default:
+                controlsToCheck = [];
+        }
+        var asyncValidationActions = getAsyncValidationActions(controlsToCheck);
+        return rxjs.of.apply(void 0, __spreadArray([formChangeAction], asyncValidationActions, false));
+    }));
+    return sourceForHub2$;
+};
+
+var UPDATE_ANCESTOR_VALUES = 'UPDATE_ANCESTOR_VALUES';
+var updateAncestorValues = function (form, _a) {
+    var _b;
+    var controlRef = _a.payload;
+    if (controlRef.length) {
+        var parentRef = controlRef.slice(0, -1);
+        var parentKey = getFormKey(parentRef);
+        var siblingControls = getDescendantControls(parentRef, form).filter(
+        // Out of descendants we only need the siblings
+        function (control) { return control.controlRef.length === controlRef.length; });
+        var newValue = void 0;
+        // If parent is a Form Array
+        if (Array.isArray(form[parentKey].value)) {
+            newValue = siblingControls
+                .slice()
+                .sort(function (a, b) { return a.controlRef.at(-1) - b.controlRef.at(-1); })
+                .map(function (control) { return control.value; });
+        }
+        else {
+            // If parent is a Form Group
+            newValue = siblingControls.reduce(function (acc, _a) {
+                var _b;
+                var controlRef = _a.controlRef, value = _a.value;
+                return __assign(__assign({}, acc), (_b = {}, _b[controlRef.at(-1)] = value, _b));
+            }, {});
+        }
+        var newParentControl = __assign(__assign({}, form[parentKey]), { value: newValue });
+        return updateAncestorValues(__assign(__assign({}, form), (_b = {}, _b[parentKey] = newParentControl, _b)), {
+            type: UPDATE_ANCESTOR_VALUES,
+            payload: parentRef
+        });
+    }
+    return form;
+};
+
+var updateDirty = function (form) {
+    return Object.entries(form).reduce(function (acc, _a) {
+        var _b;
+        var key = _a[0], control = _a[1];
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = __assign(__assign({}, control), { dirty: !isEqual__default["default"](control.value, control.pristineValue) }), _b));
+    }, {});
+};
+
+var isChildRef = function (controlRef, parentRef) {
+    return (parentRef.every(function (key, index) { return controlRef[index] === key; }) &&
+        controlRef.length === parentRef.length + 1);
+};
+
+var UPDATE_DESCENDANT_VALUES = 'UPDATE_DESCENDANT_VALUES';
+var updateDescendants = function (form, _a) {
+    var _b = _a.payload, controlRef = _b.controlRef, value = _b.value;
+    var result = Object.entries(form).reduce(function (acc, _a) {
+        var _b;
+        var key = _a[0], control = _a[1];
+        if (isChildRef(control.controlRef, controlRef)) {
+            var childValue = value[control.controlRef.at(-1)];
+            acc = __assign(__assign({}, acc), (_b = {}, _b[key] = __assign(__assign({}, control), { value: childValue }), _b));
+            var configControls = control.config.controls;
+            if (configControls) {
+                acc = updateDescendants(acc, {
+                    type: UPDATE_DESCENDANT_VALUES,
+                    payload: { controlRef: control.controlRef, value: childValue }
+                });
+            }
+        }
+        return acc;
+    }, form);
+    return result;
+};
+// Will only update child controls that are present.
+// Use AddControl/RemoveControl action reducers to add/remove control
+var updateValues = function (_a, action) {
+    var _b;
+    var form = _a.form;
+    var _c = action.payload, controlRef = _c.controlRef, value = _c.value;
+    // Update its own value
+    var ctrlKey = getFormKey(controlRef);
+    var result = __assign(__assign({}, form), (_b = {}, _b[ctrlKey] = __assign(__assign({}, form[ctrlKey]), { value: value }), _b));
+    var configControls = form[ctrlKey].config.controls;
+    // Update its children
+    if (configControls) {
+        result = updateDescendants(result, {
+            type: UPDATE_DESCENDANT_VALUES,
+            payload: {
+                controlRef: controlRef,
+                value: value
+            }
+        });
+    }
+    // Update its Ancestors
+    if (controlRef.length) {
+        result = updateAncestorValues(result, {
+            type: UPDATE_ANCESTOR_VALUES,
+            payload: controlRef
+        });
+    }
+    return { form: syncValidate(updateDirty(result)), action: action };
+};
+
+var removeControl = function (_a, action) {
+    var form = _a.form;
+    var controlRef = action.payload;
+    if (!getControl(controlRef, form)) {
+        throw 'Control not found';
+    }
+    // Can't remove the root of the form
+    if (!controlRef.length)
+        return { form: form, action: action };
+    var parentRef = controlRef.slice(0, -1);
+    var parentIsFormArray = Array.isArray(getControl(parentRef, form).config.controls);
+    // Remove control and all descendants
+    var controlRemoved = Object.entries(form)
+        .filter(function (_a) {
+        _a[0]; var control = _a[1];
+        return !(control.controlRef.length > parentRef.length &&
+            controlRef.every(function (key, index) { return key === control.controlRef[index]; }));
+    })
+        .reduce(function (acc, _a) {
+        var _b, _c;
+        var key = _a[0], control = _a[1];
+        // May need to reindex array items of removed control
+        // if it was part of a Form Array.
+        if (parentIsFormArray) {
+            var oldIndex = control.controlRef.at(parentRef.length);
+            if (
+            // If control is descendant.
+            parentRef.every(function (ref, index) { return control.controlRef[index] === ref; }) &&
+                control.controlRef.length > parentRef.length &&
+                // If the array item index was greater than the index of item removed
+                // we need to decrement its index by 1.
+                oldIndex > controlRef.at(-1)) {
+                var newRef = parentRef
+                    .concat(oldIndex - 1)
+                    .concat(control.controlRef.slice(parentRef.length + 1));
+                return __assign(__assign({}, acc), (_b = {}, _b[getFormKey(newRef)] = __assign(__assign({}, control), { controlRef: newRef }), _b));
+            }
+        }
+        return __assign(__assign({}, acc), (_c = {}, _c[key] = control, _c));
+    }, {});
+    return {
+        form: syncValidate(updateDirty(updateAncestorValues(controlRemoved, {
+            type: UPDATE_ANCESTOR_VALUES,
+            payload: controlRef
+        }))),
+        action: action
+    };
+};
+
+var addControl = function (state, action) {
+    var newControlRef;
+    var _a = action.payload, config = _a.config, controlRef = _a.controlRef;
+    var existingControl = getControl(controlRef, state.form);
+    // If controlRef exists we are adding control to a Form Array
+    if (existingControl && Array.isArray(existingControl.config.controls)) {
+        newControlRef = controlRef.concat(existingControl.value.length);
+    }
+    else {
+        // If controlRef does not exist we are adding control to a Form Group
+        if (!getControl(controlRef.slice(0, -1), state.form)) {
+            throw 'You are attempting to add a control to a non-existent form group';
+        }
+        newControlRef = controlRef;
+    }
+    var newForm = buildState(config, state.form, newControlRef);
+    var ancestorsUpdated = updateAncestorValues(newForm, {
+        type: UPDATE_ANCESTOR_VALUES,
+        payload: newControlRef
+    });
+    return { form: syncValidate(updateDirty(ancestorsUpdated)), action: action };
+};
+
+// Same implementation as updateAncestor values except updating pristine values
+var UPDATE_ANCESTOR_PRISTINE_VALUES = 'UPDATE_ANCESTOR_PRISTINE_VALUES';
+var updateAncestorPristineValues = function (form, _a) {
+    var _b;
+    var controlRef = _a.payload;
+    if (controlRef.length) {
+        var parentRef = controlRef.slice(0, -1);
+        var parentKey = getFormKey(parentRef);
+        var siblingControls = getDescendantControls(parentRef, form).filter(
+        // Out of descendants we only need the siblings
+        function (control) { return control.controlRef.length === controlRef.length; });
+        var newValue = void 0;
+        // If parent is a Form Array
+        if (Array.isArray(form[parentKey].value)) {
+            newValue = siblingControls
+                .slice()
+                .sort(function (a, b) { return a.controlRef.at(-1) - b.controlRef.at(-1); })
+                .map(function (control) { return control.pristineValue; });
+        }
+        else {
+            // If parent is a Form Group
+            newValue = siblingControls.reduce(function (acc, _a) {
+                var _b;
+                var controlRef = _a.controlRef, pristineValue = _a.pristineValue;
+                return __assign(__assign({}, acc), (_b = {}, _b[controlRef.at(-1)] = pristineValue, _b));
+            }, {});
+        }
+        var newParentControl = __assign(__assign({}, form[parentKey]), { pristineValue: newValue });
+        return updateAncestorPristineValues(__assign(__assign({}, form), (_b = {}, _b[parentKey] = newParentControl, _b)), {
+            type: UPDATE_ANCESTOR_PRISTINE_VALUES,
+            payload: parentRef
+        });
+    }
+    return form;
+};
+
+var markControlAsPristine = function (_a, action) {
+    var form = _a.form;
+    var controlRef = action.payload;
+    var descendants = getDescendantControls(controlRef, form);
+    var result = Object.entries(form).reduce(function (acc, _a) {
+        var _b;
+        var key = _a[0], control = _a[1];
+        var isDescendant = descendants.includes(control);
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = isDescendant
+            ? __assign(__assign({}, control), { pristineValue: control.value, dirty: false }) : control, _b));
+    }, {});
+    if (controlRef.length) {
+        result = updateAncestorPristineValues(result, {
+            type: UPDATE_ANCESTOR_PRISTINE_VALUES,
+            payload: controlRef
+        });
+    }
+    return { form: updateDirty(result), action: action };
+};
+
+var markControlAsTouched = function (_a, action) {
+    var form = _a.form;
+    var _b = action.payload, controlRef = _b.controlRef, markAll = _b.markAll;
+    var controls = markAll
+        ? getControlBranch(controlRef, form)
+        : getAncestorControls(controlRef, form);
+    return {
+        form: Object.entries(form).reduce(function (acc, _a) {
+            var _b;
+            var key = _a[0], control = _a[1];
+            return (__assign(__assign({}, acc), (_b = {}, _b[key] = __assign(__assign({}, control), { touched: controls.includes(control) ? true : control.touched }), _b)));
+        }, {}),
+        action: action
+    };
+};
+
+var markControlAsUntouched = function (_a, action) {
+    var _b;
+    var form = _a.form;
+    var controlRef = action.payload;
+    var descendants = getDescendantControls(controlRef, form);
+    var result = Object.entries(form).reduce(function (acc, _a) {
+        var _b;
+        var key = _a[0], control = _a[1];
+        return (__assign(__assign({}, acc), (_b = {}, _b[key] = __assign(__assign({}, control), { touched: descendants.includes(control) ? false : control.touched }), _b)));
+    }, {});
+    // Update ancestors
+    var currentRef = controlRef;
+    var key;
+    while (currentRef.length > 0) {
+        currentRef = currentRef.slice(0, -1);
+        key = getFormKey(currentRef);
+        result = __assign(__assign({}, result), (_b = {}, _b[key] = __assign(__assign({}, result[key]), { touched: getDescendantControls(currentRef, result, true).some(function (control) { return control.touched; }) }), _b));
+    }
+    return { form: result, action: action };
+};
+
+var resetControl = function (_a, action) {
+    var form = _a.form;
+    var controlRef = action.payload;
+    var controlToReset = getControl(controlRef, form);
+    var descendants = getDescendantControls(controlRef, form);
+    // Remove all descendants
+    var descendantsRemoved = Object.entries(form).reduce(function (acc, _a) {
+        var _b;
+        var key = _a[0], control = _a[1];
+        if (descendants.includes(control))
+            return acc;
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = control, _b));
+    }, {});
+    var restoredControls = buildState(controlToReset.config, descendantsRemoved, controlToReset.controlRef);
+    return {
+        form: updateDirty(syncValidate(updateAncestorValues(restoredControls, {
+            type: UPDATE_ANCESTOR_VALUES,
+            payload: controlRef
+        }))),
+        action: action
+    };
+};
+
+var asyncValidation = function (form, _a) {
+    var controlRef = _a.payload.controlRef;
+    var ancestors = getAncestorControls(controlRef, form);
+    var result = Object.entries(form).reduce(function (acc, _a) {
+        var _b, _c;
+        var key = _a[0], control = _a[1];
+        if (ancestors.includes(control)) {
+            var isChangedControl = getFormKey(control.controlRef) === getFormKey(controlRef);
+            return __assign(__assign({}, acc), (_b = {}, _b[key] = __assign(__assign({}, control), { pending: true, asyncValidateInProgress: isChangedControl
+                    ? __assign({}, control.config.asyncValidators.reduce(function (acc, _, index) {
+                        var _a;
+                        return (__assign(__assign({}, acc), (_a = {}, _a[index] = true, _a)));
+                    }, {})) : control.asyncValidateInProgress }), _b));
+        }
+        return __assign(__assign({}, acc), (_c = {}, _c[key] = control, _c));
+    }, {});
+    return result;
+};
+
+var hasErrors = function (errors) {
+    return Object.values(errors).some(function (hasError) { return hasError; });
+};
+var mergeErrors = function (form) {
+    var errorsMerged = Object.entries(form).reduce(function (acc, _a) {
+        var _b;
+        var key = _a[0], control = _a[1];
+        var errors = __assign(__assign({}, control.validatorErrors), control.asyncValidatorErrors);
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = __assign(__assign({}, control), { errors: errors, valid: !hasErrors(errors) }), _b));
+    }, {});
+    var childrenErrorsChecked = Object.entries(errorsMerged).reduce(function (acc, _a) {
+        var _b;
+        var key = _a[0], control = _a[1];
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = __assign(__assign({}, control), { valid: control.valid &&
+                getDescendantControls(control.controlRef, errorsMerged).every(function (control) { return control.valid; }) }), _b));
+    }, {});
+    return childrenErrorsChecked;
+};
+
+var isControlValidating = function (control) {
+    if (!control.asyncValidateInProgress)
+        return false;
+    return Object.values(control.asyncValidateInProgress).some(function (pending) { return pending; });
+};
+var isControlAsyncValid = function (control) {
+    return !Object.values(control.asyncValidatorErrors).some(function (error) { return error; });
+};
+var getControlByKey = function (key, form) {
+    return Object.values(form).find(function (control) { return control.key === key; });
+};
+var asyncValidationResponseSuccess = function (form, _a) {
+    var _b, _c;
+    var _d = _a.payload, key = _d.key, validatorIndex = _d.validatorIndex, errors = _d.errors;
+    var control = getControlByKey(key, form);
+    if (!control) {
+        return form;
+    }
+    var controlUpdated = __assign(__assign({}, form), (_b = {}, _b[getFormKey(control.controlRef)] = __assign(__assign({}, control), { asyncValidateInProgress: __assign(__assign({}, control.asyncValidateInProgress), (_c = {}, _c[validatorIndex] = false, _c)), asyncValidatorErrors: __assign(__assign({}, control.asyncValidatorErrors), errors) }), _b));
+    var ancestors = getAncestorControls(control.controlRef, controlUpdated);
+    var ancestorsUpdated = Object.entries(controlUpdated).reduce(function (acc, _a) {
+        var _b, _c;
+        var key = _a[0], control = _a[1];
+        if (ancestors.includes(control)) {
+            var descendants = getDescendantControls(control.controlRef, controlUpdated);
+            return __assign(__assign({}, acc), (_b = {}, _b[key] = __assign(__assign({}, control), { pending: descendants.some(function (control) { return isControlValidating(control); }), asyncValidatorsValid: descendants.every(function (control) { return isControlAsyncValid(control); }) }), _b));
+        }
+        return __assign(__assign({}, acc), (_c = {}, _c[key] = control, _c));
+    }, {});
+    return mergeErrors(ancestorsUpdated);
+};
+
+var DEFAULT_HUB2_FIELDS = {
+    asyncValidatorsValid: true,
+    asyncValidatorErrors: {},
+    asyncValidateInProgress: {},
+    pending: false,
+    valid: null,
+    errors: null
+};
+var formChange = function (state, _a) {
+    if (state === void 0) { state = null; }
+    var _b = _a.payload, form = _b.form, action = _b.action;
+    return mergeErrors(Object.entries(form).reduce(function (acc, _a) {
+        var _b;
+        var dictKey = _a[0], baseControl = _a[1];
+        var existingControl = (action === null || action === void 0 ? void 0 : action.type) === 'removeControl'
+            ? state && Object.values(state).find(function (control) { return baseControl.key === control.key; })
+            : state && state[dictKey];
+        return __assign(__assign({}, acc), (_b = {}, _b[dictKey] = __assign(__assign({}, (existingControl
+            ? existingControl
+            : structuredClone(DEFAULT_HUB2_FIELDS))), baseControl), _b));
+    }, {}));
+};
+
+var control = function (config) {
+    if (Array.isArray(config)) {
+        return config.reduce(function (acc, item, index) {
+            var _a;
+            var indexMap = {
+                0: 'initialValue',
+                1: 'validators',
+                2: 'asyncValidators'
+            };
+            return __assign(__assign({}, acc), (_a = {}, _a[indexMap[index]] = index < 1 ? item : [].concat(item || []), _a));
+        }, {});
+    }
+    return config;
+};
+var array = function (config) { return config; };
+var group = function (config) { return config; };
+var build = function (config) {
+    var initialState = buildFormState(config);
+    var rxHub1 = core.RxBuilder({
+        initialState: initialState,
+        reducers: {
+            updateValues: updateValues,
+            removeControl: removeControl,
+            addControl: addControl,
+            markControlAsPristine: markControlAsPristine,
+            markControlAsTouched: markControlAsTouched,
+            markControlAsUntouched: markControlAsUntouched,
+            resetControl: resetControl
+        }
+    });
+    var rxHub2 = core.RxBuilder({
+        sources: [buildHub2Source(rxHub1)],
+        initialState: null,
+        reducers: {
+            formChange: formChange,
+            asyncValidation: {
+                reducer: asyncValidation,
+                effects: function (control) { return ({
+                    key: control.key,
+                    effects: getScopedEffectsForControl(control)
+                }); }
+            },
+            asyncValidationResponseSuccess: asyncValidationResponseSuccess
+        }
+    });
+    return {
+        state$: rxHub2.state$.pipe(operators.filter(function (form) { return form !== null; })),
+        actions: rxHub1.actions
+    };
+};
+var RxForm = {
+    group: group,
+    array: array,
+    control: control,
+    build: build
+};
+
+var getArrayItems = function (controlRef, form) {
+    if (!Array.isArray(getControl(controlRef, form).config.controls)) {
+        throw "".concat(controlRef.join('.'), " is not a Form Array control");
+    }
+    return Object.values(form)
+        .filter(function (control) {
+        var isItem = controlRef.every(function (key, index) { return key === control.controlRef[index]; }) &&
+            control.controlRef.length === controlRef.length + 1 &&
+            typeof control.controlRef[controlRef.length] === 'number';
+        return isItem;
+    })
+        .sort(function (a, b) { return +a.controlRef.slice(-1) - +b.controlRef.slice(-1); });
+};
+
+exports.ControlModels = Controls;
+exports.RxForm = RxForm;
+exports.Validators = index;
+exports.getArrayItems = getArrayItems;