@eclat/form/bundles/eclat-form.umd.js

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/forms'), require('rxjs'), require('rxjs/operators'), require('@angular/common')) :
    typeof define === 'function' && define.amd ? define('@eclat/form', ['exports', '@angular/core', '@angular/forms', 'rxjs', 'rxjs/operators', '@angular/common'], factory) :
    (global = global || self, factory((global.eclat = global.eclat || {}, global.eclat.form = {}), global.ng.core, global.ng.forms, global.rxjs, global.rxjs.operators, global.ng.common));
}(this, function (exports, core, forms, rxjs, operators, common) { 'use strict';

    /*! *****************************************************************************
    Copyright (c) Microsoft Corporation. All rights reserved.
    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
    this file except in compliance with the License. You may obtain a copy of the
    License at http://www.apache.org/licenses/LICENSE-2.0

    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
    MERCHANTABLITY OR NON-INFRINGEMENT.

    See the Apache Version 2.0 License for specific language governing permissions
    and limitations under the License.
    ***************************************************************************** */
    /* global Reflect, Promise */

    var extendStatics = function(d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };

    function __extends(d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    }

    function __read(o, n) {
        var m = typeof Symbol === "function" && o[Symbol.iterator];
        if (!m) return o;
        var i = m.call(o), r, ar = [], e;
        try {
            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
        }
        catch (error) { e = { error: error }; }
        finally {
            try {
                if (r && !r.done && (m = i["return"])) m.call(i);
            }
            finally { if (e) throw e.error; }
        }
        return ar;
    }

    function __spread() {
        for (var ar = [], i = 0; i < arguments.length; i++)
            ar = ar.concat(__read(arguments[i]));
        return ar;
    }

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var EclatRecursiveConfig = /** @class */ (function () {
        function EclatRecursiveConfig() {
        }
        return EclatRecursiveConfig;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */

    (function (EclatFormUtility) {
        /**
         * @template T
         * @param {?} eclatForm
         * @return {?}
         */
        function isEclatFormControlConfig(eclatForm) {
            if (Array.isArray(eclatForm)) {
                return true;
            }
            return false;
        }
        EclatFormUtility.isEclatFormControlConfig = isEclatFormControlConfig;
        /**
         * @template T
         * @param {?} eclatForm
         * @return {?}
         */
        function isEclatFormGroupConfig(eclatForm) {
            if (((/** @type {?} */ (eclatForm))).controlsRules) {
                return true;
            }
            return false;
        }
        EclatFormUtility.isEclatFormGroupConfig = isEclatFormGroupConfig;
        /**
         * @template T
         * @param {?} eclatForm
         * @return {?}
         */
        function isEclatFormArrayConfig(eclatForm) {
            if (((/** @type {?} */ (eclatForm))).controlConfig) {
                return true;
            }
            return false;
        }
        EclatFormUtility.isEclatFormArrayConfig = isEclatFormArrayConfig;
        /**
         * @template T
         * @param {?} data
         * @return {?}
         */
        function eclatRecursiveTransformer(data) {
            /** @type {?} */
            var path = recursivePathFinder(data);
            if (!path) {
                throw Error();
            }
            /** @type {?} */
            var paths = path.split('.');
            /** @type {?} */
            var latestPath = (/** @type {?} */ (paths.pop()));
            paths.reduce((/**
             * @param {?} acc
             * @param {?} cur
             * @return {?}
             */
            function (acc, cur) {
                return acc[cur];
            }), (/** @type {?} */ (data)))[latestPath] = data;
            return (/** @type {?} */ (data));
        }
        EclatFormUtility.eclatRecursiveTransformer = eclatRecursiveTransformer;
    })(exports.EclatFormUtility || (exports.EclatFormUtility = {}));
    /**
     * @param {?} data
     * @param {?=} path
     * @return {?}
     */
    function recursivePathFinder(data, path) {
        if (path === void 0) { path = null; }
        if (data instanceof EclatRecursiveConfig) {
            return '';
        }
        if (Array.isArray(data)) {
            /** @type {?} */
            var found_1 = null;
            data.some((/**
             * @param {?} value
             * @param {?} key
             * @return {?}
             */
            function (value, key) {
                /** @type {?} */
                var temp = recursivePathFinder(value, path);
                if (temp !== null) {
                    if (temp) {
                        found_1 = key + '.' + temp;
                    }
                    else {
                        found_1 = key.toString();
                    }
                }
                return !!found_1;
            }));
            return found_1;
        }
        if (data === Object(data)) {
            /** @type {?} */
            var found_2 = null;
            Object.entries(data).some((/**
             * @param {?} __0
             * @return {?}
             */
            function (_a) {
                var _b = __read(_a, 2), key = _b[0], value = _b[1];
                /** @type {?} */
                var temp = recursivePathFinder(value, path);
                if (temp !== null) {
                    if (temp) {
                        found_2 = key + '.' + temp;
                    }
                    else {
                        found_2 = key;
                    }
                }
                return !!found_2;
            }));
            return found_2;
        }
        return null;
    }

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /**
     * @abstract
     * @template T, C
     */
    var   /**
     * @abstract
     * @template T, C
     */
    AbstractEclatFormControl = /** @class */ (function () {
        function AbstractEclatFormControl(rules) {
            /** @type {?} */
            var validators = [];
            /** @type {?} */
            var asyncValidators = [];
            /** @type {?} */
            var errorMapping = {};
            if (rules) {
                rules.forEach((/**
                 * @param {?} __0
                 * @return {?}
                 */
                function (_a) {
                    var validator = _a.validator, asyncValidator = _a.asyncValidator, key = _a.key, message = _a.message;
                    errorMapping[key] = message;
                    if (validator) {
                        validators.push(validator);
                    }
                    if (asyncValidator) {
                        asyncValidators.push(asyncValidator);
                    }
                }));
            }
            this.rules = errorMapping;
            this.validators = validators;
            this.asyncValidators = asyncValidators;
        }
        Object.defineProperty(AbstractEclatFormControl.prototype, "errorMessages", {
            get: /**
             * @return {?}
             */
            function () {
                var _this = this;
                if (!this.control.errors) {
                    return [];
                }
                return Object.entries(this.control.errors).reduce((/**
                 * @param {?} acc
                 * @param {?} __1
                 * @return {?}
                 */
                function (acc, _a) {
                    var _b = __read(_a, 2), key = _b[0], value = _b[1];
                    if (value) {
                        /** @type {?} */
                        var temp = _this.rules[key];
                        /** @type {?} */
                        var errors = typeof temp === 'function' ? temp(_this) : temp;
                        if (Array.isArray(errors)) {
                            acc.push.apply(acc, __spread(errors));
                        }
                        else {
                            acc.push(errors);
                        }
                    }
                    return acc;
                }), (/** @type {?} */ ([])));
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(AbstractEclatFormControl.prototype, "value", {
            get: /**
             * @return {?}
             */
            function () {
                return this.control.value;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(AbstractEclatFormControl.prototype, "valid", {
            get: /**
             * @return {?}
             */
            function () {
                return this.control.valid;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(AbstractEclatFormControl.prototype, "valueChanges", {
            get: /**
             * @return {?}
             */
            function () {
                return this.control.valueChanges;
            },
            enumerable: true,
            configurable: true
        });
        /**
         * @param {?=} isDisabled
         * @param {?=} opts
         * @return {?}
         */
        AbstractEclatFormControl.prototype.disable = /**
         * @param {?=} isDisabled
         * @param {?=} opts
         * @return {?}
         */
        function (isDisabled, opts) {
            if (isDisabled === void 0) { isDisabled = true; }
            if (isDisabled) {
                this.control.disable(opts);
            }
            else {
                this.control.enable(opts);
            }
        };
        return AbstractEclatFormControl;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /**
     * @param {?} config
     * @param {?=} data
     * @return {?}
     */
    function getEclatControl(config, data) {
        if (exports.EclatFormUtility.isEclatFormControlConfig(config)) {
            return new EclatFormControl(config, data);
        }
        if (exports.EclatFormUtility.isEclatFormGroupConfig(config)) {
            return new EclatFormGroup(config, data);
        }
        if (exports.EclatFormUtility.isEclatFormArrayConfig(config)) {
            return new EclatFormArray(config, data);
        }
        return null;
    }
    /**
     * @template T
     */
    var   /**
     * @template T
     */
    EclatFormControl = /** @class */ (function (_super) {
        __extends(EclatFormControl, _super);
        function EclatFormControl(config, initialData) {
            var _this = _super.call(this, config) || this;
            _this.control = new forms.FormControl(null, _this.validators, _this.asyncValidators);
            if (initialData) {
                _this.resetState(initialData);
            }
            return _this;
        }
        /**
         * @param {?} data
         * @param {?=} emitEvent
         * @return {?}
         */
        EclatFormControl.prototype.patchState = /**
         * @param {?} data
         * @param {?=} emitEvent
         * @return {?}
         */
        function (data, emitEvent) {
            if (emitEvent === void 0) { emitEvent = true; }
            this.control.patchValue(data, { emitEvent: emitEvent });
        };
        /**
         * @param {?} data
         * @param {?=} emitEvent
         * @return {?}
         */
        EclatFormControl.prototype.resetState = /**
         * @param {?} data
         * @param {?=} emitEvent
         * @return {?}
         */
        function (data, emitEvent) {
            if (emitEvent === void 0) { emitEvent = true; }
            this.control.reset(data, { emitEvent: emitEvent });
        };
        return EclatFormControl;
    }(AbstractEclatFormControl));
    /**
     * @template T
     */
    var   /**
     * @template T
     */
    EclatFormGroup = /** @class */ (function (_super) {
        __extends(EclatFormGroup, _super);
        function EclatFormGroup(dfg, initialData) {
            var _this = _super.call(this, dfg.rules) || this;
            /** @type {?} */
            var children = {};
            /** @type {?} */
            var controls = {};
            Object.keys(dfg.controlsRules).forEach((/**
             * @param {?} key
             * @return {?}
             */
            function (key) {
                /** @type {?} */
                var value = dfg.controlsRules[(/** @type {?} */ (key))];
                /** @type {?} */
                var eclatControl = getEclatControl(value);
                if (eclatControl) {
                    children[key] = eclatControl;
                    controls[key] = eclatControl.control;
                }
            }));
            _this.control = new forms.FormGroup(controls, _this.validators, _this.asyncValidators);
            _this.children = children;
            if (initialData) {
                _this.resetState(initialData);
            }
            return _this;
        }
        /**
         * @param {?} data
         * @param {?=} emitEvent
         * @return {?}
         */
        EclatFormGroup.prototype.patchState = /**
         * @param {?} data
         * @param {?=} emitEvent
         * @return {?}
         */
        function (data, emitEvent) {
            var _this = this;
            if (emitEvent === void 0) { emitEvent = true; }
            if (!data) {
                console.warn("Expect an object, but " + data + " is given");
                return;
            }
            Object.entries(data).forEach((/**
             * @param {?} __0
             * @return {?}
             */
            function (_a) {
                var _b = __read(_a, 2), key = _b[0], value = _b[1];
                if (_this.children[(/** @type {?} */ (key))]) {
                    _this.children[(/** @type {?} */ (key))].patchState(value, false);
                }
            }));
            this.control.patchValue({}, { emitEvent: emitEvent });
        };
        /**
         * @param {?} data
         * @param {?=} emitEvent
         * @return {?}
         */
        EclatFormGroup.prototype.resetState = /**
         * @param {?} data
         * @param {?=} emitEvent
         * @return {?}
         */
        function (data, emitEvent) {
            var _this = this;
            if (emitEvent === void 0) { emitEvent = true; }
            if (!data) {
                console.warn("Expect an object, but " + data + " is given");
                return;
            }
            Object.entries(data).forEach((/**
             * @param {?} __0
             * @return {?}
             */
            function (_a) {
                var _b = __read(_a, 2), key = _b[0], value = _b[1];
                if (_this.children[(/** @type {?} */ (key))]) {
                    _this.children[(/** @type {?} */ (key))].resetState(value, false);
                }
            }));
            this.control.reset(undefined, { emitEvent: emitEvent });
        };
        /**
         * @template P
         * @param {?} key
         * @return {?}
         */
        EclatFormGroup.prototype.getChild = /**
         * @template P
         * @param {?} key
         * @return {?}
         */
        function (key) {
            return this.children[key];
        };
        /**
         * @private
         * @param {?} key
         * @param {?} config
         * @param {?} data
         * @return {?}
         */
        EclatFormGroup.prototype.addChild = /**
         * @private
         * @param {?} key
         * @param {?} config
         * @param {?} data
         * @return {?}
         */
        function (key, config, data) {
            /** @type {?} */
            var eclatControl = getEclatControl(config);
            if (eclatControl) {
                eclatControl.resetState(data);
                this.children[key] = (/** @type {?} */ (eclatControl));
                this.control.addControl(key, this.children[key].control);
            }
        };
        /**
         * @private
         * @param {?} key
         * @return {?}
         */
        EclatFormGroup.prototype.removeChild = /**
         * @private
         * @param {?} key
         * @return {?}
         */
        function (key) {
            delete this.children[key];
            this.control.removeControl(key);
        };
        return EclatFormGroup;
    }(AbstractEclatFormControl));
    /**
     * @template T
     */
    var   /**
     * @template T
     */
    EclatFormArray = /** @class */ (function (_super) {
        __extends(EclatFormArray, _super);
        function EclatFormArray(dfa, initialData) {
            var _this = _super.call(this, dfa.rules) || this;
            _this.control = new forms.FormArray([], _this.validators, _this.asyncValidators);
            _this.childConfig = dfa.controlConfig;
            _this.children = [];
            if (initialData) {
                _this.resetState(initialData);
            }
            return _this;
        }
        /**
         * @param {?=} data
         * @return {?}
         */
        EclatFormArray.prototype.addChild = /**
         * @param {?=} data
         * @return {?}
         */
        function (data) {
            /** @type {?} */
            var eclatControl = getEclatControl(this.childConfig);
            if (eclatControl) {
                eclatControl.resetState(data);
                this.children.push((/** @type {?} */ (eclatControl)));
                this.control.push(eclatControl.control);
            }
        };
        /**
         * @param {?} index
         * @return {?}
         */
        EclatFormArray.prototype.removeChild = /**
         * @param {?} index
         * @return {?}
         */
        function (index) {
            this.children.splice(index, 1);
            this.control.removeAt(index);
        };
        /**
         * @param {?} data
         * @param {?=} emitEvent
         * @return {?}
         */
        EclatFormArray.prototype.patchState = /**
         * @param {?} data
         * @param {?=} emitEvent
         * @return {?}
         */
        function (data, emitEvent) {
            var _this = this;
            if (emitEvent === void 0) { emitEvent = true; }
            if (!data) {
                console.warn("Expect an array, but " + data + " is given");
                return;
            }
            this.control.controls = [];
            this.children = [];
            data.forEach((/**
             * @param {?} d
             * @return {?}
             */
            function (d) {
                /** @type {?} */
                var eclatControl = getEclatControl(_this.childConfig);
                if (eclatControl) {
                    eclatControl.patchState(d, false);
                    _this.children.push((/** @type {?} */ (eclatControl)));
                    _this.control.push(eclatControl.control);
                }
            }));
            this.control.patchValue([], { emitEvent: emitEvent });
        };
        /**
         * @param {?} data
         * @param {?=} emitEvent
         * @return {?}
         */
        EclatFormArray.prototype.resetState = /**
         * @param {?} data
         * @param {?=} emitEvent
         * @return {?}
         */
        function (data, emitEvent) {
            var _this = this;
            if (emitEvent === void 0) { emitEvent = true; }
            if (!data) {
                console.warn("Expect an array, but " + data + " is given");
                return;
            }
            this.control.controls = [];
            this.children = [];
            data.forEach((/**
             * @param {?} d
             * @return {?}
             */
            function (d) {
                /** @type {?} */
                var eclatControl = getEclatControl(_this.childConfig);
                if (eclatControl) {
                    eclatControl.resetState(d, false);
                    _this.children.push((/** @type {?} */ (eclatControl)));
                    _this.control.push(eclatControl.control);
                }
            }));
            this.control.reset(undefined, { emitEvent: emitEvent });
        };
        /**
         * @param {?} index
         * @return {?}
         */
        EclatFormArray.prototype.getChild = /**
         * @param {?} index
         * @return {?}
         */
        function (index) {
            return this.children[index];
        };
        return EclatFormArray;
    }(AbstractEclatFormControl));

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /**
     * @template T
     */
    var   /**
     * @template T
     */
    EclatFormContext = /** @class */ (function () {
        function EclatFormContext($implicit) {
            this.$implicit = $implicit;
        }
        return EclatFormContext;
    }());
    /**
     * @template T
     */
    var EclatFormOfDirective = /** @class */ (function () {
        function EclatFormOfDirective(templateRef, viewContainer) {
            this.templateRef = templateRef;
            this.viewContainer = viewContainer;
        }
        Object.defineProperty(EclatFormOfDirective.prototype, "eclatFormOf", {
            set: /**
             * @param {?} state
             * @return {?}
             */
            function (state) {
                if (!this.context || !this.latestState || this.latestState.config !== state.config) {
                    this.setContext(getEclatControl(state.config, state.data));
                }
                else if (this.latestState.data !== state.data) {
                    this.context.$implicit.resetState(state.data);
                }
                this.latestState = state;
            },
            enumerable: true,
            configurable: true
        });
        /**
         * @private
         * @param {?=} control
         * @return {?}
         */
        EclatFormOfDirective.prototype.setContext = /**
         * @private
         * @param {?=} control
         * @return {?}
         */
        function (control) {
            if (!control) {
                throw new Error('control not found');
            }
            if (!this.context) {
                this.context = new EclatFormContext(control);
                this.viewContainer.createEmbeddedView(this.templateRef, this.context);
            }
            else {
                this.context.$implicit = control;
            }
        };
        EclatFormOfDirective.decorators = [
            { type: core.Directive, args: [{ selector: '[eclatForm][eclatFormOf]' },] }
        ];
        /** @nocollapse */
        EclatFormOfDirective.ctorParameters = function () { return [
            { type: core.TemplateRef },
            { type: core.ViewContainerRef }
        ]; };
        EclatFormOfDirective.propDecorators = {
            eclatFormOf: [{ type: core.Input }]
        };
        return EclatFormOfDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /**
     * @abstract
     * @template T
     */
    var EclatFormContainerDirective = /** @class */ (function () {
        function EclatFormContainerDirective() {
            this._formControl = new rxjs.BehaviorSubject(undefined);
            this.onSubmit = new core.EventEmitter();
        }
        Object.defineProperty(EclatFormContainerDirective.prototype, "formControl", {
            get: /**
             * @return {?}
             */
            function () {
                return this._formControl.getValue();
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(EclatFormContainerDirective.prototype, "formControl$", {
            get: /**
             * @return {?}
             */
            function () {
                return this._formControl.asObservable();
            },
            enumerable: true,
            configurable: true
        });
        /**
         * @return {?}
         */
        EclatFormContainerDirective.prototype.submit = /**
         * @return {?}
         */
        function () {
            if (this.formControl) {
                this.onSubmit.emit(this.formControl.value);
            }
        };
        EclatFormContainerDirective.propDecorators = {
            onSubmit: [{ type: core.Output }]
        };
        return EclatFormContainerDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /**
     * @template T
     */
    var /**
     * @template T
     */
    EclatFormErrorContext = /** @class */ (function () {
        function EclatFormErrorContext(control) {
            this.control = control;
        }
        Object.defineProperty(EclatFormErrorContext.prototype, "$implicit", {
            get: /**
             * @return {?}
             */
            function () {
                return this.control.errorMessages;
            },
            enumerable: true,
            configurable: true
        });
        return EclatFormErrorContext;
    }());
    /**
     * @template T
     */
    var EclatFormErrorDirective = /** @class */ (function () {
        function EclatFormErrorDirective(templateRef, viewContainer, parent) {
            this.templateRef = templateRef;
            this.viewContainer = viewContainer;
            this.parent = parent;
            this.onDestroy$ = new rxjs.Subject();
            this.errorMatcher = (/**
             * @return {?}
             */
            function () { return true; });
        }
        Object.defineProperty(EclatFormErrorDirective.prototype, "eclatControl", {
            set: /**
             * @param {?} control
             * @return {?}
             */
            function (control) {
                this.setContext(control);
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(EclatFormErrorDirective.prototype, "eclatControlName", {
            set: /**
             * @param {?} controlName
             * @return {?}
             */
            function (controlName) {
                if (!this.parent.formControl) {
                    throw new Error('parent formControl not exist');
                }
                /** @type {?} */
                var instance = !controlName ? this.parent.formControl : this.parent.formControl.getChild(controlName);
                if (!instance) {
                    throw new Error('control not found');
                    return;
                }
                this.latestControlName = controlName;
                this.setContext(instance);
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(EclatFormErrorDirective.prototype, "eclatFormError", {
            set: /**
             * @param {?} control
             * @return {?}
             */
            function (control) {
                if (control instanceof AbstractEclatFormControl) {
                    this.setContext(control);
                }
                else {
                    this.eclatControlName = control;
                }
            },
            enumerable: true,
            configurable: true
        });
        /**
         * @return {?}
         */
        EclatFormErrorDirective.prototype.ngOnInit = /**
         * @return {?}
         */
        function () {
            var _this = this;
            this.parent.formControl$.pipe(operators.takeUntil(this.onDestroy$)).subscribe((/**
             * @param {?} formControl
             * @return {?}
             */
            function (formControl) {
                if (formControl && _this.latestControlName) {
                    _this.eclatFormError = formControl.getChild(_this.latestControlName);
                }
            }));
        };
        /**
         * @return {?}
         */
        EclatFormErrorDirective.prototype.ngOnDestroy = /**
         * @return {?}
         */
        function () {
            this.onDestroy$.next();
        };
        /**
         * @private
         * @param {?} control
         * @return {?}
         */
        EclatFormErrorDirective.prototype.setContext = /**
         * @private
         * @param {?} control
         * @return {?}
         */
        function (control) {
            var _this = this;
            if (!this.context) {
                this.context = new EclatFormErrorContext(control);
                this.viewContainer.createEmbeddedView(this.templateRef, this.context);
            }
            else if (this.context.control !== control) {
                this.context.control = control;
            }
            if (this.valueChangesSub) {
                this.valueChangesSub.unsubscribe();
            }
            this.checkValidity(control);
            this.valueChangesSub = control.valueChanges.pipe(operators.takeUntil(this.onDestroy$)).subscribe((/**
             * @return {?}
             */
            function () {
                _this.checkValidity(control);
            }));
        };
        /**
         * @private
         * @param {?} control
         * @return {?}
         */
        EclatFormErrorDirective.prototype.checkValidity = /**
         * @private
         * @param {?} control
         * @return {?}
         */
        function (control) {
            /** @type {?} */
            var isAttached = !!this.viewContainer.length;
            if (!control.valid && this.errorMatcher(control)) {
                if (!isAttached) {
                    this.viewContainer.createEmbeddedView(this.templateRef, this.context);
                }
            }
            else {
                if (isAttached) {
                    this.viewContainer.remove();
                }
            }
        };
        EclatFormErrorDirective.decorators = [
            { type: core.Directive, args: [{ selector: '[eclatFormError]' },] }
        ];
        /** @nocollapse */
        EclatFormErrorDirective.ctorParameters = function () { return [
            { type: core.TemplateRef },
            { type: core.ViewContainerRef },
            { type: EclatFormContainerDirective }
        ]; };
        EclatFormErrorDirective.propDecorators = {
            errorMatcher: [{ type: core.Input }],
            eclatControl: [{ type: core.Input }],
            eclatControlName: [{ type: core.Input }],
            eclatFormError: [{ type: core.Input }]
        };
        return EclatFormErrorDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /**
     * @template T
     */
    var EclatFormGroupDirective = /** @class */ (function (_super) {
        __extends(EclatFormGroupDirective, _super);
        function EclatFormGroupDirective() {
            return _super.call(this) || this;
        }
        Object.defineProperty(EclatFormGroupDirective.prototype, "eclatFormGroup", {
            set: /**
             * @param {?} formGroup
             * @return {?}
             */
            function (formGroup) {
                this._formControl.next(formGroup);
            },
            enumerable: true,
            configurable: true
        });
        /**
         * @param {?} key
         * @return {?}
         */
        EclatFormGroupDirective.prototype.getChild = /**
         * @param {?} key
         * @return {?}
         */
        function (key) {
            if (this.formControl) {
                return this.formControl.getChild(key);
            }
            return undefined;
        };
        EclatFormGroupDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[eclatFormGroup]',
                        providers: [{
                                provide: EclatFormContainerDirective,
                                useExisting: core.forwardRef((/**
                                 * @return {?}
                                 */
                                function () { return EclatFormGroupDirective; })),
                            }],
                    },] }
        ];
        /** @nocollapse */
        EclatFormGroupDirective.ctorParameters = function () { return []; };
        EclatFormGroupDirective.propDecorators = {
            eclatFormGroup: [{ type: core.Input }]
        };
        return EclatFormGroupDirective;
    }(EclatFormContainerDirective));

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /**
     * @template T
     */
    var EclatFormGroupNameDirective = /** @class */ (function (_super) {
        __extends(EclatFormGroupNameDirective, _super);
        function EclatFormGroupNameDirective(parent) {
            var _this = _super.call(this) || this;
            _this.parent = parent;
            _this.onDestroy$ = new rxjs.Subject();
            return _this;
        }
        Object.defineProperty(EclatFormGroupNameDirective.prototype, "eclatFormGroupName", {
            set: /**
             * @param {?} name
             * @return {?}
             */
            function (name) {
                this.latestName = name;
                this._formControl.next((/** @type {?} */ (this.parent.getChild(name))));
            },
            enumerable: true,
            configurable: true
        });
        /**
         * @return {?}
         */
        EclatFormGroupNameDirective.prototype.ngOnDestroy = /**
         * @return {?}
         */
        function () {
            this.onDestroy$.next();
        };
        /**
         * @return {?}
         */
        EclatFormGroupNameDirective.prototype.ngOnInit = /**
         * @return {?}
         */
        function () {
            var _this = this;
            this.parent.formControl$.pipe(operators.takeUntil(this.onDestroy$)).subscribe((/**
             * @return {?}
             */
            function () {
                _this.eclatFormGroupName = _this.latestName;
            }));
        };
        /**
         * @param {?} key
         * @return {?}
         */
        EclatFormGroupNameDirective.prototype.getChild = /**
         * @param {?} key
         * @return {?}
         */
        function (key) {
            if (this.formControl) {
                return this.formControl.getChild(key);
            }
            return undefined;
        };
        EclatFormGroupNameDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[eclatFormGroupName]',
                        providers: [{
                                provide: EclatFormContainerDirective,
                                useExisting: core.forwardRef((/**
                                 * @return {?}
                                 */
                                function () { return EclatFormGroupNameDirective; })),
                            }],
                    },] }
        ];
        /** @nocollapse */
        EclatFormGroupNameDirective.ctorParameters = function () { return [
            { type: EclatFormContainerDirective, decorators: [{ type: core.SkipSelf }] }
        ]; };
        EclatFormGroupNameDirective.propDecorators = {
            eclatFormGroupName: [{ type: core.Input }]
        };
        return EclatFormGroupNameDirective;
    }(EclatFormContainerDirective));

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /**
     * @template T
     */
    var EclatFormArrayNameDirective = /** @class */ (function (_super) {
        __extends(EclatFormArrayNameDirective, _super);
        function EclatFormArrayNameDirective(parent) {
            var _this = _super.call(this) || this;
            _this.parent = parent;
            _this.onDestroy$ = new rxjs.Subject();
            return _this;
        }
        Object.defineProperty(EclatFormArrayNameDirective.prototype, "eclatFormArrayName", {
            set: /**
             * @param {?} name
             * @return {?}
             */
            function (name) {
                this.latestName = name;
                this._formControl.next((/** @type {?} */ (this.parent.getChild(name))));
            },
            enumerable: true,
            configurable: true
        });
        /**
         * @return {?}
         */
        EclatFormArrayNameDirective.prototype.ngOnDestroy = /**
         * @return {?}
         */
        function () {
            this.onDestroy$.next();
        };
        /**
         * @return {?}
         */
        EclatFormArrayNameDirective.prototype.ngOnInit = /**
         * @return {?}
         */
        function () {
            var _this = this;
            this.parent.formControl$.pipe(operators.takeUntil(this.onDestroy$)).subscribe((/**
             * @return {?}
             */
            function () {
                _this.eclatFormArrayName = _this.latestName;
            }));
        };
        /**
         * @param {?} key
         * @return {?}
         */
        EclatFormArrayNameDirective.prototype.getChild = /**
         * @param {?} key
         * @return {?}
         */
        function (key) {
            if (this.formControl) {
                return this.formControl.getChild(key);
            }
            return undefined;
        };
        EclatFormArrayNameDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[eclatFormArrayName]',
                        providers: [{
                                provide: EclatFormContainerDirective,
                                useExisting: core.forwardRef((/**
                                 * @return {?}
                                 */
                                function () { return EclatFormArrayNameDirective; })),
                            }],
                    },] }
        ];
        /** @nocollapse */
        EclatFormArrayNameDirective.ctorParameters = function () { return [
            { type: EclatFormContainerDirective, decorators: [{ type: core.SkipSelf }] }
        ]; };
        EclatFormArrayNameDirective.propDecorators = {
            eclatFormArrayName: [{ type: core.Input }]
        };
        return EclatFormArrayNameDirective;
    }(EclatFormContainerDirective));

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /**
     * @template T
     */
    var EclatFormArrayDirective = /** @class */ (function (_super) {
        __extends(EclatFormArrayDirective, _super);
        function EclatFormArrayDirective() {
            return _super.call(this) || this;
        }
        Object.defineProperty(EclatFormArrayDirective.prototype, "eclatFormArray", {
            set: /**
             * @param {?} formArray
             * @return {?}
             */
            function (formArray) {
                this._formControl.next(formArray);
            },
            enumerable: true,
            configurable: true
        });
        /**
         * @param {?} key
         * @return {?}
         */
        EclatFormArrayDirective.prototype.getChild = /**
         * @param {?} key
         * @return {?}
         */
        function (key) {
            if (this.formControl) {
                return this.formControl.getChild(key);
            }
            return undefined;
        };
        EclatFormArrayDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[eclatFormArray]',
                        providers: [{
                                provide: EclatFormContainerDirective,
                                useExisting: core.forwardRef((/**
                                 * @return {?}
                                 */
                                function () { return EclatFormArrayDirective; })),
                            }],
                    },] }
        ];
        /** @nocollapse */
        EclatFormArrayDirective.ctorParameters = function () { return []; };
        EclatFormArrayDirective.propDecorators = {
            eclatFormArray: [{ type: core.Input }]
        };
        return EclatFormArrayDirective;
    }(EclatFormContainerDirective));

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /**
     * @template T
     */
    var EclatFormArrayChildrenDirective = /** @class */ (function () {
        function EclatFormArrayChildrenDirective(templateRef, viewContainer, parent) {
            this.templateRef = templateRef;
            this.viewContainer = viewContainer;
            this.parent = parent;
            this.onDestroy$ = new rxjs.Subject();
            this.latestChildren = [];
        }
        /**
         * @return {?}
         */
        EclatFormArrayChildrenDirective.prototype.ngOnDestroy = /**
         * @return {?}
         */
        function () {
            this.onDestroy$.next();
        };
        /**
         * @return {?}
         */
        EclatFormArrayChildrenDirective.prototype.ngOnInit = /**
         * @return {?}
         */
        function () {
            var _this = this;
            this.parent.formControl$.pipe(operators.takeUntil(this.onDestroy$)).subscribe((/**
             * @param {?} formControl
             * @return {?}
             */
            function (formControl) {
                if (formControl) {
                    if (_this.valueChangeSubs) {
                        _this.valueChangeSubs.unsubscribe();
                    }
                    _this.onChange(formControl);
                    _this.valueChangeSubs = formControl.valueChanges.pipe(operators.takeUntil(_this.onDestroy$)).subscribe((/**
                     * @return {?}
                     */
                    function () {
                        _this.onChange(formControl);
                    }));
                }
            }));
        };
        /**
         * @private
         * @param {?} control
         * @return {?}
         */
        EclatFormArrayChildrenDirective.prototype.onChange = /**
         * @private
         * @param {?} control
         * @return {?}
         */
        function (control) {
            var _this = this;
            /** @type {?} */
            var children = [];
            /** @type {?} */
            var controlChildrenLength = control.children.length;
            control.children.forEach((/**
             * @param {?} c
             * @param {?} index
             * @return {?}
             */
            function (c, index) {
                /** @type {?} */
                var lastIndex = _this.latestChildren.findIndex((/**
                 * @param {?} o
                 * @return {?}
                 */
                function (o) { return o === c; }));
                /** @type {?} */
                var first = index === 0;
                /** @type {?} */
                var last = index === (controlChildrenLength - 1);
                if (lastIndex < 0) {
                    _this.viewContainer.createEmbeddedView(_this.templateRef, { $implicit: index, last: last, first: first }, index);
                }
                else if (lastIndex !== index) {
                    /** @type {?} */
                    var embeddedView = (/** @type {?} */ ((/** @type {?} */ (_this.viewContainer.get(lastIndex)))));
                    embeddedView.context.$implicit = index;
                    embeddedView.context.last = last;
                    embeddedView.context.first = first;
                    _this.viewContainer.move(embeddedView, index);
                }
                children.push(c);
            }));
            while (this.viewContainer.length > controlChildrenLength) {
                this.viewContainer.remove();
            }
            this.latestChildren = children;
        };
        EclatFormArrayChildrenDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[eclatFormArrayChildren]',
                    },] }
        ];
        /** @nocollapse */
        EclatFormArrayChildrenDirective.ctorParameters = function () { return [
            { type: core.TemplateRef },
            { type: core.ViewContainerRef },
            { type: EclatFormContainerDirective }
        ]; };
        return EclatFormArrayChildrenDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var EclatFormSubmitDirective = /** @class */ (function () {
        function EclatFormSubmitDirective(parent) {
            this.parent = parent;
        }
        /**
         * @return {?}
         */
        EclatFormSubmitDirective.prototype.onClick = /**
         * @return {?}
         */
        function () {
            this.parent.submit();
        };
        EclatFormSubmitDirective.decorators = [
            { type: core.Directive, args: [{ selector: '[eclatFormSubmit]' },] }
        ];
        /** @nocollapse */
        EclatFormSubmitDirective.ctorParameters = function () { return [
            { type: EclatFormContainerDirective }
        ]; };
        EclatFormSubmitDirective.propDecorators = {
            onClick: [{ type: core.HostListener, args: ['click', ['$event'],] }, { type: core.HostListener, args: ['tap', ['$event'],] }]
        };
        return EclatFormSubmitDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /**
     * @template T
     */
    var EclatFormArrayAddDirective = /** @class */ (function () {
        function EclatFormArrayAddDirective(parent) {
            this.parent = parent;
        }
        /**
         * @return {?}
         */
        EclatFormArrayAddDirective.prototype.onClick = /**
         * @return {?}
         */
        function () {
            /** @type {?} */
            var control = this.parent.formControl;
            if (control) {
                control.addChild(this.value);
            }
        };
        EclatFormArrayAddDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[eclatFormAddChildren]',
                    },] }
        ];
        /** @nocollapse */
        EclatFormArrayAddDirective.ctorParameters = function () { return [
            { type: EclatFormContainerDirective }
        ]; };
        EclatFormArrayAddDirective.propDecorators = {
            value: [{ type: core.Input, args: ['eclatFormAddChildren',] }],
            onClick: [{ type: core.HostListener, args: ['click', ['$event'],] }]
        };
        return EclatFormArrayAddDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /**
     * @template T
     */
    var /**
     * @template T
     */
    EclatFormValueContext = /** @class */ (function () {
        function EclatFormValueContext(control) {
            this.control = control;
        }
        Object.defineProperty(EclatFormValueContext.prototype, "$implicit", {
            get: /**
             * @return {?}
             */
            function () {
                return this.control.value;
            },
            enumerable: true,
            configurable: true
        });
        return EclatFormValueContext;
    }());
    /**
     * @template T
     */
    var EclatFormValueDirective = /** @class */ (function () {
        function EclatFormValueDirective(templateRef, viewContainer, parent) {
            this.templateRef = templateRef;
            this.viewContainer = viewContainer;
            this.parent = parent;
            this.onDestroy$ = new rxjs.Subject();
        }
        Object.defineProperty(EclatFormValueDirective.prototype, "eclatControl", {
            set: /**
             * @param {?} control
             * @return {?}
             */
            function (control) {
                this.setContext(control);
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(EclatFormValueDirective.prototype, "eclatControlName", {
            set: /**
             * @param {?} controlName
             * @return {?}
             */
            function (controlName) {
                if (!this.parent.formControl) {
                    throw new Error('parent formControl not exist');
                }
                /** @type {?} */
                var instance = this.parent.formControl.getChild(controlName);
                if (!instance) {
                    throw new Error('control not found');
                    return;
                }
                this.latestControlName = controlName;
                this.setContext(instance);
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(EclatFormValueDirective.prototype, "eclatFormValue", {
            set: /**
             * @param {?} control
             * @return {?}
             */
            function (control) {
                if (control instanceof AbstractEclatFormControl) {
                    this.setContext(control);
                }
                else if (control || control === 0) {
                    this.eclatControlName = control;
                }
            },
            enumerable: true,
            configurable: true
        });
        /**
         * @return {?}
         */
        EclatFormValueDirective.prototype.ngOnInit = /**
         * @return {?}
         */
        function () {
            var _this = this;
            this.parent.formControl$.pipe(operators.takeUntil(this.onDestroy$)).subscribe((/**
             * @param {?} formControl
             * @return {?}
             */
            function (formControl) {
                if (formControl && _this.latestControlName) {
                    _this.eclatFormValue = formControl.getChild(_this.latestControlName);
                }
            }));
        };
        /**
         * @return {?}
         */
        EclatFormValueDirective.prototype.ngOnDestroy = /**
         * @return {?}
         */
        function () {
            this.onDestroy$.next();
        };
        /**
         * @private
         * @param {?} control
         * @return {?}
         */
        EclatFormValueDirective.prototype.setContext = /**
         * @private
         * @param {?} control
         * @return {?}
         */
        function (control) {
            if (!this.context) {
                this.context = new EclatFormValueContext(control);
                this.viewContainer.createEmbeddedView(this.templateRef, this.context);
            }
            else if (this.context.control !== control) {
                this.context.control = control;
            }
        };
        EclatFormValueDirective.decorators = [
            { type: core.Directive, args: [{ selector: '[eclatFormValue]' },] }
        ];
        /** @nocollapse */
        EclatFormValueDirective.ctorParameters = function () { return [
            { type: core.TemplateRef },
            { type: core.ViewContainerRef },
            { type: EclatFormContainerDirective }
        ]; };
        EclatFormValueDirective.propDecorators = {
            eclatControl: [{ type: core.Input }],
            eclatControlName: [{ type: core.Input }],
            eclatFormValue: [{ type: core.Input }]
        };
        return EclatFormValueDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /**
     * @template T
     */
    var EclatFormGroupBinderDirective = /** @class */ (function (_super) {
        __extends(EclatFormGroupBinderDirective, _super);
        function EclatFormGroupBinderDirective() {
            return _super !== null && _super.apply(this, arguments) || this;
        }
        Object.defineProperty(EclatFormGroupBinderDirective.prototype, "eclatFormGroup", {
            set: /**
             * @param {?} formGroup
             * @return {?}
             */
            function (formGroup) {
                this.form = formGroup.control;
            },
            enumerable: true,
            configurable: true
        });
        /**
         * @param {?} changes
         * @return {?}
         */
        EclatFormGroupBinderDirective.prototype.ngOnChanges = /**
         * @param {?} changes
         * @return {?}
         */
        function (changes) {
            /** @type {?} */
            var eclatFormGroupChanges = changes.eclatFormGroup;
            if (eclatFormGroupChanges) {
                /** @type {?} */
                var prevValue = eclatFormGroupChanges.previousValue ? eclatFormGroupChanges.previousValue.control : undefined;
                /** @type {?} */
                var currentValue = eclatFormGroupChanges.currentValue.control;
                /** @type {?} */
                var firstChange = eclatFormGroupChanges.firstChange;
                _super.prototype.ngOnChanges.call(this, { form: new core.SimpleChange(prevValue, currentValue, firstChange) });
            }
        };
        EclatFormGroupBinderDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[eclatFormGroup]',
                        providers: [{
                                provide: forms.ControlContainer,
                                useExisting: core.forwardRef((/**
                                 * @return {?}
                                 */
                                function () { return EclatFormGroupBinderDirective; })),
                            }],
                    },] }
        ];
        EclatFormGroupBinderDirective.propDecorators = {
            eclatFormGroup: [{ type: core.Input }]
        };
        return EclatFormGroupBinderDirective;
    }(forms.FormGroupDirective));

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /**
     * @template T
     */
    var EclatFormGroupNameBinderDirective = /** @class */ (function (_super) {
        __extends(EclatFormGroupNameBinderDirective, _super);
        function EclatFormGroupNameBinderDirective() {
            return _super !== null && _super.apply(this, arguments) || this;
        }
        Object.defineProperty(EclatFormGroupNameBinderDirective.prototype, "eclatFormGroupName", {
            set: /**
             * @param {?} name
             * @return {?}
             */
            function (name) {
                this.name = name;
            },
            enumerable: true,
            configurable: true
        });
        EclatFormGroupNameBinderDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[eclatFormGroupName]',
                        providers: [{
                                provide: forms.ControlContainer,
                                useExisting: core.forwardRef((/**
                                 * @return {?}
                                 */
                                function () { return EclatFormGroupNameBinderDirective; })),
                            }],
                    },] }
        ];
        EclatFormGroupNameBinderDirective.propDecorators = {
            eclatFormGroupName: [{ type: core.Input }]
        };
        return EclatFormGroupNameBinderDirective;
    }(forms.FormGroupName));

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /**
     * @template T
     */
    var EclatFormArrayNameBinderDirective = /** @class */ (function (_super) {
        __extends(EclatFormArrayNameBinderDirective, _super);
        function EclatFormArrayNameBinderDirective() {
            return _super !== null && _super.apply(this, arguments) || this;
        }
        Object.defineProperty(EclatFormArrayNameBinderDirective.prototype, "eclatFormArrayName", {
            set: /**
             * @param {?} name
             * @return {?}
             */
            function (name) {
                this.name = name;
            },
            enumerable: true,
            configurable: true
        });
        EclatFormArrayNameBinderDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[eclatFormArrayName]',
                        providers: [{
                                provide: forms.ControlContainer,
                                useExisting: core.forwardRef((/**
                                 * @return {?}
                                 */
                                function () { return EclatFormArrayNameBinderDirective; })),
                            }],
                    },] }
        ];
        EclatFormArrayNameBinderDirective.propDecorators = {
            eclatFormArrayName: [{ type: core.Input }]
        };
        return EclatFormArrayNameBinderDirective;
    }(forms.FormArrayName));

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /**
     * @template T
     */
    var EclatFormArrayRemoveDirective = /** @class */ (function () {
        function EclatFormArrayRemoveDirective(parent) {
            this.parent = parent;
        }
        /**
         * @return {?}
         */
        EclatFormArrayRemoveDirective.prototype.onClick = /**
         * @return {?}
         */
        function () {
            /** @type {?} */
            var control = this.parent.formControl;
            if (control) {
                control.removeChild(this.index);
            }
        };
        EclatFormArrayRemoveDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[eclatFormRemoveChildren]',
                    },] }
        ];
        /** @nocollapse */
        EclatFormArrayRemoveDirective.ctorParameters = function () { return [
            { type: EclatFormContainerDirective }
        ]; };
        EclatFormArrayRemoveDirective.propDecorators = {
            index: [{ type: core.Input, args: ['eclatFormRemoveChildren',] }],
            onClick: [{ type: core.HostListener, args: ['click', ['$event'],] }]
        };
        return EclatFormArrayRemoveDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var EclatFormModule = /** @class */ (function () {
        function EclatFormModule() {
        }
        EclatFormModule.decorators = [
            { type: core.NgModule, args: [{
                        imports: [common.CommonModule, forms.ReactiveFormsModule],
                        declarations: [EclatFormOfDirective, EclatFormErrorDirective, EclatFormGroupDirective, EclatFormGroupNameDirective, EclatFormArrayDirective, EclatFormArrayNameDirective, EclatFormArrayChildrenDirective, EclatFormSubmitDirective, EclatFormArrayAddDirective, EclatFormValueDirective, EclatFormGroupBinderDirective, EclatFormGroupNameBinderDirective, EclatFormArrayNameBinderDirective, EclatFormArrayRemoveDirective],
                        exports: [common.CommonModule, forms.ReactiveFormsModule, EclatFormOfDirective, EclatFormErrorDirective, EclatFormGroupDirective, EclatFormGroupNameDirective, EclatFormArrayDirective, EclatFormArrayNameDirective, EclatFormArrayChildrenDirective, EclatFormSubmitDirective, EclatFormArrayAddDirective, EclatFormValueDirective, EclatFormGroupBinderDirective, EclatFormGroupNameBinderDirective, EclatFormArrayNameBinderDirective, EclatFormArrayRemoveDirective],
                    },] }
        ];
        return EclatFormModule;
    }());

    exports.AbstractEclatFormControl = AbstractEclatFormControl;
    exports.EclatFormArray = EclatFormArray;
    exports.EclatFormContext = EclatFormContext;
    exports.EclatFormControl = EclatFormControl;
    exports.EclatFormErrorDirective = EclatFormErrorDirective;
    exports.EclatFormGroup = EclatFormGroup;
    exports.EclatFormGroupDirective = EclatFormGroupDirective;
    exports.EclatFormModule = EclatFormModule;
    exports.EclatFormOfDirective = EclatFormOfDirective;
    exports.EclatRecursiveConfig = EclatRecursiveConfig;
    exports.getEclatControl = getEclatControl;
    exports.ɵa = EclatFormContainerDirective;
    exports.ɵb = EclatFormGroupNameDirective;
    exports.ɵc = EclatFormArrayDirective;
    exports.ɵd = EclatFormArrayNameDirective;
    exports.ɵe = EclatFormArrayChildrenDirective;
    exports.ɵf = EclatFormSubmitDirective;
    exports.ɵg = EclatFormArrayAddDirective;
    exports.ɵh = EclatFormValueDirective;
    exports.ɵi = EclatFormGroupBinderDirective;
    exports.ɵj = EclatFormGroupNameBinderDirective;
    exports.ɵk = EclatFormArrayNameBinderDirective;
    exports.ɵl = EclatFormArrayRemoveDirective;

    Object.defineProperty(exports, '__esModule', { value: true });

}));
//# sourceMappingURL=eclat-form.umd.js.map