shared-ui-test-1 1.0.1

package/esm2022/modules/ui-kit/components/data-table/data-table/data-table.component.mjs

@@ -0,0 +1,1534 @@
+/* eslint-disable @angular-eslint/no-output-on-prefix */
+/* eslint-disable sort-class-members/sort-class-members */
+import { SelectionModel } from '@angular/cdk/collections';
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, TemplateRef, ViewChild, } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { MatDialogConfig } from '@angular/material/dialog';
+import { ActionTypesEnum } from 'idp-apps-shared-ui/enums/action-types.enum';
+import { SortDirectionEnum } from 'idp-apps-shared-ui/enums/sort-direction.enum';
+import { SourceTypesEnum } from 'idp-apps-shared-ui/enums/source-types.enum';
+import { ToolTipsProp, tooltipsDefaultValue } from 'idp-apps-shared-ui/enums/tooltips-prop.enum';
+import { CommonConfirmModalComponent } from 'idp-apps-shared-ui/modules/ui-kit/components/modals/common-confirm-modal/common-confirm-modal.component';
+import { clone, isFunction, isUndefined, merge } from 'lodash';
+import cloneDeep from 'lodash/cloneDeep';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { debounceTime, distinctUntilChanged, filter, first, takeUntil } from 'rxjs/operators';
+import { ChangeType } from '../../../../../modules/ui-kit/components/data-table/constants/change-type.enum';
+import { DataTableConstants } from '../../../constants/data-table.constants';
+import { ColumnDisableModes } from '../../../enums/column-disable-mode.enum';
+import { ColumnTypes } from '../../../enums/column-types.enum';
+import { FormTypes } from '../../../enums/form-types.enum';
+import { Icons } from '../../../enums/icons.enum';
+import { SnackbarTypes } from '../../../enums/snackbar.enum';
+import { DeleteModalComponent } from '../../modals/delete-modal/delete-modal.component';
+import { FilterManager } from '../api-classes/filter-manager';
+import { GridApi } from '../api-classes/grid-api';
+import { COLUMN_ID } from '../constants/column-id';
+import { ROW } from '../constants/row';
+import { DataColDispComponent } from '../data-col-disp/data-col-disp.component';
+import { DataTableBodyComponent } from '../data-table-body/data-table-body.component';
+import { DATA_TABLE_CONTEXT } from '../services/data-table-context.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/data-table.service";
+import * as i2 from "@angular/router";
+import * as i3 from "@angular/material/dialog";
+import * as i4 from "../../../services/snackbar.service";
+import * as i5 from "idp-apps-shared-ui/core/services/user-management.service";
+import * as i6 from "idp-apps-shared-ui/modules/ui-kit/pipes/column-filter.pipe";
+import * as i7 from "idp-apps-shared-ui/modules/ui-kit/pipes/search.pipe";
+import * as i8 from "idp-apps-shared-ui/core/services/local-storage.service";
+import * as i9 from "../../../services/form.service";
+import * as i10 from "../services/data-table-context.service";
+import * as i11 from "@angular/common";
+import * as i12 from "@angular/material/input";
+import * as i13 from "@angular/material/button";
+import * as i14 from "@angular/material/card";
+import * as i15 from "@angular/material/checkbox";
+import * as i16 from "@angular/material/expansion";
+import * as i17 from "@angular/material/progress-spinner";
+import * as i18 from "@angular/forms";
+import * as i19 from "@angular/flex-layout/extended";
+import * as i20 from "../../data-pagination/data-pagination.component";
+import * as i21 from "../../loader/loader.component";
+import * as i22 from "../data-table-actions/data-table-actions.component";
+import * as i23 from "../../icon/icon/icon.component";
+import * as i24 from "../data-table-body/data-table-body.component";
+import * as i25 from "../data-col-filter/data-col-filter.component";
+import * as i26 from "../../../../../core/directive/authorize.directive";
+import * as i27 from "../../../pipes/column-filter.pipe";
+export class DataTableComponent {
+    // Inline edit settings
+    get canInlineEdit() {
+        return this.gridOptions.canInlineEdit;
+    }
+    set setDataTableBody(tableBody) {
+        this.dataTableBody = tableBody;
+    }
+    get columnShowhideStoragekey() {
+        return this.gridOptions.columnShowhideStoragekey;
+    }
+    get allowSaveColumnVisibilitySettings() {
+        return this.gridOptions.allowSaveColumnVisibilitySettings;
+    }
+    get addActionTitle() {
+        return `${this.gridOptions.actionAddTitle}`;
+    }
+    get isViewActionVisible() {
+        return this.gridOptions.isRowLevelViewActionVisible;
+    }
+    get searchPlaceholder() {
+        return this.gridOptions.searchboxPlaceholder ? this.gridOptions.searchboxPlaceholder : this.header;
+    }
+    get isTableInEditState() {
+        return this.isEditing || this.hasEmptyRow;
+    }
+    get apiReqParams() {
+        return {
+            page: this.currentPage,
+            itemsOnPage: this.pageSize,
+            filterParams: this.populateFilterParams(),
+            searchText: this.searchValue.value,
+            ...this.getSortParams,
+        };
+    }
+    get getSortParams() {
+        const parmas = [];
+        Object.keys(this.sortedColumn).forEach((x) => {
+            parmas.push({ sortBy: x, sortDirection: this.sortedColumn[x] });
+        });
+        return parmas.length ? parmas[0] : {};
+    }
+    constructor(dataTableService, router, activatedRoute, matDialog, changeDetectorRef, snackbarService, userManagementService, filterPipe, searchPipe, localStorageService, dialog, formService, dataTableContext) {
+        this.dataTableService = dataTableService;
+        this.router = router;
+        this.activatedRoute = activatedRoute;
+        this.matDialog = matDialog;
+        this.changeDetectorRef = changeDetectorRef;
+        this.snackbarService = snackbarService;
+        this.userManagementService = userManagementService;
+        this.filterPipe = filterPipe;
+        this.searchPipe = searchPipe;
+        this.localStorageService = localStorageService;
+        this.dialog = dialog;
+        this.formService = formService;
+        this.dataTableContext = dataTableContext;
+        this.ICONS = Icons;
+        this.sortDirectionEnum = SortDirectionEnum;
+        this.toolTips = ToolTipsProp;
+        this.actionTypes = ActionTypesEnum;
+        this.DEFAULT_PAGE_SIZE = DataTableConstants.DEFAULT_PAGE_SIZE;
+        this.DEFAULT_INIT_PAGE = DataTableConstants.DEFAULT_INIT_PAGE;
+        this.confirmationMsgPagination = `Selected checkbox will be lost `;
+        this.defaultRowValues = {};
+        this.header = '';
+        this.isIdColVisible = false;
+        this.hasPagination = true;
+        this.isOnlyView = false;
+        this.isEditable = true;
+        this.isCloneVisible = true;
+        this.isLazyInitialization = false;
+        this.isRowSelectionEnable = false;
+        this.isSaveDataLocal = false;
+        // Tree grid settings
+        this.isTreeGrid = false;
+        this.changeLocalData = new EventEmitter();
+        this.actionClick = new EventEmitter();
+        this.onInitCompleted = new EventEmitter();
+        this.onComplexDetailClicked = new EventEmitter();
+        this.onEditClicked = new EventEmitter();
+        this.onAddClicked = new EventEmitter();
+        this.onRowClicked = new EventEmitter();
+        this.onPageChanged = new EventEmitter();
+        this.matExpansionPanelClicked = new EventEmitter();
+        this.onUpdateCompleted = new EventEmitter();
+        this.onDeleteCompleted = new EventEmitter();
+        this.onScrolled = new EventEmitter();
+        this.CheckboxSelect = new EventEmitter();
+        this.isTableDataLoad = new EventEmitter();
+        this.searchValue = new FormControl();
+        this.isSearchDisabled = false;
+        this.sourceTypes = SourceTypesEnum;
+        this.masterSelection = new FormControl(false);
+        this.paginationParams = {
+            currentPage: this.DEFAULT_INIT_PAGE,
+            pageSize: this.DEFAULT_PAGE_SIZE,
+        };
+        this.searchedRowCount$ = new Subject();
+        this.isClearFilter$ = new BehaviorSubject(false);
+        this.isFilterView = false;
+        this.excludedRows = [];
+        this.sortedColumn = {};
+        this.count = 0;
+        this.isLoading$ = new BehaviorSubject(false);
+        this.hasEmptyRow = false;
+        this.isEditing = false;
+        this.isSaving = false;
+        this.map = new Map();
+        this.numberOfTableRefresh = 0;
+        this.clearSubs$ = new Subject();
+        this.totalItems = 0;
+        this.startX = 0;
+        this.startWidth = 0;
+        this.resizingTh = null;
+        this.apolloDataTable = null;
+        this.resizingTd = null;
+        this.defaultGridOptions = {
+            addIdColumn: true,
+            actionAddTitle: '',
+            allowSaveColumnVisibilitySettings: false,
+            isRowLevelViewActionVisible: true,
+            isOnlyView: false,
+            isRowSelectionEnable: false,
+            idProperty: COLUMN_ID.PROP,
+            isClientSidePagination: true,
+            canInlineAdd: true,
+            canInlineEdit: true,
+            isSaveDataLocal: false,
+            isSearchBoxVisible: true,
+            isFilterEnabled: false,
+            filterableColumns: [],
+            defaultSortProperty: {},
+            cloneOptions: {
+                copyOfClonableProperties: [],
+                emptyValueProperties: [],
+            },
+            searchableProperties: [],
+            sortableProperties: [],
+            isRowActionVisible: true,
+            topRightActions: [],
+            deleteOptions: {},
+            searchboxPlaceholder: this.header,
+            refreshOnAdd: true,
+            topLeftAdditionalActions: [],
+            isSortEnabled: false,
+            disableIcons: {
+                add: false,
+                edit: false,
+                delete: false,
+                clone: false,
+                add$: new BehaviorSubject(false),
+                edit$: new BehaviorSubject(false),
+                delete$: new BehaviorSubject(false),
+                copy$: new BehaviorSubject(false),
+            },
+            gridMenuOptions: {
+                isMenuEnabled: false,
+                menuItems: [],
+            },
+            actionLoading$: {
+                copy$: new BehaviorSubject(false),
+                edit$: new BehaviorSubject(false),
+                delete$: new BehaviorSubject(false),
+            },
+        };
+        this.onMouseMove = (event) => {
+            const width = this.startWidth + (event.pageX - this.startX);
+            if (this.resizingTh) {
+                this.setWidthToElement(width, width, this.resizingTh.offsetWidth);
+            }
+        };
+        this.onMouseUp = () => {
+            document.removeEventListener('mousemove', this.onMouseMove);
+            document.removeEventListener('mouseup', this.onMouseUp);
+            document.body.classList.remove('no-select-resize');
+            this.resizingTh = null;
+            this.resizingTd = null;
+        };
+        this.filterManager = new FilterManager();
+        this.gridApi = new GridApi(this, this.formService);
+        this.dataTableContext.setDataTableComponent(this);
+    }
+    get getSelectedRows() {
+        return this.getFilteredDataRow(this.selection.selected);
+    }
+    get getAllCheckedRows() {
+        return this.selection.selected;
+    }
+    get isActionsDisabled() {
+        return this.filteredRows.length === 0;
+    }
+    get getRows() {
+        return this.getFilteredDataRow(this.rows);
+    }
+    get getCustomTableStyle() {
+        if (this.gridOptions.isInnerScroll) {
+            return this.gridOptions.customTableStyle ? this.gridOptions.customTableStyle : { height: '30vh' };
+        }
+        return {};
+    }
+    onTableScrolled(e) {
+        const htmlElement = this.customDataTable.nativeElement;
+        const event = {
+            ...e,
+            currentElement: this.customDataTable,
+            currentScrollPosition: { x: htmlElement.scrollLeft, y: htmlElement.scrollTop },
+        };
+        this.onScrolled.emit(event);
+    }
+    changeScrollPosition(position) {
+        const htmlElement = this.customDataTable.nativeElement;
+        htmlElement.scroll(position.x, position.y);
+    }
+    ngOnInit() {
+        if (!this.isLazyInitialization) {
+            this.init();
+        }
+        else {
+            this.isLoading$.next(true);
+        }
+        if (!this.gridOptions.isClientSidePagination) {
+            this.searchTable();
+        }
+    }
+    isDisabledMainAction(actionProp) {
+        return this.gridOptions.disableIcons && this.gridOptions.disableIcons[actionProp];
+    }
+    nonFilterClassName(columnProp) {
+        if (!this.isFilterEnable(columnProp) && this.isRowSelectionEnable) {
+            return 'row-selection-non-filter-cell';
+        }
+        if (!this.isFilterEnable(columnProp)) {
+            return 'non-filter-cell';
+        }
+        return '';
+    }
+    isFilterEnable(columnProp) {
+        if (this.isTableInEditState) {
+            return false;
+        }
+        return this.gridOptions.isFilterEnabled && (!this.gridOptions.filterableColumns.length || this.isFilterableColumn(columnProp));
+    }
+    isFilterableColumn(columnProp) {
+        return this.gridOptions.filterableColumns.findIndex((item) => item === columnProp) !== -1;
+    }
+    get isFilterApplied() {
+        return this.filterManager.getFilterParams().length > 0;
+    }
+    get nonDisabledRows() {
+        if (this.gridOptions.rowDisableFn && isFunction(this.gridOptions.rowDisableFn)) {
+            return this.rows.filter((row) => !this.gridOptions.rowDisableFn(row));
+        }
+        return this.rows;
+    }
+    ngAfterViewInit() {
+        this.fireInitCompleted();
+        if (this.scrollPosition) {
+            const htmlElement = this.customDataTable.nativeElement;
+            htmlElement.scrollTop = this.scrollPosition.y;
+            htmlElement.scrollLeft = this.scrollPosition.x;
+        }
+    }
+    checkDeleteDisabled() {
+        if (isFunction(this.isDeleteDisabled) && !isUndefined(this.selectedRow)) {
+            return this.isDeleteDisabled(this.selectedRow);
+        }
+        if (this.isDeleteDisabled && typeof this.isDeleteDisabled !== 'function') {
+            return true;
+        }
+        return false;
+    }
+    isAllSelected() {
+        if (this.gridOptions.isClientSidePagination) {
+            return this.nonDisabledRows.length === this.selection.selected.length;
+        }
+        return (this.masterSelection.value && this.excludedRows.length === 0) || this.totalItems === this.selection.selected.length;
+    }
+    isSortColumn(viewColumn) {
+        return !!(this.gridOptions.sortableProperties && this.gridOptions.sortableProperties.find((x) => x === viewColumn.prop));
+    }
+    openColumnShowHideDialogue() {
+        let dialogConfig = new MatDialogConfig();
+        dialogConfig = this.configureDialog(dialogConfig);
+        const dialogRef = this.dialog.open(DataColDispComponent, dialogConfig);
+        dialogRef.afterClosed().subscribe((result) => {
+            if (result && result.status === 'OK') {
+                this.viewColumns = result.columns;
+                this.changeDetectorRef.detectChanges();
+            }
+        });
+    }
+    masterToggle() {
+        this.excludedRows = [];
+        if (!this.masterSelection.pristine && !this.masterSelection.value) {
+            this.selection.clear();
+            this.changeDetectorRef.detectChanges();
+            this.gridApi.detectRowChanges();
+            this.masterSelection.reset();
+            this.CheckboxSelect.emit({ rows: [], gridApi: this.getGridApi(), checked: false });
+            return;
+        }
+        if (!this.gridOptions.isClientSidePagination) {
+            this.checkedAllExceptExcludedRows();
+            this.changeDetectorRef.detectChanges();
+            this.gridApi.detectRowChanges();
+            this.CheckboxSelect.emit({ rows: [], gridApi: this.getGridApi(), checked: true });
+        }
+        else {
+            this.masterToggleClientSide();
+            this.CheckboxSelect.emit({ rows: this.rows, gridApi: this.getGridApi(), checked: true });
+        }
+    }
+    isCheckboxSelect(row) {
+        const isSelected = this.selection.isSelected(row);
+        if (this.masterSelection.value && !isSelected) {
+            this.excludedRows.push(row);
+        }
+        else if (this.masterSelection.value && isSelected) {
+            const findIndex = this.excludedRows.findIndex((x) => JSON.stringify(x) === JSON.stringify(row));
+            if (findIndex > -1) {
+                this.excludedRows.splice(findIndex, 1);
+            }
+        }
+        this.CheckboxSelect.emit({ rows: [row], gridApi: this.getGridApi(), checked: isSelected });
+        if (isSelected) {
+            this.rows.forEach((row) => (row.isSelected = false));
+        }
+        const checkedRows = this.gridApi.getAllCheckedRows();
+        if (!this.selectedRow && checkedRows.length > 0) {
+            this.selectedRow = checkedRows[checkedRows.length - 1];
+        }
+    }
+    refresh() {
+        this.setData();
+    }
+    onClickAction(action) {
+        this.actionClick.emit(action);
+    }
+    onClickAdd() {
+        this.onAddClicked.emit();
+        if (isFunction(this.onAddClick) && !this.onAddClick(undefined, undefined)) {
+            return;
+        }
+        this.addActionHandler();
+    }
+    addActionHandler() {
+        this.setIdColumn();
+        this.setPaginationData({ currentPage: this.DEFAULT_INIT_PAGE, pageSize: this.pageSize });
+        this.isSearchDisabled = true;
+        this.searchValue.setValue(DataTableConstants.EMPTY);
+        if (this.gridOptions.canInlineAdd) {
+            if (!this.hasEmptyRow) {
+                this.addEmptyRow();
+            }
+        }
+        else {
+            this.navigatePage(FormTypes.Add);
+        }
+    }
+    onClickRow(eventData) {
+        const checkedRows = this.gridApi.getAllCheckedRows();
+        if (checkedRows?.length > 0) {
+            return;
+        }
+        if (this.isDefaultFirstRowSelected()) {
+            this.rows.forEach((x) => (x.isSelected = false));
+        }
+        if (this.selectedRow) {
+            this.selectedRow.isSelected = false;
+        }
+        this.selectedRow = eventData.row;
+        eventData.row.isSelected = true;
+        const emitIndex = this.gridOptions.isClientSidePagination
+            ? eventData.row.rowIndex + this.pageSize * (this.currentPage - 1)
+            : eventData.row.rowIndex;
+        this.selectedRow.rowIndex = emitIndex;
+        this.onRowClicked.emit(eventData.row);
+    }
+    onClickRowAdd(eventData) {
+        if (this.gridOptions.canInlineAdd && !this.hasEmptyRow) {
+            this.addEmptyRow(eventData.row.depth + 1, this.dataTableService.getRowId(eventData.row));
+        }
+    }
+    onClickEdit(eventData) {
+        if (isFunction(this.onBeforeEdit) && !this.onBeforeEdit(this.dataTableService.getRowsDataFromRows(this.rows), eventData)) {
+            return;
+        }
+        this.onEditClicked.emit(eventData);
+        if (this.gridOptions.canInlineEdit) {
+            if (!this.isEditing) {
+                this.toggleRowEditing(eventData.row, true);
+            }
+        }
+        else {
+            this.navigateToItem(FormTypes.Edit, this.dataTableService.getRowId(eventData.row));
+        }
+    }
+    onClickClone(eventData) {
+        if (this.gridOptions.canInlineAdd && !this.hasEmptyRow) {
+            const newEventData = cloneDeep(eventData);
+            this.addCloneRow(newEventData.row);
+        }
+    }
+    onClickView(eventData) {
+        this.navigateToItem(FormTypes.View, this.getNavigateItemValue(eventData));
+    }
+    ComplexDetailClicked(eventData) {
+        this.onComplexDetailClicked.emit(eventData);
+    }
+    ActionClickHandler(action) {
+        if (action.clicked) {
+            action.clicked(this.selectedRow);
+        }
+    }
+    showHideFilterView() {
+        this.isFilterView = !this.isFilterView;
+    }
+    clearGlobalFilter() {
+        this.isClearFilter$.next(true);
+        this.searchValue.setValue('');
+        this.changeDetectorRef.detectChanges();
+        this.filterManager.clearFilterParams();
+        this.setData();
+    }
+    onChangePage(paginationParams, selectableIndex) {
+        this.setPaginationData(paginationParams);
+        if (!this.isClientSidePagination()) {
+            this.setData(selectableIndex);
+        }
+        else if (this.isDefaultFirstRowSelected() && this.isClientSidePagination()) {
+            if (selectableIndex) {
+                this.emitNextRow(this.pageSize * (this.currentPage - 1) + this.getSelectableValidIndex(selectableIndex));
+            }
+            else {
+                this.emitNextRow(this.pageSize * (this.currentPage - 1));
+            }
+        }
+        this.onPageChanged.emit();
+    }
+    onExpansionPanelClick(eventData) {
+        this.matExpansionPanelClicked.emit(eventData);
+    }
+    onChangePageSize(pageSize) {
+        this.setPaginationDataOnSizeChanged(pageSize);
+        if (!this.isClientSidePagination()) {
+            this.setData();
+        }
+    }
+    getFilterParam(column) {
+        return this.filterManager.getFilterParam(column);
+    }
+    isFilteredColumn(columnProp) {
+        return this.filterManager.getFilterParams().findIndex((item) => item.filterColumn.prop === columnProp) !== -1;
+    }
+    onFilterClicked(filterParam) {
+        this.filterManager.setFilterParams(filterParam);
+        this.filteredRows = this.filterPipe.transform(this.rows, this.filterManager.getFilterParams(), this.columns, this.gridOptions.isClientSidePagination);
+        this.setPaginationData({ currentPage: this.DEFAULT_INIT_PAGE, pageSize: this.pageSize });
+        if (!this.isClientSidePagination()) {
+            this.setData();
+        }
+        else {
+            // this.numberOfTableRefresh = 1.5; // to skip init filter value assign
+        }
+    }
+    onClickEditCancel(eventData) {
+        this.isSearchDisabled = false;
+        if (this.dataTableService.isEmptyRow(eventData.row)) {
+            this.removeEmptyRow();
+        }
+        else {
+            this.toggleRowEditing(eventData.row, false);
+        }
+    }
+    onClickEditSave(eventData) {
+        this.isSearchDisabled = false;
+        if (isFunction(this.beforeSaveFn) && !this.beforeSaveFn(this.dataTableService.getRowsDataFromRows(this.rows), eventData)) {
+            return;
+        }
+        if (this.isSaveDataLocal) {
+            this.onSaveLocalRow(eventData);
+        }
+        else {
+            this.saveRow(eventData);
+        }
+    }
+    onChangeExpandCollapse(eventData) {
+        this.toggleRowExpandCollapse(eventData.row, eventData.shouldExpand);
+    }
+    getNavigateItemValue(eventData) {
+        if (this.gridOptions && this.gridOptions.rowNavigationProperty) {
+            return this.dataTableService.getValueByPropertyName(eventData.row, this.gridOptions.rowNavigationProperty);
+        }
+        return this.dataTableService.getRowId(eventData.row);
+    }
+    navigateToItem(type, id) {
+        const url = this.gridOptions.editExtraRouteParam ? `${type}/${id}/${this.gridOptions.editExtraRouteParam}` : `${type}/${id}`;
+        this.navigatePage(url);
+    }
+    onClickDeleteRow(eventData) {
+        this.openDeleteModal(eventData.row);
+    }
+    onClickDeleteModal(shouldDelete) {
+        if (shouldDelete) {
+            this.gridOptions?.actionLoading$?.delete$.next(true);
+            if (this.isSaveDataLocal) {
+                this.removeLocalRow(this.dataTableService.getRowId(this.rowToDelete));
+                this.onChangeLocalData(ChangeType.ROW_DELETED);
+                this.gridOptions?.actionLoading$?.delete$.next(false);
+            }
+            else {
+                this.deleteRow(this.rowToDelete);
+            }
+        }
+    }
+    VisibleColumnListChanged(columnList) {
+        this.viewColumns = columnList;
+    }
+    ngOnDestroy() {
+        this.clearSubs$.next(null);
+        this.clearSubs$.complete();
+        this.isClearFilter$.next(false);
+        this.isClearFilter$.complete();
+        this.dataTableContext.clearDataTableComponent();
+    }
+    init() {
+        this.gridOptions = merge(this.defaultGridOptions, this.gridOptions);
+        this.setPaginationData({
+            currentPage: isUndefined(this.initialPage) ? this.DEFAULT_INIT_PAGE : this.initialPage,
+            pageSize: this.pageSize,
+        });
+        this.selection = new SelectionModel(!this.isSingleSelect, []);
+        if (!this.gridOptions.isAutoColumn) {
+            this.setIdColumn();
+            this.initColumns();
+            this.defaultSortedColumns = clone(this.viewColumns);
+        }
+        this.getConfiguredColumns();
+        this.setData();
+    }
+    sortTable(viewColumn) {
+        if (this.isTableInEditState) {
+            return;
+        }
+        if (!this.gridOptions.sortableProperties.find((item) => item === viewColumn.prop) && !this.gridOptions.isSortEnabled) {
+            return;
+        }
+        if (this.sortedColumn[viewColumn.prop] === undefined) {
+            this.sortedColumn = {};
+            this.sortedColumn[viewColumn.prop] = SortDirectionEnum.ASC;
+            this.sortData(viewColumn, true);
+        }
+        else if (this.sortedColumn[viewColumn.prop] === SortDirectionEnum.ASC) {
+            this.sortedColumn[viewColumn.prop] = SortDirectionEnum.DESC;
+            this.sortData(viewColumn, false);
+        }
+        else {
+            this.sortedColumn = {};
+            this.sortData(viewColumn, false, true);
+        }
+    }
+    deleteRow(row) {
+        this.setIdColumn();
+        const rowId = this.dataTableService.getRowId(row);
+        this.deleteItemFn(rowId, row.data)
+            .pipe(first(), takeUntil(this.clearSubs$))
+            .subscribe({
+            next: () => {
+                this.gridOptions?.actionLoading$?.delete$.next(false);
+                this.snackbarService.success(SnackbarTypes.Deleted, SnackbarTypes.Deleted);
+                if (this.isClientSidePagination()) {
+                    this.removeLocalRow(rowId);
+                }
+                else {
+                    this.setData();
+                }
+                if (!this.isDefaultFirstRowSelected()) {
+                    this.selectedRow = undefined;
+                }
+                this.onDeleteCompleted.emit({ row: this.selectedRow });
+            },
+            error: () => {
+                // Empty method block.
+            },
+        });
+    }
+    searchModelChanged() {
+        if (this.gridOptions.isClientSidePagination) {
+            this.filteredRows = this.searchPipe.transform(this.rows, this.searchValue.value, this.searchColumns, this.gridOptions.isClientSidePagination, this.searchedRowCount$);
+            this.setPaginationData({ currentPage: this.DEFAULT_INIT_PAGE, pageSize: this.pageSize });
+            this.changeDetectorRef.detectChanges();
+        }
+    }
+    getTooltipText(text) {
+        if (this.gridOptions.iconTooltips && this.gridOptions.iconTooltips[text]) {
+            return this.gridOptions.iconTooltips[text];
+        }
+        return tooltipsDefaultValue[text];
+    }
+    getActionName(prop) {
+        return this.userManagementService.getActionName(this.gridOptions, prop);
+    }
+    getLeftActionName(prop) {
+        return this.userManagementService.getLeftActionName(this.gridOptions, prop);
+    }
+    getLeftRightActionText(data) {
+        if (data.title) {
+            return data.title;
+        }
+        return tooltipsDefaultValue[data.title];
+    }
+    get isSingleSelect() {
+        return this.gridOptions && this.gridOptions.isSingleSelect === true;
+    }
+    get pageSize() {
+        return this.paginationParams.pageSize;
+    }
+    get currentPage() {
+        return this.paginationParams.currentPage;
+    }
+    detectChange() {
+        this.changeDetectorRef.detectChanges();
+    }
+    selectNextRow() {
+        if (this.isLastRowInPage()) {
+            this.paginationParams.currentPage = this.isLastRowInLastPage() ? 1 : this.paginationParams.currentPage + 1;
+            this.onChangePage(this.paginationParams);
+        }
+        else {
+            this.emitNextRow(this.selectedRow.rowIndex + 1);
+        }
+    }
+    selectPreviousRow() {
+        if (this.isFirstRowInPage()) {
+            this.paginationParams.currentPage = this.isFirstRowInFirstPage() ? this.pagesCount : this.paginationParams.currentPage - 1;
+            this.onChangePage(this.paginationParams, 'last');
+        }
+        else {
+            this.emitNextRow(this.selectedRow.rowIndex - 1);
+        }
+    }
+    uncheckSelectedSource() {
+        this.selection.clear();
+        this.changeDetectorRef.detectChanges();
+        this.gridApi.detectRowChanges();
+    }
+    onDoubleClickSeparator(index, viewColumn) {
+        if (!this.gridOptions.draggable || !viewColumn.draggable) {
+            return;
+        }
+        clearTimeout(this.clickTimeout);
+        this.resizingTh = this.getSelectedHtml(`th[data-column-prop="${viewColumn.prop}"] div`);
+        this.resizingTd = this.getSelectedHtml(`td[data-column-prop="${viewColumn.prop}"]`, true);
+        if (!this.resizingTh || !this.resizingTd) {
+            return;
+        }
+        viewColumn.doubleClicked = !viewColumn.doubleClicked;
+        viewColumn.dragged = false;
+        this.formatTableData(viewColumn);
+        this.formatTableHeader();
+    }
+    getHeaderStyle(index, viewColumn) {
+        let classes = [];
+        if (this.viewColumns[index].dragged || viewColumn?.doubleClicked === true) {
+            classes.push('drag-column');
+        }
+        else if (this.gridOptions.fixedWidthData) {
+            classes.push('header-max-width');
+        }
+        return classes;
+    }
+    onSeparatorMouseDown(event, index, viewColumn) {
+        clearTimeout(this.clickTimeout);
+        this.clickTimeout = setTimeout(() => {
+            if (!this.gridOptions.draggable || !viewColumn.draggable) {
+                return;
+            }
+            if (!viewColumn.dragged) {
+                viewColumn.dragged = true;
+                this.changeDetectorRef.detectChanges();
+            }
+            this.resizingTh = this.getSelectedHtml(`th[data-column-prop="${viewColumn.prop}"] div`);
+            this.resizingTd = this.getSelectedHtml(`td[data-column-prop="${viewColumn.prop}"]`, true);
+            const tdDiv = this.getSelectedHtml(`td[data-column-prop="${viewColumn.prop}"] div`);
+            this.apolloDataTable = document.querySelector('.apollo-design-new-data-table');
+            if (this.resizingTh) {
+                this.startX = event.pageX;
+                this.startWidth = this.getActualWidth(this.resizingTh, this.startX);
+                const tdDivWidth = this.getActualWidth(tdDiv, this.startX);
+                if (this.resizingTd) {
+                    this.resizingTd.forEach((cell) => {
+                        const tdDiv = cell.querySelector('div');
+                        tdDiv.classList.remove('data-max-width');
+                        tdDiv.classList.add('drag-column');
+                    });
+                }
+                this.setWidthToElement(this.startWidth, tdDivWidth, this.resizingTh.offsetWidth);
+            }
+        }, 250);
+        document.body.classList.add('no-select-resize');
+        if (this.gridOptions.draggable && viewColumn.draggable) {
+            document.addEventListener('mousemove', this.onMouseMove);
+        }
+        document.addEventListener('mouseup', this.onMouseUp);
+    }
+    getSelectedHtml(selector, isSelectAll = false) {
+        if (isSelectAll) {
+            return this.customDataTable.nativeElement.querySelectorAll(selector);
+        }
+        return this.customDataTable.nativeElement.querySelector(selector);
+    }
+    formatTableData(viewColumn) {
+        if (!viewColumn.doubleClicked) {
+            this.resizingTd.forEach((cell) => {
+                const tdDiv = cell.querySelector('div');
+                tdDiv.classList.remove('drag-column');
+                if (this.gridOptions.fixedWidthData) {
+                    tdDiv.classList.add('data-max-width');
+                }
+            });
+        }
+        else {
+            this.resizingTd.forEach((cell) => {
+                const tdDiv = cell.querySelector('div');
+                tdDiv.classList.remove('data-max-width');
+                tdDiv.classList.add('drag-column');
+            });
+        }
+    }
+    formatTableHeader() {
+        this.resizingTh.style.width = '';
+        this.resizingTd.forEach((cell) => {
+            const tdDiv = cell.querySelector('div');
+            tdDiv.style.width = '';
+        });
+    }
+    setWidthToElement(thWidth, tdWidth, previousThWidth) {
+        if (this.resizingTh) {
+            this.resizingTh.style.width = `${thWidth}px`;
+        }
+        if (this.resizingTd) {
+            this.resizingTd.forEach((cell) => {
+                const div = cell.querySelector('div.drag-column');
+                if (div) {
+                    div.style.width = `${tdWidth}px`;
+                }
+            });
+        }
+        if (this.resizingTh && this.apolloDataTable) {
+            const updatedTableWidth = this.apolloDataTable.offsetWidth + (this.resizingTh.offsetWidth - previousThWidth);
+            this.apolloDataTable.style.width = `${updatedTableWidth}px`;
+        }
+    }
+    getActualWidth(element, startX) {
+        let width;
+        const boundingRect = element.getBoundingClientRect();
+        width = boundingRect.width;
+        const offset = startX - boundingRect.left;
+        if (offset < boundingRect.width) {
+            width = offset;
+        }
+        return width;
+    }
+    get pagesCount() {
+        return Math.ceil(this.count / this.pageSize);
+    }
+    get rowsCountInCurrentPage() {
+        if (!this.gridOptions.isClientSidePagination) {
+            return this.rows.length;
+        }
+        const leftRows = this.rows.length - this.pageSize * (this.currentPage - 1);
+        return leftRows >= this.pageSize ? this.pageSize : leftRows;
+    }
+    isLastRowInPage() {
+        if (this.selectedRow && this.gridOptions.isClientSidePagination) {
+            return ((this.selectedRow.rowIndex + 1) / this.currentPage === this.rowsCountInCurrentPage || this.selectedRow.rowIndex + 1 === this.count);
+        }
+        return this.selectedRow && this.selectedRow.rowIndex + 1 === this.rowsCountInCurrentPage;
+    }
+    isFirstRowInPage() {
+        return this.selectedRow && this.selectedRow.rowIndex % this.pageSize === 0;
+    }
+    isFirstRowInFirstPage() {
+        return this.isFirstRowInPage() && this.currentPage === 1;
+    }
+    isLastRowInLastPage() {
+        return this.isLastRowInPage() && this.currentPage === this.pagesCount;
+    }
+    detectRowChange() {
+        this.rows = clone(this.rows);
+        this.changeDetectorRef.detectChanges();
+    }
+    isClientSidePagination() {
+        return this.gridOptions.isClientSidePagination;
+    }
+    setIdColumn() {
+        // To do improve
+        if (this.gridOptions && this.gridOptions.idProperty) {
+            COLUMN_ID.PROP = this.gridOptions.idProperty;
+        }
+        else {
+            COLUMN_ID.PROP = 'id';
+        }
+    }
+    initColumns() {
+        this.initViewColumns();
+        if (this.gridOptions && this.gridOptions.addIdColumn) {
+            this.addIdColumn();
+        }
+    }
+    configureDialog(dialogConfig) {
+        dialogConfig.position = {
+            top: '15vh',
+            left: '20vw',
+        };
+        dialogConfig.height = '80vh';
+        dialogConfig.width = '60vw';
+        dialogConfig.panelClass = 'columnshowhide-panel';
+        dialogConfig.data = {
+            defaultSortedColumns: this.defaultSortedColumns,
+            columns: this.viewColumns,
+            storageKey: this.storageKey,
+            metaDataColumns: this.gridOptions.metaDataColumns,
+        };
+        dialogConfig.disableClose = false;
+        return dialogConfig;
+    }
+    initViewColumns() {
+        this.viewColumns = clone(this.columns.filter((x) => x != undefined));
+        this.viewColumns.forEach((viewColumn) => {
+            if (viewColumn.isVisible === undefined) {
+                viewColumn.isVisible = true;
+            }
+            if (viewColumn.isDisplayValueAsFormControl === undefined) {
+                viewColumn.isDisplayValueAsFormControl = false;
+            }
+        });
+        this.searchColumns = this.getSearchableColumns(this.viewColumns);
+    }
+    addIdColumn() {
+        this.viewColumns.unshift({
+            header: COLUMN_ID.HEADER,
+            prop: COLUMN_ID.PROP,
+            type: ColumnTypes.Integer,
+            isReadOnly: true,
+            isVisible: false, // this.isIdColVisible,
+            isDisplayValueAsFormControl: false,
+            editDisabledMode: ColumnDisableModes.AlwaysDisabled,
+        });
+    }
+    setData(selectableIndex) {
+        this.numberOfTableRefresh += 1;
+        this.isLoading$.next(true);
+        if (!this.gridOptions.isAutoColumn) {
+            this.setInitApiParams();
+        }
+        this.applyDefaultSortingParams();
+        this.getListFn(this.apiReqParams)
+            .pipe(first(), takeUntil(this.clearSubs$))
+            .subscribe((response) => {
+            // TODO: add error handling
+            this.totalItems = response.itemsTotal;
+            this.initGetFunc(response, selectableIndex);
+            if (this.gridOptions.isDefaultAllRowSelected && this.gridOptions.isClientSidePagination) {
+                this.masterSelection.setValue(true);
+                this.masterToggle();
+            }
+            this.isTableDataLoad.emit(true);
+        }, (err) => {
+            if (err) {
+                this.isLoading$.next(false);
+                this.rows = this.rows || [];
+                this.changeDetectorRef.detectChanges();
+            }
+        }, () => {
+            // Empty Method block
+        });
+    }
+    setInitApiParams() {
+        if (this.numberOfTableRefresh > 1) {
+            return;
+        }
+        this.setInitFilterParams();
+    }
+    setInitFilterParams() {
+        this.filterManager.setInitFilterParams(this.columns);
+    }
+    initGetFunc(response, selectableIndex) {
+        this.count = this.gridOptions.isClientSidePagination ? response.resultSet.length : response.itemsTotal;
+        this.searchedRowCount$.next(response.itemsTotal);
+        if (this.gridOptions.isAutoColumn) {
+            this.generateColumns(response.resultSet);
+        }
+        this.rows = this.dataTableService.getRowsFromRowsData(response.resultSet);
+        if (this.gridOptions.editable) {
+            this.rows.forEach((x) => (x.isEditing = true));
+        }
+        if (this.gridOptions.isClientSidePagination) {
+            this.originalUnsortedRows = cloneDeep(this.rows);
+        }
+        this.filteredRows = cloneDeep(this.rows);
+        this.selectedRow = undefined;
+        this.isLoading$.next(false);
+        this.isClearFilter$.next(false);
+        this.isEditing = false;
+        this.hasEmptyRow = false;
+        if (this.gridOptions.defaultSortProperty.prop) {
+            this.applyDefaultSort();
+        }
+        if (this.isEligibleForAllCheck()) {
+            this.checkedAllExceptExcludedRows();
+        }
+        else if (this.isRowSelectionEnable && !this.gridOptions.isClientSidePagination) {
+            this.setRowChecked();
+        }
+        if (this.isDefaultFirstRowSelected()) {
+            // TODO - refactor
+            this.emitNextRow(this.getSelectableValidIndex(selectableIndex));
+        }
+        this.changeDetectorRef.detectChanges();
+    }
+    isEligibleForAllCheck() {
+        return (this.isRowSelectionEnable && !this.gridOptions.isClientSidePagination && !this.masterSelection.pristine && this.masterSelection.value);
+    }
+    getSelectableValidIndex(selectableIndex) {
+        if (selectableIndex === 'last') {
+            selectableIndex = this.pageSize;
+        }
+        return Number(selectableIndex) > this.rowsCountInCurrentPage - 1 ? this.rowsCountInCurrentPage - 1 : selectableIndex;
+    }
+    setPaginationData(paginationParams) {
+        this.paginationParams = paginationParams;
+    }
+    checkedAllExceptExcludedRows() {
+        this.clearPropertyWhenSelectionEnable(this.excludedRows);
+        this.selection.clear();
+        const excludedCurrentPageRows = this.rows.filter((x) => this.excludedRows.map((e) => JSON.stringify(e)).includes(JSON.stringify(x)));
+        this.rows
+            .filter((x) => !excludedCurrentPageRows.some((y) => JSON.stringify(x) === JSON.stringify(y)))
+            .forEach((row) => {
+            if (this.gridOptions.rowDisableFn && isFunction(this.gridOptions.rowDisableFn) && !this.gridOptions.rowDisableFn(row)) {
+                this.selection.select(row);
+            }
+            else if (!this.gridOptions.rowDisableFn) {
+                this.selection.select(row);
+            }
+        });
+    }
+    applyDefaultSort() {
+        if (this.gridOptions.defaultSortProperty.order === SortDirectionEnum.DESC) {
+            this.downSort(this.gridOptions.defaultSortProperty);
+        }
+        else {
+            this.upSort(this.gridOptions.defaultSortProperty);
+        }
+    }
+    applyDefaultSortingParams() {
+        if (!this.gridOptions.defaultSortProperty.prop) {
+            return;
+        }
+        this.sortedColumn = {};
+        if (this.gridOptions.defaultSortProperty.order === SortDirectionEnum.DESC) {
+            this.sortedColumn[this.gridOptions.defaultSortProperty.prop] = SortDirectionEnum.DESC;
+        }
+        else {
+            this.sortedColumn[this.gridOptions.defaultSortProperty.prop] = SortDirectionEnum.ASC;
+        }
+    }
+    setPaginationDataOnSizeChanged(pageSize) {
+        this.paginationParams.pageSize = pageSize;
+    }
+    navigatePage(url) {
+        this.router.navigate([url], { relativeTo: this.activatedRoute });
+    }
+    openDeleteModal(row) {
+        this.rowToDelete = row;
+        const dialogConfig = new MatDialogConfig();
+        dialogConfig.data = {
+            message: this.gridOptions.deleteOptions.confirmationMessage,
+        };
+        dialogConfig.position = {
+            top: '7%',
+        };
+        dialogConfig.panelClass = 'delete-modal-panel';
+        const dialogRef = this.matDialog.open(DeleteModalComponent, dialogConfig);
+        dialogRef
+            .afterClosed()
+            .pipe(first(), takeUntil(this.clearSubs$))
+            .subscribe((result) => this.onClickDeleteModal(result));
+        this.changeDetectorRef.detectChanges();
+    }
+    saveRow(eventData) {
+        this.setIdColumn();
+        const row = eventData.row, saveData = eventData.saveData;
+        if (saveData[COLUMN_ID.PROP] === COLUMN_ID.EMPTY_ROW_VAL) {
+            this.postDataForAdd(saveData, row);
+        }
+        else {
+            this.putDataForEdit(saveData, row);
+        }
+    }
+    postDataForAdd(saveData, row) {
+        this.isSaving = true;
+        row.isSaving = true;
+        this.postItemFn(saveData)
+            .pipe(first(), takeUntil(this.clearSubs$))
+            .subscribe((result) => {
+            this.isSaving = false;
+            row.isSaving = false;
+            this.snackbarService.success(SnackbarTypes.Success, SnackbarTypes.Success);
+            if (this.gridOptions.refreshOnAdd) {
+                this.setData();
+            }
+            else {
+                this.hasEmptyRow = false;
+                saveData[COLUMN_ID.PROP] = result[COLUMN_ID.PROP];
+                this.saveLocalRow(row, saveData);
+            }
+        }, () => {
+            this.isSaving = false;
+            row.isSaving = false;
+            this.changeDetectorRef.detectChanges();
+        });
+    }
+    putDataForEdit(saveData, row) {
+        this.isSaving = true;
+        row.isSaving = true;
+        this.putItemFn(this.dataTableService.getRowId(row), saveData)
+            .pipe(first(), takeUntil(this.clearSubs$))
+            .subscribe((returnData) => {
+            if (returnData) {
+                saveData = merge(saveData, returnData);
+            }
+            this.isSaving = false;
+            row.isSaving = false;
+            this.snackbarService.info(SnackbarTypes.Update, SnackbarTypes.Update);
+            if (!this.isClientSidePagination()) {
+                this.setData();
+            }
+            else {
+                this.saveLocalRow(row, saveData);
+                this.onUpdateCompleted.emit({ row });
+            }
+        }, () => {
+            this.isSaving = false;
+            row.isSaving = false;
+            this.changeDetectorRef.detectChanges();
+        });
+    }
+    downSort(viewColumn) {
+        this.rows.sort((item1, item2) => {
+            return item1.data[viewColumn.prop] <= item2.data[viewColumn.prop] ? 1 : -1;
+        });
+        this.detectRowChange();
+    }
+    upSort(viewColumn) {
+        this.rows.sort((item1, item2) => {
+            return item1.data[viewColumn.prop] >= item2.data[viewColumn.prop] ? 1 : -1;
+        });
+        this.detectRowChange();
+    }
+    unsort() {
+        this.rows = this.originalUnsortedRows.filter((original) => {
+            return this.rows.filter((row) => JSON.stringify(row.data) === JSON.stringify(original.data));
+        });
+    }
+    sortData(viewColumn, isAscending, isUnsort = false) {
+        if (!this.gridOptions.isClientSidePagination) {
+            this.setData();
+            return;
+        }
+        if (isUnsort) {
+            this.unsort();
+        }
+        else {
+            isAscending ? this.upSort(viewColumn) : this.downSort(viewColumn);
+        }
+    }
+    addEmptyRow(depth = ROW.ROOT_DEPTH, parentId = COLUMN_ID.NO_PARENT_VAL) {
+        this.hasEmptyRow = true;
+        this.filterManager.clearFilterParams();
+        const newRow = this.getEmptyRow(depth, parentId);
+        this.selectedRow = newRow;
+        this.rows = this.dataTableService.getRowsWithInsertedRow(parentId, this.rows, newRow);
+    }
+    removeEmptyRow() {
+        this.hasEmptyRow = false;
+        this.selectedRow = undefined;
+        this.removeLocalRow(COLUMN_ID.EMPTY_ROW_VAL);
+    }
+    onSaveLocalRow(eventData) {
+        if (this.dataTableService.isEmptyRow(eventData.row)) {
+            this.addLocalRow(eventData.row, eventData.saveData);
+            this.onChangeLocalData(ChangeType.ROW_ADDED);
+        }
+        else {
+            this.editLocalRow(eventData.row, eventData.saveData);
+            this.onChangeLocalData(ChangeType.ROW_UPDATED);
+        }
+    }
+    addLocalRow(row, saveData) {
+        this.hasEmptyRow = false;
+        this.saveLocalRow(row, { ...saveData, id: this.dataTableService.getNewRowId() });
+    }
+    editLocalRow(row, saveData) {
+        this.saveLocalRow(row, saveData);
+    }
+    saveLocalRow(row, saveData) {
+        this.isEditing = false;
+        this.updateRowData(row, saveData);
+        row.isEditing = false;
+        this.detectRowChange();
+    }
+    updateRowData(row, saveData) {
+        Object.assign(row.data, saveData);
+        if (!isUndefined(row.formGroup)) {
+            this.formService.fillForm(row.formGroup, row.data);
+        }
+    }
+    removeLocalRow(removeRowId) {
+        const index = this.rows.findIndex((x) => x.data[COLUMN_ID.PROP] === removeRowId);
+        this.rows = this.dataTableService.getRowsWithRemovedRow(removeRowId, this.rows);
+        if (this.isDefaultFirstRowSelected()) {
+            this.selectAutoNextRow(index);
+        }
+        else if (this.gridOptions.defaultFirstRowSelection && this.rows.length === 0) {
+            this.onRowClicked.emit();
+        }
+        if (this.rows.length && this.rows.length % this.paginationParams.pageSize === 0) {
+            this.paginationParams.currentPage--;
+            this.searchedRowCount$.next(this.rows.length);
+        }
+        this.changeDetectorRef.detectChanges();
+    }
+    selectAutoNextRow(index) {
+        if (index !== -1) {
+            this.emitNextRow(this.rows.length === index ? this.rows.length - 1 : index);
+        }
+    }
+    isDefaultFirstRowSelected() {
+        return this.gridOptions.defaultFirstRowSelection;
+    }
+    emitNextRow(index = 0) {
+        if (this.rows.length > 0) {
+            this.rows.forEach((x) => (x.isSelected = false));
+            this.selectedRow = this.rows[index];
+            this.selectedRow.rowIndex = index;
+            this.rows[index].isSelected = true;
+            this.changeDetectorRef.detectChanges();
+            this.dataTableBody.detectChange();
+            this.onRowClicked.emit(this.rows[index]);
+        }
+        else {
+            this.onRowClicked.emit();
+        }
+    }
+    toggleRowEditing(row, isEditing) {
+        this.isEditing = isEditing;
+        row.isEditing = isEditing;
+        this.rows = [...this.rows];
+        this.changeDetectorRef.detectChanges();
+    }
+    toggleRowExpandCollapse(row, shouldExpand) {
+        row.isExpanded = shouldExpand;
+        this.rows = [...this.rows];
+        this.changeDetectorRef.detectChanges();
+    }
+    getEmptyRow(depth, parentId) {
+        return this.dataTableService.getRow(this.dataTableService.getEmptyRowData(this.viewColumns, this.defaultRowValues), depth, parentId, true);
+    }
+    onChangeLocalData(changeType = ChangeType.OTHER) {
+        this.changeLocalData.emit({
+            rowsData: this.dataTableService.getRowsDataFromRows(this.rows),
+            changeType,
+        });
+    }
+    fireInitCompleted() {
+        this.onInitCompleted.emit(this.getGridApi());
+    }
+    addCloneRow(row, depth = ROW.ROOT_DEPTH, parentId = COLUMN_ID.NO_PARENT_VAL) {
+        this.hasEmptyRow = true;
+        row.data[COLUMN_ID.PROP] = COLUMN_ID.EMPTY_ROW_VAL;
+        this.gridOptions.cloneOptions.copyOfClonableProperties.forEach((property) => {
+            row.data[property] = DataTableConstants.COPY_OF + row.data[property];
+        });
+        const emptyValueColumns = this.viewColumns.filter((col) => {
+            return this.gridOptions.cloneOptions.emptyValueProperties.includes(col.prop);
+        });
+        this.dataTableService.setEmptyValuesInRowData(row, emptyValueColumns);
+        const clonedRow = this.dataTableService.getRow(row.data, depth, parentId, true);
+        this.rows = this.dataTableService.getRowsWithInsertedRow(parentId, this.rows, clonedRow);
+        this.selectedRow = clonedRow;
+    }
+    getGridApi() {
+        return this.gridApi;
+    }
+    getSearchableColumns(columns) {
+        const searchableColumns = columns.filter((item) => Object.hasOwnProperty.call(item, 'prop') && this.gridOptions.searchableProperties.includes(item.prop));
+        return searchableColumns.length === 0 ? columns : searchableColumns;
+    }
+    masterToggleClientSide() {
+        this.isAllSelected() ? this.selection.clear() : this.nonDisabledRows.forEach((row) => this.selection.select(row));
+        this.changeDetectorRef.detectChanges();
+        this.gridApi.detectRowChanges();
+    }
+    clearPropertyWhenSelectionEnable(checkedRows) {
+        if (this.isRowSelectionEnable && checkedRows.length) {
+            checkedRows.forEach((s) => {
+                if (s.hasOwnProperty('isSelected')) {
+                    delete s.isSelected;
+                }
+                if (s.hasOwnProperty('rowIndex')) {
+                    delete s.rowIndex;
+                }
+            });
+        }
+    }
+    getCheckedRows() {
+        const checkedRows = this.selection.selected;
+        this.clearPropertyWhenSelectionEnable(checkedRows);
+        const pageMatchedPreviousCheckedRows = this.rows.filter((row) => {
+            return checkedRows.some((item) => JSON.stringify(row) === JSON.stringify(item));
+        });
+        const pageUnmatchedCheckedRows = checkedRows.filter((e) => {
+            return pageMatchedPreviousCheckedRows.findIndex((m) => JSON.stringify(e) === JSON.stringify(m)) < 0;
+        });
+        return { pageMatchedPreviousCheckedRows: pageMatchedPreviousCheckedRows, pageUnmatchedCheckedRows: pageUnmatchedCheckedRows };
+    }
+    masterToggleServerSide() {
+        const previousCheckedRows = this.getCheckedRows();
+        this.selection.clear();
+        this.addUnmatchedRowToSelection(previousCheckedRows.pageUnmatchedCheckedRows);
+        if (this.rows.length !== previousCheckedRows.pageMatchedPreviousCheckedRows.length) {
+            this.rows.forEach((row) => this.selection.select(row));
+        }
+        this.changeDetectorRef.detectChanges();
+        this.gridApi.detectRowChanges();
+    }
+    addUnmatchedRowToSelection(rows) {
+        rows.forEach((row) => this.selection.select(row));
+    }
+    setRowChecked() {
+        const previousCheckedRows = this.getCheckedRows();
+        this.selection.clear();
+        this.addUnmatchedRowToSelection(previousCheckedRows.pageUnmatchedCheckedRows);
+        this.rows
+            .filter((e) => {
+            return previousCheckedRows.pageMatchedPreviousCheckedRows.some((item) => JSON.stringify(e) === JSON.stringify(item));
+        })
+            .forEach((row) => {
+            this.selection.select(row);
+        });
+        this.changeDetectorRef.detectChanges();
+        this.gridApi.detectRowChanges();
+    }
+    getFilteredDataRow(dataRows) {
+        return dataRows.filter((e) => {
+            return this.filteredRows.some((item) => JSON.stringify(e.data) === JSON.stringify(item.data));
+        });
+    }
+    setColumnSource(property) {
+        let source;
+        const index = this.gridOptions.metaDataColumns.findIndex((value) => value === property);
+        if (index > -1) {
+            source = this.sourceTypes.METADATA;
+        }
+        else {
+            source = this.sourceTypes.DATA_SOURCE;
+        }
+        return source;
+    }
+    setColumnsUsingStoredData(defaultColumns) {
+        let tempCollection = [];
+        tempCollection = defaultColumns.filter((x) => x != undefined);
+        if (!this.storageKey) {
+            return tempCollection;
+        }
+        let storedColumns = this.localStorageService.getItem(this.storageKey);
+        if (storedColumns && storedColumns.length) {
+            var index = 0;
+            storedColumns
+                .filter((x) => x != undefined)
+                .forEach((item) => {
+                const existingColumnIndex = tempCollection.findIndex((x) => x.prop === item.prop);
+                if (existingColumnIndex > -1) {
+                    const existingColumn = tempCollection.find((x) => x.prop === item.prop);
+                    if (existingColumn) {
+                        existingColumn.isVisible = true;
+                        var tempcolumn = tempCollection[index];
+                        tempCollection[index] = existingColumn;
+                        tempCollection[existingColumnIndex] = tempcolumn;
+                    }
+                }
+                index++;
+            });
+            // added invisible columns at the end to complete the set
+            tempCollection
+                .filter((item) => item && storedColumns.findIndex((x) => x.prop === item.prop) < 0)
+                .forEach((item) => {
+                if (item) {
+                    item.isVisible = false;
+                }
+            });
+        }
+        return tempCollection;
+    }
+    selectedCheckboxPagingConfirmation(selectableIndex) {
+        const dialogRef = this.matDialog.open(CommonConfirmModalComponent, {
+            width: '450px',
+            data: {
+                body: this.confirmationMsgPagination,
+            },
+        });
+        dialogRef
+            .afterClosed()
+            .pipe()
+            .subscribe((confirmation) => {
+            if (confirmation) {
+                this.setData(selectableIndex);
+            }
+        });
+    }
+    isSelectedRow() {
+        return this.gridApi.getSelectedRows().map((x) => x.data).length;
+    }
+    searchTable() {
+        this.searchValue.valueChanges
+            .pipe(filter((res) => res.length >= 2 || res === ''), debounceTime(500), distinctUntilChanged(), takeUntil(this.clearSubs$))
+            .subscribe(() => {
+            if (!this.isSearchDisabled) {
+                this.paginationParams.currentPage = 1;
+                this.changeDetectorRef.detectChanges();
+                this.setData();
+            }
+        });
+    }
+    populateFilterParams() {
+        if (!this.gridOptions.isClientSidePagination && this.gridOptions.isSearchBoxVisible && !this.gridOptions.isUpdatedTableDesign) {
+            return [{ columnName: 'searchText', filterValue: this.searchValue.value }, ...this.filterManager.getFilterParams()];
+        }
+        return this.filterManager.getFilterParams();
+    }
+    getConfiguredColumns() {
+        if (isFunction(this.gridOptions.storageFn)) {
+            this.storageKey = this.gridOptions.storageFn();
+            let columns = this.setColumnsUsingStoredData(this.columns);
+            this.viewColumns = columns.filter((x) => x != undefined);
+        }
+    }
+    generateColumns(rowData) {
+        this.columns = Object.keys(rowData[0]).map((x) => {
+            return {
+                header: x.toUpperCase(),
+                prop: x,
+                type: ColumnTypes.String,
+                rendererTemplate: this.gridOptions.renderTemplatesProp ? this.gridOptions.renderTemplatesProp[x] : undefined,
+            };
+        });
+        this.initColumns();
+        this.defaultSortedColumns = clone(this.viewColumns);
+        this.changeDetectorRef.detectChanges();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DataTableComponent, deps: [{ token: i1.DataTableService }, { token: i2.Router }, { token: i2.ActivatedRoute }, { token: i3.MatDialog }, { token: i0.ChangeDetectorRef }, { token: i4.SnackbarService }, { token: i5.UserManagementService }, { token: i6.ColumnFilterPipe }, { token: i7.SearchPipe }, { token: i8.LocalStorageService }, { token: i3.MatDialog }, { token: i9.FormService }, { token: i10.DataTableContextService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: DataTableComponent, selector: "app-data-table", inputs: { defaultRowValues: "defaultRowValues", columns: "columns", getListFn: "getListFn", postItemFn: "postItemFn", putItemFn: "putItemFn", deleteItemFn: "deleteItemFn", header: "header", description: "description", actionAddTitle: "actionAddTitle", isIdColVisible: "isIdColVisible", hasPagination: "hasPagination", isOnlyView: "isOnlyView", isOnlyViewRow: "isOnlyViewRow", isDeleteDisabled: "isDeleteDisabled", isEditable: "isEditable", isCloneVisible: "isCloneVisible", isLazyInitialization: "isLazyInitialization", objectName: "objectName", gridOptions: "gridOptions", isRowSelectionEnable: "isRowSelectionEnable", beforeSaveFn: "beforeSaveFn", onBeforeEdit: "onBeforeEdit", onAddClick: "onAddClick", isRowUnchecked: "isRowUnchecked", isSaveDataLocal: "isSaveDataLocal", scrollPosition: "scrollPosition", isTreeGrid: "isTreeGrid", initialPage: "initialPage" }, outputs: { changeLocalData: "changeLocalData", actionClick: "actionClick", onInitCompleted: "onInitCompleted", onComplexDetailClicked: "onComplexDetailClicked", onEditClicked: "onEditClicked", onAddClicked: "onAddClicked", onRowClicked: "onRowClicked", onPageChanged: "onPageChanged", matExpansionPanelClicked: "matExpansionPanelClicked", onUpdateCompleted: "onUpdateCompleted", onDeleteCompleted: "onDeleteCompleted", onScrolled: "onScrolled", CheckboxSelect: "CheckboxSelect", isTableDataLoad: "isTableDataLoad" }, providers: [
+            {
+                provide: DATA_TABLE_CONTEXT,
+                useExisting: DataTableComponent,
+            },
+        ], viewQueries: [{ propertyName: "setDataTableBody", first: true, predicate: DataTableBodyComponent, descendants: true }, { propertyName: "deleteModal", first: true, predicate: ["deleteModal"], descendants: true, read: TemplateRef, static: true }, { propertyName: "customDataTable", first: true, predicate: ["customDataTable"], descendants: true }, { propertyName: "sliderTemplate", first: true, predicate: ["sliderTemplate"], descendants: true }], ngImport: i0, template: "<div>\n    <section class=\"actions\">\n        <section class=\"search\" *ngIf=\"gridOptions.isSearchBoxVisible && !gridOptions.isUpdatedTableDesign\">\n            <form ngForm>\n                <div class=\"searchbar-wrapper\">\n                    <i class=\"svg-icon fa-solid fa-magnifying-glass\"></i>\n                    <input matInput type=\"text\" placeholder=\"Search {{ searchPlaceholder }}\" name=\"search\"\n                        [formControl]=\"searchValue\" [disabled]=\"isSearchDisabled\"\n                        (ngModelChange)=\"searchModelChanged()\" />\n                </div>\n            </form>\n        </section>\n        <div class=\"toolbar\" *ngIf=\"!gridOptions.hideTopToolbar\">\n            <section *ngIf=\"!isOnlyView\" class=\"adding\">\n                <ul class=\"row-actions\">\n                    <ng-container *hasPermission=\"getActionName(actionTypes.ADD)\">\n                        <li *ngIf=\"!gridOptions.addButtonTemplate\">\n                            <span *ngIf=\"!isTableInEditState\">\n                                <a (click)=\"onClickAdd()\"\n                                    [ngClass]=\"{'disabled': isDisabledMainAction(actionTypes.ADD) || (gridOptions.disableIcons && gridOptions.disableIcons.add$ |async)}\">\n                                    <span title=\"{{getTooltipText(toolTips.ADD)}}\" class=\"toolbar-icon icon-plus\"\n                                        [ngClass]=\"(isDisabledMainAction(actionTypes.ADD) || (gridOptions.disableIcons && gridOptions.disableIcons.add$ |async))? 'icon-inactive': 'icon-active'\"></span>\n                                </a>\n                            </span>\n                        </li>\n                    </ng-container>\n                    <ng-container *ngIf=\"gridOptions.addButtonTemplate\">\n                        <li>\n                            <ng-container *ngTemplateOutlet=\"gridOptions.addButtonTemplate;\"></ng-container>\n                        </li>\n                    </ng-container>\n                </ul>\n                <ng-container *ngIf=\"!isLoading$.getValue()\">\n                    <app-data-table-actions\n                        *ngIf=\"!(isOnlyView && !isViewActionVisible) && !gridOptions.isRowActionVisible\"\n                        [gridApi]=\"gridApi\" [canInlineEdit]=\"canInlineEdit\" [isTreeGrid]=\"isTreeGrid\"\n                        [gridOptions]=\"gridOptions\" [selectedRow]=\"selectedRow\" [isIconsDisabled]=\"isActionsDisabled\"\n                        [isEditing]=\"selectedRow?.isEditing\" [isSaving]=\"selectedRow?.isSaving\"\n                        [isOnlyView]=\"isOnlyView\" [isEditable]=\"isEditable\" (clickAdd)=\"onClickAdd()\"\n                        [hasEmptyRow]=\"hasEmptyRow\" [isEditing]=\"isEditing\" [isSaving]=\"isSaving\"\n                        [isCloneVisible]=\"isCloneVisible\" [isDeleteVisible]=\"!checkDeleteDisabled()\">\n                    </app-data-table-actions>\n                </ng-container>\n            </section>\n            <ul class=\"row-actions\" *ngIf=\"!isOnlyView || gridOptions.isTopLeftActionsForceDisply\">\n                <ng-container *ngFor=\"let action of gridOptions.topLeftAdditionalActions\">\n                    <li>\n                        <a *hasPermission=\"getLeftActionName(action.actionName)\"\n                            [ngClass]=\"{'disabled': action.isDisabled}\" (click)=\"ActionClickHandler(action)\"\n                            class=\"fontIco\">\n                            <app-icon *ngIf=\"!action.isClass\" [title]=\"getLeftRightActionText(action)\"\n                                [name]=\"action.iconOrClassName\"></app-icon>\n                            <span *ngIf=\"action.isClass\" title=\"{{getLeftRightActionText(action)}}\"\n                                class=\"toolbar-icon {{ action.iconOrClassName }}\"\n                                [ngClass]=\"(action.actionName===actionTypes.UPLOAD && action.isDisabled)? 'icon-inactive': ''\"></span>\n                        </a>\n                    </li>\n                    <li *ngIf=\"action.loading$ | async\">\n                        <mat-spinner class=\"mr-1 action-loader\" [diameter]=\"25\"></mat-spinner>\n                    </li>\n                </ng-container>\n\n            </ul>\n            <ng-container *ngIf=\"gridOptions.leftActionBtnTemplate\">\n                <ng-container *ngTemplateOutlet=\"gridOptions.leftActionBtnTemplate\"></ng-container>\n            </ng-container>\n            <span class=\"toolbar-spacer\"></span>\n\n            <ul class=\"row-actions\">\n\n                <ng-container *ngFor=\"let action of gridOptions.topRightActions\">\n                    <li>\n                        <a (click)=\"ActionClickHandler(action)\" class=\"fontIco\">\n                            <app-icon [title]=\"getLeftRightActionText(action)\" [name]=\"action.icon\"></app-icon>\n                        </a>\n                    </li>\n                </ng-container>\n\n            </ul>\n            <ng-container *ngIf=\"gridOptions.isUpdatedTableDesign\">\n                <ng-container *ngIf=\"gridOptions.newTableButtontemplate\">\n                    <ng-container *ngTemplateOutlet=\"gridOptions.newTableButtontemplate\"></ng-container>\n                </ng-container>\n                <section class=\"search\" *ngIf=\"gridOptions.isSearchBoxVisible\">\n                    <form ngForm>\n                        <div class=\"searchbar-wrapper\">\n                            <i class=\"svg-icon fa-solid fa-magnifying-glass\"></i>\n                            <input matInput type=\"text\" placeholder=\"Search\" name=\"search\" [formControl]=\"searchValue\"\n                                [disabled]=\"isSearchDisabled\" (ngModelChange)=\"searchModelChanged()\" />\n                        </div>\n                    </form>\n                </section>\n                <ng-container *ngIf=\"gridOptions.isFilterEnabled\">\n                    <button mat-stroked-button color=\"primary\" (click)=\"showHideFilterView()\">\n                        <em class=\"fas fa-filter inactive-filter\" [ngClass]=\"{'active-filter': isFilterApplied }\"></em>\n                        Filter\n                    </button>\n                    <button [title]=\"'Clear'\" (click)=\"clearGlobalFilter()\" mat-stroked-button color=\"primary\">\n                        <em class=\"fas fa-broom\"></em>\n                    </button>\n                </ng-container>\n            </ng-container>\n\n            <ul class=\"row-actions\">\n                <li *ngIf=\"!gridOptions.hideColumnConfiguration\">\n                    <a (click)=\"openColumnShowHideDialogue()\" class=\"fontIco\">\n                        <app-icon [title]=\"getTooltipText(toolTips.COLUMN_CONFIGURATION)\" [name]=\"ICONS.ColumnSelector\">\n                        </app-icon>\n                    </a>\n                </li>\n            </ul>\n\n        </div>\n    </section>\n</div>\n\n<mat-card class=\"table-card\" [ngClass]=\"{'transparent-table-design': gridOptions.isTransparentTableDesign}\">\n    <app-loader *ngIf=\"isLoading$ | async\" class=\"loader-middle\"></app-loader>\n\n    <mat-card-content>\n        <div class=\"custom-data-table\" [ngClass]=\"{'default-table-height': isLoading$.getValue(), 'overflow-visible': gridOptions.isAccordionTable }\"\n            (scroll)=\"onTableScrolled($event)\" #customDataTable [ngStyle]=\"getCustomTableStyle\">\n            <table aria-describedby=\"Generic data table\" *ngIf=\"!gridOptions.isAccordionTable\"\n                class=\"table apollo-design-new-data-table\" [ngClass]=\"{ '-tree': isTreeGrid }\" mdbTable>\n                <thead *ngIf=\"!gridOptions.hideTableHeader\" class=\"sticky-header\">\n                    <tr *ngIf=\"gridOptions.isUpdatedTableDesign && isFilterView\" class=\"table-first-header\">\n                        <th *ngIf=\"isRowSelectionEnable\" scope=\"col\"></th>\n                        <ng-container *ngFor=\"let viewColumn of viewColumns\">\n                            <th *ngIf=\"viewColumn.isVisible\" scope=\"col\" class=\"header\"\n                                [ngClass]=\"{'transparent': !viewColumn.isMetaDataColumn && gridOptions.isUpdatedTableDesign}\">\n                                <app-data-col-filter *ngIf=\"isFilterEnable(viewColumn.prop)\" [columnName]=\"viewColumn\"\n                                    [ngClass]=\"{'filteredColumn': isFilteredColumn(viewColumn.prop)}\"\n                                    (onFilterClicked)=\"onFilterClicked($event)\" [filterOption]=\"viewColumn.filterOption\"\n                                    [numberOfTableRefresh]=\"numberOfTableRefresh\" [isUpdatedFilterDesign]=\"true\"\n                                    [isClearFilter$]=\"isClearFilter$\" [filterParam]=\"getFilterParam(viewColumn)\">\n                                </app-data-col-filter>\n                            </th>\n                        </ng-container>\n                    </tr>\n                    <tr class=\"table-second-header\">\n                        <th *ngIf=\"isRowSelectionEnable  && !isSingleSelect\" scope=\"col\" class=\"hasSelection\">\n                            <mat-checkbox class=\"table-header-checkbox\" (change)=\"$event ? masterToggle() : null\"\n                                [formControl]=\"masterSelection\" [checked]=\"selection.hasValue() && isAllSelected()\"\n                                [indeterminate]=\"selection.hasValue() && !isAllSelected()\">\n                            </mat-checkbox>\n                        </th>\n                        <th scope=\"col\" *ngIf=\"isRowSelectionEnable && isSingleSelect\" class=\"hasSelection\"></th>\n                        <ng-container *ngFor=\"let viewColumn of viewColumns; let i = index\">\n                            <th *ngIf=\"viewColumn.isVisible\" scope=\"col\" class=\"header\" [attr.data-column-prop]=\"viewColumn.prop\"\n                                [ngClass]=\"{'transparent': !viewColumn.isMetaDataColumn && gridOptions.isUpdatedTableDesign}\">\n                                <div [ngClass]=\"getHeaderStyle(i, viewColumn)\">\n                                    <app-data-col-filter\n                                        *ngIf=\"isFilterEnable(viewColumn.prop) && !gridOptions.isUpdatedTableDesign\"\n                                        [columnName]=\"viewColumn\"\n                                        [ngClass]=\"{'filteredColumn': isFilteredColumn(viewColumn.prop)}\"\n                                        (onFilterClicked)=\"onFilterClicked($event)\"\n                                        [filterOption]=\"viewColumn.filterOption\"\n                                        [numberOfTableRefresh]=\"numberOfTableRefresh\" [isClearFilter$]=\"isClearFilter$\"\n                                        [filterParam]=\"getFilterParam(viewColumn)\">\n                                    </app-data-col-filter>\n\n                                    <span class=\"header\" [ngClass]=\"{'sort-column': isSortColumn(viewColumn)}\"\n                                        (click)=\"sortTable(viewColumn)\">{{ viewColumn.header }}\n                                        <ng-container *ngIf=\"viewColumn.headerIconClass\">\n                                            <span class=\"header-icon\" [ngClass]=\"viewColumn.headerIconClass\"></span>\n                                        </ng-container>\n                                        <span class=\"sort-icon\"\n                                            *ngIf=\"sortedColumn[viewColumn.prop]=== sortDirectionEnum.DESC\">\n                                            <em class=\"material-icons\">\n                                                arrow_downward\n                                            </em>\n                                        </span>\n                                        <span class=\"sort-icon\"\n                                            *ngIf=\"sortedColumn[viewColumn.prop]=== sortDirectionEnum.ASC\">\n                                            <em class=\"material-icons\">\n                                                arrow_upward\n                                            </em>\n                                        </span>\n                                    </span>\n                                    <ng-container\n                                        *ngIf=\"gridOptions.isUpdatedTableDesign && isFilteredColumn(viewColumn.prop)\">\n                                        <em class=\"fas fa-filter active-filter\"></em>\n                                    </ng-container>\n                                    <div *ngIf=\"gridOptions.draggable\"\n                                        [ngClass]=\"{ 'header-separator': true, 'col-resize-cursor': viewColumn.draggable }\"\n                                        (mousedown)=\"onSeparatorMouseDown($event, i, viewColumn)\"\n                                        (dblclick)=\"onDoubleClickSeparator(i, viewColumn)\">\n                                    </div>\n                                </div>\n                            </th>\n                        </ng-container>\n                        <th *ngIf=\"!(isOnlyView && !isViewActionVisible) && gridOptions.isRowActionVisible\" scope=\"col\">\n                            Actions</th>\n                        <th [ngClass]=\"{'transparent': gridOptions.isUpdatedTableDesign}\"\n                            *ngIf=\"gridOptions.gridMenuOptions && gridOptions.gridMenuOptions.isMenuEnabled\"></th>\n                    </tr>\n                    <ng-container *ngIf=\"gridOptions.hasFixedFirstRow\">\n                        <tr *ngIf=\"!(isLoading$ | async)\">\n                            <th *ngIf=\"isRowSelectionEnable  && !isSingleSelect\" class=\"transparent\"></th>\n                            <th *ngIf=\"isRowSelectionEnable && isSingleSelect\" class=\"transparent\"></th>\n                            <ng-container *ngFor=\"let viewColumn of viewColumns\">\n                                <th class=\"transparent\">\n                                    <ng-container\n                                        *ngTemplateOutlet=\"viewColumn.fixedFirstRowTemplate; context: { $implicit: { col: viewColumn } }\"></ng-container>\n                                </th>\n                            </ng-container>\n                        </tr>\n                    </ng-container>\n                </thead>\n                <tbody *ngIf=\"!isLoading$.getValue()\" app-data-table-body [gridOptions]=\"gridOptions\"\n                    [selection]=\"selection\"\n                    [rows]=\"rows | columnFilter : filterManager.getFilterParams() : columns: gridOptions.isClientSidePagination\"\n                    [viewColumns]=\"viewColumns\" [canInlineEdit]=\"canInlineEdit\" [isTreeGrid]=\"isTreeGrid\"\n                    [isOnlyView]=\"isOnlyView\" [searchedRowCount$]=\"searchedRowCount$\" [onAddClick]=\"onAddClick\"\n                    [isOnlyViewRow]=\"isOnlyViewRow\" [isDeleteDisabled]=\"isDeleteDisabled\" [search]=\"searchValue.value\"\n                    [paginationParams]=\"paginationParams\" [hasEmptyRow]=\"hasEmptyRow\" [isEditing]=\"isEditing\"\n                    [isRowSelectionEnable]=\"isRowSelectionEnable\" [searchColumns]=\"searchColumns\"\n                    [isCloneVisible]=\"isCloneVisible\" (clickEdit)=\"onClickEdit($event)\"\n                    (clickClone)=\"onClickClone($event)\" (clickAction)=\"onClickAction($event)\"\n                    (clickEditCancel)=\"onClickEditCancel($event)\" (clickEditSave)=\"onClickEditSave($event)\"\n                    (clickDelete)=\"onClickDeleteRow($event)\" (clickView)=\"onClickView($event)\"\n                    (clickAdd)=\"onClickRowAdd($event)\" (clickRow)=\"onClickRow($event)\"\n                    (changeExpandCollapse)=\"onChangeExpandCollapse($event)\"\n                    (complexDetailClicked)=\"ComplexDetailClicked($event)\" [isRowUnchecked]=\"isRowUnchecked\"\n                    (CheckboxSelect)=\"isCheckboxSelect($event)\">\n                </tbody>\n\n            </table>\n\n            <ng-container *ngIf=\"gridOptions.isAccordionTable\">\n                <mat-accordion displayMode=\"flat\" multi class=\"mat-table\" *ngIf=\"gridOptions.isAccordionTable\">\n                    <mat-expansion-panel *ngIf=\"!gridOptions.hideTableHeader\" class=\"mask-body header-panel\" hideToggle>\n                        <mat-expansion-panel-header (keydown.Enter)=\"$event.stopImmediatePropagation();\"\n                            [collapsedHeight]=\"'auto'\" [expandedHeight]=\"'auto'\" class=\"mat-row header-row\">\n                            <div class=\"mat-checkboxRow\" *ngIf=\"isRowSelectionEnable  && !isSingleSelect\"\n                                (click)=\"$event.stopPropagation()\">\n                                <mat-checkbox (change)=\"$event ? masterToggle() : null\" [(ngModel)]=\"masterSelection\"\n                                    [checked]=\"selection.hasValue() && isAllSelected()\"\n                                    [indeterminate]=\"selection.hasValue() && !isAllSelected()\">\n                                </mat-checkbox>\n                            </div>\n                            <ng-container *ngFor=\"let viewColumn of viewColumns\">\n                                <div *ngIf=\"viewColumn.isVisible\" scope=\"col\" (click)=\"$event.stopPropagation()\"\n                                    class=\"mat-cell d-inline-block\" [ngClass]=\"viewColumn.customCssClass\">\n                                    <app-data-col-filter class=\"filter-column\" *ngIf=\"isFilterEnable(viewColumn.prop)\"\n                                        [columnName]=\"viewColumn\"\n                                        [ngClass]=\"{'filteredColumn': isFilteredColumn(viewColumn.prop)}\"\n                                        (onFilterClicked)=\"onFilterClicked($event)\"\n                                        [filterOption]=\"viewColumn.filterOption\"\n                                        [numberOfTableRefresh]=\"numberOfTableRefresh\"\n                                        [filterParam]=\"getFilterParam(viewColumn)\">\n                                    </app-data-col-filter>\n                                    &nbsp;\n                                    <span [ngClass]=\"nonFilterClassName(viewColumn.prop)\" class=\"table .header\"\n                                        (click)=\"sortTable(viewColumn)\">{{ viewColumn.header }}\n                                        <span class=\"sort-icon\" *ngIf=\"sortedColumn[viewColumn.prop]=='DownSorted'\">\n                                            <em class=\"material-icons\">\n                                                arrow_downward\n                                            </em>\n                                        </span>\n                                        <span class=\"sort-icon\" *ngIf=\"sortedColumn[viewColumn.prop]=='UpSorted'\">\n                                            <em class=\"material-icons\">\n                                                arrow_upward\n                                            </em>\n                                        </span>\n                                    </span>\n                                </div>\n                            </ng-container>\n                        </mat-expansion-panel-header>\n                    </mat-expansion-panel>\n                    <ng-container>\n                        <div *ngIf=\"!isLoading$.getValue()\" app-data-table-body [gridOptions]=\"gridOptions\"\n                            [selection]=\"selection\"\n                            [rows]=\"rows | columnFilter : filterManager.getFilterParams() : columns: gridOptions.isClientSidePagination\"\n                            [viewColumns]=\"viewColumns\" [canInlineEdit]=\"canInlineEdit\" [isTreeGrid]=\"isTreeGrid\"\n                            [isOnlyView]=\"isOnlyView\" [searchedRowCount$]=\"searchedRowCount$\"\n                            [isOnlyViewRow]=\"isOnlyViewRow\" [isDeleteDisabled]=\"isDeleteDisabled\"\n                            [search]=\"searchValue.value\" [paginationParams]=\"paginationParams\"\n                            [hasEmptyRow]=\"hasEmptyRow\" [isEditing]=\"isEditing\"\n                            [isRowSelectionEnable]=\"isRowSelectionEnable\" [searchColumns]=\"searchColumns\"\n                            [isCloneVisible]=\"isCloneVisible\" (clickEdit)=\"onClickEdit($event)\"\n                            (matExpansionPanelClicked)=\"onExpansionPanelClick($event)\"\n                            (clickClone)=\"onClickClone($event)\" (clickAction)=\"onClickAction($event)\"\n                            (clickEditCancel)=\"onClickEditCancel($event)\" (clickEditSave)=\"onClickEditSave($event)\"\n                            (clickDelete)=\"onClickDeleteRow($event)\" (clickView)=\"onClickView($event)\"\n                            (clickAdd)=\"onClickRowAdd($event)\" (clickRow)=\"onClickRow($event)\"\n                            (changeExpandCollapse)=\"onChangeExpandCollapse($event)\"\n                            (complexDetailClicked)=\"ComplexDetailClicked($event)\"\n                            (CheckboxSelect)=\"isCheckboxSelect($event)\"></div>\n\n                    </ng-container>\n                </mat-accordion>\n            </ng-container>\n        </div>\n        <section *ngIf=\"hasPagination && selection\" class=\"pagination\">\n            <app-data-pagination [selectionCount]=\"selection.selected.length\" class=\"table-pagination-container\" [ngClass]=\"{'transparent-table-design': gridOptions.isTransparentTableDesign}\"  [totalRowCount$]=\"this.searchedRowCount$\"\n                [count]=\"count\" [page]=\"paginationParams.currentPage\" [size]=\"paginationParams.pageSize\" [hasDropdownStylePageSize]=\"gridOptions.hasDropdownStylePageSize ?? true\"\n                (changePage)=\"onChangePage($event)\">\n            </app-data-pagination>\n        </section>\n    </mat-card-content>\n</mat-card>", styles: [".show-hide{float:right}::-webkit-input-placeholder{color:#000;font-size:11px}::-moz-placeholder{color:#000;font-size:11px}:-ms-input-placeholder{color:#000;font-size:11px}::placeholder{color:#000;font-size:11px}.custom-data-table{margin:0!important;overflow-x:auto;position:relative}.table-card{padding:0}.custom-data-table .table thead th:first-child{border-top-left-radius:4px}.custom-data-table .table thead th:last-child{border-top-right-radius:4px}.custom-data-table .table thead th{padding:.5rem .8rem;text-align:left;white-space:nowrap;font-weight:400;color:#393939;font-size:.9rem;vertical-align:middle;position:relative}.hasSelection{width:20px}.search{margin:1px 0 22px}.sort-icon .material-icons{color:#2371fc;font-size:18px;position:relative;top:4px;left:10px;padding-right:14px}.table-card-hidden{visibility:hidden}.disabled{pointer-events:none!important;color:gray!important}.table-card{margin-bottom:14px;border-radius:4px;border:1px solid rgb(233,233,233);box-shadow:0 4px 16px #0000000a;opacity:1;background-color:#fff}::ng-deep .mat-checkbox-checked.mat-accent .mat-checkbox-background,.mat-checkbox-indeterminate.mat-accent .mat-checkbox-background{background-color:#0768fd}::ng-deep .filteredColumn>a:hover{color:#0768fd!important}::ng-deep .mat-checkbox-indeterminate.mat-accent .mat-checkbox-background,.mat-checkbox-checked.mat-accent .mat-checkbox-background{background-color:#0768fd}:host ::ng-deep app-data-col-filter.filteredColumn>a{color:#0768fd}:host ::ng-deep app-data-col-filter a{color:#999}.table-pagination-container{width:100%;padding:12px 16px;border-bottom-left-radius:4px;border-bottom-right-radius:4px;border-top:1px solid rgb(233,233,233);opacity:1;background-color:#f6f7fb}.text-link-with-ico{color:#0768fd!important}.text-link-with-ico img{position:relative;top:-2px;padding-right:12px}a.text-link-with-ico{margin-right:0}.search-icon{margin-right:5px;position:absolute;top:10px;left:10px;font-size:16px;color:#bbb;z-index:1000}.fontIco{font-size:20px}.mat-checkboxRow{margin-right:6px}.filter-column{color:#ccc;margin-left:2px}.empty-row{width:auto;margin:0;font-size:15px;line-height:5rem;text-align:center}.non-filter-cell{margin-left:-8px}.row-selection-non-filter-cell{margin-left:-2px}.table-header-checkbox{margin-left:0}.toolbar .adding{display:flex;align-items:center}.sticky-header{position:sticky;top:0;z-index:100}.inactive-filter{color:#ccc!important}.active-filter,.header-icon{color:#0768fd!important}.clear-button{padding:4px 15px!important;font-weight:700}.transparent{background-color:#fff;opacity:1}.loader-middle{position:absolute;z-index:99;left:45%;margin-left:-28px;top:40%;margin-top:-28px}.default-table-height{height:300px}.no-records-found{width:auto;font-size:15px;position:absolute;top:40%;left:45%}.sort-column{cursor:pointer}.icon-inactive{filter:grayscale(1)}.header-separator{position:absolute;top:7px;right:0;height:60%;width:3px;background-color:#1c1a1a33;transition:background-color .3s ease;z-index:1}.header-separator:before{content:\"\";position:absolute;inset:0 0 0 -10px}.col-resize-cursor{cursor:col-resize}.header-separator:hover{background-color:#00000080}.drag-column{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;min-width:50px}.header-max-width{max-width:170px;overflow:hidden;text-overflow:ellipsis}.overflow-visible{overflow:visible}:host ::ng-deep .mat-expansion-panel.header-panel{overflow:visible}\n"], dependencies: [{ kind: "directive", type: i11.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i11.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i11.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i11.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i11.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "directive", type: i12.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "component", type: i13.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", exportAs: ["matButton"] }, { kind: "component", type: i14.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "directive", type: i14.MatCardContent, selector: "mat-card-content" }, { kind: "component", type: i15.MatCheckbox, selector: "mat-checkbox", inputs: ["aria-label", "aria-labelledby", "aria-describedby", "id", "required", "labelPosition", "name", "value", "disableRipple", "tabIndex", "color", "disabledInteractive", "checked", "disabled", "indeterminate"], outputs: ["change", "indeterminateChange"], exportAs: ["matCheckbox"] }, { kind: "directive", type: i16.MatAccordion, selector: "mat-accordion", inputs: ["hideToggle", "displayMode", "togglePosition"], exportAs: ["matAccordion"] }, { kind: "component", type: i16.MatExpansionPanel, selector: "mat-expansion-panel", inputs: ["hideToggle", "togglePosition"], outputs: ["afterExpand", "afterCollapse"], exportAs: ["matExpansionPanel"] }, { kind: "component", type: i16.MatExpansionPanelHeader, selector: "mat-expansion-panel-header", inputs: ["expandedHeight", "collapsedHeight", "tabIndex"] }, { kind: "component", type: i17.MatProgressSpinner, selector: "mat-progress-spinner, mat-spinner", inputs: ["color", "mode", "value", "diameter", "strokeWidth"], exportAs: ["matProgressSpinner"] }, { kind: "directive", type: i18.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i18.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i18.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i18.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i18.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: i18.NgForm, selector: "form:not([ngNoForm]):not([formGroup]),ng-form,[ngForm]", inputs: ["ngFormOptions"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i18.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "directive", type: i19.DefaultClassDirective, selector: "  [ngClass], [ngClass.xs], [ngClass.sm], [ngClass.md], [ngClass.lg], [ngClass.xl],  [ngClass.lt-sm], [ngClass.lt-md], [ngClass.lt-lg], [ngClass.lt-xl],  [ngClass.gt-xs], [ngClass.gt-sm], [ngClass.gt-md], [ngClass.gt-lg]", inputs: ["ngClass", "ngClass.xs", "ngClass.sm", "ngClass.md", "ngClass.lg", "ngClass.xl", "ngClass.lt-sm", "ngClass.lt-md", "ngClass.lt-lg", "ngClass.lt-xl", "ngClass.gt-xs", "ngClass.gt-sm", "ngClass.gt-md", "ngClass.gt-lg"] }, { kind: "directive", type: i19.DefaultStyleDirective, selector: "  [ngStyle],  [ngStyle.xs], [ngStyle.sm], [ngStyle.md], [ngStyle.lg], [ngStyle.xl],  [ngStyle.lt-sm], [ngStyle.lt-md], [ngStyle.lt-lg], [ngStyle.lt-xl],  [ngStyle.gt-xs], [ngStyle.gt-sm], [ngStyle.gt-md], [ngStyle.gt-lg]", inputs: ["ngStyle", "ngStyle.xs", "ngStyle.sm", "ngStyle.md", "ngStyle.lg", "ngStyle.xl", "ngStyle.lt-sm", "ngStyle.lt-md", "ngStyle.lt-lg", "ngStyle.lt-xl", "ngStyle.gt-xs", "ngStyle.gt-sm", "ngStyle.gt-md", "ngStyle.gt-lg"] }, { kind: "component", type: i20.DataPaginationComponent, selector: "app-data-pagination", inputs: ["totalRowCount$", "count", "page", "pageSizeOptions", "size", "selectionCount", "numberOfLinks", "hasDropdownStylePageSize"], outputs: ["changePage", "changePageSize"] }, { kind: "component", type: i21.LoaderComponent, selector: "app-loader", inputs: ["colorScheme", "componentSize"] }, { kind: "component", type: i22.DataTableActionsComponent, selector: "app-data-table-actions", inputs: ["canInlineEdit", "isEditable", "isEditing", "isSaving", "isTreeGrid", "isOnlyView", "hasEmptyRow", "isCloneVisible", "isDeleteVisible", "selectedRow", "gridApi", "gridOptions", "isIconsDisabled"], outputs: ["clickAdd"] }, { kind: "component", type: i23.IconComponent, selector: "app-icon", inputs: ["name", "title", "colorScheme", "hasStyleOnHover", "isDisabled"] }, { kind: "component", type: i24.DataTableBodyComponent, selector: "[app-data-table-body]", inputs: ["rows", "viewColumns", "canInlineEdit", "isTreeGrid", "isOnlyView", "isOnlyViewRow", "isDeleteDisabled", "isEditable", "searchedRowCount$", "gridOptions", "search", "paginationParams", "hasEmptyRow", "isEditing", "isSaving", "isRowSelectionEnable", "isCloneVisible", "searchColumns", "selection", "isRowUnchecked", "onAddClick"], outputs: ["clickAction", "clickEdit", "clickEditCancel", "clickEditSave", "clickView", "clickDelete", "clickAdd", "clickRow", "changeExpandCollapse", "complexDetailClicked", "clickClone", "matExpansionPanelClicked", "CheckboxSelect"] }, { kind: "component", type: i25.DataColFilterComponent, selector: "app-data-col-filter", inputs: ["isClearFilter$", "isUpdatedFilterDesign", "columnName", "filterParam", "numberOfTableRefresh", "filterOption"], outputs: ["onFilterClicked"] }, { kind: "directive", type: i26.AuthorizedDirective, selector: "[hasPermission]", inputs: ["hasPermission", "hasPermissionElse"] }, { kind: "pipe", type: i11.AsyncPipe, name: "async" }, { kind: "pipe", type: i27.ColumnFilterPipe, name: "columnFilter" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DataTableComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-data-table', changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        {
+                            provide: DATA_TABLE_CONTEXT,
+                            useExisting: DataTableComponent,
+                        },
+                    ], template: "<div>\n    <section class=\"actions\">\n        <section class=\"search\" *ngIf=\"gridOptions.isSearchBoxVisible && !gridOptions.isUpdatedTableDesign\">\n            <form ngForm>\n                <div class=\"searchbar-wrapper\">\n                    <i class=\"svg-icon fa-solid fa-magnifying-glass\"></i>\n                    <input matInput type=\"text\" placeholder=\"Search {{ searchPlaceholder }}\" name=\"search\"\n                        [formControl]=\"searchValue\" [disabled]=\"isSearchDisabled\"\n                        (ngModelChange)=\"searchModelChanged()\" />\n                </div>\n            </form>\n        </section>\n        <div class=\"toolbar\" *ngIf=\"!gridOptions.hideTopToolbar\">\n            <section *ngIf=\"!isOnlyView\" class=\"adding\">\n                <ul class=\"row-actions\">\n                    <ng-container *hasPermission=\"getActionName(actionTypes.ADD)\">\n                        <li *ngIf=\"!gridOptions.addButtonTemplate\">\n                            <span *ngIf=\"!isTableInEditState\">\n                                <a (click)=\"onClickAdd()\"\n                                    [ngClass]=\"{'disabled': isDisabledMainAction(actionTypes.ADD) || (gridOptions.disableIcons && gridOptions.disableIcons.add$ |async)}\">\n                                    <span title=\"{{getTooltipText(toolTips.ADD)}}\" class=\"toolbar-icon icon-plus\"\n                                        [ngClass]=\"(isDisabledMainAction(actionTypes.ADD) || (gridOptions.disableIcons && gridOptions.disableIcons.add$ |async))? 'icon-inactive': 'icon-active'\"></span>\n                                </a>\n                            </span>\n                        </li>\n                    </ng-container>\n                    <ng-container *ngIf=\"gridOptions.addButtonTemplate\">\n                        <li>\n                            <ng-container *ngTemplateOutlet=\"gridOptions.addButtonTemplate;\"></ng-container>\n                        </li>\n                    </ng-container>\n                </ul>\n                <ng-container *ngIf=\"!isLoading$.getValue()\">\n                    <app-data-table-actions\n                        *ngIf=\"!(isOnlyView && !isViewActionVisible) && !gridOptions.isRowActionVisible\"\n                        [gridApi]=\"gridApi\" [canInlineEdit]=\"canInlineEdit\" [isTreeGrid]=\"isTreeGrid\"\n                        [gridOptions]=\"gridOptions\" [selectedRow]=\"selectedRow\" [isIconsDisabled]=\"isActionsDisabled\"\n                        [isEditing]=\"selectedRow?.isEditing\" [isSaving]=\"selectedRow?.isSaving\"\n                        [isOnlyView]=\"isOnlyView\" [isEditable]=\"isEditable\" (clickAdd)=\"onClickAdd()\"\n                        [hasEmptyRow]=\"hasEmptyRow\" [isEditing]=\"isEditing\" [isSaving]=\"isSaving\"\n                        [isCloneVisible]=\"isCloneVisible\" [isDeleteVisible]=\"!checkDeleteDisabled()\">\n                    </app-data-table-actions>\n                </ng-container>\n            </section>\n            <ul class=\"row-actions\" *ngIf=\"!isOnlyView || gridOptions.isTopLeftActionsForceDisply\">\n                <ng-container *ngFor=\"let action of gridOptions.topLeftAdditionalActions\">\n                    <li>\n                        <a *hasPermission=\"getLeftActionName(action.actionName)\"\n                            [ngClass]=\"{'disabled': action.isDisabled}\" (click)=\"ActionClickHandler(action)\"\n                            class=\"fontIco\">\n                            <app-icon *ngIf=\"!action.isClass\" [title]=\"getLeftRightActionText(action)\"\n                                [name]=\"action.iconOrClassName\"></app-icon>\n                            <span *ngIf=\"action.isClass\" title=\"{{getLeftRightActionText(action)}}\"\n                                class=\"toolbar-icon {{ action.iconOrClassName }}\"\n                                [ngClass]=\"(action.actionName===actionTypes.UPLOAD && action.isDisabled)? 'icon-inactive': ''\"></span>\n                        </a>\n                    </li>\n                    <li *ngIf=\"action.loading$ | async\">\n                        <mat-spinner class=\"mr-1 action-loader\" [diameter]=\"25\"></mat-spinner>\n                    </li>\n                </ng-container>\n\n            </ul>\n            <ng-container *ngIf=\"gridOptions.leftActionBtnTemplate\">\n                <ng-container *ngTemplateOutlet=\"gridOptions.leftActionBtnTemplate\"></ng-container>\n            </ng-container>\n            <span class=\"toolbar-spacer\"></span>\n\n            <ul class=\"row-actions\">\n\n                <ng-container *ngFor=\"let action of gridOptions.topRightActions\">\n                    <li>\n                        <a (click)=\"ActionClickHandler(action)\" class=\"fontIco\">\n                            <app-icon [title]=\"getLeftRightActionText(action)\" [name]=\"action.icon\"></app-icon>\n                        </a>\n                    </li>\n                </ng-container>\n\n            </ul>\n            <ng-container *ngIf=\"gridOptions.isUpdatedTableDesign\">\n                <ng-container *ngIf=\"gridOptions.newTableButtontemplate\">\n                    <ng-container *ngTemplateOutlet=\"gridOptions.newTableButtontemplate\"></ng-container>\n                </ng-container>\n                <section class=\"search\" *ngIf=\"gridOptions.isSearchBoxVisible\">\n                    <form ngForm>\n                        <div class=\"searchbar-wrapper\">\n                            <i class=\"svg-icon fa-solid fa-magnifying-glass\"></i>\n                            <input matInput type=\"text\" placeholder=\"Search\" name=\"search\" [formControl]=\"searchValue\"\n                                [disabled]=\"isSearchDisabled\" (ngModelChange)=\"searchModelChanged()\" />\n                        </div>\n                    </form>\n                </section>\n                <ng-container *ngIf=\"gridOptions.isFilterEnabled\">\n                    <button mat-stroked-button color=\"primary\" (click)=\"showHideFilterView()\">\n                        <em class=\"fas fa-filter inactive-filter\" [ngClass]=\"{'active-filter': isFilterApplied }\"></em>\n                        Filter\n                    </button>\n                    <button [title]=\"'Clear'\" (click)=\"clearGlobalFilter()\" mat-stroked-button color=\"primary\">\n                        <em class=\"fas fa-broom\"></em>\n                    </button>\n                </ng-container>\n            </ng-container>\n\n            <ul class=\"row-actions\">\n                <li *ngIf=\"!gridOptions.hideColumnConfiguration\">\n                    <a (click)=\"openColumnShowHideDialogue()\" class=\"fontIco\">\n                        <app-icon [title]=\"getTooltipText(toolTips.COLUMN_CONFIGURATION)\" [name]=\"ICONS.ColumnSelector\">\n                        </app-icon>\n                    </a>\n                </li>\n            </ul>\n\n        </div>\n    </section>\n</div>\n\n<mat-card class=\"table-card\" [ngClass]=\"{'transparent-table-design': gridOptions.isTransparentTableDesign}\">\n    <app-loader *ngIf=\"isLoading$ | async\" class=\"loader-middle\"></app-loader>\n\n    <mat-card-content>\n        <div class=\"custom-data-table\" [ngClass]=\"{'default-table-height': isLoading$.getValue(), 'overflow-visible': gridOptions.isAccordionTable }\"\n            (scroll)=\"onTableScrolled($event)\" #customDataTable [ngStyle]=\"getCustomTableStyle\">\n            <table aria-describedby=\"Generic data table\" *ngIf=\"!gridOptions.isAccordionTable\"\n                class=\"table apollo-design-new-data-table\" [ngClass]=\"{ '-tree': isTreeGrid }\" mdbTable>\n                <thead *ngIf=\"!gridOptions.hideTableHeader\" class=\"sticky-header\">\n                    <tr *ngIf=\"gridOptions.isUpdatedTableDesign && isFilterView\" class=\"table-first-header\">\n                        <th *ngIf=\"isRowSelectionEnable\" scope=\"col\"></th>\n                        <ng-container *ngFor=\"let viewColumn of viewColumns\">\n                            <th *ngIf=\"viewColumn.isVisible\" scope=\"col\" class=\"header\"\n                                [ngClass]=\"{'transparent': !viewColumn.isMetaDataColumn && gridOptions.isUpdatedTableDesign}\">\n                                <app-data-col-filter *ngIf=\"isFilterEnable(viewColumn.prop)\" [columnName]=\"viewColumn\"\n                                    [ngClass]=\"{'filteredColumn': isFilteredColumn(viewColumn.prop)}\"\n                                    (onFilterClicked)=\"onFilterClicked($event)\" [filterOption]=\"viewColumn.filterOption\"\n                                    [numberOfTableRefresh]=\"numberOfTableRefresh\" [isUpdatedFilterDesign]=\"true\"\n                                    [isClearFilter$]=\"isClearFilter$\" [filterParam]=\"getFilterParam(viewColumn)\">\n                                </app-data-col-filter>\n                            </th>\n                        </ng-container>\n                    </tr>\n                    <tr class=\"table-second-header\">\n                        <th *ngIf=\"isRowSelectionEnable  && !isSingleSelect\" scope=\"col\" class=\"hasSelection\">\n                            <mat-checkbox class=\"table-header-checkbox\" (change)=\"$event ? masterToggle() : null\"\n                                [formControl]=\"masterSelection\" [checked]=\"selection.hasValue() && isAllSelected()\"\n                                [indeterminate]=\"selection.hasValue() && !isAllSelected()\">\n                            </mat-checkbox>\n                        </th>\n                        <th scope=\"col\" *ngIf=\"isRowSelectionEnable && isSingleSelect\" class=\"hasSelection\"></th>\n                        <ng-container *ngFor=\"let viewColumn of viewColumns; let i = index\">\n                            <th *ngIf=\"viewColumn.isVisible\" scope=\"col\" class=\"header\" [attr.data-column-prop]=\"viewColumn.prop\"\n                                [ngClass]=\"{'transparent': !viewColumn.isMetaDataColumn && gridOptions.isUpdatedTableDesign}\">\n                                <div [ngClass]=\"getHeaderStyle(i, viewColumn)\">\n                                    <app-data-col-filter\n                                        *ngIf=\"isFilterEnable(viewColumn.prop) && !gridOptions.isUpdatedTableDesign\"\n                                        [columnName]=\"viewColumn\"\n                                        [ngClass]=\"{'filteredColumn': isFilteredColumn(viewColumn.prop)}\"\n                                        (onFilterClicked)=\"onFilterClicked($event)\"\n                                        [filterOption]=\"viewColumn.filterOption\"\n                                        [numberOfTableRefresh]=\"numberOfTableRefresh\" [isClearFilter$]=\"isClearFilter$\"\n                                        [filterParam]=\"getFilterParam(viewColumn)\">\n                                    </app-data-col-filter>\n\n                                    <span class=\"header\" [ngClass]=\"{'sort-column': isSortColumn(viewColumn)}\"\n                                        (click)=\"sortTable(viewColumn)\">{{ viewColumn.header }}\n                                        <ng-container *ngIf=\"viewColumn.headerIconClass\">\n                                            <span class=\"header-icon\" [ngClass]=\"viewColumn.headerIconClass\"></span>\n                                        </ng-container>\n                                        <span class=\"sort-icon\"\n                                            *ngIf=\"sortedColumn[viewColumn.prop]=== sortDirectionEnum.DESC\">\n                                            <em class=\"material-icons\">\n                                                arrow_downward\n                                            </em>\n                                        </span>\n                                        <span class=\"sort-icon\"\n                                            *ngIf=\"sortedColumn[viewColumn.prop]=== sortDirectionEnum.ASC\">\n                                            <em class=\"material-icons\">\n                                                arrow_upward\n                                            </em>\n                                        </span>\n                                    </span>\n                                    <ng-container\n                                        *ngIf=\"gridOptions.isUpdatedTableDesign && isFilteredColumn(viewColumn.prop)\">\n                                        <em class=\"fas fa-filter active-filter\"></em>\n                                    </ng-container>\n                                    <div *ngIf=\"gridOptions.draggable\"\n                                        [ngClass]=\"{ 'header-separator': true, 'col-resize-cursor': viewColumn.draggable }\"\n                                        (mousedown)=\"onSeparatorMouseDown($event, i, viewColumn)\"\n                                        (dblclick)=\"onDoubleClickSeparator(i, viewColumn)\">\n                                    </div>\n                                </div>\n                            </th>\n                        </ng-container>\n                        <th *ngIf=\"!(isOnlyView && !isViewActionVisible) && gridOptions.isRowActionVisible\" scope=\"col\">\n                            Actions</th>\n                        <th [ngClass]=\"{'transparent': gridOptions.isUpdatedTableDesign}\"\n                            *ngIf=\"gridOptions.gridMenuOptions && gridOptions.gridMenuOptions.isMenuEnabled\"></th>\n                    </tr>\n                    <ng-container *ngIf=\"gridOptions.hasFixedFirstRow\">\n                        <tr *ngIf=\"!(isLoading$ | async)\">\n                            <th *ngIf=\"isRowSelectionEnable  && !isSingleSelect\" class=\"transparent\"></th>\n                            <th *ngIf=\"isRowSelectionEnable && isSingleSelect\" class=\"transparent\"></th>\n                            <ng-container *ngFor=\"let viewColumn of viewColumns\">\n                                <th class=\"transparent\">\n                                    <ng-container\n                                        *ngTemplateOutlet=\"viewColumn.fixedFirstRowTemplate; context: { $implicit: { col: viewColumn } }\"></ng-container>\n                                </th>\n                            </ng-container>\n                        </tr>\n                    </ng-container>\n                </thead>\n                <tbody *ngIf=\"!isLoading$.getValue()\" app-data-table-body [gridOptions]=\"gridOptions\"\n                    [selection]=\"selection\"\n                    [rows]=\"rows | columnFilter : filterManager.getFilterParams() : columns: gridOptions.isClientSidePagination\"\n                    [viewColumns]=\"viewColumns\" [canInlineEdit]=\"canInlineEdit\" [isTreeGrid]=\"isTreeGrid\"\n                    [isOnlyView]=\"isOnlyView\" [searchedRowCount$]=\"searchedRowCount$\" [onAddClick]=\"onAddClick\"\n                    [isOnlyViewRow]=\"isOnlyViewRow\" [isDeleteDisabled]=\"isDeleteDisabled\" [search]=\"searchValue.value\"\n                    [paginationParams]=\"paginationParams\" [hasEmptyRow]=\"hasEmptyRow\" [isEditing]=\"isEditing\"\n                    [isRowSelectionEnable]=\"isRowSelectionEnable\" [searchColumns]=\"searchColumns\"\n                    [isCloneVisible]=\"isCloneVisible\" (clickEdit)=\"onClickEdit($event)\"\n                    (clickClone)=\"onClickClone($event)\" (clickAction)=\"onClickAction($event)\"\n                    (clickEditCancel)=\"onClickEditCancel($event)\" (clickEditSave)=\"onClickEditSave($event)\"\n                    (clickDelete)=\"onClickDeleteRow($event)\" (clickView)=\"onClickView($event)\"\n                    (clickAdd)=\"onClickRowAdd($event)\" (clickRow)=\"onClickRow($event)\"\n                    (changeExpandCollapse)=\"onChangeExpandCollapse($event)\"\n                    (complexDetailClicked)=\"ComplexDetailClicked($event)\" [isRowUnchecked]=\"isRowUnchecked\"\n                    (CheckboxSelect)=\"isCheckboxSelect($event)\">\n                </tbody>\n\n            </table>\n\n            <ng-container *ngIf=\"gridOptions.isAccordionTable\">\n                <mat-accordion displayMode=\"flat\" multi class=\"mat-table\" *ngIf=\"gridOptions.isAccordionTable\">\n                    <mat-expansion-panel *ngIf=\"!gridOptions.hideTableHeader\" class=\"mask-body header-panel\" hideToggle>\n                        <mat-expansion-panel-header (keydown.Enter)=\"$event.stopImmediatePropagation();\"\n                            [collapsedHeight]=\"'auto'\" [expandedHeight]=\"'auto'\" class=\"mat-row header-row\">\n                            <div class=\"mat-checkboxRow\" *ngIf=\"isRowSelectionEnable  && !isSingleSelect\"\n                                (click)=\"$event.stopPropagation()\">\n                                <mat-checkbox (change)=\"$event ? masterToggle() : null\" [(ngModel)]=\"masterSelection\"\n                                    [checked]=\"selection.hasValue() && isAllSelected()\"\n                                    [indeterminate]=\"selection.hasValue() && !isAllSelected()\">\n                                </mat-checkbox>\n                            </div>\n                            <ng-container *ngFor=\"let viewColumn of viewColumns\">\n                                <div *ngIf=\"viewColumn.isVisible\" scope=\"col\" (click)=\"$event.stopPropagation()\"\n                                    class=\"mat-cell d-inline-block\" [ngClass]=\"viewColumn.customCssClass\">\n                                    <app-data-col-filter class=\"filter-column\" *ngIf=\"isFilterEnable(viewColumn.prop)\"\n                                        [columnName]=\"viewColumn\"\n                                        [ngClass]=\"{'filteredColumn': isFilteredColumn(viewColumn.prop)}\"\n                                        (onFilterClicked)=\"onFilterClicked($event)\"\n                                        [filterOption]=\"viewColumn.filterOption\"\n                                        [numberOfTableRefresh]=\"numberOfTableRefresh\"\n                                        [filterParam]=\"getFilterParam(viewColumn)\">\n                                    </app-data-col-filter>\n                                    &nbsp;\n                                    <span [ngClass]=\"nonFilterClassName(viewColumn.prop)\" class=\"table .header\"\n                                        (click)=\"sortTable(viewColumn)\">{{ viewColumn.header }}\n                                        <span class=\"sort-icon\" *ngIf=\"sortedColumn[viewColumn.prop]=='DownSorted'\">\n                                            <em class=\"material-icons\">\n                                                arrow_downward\n                                            </em>\n                                        </span>\n                                        <span class=\"sort-icon\" *ngIf=\"sortedColumn[viewColumn.prop]=='UpSorted'\">\n                                            <em class=\"material-icons\">\n                                                arrow_upward\n                                            </em>\n                                        </span>\n                                    </span>\n                                </div>\n                            </ng-container>\n                        </mat-expansion-panel-header>\n                    </mat-expansion-panel>\n                    <ng-container>\n                        <div *ngIf=\"!isLoading$.getValue()\" app-data-table-body [gridOptions]=\"gridOptions\"\n                            [selection]=\"selection\"\n                            [rows]=\"rows | columnFilter : filterManager.getFilterParams() : columns: gridOptions.isClientSidePagination\"\n                            [viewColumns]=\"viewColumns\" [canInlineEdit]=\"canInlineEdit\" [isTreeGrid]=\"isTreeGrid\"\n                            [isOnlyView]=\"isOnlyView\" [searchedRowCount$]=\"searchedRowCount$\"\n                            [isOnlyViewRow]=\"isOnlyViewRow\" [isDeleteDisabled]=\"isDeleteDisabled\"\n                            [search]=\"searchValue.value\" [paginationParams]=\"paginationParams\"\n                            [hasEmptyRow]=\"hasEmptyRow\" [isEditing]=\"isEditing\"\n                            [isRowSelectionEnable]=\"isRowSelectionEnable\" [searchColumns]=\"searchColumns\"\n                            [isCloneVisible]=\"isCloneVisible\" (clickEdit)=\"onClickEdit($event)\"\n                            (matExpansionPanelClicked)=\"onExpansionPanelClick($event)\"\n                            (clickClone)=\"onClickClone($event)\" (clickAction)=\"onClickAction($event)\"\n                            (clickEditCancel)=\"onClickEditCancel($event)\" (clickEditSave)=\"onClickEditSave($event)\"\n                            (clickDelete)=\"onClickDeleteRow($event)\" (clickView)=\"onClickView($event)\"\n                            (clickAdd)=\"onClickRowAdd($event)\" (clickRow)=\"onClickRow($event)\"\n                            (changeExpandCollapse)=\"onChangeExpandCollapse($event)\"\n                            (complexDetailClicked)=\"ComplexDetailClicked($event)\"\n                            (CheckboxSelect)=\"isCheckboxSelect($event)\"></div>\n\n                    </ng-container>\n                </mat-accordion>\n            </ng-container>\n        </div>\n        <section *ngIf=\"hasPagination && selection\" class=\"pagination\">\n            <app-data-pagination [selectionCount]=\"selection.selected.length\" class=\"table-pagination-container\" [ngClass]=\"{'transparent-table-design': gridOptions.isTransparentTableDesign}\"  [totalRowCount$]=\"this.searchedRowCount$\"\n                [count]=\"count\" [page]=\"paginationParams.currentPage\" [size]=\"paginationParams.pageSize\" [hasDropdownStylePageSize]=\"gridOptions.hasDropdownStylePageSize ?? true\"\n                (changePage)=\"onChangePage($event)\">\n            </app-data-pagination>\n        </section>\n    </mat-card-content>\n</mat-card>", styles: [".show-hide{float:right}::-webkit-input-placeholder{color:#000;font-size:11px}::-moz-placeholder{color:#000;font-size:11px}:-ms-input-placeholder{color:#000;font-size:11px}::placeholder{color:#000;font-size:11px}.custom-data-table{margin:0!important;overflow-x:auto;position:relative}.table-card{padding:0}.custom-data-table .table thead th:first-child{border-top-left-radius:4px}.custom-data-table .table thead th:last-child{border-top-right-radius:4px}.custom-data-table .table thead th{padding:.5rem .8rem;text-align:left;white-space:nowrap;font-weight:400;color:#393939;font-size:.9rem;vertical-align:middle;position:relative}.hasSelection{width:20px}.search{margin:1px 0 22px}.sort-icon .material-icons{color:#2371fc;font-size:18px;position:relative;top:4px;left:10px;padding-right:14px}.table-card-hidden{visibility:hidden}.disabled{pointer-events:none!important;color:gray!important}.table-card{margin-bottom:14px;border-radius:4px;border:1px solid rgb(233,233,233);box-shadow:0 4px 16px #0000000a;opacity:1;background-color:#fff}::ng-deep .mat-checkbox-checked.mat-accent .mat-checkbox-background,.mat-checkbox-indeterminate.mat-accent .mat-checkbox-background{background-color:#0768fd}::ng-deep .filteredColumn>a:hover{color:#0768fd!important}::ng-deep .mat-checkbox-indeterminate.mat-accent .mat-checkbox-background,.mat-checkbox-checked.mat-accent .mat-checkbox-background{background-color:#0768fd}:host ::ng-deep app-data-col-filter.filteredColumn>a{color:#0768fd}:host ::ng-deep app-data-col-filter a{color:#999}.table-pagination-container{width:100%;padding:12px 16px;border-bottom-left-radius:4px;border-bottom-right-radius:4px;border-top:1px solid rgb(233,233,233);opacity:1;background-color:#f6f7fb}.text-link-with-ico{color:#0768fd!important}.text-link-with-ico img{position:relative;top:-2px;padding-right:12px}a.text-link-with-ico{margin-right:0}.search-icon{margin-right:5px;position:absolute;top:10px;left:10px;font-size:16px;color:#bbb;z-index:1000}.fontIco{font-size:20px}.mat-checkboxRow{margin-right:6px}.filter-column{color:#ccc;margin-left:2px}.empty-row{width:auto;margin:0;font-size:15px;line-height:5rem;text-align:center}.non-filter-cell{margin-left:-8px}.row-selection-non-filter-cell{margin-left:-2px}.table-header-checkbox{margin-left:0}.toolbar .adding{display:flex;align-items:center}.sticky-header{position:sticky;top:0;z-index:100}.inactive-filter{color:#ccc!important}.active-filter,.header-icon{color:#0768fd!important}.clear-button{padding:4px 15px!important;font-weight:700}.transparent{background-color:#fff;opacity:1}.loader-middle{position:absolute;z-index:99;left:45%;margin-left:-28px;top:40%;margin-top:-28px}.default-table-height{height:300px}.no-records-found{width:auto;font-size:15px;position:absolute;top:40%;left:45%}.sort-column{cursor:pointer}.icon-inactive{filter:grayscale(1)}.header-separator{position:absolute;top:7px;right:0;height:60%;width:3px;background-color:#1c1a1a33;transition:background-color .3s ease;z-index:1}.header-separator:before{content:\"\";position:absolute;inset:0 0 0 -10px}.col-resize-cursor{cursor:col-resize}.header-separator:hover{background-color:#00000080}.drag-column{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;min-width:50px}.header-max-width{max-width:170px;overflow:hidden;text-overflow:ellipsis}.overflow-visible{overflow:visible}:host ::ng-deep .mat-expansion-panel.header-panel{overflow:visible}\n"] }]
+        }], ctorParameters: () => [{ type: i1.DataTableService }, { type: i2.Router }, { type: i2.ActivatedRoute }, { type: i3.MatDialog }, { type: i0.ChangeDetectorRef }, { type: i4.SnackbarService }, { type: i5.UserManagementService }, { type: i6.ColumnFilterPipe }, { type: i7.SearchPipe }, { type: i8.LocalStorageService }, { type: i3.MatDialog }, { type: i9.FormService }, { type: i10.DataTableContextService }], propDecorators: { setDataTableBody: [{
+                type: ViewChild,
+                args: [DataTableBodyComponent, { static: false }]
+            }], defaultRowValues: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], getListFn: [{
+                type: Input
+            }], postItemFn: [{
+                type: Input
+            }], putItemFn: [{
+                type: Input
+            }], deleteItemFn: [{
+                type: Input
+            }], header: [{
+                type: Input
+            }], description: [{
+                type: Input
+            }], actionAddTitle: [{
+                type: Input
+            }], isIdColVisible: [{
+                type: Input
+            }], hasPagination: [{
+                type: Input
+            }], isOnlyView: [{
+                type: Input
+            }], isOnlyViewRow: [{
+                type: Input
+            }], isDeleteDisabled: [{
+                type: Input
+            }], isEditable: [{
+                type: Input
+            }], isCloneVisible: [{
+                type: Input
+            }], isLazyInitialization: [{
+                type: Input
+            }], objectName: [{
+                type: Input
+            }], gridOptions: [{
+                type: Input
+            }], isRowSelectionEnable: [{
+                type: Input
+            }], beforeSaveFn: [{
+                type: Input
+            }], onBeforeEdit: [{
+                type: Input
+            }], onAddClick: [{
+                type: Input
+            }], isRowUnchecked: [{
+                type: Input
+            }], isSaveDataLocal: [{
+                type: Input
+            }], scrollPosition: [{
+                type: Input
+            }], isTreeGrid: [{
+                type: Input
+            }], initialPage: [{
+                type: Input
+            }], changeLocalData: [{
+                type: Output
+            }], actionClick: [{
+                type: Output
+            }], onInitCompleted: [{
+                type: Output
+            }], onComplexDetailClicked: [{
+                type: Output
+            }], onEditClicked: [{
+                type: Output
+            }], onAddClicked: [{
+                type: Output
+            }], onRowClicked: [{
+                type: Output
+            }], onPageChanged: [{
+                type: Output
+            }], matExpansionPanelClicked: [{
+                type: Output
+            }], onUpdateCompleted: [{
+                type: Output
+            }], onDeleteCompleted: [{
+                type: Output
+            }], onScrolled: [{
+                type: Output
+            }], CheckboxSelect: [{
+                type: Output
+            }], isTableDataLoad: [{
+                type: Output
+            }], deleteModal: [{
+                type: ViewChild,
+                args: ['deleteModal', { read: TemplateRef, static: true }]
+            }], customDataTable: [{
+                type: ViewChild,
+                args: ['customDataTable']
+            }], sliderTemplate: [{
+                type: ViewChild,
+                args: ['sliderTemplate']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-table.component.js","sourceRoot":"","sources":["../../../../../../../lib/src/modules/ui-kit/components/data-table/data-table/data-table.component.ts","../../../../../../../lib/src/modules/ui-kit/components/data-table/data-table/data-table.component.html"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @angular-eslint/no-output-on-prefix */\n/* eslint-disable sort-class-members/sort-class-members */\nimport { SelectionModel } from '@angular/cdk/collections';\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output,\n  TemplateRef,\n  ViewChild,\n  ViewContainerRef,\n} from '@angular/core';\nimport { FormControl } from '@angular/forms';\nimport { MatDialog, MatDialogConfig, MatDialogRef } from '@angular/material/dialog';\nimport { ActivatedRoute, Router } from '@angular/router';\nimport { LocalStorageService } from 'idp-apps-shared-ui/core/services/local-storage.service';\nimport { UserManagementService } from 'idp-apps-shared-ui/core/services/user-management.service';\nimport { ActionTypesEnum } from 'idp-apps-shared-ui/enums/action-types.enum';\nimport { SortDirectionEnum } from 'idp-apps-shared-ui/enums/sort-direction.enum';\nimport { SourceTypesEnum } from 'idp-apps-shared-ui/enums/source-types.enum';\nimport { ToolTipsProp, tooltipsDefaultValue } from 'idp-apps-shared-ui/enums/tooltips-prop.enum';\nimport { CommonConfirmModalComponent } from 'idp-apps-shared-ui/modules/ui-kit/components/modals/common-confirm-modal/common-confirm-modal.component';\nimport { IRowSelectionInfo } from 'idp-apps-shared-ui/modules/ui-kit/interfaces/row-selection-info.interface';\nimport { ColumnFilterPipe } from 'idp-apps-shared-ui/modules/ui-kit/pipes/column-filter.pipe';\nimport { SearchPipe } from 'idp-apps-shared-ui/modules/ui-kit/pipes/search.pipe';\nimport { clone, isFunction, isUndefined, merge } from 'lodash';\nimport cloneDeep from 'lodash/cloneDeep';\nimport { BehaviorSubject, Subject } from 'rxjs';\nimport { debounceTime, distinctUntilChanged, filter, first, takeUntil } from 'rxjs/operators';\nimport { ChangeType } from '../../../../../modules/ui-kit/components/data-table/constants/change-type.enum';\nimport { DataTableConstants } from '../../../constants/data-table.constants';\nimport { ColumnDisableModes } from '../../../enums/column-disable-mode.enum';\nimport { ColumnTypes } from '../../../enums/column-types.enum';\nimport { FormTypes } from '../../../enums/form-types.enum';\nimport { Icons } from '../../../enums/icons.enum';\nimport { SnackbarTypes } from '../../../enums/snackbar.enum';\nimport { IFilterParam, IListReqParamsApi, IListResApi } from '../../../interfaces/api.interface';\nimport {\n  GridOptions,\n  ICheckedRowEvent,\n  IClickedEventData,\n  IDataTableAction,\n  IDataTableChangeLocalDataEvent,\n  IDataTableColumn,\n  IDataTableExpandCollapseEvent,\n  IDataTableRow,\n  IDataTableRowEvent,\n  IDataTableRowSaveEvent,\n  IRowData,\n  ITopRightAction,\n} from '../../../interfaces/data-table.interface';\nimport { IKeyValue, IPaginationParams } from '../../../interfaces/generic.interface';\nimport { ListItem } from '../../../interfaces/list-item.interface';\nimport { DataTableService } from '../../../services/data-table.service';\nimport { FormService } from '../../../services/form.service';\nimport { SnackbarService } from '../../../services/snackbar.service';\nimport { DeleteItemFn, GetListFn, PostItemFn, PutItemFn } from '../../../types/function.type';\nimport { DeleteModalComponent } from '../../modals/delete-modal/delete-modal.component';\nimport { FilterManager } from '../api-classes/filter-manager';\nimport { GridApi } from '../api-classes/grid-api';\nimport { COLUMN_ID } from '../constants/column-id';\nimport { ROW } from '../constants/row';\nimport { DataColDispComponent } from '../data-col-disp/data-col-disp.component';\nimport { DataTableBodyComponent } from '../data-table-body/data-table-body.component';\nimport { IDataTableComponent } from '../interfaces/data-table-component.interface';\nimport { DATA_TABLE_CONTEXT, DataTableContextService } from '../services/data-table-context.service';\n\nexport interface ScrollPosition {\n  x: number;\n  y: number;\n}\n\nexport interface ScrollEvent extends Event {\n  isTrusted: boolean;\n  currentScrollPosition: ScrollPosition;\n  currentElement: ElementRef<HTMLElement>;\n}\n\n@Component({\n  selector: 'app-data-table',\n  templateUrl: './data-table.component.html',\n  styleUrls: ['./data-table.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [\n    {\n      provide: DATA_TABLE_CONTEXT,\n      useExisting: DataTableComponent,\n    },\n  ],\n})\nexport class DataTableComponent implements OnInit, AfterViewInit, OnDestroy, IDataTableComponent {\n  // Inline edit settings\n  public get canInlineEdit(): boolean {\n    return this.gridOptions.canInlineEdit;\n  }\n\n  @ViewChild(DataTableBodyComponent, { static: false })\n  public set setDataTableBody(tableBody: DataTableBodyComponent) {\n    this.dataTableBody = tableBody;\n  }\n\n  public get columnShowhideStoragekey(): string | undefined {\n    return this.gridOptions.columnShowhideStoragekey;\n  }\n\n  public get allowSaveColumnVisibilitySettings(): boolean {\n    return this.gridOptions.allowSaveColumnVisibilitySettings;\n  }\n\n  public get addActionTitle(): string {\n    return `${this.gridOptions.actionAddTitle}`;\n  }\n\n  public get isViewActionVisible(): boolean {\n    return this.gridOptions.isRowLevelViewActionVisible;\n  }\n\n  public get searchPlaceholder(): string {\n    return this.gridOptions.searchboxPlaceholder ? this.gridOptions.searchboxPlaceholder : this.header;\n  }\n\n  public get isTableInEditState(): boolean {\n    return this.isEditing || this.hasEmptyRow;\n  }\n\n  private get apiReqParams(): IListReqParamsApi {\n    return {\n      page: this.currentPage,\n      itemsOnPage: this.pageSize,\n      filterParams: this.populateFilterParams(),\n      searchText: this.searchValue.value,\n      ...this.getSortParams,\n    };\n  }\n\n  get getSortParams(): { sortBy: string; sortDirection: SortDirectionEnum } {\n    const parmas = [];\n    Object.keys(this.sortedColumn).forEach((x) => {\n      parmas.push({ sortBy: x, sortDirection: this.sortedColumn[x] });\n    });\n    return parmas.length ? parmas[0] : {};\n  }\n\n  public readonly ICONS: typeof Icons = Icons;\n  public readonly sortDirectionEnum: typeof SortDirectionEnum = SortDirectionEnum;\n  public readonly toolTips: typeof ToolTipsProp = ToolTipsProp;\n  public readonly actionTypes: typeof ActionTypesEnum = ActionTypesEnum;\n  public readonly DEFAULT_PAGE_SIZE: number = DataTableConstants.DEFAULT_PAGE_SIZE;\n  public readonly DEFAULT_INIT_PAGE: number = DataTableConstants.DEFAULT_INIT_PAGE;\n\n  public readonly confirmationMsgPagination: string = `Selected checkbox will be lost `;\n  @Input() public defaultRowValues: IKeyValue = {};\n  @Input() public columns: IDataTableColumn[];\n  @Input() public getListFn: GetListFn;\n  @Input() public postItemFn: PostItemFn;\n  @Input() public putItemFn: PutItemFn;\n  @Input() public deleteItemFn: DeleteItemFn;\n  @Input() public header: string = '';\n  @Input() public description: string;\n  @Input() public actionAddTitle: string;\n  @Input() public isIdColVisible: boolean = false;\n  @Input() public hasPagination: boolean = true;\n  @Input() public isOnlyView: boolean = false;\n  @Input() public isOnlyViewRow?: (row: IDataTableRow) => boolean;\n  @Input() public isDeleteDisabled?: (row: IDataTableRow) => boolean;\n  @Input() public isEditable: boolean = true;\n  @Input() public isCloneVisible: boolean = true;\n  @Input() public isLazyInitialization: boolean = false;\n  @Input() public objectName: string;\n  @Input() public gridOptions: GridOptions;\n  @Input() public isRowSelectionEnable: boolean = false;\n  @Input() public beforeSaveFn?: (rowsData: IRowData[], saveEventData: IDataTableRowSaveEvent) => boolean;\n  @Input() public onBeforeEdit?: (rowsData: IRowData[], saveEventData: IDataTableRowEvent) => boolean;\n  @Input() public onAddClick?: (rowsData: IRowData[], saveEventData: IDataTableRowEvent) => boolean;\n  @Input() public isRowUnchecked?: (row: IDataTableRow) => boolean;\n  @Input() public isSaveDataLocal: boolean = false;\n  @Input() public scrollPosition: ScrollPosition;\n\n  // Tree grid settings\n  @Input() public isTreeGrid: boolean = false;\n\n  @Input() public initialPage: number;\n\n  @Output() public changeLocalData: EventEmitter<IDataTableChangeLocalDataEvent> = new EventEmitter();\n  @Output() public actionClick: EventEmitter<IDataTableAction> = new EventEmitter();\n  @Output() public onInitCompleted: EventEmitter<any> = new EventEmitter();\n  @Output() public onComplexDetailClicked: EventEmitter<IClickedEventData> = new EventEmitter<IClickedEventData>();\n  @Output() public onEditClicked: EventEmitter<IDataTableRowEvent> = new EventEmitter<IDataTableRowEvent>();\n  @Output() public onAddClicked: EventEmitter<any> = new EventEmitter();\n  @Output() public onRowClicked: EventEmitter<any> = new EventEmitter();\n  @Output() public onPageChanged: EventEmitter<any> = new EventEmitter();\n  @Output() public matExpansionPanelClicked: EventEmitter<IDataTableRowEvent> = new EventEmitter();\n  @Output() public onUpdateCompleted: EventEmitter<IDataTableRowEvent> = new EventEmitter();\n  @Output() public onDeleteCompleted: EventEmitter<IDataTableRowEvent> = new EventEmitter();\n  @Output() public onScrolled: EventEmitter<ScrollEvent> = new EventEmitter<ScrollEvent>();\n  @Output() public CheckboxSelect: EventEmitter<IRowSelectionInfo> = new EventEmitter();\n  @Output() public isTableDataLoad = new EventEmitter<boolean>();\n  public searchValue: FormControl = new FormControl();\n  public searchColumns: IDataTableColumn[];\n  public isSearchDisabled: boolean = false;\n  public selectedRow: IDataTableRow;\n  public filteredRows: IDataTableRow[];\n  @ViewChild('deleteModal', { read: TemplateRef, static: true })\n  public deleteModal: TemplateRef<DeleteModalComponent>;\n  @ViewChild('customDataTable')\n  public customDataTable: ElementRef<HTMLElement>;\n  @ViewChild('sliderTemplate')\n  public sliderTemplate: ViewContainerRef;\n  public readonly sourceTypes: typeof SourceTypesEnum = SourceTypesEnum;\n  public dataTableBody: DataTableBodyComponent;\n  public gridApi: GridApi;\n  public masterSelection: FormControl = new FormControl(false);\n  public paginationParams: IPaginationParams = {\n    currentPage: this.DEFAULT_INIT_PAGE,\n    pageSize: this.DEFAULT_PAGE_SIZE,\n  };\n  public searchedRowCount$ = new Subject<number>();\n  public isClearFilter$: BehaviorSubject<boolean> = new BehaviorSubject(false);\n  public isFilterView = false;\n  public viewColumns: IDataTableColumn[];\n  public rows: IDataTableRow[];\n  public excludedRows: IDataTableRow[] = [];\n  public sortedColumn = {};\n  public count: number = 0;\n\n  public filterManager: FilterManager;\n\n  public isLoading$: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);\n  public hasEmptyRow: boolean = false;\n  public isEditing = false;\n  public isSaving = false;\n\n  public rowToDelete: IDataTableRow;\n  public selection: SelectionModel<IDataTableRow>;\n\n  public map = new Map();\n\n  public numberOfTableRefresh = 0;\n  private defaultSortedColumns: IDataTableColumn[];\n  private originalUnsortedRows: IDataTableRow[];\n  private clearSubs$ = new Subject();\n  private storageKey: string;\n  private totalItems: number = 0;\n\n  private startX: number = 0;\n  private startWidth: number = 0;\n  private resizingTh: HTMLElement | null = null;\n  private apolloDataTable: HTMLElement | null = null;\n  private resizingTd: NodeList | null = null;\n  private clickTimeout: any;\n\n  private defaultGridOptions: GridOptions = {\n    addIdColumn: true,\n    actionAddTitle: '',\n    allowSaveColumnVisibilitySettings: false,\n    isRowLevelViewActionVisible: true,\n    isOnlyView: false,\n    isRowSelectionEnable: false,\n    idProperty: COLUMN_ID.PROP,\n    isClientSidePagination: true,\n    canInlineAdd: true,\n    canInlineEdit: true,\n    isSaveDataLocal: false,\n    isSearchBoxVisible: true,\n    isFilterEnabled: false,\n    filterableColumns: [],\n    defaultSortProperty: {},\n    cloneOptions: {\n      copyOfClonableProperties: [],\n      emptyValueProperties: [],\n    },\n    searchableProperties: [],\n    sortableProperties: [],\n    isRowActionVisible: true,\n    topRightActions: [],\n    deleteOptions: {},\n    searchboxPlaceholder: this.header,\n    refreshOnAdd: true,\n    topLeftAdditionalActions: [],\n    isSortEnabled: false,\n    disableIcons: {\n      add: false,\n      edit: false,\n      delete: false,\n      clone: false,\n      add$: new BehaviorSubject<boolean>(false),\n      edit$: new BehaviorSubject<boolean>(false),\n      delete$: new BehaviorSubject<boolean>(false),\n      copy$: new BehaviorSubject<boolean>(false),\n    },\n    gridMenuOptions: {\n      isMenuEnabled: false,\n      menuItems: [],\n    },\n    actionLoading$: {\n      copy$: new BehaviorSubject<boolean>(false),\n      edit$: new BehaviorSubject<boolean>(false),\n      delete$: new BehaviorSubject<boolean>(false),\n    },\n  };\n\n  constructor(\n    public dataTableService: DataTableService,\n    private router: Router,\n    private activatedRoute: ActivatedRoute,\n    private matDialog: MatDialog,\n    public changeDetectorRef: ChangeDetectorRef,\n    private snackbarService: SnackbarService,\n    private userManagementService: UserManagementService,\n    private filterPipe: ColumnFilterPipe,\n    private searchPipe: SearchPipe,\n    private localStorageService: LocalStorageService,\n    public dialog: MatDialog,\n    public formService: FormService,\n    private dataTableContext: DataTableContextService\n  ) {\n    this.filterManager = new FilterManager();\n    this.gridApi = new GridApi(this, this.formService);\n    this.dataTableContext.setDataTableComponent(this);\n  }\n\n  public get getSelectedRows(): IDataTableRow[] {\n    return this.getFilteredDataRow(this.selection.selected);\n  }\n\n  public get getAllCheckedRows(): IDataTableRow[] {\n    return this.selection.selected;\n  }\n\n  public get isActionsDisabled(): boolean {\n    return this.filteredRows.length === 0;\n  }\n\n  public get getRows(): IDataTableRow[] {\n    return this.getFilteredDataRow(this.rows);\n  }\n\n  public get getCustomTableStyle(): IKeyValue {\n    if (this.gridOptions.isInnerScroll) {\n      return this.gridOptions.customTableStyle ? this.gridOptions.customTableStyle : { height: '30vh' };\n    }\n    return {};\n  }\n\n  public onTableScrolled(e: Event): void {\n    const htmlElement = this.customDataTable.nativeElement as HTMLElement;\n    const event: ScrollEvent = {\n      ...e,\n      currentElement: this.customDataTable,\n      currentScrollPosition: { x: htmlElement.scrollLeft, y: htmlElement.scrollTop },\n    };\n    this.onScrolled.emit(event);\n  }\n\n  public changeScrollPosition(position: ScrollPosition): void {\n    const htmlElement = this.customDataTable.nativeElement as HTMLElement;\n    htmlElement.scroll(position.x, position.y);\n  }\n\n  public ngOnInit(): void {\n    if (!this.isLazyInitialization) {\n      this.init();\n    } else {\n      this.isLoading$.next(true);\n    }\n    if (!this.gridOptions.isClientSidePagination) {\n      this.searchTable();\n    }\n  }\n\n  public isDisabledMainAction(actionProp: string): boolean {\n    return this.gridOptions.disableIcons && this.gridOptions.disableIcons[actionProp];\n  }\n\n  public nonFilterClassName(columnProp: string): string {\n    if (!this.isFilterEnable(columnProp) && this.isRowSelectionEnable) {\n      return 'row-selection-non-filter-cell';\n    }\n    if (!this.isFilterEnable(columnProp)) {\n      return 'non-filter-cell';\n    }\n    return '';\n  }\n\n  public isFilterEnable(columnProp: string): boolean {\n    if (this.isTableInEditState) {\n      return false;\n    }\n    return this.gridOptions.isFilterEnabled && (!this.gridOptions.filterableColumns.length || this.isFilterableColumn(columnProp));\n  }\n\n  public isFilterableColumn(columnProp: string): boolean {\n    return this.gridOptions.filterableColumns.findIndex((item) => item === columnProp) !== -1;\n  }\n\n  public get isFilterApplied(): boolean {\n    return this.filterManager.getFilterParams().length > 0;\n  }\n\n  public get nonDisabledRows(): IDataTableRow[] {\n    if (this.gridOptions.rowDisableFn && isFunction(this.gridOptions.rowDisableFn)) {\n      return this.rows.filter((row) => !this.gridOptions.rowDisableFn(row));\n    }\n\n    return this.rows;\n  }\n\n  public ngAfterViewInit(): void {\n    this.fireInitCompleted();\n    if (this.scrollPosition) {\n      const htmlElement = this.customDataTable.nativeElement as HTMLElement;\n      htmlElement.scrollTop = this.scrollPosition.y;\n      htmlElement.scrollLeft = this.scrollPosition.x;\n    }\n  }\n\n  public checkDeleteDisabled(): boolean {\n    if (isFunction(this.isDeleteDisabled) && !isUndefined(this.selectedRow)) {\n      return this.isDeleteDisabled(this.selectedRow);\n    }\n    if (this.isDeleteDisabled && typeof this.isDeleteDisabled !== 'function') {\n      return true;\n    }\n    return false;\n  }\n\n  public isAllSelected(): boolean {\n    if (this.gridOptions.isClientSidePagination) {\n      return this.nonDisabledRows.length === this.selection.selected.length;\n    }\n    return (this.masterSelection.value && this.excludedRows.length === 0) || this.totalItems === this.selection.selected.length;\n  }\n\n  public isSortColumn(viewColumn: IDataTableColumn): boolean {\n    return !!(this.gridOptions.sortableProperties && this.gridOptions.sortableProperties.find((x) => x === viewColumn.prop));\n  }\n\n  public openColumnShowHideDialogue(): void {\n    let dialogConfig = new MatDialogConfig();\n    dialogConfig = this.configureDialog(dialogConfig);\n    const dialogRef = this.dialog.open(DataColDispComponent, dialogConfig);\n    dialogRef.afterClosed().subscribe((result) => {\n      if (result && result.status === 'OK') {\n        this.viewColumns = result.columns;\n        this.changeDetectorRef.detectChanges();\n      }\n    });\n  }\n\n  public masterToggle(): void {\n    this.excludedRows = [];\n    if (!this.masterSelection.pristine && !this.masterSelection.value) {\n      this.selection.clear();\n      this.changeDetectorRef.detectChanges();\n      this.gridApi.detectRowChanges();\n      this.masterSelection.reset();\n      this.CheckboxSelect.emit({ rows: [], gridApi: this.getGridApi(), checked: false });\n      return;\n    }\n    if (!this.gridOptions.isClientSidePagination) {\n      this.checkedAllExceptExcludedRows();\n      this.changeDetectorRef.detectChanges();\n      this.gridApi.detectRowChanges();\n      this.CheckboxSelect.emit({ rows: [], gridApi: this.getGridApi(), checked: true });\n    } else {\n      this.masterToggleClientSide();\n      this.CheckboxSelect.emit({ rows: this.rows, gridApi: this.getGridApi(), checked: true });\n    }\n  }\n\n  public isCheckboxSelect(row: IDataTableRow): void {\n    const isSelected = this.selection.isSelected(row);\n    if (this.masterSelection.value && !isSelected) {\n      this.excludedRows.push(row);\n    } else if (this.masterSelection.value && isSelected) {\n      const findIndex = this.excludedRows.findIndex((x) => JSON.stringify(x) === JSON.stringify(row));\n      if (findIndex > -1) {\n        this.excludedRows.splice(findIndex, 1);\n      }\n    }\n    this.CheckboxSelect.emit({ rows: [row], gridApi: this.getGridApi(), checked: isSelected });\n\n    if (isSelected) {\n      this.rows.forEach((row) => (row.isSelected = false));\n    }\n    const checkedRows = this.gridApi.getAllCheckedRows();\n    if (!this.selectedRow && checkedRows.length > 0) {\n      this.selectedRow = checkedRows[checkedRows.length - 1];\n    }\n  }\n\n  public refresh(): void {\n    this.setData();\n  }\n\n  public onClickAction(action: IDataTableAction): void {\n    this.actionClick.emit(action);\n  }\n\n  public onClickAdd(): void {\n    this.onAddClicked.emit();\n    if (isFunction(this.onAddClick) && !this.onAddClick(undefined, undefined)) {\n      return;\n    }\n    this.addActionHandler();\n  }\n\n  public addActionHandler(): void {\n    this.setIdColumn();\n    this.setPaginationData({ currentPage: this.DEFAULT_INIT_PAGE, pageSize: this.pageSize });\n    this.isSearchDisabled = true;\n    this.searchValue.setValue(DataTableConstants.EMPTY);\n    if (this.gridOptions.canInlineAdd) {\n      if (!this.hasEmptyRow) {\n        this.addEmptyRow();\n      }\n    } else {\n      this.navigatePage(FormTypes.Add);\n    }\n  }\n\n  public onClickRow(eventData: IDataTableRowEvent): void {\n    const checkedRows = this.gridApi.getAllCheckedRows();\n    if (checkedRows?.length > 0) {\n      return;\n    }\n    if (this.isDefaultFirstRowSelected()) {\n      this.rows.forEach((x) => (x.isSelected = false));\n    }\n    if (this.selectedRow) {\n      this.selectedRow.isSelected = false;\n    }\n    this.selectedRow = eventData.row;\n    eventData.row.isSelected = true;\n    const emitIndex = this.gridOptions.isClientSidePagination\n      ? eventData.row.rowIndex + this.pageSize * (this.currentPage - 1)\n      : eventData.row.rowIndex;\n\n    this.selectedRow.rowIndex = emitIndex;\n    this.onRowClicked.emit(eventData.row);\n  }\n\n  public onClickRowAdd(eventData: IDataTableRowEvent): void {\n    if (this.gridOptions.canInlineAdd && !this.hasEmptyRow) {\n      this.addEmptyRow(eventData.row.depth + 1, this.dataTableService.getRowId(eventData.row));\n    }\n  }\n\n  public onClickEdit(eventData: IDataTableRowEvent): void {\n    if (isFunction(this.onBeforeEdit) && !this.onBeforeEdit(this.dataTableService.getRowsDataFromRows(this.rows), eventData)) {\n      return;\n    }\n\n    this.onEditClicked.emit(eventData);\n    if (this.gridOptions.canInlineEdit) {\n      if (!this.isEditing) {\n        this.toggleRowEditing(eventData.row, true);\n      }\n    } else {\n      this.navigateToItem(FormTypes.Edit, this.dataTableService.getRowId(eventData.row));\n    }\n  }\n\n  public onClickClone(eventData: IDataTableRowEvent): void {\n    if (this.gridOptions.canInlineAdd && !this.hasEmptyRow) {\n      const newEventData = cloneDeep(eventData);\n      this.addCloneRow(newEventData.row);\n    }\n  }\n\n  public onClickView(eventData: IDataTableRowEvent): void {\n    this.navigateToItem(FormTypes.View, this.getNavigateItemValue(eventData));\n  }\n\n  public ComplexDetailClicked(eventData: IClickedEventData): void {\n    this.onComplexDetailClicked.emit(eventData);\n  }\n\n  public ActionClickHandler(action: ITopRightAction): void {\n    if (action.clicked) {\n      action.clicked(this.selectedRow);\n    }\n  }\n\n  public showHideFilterView(): void {\n    this.isFilterView = !this.isFilterView;\n  }\n\n  public clearGlobalFilter(): void {\n    this.isClearFilter$.next(true);\n    this.searchValue.setValue('');\n    this.changeDetectorRef.detectChanges();\n    this.filterManager.clearFilterParams();\n    this.setData();\n  }\n\n  public onChangePage(paginationParams: IPaginationParams, selectableIndex?: number | string): void {\n    this.setPaginationData(paginationParams);\n    if (!this.isClientSidePagination()) {\n      this.setData(selectableIndex);\n    } else if (this.isDefaultFirstRowSelected() && this.isClientSidePagination()) {\n      if (selectableIndex) {\n        this.emitNextRow(this.pageSize * (this.currentPage - 1) + this.getSelectableValidIndex(selectableIndex));\n      } else {\n        this.emitNextRow(this.pageSize * (this.currentPage - 1));\n      }\n    }\n    this.onPageChanged.emit();\n  }\n\n  public onExpansionPanelClick(eventData: IDataTableRowEvent): void {\n    this.matExpansionPanelClicked.emit(eventData);\n  }\n\n  public onChangePageSize(pageSize: number): void {\n    this.setPaginationDataOnSizeChanged(pageSize);\n    if (!this.isClientSidePagination()) {\n      this.setData();\n    }\n  }\n\n  public getFilterParam(column: IDataTableColumn): IFilterParam {\n    return this.filterManager.getFilterParam(column);\n  }\n\n  public isFilteredColumn(columnProp: string): boolean {\n    return this.filterManager.getFilterParams().findIndex((item) => item.filterColumn.prop === columnProp) !== -1;\n  }\n\n  public onFilterClicked(filterParam: IFilterParam): void {\n    this.filterManager.setFilterParams(filterParam);\n    this.filteredRows = this.filterPipe.transform(\n      this.rows,\n      this.filterManager.getFilterParams(),\n      this.columns,\n      this.gridOptions.isClientSidePagination\n    );\n    this.setPaginationData({ currentPage: this.DEFAULT_INIT_PAGE, pageSize: this.pageSize });\n    if (!this.isClientSidePagination()) {\n      this.setData();\n    } else {\n      // this.numberOfTableRefresh = 1.5; // to skip init filter value assign\n    }\n  }\n\n  public onClickEditCancel(eventData: IDataTableRowEvent): void {\n    this.isSearchDisabled = false;\n    if (this.dataTableService.isEmptyRow(eventData.row)) {\n      this.removeEmptyRow();\n    } else {\n      this.toggleRowEditing(eventData.row, false);\n    }\n  }\n\n  public onClickEditSave(eventData: IDataTableRowSaveEvent): void {\n    this.isSearchDisabled = false;\n    if (isFunction(this.beforeSaveFn) && !this.beforeSaveFn(this.dataTableService.getRowsDataFromRows(this.rows), eventData)) {\n      return;\n    }\n\n    if (this.isSaveDataLocal) {\n      this.onSaveLocalRow(eventData);\n    } else {\n      this.saveRow(eventData);\n    }\n  }\n\n  public onChangeExpandCollapse(eventData: IDataTableExpandCollapseEvent): void {\n    this.toggleRowExpandCollapse(eventData.row, eventData.shouldExpand);\n  }\n\n  public getNavigateItemValue(eventData: IDataTableRowEvent): string {\n    if (this.gridOptions && this.gridOptions.rowNavigationProperty) {\n      return this.dataTableService.getValueByPropertyName(eventData.row, this.gridOptions.rowNavigationProperty);\n    }\n    return this.dataTableService.getRowId(eventData.row);\n  }\n\n  public navigateToItem(type: string, id: string): void {\n    const url: string = this.gridOptions.editExtraRouteParam ? `${type}/${id}/${this.gridOptions.editExtraRouteParam}` : `${type}/${id}`;\n    this.navigatePage(url);\n  }\n\n  public onClickDeleteRow(eventData: IDataTableRowEvent): void {\n    this.openDeleteModal(eventData.row);\n  }\n\n  public onClickDeleteModal(shouldDelete): void {\n    if (shouldDelete) {\n      this.gridOptions?.actionLoading$?.delete$.next(true);\n      if (this.isSaveDataLocal) {\n        this.removeLocalRow(this.dataTableService.getRowId(this.rowToDelete));\n        this.onChangeLocalData(ChangeType.ROW_DELETED);\n        this.gridOptions?.actionLoading$?.delete$.next(false);\n      } else {\n        this.deleteRow(this.rowToDelete);\n      }\n    }\n  }\n\n  public VisibleColumnListChanged(columnList: IDataTableColumn[]): void {\n    this.viewColumns = columnList;\n  }\n\n  public ngOnDestroy(): void {\n    this.clearSubs$.next(null);\n    this.clearSubs$.complete();\n    this.isClearFilter$.next(false);\n    this.isClearFilter$.complete();\n    this.dataTableContext.clearDataTableComponent();\n  }\n\n  public init(): void {\n    this.gridOptions = merge(this.defaultGridOptions, this.gridOptions);\n    this.setPaginationData({\n      currentPage: isUndefined(this.initialPage) ? this.DEFAULT_INIT_PAGE : this.initialPage,\n      pageSize: this.pageSize,\n    });\n    this.selection = new SelectionModel<IDataTableRow>(!this.isSingleSelect, []);\n    if (!this.gridOptions.isAutoColumn) {\n      this.setIdColumn();\n      this.initColumns();\n      this.defaultSortedColumns = clone(this.viewColumns);\n    }\n    this.getConfiguredColumns();\n    this.setData();\n  }\n\n  public sortTable(viewColumn: IDataTableColumn): void {\n    if (this.isTableInEditState) {\n      return;\n    }\n\n    if (!this.gridOptions.sortableProperties.find((item) => item === viewColumn.prop) && !this.gridOptions.isSortEnabled) {\n      return;\n    }\n\n    if (this.sortedColumn[viewColumn.prop] === undefined) {\n      this.sortedColumn = {};\n      this.sortedColumn[viewColumn.prop] = SortDirectionEnum.ASC;\n      this.sortData(viewColumn, true);\n    } else if (this.sortedColumn[viewColumn.prop] === SortDirectionEnum.ASC) {\n      this.sortedColumn[viewColumn.prop] = SortDirectionEnum.DESC;\n      this.sortData(viewColumn, false);\n    } else {\n      this.sortedColumn = {};\n      this.sortData(viewColumn, false, true);\n    }\n  }\n\n  public deleteRow(row: IDataTableRow): void {\n    this.setIdColumn();\n    const rowId = this.dataTableService.getRowId(row);\n    this.deleteItemFn(rowId, row.data)\n      .pipe(first(), takeUntil(this.clearSubs$))\n      .subscribe({\n        next: () => {\n          this.gridOptions?.actionLoading$?.delete$.next(false);\n          this.snackbarService.success(SnackbarTypes.Deleted, SnackbarTypes.Deleted);\n          if (this.isClientSidePagination()) {\n            this.removeLocalRow(rowId);\n          } else {\n            this.setData();\n          }\n          if (!this.isDefaultFirstRowSelected()) {\n            this.selectedRow = undefined;\n          }\n          this.onDeleteCompleted.emit({ row: this.selectedRow });\n        },\n        error: () => {\n          // Empty method block.\n        },\n      });\n  }\n\n  public searchModelChanged(): void {\n    if (this.gridOptions.isClientSidePagination) {\n      this.filteredRows = this.searchPipe.transform(\n        this.rows,\n        this.searchValue.value,\n        this.searchColumns,\n        this.gridOptions.isClientSidePagination,\n        this.searchedRowCount$\n      );\n      this.setPaginationData({ currentPage: this.DEFAULT_INIT_PAGE, pageSize: this.pageSize });\n      this.changeDetectorRef.detectChanges();\n    }\n  }\n\n  public getTooltipText(text: string): string {\n    if (this.gridOptions.iconTooltips && this.gridOptions.iconTooltips[text]) {\n      return this.gridOptions.iconTooltips[text];\n    }\n    return tooltipsDefaultValue[text];\n  }\n\n  public getActionName(prop: ActionTypesEnum): string {\n    return this.userManagementService.getActionName(this.gridOptions, prop);\n  }\n\n  public getLeftActionName(prop: ActionTypesEnum): string {\n    return this.userManagementService.getLeftActionName(this.gridOptions, prop);\n  }\n\n  public getLeftRightActionText(data: IKeyValue): string {\n    if (data.title) {\n      return data.title;\n    }\n    return tooltipsDefaultValue[data.title];\n  }\n\n  public get isSingleSelect(): boolean {\n    return this.gridOptions && this.gridOptions.isSingleSelect === true;\n  }\n\n  public get pageSize(): number {\n    return this.paginationParams.pageSize;\n  }\n\n  public get currentPage(): number {\n    return this.paginationParams.currentPage;\n  }\n\n  public detectChange(): void {\n    this.changeDetectorRef.detectChanges();\n  }\n\n  public selectNextRow(): void {\n    if (this.isLastRowInPage()) {\n      this.paginationParams.currentPage = this.isLastRowInLastPage() ? 1 : this.paginationParams.currentPage + 1;\n      this.onChangePage(this.paginationParams);\n    } else {\n      this.emitNextRow(this.selectedRow.rowIndex + 1);\n    }\n  }\n\n  public selectPreviousRow(): void {\n    if (this.isFirstRowInPage()) {\n      this.paginationParams.currentPage = this.isFirstRowInFirstPage() ? this.pagesCount : this.paginationParams.currentPage - 1;\n      this.onChangePage(this.paginationParams, 'last');\n    } else {\n      this.emitNextRow(this.selectedRow.rowIndex - 1);\n    }\n  }\n\n  public uncheckSelectedSource(): void {\n    this.selection.clear();\n    this.changeDetectorRef.detectChanges();\n    this.gridApi.detectRowChanges();\n  }\n\n  public onDoubleClickSeparator(index: number, viewColumn: IDataTableColumn) {\n    if (!this.gridOptions.draggable || !viewColumn.draggable) {\n      return;\n    }\n\n    clearTimeout(this.clickTimeout);\n    this.resizingTh = this.getSelectedHtml(`th[data-column-prop=\"${viewColumn.prop}\"] div`) as HTMLElement;\n    this.resizingTd = this.getSelectedHtml(`td[data-column-prop=\"${viewColumn.prop}\"]`, true) as NodeList;\n    if (!this.resizingTh || !this.resizingTd) {\n      return;\n    }\n\n    viewColumn.doubleClicked = !viewColumn.doubleClicked;\n    viewColumn.dragged = false;\n    this.formatTableData(viewColumn);\n    this.formatTableHeader();\n  }\n\n  public getHeaderStyle(index: number, viewColumn: IDataTableColumn): string[] {\n    let classes: string[] = [];\n    if (this.viewColumns[index].dragged || viewColumn?.doubleClicked === true) {\n      classes.push('drag-column');\n    } else if (this.gridOptions.fixedWidthData) {\n      classes.push('header-max-width');\n    }\n\n    return classes;\n  }\n\n  public onSeparatorMouseDown(event: MouseEvent, index: number, viewColumn: IDataTableColumn): void {\n    clearTimeout(this.clickTimeout);\n    this.clickTimeout = setTimeout(() => {\n      if (!this.gridOptions.draggable || !viewColumn.draggable) {\n        return;\n      }\n\n      if (!viewColumn.dragged) {\n        viewColumn.dragged = true;\n        this.changeDetectorRef.detectChanges();\n      }\n\n      this.resizingTh = this.getSelectedHtml(`th[data-column-prop=\"${viewColumn.prop}\"] div`) as HTMLElement;\n      this.resizingTd = this.getSelectedHtml(`td[data-column-prop=\"${viewColumn.prop}\"]`, true) as NodeList;\n      const tdDiv = this.getSelectedHtml(`td[data-column-prop=\"${viewColumn.prop}\"] div`) as HTMLElement;\n      this.apolloDataTable = document.querySelector('.apollo-design-new-data-table') as HTMLElement;\n\n      if (this.resizingTh) {\n        this.startX = event.pageX;\n        this.startWidth = this.getActualWidth(this.resizingTh, this.startX);\n        const tdDivWidth = this.getActualWidth(tdDiv, this.startX);\n\n        if (this.resizingTd) {\n          this.resizingTd.forEach((cell) => {\n            const tdDiv = (<HTMLElement>cell).querySelector('div') as HTMLElement;\n            tdDiv.classList.remove('data-max-width');\n            tdDiv.classList.add('drag-column');\n          });\n        }\n\n        this.setWidthToElement(this.startWidth, tdDivWidth, this.resizingTh.offsetWidth);\n      }\n    }, 250);\n\n    document.body.classList.add('no-select-resize');\n    if (this.gridOptions.draggable && viewColumn.draggable) {\n      document.addEventListener('mousemove', this.onMouseMove);\n    }\n\n    document.addEventListener('mouseup', this.onMouseUp);\n  }\n\n  private getSelectedHtml(selector: string, isSelectAll: boolean = false) {\n    if (isSelectAll) {\n      return this.customDataTable.nativeElement.querySelectorAll(selector);\n    }\n\n    return this.customDataTable.nativeElement.querySelector(selector);\n  }\n\n  private formatTableData(viewColumn: IDataTableColumn) {\n    if (!viewColumn.doubleClicked) {\n      this.resizingTd.forEach((cell) => {\n        const tdDiv = (<HTMLElement>cell).querySelector('div') as HTMLElement;\n        tdDiv.classList.remove('drag-column');\n        if (this.gridOptions.fixedWidthData) {\n          tdDiv.classList.add('data-max-width');\n        }\n      });\n    } else {\n      this.resizingTd.forEach((cell) => {\n        const tdDiv = (<HTMLElement>cell).querySelector('div') as HTMLElement;\n        tdDiv.classList.remove('data-max-width');\n        tdDiv.classList.add('drag-column');\n      });\n    }\n  }\n\n  private formatTableHeader() {\n    this.resizingTh.style.width = '';\n    this.resizingTd.forEach((cell) => {\n      const tdDiv = (<HTMLElement>cell).querySelector('div') as HTMLElement;\n      tdDiv.style.width = '';\n    });\n  }\n\n  private onMouseMove = (event: MouseEvent): void => {\n    const width = this.startWidth + (event.pageX - this.startX);\n    if (this.resizingTh) {\n      this.setWidthToElement(width, width, this.resizingTh.offsetWidth);\n    }\n  };\n\n  private onMouseUp = (): void => {\n    document.removeEventListener('mousemove', this.onMouseMove);\n    document.removeEventListener('mouseup', this.onMouseUp);\n    document.body.classList.remove('no-select-resize');\n    this.resizingTh = null;\n    this.resizingTd = null;\n  };\n\n  private setWidthToElement(thWidth: number, tdWidth: number, previousThWidth: number) {\n    if (this.resizingTh) {\n      this.resizingTh.style.width = `${thWidth}px`;\n    }\n\n    if (this.resizingTd) {\n      this.resizingTd.forEach((cell) => {\n        const div = (<HTMLElement>cell).querySelector('div.drag-column') as HTMLElement;\n\n        if (div) {\n          div.style.width = `${tdWidth}px`;\n        }\n      });\n    }\n\n    if (this.resizingTh && this.apolloDataTable) {\n      const updatedTableWidth = this.apolloDataTable.offsetWidth + (this.resizingTh.offsetWidth - previousThWidth);\n      this.apolloDataTable.style.width = `${updatedTableWidth}px`;\n    }\n  }\n\n  private getActualWidth(element: HTMLElement, startX: number): number {\n    let width: number;\n    const boundingRect = element.getBoundingClientRect();\n    width = boundingRect.width;\n    const offset = startX - boundingRect.left;\n\n    if (offset < boundingRect.width) {\n      width = offset;\n    }\n\n    return width;\n  }\n\n  private get pagesCount(): number {\n    return Math.ceil(this.count / this.pageSize);\n  }\n\n  private get rowsCountInCurrentPage(): number {\n    if (!this.gridOptions.isClientSidePagination) {\n      return this.rows.length;\n    }\n    const leftRows = this.rows.length - this.pageSize * (this.currentPage - 1);\n    return leftRows >= this.pageSize ? this.pageSize : leftRows;\n  }\n\n  private isLastRowInPage(): boolean {\n    if (this.selectedRow && this.gridOptions.isClientSidePagination) {\n      return (\n        (this.selectedRow.rowIndex + 1) / this.currentPage === this.rowsCountInCurrentPage || this.selectedRow.rowIndex + 1 === this.count\n      );\n    }\n    return this.selectedRow && this.selectedRow.rowIndex + 1 === this.rowsCountInCurrentPage;\n  }\n\n  private isFirstRowInPage(): boolean {\n    return this.selectedRow && this.selectedRow.rowIndex % this.pageSize === 0;\n  }\n\n  private isFirstRowInFirstPage(): boolean {\n    return this.isFirstRowInPage() && this.currentPage === 1;\n  }\n\n  private isLastRowInLastPage(): boolean {\n    return this.isLastRowInPage() && this.currentPage === this.pagesCount;\n  }\n\n  private detectRowChange(): void {\n    this.rows = clone(this.rows);\n    this.changeDetectorRef.detectChanges();\n  }\n\n  private isClientSidePagination(): boolean {\n    return this.gridOptions.isClientSidePagination;\n  }\n\n  private setIdColumn(): void {\n    // To do improve\n    if (this.gridOptions && this.gridOptions.idProperty) {\n      COLUMN_ID.PROP = this.gridOptions.idProperty;\n    } else {\n      COLUMN_ID.PROP = 'id';\n    }\n  }\n\n  private initColumns(): void {\n    this.initViewColumns();\n    if (this.gridOptions && this.gridOptions.addIdColumn) {\n      this.addIdColumn();\n    }\n  }\n\n  private configureDialog(dialogConfig: MatDialogConfig): MatDialogConfig {\n    dialogConfig.position = {\n      top: '15vh',\n      left: '20vw',\n    };\n    dialogConfig.height = '80vh';\n    dialogConfig.width = '60vw';\n    dialogConfig.panelClass = 'columnshowhide-panel';\n    dialogConfig.data = {\n      defaultSortedColumns: this.defaultSortedColumns,\n      columns: this.viewColumns,\n      storageKey: this.storageKey,\n      metaDataColumns: this.gridOptions.metaDataColumns,\n    };\n    dialogConfig.disableClose = false;\n    return dialogConfig;\n  }\n\n  private initViewColumns(): void {\n    this.viewColumns = clone(this.columns.filter((x) => x != undefined));\n    this.viewColumns.forEach((viewColumn: IDataTableColumn) => {\n      if (viewColumn.isVisible === undefined) {\n        viewColumn.isVisible = true;\n      }\n      if (viewColumn.isDisplayValueAsFormControl === undefined) {\n        viewColumn.isDisplayValueAsFormControl = false;\n      }\n    });\n    this.searchColumns = this.getSearchableColumns(this.viewColumns);\n  }\n\n  private addIdColumn(): void {\n    this.viewColumns.unshift({\n      header: COLUMN_ID.HEADER,\n      prop: COLUMN_ID.PROP,\n      type: ColumnTypes.Integer,\n      isReadOnly: true,\n      isVisible: false, // this.isIdColVisible,\n      isDisplayValueAsFormControl: false,\n      editDisabledMode: ColumnDisableModes.AlwaysDisabled,\n    });\n  }\n\n  private setData(selectableIndex?: number | string): void {\n    this.numberOfTableRefresh += 1;\n    this.isLoading$.next(true);\n    if (!this.gridOptions.isAutoColumn) {\n      this.setInitApiParams();\n    }\n    this.applyDefaultSortingParams();\n    this.getListFn(this.apiReqParams)\n      .pipe(first(), takeUntil(this.clearSubs$))\n      .subscribe(\n        (response: any) => {\n          // TODO: add error handling\n          this.totalItems = response.itemsTotal;\n          this.initGetFunc(response, selectableIndex);\n          if (this.gridOptions.isDefaultAllRowSelected && this.gridOptions.isClientSidePagination) {\n            this.masterSelection.setValue(true);\n            this.masterToggle();\n          }\n          this.isTableDataLoad.emit(true);\n        },\n        (err) => {\n          if (err) {\n            this.isLoading$.next(false);\n            this.rows = this.rows || [];\n            this.changeDetectorRef.detectChanges();\n          }\n        },\n        () => {\n          // Empty Method block\n        }\n      );\n  }\n\n  private setInitApiParams(): void {\n    if (this.numberOfTableRefresh > 1) {\n      return;\n    }\n    this.setInitFilterParams();\n  }\n\n  private setInitFilterParams(): void {\n    this.filterManager.setInitFilterParams(this.columns);\n  }\n\n  private initGetFunc(response: IListResApi<IKeyValue>, selectableIndex?: number | string): void {\n    this.count = this.gridOptions.isClientSidePagination ? response.resultSet.length : response.itemsTotal;\n    this.searchedRowCount$.next(response.itemsTotal);\n    if (this.gridOptions.isAutoColumn) {\n      this.generateColumns(response.resultSet);\n    }\n    this.rows = this.dataTableService.getRowsFromRowsData(response.resultSet);\n    if (this.gridOptions.editable) {\n      this.rows.forEach((x) => (x.isEditing = true));\n    }\n    if (this.gridOptions.isClientSidePagination) {\n      this.originalUnsortedRows = cloneDeep(this.rows);\n    }\n\n    this.filteredRows = cloneDeep(this.rows);\n    this.selectedRow = undefined;\n    this.isLoading$.next(false);\n    this.isClearFilter$.next(false);\n    this.isEditing = false;\n    this.hasEmptyRow = false;\n    if (this.gridOptions.defaultSortProperty.prop) {\n      this.applyDefaultSort();\n    }\n    if (this.isEligibleForAllCheck()) {\n      this.checkedAllExceptExcludedRows();\n    } else if (this.isRowSelectionEnable && !this.gridOptions.isClientSidePagination) {\n      this.setRowChecked();\n    }\n    if (this.isDefaultFirstRowSelected()) {\n      // TODO - refactor\n\n      this.emitNextRow(this.getSelectableValidIndex(selectableIndex));\n    }\n    this.changeDetectorRef.detectChanges();\n  }\n\n  private isEligibleForAllCheck(): boolean {\n    return (\n      this.isRowSelectionEnable && !this.gridOptions.isClientSidePagination && !this.masterSelection.pristine && this.masterSelection.value\n    );\n  }\n\n  private getSelectableValidIndex(selectableIndex: number | string): any {\n    if (selectableIndex === 'last') {\n      selectableIndex = this.pageSize;\n    }\n    return Number(selectableIndex) > this.rowsCountInCurrentPage - 1 ? this.rowsCountInCurrentPage - 1 : selectableIndex;\n  }\n\n  private setPaginationData(paginationParams: IPaginationParams): void {\n    this.paginationParams = paginationParams;\n  }\n\n  private checkedAllExceptExcludedRows(): void {\n    this.clearPropertyWhenSelectionEnable(this.excludedRows);\n    this.selection.clear();\n    const excludedCurrentPageRows = this.rows.filter((x) => this.excludedRows.map((e) => JSON.stringify(e)).includes(JSON.stringify(x)));\n    this.rows\n      .filter((x) => !excludedCurrentPageRows.some((y) => JSON.stringify(x) === JSON.stringify(y)))\n      .forEach((row) => {\n        if (this.gridOptions.rowDisableFn && isFunction(this.gridOptions.rowDisableFn) && !this.gridOptions.rowDisableFn(row)) {\n          this.selection.select(row);\n        } else if (!this.gridOptions.rowDisableFn) {\n          this.selection.select(row);\n        }\n      });\n  }\n\n  private applyDefaultSort(): void {\n    if (this.gridOptions.defaultSortProperty.order === SortDirectionEnum.DESC) {\n      this.downSort(this.gridOptions.defaultSortProperty);\n    } else {\n      this.upSort(this.gridOptions.defaultSortProperty);\n    }\n  }\n\n  private applyDefaultSortingParams(): void {\n    if (!this.gridOptions.defaultSortProperty.prop) {\n      return;\n    }\n    this.sortedColumn = {};\n    if (this.gridOptions.defaultSortProperty.order === SortDirectionEnum.DESC) {\n      this.sortedColumn[this.gridOptions.defaultSortProperty.prop] = SortDirectionEnum.DESC;\n    } else {\n      this.sortedColumn[this.gridOptions.defaultSortProperty.prop] = SortDirectionEnum.ASC;\n    }\n  }\n\n  private setPaginationDataOnSizeChanged(pageSize: number): void {\n    this.paginationParams.pageSize = pageSize;\n  }\n\n  private navigatePage(url: string): void {\n    this.router.navigate([url], { relativeTo: this.activatedRoute });\n  }\n\n  private openDeleteModal(row: IDataTableRow): void {\n    this.rowToDelete = row;\n    const dialogConfig = new MatDialogConfig();\n    dialogConfig.data = {\n      message: this.gridOptions.deleteOptions.confirmationMessage,\n    };\n    dialogConfig.position = {\n      top: '7%',\n    };\n    dialogConfig.panelClass = 'delete-modal-panel';\n    const dialogRef: MatDialogRef<DeleteModalComponent> = this.matDialog.open(DeleteModalComponent, dialogConfig);\n    dialogRef\n      .afterClosed()\n      .pipe(first(), takeUntil(this.clearSubs$))\n      .subscribe((result) => this.onClickDeleteModal(result));\n    this.changeDetectorRef.detectChanges();\n  }\n\n  private saveRow(eventData: IDataTableRowSaveEvent): void {\n    this.setIdColumn();\n    const row = eventData.row,\n      saveData = eventData.saveData;\n    if (saveData[COLUMN_ID.PROP] === COLUMN_ID.EMPTY_ROW_VAL) {\n      this.postDataForAdd(saveData, row);\n    } else {\n      this.putDataForEdit(saveData, row);\n    }\n  }\n\n  private postDataForAdd(saveData: IRowData, row: IDataTableRow): void {\n    this.isSaving = true;\n    row.isSaving = true;\n    this.postItemFn(saveData)\n      .pipe(first(), takeUntil(this.clearSubs$))\n      .subscribe(\n        (result: IKeyValue) => {\n          this.isSaving = false;\n          row.isSaving = false;\n          this.snackbarService.success(SnackbarTypes.Success, SnackbarTypes.Success);\n          if (this.gridOptions.refreshOnAdd) {\n            this.setData();\n          } else {\n            this.hasEmptyRow = false;\n            saveData[COLUMN_ID.PROP] = result[COLUMN_ID.PROP];\n            this.saveLocalRow(row, saveData);\n          }\n        },\n        () => {\n          this.isSaving = false;\n          row.isSaving = false;\n          this.changeDetectorRef.detectChanges();\n        }\n      );\n  }\n\n  private putDataForEdit(saveData: IRowData, row: IDataTableRow): void {\n    this.isSaving = true;\n    row.isSaving = true;\n    this.putItemFn(this.dataTableService.getRowId(row), saveData)\n      .pipe(first(), takeUntil(this.clearSubs$))\n      .subscribe(\n        (returnData: IRowData) => {\n          if (returnData) {\n            saveData = merge(saveData, returnData);\n          }\n          this.isSaving = false;\n          row.isSaving = false;\n          this.snackbarService.info(SnackbarTypes.Update, SnackbarTypes.Update);\n          if (!this.isClientSidePagination()) {\n            this.setData();\n          } else {\n            this.saveLocalRow(row, saveData);\n            this.onUpdateCompleted.emit({ row });\n          }\n        },\n        () => {\n          this.isSaving = false;\n          row.isSaving = false;\n          this.changeDetectorRef.detectChanges();\n        }\n      );\n  }\n\n  private downSort(viewColumn: IDataTableColumn): void {\n    this.rows.sort((item1, item2) => {\n      return item1.data[viewColumn.prop] <= item2.data[viewColumn.prop] ? 1 : -1;\n    });\n    this.detectRowChange();\n  }\n\n  private upSort(viewColumn: IDataTableColumn): void {\n    this.rows.sort((item1, item2) => {\n      return item1.data[viewColumn.prop] >= item2.data[viewColumn.prop] ? 1 : -1;\n    });\n    this.detectRowChange();\n  }\n\n  private unsort(): void {\n    this.rows = this.originalUnsortedRows.filter((original) => {\n      return this.rows.filter((row) => JSON.stringify(row.data) === JSON.stringify(original.data));\n    });\n  }\n\n  private sortData(viewColumn: IDataTableColumn, isAscending: boolean, isUnsort: boolean = false): void {\n    if (!this.gridOptions.isClientSidePagination) {\n      this.setData();\n      return;\n    }\n\n    if (isUnsort) {\n      this.unsort();\n    } else {\n      isAscending ? this.upSort(viewColumn) : this.downSort(viewColumn);\n    }\n  }\n\n  private addEmptyRow(depth: number = ROW.ROOT_DEPTH, parentId: string = COLUMN_ID.NO_PARENT_VAL): void {\n    this.hasEmptyRow = true;\n    this.filterManager.clearFilterParams();\n    const newRow = this.getEmptyRow(depth, parentId);\n    this.selectedRow = newRow;\n    this.rows = this.dataTableService.getRowsWithInsertedRow(parentId, this.rows, newRow);\n  }\n\n  private removeEmptyRow(): void {\n    this.hasEmptyRow = false;\n    this.selectedRow = undefined;\n    this.removeLocalRow(COLUMN_ID.EMPTY_ROW_VAL);\n  }\n\n  private onSaveLocalRow(eventData: IDataTableRowSaveEvent): void {\n    if (this.dataTableService.isEmptyRow(eventData.row)) {\n      this.addLocalRow(eventData.row, eventData.saveData);\n      this.onChangeLocalData(ChangeType.ROW_ADDED);\n    } else {\n      this.editLocalRow(eventData.row, eventData.saveData);\n      this.onChangeLocalData(ChangeType.ROW_UPDATED);\n    }\n  }\n\n  private addLocalRow(row: IDataTableRow, saveData: IKeyValue): void {\n    this.hasEmptyRow = false;\n    this.saveLocalRow(row, { ...saveData, id: this.dataTableService.getNewRowId() });\n  }\n\n  private editLocalRow(row: IDataTableRow, saveData: IKeyValue): void {\n    this.saveLocalRow(row, saveData);\n  }\n\n  private saveLocalRow(row: IDataTableRow, saveData: IKeyValue): void {\n    this.isEditing = false;\n    this.updateRowData(row, saveData);\n    row.isEditing = false;\n    this.detectRowChange();\n  }\n\n  private updateRowData(row: IDataTableRow, saveData: IKeyValue): void {\n    Object.assign(row.data, saveData);\n    if (!isUndefined(row.formGroup)) {\n      this.formService.fillForm(row.formGroup, row.data);\n    }\n  }\n\n  private removeLocalRow(removeRowId: string): void {\n    const index = this.rows.findIndex((x) => x.data[COLUMN_ID.PROP] === removeRowId);\n    this.rows = this.dataTableService.getRowsWithRemovedRow(removeRowId, this.rows);\n    if (this.isDefaultFirstRowSelected()) {\n      this.selectAutoNextRow(index);\n    } else if (this.gridOptions.defaultFirstRowSelection && this.rows.length === 0) {\n      this.onRowClicked.emit();\n    }\n    if (this.rows.length && this.rows.length % this.paginationParams.pageSize === 0) {\n      this.paginationParams.currentPage--;\n      this.searchedRowCount$.next(this.rows.length);\n    }\n    this.changeDetectorRef.detectChanges();\n  }\n\n  private selectAutoNextRow(index: number): void {\n    if (index !== -1) {\n      this.emitNextRow(this.rows.length === index ? this.rows.length - 1 : index);\n    }\n  }\n\n  private isDefaultFirstRowSelected(): boolean {\n    return this.gridOptions.defaultFirstRowSelection;\n  }\n\n  private emitNextRow(index: number = 0): void {\n    if (this.rows.length > 0) {\n      this.rows.forEach((x) => (x.isSelected = false));\n      this.selectedRow = this.rows[index];\n      this.selectedRow.rowIndex = index;\n      this.rows[index].isSelected = true;\n      this.changeDetectorRef.detectChanges();\n      this.dataTableBody.detectChange();\n      this.onRowClicked.emit(this.rows[index]);\n    } else {\n      this.onRowClicked.emit();\n    }\n  }\n\n  private toggleRowEditing(row: IDataTableRow, isEditing: boolean): void {\n    this.isEditing = isEditing;\n    row.isEditing = isEditing;\n    this.rows = [...this.rows];\n    this.changeDetectorRef.detectChanges();\n  }\n\n  private toggleRowExpandCollapse(row: IDataTableRow, shouldExpand: boolean): void {\n    row.isExpanded = shouldExpand;\n    this.rows = [...this.rows];\n    this.changeDetectorRef.detectChanges();\n  }\n\n  private getEmptyRow(depth: number, parentId: string): IDataTableRow {\n    return this.dataTableService.getRow(\n      this.dataTableService.getEmptyRowData(this.viewColumns, this.defaultRowValues),\n      depth,\n      parentId,\n      true\n    );\n  }\n\n  private onChangeLocalData(changeType: ChangeType = ChangeType.OTHER): void {\n    this.changeLocalData.emit({\n      rowsData: this.dataTableService.getRowsDataFromRows(this.rows),\n      changeType,\n    });\n  }\n\n  private fireInitCompleted(): void {\n    this.onInitCompleted.emit(this.getGridApi());\n  }\n\n  private addCloneRow(row: IDataTableRow, depth: number = ROW.ROOT_DEPTH, parentId: string = COLUMN_ID.NO_PARENT_VAL): void {\n    this.hasEmptyRow = true;\n    row.data[COLUMN_ID.PROP] = COLUMN_ID.EMPTY_ROW_VAL;\n    this.gridOptions.cloneOptions.copyOfClonableProperties.forEach((property: string) => {\n      row.data[property] = DataTableConstants.COPY_OF + row.data[property];\n    });\n\n    const emptyValueColumns = this.viewColumns.filter((col) => {\n      return this.gridOptions.cloneOptions.emptyValueProperties.includes(col.prop);\n    });\n    this.dataTableService.setEmptyValuesInRowData(row, emptyValueColumns);\n\n    const clonedRow = this.dataTableService.getRow(row.data, depth, parentId, true);\n    this.rows = this.dataTableService.getRowsWithInsertedRow(parentId, this.rows, clonedRow);\n    this.selectedRow = clonedRow;\n  }\n\n  private getGridApi(): GridApi {\n    return this.gridApi;\n  }\n\n  private getSearchableColumns(columns: IDataTableColumn[]): IDataTableColumn[] {\n    const searchableColumns = columns.filter(\n      (item) => Object.hasOwnProperty.call(item, 'prop') && this.gridOptions.searchableProperties.includes(item.prop)\n    );\n    return searchableColumns.length === 0 ? columns : searchableColumns;\n  }\n\n  private masterToggleClientSide(): void {\n    this.isAllSelected() ? this.selection.clear() : this.nonDisabledRows.forEach((row) => this.selection.select(row));\n    this.changeDetectorRef.detectChanges();\n    this.gridApi.detectRowChanges();\n  }\n\n  private clearPropertyWhenSelectionEnable(checkedRows: IDataTableRow[]): void {\n    if (this.isRowSelectionEnable && checkedRows.length) {\n      checkedRows.forEach((s) => {\n        if (s.hasOwnProperty('isSelected')) {\n          delete s.isSelected;\n        }\n        if (s.hasOwnProperty('rowIndex')) {\n          delete s.rowIndex;\n        }\n      });\n    }\n  }\n\n  private getCheckedRows(): ICheckedRowEvent {\n    const checkedRows = this.selection.selected;\n    this.clearPropertyWhenSelectionEnable(checkedRows);\n    const pageMatchedPreviousCheckedRows = this.rows.filter((row) => {\n      return checkedRows.some((item) => JSON.stringify(row) === JSON.stringify(item));\n    });\n    const pageUnmatchedCheckedRows = checkedRows.filter((e) => {\n      return pageMatchedPreviousCheckedRows.findIndex((m) => JSON.stringify(e) === JSON.stringify(m)) < 0;\n    });\n    return { pageMatchedPreviousCheckedRows: pageMatchedPreviousCheckedRows, pageUnmatchedCheckedRows: pageUnmatchedCheckedRows };\n  }\n\n  private masterToggleServerSide(): void {\n    const previousCheckedRows: ICheckedRowEvent = this.getCheckedRows();\n    this.selection.clear();\n    this.addUnmatchedRowToSelection(previousCheckedRows.pageUnmatchedCheckedRows);\n    if (this.rows.length !== previousCheckedRows.pageMatchedPreviousCheckedRows.length) {\n      this.rows.forEach((row) => this.selection.select(row));\n    }\n    this.changeDetectorRef.detectChanges();\n    this.gridApi.detectRowChanges();\n  }\n\n  private addUnmatchedRowToSelection(rows: IDataTableRow[]): void {\n    rows.forEach((row) => this.selection.select(row));\n  }\n\n  private setRowChecked(): void {\n    const previousCheckedRows: ICheckedRowEvent = this.getCheckedRows();\n    this.selection.clear();\n    this.addUnmatchedRowToSelection(previousCheckedRows.pageUnmatchedCheckedRows);\n\n    this.rows\n      .filter((e) => {\n        return previousCheckedRows.pageMatchedPreviousCheckedRows.some((item) => JSON.stringify(e) === JSON.stringify(item));\n      })\n      .forEach((row) => {\n        this.selection.select(row);\n      });\n\n    this.changeDetectorRef.detectChanges();\n    this.gridApi.detectRowChanges();\n  }\n\n  private getFilteredDataRow(dataRows: IDataTableRow[]): IDataTableRow[] {\n    return dataRows.filter((e) => {\n      return this.filteredRows.some((item) => JSON.stringify(e.data) === JSON.stringify(item.data));\n    });\n  }\n\n  private setColumnSource(property: string): string {\n    let source: string;\n    const index = this.gridOptions.metaDataColumns.findIndex((value: string) => value === property);\n    if (index > -1) {\n      source = this.sourceTypes.METADATA;\n    } else {\n      source = this.sourceTypes.DATA_SOURCE;\n    }\n    return source;\n  }\n\n  private setColumnsUsingStoredData(defaultColumns: IDataTableColumn[]): IDataTableColumn[] {\n    let tempCollection: IDataTableColumn[] = [];\n    tempCollection = defaultColumns.filter((x) => x != undefined);\n    if (!this.storageKey) {\n      return tempCollection;\n    }\n    let storedColumns = this.localStorageService.getItem(this.storageKey);\n    if (storedColumns && storedColumns.length) {\n      var index = 0;\n      storedColumns\n        .filter((x) => x != undefined)\n        .forEach((item: ListItem) => {\n          const existingColumnIndex = tempCollection.findIndex((x) => x.prop === item.prop);\n          if (existingColumnIndex > -1) {\n            const existingColumn = tempCollection.find((x) => x.prop === item.prop);\n            if (existingColumn) {\n              existingColumn.isVisible = true;\n              var tempcolumn = tempCollection[index];\n              tempCollection[index] = existingColumn;\n              tempCollection[existingColumnIndex] = tempcolumn;\n            }\n          }\n          index++;\n        });\n      // added invisible columns at the end to complete the set\n      tempCollection\n        .filter((item) => item && storedColumns.findIndex((x) => x.prop === item.prop) < 0)\n        .forEach((item: IDataTableColumn) => {\n          if (item) {\n            item.isVisible = false;\n          }\n        });\n    }\n\n    return tempCollection;\n  }\n\n  private selectedCheckboxPagingConfirmation(selectableIndex?: number | string): void {\n    const dialogRef: MatDialogRef<CommonConfirmModalComponent> = this.matDialog.open(CommonConfirmModalComponent, {\n      width: '450px',\n      data: {\n        body: this.confirmationMsgPagination,\n      },\n    });\n    dialogRef\n      .afterClosed()\n      .pipe()\n      .subscribe((confirmation) => {\n        if (confirmation) {\n          this.setData(selectableIndex);\n        }\n      });\n  }\n\n  private isSelectedRow(): number {\n    return this.gridApi.getSelectedRows().map((x) => x.data).length;\n  }\n\n  private searchTable(): void {\n    this.searchValue.valueChanges\n      .pipe(\n        filter((res: string) => res.length >= 2 || res === ''),\n        debounceTime(500),\n        distinctUntilChanged(),\n        takeUntil(this.clearSubs$)\n      )\n      .subscribe(() => {\n        if (!this.isSearchDisabled) {\n          this.paginationParams.currentPage = 1;\n          this.changeDetectorRef.detectChanges();\n          this.setData();\n        }\n      });\n  }\n\n  private populateFilterParams(): IFilterParam[] {\n    if (!this.gridOptions.isClientSidePagination && this.gridOptions.isSearchBoxVisible && !this.gridOptions.isUpdatedTableDesign) {\n      return [{ columnName: 'searchText', filterValue: this.searchValue.value }, ...this.filterManager.getFilterParams()];\n    }\n    return this.filterManager.getFilterParams();\n  }\n\n  private getConfiguredColumns(): void {\n    if (isFunction(this.gridOptions.storageFn)) {\n      this.storageKey = this.gridOptions.storageFn();\n      let columns = this.setColumnsUsingStoredData(this.columns);\n      this.viewColumns = columns.filter((x) => x != undefined);\n    }\n  }\n\n  private generateColumns(rowData: IKeyValue[]): void {\n    this.columns = Object.keys(rowData[0]).map((x) => {\n      return <IDataTableColumn>{\n        header: x.toUpperCase(),\n        prop: x,\n        type: ColumnTypes.String,\n        rendererTemplate: this.gridOptions.renderTemplatesProp ? this.gridOptions.renderTemplatesProp[x] : undefined,\n      };\n    });\n    this.initColumns();\n    this.defaultSortedColumns = clone(this.viewColumns);\n    this.changeDetectorRef.detectChanges();\n  }\n}\n","<div>\n    <section class=\"actions\">\n        <section class=\"search\" *ngIf=\"gridOptions.isSearchBoxVisible && !gridOptions.isUpdatedTableDesign\">\n            <form ngForm>\n                <div class=\"searchbar-wrapper\">\n                    <i class=\"svg-icon fa-solid fa-magnifying-glass\"></i>\n                    <input matInput type=\"text\" placeholder=\"Search {{ searchPlaceholder }}\" name=\"search\"\n                        [formControl]=\"searchValue\" [disabled]=\"isSearchDisabled\"\n                        (ngModelChange)=\"searchModelChanged()\" />\n                </div>\n            </form>\n        </section>\n        <div class=\"toolbar\" *ngIf=\"!gridOptions.hideTopToolbar\">\n            <section *ngIf=\"!isOnlyView\" class=\"adding\">\n                <ul class=\"row-actions\">\n                    <ng-container *hasPermission=\"getActionName(actionTypes.ADD)\">\n                        <li *ngIf=\"!gridOptions.addButtonTemplate\">\n                            <span *ngIf=\"!isTableInEditState\">\n                                <a (click)=\"onClickAdd()\"\n                                    [ngClass]=\"{'disabled': isDisabledMainAction(actionTypes.ADD) || (gridOptions.disableIcons && gridOptions.disableIcons.add$ |async)}\">\n                                    <span title=\"{{getTooltipText(toolTips.ADD)}}\" class=\"toolbar-icon icon-plus\"\n                                        [ngClass]=\"(isDisabledMainAction(actionTypes.ADD) || (gridOptions.disableIcons && gridOptions.disableIcons.add$ |async))? 'icon-inactive': 'icon-active'\"></span>\n                                </a>\n                            </span>\n                        </li>\n                    </ng-container>\n                    <ng-container *ngIf=\"gridOptions.addButtonTemplate\">\n                        <li>\n                            <ng-container *ngTemplateOutlet=\"gridOptions.addButtonTemplate;\"></ng-container>\n                        </li>\n                    </ng-container>\n                </ul>\n                <ng-container *ngIf=\"!isLoading$.getValue()\">\n                    <app-data-table-actions\n                        *ngIf=\"!(isOnlyView && !isViewActionVisible) && !gridOptions.isRowActionVisible\"\n                        [gridApi]=\"gridApi\" [canInlineEdit]=\"canInlineEdit\" [isTreeGrid]=\"isTreeGrid\"\n                        [gridOptions]=\"gridOptions\" [selectedRow]=\"selectedRow\" [isIconsDisabled]=\"isActionsDisabled\"\n                        [isEditing]=\"selectedRow?.isEditing\" [isSaving]=\"selectedRow?.isSaving\"\n                        [isOnlyView]=\"isOnlyView\" [isEditable]=\"isEditable\" (clickAdd)=\"onClickAdd()\"\n                        [hasEmptyRow]=\"hasEmptyRow\" [isEditing]=\"isEditing\" [isSaving]=\"isSaving\"\n                        [isCloneVisible]=\"isCloneVisible\" [isDeleteVisible]=\"!checkDeleteDisabled()\">\n                    </app-data-table-actions>\n                </ng-container>\n            </section>\n            <ul class=\"row-actions\" *ngIf=\"!isOnlyView || gridOptions.isTopLeftActionsForceDisply\">\n                <ng-container *ngFor=\"let action of gridOptions.topLeftAdditionalActions\">\n                    <li>\n                        <a *hasPermission=\"getLeftActionName(action.actionName)\"\n                            [ngClass]=\"{'disabled': action.isDisabled}\" (click)=\"ActionClickHandler(action)\"\n                            class=\"fontIco\">\n                            <app-icon *ngIf=\"!action.isClass\" [title]=\"getLeftRightActionText(action)\"\n                                [name]=\"action.iconOrClassName\"></app-icon>\n                            <span *ngIf=\"action.isClass\" title=\"{{getLeftRightActionText(action)}}\"\n                                class=\"toolbar-icon {{ action.iconOrClassName }}\"\n                                [ngClass]=\"(action.actionName===actionTypes.UPLOAD && action.isDisabled)? 'icon-inactive': ''\"></span>\n                        </a>\n                    </li>\n                    <li *ngIf=\"action.loading$ | async\">\n                        <mat-spinner class=\"mr-1 action-loader\" [diameter]=\"25\"></mat-spinner>\n                    </li>\n                </ng-container>\n\n            </ul>\n            <ng-container *ngIf=\"gridOptions.leftActionBtnTemplate\">\n                <ng-container *ngTemplateOutlet=\"gridOptions.leftActionBtnTemplate\"></ng-container>\n            </ng-container>\n            <span class=\"toolbar-spacer\"></span>\n\n            <ul class=\"row-actions\">\n\n                <ng-container *ngFor=\"let action of gridOptions.topRightActions\">\n                    <li>\n                        <a (click)=\"ActionClickHandler(action)\" class=\"fontIco\">\n                            <app-icon [title]=\"getLeftRightActionText(action)\" [name]=\"action.icon\"></app-icon>\n                        </a>\n                    </li>\n                </ng-container>\n\n            </ul>\n            <ng-container *ngIf=\"gridOptions.isUpdatedTableDesign\">\n                <ng-container *ngIf=\"gridOptions.newTableButtontemplate\">\n                    <ng-container *ngTemplateOutlet=\"gridOptions.newTableButtontemplate\"></ng-container>\n                </ng-container>\n                <section class=\"search\" *ngIf=\"gridOptions.isSearchBoxVisible\">\n                    <form ngForm>\n                        <div class=\"searchbar-wrapper\">\n                            <i class=\"svg-icon fa-solid fa-magnifying-glass\"></i>\n                            <input matInput type=\"text\" placeholder=\"Search\" name=\"search\" [formControl]=\"searchValue\"\n                                [disabled]=\"isSearchDisabled\" (ngModelChange)=\"searchModelChanged()\" />\n                        </div>\n                    </form>\n                </section>\n                <ng-container *ngIf=\"gridOptions.isFilterEnabled\">\n                    <button mat-stroked-button color=\"primary\" (click)=\"showHideFilterView()\">\n                        <em class=\"fas fa-filter inactive-filter\" [ngClass]=\"{'active-filter': isFilterApplied }\"></em>\n                        Filter\n                    </button>\n                    <button [title]=\"'Clear'\" (click)=\"clearGlobalFilter()\" mat-stroked-button color=\"primary\">\n                        <em class=\"fas fa-broom\"></em>\n                    </button>\n                </ng-container>\n            </ng-container>\n\n            <ul class=\"row-actions\">\n                <li *ngIf=\"!gridOptions.hideColumnConfiguration\">\n                    <a (click)=\"openColumnShowHideDialogue()\" class=\"fontIco\">\n                        <app-icon [title]=\"getTooltipText(toolTips.COLUMN_CONFIGURATION)\" [name]=\"ICONS.ColumnSelector\">\n                        </app-icon>\n                    </a>\n                </li>\n            </ul>\n\n        </div>\n    </section>\n</div>\n\n<mat-card class=\"table-card\" [ngClass]=\"{'transparent-table-design': gridOptions.isTransparentTableDesign}\">\n    <app-loader *ngIf=\"isLoading$ | async\" class=\"loader-middle\"></app-loader>\n\n    <mat-card-content>\n        <div class=\"custom-data-table\" [ngClass]=\"{'default-table-height': isLoading$.getValue(), 'overflow-visible': gridOptions.isAccordionTable }\"\n            (scroll)=\"onTableScrolled($event)\" #customDataTable [ngStyle]=\"getCustomTableStyle\">\n            <table aria-describedby=\"Generic data table\" *ngIf=\"!gridOptions.isAccordionTable\"\n                class=\"table apollo-design-new-data-table\" [ngClass]=\"{ '-tree': isTreeGrid }\" mdbTable>\n                <thead *ngIf=\"!gridOptions.hideTableHeader\" class=\"sticky-header\">\n                    <tr *ngIf=\"gridOptions.isUpdatedTableDesign && isFilterView\" class=\"table-first-header\">\n                        <th *ngIf=\"isRowSelectionEnable\" scope=\"col\"></th>\n                        <ng-container *ngFor=\"let viewColumn of viewColumns\">\n                            <th *ngIf=\"viewColumn.isVisible\" scope=\"col\" class=\"header\"\n                                [ngClass]=\"{'transparent': !viewColumn.isMetaDataColumn && gridOptions.isUpdatedTableDesign}\">\n                                <app-data-col-filter *ngIf=\"isFilterEnable(viewColumn.prop)\" [columnName]=\"viewColumn\"\n                                    [ngClass]=\"{'filteredColumn': isFilteredColumn(viewColumn.prop)}\"\n                                    (onFilterClicked)=\"onFilterClicked($event)\" [filterOption]=\"viewColumn.filterOption\"\n                                    [numberOfTableRefresh]=\"numberOfTableRefresh\" [isUpdatedFilterDesign]=\"true\"\n                                    [isClearFilter$]=\"isClearFilter$\" [filterParam]=\"getFilterParam(viewColumn)\">\n                                </app-data-col-filter>\n                            </th>\n                        </ng-container>\n                    </tr>\n                    <tr class=\"table-second-header\">\n                        <th *ngIf=\"isRowSelectionEnable  && !isSingleSelect\" scope=\"col\" class=\"hasSelection\">\n                            <mat-checkbox class=\"table-header-checkbox\" (change)=\"$event ? masterToggle() : null\"\n                                [formControl]=\"masterSelection\" [checked]=\"selection.hasValue() && isAllSelected()\"\n                                [indeterminate]=\"selection.hasValue() && !isAllSelected()\">\n                            </mat-checkbox>\n                        </th>\n                        <th scope=\"col\" *ngIf=\"isRowSelectionEnable && isSingleSelect\" class=\"hasSelection\"></th>\n                        <ng-container *ngFor=\"let viewColumn of viewColumns; let i = index\">\n                            <th *ngIf=\"viewColumn.isVisible\" scope=\"col\" class=\"header\" [attr.data-column-prop]=\"viewColumn.prop\"\n                                [ngClass]=\"{'transparent': !viewColumn.isMetaDataColumn && gridOptions.isUpdatedTableDesign}\">\n                                <div [ngClass]=\"getHeaderStyle(i, viewColumn)\">\n                                    <app-data-col-filter\n                                        *ngIf=\"isFilterEnable(viewColumn.prop) && !gridOptions.isUpdatedTableDesign\"\n                                        [columnName]=\"viewColumn\"\n                                        [ngClass]=\"{'filteredColumn': isFilteredColumn(viewColumn.prop)}\"\n                                        (onFilterClicked)=\"onFilterClicked($event)\"\n                                        [filterOption]=\"viewColumn.filterOption\"\n                                        [numberOfTableRefresh]=\"numberOfTableRefresh\" [isClearFilter$]=\"isClearFilter$\"\n                                        [filterParam]=\"getFilterParam(viewColumn)\">\n                                    </app-data-col-filter>\n\n                                    <span class=\"header\" [ngClass]=\"{'sort-column': isSortColumn(viewColumn)}\"\n                                        (click)=\"sortTable(viewColumn)\">{{ viewColumn.header }}\n                                        <ng-container *ngIf=\"viewColumn.headerIconClass\">\n                                            <span class=\"header-icon\" [ngClass]=\"viewColumn.headerIconClass\"></span>\n                                        </ng-container>\n                                        <span class=\"sort-icon\"\n                                            *ngIf=\"sortedColumn[viewColumn.prop]=== sortDirectionEnum.DESC\">\n                                            <em class=\"material-icons\">\n                                                arrow_downward\n                                            </em>\n                                        </span>\n                                        <span class=\"sort-icon\"\n                                            *ngIf=\"sortedColumn[viewColumn.prop]=== sortDirectionEnum.ASC\">\n                                            <em class=\"material-icons\">\n                                                arrow_upward\n                                            </em>\n                                        </span>\n                                    </span>\n                                    <ng-container\n                                        *ngIf=\"gridOptions.isUpdatedTableDesign && isFilteredColumn(viewColumn.prop)\">\n                                        <em class=\"fas fa-filter active-filter\"></em>\n                                    </ng-container>\n                                    <div *ngIf=\"gridOptions.draggable\"\n                                        [ngClass]=\"{ 'header-separator': true, 'col-resize-cursor': viewColumn.draggable }\"\n                                        (mousedown)=\"onSeparatorMouseDown($event, i, viewColumn)\"\n                                        (dblclick)=\"onDoubleClickSeparator(i, viewColumn)\">\n                                    </div>\n                                </div>\n                            </th>\n                        </ng-container>\n                        <th *ngIf=\"!(isOnlyView && !isViewActionVisible) && gridOptions.isRowActionVisible\" scope=\"col\">\n                            Actions</th>\n                        <th [ngClass]=\"{'transparent': gridOptions.isUpdatedTableDesign}\"\n                            *ngIf=\"gridOptions.gridMenuOptions && gridOptions.gridMenuOptions.isMenuEnabled\"></th>\n                    </tr>\n                    <ng-container *ngIf=\"gridOptions.hasFixedFirstRow\">\n                        <tr *ngIf=\"!(isLoading$ | async)\">\n                            <th *ngIf=\"isRowSelectionEnable  && !isSingleSelect\" class=\"transparent\"></th>\n                            <th *ngIf=\"isRowSelectionEnable && isSingleSelect\" class=\"transparent\"></th>\n                            <ng-container *ngFor=\"let viewColumn of viewColumns\">\n                                <th class=\"transparent\">\n                                    <ng-container\n                                        *ngTemplateOutlet=\"viewColumn.fixedFirstRowTemplate; context: { $implicit: { col: viewColumn } }\"></ng-container>\n                                </th>\n                            </ng-container>\n                        </tr>\n                    </ng-container>\n                </thead>\n                <tbody *ngIf=\"!isLoading$.getValue()\" app-data-table-body [gridOptions]=\"gridOptions\"\n                    [selection]=\"selection\"\n                    [rows]=\"rows | columnFilter : filterManager.getFilterParams() : columns: gridOptions.isClientSidePagination\"\n                    [viewColumns]=\"viewColumns\" [canInlineEdit]=\"canInlineEdit\" [isTreeGrid]=\"isTreeGrid\"\n                    [isOnlyView]=\"isOnlyView\" [searchedRowCount$]=\"searchedRowCount$\" [onAddClick]=\"onAddClick\"\n                    [isOnlyViewRow]=\"isOnlyViewRow\" [isDeleteDisabled]=\"isDeleteDisabled\" [search]=\"searchValue.value\"\n                    [paginationParams]=\"paginationParams\" [hasEmptyRow]=\"hasEmptyRow\" [isEditing]=\"isEditing\"\n                    [isRowSelectionEnable]=\"isRowSelectionEnable\" [searchColumns]=\"searchColumns\"\n                    [isCloneVisible]=\"isCloneVisible\" (clickEdit)=\"onClickEdit($event)\"\n                    (clickClone)=\"onClickClone($event)\" (clickAction)=\"onClickAction($event)\"\n                    (clickEditCancel)=\"onClickEditCancel($event)\" (clickEditSave)=\"onClickEditSave($event)\"\n                    (clickDelete)=\"onClickDeleteRow($event)\" (clickView)=\"onClickView($event)\"\n                    (clickAdd)=\"onClickRowAdd($event)\" (clickRow)=\"onClickRow($event)\"\n                    (changeExpandCollapse)=\"onChangeExpandCollapse($event)\"\n                    (complexDetailClicked)=\"ComplexDetailClicked($event)\" [isRowUnchecked]=\"isRowUnchecked\"\n                    (CheckboxSelect)=\"isCheckboxSelect($event)\">\n                </tbody>\n\n            </table>\n\n            <ng-container *ngIf=\"gridOptions.isAccordionTable\">\n                <mat-accordion displayMode=\"flat\" multi class=\"mat-table\" *ngIf=\"gridOptions.isAccordionTable\">\n                    <mat-expansion-panel *ngIf=\"!gridOptions.hideTableHeader\" class=\"mask-body header-panel\" hideToggle>\n                        <mat-expansion-panel-header (keydown.Enter)=\"$event.stopImmediatePropagation();\"\n                            [collapsedHeight]=\"'auto'\" [expandedHeight]=\"'auto'\" class=\"mat-row header-row\">\n                            <div class=\"mat-checkboxRow\" *ngIf=\"isRowSelectionEnable  && !isSingleSelect\"\n                                (click)=\"$event.stopPropagation()\">\n                                <mat-checkbox (change)=\"$event ? masterToggle() : null\" [(ngModel)]=\"masterSelection\"\n                                    [checked]=\"selection.hasValue() && isAllSelected()\"\n                                    [indeterminate]=\"selection.hasValue() && !isAllSelected()\">\n                                </mat-checkbox>\n                            </div>\n                            <ng-container *ngFor=\"let viewColumn of viewColumns\">\n                                <div *ngIf=\"viewColumn.isVisible\" scope=\"col\" (click)=\"$event.stopPropagation()\"\n                                    class=\"mat-cell d-inline-block\" [ngClass]=\"viewColumn.customCssClass\">\n                                    <app-data-col-filter class=\"filter-column\" *ngIf=\"isFilterEnable(viewColumn.prop)\"\n                                        [columnName]=\"viewColumn\"\n                                        [ngClass]=\"{'filteredColumn': isFilteredColumn(viewColumn.prop)}\"\n                                        (onFilterClicked)=\"onFilterClicked($event)\"\n                                        [filterOption]=\"viewColumn.filterOption\"\n                                        [numberOfTableRefresh]=\"numberOfTableRefresh\"\n                                        [filterParam]=\"getFilterParam(viewColumn)\">\n                                    </app-data-col-filter>\n                                    &nbsp;\n                                    <span [ngClass]=\"nonFilterClassName(viewColumn.prop)\" class=\"table .header\"\n                                        (click)=\"sortTable(viewColumn)\">{{ viewColumn.header }}\n                                        <span class=\"sort-icon\" *ngIf=\"sortedColumn[viewColumn.prop]=='DownSorted'\">\n                                            <em class=\"material-icons\">\n                                                arrow_downward\n                                            </em>\n                                        </span>\n                                        <span class=\"sort-icon\" *ngIf=\"sortedColumn[viewColumn.prop]=='UpSorted'\">\n                                            <em class=\"material-icons\">\n                                                arrow_upward\n                                            </em>\n                                        </span>\n                                    </span>\n                                </div>\n                            </ng-container>\n                        </mat-expansion-panel-header>\n                    </mat-expansion-panel>\n                    <ng-container>\n                        <div *ngIf=\"!isLoading$.getValue()\" app-data-table-body [gridOptions]=\"gridOptions\"\n                            [selection]=\"selection\"\n                            [rows]=\"rows | columnFilter : filterManager.getFilterParams() : columns: gridOptions.isClientSidePagination\"\n                            [viewColumns]=\"viewColumns\" [canInlineEdit]=\"canInlineEdit\" [isTreeGrid]=\"isTreeGrid\"\n                            [isOnlyView]=\"isOnlyView\" [searchedRowCount$]=\"searchedRowCount$\"\n                            [isOnlyViewRow]=\"isOnlyViewRow\" [isDeleteDisabled]=\"isDeleteDisabled\"\n                            [search]=\"searchValue.value\" [paginationParams]=\"paginationParams\"\n                            [hasEmptyRow]=\"hasEmptyRow\" [isEditing]=\"isEditing\"\n                            [isRowSelectionEnable]=\"isRowSelectionEnable\" [searchColumns]=\"searchColumns\"\n                            [isCloneVisible]=\"isCloneVisible\" (clickEdit)=\"onClickEdit($event)\"\n                            (matExpansionPanelClicked)=\"onExpansionPanelClick($event)\"\n                            (clickClone)=\"onClickClone($event)\" (clickAction)=\"onClickAction($event)\"\n                            (clickEditCancel)=\"onClickEditCancel($event)\" (clickEditSave)=\"onClickEditSave($event)\"\n                            (clickDelete)=\"onClickDeleteRow($event)\" (clickView)=\"onClickView($event)\"\n                            (clickAdd)=\"onClickRowAdd($event)\" (clickRow)=\"onClickRow($event)\"\n                            (changeExpandCollapse)=\"onChangeExpandCollapse($event)\"\n                            (complexDetailClicked)=\"ComplexDetailClicked($event)\"\n                            (CheckboxSelect)=\"isCheckboxSelect($event)\"></div>\n\n                    </ng-container>\n                </mat-accordion>\n            </ng-container>\n        </div>\n        <section *ngIf=\"hasPagination && selection\" class=\"pagination\">\n            <app-data-pagination [selectionCount]=\"selection.selected.length\" class=\"table-pagination-container\" [ngClass]=\"{'transparent-table-design': gridOptions.isTransparentTableDesign}\"  [totalRowCount$]=\"this.searchedRowCount$\"\n                [count]=\"count\" [page]=\"paginationParams.currentPage\" [size]=\"paginationParams.pageSize\" [hasDropdownStylePageSize]=\"gridOptions.hasDropdownStylePageSize ?? true\"\n                (changePage)=\"onChangePage($event)\">\n            </app-data-pagination>\n        </section>\n    </mat-card-content>\n</mat-card>"]}