@messaia/cdk 0.0.0-CDK

package/esm2020/lib/form-validators/services/form-control.mjs

@@ -0,0 +1,349 @@
+import { FormControl } from "@angular/forms";
+import { ObjectMaker } from "../util/object-maker";
+import { MESSAGE, CONTROLS_ERROR, VALUE_CHANGED_SYNC } from '../const';
+import { ApplicationUtil } from '../util/app-util';
+import { DisableProvider } from '../domain/disable-provider';
+import { RXCODE, MODEL_INSTANCE, PATCH } from "../const/app.const";
+import { DECORATORS } from "../const/decorators.const";
+import { defaultContainer } from "../core/defaultContainer";
+import { SANITIZERS } from "../util/sanitizers";
+import { ErrorMessageBindingStrategy } from "../enums";
+import { ReactiveFormConfig } from "../util/reactive-form-config";
+const DIRTY = "dirty";
+const TOUCHED = "touched";
+const UNTOUCHED = "untouched";
+const PRISTINE = "pristine";
+const PENDING = "pending";
+export class RxFormControl extends FormControl {
+    constructor(formState, validator, asyncValidator, entityObject, baseObject, controlName, _sanitizers) {
+        super(formState, validator, asyncValidator);
+        this.entityObject = entityObject;
+        this.baseObject = baseObject;
+        this._sanitizers = _sanitizers;
+        this._errorMessages = [];
+        this._childColumns = [];
+        this._refDisableControls = [];
+        this._refMessageControls = [];
+        this._refClassNameControls = [];
+        this._isPassedExpression = false;
+        this._dirty = false;
+        this.backEndErrors = {};
+        this.defineErrorsProperty();
+        this._baseValue = formState === undefined ? null : this.getFormState(formState);
+        this._isModified = false;
+        this.keyName = controlName;
+        this._validators = validator.validators;
+        this._asyncValidators = validator.asyncValidators;
+        this._errorMessageBindingStrategy = ReactiveFormConfig.get("reactiveForm.errorMessageBindingStrategy");
+        if (this._sanitizers) {
+            var floatSanitizer = this._sanitizers.filter(t => t.name == "toFloat")[0];
+            if (floatSanitizer && this._baseValue && ReactiveFormConfig.number && ReactiveFormConfig.number.decimalSymbol == ",") {
+                let baseValue = String(this._baseValue);
+                if (baseValue.indexOf('.') != -1) {
+                    this._baseValue = baseValue.replace(".", ReactiveFormConfig.number.decimalSymbol);
+                    super.setValue(this._baseValue);
+                }
+            }
+        }
+    }
+    get errorMessages() {
+        if (!this._messageExpression) {
+            if (this._errorMessages.length == 0 && this.errors)
+                this.setControlErrorMessages();
+        }
+        else if (this._messageExpression && !this._isPassedExpression)
+            return [];
+        if (!this.errors && this._errorMessages.length > 0)
+            this.setControlErrorMessages();
+        if (this._language != this.getLanguage())
+            this.setControlErrorMessages();
+        return this._errorMessages;
+    }
+    get errorMessage() {
+        if (!this._messageExpression) {
+            if (this._errorMessage == undefined && this.errors)
+                this.setControlErrorMessages();
+        }
+        else if (this._messageExpression && !this._isPassedExpression)
+            return undefined;
+        if (!this.errors && this._errorMessage)
+            this.setControlErrorMessages();
+        if (this._language != this.getLanguage())
+            this.setControlErrorMessages();
+        return this._errorMessage;
+    }
+    defineErrorsProperty() {
+        Object.defineProperty(this, "errors", {
+            configurable: true,
+            get() {
+                if (this._language && this._language != this.getLanguage() && this.validator) {
+                    this["errors"] = this.validator(this);
+                }
+                return this._errors;
+            },
+            set(value) { this._errors = value; },
+        });
+    }
+    getFormState(value) {
+        let baseValue = value;
+        if (Array.isArray(value)) {
+            baseValue = [];
+            value.forEach(t => baseValue.push(t));
+        }
+        return baseValue;
+    }
+    get isModified() {
+        return this._isModified;
+    }
+    getValidators() {
+        return this.getValidatorSource(this._validators);
+    }
+    getAsyncValidators() {
+        return this.getValidatorSource(this._asyncValidators);
+    }
+    getValidatorSource(validators) {
+        if (validators)
+            return Array.isArray(validators) ? [...validators] : [validators];
+        return [];
+    }
+    setValidators(newValidator) {
+        this._validators = newValidator;
+        super.setValidators(newValidator);
+    }
+    setAsyncValidators(newValidator) {
+        this._asyncValidators = newValidator;
+        super.setAsyncValidators(newValidator);
+    }
+    setValue(value, options) {
+        this.parent.changing = true;
+        let parsedValue = this.getSanitizedValue(value);
+        if (options && options.dirty)
+            this.baseObject[this.keyName] = value;
+        this.entityObject[this.keyName] = parsedValue;
+        super.setValue(value, options);
+        this.bindError();
+        this.bindClassName();
+        this.executeExpressions();
+        this.callPatch();
+        if (options && !options.updateChanged && this.root[VALUE_CHANGED_SYNC]) {
+            this.root[VALUE_CHANGED_SYNC]();
+        }
+        this.parent.changing = false;
+    }
+    getControlValue() {
+        return this.getSanitizedValue(this.value);
+    }
+    bindError() {
+        if (this._messageExpression)
+            this._isPassedExpression = this.executeExpression(this._messageExpression, this);
+        this.setControlErrorMessages();
+        var t = this;
+        t["errors"] = this.errors;
+    }
+    bindClassName() {
+        if (this.updateOnElementClass && typeof this.updateOnElementClass === "function") {
+            let className = this.executeExpression(this._classNameExpression, this);
+            let updateElement = this.updateOnElementClass;
+            updateElement(className);
+        }
+    }
+    setBackEndErrors(error) {
+        Object.keys(error).forEach(key => this.backEndErrors[key] = error[key]);
+        this.setControlErrorMessages();
+    }
+    clearBackEndErrors(errors) {
+        if (!errors)
+            this.backEndErrors = {};
+        else
+            Object.keys(errors).forEach(t => delete this.backEndErrors[t]);
+        this.setControlErrorMessages();
+    }
+    markAsTouched(opts) {
+        let currentState = this.touched;
+        super.markAsTouched(opts);
+        if (currentState != this.touched)
+            this.runControlPropChangeExpression([TOUCHED, UNTOUCHED]);
+    }
+    markAsUntouched(opts) {
+        let currentState = this.untouched;
+        super.markAsUntouched(opts);
+        if (currentState != this.untouched)
+            this.runControlPropChangeExpression([UNTOUCHED, TOUCHED]);
+    }
+    markAsDirty(opts) {
+        let currentState = this._dirty;
+        super.markAsDirty(opts);
+        this._dirty = true;
+        if (currentState != this._dirty)
+            this.runControlPropChangeExpression([DIRTY]);
+    }
+    markAsPristine(opts) {
+        let currentState = this.pristine;
+        super.markAsDirty(opts);
+        if (currentState != this.pristine)
+            this.runControlPropChangeExpression([PRISTINE]);
+    }
+    markAsPending(opts) {
+        let currentState = this.pending;
+        super.markAsDirty(opts);
+        if (currentState != this.pending)
+            this.runControlPropChangeExpression([PENDING]);
+    }
+    runControlPropChangeExpression(propNames) {
+        propNames.forEach(name => {
+            if ((this._controlProp && this._messageExpression && this._controlProp[name]) || (!this._messageExpression && this.checkErrorMessageStrategy()))
+                this.bindError();
+            if (this._classNameControlProp && this._classNameControlProp[name])
+                this.bindClassName();
+        });
+    }
+    refresh() {
+        this.getMessageExpression(this.parent, this.keyName);
+        this.bindConditionalControls(DECORATORS.disabled, "_refDisableControls");
+        this.bindConditionalControls(DECORATORS.error, "_refMessageControls");
+        this.bindConditionalControls(DECORATORS.elementClass, "_refClassNameControls");
+        this.executeExpressions();
+        this.bindError();
+    }
+    reset(value) {
+        if (value !== undefined)
+            this.setValue(value);
+        else
+            this.setValue(this.getFormState(this._baseValue));
+        this._dirty = false;
+    }
+    commit() {
+        this._baseValue = this.value;
+        this.callPatch();
+    }
+    callPatch() {
+        this._isModified = this.getValue(this._baseValue) != this.getValue(this.value);
+        if (this.parent && this.parent[PATCH])
+            this.parent[PATCH](this.keyName);
+    }
+    checkErrorMessageStrategy() {
+        let isBind = true;
+        switch (this._errorMessageBindingStrategy) {
+            case ErrorMessageBindingStrategy.OnSubmit:
+                isBind = this.parent.submitted;
+                break;
+            case ErrorMessageBindingStrategy.OnDirty:
+                isBind = this._dirty;
+                break;
+            case ErrorMessageBindingStrategy.OnTouched:
+                isBind = this.touched;
+                break;
+            case ErrorMessageBindingStrategy.OnDirtyOrTouched:
+                isBind = this._dirty || this.touched;
+                break;
+            case ErrorMessageBindingStrategy.OnDirtyOrSubmit:
+                isBind = this._dirty || this.parent.submitted;
+                break;
+            case ErrorMessageBindingStrategy.OnTouchedOrSubmit:
+                isBind = this.touched || this.parent.submitted;
+                break;
+            default:
+                isBind = true;
+        }
+        return isBind;
+    }
+    executeExpressions() {
+        this.processExpression("_refDisableControls", "disabled");
+        this.processExpression("_refMessageControls", "bindError");
+        this.processExpression("_refClassNameControls", "bindClassName");
+    }
+    getMessageExpression(formGroup, keyName) {
+        if (formGroup[MODEL_INSTANCE]) {
+            let instanceContainer = defaultContainer.get(formGroup[MODEL_INSTANCE].constructor);
+            if (instanceContainer) {
+                this._messageExpression = instanceContainer.nonValidationDecorators.error.conditionalExpressions[keyName];
+                this._controlProp = instanceContainer.nonValidationDecorators.error.controlProp[this.keyName];
+                this._classNameExpression = instanceContainer.nonValidationDecorators.elementClass.conditionalExpressions[keyName];
+                this._classNameControlProp = instanceContainer.nonValidationDecorators.elementClass.controlProp[keyName];
+                if (this._classNameExpression)
+                    this.updateOnElementClass = true;
+            }
+        }
+    }
+    getSanitizedValue(value) {
+        if (this._sanitizers) {
+            for (let sanitizer of this._sanitizers) {
+                value = SANITIZERS[sanitizer.name](value, sanitizer.config);
+            }
+        }
+        return value;
+    }
+    bindConditionalControls(decoratorType, refName) {
+        this._disableProvider = new DisableProvider(decoratorType, this.entityObject);
+        this[refName] = this._disableProvider.zeroArgumentProcess(this, this.keyName);
+        this._disableProvider.oneArgumentProcess(this, `${this.keyName}${RXCODE}1`).forEach(t => this[refName].push(t));
+    }
+    setControlErrorMessages() {
+        if ((!this._messageExpression && this.checkErrorMessageStrategy()) || this._isPassedExpression) {
+            this._errorMessages = [];
+            if (this.errors) {
+                Object.keys(this.errors).forEach(t => {
+                    if (this.parent) {
+                        this.parent[CONTROLS_ERROR][this.keyName] = this._errorMessage = this.getErrorMessage(this.errors, t);
+                        if (!this._errorMessage) {
+                            let errorObject = ObjectMaker.toJson(t, undefined, [this.errors[t][t]]);
+                            this.parent[CONTROLS_ERROR][this.keyName] = this._errorMessage = this.getErrorMessage(errorObject, t);
+                        }
+                    }
+                    else
+                        this._errorMessage = this.getErrorMessage(this.errors, t);
+                    this._errorMessages.push(this._errorMessage);
+                });
+            }
+            else {
+                this._errorMessage = undefined;
+                if (this.parent) {
+                    this.parent[CONTROLS_ERROR][this.keyName] = undefined;
+                    delete this.parent[CONTROLS_ERROR][this.keyName];
+                }
+            }
+            let backEndErrors = Object.keys(this.backEndErrors);
+            if (backEndErrors.length > 0)
+                backEndErrors.forEach(t => { this._errorMessages.push(this._errorMessage = this.backEndErrors[t]); });
+        }
+        else {
+            this._errorMessages = [];
+            this._errorMessage = undefined;
+        }
+        this._language = this.getLanguage();
+    }
+    getLanguage() {
+        return (ReactiveFormConfig.i18n && ReactiveFormConfig.i18n.language) ? ReactiveFormConfig.i18n.language : undefined;
+    }
+    getErrorMessage(errorObject, keyName) {
+        if (errorObject[keyName][MESSAGE])
+            return errorObject[keyName][MESSAGE];
+        return;
+    }
+    processExpression(propName, operationType) {
+        if (this[propName])
+            for (var controlInfo of this[propName]) {
+                let control = controlInfo.isRoot ? ApplicationUtil.getControl(controlInfo.controlPath, ApplicationUtil.getRootFormGroup(this)) : ApplicationUtil.getFormControl(controlInfo.controlPath, this);
+                if (control) {
+                    if (operationType == "disabled") {
+                        let result = this.executeExpression(controlInfo.conditionalExpression, control);
+                        if (result)
+                            control.disable();
+                        else
+                            control.enable();
+                    }
+                    else if (operationType == "bindError")
+                        control.bindError();
+                    else if (operationType == "bindClassName")
+                        control.bindClassName();
+                }
+            }
+    }
+    executeExpression(expression, control) {
+        return expression.call(control.parent[MODEL_INSTANCE], control, ApplicationUtil.getParentModelInstanceValue(this), control.parent[MODEL_INSTANCE]);
+    }
+    getValue(value) {
+        return value !== undefined && value !== null && value !== "" ? value : "";
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-control.js","sourceRoot":"","sources":["../../../../../../projects/cdk/src/lib/form-validators/services/form-control.ts"],"names":[],"mappings":"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","sourcesContent":["import { FormGroup, AbstractControl, FormControl, ValidatorFn, AsyncValidatorFn, AbstractControlOptions } from \"@angular/forms\";\r\nimport { ObjectMaker } from \"../util/object-maker\";\r\nimport { MESSAGE, CONTROLS_ERROR, VALUE_CHANGED_SYNC } from '../const'\r\nimport { ApplicationUtil } from '../util/app-util'\r\nimport { DisableProvider } from '../domain/disable-provider';\r\nimport { RXCODE, MODEL_INSTANCE, PATCH } from \"../const/app.const\"\r\nimport { DECORATORS } from \"../const/decorators.const\";\r\nimport { defaultContainer } from \"../core/defaultContainer\";\r\nimport { SANITIZERS } from \"../util/sanitizers\"\r\nimport { DataSanitizer } from '../core/validator.interface'\r\nimport { ErrorMessageBindingStrategy } from \"../enums\";\r\nimport { ReactiveFormConfig } from \"../util/reactive-form-config\";\r\n\r\nconst DIRTY: string = \"dirty\";\r\nconst TOUCHED: string = \"touched\";\r\nconst UNTOUCHED: string = \"untouched\";\r\nconst PRISTINE: string = \"pristine\";\r\nconst PENDING: string = \"pending\";\r\n\r\nexport class RxFormControl extends FormControl {\r\n    private _language: string;\r\n    private keyName: string;\r\n    private _errorMessage: string;\r\n    private _errorMessages: string[] = [];\r\n    private _disableProvider: DisableProvider;\r\n    private _columns: string[];\r\n    private _childColumns: any = [];\r\n    private _parentColumns: { [key: string]: string[] };\r\n    private _refDisableControls = [];\r\n    private _refMessageControls = [];\r\n    private _refClassNameControls = [];\r\n    private _errorMessageBindingStrategy: ErrorMessageBindingStrategy;\r\n    private _messageExpression: Function;\r\n    private _classNameExpression: Function;\r\n    private _isPassedExpression: Boolean = false;\r\n    private _controlProp: { [key: string]: boolean };\r\n    private _classNameControlProp: { [key: string]: boolean };\r\n    private _baseValue: any;\r\n    private _isModified: boolean;\r\n    private _errors: any;\r\n    private _dirty: boolean = false;\r\n    private _validators: ValidatorFn[] ;\r\n    private _asyncValidators: AsyncValidatorFn[] ;\r\n\r\n\r\n    backEndErrors: { [key: string]: string } = {};\r\n    updateOnElementClass: boolean | Function;\r\n    preHook: Function;\r\n    postHook: Function;\r\n\r\n\r\n    get errorMessages(): string[] {\r\n        if (!this._messageExpression) {\r\n            if (this._errorMessages.length == 0 && this.errors)\r\n                this.setControlErrorMessages();\r\n        }\r\n        else if (this._messageExpression && !this._isPassedExpression)\r\n            return [];\r\n        if (!this.errors && this._errorMessages.length > 0)\r\n            this.setControlErrorMessages();\r\n        if (this._language != this.getLanguage())\r\n            this.setControlErrorMessages();\r\n        return this._errorMessages;\r\n    }\r\n\r\n    get errorMessage(): string {\r\n        if (!this._messageExpression) {\r\n            if (this._errorMessage == undefined && this.errors)\r\n                this.setControlErrorMessages();\r\n        }\r\n        else if (this._messageExpression && !this._isPassedExpression)\r\n            return undefined;\r\n        if (!this.errors && this._errorMessage)\r\n            this.setControlErrorMessages();\r\n        if (this._language != this.getLanguage())\r\n            this.setControlErrorMessages();\r\n        return this._errorMessage;\r\n    }\r\n    constructor(formState: any, validator: ValidatorFn | AbstractControlOptions | ValidatorFn[] | null, asyncValidator: AsyncValidatorFn | AsyncValidatorFn[] | null, private entityObject: { [key: string]: any }, private baseObject: { [key: string]: any }, controlName: string, private _sanitizers: DataSanitizer[]) {\r\n        super(formState, validator, asyncValidator)\r\n        this.defineErrorsProperty();\r\n        this._baseValue = formState === undefined ? null : this.getFormState(formState);\r\n        this._isModified = false;\r\n        this.keyName = controlName;\r\n        this._validators = (validator as AbstractControlOptions).validators as ValidatorFn[];\r\n        this._asyncValidators = (validator as AbstractControlOptions).asyncValidators as AsyncValidatorFn[];\r\n        this._errorMessageBindingStrategy = ReactiveFormConfig.get(\"reactiveForm.errorMessageBindingStrategy\") as ErrorMessageBindingStrategy;\r\n        if (this._sanitizers) {\r\n            var floatSanitizer = this._sanitizers.filter(t => t.name == \"toFloat\")[0]\r\n            if (floatSanitizer && this._baseValue && ReactiveFormConfig.number && ReactiveFormConfig.number.decimalSymbol == \",\") {\r\n                let baseValue = String(this._baseValue);\r\n                if (baseValue.indexOf('.') != -1) {\r\n                    this._baseValue = baseValue.replace(\".\", ReactiveFormConfig.number.decimalSymbol);\r\n                    super.setValue(this._baseValue);\r\n                }\r\n\r\n            }\r\n        }\r\n    }\r\n\r\n    private defineErrorsProperty() {\r\n        Object.defineProperty(this,\"errors\", {\r\n            configurable: true,\r\n            get() {\r\n                if (this._language && this._language != this.getLanguage() && this.validator) {\r\n                    this[\"errors\"] = this.validator(this)\r\n                }\r\n                return this._errors;},\r\n            set(value) { this._errors = value; },\r\n        })\r\n    }\r\n\r\n    private getFormState(value) {\r\n        let baseValue = value\r\n        if (Array.isArray(value)) {\r\n            baseValue = [];\r\n            value.forEach(t => baseValue.push(t));\r\n        }\r\n        return baseValue;\r\n    }\r\n\r\n    get isModified() {\r\n        return this._isModified;\r\n    }\r\n\r\n    getValidators(): ValidatorFn[] {\r\n        return this.getValidatorSource(this._validators);\r\n    }\r\n\r\n    getAsyncValidators(): AsyncValidatorFn[] {\r\n        return this.getValidatorSource(this._asyncValidators);        \r\n    }\r\n\r\n    private getValidatorSource(validators:any[]) {\r\n        if (validators)\r\n            return Array.isArray(validators) ? [...validators] : [validators]\r\n        return [];\r\n    }\r\n\r\n    setValidators(newValidator: ValidatorFn | ValidatorFn[] | null) {\r\n        this._validators = newValidator as ValidatorFn[];\r\n        super.setValidators(newValidator);\r\n    }\r\n\r\n    setAsyncValidators(newValidator: AsyncValidatorFn | AsyncValidatorFn[] | null): void {\r\n        this._asyncValidators = newValidator as AsyncValidatorFn[];\r\n        super.setAsyncValidators(newValidator);\r\n    }\r\n\r\n    setValue(value: any, options?: {\r\n        dirty?: boolean;\r\n        updateChanged?: boolean;\r\n        onlySelf?: boolean;\r\n        emitEvent?: boolean;\r\n        isThroughDynamic?: boolean;\r\n    }): void {\r\n        (<any>this.parent).changing = true;\r\n        let parsedValue = this.getSanitizedValue(value)\r\n        if (options && options.dirty)\r\n            this.baseObject[this.keyName] = value;\r\n        this.entityObject[this.keyName] = parsedValue;\r\n        super.setValue(value, options);\r\n\r\n        this.bindError();\r\n        this.bindClassName();\r\n        this.executeExpressions();\r\n        this.callPatch();\r\n        if (options && !options.updateChanged && this.root[VALUE_CHANGED_SYNC]) {\r\n            this.root[VALUE_CHANGED_SYNC]();\r\n        }\r\n        (<any>this.parent).changing = false;\r\n    }\r\n\r\n    getControlValue() {\r\n        return this.getSanitizedValue(this.value);\r\n    }\r\n\r\n    bindError() {\r\n        if (this._messageExpression)\r\n            this._isPassedExpression = this.executeExpression(this._messageExpression, this);\r\n        this.setControlErrorMessages();\r\n        var t: any = this;\r\n        t[\"errors\"] = this.errors;\r\n    }\r\n\r\n    bindClassName() {\r\n        if (this.updateOnElementClass && typeof this.updateOnElementClass === \"function\") {\r\n            let className = this.executeExpression(this._classNameExpression, this);\r\n            let updateElement = this.updateOnElementClass as Function;\r\n            updateElement(className);\r\n        }\r\n    }\r\n\r\n\r\n    setBackEndErrors(error: { [key: string]: string }) {\r\n        Object.keys(error).forEach(key => this.backEndErrors[key] = error[key]);\r\n        this.setControlErrorMessages();\r\n    }\r\n\r\n    clearBackEndErrors(errors?: { [key: string]: any }) {\r\n        if (!errors)\r\n            this.backEndErrors = {};\r\n        else\r\n            Object.keys(errors).forEach(t => delete this.backEndErrors[t]);\r\n        this.setControlErrorMessages();\r\n    }\r\n\r\n    markAsTouched(opts?: {\r\n        onlySelf?: boolean;\r\n    }): void {\r\n        let currentState = this.touched;\r\n        super.markAsTouched(opts);\r\n        if (currentState != this.touched)\r\n            this.runControlPropChangeExpression([TOUCHED, UNTOUCHED])\r\n\r\n    }\r\n\r\n    markAsUntouched(opts?: {\r\n        onlySelf?: boolean;\r\n    }): void {\r\n        let currentState = this.untouched;\r\n        super.markAsUntouched(opts);\r\n        if (currentState != this.untouched)\r\n            this.runControlPropChangeExpression([UNTOUCHED, TOUCHED])\r\n    }\r\n\r\n    markAsDirty(opts?: {\r\n        onlySelf?: boolean;\r\n    }): void {\r\n        let currentState = this._dirty;\r\n        super.markAsDirty(opts);\r\n        this._dirty = true;\r\n        if (currentState != this._dirty)\r\n            this.runControlPropChangeExpression([DIRTY])\r\n    }\r\n\r\n    markAsPristine(opts?: {\r\n        onlySelf?: boolean;\r\n    }): void {\r\n        let currentState = this.pristine;\r\n        super.markAsDirty(opts);\r\n        if (currentState != this.pristine)\r\n            this.runControlPropChangeExpression([PRISTINE])\r\n    }\r\n\r\n    markAsPending(opts?: {\r\n        onlySelf?: boolean;\r\n        emitEvent?: boolean;\r\n    }): void {\r\n        let currentState = this.pending;\r\n        super.markAsDirty(opts);\r\n        if (currentState != this.pending)\r\n            this.runControlPropChangeExpression([PENDING])\r\n    }\r\n\r\n    runControlPropChangeExpression(propNames: string[]) {\r\n        propNames.forEach(name => {\r\n            if ((this._controlProp && this._messageExpression && this._controlProp[name]) || (!this._messageExpression && this.checkErrorMessageStrategy()))\r\n                this.bindError();\r\n            if (this._classNameControlProp && this._classNameControlProp[name])\r\n                this.bindClassName();\r\n        });\r\n    }\r\n\r\n    refresh() {\r\n        this.getMessageExpression(<FormGroup>this.parent, this.keyName);\r\n        this.bindConditionalControls(DECORATORS.disabled, \"_refDisableControls\");\r\n        this.bindConditionalControls(DECORATORS.error, \"_refMessageControls\");\r\n        this.bindConditionalControls(DECORATORS.elementClass, \"_refClassNameControls\");\r\n        this.executeExpressions();\r\n        this.bindError();\r\n    }\r\n\r\n    reset(value?: any) {\r\n        if (value !== undefined)\r\n            this.setValue(value);\r\n        else\r\n            this.setValue(this.getFormState(this._baseValue));\r\n        this._dirty = false;\r\n    }\r\n\r\n    commit() {\r\n        this._baseValue = this.value;\r\n        this.callPatch();\r\n    }\r\n\r\n    private callPatch() {\r\n        this._isModified = this.getValue(this._baseValue) != this.getValue(this.value);\r\n        if (this.parent && this.parent[PATCH])\r\n            this.parent[PATCH](this.keyName);\r\n    }\r\n\r\n    private checkErrorMessageStrategy() {\r\n        let isBind: boolean = true;\r\n        switch (this._errorMessageBindingStrategy) {\r\n            case ErrorMessageBindingStrategy.OnSubmit:\r\n                isBind = (<any>this.parent).submitted;\r\n                break;\r\n            case ErrorMessageBindingStrategy.OnDirty:\r\n                isBind = this._dirty;\r\n                break;\r\n            case ErrorMessageBindingStrategy.OnTouched:\r\n                isBind = this.touched;\r\n                break;\r\n            case ErrorMessageBindingStrategy.OnDirtyOrTouched:\r\n                isBind = this._dirty || this.touched;\r\n                break;\r\n            case ErrorMessageBindingStrategy.OnDirtyOrSubmit:\r\n                isBind = this._dirty || (<any>this.parent).submitted;\r\n                break;\r\n            case ErrorMessageBindingStrategy.OnTouchedOrSubmit:\r\n                isBind = this.touched || (<any>this.parent).submitted;\r\n                break;\r\n            default:\r\n                isBind = true;\r\n        }\r\n        return isBind;\r\n    }\r\n\r\n    private executeExpressions() {\r\n        this.processExpression(\"_refDisableControls\", \"disabled\");\r\n        this.processExpression(\"_refMessageControls\", \"bindError\");\r\n        this.processExpression(\"_refClassNameControls\", \"bindClassName\");\r\n    }\r\n\r\n    private getMessageExpression(formGroup: FormGroup, keyName: string): void {\r\n        if (formGroup[MODEL_INSTANCE]) {\r\n            let instanceContainer = defaultContainer.get(formGroup[MODEL_INSTANCE].constructor);\r\n            if (instanceContainer) {\r\n                this._messageExpression = instanceContainer.nonValidationDecorators.error.conditionalExpressions[keyName]\r\n                this._controlProp = instanceContainer.nonValidationDecorators.error.controlProp[this.keyName];\r\n                this._classNameExpression = instanceContainer.nonValidationDecorators.elementClass.conditionalExpressions[keyName];\r\n                this._classNameControlProp = instanceContainer.nonValidationDecorators.elementClass.controlProp[keyName];\r\n                if (this._classNameExpression)\r\n                    this.updateOnElementClass = true;\r\n            }\r\n\r\n        }\r\n    }\r\n\r\n    private getSanitizedValue(value: any) {\r\n        if (this._sanitizers) {\r\n            for (let sanitizer of this._sanitizers) {\r\n                value = SANITIZERS[sanitizer.name](value, sanitizer.config);\r\n            }\r\n        }\r\n        return value;\r\n    }\r\n\r\n    private bindConditionalControls(decoratorType: string, refName: string) {\r\n        this._disableProvider = new DisableProvider(decoratorType, this.entityObject);\r\n        this[refName] = this._disableProvider.zeroArgumentProcess(this, this.keyName)\r\n        this._disableProvider.oneArgumentProcess(this, `${this.keyName}${RXCODE}1`).forEach(t => this[refName].push(t))\r\n\r\n    }\r\n\r\n    private setControlErrorMessages() {\r\n        if ((!this._messageExpression && this.checkErrorMessageStrategy()) || this._isPassedExpression) {\r\n            this._errorMessages = [];\r\n            if (this.errors) {\r\n                Object.keys(this.errors).forEach(t => {\r\n                    if (this.parent) {\r\n                        this.parent[CONTROLS_ERROR][this.keyName] = this._errorMessage = this.getErrorMessage(this.errors, t);\r\n                        if (!this._errorMessage) {\r\n                            let errorObject = ObjectMaker.toJson(t, undefined, [this.errors[t][t]]);\r\n                            this.parent[CONTROLS_ERROR][this.keyName] = this._errorMessage = this.getErrorMessage(errorObject, t);\r\n                        }\r\n                    } else\r\n                        this._errorMessage = this.getErrorMessage(this.errors, t)\r\n                    this._errorMessages.push(this._errorMessage);\r\n                })\r\n            } else {\r\n                this._errorMessage = undefined;\r\n                if (this.parent) {\r\n                    this.parent[CONTROLS_ERROR][this.keyName] = undefined\r\n                    delete this.parent[CONTROLS_ERROR][this.keyName];\r\n                }\r\n            }\r\n            let backEndErrors = Object.keys(this.backEndErrors);\r\n            if (backEndErrors.length > 0)\r\n                backEndErrors.forEach(t => { this._errorMessages.push(this._errorMessage = this.backEndErrors[t]); })\r\n        } else {\r\n            this._errorMessages = [];\r\n            this._errorMessage = undefined;\r\n        }\r\n        this._language = this.getLanguage();\r\n        \r\n    }\r\n\r\n    private getLanguage() {\r\n        return (ReactiveFormConfig.i18n && ReactiveFormConfig.i18n.language) ? ReactiveFormConfig.i18n.language : undefined;\r\n    }\r\n\r\n    private getErrorMessage(errorObject: { [key: string]: string }, keyName: string) {\r\n        if (errorObject[keyName][MESSAGE])\r\n            return errorObject[keyName][MESSAGE];\r\n        return;\r\n    }\r\n\r\n\r\n\r\n    private processExpression(propName: string, operationType: string) {\r\n        if (this[propName])\r\n            for (var controlInfo of this[propName]) {\r\n                let control = controlInfo.isRoot ? ApplicationUtil.getControl(controlInfo.controlPath, ApplicationUtil.getRootFormGroup(this)) : ApplicationUtil.getFormControl(controlInfo.controlPath, this);\r\n                if (control) {\r\n                    if (operationType == \"disabled\") {\r\n                        let result = this.executeExpression(controlInfo.conditionalExpression, control);\r\n                        if (result)\r\n                            control.disable()\r\n                        else\r\n                            control.enable();\r\n                    } else if (operationType == \"bindError\")\r\n                        control.bindError();\r\n                    else if (operationType == \"bindClassName\")\r\n                        control.bindClassName();\r\n\r\n                }\r\n            }\r\n    }\r\n\r\n    private executeExpression(expression: Function, control: AbstractControl): Boolean {\r\n        return expression.call(control.parent[MODEL_INSTANCE], control, ApplicationUtil.getParentModelInstanceValue(this), control.parent[MODEL_INSTANCE])\r\n    }\r\n\r\n    private getValue(value: any) {\r\n        return value !== undefined && value !== null && value !== \"\" ? value : \"\";\r\n    }\r\n\r\n}\r\n"]}

