@eclat/form/fesm2015/eclat-form.js

import { Directive, TemplateRef, ViewContainerRef, Input, EventEmitter, Output, forwardRef, SkipSelf, HostListener, SimpleChange, NgModule } from '@angular/core';
import { FormControl, FormGroup, FormArray, FormGroupDirective, ControlContainer, FormGroupName, FormArrayName, ReactiveFormsModule } from '@angular/forms';
import { BehaviorSubject, Subject } from 'rxjs';
import { takeUntil } from 'rxjs/operators';
import { CommonModule } from '@angular/common';

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class 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
 */
var EclatFormUtility;
(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 {?} */
        const path = recursivePathFinder(data);
        if (!path) {
            throw Error();
        }
        /** @type {?} */
        const paths = path.split('.');
        /** @type {?} */
        const latestPath = (/** @type {?} */ (paths.pop()));
        paths.reduce((/**
         * @param {?} acc
         * @param {?} cur
         * @return {?}
         */
        (acc, cur) => {
            return acc[cur];
        }), (/** @type {?} */ (data)))[latestPath] = data;
        return (/** @type {?} */ (data));
    }
    EclatFormUtility.eclatRecursiveTransformer = eclatRecursiveTransformer;
})(EclatFormUtility || (EclatFormUtility = {}));
/**
 * @param {?} data
 * @param {?=} path
 * @return {?}
 */
