@wavemaker/app-ng-runtime 11.14.1-rc.6310 → 11.14.2-rc.6311

package/components/data/form/form-action/form-action.directive.d.ts

@@ -1,8 +1,8 @@
-import { Injector, OnInit } from '@angular/core';
+import { Injector, OnDestroy, OnInit } from '@angular/core';
 import { BaseComponent } from '@wm/components/base';
 import { FormComponent } from '../form.component';
 import * as i0 from "@angular/core";
-export declare class FormActionDirective extends BaseComponent implements OnInit {
+export declare class FormActionDirective extends BaseComponent implements OnInit, OnDestroy {
     form: FormComponent;
     static initializeProps: void;
     accessroles: any;
@@ -29,6 +29,7 @@ export declare class FormActionDirective extends BaseComponent implements OnInit
     populateAction(): void;
     ngOnInit(): void;
     onPropertyChange(key: any, nv: any, ov: any): void;
+    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FormActionDirective, [null, { optional: true; }, { optional: true; }]>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FormActionDirective, "[wmFormAction]", never, {}, {}, never, never, true, never>;
 }

package/components/data/form/form-field/form-field.directive.d.ts

@@ -1,11 +1,11 @@
-import { AfterContentInit, Injector, OnInit } from '@angular/core';
+import { AfterContentInit, Injector, OnDestroy, OnInit } from '@angular/core';
 import { FormBuilder, FormGroup } from '@angular/forms';
 import { App, Viewport } from '@wm/core';
 import { StylableComponent } from '@wm/components/base';
 import { ListComponent } from '@wm/components/data/list';
 import { FormComponent } from '../form.component';
 import * as i0 from "@angular/core";
-export declare class FormFieldDirective extends StylableComponent implements OnInit, AfterContentInit {
+export declare class FormFieldDirective extends StylableComponent implements OnInit, AfterContentInit, OnDestroy {
     static initializeProps: void;
     formWidget: any;
     formWidgetMax: any;
@@ -110,6 +110,7 @@ export declare class FormFieldDirective extends StylableComponent implements OnI
     ngOnInit(): void;
     prepareFormWidget(): void;
     ngAfterContentInit(): void;
+    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldDirective, [null, null, null, null, null, { optional: true; }, { attribute: "chipclass.bind"; }, { attribute: "dataset.bind"; }, { attribute: "displayexpression.bind"; }, { attribute: "displaylabel.bind"; }, { attribute: "widgettype"; }, { attribute: "name"; }, { attribute: "displayimagesrc.bind"; }, { attribute: "key"; }, { attribute: "is-range"; }, { attribute: "pc-display"; }, { attribute: "mobile-display"; }, { attribute: "tablet-display"; }, { self: true; }, { optional: true; }]>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FormFieldDirective, "[wmFormField]", ["wmFormField"], {}, {}, ["formWidget", "formWidgetMax"], never, true, never>;
 }

package/components/data/form/form-widget.directive.d.ts

@@ -1,7 +1,7 @@
-import { OnInit } from '@angular/core';
+import { OnDestroy, OnInit } from '@angular/core';
 import { FormBuilder, FormGroup } from '@angular/forms';
 import * as i0 from "@angular/core";
-export declare class FormWidgetDirective implements OnInit {
+export declare class FormWidgetDirective implements OnInit, OnDestroy {
     componentInstance: any;
     name: any;
     key: any;
@@ -13,6 +13,7 @@ export declare class FormWidgetDirective implements OnInit {
     addControl(fieldName: any): void;
     createControl(): any;
     ngOnInit(): void;
+    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FormWidgetDirective, [{ optional: true; }, { optional: true; }, { self: true; }, null, { attribute: "name"; }, { attribute: "key"; }]>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FormWidgetDirective, "[wmFormWidget]", never, {}, {}, never, never, true, never>;
 }

package/components/data/form/live-actions/live-actions.directive.d.ts

@@ -1,6 +1,7 @@
+import { OnDestroy } from '@angular/core';
 import { AbstractDialogService, App } from '@wm/core';
 import * as i0 from "@angular/core";
-export declare class LiveActionsDirective {
+export declare class LiveActionsDirective implements OnDestroy {
     private subscribedWidget;
     private app;
     private dialogService;
@@ -17,6 +18,7 @@ export declare class LiveActionsDirective {
     private deleteRecord;
     private performOperation;
     call(operation: any, options: any, success?: any, error?: any): void;
+    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<LiveActionsDirective, [{ self: true; }, null, null]>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<LiveActionsDirective, "[wmLiveActions]", never, {}, {}, never, never, true, never>;
 }

package/components/data/form/live-filter/live-filter.directive.d.ts

@@ -1,5 +1,6 @@
+import { OnDestroy } from '@angular/core';
 import * as i0 from "@angular/core";
-export declare class LiveFilterDirective {
+export declare class LiveFilterDirective implements OnDestroy {
     private form;
     static initializeProps: void;
     private _options;
@@ -17,6 +18,7 @@ export declare class LiveFilterDirective {
     filter(options?: any): any;
     filterOnDefault(): void;
     registerFormWidget(widget: any): void;
+    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<LiveFilterDirective, [{ self: true; }]>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<LiveFilterDirective, "[wmLiveFilter]", never, {}, {}, never, never, true, never>;
 }

package/components/data/form/live-form/live-form.directive.d.ts

@@ -1,8 +1,9 @@
+import { OnDestroy } from '@angular/core';
 import { AbstractDialogService } from '@wm/core';
 import { ToDatePipe } from '@wm/components/base';
 import { LiveTableComponent } from '@wm/components/data/live-table';
 import * as i0 from "@angular/core";
-export declare class LiveFormDirective {
+export declare class LiveFormDirective implements OnDestroy {
     private form;
     datePipe: ToDatePipe;
     private dialogService;
@@ -37,6 +38,7 @@ export declare class LiveFormDirective {
     saveAndView(): void;
     submitForm($event: any): void;
     save(event?: any, updateMode?: any, newForm?: any): void;
+    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<LiveFormDirective, [{ self: true; }, { optional: true; }, null, null, { attribute: "formlayout"; }]>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<LiveFormDirective, "[wmLiveForm]", never, {}, {}, never, never, true, never>;
 }

package/components/data/list/bundles/index.umd.js

@@ -152,28 +152,36 @@
             const $editItem = this.nativeElement.querySelector('.edit-list-item');
             const $deleteItem = this.nativeElement.querySelector('.delete-list-item');
             if ($editItem) {
-                // Triggered on click of edit action
-                $editItem.addEventListener('click', evt => {
+                // MEMORY LEAK FIX: Store bound handler for cleanup
+                this.boundEditHandler = (evt) => {
                     this.listComponent.update();
-                });
+                };
+                // Triggered on click of edit action
+                $editItem.addEventListener('click', this.boundEditHandler);
             }
             if ($deleteItem) {
-                // Triggered on click of delete action
-                $deleteItem.addEventListener('click', evt => {
+                // MEMORY LEAK FIX: Store bound handler for cleanup
+                this.boundDeleteHandler = (evt) => {
                     this.listComponent.delete();
-                });
+                };
+                // Triggered on click of delete action
+                $deleteItem.addEventListener('click', this.boundDeleteHandler);
             }
         }
         ngOnInit() {
             if (this.listComponent.mouseEnterCB) {
-                this.nativeElement.addEventListener('mouseenter', ($event) => {
+                // MEMORY LEAK FIX: Store bound handler for cleanup
+                this.boundMouseEnterHandler = ($event) => {
                     this.listComponent.invokeEventCallback('mouseenter', { widget: this, $event });
-                });
+                };
+                this.nativeElement.addEventListener('mouseenter', this.boundMouseEnterHandler);
             }
             if (this.listComponent.mouseLeaveCB) {
-                this.nativeElement.addEventListener('mouseleave', ($event) => {
+                // MEMORY LEAK FIX: Store bound handler for cleanup
+                this.boundMouseLeaveHandler = ($event) => {
                     this.listComponent.invokeEventCallback('mouseleave', { widget: this, $event });
-                });
+                };
+                this.nativeElement.addEventListener('mouseleave', this.boundMouseLeaveHandler);
             }
             // adding item attribute on every list item
             $(this.nativeElement).attr('listitemindex', this.$index);
@@ -189,6 +197,82 @@
                 }
             });
         }
+        ngOnDestroy() {
+            // MEMORY LEAK FIX: Remove event listeners
+            if (this.boundMouseEnterHandler && this.nativeElement) {
+                try {
+                    this.nativeElement.removeEventListener('mouseenter', this.boundMouseEnterHandler);
+                }
+                catch (e) {
+                    // Silently handle cleanup errors
+                }
+                this.boundMouseEnterHandler = null;
+            }
+            if (this.boundMouseLeaveHandler && this.nativeElement) {
+                try {
+                    this.nativeElement.removeEventListener('mouseleave', this.boundMouseLeaveHandler);
+                }
+                catch (e) {
+                    // Silently handle cleanup errors
+                }
+                this.boundMouseLeaveHandler = null;
+            }
+            if (this.nativeElement) {
+                const $editItem = this.nativeElement.querySelector('.edit-list-item');
+                if ($editItem && this.boundEditHandler) {
+                    try {
+                        $editItem.removeEventListener('click', this.boundEditHandler);
+                    }
+                    catch (e) {
+                        // Silently handle cleanup errors
+                    }
+                    this.boundEditHandler = null;
+                }
+                const $deleteItem = this.nativeElement.querySelector('.delete-list-item');
+                if ($deleteItem && this.boundDeleteHandler) {
+                    try {
+                        $deleteItem.removeEventListener('click', this.boundDeleteHandler);
+                    }
+                    catch (e) {
+                        // Silently handle cleanup errors
+                    }
+                    this.boundDeleteHandler = null;
+                }
+            }
+            // MEMORY LEAK FIX: Clear currentItemWidgets cache
+            // The _currentItemWidgets object accumulates references to all child widgets
+            // which prevents them from being garbage collected
+            if (this._currentItemWidgets) {
+                Object.keys(this._currentItemWidgets).forEach(key => {
+                    delete this._currentItemWidgets[key];
+                });
+                this._currentItemWidgets = null;
+            }
+            // MEMORY LEAK FIX: Clear context to release references
+            if (this.context) {
+                Object.keys(this.context).forEach(key => {
+                    delete this.context[key];
+                });
+                this.context = null;
+            }
+            // MEMORY LEAK FIX: Clear ViewContainerRef reference
+            if (this.viewContainerRef) {
+                this.viewContainerRef = null;
+            }
+            // MEMORY LEAK FIX: Complete the destroy subject
+            if (this.destroy) {
+                try {
+                    if (!this.destroy.closed) {
+                        this.destroy.next(null);
+                        this.destroy.complete();
+                    }
+                }
+                catch (e) {
+                    // Silently handle cleanup errors
+                }
+                this.destroy = null;
+            }
+        }
         static { this.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0__namespace, type: ListItemDirective, deps: [{ token: i0__namespace.Injector }, { token: i0__namespace.ElementRef }, { token: i2__namespace.App }], target: i0__namespace.ɵɵFactoryTarget.Directive }); }
         static { this.ɵdir = i0__namespace.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: ListItemDirective, isStandalone: true, selector: "[wmListItem]", inputs: { wmListItem: "wmListItem" }, host: { listeners: { "focus": "onFocus()" }, properties: { "class.active": "this.isActive", "class.disable-item": "this.disableItem" } }, exportAs: ["listItemRef"], ngImport: i0__namespace }); }
     }
@@ -575,8 +659,10 @@
                 this.allowpagesizechange = nv;
             }
             else if (key === 'pagesizeoptions') {
-                this.pagesizeoptions = nv;
-                this.setDefaultPageSize(nv);
+                this.prevPagesizeoptions = this.sanitizeCommaSeparatedIntegers(ov);
+                this.pagesizeoptions = this.sanitizeCommaSeparatedIntegers(nv);
+                if (this.allowpagesizechange)
+                    this.setDefaultPageSize(nv);
             }
             else {
                 super.onPropertyChange(key, nv, ov);
@@ -593,6 +679,10 @@
                     nv = this.pagesizeoptions?.split(',').map(Number).sort((a, b) => a - b)[0];
                     this.pagesize = nv;
                 }