package/esm2020/lib/form-validators/services/form-group.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1ncm91cC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Nkay9zcmMvbGliL2Zvcm0tdmFsaWRhdG9ycy9zZXJ2aWNlcy9mb3JtLWdyb3VwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGb3JtR3JvdXAgfSBmcm9tIFwiQGFuZ3VsYXIvZm9ybXNcIjtcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgRm9ybUdyb3VwRXh0ZW5zaW9uIGV4dGVuZHMgRm9ybUdyb3VwIHtcclxuICAgIGlzRGlydHk6ICgpID0+IGJvb2xlYW47XHJcbiAgICByZXNldEZvcm06ICgpID0+IHZvaWQ7XHJcbiAgICBnZXRFcnJvclN1bW1hcnk6IChvbmx5TWVzc2FnZTogYm9vbGVhbikgPT4geyBba2V5OiBzdHJpbmddOiBhbnkgfTtcclxuICAgIHRvRm9ybURhdGE6ICgpID0+IEZvcm1EYXRhO1xyXG5cclxufVxyXG4iXX0=

package/esm2020/lib/form-validators/services/reactive-form.module.mjs

@@ -0,0 +1,52 @@
+import { CommonModule, DecimalPipe } from "@angular/common";
+import { NgModule } from "@angular/core";
+import { FormBuilder, FormsModule, ReactiveFormsModule } from "@angular/forms";
+import { defaultContainer } from "../core/defaultContainer";
+import { ControlHostDirective } from '../directives/control-host.directive';
+import { HtmlControlTemplateDirective } from '../directives/html-control-template.directive';
+import { RxwebFormDirective } from "../directives/rx-form.directive";
+import { AsyncValidationDirective } from "../directives/template-validations/async-validation.directive";
+import { FileControlDirective } from "../directives/template-validations/file-control.directive";
+import { ImageFileControlDirective } from "../directives/template-validations/image-file-control.directive";
+import { RxFormControlDirective } from "../directives/template-validations/rxformcontrol.directive";
+import { DecimalProvider } from "../domain/element-processor/decimal.provider";
+import { ReactiveFormConfig } from "../util/reactive-form-config";
+import { RxFormBuilder } from "./rx-form-builder";
+import { TypedFormBuilder } from "./typed-form-builder";
+import * as i0 from "@angular/core";
+export class RxReactiveFormsModule {
+    static forRoot() { return { ngModule: RxReactiveFormsModule, providers: [] }; }
+}
+/** @nocollapse */ /** @nocollapse */ RxReactiveFormsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: RxReactiveFormsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ /** @nocollapse */ RxReactiveFormsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: RxReactiveFormsModule, declarations: [RxwebFormDirective, HtmlControlTemplateDirective, ControlHostDirective, RxFormControlDirective, FileControlDirective, ImageFileControlDirective, AsyncValidationDirective], imports: [CommonModule, FormsModule, ReactiveFormsModule], exports: [AsyncValidationDirective, RxwebFormDirective, HtmlControlTemplateDirective, RxFormControlDirective, FileControlDirective, ImageFileControlDirective] });
+/** @nocollapse */ /** @nocollapse */ RxReactiveFormsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: RxReactiveFormsModule, providers: [RxFormBuilder, DecimalProvider, DecimalPipe], imports: [[CommonModule, FormsModule, ReactiveFormsModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: RxReactiveFormsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [RxwebFormDirective, HtmlControlTemplateDirective, ControlHostDirective, RxFormControlDirective, FileControlDirective, ImageFileControlDirective, AsyncValidationDirective],
+                    imports: [CommonModule, FormsModule, ReactiveFormsModule],
+                    providers: [RxFormBuilder, DecimalProvider, DecimalPipe],
+                    exports: [AsyncValidationDirective, RxwebFormDirective, HtmlControlTemplateDirective, RxFormControlDirective, FileControlDirective, ImageFileControlDirective]
+                }]
+        }] });
+// Experimental
+export class ReactiveTypedFormsModule {
+    constructor() {
+        defaultContainer.isExperimental = true;
+        ReactiveFormConfig.autoInstancePush = true;
+    }
+    static forRoot() { return { ngModule: ReactiveTypedFormsModule, providers: [] }; }
+}
+/** @nocollapse */ /** @nocollapse */ ReactiveTypedFormsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ReactiveTypedFormsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ /** @nocollapse */ ReactiveTypedFormsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ReactiveTypedFormsModule, imports: [CommonModule, FormsModule, ReactiveFormsModule, RxReactiveFormsModule], exports: [ReactiveFormsModule, FormsModule, ReactiveFormsModule] });
+/** @nocollapse */ /** @nocollapse */ ReactiveTypedFormsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ReactiveTypedFormsModule, providers: [{ provide: FormBuilder, useClass: TypedFormBuilder }, TypedFormBuilder], imports: [[CommonModule, FormsModule, ReactiveFormsModule, RxReactiveFormsModule.forRoot()], ReactiveFormsModule, FormsModule, ReactiveFormsModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ReactiveTypedFormsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [CommonModule, FormsModule, ReactiveFormsModule, RxReactiveFormsModule.forRoot()],
+                    providers: [{ provide: FormBuilder, useClass: TypedFormBuilder }, TypedFormBuilder],
+                    exports: [ReactiveFormsModule, FormsModule, ReactiveFormsModule]
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/form-validators/services/rx-form-array.mjs

@@ -0,0 +1,100 @@
+import { FormArray } from "@angular/forms";
+import { VALUE_CHANGED_SYNC, PATCH } from "../const/app.const";
+import { isMatched, clone } from './entity.service';
+import { ObjectMaker } from '../util/object-maker';
+const PROP_ARRAY = "propArray";
+export class RxFormArray extends FormArray {
+    constructor(arrayObject, controls, validatorOrOpts, asyncValidator, arrayConfig) {
+        super(controls, validatorOrOpts, asyncValidator);
+        this.arrayObject = arrayObject;
+        this.arrayConfig = arrayConfig;
+        this._isModified = false;
+        this._modified = [];
+        this.cloneObject(arrayObject);
+    }
+    get isModified() {
+        return this._isModified;
+    }
+    push(control, options = { isAddedInstance: false }) {
+        let formGroup = this.root;
+        if (this.arrayObject)
+            if (control.modelInstance) {
+                if (!options.isAddedInstance)
+                    this.arrayObject.push(control.modelInstance);
+                else
+                    this.arrayObject[this.arrayObject.length] = control.modelInstance;
+            }
+        super.push(control);
+        if (formGroup[VALUE_CHANGED_SYNC])
+            formGroup.valueChangedSync();
+        this.patch();
+        this.checkValidation();
+    }
+    patch() {
+        this.checkModification();
+        if (this.parent)
+            this.parent[PATCH]();
+    }
+    resetForm(options) {
+        if (options && options.index >= 0 && options.groupOption) {
+            this.controls[options.index].resetForm(options.groupOption);
+        }
+        else {
+            for (var i = 0; i < this._baseValue.length; i++) {
+                if (this.controls[i] !== undefined)
+                    this.controls[i].resetForm({ value: this._baseValue[i] });
+                else if (options && options.pushFunction) {
+                    let formGroup = options.pushFunction(this._baseValue[i]);
+                    this.push(formGroup);
+                }
+            }
+        }
+    }
+    commit() {
+        this._baseValue = [];
+        for (let formGroup of this.controls) {
+            formGroup.commit();
+            this._baseValue.push(clone(formGroup.value));
+        }
+        this.patch();
+    }
+    removeAt(index, options = { isRemovedInstance: false }) {
+        let formGroup = this.root;
+        if (!options.isRemovedInstance)
+            this.arrayObject.splice(index, 1);
+        else {
+            for (var i = index; i < this.arrayObject.length - 1; i++)
+                this.arrayObject[i] = this.arrayObject[i + 1];
+            this.arrayObject.pop();
+        }
+        super.removeAt(index, options);
+        if (formGroup[VALUE_CHANGED_SYNC])
+            formGroup.valueChangedSync();
+        this.patch();
+        this.checkValidation();
+    }
+    checkValidation() {
+        setTimeout(() => {
+            if (this.arrayConfig != undefined && this.arrayConfig.allowMaxIndex && this.length > this.arrayConfig.allowMaxIndex)
+                this.setErrors(ObjectMaker.toJson(PROP_ARRAY, this.arrayConfig, [this.length, this.arrayConfig.allowMaxIndex]));
+            else if (this.errors && this.errors[PROP_ARRAY])
+                delete this.errors[PROP_ARRAY];
+        });
+    }
+    checkModification() {
+        this._isModified = !(this._baseValue.length == this.controls.length);
+        if (!this._isModified)
+            for (var i = 0; i < this.controls.length; i++) {
+                this._isModified = isMatched(this._baseValue[i], this.controls[i].value);
+                if (this._isModified)
+                    break;
+            }
+    }
+    cloneObject(value) {
+        this._baseValue = [];
+        for (let row of value) {
+            this._baseValue.push(clone(row));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rx-form-array.js","sourceRoot":"","sources":["../../../../../../projects/cdk/src/lib/form-validators/services/rx-form-array.ts"],"names":[],"mappings":"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","sourcesContent":["import { FormArray } from \"@angular/forms\";\r\nimport { VALUE_CHANGED_SYNC, PATCH } from \"../const/app.const\";\r\nimport { isMatched, clone } from './entity.service'\r\nimport { ResetFormType } from \"../enums/reset-type\";\r\nimport { ObjectMaker } from '../util/object-maker'\r\nconst PROP_ARRAY: string = \"propArray\";\r\nexport class RxFormArray extends FormArray {\r\n    private _baseValue: any[];\r\n    private _isModified: boolean = false;\r\n    private _modified: any[] = [];\r\n    constructor(private arrayObject: any[], controls, validatorOrOpts?: any, asyncValidator?: any, private arrayConfig?: { allowMaxIndex?: number, messageKey?: string }) {\r\n        super(controls, validatorOrOpts, asyncValidator);\r\n        this.cloneObject(arrayObject);\r\n    }\r\n\r\n    get isModified() {\r\n        return this._isModified;\r\n    }\r\n\r\n    push(control: any, options: {\r\n        emitEvent?: boolean,\r\n        isAddedInstance: boolean \r\n    } = { isAddedInstance: false}) {\r\n        let formGroup: any = this.root;\r\n        if (this.arrayObject)\r\n            if (control.modelInstance) {\r\n                if (!options.isAddedInstance)\r\n                    this.arrayObject.push(control.modelInstance);\r\n                else\r\n                    this.arrayObject[this.arrayObject.length] = control.modelInstance\r\n            }\r\n            \r\n        super.push(control);\r\n        if (formGroup[VALUE_CHANGED_SYNC])\r\n            formGroup.valueChangedSync()\r\n        this.patch()\r\n        this.checkValidation()\r\n    }\r\n\r\n    patch() {\r\n        this.checkModification();\r\n        if (this.parent)\r\n            this.parent[PATCH]();\r\n\r\n    }\r\n\r\n    resetForm(options?: {\r\n        index: number,\r\n        groupOption: {\r\n            resetType?: ResetFormType,\r\n            with?: string[],\r\n            value?: { [key: string]: any }\r\n        },\r\n        pushFunction: (value: Object) => boolean;\r\n    }) {\r\n        if (options && options.index >= 0 && options.groupOption) {\r\n            (<any>this.controls[options.index]).resetForm(options.groupOption)\r\n        } else {\r\n            for (var i = 0; i < this._baseValue.length; i++) {\r\n                if (this.controls[i] !== undefined)\r\n                    (<any>this.controls[i]).resetForm({ value: this._baseValue[i] });\r\n                else\r\n                    if (options && options.pushFunction) {\r\n                        let formGroup = options.pushFunction(this._baseValue[i]);\r\n                        this.push(formGroup);\r\n                    }\r\n            }\r\n        }\r\n    }\r\n\r\n\r\n\r\n    commit() {\r\n        this._baseValue = []\r\n        for (let formGroup of this.controls) {\r\n            (<any>formGroup).commit();\r\n            this._baseValue.push(clone(formGroup.value));\r\n        }\r\n        this.patch();\r\n    }\r\n\r\n\r\n    removeAt(index: number, options: { emitEvent?: boolean, isRemovedInstance?: boolean } = { isRemovedInstance: false }) {\r\n        let formGroup: any = this.root;\r\n        if (!options.isRemovedInstance)\r\n            this.arrayObject.splice(index, 1);\r\n        else {\r\n            for (var i = index; i < this.arrayObject.length - 1; i++)\r\n                this.arrayObject[i] = this.arrayObject[i + 1];\r\n            this.arrayObject.pop();\r\n        }\r\n\r\n\r\n        super.removeAt(index,options);\r\n        if (formGroup[VALUE_CHANGED_SYNC])\r\n            formGroup.valueChangedSync()\r\n        this.patch()\r\n        this.checkValidation();\r\n    }\r\n\r\n    private checkValidation() {\r\n        setTimeout(() => {\r\n            if (this.arrayConfig != undefined && this.arrayConfig.allowMaxIndex && this.length > this.arrayConfig.allowMaxIndex)\r\n                this.setErrors(ObjectMaker.toJson(PROP_ARRAY, this.arrayConfig, [this.length, this.arrayConfig.allowMaxIndex]));\r\n            else if (this.errors && this.errors[PROP_ARRAY])\r\n                delete this.errors[PROP_ARRAY];\r\n        })\r\n    }\r\n\r\n    private checkModification() {\r\n        this._isModified = !(this._baseValue.length == this.controls.length);\r\n        if (!this._isModified)\r\n            for (var i = 0; i < this.controls.length; i++) {\r\n                this._isModified = isMatched(this._baseValue[i], this.controls[i].value)\r\n                if (this._isModified)\r\n                    break;\r\n            }\r\n    }\r\n\r\n    private cloneObject(value: any[]) {\r\n        this._baseValue = [];\r\n        for (let row of value) {\r\n            this._baseValue.push(clone(row));\r\n        }\r\n    }\r\n\r\n\r\n}\r\n"]}