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

package/components/data/list/esm2022/list.component.mjs

@@ -0,0 +1,1294 @@
+import { __decorate, __metadata } from "tslib";
+import { CommonModule } from '@angular/common';
+import { AutoLayout, APPLY_STYLES_TYPE, configureDnD, DEBOUNCE_TIMES, extractDataSourceName, getOrderedDataset, groupData, handleHeaderClick, NAVIGATION_TYPE, provideAsWidgetRef, StylableComponent, styler, TextContentDirective, ToDatePipe, toggleAllHeaders, unsupportedStatePersistenceTypes } from "@wm/components/base";
+import { Attribute, ChangeDetectorRef, Component, ContentChild, ContentChildren, Inject, Injector, NgZone, Optional, QueryList, TemplateRef, ViewChild, ViewChildren } from '@angular/core';
+import { $appDigest, $invokeWatchers, App, AppDefaults, DataSource, generateGUId, getClonedObject, isDataSourceEqual, isDefined, isMobile, isObject, noop, PaginationService, setListClass, StatePersistence, switchClass } from '@wm/core';
+import { PaginationComponent } from '@wm/components/data/pagination';
+import { ButtonComponent } from '@wm/components/input/button';
+import { registerProps } from './list.props';
+import { ListItemDirective } from './list-item.directive';
+import { clone, cloneDeep, forEach, get, has, includes, isArray, isEmpty, isEqual, isNumber, isString, isUndefined, last, max, min, pullAllWith, pullAt, remove, some, toNumber } from "lodash-es";
+import * as i0 from "@angular/core";
+import * as i1 from "@wm/components/base";
+import * as i2 from "@wm/core";
+import * as i3 from "@angular/common";
+const DEFAULT_CLS = 'app-livelist app-panel';
+const WIDGET_CONFIG = { widgetType: 'wm-list', hostClass: DEFAULT_CLS };
+let ListComponent = class ListComponent extends StylableComponent {
+    static { this.initializeProps = registerProps(); }
+    constructor(inj, cdRef, datePipe, app, appDefaults, ngZone, binditemclass, binddisableitem, binddataset, binddatasource, mouseEnterCB, mouseLeaveCB, statePersistence, paginationService, explicitContext) {
+        let resolveFn = noop;
+        const propsInitPromise = new Promise(res => resolveFn = res);
+        super(inj, WIDGET_CONFIG, explicitContext, propsInitPromise);
+        this.allowpagesizechange = false;
+        this.itemAttrsMap = {};
+        this.hasAutolayout = false;
+        this.propsInitPromise = propsInitPromise;
+        this.promiseResolverFn = resolveFn;
+        styler(this.nativeElement, this, APPLY_STYLES_TYPE.SHELL);
+        this.cdRef = cdRef;
+        this.ngZone = ngZone;
+        this.datePipe = datePipe;
+        this.statePersistence = statePersistence;
+        this.paginationService = paginationService;
+        this._pageLoad = true;
+        this.binditemclass = binditemclass;
+        this.binddisableitem = binddisableitem;
+        this.binddataset = binddataset;
+        this.mouseEnterCB = mouseEnterCB;
+        this.mouseLeaveCB = mouseLeaveCB;
+        this.binddatasource = binddatasource;
+        this.app = app;
+        this.appDefaults = appDefaults;
+        this.variableInflight = false;
+        this.noDataFound = !binddataset;
+        this.titleId = 'wmlist-' + generateGUId();
+        // Updates pagination, filter, sort etc options for service and crud variables
+        this._listenerDestroyers = [
+            this.app.subscribe('check-state-persistence-options', options => {
+                let dataSourceName = get(this.datasource, 'name');
+                // in Prefabs, this.datasource is not resolved at the time of variable invocation, so additional check is required.
+                if (!dataSourceName) {
+                    dataSourceName = extractDataSourceName(this.binddatasource);
+                }
+                if (get(options, 'variable.name') !== dataSourceName) {
+                    return;
+                }
+                this.handleStateParams(options);
+            }),
+            // Show loading status based on the variable life cycle
+            this.app.subscribe('toggle-variable-state', this.handleLoading.bind(this)),
+            this.app.subscribe('setup-cud-listener', param => {
+                if (this.nativeElement.getAttribute('name') !== param) {
+                    return;
+                }
+                this._isDependent = true;
+            })
+        ];
+    }
+    get selecteditem() {
+        if (this.multiselect) {
+            return getClonedObject(this._items);
+        }
+        if (isEmpty(this._items)) {
+            return {};
+        }
+        return getClonedObject(this._items[0]);
+    }
+    set selecteditem(items) {
+        this._items.length = 0;
+        this.deselectListItems();
+        if (isArray(items)) {
+            items.forEach(item => this.selectItem(item));
+        }
+        else {
+            this.selectItem(items);
+        }
+        $appDigest();
+    }
+    /**
+     * Returns list of widgets present on list item by considering name and index of the widget.
+     * If we did'nt pass index, it returns array of all the widgets which are matching to widget name
+     * @param widgteName: Name of the widget
+     * @param index: Index of the widget
+     */
+    getWidgets(widgteName, index) {
+        let $target;
+        const retVal = [];
+        if (!widgteName) {
+            return;
+        }
+        if (!isDefined(index)) {
+            forEach(this.listItems.toArray(), (el) => {
+                $target = get(el.currentItemWidgets, widgteName);
+                if ($target) {
+                    retVal.push($target);
+                }
+            });
+            return retVal;
+        }
+        index = +index || 0;
+        $target = get(this.listItems.toArray(), index);
+        if ($target) {
+            return [get($target.currentItemWidgets, widgteName)];
+        }
+    }
+    // returns listitem reference by index value. This refers to the same method getListItemByIndex.
+    getItem(index) {
+        return this.getListItemByIndex(index);
+    }
+    /**
+     * Returns index of listItem(listItemDirective / listItemObject)
+     * If item is a directive, index is fetched from listItems
+     * If item is an object, index is fetched from fieldDefs
+     */
+    getIndex(item) {
+        if (item instanceof ListItemDirective) {
+            return this.getListItemIndex(item);
+        }
+        else if (item) {
+            return this.fieldDefs.findIndex((obj) => isEqual(obj, item));
+        }
+    }
+    getUpdatedPageSize() {
+        return this.updatedPageSize;
+    }
+    create() {
+        if (this._isDependent) {
+            this.triggerWMEvent('insert');
+        }
+    }
+    editRow(item) {
+        if (this._isDependent) {
+            let listItem;
+            if (item) {
+                listItem = this.getItemRefByIndexOrModel(item).item;
+            }
+            this.triggerWMEvent('update', listItem);
+        }
+    }
+    update(item) {
+        this.editRow(item);
+    }
+    deleteRow(item) {
+        if (this._isDependent) {
+            let listItem;
+            if (item) {
+                listItem = this.getItemRefByIndexOrModel(item).item;
+            }
+            this.triggerWMEvent('delete', listItem);
+        }
+    }
+    delete(item) {
+        this.deleteRow(item);
+    }
+    handleLoading(data) {
+        const dataSource = this.datasource;
+        if (dataSource && dataSource.execute(DataSource.Operation.IS_API_AWARE) && isDataSourceEqual(data.variable, dataSource)) {
+            this.ngZone.run(() => {
+                this.handleStateParams(data);
+                this.variableInflight = data.active;
+                // Fix for [WMS-23772] Update nodatafound flag once the response is recieved from the server
+                const totalEle = data.data?.pagination?.totalElements;
+                if (!isUndefined(totalEle)) {
+                    this.noDataFound = totalEle === 0 ? true : false;
+                }
+                else { // totalelements is undefined
+                    this.noDataFound = isEmpty(data.data?.data);
+                }
+            });
+        }
+    }
+    triggerListItemSelection($el, $event) {
+        if ($el && $el[0]) {
+            const listItemContext = $el.data('listItemContext');
+            // Trigger click event only if the list item is from the corresponding list.
+            if (listItemContext.listComponent === this) {
+                this.onItemClick($event, listItemContext);
+            }
+        }
+    }
+    // this method is called form other data widgets like table.
+    execute(operation, options) {
+        if ([DataSource.Operation.IS_API_AWARE, DataSource.Operation.IS_PAGEABLE, DataSource.Operation.SUPPORTS_SERVER_FILTER].includes(operation)) {
+            return false;
+        }
+        return this.datasource.execute(operation, options);
+    }
+    handleKeyDown($event, action) {
+        $event.stopPropagation();
+        if ($event.keyCode !== 13 && $event.keyCode !== 9 && !(($event.target.classList.contains('form-control') || $event.target.classList.contains('note-editable')) && $event.keyCode === 32)) {
+            $event.preventDefault();
+        }
+        const listItems = this.listItems;
+        let presentIndex = this.getListItemIndex(this.lastSelectedItem);
+        if (this.multiselect) {
+            const firstIndex = this.getListItemIndex(this.firstSelectedItem);
+            const selectCount = isArray(this.selecteditem) ? this.selecteditem.length : (isObject(this.selecteditem) ? 1 : 0);
+            if (action === 'selectPrev') {
+                if (presentIndex > 0) {
+                    if ((presentIndex <= firstIndex) && this.checkSelectionLimit(selectCount)) {
+                        this.lastSelectedItem = this.getListItemByIndex(presentIndex - 1);
+                        this.toggleListItemSelection(this.lastSelectedItem);
+                    }
+                    else if (presentIndex > firstIndex) {
+                        this.toggleListItemSelection(this.getListItemByIndex(presentIndex));
+                        this.lastSelectedItem = this.getListItemByIndex(presentIndex - 1);
+                    }
+                    else {
+                        this.invokeEventCallback('selectionlimitexceed', { $event });
+                    }
+                }
+            }
+            else if (action === 'selectNext') {
+                if (presentIndex < listItems.length - 1) {
+                    if ((presentIndex >= firstIndex) && this.checkSelectionLimit(selectCount)) {
+                        this.lastSelectedItem = this.getListItemByIndex(presentIndex + 1);
+                        this.toggleListItemSelection(this.lastSelectedItem);
+                    }
+                    else if (presentIndex < firstIndex) {
+                        this.toggleListItemSelection(this.getListItemByIndex(presentIndex));
+                        this.lastSelectedItem = this.getListItemByIndex(presentIndex + 1);
+                    }
+                    else {
+                        this.invokeEventCallback('selectionlimitexceed', { $event });
+                    }
+                }
+            }
+        }
+        if (action === 'focusPrev') {
+            if (this.isListElementMovable) {
+                presentIndex = presentIndex <= 0 ? 0 : (presentIndex);
+                if (presentIndex === 0) {
+                    return;
+                }
+                this.lastSelectedItem = this.getListItemByIndex(presentIndex);
+                const prevElt = this.getListItemByIndex(presentIndex - 1);
+                prevElt.nativeElement.before(this.lastSelectedItem.nativeElement);
+                this.lastSelectedItem.nativeElement.focus();
+                this.statePersistence.removeWidgetState(this, 'selectedItem');
+                const arr = this.listItems.toArray();
+                [arr[presentIndex - 1], arr[presentIndex]] = [arr[presentIndex], arr[presentIndex - 1]];
+                this.listItems.reset(arr);
+                this.currentIndex = presentIndex;
+                this.ariaText = "selected ";
+            }
+            else {
+                presentIndex = presentIndex <= 0 ? 0 : (presentIndex - 1);
+                this.lastSelectedItem = this.getListItemByIndex(presentIndex);
+                this.lastSelectedItem.nativeElement.focus();
+                this.currentIndex = presentIndex + 1;
+                this.ariaText = "selected ";
+            }
+        }
+        else if (action === 'focusNext') {
+            if (this.isListElementMovable) {
+                presentIndex = presentIndex < (listItems.length - 1) ? (presentIndex) : (listItems.length - 1);
+                if (presentIndex === this.listItems.length - 1) {
+                    return;
+                }
+                this.lastSelectedItem = this.getListItemByIndex(presentIndex);
+                const nextElt = this.getListItemByIndex(presentIndex + 1);
+                nextElt.nativeElement.after(this.lastSelectedItem.nativeElement);
+                this.lastSelectedItem.nativeElement.focus();
+                this.statePersistence.removeWidgetState(this, 'selectedItem');
+                const arr = this.listItems.toArray();
+                [arr[presentIndex], arr[presentIndex + 1]] = [arr[presentIndex + 1], arr[presentIndex]];
+                this.listItems.reset(arr);
+                this.currentIndex = presentIndex + 2;
+                this.ariaText = "selected ";
+            }
+            else {
+                presentIndex = presentIndex < (listItems.length - 1) ? (presentIndex + 1) : (listItems.length - 1);
+                this.lastSelectedItem = this.getListItemByIndex(presentIndex);
+                this.lastSelectedItem.nativeElement.focus();
+                this.currentIndex = presentIndex + 1;
+                this.ariaText = "selected ";
+            }
+        }
+        else if (action === 'select') {
+            // if the enter click is pressed on the item which is not the last selected item, the find the item from which the event is originated.
+            if (presentIndex === -1 || !$($event.target).closest(this.lastSelectedItem.nativeElement)) {
+                const $li = $($event.target).closest('li.app-list-item');
+                const $ul = $li.closest('ul.app-livelist-container');
+                presentIndex = $ul.find('li.app-list-item').index($li);
+            }
+            this.onItemClick($event, this.getListItemByIndex(presentIndex));
+        }
+        else if (action === 'space') {
+            if (!this.enablereorder) {
+                return;
+            }
+            this.isListElementMovable = !this.isListElementMovable;
+            this.onItemClick($event, this.getListItemByIndex(presentIndex));
+            this.currentIndex = presentIndex + 1;
+            if (this.isListElementMovable) {
+                this.ariaText = `Item ${this.currentIndex} grabbed, current position `;
+                this.$ulEle.data('oldIndex', presentIndex);
+            }
+            else {
+                this.ariaText = `Item ${this.currentIndex} dropped, final position `;
+                this.onUpdate($event, undefined, presentIndex);
+            }
+        }
+    }
+    getActualPageSize() {
+        return this.actualPageSize || 20;
+    }
+    onPropertyChange(key, nv, ov) {
+        if (key === 'dataset') {
+            if (!nv && this.binddatasource && !this.datasource) {
+                return;
+            }
+            this.onDataSetChange(nv);
+        }
+        else if (key === 'datasource') {
+            if (this.allowpagesizechange) {
+                this.datasource.maxResults = this.pagesize || this.datasource.maxResults;
+            }
+            if (this.dataset) {
+                this.onDataSetChange(this.dataset);
+            }
+        }
+        else if (key === 'navigation') {
+            // Support for older projects where navigation type was advanced instead of classic
+            if (nv === 'Advanced') {
+                this.navigation = 'Classic';
+                return;
+            }
+            switchClass(this.nativeElement, nv, ov);
+            this.onNavigationTypeChange(nv);
+            if (this.dataNavigator) {
+                this.dataNavigator.navigationClass = this.paginationclass;
+            }
+        }
+        else if (key === 'itemsperrow') {
+            setListClass(this);
+        }
+        else if (key === 'tabindex') {
+            return;
+        }
+        else if (key === 'pulltorefresh' && nv) {
+            this.app.notify('pullToRefresh:enable');
+            this.subscribeToPullToRefresh();
+        }
+        else if (key === 'paginationclass') {
+            if (this.dataNavigator) {
+                // Adding setTimeout because in pagination component updateNavSize method is overriding navigationclass
+                setTimeout(() => this.dataNavigator.navigationClass = nv);
+            }
+        }
+        else if (key === 'pagesize') {
+            this.actualPageSize = nv; // maintain default page size to calculate pagesize options
+            this.setDefaultPageSize(nv);
+        }
+        else if (key === 'enablereorder') {
+            if (nv && this.$ulEle) {
+                this.$ulEle.attr('aria-describedby', this.titleId);
+                this.configureDnD();
+                this.$ulEle.sortable('enable');
+            }
+            else if (this.$ulEle && !nv) {
+                this.$ulEle.removeAttr('aria-describedby');
+                this.$ulEle.sortable('disable');
+            }
+        }
+        else if (key === 'multiselect') {
+            // multiselect binding is evaluated after ngAfterViewInit, so initial value may be incorrect.
+            // Reassigning here to ensure selectedItemWidgets matches the updated multiselect value.
+            this.selectedItemWidgets = nv ? [] : {};
+        }
+        else if (key === 'allowpagesizechange') {
+            this.allowpagesizechange = nv;
+            this.dataNavigator.allowpagesizechange = nv;
+        }
+        else if (key === 'pagesizeoptions') {
+            this.prevPagesizeoptions = this.sanitizeCommaSeparatedIntegers(ov);
+            this.pagesizeoptions = this.sanitizeCommaSeparatedIntegers(nv);
+            if (this.allowpagesizechange)
+                this.setDefaultPageSize(nv);
+        }
+        else {
+            super.onPropertyChange(key, nv, ov);
+        }
+    }
+    setDefaultPageSize(nv) {
+        if (this.allowpagesizechange) {
+            const widgetState = this.statePersistence.getWidgetState(this);
+            if (get(widgetState, 'pagesize')) {
+                nv = get(widgetState, 'pagesize');
+                this.pagesize = nv; // updating the default pagesize to user selected pagesize
+            }
+            else if (this.pagesizeoptions) {
+                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;
+        this.dataNavigator.options = {
+            maxResults: nv
+        };
+        this.dataNavigator.widget.maxResults = nv;
+        this.dataNavigator.maxResults = nv;
+        if (this.datasource) {
+            this.datasource.maxResults = this.pagesize || this.datasource.maxResults;
+        }
+    }
+    isPageSizeOptionsChanged() {
+        return !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;
+        if (!$listItem.disableItem) {
+            this.firstSelectedItem = this.firstSelectedItem || $listItem;
+            // Setting selectCount value based number of items selected.
+            selectCount = isArray(this.selecteditem) ? this.selecteditem.length : (isObject(this.selecteditem) ? 1 : 0);
+            // Handling multiselect for mobile device
+            if (this.multiselect && isMobile()) {
+                if (this.checkSelectionLimit(selectCount) || $listItem.isActive) {
+                    this.toggleListItemSelection($listItem);
+                }
+                else {
+                    this.invokeEventCallback('selectionlimitexceed', { $event: evt });
+                }
+            }
+            else if ((evt.ctrlKey || evt.metaKey) && this.multiselect) {
+                if (this.checkSelectionLimit(selectCount) || $listItem.isActive) {
+                    this.firstSelectedItem = this.lastSelectedItem = $listItem;
+                    this.toggleListItemSelection($listItem);
+                }
+                else {
+                    this.invokeEventCallback('selectionlimitexceed', { $event: evt });
+                }
+            }
+            else if (evt.shiftKey && this.multiselect) {
+                let first = $listItem.context.index;
+                let last = this.firstSelectedItem.context.index;
+                // if first is greater than last, then swap values
+                if (first > last) {
+                    last = [first, first = last][0];
+                }
+                if (this.checkSelectionLimit(last - first)) {
+                    this.clearSelectedItems();
+                    this.listItems.forEach(($liItem) => {
+                        const index = $liItem.context.index;
+                        if (index >= first && index <= last) {
+                            this.toggleListItemSelection($liItem);
+                        }
+                    });
+                    this.lastSelectedItem = $listItem;
+                }
+                else {
+                    this.invokeEventCallback('selectionlimitexceed', { $event: evt });
+                }
+            }
+            else {
+                if (!$listItem.isActive || selectCount > 1) {
+                    this.clearSelectedItems();
+                    this.toggleListItemSelection($listItem);
+                    this.firstSelectedItem = this.lastSelectedItem = $listItem;
+                }
+            }
+            $appDigest();
+        }
+    }
+    // Empty the list content on clear
+    clear() {
+        this.updateFieldDefs([]);
+    }
+    /**
+     * deselects item in the list.
+     * @param val: index | model of the list item.
+     */
+    deselectItem(val) {
+        const listItem = this.getItemRefByIndexOrModel(val);
+        if (listItem && listItem.isActive) {
+            this.toggleListItemSelection(listItem);
+        }
+    }
+    /**
+     * selects item in the list.
+     * @param val: index | model of the list item.
+     */
+    selectItem(val, statePersistenceTriggered) {
+        const listItem = this.getItemRefByIndexOrModel(val);
+        if (!listItem) {
+            return;
+        }
+        if (!listItem.isActive) {
+            this.toggleListItemSelection(listItem, statePersistenceTriggered);
+        }
+        // focus the element.
+        listItem.nativeElement.focus();
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.handleHeaderClick = noop;
+        setTimeout(() => {
+            this.debouncedFetchNextDatasetOnScroll = this.paginationService.debouncedFetchNextDatasetOnScroll(this.dataNavigator, DEBOUNCE_TIMES.PAGINATION_DEBOUNCE_TIME, this);
+        }, 0);
+        this._items = [];
+        this.fieldDefs = [];
+        this.reorderProps = {
+            minIndex: null,
+            maxIndex: null
+        };
+        // Check if the host element has any of these autolayout attributes
+        const autoLayoutAttrs = ['wrap', 'alignment', 'gap', 'columngap'];
+        const directionValue = this.nativeElement.getAttribute('direction');
+        const hasAutoLayoutDirection = directionValue === 'row' || directionValue === 'column';
+        this.hasAutolayout = hasAutoLayoutDirection || autoLayoutAttrs.some(attr => this.nativeElement.hasAttribute(attr));
+    }
+    ngAfterViewInit() {
+        this.promiseResolverFn();
+        this.propsInitPromise.then(() => {
+            super.ngAfterViewInit();
+            this.setUpCUDHandlers();
+            this.selectedItemWidgets = this.multiselect ? [] : {};
+            var ele = $(this.nativeElement).find('.app-livelist-container');
+            if (this.enablereorder && !this.groupby) {
+                if (ele) {
+                    ele.attr('aria-describedby', this.titleId);
+                }
+                this.configureDnD();
+            }
+            if (!this.enablereorder) {
+                if (ele) {
+                    ele.removeAttr('aria-describedby');
+                }
+            }
+            if (this.groupby && this.collapsible) {
+                this.handleHeaderClick = handleHeaderClick;
+                this.toggleAllHeaders = toggleAllHeaders.bind(undefined, this);
+            }
+            setListClass(this);
+        });
+        this.setupHandlers();
+        const $ul = this.nativeElement.querySelector('ul.app-livelist-container');
+        styler($ul, this, APPLY_STYLES_TYPE.CONTAINER);
+        if (this.enablereorder) {
+            if ($ul) {
+                $ul.setAttribute('aria-describedby', this.titleId);
+            }
+        }
+        if (!this.enablereorder) {
+            if ($ul) {
+                $ul.removeAttribute('aria-describedby');
+            }
+        }
+        this._readItemAttrsFromHost();
+    }
+    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 = [];
+        }
+        // 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() {
+        super.ngOnDetach();
+        this._pageLoad = true;
+    }
+    handleEvent(node, eventName, eventCallback, locals) {
+        // tap and doubleTap events are not getting propagated.So, using mouse events instead.
+        const touchToMouse = {
+            tap: 'click',
+            doubletap: 'dblclick'
+        };
+        if (includes(['click', 'tap', 'dblclick', 'doubletap'], eventName)) {
+            this.eventManager.addEventListener(this.nativeElement, touchToMouse[eventName] || eventName, (evt) => {
+                const target = $(evt.target).closest('.app-list-item');
+                if (target.length) {
+                    const listItemContext = target.data('listItemContext');
+                    if (!listItemContext.disableItem) {
+                        this.invokeEventCallback(eventName, {
+                            widget: listItemContext,
+                            $event: evt,
+                            item: listItemContext.item
+                        });
+                    }
+                }
+            });
+        }
+    }
+    getConfiguredState() {
+        const mode = this.statePersistence.computeMode(this.statehandler);
+        return mode && mode.toLowerCase();
+    }
+    handleStateParams(options) {
+        if (this._pageLoad && this.getConfiguredState() !== 'none') {
+            this._pageLoad = false;
+            const widgetState = this.statePersistence.getWidgetState(this);
+            if (get(widgetState, 'pagination')) {
+                options.options = options.options || {};
+                options.options.page = widgetState.pagination;
+            }
+            if (get(widgetState, 'selectedItem')) {
+                this._selectedItemsExist = true;
+            }
+        }
+    }
+    triggerWMEvent(eventName, item) {
+        $invokeWatchers(true);
+        // If we have multiselect for the livelist(List with form template), in run mode deleting a record is getting failed. Becuase the selecteditem will be array of objects. So consider the last object.
+        let row = this.multiselect ? last(this.selecteditem) : this.selecteditem;
+        if (item) {
+            row = item;
+        }
+        this.app.notify('wm-event', { eventName, widgetName: this.name, row: row });
+    }
+    resetNavigation() {
+        this.showNavigation = false;
+        this.navControls = undefined;
+        this.infScroll = false;
+        this.onDemandLoad = false;
+    }
+    enableBasicNavigation() {
+        this.navControls = NAVIGATION_TYPE.BASIC;
+        this.showNavigation = true;
+    }
+    enableInlineNavigation() {
+        this.navControls = NAVIGATION_TYPE.INLINE;
+    }
+    enableClassicNavigation() {
+        this.navControls = NAVIGATION_TYPE.CLASSIC;
+        this.showNavigation = true;
+    }
+    enablePagerNavigation() {
+        this.navControls = NAVIGATION_TYPE.PAGER;
+        this.showNavigation = true;
+    }
+    setNavigationTypeNone() {
+        this.navControls = NAVIGATION_TYPE.NONE;
+        this.showNavigation = false;
+    }
+    enableInfiniteScroll() {
+        this.infScroll = true;
+    }
+    enableOnDemandLoad() {
+        this.onDemandLoad = true;
+        this.showNavigation = true;
+    }
+    /**
+     * Sets Navigation type for the list.
+     * @param type
+     */
+    onNavigationTypeChange(type) {
+        this.resetNavigation();
+        switch (type) {
+            case NAVIGATION_TYPE.BASIC:
+                this.enableBasicNavigation();
+                break;
+            case NAVIGATION_TYPE.INLINE:
+                this.enableInlineNavigation();
+                break;
+            case NAVIGATION_TYPE.ADVANCED:
+            case NAVIGATION_TYPE.CLASSIC:
+                this.enableClassicNavigation();
+                break;
+            case NAVIGATION_TYPE.PAGER:
+                this.enablePagerNavigation();
+                break;
+            case NAVIGATION_TYPE.NONE:
+                this.setNavigationTypeNone();
+                break;
+            case NAVIGATION_TYPE.SCROLL:
+                this.enableInfiniteScroll();
+                break;
+            case NAVIGATION_TYPE.ONDEMAND:
+                this.enableOnDemandLoad();
+                break;
+        }
+    }
+    /**
+     * Update fieldDefs property, fieldDefs is the model of the List Component.
+     * fieldDefs is an Array type.
+     * @param newVal
+     */
+    updateFieldDefs(newVal) {
+        if (this.infScroll || this.onDemandLoad) {
+            [this.fieldDefs, this.currentPage] = this.paginationService.updateFieldsOnPagination(this, newVal);
+        }
+        else {
+            this.fieldDefs = newVal;
+        }
+        if (this.orderby) {
+            this.fieldDefs = getOrderedDataset(this.fieldDefs, this.orderby);
+        }
+        if (this.groupby) {
+            this.groupedData = groupData(this, this.fieldDefs, this.groupby, this.match, this.orderby, this.dateformat, this.datePipe, undefined, this.appDefaults);
+        }
+        if (!this.fieldDefs.length) {
+            this.noDataFound = true;
+            this.selecteditem = undefined;
+        }
+        $appDigest();
+        this.listItems.setDirty();
+    }
+    onDataChange(newVal) {
+        // Check for newVal is not empty
+        if (!isEmpty(newVal)) {
+            this.noDataFound = false;
+            this.isDataChanged = true;
+            if (this.datasource && this.datasource.execute(DataSource.Operation.IS_API_AWARE)) {
+                // clone the the data in case of live and service variables to prevent the two-way binding for these variables.
+                newVal = cloneDeep(newVal);
+            }
+            if (isObject(newVal) && !isArray(newVal)) {
+                newVal = isEmpty(newVal) ? [] : [newVal];
+            }
+            if (isString(newVal)) {
+                newVal = newVal.split(',');
+            }
+            // if the page number is greater than 1 on initial load then we render the first page.
+            if (this.datasource && this.datasource.owner === 'App' && (this.infScroll || this.onDemandLoad) && !this.currentPage && this.datasource.execute(DataSource.Operation.GET_PAGING_OPTIONS).number > 0) {
+                newVal = this.datasource.execute(DataSource.Operation.LIST_RECORDS, {
+                    'page': 1
+                });
+            }
+            if (isArray(newVal)) {
+                if (newVal.length) {
+                    this.invokeEventCallback('beforedatarender', { $data: newVal });
+                }
+                this.updateFieldDefs(newVal);
+            }
+        }
+        else {
+            this.updateFieldDefs([]);
+        }
+    }
+    // Updates the dataSource when pagination is enabled for the Component.
+    setupDataSource() {
+        const dataNavigator = this.dataNavigator;
+        dataNavigator.options = {
+            maxResults: this.pagesize || 20
+        };
+        this.dataNavigatorWatched = true;
+        if (this.navigatorResultWatch) {
+            this.navigatorResultWatch.unsubscribe();
+        }
+        /*Register a watch on the "result" property of the "dataNavigator" so that the paginated data is displayed in the live-list.*/
+        this.navigatorResultWatch = dataNavigator.resultEmitter.subscribe((newVal) => {
+            this.onDataChange(newVal);
+        }, true);
+        /*De-register the watch if it is exists */
+        if (this.navigatorMaxResultWatch) {
+            this.navigatorMaxResultWatch.unsubscribe();
+        }
+        /*Register a watch on the "maxResults" property of the "dataNavigator" so that the "pageSize" is displayed in the live-list.*/
+        this.navigatorMaxResultWatch = dataNavigator.maxResultsEmitter.subscribe((val) => {
+            this.pagesize = val;
+        });
+        dataNavigator.maxResults = this.pagesize || 20;
+        this.removePropertyBinding('dataset');
+        // when list having "datasetboundexpr" attr indicates that list is bound to item context
+        // when dataset is bound to "item.FIELD" then item context is passed as the datasource.
+        const datasetBoundExpr = this.getAttr('datasetboundexpr');
+        this.dataNavigator.setBindDataSet(this.binddataset, this.viewParent, datasetBoundExpr ? this.context : this.datasource, this.dataset, this.binddatasource, datasetBoundExpr, this.statehandler);
+    }
+    onDataSetChange(newVal) {
+        if (get(this.datasource, 'category') === 'wm.Variable' && this.getConfiguredState() !== 'none' && this._pageLoad) {
+            const widgetState = this.statePersistence.getWidgetState(this);
+            this._pageLoad = false;
+            if (this.allowpagesizechange) { // maintain updated page size in the statePersistence
+                if (get(widgetState, 'pagination') || get(widgetState, 'pagesize')) {
+                    this.dataNavigator.pageChanged({ page: widgetState.pagination || 1, pagesize: widgetState.pagesize }, true);
+                }
+            }
+            else {
+                if (get(widgetState, 'pagination')) {
+                    this.dataNavigator.pageChanged({ page: widgetState.pagination }, true);
+                }
+            }
+            if (get(widgetState, 'selectedItem')) {
+                this._selectedItemsExist = true;
+            }
+        }
+        if (!this.dataNavigatorWatched) {
+            if (this.navigation && this.navigation !== NAVIGATION_TYPE.NONE) {
+                this.setupDataSource();
+            }
+            else {
+                this.onDataChange(newVal);
+            }
+        }
+        else if (this.navigation && this.navigation !== NAVIGATION_TYPE.NONE) {
+            // If navigation is already setup and datasource is changed, update the datasource on navigation
+            this.dataNavigator.setDataSource(this.datasource);
+        }
+    }
+    // All the ListItem's Active state is set to false.
+    deselectListItems() {
+        this.listItems.forEach(item => item.isActive = false);
+    }
+    // Deselect all the ListItems and clear the selecteditem(InOutBound Property model)
+    clearSelectedItems() {
+        this.deselectListItems();
+        this._items.length = 0;
+        $appDigest();
+    }
+    /**
+     * return the ListItemDirective instance by checking the equality of the model.
+     * @param listModel: model to be searched for
+     * @returns ListItem if the model is matched else return null.
+     */
+    getListItemByModel(listModel) {
+        return this.listItems.find((listItem) => {
+            let itemObj = listItem.item;
+            if (this.groupby && !has(listModel, '_groupIndex')) {
+                // If groupby is enabled, item contains _groupIndex property which should be excluded while comparing model.
+                itemObj = clone(itemObj);
+                delete itemObj._groupIndex;
+            }
+            if (isEqual(itemObj, listModel)) {
+                return true;
+            }
+        }) || null;
+    }
+    updateSelectedItemsWidgets(statePersistenceTriggered) {
+        let obj = {}, widgetState;
+        const pageNum = get(this.dataNavigator, 'dn.currentPage') || 1;
+        if (this.getConfiguredState() !== 'none') {
+            // remove previously configured selected items for current page and construct new ones later below.
+            widgetState = this.statePersistence.getWidgetState(this) || {};
+            if (get(widgetState, 'selectedItem')) {
+                // when multiselect is on and an item is selected without pressing CTRL, previously selected items in state should be empty.
+                if (this.multiselect && this.selecteditem.length === 1) {
+                    widgetState.selectedItem = [];
+                }
+                else {
+                    remove(widgetState.selectedItem, function (selectedItem) {
+                        return selectedItem.page === pageNum;
+                    });
+                }
+            }
+        }
+        if (this.multiselect) {
+            this.selectedItemWidgets.length = 0;
+        }
+        this.listItems.forEach((item, index) => {
+            if (item.isActive) {
+                if (this.multiselect) {
+                    this.selectedItemWidgets.push(item.currentItemWidgets);
+                }
+                else {
+                    this.selectedItemWidgets = item.currentItemWidgets;
+                }
+                obj = { page: pageNum, index: index };
+                if (get(widgetState, 'selectedItem') && this.multiselect) {
+                    if (!some(widgetState.selectedItem, obj)) {
+                        widgetState.selectedItem.push(obj);
+                    }
+                }
+                else {
+                    widgetState.selectedItem = [obj];
+                }
+            }
+        });
+        if (this.getConfiguredState() !== 'none' && !statePersistenceTriggered) {
+            if (unsupportedStatePersistenceTypes.indexOf(this.navigation) < 0) {
+                this.statePersistence.removeWidgetState(this, 'selectedItem');
+                this.statePersistence.setWidgetState(this, { 'selectedItem': widgetState.selectedItem });
+            }
+            else {
+                console.warn('Retain State handling on Widget ' + this.name + ' is not supported for current pagination type.');
+            }
+        }
+    }
+    /**
+     * Selects the listItem and updates selecteditem property.
+     * If the listItem is already a selected item then deselects the item.
+     * @param {ListItemDirective} $listItem: Item to be selected of deselected.
+     */
+    toggleListItemSelection($listItem, statePersistenceTriggered) {
+        // item is not allowed to get selected if it is disabled.
+        if ($listItem && !$listItem.disableItem) {
+            let item = $listItem.item;
+            if (this.groupby && has(item, '_groupIndex')) {
+                // If groupby is enabled, item contains _groupIndex property which should be excluded from selecteditem.
+                item = clone(item);
+                delete item._groupIndex;
+            }
+            if ($listItem.isActive) {
+                this._items = pullAllWith(this._items, [item], isEqual);
+                $listItem.isActive = false;
+            }
+            else {
+                // if multiselect is false, clear the selectItem list before adding an item to the selectItem list.
+                if (!this.multiselect) {
+                    this.clearSelectedItems();
+                }
+                this._items.push(item);
+                this.invokeEventCallback('select', { widget: $listItem, $data: item });
+                $listItem.isActive = true;
+            }
+            this.updateSelectedItemsWidgets(statePersistenceTriggered);
+        }
+    }
+    /**
+     * Method is Invoked when the model for the List Widget is changed.
+     * @param {QueryList<ListItemDirective>} listItems
+     */
+    onListRender(listItems) {
+        // Added render callback event. This method(onListRender) is calling multiple times so checking isDatachanged flag because this falg is changed whenever new data is rendered.
+        if (this.isDataChanged) {
+            // Whenever dataset is changed, trigger watchers to evaluate listitem bind expressions.
+            $invokeWatchers(true);
+            this.invokeEventCallback('render', { $data: this.fieldDefs });
+        }
+        if (this.isDataChanged && this.getConfiguredState() !== 'none' && listItems.length && this._selectedItemsExist) {
+            const widgetState = this.statePersistence.getWidgetState(this);
+            if (get(widgetState, 'selectedItem')) {
+                this._selectedItemsExist = false;
+                const selectedItemsLength = isArray(this.selecteditem) ? this.selecteditem.length : toNumber(!isEmpty(this.selecteditem));
+                const currentPage = get(this.dataNavigator, 'dn.currentPage') || 1;
+                widgetState.pagination = widgetState.pagination || 1;
+                // to prevent item selection from being triggered more than once
+                if (selectedItemsLength !== widgetState.selectedItem.length && widgetState.pagination === currentPage) {
+                    widgetState.selectedItem.forEach((item) => {
+                        if (item.page === currentPage) {
+                            this.selectItem(item.index, true);
+                        }
+                    });
+                }
+            }
+        }
+        const selectedItems = isArray(this.selecteditem) ? this.selecteditem : [this.selecteditem];
+        this.firstSelectedItem = this.lastSelectedItem = null;
+        // don't select first item if multi-select is enabled and at least item is already selected in the list.
+        // don't select first item if state information has selected items
+        if (listItems.length && this.selectfirstitem && !(this._items.length && this.multiselect) && this._selectedItemsExist !== false) {
+            const $firstItem = listItems.first;
+            if (!$firstItem.disableItem &&
+                this.isDataChanged &&
+                // "infinite scroll" or "load on demand" is enabled and at least one item is selected then dont alter the selected list items.
+                !((this.infScroll || this.onDemandLoad) &&
+                    this._items.length)) {
+                this.clearSelectedItems();
+                this.firstSelectedItem = this.lastSelectedItem = $firstItem;
+                // selecting the first record
+                this.selectItem(0);
+            }
+        }
+        else {
+            this.deselectListItems();
+            selectedItems.forEach(selecteditem => {
+                const listItem = this.getListItemByModel(selecteditem);
+                if (listItem) {
+                    listItem.isActive = true;
+                    this.lastSelectedItem = listItem;
+                    // focus the active element
+                    listItem.nativeElement.focus();
+                }
+            });
+        }
+        if (this.fieldDefs.length && this.infScroll) {
+            const smoothScrollEl = this.$element.closest('[wmsmoothscroll]');
+            // In case of mobile app when modal exists, and list items height is greater than the modal content provide ccontainer a scrollable height
+            const modalBody = this.$element.closest('.modal-body');
+            const listHt = this.$element.find('ul').height();
+            const modalHt = window.innerHeight - 140;
+            if (isMobile() && modalBody.length && listHt > modalHt) {
+                this.$element.css('height', modalHt + 'px');
+            }
+            setTimeout(() => this.paginationService.bindScrollEvt(this, '> ul', DEBOUNCE_TIMES.PAGINATION_DEBOUNCE_TIME), 500);
+            // this.paginationService.bindScrollEvt(this, '> ul', DEBOUNCE_TIMES.PAGINATION_DEBOUNCE_TIME);
+        }
+        this.isDataChanged = false;
+    }
+    setupHandlers() {
+        this.listItemsChangesSubscription = this.listItems.changes.subscribe(listItems => {
+            this.onListRender(listItems);
+            this.cdRef.detectChanges();
+        });
+        // handle click event in capturing phase.
+        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);
+        };
+        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) {
+        ui.placeholder.height(ui.item.height());
+        this.$ulEle.data('oldIndex', ui.item.index());
+    }
+    // Triggers during sorting
+    onSort(evt, ui) {
+        // In case of infinite scroll, when the element doesn't have scroll enabled
+        // on dragging the element to last item's position manually trigger loading of next items
+        if (this.infScroll) {
+            const lastItemOffset = this.$ulEle.find(`[listitemindex=${this.fieldDefs.length - 1}]`).offset();
+            if (lastItemOffset && lastItemOffset.top < ui.offset.top) {
+                this.paginationService.bindScrollEvt(this, '> ul', DEBOUNCE_TIMES.PAGINATION_DEBOUNCE_TIME);
+                this.debouncedFetchNextDatasetOnScroll();
+            }
+        }
+    }
+    // Triggers after the sorting.
+    onUpdate(evt, ui, presentIndex) {
+        const data = this.fieldDefs;
+        // If ui is not present then it is called from drag and drop using keyboard
+        const newIndex = ui === undefined ? presentIndex : ui.item.index();
+        const oldIndex = this.$ulEle.data('oldIndex');
+        const minIndex = min([newIndex, oldIndex]);
+        const maxIndex = max([newIndex, oldIndex]);
+        const draggedItem = pullAt(data, oldIndex)[0];
+        // Modify the data list only if we find a draggedItem
+        if (draggedItem) {
+            if (this.getConfiguredState() !== 'none') {
+                this.statePersistence.removeWidgetState(this, 'selectedItem');
+            }
+            this.reorderProps.minIndex = min([minIndex, this.reorderProps.minIndex]);
+            this.reorderProps.maxIndex = max([maxIndex, this.reorderProps.maxIndex]);
+            data.splice(newIndex, 0, draggedItem);
+            this.cdRef.markForCheck();
+            this.cdRef.detectChanges();
+            const $changedItem = {
+                oldIndex: oldIndex,
+                newIndex: newIndex,
+                item: data[newIndex]
+            };
+            this.invokeEventCallback('reorder', { $event: evt, $data: data, $changedItem });
+            this.$ulEle.removeData('oldIndex');
+        }
+    }
+    // configures reordering the list items.
+    configureDnD() {
+        let appendTo;
+        const modalEl = $(document).find('.modal');
+        if (this.getAttr('height')) { // when height is applied to the list, append should be the ul's parent as scroll is applied to the parent
+            appendTo = 'parent';
+        }
+        else if (modalEl.length) { // In case of dialog, appendTo should be the modal ele
+            appendTo = modalEl[modalEl.length - 1];
+        }
+        else { // As default append to should be body
+            appendTo = 'body';
+        }
+        const options = {
+            appendTo: appendTo,
+        };
+        const $el = $(this.nativeElement);
+        this.$ulEle = $el.find('.app-livelist-container');
+        configureDnD(this.$ulEle, options, this.onReorderStart.bind(this), this.onUpdate.bind(this), this.onSort.bind(this));
+        this.$ulEle.droppable({ 'accept': '.app-list-item' });
+    }
+    // returns true if the selection limit is reached.
+    checkSelectionLimit(count) {
+        return (!this.selectionlimit || count < this.selectionlimit);
+    }
+    // returns listitem reference by index value.
+    getListItemByIndex(index) {
+        return this.listItems.toArray()[index];
+    }
+    /**
+     * return index of an (listItemDirective) in the listItem
+     * @param {ListItemDirective} item
+     * @returns {number}
+     */
+    getListItemIndex(item) {
+        return this.listItems.toArray().indexOf(item);
+    }
+    /**
+     *  Returns ListItem Reference based on the input provided.
+     * @param val: index | model of the list item.
+     * @returns {ListItemDirective}
+     */
+    getItemRefByIndexOrModel(val) {
+        let listItem;
+        if (isNumber(val)) {
+            listItem = this.getListItemByIndex(val);
+        }
+        else {
+            listItem = this.getListItemByModel(val);
+        }
+        return listItem;
+    }
+    beforePaginationChange($event, $index) {
+        this.invokeEventCallback('paginationchange', { $event, $index });
+    }
+    trackByFn($index) {
+        return $index; // Return a unique identifier for each item
+    }
+    // Invoke the datasource variable by default when pulltorefresh event is not specified.
+    subscribeToPullToRefresh() {
+        this._listenerDestroyers.push(this.app.subscribe('pulltorefresh', () => {
+            if (this.datasource && this.datasource.listRecords) {
+                this.datasource.listRecords();
+            }
+        }));
+    }
+    setUpCUDHandlers() {
+        const $addItem = document.getElementsByClassName("add-list-item")[0];
+        if ($addItem) {
+            // MEMORY LEAK FIX: Store bound handler for cleanup
+            this.boundAddItemHandler = (evt) => {
+                this.create();
+            };
+            // Triggered on click of add action
+            $addItem.addEventListener('click', this.boundAddItemHandler);
+        }
+    }
+    _readItemAttrsFromHost() {
+        const raw = this.nativeElement.getAttribute("itemattrs");
+        if (!raw) {
+            this.itemAttrsMap = {};
+            return;
+        }
+        try {
+            this.itemAttrsMap = JSON.parse(raw);
+        }
+        catch (e) {
+            console.warn("list.component: failed to parse itemattrs JSON", e, raw);
+            this.itemAttrsMap = {};
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ListComponent, deps: [{ token: i0.Injector }, { token: i0.ChangeDetectorRef }, { token: i1.ToDatePipe }, { token: i2.App }, { token: i2.AppDefaults }, { token: i0.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.StatePersistence }, { token: i2.PaginationService }, { token: 'EXPLICIT_CONTEXT', optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: ListComponent, isStandalone: true, selector: "div[wmList]", providers: [
+            provideAsWidgetRef(ListComponent)
+        ], queries: [{ propertyName: "listTemplate", first: true, predicate: ["listTemplate"], descendants: true }, { propertyName: "listLeftActionTemplate", first: true, predicate: ["listLeftActionTemplate"], descendants: true }, { propertyName: "listRightActionTemplate", first: true, predicate: ["listRightActionTemplate"], descendants: true }, { propertyName: "btnComponents", predicate: ButtonComponent }], viewQueries: [{ propertyName: "dataNavigator", first: true, predicate: PaginationComponent, descendants: true }, { propertyName: "listItems", predicate: ListItemDirective, descendants: true }], usesInheritance: true, ngImport: i0, template: "@if (title || subheading || iconclass) {\n  <div class=\"panel-heading\">\n    <h3 class=\"panel-title\">\n      <div class=\"pull-left\">\n        <i class=\"app-icon panel-icon {{iconclass}}\" aria-hidden=\"true\" [hidden]=\"!iconclass\"></i>\n      </div>\n      <div class=\"pull-left\">\n        <div class=\"heading\" [innerHTML]=\"title\"></div>\n        <div class=\"description\" [innerHTML]=\"subheading\"></div>\n      </div>\n    </h3>\n  </div>\n}\n\n@if (navigation === 'Inline' && !noDataFound) {\n  <div class=\"app-datanavigator\" [attr.aria-disabled]=\"dataNavigator.isDisablePrevious\" aria-label=\"Page navigation\">\n    <ul class=\"pager\">\n      <li class=\"previous\" [ngClass]=\"{'disabled': (dataNavigator ? dataNavigator.isDisablePrevious : true)}\">\n        <a href=\"javascript:void(0);\" (click)=\"dataNavigator.navigatePage('prev', $event)\"\n          [attr.aria-disabled]=\"dataNavigator.isDisablePrevious\">\n          <i class=\"wi wi-chevron-left\" aria-hidden=\"true\"></i>\n          <span class=\"sr-only\">Go to Previous page {{dataNavigator.isDisablePrevious ? ', Disabled' : ''}}</span>\n        </a>\n      </li>\n    </ul>\n  </div>\n}\n@if (navigation === 'Inline' && !noDataFound) {\n  <div aria-live=\"polite\" aria-atomic=\"true\" class=\"sr-only\"> {{'Page ' + dataNavigator.dn.currentPage + ' of ' + dataNavigator.pageCount }}</div>\n}\n\n<div>\n  @if (enablereorder) {\n    <div id={{titleId}} class=\"sr-only\">\n      Press space bar to toggle drag drop mode, use arrow keys to move selected elements.\n    </div>\n  }\n\n  @if (listItems && enablereorder && currentIndex) {\n    <div aria-live=\"assertive\" class=\"sr-only\" >\n      {{ariaText + currentIndex + ' of ' +  listItems.length}}\n    </div>\n  }\n</div>\n\n<ul [attr.tabindex]=\"tabindex\"  class=\"list-group app-livelist-container clearfix {{direction === 'horizontal' ? 'app-horizontal-list': ''}} {{listclass}}\" role=\"list\"\n  [class.list-group-autolayout]=\"hasAutolayout\"\n  (keydown.enter)=\"handleKeyDown($event, 'select')\"\n\n  (keydown.space)=\"handleKeyDown($event, 'space')\"\n\n  (keydown.arrowup)=\"handleKeyDown($event, 'focusPrev')\"\n  (keydown.arrowdown)=\"handleKeyDown($event, 'focusNext')\"\n  (keydown.arrowleft)=\"handleKeyDown($event, 'focusPrev')\"\n  (keydown.arrowright)=\"handleKeyDown($event, 'focusNext')\"\n\n  (keydown.shift.arrowup)=\"handleKeyDown($event, 'selectPrev')\"\n  (keydown.shift.arrowdown)=\"handleKeyDown($event, 'selectNext')\"\n  (keydown.shift.arrowleft)=\"handleKeyDown($event, 'selectPrev')\"\n  (keydown.shift.arrowright)=\"handleKeyDown($event, 'selectNext')\"\n  [hidden]=\"noDataFound && !variableInflight\"\n  >\n  @if (!groupby) {\n    @for (item of fieldDefs; track item) {\n      <li class=\"app-list-item {{direction === 'horizontal' ? '' : itemsPerRowClass}}\" [ngClass]=\"listItemRef.itemClass\"\n        [wmListItem]=\"item\"\n        #listItemRef=\"listItemRef\"\n        [attr.tabindex]=\"tabindex\"\n        role=\"listitem\">\n        <ng-container [ngTemplateOutlet]=\"listTemplate\"\n          [ngTemplateOutletInjector]=\"createCustomInjector('falt_' + listItemRef.trackId, {item: item, $index: $index, itemRef: listItemRef, $first: $first, $last: $last, currentItemWidgets: listItemRef.currentItemWidgets})\"\n        [ngTemplateOutletContext]=\"{item: item, $index: $index, itemRef: listItemRef, $first: $first, $last: $last, currentItemWidgets: listItemRef.currentItemWidgets}\"></ng-container>\n      </li>\n    }\n  } @else {\n    @for (groupObj of groupedData; track groupObj; let groupIndex = $index) {\n      <li class=\"app-list-item-group clearfix\">\n        <ul [attr.tabindex]=\"tabindex\" class=\"list-group item-group\" [ngClass]=\"listclass\" [class.list-group-autolayout]=\"hasAutolayout\">\n          <li class=\"app-list-item-header list-item list-group-header\" (click)=\"handleHeaderClick($event)\" [ngClass]=\"{'collapsible-content': collapsible}\">\n            <h4>{{groupObj.key}}\n              <div class=\"header-action\">\n                @if (collapsible) {\n                  <i class=\"app-icon wi action wi-chevron-up\"></i>\n                }\n                @if (showcount) {\n                  <span class=\"label label-default\">{{groupObj.data.length}}</span>\n                }\n              </div>\n            </h4>\n          </li>\n          <li class=\"list-group-container\">\n            <ul class=\"list-group clearfix {{direction === 'horizontal' ? 'app-horizontal-list': ''}}\" [class.list-group-autolayout]=\"hasAutolayout\">\n              @for (item of groupObj.data; track trackByFn($index, item)) {\n                <li [attr.tabindex]=\"tabindex\"\n                  class=\"app-list-item group-list-item {{itemsPerRowClass}}\"\n                  [ngClass]=\"listItemRef.itemClass\"\n                  [wmListItem]=\"item\" #listItemRef=\"listItemRef\">\n                  <ng-container [ngTemplateOutlet]=\"listTemplate\"\n                    [ngTemplateOutletInjector]=\"createCustomInjector('group_' + listItemRef.trackId, {item: item, $index: $index, itemRef: listItemRef, $first: $first, $last: $last, currentItemWidgets: listItemRef.currentItemWidgets})\"\n                  [ngTemplateOutletContext]=\"{item: item, $index: $index, itemRef: listItemRef, $first: $first, $last: $last, currentItemWidgets: listItemRef.currentItemWidgets}\"></ng-container>\n                </li>\n              }\n            </ul>\n          </li>\n        </ul>\n      </li>\n    }\n  }\n  <ng-container [ngTemplateOutlet]=\"listLeftActionTemplate\"></ng-container>\n  <ng-container [ngTemplateOutlet]=\"listRightActionTemplate\"></ng-container>\n</ul>\n\n@if (noDataFound && !variableInflight) {\n  <div class=\"no-data-msg\" [textContent]=\"nodatamessage\"></div>\n}\n\n@if (variableInflight && !pulltorefresh) {\n  <div class=\"loading-data-msg\">\n    <span>\n      <i class=\"app-icon panel-icon fa-spin\" aria-hidden=\"true\" [ngClass]=\"loadingicon\"></i>\n      <span class=\"sr-only\">Loading</span>\n      <span class=\"loading-text\" [textContent]=\"loadingdatamsg\"></span>\n    </span>\n  </div>\n}\n\n@if (navigation === 'Inline' && !noDataFound) {\n  <div class=\"app-datanavigator\" [attr.aria-disabled]=\"dataNavigator.isDisableNext\">\n    <ul class=\"pager\">\n      <li class=\"next\" [ngClass]=\"{'disabled': (dataNavigator ? dataNavigator.isDisableNext  : true)}\">\n        <a href=\"javascript:void(0);\" (click)=\"dataNavigator.navigatePage('next', $event)\"\n          [attr.aria-disabled]=\"dataNavigator.isDisableNext\">\n          <i class=\"wi wi-chevron-right\" aria-hidden=\"true\"></i>\n          <span class=\"sr-only\">Go to Next page {{dataNavigator.isDisableNext ? ', Disabled' : ''}}</span>\n        </a>\n      </li>\n    </ul>\n  </div>\n}\n\n@if (navigation !== 'None') {\n  <div class=\"panel-footer\" [hidden]=\"!showNavigation || (onDemandLoad && dataNavigator.isDisableNext) || (dataNavigator?.dataSize <= pagesize && !allowpagesizechange) || (!dataNavigator.dataSize && !dataNavigator.datasource?.pagination?.next)\">\n    <nav wmPagination\n      navigationalign.bind=\"navigationalign\"\n      navigation.bind=\"navControls\"\n      showrecordcount.bind=\"showrecordcount\"\n      maxsize.bind=\"maxsize\"\n      boundarylinks.bind=\"boundarylinks\"\n      forceellipses.bind=\"forceellipses\"\n      directionlinks.bind=\"directionlinks\"\n      show.bind=\"!onDemandLoad\"\n      paginationchange.event=\"beforePaginationChange($event, $index)\"\n    ></nav>\n    @if (onDemandLoad) {\n      <a href=\"javascript:void(0);\"\n        (click)=\"dataNavigator.navigatePage('next', $event)\"\n        class=\"app-button btn btn-block\"\n        [ngClass]=\"paginationclass\"\n        [textContent]=\"ondemandmessage\"\n      ></a>\n    }\n  </div>\n}\n\n<!--This template will be displayed when groupby is specified-->\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i3.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: TextContentDirective, selector: "[textContent]", inputs: ["textContent"] }, { kind: "component", type: PaginationComponent, selector: "[wmPagination]", outputs: ["resultEmitter", "maxResultsEmitter"] }, { kind: "directive", type: ListItemDirective, selector: "[wmListItem]", inputs: ["wmListItem"], exportAs: ["listItemRef"] }] }); }
+};
+ListComponent = __decorate([
+    AutoLayout({ targetSelector: 'ul' }),
+    __metadata("design:paramtypes", [Injector,
+        ChangeDetectorRef,
+        ToDatePipe,
+        App,
+        AppDefaults,
+        NgZone, String, String, String, String, String, String, StatePersistence,
+        PaginationService, Object])
+], ListComponent);
+export { ListComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ListComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, imports: [CommonModule, TextContentDirective, PaginationComponent, ListItemDirective], selector: 'div[wmList]', providers: [
+                        provideAsWidgetRef(ListComponent)
+                    ], template: "@if (title || subheading || iconclass) {\n  <div class=\"panel-heading\">\n    <h3 class=\"panel-title\">\n      <div class=\"pull-left\">\n        <i class=\"app-icon panel-icon {{iconclass}}\" aria-hidden=\"true\" [hidden]=\"!iconclass\"></i>\n      </div>\n      <div class=\"pull-left\">\n        <div class=\"heading\" [innerHTML]=\"title\"></div>\n        <div class=\"description\" [innerHTML]=\"subheading\"></div>\n      </div>\n    </h3>\n  </div>\n}\n\n@if (navigation === 'Inline' && !noDataFound) {\n  <div class=\"app-datanavigator\" [attr.aria-disabled]=\"dataNavigator.isDisablePrevious\" aria-label=\"Page navigation\">\n    <ul class=\"pager\">\n      <li class=\"previous\" [ngClass]=\"{'disabled': (dataNavigator ? dataNavigator.isDisablePrevious : true)}\">\n        <a href=\"javascript:void(0);\" (click)=\"dataNavigator.navigatePage('prev', $event)\"\n          [attr.aria-disabled]=\"dataNavigator.isDisablePrevious\">\n          <i class=\"wi wi-chevron-left\" aria-hidden=\"true\"></i>\n          <span class=\"sr-only\">Go to Previous page {{dataNavigator.isDisablePrevious ? ', Disabled' : ''}}</span>\n        </a>\n      </li>\n    </ul>\n  </div>\n}\n@if (navigation === 'Inline' && !noDataFound) {\n  <div aria-live=\"polite\" aria-atomic=\"true\" class=\"sr-only\"> {{'Page ' + dataNavigator.dn.currentPage + ' of ' + dataNavigator.pageCount }}</div>\n}\n\n<div>\n  @if (enablereorder) {\n    <div id={{titleId}} class=\"sr-only\">\n      Press space bar to toggle drag drop mode, use arrow keys to move selected elements.\n    </div>\n  }\n\n  @if (listItems && enablereorder && currentIndex) {\n    <div aria-live=\"assertive\" class=\"sr-only\" >\n      {{ariaText + currentIndex + ' of ' +  listItems.length}}\n    </div>\n  }\n</div>\n\n<ul [attr.tabindex]=\"tabindex\"  class=\"list-group app-livelist-container clearfix {{direction === 'horizontal' ? 'app-horizontal-list': ''}} {{listclass}}\" role=\"list\"\n  [class.list-group-autolayout]=\"hasAutolayout\"\n  (keydown.enter)=\"handleKeyDown($event, 'select')\"\n\n  (keydown.space)=\"handleKeyDown($event, 'space')\"\n\n  (keydown.arrowup)=\"handleKeyDown($event, 'focusPrev')\"\n  (keydown.arrowdown)=\"handleKeyDown($event, 'focusNext')\"\n  (keydown.arrowleft)=\"handleKeyDown($event, 'focusPrev')\"\n  (keydown.arrowright)=\"handleKeyDown($event, 'focusNext')\"\n\n  (keydown.shift.arrowup)=\"handleKeyDown($event, 'selectPrev')\"\n  (keydown.shift.arrowdown)=\"handleKeyDown($event, 'selectNext')\"\n  (keydown.shift.arrowleft)=\"handleKeyDown($event, 'selectPrev')\"\n  (keydown.shift.arrowright)=\"handleKeyDown($event, 'selectNext')\"\n  [hidden]=\"noDataFound && !variableInflight\"\n  >\n  @if (!groupby) {\n    @for (item of fieldDefs; track item) {\n      <li class=\"app-list-item {{direction === 'horizontal' ? '' : itemsPerRowClass}}\" [ngClass]=\"listItemRef.itemClass\"\n        [wmListItem]=\"item\"\n        #listItemRef=\"listItemRef\"\n        [attr.tabindex]=\"tabindex\"\n        role=\"listitem\">\n        <ng-container [ngTemplateOutlet]=\"listTemplate\"\n          [ngTemplateOutletInjector]=\"createCustomInjector('falt_' + listItemRef.trackId, {item: item, $index: $index, itemRef: listItemRef, $first: $first, $last: $last, currentItemWidgets: listItemRef.currentItemWidgets})\"\n        [ngTemplateOutletContext]=\"{item: item, $index: $index, itemRef: listItemRef, $first: $first, $last: $last, currentItemWidgets: listItemRef.currentItemWidgets}\"></ng-container>\n      </li>\n    }\n  } @else {\n    @for (groupObj of groupedData; track groupObj; let groupIndex = $index) {\n      <li class=\"app-list-item-group clearfix\">\n        <ul [attr.tabindex]=\"tabindex\" class=\"list-group item-group\" [ngClass]=\"listclass\" [class.list-group-autolayout]=\"hasAutolayout\">\n          <li class=\"app-list-item-header list-item list-group-header\" (click)=\"handleHeaderClick($event)\" [ngClass]=\"{'collapsible-content': collapsible}\">\n            <h4>{{groupObj.key}}\n              <div class=\"header-action\">\n                @if (collapsible) {\n                  <i class=\"app-icon wi action wi-chevron-up\"></i>\n                }\n                @if (showcount) {\n                  <span class=\"label label-default\">{{groupObj.data.length}}</span>\n                }\n              </div>\n            </h4>\n          </li>\n          <li class=\"list-group-container\">\n            <ul class=\"list-group clearfix {{direction === 'horizontal' ? 'app-horizontal-list': ''}}\" [class.list-group-autolayout]=\"hasAutolayout\">\n              @for (item of groupObj.data; track trackByFn($index, item)) {\n                <li [attr.tabindex]=\"tabindex\"\n                  class=\"app-list-item group-list-item {{itemsPerRowClass}}\"\n                  [ngClass]=\"listItemRef.itemClass\"\n                  [wmListItem]=\"item\" #listItemRef=\"listItemRef\">\n                  <ng-container [ngTemplateOutlet]=\"listTemplate\"\n                    [ngTemplateOutletInjector]=\"createCustomInjector('group_' + listItemRef.trackId, {item: item, $index: $index, itemRef: listItemRef, $first: $first, $last: $last, currentItemWidgets: listItemRef.currentItemWidgets})\"\n                  [ngTemplateOutletContext]=\"{item: item, $index: $index, itemRef: listItemRef, $first: $first, $last: $last, currentItemWidgets: listItemRef.currentItemWidgets}\"></ng-container>\n                </li>\n              }\n            </ul>\n          </li>\n        </ul>\n      </li>\n    }\n  }\n  <ng-container [ngTemplateOutlet]=\"listLeftActionTemplate\"></ng-container>\n  <ng-container [ngTemplateOutlet]=\"listRightActionTemplate\"></ng-container>\n</ul>\n\n@if (noDataFound && !variableInflight) {\n  <div class=\"no-data-msg\" [textContent]=\"nodatamessage\"></div>\n}\n\n@if (variableInflight && !pulltorefresh) {\n  <div class=\"loading-data-msg\">\n    <span>\n      <i class=\"app-icon panel-icon fa-spin\" aria-hidden=\"true\" [ngClass]=\"loadingicon\"></i>\n      <span class=\"sr-only\">Loading</span>\n      <span class=\"loading-text\" [textContent]=\"loadingdatamsg\"></span>\n    </span>\n  </div>\n}\n\n@if (navigation === 'Inline' && !noDataFound) {\n  <div class=\"app-datanavigator\" [attr.aria-disabled]=\"dataNavigator.isDisableNext\">\n    <ul class=\"pager\">\n      <li class=\"next\" [ngClass]=\"{'disabled': (dataNavigator ? dataNavigator.isDisableNext  : true)}\">\n        <a href=\"javascript:void(0);\" (click)=\"dataNavigator.navigatePage('next', $event)\"\n          [attr.aria-disabled]=\"dataNavigator.isDisableNext\">\n          <i class=\"wi wi-chevron-right\" aria-hidden=\"true\"></i>\n          <span class=\"sr-only\">Go to Next page {{dataNavigator.isDisableNext ? ', Disabled' : ''}}</span>\n        </a>\n      </li>\n    </ul>\n  </div>\n}\n\n@if (navigation !== 'None') {\n  <div class=\"panel-footer\" [hidden]=\"!showNavigation || (onDemandLoad && dataNavigator.isDisableNext) || (dataNavigator?.dataSize <= pagesize && !allowpagesizechange) || (!dataNavigator.dataSize && !dataNavigator.datasource?.pagination?.next)\">\n    <nav wmPagination\n      navigationalign.bind=\"navigationalign\"\n      navigation.bind=\"navControls\"\n      showrecordcount.bind=\"showrecordcount\"\n      maxsize.bind=\"maxsize\"\n      boundarylinks.bind=\"boundarylinks\"\n      forceellipses.bind=\"forceellipses\"\n      directionlinks.bind=\"directionlinks\"\n      show.bind=\"!onDemandLoad\"\n      paginationchange.event=\"beforePaginationChange($event, $index)\"\n    ></nav>\n    @if (onDemandLoad) {\n      <a href=\"javascript:void(0);\"\n        (click)=\"dataNavigator.navigatePage('next', $event)\"\n        class=\"app-button btn btn-block\"\n        [ngClass]=\"paginationclass\"\n        [textContent]=\"ondemandmessage\"\n      ></a>\n    }\n  </div>\n}\n\n<!--This template will be displayed when groupby is specified-->\n" }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i0.ChangeDetectorRef }, { type: i1.ToDatePipe }, { type: i2.App }, { type: i2.AppDefaults }, { type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['itemclass.bind']
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['disableitem.bind']
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['dataset.bind']
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['datasource.bind']
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['mouseenter.event']
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['mouseleave.event']
+                }] }, { type: i2.StatePersistence }, { type: i2.PaginationService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['EXPLICIT_CONTEXT']
+                }, {
+                    type: Optional
+                }] }], propDecorators: { listTemplate: [{
+                type: ContentChild,
+                args: ['listTemplate']
+            }], listLeftActionTemplate: [{
+                type: ContentChild,
+                args: ['listLeftActionTemplate']
+            }], listRightActionTemplate: [{
+                type: ContentChild,
+                args: ['listRightActionTemplate']
+            }], btnComponents: [{
+                type: ContentChildren,
+                args: [ButtonComponent]
+            }], dataNavigator: [{
+                type: ViewChild,
+                args: [PaginationComponent]
+            }], listItems: [{
+                type: ViewChildren,
+                args: [ListItemDirective]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list.component.js","sourceRoot":"","sources":["../../../../../projects/components/widgets/data/list/src/list.component.ts","../../../../../projects/components/widgets/data/list/src/list.component.html"],"names":[],"mappings":"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","sourcesContent":["import {CommonModule} from '@angular/common';\nimport {\n    AutoLayout,\n    APPLY_STYLES_TYPE,\n    configureDnD,\n    DEBOUNCE_TIMES,\n    extractDataSourceName,\n    getOrderedDataset,\n    groupData,\n    handleHeaderClick,\n    NAVIGATION_TYPE,\n    provideAsWidgetRef,\n    StylableComponent,\n    styler,\n    TextContentDirective,\n    ToDatePipe,\n    toggleAllHeaders,\n    unsupportedStatePersistenceTypes,\n    WidgetRef\n} from \"@wm/components/base\";\nimport {\n    AfterViewInit,\n    Attribute,\n    ChangeDetectorRef,\n    Component,\n    ContentChild,\n    ContentChildren,\n    ElementRef,\n    Inject,\n    Injector,\n    NgZone,\n    OnDestroy,\n    OnInit,\n    Optional,\n    QueryList,\n    TemplateRef,\n    ViewChild,\n    ViewChildren\n} from '@angular/core';\n\nimport {Subscription} from 'rxjs';\n\nimport {\n    $appDigest,\n    $invokeWatchers,\n    App,\n    AppDefaults,\n    DataSource,\n    generateGUId,\n    getClonedObject,\n    isDataSourceEqual,\n    isDefined,\n    isMobile,\n    isObject,\n    noop,\n    PaginationService,\n    setListClass,\n    StatePersistence,\n    switchClass\n} from '@wm/core';\nimport {PaginationComponent} from '@wm/components/data/pagination';\nimport {ButtonComponent} from '@wm/components/input/button';\n\nimport {registerProps} from './list.props';\nimport {ListItemDirective} from './list-item.directive';\nimport {ListAnimator} from './list.animator';\nimport {\n    clone,\n    cloneDeep,\n    forEach,\n    get,\n    has,\n    includes,\n    isArray,\n    isEmpty,\n    isEqual,\n    isNumber,\n    isString,\n    isUndefined,\n    last,\n    max,\n    min,\n    pullAllWith,\n    pullAt,\n    remove,\n    some,\n    toNumber\n} from \"lodash-es\";\n\ndeclare const $;\n\nconst DEFAULT_CLS = 'app-livelist app-panel';\nconst WIDGET_CONFIG = {widgetType: 'wm-list', hostClass: DEFAULT_CLS};\n\n@AutoLayout({ targetSelector: 'ul' })\n@Component({\n  standalone: true,\n  imports: [CommonModule, TextContentDirective, PaginationComponent, ListItemDirective],\n    selector: 'div[wmList]',\n    templateUrl: './list.component.html',\n    providers: [\n        provideAsWidgetRef(ListComponent)\n    ]\n})\nexport class ListComponent extends StylableComponent implements OnInit, AfterViewInit, OnDestroy {\n    static initializeProps = registerProps();\n\n    @ContentChild('listTemplate') listTemplate: TemplateRef<ElementRef>;\n\n    @ContentChild('listLeftActionTemplate') listLeftActionTemplate: TemplateRef<ElementRef>;\n    @ContentChild('listRightActionTemplate') listRightActionTemplate: TemplateRef<ElementRef>;\n    @ContentChildren(ButtonComponent) btnComponents;\n\n    @ViewChild(PaginationComponent) dataNavigator;\n    @ViewChildren(ListItemDirective) listItems: QueryList<ListItemDirective>;\n    public noDataFound: boolean;\n    public lastSelectedItem: ListItemDirective;\n    public fieldDefs: Array<any>;\n    public disableitem;\n    public navigation: string;\n    public navigationalign: string;\n    public pagesize: number;\n    public dataset: any;\n    public multiselect: boolean;\n    public selectfirstitem: boolean;\n    public orderby: string;\n    public loadingicon: string;\n    public paginationclass: string;\n    public ondemandmessage: string;\n    public loadingdatamsg: string;\n    public selectionlimit: number;\n    public infScroll: boolean;\n    public enablereorder: boolean;\n    public itemsperrow: string;\n    public itemclass: string;\n    public selectedItemWidgets: Array<WidgetRef> | WidgetRef;\n    public variableInflight;\n    public name;\n    public currentPage;\n    public direction;\n    public tabindex;\n    public handleHeaderClick: Function;\n    public toggleAllHeaders: void;\n    public groupby: string;\n    public collapsible: string;\n    public datePipe: ToDatePipe;\n    public binditemclass: string;\n    public binddisableitem: string;\n    public binddataset: string;\n    public mouseEnterCB: string;\n    public mouseLeaveCB: string;\n    public pulltorefresh: boolean;\n    public title: string;\n    public subheading: string;\n    public iconclass: string;\n    public listclass: any;\n    public statehandler: any;\n    public currentIndex: number;\n    public titleId: string;\n    public allowpagesizechange: boolean = false;\n    public pagesizeoptions: string;\n    private prevPagesizeoptions: string;\n    public updatedPageSize;\n    public actualPageSize;\n    _isDependent;\n    private itemsPerRowClass: string;\n    private firstSelectedItem: ListItemDirective;\n    private navigatorMaxResultWatch: Subscription;\n    private navigatorResultWatch: Subscription;\n    private navControls: string;\n    private onDemandLoad: boolean;\n    private _items: Array<any>;\n    private dataNavigatorWatched: boolean;\n    private datasource: any;\n    private showNavigation: boolean;\n    private reorderProps: any;\n    private app: any;\n    private appDefaults: any;\n    private ngZone: NgZone;\n    private statePersistence: StatePersistence;\n    private paginationService: PaginationService;\n    private binddatasource: string;\n    private match: string;\n    private dateformat: string;\n    private groupedData: any;\n    private cdRef: ChangeDetectorRef;\n    private promiseResolverFn: Function;\n    private propsInitPromise: Promise<any>;\n    private $ulEle: any;\n    private _listAnimator: ListAnimator;\n    private _listenerDestroyers: Array<any>;\n    private debouncedFetchNextDatasetOnScroll: Function;\n    private isDataChanged: boolean;\n    private isListElementMovable: boolean;\n    private ariaText: String;\n    private _pageLoad;\n    private _selectedItemsExist;\n    private listItemsChangesSubscription: any;\n    private boundClickHandler: (event: Event) => void;\n    public itemAttrsMap: { [k: string]: string } = {};\n    public hasAutolayout: boolean = false;\n\n    private touching;\n    private touched;\n\n    constructor(\n        inj: Injector,\n        cdRef: ChangeDetectorRef,\n        datePipe: ToDatePipe,\n        app: App,\n        appDefaults: AppDefaults,\n        ngZone: NgZone,\n        @Attribute('itemclass.bind') binditemclass: string,\n        @Attribute('disableitem.bind') binddisableitem: string,\n        @Attribute('dataset.bind') binddataset: string,\n        @Attribute('datasource.bind') binddatasource: string,\n        @Attribute('mouseenter.event') mouseEnterCB: string,\n        @Attribute('mouseleave.event') mouseLeaveCB: string,\n        statePersistence: StatePersistence,\n        paginationService: PaginationService,\n        @Inject('EXPLICIT_CONTEXT') @Optional() explicitContext: any\n    ) {\n        let resolveFn: Function = noop;\n        const propsInitPromise = new Promise(res => resolveFn = res);\n        super(inj, WIDGET_CONFIG, explicitContext, propsInitPromise);\n        this.propsInitPromise = propsInitPromise;\n        this.promiseResolverFn = resolveFn;\n        styler(this.nativeElement, this, APPLY_STYLES_TYPE.SHELL);\n        this.cdRef = cdRef;\n        this.ngZone = ngZone;\n        this.datePipe = datePipe;\n        this.statePersistence = statePersistence;\n        this.paginationService = paginationService;\n        this._pageLoad = true;\n\n        this.binditemclass = binditemclass;\n        this.binddisableitem = binddisableitem;\n        this.binddataset = binddataset;\n        this.mouseEnterCB = mouseEnterCB;\n        this.mouseLeaveCB = mouseLeaveCB;\n        this.binddatasource = binddatasource;\n\n        this.app = app;\n        this.appDefaults = appDefaults;\n        this.variableInflight = false;\n\n        this.noDataFound = !binddataset;\n        this.titleId = 'wmlist-' + generateGUId();\n\n        // Updates pagination, filter, sort etc options for service and crud variables\n        this._listenerDestroyers = [\n            this.app.subscribe('check-state-persistence-options', options => {\n                let dataSourceName = get(this.datasource, 'name');\n                // in Prefabs, this.datasource is not resolved at the time of variable invocation, so additional check is required.\n                if (!dataSourceName) {\n                    dataSourceName = extractDataSourceName(this.binddatasource);\n                }\n                if (get(options, 'variable.name') !== dataSourceName) {\n                    return;\n                }\n                this.handleStateParams(options);\n            }),\n            // Show loading status based on the variable life cycle\n            this.app.subscribe('toggle-variable-state', this.handleLoading.bind(this)),\n            this.app.subscribe('setup-cud-listener', param => {\n                if (this.nativeElement.getAttribute('name') !== param) {\n                    return;\n                }\n                this._isDependent = true;\n            })\n        ];\n    }\n\n    public get selecteditem() {\n        if (this.multiselect) {\n            return getClonedObject(this._items);\n        }\n        if (isEmpty(this._items)) {\n            return {};\n        }\n        return getClonedObject(this._items[0]);\n    }\n\n    public set selecteditem(items) {\n        this._items.length = 0;\n        this.deselectListItems();\n\n        if (isArray(items)) {\n            items.forEach(item => this.selectItem(item));\n        } else {\n            this.selectItem(items);\n        }\n        $appDigest();\n    }\n\n    /**\n     * Returns list of widgets present on list item by considering name and index of the widget.\n     * If we did'nt pass index, it returns array of all the widgets which are matching to widget name\n     * @param widgteName: Name of the widget\n     * @param index: Index of the widget\n     */\n    public getWidgets(widgteName: string, index?: number) {\n        let $target;\n        const retVal = [];\n\n        if (!widgteName) {\n            return;\n        }\n\n        if (!isDefined(index)) {\n            forEach(this.listItems.toArray(), (el) => {\n                $target = get(el.currentItemWidgets, widgteName);\n                if ($target) {\n                    retVal.push($target);\n                }\n            });\n\n            return retVal;\n        }\n        index = +index || 0;\n\n        $target = get(this.listItems.toArray(), index);\n\n        if ($target) {\n            return [get($target.currentItemWidgets, widgteName)];\n        }\n    }\n\n    // returns listitem reference by index value. This refers to the same method getListItemByIndex.\n    public getItem(index: number) {\n        return this.getListItemByIndex(index);\n    }\n\n    /**\n     * Returns index of listItem(listItemDirective / listItemObject)\n     * If item is a directive, index is fetched from listItems\n     * If item is an object, index is fetched from fieldDefs\n     */\n    public getIndex(item: any) {\n        if (item instanceof ListItemDirective) {\n            return this.getListItemIndex(item);\n        } else if (item) {\n            return this.fieldDefs.findIndex((obj) => isEqual(obj, item));\n        }\n    }\n     public getUpdatedPageSize() {\n         return this.updatedPageSize;\n     }\n\n    create() {\n        if (this._isDependent) {\n            this.triggerWMEvent('insert');\n        }\n    }\n\n    editRow(item?) {\n        if (this._isDependent) {\n            let listItem;\n            if (item) {\n                listItem = this.getItemRefByIndexOrModel(item).item;\n            }\n            this.triggerWMEvent('update', listItem);\n        }\n    }\n\n    update(item?) {\n        this.editRow(item);\n    }\n\n    deleteRow(item?) {\n        if (this._isDependent) {\n            let listItem;\n            if (item) {\n                listItem = this.getItemRefByIndexOrModel(item).item;\n            }\n            this.triggerWMEvent('delete', listItem);\n        }\n    }\n\n    delete(item?) {\n        this.deleteRow(item);\n    }\n\n    handleLoading(data) {\n        const dataSource = this.datasource;\n        if (dataSource && dataSource.execute(DataSource.Operation.IS_API_AWARE) && isDataSourceEqual(data.variable, dataSource)) {\n            this.ngZone.run(() => {\n                this.handleStateParams(data);\n                this.variableInflight = data.active;\n                // Fix for [WMS-23772] Update nodatafound flag once the response is recieved from the server\n                const totalEle = data.data?.pagination?.totalElements;\n                if (!isUndefined(totalEle)) {\n                    this.noDataFound = totalEle === 0 ? true : false;\n                } else { // totalelements is undefined\n                    this.noDataFound = isEmpty(data.data?.data);\n                }\n            });\n        }\n    }\n\n    public triggerListItemSelection($el: JQuery<HTMLElement>, $event: Event) {\n        if ($el && $el[0]) {\n            const listItemContext = $el.data('listItemContext');\n            // Trigger click event only if the list item is from the corresponding list.\n            if (listItemContext.listComponent === this) {\n                this.onItemClick($event, listItemContext);\n            }\n        }\n    }\n\n    // this method is called form other data widgets like table.\n    public execute(operation, options) {\n        if ([DataSource.Operation.IS_API_AWARE, DataSource.Operation.IS_PAGEABLE, DataSource.Operation.SUPPORTS_SERVER_FILTER].includes(operation)) {\n            return false;\n        }\n        return this.datasource.execute(operation, options);\n    }\n\n    public handleKeyDown($event, action: string) {\n        $event.stopPropagation();\n        if ($event.keyCode !== 13 && $event.keyCode !== 9 && !(($event.target.classList.contains('form-control') || $event.target.classList.contains('note-editable')) && $event.keyCode === 32)) {\n            $event.preventDefault();\n        }\n\n        const listItems: QueryList<ListItemDirective> = this.listItems;\n\n        let presentIndex: number = this.getListItemIndex(this.lastSelectedItem);\n\n        if (this.multiselect) {\n            const firstIndex: number = this.getListItemIndex(this.firstSelectedItem);\n            const selectCount: number = isArray(this.selecteditem) ? this.selecteditem.length : (isObject(this.selecteditem) ? 1 : 0);\n            if (action === 'selectPrev') {\n                if (presentIndex > 0) {\n                    if ((presentIndex <= firstIndex) && this.checkSelectionLimit(selectCount)) {\n                        this.lastSelectedItem = this.getListItemByIndex(presentIndex - 1);\n                        this.toggleListItemSelection(this.lastSelectedItem);\n                    } else if (presentIndex > firstIndex) {\n                        this.toggleListItemSelection(this.getListItemByIndex(presentIndex));\n                        this.lastSelectedItem = this.getListItemByIndex(presentIndex - 1);\n                    } else {\n                        this.invokeEventCallback('selectionlimitexceed', {$event});\n                    }\n                }\n            } else if (action === 'selectNext') {\n                if (presentIndex < listItems.length - 1) {\n                    if ((presentIndex >= firstIndex) && this.checkSelectionLimit(selectCount)) {\n                        this.lastSelectedItem = this.getListItemByIndex(presentIndex + 1);\n                        this.toggleListItemSelection(this.lastSelectedItem);\n                    } else if (presentIndex < firstIndex) {\n                        this.toggleListItemSelection(this.getListItemByIndex(presentIndex));\n                        this.lastSelectedItem = this.getListItemByIndex(presentIndex + 1);\n                    } else {\n                        this.invokeEventCallback('selectionlimitexceed', {$event});\n                    }\n                }\n            }\n        }\n        if (action === 'focusPrev') {\n            if (this.isListElementMovable) {\n                presentIndex = presentIndex <= 0 ? 0 : (presentIndex);\n                if (presentIndex === 0) {\n                    return;\n                }\n\n                this.lastSelectedItem = this.getListItemByIndex(presentIndex);\n                const prevElt = this.getListItemByIndex(presentIndex - 1);\n                prevElt.nativeElement.before(this.lastSelectedItem.nativeElement);\n                this.lastSelectedItem.nativeElement.focus();\n                this.statePersistence.removeWidgetState(this, 'selectedItem');\n                const arr = this.listItems.toArray();\n                [arr[presentIndex - 1], arr[presentIndex]] = [arr[presentIndex], arr[presentIndex - 1]];\n                this.listItems.reset(arr);\n                this.currentIndex = presentIndex;\n                this.ariaText = \"selected \";\n            } else {\n                presentIndex = presentIndex <= 0 ? 0 : (presentIndex - 1);\n                this.lastSelectedItem = this.getListItemByIndex(presentIndex);\n                this.lastSelectedItem.nativeElement.focus();\n                this.currentIndex = presentIndex + 1;\n                this.ariaText = \"selected \";\n            }\n        } else if (action === 'focusNext') {\n            if (this.isListElementMovable) {\n                presentIndex = presentIndex < (listItems.length - 1) ? (presentIndex) : (listItems.length - 1);\n                if (presentIndex === this.listItems.length - 1) {\n                    return;\n                }\n\n                this.lastSelectedItem = this.getListItemByIndex(presentIndex);\n                const nextElt = this.getListItemByIndex(presentIndex + 1);\n                nextElt.nativeElement.after(this.lastSelectedItem.nativeElement);\n                this.lastSelectedItem.nativeElement.focus();\n                this.statePersistence.removeWidgetState(this, 'selectedItem');\n                const arr = this.listItems.toArray();\n                [arr[presentIndex], arr[presentIndex + 1]] = [arr[presentIndex + 1], arr[presentIndex]];\n                this.listItems.reset(arr);\n                this.currentIndex = presentIndex + 2;\n                this.ariaText = \"selected \";\n            } else {\n                presentIndex = presentIndex < (listItems.length - 1) ? (presentIndex + 1) : (listItems.length - 1);\n                this.lastSelectedItem = this.getListItemByIndex(presentIndex);\n                this.lastSelectedItem.nativeElement.focus();\n                this.currentIndex = presentIndex + 1;\n                this.ariaText = \"selected \";\n            }\n        } else if (action === 'select') {\n            // if the enter click is pressed on the item which is not the last selected item, the find the item from which the event is originated.\n            if (presentIndex === -1 || !$($event.target).closest(this.lastSelectedItem.nativeElement)) {\n                const $li = $($event.target).closest('li.app-list-item');\n                const $ul = $li.closest('ul.app-livelist-container');\n                presentIndex = $ul.find('li.app-list-item').index($li);\n            }\n            this.onItemClick($event, this.getListItemByIndex(presentIndex));\n        } else if (action === 'space') {\n            if (!this.enablereorder) {\n                return;\n            }\n            this.isListElementMovable = !this.isListElementMovable;\n            this.onItemClick($event, this.getListItemByIndex(presentIndex));\n            this.currentIndex = presentIndex + 1;\n            if (this.isListElementMovable) {\n                this.ariaText = `Item ${this.currentIndex} grabbed, current position `;\n                this.$ulEle.data('oldIndex', presentIndex);\n            } else {\n                this.ariaText = `Item ${this.currentIndex} dropped, final position `;\n                this.onUpdate($event, undefined, presentIndex);\n            }\n        }\n    }\n    getActualPageSize()  {\n        return this.actualPageSize || 20;\n    }\n\n    onPropertyChange(key: string, nv: any, ov?: any) {\n        if (key === 'dataset') {\n            if (!nv && this.binddatasource && !this.datasource) {\n                return;\n            }\n            this.onDataSetChange(nv);\n        } else if (key === 'datasource') {\n            if(this.allowpagesizechange){\n                this.datasource.maxResults = this.pagesize || this.datasource.maxResults\n            }\n            if (this.dataset) {\n                this.onDataSetChange(this.dataset);\n            }\n        } else if (key === 'navigation') {\n            // Support for older projects where navigation type was advanced instead of classic\n            if (nv === 'Advanced') {\n                this.navigation = 'Classic';\n                return;\n            }\n            switchClass(this.nativeElement, nv, ov);\n            this.onNavigationTypeChange(nv);\n            if (this.dataNavigator) {\n                this.dataNavigator.navigationClass = this.paginationclass;\n            }\n        } else if (key === 'itemsperrow') {\n            setListClass(this);\n        } else if (key === 'tabindex') {\n            return;\n        } else if (key === 'pulltorefresh' && nv) {\n            this.app.notify('pullToRefresh:enable');\n            this.subscribeToPullToRefresh();\n        } else if (key === 'paginationclass') {\n            if (this.dataNavigator) {\n                // Adding setTimeout because in pagination component updateNavSize method is overriding navigationclass\n                setTimeout(() => this.dataNavigator.navigationClass = nv);\n            }\n        } else if (key === 'pagesize') {\n            this.actualPageSize = nv; // maintain default page size to calculate pagesize options\n            this.setDefaultPageSize(nv)\n        } else if (key === 'enablereorder') {\n            if (nv && this.$ulEle) {\n                this.$ulEle.attr('aria-describedby', this.titleId);\n                this.configureDnD();\n                this.$ulEle.sortable('enable');\n            } else if (this.$ulEle && !nv) {\n                this.$ulEle.removeAttr('aria-describedby');\n                this.$ulEle.sortable('disable');\n            }\n        } else if (key === 'multiselect') {\n            // multiselect binding is evaluated after ngAfterViewInit, so initial value may be incorrect.\n            // Reassigning here to ensure selectedItemWidgets matches the updated multiselect value.\n            this.selectedItemWidgets = nv ? [] : {};\n        } else if (key === 'allowpagesizechange') {\n            this.allowpagesizechange = nv;\n            this.dataNavigator.allowpagesizechange = nv;\n        } else if(key === 'pagesizeoptions') {\n                this.prevPagesizeoptions = this.sanitizeCommaSeparatedIntegers(ov);\n                this.pagesizeoptions = this.sanitizeCommaSeparatedIntegers(nv);\n                if(this.allowpagesizechange) this.setDefaultPageSize(nv)\n        }else {\n            super.onPropertyChange(key, nv, ov);\n        }\n    }\n\n    setDefaultPageSize(nv: any){\n     if (this.allowpagesizechange) {\n        const widgetState = this.statePersistence.getWidgetState(this);\n        if (get(widgetState, 'pagesize')) {\n            nv = get(widgetState, 'pagesize');\n            this.pagesize = nv; // updating the default pagesize to user selected pagesize\n        } else if (this.pagesizeoptions) {\n            nv = this.pagesizeoptions?.split(',').map(Number).sort((a, b) => a - b)[0]\n            this.pagesize = nv;\n        }\n         if(this.isPageSizeOptionsChanged()) {\n             this.dataNavigator.defaultPageSizeOptions = this.pagesizeoptions?.split(',').map(Number).sort((a, b) => a - b) || [];\n             this.dataNavigator.pageSizeOptions = [...this.dataNavigator.defaultPageSizeOptions];\n         }\n    }\n        this.updatedPageSize = nv;\n        this.dataNavigator.updatedPageSize = nv;\n\n        this.dataNavigator.options = {\n            maxResults: nv\n        };\n        this.dataNavigator.widget.maxResults = nv;\n        this.dataNavigator.maxResults = nv;\n        if(this.datasource){\n            this.datasource.maxResults = this.pagesize || this.datasource.maxResults;\n        }\n    }\n\n    isPageSizeOptionsChanged() {\n        return !isEqual(this.prevPagesizeoptions, this.pagesizeoptions);\n    }\n\n    selectPageSize(pagesize: number) {\n        if(!this.allowpagesizechange && !pagesize) return;\n\n        if(pagesize < this.dataNavigator.pageSizeOptions[0] || pagesize > this.dataNavigator.pageSizeOptions[this.dataNavigator.pageSizeOptions.length - 1]\n            || !this.dataNavigator.pageSizeOptions.includes(Number(pagesize))) {\n            pagesize = this.dataNavigator.pageSizeOptions[0];\n        }\n        this.dataNavigator.onPageSizeChange(undefined, pagesize);\n    }\n\n    sanitizeCommaSeparatedIntegers(input: string): string {\n        if (!input) return \"\";\n        const uniqueNumbers = Array.from(\n            new Set(\n                input\n                    .split(\",\")\n                    .map(v => v.trim())\n                    .filter(v => /^-?\\d+$/.test(v))\n                    .map(v => Math.abs(parseInt(v, 10)))\n            )\n        );\n        return uniqueNumbers.join(\",\");\n    }\n\n    public onItemClick(evt: any, $listItem: ListItemDirective) {\n        let selectCount: number;\n\n        if (!$listItem.disableItem) {\n            this.firstSelectedItem = this.firstSelectedItem || $listItem;\n            // Setting selectCount value based number of items selected.\n            selectCount = isArray(this.selecteditem) ? this.selecteditem.length : (isObject(this.selecteditem) ? 1 : 0);\n\n            // Handling multiselect for mobile device\n            if (this.multiselect && isMobile()) {\n                if (this.checkSelectionLimit(selectCount) || $listItem.isActive) {\n                    this.toggleListItemSelection($listItem);\n                } else {\n                    this.invokeEventCallback('selectionlimitexceed', {$event: evt});\n                }\n            } else if ((evt.ctrlKey || evt.metaKey) && this.multiselect) {\n                if (this.checkSelectionLimit(selectCount) || $listItem.isActive) {\n                    this.firstSelectedItem = this.lastSelectedItem = $listItem;\n                    this.toggleListItemSelection($listItem);\n                } else {\n                    this.invokeEventCallback('selectionlimitexceed', {$event: evt});\n                }\n            } else if (evt.shiftKey && this.multiselect) {\n                let first = $listItem.context.index;\n                let last = this.firstSelectedItem.context.index;\n\n                // if first is greater than last, then swap values\n                if (first > last) {\n                    last = [first, first = last][0];\n                }\n                if (this.checkSelectionLimit(last - first)) {\n                    this.clearSelectedItems();\n                    this.listItems.forEach(($liItem: ListItemDirective) => {\n                        const index = $liItem.context.index;\n                        if (index >= first && index <= last) {\n                            this.toggleListItemSelection($liItem);\n                        }\n                    });\n                    this.lastSelectedItem = $listItem;\n                } else {\n                    this.invokeEventCallback('selectionlimitexceed', {$event: evt});\n                }\n\n            } else {\n                if (!$listItem.isActive || selectCount > 1) {\n                    this.clearSelectedItems();\n                    this.toggleListItemSelection($listItem);\n                    this.firstSelectedItem = this.lastSelectedItem = $listItem;\n                }\n            }\n            $appDigest();\n        }\n    }\n\n    // Empty the list content on clear\n    public clear() {\n        this.updateFieldDefs([]);\n    }\n\n    /**\n     * deselects item in the list.\n     * @param val: index | model of the list item.\n     */\n    public deselectItem(val: any) {\n        const listItem = this.getItemRefByIndexOrModel(val);\n        if (listItem && listItem.isActive) {\n            this.toggleListItemSelection(listItem);\n        }\n    }\n\n    /**\n     * selects item in the list.\n     * @param val: index | model of the list item.\n     */\n    public selectItem(val, statePersistenceTriggered?) {\n        const listItem = this.getItemRefByIndexOrModel(val);\n        if (!listItem) {\n            return;\n        }\n        if (!listItem.isActive) {\n            this.toggleListItemSelection(listItem, statePersistenceTriggered);\n        }\n        // focus the element.\n        listItem.nativeElement.focus();\n    }\n\n    ngOnInit() {\n        super.ngOnInit();\n        this.handleHeaderClick = noop;\n        setTimeout(() => {\n            this.debouncedFetchNextDatasetOnScroll = this.paginationService.debouncedFetchNextDatasetOnScroll(this.dataNavigator, DEBOUNCE_TIMES.PAGINATION_DEBOUNCE_TIME, this);\n        }, 0);\n        this._items = [];\n        this.fieldDefs = [];\n        this.reorderProps = {\n            minIndex: null,\n            maxIndex: null\n        };\n\n        // Check if the host element has any of these autolayout attributes\n        const autoLayoutAttrs = ['wrap', 'alignment', 'gap', 'columngap'];\n        const directionValue = this.nativeElement.getAttribute('direction');\n        const hasAutoLayoutDirection = directionValue === 'row' || directionValue === 'column';\n        this.hasAutolayout = hasAutoLayoutDirection || autoLayoutAttrs.some(attr => this.nativeElement.hasAttribute(attr));\n    }\n\n    ngAfterViewInit() {\n        this.promiseResolverFn();\n        this.propsInitPromise.then(() => {\n            super.ngAfterViewInit();\n            this.setUpCUDHandlers();\n            this.selectedItemWidgets = this.multiselect ? [] : {};\n            var ele = $(this.nativeElement).find('.app-livelist-container');\n\n            if (this.enablereorder && !this.groupby) {\n                if (ele) {\n                    ele.attr('aria-describedby', this.titleId);\n                }\n                this.configureDnD();\n            }\n            if (!this.enablereorder) {\n                if (ele) {\n                    ele.removeAttr('aria-describedby');\n                }\n            }\n            if (this.groupby && this.collapsible) {\n                this.handleHeaderClick = handleHeaderClick;\n                this.toggleAllHeaders = toggleAllHeaders.bind(undefined, this);\n            }\n            setListClass(this);\n        });\n        this.setupHandlers();\n        const $ul = this.nativeElement.querySelector('ul.app-livelist-container');\n        styler($ul as HTMLElement, this, APPLY_STYLES_TYPE.CONTAINER);\n        if (this.enablereorder) {\n            if ($ul) {\n                $ul.setAttribute('aria-describedby', this.titleId);\n            }\n        }\n        if (!this.enablereorder) {\n            if ($ul) {\n                $ul.removeAttribute('aria-describedby');\n            }\n        }\n\n        this._readItemAttrsFromHost();\n    }\n\n    ngOnDestroy() {\n        if (this._listAnimator && this._listAnimator.$btnSubscription) {\n            this._listAnimator.$btnSubscription.unsubscribe();\n            this._listAnimator = null;\n        }\n        \n        // MEMORY LEAK FIX: Unsubscribe from all app subscriptions\n        if (this._listenerDestroyers) {\n            this._listenerDestroyers.forEach(d => d && d());\n            this._listenerDestroyers = [];\n        }\n\n        // MEMORY LEAK FIX: Unsubscribe from navigator watches\n        if (this.navigatorResultWatch) {\n            this.navigatorResultWatch.unsubscribe();\n            this.navigatorResultWatch = null;\n        }\n        if (this.navigatorMaxResultWatch) {\n            this.navigatorMaxResultWatch.unsubscribe();\n            this.navigatorMaxResultWatch = null;\n        }\n\n        // MEMORY LEAK FIX: Unsubscribe from listItems changes\n        if (this.listItemsChangesSubscription) {\n            this.listItemsChangesSubscription.unsubscribe();\n            this.listItemsChangesSubscription = null;\n        }\n\n        // MEMORY LEAK FIX: Remove native event listener\n        const ulElement = this.nativeElement?.querySelector('ul.app-livelist-container');\n        if (ulElement && this.boundClickHandler) {\n            try {\n                ulElement.removeEventListener('click', this.boundClickHandler, true);\n            } catch (e) {\n                // Silently handle cleanup errors\n            }\n            this.boundClickHandler = null;\n        }\n\n        // MEMORY LEAK FIX: Destroy jQuery sortable widget\n        if (this.$ulEle && this.$ulEle.sortable) {\n            try {\n                this.$ulEle.sortable('destroy');\n            } catch (e) {\n                // Ignore errors during destroy\n            }\n            this.$ulEle = null;\n        }\n\n        // MEMORY LEAK FIX: Clear QueryList references\n        if (this.listItems) {\n            this.listItems = null;\n        }\n        if (this.btnComponents) {\n            this.btnComponents = null;\n        }\n\n        // MEMORY LEAK FIX: Clear ViewChild and ContentChild references\n        this.dataNavigator = null;\n        this.listTemplate = null;\n        this.listLeftActionTemplate = null;\n        this.listRightActionTemplate = null;\n\n        // MEMORY LEAK FIX: Clear all data arrays and objects\n        this.fieldDefs = [];\n        this._items = [];\n        this.groupedData = null;\n        if (Array.isArray(this.selectedItemWidgets)) {\n            this.selectedItemWidgets = [];\n        } else {\n            this.selectedItemWidgets = {};\n        }\n\n        // MEMORY LEAK FIX: Remove add item event listener\n        const $addItem = document.getElementsByClassName(\"add-list-item\")[0];\n        if ($addItem && this.boundAddItemHandler) {\n            $addItem.removeEventListener('click', this.boundAddItemHandler);\n            this.boundAddItemHandler = null;\n        }\n\n        // MEMORY LEAK FIX: Nullify closures and references\n        this.debouncedFetchNextDatasetOnScroll = null;\n        this.firstSelectedItem = null;\n        this.lastSelectedItem = null;\n        this.reorderProps = null;\n\n        super.ngOnDestroy();\n    }\n\n    ngOnDetach() {\n        super.ngOnDetach();\n        this._pageLoad = true;\n    }\n\n    protected handleEvent(node: HTMLElement, eventName: string, eventCallback: Function, locals: any) {\n        // tap and doubleTap events are not getting propagated.So, using mouse events instead.\n        const touchToMouse = {\n            tap: 'click',\n            doubletap: 'dblclick'\n        };\n        if (includes(['click', 'tap', 'dblclick', 'doubletap'], eventName)) {\n            this.eventManager.addEventListener(\n                this.nativeElement,\n                touchToMouse[eventName] || eventName,\n                (evt) => {\n                    const target = $(evt.target).closest('.app-list-item');\n                    if (target.length) {\n                        const listItemContext: ListItemDirective = target.data('listItemContext');\n                        if (!listItemContext.disableItem) {\n                            this.invokeEventCallback(eventName, {\n                                widget: listItemContext,\n                                $event: evt,\n                                item: listItemContext.item\n                            });\n                        }\n                    }\n                }\n            );\n        }\n    }\n\n    private getConfiguredState() {\n        const mode = this.statePersistence.computeMode(this.statehandler);\n        return mode && mode.toLowerCase();\n    }\n\n    private handleStateParams(options) {\n        if (this._pageLoad && this.getConfiguredState() !== 'none') {\n            this._pageLoad = false;\n            const widgetState = this.statePersistence.getWidgetState(this);\n            if (get(widgetState, 'pagination')) {\n                options.options = options.options || {};\n                options.options.page = widgetState.pagination;\n            }\n            if (get(widgetState, 'selectedItem')) {\n                this._selectedItemsExist = true;\n            }\n        }\n    }\n\n    private triggerWMEvent(eventName, item?) {\n        $invokeWatchers(true);\n        // If we have multiselect for the livelist(List with form template), in run mode deleting a record is getting failed. Becuase the selecteditem will be array of objects. So consider the last object.\n        let row = this.multiselect ? last(this.selecteditem) : this.selecteditem;\n        if (item) {\n            row = item;\n        }\n        this.app.notify('wm-event', {eventName, widgetName: this.name, row: row});\n    }\n\n    private resetNavigation() {\n        this.showNavigation = false;\n        this.navControls = undefined;\n        this.infScroll = false;\n        this.onDemandLoad = false;\n    }\n\n    private enableBasicNavigation() {\n        this.navControls = NAVIGATION_TYPE.BASIC;\n        this.showNavigation = true;\n    }\n\n    private enableInlineNavigation() {\n        this.navControls = NAVIGATION_TYPE.INLINE;\n    }\n\n    private enableClassicNavigation() {\n        this.navControls = NAVIGATION_TYPE.CLASSIC;\n        this.showNavigation = true;\n    }\n\n    private enablePagerNavigation() {\n        this.navControls = NAVIGATION_TYPE.PAGER;\n        this.showNavigation = true;\n    }\n\n    private setNavigationTypeNone() {\n        this.navControls = NAVIGATION_TYPE.NONE;\n        this.showNavigation = false;\n    }\n\n    private enableInfiniteScroll() {\n        this.infScroll = true;\n    }\n\n    private enableOnDemandLoad() {\n        this.onDemandLoad = true;\n        this.showNavigation = true;\n    }\n\n    /**\n     * Sets Navigation type for the list.\n     * @param type\n     */\n    private onNavigationTypeChange(type) {\n        this.resetNavigation();\n        switch (type) {\n            case NAVIGATION_TYPE.BASIC:\n                this.enableBasicNavigation();\n                break;\n            case NAVIGATION_TYPE.INLINE:\n                this.enableInlineNavigation();\n                break;\n            case NAVIGATION_TYPE.ADVANCED:\n            case NAVIGATION_TYPE.CLASSIC:\n                this.enableClassicNavigation();\n                break;\n            case NAVIGATION_TYPE.PAGER:\n                this.enablePagerNavigation();\n                break;\n            case NAVIGATION_TYPE.NONE :\n                this.setNavigationTypeNone();\n                break;\n            case NAVIGATION_TYPE.SCROLL:\n                this.enableInfiniteScroll();\n                break;\n            case NAVIGATION_TYPE.ONDEMAND:\n                this.enableOnDemandLoad();\n                break;\n        }\n    }\n\n    /**\n     * Update fieldDefs property, fieldDefs is the model of the List Component.\n     * fieldDefs is an Array type.\n     * @param newVal\n     */\n    private updateFieldDefs(newVal: Array<any>) {\n        if (this.infScroll || this.onDemandLoad) {\n            [this.fieldDefs, this.currentPage] = this.paginationService.updateFieldsOnPagination(this, newVal);\n        } else {\n            this.fieldDefs = newVal;\n        }\n\n        if (this.orderby) {\n            this.fieldDefs = getOrderedDataset(this.fieldDefs, this.orderby);\n        }\n        if (this.groupby) {\n            this.groupedData = groupData(this, this.fieldDefs, this.groupby, this.match, this.orderby, this.dateformat, this.datePipe, undefined, this.appDefaults);\n        }\n\n        if (!this.fieldDefs.length) {\n            this.noDataFound = true;\n            this.selecteditem = undefined;\n        }\n        $appDigest();\n        this.listItems.setDirty();\n    }\n\n    private onDataChange(newVal) {\n        // Check for newVal is not empty\n        if (!isEmpty(newVal)) {\n\n            this.noDataFound = false;\n            this.isDataChanged = true;\n\n            if (this.datasource && this.datasource.execute(DataSource.Operation.IS_API_AWARE)) {\n                // clone the the data in case of live and service variables to prevent the two-way binding for these variables.\n                newVal = cloneDeep(newVal);\n            }\n\n            if (isObject(newVal) && !isArray(newVal)) {\n                newVal = isEmpty(newVal) ? [] : [newVal];\n            }\n\n            if (isString(newVal)) {\n                newVal = newVal.split(',');\n            }\n\n            // if the page number is greater than 1 on initial load then we render the first page.\n            if (this.datasource && this.datasource.owner === 'App' && (this.infScroll || this.onDemandLoad) && !this.currentPage && this.datasource.execute(DataSource.Operation.GET_PAGING_OPTIONS).number > 0) {\n                newVal = this.datasource.execute(DataSource.Operation.LIST_RECORDS, {\n                    'page': 1\n                });\n            }\n\n            if (isArray(newVal)) {\n                if (newVal.length) {\n                    this.invokeEventCallback('beforedatarender', {$data: newVal});\n                }\n                this.updateFieldDefs(newVal);\n            }\n        } else {\n            this.updateFieldDefs([]);\n        }\n    }\n\n    // Updates the dataSource when pagination is enabled for the Component.\n    private setupDataSource() {\n        const dataNavigator = this.dataNavigator;\n\n        dataNavigator.options = {\n            maxResults: this.pagesize || 20\n        };\n\n        this.dataNavigatorWatched = true;\n\n        if (this.navigatorResultWatch) {\n            this.navigatorResultWatch.unsubscribe();\n        }\n        /*Register a watch on the \"result\" property of the \"dataNavigator\" so that the paginated data is displayed in the live-list.*/\n        this.navigatorResultWatch = dataNavigator.resultEmitter.subscribe((newVal: any) => {\n            this.onDataChange(newVal);\n        }, true);\n        /*De-register the watch if it is exists */\n        if (this.navigatorMaxResultWatch) {\n            this.navigatorMaxResultWatch.unsubscribe();\n        }\n        /*Register a watch on the \"maxResults\" property of the \"dataNavigator\" so that the \"pageSize\" is displayed in the live-list.*/\n        this.navigatorMaxResultWatch = dataNavigator.maxResultsEmitter.subscribe((val) => {\n            this.pagesize = val;\n        });\n\n        dataNavigator.maxResults = this.pagesize || 20;\n        this.removePropertyBinding('dataset');\n        // when list having \"datasetboundexpr\" attr indicates that list is bound to item context\n        // when dataset is bound to \"item.FIELD\" then item context is passed as the datasource.\n        const datasetBoundExpr = this.getAttr('datasetboundexpr');\n        this.dataNavigator.setBindDataSet(\n            this.binddataset,\n            this.viewParent,\n            datasetBoundExpr ? this.context : this.datasource,\n            this.dataset,\n            this.binddatasource,\n            datasetBoundExpr,\n            this.statehandler\n        );\n    }\n\n    private onDataSetChange(newVal) {\n        if (get(this.datasource, 'category') === 'wm.Variable' && this.getConfiguredState() !== 'none' && this._pageLoad) {\n            const widgetState = this.statePersistence.getWidgetState(this);\n            this._pageLoad = false;\n            if (this.allowpagesizechange) { // maintain updated page size in the statePersistence\n                if (get(widgetState, 'pagination') || get(widgetState, 'pagesize')) {\n                    this.dataNavigator.pageChanged({page: widgetState.pagination || 1, pagesize: widgetState.pagesize}, true);\n                }\n            } else {\n                if (get(widgetState, 'pagination')) {\n                    this.dataNavigator.pageChanged({page: widgetState.pagination}, true);\n                }\n            }\n            if (get(widgetState, 'selectedItem')) {\n                this._selectedItemsExist = true;\n            }\n        }\n        if (!this.dataNavigatorWatched) {\n            if (this.navigation && this.navigation !== NAVIGATION_TYPE.NONE) {\n                this.setupDataSource();\n            } else {\n                this.onDataChange(newVal);\n            }\n        } else if (this.navigation && this.navigation !== NAVIGATION_TYPE.NONE) {\n            // If navigation is already setup and datasource is changed, update the datasource on navigation\n            this.dataNavigator.setDataSource(this.datasource);\n        }\n    }\n\n    // All the ListItem's Active state is set to false.\n    private deselectListItems() {\n        this.listItems.forEach(item => item.isActive = false);\n    }\n\n    // Deselect all the ListItems and clear the selecteditem(InOutBound Property model)\n    private clearSelectedItems() {\n        this.deselectListItems();\n        this._items.length = 0;\n        $appDigest();\n    }\n\n    /**\n     * return the ListItemDirective instance by checking the equality of the model.\n     * @param listModel: model to be searched for\n     * @returns ListItem if the model is matched else return null.\n     */\n    private getListItemByModel(listModel): ListItemDirective {\n        return this.listItems.find((listItem) => {\n            let itemObj = listItem.item;\n            if (this.groupby && !has(listModel, '_groupIndex')) {\n                // If groupby is enabled, item contains _groupIndex property which should be excluded while comparing model.\n                itemObj = clone(itemObj);\n                delete itemObj._groupIndex;\n            }\n            if (isEqual(itemObj, listModel)) {\n                return true;\n            }\n        }) || null;\n    }\n\n    private updateSelectedItemsWidgets(statePersistenceTriggered?) {\n        let obj = {}, widgetState;\n        const pageNum = get(this.dataNavigator, 'dn.currentPage') || 1;\n        if (this.getConfiguredState() !== 'none') {\n            // remove previously configured selected items for current page and construct new ones later below.\n            widgetState = this.statePersistence.getWidgetState(this) || {};\n            if (get(widgetState, 'selectedItem')) {\n                // when multiselect is on and an item is selected without pressing CTRL, previously selected items in state should be empty.\n                if (this.multiselect && this.selecteditem.length === 1) {\n                    widgetState.selectedItem = [];\n                } else {\n                    remove(widgetState.selectedItem, function (selectedItem: any) {\n                        return selectedItem.page === pageNum;\n                    });\n                }\n            }\n        }\n        if (this.multiselect) {\n            (this.selectedItemWidgets as Array<WidgetRef>).length = 0;\n        }\n        this.listItems.forEach((item: ListItemDirective, index) => {\n            if (item.isActive) {\n                if (this.multiselect) {\n                    (this.selectedItemWidgets as Array<WidgetRef>).push(item.currentItemWidgets);\n                } else {\n                    this.selectedItemWidgets = item.currentItemWidgets;\n                }\n                obj = {page: pageNum, index: index};\n                if (get(widgetState, 'selectedItem') && this.multiselect) {\n                    if (!some(widgetState.selectedItem, obj)) {\n                        widgetState.selectedItem.push(obj);\n                    }\n                } else {\n                    widgetState.selectedItem = [obj];\n                }\n            }\n        });\n        if (this.getConfiguredState() !== 'none' && !statePersistenceTriggered) {\n            if (unsupportedStatePersistenceTypes.indexOf(this.navigation) < 0) {\n                this.statePersistence.removeWidgetState(this, 'selectedItem');\n                this.statePersistence.setWidgetState(this, {'selectedItem': widgetState.selectedItem});\n            } else {\n                console.warn('Retain State handling on Widget ' + this.name + ' is not supported for current pagination type.');\n            }\n        }\n    }\n\n    /**\n     * Selects the listItem and updates selecteditem property.\n     * If the listItem is already a selected item then deselects the item.\n     * @param {ListItemDirective} $listItem: Item to be selected of deselected.\n     */\n    private toggleListItemSelection($listItem: ListItemDirective, statePersistenceTriggered?) {\n        // item is not allowed to get selected if it is disabled.\n        if ($listItem && !$listItem.disableItem) {\n            let item = $listItem.item;\n            if (this.groupby && has(item, '_groupIndex')) {\n                // If groupby is enabled, item contains _groupIndex property which should be excluded from selecteditem.\n                item = clone(item);\n                delete item._groupIndex;\n            }\n            if ($listItem.isActive) {\n                this._items = pullAllWith(this._items, [item], isEqual);\n                $listItem.isActive = false;\n            } else {\n                // if multiselect is false, clear the selectItem list before adding an item to the selectItem list.\n                if (!this.multiselect) {\n                    this.clearSelectedItems();\n                }\n                this._items.push(item);\n                this.invokeEventCallback('select', {widget: $listItem, $data: item});\n                $listItem.isActive = true;\n            }\n            this.updateSelectedItemsWidgets(statePersistenceTriggered);\n        }\n    }\n\n    /**\n     * Method is Invoked when the model for the List Widget is changed.\n     * @param {QueryList<ListItemDirective>} listItems\n     */\n    private onListRender(listItems: QueryList<ListItemDirective>) {\n        // Added render callback event. This method(onListRender) is calling multiple times so checking isDatachanged flag because this falg is changed whenever new data is rendered.\n        if (this.isDataChanged) {\n            // Whenever dataset is changed, trigger watchers to evaluate listitem bind expressions.\n            $invokeWatchers(true);\n            this.invokeEventCallback('render', {$data: this.fieldDefs});\n        }\n        if (this.isDataChanged && this.getConfiguredState() !== 'none' && listItems.length && this._selectedItemsExist) {\n            const widgetState = this.statePersistence.getWidgetState(this);\n            if (get(widgetState, 'selectedItem')) {\n                this._selectedItemsExist = false;\n                const selectedItemsLength = isArray(this.selecteditem) ? this.selecteditem.length : toNumber(!isEmpty(this.selecteditem));\n                const currentPage = get(this.dataNavigator, 'dn.currentPage') || 1;\n                widgetState.pagination = widgetState.pagination || 1;\n                // to prevent item selection from being triggered more than once\n                if (selectedItemsLength !== widgetState.selectedItem.length && widgetState.pagination === currentPage) {\n                    widgetState.selectedItem.forEach((item) => {\n                        if (item.page === currentPage) {\n                            this.selectItem(item.index, true);\n                        }\n                    });\n                }\n            }\n        }\n        const selectedItems = isArray(this.selecteditem) ? this.selecteditem : [this.selecteditem];\n\n        this.firstSelectedItem = this.lastSelectedItem = null;\n\n        // don't select first item if multi-select is enabled and at least item is already selected in the list.\n        // don't select first item if state information has selected items\n        if (listItems.length && this.selectfirstitem && !(this._items.length && this.multiselect) && this._selectedItemsExist !== false) {\n            const $firstItem: ListItemDirective = listItems.first;\n\n            if (\n                !$firstItem.disableItem &&\n                this.isDataChanged &&\n                // \"infinite scroll\" or \"load on demand\" is enabled and at least one item is selected then dont alter the selected list items.\n                !(\n                    (this.infScroll || this.onDemandLoad) &&\n                    this._items.length\n                )\n            ) {\n                this.clearSelectedItems();\n                this.firstSelectedItem = this.lastSelectedItem = $firstItem;\n                // selecting the first record\n                this.selectItem(0);\n            }\n        } else {\n            this.deselectListItems();\n            selectedItems.forEach(selecteditem => {\n                const listItem: ListItemDirective = this.getListItemByModel(selecteditem);\n                if (listItem) {\n                    listItem.isActive = true;\n                    this.lastSelectedItem = listItem;\n                    // focus the active element\n                    listItem.nativeElement.focus();\n                }\n            });\n        }\n\n        if (this.fieldDefs.length && this.infScroll) {\n            const smoothScrollEl = this.$element.closest('[wmsmoothscroll]');\n            // In case of mobile app when modal exists, and list items height is greater than the modal content provide ccontainer a scrollable height\n            const modalBody = this.$element.closest('.modal-body');\n            const listHt = this.$element.find('ul').height();\n            const modalHt = window.innerHeight - 140;\n            if (isMobile() && modalBody.length && listHt > modalHt) {\n                this.$element.css('height', modalHt + 'px');\n            }\n            setTimeout(() => this.paginationService.bindScrollEvt(this, '> ul', DEBOUNCE_TIMES.PAGINATION_DEBOUNCE_TIME), 500);\n            // this.paginationService.bindScrollEvt(this, '> ul', DEBOUNCE_TIMES.PAGINATION_DEBOUNCE_TIME);\n\n        }\n\n        this.isDataChanged = false;\n    }\n\n    private setupHandlers() {\n        this.listItemsChangesSubscription = this.listItems.changes.subscribe(listItems => {\n            this.onListRender(listItems);\n            this.cdRef.detectChanges();\n        });\n        // handle click event in capturing phase.\n        this.boundClickHandler = ($event) => {\n            let target = $($event.target).closest('.app-list-item');\n            // Recursively find the current list item\n            while (target.get(0) && (target.closest('ul.app-livelist-container').get(0) !== $event.currentTarget)) {\n                target = target.parent().closest('.app-list-item');\n            }\n            this.triggerListItemSelection(target, $event);\n        };\n        const ulElement = this.nativeElement.querySelector('ul.app-livelist-container');\n        if (ulElement) {\n            ulElement.addEventListener('click', this.boundClickHandler, true);\n        }\n    }\n\n    // Triggers on drag start while reordering.\n    private onReorderStart(evt, ui) {\n        ui.placeholder.height(ui.item.height());\n        this.$ulEle.data('oldIndex', ui.item.index());\n    }\n\n    // Triggers during sorting\n    private onSort(evt, ui) {\n        // In case of infinite scroll, when the element doesn't have scroll enabled\n        // on dragging the element to last item's position manually trigger loading of next items\n        if (this.infScroll) {\n            const lastItemOffset = this.$ulEle.find(`[listitemindex=${this.fieldDefs.length - 1}]`).offset();\n            if (lastItemOffset && lastItemOffset.top < ui.offset.top) {\n                this.paginationService.bindScrollEvt(this, '> ul', DEBOUNCE_TIMES.PAGINATION_DEBOUNCE_TIME);\n                this.debouncedFetchNextDatasetOnScroll();\n            }\n        }\n    }\n\n    // Triggers after the sorting.\n    private onUpdate(evt, ui, presentIndex?) {\n        const data = this.fieldDefs;\n        // If ui is not present then it is called from drag and drop using keyboard\n        const newIndex = ui === undefined ? presentIndex : ui.item.index();\n        const oldIndex = this.$ulEle.data('oldIndex');\n\n        const minIndex = min([newIndex, oldIndex]);\n        const maxIndex = max([newIndex, oldIndex]);\n\n        const draggedItem = pullAt(data, oldIndex)[0];\n        // Modify the data list only if we find a draggedItem\n        if (draggedItem) {\n            if (this.getConfiguredState() !== 'none') {\n                this.statePersistence.removeWidgetState(this, 'selectedItem');\n            }\n\n            this.reorderProps.minIndex = min([minIndex, this.reorderProps.minIndex]);\n            this.reorderProps.maxIndex = max([maxIndex, this.reorderProps.maxIndex]);\n\n            data.splice(newIndex, 0, draggedItem);\n\n            this.cdRef.markForCheck();\n            this.cdRef.detectChanges();\n            const $changedItem = {\n                oldIndex: oldIndex,\n                newIndex: newIndex,\n                item: data[newIndex]\n            };\n            this.invokeEventCallback('reorder', {$event: evt, $data: data, $changedItem});\n            this.$ulEle.removeData('oldIndex');\n        }\n    }\n\n    // configures reordering the list items.\n    private configureDnD() {\n        let appendTo;\n        const modalEl = $(document).find('.modal');\n        if (this.getAttr('height')) { // when height is applied to the list, append should be the ul's parent as scroll is applied to the parent\n            appendTo = 'parent';\n        } else if (modalEl.length) { // In case of dialog, appendTo should be the modal ele\n            appendTo = modalEl[modalEl.length - 1];\n        } else { // As default append to should be body\n            appendTo = 'body';\n        }\n\n        const options = {\n            appendTo: appendTo,\n        };\n\n        const $el = $(this.nativeElement);\n        this.$ulEle = $el.find('.app-livelist-container');\n\n        configureDnD(this.$ulEle, options, this.onReorderStart.bind(this), this.onUpdate.bind(this), this.onSort.bind(this));\n\n        this.$ulEle.droppable({'accept': '.app-list-item'});\n\n\n\n    }\n\n    // returns true if the selection limit is reached.\n    private checkSelectionLimit(count: number) {\n        return (!this.selectionlimit || count < this.selectionlimit);\n    }\n\n    // returns listitem reference by index value.\n    private getListItemByIndex(index: number): ListItemDirective {\n        return this.listItems.toArray()[index];\n    }\n\n    /**\n     * return index of an (listItemDirective) in the listItem\n     * @param {ListItemDirective} item\n     * @returns {number}\n     */\n    private getListItemIndex(item: ListItemDirective) {\n        return this.listItems.toArray().indexOf(item);\n    }\n\n    /**\n     *  Returns ListItem Reference based on the input provided.\n     * @param val: index | model of the list item.\n     * @returns {ListItemDirective}\n     */\n    private getItemRefByIndexOrModel(val: any): ListItemDirective {\n        let listItem: ListItemDirective;\n        if (isNumber(val)) {\n            listItem = this.getListItemByIndex(val);\n        } else {\n            listItem = this.getListItemByModel(val);\n        }\n        return listItem;\n    }\n\n    private beforePaginationChange($event, $index) {\n        this.invokeEventCallback('paginationchange', {$event, $index});\n    }\n\n    trackByFn($index: number) {\n        return $index; // Return a unique identifier for each item\n    }\n\n    // Invoke the datasource variable by default when pulltorefresh event is not specified.\n    private subscribeToPullToRefresh() {\n        this._listenerDestroyers.push(this.app.subscribe('pulltorefresh', () => {\n            if (this.datasource && this.datasource.listRecords) {\n                this.datasource.listRecords();\n            }\n        }));\n    }\n\n    private boundAddItemHandler: (event: Event) => void;\n\n    private setUpCUDHandlers() {\n        const $addItem = document.getElementsByClassName(\"add-list-item\")[0];\n        if ($addItem) {\n            // MEMORY LEAK FIX: Store bound handler for cleanup\n            this.boundAddItemHandler = (evt: Event) => {\n                this.create();\n            };\n            // Triggered on click of add action\n            $addItem.addEventListener('click', this.boundAddItemHandler);\n        }\n    }\n\n    private _readItemAttrsFromHost() {\n        const raw = this.nativeElement.getAttribute(\"itemattrs\");\n        if (!raw) {\n            this.itemAttrsMap = {};\n            return;\n        }\n        try {\n            this.itemAttrsMap = JSON.parse(raw);\n        } catch (e) {\n            console.warn(\"list.component: failed to parse itemattrs JSON\", e, raw);\n            this.itemAttrsMap = {};\n        }\n    }\n}\n","@if (title || subheading || iconclass) {\n  <div class=\"panel-heading\">\n    <h3 class=\"panel-title\">\n      <div class=\"pull-left\">\n        <i class=\"app-icon panel-icon {{iconclass}}\" aria-hidden=\"true\" [hidden]=\"!iconclass\"></i>\n      </div>\n      <div class=\"pull-left\">\n        <div class=\"heading\" [innerHTML]=\"title\"></div>\n        <div class=\"description\" [innerHTML]=\"subheading\"></div>\n      </div>\n    </h3>\n  </div>\n}\n\n@if (navigation === 'Inline' && !noDataFound) {\n  <div class=\"app-datanavigator\" [attr.aria-disabled]=\"dataNavigator.isDisablePrevious\" aria-label=\"Page navigation\">\n    <ul class=\"pager\">\n      <li class=\"previous\" [ngClass]=\"{'disabled': (dataNavigator ? dataNavigator.isDisablePrevious : true)}\">\n        <a href=\"javascript:void(0);\" (click)=\"dataNavigator.navigatePage('prev', $event)\"\n          [attr.aria-disabled]=\"dataNavigator.isDisablePrevious\">\n          <i class=\"wi wi-chevron-left\" aria-hidden=\"true\"></i>\n          <span class=\"sr-only\">Go to Previous page {{dataNavigator.isDisablePrevious ? ', Disabled' : ''}}</span>\n        </a>\n      </li>\n    </ul>\n  </div>\n}\n@if (navigation === 'Inline' && !noDataFound) {\n  <div aria-live=\"polite\" aria-atomic=\"true\" class=\"sr-only\"> {{'Page ' + dataNavigator.dn.currentPage + ' of ' + dataNavigator.pageCount }}</div>\n}\n\n<div>\n  @if (enablereorder) {\n    <div id={{titleId}} class=\"sr-only\">\n      Press space bar to toggle drag drop mode, use arrow keys to move selected elements.\n    </div>\n  }\n\n  @if (listItems && enablereorder && currentIndex) {\n    <div aria-live=\"assertive\" class=\"sr-only\" >\n      {{ariaText + currentIndex + ' of ' +  listItems.length}}\n    </div>\n  }\n</div>\n\n<ul [attr.tabindex]=\"tabindex\"  class=\"list-group app-livelist-container clearfix {{direction === 'horizontal' ? 'app-horizontal-list': ''}} {{listclass}}\" role=\"list\"\n  [class.list-group-autolayout]=\"hasAutolayout\"\n  (keydown.enter)=\"handleKeyDown($event, 'select')\"\n\n  (keydown.space)=\"handleKeyDown($event, 'space')\"\n\n  (keydown.arrowup)=\"handleKeyDown($event, 'focusPrev')\"\n  (keydown.arrowdown)=\"handleKeyDown($event, 'focusNext')\"\n  (keydown.arrowleft)=\"handleKeyDown($event, 'focusPrev')\"\n  (keydown.arrowright)=\"handleKeyDown($event, 'focusNext')\"\n\n  (keydown.shift.arrowup)=\"handleKeyDown($event, 'selectPrev')\"\n  (keydown.shift.arrowdown)=\"handleKeyDown($event, 'selectNext')\"\n  (keydown.shift.arrowleft)=\"handleKeyDown($event, 'selectPrev')\"\n  (keydown.shift.arrowright)=\"handleKeyDown($event, 'selectNext')\"\n  [hidden]=\"noDataFound && !variableInflight\"\n  >\n  @if (!groupby) {\n    @for (item of fieldDefs; track item) {\n      <li class=\"app-list-item {{direction === 'horizontal' ? '' : itemsPerRowClass}}\" [ngClass]=\"listItemRef.itemClass\"\n        [wmListItem]=\"item\"\n        #listItemRef=\"listItemRef\"\n        [attr.tabindex]=\"tabindex\"\n        role=\"listitem\">\n        <ng-container [ngTemplateOutlet]=\"listTemplate\"\n          [ngTemplateOutletInjector]=\"createCustomInjector('falt_' + listItemRef.trackId, {item: item, $index: $index, itemRef: listItemRef, $first: $first, $last: $last, currentItemWidgets: listItemRef.currentItemWidgets})\"\n        [ngTemplateOutletContext]=\"{item: item, $index: $index, itemRef: listItemRef, $first: $first, $last: $last, currentItemWidgets: listItemRef.currentItemWidgets}\"></ng-container>\n      </li>\n    }\n  } @else {\n    @for (groupObj of groupedData; track groupObj; let groupIndex = $index) {\n      <li class=\"app-list-item-group clearfix\">\n        <ul [attr.tabindex]=\"tabindex\" class=\"list-group item-group\" [ngClass]=\"listclass\" [class.list-group-autolayout]=\"hasAutolayout\">\n          <li class=\"app-list-item-header list-item list-group-header\" (click)=\"handleHeaderClick($event)\" [ngClass]=\"{'collapsible-content': collapsible}\">\n            <h4>{{groupObj.key}}\n              <div class=\"header-action\">\n                @if (collapsible) {\n                  <i class=\"app-icon wi action wi-chevron-up\"></i>\n                }\n                @if (showcount) {\n                  <span class=\"label label-default\">{{groupObj.data.length}}</span>\n                }\n              </div>\n            </h4>\n          </li>\n          <li class=\"list-group-container\">\n            <ul class=\"list-group clearfix {{direction === 'horizontal' ? 'app-horizontal-list': ''}}\" [class.list-group-autolayout]=\"hasAutolayout\">\n              @for (item of groupObj.data; track trackByFn($index, item)) {\n                <li [attr.tabindex]=\"tabindex\"\n                  class=\"app-list-item group-list-item {{itemsPerRowClass}}\"\n                  [ngClass]=\"listItemRef.itemClass\"\n                  [wmListItem]=\"item\" #listItemRef=\"listItemRef\">\n                  <ng-container [ngTemplateOutlet]=\"listTemplate\"\n                    [ngTemplateOutletInjector]=\"createCustomInjector('group_' + listItemRef.trackId, {item: item, $index: $index, itemRef: listItemRef, $first: $first, $last: $last, currentItemWidgets: listItemRef.currentItemWidgets})\"\n                  [ngTemplateOutletContext]=\"{item: item, $index: $index, itemRef: listItemRef, $first: $first, $last: $last, currentItemWidgets: listItemRef.currentItemWidgets}\"></ng-container>\n                </li>\n              }\n            </ul>\n          </li>\n        </ul>\n      </li>\n    }\n  }\n  <ng-container [ngTemplateOutlet]=\"listLeftActionTemplate\"></ng-container>\n  <ng-container [ngTemplateOutlet]=\"listRightActionTemplate\"></ng-container>\n</ul>\n\n@if (noDataFound && !variableInflight) {\n  <div class=\"no-data-msg\" [textContent]=\"nodatamessage\"></div>\n}\n\n@if (variableInflight && !pulltorefresh) {\n  <div class=\"loading-data-msg\">\n    <span>\n      <i class=\"app-icon panel-icon fa-spin\" aria-hidden=\"true\" [ngClass]=\"loadingicon\"></i>\n      <span class=\"sr-only\">Loading</span>\n      <span class=\"loading-text\" [textContent]=\"loadingdatamsg\"></span>\n    </span>\n  </div>\n}\n\n@if (navigation === 'Inline' && !noDataFound) {\n  <div class=\"app-datanavigator\" [attr.aria-disabled]=\"dataNavigator.isDisableNext\">\n    <ul class=\"pager\">\n      <li class=\"next\" [ngClass]=\"{'disabled': (dataNavigator ? dataNavigator.isDisableNext  : true)}\">\n        <a href=\"javascript:void(0);\" (click)=\"dataNavigator.navigatePage('next', $event)\"\n          [attr.aria-disabled]=\"dataNavigator.isDisableNext\">\n          <i class=\"wi wi-chevron-right\" aria-hidden=\"true\"></i>\n          <span class=\"sr-only\">Go to Next page {{dataNavigator.isDisableNext ? ', Disabled' : ''}}</span>\n        </a>\n      </li>\n    </ul>\n  </div>\n}\n\n@if (navigation !== 'None') {\n  <div class=\"panel-footer\" [hidden]=\"!showNavigation || (onDemandLoad && dataNavigator.isDisableNext) || (dataNavigator?.dataSize <= pagesize && !allowpagesizechange) || (!dataNavigator.dataSize && !dataNavigator.datasource?.pagination?.next)\">\n    <nav wmPagination\n      navigationalign.bind=\"navigationalign\"\n      navigation.bind=\"navControls\"\n      showrecordcount.bind=\"showrecordcount\"\n      maxsize.bind=\"maxsize\"\n      boundarylinks.bind=\"boundarylinks\"\n      forceellipses.bind=\"forceellipses\"\n      directionlinks.bind=\"directionlinks\"\n      show.bind=\"!onDemandLoad\"\n      paginationchange.event=\"beforePaginationChange($event, $index)\"\n    ></nav>\n    @if (onDemandLoad) {\n      <a href=\"javascript:void(0);\"\n        (click)=\"dataNavigator.navigatePage('next', $event)\"\n        class=\"app-button btn btn-block\"\n        [ngClass]=\"paginationclass\"\n        [textContent]=\"ondemandmessage\"\n      ></a>\n    }\n  </div>\n}\n\n<!--This template will be displayed when groupby is specified-->\n"]}