+                if (this.isPageSizeOptionsChanged()) {
+                    this.dataNavigator.defaultPageSizeOptions = this.pagesizeoptions?.split(',').map(Number).sort((a, b) => a - b) || [];
+                    this.dataNavigator.pageSizeOptions = [...this.dataNavigator.defaultPageSizeOptions];
+                }
             }
             this.updatedPageSize = nv;
             this.dataNavigator.updatedPageSize = nv;
@@ -601,6 +691,31 @@
             };
             this.dataNavigator.widget.maxResults = nv;
             this.dataNavigator.maxResults = nv;
+            if (this.datasource) {
+                this.datasource.maxResults = this.pagesize || this.datasource.maxResults;
+            }
+        }
+        isPageSizeOptionsChanged() {
+            return !lodashEs.isEqual(this.prevPagesizeoptions, this.pagesizeoptions);
+        }
+        selectPageSize(pagesize) {
+            if (!this.allowpagesizechange && !pagesize)
+                return;
+            if (pagesize < this.dataNavigator.pageSizeOptions[0] || pagesize > this.dataNavigator.pageSizeOptions[this.dataNavigator.pageSizeOptions.length - 1]
+                || !this.dataNavigator.pageSizeOptions.includes(Number(pagesize))) {
+                pagesize = this.dataNavigator.pageSizeOptions[0];
+            }
+            this.dataNavigator.onPageSizeChange(undefined, pagesize);
+        }
+        sanitizeCommaSeparatedIntegers(input) {
+            if (!input)
+                return "";
+            const uniqueNumbers = Array.from(new Set(input
+                .split(",")
+                .map(v => v.trim())
+                .filter(v => /^-?\d+$/.test(v))
+                .map(v => Math.abs(parseInt(v, 10)))));
+            return uniqueNumbers.join(",");
         }
         onItemClick(evt, $listItem) {
             let selectCount;
@@ -740,8 +855,81 @@
         ngOnDestroy() {
             if (this._listAnimator && this._listAnimator.$btnSubscription) {
                 this._listAnimator.$btnSubscription.unsubscribe();
+                this._listAnimator = null;
+            }
+            // MEMORY LEAK FIX: Unsubscribe from all app subscriptions
+            if (this._listenerDestroyers) {
+                this._listenerDestroyers.forEach(d => d && d());
+                this._listenerDestroyers = [];
             }
-            this._listenerDestroyers.forEach(d => d && d());
+            // MEMORY LEAK FIX: Unsubscribe from navigator watches
+            if (this.navigatorResultWatch) {
+                this.navigatorResultWatch.unsubscribe();
+                this.navigatorResultWatch = null;
+            }
+            if (this.navigatorMaxResultWatch) {
+                this.navigatorMaxResultWatch.unsubscribe();
+                this.navigatorMaxResultWatch = null;
+            }
+            // MEMORY LEAK FIX: Unsubscribe from listItems changes
+            if (this.listItemsChangesSubscription) {
+                this.listItemsChangesSubscription.unsubscribe();
+                this.listItemsChangesSubscription = null;
+            }
+            // MEMORY LEAK FIX: Remove native event listener
+            const ulElement = this.nativeElement?.querySelector('ul.app-livelist-container');
+            if (ulElement && this.boundClickHandler) {
+                try {
+                    ulElement.removeEventListener('click', this.boundClickHandler, true);
+                }
+                catch (e) {
+                    // Silently handle cleanup errors
+                }
+                this.boundClickHandler = null;
+            }
+            // MEMORY LEAK FIX: Destroy jQuery sortable widget
+            if (this.$ulEle && this.$ulEle.sortable) {
+                try {
+                    this.$ulEle.sortable('destroy');
+                }
+                catch (e) {
+                    // Ignore errors during destroy
+                }
+                this.$ulEle = null;
+            }
+            // MEMORY LEAK FIX: Clear QueryList references
+            if (this.listItems) {
+                this.listItems = null;
+            }
+            if (this.btnComponents) {
+                this.btnComponents = null;
+            }
+            // MEMORY LEAK FIX: Clear ViewChild and ContentChild references
+            this.dataNavigator = null;
+            this.listTemplate = null;
+            this.listLeftActionTemplate = null;
+            this.listRightActionTemplate = null;
+            // MEMORY LEAK FIX: Clear all data arrays and objects
+            this.fieldDefs = [];
+            this._items = [];
+            this.groupedData = null;
+            if (Array.isArray(this.selectedItemWidgets)) {
+                this.selectedItemWidgets = [];
+            }
+            else {
+                this.selectedItemWidgets = {};
+            }
+            // MEMORY LEAK FIX: Remove add item event listener
+            const $addItem = document.getElementsByClassName("add-list-item")[0];
+            if ($addItem && this.boundAddItemHandler) {
+                $addItem.removeEventListener('click', this.boundAddItemHandler);
+                this.boundAddItemHandler = null;
+            }
+            // MEMORY LEAK FIX: Nullify closures and references
+            this.debouncedFetchNextDatasetOnScroll = null;
+            this.firstSelectedItem = null;
+            this.lastSelectedItem = null;
+            this.reorderProps = null;
             super.ngOnDestroy();
         }
         ngOnDetach() {
@@ -1155,19 +1343,23 @@
             this.isDataChanged = false;
         }
         setupHandlers() {
-            this.listItems.changes.subscribe(listItems => {
+            this.listItemsChangesSubscription = this.listItems.changes.subscribe(listItems => {
                 this.onListRender(listItems);
                 this.cdRef.detectChanges();
             });
             // handle click event in capturing phase.
-            this.nativeElement.querySelector('ul.app-livelist-container').addEventListener('click', ($event) => {
+            this.boundClickHandler = ($event) => {
                 let target = $($event.target).closest('.app-list-item');
                 // Recursively find the current list item
                 while (target.get(0) && (target.closest('ul.app-livelist-container').get(0) !== $event.currentTarget)) {
                     target = target.parent().closest('.app-list-item');
                 }
                 this.triggerListItemSelection(target, $event);
-            }, true);
+            };
+            const ulElement = this.nativeElement.querySelector('ul.app-livelist-container');
+            if (ulElement) {
+                ulElement.addEventListener('click', this.boundClickHandler, true);
+            }
         }
         // Triggers on drag start while reordering.
         onReorderStart(evt, ui) {
@@ -1283,10 +1475,12 @@
         setUpCUDHandlers() {
             const $addItem = document.getElementsByClassName("add-list-item")[0];
             if ($addItem) {
-                // Triggered on click of add action
-                $addItem.addEventListener('click', evt => {
+                // MEMORY LEAK FIX: Store bound handler for cleanup
+                this.boundAddItemHandler = (evt) => {
                     this.create();
-                });
+                };
+                // Triggered on click of add action
+                $addItem.addEventListener('click', this.boundAddItemHandler);
             }
         }
         static { this.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0__namespace, type: ListComponent, deps: [{ token: i0__namespace.Injector }, { token: i0__namespace.ChangeDetectorRef }, { token: i1__namespace.ToDatePipe }, { token: i2__namespace.App }, { token: i2__namespace.AppDefaults }, { token: i0__namespace.NgZone }, { token: 'itemclass.bind', attribute: true }, { token: 'disableitem.bind', attribute: true }, { token: 'dataset.bind', attribute: true }, { token: 'datasource.bind', attribute: true }, { token: 'mouseenter.event', attribute: true }, { token: 'mouseleave.event', attribute: true }, { token: i2__namespace.StatePersistence }, { token: i2__namespace.PaginationService }, { token: 'EXPLICIT_CONTEXT', optional: true }], target: i0__namespace.ɵɵFactoryTarget.Component }); }

package/components/data/list/esm2022/list-item.directive.mjs

@@ -86,28 +86,36 @@ export class ListItemDirective {
         const $editItem = this.nativeElement.querySelector('.edit-list-item');
         const $deleteItem = this.nativeElement.querySelector('.delete-list-item');
         if ($editItem) {
-            // Triggered on click of edit action
-            $editItem.addEventListener('click', evt => {
+            // MEMORY LEAK FIX: Store bound handler for cleanup
+            this.boundEditHandler = (evt) => {
                 this.listComponent.update();
-            });
+            };
+            // Triggered on click of edit action
+            $editItem.addEventListener('click', this.boundEditHandler);
         }
         if ($deleteItem) {
-            // Triggered on click of delete action
-            $deleteItem.addEventListener('click', evt => {
+            // MEMORY LEAK FIX: Store bound handler for cleanup
+            this.boundDeleteHandler = (evt) => {
                 this.listComponent.delete();
-            });
+            };
+            // Triggered on click of delete action
+            $deleteItem.addEventListener('click', this.boundDeleteHandler);
         }
     }
     ngOnInit() {
         if (this.listComponent.mouseEnterCB) {
-            this.nativeElement.addEventListener('mouseenter', ($event) => {
+            // MEMORY LEAK FIX: Store bound handler for cleanup
+            this.boundMouseEnterHandler = ($event) => {
                 this.listComponent.invokeEventCallback('mouseenter', { widget: this, $event });
-            });
+            };
+            this.nativeElement.addEventListener('mouseenter', this.boundMouseEnterHandler);
         }
         if (this.listComponent.mouseLeaveCB) {
-            this.nativeElement.addEventListener('mouseleave', ($event) => {
+            // MEMORY LEAK FIX: Store bound handler for cleanup
+            this.boundMouseLeaveHandler = ($event) => {
                 this.listComponent.invokeEventCallback('mouseleave', { widget: this, $event });
-            });
+            };
+            this.nativeElement.addEventListener('mouseleave', this.boundMouseLeaveHandler);
         }
         // adding item attribute on every list item
         $(this.nativeElement).attr('listitemindex', this.$index);
@@ -123,6 +131,82 @@ export class ListItemDirective {
             }
         });
     }
