@pepperi-addons/ngx-lib 0.5.0-ng15.3 → 0.5.0-ng16.2

package/esm2022/list/list.component.mjs

@@ -0,0 +1,1394 @@
+import { Component, Input, Output, EventEmitter, ViewChild, ElementRef, } from '@angular/core';
+import { PepScreenSizeType, FIELD_TYPE, } from '@pepperi-addons/ngx-lib';
+import { VirtualScrollerComponent } from './virtual-scroller';
+import { PepSelectionData, DEFAULT_PAGE_SIZE, } from './list.model';
+import * as tween from '@tweenjs/tween.js';
+import * as i0 from "@angular/core";
+import * as i1 from "@pepperi-addons/ngx-lib";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/checkbox";
+import * as i4 from "@angular/material/radio";
+import * as i5 from "@angular/material/icon";
+import * as i6 from "@pepperi-addons/ngx-lib/icon";
+import * as i7 from "@pepperi-addons/ngx-lib/form";
+import * as i8 from "./virtual-scroller";
+import * as i9 from "./list-pager.component";
+import * as i10 from "@ngx-translate/core";
+export class PepListComponent {
+    hostElement;
+    layoutService;
+    sessionService;
+    cd;
+    renderer;
+    zone;
+    listContainerResizableElementRef;
+    static TOP_ITEMS_DEFAULT = 100;
+    static TOP_ITEMS_TABLE = 100;
+    static TOP_ITEMS_THUMBNAILS = 100;
+    static TOP_ITEMS_ARRAY = 2500;
+    static SELECTED_ITEMS_STATE_KEY = 'SelectedItems';
+    static UN_SELECTED_ITEMS_STATE_KEY = 'UnSelectedItems';
+    static ALL_SELECTED_STATE_KEY = 'AllSelected';
+    static SORT_BY_STATE_KEY = 'SortBy';
+    static ASCENDING_STATE_KEY = 'IsAscending';
+    static MINIMUM_COLUMN_WIDTH = 72;
+    set sorting(value) {
+        this.sortBy = value?.sortBy || '';
+        this.isAsc = value?.sortBy.length > 0 ? value.isAsc : this.isAsc;
+    }
+    get sorting() {
+        return {
+            sortBy: this.sortBy,
+            isAsc: this.isAsc
+        };
+    }
+    cacheSize = -1;
+    noDataFoundMsg = null;
+    selectionTypeForActions = 'multi';
+    showCardSelection = false;
+    hideAllSelectionInMulti = false;
+    cardSize = 'md';
+    tableViewType = 'regular';
+    _viewType = '';
+    set viewType(value) {
+        this._viewType = value;
+        this.isTable = value === 'table';
+    }
+    get viewType() {
+        return this._viewType;
+    }
+    firstFieldAsLink = false;
+    supportSorting = true;
+    supportSortingFields = undefined;
+    supportResizing = true;
+    _parentScroll = null;
+    set parentScroll(value) {
+        this._parentScroll = value;
+    }
+    get parentScroll() {
+        return this._parentScroll;
+    }
+    disabled = false;
+    _lockEvents = false;
+    set lockEvents(value) {
+        this._lockEvents = value;
+        if (this._lockEvents) {
+            this.renderer.addClass(this.hostElement.nativeElement, 'lock-events');
+        }
+        else {
+            this.renderer.removeClass(this.hostElement.nativeElement, 'lock-events');
+        }
+    }
+    get lockEvents() {
+        return this._lockEvents;
+    }
+    lockItemInnerEvents = false;
+    printMode = false;
+    isReport = false;
+    zebraStripes = false;
+    totalsRow = [];
+    pagerType = 'scroll';
+    pageSize = DEFAULT_PAGE_SIZE;
+    pageIndex = 0;
+    // @Input() startIndex = 0;
+    bufferAmount = 0;
+    scrollAnimationTime = 500;
+    scrollDebounceTime = 0;
+    scrollThrottlingTime = 0;
+    SEPARATOR = ',';
+    _useAsWebComponent = false;
+    set useAsWebComponent(value) {
+        this._useAsWebComponent = value;
+        if (value) {
+            this.exportFunctionsOnHostElement();
+        }
+    }
+    get useAsWebComponent() {
+        return this._useAsWebComponent;
+    }
+    itemClick = new EventEmitter();
+    fieldClick = new EventEmitter();
+    valueChange = new EventEmitter();
+    sortingChange = new EventEmitter();
+    selectedItemsChange = new EventEmitter();
+    selectedItemChange = new EventEmitter();
+    selectAllClick = new EventEmitter();
+    // @Output()
+    // singleActionClick: EventEmitter<any> = new EventEmitter<any>();
+    listLoad = new EventEmitter();
+    loadItems = new EventEmitter();
+    loadPage = new EventEmitter();
+    startIndexChange = new EventEmitter();
+    virtualScroller;
+    selectAllCB;
+    _layout = null;
+    get layout() {
+        return this._layout;
+    }
+    totalRows = -1;
+    isTable = false;
+    hasColumnWidthOfTypePercentage = true;
+    _items = null;
+    get items() {
+        return this._items;
+    }
+    itemsCounter = 0;
+    currentPageItems;
+    isAllSelected = false;
+    selectedItems = new Map();
+    unSelectedItems = new Map();
+    currentTween;
+    selectedItemId = '';
+    hoveredItemId = '';
+    containerWidth = 0;
+    tableScrollWidth = 0;
+    _loadingItemsFromApi = false;
+    get loadingItemsFromApi() {
+        return this._loadingItemsFromApi;
+    }
+    screenSize;
+    deviceHasMouse = false;
+    // For resize
+    pressedColumn = '';
+    pressedColumnIndex = -1;
+    startX = 0;
+    startWidth = 0;
+    tableStartWidth = 0;
+    lastColumnsWidth = [];
+    // For sorting
+    isAsc = false;
+    sortBy = '';
+    isUserSelected = false;
+    checkForChanges = null;
+    calculatedObjectHeight = 'auto';
+    constructor(hostElement, layoutService, sessionService, cd, renderer, zone) {
+        this.hostElement = hostElement;
+        this.layoutService = layoutService;
+        this.sessionService = sessionService;
+        this.cd = cd;
+        this.renderer = renderer;
+        this.zone = zone;
+        // this.nativeWindow = window;
+        this.layoutService.onResize$.subscribe((size) => {
+            this.screenSize = size;
+        });
+        this.layoutService.onMouseOver$.subscribe((deviceHasMouse) => {
+            this.deviceHasMouse = deviceHasMouse;
+        });
+    }
+    ngOnInit() {
+        this.containerWidth = 0;
+        this.deviceHasMouse = this.layoutService.getDeviceHasMouse();
+    }
+    ngOnChanges(changes) {
+        if (this.containerWidth <= 0) {
+            this.setContainerWidth();
+        }
+    }
+    ngOnDestroy() {
+        // if (this.valueChange) {
+        //     this.valueChange.unsubscribe();
+        // }
+        // if (this.loadItems) {
+        //     this.loadItems.unsubscribe();
+        // }
+        // if (this.loadPage) {
+        //     this.loadPage.unsubscribe();
+        // }
+        // if (this.sortingChange) {
+        //     this.sortingChange.unsubscribe();
+        // }
+        // if (this.fieldClick) {
+        //     this.fieldClick.unsubscribe();
+        // }
+        // if (this.itemClick) {
+        //     this.itemClick.unsubscribe();
+        // }
+        // if (this.listLoad) {
+        //     this.listLoad.unsubscribe();
+        // }
+        this.saveSortingToSession();
+    }
+    getCachedItemsNumber() {
+        return this.cacheSize >= 0 ? this.cacheSize : PepListComponent.TOP_ITEMS_ARRAY;
+    }
+    getScrollingElement() {
+        return this.parentScroll ? this.parentScroll : this.virtualScroller?.contentElementRef.nativeElement.parentElement;
+    }
+    scrollToTop(animate = true) {
+        const scrollingElement = this.getScrollingElement();
+        if (scrollingElement) {
+            const scrollTop = 0;
+            // totally disable animate
+            if (!animate || this.scrollAnimationTime === 0) {
+                if (scrollingElement instanceof Window) {
+                    window.scrollTo(0, scrollTop);
+                }
+                else {
+                    scrollingElement.scrollTop = scrollTop;
+                }
+            }
+            else {
+                let animationRequest;
+                const isWindow = scrollingElement instanceof Window;
+                const currentScrollTop = scrollingElement instanceof Window
+                    ? window.pageYOffset
+                    : scrollingElement.scrollTop;
+                if (this.currentTween !== undefined) {
+                    this.currentTween.stop();
+                }
+                this.currentTween = new tween.Tween({ scrollTop: currentScrollTop })
+                    .to({ scrollTop }, this.scrollAnimationTime)
+                    .easing(tween.Easing.Quadratic.Out)
+                    .onUpdate((data) => {
+                    if (isNaN(data.scrollTop)) {
+                        return;
+                    }
+                    if (isWindow) {
+                        window.scrollTo(0, data.scrollTop);
+                    }
+                    else {
+                        this.renderer.setProperty(scrollingElement, 'scrollTop', data.scrollTop);
+                    }
+                })
+                    .onStop(() => {
+                    cancelAnimationFrame(animationRequest);
+                })
+                    .start();
+                const animate = (time) => {
+                    this.currentTween.update(time);
+                    if (this.currentTween._object.scrollTop !== scrollTop) {
+                        this.zone.runOutsideAngular(() => {
+                            animationRequest = requestAnimationFrame(animate);
+                        });
+                    }
+                };
+                animate();
+            }
+        }
+    }
+    getSelectionCheckBoxWidth() {
+        return this.selectionTypeForActions === 'multi' ? 44 : (this.selectionTypeForActions === 'single' ? 44 : 0);
+    }
+    setContainerWidth() {
+        if (!this.hostElement.nativeElement.parentElement) {
+            return;
+        }
+        const rowHeight = 40; // the table row height (2.5rem * 16font-size).
+        const style = getComputedStyle(this.hostElement.nativeElement.parentElement);
+        // The container-fluid class padding left + right + border
+        const containerFluidSpacing = parseInt(style.paddingLeft, 10) + parseInt(style.paddingRight, 10);
+        const parentContainer = this.hostElement.nativeElement.parentElement.parentElement > 0
+            ? this.hostElement.nativeElement.parentElement.parentElement
+            : this.hostElement.nativeElement.parentElement;
+        // Calculate if vertical scroll should appear, if so set the scroll width. (this.totalRows + 1) + 1 is for the header row.
+        this.tableScrollWidth = parentContainer.clientHeight < rowHeight * (this.totalRows + 1)
+            ? this.layoutService.getScrollbarWidth()
+            : 0;
+        // The selectionCheckBoxWidth width + containerFluidSpacing + this.tableScrollWidth.
+        const rowHeaderWidthToSub = containerFluidSpacing + this.getSelectionCheckBoxWidth() + this.tableScrollWidth;
+        this.containerWidth = parentContainer.offsetWidth - rowHeaderWidthToSub;
+    }
+    saveSortingToSession() {
+        this.sessionService.setObject(PepListComponent.SORT_BY_STATE_KEY, this.sortBy);
+        this.sessionService.setObject(PepListComponent.ASCENDING_STATE_KEY, this.isAsc);
+    }
+    getTopItems() {
+        return this.isTable
+            ? PepListComponent.TOP_ITEMS_TABLE
+            : PepListComponent.TOP_ITEMS_THUMBNAILS;
+    }
+    disableScroll(disable) {
+        if (disable) {
+            this.renderer.addClass(this.hostElement.nativeElement.parentElement, 'lock-events');
+        }
+        else {
+            this.renderer.removeClass(this.hostElement.nativeElement.parentElement, 'lock-events');
+        }
+    }
+    toggleLoadingItemsFropApi(loadingItemsFromApi) {
+        this._loadingItemsFromApi = loadingItemsFromApi;
+        // this.disableScroll(loadingItemsFromApi);
+    }
+    updateCurrentPageItems(startIndex, endIndex) {
+        this.currentPageItems = this.items.slice(startIndex, endIndex);
+    }
+    setSelectionItems(itemId, uniqItemId, isChecked) {
+        // Set selected item checkbox
+        if (this.isAllSelected) {
+            if (isChecked) {
+                this.unSelectedItems.delete(itemId);
+                this.selectedItems.set(itemId, uniqItemId);
+            }
+            else {
+                this.selectedItems.delete(itemId);
+                this.unSelectedItems.set(itemId, uniqItemId);
+            }
+        }
+        else {
+            if (isChecked) {
+                this.unSelectedItems.delete(itemId);
+                this.selectedItems.set(itemId, uniqItemId);
+            }
+            else {
+                this.selectedItems.delete(itemId);
+                this.unSelectedItems.set(itemId, uniqItemId);
+            }
+        }
+    }
+    getUniqItemId(itemId, itemType = '') {
+        return itemId + this.SEPARATOR + itemType;
+    }
+    setLayout() {
+        if (this.totalRows === 0 ||
+            !this._layout ||
+            !this._layout.ControlFields ||
+            this._layout.ControlFields.length === 0) {
+            return;
+        }
+        this._layout.ControlFields.forEach((cf) => {
+            if (cf.ColumnWidth === 0) {
+                cf.ColumnWidth = 10;
+            }
+            if (this.isTable &&
+                (cf.FieldType === FIELD_TYPE.Image ||
+                    // cf.FieldType === FIELD_TYPE.Indicators || ???
+                    cf.FieldType === FIELD_TYPE.Signature ||
+                    cf.FieldType === FIELD_TYPE.NumberIntegerQuantitySelector ||
+                    cf.FieldType === FIELD_TYPE.NumberRealQuantitySelector ||
+                    cf.FieldType === FIELD_TYPE.NumberIntegerForMatrix ||
+                    cf.FieldType === FIELD_TYPE.NumberRealForMatrix ||
+                    cf.FieldType === FIELD_TYPE.Package ||
+                    cf.ApiName === 'UnitsQuantity' ||
+                    cf.ApiName === 'QuantitySelector')) {
+                cf.Layout.XAlignment = 3;
+            }
+        });
+        if (!this.cd['destroyed']) {
+            this.cd.detectChanges();
+        }
+        // Set the container width.
+        if (this.containerWidth <= 0) {
+            this.setContainerWidth();
+        }
+        const isLastColumnsWidthSet = this.setLastColumnsWidth();
+        // Set the layout only if the last columns width couldn't set.
+        if (!isLastColumnsWidthSet) {
+            this.calcColumnsWidth();
+        }
+        this.checkForChanges = new Date().getTime();
+    }
+    setLastColumnsWidth() {
+        let res = false;
+        let totalCalcColsWidth = 0;
+        let widthToSet = 'inherit';
+        if (this.lastColumnsWidth.length > 0) {
+            // Check if this is the same UI control for table.
+            if (this.lastColumnsWidth.length === this._layout.ControlFields.length) {
+                let uiControlsAreTheSame = true;
+                for (let index = 0; index < this._layout.ControlFields.length; index++) {
+                    const uiControlField = this._layout.ControlFields[index];
+                    if (uiControlField.ApiName !== this.lastColumnsWidth[index].columnAPIName) {
+                        uiControlsAreTheSame = false;
+                        break;
+                    }
+                }
+                if (uiControlsAreTheSame) {
+                    for (let index = 0; index < this._layout.ControlFields.length; index++) {
+                        const uiControlField = this._layout.ControlFields[index];
+                        uiControlField.calcColumnWidth = this.lastColumnsWidth[index].calcColumnWidth;
+                        uiControlField.calcTitleColumnWidthString = this.lastColumnsWidth[index].calcTitleColumnWidthString;
+                        uiControlField.calcColumnWidthString = this.lastColumnsWidth[index].calcColumnWidthString;
+                        totalCalcColsWidth += this.lastColumnsWidth[index].calcColumnWidth;
+                    }
+                    widthToSet = (totalCalcColsWidth + this.getSelectionCheckBoxWidth()) + 'px';
+                    console.log(`setLastColumnsWidth -> widthToSet: ${widthToSet} *** totalCalcColsWidth: ${totalCalcColsWidth}`);
+                    this.setColumnsWidth(widthToSet);
+                    res = true;
+                }
+            }
+        }
+        return res;
+    }
+    setVirtualScrollWidth(widthToSet) {
+        if (this.virtualScroller) {
+            this.renderer.setStyle(this.virtualScroller.contentElementRef.nativeElement, 'width', widthToSet === 'inherit' ? '100%' : widthToSet);
+        }
+    }
+    setColumnsWidth(widthToSet) {
+        // this.renderer.setStyle(
+        //     this.hostElement.nativeElement,
+        //     'width',
+        //     widthToSet
+        // );
+        this.renderer.setStyle(this.listContainerResizableElementRef.nativeElement, 'width', widthToSet);
+        if (this.isTable) {
+            this.setVirtualScrollWidth(widthToSet);
+        }
+        else {
+            // Do this only after UI is change cause the property isTable is Input and can refresh after this thread.
+            setTimeout(() => {
+                this.setVirtualScrollWidth(widthToSet);
+            }, 0);
+        }
+    }
+    calcColumnsWidth() {
+        const fixedMultiple = 3.78; // for converting em to pixel.
+        const length = this._layout.ControlFields.length;
+        // Is table AND there is at least one column of width type of percentage.
+        if (this.isTable) {
+            if (this._layout && this._layout.ControlFields) {
+                this.hasColumnWidthOfTypePercentage =
+                    this._layout.ControlFields.filter((cf) => cf.ColumnWidthType === 1).length === 0;
+            }
+        }
+        // If the columns size is fixed and the total is small then the container change it to percentage.
+        if (!this.hasColumnWidthOfTypePercentage) {
+            const totalFixedColsWidth = this._layout.ControlFields.map((cf) => cf.ColumnWidth * fixedMultiple).reduce((sum, current) => sum + current);
+            if (window.innerWidth > totalFixedColsWidth) {
+                this.hasColumnWidthOfTypePercentage = true;
+            }
+        }
+        let totalCalcColsWidth = 0;
+        let widthToSet = 'inherit';
+        // Calc by percentage
+        if (this.hasColumnWidthOfTypePercentage) {
+            const totalColsWidth = this._layout.ControlFields.map((cf) => cf.ColumnWidth).reduce((sum, current) => sum + current);
+            for (let index = 0; index < length; index++) {
+                const uiControlField = this._layout.ControlFields[index];
+                const calcColumnWidthPercentage = (100 / totalColsWidth) * uiControlField.ColumnWidth;
+                uiControlField.calcColumnWidth = Math.floor((this.containerWidth * calcColumnWidthPercentage) / 100);
+                if (index === length - 1) {
+                    uiControlField.calcTitleColumnWidthString = uiControlField.calcColumnWidthString = 'calc(100% - ' + totalCalcColsWidth + 'px)'; // For 100%
+                }
+                else {
+                    uiControlField.calcTitleColumnWidthString = uiControlField.calcColumnWidthString = uiControlField.calcColumnWidth + 'px';
+                    totalCalcColsWidth += uiControlField.calcColumnWidth;
+                }
+            }
+        }
+        else {
+            for (let index = 0; index < length; index++) {
+                const uiControlField = this._layout
+                    .ControlFields[index];
+                const currentFixedWidth = Math.floor(uiControlField.ColumnWidth * fixedMultiple);
+                if (index === length - 1) {
+                    uiControlField.calcTitleColumnWidthString = uiControlField.calcColumnWidthString = currentFixedWidth + 'px';
+                }
+                else {
+                    uiControlField.calcTitleColumnWidthString = uiControlField.calcColumnWidthString = currentFixedWidth + 'px';
+                }
+                totalCalcColsWidth += currentFixedWidth;
+            }
+            widthToSet = (totalCalcColsWidth + this.getSelectionCheckBoxWidth()) + 'px';
+        }
+        console.log(`calcColumnsWidth -> widthToSet: ${widthToSet} *** totalCalcColsWidth: ${totalCalcColsWidth}`);
+        this.setColumnsWidth(widthToSet);
+    }
+    calcObjectHeight() {
+        setTimeout(() => {
+            if (this.virtualScroller) {
+                const content = this.virtualScroller.getContent();
+                console.log(`content.children.length: ${content.children.length}`);
+                if (content.children.length > 0) {
+                    const rect = this.virtualScroller.getElementSize(content.children[0]);
+                    this.calculatedObjectHeight = rect.height + 'px';
+                    console.log(`this.calculatedObjectHeight: ${this.calculatedObjectHeight}`);
+                }
+            }
+            this.disableScroll(false);
+        }, 1000);
+    }
+    initResizeData() {
+        this.startX = 0;
+        this.startWidth = 0;
+        this.tableStartWidth = 0;
+        this.pressedColumn = '';
+        this.pressedColumnIndex = -1;
+    }
+    getParent(el, parentSelector) {
+        // If no parentSelector defined will bubble up all the way to *document*
+        if (parentSelector === undefined) {
+            parentSelector = document;
+        }
+        const parent = [];
+        let p = el.parentNode;
+        while (p &&
+            p.className !== '' &&
+            p.className.indexOf(parentSelector) === -1 &&
+            parentSelector !== document) {
+            const o = p;
+            p = o.parentNode;
+        }
+        if (p.className.indexOf(parentSelector) > -1) {
+            parent.push(p); // Push that parentSelector you wanted to stop at
+        }
+        return parent;
+    }
+    cleanItems() {
+        this.itemsCounter = 0;
+        this._items =
+            this.totalRows > 0 ? Array(this.totalRows) : [];
+        this.currentPageItems = [];
+        this.calculatedObjectHeight = 'auto';
+    }
+    initVariablesFromSession(items) {
+        const selectedItemsObject = this.sessionService.getObject(PepListComponent.SELECTED_ITEMS_STATE_KEY);
+        const selectedItemsFromMap = selectedItemsObject && selectedItemsObject.length > 0
+            ? new Map(selectedItemsObject)
+            : null;
+        if (selectedItemsFromMap != null &&
+            typeof selectedItemsFromMap.size !== 'undefined' &&
+            selectedItemsFromMap.size > 0) {
+            this.selectedItems = selectedItemsFromMap;
+            this.sessionService.removeObject(PepListComponent.SELECTED_ITEMS_STATE_KEY);
+        }
+        else {
+            this.selectedItems.clear();
+        }
+        const unSelectedItemsObject = this.sessionService.getObject(PepListComponent.UN_SELECTED_ITEMS_STATE_KEY);
+        const unSelectedItemsMap = unSelectedItemsObject && unSelectedItemsObject.length > 0
+            ? new Map(unSelectedItemsObject)
+            : null;
+        if (unSelectedItemsMap != null &&
+            typeof unSelectedItemsMap.size !== 'undefined' &&
+            unSelectedItemsMap.size > 0) {
+            this.unSelectedItems = unSelectedItemsMap;
+            this.sessionService.removeObject(PepListComponent.UN_SELECTED_ITEMS_STATE_KEY);
+        }
+        else {
+            this.unSelectedItems.clear();
+        }
+        const isAllSelected = this.sessionService.getObject(PepListComponent.ALL_SELECTED_STATE_KEY);
+        if (isAllSelected != null) {
+            // Comment this in version 0.4.2-beta.103, I don't know why we need this (&& this.getIsAllSelected(items))
+            // this.isAllSelected = isAllSelected && this.getIsAllSelected(items);
+            this.isAllSelected = isAllSelected;
+            this.sessionService.removeObject(PepListComponent.ALL_SELECTED_STATE_KEY);
+        }
+        else {
+            this.isAllSelected = false;
+        }
+        const sortBy = this.sessionService.getObject(PepListComponent.SORT_BY_STATE_KEY);
+        if (sortBy && sortBy !== '') {
+            this.sortBy = sortBy;
+            this.sessionService.removeObject(PepListComponent.SORT_BY_STATE_KEY);
+        }
+        else {
+            this.sortBy = '';
+        }
+        const isAsc = this.sessionService.getObject(PepListComponent.ASCENDING_STATE_KEY);
+        if (isAsc != null) {
+            this.isAsc = isAsc;
+            this.sessionService.removeObject(PepListComponent.ASCENDING_STATE_KEY);
+        }
+        else {
+            this.isAsc = true;
+        }
+    }
+    getIsAllSelected(items) {
+        let result = true;
+        if (this.selectedItems?.size > 0 && items?.length > 0) {
+            for (const item of items) {
+                if (!(item && this.selectedItems.has(item?.UID.toString()))) {
+                    result = false;
+                    break;
+                }
+            }
+        }
+        else {
+            result = false;
+        }
+        return result;
+    }
+    getNumberOfStartItems() {
+        let numberOfStartItems = 20;
+        if (this.screenSize === PepScreenSizeType.XL ||
+            this.screenSize === PepScreenSizeType.LG) {
+            numberOfStartItems = this.isTable ? 50 : 40;
+        }
+        else if (this.screenSize === PepScreenSizeType.MD) {
+            numberOfStartItems = this.isTable ? 30 : 20;
+        }
+        else if (this.screenSize === PepScreenSizeType.SM) {
+            numberOfStartItems = this.isTable ? 20 : 10;
+        }
+        else if (this.screenSize === PepScreenSizeType.XS) {
+            numberOfStartItems = this.isTable ? 15 : 5;
+        }
+        return numberOfStartItems;
+    }
+    setItemClicked(itemId, isSelectableForActions, itemType, isChecked) {
+        const uniqItemId = this.getUniqItemId(itemId, itemType);
+        // select the selected item.
+        if (isChecked) {
+            // Set seleted item
+            this.selectedItemId = uniqItemId;
+        }
+        else {
+            if (this.selectedItemId === uniqItemId) {
+                this.selectedItemId = '';
+            }
+        }
+        if (this.selectionTypeForActions === 'single') {
+            this.selectedItemsChange.emit(this.selectedItemId.length === 0 ? 0 : 1);
+        }
+        else if (this.selectionTypeForActions === 'multi') {
+            if (isSelectableForActions) {
+                this.setSelectionItems(itemId, uniqItemId, isChecked);
+                const currentList = this.isAllSelected
+                    ? this.unSelectedItems
+                    : this.selectedItems;
+                const currentListCount = this.isAllSelected
+                    ? this.totalRows - currentList.size
+                    : currentList.size;
+                this.selectedItemsChange.emit(currentListCount);
+            }
+        }
+        // Raise selected item change event
+        if (this.selectionTypeForActions !== 'none') {
+            this.selectedItemChange.emit({
+                id: itemId,
+                selected: isChecked,
+            });
+        }
+    }
+    exportFunctionsOnHostElement() {
+        // This is for web component usage for use those functions.
+        this.hostElement.nativeElement.clear = this.clear.bind(this);
+        this.hostElement.nativeElement.initListData = this.initListData.bind(this);
+        this.hostElement.nativeElement.updateItems = this.updateItems.bind(this);
+        this.hostElement.nativeElement.updatePage = this.updatePage.bind(this);
+        this.hostElement.nativeElement.updateItem = this.updateItem.bind(this);
+    }
+    // For refresh the UI when change the is selectable for action on item.
+    getisItemDisabled(item) {
+        return this.printMode || this.lockItemInnerEvents || (item && !item.IsSelectableForActions);
+    }
+    getIsAllSelectedForActions() {
+        let res = false;
+        if (this.isAllSelected) {
+            if (this.unSelectedItems.size === 0) {
+                res = true;
+            }
+        }
+        else {
+            if (this.virtualScroller?.viewPortItems) {
+                if (this.selectedItems.size === this.totalRows) {
+                    res = this.getIsAllSelected(this.virtualScroller.viewPortItems);
+                }
+                else if (this.selectedItems.size < this.totalRows) {
+                    for (const item of this.virtualScroller.viewPortItems) {
+                        res =
+                            item && this.selectedItems.has(item?.UID.toString());
+                        if (!res) {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        return res;
+    }
+    setIsAllSelected(isChecked) {
+        if (this.selectionTypeForActions === 'multi') {
+            this.selectAllCB.checked = isChecked;
+            this.isAllSelected = isChecked;
+        }
+    }
+    selectAllItemsForActions(e) {
+        // For material checkbox || radio.
+        const isChecked = e.source.checked;
+        // Indeterminate mode
+        let isIndeterminate = false;
+        const currentList = this.isAllSelected
+            ? this.unSelectedItems
+            : this.selectedItems;
+        if (currentList.size > 0) {
+            isIndeterminate = true;
+            this.isAllSelected = false;
+            this.selectedItemsChange.emit(0);
+            e.source.checked = false;
+        }
+        this.selectedItems.clear();
+        this.unSelectedItems.clear();
+        if (!isIndeterminate) {
+            this.isAllSelected = isChecked;
+            this.selectAllClick.emit(isChecked);
+            if (this.selectionTypeForActions === 'multi') {
+                if (!isChecked) {
+                    this.selectedItemsChange.emit(0);
+                    this.selectedItemId = '';
+                }
+                else {
+                    const filteredItems = this.items.filter((item) => item && item.IsSelectableForActions);
+                    this.selectedItemsChange.emit(filteredItems.length);
+                }
+            }
+        }
+        else {
+            // Remove all
+            if (this.selectionTypeForActions === 'multi') {
+                this.selectAllClick.emit(false);
+            }
+        }
+    }
+    raiseStartIndexChange(startIndex = 0) {
+        // this.startIndex = startIndex;
+        this.startIndexChange.emit({ startIndex });
+    }
+    getIsItemSelected(item) {
+        let isSelected = false;
+        if (item) {
+            if (this.selectionTypeForActions === 'single') {
+                isSelected = this.selectedItemId === this.getUniqItemId(item.UID, item.Type.toString());
+            }
+            else if (this.selectionTypeForActions === 'multi') {
+                if (item.IsSelectableForActions) {
+                    isSelected = (this.isAllSelected && !this.unSelectedItems.has(item.UID)) || this.selectedItems.has(item.UID);
+                }
+            }
+        }
+        return isSelected;
+    }
+    selectItemForActions(e, itemId, isSelectableForActions, itemType = '') {
+        // For material checkbox || radio.
+        const isChecked = e.source.checked;
+        this.setItemClicked(itemId, isSelectableForActions, itemType, isChecked);
+    }
+    itemClicked(e, item) {
+        // Set seleted item
+        const itemId = item?.UID.toString();
+        const itemType = item?.Type.toString();
+        let isChecked = false;
+        if (item && item.IsSelectableForActions) {
+            this.selectedItemId = this.getUniqItemId(itemId, itemType);
+            isChecked = true;
+        }
+        // TODO - need to check what we want to do line view
+        if (this.isTable || this.viewType === 'cards') {
+            if (this.selectionTypeForActions === 'single') {
+                this.setItemClicked(itemId, item.IsSelectableForActions, itemType, isChecked);
+            }
+            else if (this.selectionTypeForActions === 'none') {
+                // Just mark the row as highlighted
+                this.setItemClicked(itemId, item.IsSelectableForActions, itemType, true);
+            }
+        }
+        else {
+            if (this.disabled) {
+                return;
+            }
+        }
+        this.itemClick.emit({ source: item, viewType: this.viewType });
+    }
+    onTableRowMouseEnter(event, itemId, itemType) {
+        if (!this.deviceHasMouse) {
+            return;
+        }
+        const uniqItemId = this.getUniqItemId(itemId, itemType);
+        this.hoveredItemId = uniqItemId;
+    }
+    onTableRowMouseLeave(event, itemId, itemType) {
+        this.hoveredItemId = '';
+    }
+    onTabKeydown(event, itemId, itemType) {
+        const keyboardEvent = event;
+        if (keyboardEvent.key === 'Tab') {
+            const jumpToNextRow = !keyboardEvent.shiftKey;
+            const eventTarget = event.target || event.srcElement;
+            const isLastColumn = this.isLastColunm(eventTarget, 'table-cell', jumpToNextRow);
+            // If the last column then go to the next row.
+            if (isLastColumn) {
+                const currentRowEL = this.getParentByClass(eventTarget, 'table-row');
+                const nextRow = jumpToNextRow ? currentRowEL?.nextElementSibling : currentRowEL?.previousElementSibling;
+                if (nextRow !== null) {
+                    // Remove the highlight from the current row.
+                    this.renderer.removeClass(nextRow, 'highlighted');
+                    // Highlight the next row.
+                    this.renderer.addClass(nextRow, 'highlighted');
+                    // Click on the first cell of the next row.
+                    const indexOfFocusCell = jumpToNextRow ? 0 : nextRow.querySelectorAll('.table-cell').length - 1;
+                    nextRow.querySelectorAll('.table-cell')[indexOfFocusCell].click();
+                    setTimeout(() => {
+                        nextRow.querySelectorAll('.table-cell')[indexOfFocusCell].focus();
+                    }, 100);
+                }
+            }
+        }
+    }
+    isLastColunm(el, parentSelector, isNext = true) {
+        const parent = this.getParentByClass(el, parentSelector);
+        // check if last column or if shifr pressed and it's the first column
+        return isNext ? (parent?.nextElementSibling) === null : (parent?.previousElementSibling === null);
+    }
+    getParentByClass(el, parentSelector /* optional */) {
+        // If no parentSelector defined will bubble up all the way to *document*
+        if (parentSelector === undefined) {
+            parentSelector = document;
+        }
+        let p = el.parentNode;
+        while (p &&
+            !p?.classList?.contains(parentSelector) &&
+            parentSelector !== document) {
+            const o = p;
+            p = o?.parentNode || null;
+        }
+        return p?.className.indexOf(parentSelector) > -1 ? p : null;
+    }
+    onCardMouseEnter(event, itemId, itemType) {
+        if (!this.deviceHasMouse) {
+            return;
+        }
+        const uniqItemId = this.getUniqItemId(itemId, itemType);
+        this.hoveredItemId = uniqItemId;
+    }
+    onCardMouseLeave(event, itemId, itemType) {
+        this.hoveredItemId = '';
+    }
+    // trackByFunc(index: number, item: ObjectsDataRow): any {
+    //     return item && item?.UID ? item?.UID : index;
+    //     // let res: string = "";
+    //     // if (item && item?.UID) {
+    //     //    res = item?.UID + "_" + this.listType + "_" + (this.isTable ? "Table" : "Thumbnails");
+    //     // }
+    //     // else {
+    //     //    res = index + "_" + this.listType + "_" + (this.isTable ? "Table" : "Thumbnails");
+    //     // }
+    //     // return res;
+    // }
+    clear() {
+        this.cleanItems();
+        this._layout = null;
+    }
+    setSelectedIds(selectedIds, items = null) {
+        this.selectedItems.clear();
+        this.isAllSelected = false;
+        if (selectedIds) {
+            // for (let i = 0; i < selected.length; i++) {
+            for (const selectedId of selectedIds) {
+                const tmp = selectedId.split(this.SEPARATOR);
+                if (tmp && tmp.length > 0) {
+                    const itemId = tmp[0];
+                    const itemType = tmp.length > 1 ? tmp[1] : '';
+                    this.selectedItems.set(itemId, this.getUniqItemId(itemId, itemType));
+                }
+            }
+            this.isAllSelected = this.getIsAllSelected(items ? items : this.virtualScroller?.viewPortItems);
+            this.setSelectionDataInSession();
+        }
+        this.refresh();
+    }
+    setSelectionDataInSession() {
+        if (this.selectedItems.size > 0) {
+            this.sessionService.setObject(PepListComponent.SELECTED_ITEMS_STATE_KEY, JSON.stringify([...this.selectedItems]));
+        }
+        if (this.unSelectedItems.size > 0) {
+            this.sessionService.setObject(PepListComponent.UN_SELECTED_ITEMS_STATE_KEY, JSON.stringify([...this.unSelectedItems]));
+        }
+        this.sessionService.setObject(PepListComponent.ALL_SELECTED_STATE_KEY, this.isAllSelected);
+    }
+    initListData(layout, totalRows, items, selectionTypeForActions = undefined) {
+        this.initVariablesFromSession(items);
+        const selectedItemsList = this.isAllSelected
+            ? this.unSelectedItems
+            : this.selectedItems;
+        const currentListCount = this.isAllSelected
+            ? this.totalRows - selectedItemsList.size
+            : selectedItemsList.size;
+        this.selectedItemsChange.emit(currentListCount);
+        this._layout = layout;
+        this.selectedItemId = '';
+        this.totalRows = totalRows;
+        // Added to handle if the selectionTypeForActions is set in the html then the input this.selectedItemId will no set cause this function happens before.
+        if (selectionTypeForActions) {
+            this.selectionTypeForActions = selectionTypeForActions;
+        }
+        // If is all selected is false && the size of the selected items is 1 && selectionTypeForActions is 'single' then set it as the selected item id.
+        // We need this in setTimeout cause the selectionTypeForActions is input that can set after this function.
+        if (!this.isAllSelected && this.selectedItems.size === 1 && this.selectionTypeForActions === 'single') {
+            const [firstValue] = this.selectedItems.values();
+            this.selectedItemId = firstValue;
+        }
+        this.scrollToTop(false);
+        this.cleanItems();
+        this.disableScroll(true);
+        if (items) {
+            if (this.pagerType === 'pages') {
+                // If page index out of bounds - init to 0.
+                const numberOfPages = Math.ceil(totalRows / this.pageSize);
+                if (this.pageIndex >= numberOfPages) {
+                    this.pageIndex = 0;
+                }
+                this.updatePage(items, {
+                    pageIndex: this.pageIndex,
+                    pageSize: this.pageSize,
+                });
+                this.disableScroll(false);
+            }
+            else {
+                const numberOfStartItems = this.getNumberOfStartItems();
+                const event = {
+                    fromIndex: 0,
+                    toIndex: numberOfStartItems,
+                };
+                this.updateItems(items, event);
+                if (this.virtualScroller) {
+                    this.refresh(() => {
+                        this.calcObjectHeight();
+                    });
+                }
+                else {
+                    this.calcObjectHeight();
+                }
+            }
+        }
+        if (!this.isTable) {
+            this.lastColumnsWidth = [];
+        }
+        this.setLayout();
+        // setTimeout(() => {
+        this.onListLoad();
+        // }, 0);
+    }
+    updateItems(items, event = null) {
+        if (!event) {
+            return; // Event isn't supplied.
+        }
+        // Clean array
+        if (this.itemsCounter + items.length > this.getCachedItemsNumber()) {
+            this.cleanItems();
+        }
+        const startIndex = event.fromIndex ?? 0;
+        for (let i = 0; i < items.length; i++) {
+            if (!this.items[i + startIndex]) {
+                this.items[i + startIndex] = items[i];
+                this.itemsCounter += 1;
+            }
+        }
+        this.toggleLoadingItemsFropApi(false);
+    }
+    updatePage(items, event) {
+        if (!event) {
+            return; // Event isn't supplied.
+        }
+        // Clean array
+        if (this.itemsCounter + items.length > this.getCachedItemsNumber()) {
+            this.cleanItems();
+        }
+        // const loadInChunks = this.itemsCounter === 0;
+        const startIndex = Math.min(event.pageIndex * event.pageSize, this.totalRows);
+        const endIndex = Math.min(startIndex + event.pageSize, this.totalRows);
+        for (let i = 0; i < items.length; i++) {
+            if (!this.items[i + startIndex]) {
+                this.items[i + startIndex] = items[i];
+                this.itemsCounter += 1;
+            }
+        }
+        this.updateCurrentPageItems(startIndex, endIndex);
+        this.toggleLoadingItemsFropApi(false);
+    }
+    updateItem(data) {
+        const index = this.items.findIndex((i) => i && i?.UID === data?.UID);
+        if (index >= 0 && index < this.items.length) {
+            this.updateItemProperties(this.items[index], data);
+        }
+    }
+    scrollToIndex(index, alignToBeginning = true, additionalOffset = 0, animationMilliseconds = undefined, animationCompletedCallback = undefined) {
+        this.virtualScroller?.scrollToIndex(index, alignToBeginning, additionalOffset, animationMilliseconds, animationCompletedCallback);
+    }
+    updateItemProperties(itemToUpdate, data) {
+        Object.assign(itemToUpdate, data);
+    }
+    getSelectedItemsData(isForEdit = false) {
+        const res = new PepSelectionData();
+        let selectionType = 1;
+        const items = [];
+        const itemTypes = [];
+        if (this.selectionTypeForActions === 'single') {
+            if (this.selectedItemId.length > 0) {
+                const tmp = this.selectedItemId.split(this.SEPARATOR);
+                items.push(tmp[0]);
+                itemTypes.push(tmp[1]);
+            }
+        }
+        else if (this.selectionTypeForActions === 'multi') {
+            let currentList = [];
+            // For edit - only the selected items.
+            if (isForEdit) {
+                if (!this.isAllSelected) {
+                    currentList = Array.from(this.selectedItems.values());
+                }
+                else {
+                    // Get the id's of the items that not founded in unSelectedItems.
+                    this.items.forEach((item) => {
+                        if (item &&
+                            !this.unSelectedItems.has(item?.UID.toString())) {
+                            currentList.push(this.getUniqItemId(item?.UID.toString(), item?.Type.toString()));
+                        }
+                    });
+                }
+            }
+            else {
+                // For delete - can be the unselected with select_all functionality.
+                currentList = Array.from(this.isAllSelected
+                    ? this.unSelectedItems.values()
+                    : this.selectedItems.values());
+                selectionType = this.isAllSelected ? 0 : 1;
+            }
+            currentList.forEach((item) => {
+                const tmp = item.split(this.SEPARATOR);
+                if (tmp.length === 2) {
+                    items.push(tmp[0]);
+                    itemTypes.push(tmp[1]);
+                }
+            });
+        }
+        res.selectionType = selectionType;
+        res.rows = items;
+        res.rowTypes = itemTypes;
+        return res;
+    }
+    getIsItemEditable(uid) {
+        const item = this.items.filter((x) => x?.UID.toString() === uid);
+        if (item.length > 0) {
+            return item[0].IsEditable;
+        }
+        else {
+            return false;
+        }
+    }
+    getItemDataByID(uid) {
+        return this.items.find((item) => item?.UID.toString() === uid);
+    }
+    refresh(refreshCompletedCallback = undefined) {
+        this.virtualScroller?.refresh(refreshCompletedCallback);
+    }
+    // ---------------------------------------------------------------
+    //              Events handlers.
+    // ---------------------------------------------------------------
+    onWinResize(e) {
+        this.refresh();
+        this.containerWidth = 0;
+        this.lastColumnsWidth = [];
+        this.setLayout();
+    }
+    onListResizeStart(event, columnKey, columnIndex) {
+        this.pressedColumn = columnKey;
+        this.pressedColumnIndex = columnIndex;
+        this.startX = event.x;
+        this.startWidth = event.target.closest('.header-column').offsetWidth;
+        // this.tableStartWidth = this.hostElement.nativeElement.offsetWidth; // this.virtualScroller?.contentElementRef.nativeElement.offsetWidth;
+        this.tableStartWidth = this.listContainerResizableElementRef.nativeElement.offsetWidth; // this.virtualScroller?.contentElementRef.nativeElement.offsetWidth;
+        console.log(`tableStartWidth - ${this.tableStartWidth}`);
+    }
+    onListResize(event) {
+        // if (this.pressedColumn.length > 0) {
+        if (this.pressedColumnIndex >= 0) {
+            let widthToAdd = this.layoutService.isRtl() ? this.startX - event.x : event.x - this.startX;
+            // Set the width of the column and the container of the whole columns.
+            if (this.startWidth + widthToAdd >= PepListComponent.MINIMUM_COLUMN_WIDTH || widthToAdd > 0) {
+                const length = this._layout.ControlFields.length;
+                let totalCalcColsWidth = 0;
+                for (let index = 0; index < length; index++) {
+                    const uiControlField = this._layout
+                        .ControlFields[index];
+                    if (index === length - 1) {
+                        // Calc the last column only in percentage type.
+                        if (this.hasColumnWidthOfTypePercentage) {
+                            const scrollWidth = this.layoutService.getScrollbarWidth();
+                            widthToAdd += scrollWidth;
+                            uiControlField.calcTitleColumnWidthString = uiControlField.calcColumnWidthString = 'calc(100% - ' + (totalCalcColsWidth + scrollWidth) + 'px)'; // For 100%
+                        }
+                        else {
+                            // if (uiControlField.ApiName === this.pressedColumn) {
+                            if (index === this.pressedColumnIndex) {
+                                uiControlField.calcColumnWidth = this.startWidth + widthToAdd;
+                                uiControlField.calcTitleColumnWidthString = uiControlField.calcColumnWidth + 'px';
+                                uiControlField.calcColumnWidthString = uiControlField.calcColumnWidth + 'px';
+                            }
+                        }
+                        // } else if (uiControlField.ApiName === this.pressedColumn) {
+                    }
+                    else if (index === this.pressedColumnIndex) {
+                        uiControlField.calcColumnWidth = this.startWidth + widthToAdd;
+                        uiControlField.calcTitleColumnWidthString = uiControlField.calcColumnWidthString = uiControlField.calcColumnWidth + 'px';
+                    }
+                    totalCalcColsWidth += uiControlField.calcColumnWidth;
+                }
+                const widthToSet = (this.tableStartWidth + widthToAdd) + 'px';
+                console.log(`onListResize -> widthToSet: ${widthToSet} *** widthToAdd: ${widthToAdd}`);
+                this.setColumnsWidth(widthToSet);
+                this.checkForChanges = new Date().getTime();
+            }
+        }
+    }
+    onListResizeEnd(event) {
+        // if (this.pressedColumn.length > 0) {
+        if (this.pressedColumnIndex >= 0) {
+            if (event &&
+                this.getParent(event.srcElement, 'resize-box').length > 0) {
+                this.initResizeData();
+            }
+            else {
+                // Set timeout 0 for onListSortingChange will have the pressedColumn.
+                setTimeout(() => {
+                    this.initResizeData();
+                }, 0);
+            }
+            this.lastColumnsWidth = [];
+            // Set the last columns width
+            for (let index = 0; index < this._layout.ControlFields.length; index++) {
+                const uiControlField = this._layout.ControlFields[index];
+                this.lastColumnsWidth.push({
+                    columnAPIName: uiControlField.ApiName,
+                    calcColumnWidth: uiControlField.calcColumnWidth,
+                    calcTitleColumnWidthString: uiControlField.calcTitleColumnWidthString,
+                    calcColumnWidthString: uiControlField.calcColumnWidthString
+                });
+            }
+            event.stopPropagation();
+        }
+    }
+    onListSortingChange(sortBy, isAsc, event = null) {
+        if (
+        // this.pressedColumn.length > 0 ||
+        this.pressedColumnIndex >= 0 ||
+            (event && this.getParent(event.srcElement, 'resize-box').length > 0)) {
+            return;
+        }
+        if (this.sortBy !== sortBy || this.isAsc !== isAsc) {
+            this.sortBy = sortBy;
+            this.isAsc = isAsc;
+            this.saveSortingToSession();
+            this.sortingChange.emit({ sortBy, isAsc });
+        }
+    }
+    onListHeaderMouseEnter(event) {
+        // this.headerIsInFocus = true;
+    }
+    onListHeaderMouseLeave(event) {
+        // this.headerIsInFocus = false;
+        this.onListResizeEnd(event);
+        this.initResizeData();
+    }
+    onPagerChange(event) {
+        this.pageIndex = event.pageIndex;
+        // Scroll to top.
+        //this.scrollToTop();
+        const startIndex = event.pageIndex * event.pageSize;
+        const endIndex = Math.min(startIndex + event.pageSize, this.totalRows);
+        let shouldGetItemsFromApi = false;
+        let index = startIndex;
+        while (!shouldGetItemsFromApi && index < endIndex) {
+            if (!this.items[index]) {
+                shouldGetItemsFromApi = true;
+            }
+            index++;
+        }
+        // Get bulk from api.
+        if (shouldGetItemsFromApi) {
+            if (!this.loadingItemsFromApi) {
+                this.toggleLoadingItemsFropApi(true);
+                this.loadPage.emit({
+                    pageIndex: event.pageIndex,
+                    pageSize: event.pageSize,
+                });
+                this.scrollToTop();
+            }
+        }
+        else {
+            setTimeout(() => {
+                this.updateCurrentPageItems(startIndex, endIndex);
+                this.scrollToTop();
+            }, this.scrollAnimationTime);
+        }
+    }
+    onVirtualScrollerChange(event) {
+        this.raiseStartIndexChange(event.startIndex);
+        if (this.pagerType === 'scroll') {
+            // For other events do nothing.
+            if (typeof event.startIndex === 'undefined' || event.startIndex < 0 ||
+                typeof event.endIndex === 'undefined' || event.endIndex < 0) {
+                return;
+            }
+            const addAtStart = event.scrollDirection === 'backward';
+            let shouldGetItemsFromApi = false;
+            let indexOfMissingItem;
+            if (addAtStart) {
+                indexOfMissingItem = event.endIndex;
+                while (!shouldGetItemsFromApi && indexOfMissingItem >= event.startIndex) {
+                    if (!this.items[indexOfMissingItem]) {
+                        shouldGetItemsFromApi = true;
+                    }
+                    if (!shouldGetItemsFromApi) {
+                        indexOfMissingItem--;
+                    }
+                }
+            }
+            else {
+                indexOfMissingItem = event.startIndex;
+                while (!shouldGetItemsFromApi && indexOfMissingItem <= event.endIndex) {
+                    if (!this.items[indexOfMissingItem]) {
+                        shouldGetItemsFromApi = true;
+                    }
+                    if (!shouldGetItemsFromApi) {
+                        indexOfMissingItem++;
+                    }
+                }
+            }
+            // Get bulk from api.
+            if (shouldGetItemsFromApi) {
+                if (!this.loadingItemsFromApi) {
+                    this.toggleLoadingItemsFropApi(true);
+                    const top = this.getTopItems() - 1;
+                    const fromIndex = addAtStart ? Math.max(indexOfMissingItem - top, 0) : indexOfMissingItem;
+                    const toIndex = addAtStart ? indexOfMissingItem : Math.min(indexOfMissingItem + top, this.totalRows);
+                    this.loadItems.emit({
+                        fromIndex,
+                        toIndex,
+                    });
+                }
+            }
+        }
+    }
+    onListLoad() {
+        setTimeout(() => {
+            this.listLoad.emit();
+        }, 0);
+    }
+    // onChildRectChange(event: any) {
+    //     // Set the calculatedObjectHeight only if he's not set (this case is only for the initialize when virtual scroll is undefined).
+    //     // the other cases is handled in calcObjectHeight function.
+    //     if (this.calculatedObjectHeight === 'auto') {
+    //         this.calculatedObjectHeight = event?.height + 'px';
+    //     }
+    // }
+    onValueChanged(valueChange) {
+        if (this.disabled) {
+            return;
+        }
+        this.valueChange.emit(valueChange);
+    }
+    onCustomizeFieldClick(customizeFieldClickedData) {
+        if (this.disabled) {
+            return;
+        }
+        this.fieldClick.emit(customizeFieldClickedData);
+    }
+    //added to handle sorting by specific columns----
+    isSortableColumn(apiName) {
+        //case 1 - supportSorting = true and array exists
+        if (this.supportSorting) {
+            if (this.supportSortingFields?.length) {
+                return this.supportSortingFields.includes(apiName);
+                //case 2 - supportSorting = true and array does not exist
+            }
+            else if (this.supportSortingFields === undefined) {
+                return true;
+            } // case 3 supportSorting = false
+        }
+        else
+            return false;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepListComponent, deps: [{ token: i0.ElementRef }, { token: i1.PepLayoutService }, { token: i1.PepSessionService }, { token: i0.ChangeDetectorRef }, { token: i0.Renderer2 }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: PepListComponent, selector: "pep-list", inputs: { sorting: "sorting", cacheSize: "cacheSize", noDataFoundMsg: "noDataFoundMsg", selectionTypeForActions: "selectionTypeForActions", showCardSelection: "showCardSelection", hideAllSelectionInMulti: "hideAllSelectionInMulti", cardSize: "cardSize", tableViewType: "tableViewType", viewType: "viewType", firstFieldAsLink: "firstFieldAsLink", supportSorting: "supportSorting", supportSortingFields: "supportSortingFields", supportResizing: "supportResizing", parentScroll: "parentScroll", disabled: "disabled", lockEvents: "lockEvents", lockItemInnerEvents: "lockItemInnerEvents", printMode: "printMode", isReport: "isReport", zebraStripes: "zebraStripes", totalsRow: "totalsRow", pagerType: "pagerType", pageSize: "pageSize", pageIndex: "pageIndex", bufferAmount: "bufferAmount", scrollAnimationTime: "scrollAnimationTime", scrollDebounceTime: "scrollDebounceTime", scrollThrottlingTime: "scrollThrottlingTime", SEPARATOR: "SEPARATOR", useAsWebComponent: "useAsWebComponent" }, outputs: { itemClick: "itemClick", fieldClick: "fieldClick", valueChange: "valueChange", sortingChange: "sortingChange", selectedItemsChange: "selectedItemsChange", selectedItemChange: "selectedItemChange", selectAllClick: "selectAllClick", listLoad: "listLoad", loadItems: "loadItems", loadPage: "loadPage", startIndexChange: "startIndexChange" }, host: { listeners: { "window:resize": "onWinResize($event)" } }, viewQueries: [{ propertyName: "listContainerResizableElementRef", first: true, predicate: ["listContainerResizable"], descendants: true, read: ElementRef }, { propertyName: "virtualScroller", first: true, predicate: VirtualScrollerComponent, descendants: true }, { propertyName: "selectAllCB", first: true, predicate: ["selectAllCB"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"totalRows == 0\">\n    <ng-container *ngIf=\"noDataFoundMsg; then noDataMsgInputBlock; else noDataMsgDefaultBlock\"></ng-container>\n    <ng-template #noDataMsgInputBlock>\n        <div class=\"pep-border-bottom\">\n            <p class=\"title-xl no-data\">\n                {{ noDataFoundMsg }}\n            </p>\n        </div>\n    </ng-template>\n    <ng-template #noDataMsgDefaultBlock>\n        <div class=\"pep-border-bottom\">\n            <p class=\"title-xl no-data\">\n                {{ 'LIST.NO_DATA_FOUND' | translate}}\n            </p>\n        </div>\n        <div class=\"no-data-suggestions\">\n            <p class=\"suggestions-title title-lg\">\n                {{ 'LIST.NO_DATA_FOUND_SUGGESTIONS_TITLE' | translate}}\n            </p>\n            <ul class=\"suggestions-list body-lg\" [innerHtml]=\"'LIST.NO_DATA_FOUND_SUGGESTIONS_LIST' | translate\"></ul>\n        </div>\n    </ng-template>\n</ng-container>\n<ng-container *ngIf=\"totalRows > 0\">\n    <div class=\"list-container\">\n        <div #listContainerResizable class=\"list-container-resizable\">\n            <ng-container *ngTemplateOutlet=\"tableHeader\"></ng-container>\n\n            <!-- (vsChildRectChange)=\"onChildRectChange($event)\" -->\n            <virtual-scroller #scroller [items]=\"pagerType === 'pages' ? currentPageItems : items\"\n                [scrollDebounceTime]=\"scrollDebounceTime\" [scrollThrottlingTime]=\"scrollThrottlingTime\"\n                [bufferAmount]=\"printMode ? totalRows : bufferAmount\" [parentScroll]=\"parentScroll\" [disable]=\"loadingItemsFromApi\"\n                class=\"virtual-scroller\" [ngClass]=\"{ 'table-body': isTable, 'cards-body': !isTable }\"\n                (vsChange)=\"onVirtualScrollerChange($event)\" >\n                <ng-container *ngFor=\"let item of scroller.viewPortItems; let index = index; let isFirst = first;\">\n                    <ng-container *ngTemplateOutlet=\"listData; context: {item: item, index:index}\"></ng-container>\n                </ng-container>\n            </virtual-scroller>\n            \n            <ng-container *ngTemplateOutlet=\"tableTotal\"></ng-container>\n        </div>\n    </div>\n    <pep-list-pager *ngIf=\"pagerType === 'pages'\" class=\" list-pager\" [disabled]=\"loadingItemsFromApi\"\n        [length]=\"totalRows\" [pageSize]=\"pageSize\" [pageIndex]=\"pageIndex\" (pagerChange)=\"onPagerChange($event)\">\n    </pep-list-pager>\n</ng-container>\n\n<ng-template #listData let-item=\"item\" let-index=\"index\">\n    <ng-container *ngIf=\"isTable\">\n        <!-- getIsItemSelected(item) -> item | isItemSelected: selectionTypeForActions : selectedItemId : isAllSelected : selectedItems : unSelectedItems -->\n        <div class=\"table-row\" (mouseenter)=\"onTableRowMouseEnter($event, item?.UID, item?.Type)\" (keydown)=\"onTabKeydown($event, item?.UID, item?.Type)\"\n            (mouseleave)=\"onTableRowMouseLeave($event, item?.UID, item?.Type)\" [ngClass]=\"{\n                'compact-view': tableViewType === 'compact',\n                even: zebraStripes && index % 2 !== 0,\n                selected: getIsItemSelected(item),\n                highlighted: item?.UID + SEPARATOR + item?.Type === selectedItemId}\" [ngStyle]=\"{ visibility: !loadingItemsFromApi || item ? 'visible' : 'hidden' }\">\n            <fieldset class=\"table-row-fieldset\" [ngStyle]=\"{ 'background-color': item?.BackgroundColor }\">\n                <mat-checkbox *ngIf=\"selectionTypeForActions == 'multi'\" type=\"checkbox\"\n                    class=\"pull-left flip row-selection\" [ngClass]=\"{ 'md': tableViewType === 'compact' }\"\n                    [disabled]=\"false && getisItemDisabled(item)\" [ngStyle]=\"{\n                            visibility: !deviceHasMouse ||\n                            item?.UID + SEPARATOR + item?.Type === hoveredItemId || isAllSelected || selectedItems.size > 0 ? 'visible' : 'hidden'\n                        }\" [checked]=\"getIsItemSelected(item)\"\n                    (change)=\"selectItemForActions($event, item?.UID, item?.IsSelectableForActions, item?.Type)\">\n                </mat-checkbox>\n                <mat-radio-button *ngIf=\"selectionTypeForActions == 'single'\" name=\"selection\"\n                    class=\"pull-left flip row-selection pep-radio-button\" [ngClass]=\"{ 'md': tableViewType === 'compact' }\"\n                    [disabled]=\"getisItemDisabled(item)\"\n                    [checked]=\"getIsItemSelected(item)\"\n                    (change)=\"selectItemForActions($event, item?.UID, item?.IsSelectableForActions, item?.Type)\">\n                </mat-radio-button>\n                <pep-form [layoutType]=\"'table'\" [checkForChanges]=\"checkForChanges\" [layout]=\"layout\"\n                    [firstFieldAsLink]=\"firstFieldAsLink\" [data]=\"item\" [canEditObject]=\"!disabled\"\n                    [lockEvents]=\"lockItemInnerEvents || printMode\" [isReport]=\"isReport\" [isActive]=\"\n                            (item?.UID + SEPARATOR + item?.Type === selectedItemId ||\n                            item?.UID + SEPARATOR + item?.Type === hoveredItemId) && deviceHasMouse\n                        \" (valueChange)=\"onValueChanged($event)\" (fieldClick)=\"onCustomizeFieldClick($event)\"\n                    (click)=\"itemClicked($event, item)\">\n                </pep-form>\n            </fieldset>\n        </div>\n    </ng-container>\n\n    <ng-container *ngIf=\"!isTable\">\n        <div (mouseenter)=\"onCardMouseEnter($event, item?.UID, item?.Type)\"\n            (mouseleave)=\"onCardMouseLeave($event, item?.UID, item?.Type)\" [ngClass]=\"{\n                    selected: getIsItemSelected(item),\n                    highlighted: item?.UID + SEPARATOR + item?.Type === selectedItemId,\n                    'line-view': viewType === 'lines',\n                    'card-view': viewType === 'cards',\n                    'small-card': cardSize === 'sm'\n                }\" class=\"pull-left flip\"\n            [ngStyle]=\"{ height: calculatedObjectHeight, visibility: !loadingItemsFromApi || item ? 'visible' : 'hidden' }\">\n            <mat-checkbox *ngIf=\"showCardSelection\" class=\"pull-left flip card-selection\"\n                [disabled]=\"getisItemDisabled(item)\" [checked]=\"getIsItemSelected(item)\"\n                (change)=\"selectItemForActions($event, item?.UID, item?.IsSelectableForActions, item?.Type)\">\n            </mat-checkbox>\n            <pep-form [layoutType]=\"'card'\" [firstFieldAsLink]=\"firstFieldAsLink\" [checkForChanges]=\"checkForChanges\"\n                [layout]=\"layout\" [data]=\"item\" [canEditObject]=\"!disabled\"\n                [lockEvents]=\"lockItemInnerEvents || printMode\" [isActive]=\"\n                        (item?.UID + SEPARATOR + item?.Type === selectedItemId ||\n                        item?.UID + SEPARATOR + item?.Type === hoveredItemId) && deviceHasMouse\n                    \" (valueChange)=\"onValueChanged($event)\" (fieldClick)=\"onCustomizeFieldClick($event)\"\n                (click)=\"itemClicked($event, item)\">\n            </pep-form>\n        </div>\n    </ng-container>\n</ng-template>\n\n<ng-template #tableHeader>\n    <div *ngIf=\"isTable\" class=\"table-header\" (mouseup)=\"onListResizeEnd($event)\"\n        (mouseenter)=\"onListHeaderMouseEnter($event)\" (mouseleave)=\"onListHeaderMouseLeave($event)\"\n        (mousemove)=\"onListResize($event)\">\n\n        <div class=\"table-header-padding-top\"></div>\n        <fieldset class=\"table-header-fieldset\">\n            <mat-checkbox *ngIf=\"selectionTypeForActions !== 'none'\" #selectAllCB class=\"pull-left flip row-selection\" [ngClass]=\"{ 'md': tableViewType === 'compact' }\"\n                type=\"checkbox\" [ngStyle]=\"{\n                        visibility:\n                            selectionTypeForActions == 'single' || \n                            (selectionTypeForActions == 'multi' && hideAllSelectionInMulti) ? 'hidden' : 'visible'\n                    }\"\n                [indeterminate]=\"isAllSelected ? unSelectedItems.size > 0 && unSelectedItems.size < totalRows : (selectedItems.size > 0 && !getIsAllSelectedForActions())\"\n                [disabled]=\"disabled || selectionTypeForActions === 'single'\" [checked]=\"getIsAllSelectedForActions()\"\n                (change)=\"selectAllItemsForActions($event)\"></mat-checkbox>\n            <fieldset>\n                <div *ngFor=\"let field of layout?.ControlFields; let j = index\" class=\"header-column pull-left flip\"\n                    [ngStyle]=\"{ width: field.calcTitleColumnWidthString }\" [ngClass]=\"{\n                            'compact-view': tableViewType === 'compact',\n                            'support-sorting': isSortableColumn(field.ApiName),\n                            'has-sorting': field.ApiName === sortBy,\n                            'is-resizing': field.ApiName === pressedColumn,\n                            'is-first': j === 0 && selectionTypeForActions !== 'multi',\n                            'is-last': j === layout?.ControlFields?.length - 1\n                        }\"\n                    (click)=\"isSortableColumn(field.ApiName) ? (onListSortingChange(field.ApiName, sortBy !== null && sortBy != field.ApiName ? true : !isAsc, $event)) : false\">\n\n                    <label id=\"{{ field.ApiName }}\"\n                        class=\"header-label body-sm pull-left flip text-align-{{ field.Layout.XAlignment }}\"\n                        title=\"{{ field.Title }}\">\n                        <span *ngIf=\"field.Mandatory\" class=\"mandatory\">\n                            <pep-icon name=\"system_must\"></pep-icon>\n                        </span>\n                        {{ field.Title != '' ? field.Title : ' '}}\n                    </label>\n\n                    <div *ngIf=\"supportResizing\" class=\"resize-box pull-right flip\"\n                        (mousedown)=\"onListResizeStart($event, field.ApiName, j)\">\n                        <div class=\"splitter\"></div>\n                    </div>\n\n                    <div *ngIf=\"isSortableColumn(field.ApiName)\" class=\"sorting-box pull-left flip\"\n                        [ngClass]=\"{ 'has-sorting': field.ApiName === sortBy }\">\n                        <mat-icon *ngIf=\"field.ApiName !== sortBy\">\n                            <pep-icon name=\"arrow_either\" class=\"asc\"></pep-icon>\n                        </mat-icon>\n                        <ng-container *ngIf=\"field.ApiName === sortBy\">\n                            <mat-icon *ngIf=\"!isAsc\" [ngClass]=\"{ 'sort-by': field.ApiName === sortBy && isAsc }\"\n                                title=\"{{ 'LIST.SORT_ASC' | translate }}\">\n                                <pep-icon name=\"arrow_up\" class=\"asc\"></pep-icon>\n                            </mat-icon>\n                            <mat-icon *ngIf=\"isAsc\" [ngClass]=\"{ 'sort-by': field.ApiName === sortBy && !isAsc }\"\n                                title=\"{{ 'LIST.SORT_DESC' | translate }}\">\n                                <pep-icon name=\"arrow_down\" class=\"desc\"></pep-icon>\n                            </mat-icon>\n                        </ng-container>\n                    </div>\n                </div>\n            </fieldset>\n        </fieldset>\n    </div>\n</ng-template>\n\n<ng-template #tableTotal>\n    <div *ngIf=\"isTable && totalsRow?.length > 0 && totalsRow.length <= layout?.ControlFields.length\"\n        class=\"table-total\">\n        <fieldset class=\"table-header-fieldset\">\n            <div *ngFor=\"let field of layout?.ControlFields; let j = index\" class=\"total-column pull-left flip\"\n                [ngStyle]=\"{ width: field.calcTitleColumnWidthString }\">\n                <label class=\"total-label body-sm text-align-{{ field.Layout.XAlignment }}\">\n                    {{ totalsRow[j] }}\n                </label>\n            </div>\n        </fieldset>\n    </div>\n</ng-template>", styles: [":host{width:100%;height:inherit;display:flex;flex-direction:column}:host .list-container{display:flex;flex-direction:column;height:inherit;width:100%;overflow:auto}:host .list-container .list-container-resizable{display:flex;flex-direction:column;height:inherit}.no-data{margin:var(--pep-spacing-2xl, 2rem) 0}.no-data-suggestions .suggestions-title{margin:var(--pep-spacing-lg, 1rem) 0 var(--pep-spacing-sm, .5rem)}.no-data-suggestions .suggestions-list{margin:0;padding:0;padding-inline-start:var(--pep-spacing-2xl, 2rem)}.virtual-scroller{min-height:5rem;height:inherit}\n"], dependencies: [{ kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i2.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "component", type: i3.MatCheckbox, selector: "mat-checkbox", inputs: ["disableRipple", "color", "tabIndex"], exportAs: ["matCheckbox"] }, { kind: "component", type: i4.MatRadioButton, selector: "mat-radio-button", inputs: ["disableRipple", "tabIndex"], exportAs: ["matRadioButton"] }, { kind: "component", type: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i6.PepIconComponent, selector: "pep-icon", inputs: ["spin", "name", "fill"] }, { kind: "component", type: i7.PepFormComponent, selector: "pep-form", inputs: ["isInternal", "isReport", "layout", "lockEvents", "canEditObject", "data", "lockFields", "isActive", "layoutType", "objectId", "parentId", "searchCode", "showTitle", "firstFieldAsLink", "checkForChanges"], outputs: ["valueChange", "formValidationChange", "fieldClick", "internalFormFieldClick", "internalFormFieldChange"] }, { kind: "component", type: i8.VirtualScrollerComponent, selector: "virtual-scroller,[virtualScroller]", inputs: ["disable", "executeRefreshOutsideAngularZone", "enableUnequalChildrenSizes", "RTL", "useMarginInsteadOfTranslate", "modifyOverflowStyleOfParentScroll", "stripedTable", "scrollbarWidth", "scrollbarHeight", "childWidth", "childHeight", "ssrChildWidth", "ssrChildHeight", "ssrViewportWidth", "ssrViewportHeight", "bufferAmount", "scrollAnimationTime", "resizeBypassRefreshThreshold", "scrollThrottlingTime", "scrollDebounceTime", "checkResizeInterval", "items", "compareItems", "horizontal", "parentScroll"], outputs: ["vsChildRectChange", "vsUpdate", "vsChange", "vsStart", "vsEnd"], exportAs: ["virtualScroller"] }, { kind: "component", type: i9.PepListPagerComponent, selector: "pep-list-pager", inputs: ["disabled", "pageIndex", "length", "pageSize"], outputs: ["pagerChange"] }, { kind: "pipe", type: i10.TranslatePipe, name: "translate" }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepListComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'pep-list', host: {
+                        '(window:resize)': 'onWinResize($event)',
+                    }, template: "<ng-container *ngIf=\"totalRows == 0\">\n    <ng-container *ngIf=\"noDataFoundMsg; then noDataMsgInputBlock; else noDataMsgDefaultBlock\"></ng-container>\n    <ng-template #noDataMsgInputBlock>\n        <div class=\"pep-border-bottom\">\n            <p class=\"title-xl no-data\">\n                {{ noDataFoundMsg }}\n            </p>\n        </div>\n    </ng-template>\n    <ng-template #noDataMsgDefaultBlock>\n        <div class=\"pep-border-bottom\">\n            <p class=\"title-xl no-data\">\n                {{ 'LIST.NO_DATA_FOUND' | translate}}\n            </p>\n        </div>\n        <div class=\"no-data-suggestions\">\n            <p class=\"suggestions-title title-lg\">\n                {{ 'LIST.NO_DATA_FOUND_SUGGESTIONS_TITLE' | translate}}\n            </p>\n            <ul class=\"suggestions-list body-lg\" [innerHtml]=\"'LIST.NO_DATA_FOUND_SUGGESTIONS_LIST' | translate\"></ul>\n        </div>\n    </ng-template>\n</ng-container>\n<ng-container *ngIf=\"totalRows > 0\">\n    <div class=\"list-container\">\n        <div #listContainerResizable class=\"list-container-resizable\">\n            <ng-container *ngTemplateOutlet=\"tableHeader\"></ng-container>\n\n            <!-- (vsChildRectChange)=\"onChildRectChange($event)\" -->\n            <virtual-scroller #scroller [items]=\"pagerType === 'pages' ? currentPageItems : items\"\n                [scrollDebounceTime]=\"scrollDebounceTime\" [scrollThrottlingTime]=\"scrollThrottlingTime\"\n                [bufferAmount]=\"printMode ? totalRows : bufferAmount\" [parentScroll]=\"parentScroll\" [disable]=\"loadingItemsFromApi\"\n                class=\"virtual-scroller\" [ngClass]=\"{ 'table-body': isTable, 'cards-body': !isTable }\"\n                (vsChange)=\"onVirtualScrollerChange($event)\" >\n                <ng-container *ngFor=\"let item of scroller.viewPortItems; let index = index; let isFirst = first;\">\n                    <ng-container *ngTemplateOutlet=\"listData; context: {item: item, index:index}\"></ng-container>\n                </ng-container>\n            </virtual-scroller>\n            \n            <ng-container *ngTemplateOutlet=\"tableTotal\"></ng-container>\n        </div>\n    </div>\n    <pep-list-pager *ngIf=\"pagerType === 'pages'\" class=\" list-pager\" [disabled]=\"loadingItemsFromApi\"\n        [length]=\"totalRows\" [pageSize]=\"pageSize\" [pageIndex]=\"pageIndex\" (pagerChange)=\"onPagerChange($event)\">\n    </pep-list-pager>\n</ng-container>\n\n<ng-template #listData let-item=\"item\" let-index=\"index\">\n    <ng-container *ngIf=\"isTable\">\n        <!-- getIsItemSelected(item) -> item | isItemSelected: selectionTypeForActions : selectedItemId : isAllSelected : selectedItems : unSelectedItems -->\n        <div class=\"table-row\" (mouseenter)=\"onTableRowMouseEnter($event, item?.UID, item?.Type)\" (keydown)=\"onTabKeydown($event, item?.UID, item?.Type)\"\n            (mouseleave)=\"onTableRowMouseLeave($event, item?.UID, item?.Type)\" [ngClass]=\"{\n                'compact-view': tableViewType === 'compact',\n                even: zebraStripes && index % 2 !== 0,\n                selected: getIsItemSelected(item),\n                highlighted: item?.UID + SEPARATOR + item?.Type === selectedItemId}\" [ngStyle]=\"{ visibility: !loadingItemsFromApi || item ? 'visible' : 'hidden' }\">\n            <fieldset class=\"table-row-fieldset\" [ngStyle]=\"{ 'background-color': item?.BackgroundColor }\">\n                <mat-checkbox *ngIf=\"selectionTypeForActions == 'multi'\" type=\"checkbox\"\n                    class=\"pull-left flip row-selection\" [ngClass]=\"{ 'md': tableViewType === 'compact' }\"\n                    [disabled]=\"false && getisItemDisabled(item)\" [ngStyle]=\"{\n                            visibility: !deviceHasMouse ||\n                            item?.UID + SEPARATOR + item?.Type === hoveredItemId || isAllSelected || selectedItems.size > 0 ? 'visible' : 'hidden'\n                        }\" [checked]=\"getIsItemSelected(item)\"\n                    (change)=\"selectItemForActions($event, item?.UID, item?.IsSelectableForActions, item?.Type)\">\n                </mat-checkbox>\n                <mat-radio-button *ngIf=\"selectionTypeForActions == 'single'\" name=\"selection\"\n                    class=\"pull-left flip row-selection pep-radio-button\" [ngClass]=\"{ 'md': tableViewType === 'compact' }\"\n                    [disabled]=\"getisItemDisabled(item)\"\n                    [checked]=\"getIsItemSelected(item)\"\n                    (change)=\"selectItemForActions($event, item?.UID, item?.IsSelectableForActions, item?.Type)\">\n                </mat-radio-button>\n                <pep-form [layoutType]=\"'table'\" [checkForChanges]=\"checkForChanges\" [layout]=\"layout\"\n                    [firstFieldAsLink]=\"firstFieldAsLink\" [data]=\"item\" [canEditObject]=\"!disabled\"\n                    [lockEvents]=\"lockItemInnerEvents || printMode\" [isReport]=\"isReport\" [isActive]=\"\n                            (item?.UID + SEPARATOR + item?.Type === selectedItemId ||\n                            item?.UID + SEPARATOR + item?.Type === hoveredItemId) && deviceHasMouse\n                        \" (valueChange)=\"onValueChanged($event)\" (fieldClick)=\"onCustomizeFieldClick($event)\"\n                    (click)=\"itemClicked($event, item)\">\n                </pep-form>\n            </fieldset>\n        </div>\n    </ng-container>\n\n    <ng-container *ngIf=\"!isTable\">\n        <div (mouseenter)=\"onCardMouseEnter($event, item?.UID, item?.Type)\"\n            (mouseleave)=\"onCardMouseLeave($event, item?.UID, item?.Type)\" [ngClass]=\"{\n                    selected: getIsItemSelected(item),\n                    highlighted: item?.UID + SEPARATOR + item?.Type === selectedItemId,\n                    'line-view': viewType === 'lines',\n                    'card-view': viewType === 'cards',\n                    'small-card': cardSize === 'sm'\n                }\" class=\"pull-left flip\"\n            [ngStyle]=\"{ height: calculatedObjectHeight, visibility: !loadingItemsFromApi || item ? 'visible' : 'hidden' }\">\n            <mat-checkbox *ngIf=\"showCardSelection\" class=\"pull-left flip card-selection\"\n                [disabled]=\"getisItemDisabled(item)\" [checked]=\"getIsItemSelected(item)\"\n                (change)=\"selectItemForActions($event, item?.UID, item?.IsSelectableForActions, item?.Type)\">\n            </mat-checkbox>\n            <pep-form [layoutType]=\"'card'\" [firstFieldAsLink]=\"firstFieldAsLink\" [checkForChanges]=\"checkForChanges\"\n                [layout]=\"layout\" [data]=\"item\" [canEditObject]=\"!disabled\"\n                [lockEvents]=\"lockItemInnerEvents || printMode\" [isActive]=\"\n                        (item?.UID + SEPARATOR + item?.Type === selectedItemId ||\n                        item?.UID + SEPARATOR + item?.Type === hoveredItemId) && deviceHasMouse\n                    \" (valueChange)=\"onValueChanged($event)\" (fieldClick)=\"onCustomizeFieldClick($event)\"\n                (click)=\"itemClicked($event, item)\">\n            </pep-form>\n        </div>\n    </ng-container>\n</ng-template>\n\n<ng-template #tableHeader>\n    <div *ngIf=\"isTable\" class=\"table-header\" (mouseup)=\"onListResizeEnd($event)\"\n        (mouseenter)=\"onListHeaderMouseEnter($event)\" (mouseleave)=\"onListHeaderMouseLeave($event)\"\n        (mousemove)=\"onListResize($event)\">\n\n        <div class=\"table-header-padding-top\"></div>\n        <fieldset class=\"table-header-fieldset\">\n            <mat-checkbox *ngIf=\"selectionTypeForActions !== 'none'\" #selectAllCB class=\"pull-left flip row-selection\" [ngClass]=\"{ 'md': tableViewType === 'compact' }\"\n                type=\"checkbox\" [ngStyle]=\"{\n                        visibility:\n                            selectionTypeForActions == 'single' || \n                            (selectionTypeForActions == 'multi' && hideAllSelectionInMulti) ? 'hidden' : 'visible'\n                    }\"\n                [indeterminate]=\"isAllSelected ? unSelectedItems.size > 0 && unSelectedItems.size < totalRows : (selectedItems.size > 0 && !getIsAllSelectedForActions())\"\n                [disabled]=\"disabled || selectionTypeForActions === 'single'\" [checked]=\"getIsAllSelectedForActions()\"\n                (change)=\"selectAllItemsForActions($event)\"></mat-checkbox>\n            <fieldset>\n                <div *ngFor=\"let field of layout?.ControlFields; let j = index\" class=\"header-column pull-left flip\"\n                    [ngStyle]=\"{ width: field.calcTitleColumnWidthString }\" [ngClass]=\"{\n                            'compact-view': tableViewType === 'compact',\n                            'support-sorting': isSortableColumn(field.ApiName),\n                            'has-sorting': field.ApiName === sortBy,\n                            'is-resizing': field.ApiName === pressedColumn,\n                            'is-first': j === 0 && selectionTypeForActions !== 'multi',\n                            'is-last': j === layout?.ControlFields?.length - 1\n                        }\"\n                    (click)=\"isSortableColumn(field.ApiName) ? (onListSortingChange(field.ApiName, sortBy !== null && sortBy != field.ApiName ? true : !isAsc, $event)) : false\">\n\n                    <label id=\"{{ field.ApiName }}\"\n                        class=\"header-label body-sm pull-left flip text-align-{{ field.Layout.XAlignment }}\"\n                        title=\"{{ field.Title }}\">\n                        <span *ngIf=\"field.Mandatory\" class=\"mandatory\">\n                            <pep-icon name=\"system_must\"></pep-icon>\n                        </span>\n                        {{ field.Title != '' ? field.Title : ' '}}\n                    </label>\n\n                    <div *ngIf=\"supportResizing\" class=\"resize-box pull-right flip\"\n                        (mousedown)=\"onListResizeStart($event, field.ApiName, j)\">\n                        <div class=\"splitter\"></div>\n                    </div>\n\n                    <div *ngIf=\"isSortableColumn(field.ApiName)\" class=\"sorting-box pull-left flip\"\n                        [ngClass]=\"{ 'has-sorting': field.ApiName === sortBy }\">\n                        <mat-icon *ngIf=\"field.ApiName !== sortBy\">\n                            <pep-icon name=\"arrow_either\" class=\"asc\"></pep-icon>\n                        </mat-icon>\n                        <ng-container *ngIf=\"field.ApiName === sortBy\">\n                            <mat-icon *ngIf=\"!isAsc\" [ngClass]=\"{ 'sort-by': field.ApiName === sortBy && isAsc }\"\n                                title=\"{{ 'LIST.SORT_ASC' | translate }}\">\n                                <pep-icon name=\"arrow_up\" class=\"asc\"></pep-icon>\n                            </mat-icon>\n                            <mat-icon *ngIf=\"isAsc\" [ngClass]=\"{ 'sort-by': field.ApiName === sortBy && !isAsc }\"\n                                title=\"{{ 'LIST.SORT_DESC' | translate }}\">\n                                <pep-icon name=\"arrow_down\" class=\"desc\"></pep-icon>\n                            </mat-icon>\n                        </ng-container>\n                    </div>\n                </div>\n            </fieldset>\n        </fieldset>\n    </div>\n</ng-template>\n\n<ng-template #tableTotal>\n    <div *ngIf=\"isTable && totalsRow?.length > 0 && totalsRow.length <= layout?.ControlFields.length\"\n        class=\"table-total\">\n        <fieldset class=\"table-header-fieldset\">\n            <div *ngFor=\"let field of layout?.ControlFields; let j = index\" class=\"total-column pull-left flip\"\n                [ngStyle]=\"{ width: field.calcTitleColumnWidthString }\">\n                <label class=\"total-label body-sm text-align-{{ field.Layout.XAlignment }}\">\n                    {{ totalsRow[j] }}\n                </label>\n            </div>\n        </fieldset>\n    </div>\n</ng-template>", styles: [":host{width:100%;height:inherit;display:flex;flex-direction:column}:host .list-container{display:flex;flex-direction:column;height:inherit;width:100%;overflow:auto}:host .list-container .list-container-resizable{display:flex;flex-direction:column;height:inherit}.no-data{margin:var(--pep-spacing-2xl, 2rem) 0}.no-data-suggestions .suggestions-title{margin:var(--pep-spacing-lg, 1rem) 0 var(--pep-spacing-sm, .5rem)}.no-data-suggestions .suggestions-list{margin:0;padding:0;padding-inline-start:var(--pep-spacing-2xl, 2rem)}.virtual-scroller{min-height:5rem;height:inherit}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.PepLayoutService }, { type: i1.PepSessionService }, { type: i0.ChangeDetectorRef }, { type: i0.Renderer2 }, { type: i0.NgZone }]; }, propDecorators: { listContainerResizableElementRef: [{
+                type: ViewChild,
+                args: ['listContainerResizable', { read: ElementRef }]
+            }], sorting: [{
+                type: Input
+            }], cacheSize: [{
+                type: Input
+            }], noDataFoundMsg: [{
+                type: Input
+            }], selectionTypeForActions: [{
+                type: Input
+            }], showCardSelection: [{
+                type: Input
+            }], hideAllSelectionInMulti: [{
+                type: Input
+            }], cardSize: [{
+                type: Input
+            }], tableViewType: [{
+                type: Input
+            }], viewType: [{
+                type: Input
+            }], firstFieldAsLink: [{
+                type: Input
+            }], supportSorting: [{
+                type: Input
+            }], supportSortingFields: [{
+                type: Input
+            }], supportResizing: [{
+                type: Input
+            }], parentScroll: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], lockEvents: [{
+                type: Input
+            }], lockItemInnerEvents: [{
+                type: Input
+            }], printMode: [{
+                type: Input
+            }], isReport: [{
+                type: Input
+            }], zebraStripes: [{
+                type: Input
+            }], totalsRow: [{
+                type: Input
+            }], pagerType: [{
+                type: Input
+            }], pageSize: [{
+                type: Input
+            }], pageIndex: [{
+                type: Input
+            }], bufferAmount: [{
+                type: Input
+            }], scrollAnimationTime: [{
+                type: Input
+            }], scrollDebounceTime: [{
+                type: Input
+            }], scrollThrottlingTime: [{
+                type: Input
+            }], SEPARATOR: [{
+                type: Input
+            }], useAsWebComponent: [{
+                type: Input
+            }], itemClick: [{
+                type: Output
+            }], fieldClick: [{
+                type: Output
+            }], valueChange: [{
+                type: Output
+            }], sortingChange: [{
+                type: Output
+            }], selectedItemsChange: [{
+                type: Output
+            }], selectedItemChange: [{
+                type: Output
+            }], selectAllClick: [{
+                type: Output
+            }], listLoad: [{
+                type: Output
+            }], loadItems: [{
+                type: Output
+            }], loadPage: [{
+                type: Output
+            }], startIndexChange: [{
+                type: Output
+            }], virtualScroller: [{
+                type: ViewChild,
+                args: [VirtualScrollerComponent]
+            }], selectAllCB: [{
+                type: ViewChild,
+                args: ['selectAllCB']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list.component.js","sourceRoot":"","sources":["../../../../projects/ngx-lib/list/list.component.ts","../../../../projects/ngx-lib/list/list.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n    Component,\n    Input,\n    Output,\n    EventEmitter,\n    OnInit,\n    Renderer2,\n    ViewChild,\n    ElementRef,\n    ChangeDetectorRef,\n    OnDestroy,\n    OnChanges,\n    NgZone,\n} from '@angular/core';\nimport { delay } from 'rxjs/operators';\nimport {\n    PepLayoutService,\n    PepScreenSizeType,\n    PepSessionService,\n    UIControl,\n    UIControlField,\n    FIELD_TYPE,\n    ObjectsDataRow,\n} from '@pepperi-addons/ngx-lib';\nimport {\n    IPepFormFieldValueChangeEvent,\n    IPepFormFieldClickEvent,\n} from '@pepperi-addons/ngx-lib/form';\n\nimport { VirtualScrollerComponent, IPageInfo } from './virtual-scroller';\n\nimport {\n    IPepListLoadItemsEvent,\n    IPepListSortingChangeEvent,\n    IPepListItemClickEvent,\n    PepListSelectionType,\n    PepListViewType,\n    PepSelectionData,\n    PepListPagerType,\n    IPepListLoadPageEvent,\n    DEFAULT_PAGE_SIZE,\n    IPepListStartIndexChangeEvent,\n    PepListCardSizeType,\n    PepListTableViewType,\n    IPepListSortingData,\n} from './list.model';\nimport {\n    IPepListPagerChangeEvent,\n    PepListPagerComponent,\n} from './list-pager.component';\n\nimport * as tween from '@tweenjs/tween.js';\n\n@Component({\n    selector: 'pep-list',\n    templateUrl: './list.component.html',\n    styleUrls: ['./list.component.scss'],\n    host: {\n        '(window:resize)': 'onWinResize($event)',\n    },\n    // changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class PepListComponent implements OnInit, OnChanges, OnDestroy {\n    @ViewChild('listContainerResizable', { read: ElementRef }) private listContainerResizableElementRef: ElementRef;\n\n    static TOP_ITEMS_DEFAULT = 100;\n    static TOP_ITEMS_TABLE = 100;\n    static TOP_ITEMS_THUMBNAILS = 100;\n    static TOP_ITEMS_ARRAY = 2500;\n\n    static SELECTED_ITEMS_STATE_KEY = 'SelectedItems';\n    static UN_SELECTED_ITEMS_STATE_KEY = 'UnSelectedItems';\n    static ALL_SELECTED_STATE_KEY = 'AllSelected';\n    static SORT_BY_STATE_KEY = 'SortBy';\n    static ASCENDING_STATE_KEY = 'IsAscending';\n\n    static MINIMUM_COLUMN_WIDTH = 72;\n\n    @Input() \n    set sorting(value: IPepListSortingData) {\n        this.sortBy = value?.sortBy || '';\n        this.isAsc = value?.sortBy.length > 0 ? value.isAsc : this.isAsc;\n    }\n    get sorting(): IPepListSortingData {\n        return {\n            sortBy: this.sortBy,\n            isAsc: this.isAsc\n        };\n    }\n    \n    @Input() cacheSize = -1;\n    @Input() noDataFoundMsg: string = null;\n    @Input() selectionTypeForActions: PepListSelectionType = 'multi';\n    @Input() showCardSelection = false;\n    @Input() hideAllSelectionInMulti = false;\n\n    @Input() cardSize: PepListCardSizeType = 'md';\n    @Input() tableViewType: PepListTableViewType = 'regular';\n    \n    private _viewType: PepListViewType = '';\n    @Input()\n    set viewType(value: PepListViewType) {\n        this._viewType = value;\n        this.isTable = value === 'table';\n    }\n    get viewType(): PepListViewType {\n        return this._viewType;\n    }\n\n    @Input() firstFieldAsLink = false;\n    @Input() supportSorting = true;\n    @Input() supportSortingFields: string[] = undefined;\n    @Input() supportResizing = true;\n\n    private _parentScroll: Element | Window = null;\n    @Input()\n    set parentScroll(value: Element | Window) {\n        this._parentScroll = value;\n    }\n    get parentScroll(): Element | Window {\n        return this._parentScroll;\n    }\n\n    @Input() disabled = false;\n\n    private _lockEvents = false;\n    @Input()\n    set lockEvents(value: boolean) {\n        this._lockEvents = value;\n\n        if (this._lockEvents) {\n            this.renderer.addClass(this.hostElement.nativeElement, 'lock-events');\n        } else {\n            this.renderer.removeClass(this.hostElement.nativeElement, 'lock-events');\n        }\n    }\n    get lockEvents(): boolean {\n        return this._lockEvents;\n    }\n\n    @Input() lockItemInnerEvents = false;\n    @Input() printMode = false;\n    @Input() isReport = false;\n    @Input() zebraStripes = false;\n    @Input() totalsRow = [];\n    @Input() pagerType: PepListPagerType = 'scroll';\n    @Input() pageSize: number = DEFAULT_PAGE_SIZE;\n    @Input() pageIndex = 0;\n    // @Input() startIndex = 0;\n\n    @Input() bufferAmount = 0;\n    @Input() scrollAnimationTime = 500;\n    @Input() scrollDebounceTime = 0;\n    @Input() scrollThrottlingTime = 0;\n    @Input() SEPARATOR = ',';\n    private _useAsWebComponent = false;\n    @Input()\n    set useAsWebComponent(value: boolean) {\n        this._useAsWebComponent = value;\n        if (value) {\n            this.exportFunctionsOnHostElement();\n        }\n    }\n    get useAsWebComponent(): boolean {\n        return this._useAsWebComponent;\n    }\n\n    @Output()\n    itemClick: EventEmitter<IPepListItemClickEvent> = new EventEmitter<IPepListItemClickEvent>();\n\n    @Output()\n    fieldClick: EventEmitter<IPepFormFieldClickEvent> = new EventEmitter<IPepFormFieldClickEvent>();\n\n    @Output()\n    valueChange: EventEmitter<IPepFormFieldValueChangeEvent> = new EventEmitter<IPepFormFieldValueChangeEvent>();\n\n    @Output()\n    sortingChange: EventEmitter<IPepListSortingChangeEvent> = new EventEmitter<IPepListSortingChangeEvent>();\n\n    @Output()\n    selectedItemsChange: EventEmitter<number> = new EventEmitter<number>();\n\n    @Output()\n    selectedItemChange: EventEmitter<any> = new EventEmitter<any>();\n\n    @Output()\n    selectAllClick: EventEmitter<any> = new EventEmitter<any>();\n\n    // @Output()\n    // singleActionClick: EventEmitter<any> = new EventEmitter<any>();\n\n    @Output()\n    listLoad: EventEmitter<void> = new EventEmitter<void>();\n\n    @Output()\n    loadItems: EventEmitter<IPepListLoadItemsEvent> = new EventEmitter<IPepListLoadItemsEvent>();\n\n    @Output()\n    loadPage: EventEmitter<IPepListLoadPageEvent> = new EventEmitter<IPepListLoadPageEvent>();\n\n    @Output()\n    startIndexChange: EventEmitter<IPepListStartIndexChangeEvent> = new EventEmitter<IPepListStartIndexChangeEvent>();\n\n    @ViewChild(VirtualScrollerComponent) private virtualScroller: VirtualScrollerComponent;\n    @ViewChild('selectAllCB') selectAllCB: any;\n\n    private _layout: UIControl = null;\n    get layout(): UIControl {\n        return this._layout;\n    }\n\n    totalRows = -1;\n    isTable = false;\n    private hasColumnWidthOfTypePercentage = true;\n\n    private _items: Array<ObjectsDataRow> = null;\n    get items(): Array<ObjectsDataRow> {\n        return this._items;\n    }\n\n    private itemsCounter = 0;\n\n    currentPageItems: Array<ObjectsDataRow>;\n\n\n    isAllSelected = false;\n    selectedItems = new Map<string, string>();\n    unSelectedItems = new Map<string, string>();\n\n    private currentTween: any;\n\n    selectedItemId = '';\n    hoveredItemId = '';\n\n    private containerWidth = 0;\n    private tableScrollWidth = 0;\n\n    private _loadingItemsFromApi = false;\n    get loadingItemsFromApi() {\n        return this._loadingItemsFromApi;\n    }\n\n    screenSize: PepScreenSizeType;\n    deviceHasMouse = false;\n\n    // For resize\n    pressedColumn = '';\n    pressedColumnIndex = -1;\n    startX = 0;\n    startWidth = 0;\n    tableStartWidth = 0;\n    \n    private lastColumnsWidth: Array<{ columnAPIName: string, calcColumnWidth: number, calcTitleColumnWidthString: string, calcColumnWidthString: string }> = [];\n\n    // For sorting\n    isAsc = false;\n    sortBy = '';\n    isUserSelected = false;\n    checkForChanges: any = null;\n    calculatedObjectHeight = 'auto';\n\n    constructor(\n        private hostElement: ElementRef,\n        private layoutService: PepLayoutService,\n        private sessionService: PepSessionService,\n        private cd: ChangeDetectorRef,\n        private renderer: Renderer2,\n        private zone: NgZone\n    ) {\n        // this.nativeWindow = window;\n        this.layoutService.onResize$.subscribe((size: PepScreenSizeType) => {\n            this.screenSize = size;\n        });\n\n        this.layoutService.onMouseOver$.subscribe((deviceHasMouse: boolean) => {\n            this.deviceHasMouse = deviceHasMouse;\n        });\n    }\n\n    ngOnInit(): void {\n        this.containerWidth = 0;\n        this.deviceHasMouse = this.layoutService.getDeviceHasMouse();\n    }\n\n    ngOnChanges(changes): void {\n        if (this.containerWidth <= 0) {\n            this.setContainerWidth();\n        }\n    }\n\n    ngOnDestroy(): void {\n        // if (this.valueChange) {\n        //     this.valueChange.unsubscribe();\n        // }\n\n        // if (this.loadItems) {\n        //     this.loadItems.unsubscribe();\n        // }\n\n        // if (this.loadPage) {\n        //     this.loadPage.unsubscribe();\n        // }\n\n        // if (this.sortingChange) {\n        //     this.sortingChange.unsubscribe();\n        // }\n\n        // if (this.fieldClick) {\n        //     this.fieldClick.unsubscribe();\n        // }\n\n        // if (this.itemClick) {\n        //     this.itemClick.unsubscribe();\n        // }\n\n        // if (this.listLoad) {\n        //     this.listLoad.unsubscribe();\n        // }\n\n        this.saveSortingToSession();\n    }\n\n    getCachedItemsNumber() {\n        return this.cacheSize >= 0 ? this.cacheSize : PepListComponent.TOP_ITEMS_ARRAY;\n    }\n\n    private getScrollingElement() {\n        return this.parentScroll ? this.parentScroll : this.virtualScroller?.contentElementRef.nativeElement.parentElement;\n    }\n\n    private scrollToTop(animate = true) {\n        const scrollingElement = this.getScrollingElement();\n        if (scrollingElement) {\n            const scrollTop = 0;\n\n            // totally disable animate\n            if (!animate || this.scrollAnimationTime === 0) {\n                if (scrollingElement instanceof Window) {\n                    window.scrollTo(0, scrollTop);\n                } else {\n                    scrollingElement.scrollTop = scrollTop;\n                }\n            } else {\n                let animationRequest;\n                const isWindow = scrollingElement instanceof Window;\n                const currentScrollTop =\n                    scrollingElement instanceof Window\n                        ? window.pageYOffset\n                        : scrollingElement.scrollTop;\n\n                if (this.currentTween !== undefined) {\n                    this.currentTween.stop();\n                }\n                this.currentTween = new tween.Tween({ scrollTop: currentScrollTop })\n                    .to({ scrollTop }, this.scrollAnimationTime)\n                    .easing(tween.Easing.Quadratic.Out)\n                    .onUpdate((data) => {\n                        if (isNaN(data.scrollTop)) {\n                            return;\n                        }\n\n                        if (isWindow) {\n                            window.scrollTo(0, data.scrollTop);\n                        } else {\n                            this.renderer.setProperty(\n                                scrollingElement,\n                                'scrollTop',\n                                data.scrollTop\n                            );\n                        }\n                    })\n                    .onStop(() => {\n                        cancelAnimationFrame(animationRequest);\n                    })\n                    .start();\n\n                const animate = (time?) => {\n                    this.currentTween.update(time);\n                    if (this.currentTween._object.scrollTop !== scrollTop) {\n                        this.zone.runOutsideAngular(() => {\n                            animationRequest = requestAnimationFrame(animate);\n                        });\n                    }\n                };\n\n                animate();\n            }\n        }\n    }\n\n    private getSelectionCheckBoxWidth(): number {\n        return this.selectionTypeForActions === 'multi' ? 44 : (this.selectionTypeForActions === 'single' ? 44 : 0);\n    }\n\n    private setContainerWidth(): void {\n        if (!this.hostElement.nativeElement.parentElement) {\n            return;\n        }\n\n        const rowHeight = 40; // the table row height (2.5rem * 16font-size).\n        const style = getComputedStyle(\n            this.hostElement.nativeElement.parentElement\n        );\n        // The container-fluid class padding left + right + border\n        const containerFluidSpacing =\n            parseInt(style.paddingLeft, 10) + parseInt(style.paddingRight, 10);\n\n        const parentContainer =\n            this.hostElement.nativeElement.parentElement.parentElement > 0\n                ? this.hostElement.nativeElement.parentElement.parentElement\n                : this.hostElement.nativeElement.parentElement;\n\n        // Calculate if vertical scroll should appear, if so set the scroll width. (this.totalRows + 1) + 1 is for the header row.\n        this.tableScrollWidth = parentContainer.clientHeight < rowHeight * (this.totalRows + 1)\n            ? this.layoutService.getScrollbarWidth()\n            : 0;\n\n        // The selectionCheckBoxWidth width + containerFluidSpacing + this.tableScrollWidth.\n        const rowHeaderWidthToSub =\n            containerFluidSpacing + this.getSelectionCheckBoxWidth() + this.tableScrollWidth;\n        this.containerWidth = parentContainer.offsetWidth - rowHeaderWidthToSub;\n    }\n\n    private saveSortingToSession(): void {\n        this.sessionService.setObject(\n            PepListComponent.SORT_BY_STATE_KEY,\n            this.sortBy\n        );\n        this.sessionService.setObject(\n            PepListComponent.ASCENDING_STATE_KEY,\n            this.isAsc\n        );\n    }\n\n    private getTopItems(): number {\n        return this.isTable\n            ? PepListComponent.TOP_ITEMS_TABLE\n            : PepListComponent.TOP_ITEMS_THUMBNAILS;\n    }\n\n    private disableScroll(disable: boolean) {\n        if (disable) {\n            this.renderer.addClass(this.hostElement.nativeElement.parentElement, 'lock-events');\n        } else {\n            this.renderer.removeClass(this.hostElement.nativeElement.parentElement, 'lock-events');\n        }\n    }\n\n    private toggleLoadingItemsFropApi(loadingItemsFromApi: boolean): void {\n        this._loadingItemsFromApi = loadingItemsFromApi;\n\n        // this.disableScroll(loadingItemsFromApi);\n    }\n\n    private updateCurrentPageItems(startIndex: number, endIndex: number): void {\n        this.currentPageItems = this.items.slice(startIndex, endIndex);\n    }\n\n    private setSelectionItems(\n        itemId: string,\n        uniqItemId: string,\n        isChecked: boolean\n    ): void {\n        // Set selected item checkbox\n        if (this.isAllSelected) {\n            if (isChecked) {\n                this.unSelectedItems.delete(itemId);\n                this.selectedItems.set(itemId, uniqItemId);\n            } else {\n                this.selectedItems.delete(itemId);\n                this.unSelectedItems.set(itemId, uniqItemId);\n            }\n        } else {\n            if (isChecked) {\n                this.unSelectedItems.delete(itemId);\n                this.selectedItems.set(itemId, uniqItemId);\n            } else {\n                this.selectedItems.delete(itemId);\n                this.unSelectedItems.set(itemId, uniqItemId);\n            }\n        }\n    }\n\n    private getUniqItemId(itemId: string, itemType = ''): string {\n        return itemId + this.SEPARATOR + itemType;\n    }\n\n    private setLayout(): void {\n        if (\n            this.totalRows === 0 ||\n            !this._layout ||\n            !this._layout.ControlFields ||\n            this._layout.ControlFields.length === 0\n        ) {\n            return;\n        }\n\n        this._layout.ControlFields.forEach((cf) => {\n            if (cf.ColumnWidth === 0) {\n                cf.ColumnWidth = 10;\n            }\n\n            if (\n                this.isTable &&\n                (cf.FieldType === FIELD_TYPE.Image ||\n                    // cf.FieldType === FIELD_TYPE.Indicators || ???\n                    cf.FieldType === FIELD_TYPE.Signature ||\n                    cf.FieldType === FIELD_TYPE.NumberIntegerQuantitySelector ||\n                    cf.FieldType === FIELD_TYPE.NumberRealQuantitySelector ||\n                    cf.FieldType === FIELD_TYPE.NumberIntegerForMatrix ||\n                    cf.FieldType === FIELD_TYPE.NumberRealForMatrix ||\n                    cf.FieldType === FIELD_TYPE.Package ||\n                    cf.ApiName === 'UnitsQuantity' ||\n                    cf.ApiName === 'QuantitySelector')\n            ) {\n                cf.Layout.XAlignment = 3;\n            }\n        });\n\n        if (!this.cd['destroyed']) {\n            this.cd.detectChanges();\n        }\n\n        // Set the container width.\n        if (this.containerWidth <= 0) {\n            this.setContainerWidth();\n        }\n\n        const isLastColumnsWidthSet = this.setLastColumnsWidth();\n            \n        // Set the layout only if the last columns width couldn't set.\n        if (!isLastColumnsWidthSet) {\n            this.calcColumnsWidth();\n        }\n        \n        this.checkForChanges = new Date().getTime();\n    }\n\n    private setLastColumnsWidth(): boolean {\n        let res = false;\n\n        let totalCalcColsWidth = 0;\n        let widthToSet = 'inherit';\n\n        if (this.lastColumnsWidth.length > 0) {\n            // Check if this is the same UI control for table.\n            if (this.lastColumnsWidth.length === this._layout.ControlFields.length) {\n                let uiControlsAreTheSame = true;\n\n                for (let index = 0; index < this._layout.ControlFields.length; index++) {\n                    const uiControlField: UIControlField = this._layout.ControlFields[index];\n                    \n                    if (uiControlField.ApiName !== this.lastColumnsWidth[index].columnAPIName) {\n                        uiControlsAreTheSame = false;\n                        break;\n                    }\n                }\n    \n                if (uiControlsAreTheSame) {\n                    for (let index = 0; index < this._layout.ControlFields.length; index++) {\n                        const uiControlField: UIControlField = this._layout.ControlFields[index];\n                        uiControlField.calcColumnWidth = this.lastColumnsWidth[index].calcColumnWidth;\n                        uiControlField.calcTitleColumnWidthString = this.lastColumnsWidth[index].calcTitleColumnWidthString;\n                        uiControlField.calcColumnWidthString = this.lastColumnsWidth[index].calcColumnWidthString;\n                        totalCalcColsWidth += this.lastColumnsWidth[index].calcColumnWidth;\n                    }\n                    \n                    widthToSet = (totalCalcColsWidth + this.getSelectionCheckBoxWidth()) + 'px'\n                    console.log(`setLastColumnsWidth -> widthToSet: ${widthToSet} *** totalCalcColsWidth: ${totalCalcColsWidth}`);\n                    this.setColumnsWidth(widthToSet);\n\n                    res = true;\n                }\n            }\n        }\n        return res;\n    }\n\n    private setVirtualScrollWidth(widthToSet: string) {\n        if (this.virtualScroller) {\n            this.renderer.setStyle(\n                this.virtualScroller.contentElementRef.nativeElement,\n                'width',\n                widthToSet === 'inherit' ? '100%' : widthToSet\n            );\n        }\n    }\n\n    private setColumnsWidth(widthToSet: string) {\n        // this.renderer.setStyle(\n        //     this.hostElement.nativeElement,\n        //     'width',\n        //     widthToSet\n        // );\n        this.renderer.setStyle(\n            this.listContainerResizableElementRef.nativeElement,\n            'width',\n            widthToSet\n        );\n\n        if (this.isTable) {\n            this.setVirtualScrollWidth(widthToSet);\n        } else {\n            // Do this only after UI is change cause the property isTable is Input and can refresh after this thread.\n            setTimeout(() => {\n                this.setVirtualScrollWidth(widthToSet);\n            }, 0);\n        }\n    }\n\n    private calcColumnsWidth(): void {\n        const fixedMultiple = 3.78; // for converting em to pixel.\n        const length = this._layout.ControlFields.length;\n        \n        // Is table AND there is at least one column of width type of percentage.\n        if (this.isTable) {\n            if (this._layout && this._layout.ControlFields) {\n                this.hasColumnWidthOfTypePercentage =\n                    this._layout.ControlFields.filter(\n                        (cf) => cf.ColumnWidthType === 1\n                    ).length === 0;\n            }\n        }\n\n        // If the columns size is fixed and the total is small then the container change it to percentage.\n        if (!this.hasColumnWidthOfTypePercentage) {\n            const totalFixedColsWidth = this._layout.ControlFields.map(\n                (cf) => cf.ColumnWidth * fixedMultiple\n            ).reduce((sum, current) => sum + current);\n\n            if (window.innerWidth > totalFixedColsWidth) {\n                this.hasColumnWidthOfTypePercentage = true;\n            }\n        }\n\n        let totalCalcColsWidth = 0;\n\n        let widthToSet = 'inherit';\n\n        // Calc by percentage\n        if (this.hasColumnWidthOfTypePercentage) {\n            const totalColsWidth: number = this._layout.ControlFields.map(\n                (cf) => cf.ColumnWidth\n            ).reduce((sum, current) => sum + current);\n\n            for (let index = 0; index < length; index++) {\n                const uiControlField: UIControlField = this._layout.ControlFields[index];\n                const calcColumnWidthPercentage = (100 / totalColsWidth) * uiControlField.ColumnWidth;\n\n                uiControlField.calcColumnWidth = Math.floor((this.containerWidth * calcColumnWidthPercentage) / 100);\n\n                if (index === length - 1) {\n                    uiControlField.calcTitleColumnWidthString = uiControlField.calcColumnWidthString = 'calc(100% - ' + totalCalcColsWidth + 'px)'; // For 100%\n                } else {\n                    uiControlField.calcTitleColumnWidthString = uiControlField.calcColumnWidthString = uiControlField.calcColumnWidth + 'px';\n                    totalCalcColsWidth += uiControlField.calcColumnWidth;\n                }\n            }\n        } else {\n            for (let index = 0; index < length; index++) {\n                const uiControlField: UIControlField = this._layout\n                    .ControlFields[index];\n                const currentFixedWidth = Math.floor(\n                    uiControlField.ColumnWidth * fixedMultiple\n                );\n\n                if (index === length - 1) {\n                    uiControlField.calcTitleColumnWidthString = uiControlField.calcColumnWidthString = currentFixedWidth + 'px';\n                } else {\n                    uiControlField.calcTitleColumnWidthString = uiControlField.calcColumnWidthString = currentFixedWidth + 'px';\n                }\n\n                totalCalcColsWidth += currentFixedWidth;\n            }\n\n            widthToSet = (totalCalcColsWidth + this.getSelectionCheckBoxWidth()) + 'px'\n        }\n\n        console.log(`calcColumnsWidth -> widthToSet: ${widthToSet} *** totalCalcColsWidth: ${totalCalcColsWidth}`);\n        this.setColumnsWidth(widthToSet);\n    }\n\n    private calcObjectHeight() {\n        setTimeout(() => {\n            if (this.virtualScroller) {\n                const content = this.virtualScroller.getContent();\n                console.log(`content.children.length: ${content.children.length}`);\n\n                if (content.children.length > 0) {\n                    const rect = this.virtualScroller.getElementSize(content.children[0]);\n                    this.calculatedObjectHeight = rect.height + 'px';\n                    console.log(`this.calculatedObjectHeight: ${this.calculatedObjectHeight}`);\n                }\n            }\n            this.disableScroll(false);\n        }, 1000);\n    }\n\n    private initResizeData(): void {\n        this.startX = 0;\n        this.startWidth = 0;\n        this.tableStartWidth = 0;\n        this.pressedColumn = '';\n        this.pressedColumnIndex = -1;\n    }\n\n    private getParent(el, parentSelector): any {\n        // If no parentSelector defined will bubble up all the way to *document*\n        if (parentSelector === undefined) {\n            parentSelector = document;\n        }\n        const parent = [];\n        let p = el.parentNode;\n\n        while (\n            p &&\n            p.className !== '' &&\n            p.className.indexOf(parentSelector) === -1 &&\n            parentSelector !== document\n        ) {\n            const o = p;\n            p = o.parentNode;\n        }\n        if (p.className.indexOf(parentSelector) > -1) {\n            parent.push(p); // Push that parentSelector you wanted to stop at\n        }\n        return parent;\n    }\n\n    private cleanItems(): void {\n        this.itemsCounter = 0;\n        this._items =\n            this.totalRows > 0 ? Array<ObjectsDataRow>(this.totalRows) : [];\n        this.currentPageItems = [];\n        this.calculatedObjectHeight = 'auto';\n    }\n\n    private initVariablesFromSession(items: ObjectsDataRow[]): void {\n        const selectedItemsObject: Array<any> = this.sessionService.getObject<\n            Array<any>\n        >(PepListComponent.SELECTED_ITEMS_STATE_KEY);\n        const selectedItemsFromMap: Map<string, string> =\n            selectedItemsObject && selectedItemsObject.length > 0\n                ? new Map(selectedItemsObject)\n                : null;\n        if (\n            selectedItemsFromMap != null &&\n            typeof selectedItemsFromMap.size !== 'undefined' &&\n            selectedItemsFromMap.size > 0\n        ) {\n            this.selectedItems = selectedItemsFromMap;\n            this.sessionService.removeObject(\n                PepListComponent.SELECTED_ITEMS_STATE_KEY\n            );\n        } else {\n            this.selectedItems.clear();\n        }\n\n        const unSelectedItemsObject: Array<any> = this.sessionService.getObject<\n            Array<any>\n        >(PepListComponent.UN_SELECTED_ITEMS_STATE_KEY);\n        const unSelectedItemsMap: Map<string, string> =\n            unSelectedItemsObject && unSelectedItemsObject.length > 0\n                ? new Map(unSelectedItemsObject)\n                : null;\n        if (\n            unSelectedItemsMap != null &&\n            typeof unSelectedItemsMap.size !== 'undefined' &&\n            unSelectedItemsMap.size > 0\n        ) {\n            this.unSelectedItems = unSelectedItemsMap;\n            this.sessionService.removeObject(\n                PepListComponent.UN_SELECTED_ITEMS_STATE_KEY\n            );\n        } else {\n            this.unSelectedItems.clear();\n        }\n\n        const isAllSelected = this.sessionService.getObject(\n            PepListComponent.ALL_SELECTED_STATE_KEY\n        );\n        if (isAllSelected != null) {\n            // Comment this in version 0.4.2-beta.103, I don't know why we need this (&& this.getIsAllSelected(items))\n            // this.isAllSelected = isAllSelected && this.getIsAllSelected(items);\n            this.isAllSelected = isAllSelected;\n            this.sessionService.removeObject(\n                PepListComponent.ALL_SELECTED_STATE_KEY\n            );\n        } else {\n            this.isAllSelected = false;\n        }\n\n        const sortBy = this.sessionService.getObject(\n            PepListComponent.SORT_BY_STATE_KEY\n        );\n        if (sortBy && sortBy !== '') {\n            this.sortBy = sortBy;\n            this.sessionService.removeObject(\n                PepListComponent.SORT_BY_STATE_KEY\n            );\n        } else {\n            this.sortBy = '';\n        }\n\n        const isAsc = this.sessionService.getObject(\n            PepListComponent.ASCENDING_STATE_KEY\n        );\n        if (isAsc != null) {\n            this.isAsc = isAsc;\n            this.sessionService.removeObject(\n                PepListComponent.ASCENDING_STATE_KEY\n            );\n        } else {\n            this.isAsc = true;\n        }\n    }\n\n    private getIsAllSelected(items: Array<ObjectsDataRow>): boolean {\n        let result = true;\n\n        if (this.selectedItems?.size > 0 && items?.length > 0) {\n            for (const item of items) {\n                if (!(item && this.selectedItems.has(item?.UID.toString()))) {\n                    result = false;\n                    break;\n                }\n            }\n        } else {\n            result = false;\n        }\n\n        return result;\n    }\n\n    private getNumberOfStartItems(): number {\n        let numberOfStartItems = 20;\n\n        if (\n            this.screenSize === PepScreenSizeType.XL ||\n            this.screenSize === PepScreenSizeType.LG\n        ) {\n            numberOfStartItems = this.isTable ? 50 : 40;\n        } else if (this.screenSize === PepScreenSizeType.MD) {\n            numberOfStartItems = this.isTable ? 30 : 20;\n        } else if (this.screenSize === PepScreenSizeType.SM) {\n            numberOfStartItems = this.isTable ? 20 : 10;\n        } else if (this.screenSize === PepScreenSizeType.XS) {\n            numberOfStartItems = this.isTable ? 15 : 5;\n        }\n\n        return numberOfStartItems;\n    }\n\n    private setItemClicked(\n        itemId,\n        isSelectableForActions: boolean,\n        itemType: string,\n        isChecked: boolean\n    ): void {\n        const uniqItemId = this.getUniqItemId(itemId, itemType);\n\n        // select the selected item.\n        if (isChecked) {\n            // Set seleted item\n            this.selectedItemId = uniqItemId;\n        } else {\n            if (this.selectedItemId === uniqItemId) {\n                this.selectedItemId = '';\n            }\n        }\n\n        if (this.selectionTypeForActions === 'single') {\n            this.selectedItemsChange.emit(\n                this.selectedItemId.length === 0 ? 0 : 1\n            );\n        } else if (this.selectionTypeForActions === 'multi') {\n            if (isSelectableForActions) {\n                this.setSelectionItems(itemId, uniqItemId, isChecked);\n\n                const currentList = this.isAllSelected\n                    ? this.unSelectedItems\n                    : this.selectedItems;\n                const currentListCount = this.isAllSelected\n                    ? this.totalRows - currentList.size\n                    : currentList.size;\n                this.selectedItemsChange.emit(currentListCount);\n            }\n        }\n\n        // Raise selected item change event\n        if (this.selectionTypeForActions !== 'none') {\n            this.selectedItemChange.emit({\n                id: itemId,\n                selected: isChecked,\n            });\n        }\n    }\n\n    private exportFunctionsOnHostElement() {\n        // This is for web component usage for use those functions.\n        this.hostElement.nativeElement.clear = this.clear.bind(this);\n        this.hostElement.nativeElement.initListData = this.initListData.bind(\n            this\n        );\n        this.hostElement.nativeElement.updateItems = this.updateItems.bind(\n            this\n        );\n        this.hostElement.nativeElement.updatePage = this.updatePage.bind(this);\n        this.hostElement.nativeElement.updateItem = this.updateItem.bind(this);\n    }\n\n    // For refresh the UI when change the is selectable for action on item.\n    getisItemDisabled(item: ObjectsDataRow): boolean {\n        return this.printMode || this.lockItemInnerEvents || (item && !item.IsSelectableForActions)\n    }\n\n    getIsAllSelectedForActions(): boolean {\n        let res = false;\n\n        if (this.isAllSelected) {\n            if (this.unSelectedItems.size === 0) {\n                res = true;\n            }\n        } else {\n            if (this.virtualScroller?.viewPortItems) {\n                if (this.selectedItems.size === this.totalRows) {\n                    res = this.getIsAllSelected(this.virtualScroller.viewPortItems);\n                } else if (this.selectedItems.size < this.totalRows) {\n                    for (const item of this.virtualScroller.viewPortItems) {\n                        res =\n                            item && this.selectedItems.has(item?.UID.toString());\n\n                        if (!res) {\n                            break;\n                        }\n                    }\n                }\n            }\n        }\n\n        return res;\n    }\n\n    setIsAllSelected(isChecked: boolean): void {\n        if (this.selectionTypeForActions === 'multi') {\n            this.selectAllCB.checked = isChecked;\n            this.isAllSelected = isChecked;\n        }\n    }\n\n    selectAllItemsForActions(e: any): void {\n        // For material checkbox || radio.\n        const isChecked = e.source.checked;\n\n        // Indeterminate mode\n        let isIndeterminate = false;\n        const currentList = this.isAllSelected\n            ? this.unSelectedItems\n            : this.selectedItems;\n        if (currentList.size > 0) {\n            isIndeterminate = true;\n            this.isAllSelected = false;\n            this.selectedItemsChange.emit(0);\n            e.source.checked = false;\n        }\n\n        this.selectedItems.clear();\n        this.unSelectedItems.clear();\n\n        if (!isIndeterminate) {\n            this.isAllSelected = isChecked;\n            this.selectAllClick.emit(isChecked);\n\n            if (this.selectionTypeForActions === 'multi') {\n                if (!isChecked) {\n                    this.selectedItemsChange.emit(0);\n                    this.selectedItemId = '';\n                } else {\n                    const filteredItems = this.items.filter(\n                        (item) => item && item.IsSelectableForActions\n                    );\n                    this.selectedItemsChange.emit(filteredItems.length);\n                }\n            }\n        } else {\n            // Remove all\n            if (this.selectionTypeForActions === 'multi') {\n                this.selectAllClick.emit(false);\n            }\n        }\n    }\n\n    raiseStartIndexChange(startIndex = 0) {\n        // this.startIndex = startIndex;\n        this.startIndexChange.emit({ startIndex });\n    }\n\n    getIsItemSelected(item: ObjectsDataRow): boolean {\n        let isSelected = false;\n\n        if (item) {\n            if (this.selectionTypeForActions === 'single') {\n                isSelected = this.selectedItemId === this.getUniqItemId(item.UID, item.Type.toString());\n            } else if (this.selectionTypeForActions === 'multi') {\n                if (item.IsSelectableForActions) {\n                    isSelected = (this.isAllSelected && !this.unSelectedItems.has(item.UID)) || this.selectedItems.has(item.UID);\n                }\n            }\n        }\n\n        return isSelected;\n    }\n\n    selectItemForActions(\n        e: any,\n        itemId: string,\n        isSelectableForActions: boolean,\n        itemType = ''\n    ): void {\n        // For material checkbox || radio.\n        const isChecked = e.source.checked;\n        this.setItemClicked(\n            itemId,\n            isSelectableForActions,\n            itemType,\n            isChecked\n        );\n    }\n\n    itemClicked(e: any, item: ObjectsDataRow): void {\n        // Set seleted item\n        const itemId = item?.UID.toString();\n        const itemType = item?.Type.toString();\n        let isChecked = false;\n\n        if (item && item.IsSelectableForActions) {\n            this.selectedItemId = this.getUniqItemId(itemId, itemType);\n            isChecked = true;\n        }\n        // TODO - need to check what we want to do line view\n        if (this.isTable || this.viewType === 'cards') {\n            if (this.selectionTypeForActions === 'single') {\n                this.setItemClicked(\n                    itemId,\n                    item.IsSelectableForActions,\n                    itemType,\n                    isChecked\n                );\n            } else if (this.selectionTypeForActions === 'none') {\n                // Just mark the row as highlighted\n                this.setItemClicked(\n                    itemId,\n                    item.IsSelectableForActions,\n                    itemType,\n                    true\n                );\n            }\n        } else {\n            if (this.disabled) {\n                return;\n            }\n        }\n\n        this.itemClick.emit({ source: item, viewType: this.viewType });\n    }\n\n    onTableRowMouseEnter(event: any, itemId: string, itemType: string): void {\n        if (!this.deviceHasMouse) {\n            return;\n        }\n\n        const uniqItemId = this.getUniqItemId(itemId, itemType);\n        this.hoveredItemId = uniqItemId;\n    }\n\n    onTableRowMouseLeave(event: any, itemId: string, itemType: string): void {\n        this.hoveredItemId = '';\n    }\n\n    onTabKeydown(event: any, itemId: string, itemType: string): void {\n        const keyboardEvent = event as KeyboardEvent;\n        if (keyboardEvent.key === 'Tab') {\n\n                const jumpToNextRow = !keyboardEvent.shiftKey;\n\n                const eventTarget = event.target || event.srcElement;\n                const isLastColumn = this.isLastColunm(eventTarget, 'table-cell', jumpToNextRow);\n\n                // If the last column then go to the next row.\n                if(isLastColumn) {\n                    const currentRowEL = this.getParentByClass(eventTarget, 'table-row');\n                    const nextRow = jumpToNextRow ? currentRowEL?.nextElementSibling : currentRowEL?.previousElementSibling;\n                    if (nextRow !== null) {\n                        // Remove the highlight from the current row.\n                        this.renderer.removeClass(nextRow, 'highlighted');\n                        // Highlight the next row.\n                        this.renderer.addClass(nextRow, 'highlighted');\n                        // Click on the first cell of the next row.\n                            const indexOfFocusCell = jumpToNextRow ? 0 : nextRow.querySelectorAll('.table-cell').length - 1;\n                            nextRow.querySelectorAll('.table-cell')[indexOfFocusCell].click(); \n                            setTimeout(() => {\n                                nextRow.querySelectorAll('.table-cell')[indexOfFocusCell].focus();\n                            }, 100);\n                      \n                        \n                    }\n                }\n            }\n    }\n\n    isLastColunm(el, parentSelector, isNext = true): boolean {\n        const parent = this.getParentByClass(el, parentSelector);\n        // check if last column or if shifr pressed and it's the first column\n        return isNext ? (parent?.nextElementSibling) === null : (parent?.previousElementSibling === null);\n    }\n\n    getParentByClass(el, parentSelector /* optional */): any {\n        // If no parentSelector defined will bubble up all the way to *document*\n        if (parentSelector === undefined) {\n            parentSelector = document;\n        }\n\n        let p = el.parentNode;\n\n        while (\n            p &&\n            !p?.classList?.contains(parentSelector) &&\n            parentSelector !== document\n        ) {\n            const o = p;\n            p = o?.parentNode || null;\n        }\n\n        return p?.className.indexOf(parentSelector) > -1 ? p : null;\n    }\n    onCardMouseEnter(event: any, itemId: string, itemType: string): void {\n        if (!this.deviceHasMouse) {\n            return;\n        }\n\n        const uniqItemId = this.getUniqItemId(itemId, itemType);\n        this.hoveredItemId = uniqItemId;\n    }\n\n    onCardMouseLeave(event: any, itemId: string, itemType: string): void {\n        this.hoveredItemId = '';\n    }\n\n    // trackByFunc(index: number, item: ObjectsDataRow): any {\n    //     return item && item?.UID ? item?.UID : index;\n    //     // let res: string = \"\";\n\n    //     // if (item && item?.UID) {\n    //     //    res = item?.UID + \"_\" + this.listType + \"_\" + (this.isTable ? \"Table\" : \"Thumbnails\");\n    //     // }\n    //     // else {\n    //     //    res = index + \"_\" + this.listType + \"_\" + (this.isTable ? \"Table\" : \"Thumbnails\");\n    //     // }\n\n    //     // return res;\n    // }\n\n    clear(): void {\n        this.cleanItems();\n        this._layout = null;\n    }\n\n    setSelectedIds(selectedIds: string[], items = null): void {\n        this.selectedItems.clear();\n        this.isAllSelected = false;\n\n        if (selectedIds) {\n            // for (let i = 0; i < selected.length; i++) {\n            for (const selectedId of selectedIds) {\n                const tmp = selectedId.split(this.SEPARATOR);\n\n                if (tmp && tmp.length > 0) {\n                    const itemId = tmp[0];\n                    const itemType = tmp.length > 1 ? tmp[1] : '';\n\n                    this.selectedItems.set(\n                        itemId,\n                        this.getUniqItemId(itemId, itemType)\n                    );\n                }\n            }\n\n            this.isAllSelected = this.getIsAllSelected(items ? items : this.virtualScroller?.viewPortItems);\n            this.setSelectionDataInSession();\n        }\n\n        this.refresh();\n    }\n\n    setSelectionDataInSession(): void {\n        if (this.selectedItems.size > 0) {\n            this.sessionService.setObject(\n                PepListComponent.SELECTED_ITEMS_STATE_KEY,\n                JSON.stringify([...this.selectedItems])\n            );\n        }\n\n        if (this.unSelectedItems.size > 0) {\n            this.sessionService.setObject(\n                PepListComponent.UN_SELECTED_ITEMS_STATE_KEY,\n                JSON.stringify([...this.unSelectedItems])\n            );\n        }\n\n        this.sessionService.setObject(\n            PepListComponent.ALL_SELECTED_STATE_KEY,\n            this.isAllSelected\n        );\n    }\n\n    initListData(\n        layout: UIControl,\n        totalRows: number,\n        items: ObjectsDataRow[],\n        selectionTypeForActions: PepListSelectionType | undefined = undefined\n    ): void {\n        this.initVariablesFromSession(items);\n        const selectedItemsList = this.isAllSelected\n            ? this.unSelectedItems\n            : this.selectedItems;\n        const currentListCount = this.isAllSelected\n            ? this.totalRows - selectedItemsList.size\n            : selectedItemsList.size;\n        this.selectedItemsChange.emit(currentListCount);\n\n        this._layout = layout;\n        this.selectedItemId = ''; \n        this.totalRows = totalRows;\n\n        // Added to handle if the selectionTypeForActions is set in the html then the input this.selectedItemId will no set cause this function happens before.\n        if (selectionTypeForActions) {\n            this.selectionTypeForActions = selectionTypeForActions;\n        }\n\n        // If is all selected is false && the size of the selected items is 1 && selectionTypeForActions is 'single' then set it as the selected item id.\n        // We need this in setTimeout cause the selectionTypeForActions is input that can set after this function.\n        if (!this.isAllSelected && this.selectedItems.size === 1 && this.selectionTypeForActions === 'single') {\n            const [firstValue] = this.selectedItems.values();\n            this.selectedItemId = firstValue;\n        }\n        \n        this.scrollToTop(false);\n        this.cleanItems();\n        this.disableScroll(true);\n\n        if (items) {\n            if (this.pagerType === 'pages') {\n                // If page index out of bounds - init to 0.\n                const numberOfPages = Math.ceil(totalRows / this.pageSize);\n\n                if (this.pageIndex >= numberOfPages) {\n                    this.pageIndex = 0;\n                }\n\n                this.updatePage(items, {\n                    pageIndex: this.pageIndex,\n                    pageSize: this.pageSize,\n                });\n\n                this.disableScroll(false);\n            } else {\n                const numberOfStartItems = this.getNumberOfStartItems();\n                const event = {\n                    fromIndex: 0,\n                    toIndex: numberOfStartItems,\n                };\n                this.updateItems(items, event);\n                \n                if (this.virtualScroller) {\n                    this.refresh(() => {\n                        this.calcObjectHeight();\n                    });\n                } else {\n                    this.calcObjectHeight();\n                }\n            }\n        }\n\n        if (!this.isTable) {\n            this.lastColumnsWidth = [];\n        }\n\n        this.setLayout();\n\n        // setTimeout(() => {\n            this.onListLoad();\n        // }, 0);\n    }\n\n    updateItems(\n        items: ObjectsDataRow[],\n        event: IPepListLoadItemsEvent = null\n    ): void {\n        if (!event) {\n            return; // Event isn't supplied.\n        }\n\n        // Clean array\n        if (this.itemsCounter + items.length > this.getCachedItemsNumber()) {\n            this.cleanItems();\n        }\n\n        const startIndex = event.fromIndex ?? 0;\n\n        for (let i = 0; i < items.length; i++) {\n            if (!this.items[i + startIndex]) {\n                this.items[i + startIndex] = items[i];\n                this.itemsCounter += 1;\n            }\n        }\n\n        this.toggleLoadingItemsFropApi(false);\n    }\n\n    updatePage(items: ObjectsDataRow[], event: IPepListLoadPageEvent): void {\n        if (!event) {\n            return; // Event isn't supplied.\n        }\n\n        // Clean array\n        if (this.itemsCounter + items.length > this.getCachedItemsNumber()) {\n            this.cleanItems();\n        }\n\n        // const loadInChunks = this.itemsCounter === 0;\n        const startIndex = Math.min(event.pageIndex * event.pageSize, this.totalRows);\n        const endIndex = Math.min(startIndex + event.pageSize, this.totalRows);\n\n        for (let i = 0; i < items.length; i++) {\n            if (!this.items[i + startIndex]) {\n                this.items[i + startIndex] = items[i];\n                this.itemsCounter += 1;\n            }\n        }\n\n        this.updateCurrentPageItems(startIndex, endIndex);\n        this.toggleLoadingItemsFropApi(false);\n    }\n\n    updateItem(data: ObjectsDataRow): void {\n        const index = this.items.findIndex((i) => i && i?.UID === data?.UID);\n        if (index >= 0 && index < this.items.length) {\n            this.updateItemProperties(this.items[index], data);\n        }\n    }\n\n    scrollToIndex(index: number, alignToBeginning = true, additionalOffset = 0, animationMilliseconds: number = undefined, animationCompletedCallback: () => void = undefined) {\n        this.virtualScroller?.scrollToIndex(index, alignToBeginning, additionalOffset, animationMilliseconds, animationCompletedCallback);\n    }\n\n    updateItemProperties(itemToUpdate: ObjectsDataRow, data: ObjectsDataRow) {\n        Object.assign(itemToUpdate, data);\n    }\n\n    getSelectedItemsData(isForEdit = false): PepSelectionData {\n        const res = new PepSelectionData();\n\n        let selectionType = 1;\n        const items = [];\n        const itemTypes = [];\n\n        if (this.selectionTypeForActions === 'single') {\n            if (this.selectedItemId.length > 0) {\n                const tmp = this.selectedItemId.split(this.SEPARATOR);\n                items.push(tmp[0]);\n                itemTypes.push(tmp[1]);\n            }\n        } else if (this.selectionTypeForActions === 'multi') {\n            let currentList = [];\n\n            // For edit - only the selected items.\n            if (isForEdit) {\n                if (!this.isAllSelected) {\n                    currentList = Array.from(this.selectedItems.values());\n                } else {\n                    // Get the id's of the items that not founded in unSelectedItems.\n                    this.items.forEach((item) => {\n                        if (\n                            item &&\n                            !this.unSelectedItems.has(item?.UID.toString())\n                        ) {\n                            currentList.push(\n                                this.getUniqItemId(\n                                    item?.UID.toString(),\n                                    item?.Type.toString()\n                                )\n                            );\n                        }\n                    });\n                }\n            } else {\n                // For delete - can be the unselected with select_all functionality.\n                currentList = Array.from(\n                    this.isAllSelected\n                        ? this.unSelectedItems.values()\n                        : this.selectedItems.values()\n                );\n                selectionType = this.isAllSelected ? 0 : 1;\n            }\n\n            currentList.forEach((item) => {\n                const tmp = item.split(this.SEPARATOR);\n\n                if (tmp.length === 2) {\n                    items.push(tmp[0]);\n                    itemTypes.push(tmp[1]);\n                }\n            });\n\n        }\n\n        res.selectionType = selectionType;\n        res.rows = items;\n        res.rowTypes = itemTypes;\n\n        return res;\n    }\n\n    getIsItemEditable(uid: string): boolean {\n        const item = this.items.filter((x) => x?.UID.toString() === uid);\n        if (item.length > 0) {\n            return item[0].IsEditable;\n        } else {\n            return false;\n        }\n    }\n\n    getItemDataByID(uid: string): ObjectsDataRow {\n        return this.items.find((item) => item?.UID.toString() === uid);\n    }\n\n    refresh(refreshCompletedCallback: () => void = undefined) {\n        this.virtualScroller?.refresh(refreshCompletedCallback);\n    }\n\n    // ---------------------------------------------------------------\n    //              Events handlers.\n    // ---------------------------------------------------------------\n\n    onWinResize(e): void {\n        this.refresh();\n\n        this.containerWidth = 0;\n        this.lastColumnsWidth = [];\n        this.setLayout();\n    }\n\n    onListResizeStart(event, columnKey: string, columnIndex: number): void {\n        this.pressedColumn = columnKey;\n        this.pressedColumnIndex = columnIndex;\n        this.startX = event.x;\n        this.startWidth = event.target.closest('.header-column').offsetWidth;\n        // this.tableStartWidth = this.hostElement.nativeElement.offsetWidth; // this.virtualScroller?.contentElementRef.nativeElement.offsetWidth;\n        this.tableStartWidth = this.listContainerResizableElementRef.nativeElement.offsetWidth; // this.virtualScroller?.contentElementRef.nativeElement.offsetWidth;\n        console.log(`tableStartWidth - ${this.tableStartWidth}`);\n    }\n\n    onListResize(event): void {\n        // if (this.pressedColumn.length > 0) {\n        if (this.pressedColumnIndex >= 0) {\n            let widthToAdd = this.layoutService.isRtl() ? this.startX - event.x : event.x - this.startX;\n\n            // Set the width of the column and the container of the whole columns.\n            if (this.startWidth + widthToAdd >= PepListComponent.MINIMUM_COLUMN_WIDTH || widthToAdd > 0) {\n                const length = this._layout.ControlFields.length;\n                let totalCalcColsWidth = 0;\n\n                for (let index = 0; index < length; index++) {\n                    const uiControlField: UIControlField = this._layout\n                        .ControlFields[index];\n\n                    if (index === length - 1) {\n                        // Calc the last column only in percentage type.\n                        if (this.hasColumnWidthOfTypePercentage) {\n                            const scrollWidth = this.layoutService.getScrollbarWidth();\n                            widthToAdd += scrollWidth;\n                            uiControlField.calcTitleColumnWidthString = uiControlField.calcColumnWidthString = 'calc(100% - ' + (totalCalcColsWidth + scrollWidth) + 'px)'; // For 100%\n                        } else {\n                            // if (uiControlField.ApiName === this.pressedColumn) {\n                            if (index === this.pressedColumnIndex) {\n                                uiControlField.calcColumnWidth = this.startWidth + widthToAdd;\n                                uiControlField.calcTitleColumnWidthString = uiControlField.calcColumnWidth + 'px';\n                                uiControlField.calcColumnWidthString = uiControlField.calcColumnWidth + 'px';\n                            }\n                        }\n                    // } else if (uiControlField.ApiName === this.pressedColumn) {\n                    } else if (index === this.pressedColumnIndex) {\n                        uiControlField.calcColumnWidth = this.startWidth + widthToAdd;\n                        uiControlField.calcTitleColumnWidthString = uiControlField.calcColumnWidthString = uiControlField.calcColumnWidth + 'px';\n                    }\n\n                    totalCalcColsWidth += uiControlField.calcColumnWidth;\n                }\n\n                const widthToSet = (this.tableStartWidth + widthToAdd) + 'px';\n                console.log(`onListResize -> widthToSet: ${widthToSet} *** widthToAdd: ${widthToAdd}`);\n                this.setColumnsWidth(widthToSet);\n                this.checkForChanges = new Date().getTime();\n            }\n\n        }\n    }\n\n    onListResizeEnd(event): void {\n        // if (this.pressedColumn.length > 0) {\n        if (this.pressedColumnIndex >= 0) {\n            if (\n                event &&\n                this.getParent(event.srcElement, 'resize-box').length > 0\n            ) {\n                this.initResizeData();\n            } else {\n                // Set timeout 0 for onListSortingChange will have the pressedColumn.\n                setTimeout(() => {\n                    this.initResizeData();\n                }, 0);\n            }\n\n            this.lastColumnsWidth = [];\n            \n            // Set the last columns width\n            for (let index = 0; index < this._layout.ControlFields.length; index++) {\n                const uiControlField: UIControlField = this._layout.ControlFields[index];\n                \n                this.lastColumnsWidth.push({ \n                    columnAPIName: uiControlField.ApiName, \n                    calcColumnWidth: uiControlField.calcColumnWidth,\n                    calcTitleColumnWidthString: uiControlField.calcTitleColumnWidthString,\n                    calcColumnWidthString: uiControlField.calcColumnWidthString\n                })\n            }\n            \n            event.stopPropagation();\n        }\n    }\n\n    onListSortingChange(sortBy: string, isAsc: boolean, event = null): void {\n        if (\n            // this.pressedColumn.length > 0 ||\n            this.pressedColumnIndex >= 0 ||\n            (event && this.getParent(event.srcElement, 'resize-box').length > 0)\n        ) {\n            return;\n        }\n\n        if (this.sortBy !== sortBy || this.isAsc !== isAsc) {\n            this.sortBy = sortBy;\n            this.isAsc = isAsc;\n            this.saveSortingToSession();\n\n            this.sortingChange.emit({ sortBy, isAsc });\n        }\n    }\n\n    onListHeaderMouseEnter(event): void {\n        // this.headerIsInFocus = true;\n    }\n\n    onListHeaderMouseLeave(event): void {\n        // this.headerIsInFocus = false;\n        this.onListResizeEnd(event);\n        this.initResizeData();\n    }\n\n    onPagerChange(event: IPepListPagerChangeEvent): void {\n        this.pageIndex = event.pageIndex;\n\n        // Scroll to top.\n        //this.scrollToTop();\n\n        const startIndex = event.pageIndex * event.pageSize;\n        const endIndex = Math.min(\n            startIndex + event.pageSize,\n            this.totalRows\n        );\n\n        let shouldGetItemsFromApi = false;\n        let index: number = startIndex;\n\n        while (!shouldGetItemsFromApi && index < endIndex) {\n            if (!this.items[index]) {\n                shouldGetItemsFromApi = true;\n            }\n            index++;\n        }\n\n        // Get bulk from api.\n        if (shouldGetItemsFromApi) {\n            if (!this.loadingItemsFromApi) {\n                this.toggleLoadingItemsFropApi(true);\n\n                this.loadPage.emit({\n                    pageIndex: event.pageIndex,\n                    pageSize: event.pageSize,\n                }); \n                \n                this.scrollToTop();\n            }\n        } else {\n            setTimeout(() => {\n                this.updateCurrentPageItems(startIndex, endIndex);\n                this.scrollToTop();\n            }, this.scrollAnimationTime);\n        }\n    }\n\n    onVirtualScrollerChange(event: IPageInfo): void {\n        this.raiseStartIndexChange(event.startIndex);\n\n        if (this.pagerType === 'scroll') {\n            // For other events do nothing.\n            if (typeof event.startIndex === 'undefined' || event.startIndex < 0 ||\n                typeof event.endIndex === 'undefined' || event.endIndex < 0) {\n                return;\n            }\n\n            const addAtStart = event.scrollDirection === 'backward';\n            let shouldGetItemsFromApi = false;\n            let indexOfMissingItem: number;\n\n            if (addAtStart) {\n                indexOfMissingItem = event.endIndex;\n                while (!shouldGetItemsFromApi && indexOfMissingItem >= event.startIndex) {\n                    if (!this.items[indexOfMissingItem]) {\n                        shouldGetItemsFromApi = true;\n                    }\n\n                    if (!shouldGetItemsFromApi) {\n                        indexOfMissingItem--;\n                    }\n                }\n            } else {\n                indexOfMissingItem = event.startIndex;\n                while (!shouldGetItemsFromApi && indexOfMissingItem <= event.endIndex) {\n                    if (!this.items[indexOfMissingItem]) {\n                        shouldGetItemsFromApi = true;\n                    }\n\n                    if (!shouldGetItemsFromApi) {\n                        indexOfMissingItem++;\n                    }\n                }\n            }\n\n            // Get bulk from api.\n            if (shouldGetItemsFromApi) {\n                if (!this.loadingItemsFromApi) {\n                    this.toggleLoadingItemsFropApi(true);\n\n                    const top = this.getTopItems() - 1;\n                    const fromIndex = addAtStart ? Math.max(indexOfMissingItem - top, 0) : indexOfMissingItem;\n                    const toIndex = addAtStart ? indexOfMissingItem : Math.min(indexOfMissingItem + top, this.totalRows);\n\n                    this.loadItems.emit({\n                        fromIndex,\n                        toIndex,\n                    });\n                }\n            }\n        }\n    }\n\n    onListLoad(): void {\n        setTimeout(() => {\n            this.listLoad.emit();\n        }, 0);\n    }\n\n    // onChildRectChange(event: any) {\n    //     // Set the calculatedObjectHeight only if he's not set (this case is only for the initialize when virtual scroll is undefined).\n    //     // the other cases is handled in calcObjectHeight function.\n    //     if (this.calculatedObjectHeight === 'auto') {\n    //         this.calculatedObjectHeight = event?.height + 'px';\n    //     }\n    // }\n\n    onValueChanged(valueChange: IPepFormFieldValueChangeEvent): void {\n        if (this.disabled) {\n            return;\n        }\n\n        this.valueChange.emit(valueChange);\n    }\n\n    onCustomizeFieldClick(\n        customizeFieldClickedData: IPepFormFieldClickEvent\n    ): void {\n        if (this.disabled) {\n            return;\n        }\n\n        this.fieldClick.emit(customizeFieldClickedData);\n    }\n    //added to handle sorting by specific columns----\n    isSortableColumn(apiName: string) {\n        //case 1 - supportSorting = true and array exists\n          if(this.supportSorting) {\n            if(this.supportSortingFields?.length) {\n              return this.supportSortingFields.includes(apiName);\n        //case 2 - supportSorting = true and array does not exist\n            } else if (this.supportSortingFields === undefined) {\n              return true\n            } // case 3 supportSorting = false\n          } else return false;\n    \n      }\n}\n","<ng-container *ngIf=\"totalRows == 0\">\n    <ng-container *ngIf=\"noDataFoundMsg; then noDataMsgInputBlock; else noDataMsgDefaultBlock\"></ng-container>\n    <ng-template #noDataMsgInputBlock>\n        <div class=\"pep-border-bottom\">\n            <p class=\"title-xl no-data\">\n                {{ noDataFoundMsg }}\n            </p>\n        </div>\n    </ng-template>\n    <ng-template #noDataMsgDefaultBlock>\n        <div class=\"pep-border-bottom\">\n            <p class=\"title-xl no-data\">\n                {{ 'LIST.NO_DATA_FOUND' | translate}}\n            </p>\n        </div>\n        <div class=\"no-data-suggestions\">\n            <p class=\"suggestions-title title-lg\">\n                {{ 'LIST.NO_DATA_FOUND_SUGGESTIONS_TITLE' | translate}}\n            </p>\n            <ul class=\"suggestions-list body-lg\" [innerHtml]=\"'LIST.NO_DATA_FOUND_SUGGESTIONS_LIST' | translate\"></ul>\n        </div>\n    </ng-template>\n</ng-container>\n<ng-container *ngIf=\"totalRows > 0\">\n    <div class=\"list-container\">\n        <div #listContainerResizable class=\"list-container-resizable\">\n            <ng-container *ngTemplateOutlet=\"tableHeader\"></ng-container>\n\n            <!-- (vsChildRectChange)=\"onChildRectChange($event)\" -->\n            <virtual-scroller #scroller [items]=\"pagerType === 'pages' ? currentPageItems : items\"\n                [scrollDebounceTime]=\"scrollDebounceTime\" [scrollThrottlingTime]=\"scrollThrottlingTime\"\n                [bufferAmount]=\"printMode ? totalRows : bufferAmount\" [parentScroll]=\"parentScroll\" [disable]=\"loadingItemsFromApi\"\n                class=\"virtual-scroller\" [ngClass]=\"{ 'table-body': isTable, 'cards-body': !isTable }\"\n                (vsChange)=\"onVirtualScrollerChange($event)\" >\n                <ng-container *ngFor=\"let item of scroller.viewPortItems; let index = index; let isFirst = first;\">\n                    <ng-container *ngTemplateOutlet=\"listData; context: {item: item, index:index}\"></ng-container>\n                </ng-container>\n            </virtual-scroller>\n            \n            <ng-container *ngTemplateOutlet=\"tableTotal\"></ng-container>\n        </div>\n    </div>\n    <pep-list-pager *ngIf=\"pagerType === 'pages'\" class=\" list-pager\" [disabled]=\"loadingItemsFromApi\"\n        [length]=\"totalRows\" [pageSize]=\"pageSize\" [pageIndex]=\"pageIndex\" (pagerChange)=\"onPagerChange($event)\">\n    </pep-list-pager>\n</ng-container>\n\n<ng-template #listData let-item=\"item\" let-index=\"index\">\n    <ng-container *ngIf=\"isTable\">\n        <!-- getIsItemSelected(item) -> item | isItemSelected: selectionTypeForActions : selectedItemId : isAllSelected : selectedItems : unSelectedItems -->\n        <div class=\"table-row\" (mouseenter)=\"onTableRowMouseEnter($event, item?.UID, item?.Type)\" (keydown)=\"onTabKeydown($event, item?.UID, item?.Type)\"\n            (mouseleave)=\"onTableRowMouseLeave($event, item?.UID, item?.Type)\" [ngClass]=\"{\n                'compact-view': tableViewType === 'compact',\n                even: zebraStripes && index % 2 !== 0,\n                selected: getIsItemSelected(item),\n                highlighted: item?.UID + SEPARATOR + item?.Type === selectedItemId}\" [ngStyle]=\"{ visibility: !loadingItemsFromApi || item ? 'visible' : 'hidden' }\">\n            <fieldset class=\"table-row-fieldset\" [ngStyle]=\"{ 'background-color': item?.BackgroundColor }\">\n                <mat-checkbox *ngIf=\"selectionTypeForActions == 'multi'\" type=\"checkbox\"\n                    class=\"pull-left flip row-selection\" [ngClass]=\"{ 'md': tableViewType === 'compact' }\"\n                    [disabled]=\"false && getisItemDisabled(item)\" [ngStyle]=\"{\n                            visibility: !deviceHasMouse ||\n                            item?.UID + SEPARATOR + item?.Type === hoveredItemId || isAllSelected || selectedItems.size > 0 ? 'visible' : 'hidden'\n                        }\" [checked]=\"getIsItemSelected(item)\"\n                    (change)=\"selectItemForActions($event, item?.UID, item?.IsSelectableForActions, item?.Type)\">\n                </mat-checkbox>\n                <mat-radio-button *ngIf=\"selectionTypeForActions == 'single'\" name=\"selection\"\n                    class=\"pull-left flip row-selection pep-radio-button\" [ngClass]=\"{ 'md': tableViewType === 'compact' }\"\n                    [disabled]=\"getisItemDisabled(item)\"\n                    [checked]=\"getIsItemSelected(item)\"\n                    (change)=\"selectItemForActions($event, item?.UID, item?.IsSelectableForActions, item?.Type)\">\n                </mat-radio-button>\n                <pep-form [layoutType]=\"'table'\" [checkForChanges]=\"checkForChanges\" [layout]=\"layout\"\n                    [firstFieldAsLink]=\"firstFieldAsLink\" [data]=\"item\" [canEditObject]=\"!disabled\"\n                    [lockEvents]=\"lockItemInnerEvents || printMode\" [isReport]=\"isReport\" [isActive]=\"\n                            (item?.UID + SEPARATOR + item?.Type === selectedItemId ||\n                            item?.UID + SEPARATOR + item?.Type === hoveredItemId) && deviceHasMouse\n                        \" (valueChange)=\"onValueChanged($event)\" (fieldClick)=\"onCustomizeFieldClick($event)\"\n                    (click)=\"itemClicked($event, item)\">\n                </pep-form>\n            </fieldset>\n        </div>\n    </ng-container>\n\n    <ng-container *ngIf=\"!isTable\">\n        <div (mouseenter)=\"onCardMouseEnter($event, item?.UID, item?.Type)\"\n            (mouseleave)=\"onCardMouseLeave($event, item?.UID, item?.Type)\" [ngClass]=\"{\n                    selected: getIsItemSelected(item),\n                    highlighted: item?.UID + SEPARATOR + item?.Type === selectedItemId,\n                    'line-view': viewType === 'lines',\n                    'card-view': viewType === 'cards',\n                    'small-card': cardSize === 'sm'\n                }\" class=\"pull-left flip\"\n            [ngStyle]=\"{ height: calculatedObjectHeight, visibility: !loadingItemsFromApi || item ? 'visible' : 'hidden' }\">\n            <mat-checkbox *ngIf=\"showCardSelection\" class=\"pull-left flip card-selection\"\n                [disabled]=\"getisItemDisabled(item)\" [checked]=\"getIsItemSelected(item)\"\n                (change)=\"selectItemForActions($event, item?.UID, item?.IsSelectableForActions, item?.Type)\">\n            </mat-checkbox>\n            <pep-form [layoutType]=\"'card'\" [firstFieldAsLink]=\"firstFieldAsLink\" [checkForChanges]=\"checkForChanges\"\n                [layout]=\"layout\" [data]=\"item\" [canEditObject]=\"!disabled\"\n                [lockEvents]=\"lockItemInnerEvents || printMode\" [isActive]=\"\n                        (item?.UID + SEPARATOR + item?.Type === selectedItemId ||\n                        item?.UID + SEPARATOR + item?.Type === hoveredItemId) && deviceHasMouse\n                    \" (valueChange)=\"onValueChanged($event)\" (fieldClick)=\"onCustomizeFieldClick($event)\"\n                (click)=\"itemClicked($event, item)\">\n            </pep-form>\n        </div>\n    </ng-container>\n</ng-template>\n\n<ng-template #tableHeader>\n    <div *ngIf=\"isTable\" class=\"table-header\" (mouseup)=\"onListResizeEnd($event)\"\n        (mouseenter)=\"onListHeaderMouseEnter($event)\" (mouseleave)=\"onListHeaderMouseLeave($event)\"\n        (mousemove)=\"onListResize($event)\">\n\n        <div class=\"table-header-padding-top\"></div>\n        <fieldset class=\"table-header-fieldset\">\n            <mat-checkbox *ngIf=\"selectionTypeForActions !== 'none'\" #selectAllCB class=\"pull-left flip row-selection\" [ngClass]=\"{ 'md': tableViewType === 'compact' }\"\n                type=\"checkbox\" [ngStyle]=\"{\n                        visibility:\n                            selectionTypeForActions == 'single' || \n                            (selectionTypeForActions == 'multi' && hideAllSelectionInMulti) ? 'hidden' : 'visible'\n                    }\"\n                [indeterminate]=\"isAllSelected ? unSelectedItems.size > 0 && unSelectedItems.size < totalRows : (selectedItems.size > 0 && !getIsAllSelectedForActions())\"\n                [disabled]=\"disabled || selectionTypeForActions === 'single'\" [checked]=\"getIsAllSelectedForActions()\"\n                (change)=\"selectAllItemsForActions($event)\"></mat-checkbox>\n            <fieldset>\n                <div *ngFor=\"let field of layout?.ControlFields; let j = index\" class=\"header-column pull-left flip\"\n                    [ngStyle]=\"{ width: field.calcTitleColumnWidthString }\" [ngClass]=\"{\n                            'compact-view': tableViewType === 'compact',\n                            'support-sorting': isSortableColumn(field.ApiName),\n                            'has-sorting': field.ApiName === sortBy,\n                            'is-resizing': field.ApiName === pressedColumn,\n                            'is-first': j === 0 && selectionTypeForActions !== 'multi',\n                            'is-last': j === layout?.ControlFields?.length - 1\n                        }\"\n                    (click)=\"isSortableColumn(field.ApiName) ? (onListSortingChange(field.ApiName, sortBy !== null && sortBy != field.ApiName ? true : !isAsc, $event)) : false\">\n\n                    <label id=\"{{ field.ApiName }}\"\n                        class=\"header-label body-sm pull-left flip text-align-{{ field.Layout.XAlignment }}\"\n                        title=\"{{ field.Title }}\">\n                        <span *ngIf=\"field.Mandatory\" class=\"mandatory\">\n                            <pep-icon name=\"system_must\"></pep-icon>\n                        </span>\n                        {{ field.Title != '' ? field.Title : ' '}}\n                    </label>\n\n                    <div *ngIf=\"supportResizing\" class=\"resize-box pull-right flip\"\n                        (mousedown)=\"onListResizeStart($event, field.ApiName, j)\">\n                        <div class=\"splitter\"></div>\n                    </div>\n\n                    <div *ngIf=\"isSortableColumn(field.ApiName)\" class=\"sorting-box pull-left flip\"\n                        [ngClass]=\"{ 'has-sorting': field.ApiName === sortBy }\">\n                        <mat-icon *ngIf=\"field.ApiName !== sortBy\">\n                            <pep-icon name=\"arrow_either\" class=\"asc\"></pep-icon>\n                        </mat-icon>\n                        <ng-container *ngIf=\"field.ApiName === sortBy\">\n                            <mat-icon *ngIf=\"!isAsc\" [ngClass]=\"{ 'sort-by': field.ApiName === sortBy && isAsc }\"\n                                title=\"{{ 'LIST.SORT_ASC' | translate }}\">\n                                <pep-icon name=\"arrow_up\" class=\"asc\"></pep-icon>\n                            </mat-icon>\n                            <mat-icon *ngIf=\"isAsc\" [ngClass]=\"{ 'sort-by': field.ApiName === sortBy && !isAsc }\"\n                                title=\"{{ 'LIST.SORT_DESC' | translate }}\">\n                                <pep-icon name=\"arrow_down\" class=\"desc\"></pep-icon>\n                            </mat-icon>\n                        </ng-container>\n                    </div>\n                </div>\n            </fieldset>\n        </fieldset>\n    </div>\n</ng-template>\n\n<ng-template #tableTotal>\n    <div *ngIf=\"isTable && totalsRow?.length > 0 && totalsRow.length <= layout?.ControlFields.length\"\n        class=\"table-total\">\n        <fieldset class=\"table-header-fieldset\">\n            <div *ngFor=\"let field of layout?.ControlFields; let j = index\" class=\"total-column pull-left flip\"\n                [ngStyle]=\"{ width: field.calcTitleColumnWidthString }\">\n                <label class=\"total-label body-sm text-align-{{ field.Layout.XAlignment }}\">\n                    {{ totalsRow[j] }}\n                </label>\n            </div>\n        </fieldset>\n    </div>\n</ng-template>"]}