@wavemaker-ai/app-ng-runtime 1.0.0-rc.647469

package/components/base/esm2022/widgets/common/base/base-container.component.mjs

@@ -0,0 +1,80 @@
+import { ContentChildren, Directive, Injector } from '@angular/core';
+import { StylableComponent } from "./stylable.component";
+import { RedrawableDirective } from "../redraw/redrawable.directive";
+import { includes, pickBy } from "lodash-es";
+import * as i0 from "@angular/core";
+export class BaseContainerComponent extends StylableComponent {
+    constructor(inj, WIDGET_CONFIG, explicitContext) {
+        super(inj, WIDGET_CONFIG, explicitContext);
+    }
+    updateRedrawableComponents(widgets) {
+        pickBy(widgets, widget => {
+            // check for redrawable widget and whether it is already exist in reDrawableComponents query list or not
+            if (widget && widget.nativeElement && widget.nativeElement.hasAttribute('redrawable') && !includes(this.reDrawableComponents._results, widget)) {
+                this.reDrawableComponents._results.push(widget);
+            }
+            if (widget && widget.Widgets) {
+                this.updateRedrawableComponents(widget.Widgets);
+            }
+        });
+    }
+    redrawChildren() {
+        // If container is bound to partial content, manually updating reDrawableComponents query list.
+        if (this.content && this.Widgets) {
+            this.updateRedrawableComponents(this.Widgets);
+        }
+        setTimeout(() => {
+            if (this.reDrawableComponents) {
+                this.reDrawableComponents.forEach(c => c.redraw());
+            }
+        }, 100);
+    }
+    onPropertyChange(key, nv, ov) {
+        super.onPropertyChange(key, nv, ov);
+        if (key === 'show') {
+            if (nv) {
+                this.redrawChildren();
+            }
+        }
+    }
+    ngOnDestroy() {
+        // MEMORY LEAK FIX: Clear redrawable components references
+        // The reDrawableComponents QueryList holds references to child components
+        // and updateRedrawableComponents manually pushes to _results array
+        if (this.reDrawableComponents) {
+            // Clear the manually added items from _results
+            if (this.reDrawableComponents._results) {
+                this.reDrawableComponents._results.length = 0;
+            }
+            // Reset the QueryList
+            this.reDrawableComponents.reset([]);
+        }
+        // MEMORY LEAK FIX: Clear Widgets object to release child widget references
+        // This object holds references to all child widgets in the container
+        if (this.Widgets) {
+            Object.keys(this.Widgets).forEach(key => {
+                delete this.Widgets[key];
+            });
+            this.Widgets = null;
+        }
+        // MEMORY LEAK FIX: Clear content reference
+        this.content = null;
+        // Call parent ngOnDestroy (StylableComponent → BaseComponent)
+        // This will clear the context and unregister the widget
+        super.ngOnDestroy();
+    }
+    static { this.ɵfac = function BaseContainerComponent_Factory(__ngFactoryType__) { i0.ɵɵinvalidFactory(); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: BaseContainerComponent, contentQueries: function BaseContainerComponent_ContentQueries(rf, ctx, dirIndex) { if (rf & 1) {
+            i0.ɵɵcontentQuery(dirIndex, RedrawableDirective, 5);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.reDrawableComponents = _t);
+        } }, features: [i0.ɵɵInheritDefinitionFeature] }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(BaseContainerComponent, [{
+        type: Directive
+    }], () => [{ type: i0.Injector }, { type: undefined }, { type: undefined }], { reDrawableComponents: [{
+            type: ContentChildren,
+            args: [RedrawableDirective, { descendants: true }]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/components/base/esm2022/widgets/common/base/base-field-validations.mjs

@@ -0,0 +1,295 @@
+import { Validators } from '@angular/forms';
+import { $unwatch, $watch, FormWidgetType, VALIDATOR } from '@wm/core';
+import { cloneDeep, concat, extend, filter, find, forEach, get, isEmpty, isFunction, keys as _keys, toUpper } from "lodash-es";
+const DEFAULT_VALIDATOR = {
+    pattern: 'regexp',
+    max: 'maxvalue',
+    min: 'minvalue',
+    required: 'required',
+    maxlength: 'maxchars',
+    mindate: 'mindate',
+    maxdate: 'maxdate',
+    excludedates: 'excludedates',
+    excludedays: 'excludedays',
+    invalidNumber: 'invalidNumber'
+};
+export class BaseFieldValidations {
+    constructor(instance, formwidget, widgettype, widgetControl, widgetContext, tableFieldType) {
+        this.instance = instance;
+        this.formwidget = formwidget;
+        this.widgettype = widgettype;
+        this.widgetControl = widgetControl;
+        this.widgetContext = widgetContext;
+        this.defaultValidatorMessages = [];
+        if (tableFieldType) {
+            this.tableFieldType = tableFieldType;
+        }
+    }
+    // this method returns the collection of supported default validators
+    getDefaultValidators() {
+        const _validator = [];
+        if (!this.instance.show)
+            return _validator;
+        if (this.widgettype !== FormWidgetType.DATE && this.widgettype !== FormWidgetType.TIME && this.widgettype !== FormWidgetType.DATETIME) {
+            if (this.instance.required) {
+                // For checkbox/toggle widget, required validation should consider true value only
+                if ((this.widgettype === FormWidgetType.CHECKBOX) && (this.instance.checkedvalue != true)) {
+                    _validator.push(Validators.pattern(this.instance.checkedvalue));
+                }
+                else if (this.widgettype === FormWidgetType.CHECKBOX || this.widgettype === FormWidgetType.TOGGLE) {
+                    _validator.push(Validators.requiredTrue);
+                }
+                else {
+                    _validator.push(Validators.required);
+                }
+            }
+        }
+        if (this.instance.maxchars) {
+            _validator.push(Validators.maxLength(this.instance.maxchars));
+        }
+        if (this.instance.minvalue) {
+            _validator.push(Validators.min(this.instance.minvalue));
+        }
+        if (this.instance.maxvalue && this.widgettype !== FormWidgetType.RATING) {
+            _validator.push(Validators.max(this.instance.maxvalue));
+        }
+        if (this.instance.regexp) {
+            _validator.push(Validators.pattern(this.instance.regexp));
+        }
+        if (this.formwidget && isFunction(this.formwidget.validate)) {
+            _validator.push(this.formwidget.validate.bind(this.formwidget));
+        }
+        if ((this.widgettype === FormWidgetType.DATE || this.widgettype === FormWidgetType.TIME || this.widgettype === FormWidgetType.DATETIME) && this.instance.required) {
+            _validator.push(Validators.required);
+        }
+        return _validator;
+    }
+    // On change of any validation property, set the angular form validators
+    setUpValidators(customValidator) {
+        if (this.hasValidators) {
+            return;
+        }
+        this.instance._validators = this.getDefaultValidators();
+        if (customValidator) {
+            this.instance._validators.push(customValidator);
+        }
+        if (this.widgetContext.ngform) {
+            this.widgetControl.setValidators(this.instance._validators);
+            const opt = {};
+            // updating the value only when prevData is not equal to current value. and also initially when  instance.value is empty or null for some widgets like date, checkboxset
+            // emitEvent flag will prevent from emitting the valueChanges when value is equal to the prevDatavalue.
+            if (this.formwidget && (this.instance.value === this.formwidget.prevDatavalue || this.isNullOrEmptyOrFalsy(this.instance.value))) {
+                opt['emitEvent'] = false;
+            }
+            this.widgetControl.updateValueAndValidity(opt);
+        }
+    }
+    getPromiseList(validators) {
+        const arr = [];
+        forEach(validators, (fn, index) => {
+            let promise = fn;
+            if (fn instanceof Function && fn.bind) {
+                promise = fn(this.widgetControl, this.widgetContext);
+            }
+            if (promise instanceof Promise) {
+                arr.push(promise);
+            }
+        });
+        return arr;
+    }
+    // this method sets the asyncValidation on the form field. Assigns validationmessages from the returned response
+    setAsyncValidators(validators) {
+        this._asyncValidatorFn = () => {
+            return () => {
+                return Promise.all(this.getPromiseList(validators)).then(() => {
+                    this.instance.validationmessage = '';
+                    return null;
+                }, err => {
+                    // if err obj has validationMessage key, then set validationMessage using this value
+                    // else return the value of the first key in the err object as validation message.
+                    if (err.hasOwnProperty('errorMessage')) {
+                        this.instance.validationmessage = get(err, 'errorMessage');
+                    }
+                    else {
+                        const keys = _keys(err);
+                        this.instance.validationmessage = (err[keys[0]]).toString();
+                    }
+                    return err;
+                }).then(response => {
+                    // form control status is not changed from pending. This is an angular issue refer https://github.com/angular/angular/issues/13200
+                    const checkForStatusChange = () => {
+                        setTimeout(() => {
+                            if (this.widgetControl.status === 'PENDING') {
+                                checkForStatusChange();
+                            }
+                            else {
+                                this.instance.onStatusChange(this.widgetControl.status, this.tableFieldType);
+                            }
+                        }, 100);
+                    };
+                    checkForStatusChange();
+                    return response;
+                });
+            };
+        };
+        this.widgetControl.setAsyncValidators([this._asyncValidatorFn()]);
+        if (this.widgetContext.ngform.touched) {
+            const opt = {};
+            // updating the value only when prevData is not equal to current value. and also initially when  instance.value is empty or null for some widgets like date, checkboxset
+            // emitEvent flag will prevent from emitting the valueChanges when value is equal to the prevDatavalue.
+            if (this.formwidget && (this.instance.value === this.formwidget.prevDatavalue || this.isNullOrEmptyOrFalsy(this.instance.value))) {
+                opt['emitEvent'] = false;
+            }
+            this.widgetControl.updateValueAndValidity(opt);
+        }
+    }
+    isDefaultValidator(type) {
+        return get(VALIDATOR, toUpper(type));
+    }
+    // default validator is bound to a function then watch for value changes
+    // otherwise set the value of default validator directly
+    setDefaultValidator(key, value) {
+        if (value && value instanceof Function) {
+            // passing formfield and form as arguments to the default validator function
+            this.watchDefaultValidatorExpr(value.bind(undefined, this.widgetControl, this.widgetContext), key);
+        }
+        else {
+            if (this.widgettype === 'custom-widget') {
+                this.instance.formWidget.baseWidget[key] = value;
+            }
+            this.instance.widget[key] = value;
+            this.instance[key] = value;
+        }
+    }
+    // sets the default validation on the form field
+    setValidators(validators) {
+        let _cloneValidators = cloneDeep(validators);
+        this.hasValidators = true;
+        this._syncValidators = [];
+        forEach(_cloneValidators, (obj, index) => {
+            // custom validation is bound to function.
+            if (obj && obj instanceof Function) {
+                // passing formfield and form as arguments to the obj (i.e. validator function)
+                _cloneValidators[index] = obj.bind(undefined, this.widgetControl, this.widgetContext);
+                this._syncValidators.push(_cloneValidators[index]);
+            }
+            else {
+                // checks for default validator like required, maxchars etc.
+                const key = get(obj, 'type');
+                this.defaultValidatorMessages[key] = get(obj, 'errorMessage');
+                if (this.isDefaultValidator(key)) {
+                    const value = get(obj, 'validator');
+                    this.setDefaultValidator(key, value);
+                    _cloneValidators[index] = '';
+                }
+            }
+        });
+        // _syncValidators contains all the custom validations on the form field. will not include default validators.
+        this._syncValidators = filter(_cloneValidators, val => {
+            if (val) {
+                return val;
+            }
+        });
+        this.applyDefaultValidators();
+    }
+    observeOn(fields, context) {
+        forEach(fields, field => {
+            const formfield = find(this.widgetContext[context], { 'key': field });
+            if (formfield) {
+                if (!formfield.notifyForFields) {
+                    formfield.notifyForFields = [];
+                }
+                formfield.notifyForFields.push(this.instance);
+            }
+        });
+    }
+    validate() {
+        this.applyDefaultValidators();
+        if (this._asyncValidatorFn) {
+            const opt = {};
+            // updating the value only when prevData is not equal to current value. and also initially when  instance.value is empty or null for some widgets like date, checkboxset
+            // emitEvent flag will prevent from emitting the valueChanges when value is equal to the prevDatavalue.
+            if (this.formwidget && (this.instance.value === this.formwidget.prevDatavalue || this.isNullOrEmptyOrFalsy(this.instance.value))) {
+                opt['emitEvent'] = false;
+            }
+            this.widgetControl.setAsyncValidators([this._asyncValidatorFn()]);
+            this.widgetControl.updateValueAndValidity(opt);
+        }
+        // show the validation erros show when form is touched and not on load. This just highlights the field that is subscribed for changes.
+        if (this.widgetContext.ngform.touched) {
+            this.widgetControl.markAsTouched();
+        }
+    }
+    // watches for changes in the bound function for default validators.
+    watchDefaultValidatorExpr(fn, key) {
+        const watchName = `${this.instance.widgetId}_` + key + '_formField';
+        $unwatch(watchName);
+        //[Todo-CSP]: Need clarity generate this expr fn if form is present in the page
+        this.instance.registerDestroyListener($watch('boundFn(fn)', extend(this.instance, this.instance.viewParent), { fn }, (nv, ov) => {
+            this.instance.widget[key] = nv;
+            this.applyDefaultValidators();
+        }, watchName));
+    }
+    isNullOrEmptyOrFalsy(value) {
+        return isEmpty(value);
+    }
+    // invokes both custom sync validations and default validations.
+    applyDefaultValidators() {
+        const validators = this.getDefaultValidators();
+        const opt = {};
+        // updating the value only when prevData is not equal to current value. and also initially when  instance.value is empty or null for some widgets like date, checkboxset
+        // emitEvent flag will prevent from emitting the valueChanges when value is equal to the prevDatavalue.
+        if (this.formwidget && (this.instance.value === this.formwidget.prevDatavalue || this.isNullOrEmptyOrFalsy(this.instance.value))) {
+            opt['emitEvent'] = false;
+        }
+        this.widgetControl.setValidators(concat(this._syncValidators || [], validators));
+        this.widgetControl.updateValueAndValidity(opt);
+        this.setCustomValidationMessage();
+    }
+    setCustomValidationMessage() {
+        const fieldErrors = this.widgetControl && this.widgetControl.errors;
+        if (!fieldErrors) {
+            return;
+        }
+        if (fieldErrors.hasOwnProperty('errorMessage')) {
+            this.instance.validationmessage = get(fieldErrors, 'errorMessage');
+        }
+        else {
+            const keys = _keys(fieldErrors);
+            const key = keys[0];
+            const validationMsgKey = get(DEFAULT_VALIDATOR, key) || this.formwidget.validateType;
+            if (validationMsgKey) {
+                const msg = get(this.defaultValidatorMessages, validationMsgKey) || this.instance.validationmessage;
+                if (msg && msg instanceof Function) {
+                    // passing formfield and form as arguments to the errorMessage function.
+                    this.instance.validationmessage = msg(this.widgetControl, this.widgetContext);
+                }
+                else {
+                    this.instance.validationmessage = msg;
+                }
+            }
+            else {
+                // fallback when there is no validationmessage for fields other than default validators.
+                this.instance.validationmessage = '';
+            }
+        }
+    }
+    // MEMORY LEAK FIX: Cleanup method to release all references
+    destroy() {
+        // Clear all references to prevent memory leaks
+        this.instance = null;
+        this.formwidget = null;
+        this.widgetControl = null;
+        this.widgetContext = null;
+        // Clear validators array and async validator function
+        if (this._syncValidators) {
+            this._syncValidators = [];
+        }
+        this._asyncValidatorFn = null;
+        // Clear default validator messages
+        if (this.defaultValidatorMessages) {
+            this.defaultValidatorMessages = [];
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-field-validations.js","sourceRoot":"","sources":["../../../../../../../projects/components/base/src/widgets/common/base/base-field-validations.ts"],"names":[],"mappings":"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","sourcesContent":["import {Validators} from '@angular/forms';\n\nimport {$unwatch, $watch, FormWidgetType, VALIDATOR} from '@wm/core';\nimport {\n    cloneDeep,\n    concat,\n    extend,\n    filter,\n    find,\n    forEach,\n    get,\n    isEmpty,\n    isFunction,\n    keys as _keys,\n    toUpper\n} from \"lodash-es\";\n\nconst DEFAULT_VALIDATOR = {\n    pattern: 'regexp',\n    max: 'maxvalue',\n    min: 'minvalue',\n    required: 'required',\n    maxlength: 'maxchars',\n    mindate: 'mindate',\n    maxdate: 'maxdate',\n    excludedates: 'excludedates',\n    excludedays: 'excludedays',\n    invalidNumber:'invalidNumber'\n};\n\nexport class BaseFieldValidations {\n    private hasValidators;\n\n    // Instance of the directive table-column, form-field..\n    private instance;\n    // Inline form widget\n    public formwidget;\n    // Widget type\n    private widgettype;\n    // From control\n    private widgetControl;\n    // Parent widget context Table, Form..\n    private widgetContext;\n    // Optional table column type quickedit newrow/ inline edit\n    private tableFieldType;\n\n    private defaultValidatorMessages: any;\n    private _syncValidators: any;\n    private _asyncValidatorFn: any;\n\n    constructor(instance, formwidget, widgettype, widgetControl, widgetContext, tableFieldType?){\n        this.instance = instance;\n        this.formwidget = formwidget;\n        this.widgettype = widgettype;\n        this.widgetControl = widgetControl;\n        this.widgetContext = widgetContext;\n\n        this.defaultValidatorMessages = [];\n        if (tableFieldType) {\n            this.tableFieldType = tableFieldType;\n        }\n    }\n\n    // this method returns the collection of supported default validators\n    private getDefaultValidators() {\n        const _validator = [];\n        if(!this.instance.show) return _validator;\n        if(this.widgettype!== FormWidgetType.DATE && this.widgettype!==FormWidgetType.TIME && this.widgettype!==FormWidgetType.DATETIME) {\n            if (this.instance.required) {\n                // For checkbox/toggle widget, required validation should consider true value only\n                if((this.widgettype === FormWidgetType.CHECKBOX) && (this.instance.checkedvalue!=true)){\n                    _validator.push(Validators.pattern(this.instance.checkedvalue));\n                } else if(this.widgettype === FormWidgetType.CHECKBOX || this.widgettype === FormWidgetType.TOGGLE) {\n                    _validator.push(Validators.requiredTrue);\n                } else {\n                    _validator.push(Validators.required);\n                }\n            }\n        }\n        if (this.instance.maxchars) {\n            _validator.push(Validators.maxLength(this.instance.maxchars));\n        }\n        if (this.instance.minvalue) {\n            _validator.push(Validators.min(this.instance.minvalue));\n        }\n        if (this.instance.maxvalue && this.widgettype !== FormWidgetType.RATING) {\n            _validator.push(Validators.max(this.instance.maxvalue));\n        }\n        if (this.instance.regexp) {\n            _validator.push(Validators.pattern(this.instance.regexp));\n        }\n        if (this.formwidget && isFunction(this.formwidget.validate)) {\n            _validator.push(this.formwidget.validate.bind(this.formwidget));\n        }\n        if((this.widgettype=== FormWidgetType.DATE|| this.widgettype===FormWidgetType.TIME ||this.widgettype===FormWidgetType.DATETIME) && this.instance.required){\n            _validator.push(Validators.required);\n        }\n            return _validator;\n    }\n\n    // On change of any validation property, set the angular form validators\n    setUpValidators(customValidator?) {\n        if (this.hasValidators) {\n            return;\n        }\n        this.instance._validators = this.getDefaultValidators();\n\n        if (customValidator) {\n            this.instance._validators.push(customValidator);\n        }\n\n        if (this.widgetContext.ngform) {\n            this.widgetControl.setValidators(this.instance._validators);\n            const opt = {};\n            // updating the value only when prevData is not equal to current value. and also initially when  instance.value is empty or null for some widgets like date, checkboxset\n            // emitEvent flag will prevent from emitting the valueChanges when value is equal to the prevDatavalue.\n            if (this.formwidget && (this.instance.value === this.formwidget.prevDatavalue || this.isNullOrEmptyOrFalsy(this.instance.value))) {\n                opt['emitEvent'] = false;\n            }\n            this.widgetControl.updateValueAndValidity(opt);\n        }\n    }\n\n    getPromiseList(validators) {\n        const arr = [];\n        forEach(validators, (fn, index) => {\n            let promise = fn;\n            if (fn instanceof Function && fn.bind) {\n                promise = fn(this.widgetControl, this.widgetContext);\n            }\n            if (promise instanceof Promise) {\n                arr.push(promise);\n            }\n        });\n        return arr;\n    }\n\n    // this method sets the asyncValidation on the form field. Assigns validationmessages from the returned response\n    setAsyncValidators(validators) {\n        this._asyncValidatorFn = () => {\n            return () => {\n                return Promise.all(this.getPromiseList(validators)).then(() => {\n                    this.instance.validationmessage = '';\n                    return null;\n                }, err => {\n                    // if err obj has validationMessage key, then set validationMessage using this value\n                    // else return the value of the first key in the err object as validation message.\n                    if (err.hasOwnProperty('errorMessage')) {\n                        this.instance.validationmessage = get(err, 'errorMessage');\n                    } else {\n                        const keys = _keys(err);\n                        this.instance.validationmessage = (err[keys[0]]).toString();\n                    }\n                    return err;\n                }).then(response => {\n                    // form control status is not changed from pending. This is an angular issue refer https://github.com/angular/angular/issues/13200\n                    const checkForStatusChange = () => {\n                        setTimeout(() => {\n                            if (this.widgetControl.status === 'PENDING') {\n                                checkForStatusChange();\n                            } else {\n                                this.instance.onStatusChange(this.widgetControl.status, this.tableFieldType);\n                            }\n                        }, 100);\n                    };\n                    checkForStatusChange();\n                    return response;\n                });\n            };\n        };\n\n        this.widgetControl.setAsyncValidators([this._asyncValidatorFn()]);\n        if(this.widgetContext.ngform.touched){\n            const opt = {};\n            // updating the value only when prevData is not equal to current value. and also initially when  instance.value is empty or null for some widgets like date, checkboxset\n            // emitEvent flag will prevent from emitting the valueChanges when value is equal to the prevDatavalue.\n            if (this.formwidget && (this.instance.value === this.formwidget.prevDatavalue || this.isNullOrEmptyOrFalsy(this.instance.value))) {\n                opt['emitEvent'] = false;\n            }\n            this.widgetControl.updateValueAndValidity(opt);\n        }\n    }\n\n    isDefaultValidator(type) {\n        return get(VALIDATOR, toUpper(type));\n    }\n\n    // default validator is bound to a function then watch for value changes\n    // otherwise set the value of default validator directly\n    setDefaultValidator(key, value) {\n        if (value && value instanceof Function) {\n            // passing formfield and form as arguments to the default validator function\n            this.watchDefaultValidatorExpr(value.bind(undefined, this.widgetControl, this.widgetContext), key);\n        } else {\n            if (this.widgettype === 'custom-widget') {\n                this.instance.formWidget.baseWidget[key] = value;\n            }\n            this.instance.widget[key] = value;\n            this.instance[key] = value;\n        }\n    }\n\n    // sets the default validation on the form field\n    setValidators(validators) {\n        let _cloneValidators = cloneDeep(validators);\n        this.hasValidators = true;\n        this._syncValidators = [];\n        forEach(_cloneValidators, (obj, index) => {\n            // custom validation is bound to function.\n            if (obj && obj instanceof Function) {\n                // passing formfield and form as arguments to the obj (i.e. validator function)\n                _cloneValidators[index] = obj.bind(undefined, this.widgetControl, this.widgetContext);\n                this._syncValidators.push(_cloneValidators[index]);\n            } else {\n                // checks for default validator like required, maxchars etc.\n                const key = get(obj, 'type');\n                this.defaultValidatorMessages[key] = get(obj, 'errorMessage');\n                if (this.isDefaultValidator(key)) {\n                    const value = get(obj, 'validator');\n                    this.setDefaultValidator(key, value);\n                    _cloneValidators[index] = '';\n                }\n            }\n        });\n\n        // _syncValidators contains all the custom validations on the form field. will not include default validators.\n        this._syncValidators = filter(_cloneValidators, val => {\n            if (val) {\n                return val;\n            }\n        });\n        this.applyDefaultValidators();\n    }\n\n    observeOn(fields, context) {\n        forEach(fields, field => {\n            const formfield = find(this.widgetContext[context], {'key': field});\n            if (formfield) {\n                if (!formfield.notifyForFields) {\n                    formfield.notifyForFields = [];\n                }\n                formfield.notifyForFields.push(this.instance);\n            }\n        });\n    }\n\n    validate() {\n        this.applyDefaultValidators();\n        if (this._asyncValidatorFn) {\n            const opt = {};\n            // updating the value only when prevData is not equal to current value. and also initially when  instance.value is empty or null for some widgets like date, checkboxset\n            // emitEvent flag will prevent from emitting the valueChanges when value is equal to the prevDatavalue.\n            if (this.formwidget && (this.instance.value === this.formwidget.prevDatavalue || this.isNullOrEmptyOrFalsy(this.instance.value))) {\n                opt['emitEvent'] = false;\n            }\n            this.widgetControl.setAsyncValidators([this._asyncValidatorFn()]);\n            this.widgetControl.updateValueAndValidity(opt);\n        }\n        // show the validation erros show when form is touched and not on load. This just highlights the field that is subscribed for changes.\n        if (this.widgetContext.ngform.touched) {\n            this.widgetControl.markAsTouched();\n        }\n    }\n\n    // watches for changes in the bound function for default validators.\n    watchDefaultValidatorExpr(fn, key) {\n        const watchName = `${this.instance.widgetId}_` + key + '_formField';\n        $unwatch(watchName);\n        //[Todo-CSP]: Need clarity generate this expr fn if form is present in the page\n        this.instance.registerDestroyListener($watch('boundFn(fn)', extend(this.instance, this.instance.viewParent), {fn}, (nv, ov) => {\n            this.instance.widget[key] = nv;\n            this.applyDefaultValidators();\n        }, watchName));\n    }\n    isNullOrEmptyOrFalsy(value)  {\n        return isEmpty(value);\n    }\n\n    // invokes both custom sync validations and default validations.\n    applyDefaultValidators() {\n        const validators = this.getDefaultValidators();\n        const opt = {};\n        // updating the value only when prevData is not equal to current value. and also initially when  instance.value is empty or null for some widgets like date, checkboxset\n        // emitEvent flag will prevent from emitting the valueChanges when value is equal to the prevDatavalue.\n        if (this.formwidget && (this.instance.value === this.formwidget.prevDatavalue || this.isNullOrEmptyOrFalsy(this.instance.value))) {\n            opt['emitEvent'] = false;\n        }\n        this.widgetControl.setValidators(concat(this._syncValidators || [], validators));\n        this.widgetControl.updateValueAndValidity(opt);\n        this.setCustomValidationMessage();\n    }\n\n    setCustomValidationMessage() {\n        const fieldErrors = this.widgetControl && this.widgetControl.errors;\n\n        if (!fieldErrors) {\n            return;\n        }\n        if (fieldErrors.hasOwnProperty('errorMessage')) {\n            this.instance.validationmessage = get(fieldErrors, 'errorMessage');\n        } else {\n            const keys = _keys(fieldErrors);\n            const key = keys[0];\n            const validationMsgKey = get(DEFAULT_VALIDATOR, key) || this.formwidget.validateType;\n            if (validationMsgKey) {\n                const msg = get(this.defaultValidatorMessages, validationMsgKey) || this.instance.validationmessage;\n                if (msg && msg instanceof Function) {\n                    // passing formfield and form as arguments to the errorMessage function.\n                    this.instance.validationmessage = msg(this.widgetControl, this.widgetContext);\n                } else {\n                    this.instance.validationmessage = msg;\n                }\n            } else {\n                // fallback when there is no validationmessage for fields other than default validators.\n                this.instance.validationmessage = '';\n            }\n        }\n    }\n\n    // MEMORY LEAK FIX: Cleanup method to release all references\n    destroy() {\n        // Clear all references to prevent memory leaks\n        this.instance = null;\n        this.formwidget = null;\n        this.widgetControl = null;\n        this.widgetContext = null;\n        \n        // Clear validators array and async validator function\n        if (this._syncValidators) {\n            this._syncValidators = [];\n        }\n        this._asyncValidatorFn = null;\n        \n        // Clear default validator messages\n        if (this.defaultValidatorMessages) {\n            this.defaultValidatorMessages = [];\n        }\n    }\n}\n"]}