+    ngOnDestroy() {
+        // MEMORY LEAK FIX: Remove event listeners
+        if (this.boundMouseEnterHandler && this.nativeElement) {
+            try {
+                this.nativeElement.removeEventListener('mouseenter', this.boundMouseEnterHandler);
+            }
+            catch (e) {
+                // Silently handle cleanup errors
+            }
+            this.boundMouseEnterHandler = null;
+        }
+        if (this.boundMouseLeaveHandler && this.nativeElement) {
+            try {
+                this.nativeElement.removeEventListener('mouseleave', this.boundMouseLeaveHandler);
+            }
+            catch (e) {
+                // Silently handle cleanup errors
+            }
+            this.boundMouseLeaveHandler = null;
+        }
+        if (this.nativeElement) {
+            const $editItem = this.nativeElement.querySelector('.edit-list-item');
+            if ($editItem && this.boundEditHandler) {
+                try {
+                    $editItem.removeEventListener('click', this.boundEditHandler);
+                }
+                catch (e) {
+                    // Silently handle cleanup errors
+                }
+                this.boundEditHandler = null;
+            }
+            const $deleteItem = this.nativeElement.querySelector('.delete-list-item');
+            if ($deleteItem && this.boundDeleteHandler) {
+                try {
+                    $deleteItem.removeEventListener('click', this.boundDeleteHandler);
+                }
+                catch (e) {
+                    // Silently handle cleanup errors
+                }
+                this.boundDeleteHandler = null;
+            }
+        }
+        // MEMORY LEAK FIX: Clear currentItemWidgets cache
+        // The _currentItemWidgets object accumulates references to all child widgets
+        // which prevents them from being garbage collected
+        if (this._currentItemWidgets) {
+            Object.keys(this._currentItemWidgets).forEach(key => {
+                delete this._currentItemWidgets[key];
+            });
+            this._currentItemWidgets = null;
+        }
+        // MEMORY LEAK FIX: Clear context to release references
+        if (this.context) {
+            Object.keys(this.context).forEach(key => {
+                delete this.context[key];
+            });
+            this.context = null;
+        }
+        // MEMORY LEAK FIX: Clear ViewContainerRef reference
+        if (this.viewContainerRef) {
+            this.viewContainerRef = null;
+        }
+        // MEMORY LEAK FIX: Complete the destroy subject
+        if (this.destroy) {
+            try {
+                if (!this.destroy.closed) {
+                    this.destroy.next(null);
+                    this.destroy.complete();
+                }
+            }
+            catch (e) {
+                // Silently handle cleanup errors
+            }
+            this.destroy = null;
+        }
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ListItemDirective, deps: [{ token: i0.Injector }, { token: i0.ElementRef }, { token: i1.App }], target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: ListItemDirective, isStandalone: true, selector: "[wmListItem]", inputs: { wmListItem: "wmListItem" }, host: { listeners: { "focus": "onFocus()" }, properties: { "class.active": "this.isActive", "class.disable-item": "this.disableItem" } }, exportAs: ["listItemRef"], ngImport: i0 }); }
 }