function recursivePathFinder(data, path = null) {
    if (data instanceof EclatRecursiveConfig) {
        return '';
    }
    if (Array.isArray(data)) {
        /** @type {?} */
        let found = null;
        data.some((/**
         * @param {?} value
         * @param {?} key
         * @return {?}
         */
        (value, key) => {
            /** @type {?} */
            const temp = recursivePathFinder(value, path);
            if (temp !== null) {
                if (temp) {
                    found = key + '.' + temp;
                }
                else {
                    found = key.toString();
                }
            }
            return !!found;
        }));
        return found;
    }
    if (data === Object(data)) {
        /** @type {?} */
        let found = null;
        Object.entries(data).some((/**
         * @param {?} __0
         * @return {?}
         */
        ([key, value]) => {
            /** @type {?} */
            const temp = recursivePathFinder(value, path);
            if (temp !== null) {
                if (temp) {
                    found = key + '.' + temp;
                }
                else {
                    found = key;
                }
            }
            return !!found;
        }));
        return found;
    }
    return null;
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @abstract
 * @template T, C
 */
class AbstractEclatFormControl {
    /**
     * @param {?=} rules
     */
    constructor(rules) {
        /** @type {?} */
        const validators = [];
        /** @type {?} */
        const asyncValidators = [];
        /** @type {?} */
        const errorMapping = {};
        if (rules) {
            rules.forEach((/**
             * @param {?} __0
             * @return {?}
             */
            ({ validator, asyncValidator, key, message }) => {
                errorMapping[key] = message;
                if (validator) {
                    validators.push(validator);
                }
                if (asyncValidator) {
                    asyncValidators.push(asyncValidator);
                }
            }));
        }
        this.rules = errorMapping;
        this.validators = validators;
        this.asyncValidators = asyncValidators;
    }
    /**
     * @return {?}
     */
    get errorMessages() {
        if (!this.control.errors) {
            return [];
        }
        return Object.entries(this.control.errors).reduce((/**
         * @param {?} acc
         * @param {?} __1
         * @return {?}
         */
        (acc, [key, value]) => {
            if (value) {
                /** @type {?} */
                const temp = this.rules[key];
                /** @type {?} */
                const errors = typeof temp === 'function' ? temp(this) : temp;
                if (Array.isArray(errors)) {
                    acc.push(...errors);
                }
                else {
                    acc.push(errors);
                }
            }
            return acc;
        }), (/** @type {?} */ ([])));
    }
    /**
     * @return {?}
     */
    get value() {
        return this.control.value;
    }
    /**
     * @return {?}
     */
    get valid() {
        return this.control.valid;
    }
    /**
     * @return {?}
     */
    get valueChanges() {
        return this.control.valueChanges;
    }
    /**
     * @param {?=} isDisabled
     * @param {?=} opts
     * @return {?}
     */
    disable(isDisabled = true, opts) {
        if (isDisabled) {
            this.control.disable(opts);
        }
        else {
            this.control.enable(opts);
        }
    }
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @param {?} config
 * @param {?=} data
 * @return {?}
 */
function getEclatControl(config, data) {
    if (EclatFormUtility.isEclatFormControlConfig(config)) {
        return new EclatFormControl(config, data);
    }
    if (EclatFormUtility.isEclatFormGroupConfig(config)) {
        return new EclatFormGroup(config, data);
    }
    if (EclatFormUtility.isEclatFormArrayConfig(config)) {
        return new EclatFormArray(config, data);
    }
    return null;
}
/**
 * @template T
 */
class EclatFormControl extends AbstractEclatFormControl {
    /**
     * @param {?} config
     * @param {?=} initialData
     */
    constructor(config, initialData) {
        super(config);
        this.control = new FormControl(null, this.validators, this.asyncValidators);
        if (initialData) {
            this.resetState(initialData, false);
        }
    }
    /**
     * @param {?} data
     * @param {?=} emitEvent
     * @return {?}
     */
    patchState(data, emitEvent = true) {
        this.control.patchValue(data, { emitEvent });
    }
    /**
     * @param {?} data
     * @param {?=} emitEvent
     * @return {?}
     */
    resetState(data, emitEvent = true) {
        this.control.reset(data, { emitEvent });
    }
}
/**
 * @template T
 */
class EclatFormGroup extends AbstractEclatFormControl {
    /**
     * @param {?} dfg
     * @param {?=} initialData
     */
    constructor(dfg, initialData) {
        super(dfg.rules);
        /** @type {?} */
        const children = {};
        /** @type {?} */
        const controls = {};
        Object.keys(dfg.controlsRules).forEach((/**
         * @param {?} key
         * @return {?}
         */
        (key) => {
            /** @type {?} */
            const value = dfg.controlsRules[(/** @type {?} */ (key))];
            /** @type {?} */
            const eclatControl = getEclatControl(value);
            if (eclatControl) {
                children[key] = eclatControl;
                controls[key] = eclatControl.control;
            }
        }));
        this.control = new FormGroup(controls, this.validators, this.asyncValidators);
        this.children = children;
        if (initialData) {
            this.resetState(initialData, false);
        }
    }
    /**
     * @param {?} data
     * @param {?=} emitEvent
     * @return {?}
     */
    patchState(data, emitEvent = true) {
        if (!data) {
            console.warn(`Expect an object, but ${data} is given`);
            return;
        }
        Object.entries(data).forEach((/**
         * @param {?} __0
         * @return {?}
         */
        ([key, value]) => {
            if (this.children[(/** @type {?} */ (key))]) {
                this.children[(/** @type {?} */ (key))].patchState(value, false);
            }
        }));
        this.control.updateValueAndValidity({ emitEvent });
    }
    /**
     * @param {?} data
     * @param {?=} emitEvent
     * @return {?}
     */
    resetState(data, emitEvent = true) {
        if (!data) {
            console.warn(`Expect an object, but ${data} is given`);
            return;
        }
        Object.entries(data).forEach((/**
         * @param {?} __0
         * @return {?}
         */
        ([key, value]) => {
            if (this.children[(/** @type {?} */ (key))]) {
                this.children[(/** @type {?} */ (key))].resetState(value, false);
            }
        }));
        this.control.updateValueAndValidity({ emitEvent });
    }
    /**
     * @template P
     * @param {?} key
     * @return {?}
     */
    getChild(key) {
        return this.children[key];
    }
    /**
     * @private
     * @param {?} key
     * @param {?} config
     * @param {?} data
     * @return {?}
     */
    addChild(key, config, data) {
        /** @type {?} */
        const 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 {?}
     */
    removeChild(key) {
        delete this.children[key];
        this.control.removeControl(key);
    }
}
/**
 * @template T
 */
class EclatFormArray extends AbstractEclatFormControl {
    /**
     * @param {?} dfa
     * @param {?=} initialData
     */
    constructor(dfa, initialData) {
        super(dfa.rules);
        this.control = new FormArray([], this.validators, this.asyncValidators);
        this.childConfig = dfa.controlConfig;
        this.children = [];
        if (initialData) {
            this.resetState(initialData, false);
        }
    }
    /**
     * @param {?=} data
     * @return {?}
     */
    addChild(data) {
        /** @type {?} */
        const eclatControl = getEclatControl(this.childConfig);
        if (eclatControl) {
            eclatControl.resetState(data);
            this.children.push((/** @type {?} */ (eclatControl)));
            this.control.push(eclatControl.control);
        }
    }
    /**
     * @param {?} index
     * @return {?}
     */
    removeChild(index) {
        this.children.splice(index, 1);
        this.control.removeAt(index);
    }
    /**
     * @param {?} data
     * @param {?=} emitEvent
     * @return {?}
     */
    patchState(data, emitEvent = true) {
        if (!data) {
            console.warn(`Expect an array, but ${data} is given`);
            return;
        }
        /** @type {?} */
        const controls = [];
        this.children = [];
        data.forEach((/**
         * @param {?} d
         * @return {?}
         */
        d => {
            /** @type {?} */
            const eclatControl = getEclatControl(this.childConfig, d);
            if (eclatControl) {
                this.children.push((/** @type {?} */ (eclatControl)));
                controls.push(eclatControl.control);
            }
        }));
        this.control.controls = controls;
        this.control.updateValueAndValidity({ emitEvent: true }); // used by eclat form array children
    }
    /**
     * @param {?} data
     * @param {?=} emitEvent
     * @return {?}
     */
    resetState(data, emitEvent = true) {
        if (!data) {
            console.warn(`Expect an array, but ${data} is given`);
            return;
        }
        /** @type {?} */
        const controls = [];
        this.children = [];
        data.forEach((/**
         * @param {?} d
         * @return {?}
         */
        d => {
            /** @type {?} */
            const eclatControl = getEclatControl(this.childConfig, d);
            if (eclatControl) {
                this.children.push((/** @type {?} */ (eclatControl)));
                controls.push(eclatControl.control);
            }
        }));
        this.control.controls = controls;
        this.control.updateValueAndValidity({ emitEvent: true }); // used by eclat form array children
    }
    /**
     * @param {?} index
     * @return {?}
     */
    getChild(index) {
        return this.children[index];
    }
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @template T
 */
class EclatFormContext {
    /**
     * @param {?} $implicit
     */
    constructor($implicit) {
        this.$implicit = $implicit;
    }
}
/**
 * @template T
 */
class EclatFormOfDirective {
    /**
     * @param {?} templateRef
     * @param {?} viewContainer
     */
    constructor(templateRef, viewContainer) {
        this.templateRef = templateRef;
        this.viewContainer = viewContainer;
    }
    /**
     * @param {?} state
     * @return {?}
     */
    set eclatFormOf(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;
    }
    /**
     * @private
     * @param {?=} control
     * @return {?}
     */
    setContext(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: Directive, args: [{ selector: '[eclatForm][eclatFormOf]' },] }
];
/** @nocollapse */
EclatFormOfDirective.ctorParameters = () => [
    { type: TemplateRef },
    { type: ViewContainerRef }
];
EclatFormOfDirective.propDecorators = {
    eclatFormOf: [{ type: Input }]
};

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

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @template T
 */
class EclatFormErrorContext {
    /**
     * @param {?} control
     */
    constructor(control) {
        this.control = control;
    }
    /**
     * @return {?}
     */
    get $implicit() {
        return this.control.errorMessages;
    }
}
/**
 * @template T
 */
class EclatFormErrorDirective {
    /**
     * @param {?} templateRef
     * @param {?} viewContainer
     * @param {?} parent
     */
    constructor(templateRef, viewContainer, parent) {
        this.templateRef = templateRef;
        this.viewContainer = viewContainer;
        this.parent = parent;
        this.onDestroy$ = new Subject();
        this.errorMatcher = (/**
         * @return {?}
         */
        () => true);
    }
    /**
     * @param {?} control
     * @return {?}
     */
    set eclatControl(control) {
        this.setContext(control);
    }
    /**
     * @param {?} controlName
     * @return {?}
     */
    set eclatControlName(controlName) {
        if (!this.parent.formControl) {
            throw new Error('parent formControl not exist');
        }
        /** @type {?} */
        const 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);
    }
    /**
     * @param {?} control
     * @return {?}
     */
    set eclatFormError(control) {
        if (control instanceof AbstractEclatFormControl) {
            this.setContext(control);
        }
        else {
            this.eclatControlName = control;
        }
    }
    /**
     * @return {?}
     */
    ngOnInit() {
        this.parent.formControl$.pipe(takeUntil(this.onDestroy$)).subscribe((/**
         * @param {?} formControl
         * @return {?}
         */
        (formControl) => {
            if (formControl && this.latestControlName) {
                this.eclatFormError = formControl.getChild(this.latestControlName);
            }
        }));
    }
    /**
     * @return {?}
     */
    ngOnDestroy() {
        this.onDestroy$.next();
    }
    /**
     * @private
     * @param {?} control
     * @return {?}
     */
    setContext(control) {
        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(takeUntil(this.onDestroy$)).subscribe((/**
         * @return {?}
         */
        () => {
            this.checkValidity(control);
        }));
    }
    /**
     * @private
     * @param {?} control
     * @return {?}
     */
    checkValidity(control) {
        /** @type {?} */
        const 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: Directive, args: [{ selector: '[eclatFormError]' },] }
];
/** @nocollapse */
EclatFormErrorDirective.ctorParameters = () => [
    { type: TemplateRef },
    { type: ViewContainerRef },
    { type: EclatFormContainerDirective }
];
EclatFormErrorDirective.propDecorators = {
    errorMatcher: [{ type: Input }],
    eclatControl: [{ type: Input }],
    eclatControlName: [{ type: Input }],
    eclatFormError: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @template T
 */
class EclatFormGroupDirective extends EclatFormContainerDirective {
    constructor() {
        super();
    }
    /**
     * @param {?} formGroup
     * @return {?}
     */
    set eclatFormGroup(formGroup) {
        this._formControl.next(formGroup);
    }
    /**
     * @param {?} key
     * @return {?}
     */
    getChild(key) {
        if (this.formControl) {
            return this.formControl.getChild(key);
        }
        return undefined;
    }
}
EclatFormGroupDirective.decorators = [
    { type: Directive, args: [{
                selector: '[eclatFormGroup]',
                providers: [{
                        provide: EclatFormContainerDirective,
                        useExisting: forwardRef((/**
                         * @return {?}
                         */
                        () => EclatFormGroupDirective)),
                    }],
            },] }
];
/** @nocollapse */
EclatFormGroupDirective.ctorParameters = () => [];
EclatFormGroupDirective.propDecorators = {
    eclatFormGroup: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @template T
 */
class EclatFormGroupNameDirective extends EclatFormContainerDirective {
    /**
     * @param {?} parent
     */
    constructor(parent) {
        super();
        this.parent = parent;
        this.onDestroy$ = new Subject();
    }
    /**
     * @param {?} name
     * @return {?}
     */
    set eclatFormGroupName(name) {
        this.latestName = name;
        this._formControl.next((/** @type {?} */ (this.parent.getChild(name))));
    }
    /**
     * @return {?}
     */
    ngOnDestroy() {
        this.onDestroy$.next();
    }
    /**
     * @return {?}
     */
    ngOnInit() {
        this.parent.formControl$.pipe(takeUntil(this.onDestroy$)).subscribe((/**
         * @return {?}
         */
        () => {
            this.eclatFormGroupName = this.latestName;
        }));
    }
    /**
     * @param {?} key
     * @return {?}
     */
    getChild(key) {
        if (this.formControl) {
            return this.formControl.getChild(key);
        }
        return undefined;
    }
}
EclatFormGroupNameDirective.decorators = [
    { type: Directive, args: [{
                selector: '[eclatFormGroupName]',
                providers: [{
                        provide: EclatFormContainerDirective,
                        useExisting: forwardRef((/**
                         * @return {?}
                         */
                        () => EclatFormGroupNameDirective)),
                    }],
            },] }
];
/** @nocollapse */
EclatFormGroupNameDirective.ctorParameters = () => [
    { type: EclatFormContainerDirective, decorators: [{ type: SkipSelf }] }
];
EclatFormGroupNameDirective.propDecorators = {
    eclatFormGroupName: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @template T
 */
class EclatFormArrayNameDirective extends EclatFormContainerDirective {
    /**
     * @param {?} parent
     */
    constructor(parent) {
        super();
        this.parent = parent;
        this.onDestroy$ = new Subject();
    }
    /**
     * @param {?} name
     * @return {?}
     */
    set eclatFormArrayName(name) {
        this.latestName = name;
        this._formControl.next((/** @type {?} */ (this.parent.getChild(name))));
    }
    /**
     * @return {?}
     */
    ngOnDestroy() {
        this.onDestroy$.next();
    }
    /**
     * @return {?}
     */
    ngOnInit() {
        this.parent.formControl$.pipe(takeUntil(this.onDestroy$)).subscribe((/**
         * @return {?}
         */
        () => {
            this.eclatFormArrayName = this.latestName;
        }));
    }
    /**
     * @param {?} key
     * @return {?}
     */
    getChild(key) {
        if (this.formControl) {
            return this.formControl.getChild(key);
        }
        return undefined;
    }
}
EclatFormArrayNameDirective.decorators = [
    { type: Directive, args: [{
                selector: '[eclatFormArrayName]',
                providers: [{
                        provide: EclatFormContainerDirective,
                        useExisting: forwardRef((/**
                         * @return {?}
                         */
                        () => EclatFormArrayNameDirective)),
                    }],
            },] }
];
/** @nocollapse */
EclatFormArrayNameDirective.ctorParameters = () => [
    { type: EclatFormContainerDirective, decorators: [{ type: SkipSelf }] }
];
EclatFormArrayNameDirective.propDecorators = {
    eclatFormArrayName: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @template T
 */
class EclatFormArrayDirective extends EclatFormContainerDirective {
    constructor() {
        super();
    }
    /**
     * @param {?} formArray
     * @return {?}
     */
    set eclatFormArray(formArray) {
        this._formControl.next(formArray);
    }
    /**
     * @param {?} key
     * @return {?}
     */
    getChild(key) {
        if (this.formControl) {
            return this.formControl.getChild(key);
        }
        return undefined;
    }
}
EclatFormArrayDirective.decorators = [
    { type: Directive, args: [{
                selector: '[eclatFormArray]',
                providers: [{
                        provide: EclatFormContainerDirective,
                        useExisting: forwardRef((/**
                         * @return {?}
                         */
                        () => EclatFormArrayDirective)),
                    }],
            },] }
];
/** @nocollapse */
EclatFormArrayDirective.ctorParameters = () => [];
EclatFormArrayDirective.propDecorators = {
    eclatFormArray: [{ type: Input }]
};

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

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

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

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @template T
 */
class EclatFormValueContext {
    /**
     * @param {?} control
     */
    constructor(control) {
        this.control = control;
    }
    /**
     * @return {?}
     */
    get $implicit() {
        return this.control.value;
    }
}
/**
 * @template T
 */
class EclatFormValueDirective {
    /**
     * @param {?} templateRef
     * @param {?} viewContainer
     * @param {?} parent
     */
    constructor(templateRef, viewContainer, parent) {
        this.templateRef = templateRef;
        this.viewContainer = viewContainer;
        this.parent = parent;
        this.onDestroy$ = new Subject();
    }
    /**
     * @param {?} control
     * @return {?}
     */
    set eclatControl(control) {
        this.setContext(control);
    }
    /**
     * @param {?} controlName
     * @return {?}
     */
    set eclatControlName(controlName) {
        if (!this.parent.formControl) {
            throw new Error('parent formControl not exist');
        }
        /** @type {?} */
        const instance = this.parent.formControl.getChild(controlName);
        if (!instance) {
            throw new Error('control not found');
            return;
        }
        this.latestControlName = controlName;
        this.setContext(instance);
    }
    /**
     * @param {?} control
     * @return {?}
     */
    set eclatFormValue(control) {
        if (control instanceof AbstractEclatFormControl) {
            this.setContext(control);
        }
        else if (control || control === 0) {
            this.eclatControlName = control;
        }
    }
    /**
     * @return {?}
     */
    ngOnInit() {
        this.parent.formControl$.pipe(takeUntil(this.onDestroy$)).subscribe((/**
         * @param {?} formControl
         * @return {?}
         */
        (formControl) => {
            if (formControl && this.latestControlName) {
                this.eclatFormValue = formControl.getChild(this.latestControlName);
            }
        }));
    }
    /**
     * @return {?}
     */
    ngOnDestroy() {
        this.onDestroy$.next();
    }
    /**
     * @private
     * @param {?} control
     * @return {?}
     */
    setContext(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: Directive, args: [{ selector: '[eclatFormValue]' },] }
];
/** @nocollapse */
EclatFormValueDirective.ctorParameters = () => [
    { type: TemplateRef },
    { type: ViewContainerRef },
    { type: EclatFormContainerDirective }
];
EclatFormValueDirective.propDecorators = {
    eclatControl: [{ type: Input }],
    eclatControlName: [{ type: Input }],
    eclatFormValue: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @template T
 */
class EclatFormGroupBinderDirective extends FormGroupDirective {
    /**
     * @param {?} formGroup
     * @return {?}
     */
    set eclatFormGroup(formGroup) {
        this.form = formGroup.control;
    }
    /**
     * @param {?} changes
     * @return {?}
     */
    ngOnChanges(changes) {
        /** @type {?} */
        const eclatFormGroupChanges = changes.eclatFormGroup;
        if (eclatFormGroupChanges) {
            /** @type {?} */
            const prevValue = eclatFormGroupChanges.previousValue ? eclatFormGroupChanges.previousValue.control : undefined;
            /** @type {?} */
            const currentValue = eclatFormGroupChanges.currentValue.control;
            /** @type {?} */
            const firstChange = eclatFormGroupChanges.firstChange;
            super.ngOnChanges({ form: new SimpleChange(prevValue, currentValue, firstChange) });
        }
    }
}
EclatFormGroupBinderDirective.decorators = [
    { type: Directive, args: [{
                selector: '[eclatFormGroup]',
                providers: [{
                        provide: ControlContainer,
                        useExisting: forwardRef((/**
                         * @return {?}
                         */
                        () => EclatFormGroupBinderDirective)),
                    }],
            },] }
];
EclatFormGroupBinderDirective.propDecorators = {
    eclatFormGroup: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @template T
 */
class EclatFormGroupNameBinderDirective extends FormGroupName {
    /**
     * @param {?} name
     * @return {?}
     */
    set eclatFormGroupName(name) {
        this.name = name;
    }
}
EclatFormGroupNameBinderDirective.decorators = [
    { type: Directive, args: [{
                selector: '[eclatFormGroupName]',
                providers: [{
                        provide: ControlContainer,
                        useExisting: forwardRef((/**
                         * @return {?}
                         */
                        () => EclatFormGroupNameBinderDirective)),
                    }],
            },] }
];
EclatFormGroupNameBinderDirective.propDecorators = {
    eclatFormGroupName: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @template T
 */
class EclatFormArrayNameBinderDirective extends FormArrayName {
    /**
     * @param {?} name
     * @return {?}
     */
    set eclatFormArrayName(name) {
        this.name = name;
    }
}
EclatFormArrayNameBinderDirective.decorators = [
    { type: Directive, args: [{
                selector: '[eclatFormArrayName]',
                providers: [{
                        provide: ControlContainer,
                        useExisting: forwardRef((/**
                         * @return {?}
                         */
                        () => EclatFormArrayNameBinderDirective)),
                    }],
            },] }
];
EclatFormArrayNameBinderDirective.propDecorators = {
    eclatFormArrayName: [{ type: Input }]
};

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

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

/**
 * @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
 */

export { AbstractEclatFormControl, EclatFormArray, EclatFormContext, EclatFormControl, EclatFormErrorDirective, EclatFormGroup, EclatFormGroupDirective, EclatFormModule, EclatFormOfDirective, EclatFormUtility, EclatRecursiveConfig, getEclatControl, EclatFormContainerDirective as ɵa, EclatFormGroupNameDirective as ɵb, EclatFormArrayDirective as ɵc, EclatFormArrayNameDirective as ɵd, EclatFormArrayChildrenDirective as ɵe, EclatFormSubmitDirective as ɵf, EclatFormArrayAddDirective as ɵg, EclatFormValueDirective as ɵh, EclatFormGroupBinderDirective as ɵi, EclatFormGroupNameBinderDirective as ɵj, EclatFormArrayNameBinderDirective as ɵk, EclatFormArrayRemoveDirective as ɵl };
//# sourceMappingURL=eclat-form.js.map