@messaia/cdk 0.0.0-CDK

package/esm2020/lib/form-validators/directives/template-validations/rxformcontrol.directive.mjs

@@ -0,0 +1,277 @@
+import { Directive, ElementRef, forwardRef, Input, Renderer2 } from '@angular/core';
+import { NG_VALIDATORS } from '@angular/forms';
+import { BLANK, BLUR, ELEMENT_VALUE, FOCUS } from "../../const";
+import { APP_VALIDATORS } from '../../const/app-validators.const';
+import { CONDITIONAL_VALIDATOR, TEMPLATE_VALIDATION_CONFIG, VALIDATOR_CONFIG } from '../../const/app.const';
+import { DecimalProvider } from "../../domain/element-processor/decimal.provider";
+import { MaskProvider } from '../../domain/element-processor/mask.provider';
+import { RegexValidator } from '../../util';
+import { ApplicationUtil } from '../../util/app-util';
+import { BaseValidator } from './base-validator.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "../../domain/element-processor/decimal.provider";
+const NGMODEL_BINDING = {
+    provide: NG_VALIDATORS,
+    useExisting: forwardRef(() => RxFormControlDirective),
+    multi: true
+};
+const ALLOW_VALIDATOR_WITHOUT_CONFIG = ['required', 'notEmpty', 'alpha', 'alphaNumeric', 'ascii', 'dataUri', 'digit', 'email', 'even', 'hexColor', 'json', 'latitude', 'latLong', 'leapYear', 'longitude', 'lowerCase', 'mac', 'odd', 'port', 'primeNumber', 'time', 'upperCase', 'url', 'unique', 'cusip', 'gird'];
+const NUMERIC = "numeric";
+const IS_FORMAT = "isFormat";
+const DIGITS_INFO = "digitsInfo";
+export class RxFormControlDirective extends BaseValidator {
+    constructor(elementRef, renderer, decimalProvider) {
+        super();
+        this.elementRef = elementRef;
+        this.renderer = renderer;
+        this.decimalProvider = decimalProvider;
+        this.eventListeners = [];
+        this.isNumericSubscribed = false;
+        this.isFocusCalled = false;
+        this.isMasked = false;
+        this.element = elementRef.nativeElement;
+        this.setEventName();
+    }
+    set validationControls(value) {
+        this.controls = value;
+    }
+    get validationControls() {
+        return this.controls;
+    }
+    ngOnInit() {
+        let validators = [];
+        Object.keys(APP_VALIDATORS).forEach(validatorName => {
+            if ((this[`rx${validatorName}`]) || (ALLOW_VALIDATOR_WITHOUT_CONFIG.indexOf(validatorName) != -1 && this[`rx${validatorName}`] == BLANK)) {
+                validators.push(APP_VALIDATORS[validatorName](this[`rx${validatorName}`]));
+                if (this.name && !(this.formControlName && this.formControl)) {
+                    ApplicationUtil.configureControl(this.controlConfig, this[`rx${validatorName}`], validatorName);
+                }
+            }
+        });
+        if (validators.length > 0)
+            this.validators = validators;
+        if (this.rxnumeric && (this.rxnumeric.isFormat || this.rxnumeric.digitsInfo)) {
+            this.bindNumericElementEvent();
+        }
+    }
+    blurEvent() {
+        if (!(this.formControl && this.formControl.errors && this.formControl.errors.numeric)) {
+            if (this.formControl.value !== null && this.formControl.value !== undefined) {
+                let value = this.decimalProvider.transFormDecimal(this.formControl.value, this.rxnumeric.digitsInfo);
+                value = (!this.rxnumeric.isFormat) ? this.decimalProvider.replacer(value) : value;
+                this.setValueOnElement(value);
+            }
+            this.isFocusCalled = false;
+        }
+    }
+    bindNumericElementEvent(config) {
+        if (config)
+            this.rxnumeric = config;
+        let listener = this.renderer.listen(this.element, BLUR, this.blurEvent.bind(this));
+        this.eventListeners.push(listener);
+        listener = this.renderer.listen(this.element, FOCUS, (event) => {
+            this.isFocusCalled = true;
+            if (!(this.formControl && this.formControl.errors && this.formControl.errors.numeric) && this.formControl.value != null) {
+                let value = this.decimalProvider.replacer(this.element.value);
+                this.setValueOnElement(value);
+            }
+        });
+        this.eventListeners.push(listener);
+    }
+    bindValueChangeEvent() {
+        if (this.eventName != BLANK) {
+            let listener = this.renderer.listen(this.element, this.eventName, () => {
+                Object.keys(this.validationControls).forEach(fieldName => {
+                    this.validationControls[fieldName].updateValueAndValidity();
+                });
+            });
+            this.eventListeners.push(listener);
+        }
+    }
+    subscribeNumericFormatter() {
+        if (this.formControl[VALIDATOR_CONFIG] && this.formControl[VALIDATOR_CONFIG][NUMERIC] && (this.formControl[VALIDATOR_CONFIG][NUMERIC][IS_FORMAT] || this.formControl[VALIDATOR_CONFIG][NUMERIC][DIGITS_INFO])) {
+            if (!this.isNumericSubscribed) {
+                this.bindNumericElementEvent(this.formControl[VALIDATOR_CONFIG][NUMERIC]);
+                this.isNumericSubscribed = true;
+            }
+            if (!this.isFocusCalled && RegexValidator.isNotBlank(this.formControl.value)) {
+                this.blurEvent();
+            }
+        }
+    }
+    subscribeMaskValidator() {
+        if (this.formControl[VALIDATOR_CONFIG] && this.formControl[VALIDATOR_CONFIG]["mask"] && !this.isMasked) {
+            let config = this.formControl[VALIDATOR_CONFIG]["mask"];
+            this.maskProvider = new MaskProvider(this.element, config.mask, this.renderer, this.formControl, config);
+            this.isMasked = true;
+        }
+    }
+    setValueOnElement(value) {
+        this.renderer.setProperty(this.element, ELEMENT_VALUE, value);
+    }
+    setTemplateValidators(control) {
+        for (let validatorName in control[VALIDATOR_CONFIG]) {
+            this[validatorName] = control[VALIDATOR_CONFIG][validatorName];
+        }
+        delete control[TEMPLATE_VALIDATION_CONFIG];
+        delete control[VALIDATOR_CONFIG];
+        this.ngOnInit();
+    }
+    updateOnElementClass(element) {
+        var previousClassName = '';
+        return function (className) {
+            if (previousClassName)
+                element.classList.remove(previousClassName);
+            if (className)
+                element.classList.add(className);
+            previousClassName = className;
+        };
+    }
+    setValidatorConfig(control) {
+        if (!this.formControl) {
+            this.formControl = control;
+            let rxFormControl = this.formControl;
+            if (rxFormControl.updateOnElementClass)
+                rxFormControl.updateOnElementClass = this.updateOnElementClass(this.element);
+        }
+        this.subscribeMaskValidator();
+        this.subscribeNumericFormatter();
+        if (control[TEMPLATE_VALIDATION_CONFIG])
+            this.setTemplateValidators(control);
+        if (control[CONDITIONAL_VALIDATOR]) {
+            this.conditionalValidator = control[CONDITIONAL_VALIDATOR];
+            delete control[CONDITIONAL_VALIDATOR];
+        }
+    }
+    validate(control) {
+        this.setValidatorConfig(control);
+        if (this.conditionalValidator)
+            this.conditionalValidator(control);
+        if (!this.isProcessed)
+            this.setModelConfig(control);
+        return ((this.validators && this.validators.length > 0) || this.maskProvider) ? this.validation(control) : null;
+    }
+    ngOnDestroy() {
+        this.controls = undefined;
+        let eventCount = this.eventListeners.length;
+        for (var i = 0; i < eventCount; i++) {
+            this.eventListeners[0]();
+            this.eventListeners.splice(0, 1);
+        }
+        this.eventListeners = [];
+        if (this.maskProvider)
+            this.maskProvider.onDestroy();
+    }
+}
+/** @nocollapse */ /** @nocollapse */ RxFormControlDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: RxFormControlDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.DecimalProvider }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ /** @nocollapse */ RxFormControlDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.0", type: RxFormControlDirective, selector: "[ngModel],[formControlName],[formControl]", inputs: { rxalpha: "rxalpha", rxalphaNumeric: "rxalphaNumeric", rxascii: "rxascii", rxcompare: "rxcompare", rxcompose: "rxcompose", rxcontains: "rxcontains", rxcreditCard: "rxcreditCard", rxdataUri: "rxdataUri", rxdifferent: "rxdifferent", rxdigit: "rxdigit", rxemail: "rxemail", rxendsWith: "rxendsWith", rxeven: "rxeven", rxextension: "rxextension", rxfactor: "rxfactor", rxfileSize: "rxfileSize", rxgreaterThanEqualTo: "rxgreaterThanEqualTo", rxgreaterThan: "rxgreaterThan", rxhexColor: "rxhexColor", rxjson: "rxjson", rxlatitude: "rxlatitude", rxlatLong: "rxlatLong", rxleapYear: "rxleapYear", rxlessThan: "rxlessThan", rxlessThanEqualTo: "rxlessThanEqualTo", rxlongitude: "rxlongitude", rxlowerCase: "rxlowerCase", rxmac: "rxmac", rxmaxDate: "rxmaxDate", rxmaxLength: "rxmaxLength", rxmaxNumber: "rxmaxNumber", rxminDate: "rxminDate", rxminLength: "rxminLength", rxminNumber: "rxminNumber", rxnumeric: "rxnumeric", rxodd: "rxodd", rxpassword: "rxpassword", rxport: "rxport", rxprimeNumber: "rxprimeNumber", rxrequired: "rxrequired", rxrange: "rxrange", rxrule: "rxrule", rxstartsWith: "rxstartsWith", rxtime: "rxtime", rxupperCase: "rxupperCase", rxurl: "rxurl", rxunique: "rxunique", rxnotEmpty: "rxnotEmpty", rxcusip: "rxcusip", rxgrid: "rxgrid", rxdate: "rxdate" }, providers: [NGMODEL_BINDING], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: RxFormControlDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ngModel],[formControlName],[formControl]',
+                    providers: [NGMODEL_BINDING],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.DecimalProvider }]; }, propDecorators: { rxalpha: [{
+                type: Input
+            }], rxalphaNumeric: [{
+                type: Input
+            }], rxascii: [{
+                type: Input
+            }], rxcompare: [{
+                type: Input
+            }], rxcompose: [{
+                type: Input
+            }], rxcontains: [{
+                type: Input
+            }], rxcreditCard: [{
+                type: Input
+            }], rxdataUri: [{
+                type: Input
+            }], rxdifferent: [{
+                type: Input
+            }], rxdigit: [{
+                type: Input
+            }], rxemail: [{
+                type: Input
+            }], rxendsWith: [{
+                type: Input
+            }], rxeven: [{
+                type: Input
+            }], rxextension: [{
+                type: Input
+            }], rxfactor: [{
+                type: Input
+            }], rxfileSize: [{
+                type: Input
+            }], rxgreaterThanEqualTo: [{
+                type: Input
+            }], rxgreaterThan: [{
+                type: Input
+            }], rxhexColor: [{
+                type: Input
+            }], rxjson: [{
+                type: Input
+            }], rxlatitude: [{
+                type: Input
+            }], rxlatLong: [{
+                type: Input
+            }], rxleapYear: [{
+                type: Input
+            }], rxlessThan: [{
+                type: Input
+            }], rxlessThanEqualTo: [{
+                type: Input
+            }], rxlongitude: [{
+                type: Input
+            }], rxlowerCase: [{
+                type: Input
+            }], rxmac: [{
+                type: Input
+            }], rxmaxDate: [{
+                type: Input
+            }], rxmaxLength: [{
+                type: Input
+            }], rxmaxNumber: [{
+                type: Input
+            }], rxminDate: [{
+                type: Input
+            }], rxminLength: [{
+                type: Input
+            }], rxminNumber: [{
+                type: Input
+            }], rxnumeric: [{
+                type: Input
+            }], rxodd: [{
+                type: Input
+            }], rxpassword: [{
+                type: Input
+            }], rxport: [{
+                type: Input
+            }], rxprimeNumber: [{
+                type: Input
+            }], rxrequired: [{
+                type: Input
+            }], rxrange: [{
+                type: Input
+            }], rxrule: [{
+                type: Input
+            }], rxstartsWith: [{
+                type: Input
+            }], rxtime: [{
+                type: Input
+            }], rxupperCase: [{
+                type: Input
+            }], rxurl: [{
+                type: Input
+            }], rxunique: [{
+                type: Input
+            }], rxnotEmpty: [{
+                type: Input
+            }], rxcusip: [{
+                type: Input
+            }], rxgrid: [{
+                type: Input
+            }], rxdate: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rxformcontrol.directive.js","sourceRoot":"","sources":["../../../../../../../projects/cdk/src/lib/form-validators/directives/template-validations/rxformcontrol.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, forwardRef, Input, OnDestroy, OnInit, Renderer2 } from '@angular/core';\r\nimport { AbstractControl, FormControl, NG_VALIDATORS, Validator } from '@angular/forms';\r\nimport { BLANK, BLUR, ELEMENT_VALUE, FOCUS } from \"../../const\";\r\nimport { APP_VALIDATORS } from '../../const/app-validators.const';\r\nimport { CONDITIONAL_VALIDATOR, TEMPLATE_VALIDATION_CONFIG, VALIDATOR_CONFIG } from '../../const/app.const';\r\nimport { DecimalProvider } from \"../../domain/element-processor/decimal.provider\";\r\nimport { MaskProvider } from '../../domain/element-processor/mask.provider';\r\nimport { AlphaConfig, BaseConfig, CompareConfig, ComposeConfig, ContainsConfig, CreditCardConfig, DateConfig, DefaultConfig, DifferentConfig, DigitConfig, EmailConfig, ExtensionConfig, FactorConfig, MessageConfig, NumberConfig, NumericConfig, PasswordConfig, RangeConfig, RelationalOperatorConfig, RequiredConfig, RuleConfig, SizeConfig, TimeConfig, UniqueConfig } from '../../models/config';\r\nimport { RxFormControl } from \"../../services/form-control\";\r\nimport { RegexValidator } from '../../util';\r\nimport { ApplicationUtil } from '../../util/app-util';\r\nimport { BaseValidator } from './base-validator.directive';\r\n\r\nconst NGMODEL_BINDING: any = {\r\n    provide: NG_VALIDATORS,\r\n    useExisting: forwardRef(() => RxFormControlDirective),\r\n    multi: true\r\n};\r\n\r\nconst ALLOW_VALIDATOR_WITHOUT_CONFIG = ['required', 'notEmpty', 'alpha', 'alphaNumeric', 'ascii', 'dataUri', 'digit', 'email', 'even', 'hexColor', 'json', 'latitude', 'latLong', 'leapYear', 'longitude', 'lowerCase', 'mac', 'odd', 'port', 'primeNumber', 'time', 'upperCase', 'url', 'unique', 'cusip', 'gird'];\r\nconst NUMERIC: string = \"numeric\";\r\nconst IS_FORMAT: string = \"isFormat\";\r\nconst DIGITS_INFO: string = \"digitsInfo\";\r\n\r\n@Directive({\r\n    selector: '[ngModel],[formControlName],[formControl]',\r\n    providers: [NGMODEL_BINDING],\r\n})\r\nexport class RxFormControlDirective extends BaseValidator implements OnInit, OnDestroy, Validator {\r\n    private eventListeners: any[] = [];\r\n    private isNumericSubscribed: boolean = false;\r\n    private isFocusCalled: boolean = false;\r\n    private isMasked: boolean = false;\r\n\r\n\r\n    set validationControls(value: { [key: string]: FormControl }) {\r\n        this.controls = value;\r\n    }\r\n\r\n    get validationControls() {\r\n        return this.controls;\r\n    }\r\n\r\n    @Input() rxalpha: AlphaConfig;\r\n    @Input() rxalphaNumeric: AlphaConfig;\r\n    @Input() rxascii: BaseConfig;\r\n    @Input() rxcompare: CompareConfig;\r\n    @Input() rxcompose: ComposeConfig;\r\n    @Input() rxcontains: ContainsConfig;\r\n    @Input() rxcreditCard: CreditCardConfig;\r\n    @Input() rxdataUri: BaseConfig;\r\n    @Input() rxdifferent: DifferentConfig;\r\n    @Input() rxdigit: DigitConfig;\r\n    @Input() rxemail: EmailConfig;\r\n    @Input() rxendsWith: DefaultConfig;\r\n    @Input() rxeven: BaseConfig;\r\n    @Input() rxextension: ExtensionConfig;\r\n    @Input() rxfactor: FactorConfig;\r\n    @Input() rxfileSize: SizeConfig;\r\n    @Input() rxgreaterThanEqualTo: RelationalOperatorConfig;\r\n    @Input() rxgreaterThan: RelationalOperatorConfig;\r\n    @Input() rxhexColor: MessageConfig;\r\n    @Input() rxjson: DefaultConfig;\r\n    @Input() rxlatitude: BaseConfig;\r\n    @Input() rxlatLong: BaseConfig;\r\n    @Input() rxleapYear: BaseConfig;\r\n    @Input() rxlessThan: RelationalOperatorConfig;\r\n    @Input() rxlessThanEqualTo: RelationalOperatorConfig;\r\n    @Input() rxlongitude: BaseConfig;\r\n    @Input() rxlowerCase: MessageConfig;\r\n    @Input() rxmac: BaseConfig;\r\n    @Input() rxmaxDate: DateConfig;\r\n    @Input() rxmaxLength: NumberConfig;\r\n    @Input() rxmaxNumber: NumberConfig;\r\n    @Input() rxminDate: DateConfig;\r\n    @Input() rxminLength: NumberConfig;\r\n    @Input() rxminNumber: NumberConfig;\r\n    @Input() rxnumeric: NumericConfig;\r\n    @Input() rxodd: BaseConfig;\r\n    @Input() rxpassword: PasswordConfig;\r\n    @Input() rxport: BaseConfig;\r\n    @Input() rxprimeNumber: BaseConfig;\r\n    @Input() rxrequired: RequiredConfig;\r\n    @Input() rxrange: RangeConfig;\r\n    @Input() rxrule: RuleConfig;\r\n    @Input() rxstartsWith: DefaultConfig;\r\n    @Input() rxtime: TimeConfig;\r\n    @Input() rxupperCase: MessageConfig;\r\n    @Input() rxurl: DefaultConfig;\r\n    @Input() rxunique: UniqueConfig;\r\n    @Input() rxnotEmpty: BaseConfig;\r\n    @Input() rxcusip: BaseConfig;\r\n    @Input() rxgrid: BaseConfig;\r\n    @Input() rxdate: BaseConfig;\r\n\r\n\r\n\r\n    constructor(private elementRef: ElementRef,\r\n        private renderer: Renderer2, private decimalProvider: DecimalProvider) {\r\n        super();\r\n        this.element = elementRef.nativeElement as Node;\r\n        this.setEventName();\r\n    }\r\n\r\n    ngOnInit() {\r\n        let validators = [];\r\n        Object.keys(APP_VALIDATORS).forEach(validatorName => {\r\n            if ((this[`rx${validatorName}`]) || (ALLOW_VALIDATOR_WITHOUT_CONFIG.indexOf(validatorName) != -1 && this[`rx${validatorName}`] == BLANK)) {\r\n                validators.push(APP_VALIDATORS[validatorName](this[`rx${validatorName}`]));\r\n                if (this.name && !(this.formControlName && this.formControl)) {\r\n                    ApplicationUtil.configureControl(this.controlConfig, this[`rx${validatorName}`], validatorName);\r\n                }\r\n\r\n            }\r\n        })\r\n        if (validators.length > 0)\r\n            this.validators = validators\r\n        if (this.rxnumeric && (this.rxnumeric.isFormat || this.rxnumeric.digitsInfo)) {\r\n            this.bindNumericElementEvent();\r\n        }\r\n\r\n    }\r\n\r\n\r\n    blurEvent() {\r\n        if (!(this.formControl && this.formControl.errors && this.formControl.errors.numeric)) {\r\n            if (this.formControl.value !== null && this.formControl.value !== undefined) {\r\n                let value = this.decimalProvider.transFormDecimal(this.formControl.value, this.rxnumeric.digitsInfo);\r\n                value = (!this.rxnumeric.isFormat) ? this.decimalProvider.replacer(value) : value;\r\n                this.setValueOnElement(value);\r\n            }\r\n            this.isFocusCalled = false;\r\n        }\r\n    }\r\n\r\n    bindNumericElementEvent(config?: NumericConfig) {\r\n        if (config)\r\n            this.rxnumeric = config;\r\n        let listener = this.renderer.listen(this.element, BLUR, this.blurEvent.bind(this));\r\n        this.eventListeners.push(listener)\r\n        listener = this.renderer.listen(this.element, FOCUS, (event) => {\r\n            this.isFocusCalled = true;\r\n            if (!(this.formControl && this.formControl.errors && this.formControl.errors.numeric) && this.formControl.value != null) {\r\n                let value = this.decimalProvider.replacer(this.element.value);\r\n                this.setValueOnElement(value);\r\n            }\r\n        });\r\n        this.eventListeners.push(listener)\r\n    }\r\n\r\n    bindValueChangeEvent() {\r\n        if (this.eventName != BLANK) {\r\n            let listener = this.renderer.listen(this.element, this.eventName, () => {\r\n                Object.keys(this.validationControls).forEach(fieldName => {\r\n                    this.validationControls[fieldName].updateValueAndValidity();\r\n                })\r\n            });\r\n            this.eventListeners.push(listener);\r\n        }\r\n    }\r\n\r\n    subscribeNumericFormatter() {\r\n        if (this.formControl[VALIDATOR_CONFIG] && this.formControl[VALIDATOR_CONFIG][NUMERIC] && (this.formControl[VALIDATOR_CONFIG][NUMERIC][IS_FORMAT] || this.formControl[VALIDATOR_CONFIG][NUMERIC][DIGITS_INFO])) {\r\n            if (!this.isNumericSubscribed) {\r\n                this.bindNumericElementEvent(this.formControl[VALIDATOR_CONFIG][NUMERIC]);\r\n                this.isNumericSubscribed = true;\r\n            }\r\n            if (!this.isFocusCalled && RegexValidator.isNotBlank(this.formControl.value)) {\r\n                this.blurEvent();\r\n            }\r\n        }\r\n\r\n    }\r\n\r\n    subscribeMaskValidator() {\r\n        if (this.formControl[VALIDATOR_CONFIG] && this.formControl[VALIDATOR_CONFIG][\"mask\"] && !this.isMasked) {\r\n            let config = this.formControl[VALIDATOR_CONFIG][\"mask\"];\r\n            this.maskProvider = new MaskProvider(this.element, config.mask, this.renderer, this.formControl as FormControl, config);\r\n            this.isMasked = true;\r\n        }\r\n    }\r\n\r\n    private setValueOnElement(value: any) {\r\n        this.renderer.setProperty(this.element, ELEMENT_VALUE, value);\r\n    }\r\n\r\n    private setTemplateValidators(control: AbstractControl) {\r\n        for (let validatorName in control[VALIDATOR_CONFIG]) {\r\n            this[validatorName] = control[VALIDATOR_CONFIG][validatorName];\r\n        }\r\n        delete control[TEMPLATE_VALIDATION_CONFIG];\r\n        delete control[VALIDATOR_CONFIG]\r\n        this.ngOnInit();\r\n    }\r\n\r\n    private updateOnElementClass(element: HTMLElement) {\r\n        var previousClassName: string = '';\r\n        return function (className: string) {\r\n            if (previousClassName)\r\n                element.classList.remove(previousClassName);\r\n            if (className)\r\n                element.classList.add(className)\r\n            previousClassName = className;\r\n        }\r\n    }\r\n\r\n    private setValidatorConfig(control: AbstractControl) {\r\n        if (!this.formControl) {\r\n            this.formControl = control;\r\n            let rxFormControl = this.formControl as RxFormControl;\r\n            if (rxFormControl.updateOnElementClass)\r\n                rxFormControl.updateOnElementClass = this.updateOnElementClass(this.element);\r\n        }\r\n\r\n        this.subscribeMaskValidator();\r\n        this.subscribeNumericFormatter();\r\n        if (control[TEMPLATE_VALIDATION_CONFIG])\r\n            this.setTemplateValidators(control);\r\n        if (control[CONDITIONAL_VALIDATOR]) {\r\n            this.conditionalValidator = control[CONDITIONAL_VALIDATOR];\r\n            delete control[CONDITIONAL_VALIDATOR];\r\n        }\r\n\r\n    }\r\n\r\n    validate(control: AbstractControl): { [key: string]: any } {\r\n        this.setValidatorConfig(control);\r\n        if (this.conditionalValidator)\r\n            this.conditionalValidator(control);\r\n        if (!this.isProcessed)\r\n            this.setModelConfig(control);\r\n        return ((this.validators && this.validators.length > 0) || this.maskProvider) ? this.validation(control) : null;\r\n    }\r\n\r\n    ngOnDestroy() {\r\n        this.controls = undefined;\r\n        let eventCount = this.eventListeners.length;\r\n        for (var i = 0; i < eventCount; i++) {\r\n            this.eventListeners[0]();\r\n            this.eventListeners.splice(0, 1);\r\n        }\r\n        this.eventListeners = [];\r\n        if (this.maskProvider)\r\n            this.maskProvider.onDestroy();\r\n    }\r\n}\r\n"]}