@@ -145,4 +229,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
             }], wmListItem: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list-item.directive.js","sourceRoot":"","sources":["../../../../../projects/components/widgets/data/list/src/list-item.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterViewInit,\n    Directive,\n    ElementRef,\n    HostBinding,\n    HostListener,\n    inject,\n    Injector,\n    Input,\n    OnInit,\n    Optional,\n    ViewContainerRef\n} from '@angular/core';\n\nimport {Observable, Subject} from 'rxjs';\n\nimport {$watch, App} from '@wm/core';\n\nimport {ListComponent} from './list.component';\nimport {widgetIdGenerator} from \"@wm/components/base\";\nimport {BaseFormComponent} from \"@wm/components/input/base-form\";\n\ndeclare const $;\n\n@Directive({\n  standalone: true,\n    selector: '[wmListItem]',\n    exportAs: 'listItemRef'\n})\nexport class ListItemDirective implements OnInit, AfterViewInit {\n\n    public item;\n    public context;\n    public destroy: Subject<any> = new Subject();\n    public destroy$: Observable<any> = this.destroy.asObservable();\n    public nativeElement: HTMLElement;\n    public readonly listComponent: ListComponent;\n\n    private itemClass = '';\n    private _currentItemWidgets = {};\n    private viewContainerRef: ViewContainerRef;\n    /**\n     * To avoid re-rendering of widget, passing unique id as contextKey to createCustomInjector\n     */\n    protected trackId = widgetIdGenerator.nextUid();\n\n    @HostBinding('class.active') isActive = false;\n    @HostBinding('class.disable-item') disableItem = false;\n\n    @HostListener('focus')\n    onFocus() {\n        // maintains which element is focused/selected most recently.\n        this.listComponent.lastSelectedItem = this;\n    }\n\n    get $index() {\n        return this.context.$index;\n    }\n\n    get $even() {\n        return this.context.even;\n    }\n\n    get $odd() {\n        return this.context.odd;\n    }\n\n    get $first() {\n        return this.context.first;\n    }\n\n    get $last() {\n        return this.context.last;\n    }\n\n    get currentItemWidgets () {\n        const componentElements = Array.from(this.nativeElement.querySelectorAll('[widget-id]'));\n        return Object.assign(this._currentItemWidgets, componentElements.reduce((result, comp: any) => {\n            result[comp.widget.name] = comp.widget;\n            return result;\n        }, {}));\n    }\n\n    @Input() set wmListItem(val) {\n        this.item = val;\n    }\n    private _viewParent = inject(ListComponent, {optional: true});\n    constructor(private inj: Injector, elRef: ElementRef, private app: App) {\n        this.viewContainerRef = inj.get(ViewContainerRef);\n        this.nativeElement = elRef.nativeElement;\n        this.listComponent = this._viewParent;\n        // this.context = (<NgForOfContext<ListItemDirective>>(<any>inj).view.context);\n        this.context = (this.inj as any)._lView[8];\n        //this.context = (this.viewContainerRef as any)._hostLView.find(t => t && !!t.$implicit);\n        this.itemClassWatcher(this.listComponent);\n        this.disableItemWatcher(this.listComponent);\n        $(this.nativeElement).data('listItemContext', this);\n    }\n\n    private registerWatch(expression: string, callback: Function) {\n        // Removing ngFor context as the same properties are availble on listitem scope.\n        // passing viewparent context for accessing varibales and widgets.\n        //[CSP]: expression will be generated in the component as e.g. 'item.className'\n        this.destroy$.subscribe($watch(expression, (this.listComponent as any).viewParent, this, callback));\n    }\n\n    private itemClassWatcher(listComponent: ListComponent) {\n        if (listComponent.binditemclass) {\n            this.registerWatch(listComponent.binditemclass, nv => this.itemClass = nv || '');\n        } else {\n            this.itemClass = listComponent.itemclass;\n        }\n    }\n\n    private disableItemWatcher($list: ListComponent) {\n        if ($list.binddisableitem) {\n            this.registerWatch($list.binddisableitem, nv => this.disableItem = nv || false);\n        } else {\n            this.disableItem = $list.disableitem || false;\n        }\n    }\n\n    private setUpCUDHandlers() {\n        const $editItem = this.nativeElement.querySelector('.edit-list-item');\n        const $deleteItem = this.nativeElement.querySelector('.delete-list-item');\n\n        if ($editItem) {\n            // Triggered on click of edit action\n            $editItem.addEventListener('click', evt => {\n                this.listComponent.update();\n            });\n        }\n\n        if ($deleteItem) {\n            // Triggered on click of delete action\n            $deleteItem.addEventListener('click', evt => {\n                this.listComponent.delete();\n            });\n        }\n    }\n    ngOnInit() {\n        if (this.listComponent.mouseEnterCB) {\n            this.nativeElement.addEventListener('mouseenter', ($event) => {\n                this.listComponent.invokeEventCallback('mouseenter', {widget: this, $event});\n            });\n        }\n        if (this.listComponent.mouseLeaveCB) {\n            this.nativeElement.addEventListener('mouseleave', ($event) => {\n                this.listComponent.invokeEventCallback('mouseleave', {widget: this, $event});\n            });\n        }\n        // adding item attribute on every list item\n        $(this.nativeElement).attr('listitemindex', this.$index);\n    }\n\n    ngAfterViewInit() {\n        this.setUpCUDHandlers();\n        const componentElements = Array.from(this.nativeElement.querySelectorAll('[widget-id]'));\n        componentElements.forEach((component: any) => {\n            if(component.widget instanceof BaseFormComponent) {\n                if(!component.widget.$attrs.get('datavaluesource.bind')) {\n                    component.widget.datavaluesource = this.listComponent['datasource'];\n                }\n            }\n        });\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list-item.directive.js","sourceRoot":"","sources":["../../../../../projects/components/widgets/data/list/src/list-item.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterViewInit,\n    Directive,\n    ElementRef,\n    HostBinding,\n    HostListener,\n    inject,\n    Injector,\n    Input,\n    OnDestroy,\n    OnInit,\n    ViewContainerRef\n} from '@angular/core';\n\nimport {Observable, Subject} from 'rxjs';\n\nimport {$watch, App} from '@wm/core';\n\nimport {ListComponent} from './list.component';\nimport {widgetIdGenerator} from \"@wm/components/base\";\nimport {BaseFormComponent} from \"@wm/components/input/base-form\";\n\ndeclare const $;\n\n@Directive({\n  standalone: true,\n    selector: '[wmListItem]',\n    exportAs: 'listItemRef'\n})\nexport class ListItemDirective implements OnInit, AfterViewInit, OnDestroy {\n\n    public item;\n    public context;\n    public destroy: Subject<any> = new Subject();\n    public destroy$: Observable<any> = this.destroy.asObservable();\n    public nativeElement: HTMLElement;\n    public readonly listComponent: ListComponent;\n\n    private itemClass = '';\n    private _currentItemWidgets = {};\n    private viewContainerRef: ViewContainerRef;\n    /**\n     * To avoid re-rendering of widget, passing unique id as contextKey to createCustomInjector\n     */\n    protected trackId = widgetIdGenerator.nextUid();\n\n    @HostBinding('class.active') isActive = false;\n    @HostBinding('class.disable-item') disableItem = false;\n\n    @HostListener('focus')\n    onFocus() {\n        // maintains which element is focused/selected most recently.\n        this.listComponent.lastSelectedItem = this;\n    }\n\n    get $index() {\n        return this.context.$index;\n    }\n\n    get $even() {\n        return this.context.even;\n    }\n\n    get $odd() {\n        return this.context.odd;\n    }\n\n    get $first() {\n        return this.context.first;\n    }\n\n    get $last() {\n        return this.context.last;\n    }\n\n    get currentItemWidgets () {\n        const componentElements = Array.from(this.nativeElement.querySelectorAll('[widget-id]'));\n        return Object.assign(this._currentItemWidgets, componentElements.reduce((result, comp: any) => {\n            result[comp.widget.name] = comp.widget;\n            return result;\n        }, {}));\n    }\n\n    @Input() set wmListItem(val) {\n        this.item = val;\n    }\n    private _viewParent = inject(ListComponent, {optional: true});\n    constructor(private inj: Injector, elRef: ElementRef, private app: App) {\n        this.viewContainerRef = inj.get(ViewContainerRef);\n        this.nativeElement = elRef.nativeElement;\n        this.listComponent = this._viewParent;\n        // this.context = (<NgForOfContext<ListItemDirective>>(<any>inj).view.context);\n        this.context = (this.inj as any)._lView[8];\n        //this.context = (this.viewContainerRef as any)._hostLView.find(t => t && !!t.$implicit);\n        this.itemClassWatcher(this.listComponent);\n        this.disableItemWatcher(this.listComponent);\n        $(this.nativeElement).data('listItemContext', this);\n    }\n\n    private registerWatch(expression: string, callback: Function) {\n        // Removing ngFor context as the same properties are availble on listitem scope.\n        // passing viewparent context for accessing varibales and widgets.\n        //[CSP]: expression will be generated in the component as e.g. 'item.className'\n        this.destroy$.subscribe($watch(expression, (this.listComponent as any).viewParent, this, callback));\n    }\n\n    private itemClassWatcher(listComponent: ListComponent) {\n        if (listComponent.binditemclass) {\n            this.registerWatch(listComponent.binditemclass, nv => this.itemClass = nv || '');\n        } else {\n            this.itemClass = listComponent.itemclass;\n        }\n    }\n\n    private disableItemWatcher($list: ListComponent) {\n        if ($list.binddisableitem) {\n            this.registerWatch($list.binddisableitem, nv => this.disableItem = nv || false);\n        } else {\n            this.disableItem = $list.disableitem || false;\n        }\n    }\n\n    private boundEditHandler: (event: Event) => void;\n    private boundDeleteHandler: (event: Event) => void;\n    private boundMouseEnterHandler: (event: Event) => void;\n    private boundMouseLeaveHandler: (event: Event) => void;\n\n    private setUpCUDHandlers() {\n        const $editItem = this.nativeElement.querySelector('.edit-list-item');\n        const $deleteItem = this.nativeElement.querySelector('.delete-list-item');\n\n        if ($editItem) {\n            // MEMORY LEAK FIX: Store bound handler for cleanup\n            this.boundEditHandler = (evt: Event) => {\n                this.listComponent.update();\n            };\n            // Triggered on click of edit action\n            $editItem.addEventListener('click', this.boundEditHandler);\n        }\n\n        if ($deleteItem) {\n            // MEMORY LEAK FIX: Store bound handler for cleanup\n            this.boundDeleteHandler = (evt: Event) => {\n                this.listComponent.delete();\n            };\n            // Triggered on click of delete action\n            $deleteItem.addEventListener('click', this.boundDeleteHandler);\n        }\n    }\n    ngOnInit() {\n        if (this.listComponent.mouseEnterCB) {\n            // MEMORY LEAK FIX: Store bound handler for cleanup\n            this.boundMouseEnterHandler = ($event: Event) => {\n                this.listComponent.invokeEventCallback('mouseenter', {widget: this, $event});\n            };\n            this.nativeElement.addEventListener('mouseenter', this.boundMouseEnterHandler);\n        }\n        if (this.listComponent.mouseLeaveCB) {\n            // MEMORY LEAK FIX: Store bound handler for cleanup\n            this.boundMouseLeaveHandler = ($event: Event) => {\n                this.listComponent.invokeEventCallback('mouseleave', {widget: this, $event});\n            };\n            this.nativeElement.addEventListener('mouseleave', this.boundMouseLeaveHandler);\n        }\n        // adding item attribute on every list item\n        $(this.nativeElement).attr('listitemindex', this.$index);\n    }\n\n    ngAfterViewInit() {\n        this.setUpCUDHandlers();\n        const componentElements = Array.from(this.nativeElement.querySelectorAll('[widget-id]'));\n        componentElements.forEach((component: any) => {\n            if(component.widget instanceof BaseFormComponent) {\n                if(!component.widget.$attrs.get('datavaluesource.bind')) {\n                    component.widget.datavaluesource = this.listComponent['datasource'];\n                }\n            }\n        });\n    }\n\n    ngOnDestroy() {\n        // MEMORY LEAK FIX: Remove event listeners\n        if (this.boundMouseEnterHandler && this.nativeElement) {\n            try {\n                this.nativeElement.removeEventListener('mouseenter', this.boundMouseEnterHandler);\n            } catch (e) {\n                // Silently handle cleanup errors\n            }\n            this.boundMouseEnterHandler = null;\n        }\n        if (this.boundMouseLeaveHandler && this.nativeElement) {\n            try {\n                this.nativeElement.removeEventListener('mouseleave', this.boundMouseLeaveHandler);\n            } catch (e) {\n                // Silently handle cleanup errors\n            }\n            this.boundMouseLeaveHandler = null;\n        }\n\n        if (this.nativeElement) {\n            const $editItem = this.nativeElement.querySelector('.edit-list-item');\n            if ($editItem && this.boundEditHandler) {\n                try {\n                    $editItem.removeEventListener('click', this.boundEditHandler);\n                } catch (e) {\n                    // Silently handle cleanup errors\n                }\n                this.boundEditHandler = null;\n            }\n\n            const $deleteItem = this.nativeElement.querySelector('.delete-list-item');\n            if ($deleteItem && this.boundDeleteHandler) {\n                try {\n                    $deleteItem.removeEventListener('click', this.boundDeleteHandler);\n                } catch (e) {\n                    // Silently handle cleanup errors\n                }\n                this.boundDeleteHandler = null;\n            }\n        }\n\n        // MEMORY LEAK FIX: Clear currentItemWidgets cache\n        // The _currentItemWidgets object accumulates references to all child widgets\n        // which prevents them from being garbage collected\n        if (this._currentItemWidgets) {\n            Object.keys(this._currentItemWidgets).forEach(key => {\n                delete this._currentItemWidgets[key];\n            });\n            this._currentItemWidgets = null;\n        }\n\n        // MEMORY LEAK FIX: Clear context to release references\n        if (this.context) {\n            Object.keys(this.context).forEach(key => {\n                delete this.context[key];\n            });\n            this.context = null;\n        }\n\n        // MEMORY LEAK FIX: Clear ViewContainerRef reference\n        if (this.viewContainerRef) {\n            this.viewContainerRef = null;\n        }\n\n        // MEMORY LEAK FIX: Complete the destroy subject\n        if (this.destroy) {\n            try {\n                if (!this.destroy.closed) {\n                    this.destroy.next(null);\n                    this.destroy.complete();\n                }\n            } catch (e) {\n                // Silently handle cleanup errors\n            }\n            this.destroy = null;\n        }\n    }\n}\n"]}