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

package/components/data/table/esm2022/table-column/table-column.directive.mjs

@@ -0,0 +1,744 @@
+import { Attribute, ContentChild, ContentChildren, Directive, Inject, Injector, Optional, TemplateRef } from '@angular/core';
+import { $watch, AppDefaults, DataSource, DataType, FormWidgetType, getDisplayDateTimeFormat, isDateTimeType, isDefined } from '@wm/core';
+import { applyFilterOnField, BaseComponent, BaseFieldValidations, EDIT_MODE, fetchRelatedFieldData, getDataTableFilterWidget, getDefaultValue, getDistinctFieldProperties, getDistinctValues, getDistinctValuesForField, getEditModeWidget, getWatchIdentifier, isDataSetWidget, provideAsWidgetRef, setHeaderConfigForTable } from '@wm/components/base';
+import { registerProps } from './table-column.props';
+import { TableComponent } from '../table.component';
+import { TableColumnGroupDirective } from '../table-column-group/table-column-group.directive';
+import { debounceTime } from 'rxjs/operators';
+import { cloneDeep, forEach, head, includes, last, map, max, mean, min, round, split, sum } from "lodash-es";
+import * as i0 from "@angular/core";
+import * as i1 from "@wm/core";
+import * as i2 from "../table.component";
+import * as i3 from "../table-column-group/table-column-group.directive";
+const WIDGET_CONFIG = { widgetType: 'wm-table-column', hostClass: '' };
+let inlineWidgetProps = ['datafield', 'displayfield', 'placeholder', 'searchkey', 'sortby', 'matchmode', 'displaylabel', 'groupby', 'match', 'dateformat', 'showcount', 'collapsible',
+    'checkedvalue', 'uncheckedvalue', 'showdropdownon', 'dataentrymode', 'autoclose', 'dataset', 'outputformat'];
+const validationProps = ['maxchars', 'regexp', 'minvalue', 'maxvalue', 'step', 'required', 'mindate', 'maxdate',
+    'excludedates', 'excludedays', 'mintime', 'maxtime'];
+inlineWidgetProps = [...inlineWidgetProps, ...validationProps];
+class FieldDef {
+    constructor(widget) {
+        this.widget = widget;
+    }
+    focus() {
+        this.widget.focus();
+    }
+    setProperty(prop, newval) {
+        // Get the scope of the current editable widget and set the value
+        prop = prop === 'value' ? 'datavalue' : prop;
+        this.widget[prop] = newval;
+    }
+    getProperty(prop) {
+        prop = prop === 'value' ? 'datavalue' : prop;
+        return this.widget[prop];
+    }
+}
+export class TableColumnDirective extends BaseComponent {
+    static { this.initializeProps = registerProps(); }
+    constructor(inj, appDefaults, table, group, bindfilterdataset, binddataset, explicitContext) {
+        super(inj, WIDGET_CONFIG, explicitContext);
+        this.appDefaults = appDefaults;
+        this.table = table;
+        this.group = group;
+        this.bindfilterdataset = bindfilterdataset;
+        this.binddataset = binddataset;
+        this.syncValidators = [];
+        this.asyncValidators = [];
+        this.observeOnFields = [];
+        this.aggregate = {
+            sum: () => {
+                return sum(this._getColumnData());
+            },
+            average: (precision = 2) => {
+                return round(mean(this._getColumnData()), precision);
+            },
+            count: () => {
+                return this._getColumnData().length;
+            },
+            minimum: () => {
+                return min(this._getColumnData());
+            },
+            maximum: () => {
+                return max(this._getColumnData());
+            },
+            percent: (value, precision = 2) => {
+                return round((sum(this._getColumnData()) / value) * 100, precision);
+            }
+        };
+        this.notifyForFields = [];
+    }
+    get dataoptions() {
+        return this._dataoptions;
+    }
+    set dataoptions(options) {
+        this._dataoptions = options;
+    }
+    get datasource() {
+        return this._datasource;
+    }
+    set datasource(ds) {
+        this._datasource = ds;
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        // Set the default values and register with table
+        this.populateFieldDef();
+        // when column is inside a group then consider the col index and not header index.
+        const colIndex = parseInt(this.getAttr('index'), 10);
+        const headerIndex = parseInt(this.getAttr('headerIndex'), 10);
+        const fieldName = this.group && this.group.name;
+        // Register column with header config to create group structure
+        setHeaderConfigForTable(this.table.headerConfig, {
+            field: this.field,
+            displayName: this.displayName
+        }, fieldName, fieldName ? colIndex : headerIndex);
+        this.table.registerColumns(this.widget, colIndex);
+        this._isRowFilter = this.table.filtermode === 'multicolumn' && this.searchable;
+        this._isInlineEditable = !this.readonly && (this.table.editmode !== EDIT_MODE.DIALOG && this.table.editmode !== EDIT_MODE.FORM);
+        this._isNewEditableRow = this._isInlineEditable && this.table.editmode === EDIT_MODE.QUICK_EDIT && this.table.shownewrow;
+        this.setUpControls();
+        this._propsInitialized = true;
+        // Inline control status change subscriber
+        if (this.getFormControl()) {
+            const onStatusChangeSubscription = this.getFormControl().statusChanges
+                .pipe(debounceTime(100))
+                .subscribe(status => this.onStatusChange(status, 'inlineInstance'));
+            this.registerDestroyListener(() => onStatusChangeSubscription.unsubscribe());
+            // Instantiate custom validators class for inline edit form control
+            this.fieldValidations = new BaseFieldValidations(this, this['inlineInstance'], this.editWidgetType, this.getFormControl(), this.table, 'inlineInstance');
+        }
+        // Quick edit new row control status change subscriber
+        if (this._checkNewEditableRowControl()) {
+            const onStatusChangeSubscription_new = this.getFormControl('_new').statusChanges
+                .pipe(debounceTime(100))
+                .subscribe(status => this.onStatusChange(status, 'inlineInstanceNew'));
+            this.registerDestroyListener(() => onStatusChangeSubscription_new.unsubscribe());
+            // Instantiate custom validators class for Quick edit newrow form control
+            this.fieldValidations_new = new BaseFieldValidations(this, this['inlineInstanceNew'], this.editWidgetType, this.getFormControl('_new'), this.table, 'inlineInstanceNew');
+        }
+    }
+    ngAfterContentInit() {
+        if (this._isRowFilter) {
+            // Listen on the inner row filter widget and setup the widget
+            const s1 = this._filterInstances.changes.subscribe((val) => {
+                this.filterInstance = val.first && val.first.widget;
+                this.setUpFilterWidget();
+            });
+            this.registerDestroyListener(() => s1.unsubscribe());
+        }
+        if (this._isInlineEditable) {
+            const s2 = this._inlineInstances.changes.subscribe((val) => {
+                // Listen on the inner inline widget and setup the widget
+                this.inlineInstance = val.first && val.first.widget;
+                this.fieldValidations.formwidget = val.first;
+                this.table.registerFormField(this.binding, new FieldDef(this.inlineInstance));
+                this.setUpInlineWidget('inlineInstance');
+            });
+            this.registerDestroyListener(() => s2.unsubscribe());
+            if (this._isNewEditableRow) {
+                const s3 = this._inlineInstancesNew.changes.subscribe((val) => {
+                    // Listen on the inner inline widget and setup the widget
+                    this.inlineInstanceNew = val.first && val.first.widget;
+                    this.fieldValidations_new.formwidget = val.first;
+                    this.setUpInlineWidget('inlineInstanceNew');
+                });
+                this.registerDestroyListener(() => s3.unsubscribe());
+            }
+        }
+        this.registerReadyStateListener(() => {
+            this.key = this.field || this.binding;
+        });
+        super.ngAfterContentInit();
+        if (this.table.isdynamictable) {
+            this.table.inlineWidgetTmpl._results.push(this.inlineWidthTempRef);
+        }
+    }
+    ngAfterViewInit() {
+        // manually listing the table column templateRef as templateRef will not be available prior.
+        if (this.filterTemplateRef) {
+            this.table.renderDynamicFilterColumn(this.filterTemplateRef);
+        }
+    }
+    // Apply default|sync|async|prop validators for inline form control
+    applyValidations() {
+        if (!this.getFormControl()) {
+            return;
+        }
+        if (this.syncValidators.length > 0) {
+            this.fieldValidations.setValidators(this.syncValidators);
+        }
+        this.fieldValidations.setUpValidators();
+        if (this.asyncValidators.length > 0) {
+            this.fieldValidations.setAsyncValidators(this.asyncValidators);
+        }
+        if (this.observeOnFields.length > 0) {
+            this.fieldValidations.observeOn(this.observeOnFields, 'columns');
+        }
+    }
+    // Remove validators for the inline widget and set form to untouched
+    removeValidations() {
+        // Guard against component destruction or table/ngform being null
+        if (this.isDestroyed || !this.table || !this.table.ngform) {
+            return;
+        }
+        this.table.ngform.markAsUntouched();
+        const control = this.getFormControl();
+        if (!control) {
+            return;
+        }
+        control.clearValidators();
+        control.clearAsyncValidators();
+        control.updateValueAndValidity();
+    }
+    // Apply default|sync|async|prop validators for QuickEdit new row form control
+    applyNewRowValidations() {
+        // Guard against component destruction or table/ngform being null
+        if (this.isDestroyed || !this.table || !this.table.ngform) {
+            return;
+        }
+        if (!this._checkNewEditableRowControl()) {
+            return;
+        }
+        if (this.syncValidators.length > 0) {
+            this.fieldValidations_new.setValidators(this.syncValidators);
+        }
+        this.fieldValidations_new.setUpValidators();
+        if (this.asyncValidators.length > 0) {
+            this.fieldValidations_new.setAsyncValidators(this.asyncValidators);
+        }
+        if (this.observeOnFields.length > 0) {
+            this.fieldValidations_new.observeOn(this.observeOnFields, 'columns');
+        }
+    }
+    // Remove validators for the QuickEdit new row widget and set form to untouched
+    removeNewRowValidations() {
+        // Guard against component destruction or table/ngform being null
+        if (this.isDestroyed || !this.table || !this.table.ngform) {
+            return;
+        }
+        this.table.ngform.markAsUntouched();
+        if (!this._checkNewEditableRowControl()) {
+            return;
+        }
+        const control = this.getFormControl('_new');
+        if (!control) {
+            return;
+        }
+        control.clearValidators();
+        control.clearAsyncValidators();
+        control.updateValueAndValidity();
+    }
+    addFormControl(suffix) {
+        // Guard against component destruction or table/ngform being null
+        if (this.isDestroyed || !this.table || !this.table.ngform) {
+            return;
+        }
+        const ctrlName = suffix ? (this.binding + suffix) : this.binding;
+        this.table.ngform.addControl(ctrlName, this.table.fb.control(''));
+    }
+    getFormControl(suffix) {
+        // Guard against component destruction or table/ngform being null
+        if (this.isDestroyed || !this.table || !this.table.ngform) {
+            return null;
+        }
+        const ctrlName = suffix ? (this.binding + suffix) : this.binding;
+        return this.table.ngform.controls[ctrlName] || null;
+    }
+    _checkNewEditableRowControl() {
+        return this._isNewEditableRow && this.getFormControl('_new');
+    }
+    // Setup the inline edit and filter widget
+    setUpControls() {
+        if (this._isInlineEditable) {
+            if (this.editWidgetType === FormWidgetType.UPLOAD) {
+                return;
+            }
+            this.addFormControl();
+            const control = this.getFormControl();
+            if (control) {
+                const onValueChangeSubscription = control.valueChanges
+                    .pipe(debounceTime(200))
+                    .subscribe(value => this.onValueChange(value, 'inlineInstance'));
+                this.registerDestroyListener(() => onValueChangeSubscription.unsubscribe());
+            }
+            if (this._isNewEditableRow) {
+                this.addFormControl('_new');
+                const newControl = this.getFormControl('_new');
+                if (newControl) {
+                    const onNewValueChangeSubscription = newControl.valueChanges
+                        .pipe(debounceTime(200))
+                        .subscribe(value => this.onValueChange(value, 'inlineInstanceNew'));
+                    this.registerDestroyListener(() => onNewValueChangeSubscription.unsubscribe());
+                }
+            }
+        }
+        if (this._isRowFilter) {
+            this.addFormControl('_filter');
+            this.filterControl = this.getFormControl('_filter');
+            if (this.filterControl) {
+                const onFilterValueSubscription = this.filterControl.valueChanges.subscribe(this.onFilterValueChange.bind(this));
+                this.registerDestroyListener(() => onFilterValueSubscription.unsubscribe());
+            }
+        }
+    }
+    // Reset the row filter value
+    resetFilter() {
+        if (this.filterControl) {
+            this.filterControl.setValue('');
+        }
+        if (this.filterwidget === FormWidgetType.AUTOCOMPLETE) {
+            this.filterInstance.query = '';
+            this.filterInstance.queryModel = '';
+        }
+    }
+    // On field value change, propagate event to parent form
+    onFilterValueChange(val) {
+        this.table.rowFilter[this.field].value = val;
+    }
+    // Get of the active from control
+    get datavalue() {
+        return this[this.activeControlType] && this[this.activeControlType].datavalue;
+    }
+    set datavalue(val) {
+        const control = this.getFormControl(this.activeControlType === 'inlineInstanceNew' ? '_new' : undefined);
+        if (!control) {
+            return;
+        }
+        if (control && this.editWidgetType !== FormWidgetType.UPLOAD) {
+            control.setValue(val);
+        }
+    }
+    get value() {
+        return this.datavalue;
+    }
+    set value(val) {
+        this.datavalue = val;
+    }
+    // On field value change, apply cascading filter and set validation message
+    onValueChange(val, widget) {
+        // Guard against component destruction or table being null
+        if (this.isDestroyed || !this.table) {
+            return;
+        }
+        if (val !== null) {
+            applyFilterOnField(this.table.datasource, this.widget, this.table.fieldDefs, val, {
+                widget: 'edit-widget-type'
+            });
+        }
+        if (this.table.ngform && this.table.ngform.touched) {
+            this.activeControlType = widget;
+            if (widget === 'inlineInstance') {
+                this.notifyChanges();
+                this.fieldValidations.setCustomValidationMessage();
+            }
+            else if (this._isNewEditableRow) {
+                this.notifyChanges('_new');
+                this.fieldValidations_new.setCustomValidationMessage();
+            }
+        }
+    }
+    loadFilterData() {
+        // If filterdataset is not bound, get the data implicitly
+        if (this._isRowFilter && isDataSetWidget(this.filterwidget) && !this.bindfilterdataset) {
+            // For live variable, get the data using distinct API
+            if (this.table.datasource.execute(DataSource.Operation.SUPPORTS_DISTINCT_API)) {
+                // check for related entity columns
+                if (this.relatedEntityName) {
+                    this.widget['is-related'] = true;
+                    this.widget['lookup-type'] = this.relatedEntityName;
+                    this.widget['lookup-field'] = last(split(this.field, '.'));
+                }
+                if (this.filterwidget === FormWidgetType.AUTOCOMPLETE) {
+                    this.filterInstance.dataoptions = getDistinctFieldProperties(this.table.datasource, this);
+                    this.filterInstance.datasource = this.table.datasource;
+                }
+                else {
+                    getDistinctValues(this.table.datasource, this.widget, 'filterwidget').then((res) => {
+                        this._filterDataSet = res.data;
+                        this.setFilterWidgetDataSet();
+                    });
+                }
+            }
+            else {
+                // For other datasources, get the data from datasource bound to table
+                //[Todo-CSP]: watch fn should already be generated from table dataset.bind expr
+                this.registerDestroyListener($watch(this.table.binddataset, this.viewParent, {}, nv => this.widget.filterdataset = nv, getWatchIdentifier(this.widgetId, 'filterdataset')));
+            }
+        }
+    }
+    loadInlineWidgetData() {
+        // If dataset is not bound, get the data implicitly
+        if (isDataSetWidget(this['edit-widget-type']) && !this.binddataset && !this.readonly) {
+            const dataSource = this.table.datasource;
+            if (this['related-entity-name'] && this['primary-key']) {
+                // Fetch the data for the related fields
+                this.isDataSetBound = true;
+                const bindings = split(this.binding, '.');
+                this.showPendingSpinner = true;
+                fetchRelatedFieldData(dataSource, this.widget, {
+                    relatedField: head(bindings),
+                    datafield: last(bindings),
+                    widget: 'edit-widget-type'
+                });
+            }
+            else if (dataSource.execute(DataSource.Operation.SUPPORTS_DISTINCT_API)) {
+                getDistinctValuesForField(dataSource, this.widget, {
+                    widget: 'edit-widget-type'
+                });
+            }
+        }
+    }
+    // On table datasource change, get the data for row filters
+    onDataSourceChange() {
+        this.loadFilterData();
+        if (this.table.editmode === EDIT_MODE.QUICK_EDIT) {
+            this.loadInlineWidgetData();
+        }
+    }
+    // Set the data on the row filter widget
+    setFilterWidgetDataSet() {
+        if (this.filterInstance) {
+            this.filterInstance.dataset = this._filterDataSet;
+        }
+    }
+    // Set the props on the row filter widget
+    setUpFilterWidget() {
+        this.filterInstance.registerReadyStateListener(() => {
+            if (isDataSetWidget(this.filterwidget)) {
+                // if binding is department.deptId then field will be deptId
+                const field = last(this.binding.split('.'));
+                this.filterInstance.dataset = this._filterDataSet;
+                this.filterInstance.datafield = this.filterdatafield || field;
+                this.filterInstance.displayfield = this.filterdisplayfield || field;
+                if (this.filterwidget === FormWidgetType.AUTOCOMPLETE) {
+                    this.filterInstance.displaylabel = this.filterdisplaylabel || field;
+                    this.filterInstance.searchkey = this.filtersearchkey || field;
+                }
+            }
+            if (this.filterwidget === FormWidgetType.TIME) {
+                this.filterInstance.timepattern = this.appDefaults.timeFormat || 'hh:mm:ss a';
+            }
+            this.filterInstance.placeholder = this.filterplaceholder || '';
+        });
+    }
+    // Notifies all the dependent validation controls incase of any changes
+    notifyChanges(quickEdit) {
+        forEach(this.notifyForFields, field => {
+            if (quickEdit && this._isNewEditableRow) {
+                field.fieldValidations_new.validate();
+            }
+            else {
+                field.fieldValidations.validate();
+            }
+        });
+    }
+    // Watches control for dependent validation changes
+    observeOn(fields) {
+        this.observeOnFields = cloneDeep(fields);
+    }
+    // Sets the default validators inline and quickedit new row using props
+    setUpValidators() {
+        this.fieldValidations.setUpValidators();
+        if (this._checkNewEditableRowControl()) {
+            this.fieldValidations_new.setUpValidators();
+        }
+    }
+    // Sets the Async validators on the inline and quickedit new row form control
+    setAsyncValidators(validators) {
+        this.asyncValidators = cloneDeep(validators);
+    }
+    // Sets the default/custom validators on the inline and quickedit new row form control
+    setValidators(validators) {
+        this.syncValidators = cloneDeep(validators);
+    }
+    boundFn(fn) {
+        return fn();
+    }
+    // Shows spinner for async validators based on status
+    onStatusChange(status, type) {
+        this['showPendingSpinner' + (type === 'inlineInstance' ? '' : 'New')] = (status === 'PENDING');
+    }
+    /* Summary Row Logic start */
+    setSummaryRowData(data) {
+        const newData = (data instanceof Array) ? data : [data];
+        this._invokeSummaryRowData(newData);
+    }
+    _invokeSummaryRowData(data) {
+        forEach(data, (item, index) => {
+            const content = item;
+            if (content instanceof Promise) {
+                content.then(res => {
+                    this.table.callDataGridMethod('setSummaryRowDef', this.key, res, index, true);
+                });
+            }
+            else if (content.value && content.value instanceof Promise) {
+                const contentData = content;
+                content.value.then(res => {
+                    contentData.value = res;
+                    this.table.callDataGridMethod('setSummaryRowDef', this.key, contentData, index, true);
+                });
+            }
+            this.table.callDataGridMethod('setSummaryRowDef', this.key, content, index);
+        });
+    }
+    _getColumnData() {
+        return map(this.table.dataset, this.binding);
+    }
+    /* Summary Row Logic end */
+    // Set the props on the inline edit widget
+    setInlineWidgetProp(widget, prop, nv) {
+        if (prop === 'datepattern' && this.editWidgetType === FormWidgetType.TIME) {
+            prop = 'timepattern';
+        }
+        if (this[widget] && isDefined(nv)) {
+            this[widget][prop] = nv;
+        }
+    }
+    // Initialize the inline edit widget
+    setUpInlineWidget(widget) {
+        this[widget].registerReadyStateListener(() => {
+            if (isDataSetWidget(this['edit-widget-type'])) {
+                this[widget].dataset = this.dataset;
+            }
+            inlineWidgetProps.forEach(key => {
+                this.setInlineWidgetProp(widget, key, this[key]);
+            });
+            this[widget].datasource = this._datasource;
+            this[widget].dataoptions = this._dataoptions;
+            this.setInlineWidgetProp(widget, 'datepattern', this.editdatepattern);
+        });
+    }
+    getStyleDef() {
+        return `width: ${this.width || ''}; background-color: ${this.backgroundcolor || ''}; color: ${this.textcolor || ''};`;
+    }
+    populateFieldDef() {
+        this.width = this.width === 'px' ? '' : (this.width || '');
+        this.field = this.binding;
+        this.displayName = this.caption || '';
+        this.pcDisplay = this.pcdisplay;
+        this.mobileDisplay = this.mobiledisplay;
+        this.tabletDisplay = this.tabletdisplay;
+        this.textAlignment = this.textalignment;
+        this.backgroundColor = this.backgroundcolor;
+        this.textColor = this.textcolor;
+        this.primaryKey = this['primary-key'];
+        this.relatedEntityName = this['related-entity-name'];
+        this.style = this.getStyleDef();
+        this.class = this['col-class'];
+        this.ngclass = this['col-ng-class'];
+        this.formatpattern = this.formatpattern === 'toNumber' ? 'numberToString' : this.formatpattern;
+        this.searchable = (this.type === 'blob' || this.type === 'clob') ? false : this.searchable;
+        this.showinfilter = (this.nativeElement.hasAttribute('showinfilter') && !(this.table && this.table.isdynamictable)) ? this.nativeElement.getAttribute('showinfilter') : (this.show);
+        this.limit = this.limit ? +this.limit : undefined;
+        this.editWidgetType = this['edit-widget-type'] = this['edit-widget-type'] || getEditModeWidget(this);
+        this.filterOn = this['filter-on'];
+        this.readonly = isDefined(this.getAttr('readonly')) ? this.getAttr('readonly') === 'true' : (this['related-entity-name'] ? !this['primary-key'] : includes(['identity', 'uniqueid', 'sequence'], this.generator));
+        this.filterwidget = this.filterwidget || getDataTableFilterWidget(this.type || 'string');
+        this.isFilterDataSetBound = !!this.bindfilterdataset;
+        this.defaultvalue = getDefaultValue(this.defaultvalue, this.type, this.editWidgetType);
+        this.caseinsensitive = !!this.getAttr('caseinsensitive');
+        this.sortby = this.sortby || this.getAttr('sortby') || "";
+        // For date time data types, if date pattern is not specified, set the app format or default format
+        if (isDateTimeType(this.type) && this.formatpattern === 'toDate' && !this.datepattern) {
+            const defaultFormat = getDisplayDateTimeFormat(this.type);
+            if (this.type === DataType.DATE) {
+                this.datepattern = this.appDefaults.dateFormat || defaultFormat;
+            }
+            else if (this.type === DataType.TIME) {
+                this.datepattern = this.appDefaults.timeFormat || defaultFormat;
+            }
+            else if (this.type === DataType.TIMESTAMP || this.type === DataType.DATETIME) {
+                this.datepattern = this.appDefaults.dateTimeFormat || defaultFormat;
+            }
+        }
+    }
+    onPropertyChange(key, nv, ov) {
+        if (!this._propsInitialized) {
+            return;
+        }
+        switch (key) {
+            case 'caption':
+                this.displayName = nv || '';
+                this.setProperty('displayName', this.displayName);
+                // Fix for [WMS-25934]: update the headerConfig list when there is change in display name
+                // when column is inside a group then consider the col index and not header index.
+                const fieldName = this.group && this.group.name;
+                const index = fieldName ? parseInt(this.getAttr('index'), 10) : parseInt(this.getAttr('headerIndex'), 10);
+                // Register column with header config to create group structure
+                if (!this.table.headerConfig.some(value => this.field == value.field)) {
+                    setHeaderConfigForTable(this.table.headerConfig, {
+                        field: this.field,
+                        displayName: this.displayName
+                    }, fieldName, index);
+                }
+                else {
+                    this.table.headerConfig.map(value => {
+                        if (this.field == value.field) {
+                            value.displayName = this.displayName;
+                        }
+                    });
+                }
+                break;
+            case 'defaultvalue':
+                this.defaultvalue = getDefaultValue(this.defaultvalue, this.type, this.editWidgetType);
+                break;
+            case 'show':
+                this.table.redraw(false);
+                this.showinfilter = this.nativeElement.hasAttribute('showinfilter') ? this.nativeElement.getAttribute('showinfilter') : nv;
+                break;
+            case 'filterdataset':
+                this._filterDataSet = nv;
+                this.setFilterWidgetDataSet();
+                break;
+            case 'editdatepattern':
+                this.setInlineWidgetProp('inlineInstance', 'datepattern', nv);
+                this.setInlineWidgetProp('inlineInstanceNew', 'datepattern', nv);
+                break;
+            case 'showinfilter':
+                this.showinfilter = nv;
+                break;
+            default:
+                if (inlineWidgetProps.includes(key)) {
+                    this.setInlineWidgetProp('inlineInstance', key, nv);
+                    this.setInlineWidgetProp('inlineInstanceNew', key, nv);
+                }
+                break;
+        }
+        super.onPropertyChange(key, nv, ov);
+    }
+    setProperty(property, nv) {
+        this[property] = nv;
+        switch (property) {
+            case 'displayName':
+                this.table.callDataGridMethod('setColumnProp', this.field, property, nv);
+                break;
+            default:
+                this.table.redraw(true);
+        }
+    }
+    ngOnDestroy() {
+        // MEMORY LEAK FIX: Clear ContentChildren QueryLists
+        if (this._filterInstances) {
+            try {
+                this._filterInstances.reset([]);
+            }
+            catch (e) {
+                // Silently handle cleanup errors - QueryList might already be destroyed
+            }
+        }
+        if (this._inlineInstances) {
+            try {
+                this._inlineInstances.reset([]);
+            }
+            catch (e) {
+                // Silently handle cleanup errors - QueryList might already be destroyed
+            }
+        }
+        if (this._inlineInstancesNew) {
+            try {
+                this._inlineInstancesNew.reset([]);
+            }
+            catch (e) {
+                // Silently handle cleanup errors - QueryList might already be destroyed
+            }
+        }
+        // MEMORY LEAK FIX: Clear all widget instance references
+        this.filterInstance = null;
+        this.inlineInstance = null;
+        this.inlineInstanceNew = null;
+        // MEMORY LEAK FIX: Clear template references
+        this.customExprTmpl = null;
+        this.inlineWidthTempRef = null;
+        this.filterTemplateRef = null;
+        // MEMORY LEAK FIX: Clear dataset references
+        this._filterDataSet = null;
+        this.dataset = null;
+        this._dataoptions = null;
+        this._datasource = null;
+        // MEMORY LEAK FIX: Clear validation objects
+        if (this.fieldValidations) {
+            try {
+                this.fieldValidations.destroy();
+            }
+            catch (e) {
+                // Silently handle cleanup errors
+            }
+            this.fieldValidations = null;
+        }
+        if (this.fieldValidations_new) {
+            try {
+                this.fieldValidations_new.destroy();
+            }
+            catch (e) {
+                // Silently handle cleanup errors
+            }
+            this.fieldValidations_new = null;
+        }
+        this.syncValidators = [];
+        this.asyncValidators = [];
+        // MEMORY LEAK FIX: Clear filter control reference
+        this.filterControl = null;
+        // MEMORY LEAK FIX: Clear notify fields array
+        if (this.notifyForFields) {
+            this.notifyForFields = [];
+        }
+        // MEMORY LEAK FIX: Clear observe fields array
+        if (this.observeOnFields) {
+            this.observeOnFields = [];
+        }
+        // MEMORY LEAK FIX: Clear table and group references
+        // Note: These are injected dependencies, but clearing helps GC
+        this.table = null;
+        this.group = null;
+        // Call parent ngOnDestroy
+        super.ngOnDestroy();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TableColumnDirective, deps: [{ token: i0.Injector }, { token: i1.AppDefaults }, { token: i2.TableComponent, optional: true }, { token: i3.TableColumnGroupDirective, optional: true }, { token: 'filterdataset.bind', attribute: true }, { token: 'dataset.bind', attribute: true }, { token: 'EXPLICIT_CONTEXT', optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: TableColumnDirective, isStandalone: true, selector: "[wmTableColumn]", providers: [
+            provideAsWidgetRef(TableColumnDirective)
+        ], queries: [{ propertyName: "customExprTmpl", first: true, predicate: ["customExprTmpl"], descendants: true }, { propertyName: "inlineWidthTempRef", first: true, predicate: ["inlineWidgetTmpl"], descendants: true }, { propertyName: "filterTemplateRef", first: true, predicate: ["filterTmpl"], descendants: true }, { propertyName: "_filterInstances", predicate: ["filterWidget"], descendants: true }, { propertyName: "_inlineInstances", predicate: ["inlineWidget"], descendants: true }, { propertyName: "_inlineInstancesNew", predicate: ["inlineWidgetNew"], descendants: true }], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TableColumnDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[wmTableColumn]',
+                    providers: [
+                        provideAsWidgetRef(TableColumnDirective)
+                    ]
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i1.AppDefaults }, { type: i2.TableComponent, decorators: [{
+                    type: Optional
+                }] }, { type: i3.TableColumnGroupDirective, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['filterdataset.bind']
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['dataset.bind']
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['EXPLICIT_CONTEXT']
+                }, {
+                    type: Optional
+                }] }], propDecorators: { _filterInstances: [{
+                type: ContentChildren,
+                args: ['filterWidget', { descendants: true }]
+            }], _inlineInstances: [{
+                type: ContentChildren,
+                args: ['inlineWidget', { descendants: true }]
+            }], _inlineInstancesNew: [{
+                type: ContentChildren,
+                args: ['inlineWidgetNew', { descendants: true }]
+            }], customExprTmpl: [{
+                type: ContentChild,
+                args: ['customExprTmpl']
+            }], inlineWidthTempRef: [{
+                type: ContentChild,
+                args: ['inlineWidgetTmpl']
+            }], filterTemplateRef: [{
+                type: ContentChild,
+                args: ['filterTmpl']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-column.directive.js","sourceRoot":"","sources":["../../../../../../projects/components/widgets/data/table/src/table-column/table-column.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterContentInit,\n    AfterViewInit,\n    Attribute,\n    ContentChild,\n    ContentChildren,\n    Directive,\n    Inject,\n    Injector,\n    OnDestroy,\n    OnInit,\n    Optional,\n    TemplateRef\n} from '@angular/core';\n\nimport {\n    $watch,\n    AppDefaults,\n    DataSource,\n    DataType,\n    FormWidgetType,\n    getDisplayDateTimeFormat,\n    isDateTimeType,\n    isDefined\n} from '@wm/core';\nimport {\n    applyFilterOnField,\n    BaseComponent,\n    BaseFieldValidations,\n    EDIT_MODE,\n    fetchRelatedFieldData,\n    getDataTableFilterWidget,\n    getDefaultValue,\n    getDistinctFieldProperties,\n    getDistinctValues,\n    getDistinctValuesForField,\n    getEditModeWidget,\n    getWatchIdentifier,\n    isDataSetWidget,\n    provideAsWidgetRef,\n    setHeaderConfigForTable\n} from '@wm/components/base';\nimport {registerProps} from './table-column.props';\nimport {TableComponent} from '../table.component';\nimport {TableColumnGroupDirective} from '../table-column-group/table-column-group.directive';\nimport {debounceTime} from 'rxjs/operators';\nimport {cloneDeep, forEach, head, includes, last, map, max, mean, min, round, split, sum} from \"lodash-es\";\n\nconst WIDGET_CONFIG = {widgetType: 'wm-table-column', hostClass: ''};\n\nlet inlineWidgetProps = ['datafield', 'displayfield', 'placeholder', 'searchkey','sortby', 'matchmode', 'displaylabel', 'groupby', 'match', 'dateformat', 'showcount', 'collapsible',\n                            'checkedvalue', 'uncheckedvalue', 'showdropdownon', 'dataentrymode', 'autoclose', 'dataset', 'outputformat'];\nconst validationProps = ['maxchars', 'regexp', 'minvalue', 'maxvalue', 'step', 'required', 'mindate', 'maxdate',\n                            'excludedates', 'excludedays', 'mintime', 'maxtime'];\ninlineWidgetProps = [...inlineWidgetProps, ...validationProps];\n\nclass FieldDef {\n    widget;\n\n    constructor(widget) {\n        this.widget = widget;\n    }\n\n    focus() {\n        this.widget.focus();\n    }\n\n    setProperty(prop, newval) {\n        // Get the scope of the current editable widget and set the value\n        prop = prop === 'value' ? 'datavalue' : prop;\n        this.widget[prop] = newval;\n    }\n\n    getProperty(prop) {\n        prop = prop === 'value' ? 'datavalue' : prop;\n        return this.widget[prop];\n    }\n}\n\n@Directive({\n  standalone: true,\n    selector: '[wmTableColumn]',\n    providers: [\n        provideAsWidgetRef(TableColumnDirective)\n    ]\n})\nexport class TableColumnDirective extends BaseComponent implements OnInit, AfterContentInit, AfterViewInit, OnDestroy {\n    static initializeProps = registerProps();\n\n    @ContentChildren('filterWidget', { descendants: true }) _filterInstances;\n    @ContentChildren('inlineWidget', { descendants: true }) _inlineInstances;\n    @ContentChildren('inlineWidgetNew', { descendants: true }) _inlineInstancesNew;\n    @ContentChild('customExprTmpl') customExprTmpl;\n    @ContentChild('inlineWidgetTmpl') inlineWidthTempRef;\n\n    private _propsInitialized: boolean;\n    private _filterDataSet;\n    private _isRowFilter;\n    private _isInlineEditable;\n    private _isNewEditableRow;\n\n    key;\n    filterInstance;\n    inlineInstance;\n    inlineInstanceNew;\n\n    backgroundcolor;\n    binding;\n    caption;\n    dataset;\n    defaultvalue;\n    editWidgetType;\n    filterwidget;\n    field;\n    formatpattern;\n    custompipeformat;\n    generator;\n    limit;\n    mobiledisplay;\n    pcdisplay;\n    tabletdisplay;\n    readonly;\n    required;\n    maxchars;\n    minvalue;\n    maxvalue;\n    regexp;\n    searchable;\n    showinfilter;\n    show;\n    sortable;\n    caseinsensitive;\n    textalignment;\n    textcolor;\n    type;\n    width;\n    datepattern;\n    editdatepattern;\n    filterdatafield;\n    filterdisplayfield;\n    filterdisplaylabel;\n    filtersearchkey;\n    sortby;\n    filterplaceholder;\n    datafield;\n    displayfield;\n    displayName;\n    pcDisplay;\n    mobileDisplay;\n    tabletDisplay;\n    textAlignment;\n    backgroundColor;\n    textColor;\n    primaryKey;\n    relatedEntityName;\n    style;\n    class;\n    ngclass;\n    filterOn;\n    filterControl;\n    isDataSetBound;\n    isFilterDataSetBound;\n    showPendingSpinner;\n    showPendingSpinnerNew;\n    validationmessage;\n    activeControlType;\n    private _dataoptions: any;\n    private _datasource: any;\n    private notifyForFields: any;\n    private fieldValidations;\n    private fieldValidations_new;\n\n    private syncValidators = [];\n    private asyncValidators = [];\n    private observeOnFields = [];\n\n    @ContentChild('filterTmpl') filterTemplateRef: TemplateRef<any>;\n\n    constructor(\n        inj: Injector,\n        private appDefaults: AppDefaults,\n        @Optional() public table: TableComponent,\n        @Optional() public group: TableColumnGroupDirective,\n        @Attribute('filterdataset.bind') public bindfilterdataset,\n        @Attribute('dataset.bind') public binddataset,\n        @Inject('EXPLICIT_CONTEXT') @Optional() explicitContext: any\n    ) {\n        super(inj, WIDGET_CONFIG, explicitContext);\n\n        this.notifyForFields = [];\n    }\n\n    get dataoptions() {\n        return this._dataoptions;\n    }\n\n    set dataoptions(options) {\n        this._dataoptions = options;\n    }\n\n    get datasource() {\n        return this._datasource;\n    }\n\n    set datasource(ds) {\n        this._datasource = ds;\n    }\n\n    ngOnInit() {\n        super.ngOnInit();\n\n        // Set the default values and register with table\n        this.populateFieldDef();\n        // when column is inside a group then consider the col index and not header index.\n        const colIndex = parseInt(this.getAttr('index'), 10);\n        const headerIndex = parseInt(this.getAttr('headerIndex'), 10);\n        const fieldName = this.group && this.group.name;\n        // Register column with header config to create group structure\n        setHeaderConfigForTable(this.table.headerConfig, {\n            field: this.field,\n            displayName: this.displayName\n        }, fieldName, fieldName ? colIndex : headerIndex);\n\n        this.table.registerColumns(this.widget, colIndex);\n\n        this._isRowFilter = this.table.filtermode === 'multicolumn' && this.searchable;\n        this._isInlineEditable = !this.readonly && (this.table.editmode !== EDIT_MODE.DIALOG && this.table.editmode !== EDIT_MODE.FORM);\n        this._isNewEditableRow = this._isInlineEditable && this.table.editmode === EDIT_MODE.QUICK_EDIT && this.table.shownewrow;\n        this.setUpControls();\n\n        this._propsInitialized = true;\n\n        // Inline control status change subscriber\n        if (this.getFormControl()) {\n            const onStatusChangeSubscription = this.getFormControl().statusChanges\n                .pipe(debounceTime(100))\n                .subscribe(status => this.onStatusChange(status, 'inlineInstance'));\n            this.registerDestroyListener(() => onStatusChangeSubscription.unsubscribe());\n            // Instantiate custom validators class for inline edit form control\n            this.fieldValidations = new BaseFieldValidations(this, this['inlineInstance'], this.editWidgetType, this.getFormControl(), this.table, 'inlineInstance');\n        }\n\n        // Quick edit new row control status change subscriber\n        if (this._checkNewEditableRowControl()) {\n            const onStatusChangeSubscription_new = this.getFormControl('_new').statusChanges\n                .pipe(debounceTime(100))\n                .subscribe(status => this.onStatusChange(status, 'inlineInstanceNew'));\n            this.registerDestroyListener(() => onStatusChangeSubscription_new.unsubscribe());\n            // Instantiate custom validators class for Quick edit newrow form control\n            this.fieldValidations_new = new BaseFieldValidations(this, this['inlineInstanceNew'], this.editWidgetType, this.getFormControl('_new'), this.table, 'inlineInstanceNew');\n        }\n    }\n\n    ngAfterContentInit() {\n        if (this._isRowFilter) {\n            // Listen on the inner row filter widget and setup the widget\n            const s1 = this._filterInstances.changes.subscribe((val) => {\n                this.filterInstance = val.first && val.first.widget;\n                this.setUpFilterWidget();\n            });\n            this.registerDestroyListener(() => s1.unsubscribe());\n        }\n\n        if (this._isInlineEditable) {\n            const s2 = this._inlineInstances.changes.subscribe((val) => {\n                // Listen on the inner inline widget and setup the widget\n                this.inlineInstance = val.first && val.first.widget;\n                this.fieldValidations.formwidget = val.first;\n                this.table.registerFormField(this.binding, new FieldDef(this.inlineInstance));\n                this.setUpInlineWidget('inlineInstance');\n            });\n            this.registerDestroyListener(() => s2.unsubscribe());\n\n            if (this._isNewEditableRow) {\n                const s3 = this._inlineInstancesNew.changes.subscribe((val) => {\n                    // Listen on the inner inline widget and setup the widget\n                    this.inlineInstanceNew = val.first && val.first.widget;\n                    this.fieldValidations_new.formwidget = val.first;\n                    this.setUpInlineWidget('inlineInstanceNew');\n                });\n                this.registerDestroyListener(() => s3.unsubscribe());\n            }\n        }\n        this.registerReadyStateListener(() => {\n            this.key = this.field || this.binding;\n        });\n        super.ngAfterContentInit();\n        if ((this as any).table.isdynamictable) {\n            (this.table.inlineWidgetTmpl as any)._results.push(this.inlineWidthTempRef);\n        }\n    }\n\n    ngAfterViewInit() {\n        // manually listing the table column templateRef as templateRef will not be available prior.\n        if (this.filterTemplateRef) {\n            this.table.renderDynamicFilterColumn(this.filterTemplateRef);\n        }\n    }\n\n    // Apply default|sync|async|prop validators for inline form control\n    applyValidations() {\n        if (!this.getFormControl()) {\n            return;\n        }\n        if (this.syncValidators.length > 0) {\n            this.fieldValidations.setValidators(this.syncValidators);\n        }\n        this.fieldValidations.setUpValidators();\n        if (this.asyncValidators.length > 0) {\n            this.fieldValidations.setAsyncValidators(this.asyncValidators);\n        }\n        if (this.observeOnFields.length > 0) {\n            this.fieldValidations.observeOn(this.observeOnFields, 'columns');\n        }\n    }\n\n    // Remove validators for the inline widget and set form to untouched\n    removeValidations() {\n        // Guard against component destruction or table/ngform being null\n        if (this.isDestroyed || !this.table || !this.table.ngform) {\n            return;\n        }\n        this.table.ngform.markAsUntouched();\n        const control = this.getFormControl();\n        if (!control) {\n            return;\n        }\n        control.clearValidators();\n        control.clearAsyncValidators();\n        control.updateValueAndValidity();\n    }\n\n    // Apply default|sync|async|prop validators for QuickEdit new row form control\n    applyNewRowValidations() {\n        // Guard against component destruction or table/ngform being null\n        if (this.isDestroyed || !this.table || !this.table.ngform) {\n            return;\n        }\n        if (!this._checkNewEditableRowControl()) {\n            return;\n        }\n        if (this.syncValidators.length > 0) {\n            this.fieldValidations_new.setValidators(this.syncValidators);\n        }\n        this.fieldValidations_new.setUpValidators();\n        if (this.asyncValidators.length > 0) {\n            this.fieldValidations_new.setAsyncValidators(this.asyncValidators);\n        }\n        if (this.observeOnFields.length > 0) {\n            this.fieldValidations_new.observeOn(this.observeOnFields, 'columns');\n        }\n    }\n\n    // Remove validators for the QuickEdit new row widget and set form to untouched\n    removeNewRowValidations() {\n        // Guard against component destruction or table/ngform being null\n        if (this.isDestroyed || !this.table || !this.table.ngform) {\n            return;\n        }\n        this.table.ngform.markAsUntouched();\n        if (!this._checkNewEditableRowControl()) {\n            return;\n        }\n        const control = this.getFormControl('_new');\n        if (!control) {\n            return;\n        }\n        control.clearValidators();\n        control.clearAsyncValidators();\n        control.updateValueAndValidity();\n    }\n\n    addFormControl(suffix?: string) {\n        // Guard against component destruction or table/ngform being null\n        if (this.isDestroyed || !this.table || !this.table.ngform) {\n            return;\n        }\n        const ctrlName = suffix ? (this.binding + suffix) : this.binding;\n        this.table.ngform.addControl(ctrlName, this.table.fb.control(''));\n    }\n\n    getFormControl(suffix?: string) {\n        // Guard against component destruction or table/ngform being null\n        if (this.isDestroyed || !this.table || !this.table.ngform) {\n            return null;\n        }\n        const ctrlName = suffix ? (this.binding + suffix) : this.binding;\n        return this.table.ngform.controls[ctrlName] || null;\n    }\n\n    private _checkNewEditableRowControl() {\n        return this._isNewEditableRow && this.getFormControl('_new');\n    }\n\n    // Setup the inline edit and filter widget\n    setUpControls() {\n        if (this._isInlineEditable) {\n            if (this.editWidgetType === FormWidgetType.UPLOAD) {\n                return;\n            }\n            this.addFormControl();\n            const control = this.getFormControl();\n            if (control) {\n                const onValueChangeSubscription =  control.valueChanges\n                    .pipe(debounceTime(200))\n                    .subscribe(value => this.onValueChange(value, 'inlineInstance'));\n                this.registerDestroyListener(() => onValueChangeSubscription.unsubscribe());\n            }\n\n            if (this._isNewEditableRow) {\n                this.addFormControl('_new');\n                const newControl = this.getFormControl('_new');\n                if (newControl) {\n                    const onNewValueChangeSubscription =  newControl.valueChanges\n                        .pipe(debounceTime(200))\n                        .subscribe(value => this.onValueChange(value, 'inlineInstanceNew'));\n                    this.registerDestroyListener(() => onNewValueChangeSubscription.unsubscribe());\n                }\n            }\n        }\n\n        if (this._isRowFilter) {\n            this.addFormControl('_filter');\n            this.filterControl = this.getFormControl('_filter');\n            if (this.filterControl) {\n                const onFilterValueSubscription = this.filterControl.valueChanges.subscribe(this.onFilterValueChange.bind(this));\n                this.registerDestroyListener(() => onFilterValueSubscription.unsubscribe());\n            }\n        }\n    }\n\n    // Reset the row filter value\n    resetFilter() {\n        if (this.filterControl) {\n            this.filterControl.setValue('');\n        }\n        if (this.filterwidget === FormWidgetType.AUTOCOMPLETE) {\n            this.filterInstance.query = '';\n            this.filterInstance.queryModel = '';\n        }\n    }\n\n    // On field value change, propagate event to parent form\n    onFilterValueChange(val) {\n        this.table.rowFilter[this.field].value = val;\n    }\n\n    // Get of the active from control\n    get datavalue() {\n        return this[this.activeControlType] && this[this.activeControlType].datavalue;\n    }\n\n    set datavalue(val) {\n        const control = this.getFormControl(this.activeControlType === 'inlineInstanceNew' ? '_new' : undefined);\n        if (!control) {\n            return;\n        }\n        if (control && this.editWidgetType !== FormWidgetType.UPLOAD) {\n            control.setValue(val);\n        }\n    }\n\n    get value() {\n        return this.datavalue;\n    }\n\n    set value(val) {\n        this.datavalue = val;\n    }\n\n    // On field value change, apply cascading filter and set validation message\n    onValueChange(val, widget) {\n        // Guard against component destruction or table being null\n        if (this.isDestroyed || !this.table) {\n            return;\n        }\n        if (val !== null) {\n            applyFilterOnField(this.table.datasource, this.widget, this.table.fieldDefs, val, {\n                widget: 'edit-widget-type'\n            });\n        }\n        if (this.table.ngform && this.table.ngform.touched) {\n            this.activeControlType = widget;\n            if (widget === 'inlineInstance') {\n                this.notifyChanges();\n                this.fieldValidations.setCustomValidationMessage();\n            } else if (this._isNewEditableRow) {\n                this.notifyChanges('_new');\n                this.fieldValidations_new.setCustomValidationMessage();\n            }\n        }\n    }\n\n    loadFilterData() {\n        // If filterdataset is not bound, get the data implicitly\n        if (this._isRowFilter && isDataSetWidget(this.filterwidget) && !this.bindfilterdataset) {\n            // For live variable, get the data using distinct API\n            if (this.table.datasource.execute(DataSource.Operation.SUPPORTS_DISTINCT_API)) {\n                // check for related entity columns\n                if (this.relatedEntityName) {\n                    this.widget['is-related']  = true;\n                    this.widget['lookup-type']  = this.relatedEntityName;\n                    this.widget['lookup-field'] = last(split(this.field, '.'));\n                }\n                if (this.filterwidget === FormWidgetType.AUTOCOMPLETE) {\n                    this.filterInstance.dataoptions = getDistinctFieldProperties(this.table.datasource, this);\n                    this.filterInstance.datasource = this.table.datasource;\n                } else {\n                    getDistinctValues(this.table.datasource, this.widget, 'filterwidget').then((res: any) => {\n                        this._filterDataSet = res.data;\n                        this.setFilterWidgetDataSet();\n                    });\n                }\n            } else {\n                // For other datasources, get the data from datasource bound to table\n                //[Todo-CSP]: watch fn should already be generated from table dataset.bind expr\n                this.registerDestroyListener(\n                    $watch(\n                        this.table.binddataset,\n                        this.viewParent,\n                        {},\n                        nv => this.widget.filterdataset = nv,\n                        getWatchIdentifier(this.widgetId, 'filterdataset')\n                    )\n                );\n            }\n        }\n    }\n\n    loadInlineWidgetData() {\n        // If dataset is not bound, get the data implicitly\n        if (isDataSetWidget(this['edit-widget-type']) && !this.binddataset && !this.readonly) {\n            const dataSource = this.table.datasource;\n            if (this['related-entity-name'] && this['primary-key']) {\n                // Fetch the data for the related fields\n                this.isDataSetBound = true;\n                const bindings = split(this.binding, '.');\n                this.showPendingSpinner = true;\n                fetchRelatedFieldData(dataSource, this.widget, {\n                    relatedField: head(bindings),\n                    datafield: last(bindings),\n                    widget: 'edit-widget-type'\n                });\n            } else if (dataSource.execute(DataSource.Operation.SUPPORTS_DISTINCT_API)) {\n                getDistinctValuesForField(dataSource, this.widget, {\n                    widget: 'edit-widget-type'\n                });\n            }\n        }\n    }\n\n    // On table datasource change, get the data for row filters\n    onDataSourceChange() {\n        this.loadFilterData();\n        if (this.table.editmode === EDIT_MODE.QUICK_EDIT) {\n            this.loadInlineWidgetData();\n        }\n    }\n\n    // Set the data on the row filter widget\n    setFilterWidgetDataSet() {\n        if (this.filterInstance) {\n            this.filterInstance.dataset = this._filterDataSet;\n        }\n    }\n\n    // Set the props on the row filter widget\n    setUpFilterWidget() {\n        this.filterInstance.registerReadyStateListener(() => {\n            if (isDataSetWidget(this.filterwidget)) {\n                // if binding is department.deptId then field will be deptId\n                const field = last(this.binding.split('.'));\n                this.filterInstance.dataset = this._filterDataSet;\n                this.filterInstance.datafield = this.filterdatafield || field;\n                this.filterInstance.displayfield = this.filterdisplayfield || field;\n                if (this.filterwidget === FormWidgetType.AUTOCOMPLETE) {\n                    this.filterInstance.displaylabel = this.filterdisplaylabel || field;\n                    this.filterInstance.searchkey = this.filtersearchkey || field;\n                }\n            }\n            if (this.filterwidget === FormWidgetType.TIME) {\n                this.filterInstance.timepattern = this.appDefaults.timeFormat || 'hh:mm:ss a';\n            }\n            this.filterInstance.placeholder = this.filterplaceholder || '';\n        });\n    }\n\n    // Notifies all the dependent validation controls incase of any changes\n    notifyChanges(quickEdit?) {\n        forEach(this.notifyForFields, field => {\n            if (quickEdit && this._isNewEditableRow) {\n                field.fieldValidations_new.validate();\n            } else {\n                field.fieldValidations.validate();\n            }\n        });\n    }\n\n    // Watches control for dependent validation changes\n    observeOn(fields) {\n        this.observeOnFields = cloneDeep(fields);\n    }\n\n    // Sets the default validators inline and quickedit new row using props\n    setUpValidators() {\n        this.fieldValidations.setUpValidators();\n        if (this._checkNewEditableRowControl()) {\n            this.fieldValidations_new.setUpValidators();\n        }\n    }\n\n    // Sets the Async validators on the inline and quickedit new row form control\n    setAsyncValidators(validators) {\n        this.asyncValidators = cloneDeep(validators);\n    }\n\n    // Sets the default/custom validators on the inline and quickedit new row form control\n    setValidators(validators) {\n        this.syncValidators = cloneDeep(validators);\n    }\n\n    boundFn(fn) {\n        return fn();\n    }\n\n    // Shows spinner for async validators based on status\n    onStatusChange(status, type) {\n        this['showPendingSpinner' + (type === 'inlineInstance' ? '' : 'New')] = (status === 'PENDING');\n    }\n\n    /* Summary Row Logic start */\n    setSummaryRowData(data) {\n        const newData = (data instanceof Array) ? data : [data];\n        this._invokeSummaryRowData(newData);\n    }\n\n    private _invokeSummaryRowData(data) {\n        forEach(data, (item, index) => {\n            const content = item;\n            if (content instanceof Promise) {\n                content.then(res => {\n                    this.table.callDataGridMethod('setSummaryRowDef', this.key, res, index, true);\n                });\n            } else if (content.value && content.value instanceof Promise) {\n                const contentData = content;\n                content.value.then(res => {\n                    contentData.value = res;\n                    this.table.callDataGridMethod('setSummaryRowDef', this.key, contentData, index, true);\n                });\n            }\n            this.table.callDataGridMethod('setSummaryRowDef', this.key, content, index);\n        });\n    }\n    private _getColumnData() {\n        return map(this.table.dataset, this.binding);\n    }\n\n    public aggregate = {\n        sum: () => {\n            return sum(this._getColumnData());\n        },\n        average: (precision: number = 2) => {\n            return round(mean(this._getColumnData()), precision);\n        },\n        count: () => {\n            return this._getColumnData().length;\n        },\n        minimum: () => {\n            return min(this._getColumnData());\n        },\n        maximum: () => {\n            return max(this._getColumnData());\n        },\n        percent: (value, precision: number = 2) => {\n            return round((sum(this._getColumnData()) / value) * 100, precision);\n        }\n    };\n    /* Summary Row Logic end */\n\n    // Set the props on the inline edit widget\n    setInlineWidgetProp(widget, prop, nv) {\n        if (prop === 'datepattern' && this.editWidgetType === FormWidgetType.TIME) {\n            prop = 'timepattern';\n        }\n        if (this[widget] && isDefined(nv)) {\n            this[widget][prop] = nv;\n        }\n    }\n\n    // Initialize the inline edit widget\n    setUpInlineWidget(widget) {\n        this[widget].registerReadyStateListener(() => {\n            if (isDataSetWidget(this['edit-widget-type'])) {\n                this[widget].dataset = this.dataset;\n            }\n            inlineWidgetProps.forEach(key => {\n                this.setInlineWidgetProp(widget, key, this[key]);\n            });\n            this[widget].datasource = this._datasource;\n            this[widget].dataoptions = this._dataoptions;\n            this.setInlineWidgetProp(widget, 'datepattern', this.editdatepattern);\n        });\n    }\n\n    getStyleDef() {\n        return `width: ${this.width || ''}; background-color: ${this.backgroundcolor || ''}; color: ${this.textcolor || ''};`;\n    }\n\n    populateFieldDef() {\n        this.width = this.width === 'px' ?  '' : (this.width || '');\n        this.field = this.binding;\n        this.displayName =  this.caption || '';\n        this.pcDisplay =  this.pcdisplay;\n        this.mobileDisplay =  this.mobiledisplay;\n        this.tabletDisplay =  this.tabletdisplay;\n        this.textAlignment =  this.textalignment;\n        this.backgroundColor =  this.backgroundcolor;\n        this.textColor =  this.textcolor;\n        this.primaryKey =  this['primary-key'];\n        this.relatedEntityName =  this['related-entity-name'];\n        this.style =  this.getStyleDef();\n        this.class =  this['col-class'];\n        this.ngclass =  this['col-ng-class'];\n        this.formatpattern =  this.formatpattern === 'toNumber' ? 'numberToString'  :  this.formatpattern;\n        this.searchable =  (this.type === 'blob' || this.type === 'clob') ? false  :  this.searchable;\n        this.showinfilter = (this.nativeElement.hasAttribute('showinfilter') && !((this as any).table && (this as any).table.isdynamictable)) ? this.nativeElement.getAttribute('showinfilter') : (this.show);\n        this.limit =  this.limit ? +this.limit  :  undefined;\n        this.editWidgetType = this['edit-widget-type'] =  this['edit-widget-type'] || getEditModeWidget(this);\n        this.filterOn =  this['filter-on'];\n        this.readonly = isDefined(this.getAttr('readonly')) ? this.getAttr('readonly') === 'true' : (this['related-entity-name'] ? !this['primary-key'] : includes(['identity', 'uniqueid', 'sequence'], this.generator));\n        this.filterwidget =  this.filterwidget || getDataTableFilterWidget(this.type || 'string');\n        this.isFilterDataSetBound = !!this.bindfilterdataset;\n        this.defaultvalue = getDefaultValue(this.defaultvalue, this.type, this.editWidgetType);\n        this.caseinsensitive =  !!this.getAttr('caseinsensitive');\n        this.sortby =  this.sortby||this.getAttr('sortby') || \"\";\n\n        // For date time data types, if date pattern is not specified, set the app format or default format\n        if (isDateTimeType(this.type) && this.formatpattern === 'toDate' && !this.datepattern) {\n            const defaultFormat = getDisplayDateTimeFormat(this.type);\n            if (this.type === DataType.DATE) {\n                this.datepattern  = this.appDefaults.dateFormat || defaultFormat;\n            } else if (this.type === DataType.TIME) {\n                this.datepattern  = this.appDefaults.timeFormat || defaultFormat;\n            } else if (this.type === DataType.TIMESTAMP || this.type === DataType.DATETIME) {\n                this.datepattern  = this.appDefaults.dateTimeFormat || defaultFormat;\n            }\n        }\n    }\n\n    onPropertyChange(key, nv, ov) {\n        if (!this._propsInitialized) {\n            return;\n        }\n        switch (key) {\n            case 'caption':\n                this.displayName = nv || '';\n                this.setProperty('displayName', this.displayName);\n                // Fix for [WMS-25934]: update the headerConfig list when there is change in display name\n                // when column is inside a group then consider the col index and not header index.\n                const fieldName = this.group && this.group.name;\n                const index: number = fieldName ? parseInt(this.getAttr('index'), 10) : parseInt(this.getAttr('headerIndex'), 10);\n                // Register column with header config to create group structure\n                if (!this.table.headerConfig.some(value => this.field == value.field)) {\n                    setHeaderConfigForTable(this.table.headerConfig, {\n                        field: this.field,\n                        displayName: this.displayName\n                    }, fieldName, index);\n                }\n                else {\n                    this.table.headerConfig.map(value => {\n                        if (this.field == value.field) {\n                            value.displayName = this.displayName;\n                        }\n                    });\n                }\n                break;\n            case 'defaultvalue':\n                this.defaultvalue = getDefaultValue(this.defaultvalue, this.type, this.editWidgetType);\n                break;\n            case 'show':\n                this.table.redraw(false);\n                this.showinfilter = this.nativeElement.hasAttribute('showinfilter') ? this.nativeElement.getAttribute('showinfilter') : nv;\n                break;\n            case 'filterdataset':\n                this._filterDataSet = nv;\n                this.setFilterWidgetDataSet();\n                break;\n            case 'editdatepattern':\n                this.setInlineWidgetProp('inlineInstance', 'datepattern', nv);\n                this.setInlineWidgetProp('inlineInstanceNew', 'datepattern', nv);\n                break;\n            case 'showinfilter':\n                this.showinfilter = nv;\n                break;\n            default:\n                if (inlineWidgetProps.includes(key)) {\n                    this.setInlineWidgetProp('inlineInstance', key, nv);\n                    this.setInlineWidgetProp('inlineInstanceNew', key, nv);\n                }\n                break;\n        }\n\n        super.onPropertyChange(key, nv, ov);\n    }\n\n    setProperty(property, nv) {\n        this[property] = nv;\n        switch (property) {\n            case 'displayName':\n                this.table.callDataGridMethod('setColumnProp', this.field, property, nv);\n                break;\n            default:\n                this.table.redraw(true);\n        }\n    }\n\n    ngOnDestroy() {\n        // MEMORY LEAK FIX: Clear ContentChildren QueryLists\n        if (this._filterInstances) {\n            try {\n                this._filterInstances.reset([]);\n            } catch (e) {\n                // Silently handle cleanup errors - QueryList might already be destroyed\n            }\n        }\n        if (this._inlineInstances) {\n            try {\n                this._inlineInstances.reset([]);\n            } catch (e) {\n                // Silently handle cleanup errors - QueryList might already be destroyed\n            }\n        }\n        if (this._inlineInstancesNew) {\n            try {\n                this._inlineInstancesNew.reset([]);\n            } catch (e) {\n                // Silently handle cleanup errors - QueryList might already be destroyed\n            }\n        }\n\n        // MEMORY LEAK FIX: Clear all widget instance references\n        this.filterInstance = null;\n        this.inlineInstance = null;\n        this.inlineInstanceNew = null;\n\n        // MEMORY LEAK FIX: Clear template references\n        this.customExprTmpl = null;\n        this.inlineWidthTempRef = null;\n        this.filterTemplateRef = null;\n\n        // MEMORY LEAK FIX: Clear dataset references\n        this._filterDataSet = null;\n        this.dataset = null;\n        this._dataoptions = null;\n        this._datasource = null;\n\n        // MEMORY LEAK FIX: Clear validation objects\n        if (this.fieldValidations) {\n            try {\n                this.fieldValidations.destroy();\n            } catch (e) {\n                // Silently handle cleanup errors\n            }\n            this.fieldValidations = null;\n        }\n        if (this.fieldValidations_new) {\n            try {\n                this.fieldValidations_new.destroy();\n            } catch (e) {\n                // Silently handle cleanup errors\n            }\n            this.fieldValidations_new = null;\n        }\n        this.syncValidators = [];\n        this.asyncValidators = [];\n\n        // MEMORY LEAK FIX: Clear filter control reference\n        this.filterControl = null;\n\n        // MEMORY LEAK FIX: Clear notify fields array\n        if (this.notifyForFields) {\n            this.notifyForFields = [];\n        }\n\n        // MEMORY LEAK FIX: Clear observe fields array\n        if (this.observeOnFields) {\n            this.observeOnFields = [];\n        }\n\n        // MEMORY LEAK FIX: Clear table and group references\n        // Note: These are injected dependencies, but clearing helps GC\n        this.table = null;\n        this.group = null;\n\n        // Call parent ngOnDestroy\n        super.ngOnDestroy();\n    }\n}\n"]}