package/esm2020/lib/form-validators/domain/disable-provider.mjs

@@ -0,0 +1,93 @@
+import { MODEL_INSTANCE, RXCODE } from "../const/app.const";
+import { OBJECT_PROPERTY } from "../const/validator.const";
+import { defaultContainer } from "../core/defaultContainer";
+import { ApplicationUtil } from "../util/app-util";
+import { instanceProvider } from "../util/instance-provider.function";
+export class DisableProvider {
+    constructor(decoratorType, entityObject) {
+        this.decoratorType = decoratorType;
+        this.entityObject = entityObject;
+    }
+    getFormGroupName(currentFormGroup) {
+        let keyName = '';
+        if (currentFormGroup.parent)
+            for (var controlName of Object.keys(currentFormGroup.parent.controls))
+                if (currentFormGroup.parent.controls[controlName] == currentFormGroup) {
+                    keyName = controlName;
+                    break;
+                }
+        return keyName;
+    }
+    zeroArgumentProcess(control, columnName) {
+        let disabledColumns = [];
+        this.getDisabledColumns(control.parent, `${columnName}${RXCODE}0`, false).forEach(t => disabledColumns.push(t));
+        let path = this.topControlPath(control, columnName);
+        let splitPath = path.split(".");
+        if (splitPath.length > 1) {
+            let rootFormGroup = ApplicationUtil.getRootFormGroup(control);
+            this.getDisabledColumns(rootFormGroup, `${path}${RXCODE}0`, true).forEach(t => disabledColumns.push(t));
+            let controlPath = '';
+            for (var i = 0; i < splitPath.length - 2; i++) {
+                let controlName = splitPath[i];
+                controlPath = `${path.replace(`${controlName}.`, '')}${RXCODE}-0`;
+                if (rootFormGroup.controls[controlName]) {
+                    this.getDisabledColumns(rootFormGroup.controls[controlName], controlPath, true, controlName).forEach(t => disabledColumns.push(t));
+                    rootFormGroup = rootFormGroup.controls[controlName];
+                }
+            }
+        }
+        return disabledColumns;
+    }
+    getDisabledColumns(formGroup, columnName, isRoot, pathName = "") {
+        if (formGroup[MODEL_INSTANCE]) {
+            let instanceContainer = instanceProvider(formGroup[MODEL_INSTANCE].constructor, this.entityObject);
+            return this.getChangeDetectionColumns(instanceContainer, columnName, isRoot, pathName);
+        }
+        return [];
+    }
+    getChangeDetectionColumns(instanceContainer, columnName, isRoot, pathName = "") {
+        let conditionalDisableControls = [];
+        let columns = instanceContainer.nonValidationDecorators[this.decoratorType].changeDetection[columnName];
+        if (columns) {
+            columns.forEach(t => {
+                conditionalDisableControls.push({ controlPath: pathName ? `${pathName}.${t}` : t, conditionalExpression: instanceContainer.nonValidationDecorators[this.decoratorType].conditionalExpressions[t], isRoot: isRoot });
+            });
+        }
+        return conditionalDisableControls;
+    }
+    topControlPath(control, columnName) {
+        if (control.parent) {
+            let name = this.getFormGroupName(control.parent);
+            if (name) {
+                columnName = `${name}.${columnName}`;
+                return this.topControlPath(control.parent, columnName);
+            }
+        }
+        return columnName;
+    }
+    childControlDisabledExpression(formGroup, columnName, path = "") {
+        let disabledColumns = [];
+        if (formGroup[MODEL_INSTANCE]) {
+            let instanceContainer = defaultContainer.get(formGroup[MODEL_INSTANCE].constructor);
+            if (instanceContainer) {
+                this.getChangeDetectionColumns(instanceContainer, columnName, true, path).forEach(t => disabledColumns.push(t));
+                var props = instanceContainer.properties.filter(t => t.propertyType == OBJECT_PROPERTY);
+                props.forEach(t => {
+                    if (formGroup.controls[t.name]) {
+                        let columns = this.getDisabledColumns(formGroup.controls[t.name], columnName, true, path ? `${path}.${t.name}` : `${t.name}`);
+                        columns.forEach(x => disabledColumns.push(x));
+                        this.childControlDisabledExpression(formGroup.controls[t.name], columnName, path ? `${path}.${t.name}` : `${t.name}`).forEach(y => disabledColumns.push(y));
+                    }
+                });
+            }
+        }
+        return disabledColumns;
+    }
+    oneArgumentProcess(control, columnName) {
+        let path = this.topControlPath(control, columnName);
+        let rootFormGroup = ApplicationUtil.getRootFormGroup(control);
+        let childColumns = this.childControlDisabledExpression(rootFormGroup, path);
+        return childColumns;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"disable-provider.js","sourceRoot":"","sources":["../../../../../../projects/cdk/src/lib/form-validators/domain/disable-provider.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractControl, FormGroup } from \"@angular/forms\";\r\nimport { MODEL_INSTANCE, RXCODE } from \"../const/app.const\";\r\nimport { OBJECT_PROPERTY } from \"../const/validator.const\";\r\nimport { defaultContainer } from \"../core/defaultContainer\";\r\nimport { InstanceContainer } from \"../core/validator.interface\";\r\nimport { ApplicationUtil } from \"../util/app-util\";\r\nimport { instanceProvider } from \"../util/instance-provider.function\";\r\n\r\nexport class DisableProvider {\r\n\r\n    constructor(private decoratorType: string, private entityObject: { [key: string]: any }) { }\r\n\r\n    getFormGroupName(currentFormGroup: FormGroup) {\r\n        let keyName = '';\r\n        if (currentFormGroup.parent)\r\n            for (var controlName of Object.keys(currentFormGroup.parent.controls))\r\n                if (currentFormGroup.parent.controls[controlName] == currentFormGroup) {\r\n                    keyName = controlName;\r\n                    break;\r\n                }\r\n        return keyName;\r\n    }\r\n\r\n    zeroArgumentProcess(control: AbstractControl, columnName: string) {\r\n        let disabledColumns = [];\r\n        this.getDisabledColumns(<FormGroup>control.parent, `${columnName}${RXCODE}0`, false).forEach(t => disabledColumns.push(t));\r\n        let path = this.topControlPath(control, columnName);\r\n        let splitPath = path.split(\".\");\r\n        if (splitPath.length > 1) {\r\n            let rootFormGroup = ApplicationUtil.getRootFormGroup(control);\r\n            this.getDisabledColumns(rootFormGroup, `${path}${RXCODE}0`, true).forEach(t => disabledColumns.push(t));\r\n            let controlPath: string = '';\r\n            for (var i = 0; i < splitPath.length - 2; i++) {\r\n                let controlName = splitPath[i];\r\n                controlPath = `${path.replace(`${controlName}.`, '')}${RXCODE}-0`\r\n                if (rootFormGroup.controls[controlName]) {\r\n                    this.getDisabledColumns(<FormGroup>rootFormGroup.controls[controlName], controlPath, true, controlName).forEach(t => disabledColumns.push(t));\r\n                    rootFormGroup = <FormGroup>rootFormGroup.controls[controlName];\r\n                }\r\n            }\r\n        }\r\n        return disabledColumns;\r\n    }\r\n\r\n    private getDisabledColumns(formGroup: FormGroup, columnName: string, isRoot: Boolean, pathName: string = \"\") {\r\n        if (formGroup[MODEL_INSTANCE]) {\r\n            let instanceContainer = instanceProvider(formGroup[MODEL_INSTANCE].constructor, this.entityObject);\r\n            return this.getChangeDetectionColumns(instanceContainer, columnName, isRoot, pathName)\r\n        } return [];\r\n    }\r\n\r\n    private getChangeDetectionColumns(instanceContainer: InstanceContainer, columnName: string, isRoot: Boolean, pathName: string = \"\") {\r\n        let conditionalDisableControls = [];\r\n        let columns = instanceContainer.nonValidationDecorators[this.decoratorType].changeDetection[columnName]\r\n        if (columns) {\r\n            columns.forEach(t => {\r\n                conditionalDisableControls.push({ controlPath: pathName ? `${pathName}.${t}` : t, conditionalExpression: instanceContainer.nonValidationDecorators[this.decoratorType].conditionalExpressions[t], isRoot: isRoot })\r\n            })\r\n        }\r\n        return conditionalDisableControls;\r\n    }\r\n\r\n    private topControlPath(control: AbstractControl | FormGroup, columnName: string) {\r\n        if (control.parent) {\r\n            let name = this.getFormGroupName((<FormGroup>control.parent))\r\n            if (name) {\r\n                columnName = `${name}.${columnName}`\r\n                return this.topControlPath(control.parent, columnName)\r\n            }\r\n        }\r\n        return columnName;\r\n    }\r\n\r\n    childControlDisabledExpression(formGroup: FormGroup, columnName: string, path: string = \"\"): any[] {\r\n        let disabledColumns = [];\r\n        if (formGroup[MODEL_INSTANCE]) {\r\n            let instanceContainer = defaultContainer.get(formGroup[MODEL_INSTANCE].constructor);\r\n            if (instanceContainer) {\r\n                this.getChangeDetectionColumns(instanceContainer, columnName, true, path).forEach(t => disabledColumns.push(t));\r\n                var props = instanceContainer.properties.filter(t => t.propertyType == OBJECT_PROPERTY)\r\n                props.forEach(t => {\r\n                    if (formGroup.controls[t.name]) {\r\n                        let columns = this.getDisabledColumns(<FormGroup>formGroup.controls[t.name], columnName, true, path ? `${path}.${t.name}` : `${t.name}`)\r\n                        columns.forEach(x => disabledColumns.push(x));\r\n                        this.childControlDisabledExpression((<FormGroup>formGroup.controls[t.name]), columnName, path ? `${path}.${t.name}` : `${t.name}`).forEach(y => disabledColumns.push(y))\r\n                    }\r\n                })\r\n            }\r\n        }\r\n        return disabledColumns;\r\n    }\r\n\r\n    oneArgumentProcess(control: AbstractControl | FormGroup, columnName: string): any[] {\r\n        let path = this.topControlPath(control, columnName);\r\n        let rootFormGroup = ApplicationUtil.getRootFormGroup(control);\r\n        let childColumns = this.childControlDisabledExpression(rootFormGroup, path);\r\n        return childColumns;\r\n    }\r\n}"]}

package/esm2020/lib/form-validators/domain/element-processor/decimal.provider.mjs

@@ -0,0 +1,59 @@
+import { DecimalPipe, getLocaleNumberSymbol, NumberSymbol } from "@angular/common";
+import { Inject, Injectable, LOCALE_ID } from "@angular/core";
+import { BLANK } from "../../const";
+import { ReactiveFormConfig } from "../../util/reactive-form-config";
+import { RegexValidator } from '../../util/regex-validator';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class DecimalProvider {
+    constructor(decimalPipe, localeId) {
+        this.decimalPipe = decimalPipe;
+        this.localeId = localeId;
+        this.decimalSeperator = ".";
+        this.groupSeperator = ",";
+        this.isSetConfig = false;
+        this.decimalSeperator = getLocaleNumberSymbol(localeId, NumberSymbol.Decimal);
+        ;
+        this.groupSeperator = getLocaleNumberSymbol(localeId, NumberSymbol.Group);
+        this.setSymbolInConfig();
+    }
+    replacer(value) {
+        value = String(value);
+        if (!this.isSetConfig)
+            this.bindConfig();
+        value = value.split(this.groupSeperator).join(BLANK);
+        if (this.allowDecimalSymbol)
+            value = value.replace(this.decimalSeperator, this.allowDecimalSymbol);
+        var splitValue = value.split(this.decimalSeperator);
+        value = (splitValue.length > 1 && splitValue[1] && RegexValidator.isZero(splitValue[1])) ? splitValue[0] : value;
+        return value;
+    }
+    transFormDecimal(value, digitsInfo) {
+        value = String(value);
+        if (!value) {
+            return value;
+        }
+        return this.decimalPipe.transform(value.replace(ReactiveFormConfig.number.groupSymbol, "").replace(this.decimalSeperator, "."), digitsInfo, this.localeId);
+    }
+    setSymbolInConfig() {
+        ReactiveFormConfig.number = { decimalSymbol: this.decimalSeperator, groupSymbol: this.groupSeperator };
+    }
+    bindConfig() {
+        if (ReactiveFormConfig.json) {
+            if (ReactiveFormConfig.json.localeId)
+                this.localeId = ReactiveFormConfig.json.localeId;
+            if (ReactiveFormConfig.json.allowDecimalSymbol)
+                this.allowDecimalSymbol = ReactiveFormConfig.json.allowDecimalSymbol;
+        }
+        this.isSetConfig = true;
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DecimalProvider.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DecimalProvider, deps: [{ token: i1.DecimalPipe }, { token: LOCALE_ID }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ DecimalProvider.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DecimalProvider });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DecimalProvider, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.DecimalPipe }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOCALE_ID]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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