@reactables/forms 1.3.0-beta.3 → 2.0.0-beta.1

package/dist/index.cjs

@@ -0,0 +1,1213 @@
+'use strict';
+
+var core = require('@reactables/core');
+var operators = require('rxjs/operators');
+var rxjs = require('rxjs');
+var isEqual = require('lodash.isequal');
+
+var DEFAULT_HUB2_FIELDS = {
+    asyncValidatorErrors: {},
+    asyncValidateInProgress: {},
+    pending: false,
+    valid: null,
+    childrenValid: null,
+    errors: null
+};
+
+var Controls = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    DEFAULT_HUB2_FIELDS: DEFAULT_HUB2_FIELDS
+});
+
+var required = function (value) {
+    if (typeof value === 'string' || typeof value === 'object') {
+        return { required: !Boolean(value) };
+    }
+    if (typeof value === 'number') {
+        return { required: !(value !== undefined && value !== null) };
+    }
+    if (typeof value === 'boolean') {
+        return { required: !value };
+    }
+    return { required: false };
+};
+var arrayNotEmpty = function (value) { return ({
+    arrayNotEmpty: !Boolean(value.length)
+}); };
+var email = function (value) {
+    return value && !/^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/g.test(value) ? { email: true } : { email: false };
+};
+
+var Validators = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    arrayNotEmpty: arrayNotEmpty,
+    email: email,
+    required: required
+});
+
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    arrayNotEmpty: arrayNotEmpty,
+    email: email,
+    required: required
+});
+
+/******************************************************************************
+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.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+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 __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+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;
+};
+
+var getErrors = function (control, value, _a) {
+    var _b;
+    var validators = _a.validators;
+    return ((_b = control.config.validators) === null || _b === void 0 ? void 0 : _b.reduce(function (acc, validator) {
+        if (!validators[validator]) {
+            throw "You have not provided a validator for \"".concat(validator, "\"");
+        }
+        return __assign(__assign({}, acc), validators[validator](value));
+    }, {})) || {};
+};
+
+var buildState = function (config, form, controlRef, providers) {
+    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: {},
+        config: config,
+        key: generateKey(5)
+    };
+    var newForm = __assign(__assign({}, form), (_a = {}, _a[getFormKey(controlRef)] = __assign(__assign({}, control), { validatorErrors: getErrors(control, value, providers) }), _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), providers);
+        }, 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), providers);
+        }, newForm);
+    }
+    return newForm;
+};
+var buildFormState = function (config, form, controlRef, providers) {
+    if (form === void 0) { form = { root: null }; }
+    if (controlRef === void 0) { controlRef = []; }
+    return {
+        form: buildState(config, form, controlRef, providers)
+    };
+};
+
+var getScopedEffectsForControl = function (formControl, providers) {
+    var config = formControl.config, key = formControl.key, controlRef = formControl.controlRef;
+    var asyncValidators = config.asyncValidators;
+    var scopedEffects = [];
+    if (asyncValidators && asyncValidators.length) {
+        scopedEffects = asyncValidators.reduce(function (acc, asyncValidator, validatorIndex) {
+            var effect = function (actions$) {
+                if (!providers.asyncValidators[asyncValidator]) {
+                    throw "You have not provided an asyncValidator for \"".concat(asyncValidator, "\"");
+                }
+                return actions$.pipe(operators.map(function (_a) {
+                    var control = _a.payload;
+                    return control;
+                }), providers.asyncValidators[asyncValidator], operators.switchMap(function (errors$) {
+                    return rxjs.concat(rxjs.of({ type: 'asyncValidation', payload: controlRef }), errors$.pipe(operators.map(function (errors) { return ({
+                        type: 'asyncValidationResponse',
+                        payload: {
+                            key: key,
+                            errors: errors,
+                            validatorIndex: validatorIndex
+                        }
+                    }); }), operators.catchError(function () {
+                        return rxjs.of({
+                            type: 'asyncValidationResponse',
+                            payload: {
+                                key: key,
+                                errors: { asyncValidationApiError: true },
+                                validatorIndex: validatorIndex
+                            }
+                        });
+                    })));
+                }));
+            };
+            return acc.concat(effect);
+        }, []);
+    }
+    return scopedEffects;
+};
+var getAsyncValidationEffects = function (formControls) {
+    return formControls.reduce(function (acc, control) {
+        var _a;
+        if (!((_a = control.config.asyncValidators) === null || _a === void 0 ? void 0 : _a.length))
+            return acc;
+        var action = { type: 'asyncValidationEffect', payload: control };
+        return acc.concat(action);
+    }, []);
+};
+
+var buildHub2Source = function (hub1State$, initialBaseState) {
+    var hub1StateMapped$ = hub1State$.pipe(operators.map(function (payload) { return ({ type: 'formChange', payload: payload }); }));
+    var initialAction = { type: 'formChange', payload: initialBaseState };
+    var sourceForHub2$ = hub1StateMapped$.pipe(operators.startWith(initialAction), operators.pairwise(), operators.mergeMap(function (_a) {
+        var prevForm = _a[0].payload.form, currAction = _a[1];
+        var _b = currAction.payload, _changedControls = _b._changedControls, currentForm = _b.form;
+        var valueChanged = !isEqual(prevForm.root.value, currentForm.root.value);
+        var controlsToCheck = _changedControls && valueChanged ? Object.values(_changedControls) : [];
+        var asyncValidationEffectActions = getAsyncValidationEffects(controlsToCheck);
+        return rxjs.of.apply(void 0, __spreadArray([currAction], asyncValidationEffectActions, false));
+    }));
+    return sourceForHub2$;
+};
+
+var getControl = function (controlRef, form) {
+    return form[getFormKey(controlRef)];
+};
+
+var updateAncestorValues = function (form, _a, providers) {
+    var _b, _c;
+    var _d = _a.payload, controlRef = _d.controlRef, value = _d.value;
+    if (controlRef.length) {
+        var parentRef = controlRef.slice(0, -1);
+        var parentControl = getControl(parentRef, form);
+        var parentFormKey = getFormKey(parentControl.controlRef);
+        var childKey_1 = controlRef.slice(-1)[0];
+        var newValue = void 0;
+        // If parent is a Form Array
+        if (Array.isArray(parentControl.value)) {
+            newValue = parentControl.value.map(function (item, index) {
+                return index === childKey_1 ? value : item;
+            });
+        }
+        else {
+            // If parent is a Form Group
+            newValue = __assign(__assign({}, parentControl.value), (_b = {}, _b[childKey_1] = value, _b));
+        }
+        var newParentControl = __assign(__assign({}, parentControl), { validatorErrors: getErrors(parentControl, newValue, providers), value: newValue, dirty: !isEqual(newValue, parentControl.pristineValue) });
+        return updateAncestorValues(__assign(__assign({}, form), (_c = {}, _c[parentFormKey] = newParentControl, _c)), {
+            payload: { controlRef: parentRef, value: newValue }
+        }, providers);
+    }
+    return form;
+};
+
+var isChildRef = function (controlRef, parentRef) {
+    return (parentRef.every(function (key, index) { return controlRef[index] === key; }) &&
+        controlRef.length === parentRef.length + 1);
+};
+
+// Includes the original control of interest unless excludeSelf === true
+var getDescendantControls = function (controlRef, form, excludeSelf) {
+    if (excludeSelf === void 0) { excludeSelf = false; }
+    if (!controlRef.length) {
+        return Object.values(form).filter(function (_a) {
+            var controlRef = _a.controlRef;
+            return excludeSelf ? controlRef.length !== 0 : true;
+        });
+    }
+    var control = getControl(controlRef, form);
+    var value = control.value, config = control.config;
+    var descendants;
+    if (Array.isArray(config.controls)) {
+        // If control is a Form Array
+        descendants = value.reduce(function (acc, item, index) {
+            return acc.concat(getDescendantControls(controlRef.concat(index), form));
+        }, []);
+    }
+    else if (config.controls) {
+        // If control is a Form Group
+        descendants = Object.keys(value).reduce(function (acc, key) {
+            return acc.concat(getDescendantControls(controlRef.concat(key), form));
+        }, []);
+    }
+    if (excludeSelf)
+        return descendants;
+    return [control].concat(descendants || []);
+};
+
+// 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;
+    });
+};
+
+/**
+ * @description see if any keys in a ControlRef has a "." probably a mistake by developer
+ */
+var controlRefCheck = function (ref) {
+    try {
+        var hasError = ref.some(function (key) {
+            if (typeof key === 'string') {
+                return key.includes('.');
+            }
+            return false;
+        });
+        if (hasError) {
+            var refString = "[".concat(ref.reduce(function (acc, key, index) {
+                if (index > 0) {
+                    acc = acc.concat(', ');
+                }
+                if (typeof key === 'number') {
+                    return acc.concat(key.toString());
+                }
+                return acc.concat("'".concat(key, "'"));
+            }, ''), "]");
+            var suggestion = "[".concat(ref.reduce(function (acc, key, index) {
+                if (index > 0) {
+                    acc = acc.concat(', ');
+                }
+                if (typeof key === 'number') {
+                    return acc.concat(key.toString());
+                }
+                var splitted = key
+                    .split('.')
+                    .map(function (key) { return "'".concat(key, "'"); })
+                    .join(', ');
+                return acc.concat("".concat(splitted));
+            }, ''), "]");
+            console.warn("You provided ".concat(refString, ". Did you mean ").concat(suggestion, "?"));
+        }
+    }
+    catch (_a) { }
+};
+
+var checkKeys = function (obj1, obj2) {
+    if (Object.keys(obj1).slice().sort().join() !== Object.keys(obj2).slice().sort().join()) {
+        throw 'Can not update value because keys are not the same.';
+    }
+};
+var updateDescendantValues = function (form, _a, providers) {
+    var _b = _a.payload, controlRef = _b.controlRef, value = _b.value;
+    var descendants = getDescendantControls(controlRef, form, true).map(function (control) { return [getFormKey(control.controlRef), control]; });
+    var result = descendants.reduce(function (acc, _a) {
+        var _b;
+        var key = _a[0], control = _a[1];
+        if (isChildRef(control.controlRef, controlRef)) {
+            var newChildValue = value[control.controlRef.at(-1)];
+            var validatorErrors = getErrors(control, newChildValue, providers);
+            var oldChildValue = control.value;
+            var newControl = __assign(__assign({}, control), { value: newChildValue, validatorErrors: validatorErrors, dirty: !isEqual(newChildValue, control.pristineValue) });
+            acc = __assign(__assign({}, acc), (_b = {}, _b[key] = newControl, _b));
+            var configControls = control.config.controls;
+            if (configControls) {
+                checkKeys(oldChildValue, newChildValue);
+                acc = updateDescendantValues(acc, {
+                    payload: { controlRef: control.controlRef, value: newChildValue }
+                }, providers);
+            }
+        }
+        return acc;
+    }, form);
+    return result;
+};
+// Will only update child controls that are present.
+// Use AddControlPayload/RemoveControl action reducers to add/remove control
+var updateValues = function (_a, action, providers, mergeChanges) {
+    var _b, _c;
+    var form = _a.form, _d = _a._changedControls, _changedControls = _d === void 0 ? {} : _d, _e = _a._removedControls, _removedControls = _e === void 0 ? {} : _e;
+    if (mergeChanges === void 0) { mergeChanges = false; }
+    var normalizers = providers.normalizers;
+    var _f = action.payload, controlRef = _f.controlRef, value = _f.value;
+    controlRefCheck(controlRef);
+    // Update its own value
+    var ctrlKey = getFormKey(controlRef);
+    var newValue = value;
+    var oldValue = form[ctrlKey].value;
+    var config = form[ctrlKey].config;
+    if (config.normalizers) {
+        newValue = config.normalizers.reduce(function (acc, normalizer) {
+            if (!normalizers[normalizer]) {
+                throw "You have not provided a normalizer for \"".concat(normalizer, "\"");
+            }
+            return normalizers[normalizer](acc);
+        }, value);
+    }
+    var validatorErrors = getErrors(form[ctrlKey], newValue, providers);
+    var newControl = __assign(__assign({}, form[ctrlKey]), { validatorErrors: validatorErrors, dirty: !isEqual(value, form[ctrlKey].pristineValue), value: newValue });
+    var result = {
+        form: __assign(__assign({}, form), (_b = {}, _b[ctrlKey] = newControl, _b)),
+        _changedControls: (_c = {}, _c[newControl.key] = newControl, _c)
+    };
+    var configControls = config.controls;
+    // Update its descendants
+    if (configControls) {
+        checkKeys(oldValue, newValue);
+        var updatedDescendants = updateDescendantValues(result.form, {
+            payload: {
+                controlRef: controlRef,
+                value: newValue
+            }
+        }, providers);
+        var changedDescendantControls = getDescendantControls(controlRef, updatedDescendants).reduce(function (acc, control) {
+            var _a;
+            return (__assign(__assign({}, acc), (_a = {}, _a[control.key] = control, _a)));
+        }, {});
+        result = __assign(__assign({}, result), { form: updatedDescendants, _changedControls: __assign(__assign({}, result._changedControls), changedDescendantControls) });
+    }
+    // Update its Ancestors
+    if (controlRef.length) {
+        result = __assign(__assign({}, result), { form: updateAncestorValues(result.form, {
+                payload: { controlRef: controlRef, value: newValue }
+            }, providers) });
+    }
+    var changedAncestorControls = getAncestorControls(controlRef, result.form).reduce(function (acc, control) {
+        var _a;
+        return (__assign(__assign({}, acc), (_a = {}, _a[control.key] = control, _a)));
+    }, {});
+    var mergedResult = __assign(__assign({}, result), { _changedControls: __assign(__assign(__assign({}, (mergeChanges ? _changedControls : undefined)), changedAncestorControls), result._changedControls), _removedControls: mergeChanges ? _removedControls : undefined });
+    return mergedResult;
+};
+
+var updateAncestorValuesRemoveControl = function (form, _a, providers) {
+    var _b;
+    var controlRef = _a.payload;
+    if (controlRef.length) {
+        var parentRef = controlRef.slice(0, -1);
+        var parentControl = getControl(parentRef, form);
+        var parentFormKey = getFormKey(parentControl.controlRef);
+        var childKey_1 = controlRef.slice(-1)[0];
+        var newValue = void 0;
+        // If parent is a Form Array
+        if (Array.isArray(parentControl.value)) {
+            newValue = parentControl.value.filter(function (item, index) { return index !== childKey_1; });
+        }
+        else {
+            // If parent is a Form Group
+            newValue = __assign({}, parentControl.value);
+            delete newValue[childKey_1];
+        }
+        var newParentControl = __assign(__assign({}, parentControl), { value: newValue, validatorErrors: getErrors(parentControl, newValue, providers), dirty: !isEqual(newValue, parentControl.pristineValue) });
+        return updateAncestorValues(__assign(__assign({}, form), (_b = {}, _b[parentFormKey] = newParentControl, _b)), {
+            payload: { controlRef: parentRef, value: newValue }
+        }, providers);
+    }
+    return form;
+};
+
+var removeControl = function (state, action, providers, mergeChanges) {
+    var _a;
+    if (mergeChanges === void 0) { mergeChanges = false; }
+    var form = state.form;
+    var controlRef = action.payload;
+    controlRefCheck(controlRef);
+    var controlToRemove = getControl(controlRef, form);
+    if (!controlToRemove) {
+        throw 'Control not found';
+    }
+    // Can't remove the root of the form
+    if (!controlRef.length)
+        return { form: form };
+    var parentRef = controlRef.slice(0, -1);
+    var parentIsFormArray = Array.isArray(getControl(parentRef, form).config.controls);
+    var descendants = getDescendantControls(controlRef, form);
+    var descendantkeys = descendants.map(function (_a) {
+        var controlRef = _a.controlRef;
+        return getFormKey(controlRef);
+    });
+    var controlsRemoved = __assign({}, form);
+    descendantkeys.forEach(function (key) {
+        delete controlsRemoved[key];
+    });
+    // Remove control and all descendants
+    var controlRemoved = Object.entries(controlsRemoved).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));
+    }, {});
+    var result = updateAncestorValuesRemoveControl(controlRemoved, {
+        payload: controlRef
+    }, providers);
+    var _changedControls = __assign(__assign({}, (mergeChanges ? state._changedControls || {} : undefined)), getAncestorControls(controlRef.slice(0, -1), result).reduce(function (acc, control) {
+        var _a;
+        return (__assign(__assign({}, acc), (_a = {}, _a[control.key] = control, _a)));
+    }, {}));
+    // Check for reindexing for changed controls
+    if (parentIsFormArray) {
+        _changedControls = Object.entries(_changedControls).reduce(function (acc, _a) {
+            var _b, _c;
+            var key = _a[0], control = _a[1];
+            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));
+            }
+            else {
+                return __assign(__assign({}, acc), (_c = {}, _c[key] = control, _c));
+            }
+        }, {});
+    }
+    var _removedControls = __assign(__assign({}, (mergeChanges ? state._removedControls || {} : undefined)), (_a = {}, _a[controlToRemove.key] = controlToRemove, _a));
+    descendants
+        .map(function (_a) {
+        var key = _a.key;
+        return key;
+    })
+        .forEach(function (key) {
+        delete _changedControls[key];
+    });
+    return {
+        form: result,
+        _changedControls: _changedControls,
+        _removedControls: _removedControls
+    };
+};
+
+var updateAncestorValuesAddControl = function (form, _a, providers) {
+    var _b, _c;
+    var _d = _a.payload, controlRef = _d.controlRef, value = _d.value;
+    if (controlRef.length) {
+        var parentRef = controlRef.slice(0, -1);
+        var parentControl = getControl(parentRef, form);
+        var parentFormKey = getFormKey(parentControl.controlRef);
+        var childKey = controlRef.slice(-1)[0];
+        var newValue = void 0;
+        // If parent is a Form Array
+        if (Array.isArray(parentControl.value)) {
+            newValue = parentControl.value.concat(value);
+        }
+        else {
+            // If parent is a Form Group
+            newValue = __assign(__assign({}, form[parentFormKey].value), (_b = {}, _b[childKey] = value, _b));
+        }
+        var newParentControl = __assign(__assign({}, parentControl), { value: newValue, validatorErrors: getErrors(parentControl, newValue, providers), dirty: !isEqual(newValue, parentControl.pristineValue) });
+        return updateAncestorValues(__assign(__assign({}, form), (_c = {}, _c[parentFormKey] = newParentControl, _c)), {
+            payload: { controlRef: parentRef, value: newValue }
+        }, providers);
+    }
+    return form;
+};
+
+var getControlBranch = function (controlRef, form) {
+    var ancestors = getAncestorControls(controlRef, form);
+    var childControls = getDescendantControls(controlRef, form).slice(1);
+    return ancestors.concat(childControls).sort(function (a, b) { return a.controlRef.length - b.controlRef.length; });
+};
+
+var addControl = function (state, action, providers, mergeChanges) {
+    if (mergeChanges === void 0) { mergeChanges = false; }
+    var _a = action.payload, config = _a.config, controlRef = _a.controlRef;
+    controlRefCheck(controlRef);
+    // 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';
+    }
+    var newForm = buildState(config, state.form, controlRef, providers);
+    var newValue = getControl(controlRef, newForm).value;
+    var ancestorsUpdated = updateAncestorValuesAddControl(newForm, {
+        payload: { controlRef: controlRef, value: newValue }
+    }, providers);
+    var _changedControls = getControlBranch(controlRef, ancestorsUpdated).reduce(function (acc, control) {
+        var _a;
+        return (__assign(__assign({}, acc), (_a = {}, _a[control.key] = control, _a)));
+    }, {});
+    return {
+        form: ancestorsUpdated,
+        _changedControls: __assign(__assign({}, (mergeChanges ? state._changedControls || {} : undefined)), _changedControls),
+        _removedControls: mergeChanges ? state._removedControls || {} : undefined
+    };
+};
+
+var pushControl = function (state, action, providers, mergeChanges) {
+    if (mergeChanges === void 0) { mergeChanges = false; }
+    var newControlRef;
+    var _a = action.payload, config = _a.config, controlRef = _a.controlRef;
+    controlRefCheck(controlRef);
+    var existingControl = getControl(controlRef, state.form);
+    if (!existingControl)
+        throw 'You are attempting to push to a control that does not exist';
+    // If controlRef exists we are adding control to a Form Array
+    if (Array.isArray(existingControl.config.controls)) {
+        newControlRef = controlRef.concat(existingControl.value.length);
+    }
+    else {
+        throw 'You are attempting to push to a control that is not a Form Array';
+    }
+    var newForm = buildState(config, state.form, newControlRef, providers);
+    var newValue = getControl(newControlRef, newForm).value;
+    var ancestorsUpdated = updateAncestorValuesAddControl(newForm, {
+        payload: { controlRef: newControlRef, value: newValue }
+    }, providers);
+    var _changedControls = getControlBranch(newControlRef, ancestorsUpdated).reduce(function (acc, control) {
+        var _a;
+        return (__assign(__assign({}, acc), (_a = {}, _a[control.key] = control, _a)));
+    }, {});
+    return {
+        form: ancestorsUpdated,
+        _changedControls: __assign(__assign({}, (mergeChanges ? state._changedControls || {} : undefined)), _changedControls),
+        _removedControls: mergeChanges ? state._removedControls || {} : undefined
+    };
+};
+
+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, dirty: isEqual(form[parentKey].value, newValue) });
+        return updateAncestorPristineValues(__assign(__assign({}, form), (_b = {}, _b[parentKey] = newParentControl, _b)), {
+            payload: parentRef
+        });
+    }
+    return form;
+};
+
+var markControlAsPristine = function (state, action, mergeChanges) {
+    if (mergeChanges === void 0) { mergeChanges = false; }
+    var form = state.form;
+    var controlRef = action.payload;
+    controlRefCheck(controlRef);
+    var descendants = getDescendantControls(controlRef, form).reduce(function (acc, control) {
+        var _a;
+        return (__assign(__assign({}, acc), (_a = {}, _a[getFormKey(control.controlRef)] = __assign(__assign({}, control), { dirty: false, pristineValue: control.value }), _a)));
+    }, {});
+    var result = __assign(__assign({}, form), descendants);
+    if (controlRef.length) {
+        result = updateAncestorPristineValues(result, {
+            payload: controlRef
+        });
+    }
+    var _changedControls = getControlBranch(controlRef, result).reduce(function (acc, control) {
+        var _a;
+        return (__assign(__assign({}, acc), (_a = {}, _a[control.key] = control, _a)));
+    }, {});
+    return {
+        form: result,
+        _changedControls: __assign(__assign({}, (mergeChanges ? state._changedControls || {} : undefined)), _changedControls),
+        _removedControls: mergeChanges ? state._removedControls || {} : undefined
+    };
+};
+
+var markControlAsTouched = function (state, action, mergeChanges) {
+    if (mergeChanges === void 0) { mergeChanges = false; }
+    var form = state.form;
+    var _a = action.payload, controlRef = _a.controlRef, _b = _a.markAll, markAll = _b === void 0 ? false : _b;
+    controlRefCheck(controlRef);
+    var controls = (markAll ? getControlBranch(controlRef, form) : getAncestorControls(controlRef, form)).reduce(function (acc, control) {
+        var _a;
+        return (__assign(__assign({}, acc), (_a = {}, _a[getFormKey(control.controlRef)] = __assign(__assign({}, control), { touched: true }), _a)));
+    }, {});
+    var result = {
+        form: __assign(__assign({}, form), controls)};
+    var _changedControls = getControlBranch(controlRef, result.form).reduce(function (acc, control) {
+        var _a;
+        return (__assign(__assign({}, acc), (_a = {}, _a[control.key] = control, _a)));
+    }, {});
+    return {
+        form: __assign(__assign({}, form), controls),
+        _changedControls: __assign(__assign({}, (mergeChanges ? state._changedControls || {} : undefined)), _changedControls),
+        _removedControls: mergeChanges ? state._removedControls || {} : undefined
+    };
+};
+
+var markControlAsUntouched = function (state, action, mergeChanges) {
+    var _a;
+    if (mergeChanges === void 0) { mergeChanges = false; }
+    var form = state.form;
+    var controlRef = action.payload;
+    controlRefCheck(controlRef);
+    var result = getDescendantControls(controlRef, form).reduce(function (acc, control) {
+        var _a;
+        return (__assign(__assign({}, acc), (_a = {}, _a[getFormKey(control.controlRef)] = __assign(__assign({}, control), { touched: false }), _a)));
+    }, {});
+    result = __assign(__assign({}, form), result);
+    // Update ancestors
+    var currentRef = controlRef;
+    var key;
+    while (currentRef.length > 0) {
+        currentRef = currentRef.slice(0, -1);
+        key = getFormKey(currentRef);
+        result = __assign(__assign({}, result), (_a = {}, _a[key] = __assign(__assign({}, result[key]), { touched: getDescendantControls(currentRef, result, true).some(function (control) { return control.touched; }) }), _a));
+    }
+    var _changedControls = getControlBranch(controlRef, result).reduce(function (acc, control) {
+        var _a;
+        return (__assign(__assign({}, acc), (_a = {}, _a[control.key] = control, _a)));
+    }, {});
+    return {
+        form: result,
+        _changedControls: __assign(__assign({}, (mergeChanges ? state._changedControls || {} : undefined)), _changedControls),
+        _removedControls: mergeChanges ? state._removedControls || {} : undefined
+    };
+};
+
+var resetControl = function (state, action, providers, mergeChanges) {
+    var _a;
+    if (mergeChanges === void 0) { mergeChanges = false; }
+    var form = state.form;
+    var controlRef = action.payload;
+    controlRefCheck(controlRef);
+    var controlToReset = getControl(controlRef, form);
+    var descendantsRemoved = __assign({}, form);
+    var descendants = getDescendantControls(controlRef, form);
+    var descendantKeys = descendants.map(function (_a) {
+        var controlRef = _a.controlRef;
+        return getFormKey(controlRef);
+    });
+    descendantKeys.forEach(function (key) {
+        delete descendantsRemoved[key];
+    });
+    // Remove all descendants
+    var restoredControls = buildState(controlToReset.config, descendantsRemoved, controlToReset.controlRef, providers);
+    var restoredControlValue = getControl(controlRef, restoredControls).value;
+    var result = updateAncestorValues(restoredControls, {
+        payload: { controlRef: controlRef, value: restoredControlValue }
+    }, providers);
+    var _changedControls = __assign(__assign({}, (mergeChanges ? state._changedControls || {} : undefined)), getControlBranch(controlRef, result).reduce(function (acc, control) {
+        var _a;
+        return (__assign(__assign({}, acc), (_a = {}, _a[control.key] = control, _a)));
+    }, {}));
+    var _removedControls = __assign(__assign({}, (mergeChanges ? state._removedControls || {} : undefined)), (_a = {}, _a[controlToReset.key] = controlToReset, _a));
+    // If control is removed, we can delete it from the _changedControls check
+    descendants
+        .map(function (_a) {
+        var key = _a.key;
+        return key;
+    })
+        .forEach(function (key) {
+        delete _changedControls[key];
+    });
+    return {
+        form: result,
+        _changedControls: _changedControls,
+        _removedControls: _removedControls
+    };
+};
+
+var asyncValidation = function (form, _a) {
+    var controlRef = _a.payload;
+    var updatedSelfAndAncestors = getAncestorControls(controlRef, form).reduce(function (acc, control) {
+        var _a;
+        var isChangedControl = getFormKey(control.controlRef) === getFormKey(controlRef);
+        return __assign(__assign({}, acc), (_a = {}, _a[getFormKey(control.controlRef)] = __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 }), _a));
+    }, {});
+    return __assign(__assign({}, form), updatedSelfAndAncestors);
+};
+
+var reverseObjectKeys = function (form) {
+    return Object.keys(form)
+        .reverse()
+        .reduce(function (acc, key) {
+        acc[key] = form[key];
+        return acc;
+    }, {});
+};
+
+var hasErrors$3 = function (errors) {
+    return Object.values(errors).some(function (hasError) { return hasError; });
+};
+var mergeBranchErrors = function (form, controlRef) {
+    var controlBranch = getControlBranch(controlRef, form).reduce(function (acc, ctrl) {
+        var _a;
+        return __assign(__assign({}, acc), (_a = {}, _a[getFormKey(ctrl.controlRef)] = ctrl, _a));
+    }, {});
+    var errorsMerged = Object.entries(controlBranch)
+        .reverse()
+        .reduce(function (acc, _a) {
+        var _b;
+        var key = _a[0], control = _a[1];
+        var errors = __assign(__assign({}, control.validatorErrors), control.asyncValidatorErrors);
+        var selfValid = !hasErrors$3(errors);
+        var childrenValid = true;
+        if (Array.isArray(control.config.controls)) {
+            // If control is a FormArray
+            childrenValid = control.value.every(function (item, index) {
+                var formKey = getFormKey(control.controlRef.concat(index));
+                var valid = acc[formKey] === undefined ? form[formKey].valid : acc[formKey].valid;
+                return valid;
+            });
+        }
+        else if (control.config.controls) {
+            // If control is a FormGroup
+            childrenValid = Object.keys(control.value).every(function (childKey) {
+                var formKey = getFormKey(control.controlRef.concat(childKey));
+                var valid = acc[formKey] === undefined ? form[formKey].valid : acc[formKey].valid;
+                return valid;
+            });
+        }
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = __assign(__assign({}, control), { errors: errors, valid: selfValid && childrenValid, childrenValid: childrenValid }), _b));
+    }, {});
+    var errorsMergedOrderRestored = reverseObjectKeys(errorsMerged);
+    return __assign(__assign({}, form), errorsMergedOrderRestored);
+};
+
+var isControlValidating = function (control) {
+    if (!control.asyncValidateInProgress)
+        return false;
+    return Object.values(control.asyncValidateInProgress).some(function (pending) { return pending; });
+};
+var getControlByKey = function (key, form) {
+    return Object.values(form).find(function (control) { return control.key === key; });
+};
+var asyncValidationResponse = 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);
+            var pending_1 = descendants.some(function (control) { return isControlValidating(control); });
+            return __assign(__assign({}, acc), (_b = {}, _b[key] = __assign(__assign({}, control), { pending: pending_1 }), _b));
+        }
+        return __assign(__assign({}, acc), (_c = {}, _c[key] = control, _c));
+    }, {});
+    return mergeBranchErrors(ancestorsUpdated, control.controlRef);
+};
+
+var hasErrors$2 = function (errors) {
+    return Object.values(errors).some(function (hasError) { return hasError; });
+};
+// TODO: update merge errors to not do the entire form but just a subset of it
+// TODO: separation of concern to update validity of control and ancestors
+var mergeErrors = function (form) {
+    var errorsMerged = Object.entries(form)
+        .reverse()
+        .reduce(function (acc, _a) {
+        var _b;
+        var key = _a[0], control = _a[1];
+        var errors = __assign(__assign({}, control.validatorErrors), control.asyncValidatorErrors);
+        var selfValid = !hasErrors$2(errors);
+        var childrenValid = true;
+        if (Array.isArray(control.config.controls)) {
+            // If control is a FormArray
+            childrenValid = control.value.every(function (item, index) { return acc[getFormKey(control.controlRef.concat(index))].valid; });
+        }
+        else if (control.config.controls) {
+            // If control is a FormGroup
+            childrenValid = Object.keys(control.value).every(function (childKey) { return acc[getFormKey(control.controlRef.concat(childKey))].valid; });
+        }
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = __assign(__assign({}, control), { errors: errors, valid: selfValid && childrenValid, childrenValid: childrenValid }), _b));
+    }, {});
+    var restoredOrder = reverseObjectKeys(errorsMerged);
+    return restoredOrder;
+};
+
+var hasErrors$1 = function (errors) {
+    return Object.values(errors).some(function (hasError) { return hasError; });
+};
+var mergeRemoveControl = function (state, form, controlRef) {
+    var parentRef = controlRef.slice(0, -1);
+    var existingBranch = getControlBranch(parentRef, state);
+    var updatedControlBranch = getControlBranch(parentRef, form)
+        .reverse()
+        .reduce(function (acc, baseControl) {
+        var _a;
+        var key = getFormKey(baseControl.controlRef);
+        var existingControl = existingBranch.find(function (control) { return baseControl.key === control.key; }) ||
+            structuredClone(DEFAULT_HUB2_FIELDS);
+        var errors = __assign(__assign({}, baseControl.validatorErrors), existingControl.asyncValidatorErrors);
+        var selfValid = !hasErrors$1(errors);
+        var childrenValid = true;
+        if (Array.isArray(baseControl.config.controls)) {
+            // If control is a FormArray
+            childrenValid = baseControl.value.every(function (item, index) {
+                var formKey = getFormKey(baseControl.controlRef.concat(index));
+                var valid = acc[formKey] === undefined ? state[formKey].valid : acc[formKey].valid;
+                return valid;
+            });
+        }
+        else if (baseControl.config.controls) {
+            // If control is a FormGroup
+            childrenValid = Object.keys(baseControl.value).every(function (childKey) {
+                var formKey = getFormKey(baseControl.controlRef.concat(childKey));
+                var valid = acc[formKey] === undefined ? state[formKey].valid : acc[formKey].valid;
+                return valid;
+            });
+        }
+        return __assign(__assign({}, acc), (_a = {}, _a[key] = __assign(__assign(__assign({}, existingControl), baseControl), { errors: errors, valid: selfValid && childrenValid, childrenValid: childrenValid }), _a));
+    }, {});
+    var updatedControlBranchOrderRestored = reverseObjectKeys(updatedControlBranch);
+    var descendants = existingBranch.filter(function (control) { return control.controlRef.length > parentRef.length; });
+    var _removedControls = __assign({}, state);
+    descendants.forEach(function (control) {
+        delete _removedControls[getFormKey(control.controlRef)];
+    });
+    delete _removedControls[getFormKey(controlRef)];
+    return __assign(__assign({}, _removedControls), updatedControlBranchOrderRestored);
+};
+
+var hasErrors = function (errors) {
+    return Object.values(errors).some(function (hasError) { return hasError; });
+};
+var mergeControls = function (state, _a) {
+    var form = _a.form, _b = _a._changedControls, _changedControls = _b === void 0 ? {} : _b, _removedControls = _a._removedControls;
+    var controlsRemoved = _removedControls
+        ? Object.values(_removedControls).reduce(function (acc, _a) {
+            var controlRef = _a.controlRef;
+            return mergeRemoveControl(acc, form, controlRef);
+        }, state)
+        : state;
+    var updatedBranch = Object.values(_changedControls)
+        .reverse()
+        .reduce(function (acc, control) {
+        var _a;
+        var formKey = getFormKey(control.controlRef);
+        var existingControl = controlsRemoved && controlsRemoved[formKey];
+        var newControl = __assign(__assign({}, (existingControl
+            ? existingControl
+            : structuredClone(DEFAULT_HUB2_FIELDS))), control);
+        var errors = __assign(__assign({}, newControl.validatorErrors), newControl.asyncValidatorErrors);
+        var selfValid = !hasErrors(errors);
+        var childrenValid = true;
+        if (Array.isArray(control.config.controls)) {
+            // If control is a FormArray
+            childrenValid = control.value.every(function (item, index) {
+                var formKey = getFormKey(control.controlRef.concat(index));
+                var valid = acc[formKey] === undefined ? controlsRemoved[formKey].valid : acc[formKey].valid;
+                return valid;
+            });
+        }
+        else if (control.config.controls) {
+            // If control is a FormGroup
+            childrenValid = Object.keys(control.value).every(function (childKey) {
+                var formKey = getFormKey(control.controlRef.concat(childKey));
+                var valid = acc[formKey] === undefined ? controlsRemoved[formKey].valid : acc[formKey].valid;
+                return valid;
+            });
+        }
+        return __assign(__assign({}, acc), (_a = {}, _a[formKey] = __assign(__assign({}, newControl), { errors: errors, valid: selfValid && childrenValid, childrenValid: childrenValid }), _a));
+    }, {});
+    var orderRestored = reverseObjectKeys(updatedBranch);
+    var result = __assign(__assign({}, controlsRemoved), orderRestored);
+    return result;
+};
+
+var formChange = function (state, _a) {
+    if (state === void 0) { state = null; }
+    var payload = _a.payload;
+    var form = payload.form;
+    if (state === null) {
+        return mergeErrors(Object.entries(form).reduce(function (acc, _a) {
+            var _b;
+            var dictKey = _a[0], baseControl = _a[1];
+            return __assign(__assign({}, acc), (_b = {}, _b[dictKey] = __assign(__assign({}, structuredClone(DEFAULT_HUB2_FIELDS)), baseControl), _b));
+        }, {}));
+    }
+    return mergeControls(state, payload);
+};
+
+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 reducerTools = function (providers) { return ({
+    updateValues: function (state, payload) {
+        return updateValues(state, { payload: payload }, providers, true);
+    },
+    removeControl: function (state, payload) {
+        return removeControl(state, { payload: payload }, providers, true);
+    },
+    pushControl: function (state, payload) {
+        return pushControl(state, { payload: payload }, providers, true);
+    },
+    addControl: function (state, payload) {
+        return addControl(state, { payload: payload }, providers, true);
+    },
+    resetControl: function (state, payload) {
+        return resetControl(state, { payload: payload }, providers, true);
+    },
+    markControlAsPristine: function (state, payload) {
+        return markControlAsPristine(state, { payload: payload }, true);
+    },
+    markControlAsTouched: function (state, payload) {
+        return markControlAsTouched(state, { payload: payload }, true);
+    },
+    markControlAsUntouched: function (state, payload) {
+        return markControlAsUntouched(state, { payload: payload }, true);
+    }
+}); };
+var build = function (config, options) {
+    var _a, _b, _c;
+    if (options === void 0) { options = {}; }
+    var providers = {
+        normalizers: __assign({}, (_a = options.providers) === null || _a === void 0 ? void 0 : _a.normalizers),
+        validators: __assign(__assign({}, Validators), (_b = options.providers) === null || _b === void 0 ? void 0 : _b.validators),
+        asyncValidators: __assign({}, (_c = options.providers) === null || _c === void 0 ? void 0 : _c.asyncValidators)
+    };
+    var initialState = buildFormState(config, undefined, undefined, providers);
+    return createReactable(initialState, options);
+};
+var load = function (state, options) {
+    if (options === void 0) { options = {}; }
+    var baseFormState = {
+        form: Object.entries(state).reduce(function (acc, _a) {
+            var _b;
+            var key = _a[0], control = _a[1];
+            return __assign(__assign({}, acc), (_b = {}, _b[key] = Object.entries(control)
+                .filter(function (_a) {
+                var key = _a[0];
+                return !Object.keys(DEFAULT_HUB2_FIELDS).includes(key);
+            })
+                .reduce(function (acc, _a) {
+                var _b;
+                var key = _a[0], value = _a[1];
+                return (__assign(__assign({}, acc), (_b = {}, _b[key] = value, _b)));
+            }, {}), _b));
+        }, {})
+    };
+    return createReactable(baseFormState, options);
+};
+var createReactable = function (initialBaseState, options, initialFormState) {
+    var _a, _b, _c;
+    if (options === void 0) { options = {}; }
+    var providers = {
+        normalizers: __assign({}, (_a = options.providers) === null || _a === void 0 ? void 0 : _a.normalizers),
+        validators: __assign(__assign({}, Validators), (_b = options.providers) === null || _b === void 0 ? void 0 : _b.validators),
+        asyncValidators: __assign({}, (_c = options.providers) === null || _c === void 0 ? void 0 : _c.asyncValidators)
+    };
+    var reducers = options.reducers, debug = options.debug, name = options.name, otherOptions = __rest(options, ["reducers", "debug", "name"]);
+    var customReducers = Object.entries(reducers || {}).reduce(function (acc, _a) {
+        var _b;
+        var key = _a[0], _case = _a[1];
+        var _reducer = typeof _case === 'function' ? _case : _case.reducer;
+        var effects = typeof _case === 'function' ? [] : _case.effects;
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = {
+            reducer: function (_a, action) {
+                var form = _a.form;
+                return _reducer(reducerTools(providers), { form: form }, action);
+            },
+            effects: effects
+        }, _b));
+    }, {});
+    var _d = core.RxBuilder(__assign({ initialState: initialBaseState, name: "Stage 1 ".concat(name ? name : 'rxForm'), debug: debug, reducers: __assign({ updateValues: function (state, action) {
+                return updateValues(state, action, providers);
+            }, removeControl: function (state, action) { return removeControl(state, action, providers); }, addControl: function (state, action) {
+                return addControl(state, action, providers);
+            }, pushControl: function (state, action) {
+                return pushControl(state, action, providers);
+            }, resetControl: function (state, action) { return resetControl(state, action, providers); }, markControlAsPristine: function (state, action) {
+                return markControlAsPristine(state, action);
+            }, markControlAsTouched: function (state, action) {
+                return markControlAsTouched(state, action);
+            }, markControlAsUntouched: function (state, action) {
+                return markControlAsUntouched(state, action);
+            } }, customReducers) }, otherOptions)), hub1State$ = _d[0], hub1Actions = _d[1], hub1Actions$ = _d[2];
+    var _e = core.RxBuilder({
+        sources: [buildHub2Source(hub1State$, initialBaseState).pipe(operators.skip(0))],
+        initialState: null,
+        name: "Stage 2 ".concat(name ? name : 'rxForm'),
+        debug: debug,
+        reducers: {
+            formChange: formChange,
+            asyncValidationEffect: {
+                reducer: function (state) { return state; },
+                effects: function (control) { return ({
+                    key: control.key,
+                    effects: getScopedEffectsForControl(control, providers)
+                }); }
+            },
+            asyncValidation: asyncValidation,
+            asyncValidationResponse: asyncValidationResponse
+        }
+    }), state$ = _e[0], hub2Actions = _e[1];
+    var destroy = function () {
+        hub1Actions.destroy();
+        hub2Actions.destroy();
+    };
+    return [
+        state$.pipe(operators.filter(function (form) { return form !== null; })),
+        __assign(__assign({}, hub1Actions), { destroy: destroy }),
+        hub1Actions$,
+    ];
+};
+
+var getArrayItems = function (controlRef, form) {
+    var control = getControl(controlRef, form);
+    if (!Array.isArray(control.config.controls)) {
+        throw "".concat(controlRef.join('.'), " is not a Form Array control");
+    }
+    var result = control.value.map(function (_, index) { return form[getFormKey(controlRef.concat(index))]; });
+    return result;
+};
+
+exports.ControlModels = Controls;
+exports.Validators = index;
+exports.array = array;
+exports.build = build;
+exports.control = control;
+exports.getAncestorControls = getAncestorControls;
+exports.getArrayItems = getArrayItems;
+exports.getDescendantControls = getDescendantControls;
+exports.getValueFromControlConfig = getValueFromControlConfig;
+exports.group = group;
+exports.load = load;
+//# sourceMappingURL=index.cjs.map