mat-table-ext 0.0.0 → 0.0.2

package/esm2020/lib/mat-table-ext.component.mjs

@@ -0,0 +1,1021 @@
+import { animate, state, style, transition, trigger, } from '@angular/animations';
+import { SelectionModel } from '@angular/cdk/collections';
+import { moveItemInArray } from '@angular/cdk/drag-drop';
+import { EventEmitter, Output, } from '@angular/core';
+import { Component, Input, ViewChild, ViewEncapsulation, } from '@angular/core';
+import { MatDialogConfig } from '@angular/material/dialog';
+import { MatMenuTrigger } from '@angular/material/menu';
+import { MatPaginator } from '@angular/material/paginator';
+import { MatSort } from '@angular/material/sort';
+import { MatTableDataSource } from '@angular/material/table';
+import { EditingComponent } from '../lib/components/editing/editing.component';
+import * as XLSX from 'xlsx';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "../lib/mat-table-ext.service";
+import * as i3 from "@angular/forms";
+import * as i4 from "@angular/platform-browser";
+import * as i5 from "@angular/material/icon";
+import * as i6 from "@angular/common";
+import * as i7 from "@angular/material/table";
+import * as i8 from "@angular/cdk/drag-drop";
+import * as i9 from "@angular/material/core";
+import * as i10 from "@angular/material/button";
+import * as i11 from "@angular/material/card";
+import * as i12 from "@angular/material/checkbox";
+import * as i13 from "@angular/material/form-field";
+import * as i14 from "@angular/material/input";
+import * as i15 from "@angular/material/menu";
+import * as i16 from "@angular/material/paginator";
+import * as i17 from "@angular/material/progress-bar";
+import * as i18 from "@angular/material/select";
+import * as i19 from "@angular/material/sort";
+import * as i20 from "@angular/material/toolbar";
+import * as i21 from "@angular/material/tooltip";
+import * as i22 from "./directives/resize-column.directive";
+import * as i23 from "./components/column-pinning/column-pinning.component";
+import * as i24 from "./components/filter-columns-component/filter-columns-component.component";
+export class MatTableExtComponent {
+    constructor(dialog, service, formBuildersService, domSanitizer, matIconRegistry, cdr) {
+        this.dialog = dialog;
+        this.service = service;
+        this.formBuildersService = formBuildersService;
+        this.domSanitizer = domSanitizer;
+        this.matIconRegistry = matIconRegistry;
+        this.cdr = cdr;
+        this.columns = [];
+        this.columnResizable = false;
+        this.stripedRows = false;
+        this.rowHover = false;
+        this.inlineRowEditing = false;
+        this.inCellEditing = false;
+        this.popupRowEditing = false;
+        this.enableDelete = false;
+        this.rowSelection = false;
+        this.multiRowSelection = false;
+        this.stickyFooter = false;
+        this.stickyHeader = false;
+        this.showFooterRow = false;
+        this.columnFilter = false;
+        this.loadingIndicator = false;
+        this.sorting = false;
+        this.showToolbar = false;
+        this.toolbarTitle = '';
+        this.tableHeight = '';
+        this.toolbarHeight = '50px';
+        this.tableWidth = '100%';
+        this.scrollbarH = false;
+        this.columnHidable = false;
+        this.columnPinnable = false;
+        this.globalSearch = false;
+        this.expandRows = false;
+        this.dndColumns = false;
+        this.showPaginator = true;
+        this.showFirstLastButtons = false;
+        this.exportButtonEnable = false;
+        this.pageSizeOptions = [10, 50, 100];
+        this.cellTemplateRefMap = {};
+        // Table outputs
+        this.inlineChange = new EventEmitter();
+        this.cellChange = new EventEmitter();
+        this.popupChange = new EventEmitter();
+        this.rowDeleted = new EventEmitter();
+        this.scroll = new EventEmitter();
+        this.selectionChanged = new EventEmitter();
+        this.expansionChange = new EventEmitter();
+        this.tableID = new Date().getTime();
+        this.columnPinningOptions = [];
+        this.exportMenuCtrl = false;
+        this.columnPinMenuCtrl = false;
+        this.hideShowMenuCtrl = false;
+        this.columnFilterBySelection = false;
+        this.rowDataTemp = {};
+        this.inlineEditingTemplateRefData = {};
+        this.displayedColumns = [];
+        this.showHideColumnsArray = [];
+        this.columnsList = [];
+        this.columnsArray = [];
+        this.headersFiltersIds = [];
+        this.columnsToDisplayWithExpand = [];
+        this.selection = new SelectionModel(false, []);
+        this.hiddenCtrl = new SelectionModel(true, []);
+        this.tableData = [];
+        this.filterValues = {};
+        this.globalFilter = '';
+        this.showHideFilter = '';
+        this.individualFilter = '';
+        this.toggleFilters = false;
+        this.hideRows = false;
+        this.currentRowIndex = -1;
+        this.currentRow = {};
+        this.cellEditing = {};
+        this.menuX = 0;
+        this.menuY = 0;
+        this.dynamicDisplayedColumns = [
+            { filter: false, name: 'select', show: false },
+            { filter: false, name: 'edit', show: false },
+            { filter: false, name: 'popup', show: false },
+            { filter: false, name: 'delete', show: false },
+            { filter: false, name: 'expand', show: false },
+        ];
+        this.inputPropertyKeys = [
+            'dataSource',
+            'columns',
+            'inlineRowEditing',
+            'popupRowEditing',
+            'enableDelete',
+            'rowSelection',
+            'multiRowSelection',
+            'stickyHeader',
+            'stickyFooter',
+            'columnFilter',
+            'globalSearch',
+            'expandRows',
+            'sorting',
+        ];
+        /**
+         * @description This mapping is used to set and update changesin the table.
+         */
+        this.setPropertiesMap = {
+            dataSource: (value) => this.setTableDataSource(value),
+            columns: (value) => this.setColumnsData(value.currentValue),
+            inlineRowEditing: (value) => this.showHideColumn('edit', value.currentValue),
+            popupRowEditing: (value) => this.showHideColumn('popup', value.currentValue),
+            enableDelete: (value) => this.showHideColumn('delete', value.currentValue),
+            rowSelection: (value) => this.setRowSelection(value.currentValue),
+            multiRowSelection: (value) => {
+                this.selection = new SelectionModel(value.currentValue, []);
+            },
+            stickyHeader: (value) => {
+                this.stickyHeader = value.currentValue;
+            },
+            stickyFooter: (value) => {
+                this.stickyFooter = value.currentValue;
+            },
+            columnFilter: (value) => this.setColumnFilter(value.currentValue),
+            globalSearch: (value) => (this.dataSource.filterPredicate = this.createFilter()),
+            expandRows: (value) => {
+                this.loadingIndicator = true;
+                this.dataSource = new MatTableDataSource(this.tableData);
+                if (value.currentValue == true) {
+                    if (!this.displayedColumns.includes('expand')) {
+                        this.displayedColumns.push('expand');
+                        this.columnsToDisplayWithExpand = [...this.displayedColumns];
+                    }
+                }
+                else {
+                    this.columnsToDisplayWithExpand = [...this.displayedColumns];
+                    if (this.displayedColumns.includes('expand')) {
+                        let index = this.displayedColumns.indexOf('expand');
+                        this.displayedColumns.splice(index, 1);
+                    }
+                    this.expandedElement = null;
+                }
+                setTimeout(() => {
+                    this.loadingIndicator = false;
+                }, 200);
+            },
+            sorting: (value) => (this.dataSource.sort = this.sort),
+        };
+        /**
+         * @description This method will take data from inline editing template and update in table data source.
+         * @param row updated row from inline editing template.
+         */
+        this.updateInlineTemplateData = (row) => {
+            this.service.selectedRow.next(row);
+        };
+        this.addIconsToRegistry();
+        if (this.dataSource) {
+            this.tableData = this.dataSource.data;
+        }
+    }
+    /**
+     *
+     * @param changes changes captured each time user changes property value.
+     */
+    ngOnChanges(changes) {
+        this.setPropertyValue(changes);
+    }
+    ngOnInit() {
+        if (this.dataSource) {
+            this.dataSource.filterPredicate = this.createFilter();
+        }
+    }
+    ngAfterViewInit() {
+        if (this.dataSource) {
+            this.dataSource.paginator = this.paginator;
+            this.dataSource.sort = this.sort;
+        }
+    }
+    /**
+     * @description checks and updates the the column's hide and show properties.
+     */
+    setColumnHideShow() {
+        if (this.hideShowMenuGroup !== undefined &&
+            this.hideShowMenuGroup !== null) {
+            this.updateColumnsHideShow(this.hideShowMenuGroup.value);
+        }
+    }
+    /**
+     * @description set the properties of the table.
+     * @param changes changes captured each time user changes property value.
+     */
+    setPropertyValue(changes) {
+        let keys = Object.keys(changes);
+        keys.forEach((property) => {
+            if (this.inputPropertyKeys.includes(property)) {
+                this.setPropertiesMap[property](changes[property]);
+            }
+            else if (property == 'showToolbar') {
+                if (changes['columns']) {
+                    this.setToolbarMenuControls(changes['columns'].currentValue);
+                }
+                else {
+                    this.setToolbarMenuControls(this.columnsArray);
+                }
+            }
+        });
+    }
+    /**
+     * @description used set data source for table.
+     * @param value data source value from user.
+     */
+    setTableDataSource(value) {
+        if (value.currentValue) {
+            this.tableData = value.currentValue.data;
+            this.dataSource = value.currentValue;
+            this.reCal();
+        }
+        else {
+            this.dataSource = new MatTableDataSource([{}]);
+        }
+    }
+    /**
+     * @description used create seletion model and set selection column visibility.
+     * @param value boolean value to show or hide selection Column from table.
+     */
+    setRowSelection(value) {
+        this.selection = new SelectionModel(true, []);
+        this.updateSelectionColumnVisibility(value);
+    }
+    /**
+     * @description create filter header row and assigns filter predicate to table data source.
+     * @param value boolean value to change  visibility of column filter row.
+     */
+    setColumnFilter(value) {
+        if (value) {
+            let array = [];
+            this.columnsArray.forEach((column, i) => {
+                if (this.dynamicDisplayedColumns.filter((a) => a.name == column?.field)[0]
+                    .show) {
+                    array.push(column?.field + '_' + i);
+                }
+            });
+            this.headersFiltersIds = array;
+            this.dataSource.filterPredicate = this.createFilter();
+        }
+        else {
+            this.headersFiltersIds = [];
+            this.dataSource.filter = '';
+        }
+        this.toggleFilters = value;
+    }
+    /**
+     * @description This method returns the list of visible column names.
+     * @returns list of visible column names.
+     */
+    getDisplayedColumns() {
+        let list = this.dynamicDisplayedColumns
+            .filter((cd) => cd.show)
+            .map((cd) => cd.name);
+        return list;
+    }
+    /**
+     * @param menuType type of menu to open from toolbar.
+     * @param event mouse event to open menu on that location.
+     */
+    openMenu(menuType, event) {
+        this.menuX = event.clientX;
+        this.menuY = event.clientY;
+        switch (menuType) {
+            case 'export': {
+                this.exportMenuCtrl = true;
+                this.menuTrigger.openMenu();
+                break;
+            }
+            case 'hideShow': {
+                this.hideShowMenuCtrl = true;
+                this.openHideShowMenu(this.columnsArray);
+                break;
+            }
+            case 'columnPin': {
+                this.columnPinMenuCtrl = true;
+                this.openHideShowMenu(this.columnsArray);
+                break;
+            }
+        }
+    }
+    /**
+     * @description triggers when menu is closed and reset the required controls.
+     */
+    menuClosed() {
+        this.exportMenuCtrl = false;
+    }
+    /**
+     * @description set list of columns to display in table.
+     * @param columns columns array from user input.
+     */
+    setColumnsData(columns) {
+        if (columns.length) {
+            this.columnsArray = [...columns];
+            this.setColumnsList(columns);
+        }
+    }
+    /**
+     * @description set list of columns to display in table.
+     * @param columns columns array from user input with configurations.
+     */
+    setColumnsList(columns) {
+        this.columnsList = [];
+        this.displayedColumns = ['select', 'edit', 'popup', 'delete'];
+        let columnsArray = [];
+        columns.forEach((col) => {
+            if (typeof col?.header == 'string') {
+                this.columnsList.push(col?.header);
+                this.displayedColumns.push(col?.field);
+                columnsArray.push({ filter: true, name: col?.field, show: !col.hide });
+            }
+        });
+        this.dynamicDisplayedColumns = [
+            { filter: false, name: 'select', show: false },
+            { filter: false, name: 'edit', show: false },
+            { filter: false, name: 'popup', show: false },
+            { filter: false, name: 'delete', show: false },
+        ];
+        this.dynamicDisplayedColumns = columnsArray.concat(this.dynamicDisplayedColumns);
+    }
+    /**
+     * @description Take boolean value and name column and update its visibility status in table.
+     * @param name name of the column to set visibility.
+     * @param value boolean value to set visibility of the column.
+     */
+    showHideColumn(name, value) {
+        this.dynamicDisplayedColumns.filter((a) => a.name == name)[0].show = value;
+        if (this.columnFilter) {
+            this.setColumnFilter(true);
+        }
+    }
+    /**
+     * @description This method will position the selection column to first and also update its visibility.
+     * @param value value used to set visibility of the selection column.
+     */
+    updateSelectionColumnVisibility(value) {
+        let columnName = 'select';
+        let column = this.dynamicDisplayedColumns.filter((a) => a.name == columnName)[0];
+        let index = this.dynamicDisplayedColumns.findIndex((column) => column.name == columnName);
+        if (index > -1) {
+            this.dynamicDisplayedColumns.splice(index, 1);
+            this.dynamicDisplayedColumns.unshift(column);
+            this.dynamicDisplayedColumns.filter((column) => column.name == columnName)[0].show = value;
+        }
+    }
+    /**
+     * @description This method is used to update the position of  column in columns array according to its dropped position.
+     * @param event CdkDragDrop used to update column position in columns array.
+     */
+    onDrop(event) {
+        if (this.dndColumns) {
+            let adjustedValue = 0;
+            if (this.dynamicDisplayedColumns[0].name == 'select' &&
+                this.dynamicDisplayedColumns[0].show == false) {
+                adjustedValue = 1;
+            }
+            moveItemInArray(this.dynamicDisplayedColumns, event.previousIndex + adjustedValue, event.currentIndex + adjustedValue);
+        }
+    }
+    /**
+     * @description This methohd create filter predicate function which will set search value to table filters
+     * for both global and individual colum filtering.
+     * @returns returns boolean value to filter rows in table.
+     */
+    createFilter() {
+        const tableFilterPredicate = (data, filter) => {
+            let result = true;
+            // search all column fields
+            if (this.globalFilter) {
+                let expression = '';
+                let keys = Object.keys(data);
+                keys.forEach((key) => {
+                    expression =
+                        expression +
+                            `data.${key}.toString().trim().toLowerCase().indexOf(this.globalFilter.toLowerCase()) !== -1 ||`;
+                });
+                if (expression.charAt(expression.length - 2) +
+                    expression.charAt(expression.length - 1) ==
+                    '||') {
+                    expression = expression.substring(0, expression.length - 2);
+                }
+                result = eval(expression);
+            }
+            if (!result) {
+                return false;
+            }
+            let searchString = JSON.parse(filter);
+            //search single column field
+            if (this.individualFilter) {
+                return (data[this.individualFilter]
+                    .toString()
+                    .trim()
+                    .toLowerCase()
+                    .indexOf(searchString[this.individualFilter].toString().toLowerCase()) !== -1);
+            }
+            return true;
+        };
+        return tableFilterPredicate;
+    }
+    /**
+     * @description assigns the search value to mat table data source to apply the filter.
+     * @param searchValue value to be searched from table rows.
+     */
+    applyGlobalFilter(searchValue) {
+        this.globalFilter = searchValue;
+        let columns = {};
+        this.columnsArray.forEach((column) => {
+            if (column.field)
+                columns[column.field] = searchValue;
+        });
+        this.dataSource.filter = JSON.stringify(columns);
+    }
+    /**
+     * @description This method is used to apply column based filtering
+     * @param searchValue value to be searched from table rows.
+     * @param column filter will be applied based on this column field.
+     */
+    applyColumnFilter(searchValue, column) {
+        this.individualFilter = column.field;
+        this.filterValues[column.field] = searchValue[column.field];
+        this.dataSource.filter = JSON.stringify(this.filterValues);
+    }
+    /**
+     * @description This method will take row and its index enable inline editing tools on that row.
+     * @param row row on which user wants to do edit.
+     * @param index index of the row where inline editing will be enabled.
+     */
+    enableInlineEditing(row, index) {
+        const rowData = {};
+        rowData['e' + index] = { ...row };
+        this.rowDataTemp = rowData;
+        setTimeout(() => {
+            this.tableData[index]['editable'] = !this.tableData[index]['editable'];
+        }, 0);
+    }
+    /**
+     * @description This method will create and return data to inline editing template.
+     * @param row row on which user wants to do edit.
+     * @param index index of the row where inline editing will be enabled.
+     * @param column current column of the table.
+     */
+    getInlineEditingData(row, index, column) {
+        this.inlineEditingTemplateRefData = {
+            row: { ...row },
+            column: { ...column },
+            index: index,
+            updateFunc: this.updateInlineTemplateData,
+        };
+        return this.inlineEditingTemplateRefData;
+    }
+    /**
+     * @description This method set data for in-cell editing.
+     * @param row row on which user wants to do edit.
+     * @param index index of the row where inline editing will be enabled.
+     */
+    setCellData(row, index) {
+        this.currentRow = { ...row };
+        this.currentRowIndex = index;
+        this.rowDataTemp['e' + index] = { ...row };
+    }
+    /**
+     * @description This will restore the data and cencel the inline editing.
+     * @param row row on which user wants to do edit.
+     * @param index index of the row where inline editing will be enabled.
+     */
+    cancelInlineEditing(row, index) {
+        this.tableData.filter((a, i) => i == index)[0]['editable'] =
+            !this.tableData.filter((a, i) => i == index)[0]['editable'];
+        this.dataSource = new MatTableDataSource(this.tableData);
+        this.rowDataTemp['e' + index] = {};
+        this.service.selectedRow.next(undefined);
+    }
+    /**
+     * @description This method will save and update the inline editing data and emit the update row and index.
+     * @param row row on which user wants to do edit.
+     * @param index index of the row where inline editing will be enabled.
+     */
+    saveInlineEditing(row, index) {
+        if (!this.inlineEditingTemplateRef) {
+            this.tableData[index] = { ...this.rowDataTemp['e' + index] };
+            row = { ...this.rowDataTemp['e' + index] };
+        }
+        else {
+            let changedData = this.service.selectedRow.value;
+            if (changedData) {
+                this.tableData[index] = { ...changedData };
+            }
+        }
+        this.dataSource = new MatTableDataSource(this.tableData);
+        this.rowDataTemp['e' + index] = {};
+        let data = {
+            row: row,
+            index: index,
+        };
+        this.inlineChange.emit(data);
+        this.tableData[index]['editable'] = false;
+    }
+    /**
+     * @description This method will save and update the cell editing data and emit the update row and index.
+     */
+    saveCellEditing() {
+        this.cellEditing = {};
+        let index = this.currentRowIndex;
+        if (index > -1) {
+            if (this.cellEditingTemplateRef) {
+                let changedData = this.service.selectedRow.value;
+                if (changedData) {
+                    this.tableData[index] = { ...changedData };
+                }
+            }
+            else {
+                this.tableData[index] = { ...this.rowDataTemp['e' + index] };
+            }
+            this.dataSource = new MatTableDataSource(this.tableData);
+            this.rowDataTemp['e' + index] = {};
+            let data = {
+                row: { ...this.tableData[index] },
+                index: index,
+            };
+            this.currentRowIndex = -1;
+            this.cellChange.emit(data);
+        }
+    }
+    /**
+     * @description This method will delete the row from the given index and emit the deleted row and index.
+     * @param row row to be deleted.
+     * @param index index of the row to be deleted.
+     */
+    deleteRow(row, index) {
+        this.tableData.splice(index, 1);
+        this.dataSource = new MatTableDataSource(this.tableData);
+        this.dataSource.paginator = this.paginator;
+        this.dataSource.sort = this.sort;
+        this.rowDeleted.emit({ removedRow: row, fromIndex: index });
+    }
+    /**
+     * @description This method will expand or collapse the row and emit expand event.
+     * @param row row to be expanded or collapsed.
+     * @param expand value used to expand or collapse the row.
+     * @param index index of the row.
+     */
+    expandRow(row, expand, index) {
+        if (this.expandRows) {
+            this.expansionChange.emit({ data: row, expanded: expand, index: index });
+            this.expandedElement = this.expandedElement === row ? null : row;
+        }
+    }
+    /**
+     * @description This method is used to set data for popup component and open editing dialog.
+     * @param row row which used want to edit.
+     */
+    openEditingDialog(row) {
+        const dialogConfig = new MatDialogConfig();
+        dialogConfig.disableClose = true;
+        dialogConfig.width = '40%';
+        dialogConfig.height = '70%';
+        dialogConfig.maxWidth = '100%';
+        let rowData = { ...row };
+        dialogConfig.data = {
+            row: rowData,
+            columns: [...this.columnsArray],
+            templateRef: this.popupEditingTemplateRef,
+        };
+        this.dialog
+            .open(EditingComponent, dialogConfig)
+            .afterClosed()
+            .subscribe((data) => {
+            let index = this.tableData.indexOf(row);
+            if (data && index > -1) {
+                this.tableData[index] = data;
+                this.dataSource = new MatTableDataSource(this.tableData);
+                let dataChange = {
+                    row: data,
+                    index: index,
+                };
+                this.popupChange.emit(dataChange);
+            }
+        });
+    }
+    /**
+     * @description used to check whether all rows are selected.
+     */
+    isAllSelected() {
+        const numSelected = this.selection.selected.length;
+        const numRows = this.dataSource.data.length;
+        return numSelected === numRows;
+    }
+    /**
+     * @description this method is used to toggle the all and no rows selection.
+     */
+    toggleAllRows() {
+        if (this.isAllSelected()) {
+            this.selection.clear();
+            return;
+        }
+        this.selection.select(...this.dataSource.data);
+    }
+    /**
+     * @description This method is used return aria-label for selection column checkboxs.
+     * @param row row from table.
+     * @returns labels for selection column checkboxs.
+     */
+    checkboxLabel(row) {
+        if (!row) {
+            return `${this.isAllSelected() ? 'deselect' : 'select'} all`;
+        }
+        return `${this.selection.isSelected(row) ? 'deselect' : 'select'} row ${row.position + 1}`;
+    }
+    /**
+     * @description create form control for columns for hiding and and pinning purpose
+     * @param columns list of columns to be displayed
+     */
+    setToolbarMenuControls(columns) {
+        if (columns.length > 0 && this.showToolbar) {
+            const group = this.formBuildersService.group({});
+            columns.forEach((column) => {
+                const control = this.formBuildersService.control(true);
+                group.addControl(column.field, control);
+            });
+            this.hideShowMenuGroup = group;
+        }
+    }
+    /**
+     * @param column current column
+     * @param event mouse event used to set the menu position
+     */
+    openPinnablePropertyMenu(column, event) {
+        this.menuX = event.clientX;
+        this.menuY = event.clientY;
+        let options = [
+            {
+                label: 'Pin Left',
+                value: 'left',
+                selected: false,
+                field: column.field,
+            },
+            {
+                label: 'Pin Right',
+                value: 'right',
+                selected: false,
+                field: column.field,
+            },
+            { label: 'No Pin', value: null, selected: false, field: column.field },
+        ];
+        if (column.pinned && column.pinned !== null) {
+            options.forEach((opt) => {
+                if (opt.value === column.pinned) {
+                    opt.selected = true;
+                }
+            });
+        }
+        else if (column.pinned == null || column.pinned == 'null') {
+            options[2].selected = true;
+        }
+        this.columnPinningOptions = options;
+        this.columnMenuTrigger.openMenu();
+    }
+    /**
+     * @description This method is used to reset menu checks when required.
+     */
+    resetMenuChecks() {
+        this.hideShowMenuCtrl = false;
+        this.showHideColumnsArray = [];
+        this.columnPinMenuCtrl = false;
+        this.columnPinningOptions = [];
+    }
+    /**
+     * @description This method is used to filter columns for menus like pinning or hide show menu.
+     * @param value search value to filter colunms
+     */
+    filterColumns(value) {
+        if (value !== '') {
+            this.showHideColumnsArray = this.columnsArray.filter((col) => {
+                return col.header.toLowerCase().includes(value.toLowerCase());
+            });
+        }
+        else {
+            this.showHideColumnsArray = this.columnsArray;
+        }
+    }
+    /**
+     * @description This method is used to open hide show column menu.
+     * @param columns columns array to display in hide show menu.
+     */
+    openHideShowMenu(columns) {
+        this.showHideColumnsArray = [...columns];
+        this.columnMenuTrigger.openMenu();
+    }
+    /**
+     * @param values columns
+     */
+    updateColumnsHideShow(values) {
+        let keys = Object.keys(values);
+        keys.forEach((key) => {
+            this.showHideColumn(key, values[key]);
+        });
+    }
+    /**
+     * @description This method is called when the table rows are scrolled.
+     * @param event scroll event
+     */
+    onScroll(event) {
+        this.scroll.emit(event);
+    }
+    /**
+     * @param row row to be toggled
+     * @param index index of toggled row
+     */
+    setSelectedRows(row, index) {
+        this.selection.toggle(row);
+        if (this.selection.isSelected(row)) {
+            this.selectionChanged.emit({ row: row, index: index, isSelected: true });
+        }
+        else {
+            this.selectionChanged.emit({ row: row, index: index, isSelected: false });
+        }
+    }
+    /**
+     * @description This method is used to display all hidden rows.
+     */
+    showHiddenRows() {
+        this.hideRows = false;
+        this.selection.clear();
+        this.hiddenCtrl.clear();
+    }
+    /**
+     * @description This method is used to hide all selected rows.
+     */
+    hideSelectedRows() {
+        if (!this.selection.isEmpty()) {
+            let values = [...this.selection.selected];
+            values.forEach((value) => {
+                if (!this.hiddenCtrl.isSelected(value)) {
+                    this.hiddenCtrl.toggle(value);
+                }
+            });
+            this.selection.clear();
+            this.hideRows = true;
+        }
+    }
+    /**
+     * @description This method is used to recalculate the required values for table.
+     */
+    reCal() {
+        if (this.showPaginator) {
+            this.dataSource.paginator = this.paginator;
+        }
+        if (this.sorting) {
+            this.dataSource.sort = this.sort;
+        }
+        if (this.columnFilter) {
+            this.dataSource.filterPredicate = this.createFilter();
+        }
+    }
+    /**
+     * @description This method is called in constructor method to add SVGs into icon registration.
+     */
+    addIconsToRegistry() {
+        let y = this.domSanitizer.bypassSecurityTrustResourceUrl(`assets/pinRight.svg`);
+        let iconNames = ['pinLeft', 'pinRight', 'pinNone', 'pinned', 'pinIcon'];
+        iconNames.forEach((icon) => {
+            this.matIconRegistry.addSvgIcon(icon, this.domSanitizer.bypassSecurityTrustResourceUrl(`assets/${icon}.svg`));
+        });
+    }
+    /**
+     * @description This method is used to export table data.
+     * @param type type of file to be exported.
+     */
+    exportTable(type) {
+        var element = document.getElementById('matTableExt' + this.tableID);
+        var ws = XLSX.utils.table_to_sheet(element);
+        ws = this.writeSheetData(ws);
+        const wb = XLSX.utils.book_new();
+        XLSX.utils.book_append_sheet(wb, ws, 'Sheet1');
+        XLSX.writeFile(wb, `tablesheets.${type}`);
+    }
+    /**
+     * @description This method is used to split name of filter row header to get index.
+     * @param value value to be splited for index.
+     * @returns Will return index of column from value.
+     */
+    returnIndex(value) {
+        return Number(value.split('_')[1]);
+    }
+    /**
+     * @description This method is used to manage column filtering, expanded data for exporting.
+     * @param ws work sheet
+     * @returns custom generated worksheet to be used in export.
+     */
+    writeSheetData(ws) {
+        let displayedColumns = this.getDisplayedColumns();
+        var nMerges = this.getMergeIndex(ws['!merges'] || []);
+        var merges = ws['!merges'] || [];
+        let data = {
+            '!cols': [],
+            '!rows': [],
+            '!merges': nMerges,
+        };
+        var range = XLSX.utils.decode_range(ws['!ref'] || '');
+        let extracolumns = ['popup', 'delete', 'select', 'edit'];
+        let keys = Object.keys(ws);
+        let nKey = 'A';
+        keys.forEach((key, i) => {
+            if (ws[key]?.v && typeof ws[key]?.v === 'string') {
+                if (!extracolumns.includes(ws[key].v.toLowerCase()) &&
+                    displayedColumns.includes(ws[key].v.toLowerCase())) {
+                    let lastRowIndex = range?.e?.r;
+                    data[key] = ws[key];
+                    let chr = key.charAt(0);
+                    for (let j = 2; j <= lastRowIndex; j++) {
+                        if (ws[chr + (j + 1)] !== undefined &&
+                            (typeof ws[chr + (j + 1)].v === 'string' ||
+                                typeof ws[chr + (j + 1)].v === 'number')) {
+                            data[nKey + j] = ws[chr + (j + 1)];
+                        }
+                    }
+                    nKey = String.fromCharCode(nKey.charCodeAt(0) + 1);
+                }
+            }
+        });
+        if (this.rowSelection) {
+            let chr = 'A';
+            for (let i = 1; i < range.e.c + 1; i++) {
+                data[chr + 1] = data[String.fromCharCode(chr.charCodeAt(0) + 1) + 1];
+                chr = String.fromCharCode(chr.charCodeAt(0) + 1);
+                if (i == range.e.c) {
+                    data[chr + 1] = undefined;
+                }
+            }
+        }
+        if (this.rowSelection && this.expandRows) {
+            merges.forEach((merge) => {
+                data['A' + merge.s.r] = ws['A' + (merge.s.r + 1)];
+            });
+        }
+        range.e.r--;
+        let nRef = XLSX.utils.encode_range(range);
+        data['!ref'] = nRef;
+        data['!fullref'] = nRef;
+        return data;
+    }
+    getMergeIndex(merges) {
+        var arr = [];
+        merges.forEach((element) => {
+            arr.push({
+                e: {
+                    r: element.e.r == 0 ? element.e.r : element.e.r - 1,
+                    c: element.e.c,
+                },
+                s: {
+                    r: element.s.r == 0 ? element.s.r : element.s.r - 1,
+                    c: element.s.c,
+                },
+            });
+        });
+        return arr;
+    }
+}
+MatTableExtComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: MatTableExtComponent, deps: [{ token: i1.MatDialog }, { token: i2.MatTableExtService }, { token: i3.FormBuilder }, { token: i4.DomSanitizer }, { token: i5.MatIconRegistry }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+MatTableExtComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: MatTableExtComponent, selector: "mat-table-ext", inputs: { dataSource: "dataSource", columns: "columns", columnResizable: "columnResizable", stripedRows: "stripedRows", rowHover: "rowHover", inlineRowEditing: "inlineRowEditing", inCellEditing: "inCellEditing", popupRowEditing: "popupRowEditing", enableDelete: "enableDelete", rowSelection: "rowSelection", multiRowSelection: "multiRowSelection", stickyFooter: "stickyFooter", stickyHeader: "stickyHeader", showFooterRow: "showFooterRow", columnFilter: "columnFilter", loadingIndicator: "loadingIndicator", sorting: "sorting", showToolbar: "showToolbar", toolbarTitle: "toolbarTitle", tableHeight: "tableHeight", toolbarHeight: "toolbarHeight", tableWidth: "tableWidth", scrollbarH: "scrollbarH", toolbarTemplate: "toolbarTemplate", columnHidable: "columnHidable", columnPinnable: "columnPinnable", globalSearch: "globalSearch", expandRows: "expandRows", dndColumns: "dndColumns", showPaginator: "showPaginator", showFirstLastButtons: "showFirstLastButtons", exportButtonEnable: "exportButtonEnable", pageSizeOptions: "pageSizeOptions", toolbarTemplateRef: "toolbarTemplateRef", headerTemplateRef: "headerTemplateRef", cellTemplateRef: "cellTemplateRef", expansionTemplateRef: "expansionTemplateRef", popupEditingTemplateRef: "popupEditingTemplateRef", inlineEditingTemplateRef: "inlineEditingTemplateRef", cellEditingTemplateRef: "cellEditingTemplateRef", cellTemplateRefMap: "cellTemplateRefMap" }, outputs: { inlineChange: "inlineChange", cellChange: "cellChange", popupChange: "popupChange", rowDeleted: "rowDeleted", scroll: "scroll", selectionChanged: "selectionChanged", expansionChange: "expansionChange" }, viewQueries: [{ propertyName: "menuTrigger", first: true, predicate: MatMenuTrigger, descendants: true }, { propertyName: "columnMenuTrigger", first: true, predicate: ["columnMenuTrigger"], descendants: true }, { propertyName: "paginator", first: true, predicate: MatPaginator, descendants: true }, { propertyName: "sort", first: true, predicate: MatSort, descendants: true }], usesOnChanges: true, ngImport: i0, template: "<mat-card class=\"main-table-ext-container mat-elevation-z8\" [style.width]=\"tableWidth\">\r\n    <mat-form-field class=\"global-search-field\" appearance=\"fill\" *ngIf=\"globalSearch\">\r\n        <mat-label>Search</mat-label>\r\n        <input matInput [ngModel]=\"globalFilter\" (ngModelChange)=\"applyGlobalFilter($event)\" placeholder=\"Ex. Mia\" #input>\r\n    </mat-form-field>\r\n    <mat-toolbar class=\"toolbar-container\" *ngIf=\"showToolbar\" [style.height]=\"toolbarHeight?toolbarHeight:'50px'\">\r\n        <span class=\"toolbar-title\" *ngIf=\"toolbarTitle\">{{toolbarTitle}}</span>\r\n        <ng-container *ngIf=\"toolbarTemplateRef\" [ngTemplateOutlet]=\"toolbarTemplateRef\"></ng-container>\r\n        <span class=\"example-spacer\"></span>\r\n        <ng-container *ngIf=\"rowSelection || multiRowSelection\">\r\n            <button class=\"hide-button\" mat-stroked-button color=\"primary\" (click)=\"hideSelectedRows()\">\r\n                Hide Rows\r\n            </button>\r\n            <button class=\"hide-button\" mat-stroked-button color=\"primary\" (click)=\"showHiddenRows()\">\r\n                Show All Rows\r\n            </button>\r\n        </ng-container>\r\n        <button *ngIf=\"columnHidable\" class=\"hide-button\" mat-stroked-button color=\"primary\"\r\n            (click)=\"openMenu('hideShow',$event)\" matTooltip=\"Column Visibility\" matTooltipPosition=\"above\">\r\n            <mat-icon>visibility</mat-icon>\r\n        </button>\r\n        <button *ngIf=\"columnPinnable\" class=\"pin-button\" mat-stroked-button color=\"primary\"\r\n            (click)=\"openMenu('columnPin',$event)\" matTooltip=\"Column Pinning\">\r\n            <mat-icon svgIcon=\"pinIcon\"></mat-icon>\r\n        </button>\r\n        <button *ngIf=\"exportButtonEnable\" class=\"export-button\" mat-stroked-button color=\"primary\"\r\n            (click)=\"openMenu('export',$event)\" matTooltip=\"Table Data Export\">\r\n            <mat-icon>import_export</mat-icon> <span>Export</span>\r\n            <mat-icon>expand_more</mat-icon>\r\n        </button>\r\n        <div style=\"visibility: hidden; position:fixed\" [matMenuTriggerFor]=\"menu\" [style.left.px]=\"menuX\"\r\n            [style.top.px]=\"menuY\"></div>\r\n    </mat-toolbar>\r\n    <mat-menu #menu=\"matMenu\" (closed)=\"menuClosed()\" id=\"exportMenu\">\r\n        <ng-container *ngIf=\"exportMenuCtrl\">\r\n            <mat-option (click)=\"exportTable('xlsx')\">Export to Excel</mat-option>\r\n            <mat-option (click)=\"exportTable('csv')\">Export to CSV</mat-option>\r\n        </ng-container>\r\n    </mat-menu>\r\n    <div style=\"visibility: hidden; position:fixed\" #columnMenuTrigger=\"matMenuTrigger\" [matMenuTriggerFor]=\"columnMenu\"\r\n        [style.left.px]=\"menuX\" [style.top.px]=\"menuY\">\r\n    </div>\r\n    <mat-menu #columnMenu=\"matMenu\" (closed)=\"resetMenuChecks()\">\r\n        <div class=\"toolbar-menu-container\" *ngIf=\"hideShowMenuCtrl\" [formGroup]=\"hideShowMenuGroup\"\r\n            (click)=\"$event.stopPropagation()\">\r\n            <h4 class=\"column-headers\">Visible Columns</h4>\r\n            <mat-form-field appearance=\"fill\" style=\"width: -webkit-fill-available;\">\r\n                <mat-label>Filter Columns</mat-label>\r\n                <input matInput [(ngModel)]=\"showHideFilter\" (ngModelChange)=\"filterColumns($event)\"\r\n                    [ngModelOptions]=\"{standalone: true}\">\r\n            </mat-form-field>\r\n            <div class=\"showHide-menu-columns-list\">\r\n                <div class=\"toolbar-menu-item\" *ngFor=\"let column of showHideColumnsArray\">\r\n                    <mat-checkbox color=\"primary\" class=\"toolbar-menu-checkbox\" style=\"width: max-content;\"\r\n                        [formControlName]=\"column.field\" (change)=\"setColumnHideShow()\">{{column.header}}</mat-checkbox>\r\n                </div>\r\n            </div>\r\n        </div>\r\n        <div class=\"toolbar-menu-container\" *ngIf=\"columnPinMenuCtrl\" (click)=\"$event.stopPropagation()\">\r\n            <h4 class=\"column-headers\">Pin Columns</h4>\r\n            <form class=\"example-form\">\r\n                <mat-form-field appearance=\"fill\" style=\"width: -webkit-fill-available;\">\r\n                    <mat-label>Filter Columns</mat-label>\r\n                    <input matInput [(ngModel)]=\"showHideFilter\" (ngModelChange)=\"filterColumns($event)\"\r\n                        [ngModelOptions]=\"{standalone: true}\">\r\n                </mat-form-field>\r\n            </form>\r\n            <div class=\"showHide-menu-columns-list\">\r\n                <app-column-pinning [columns]=\"showHideColumnsArray\"></app-column-pinning>\r\n            </div>\r\n        </div>\r\n    </mat-menu>\r\n\r\n    <mat-progress-bar *ngIf=\"loadingIndicator\" mode=\"indeterminate\"></mat-progress-bar>\r\n    <section id=\"tableContainer\" class=\"mat-table-ext-container\" (scroll)=\"onScroll($event)\"\r\n        [style.height]=\"tableHeight ? tableHeight :'max-content'\">\r\n        <table mat-table [id]=\"'matTableExt'+tableID\" [dataSource]=\"dataSource\" matSort cdkDropList\r\n            cdkDropListOrientation=\"horizontal\" multiTemplateDataRows (cdkDropListDropped)=\"onDrop($event)\"\r\n            (click)=\"saveCellEditing()\" [style.width]=\"scrollbarH?'max-content':'100%'\">\r\n            <!-- Row selection column -->\r\n            <ng-container matColumnDef=\"select\">\r\n                <th mat-header-cell *matHeaderCellDef cdkDragLockAxis=\"x\" cdkDrag [cdkDragDisabled]=\"!dndColumns\">\r\n                    <mat-checkbox (change)=\"$event ? toggleAllRows() : null\"\r\n                        [checked]=\"selection.hasValue() && isAllSelected()\"\r\n                        [indeterminate]=\"selection.hasValue() && !isAllSelected()\" [aria-label]=\"checkboxLabel()\">\r\n                    </mat-checkbox>\r\n                </th>\r\n                <td mat-cell *matCellDef=\"let row;let i = dataIndex\">\r\n                    <mat-checkbox (click)=\"$event.stopPropagation()\" (change)=\"$event ? setSelectedRows(row,i) : null\"\r\n                        [checked]=\"selection.isSelected(row)\" [aria-label]=\"checkboxLabel(row)\">\r\n                    </mat-checkbox>\r\n                </td>\r\n                <ng-container *ngIf=\"showFooterRow\">\r\n                    <td mat-footer-cell *matFooterCellDef></td>\r\n                </ng-container>\r\n            </ng-container>\r\n            <!--dynamic columns are being generated here-->\r\n            <div matColumnDef=\"{{column['field']}}\" [sticky]=\"column.pinned == 'left' ? true:false\"\r\n                [stickyEnd]=\"column.pinned == 'right' ? true:false\" *ngFor=\"let column of columnsArray; let i = index\">\r\n                <th mat-header-cell *matHeaderCellDef [style.width]=\"column.width\" [style.maxWidth]=\"column.maxWidth\"\r\n                    [style.minWidth]=\"column.minWidth\" cdkDragLockAxis=\"x\" cdkDrag [cdkDragDisabled]=\"!dndColumns\"\r\n                    [columnsResizable]=\"columnResizable\" [index]=\"i\">\r\n                    <span *ngIf=\"!headerTemplateRef\" matTooltip=\"{{column.headerTooltip?.value}}\"\r\n                        [matTooltipPosition]=\"column?.headerTooltip?.tooltipPosition!\" mat-sort-header\r\n                        [disabled]=\"!sorting || column.disabled === true\">{{column.header}}</span>\r\n                    <ng-container *ngIf=\"headerTemplateRef\" [ngTemplateOutlet]=\"headerTemplateRef\"\r\n                        [ngTemplateOutletContext]=\"{data:column}\"></ng-container>\r\n                    <ng-container *ngIf=\"column.headerTemplate\" [ngTemplateOutlet]=\"column.headerTemplate\"\r\n                        [ngTemplateOutletContext]=\"{data:column}\"></ng-container>\r\n                </th>\r\n                <td mat-cell *matCellDef=\"let row ;let i=dataIndex\">\r\n                    <div *ngIf=\"!row.editable && !cellEditing[i +'_'+column.field]\"\r\n                        (dblclick)=\"cellEditing[i +'_'+column.field] = inCellEditing;setCellData(row,i)\"\r\n                        matTooltip=\"{{column.cellTooltip?.value}}\"\r\n                        [matTooltipPosition]=\"column?.cellTooltip?.tooltipPosition!\">\r\n                        <span\r\n                            *ngIf=\"!cellTemplateRef && !column?.cellTemplate && !cellTemplateRefMap[column.field]\">{{row[column.field]}}</span>\r\n                        <ng-container *ngIf=\"cellTemplateRefMap[column.field]\"\r\n                            [ngTemplateOutlet]=\"cellTemplateRefMap[column.field]\"\r\n                            [ngTemplateOutletContext]=\"{row:row,column:column,index:i}\">\r\n                        </ng-container>\r\n                        <ng-container\r\n                            *ngIf=\"cellTemplateRef && column.cellTemplate && !cellTemplateRefMap[column.field]\"\r\n                            [ngTemplateOutlet]=\"column.cellTemplate\"\r\n                            [ngTemplateOutletContext]=\"{row:row,column:column,index:i}\">\r\n                        </ng-container>\r\n                        <ng-container\r\n                            *ngIf=\"!cellTemplateRef && column.cellTemplate && !cellTemplateRefMap[column.field]\"\r\n                            [ngTemplateOutlet]=\"column.cellTemplate\"\r\n                            [ngTemplateOutletContext]=\"{row:row,column:column,index:i}\">\r\n                        </ng-container>\r\n                        <ng-container\r\n                            *ngIf=\"cellTemplateRef && !column.cellTemplate && !cellTemplateRefMap[column.field]\"\r\n                            [ngTemplateOutlet]=\"cellTemplateRef\"\r\n                            [ngTemplateOutletContext]=\"{row:row,column:column,index:i}\">\r\n                        </ng-container>\r\n                    </div>\r\n                    <div *ngIf=\"row.editable || cellEditing[i +'_'+column.field]\" (click)=\"$event.stopPropagation()\">\r\n                        <ng-container *ngIf=\"inlineEditingTemplateRef && !cellEditing[i +'_'+column.field]\"\r\n                            [ngTemplateOutlet]=\"inlineEditingTemplateRef\"\r\n                            [ngTemplateOutletContext]=\"{data:getInlineEditingData(row,i,column)}\"></ng-container>\r\n                        <ng-container *ngIf=\"cellEditingTemplateRef && !(row.editable)\"\r\n                            [ngTemplateOutlet]=\"cellEditingTemplateRef\"\r\n                            [ngTemplateOutletContext]=\"{data:getInlineEditingData(row,i,column)}\"></ng-container>\r\n                        <ng-container *ngIf=\"!inlineEditingTemplateRef && (row.editable) && rowDataTemp['e'+i]\">\r\n                            <mat-form-field *ngIf=\"column.type == 'number'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <input matInput type=\"number\" [(ngModel)]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [ngModelOptions]=\"{standalone: true}\">\r\n                            </mat-form-field>\r\n                            <mat-form-field style=\"width: 100%;\" *ngIf=\"column.type == 'string'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <input matInput type=\"text\" [(ngModel)]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [ngModelOptions]=\"{standalone: true}\">\r\n                            </mat-form-field>\r\n                            <mat-form-field *ngIf=\"column.type == 'date'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <input matInput type=\"date\" [(ngModel)]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [ngModelOptions]=\"{standalone: true}\">\r\n                            </mat-form-field>\r\n                            <mat-form-field *ngIf=\"column.type == 'selection'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <mat-select [value]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [(ngModel)]=\"rowDataTemp['e'+i][column.field]\">\r\n                                    <mat-option *ngFor=\"let option of column.options\" [value]=\"option\">\r\n                                        {{option}}\r\n                                    </mat-option>\r\n                                </mat-select>\r\n                            </mat-form-field>\r\n                            <mat-checkbox (click)=\"$event.stopPropagation()\" *ngIf=\"column.type == 'boolean'\"\r\n                                color=\"primary\" [(ngModel)]=\"row[column.field]\"></mat-checkbox>\r\n                        </ng-container>\r\n                        <ng-container *ngIf=\"!cellEditingTemplateRef && cellEditing[i +'_'+column.field]\">\r\n                            <mat-form-field *ngIf=\"column.type == 'number'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <input matInput type=\"number\" [(ngModel)]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [ngModelOptions]=\"{standalone: true}\">\r\n                            </mat-form-field>\r\n                            <mat-form-field *ngIf=\"column.type == 'string'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <input matInput type=\"text\" [(ngModel)]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [ngModelOptions]=\"{standalone: true}\">\r\n                            </mat-form-field>\r\n                            <mat-form-field *ngIf=\"column.type == 'date'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <input matInput type=\"date\" [(ngModel)]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [ngModelOptions]=\"{standalone: true}\">\r\n                            </mat-form-field>\r\n                            <mat-form-field *ngIf=\"column.type == 'selection'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <mat-select [value]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [(ngModel)]=\"rowDataTemp['e'+i][column.field]\">\r\n                                    <mat-option *ngFor=\"let option of column.options\" [value]=\"option\">\r\n                                        {{option}}\r\n                                    </mat-option>\r\n                                </mat-select>\r\n                            </mat-form-field>\r\n                            <mat-checkbox (click)=\"$event.stopPropagation()\" *ngIf=\"column.type == 'boolean'\"\r\n                                color=\"primary\" [(ngModel)]=\"row[column.field]\"></mat-checkbox>\r\n                        </ng-container>\r\n                    </div>\r\n                </td>\r\n                <ng-container *ngIf=\"showFooterRow\">\r\n                    <td mat-footer-cell *matFooterCellDef> {{column.footerText}} </td>\r\n                </ng-container>\r\n            </div>\r\n            <ng-container matColumnDef=\"edit\" stickyEnd=\"false\">\r\n                <th mat-header-cell cdkDragLockAxis=\"x\" cdkDrag [cdkDragDisabled]=\"true\" *matHeaderCellDef\r\n                    class=\"action-column-cells\"> Edit </th>\r\n                <td mat-cell *matCellDef=\"let row; let i = dataIndex\" class=\"inline-edit-column-cell\">\r\n                    <mat-icon class=\"edit-column-icons\" *ngIf=\"!row.editable && !row.editmodal\" aria-hidden=\"false\"\r\n                        (click)=\"enableInlineEditing(row,i)\" fontIcon=\"edit_note\">\r\n                    </mat-icon>\r\n                    <div class=\"inline-editing-controls\" *ngIf=\"row.editable && !row.editmodal\">\r\n                        <mat-icon class=\"edit-column-icons\" aria-hidden=\"false\" (click)=\"saveInlineEditing(row,i)\"\r\n                            fontIcon=\"done\"></mat-icon>\r\n                        <mat-icon class=\"edit-column-icons\" aria-hidden=\"false\" (click)=\"cancelInlineEditing(row,i)\"\r\n                            fontIcon=\"close\"></mat-icon>\r\n                    </div>\r\n                </td>\r\n                <td mat-footer-cell *matFooterCellDef> edit </td>\r\n            </ng-container>\r\n            <ng-container matColumnDef=\"popup\" stickyEnd=\"false\">\r\n                <th mat-header-cell cdkDragLockAxis=\"x\" cdkDrag [cdkDragDisabled]=\"true\" *matHeaderCellDef\r\n                    class=\"action-column-cells\"> Popup\r\n                </th>\r\n                <td mat-cell *matCellDef=\"let row; let i = index\">\r\n                    <mat-icon aria-hidden=\"false\" (click)=\"openEditingDialog(row)\" fontIcon=\"edit\">\r\n                    </mat-icon>\r\n                </td>\r\n                <td mat-footer-cell *matFooterCellDef></td>\r\n            </ng-container>\r\n\r\n            <ng-container matColumnDef=\"delete\">\r\n                <th mat-header-cell cdkDragLockAxis=\"x\" cdkDrag [cdkDragDisabled]=\"true\" *matHeaderCellDef\r\n                    class=\"action-column-cells\"> Delete\r\n                </th>\r\n                <td mat-cell *matCellDef=\"let row;let i=dataIndex\">\r\n                    <mat-icon (click)=\"deleteRow(row,i)\" aria-hidden=\"false\" aria-label=\"Example home icon\"\r\n                        fontIcon=\"delete\">\r\n                    </mat-icon>\r\n                </td>\r\n                <td mat-footer-cell *matFooterCellDef></td>\r\n            </ng-container>\r\n            <!-- Expanded Content Column - The detail row is made up of this one column that spans across all columns -->\r\n            <ng-container *ngIf=\"expandRows\" matColumnDef=\"expandedDetail\">\r\n                <td mat-cell *matCellDef=\"let element;let i=dataIndex \"\r\n                    [attr.colspan]=\"columnsToDisplayWithExpand.length\">\r\n                    <div class=\"example-element-detail\"\r\n                        [@detailExpand]=\"element == expandedElement ? 'expanded' : 'collapsed'\">\r\n                        <ng-container *ngIf=\"expansionTemplateRef\" [ngTemplateOutlet]=\"expansionTemplateRef\"\r\n                            [ngTemplateOutletContext]=\"{$explicit:element,row:element,index:i}\">\r\n                        </ng-container>\r\n                    </div>\r\n                </td>\r\n            </ng-container>\r\n            <ng-container *ngFor=\"let ids of headersFiltersIds; let i=index\" [matColumnDef]=\"ids\">\r\n                <th mat-header-cell *matHeaderCellDef>\r\n                    <div class=\"filters-container\" [class.animate]=\"toggleFilters\">\r\n                        <app-filter-columns-component [obj]=\"columnsArray[returnIndex(ids)]\"\r\n                            (filterOutput)=\"applyColumnFilter($event,columnsArray[returnIndex(ids)])\"></app-filter-columns-component>\r\n                    </div>\r\n                </th>\r\n            </ng-container>\r\n            <tr mat-header-row *matHeaderRowDef=\" getDisplayedColumns(); sticky: stickyHeader\"></tr>\r\n            <tr mat-row *matRowDef=\"let row; columns:getDisplayedColumns(); let i=dataIndex;\" class=\"data-row\"\r\n                [ngClass]=\"{'data-row':expandRows,'stripedRows':(stripedRows &&  i % 2 == 1),'hoverClass':rowHover, 'hidden':hiddenCtrl.isSelected(row) && hideRows,'example-expanded-row':expandedElement === row}\"\r\n                (click)=\"expandRow(row, row !== expandedElement,i)\">\r\n            </tr>\r\n            <tr style=\"height: 0px;\" mat-header-row class=\"no-default-height\" *matHeaderRowDef=\"headersFiltersIds\">\r\n            </tr>\r\n            <ng-container *ngIf=\"expandRows\">\r\n                <tr style=\"height: 0px;\" mat-row *matRowDef=\"let row; columns: ['expandedDetail']\"\r\n                    [ngClass]=\"{'example-detail-row': (expandRows && row === expandedElement),'expand-row':row !== expandedElement}\">\r\n                </tr>\r\n            </ng-container>\r\n            <ng-container *ngIf=\"showFooterRow\">\r\n                <tr mat-footer-row *matFooterRowDef=\"getDisplayedColumns(); sticky: stickyFooter\"></tr>\r\n            </ng-container>\r\n        </table>\r\n    </section>\r\n    <mat-paginator *ngIf=\"showPaginator\" [pageSizeOptions]=\"pageSizeOptions\"\r\n        [showFirstLastButtons]=\"showFirstLastButtons\">\r\n    </mat-paginator>\r\n</mat-card>", styles: ["table{min-width:100%}.mat-table-sticky-border-elem-right{border-left:1px solid #e0e0e0}.mat-table-sticky-border-elem-left{border-right:1px solid #e0e0e0}tr.example-detail-row{display:table-row!important}.example-element-detail{overflow:hidden;display:flex}.hidden{display:none}.stripedRows{background:#eaeaea!important}.hoverClass:hover{background:#dbdbdb!important}.filters-container{overflow:hidden;max-height:0px;transition:max-height .5s ease-in-out}.animate{max-height:50px!important}.resize-handle{display:inline-block;border-right:2px solid rgb(140,140,140);position:absolute;top:0;right:0;height:100%;cursor:col-resize;opacity:0}.resize-handle:hover{width:20px}table th:hover .resize-handle{opacity:1;transition:.3s ease-in-out}.mat-table.resizing{-webkit-user-select:none;user-select:none;cursor:col-resize}.mat-table .mat-header-cell{position:relative}.mat-table .mat-header-cell:not(:last-child) .resize-holder{cursor:col-resize;width:20px;height:100%;position:absolute;right:-10px;top:0;z-index:1}.toolbar-container{display:flex;padding:0 15px;gap:1rem;grid-auto-rows:10px;justify-content:flex-end;align-items:center}.mat-table-ext-container{width:100%;max-width:100%;overflow:auto}.column-headers{font-family:Roboto,Helvetica Neue,sans-serif}.example-spacer{flex:1 1 auto}.export-button .mat-button-wrapper{display:flex!important;width:8em;justify-content:space-around;align-items:center}.toolbar-menu-container{display:flex;flex-direction:column;margin:auto .8em;width:15em;height:20em}.toolbar-menu-item{display:flex;height:3em}.toolbar-menu-checkbox{margin-left:8%}.toolbar-menu-checkbox.mat-checkbox{width:max-content;display:flex;align-items:center}.hide-button .mat-button-wrapper,.pin-button .mat-button-wrapper{display:flex!important;width:5em;justify-content:space-around;align-items:center}.hide-button,.pin-button,.export-button{height:3em;border:2px solid currentColor!important}.showHide-menu-columns-list{height:10em;max-height:10em;overflow-y:auto}mat-card.main-table-ext-container{padding:0}.main-table-ext-container{margin:10px}.mat-column-select{width:50px!important}.data-row td,.example-expanded-row td{border-bottom-width:0!important}.action-column-cells{width:40px;height:inherit}.inline-editing-controls{display:flex}.global-search-field{width:-webkit-fill-available}\n"], dependencies: [{ kind: "directive", type: i6.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i6.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i6.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: i7.MatTable, selector: "mat-table, table[mat-table]", exportAs: ["matTable"] }, { kind: "directive", type: i7.MatHeaderCellDef, selector: "[matHeaderCellDef]" }, { kind: "directive", type: i7.MatHeaderRowDef, selector: "[matHeaderRowDef]", inputs: ["matHeaderRowDef", "matHeaderRowDefSticky"] }, { kind: "directive", type: i7.MatColumnDef, selector: "[matColumnDef]", inputs: ["sticky", "matColumnDef"] }, { kind: "directive", type: i7.MatCellDef, selector: "[matCellDef]" }, { kind: "directive", type: i7.MatRowDef, selector: "[matRowDef]", inputs: ["matRowDefColumns", "matRowDefWhen"] }, { kind: "directive", type: i7.MatFooterCellDef, selector: "[matFooterCellDef]" }, { kind: "directive", type: i7.MatFooterRowDef, selector: "[matFooterRowDef]", inputs: ["matFooterRowDef", "matFooterRowDefSticky"] }, { kind: "directive", type: i7.MatHeaderCell, selector: "mat-header-cell, th[mat-header-cell]" }, { kind: "directive", type: i7.MatCell, selector: "mat-cell, td[mat-cell]" }, { kind: "directive", type: i7.MatFooterCell, selector: "mat-footer-cell, td[mat-footer-cell]" }, { kind: "component", type: i7.MatHeaderRow, selector: "mat-header-row, tr[mat-header-row]", exportAs: ["matHeaderRow"] }, { kind: "component", type: i7.MatRow, selector: "mat-row, tr[mat-row]", exportAs: ["matRow"] }, { kind: "component", type: i7.MatFooterRow, selector: "mat-footer-row, tr[mat-footer-row]", exportAs: ["matFooterRow"] }, { kind: "directive", type: i3.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i3.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: i3.NumberValueAccessor, selector: "input[type=number][formControlName],input[type=number][formControl],input[type=number][ngModel]" }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: i3.NgForm, selector: "form:not([ngNoForm]):not([formGroup]),ng-form,[ngForm]", inputs: ["ngFormOptions"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i3.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "directive", type: i8.CdkDropList, selector: "[cdkDropList], cdk-drop-list", inputs: ["cdkDropListConnectedTo", "cdkDropListData", "cdkDropListOrientation", "id", "cdkDropListLockAxis", "cdkDropListDisabled", "cdkDropListSortingDisabled", "cdkDropListEnterPredicate", "cdkDropListSortPredicate", "cdkDropListAutoScrollDisabled", "cdkDropListAutoScrollStep"], outputs: ["cdkDropListDropped", "cdkDropListEntered", "cdkDropListExited", "cdkDropListSorted"], exportAs: ["cdkDropList"] }, { kind: "directive", type: i8.CdkDrag, selector: "[cdkDrag]", inputs: ["cdkDragData", "cdkDragLockAxis", "cdkDragRootElement", "cdkDragBoundary", "cdkDragStartDelay", "cdkDragFreeDragPosition", "cdkDragDisabled", "cdkDragConstrainPosition", "cdkDragPreviewClass", "cdkDragPreviewContainer"], outputs: ["cdkDragStarted", "cdkDragReleased", "cdkDragEnded", "cdkDragEntered", "cdkDragExited", "cdkDragDropped", "cdkDragMoved"], exportAs: ["cdkDrag"] }, { kind: "component", type: i9.MatOption, selector: "mat-option", exportAs: ["matOption"] }, { kind: "component", type: i10.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "component", type: i11.MatCard, selector: "mat-card", exportAs: ["matCard"] }, { kind: "component", type: i12.MatCheckbox, selector: "mat-checkbox", inputs: ["disableRipple", "color", "tabIndex"], exportAs: ["matCheckbox"] }, { kind: "component", type: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i13.MatFormField, selector: "mat-form-field", inputs: ["color", "appearance", "hideRequiredMarker", "hintLabel", "floatLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i13.MatLabel, selector: "mat-label" }, { kind: "directive", type: i14.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: i15.MatMenu, selector: "mat-menu", exportAs: ["matMenu"] }, { kind: "directive", type: i15.MatMenuTrigger, selector: "[mat-menu-trigger-for], [matMenuTriggerFor]", exportAs: ["matMenuTrigger"] }, { kind: "component", type: i16.MatPaginator, selector: "mat-paginator", inputs: ["disabled"], exportAs: ["matPaginator"] }, { kind: "component", type: i17.MatProgressBar, selector: "mat-progress-bar", inputs: ["color", "value", "bufferValue", "mode"], outputs: ["animationEnd"], exportAs: ["matProgressBar"] }, { kind: "component", type: i18.MatSelect, selector: "mat-select", inputs: ["disabled", "disableRipple", "tabIndex"], exportAs: ["matSelect"] }, { kind: "directive", type: i19.MatSort, selector: "[matSort]", inputs: ["matSortDisabled", "matSortActive", "matSortStart", "matSortDirection", "matSortDisableClear"], outputs: ["matSortChange"], exportAs: ["matSort"] }, { kind: "component", type: i19.MatSortHeader, selector: "[mat-sort-header]", inputs: ["disabled", "mat-sort-header", "arrowPosition", "start", "sortActionDescription", "disableClear"], exportAs: ["matSortHeader"] }, { kind: "component", type: i20.MatToolbar, selector: "mat-toolbar", inputs: ["color"], exportAs: ["matToolbar"] }, { kind: "directive", type: i21.MatTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }, { kind: "directive", type: i22.ResizeColumnDirective, selector: "[columnsResizable]", inputs: ["columnsResizable", "index"] }, { kind: "component", type: i23.ColumnPinningComponent, selector: "app-column-pinning", inputs: ["columns"], outputs: ["columnsChanged"] }, { kind: "component", type: i24.FilterColumnsComponentComponent, selector: "app-filter-columns-component", inputs: ["obj"], outputs: ["filterOutput"] }], animations: [
+        trigger('detailExpand', [
+            state('collapsed', style({ height: '0px', minHeight: '0' })),
+            state('expanded', style({ height: '*' })),
+            transition('expanded <=> collapsed', animate('300ms cubic-bezier(0.4, 0.0, 0.2, 1)')),
+        ]),
+    ], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: MatTableExtComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'mat-table-ext', encapsulation: ViewEncapsulation.None, animations: [
+                        trigger('detailExpand', [
+                            state('collapsed', style({ height: '0px', minHeight: '0' })),
+                            state('expanded', style({ height: '*' })),
+                            transition('expanded <=> collapsed', animate('300ms cubic-bezier(0.4, 0.0, 0.2, 1)')),
+                        ]),
+                    ], template: "<mat-card class=\"main-table-ext-container mat-elevation-z8\" [style.width]=\"tableWidth\">\r\n    <mat-form-field class=\"global-search-field\" appearance=\"fill\" *ngIf=\"globalSearch\">\r\n        <mat-label>Search</mat-label>\r\n        <input matInput [ngModel]=\"globalFilter\" (ngModelChange)=\"applyGlobalFilter($event)\" placeholder=\"Ex. Mia\" #input>\r\n    </mat-form-field>\r\n    <mat-toolbar class=\"toolbar-container\" *ngIf=\"showToolbar\" [style.height]=\"toolbarHeight?toolbarHeight:'50px'\">\r\n        <span class=\"toolbar-title\" *ngIf=\"toolbarTitle\">{{toolbarTitle}}</span>\r\n        <ng-container *ngIf=\"toolbarTemplateRef\" [ngTemplateOutlet]=\"toolbarTemplateRef\"></ng-container>\r\n        <span class=\"example-spacer\"></span>\r\n        <ng-container *ngIf=\"rowSelection || multiRowSelection\">\r\n            <button class=\"hide-button\" mat-stroked-button color=\"primary\" (click)=\"hideSelectedRows()\">\r\n                Hide Rows\r\n            </button>\r\n            <button class=\"hide-button\" mat-stroked-button color=\"primary\" (click)=\"showHiddenRows()\">\r\n                Show All Rows\r\n            </button>\r\n        </ng-container>\r\n        <button *ngIf=\"columnHidable\" class=\"hide-button\" mat-stroked-button color=\"primary\"\r\n            (click)=\"openMenu('hideShow',$event)\" matTooltip=\"Column Visibility\" matTooltipPosition=\"above\">\r\n            <mat-icon>visibility</mat-icon>\r\n        </button>\r\n        <button *ngIf=\"columnPinnable\" class=\"pin-button\" mat-stroked-button color=\"primary\"\r\n            (click)=\"openMenu('columnPin',$event)\" matTooltip=\"Column Pinning\">\r\n            <mat-icon svgIcon=\"pinIcon\"></mat-icon>\r\n        </button>\r\n        <button *ngIf=\"exportButtonEnable\" class=\"export-button\" mat-stroked-button color=\"primary\"\r\n            (click)=\"openMenu('export',$event)\" matTooltip=\"Table Data Export\">\r\n            <mat-icon>import_export</mat-icon> <span>Export</span>\r\n            <mat-icon>expand_more</mat-icon>\r\n        </button>\r\n        <div style=\"visibility: hidden; position:fixed\" [matMenuTriggerFor]=\"menu\" [style.left.px]=\"menuX\"\r\n            [style.top.px]=\"menuY\"></div>\r\n    </mat-toolbar>\r\n    <mat-menu #menu=\"matMenu\" (closed)=\"menuClosed()\" id=\"exportMenu\">\r\n        <ng-container *ngIf=\"exportMenuCtrl\">\r\n            <mat-option (click)=\"exportTable('xlsx')\">Export to Excel</mat-option>\r\n            <mat-option (click)=\"exportTable('csv')\">Export to CSV</mat-option>\r\n        </ng-container>\r\n    </mat-menu>\r\n    <div style=\"visibility: hidden; position:fixed\" #columnMenuTrigger=\"matMenuTrigger\" [matMenuTriggerFor]=\"columnMenu\"\r\n        [style.left.px]=\"menuX\" [style.top.px]=\"menuY\">\r\n    </div>\r\n    <mat-menu #columnMenu=\"matMenu\" (closed)=\"resetMenuChecks()\">\r\n        <div class=\"toolbar-menu-container\" *ngIf=\"hideShowMenuCtrl\" [formGroup]=\"hideShowMenuGroup\"\r\n            (click)=\"$event.stopPropagation()\">\r\n            <h4 class=\"column-headers\">Visible Columns</h4>\r\n            <mat-form-field appearance=\"fill\" style=\"width: -webkit-fill-available;\">\r\n                <mat-label>Filter Columns</mat-label>\r\n                <input matInput [(ngModel)]=\"showHideFilter\" (ngModelChange)=\"filterColumns($event)\"\r\n                    [ngModelOptions]=\"{standalone: true}\">\r\n            </mat-form-field>\r\n            <div class=\"showHide-menu-columns-list\">\r\n                <div class=\"toolbar-menu-item\" *ngFor=\"let column of showHideColumnsArray\">\r\n                    <mat-checkbox color=\"primary\" class=\"toolbar-menu-checkbox\" style=\"width: max-content;\"\r\n                        [formControlName]=\"column.field\" (change)=\"setColumnHideShow()\">{{column.header}}</mat-checkbox>\r\n                </div>\r\n            </div>\r\n        </div>\r\n        <div class=\"toolbar-menu-container\" *ngIf=\"columnPinMenuCtrl\" (click)=\"$event.stopPropagation()\">\r\n            <h4 class=\"column-headers\">Pin Columns</h4>\r\n            <form class=\"example-form\">\r\n                <mat-form-field appearance=\"fill\" style=\"width: -webkit-fill-available;\">\r\n                    <mat-label>Filter Columns</mat-label>\r\n                    <input matInput [(ngModel)]=\"showHideFilter\" (ngModelChange)=\"filterColumns($event)\"\r\n                        [ngModelOptions]=\"{standalone: true}\">\r\n                </mat-form-field>\r\n            </form>\r\n            <div class=\"showHide-menu-columns-list\">\r\n                <app-column-pinning [columns]=\"showHideColumnsArray\"></app-column-pinning>\r\n            </div>\r\n        </div>\r\n    </mat-menu>\r\n\r\n    <mat-progress-bar *ngIf=\"loadingIndicator\" mode=\"indeterminate\"></mat-progress-bar>\r\n    <section id=\"tableContainer\" class=\"mat-table-ext-container\" (scroll)=\"onScroll($event)\"\r\n        [style.height]=\"tableHeight ? tableHeight :'max-content'\">\r\n        <table mat-table [id]=\"'matTableExt'+tableID\" [dataSource]=\"dataSource\" matSort cdkDropList\r\n            cdkDropListOrientation=\"horizontal\" multiTemplateDataRows (cdkDropListDropped)=\"onDrop($event)\"\r\n            (click)=\"saveCellEditing()\" [style.width]=\"scrollbarH?'max-content':'100%'\">\r\n            <!-- Row selection column -->\r\n            <ng-container matColumnDef=\"select\">\r\n                <th mat-header-cell *matHeaderCellDef cdkDragLockAxis=\"x\" cdkDrag [cdkDragDisabled]=\"!dndColumns\">\r\n                    <mat-checkbox (change)=\"$event ? toggleAllRows() : null\"\r\n                        [checked]=\"selection.hasValue() && isAllSelected()\"\r\n                        [indeterminate]=\"selection.hasValue() && !isAllSelected()\" [aria-label]=\"checkboxLabel()\">\r\n                    </mat-checkbox>\r\n                </th>\r\n                <td mat-cell *matCellDef=\"let row;let i = dataIndex\">\r\n                    <mat-checkbox (click)=\"$event.stopPropagation()\" (change)=\"$event ? setSelectedRows(row,i) : null\"\r\n                        [checked]=\"selection.isSelected(row)\" [aria-label]=\"checkboxLabel(row)\">\r\n                    </mat-checkbox>\r\n                </td>\r\n                <ng-container *ngIf=\"showFooterRow\">\r\n                    <td mat-footer-cell *matFooterCellDef></td>\r\n                </ng-container>\r\n            </ng-container>\r\n            <!--dynamic columns are being generated here-->\r\n            <div matColumnDef=\"{{column['field']}}\" [sticky]=\"column.pinned == 'left' ? true:false\"\r\n                [stickyEnd]=\"column.pinned == 'right' ? true:false\" *ngFor=\"let column of columnsArray; let i = index\">\r\n                <th mat-header-cell *matHeaderCellDef [style.width]=\"column.width\" [style.maxWidth]=\"column.maxWidth\"\r\n                    [style.minWidth]=\"column.minWidth\" cdkDragLockAxis=\"x\" cdkDrag [cdkDragDisabled]=\"!dndColumns\"\r\n                    [columnsResizable]=\"columnResizable\" [index]=\"i\">\r\n                    <span *ngIf=\"!headerTemplateRef\" matTooltip=\"{{column.headerTooltip?.value}}\"\r\n                        [matTooltipPosition]=\"column?.headerTooltip?.tooltipPosition!\" mat-sort-header\r\n                        [disabled]=\"!sorting || column.disabled === true\">{{column.header}}</span>\r\n                    <ng-container *ngIf=\"headerTemplateRef\" [ngTemplateOutlet]=\"headerTemplateRef\"\r\n                        [ngTemplateOutletContext]=\"{data:column}\"></ng-container>\r\n                    <ng-container *ngIf=\"column.headerTemplate\" [ngTemplateOutlet]=\"column.headerTemplate\"\r\n                        [ngTemplateOutletContext]=\"{data:column}\"></ng-container>\r\n                </th>\r\n                <td mat-cell *matCellDef=\"let row ;let i=dataIndex\">\r\n                    <div *ngIf=\"!row.editable && !cellEditing[i +'_'+column.field]\"\r\n                        (dblclick)=\"cellEditing[i +'_'+column.field] = inCellEditing;setCellData(row,i)\"\r\n                        matTooltip=\"{{column.cellTooltip?.value}}\"\r\n                        [matTooltipPosition]=\"column?.cellTooltip?.tooltipPosition!\">\r\n                        <span\r\n                            *ngIf=\"!cellTemplateRef && !column?.cellTemplate && !cellTemplateRefMap[column.field]\">{{row[column.field]}}</span>\r\n                        <ng-container *ngIf=\"cellTemplateRefMap[column.field]\"\r\n                            [ngTemplateOutlet]=\"cellTemplateRefMap[column.field]\"\r\n                            [ngTemplateOutletContext]=\"{row:row,column:column,index:i}\">\r\n                        </ng-container>\r\n                        <ng-container\r\n                            *ngIf=\"cellTemplateRef && column.cellTemplate && !cellTemplateRefMap[column.field]\"\r\n                            [ngTemplateOutlet]=\"column.cellTemplate\"\r\n                            [ngTemplateOutletContext]=\"{row:row,column:column,index:i}\">\r\n                        </ng-container>\r\n                        <ng-container\r\n                            *ngIf=\"!cellTemplateRef && column.cellTemplate && !cellTemplateRefMap[column.field]\"\r\n                            [ngTemplateOutlet]=\"column.cellTemplate\"\r\n                            [ngTemplateOutletContext]=\"{row:row,column:column,index:i}\">\r\n                        </ng-container>\r\n                        <ng-container\r\n                            *ngIf=\"cellTemplateRef && !column.cellTemplate && !cellTemplateRefMap[column.field]\"\r\n                            [ngTemplateOutlet]=\"cellTemplateRef\"\r\n                            [ngTemplateOutletContext]=\"{row:row,column:column,index:i}\">\r\n                        </ng-container>\r\n                    </div>\r\n                    <div *ngIf=\"row.editable || cellEditing[i +'_'+column.field]\" (click)=\"$event.stopPropagation()\">\r\n                        <ng-container *ngIf=\"inlineEditingTemplateRef && !cellEditing[i +'_'+column.field]\"\r\n                            [ngTemplateOutlet]=\"inlineEditingTemplateRef\"\r\n                            [ngTemplateOutletContext]=\"{data:getInlineEditingData(row,i,column)}\"></ng-container>\r\n                        <ng-container *ngIf=\"cellEditingTemplateRef && !(row.editable)\"\r\n                            [ngTemplateOutlet]=\"cellEditingTemplateRef\"\r\n                            [ngTemplateOutletContext]=\"{data:getInlineEditingData(row,i,column)}\"></ng-container>\r\n                        <ng-container *ngIf=\"!inlineEditingTemplateRef && (row.editable) && rowDataTemp['e'+i]\">\r\n                            <mat-form-field *ngIf=\"column.type == 'number'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <input matInput type=\"number\" [(ngModel)]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [ngModelOptions]=\"{standalone: true}\">\r\n                            </mat-form-field>\r\n                            <mat-form-field style=\"width: 100%;\" *ngIf=\"column.type == 'string'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <input matInput type=\"text\" [(ngModel)]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [ngModelOptions]=\"{standalone: true}\">\r\n                            </mat-form-field>\r\n                            <mat-form-field *ngIf=\"column.type == 'date'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <input matInput type=\"date\" [(ngModel)]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [ngModelOptions]=\"{standalone: true}\">\r\n                            </mat-form-field>\r\n                            <mat-form-field *ngIf=\"column.type == 'selection'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <mat-select [value]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [(ngModel)]=\"rowDataTemp['e'+i][column.field]\">\r\n                                    <mat-option *ngFor=\"let option of column.options\" [value]=\"option\">\r\n                                        {{option}}\r\n                                    </mat-option>\r\n                                </mat-select>\r\n                            </mat-form-field>\r\n                            <mat-checkbox (click)=\"$event.stopPropagation()\" *ngIf=\"column.type == 'boolean'\"\r\n                                color=\"primary\" [(ngModel)]=\"row[column.field]\"></mat-checkbox>\r\n                        </ng-container>\r\n                        <ng-container *ngIf=\"!cellEditingTemplateRef && cellEditing[i +'_'+column.field]\">\r\n                            <mat-form-field *ngIf=\"column.type == 'number'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <input matInput type=\"number\" [(ngModel)]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [ngModelOptions]=\"{standalone: true}\">\r\n                            </mat-form-field>\r\n                            <mat-form-field *ngIf=\"column.type == 'string'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <input matInput type=\"text\" [(ngModel)]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [ngModelOptions]=\"{standalone: true}\">\r\n                            </mat-form-field>\r\n                            <mat-form-field *ngIf=\"column.type == 'date'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <input matInput type=\"date\" [(ngModel)]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [ngModelOptions]=\"{standalone: true}\">\r\n                            </mat-form-field>\r\n                            <mat-form-field *ngIf=\"column.type == 'selection'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <mat-select [value]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [(ngModel)]=\"rowDataTemp['e'+i][column.field]\">\r\n                                    <mat-option *ngFor=\"let option of column.options\" [value]=\"option\">\r\n                                        {{option}}\r\n                                    </mat-option>\r\n                                </mat-select>\r\n                            </mat-form-field>\r\n                            <mat-checkbox (click)=\"$event.stopPropagation()\" *ngIf=\"column.type == 'boolean'\"\r\n                                color=\"primary\" [(ngModel)]=\"row[column.field]\"></mat-checkbox>\r\n                        </ng-container>\r\n                    </div>\r\n                </td>\r\n                <ng-container *ngIf=\"showFooterRow\">\r\n                    <td mat-footer-cell *matFooterCellDef> {{column.footerText}} </td>\r\n                </ng-container>\r\n            </div>\r\n            <ng-container matColumnDef=\"edit\" stickyEnd=\"false\">\r\n                <th mat-header-cell cdkDragLockAxis=\"x\" cdkDrag [cdkDragDisabled]=\"true\" *matHeaderCellDef\r\n                    class=\"action-column-cells\"> Edit </th>\r\n                <td mat-cell *matCellDef=\"let row; let i = dataIndex\" class=\"inline-edit-column-cell\">\r\n                    <mat-icon class=\"edit-column-icons\" *ngIf=\"!row.editable && !row.editmodal\" aria-hidden=\"false\"\r\n                        (click)=\"enableInlineEditing(row,i)\" fontIcon=\"edit_note\">\r\n                    </mat-icon>\r\n                    <div class=\"inline-editing-controls\" *ngIf=\"row.editable && !row.editmodal\">\r\n                        <mat-icon class=\"edit-column-icons\" aria-hidden=\"false\" (click)=\"saveInlineEditing(row,i)\"\r\n                            fontIcon=\"done\"></mat-icon>\r\n                        <mat-icon class=\"edit-column-icons\" aria-hidden=\"false\" (click)=\"cancelInlineEditing(row,i)\"\r\n                            fontIcon=\"close\"></mat-icon>\r\n                    </div>\r\n                </td>\r\n                <td mat-footer-cell *matFooterCellDef> edit </td>\r\n            </ng-container>\r\n            <ng-container matColumnDef=\"popup\" stickyEnd=\"false\">\r\n                <th mat-header-cell cdkDragLockAxis=\"x\" cdkDrag [cdkDragDisabled]=\"true\" *matHeaderCellDef\r\n                    class=\"action-column-cells\"> Popup\r\n                </th>\r\n                <td mat-cell *matCellDef=\"let row; let i = index\">\r\n                    <mat-icon aria-hidden=\"false\" (click)=\"openEditingDialog(row)\" fontIcon=\"edit\">\r\n                    </mat-icon>\r\n                </td>\r\n                <td mat-footer-cell *matFooterCellDef></td>\r\n            </ng-container>\r\n\r\n            <ng-container matColumnDef=\"delete\">\r\n                <th mat-header-cell cdkDragLockAxis=\"x\" cdkDrag [cdkDragDisabled]=\"true\" *matHeaderCellDef\r\n                    class=\"action-column-cells\"> Delete\r\n                </th>\r\n                <td mat-cell *matCellDef=\"let row;let i=dataIndex\">\r\n                    <mat-icon (click)=\"deleteRow(row,i)\" aria-hidden=\"false\" aria-label=\"Example home icon\"\r\n                        fontIcon=\"delete\">\r\n                    </mat-icon>\r\n                </td>\r\n                <td mat-footer-cell *matFooterCellDef></td>\r\n            </ng-container>\r\n            <!-- Expanded Content Column - The detail row is made up of this one column that spans across all columns -->\r\n            <ng-container *ngIf=\"expandRows\" matColumnDef=\"expandedDetail\">\r\n                <td mat-cell *matCellDef=\"let element;let i=dataIndex \"\r\n                    [attr.colspan]=\"columnsToDisplayWithExpand.length\">\r\n                    <div class=\"example-element-detail\"\r\n                        [@detailExpand]=\"element == expandedElement ? 'expanded' : 'collapsed'\">\r\n                        <ng-container *ngIf=\"expansionTemplateRef\" [ngTemplateOutlet]=\"expansionTemplateRef\"\r\n                            [ngTemplateOutletContext]=\"{$explicit:element,row:element,index:i}\">\r\n                        </ng-container>\r\n                    </div>\r\n                </td>\r\n            </ng-container>\r\n            <ng-container *ngFor=\"let ids of headersFiltersIds; let i=index\" [matColumnDef]=\"ids\">\r\n                <th mat-header-cell *matHeaderCellDef>\r\n                    <div class=\"filters-container\" [class.animate]=\"toggleFilters\">\r\n                        <app-filter-columns-component [obj]=\"columnsArray[returnIndex(ids)]\"\r\n                            (filterOutput)=\"applyColumnFilter($event,columnsArray[returnIndex(ids)])\"></app-filter-columns-component>\r\n                    </div>\r\n                </th>\r\n            </ng-container>\r\n            <tr mat-header-row *matHeaderRowDef=\" getDisplayedColumns(); sticky: stickyHeader\"></tr>\r\n            <tr mat-row *matRowDef=\"let row; columns:getDisplayedColumns(); let i=dataIndex;\" class=\"data-row\"\r\n                [ngClass]=\"{'data-row':expandRows,'stripedRows':(stripedRows &&  i % 2 == 1),'hoverClass':rowHover, 'hidden':hiddenCtrl.isSelected(row) && hideRows,'example-expanded-row':expandedElement === row}\"\r\n                (click)=\"expandRow(row, row !== expandedElement,i)\">\r\n            </tr>\r\n            <tr style=\"height: 0px;\" mat-header-row class=\"no-default-height\" *matHeaderRowDef=\"headersFiltersIds\">\r\n            </tr>\r\n            <ng-container *ngIf=\"expandRows\">\r\n                <tr style=\"height: 0px;\" mat-row *matRowDef=\"let row; columns: ['expandedDetail']\"\r\n                    [ngClass]=\"{'example-detail-row': (expandRows && row === expandedElement),'expand-row':row !== expandedElement}\">\r\n                </tr>\r\n            </ng-container>\r\n            <ng-container *ngIf=\"showFooterRow\">\r\n                <tr mat-footer-row *matFooterRowDef=\"getDisplayedColumns(); sticky: stickyFooter\"></tr>\r\n            </ng-container>\r\n        </table>\r\n    </section>\r\n    <mat-paginator *ngIf=\"showPaginator\" [pageSizeOptions]=\"pageSizeOptions\"\r\n        [showFirstLastButtons]=\"showFirstLastButtons\">\r\n    </mat-paginator>\r\n</mat-card>", styles: ["table{min-width:100%}.mat-table-sticky-border-elem-right{border-left:1px solid #e0e0e0}.mat-table-sticky-border-elem-left{border-right:1px solid #e0e0e0}tr.example-detail-row{display:table-row!important}.example-element-detail{overflow:hidden;display:flex}.hidden{display:none}.stripedRows{background:#eaeaea!important}.hoverClass:hover{background:#dbdbdb!important}.filters-container{overflow:hidden;max-height:0px;transition:max-height .5s ease-in-out}.animate{max-height:50px!important}.resize-handle{display:inline-block;border-right:2px solid rgb(140,140,140);position:absolute;top:0;right:0;height:100%;cursor:col-resize;opacity:0}.resize-handle:hover{width:20px}table th:hover .resize-handle{opacity:1;transition:.3s ease-in-out}.mat-table.resizing{-webkit-user-select:none;user-select:none;cursor:col-resize}.mat-table .mat-header-cell{position:relative}.mat-table .mat-header-cell:not(:last-child) .resize-holder{cursor:col-resize;width:20px;height:100%;position:absolute;right:-10px;top:0;z-index:1}.toolbar-container{display:flex;padding:0 15px;gap:1rem;grid-auto-rows:10px;justify-content:flex-end;align-items:center}.mat-table-ext-container{width:100%;max-width:100%;overflow:auto}.column-headers{font-family:Roboto,Helvetica Neue,sans-serif}.example-spacer{flex:1 1 auto}.export-button .mat-button-wrapper{display:flex!important;width:8em;justify-content:space-around;align-items:center}.toolbar-menu-container{display:flex;flex-direction:column;margin:auto .8em;width:15em;height:20em}.toolbar-menu-item{display:flex;height:3em}.toolbar-menu-checkbox{margin-left:8%}.toolbar-menu-checkbox.mat-checkbox{width:max-content;display:flex;align-items:center}.hide-button .mat-button-wrapper,.pin-button .mat-button-wrapper{display:flex!important;width:5em;justify-content:space-around;align-items:center}.hide-button,.pin-button,.export-button{height:3em;border:2px solid currentColor!important}.showHide-menu-columns-list{height:10em;max-height:10em;overflow-y:auto}mat-card.main-table-ext-container{padding:0}.main-table-ext-container{margin:10px}.mat-column-select{width:50px!important}.data-row td,.example-expanded-row td{border-bottom-width:0!important}.action-column-cells{width:40px;height:inherit}.inline-editing-controls{display:flex}.global-search-field{width:-webkit-fill-available}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialog }, { type: i2.MatTableExtService }, { type: i3.FormBuilder }, { type: i4.DomSanitizer }, { type: i5.MatIconRegistry }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { menuTrigger: [{
+                type: ViewChild,
+                args: [MatMenuTrigger]
+            }], columnMenuTrigger: [{
+                type: ViewChild,
+                args: ['columnMenuTrigger']
+            }], paginator: [{
+                type: ViewChild,
+                args: [MatPaginator]
+            }], sort: [{
+                type: ViewChild,
+                args: [MatSort]
+            }], dataSource: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], columnResizable: [{
+                type: Input
+            }], stripedRows: [{
+                type: Input
+            }], rowHover: [{
+                type: Input
+            }], inlineRowEditing: [{
+                type: Input
+            }], inCellEditing: [{
+                type: Input
+            }], popupRowEditing: [{
+                type: Input
+            }], enableDelete: [{
+                type: Input
+            }], rowSelection: [{
+                type: Input
+            }], multiRowSelection: [{
+                type: Input
+            }], stickyFooter: [{
+                type: Input
+            }], stickyHeader: [{
+                type: Input
+            }], showFooterRow: [{
+                type: Input
+            }], columnFilter: [{
+                type: Input
+            }], loadingIndicator: [{
+                type: Input
+            }], sorting: [{
+                type: Input
+            }], showToolbar: [{
+                type: Input
+            }], toolbarTitle: [{
+                type: Input
+            }], tableHeight: [{
+                type: Input
+            }], toolbarHeight: [{
+                type: Input
+            }], tableWidth: [{
+                type: Input
+            }], scrollbarH: [{
+                type: Input
+            }], toolbarTemplate: [{
+                type: Input
+            }], columnHidable: [{
+                type: Input
+            }], columnPinnable: [{
+                type: Input
+            }], globalSearch: [{
+                type: Input
+            }], expandRows: [{
+                type: Input
+            }], dndColumns: [{
+                type: Input
+            }], showPaginator: [{
+                type: Input
+            }], showFirstLastButtons: [{
+                type: Input
+            }], exportButtonEnable: [{
+                type: Input
+            }], pageSizeOptions: [{
+                type: Input
+            }], toolbarTemplateRef: [{
+                type: Input
+            }], headerTemplateRef: [{
+                type: Input
+            }], cellTemplateRef: [{
+                type: Input
+            }], expansionTemplateRef: [{
+                type: Input
+            }], popupEditingTemplateRef: [{
+                type: Input
+            }], inlineEditingTemplateRef: [{
+                type: Input
+            }], cellEditingTemplateRef: [{
+                type: Input
+            }], cellTemplateRefMap: [{
+                type: Input
+            }], inlineChange: [{
+                type: Output
+            }], cellChange: [{
+                type: Output
+            }], popupChange: [{
+                type: Output
+            }], rowDeleted: [{
+                type: Output
+            }], scroll: [{
+                type: Output
+            }], selectionChanged: [{
+                type: Output
+            }], expansionChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mat-table-ext.component.js","sourceRoot":"","sources":["../../../../projects/mat-table-ext/src/lib/mat-table-ext.component.ts","../../../../projects/mat-table-ext/src/lib/mat-table-ext.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  animate,\r\n  state,\r\n  style,\r\n  transition,\r\n  trigger,\r\n} from '@angular/animations';\r\nimport { SelectionModel } from '@angular/cdk/collections';\r\nimport { CdkDragDrop, moveItemInArray } from '@angular/cdk/drag-drop';\r\nimport {\r\n  AfterViewInit,\r\n  ChangeDetectorRef,\r\n  EventEmitter,\r\n  Output,\r\n} from '@angular/core';\r\nimport {\r\n  Component,\r\n  Input,\r\n  OnChanges,\r\n  OnInit,\r\n  SimpleChanges,\r\n  TemplateRef,\r\n  ViewChild,\r\n  ViewEncapsulation,\r\n} from '@angular/core';\r\nimport { FormBuilder, FormGroup } from '@angular/forms';\r\nimport { MatDialog, MatDialogConfig } from '@angular/material/dialog';\r\nimport { MatMenuTrigger } from '@angular/material/menu';\r\nimport { MatPaginator } from '@angular/material/paginator';\r\nimport { MatSort } from '@angular/material/sort';\r\nimport { MatTableDataSource } from '@angular/material/table';\r\nimport { EditingComponent } from '../lib/components/editing/editing.component';\r\nimport {\r\n  RowChange,\r\n  DisplayColumn,\r\n  MTExColumn,\r\n  MTExColumnPinOption,\r\n  RowSelectionChange,\r\n  CellTemplateRefMap,\r\n  ExpansionChange,\r\n  FilterSearchValue,\r\n  MTExRow,\r\n  ColumnVisibility,\r\n} from '../lib/models/tableExtModels';\r\nimport { MatTableExtService } from '../lib/mat-table-ext.service';\r\nimport { DomSanitizer } from '@angular/platform-browser';\r\nimport { MatIconRegistry } from '@angular/material/icon';\r\nimport * as XLSX from 'xlsx';\r\n@Component({\r\n  selector: 'mat-table-ext',\r\n  templateUrl: 'mat-table-ext.component.html',\r\n  styleUrls: ['mat-table-ext.scss'],\r\n  encapsulation: ViewEncapsulation.None,\r\n  animations: [\r\n    trigger('detailExpand', [\r\n      state('collapsed', style({ height: '0px', minHeight: '0' })),\r\n      state('expanded', style({ height: '*' })),\r\n      transition(\r\n        'expanded <=> collapsed',\r\n        animate('300ms cubic-bezier(0.4, 0.0, 0.2, 1)')\r\n      ),\r\n    ]),\r\n  ],\r\n})\r\nexport class MatTableExtComponent implements OnInit, OnChanges, AfterViewInit {\r\n  @ViewChild(MatMenuTrigger) menuTrigger!: MatMenuTrigger;\r\n  @ViewChild('columnMenuTrigger') columnMenuTrigger!: MatMenuTrigger;\r\n  @ViewChild(MatPaginator) paginator!: MatPaginator;\r\n  @ViewChild(MatSort) sort!: MatSort;\r\n\r\n  // Table inputs\r\n  @Input() dataSource!: MatTableDataSource<any>;\r\n  @Input() columns: MTExColumn[] = [];\r\n  @Input() columnResizable: boolean = false;\r\n  @Input() stripedRows: boolean = false;\r\n  @Input() rowHover: boolean = false;\r\n  @Input() inlineRowEditing: boolean = false;\r\n  @Input() inCellEditing: boolean = false;\r\n  @Input() popupRowEditing: boolean = false;\r\n  @Input() enableDelete: boolean = false;\r\n  @Input() rowSelection: boolean = false;\r\n  @Input() multiRowSelection: boolean = false;\r\n  @Input() stickyFooter: boolean = false;\r\n  @Input() stickyHeader: boolean = false;\r\n  @Input() showFooterRow: boolean = false;\r\n  @Input() columnFilter: boolean = false;\r\n  @Input() loadingIndicator: boolean = false;\r\n  @Input() sorting: boolean = false;\r\n  @Input() showToolbar: boolean = false;\r\n  @Input() toolbarTitle: string = '';\r\n  @Input() tableHeight: string = '';\r\n  @Input() toolbarHeight: string = '50px';\r\n  @Input() tableWidth: string = '100%';\r\n  @Input() scrollbarH: boolean = false;\r\n  @Input() toolbarTemplate: TemplateRef<any> | undefined;\r\n  @Input() columnHidable: boolean = false;\r\n  @Input() columnPinnable: boolean = false;\r\n  @Input() globalSearch: boolean = false;\r\n  @Input() expandRows: boolean = false;\r\n  @Input() dndColumns: boolean = false;\r\n  @Input() showPaginator: boolean = true;\r\n  @Input() showFirstLastButtons: boolean = false;\r\n  @Input() exportButtonEnable: boolean = false;\r\n  @Input() pageSizeOptions: number[] = [10, 50, 100];\r\n  @Input() toolbarTemplateRef!: TemplateRef<any> | undefined;\r\n  @Input() headerTemplateRef!: TemplateRef<any> | undefined;\r\n  @Input() cellTemplateRef!: TemplateRef<any> | undefined;\r\n  @Input() expansionTemplateRef!: TemplateRef<any> | undefined;\r\n  @Input() popupEditingTemplateRef!: TemplateRef<any> | undefined;\r\n  @Input() inlineEditingTemplateRef!: TemplateRef<any> | undefined;\r\n  @Input() cellEditingTemplateRef!: TemplateRef<any> | undefined;\r\n  @Input() cellTemplateRefMap: CellTemplateRefMap = {};\r\n\r\n  // Table outputs\r\n  @Output() inlineChange: EventEmitter<any> = new EventEmitter<RowChange>();\r\n  @Output() cellChange: EventEmitter<any> = new EventEmitter<RowChange>();\r\n  @Output() popupChange: EventEmitter<any> = new EventEmitter<RowChange>();\r\n  @Output() rowDeleted: EventEmitter<any> = new EventEmitter<any>();\r\n  @Output() scroll: EventEmitter<any> = new EventEmitter<any>();\r\n  @Output() selectionChanged: EventEmitter<RowSelectionChange> =\r\n    new EventEmitter<any>();\r\n  @Output() expansionChange: EventEmitter<ExpansionChange> =\r\n    new EventEmitter<any>();\r\n  tableID = new Date().getTime();\r\n  columnPinningOptions: MTExColumnPinOption[] = [];\r\n  exportMenuCtrl: boolean = false;\r\n  columnPinMenuCtrl: boolean = false;\r\n  hideShowMenuCtrl: boolean = false;\r\n  columnFilterBySelection: any = false;\r\n  rowDataTemp: any = {};\r\n  inlineEditingTemplateRefData: any = {};\r\n  displayedColumns: string[] = [];\r\n  showHideColumnsArray: MTExColumn[] = [];\r\n  columnsList: string[] = [];\r\n  columnsArray: MTExColumn[] = [];\r\n  headersFiltersIds: string[] = [];\r\n  columnsToDisplayWithExpand: string[] = [];\r\n  selection = new SelectionModel<any>(false, []);\r\n  hiddenCtrl = new SelectionModel<any>(true, []);\r\n  tableData: any = [];\r\n  filterValues: any = {};\r\n  globalFilter = '';\r\n  showHideFilter = '';\r\n  individualFilter = '';\r\n  toggleFilters = false;\r\n  hideRows = false;\r\n  expandedElement: any | null;\r\n  currentRowIndex: number = -1;\r\n  currentRow: any = {};\r\n  cellEditing: any = {};\r\n  hideShowMenuGroup!: FormGroup;\r\n  cellTemplate!: TemplateRef<any>;\r\n  menuX: number = 0;\r\n  menuY: number = 0;\r\n  dynamicDisplayedColumns: any[] = [\r\n    { filter: false, name: 'select', show: false },\r\n    { filter: false, name: 'edit', show: false },\r\n    { filter: false, name: 'popup', show: false },\r\n    { filter: false, name: 'delete', show: false },\r\n    { filter: false, name: 'expand', show: false },\r\n  ];\r\n  inputPropertyKeys: string[] = [\r\n    'dataSource',\r\n    'columns',\r\n    'inlineRowEditing',\r\n    'popupRowEditing',\r\n    'enableDelete',\r\n    'rowSelection',\r\n    'multiRowSelection',\r\n    'stickyHeader',\r\n    'stickyFooter',\r\n    'columnFilter',\r\n    'globalSearch',\r\n    'expandRows',\r\n    'sorting',\r\n  ];\r\n\r\n  constructor(\r\n    public dialog: MatDialog,\r\n    public service: MatTableExtService,\r\n    public formBuildersService: FormBuilder,\r\n    public domSanitizer: DomSanitizer,\r\n    public matIconRegistry: MatIconRegistry,\r\n    private cdr: ChangeDetectorRef\r\n  ) {\r\n    this.addIconsToRegistry();\r\n    if (this.dataSource) {\r\n      this.tableData = this.dataSource.data;\r\n    }\r\n  }\r\n  /**\r\n   *\r\n   * @param changes changes captured each time user changes property value.\r\n   */\r\n  ngOnChanges(changes: SimpleChanges) {\r\n    this.setPropertyValue(changes);\r\n  }\r\n\r\n  ngOnInit() {\r\n    if (this.dataSource) {\r\n      this.dataSource.filterPredicate = this.createFilter();\r\n    }\r\n  }\r\n\r\n  ngAfterViewInit() {\r\n    if (this.dataSource) {\r\n      this.dataSource.paginator = this.paginator;\r\n      this.dataSource.sort = this.sort;\r\n    }\r\n  }\r\n  /**\r\n   * @description checks and updates the the column's hide and show properties.\r\n   */\r\n  setColumnHideShow() {\r\n    if (\r\n      this.hideShowMenuGroup !== undefined &&\r\n      this.hideShowMenuGroup !== null\r\n    ) {\r\n      this.updateColumnsHideShow(this.hideShowMenuGroup.value);\r\n    }\r\n  }\r\n  /**\r\n   * @description set the properties of the table.\r\n   * @param changes changes captured each time user changes property value.\r\n   */\r\n  setPropertyValue(changes: SimpleChanges) {\r\n    let keys = Object.keys(changes);\r\n    keys.forEach((property) => {\r\n      if (this.inputPropertyKeys.includes(property)) {\r\n        this.setPropertiesMap[property](changes[property]);\r\n      } else if (property == 'showToolbar') {\r\n        if (changes['columns']) {\r\n          this.setToolbarMenuControls(changes['columns'].currentValue);\r\n        } else {\r\n          this.setToolbarMenuControls(this.columnsArray);\r\n        }\r\n      }\r\n    });\r\n  }\r\n  /**\r\n   * @description This mapping is used to set and update changesin the table.\r\n   */\r\n  setPropertiesMap: any = {\r\n    dataSource: (value: any) => this.setTableDataSource(value),\r\n    columns: (value: any) => this.setColumnsData(value.currentValue),\r\n    inlineRowEditing: (value: any) =>\r\n      this.showHideColumn('edit', value.currentValue),\r\n    popupRowEditing: (value: any) =>\r\n      this.showHideColumn('popup', value.currentValue),\r\n    enableDelete: (value: any) =>\r\n      this.showHideColumn('delete', value.currentValue),\r\n    rowSelection: (value: any) => this.setRowSelection(value.currentValue),\r\n    multiRowSelection: (value: any) => {\r\n      this.selection = new SelectionModel<any>(value.currentValue, []);\r\n    },\r\n    stickyHeader: (value: any) => {\r\n      this.stickyHeader = value.currentValue;\r\n    },\r\n    stickyFooter: (value: any) => {\r\n      this.stickyFooter = value.currentValue;\r\n    },\r\n    columnFilter: (value: any) => this.setColumnFilter(value.currentValue),\r\n    globalSearch: (value: any) =>\r\n      (this.dataSource.filterPredicate = this.createFilter()),\r\n    expandRows: (value: any) => {\r\n      this.loadingIndicator = true;\r\n      this.dataSource = new MatTableDataSource(this.tableData);\r\n      if (value.currentValue == true) {\r\n        if (!this.displayedColumns.includes('expand')) {\r\n          this.displayedColumns.push('expand');\r\n          this.columnsToDisplayWithExpand = [...this.displayedColumns];\r\n        }\r\n      } else {\r\n        this.columnsToDisplayWithExpand = [...this.displayedColumns];\r\n        if (this.displayedColumns.includes('expand')) {\r\n          let index = this.displayedColumns.indexOf('expand');\r\n          this.displayedColumns.splice(index, 1);\r\n        }\r\n        this.expandedElement = null;\r\n      }\r\n      setTimeout(() => {\r\n        this.loadingIndicator = false;\r\n      }, 200);\r\n    },\r\n    sorting: (value: any) => (this.dataSource.sort = this.sort),\r\n  };\r\n  /**\r\n   * @description used set data source for table.\r\n   * @param value data source value from user.\r\n   */\r\n  setTableDataSource(value: any) {\r\n    if (value.currentValue) {\r\n      this.tableData = value.currentValue.data;\r\n      this.dataSource = value.currentValue;\r\n      this.reCal();\r\n    } else {\r\n      this.dataSource = new MatTableDataSource([{}]);\r\n    }\r\n  }\r\n  /**\r\n   * @description used create seletion model and set selection column visibility.\r\n   * @param value boolean value to show or hide selection Column from table.\r\n   */\r\n  setRowSelection(value: boolean) {\r\n    this.selection = new SelectionModel<any>(true, []);\r\n    this.updateSelectionColumnVisibility(value);\r\n  }\r\n\r\n  /**\r\n   * @description create filter header row and assigns filter predicate to table data source.\r\n   * @param value boolean value to change  visibility of column filter row.\r\n   */\r\n  setColumnFilter(value: boolean) {\r\n    if (value) {\r\n      let array: string[] = [];\r\n      this.columnsArray.forEach((column, i) => {\r\n        if (\r\n          this.dynamicDisplayedColumns.filter((a) => a.name == column?.field)[0]\r\n            .show\r\n        ) {\r\n          array.push(column?.field + '_' + i);\r\n        }\r\n      });\r\n      this.headersFiltersIds = array;\r\n      this.dataSource.filterPredicate = this.createFilter();\r\n    } else {\r\n      this.headersFiltersIds = [];\r\n      this.dataSource.filter = '';\r\n    }\r\n    this.toggleFilters = value;\r\n  }\r\n  /**\r\n   * @description This method returns the list of visible column names.\r\n   * @returns list of visible column names.\r\n   */\r\n  getDisplayedColumns(): string[] {\r\n    let list = this.dynamicDisplayedColumns\r\n      .filter((cd) => cd.show)\r\n      .map((cd) => cd.name);\r\n    return list;\r\n  }\r\n  /**\r\n   * @param menuType type of menu to open from toolbar.\r\n   * @param event mouse event to open menu on that location.\r\n   */\r\n  openMenu(menuType: string, event: MouseEvent) {\r\n    this.menuX = event.clientX;\r\n    this.menuY = event.clientY;\r\n    switch (menuType) {\r\n      case 'export': {\r\n        this.exportMenuCtrl = true;\r\n        this.menuTrigger.openMenu();\r\n        break;\r\n      }\r\n      case 'hideShow': {\r\n        this.hideShowMenuCtrl = true;\r\n        this.openHideShowMenu(this.columnsArray);\r\n        break;\r\n      }\r\n      case 'columnPin': {\r\n        this.columnPinMenuCtrl = true;\r\n        this.openHideShowMenu(this.columnsArray);\r\n        break;\r\n      }\r\n    }\r\n  }\r\n  /**\r\n   * @description triggers when menu is closed and reset the required controls.\r\n   */\r\n  menuClosed() {\r\n    this.exportMenuCtrl = false;\r\n  }\r\n  /**\r\n   * @description set list of columns to display in table.\r\n   * @param columns columns array from user input.\r\n   */\r\n  setColumnsData(columns: MTExColumn[]) {\r\n    if (columns.length) {\r\n      this.columnsArray = [...columns];\r\n      this.setColumnsList(columns);\r\n    }\r\n  }\r\n  /**\r\n   * @description set list of columns to display in table.\r\n   * @param columns columns array from user input with configurations.\r\n   */\r\n  setColumnsList(columns: MTExColumn[]) {\r\n    this.columnsList = [];\r\n    this.displayedColumns = ['select', 'edit', 'popup', 'delete'];\r\n    let columnsArray: DisplayColumn[] = [];\r\n    columns.forEach((col) => {\r\n      if (typeof col?.header == 'string') {\r\n        this.columnsList.push(col?.header);\r\n        this.displayedColumns.push(col?.field);\r\n        columnsArray.push({ filter: true, name: col?.field, show: !col.hide });\r\n      }\r\n    });\r\n    this.dynamicDisplayedColumns = [\r\n      { filter: false, name: 'select', show: false },\r\n      { filter: false, name: 'edit', show: false },\r\n      { filter: false, name: 'popup', show: false },\r\n      { filter: false, name: 'delete', show: false },\r\n    ];\r\n    this.dynamicDisplayedColumns = columnsArray.concat(\r\n      this.dynamicDisplayedColumns\r\n    );\r\n  }\r\n  /**\r\n   * @description Take boolean value and name column and update its visibility status in table.\r\n   * @param name name of the column to set visibility.\r\n   * @param value boolean value to set visibility of the column.\r\n   */\r\n  showHideColumn(name: string, value: boolean) {\r\n    this.dynamicDisplayedColumns.filter((a) => a.name == name)[0].show = value;\r\n    if (this.columnFilter) {\r\n      this.setColumnFilter(true);\r\n    }\r\n  }\r\n  /**\r\n   * @description This method will position the selection column to first and also update its visibility.\r\n   * @param value value used to set visibility of the selection column.\r\n   */\r\n  updateSelectionColumnVisibility(value: boolean) {\r\n    let columnName = 'select';\r\n    let column = this.dynamicDisplayedColumns.filter(\r\n      (a) => a.name == columnName\r\n    )[0];\r\n    let index = this.dynamicDisplayedColumns.findIndex(\r\n      (column: any) => column.name == columnName\r\n    );\r\n    if (index > -1) {\r\n      this.dynamicDisplayedColumns.splice(index, 1);\r\n      this.dynamicDisplayedColumns.unshift(column);\r\n      this.dynamicDisplayedColumns.filter(\r\n        (column) => column.name == columnName\r\n      )[0].show = value;\r\n    }\r\n  }\r\n  /**\r\n   * @description This method is used to update the position of  column in columns array according to its dropped position.\r\n   * @param event CdkDragDrop used to update column position in columns array.\r\n   */\r\n  onDrop(event: CdkDragDrop<any>) {\r\n    if (this.dndColumns) {\r\n      let adjustedValue = 0;\r\n      if (\r\n        this.dynamicDisplayedColumns[0].name == 'select' &&\r\n        this.dynamicDisplayedColumns[0].show == false\r\n      ) {\r\n        adjustedValue = 1;\r\n      }\r\n      moveItemInArray(\r\n        this.dynamicDisplayedColumns,\r\n        event.previousIndex + adjustedValue,\r\n        event.currentIndex + adjustedValue\r\n      );\r\n    }\r\n  }\r\n  /**\r\n   * @description This methohd create filter predicate function which will set search value to table filters\r\n   * for both global and individual colum filtering.\r\n   * @returns returns boolean value to filter rows in table.\r\n   */\r\n  createFilter(): (data: any, filter: string) => boolean {\r\n    const tableFilterPredicate = (data: any, filter: string): boolean => {\r\n      let result: boolean = true;\r\n      // search all column fields\r\n      if (this.globalFilter) {\r\n        let expression = '';\r\n        let keys = Object.keys(data);\r\n        keys.forEach((key) => {\r\n          expression =\r\n            expression +\r\n            `data.${key}.toString().trim().toLowerCase().indexOf(this.globalFilter.toLowerCase()) !== -1 ||`;\r\n        });\r\n        if (\r\n          expression.charAt(expression.length - 2) +\r\n            expression.charAt(expression.length - 1) ==\r\n          '||'\r\n        ) {\r\n          expression = expression.substring(0, expression.length - 2);\r\n        }\r\n        result = eval(expression);\r\n      }\r\n      if (!result) {\r\n        return false;\r\n      }\r\n      let searchString = JSON.parse(filter);\r\n      //search single column field\r\n      if (this.individualFilter) {\r\n        return (\r\n          data[this.individualFilter]\r\n            .toString()\r\n            .trim()\r\n            .toLowerCase()\r\n            .indexOf(\r\n              searchString[this.individualFilter].toString().toLowerCase()\r\n            ) !== -1\r\n        );\r\n      }\r\n      return true;\r\n    };\r\n    return tableFilterPredicate;\r\n  }\r\n  /**\r\n   * @description assigns the search value to mat table data source to apply the filter.\r\n   * @param searchValue value to be searched from table rows.\r\n   */\r\n  applyGlobalFilter(searchValue: string) {\r\n    this.globalFilter = searchValue;\r\n    let columns: any = {};\r\n    this.columnsArray.forEach((column: MTExColumn) => {\r\n      if (column.field) columns[column.field] = searchValue;\r\n    });\r\n    this.dataSource.filter = JSON.stringify(columns);\r\n  }\r\n  /**\r\n   * @description This method is used to apply column based filtering\r\n   * @param searchValue value to be searched from table rows.\r\n   * @param column filter will be applied based on this column field.\r\n   */\r\n  applyColumnFilter(searchValue: FilterSearchValue, column: MTExColumn) {\r\n    this.individualFilter = column.field;\r\n    this.filterValues[column.field] = searchValue[column.field];\r\n    this.dataSource.filter = JSON.stringify(this.filterValues);\r\n  }\r\n  /**\r\n   * @description This method will take row and its index enable inline editing tools on that row.\r\n   * @param row row on which user wants to do edit.\r\n   * @param index index of the row where inline editing will be enabled.\r\n   */\r\n  enableInlineEditing(row: any, index: number) {\r\n    const rowData: any = {};\r\n    rowData['e' + index] = { ...row };\r\n    this.rowDataTemp = rowData;\r\n    setTimeout(() => {\r\n      this.tableData[index]['editable'] = !this.tableData[index]['editable'];\r\n    }, 0);\r\n  }\r\n  /**\r\n   * @description This method will create and return data to inline editing template.\r\n   * @param row row on which user wants to do edit.\r\n   * @param index index of the row where inline editing will be enabled.\r\n   * @param column current column of the table.\r\n   */\r\n  getInlineEditingData(row: MTExRow, index: number, column: MTExColumn) {\r\n    this.inlineEditingTemplateRefData = {\r\n      row: { ...row },\r\n      column: { ...column },\r\n      index: index,\r\n      updateFunc: this.updateInlineTemplateData,\r\n    };\r\n    return this.inlineEditingTemplateRefData;\r\n  }\r\n  /**\r\n   * @description This method will take data from inline editing template and update in table data source.\r\n   * @param row updated row from inline editing template.\r\n   */\r\n  updateInlineTemplateData = (row: MTExRow) => {\r\n    this.service.selectedRow.next(row);\r\n  };\r\n  /**\r\n   * @description This method set data for in-cell editing.\r\n   * @param row row on which user wants to do edit.\r\n   * @param index index of the row where inline editing will be enabled.\r\n   */\r\n  setCellData(row: MTExRow, index: number) {\r\n    this.currentRow = { ...row };\r\n    this.currentRowIndex = index;\r\n    this.rowDataTemp['e' + index] = { ...row };\r\n  }\r\n  /**\r\n   * @description This will restore the data and cencel the inline editing.\r\n   * @param row row on which user wants to do edit.\r\n   * @param index index of the row where inline editing will be enabled.\r\n   */\r\n  cancelInlineEditing(row: MTExRow, index: number) {\r\n    this.tableData.filter((a: any, i: number) => i == index)[0]['editable'] =\r\n      !this.tableData.filter((a: any, i: number) => i == index)[0]['editable'];\r\n    this.dataSource = new MatTableDataSource(this.tableData);\r\n    this.rowDataTemp['e' + index] = {};\r\n    this.service.selectedRow.next(undefined);\r\n  }\r\n  /**\r\n   * @description This method will save and update the inline editing data and emit the update row and index.\r\n   * @param row row on which user wants to do edit.\r\n   * @param index index of the row where inline editing will be enabled.\r\n   */\r\n  saveInlineEditing(row: MTExRow, index: number) {\r\n    if (!this.inlineEditingTemplateRef) {\r\n      this.tableData[index] = { ...this.rowDataTemp['e' + index] };\r\n      row = { ...this.rowDataTemp['e' + index] };\r\n    } else {\r\n      let changedData = this.service.selectedRow.value;\r\n      if (changedData) {\r\n        this.tableData[index] = { ...changedData };\r\n      }\r\n    }\r\n    this.dataSource = new MatTableDataSource(this.tableData);\r\n    this.rowDataTemp['e' + index] = {};\r\n    let data: RowChange = {\r\n      row: row,\r\n      index: index,\r\n    };\r\n    this.inlineChange.emit(data);\r\n    this.tableData[index]['editable'] = false;\r\n  }\r\n  /**\r\n   * @description This method will save and update the cell editing data and emit the update row and index.\r\n   */\r\n  saveCellEditing() {\r\n    this.cellEditing = {};\r\n    let index = this.currentRowIndex;\r\n    if (index > -1) {\r\n      if (this.cellEditingTemplateRef) {\r\n        let changedData = this.service.selectedRow.value;\r\n        if (changedData) {\r\n          this.tableData[index] = { ...changedData };\r\n        }\r\n      } else {\r\n        this.tableData[index] = { ...this.rowDataTemp['e' + index] };\r\n      }\r\n      this.dataSource = new MatTableDataSource(this.tableData);\r\n      this.rowDataTemp['e' + index] = {};\r\n      let data: RowChange = {\r\n        row: { ...this.tableData[index] },\r\n        index: index,\r\n      };\r\n      this.currentRowIndex = -1;\r\n      this.cellChange.emit(data);\r\n    }\r\n  }\r\n  /**\r\n   * @description This method will delete the row from the given index and emit the deleted row and index.\r\n   * @param row row to be deleted.\r\n   * @param index index of the row to be deleted.\r\n   */\r\n  deleteRow(row: any, index: number) {\r\n    this.tableData.splice(index, 1);\r\n    this.dataSource = new MatTableDataSource(this.tableData);\r\n    this.dataSource.paginator = this.paginator;\r\n    this.dataSource.sort = this.sort;\r\n    this.rowDeleted.emit({ removedRow: row, fromIndex: index });\r\n  }\r\n\r\n  /**\r\n   * @description This method will expand or collapse the row and emit expand event.\r\n   * @param row row to be expanded or collapsed.\r\n   * @param expand value used to expand or collapse the row.\r\n   * @param index index of the row.\r\n   */\r\n  expandRow(row: MTExRow, expand: boolean, index: number) {\r\n    if (this.expandRows) {\r\n      this.expansionChange.emit({ data: row, expanded: expand, index: index });\r\n      this.expandedElement = this.expandedElement === row ? null : row;\r\n    }\r\n  }\r\n  /**\r\n   * @description This method is used to set data for popup component and open editing dialog.\r\n   * @param row row which used want to edit.\r\n   */\r\n  openEditingDialog(row: MTExRow) {\r\n    const dialogConfig = new MatDialogConfig();\r\n    dialogConfig.disableClose = true;\r\n    dialogConfig.width = '40%';\r\n    dialogConfig.height = '70%';\r\n    dialogConfig.maxWidth = '100%';\r\n    let rowData = { ...row };\r\n    dialogConfig.data = {\r\n      row: rowData,\r\n      columns: [...this.columnsArray],\r\n      templateRef: this.popupEditingTemplateRef,\r\n    };\r\n    this.dialog\r\n      .open(EditingComponent, dialogConfig)\r\n      .afterClosed()\r\n      .subscribe((data) => {\r\n        let index = this.tableData.indexOf(row);\r\n        if (data && index > -1) {\r\n          this.tableData[index] = data;\r\n          this.dataSource = new MatTableDataSource(this.tableData);\r\n          let dataChange: RowChange = {\r\n            row: data,\r\n            index: index,\r\n          };\r\n          this.popupChange.emit(dataChange);\r\n        }\r\n      });\r\n  }\r\n  /**\r\n   * @description used to check whether all rows are selected.\r\n   */\r\n  isAllSelected() {\r\n    const numSelected = this.selection.selected.length;\r\n    const numRows = this.dataSource.data.length;\r\n    return numSelected === numRows;\r\n  }\r\n\r\n  /**\r\n   * @description this method is used to toggle the all and no rows selection.\r\n   */\r\n  toggleAllRows() {\r\n    if (this.isAllSelected()) {\r\n      this.selection.clear();\r\n      return;\r\n    }\r\n    this.selection.select(...this.dataSource.data);\r\n  }\r\n\r\n  /**\r\n   * @description This method is used return aria-label for selection column checkboxs.\r\n   * @param row row from table.\r\n   * @returns labels for selection column checkboxs.\r\n   */\r\n  checkboxLabel(row?: any): string {\r\n    if (!row) {\r\n      return `${this.isAllSelected() ? 'deselect' : 'select'} all`;\r\n    }\r\n    return `${this.selection.isSelected(row) ? 'deselect' : 'select'} row ${\r\n      row.position + 1\r\n    }`;\r\n  }\r\n\r\n  /**\r\n   * @description create form control for columns for hiding and and pinning purpose\r\n   * @param columns list of columns to be displayed\r\n   */\r\n  setToolbarMenuControls(columns: MTExColumn[]) {\r\n    if (columns.length > 0 && this.showToolbar) {\r\n      const group = this.formBuildersService.group({});\r\n      columns.forEach((column: MTExColumn) => {\r\n        const control = this.formBuildersService.control(true);\r\n        group.addControl(column.field, control);\r\n      });\r\n      this.hideShowMenuGroup = group;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * @param column current column\r\n   * @param event mouse event used to set the menu position\r\n   */\r\n  openPinnablePropertyMenu(column: MTExColumn, event: MouseEvent): void {\r\n    this.menuX = event.clientX;\r\n    this.menuY = event.clientY;\r\n    let options: MTExColumnPinOption[] = [\r\n      {\r\n        label: 'Pin Left',\r\n        value: 'left',\r\n        selected: false,\r\n        field: column.field,\r\n      },\r\n      {\r\n        label: 'Pin Right',\r\n        value: 'right',\r\n        selected: false,\r\n        field: column.field,\r\n      },\r\n      { label: 'No Pin', value: null, selected: false, field: column.field },\r\n    ];\r\n    if (column.pinned && column.pinned !== null) {\r\n      options.forEach((opt: MTExColumnPinOption) => {\r\n        if (opt.value === column.pinned) {\r\n          opt.selected = true;\r\n        }\r\n      });\r\n    } else if (column.pinned == null || column.pinned == 'null') {\r\n      options[2].selected = true;\r\n    }\r\n    this.columnPinningOptions = options;\r\n    this.columnMenuTrigger.openMenu();\r\n  }\r\n  /**\r\n   * @description This method is used to reset menu checks when required.\r\n   */\r\n  resetMenuChecks() {\r\n    this.hideShowMenuCtrl = false;\r\n    this.showHideColumnsArray = [];\r\n    this.columnPinMenuCtrl = false;\r\n    this.columnPinningOptions = [];\r\n  }\r\n  /**\r\n   * @description This method is used to filter columns for menus like pinning or hide show menu.\r\n   * @param value search value to filter colunms\r\n   */\r\n  filterColumns(value: string) {\r\n    if (value !== '') {\r\n      this.showHideColumnsArray = this.columnsArray.filter(\r\n        (col: MTExColumn) => {\r\n          return col.header!.toLowerCase().includes(value.toLowerCase());\r\n        }\r\n      );\r\n    } else {\r\n      this.showHideColumnsArray = this.columnsArray;\r\n    }\r\n  }\r\n  /**\r\n   * @description This method is used to open hide show column menu.\r\n   * @param columns columns array to display in hide show menu.\r\n   */\r\n  openHideShowMenu(columns: MTExColumn[]) {\r\n    this.showHideColumnsArray = [...columns];\r\n    this.columnMenuTrigger.openMenu();\r\n  }\r\n  /**\r\n   * @param values columns\r\n   */\r\n  updateColumnsHideShow(values: ColumnVisibility) {\r\n    let keys = Object.keys(values);\r\n    keys.forEach((key: string) => {\r\n      this.showHideColumn(key, values[key]);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * @description This method is called when the table rows are scrolled.\r\n   * @param event scroll event\r\n   */\r\n  onScroll(event: any) {\r\n    this.scroll.emit(event);\r\n  }\r\n  /**\r\n   * @param row row to be toggled\r\n   * @param index index of toggled row\r\n   */\r\n  setSelectedRows(row: any, index: number) {\r\n    this.selection.toggle(row);\r\n    if (this.selection.isSelected(row)) {\r\n      this.selectionChanged.emit({ row: row, index: index, isSelected: true });\r\n    } else {\r\n      this.selectionChanged.emit({ row: row, index: index, isSelected: false });\r\n    }\r\n  }\r\n/**\r\n * @description This method is used to display all hidden rows.\r\n */\r\n  showHiddenRows() {\r\n    this.hideRows = false;\r\n    this.selection.clear();\r\n    this.hiddenCtrl.clear();\r\n  }\r\n/**\r\n * @description This method is used to hide all selected rows.\r\n */\r\n  hideSelectedRows() {\r\n    if (!this.selection.isEmpty()) {\r\n      let values = [...this.selection.selected];\r\n      values.forEach((value) => {\r\n        if (!this.hiddenCtrl.isSelected(value)) {\r\n          this.hiddenCtrl.toggle(value);\r\n        }\r\n      });\r\n      this.selection.clear();\r\n      this.hideRows = true;\r\n    }\r\n  }\r\n/**\r\n * @description This method is used to recalculate the required values for table.\r\n */\r\n  reCal() {\r\n    if (this.showPaginator) {\r\n      this.dataSource.paginator = this.paginator;\r\n    }\r\n    if (this.sorting) {\r\n      this.dataSource.sort = this.sort;\r\n    }\r\n    if (this.columnFilter) {\r\n      this.dataSource.filterPredicate = this.createFilter();\r\n    }\r\n  }\r\n/**\r\n * @description This method is called in constructor method to add SVGs into icon registration.\r\n */\r\n  addIconsToRegistry() {\r\n    let y = this.domSanitizer.bypassSecurityTrustResourceUrl(\r\n      `assets/pinRight.svg`\r\n    );\r\n    let iconNames = ['pinLeft', 'pinRight', 'pinNone', 'pinned', 'pinIcon'];\r\n    iconNames.forEach((icon) => {\r\n      this.matIconRegistry.addSvgIcon(\r\n        icon,\r\n        this.domSanitizer.bypassSecurityTrustResourceUrl(\r\n          `assets/${icon}.svg`\r\n        )\r\n      );\r\n    });\r\n  }\r\n/**\r\n * @description This method is used to export table data.\r\n * @param type type of file to be exported.\r\n */\r\n  exportTable(type: string) {\r\n    var element = document.getElementById('matTableExt' + this.tableID);\r\n    var ws: XLSX.WorkSheet = XLSX.utils.table_to_sheet(element);\r\n    ws = this.writeSheetData(ws);\r\n    const wb: XLSX.WorkBook = XLSX.utils.book_new();\r\n    XLSX.utils.book_append_sheet(wb, ws, 'Sheet1');\r\n    XLSX.writeFile(wb, `tablesheets.${type}`);\r\n  }\r\n  /**\r\n   * @description This method is used to split name of filter row header to get index.\r\n   * @param value value to be splited for index.\r\n   * @returns Will return index of column from value.\r\n   */\r\n  returnIndex(value: string): number {\r\n    return Number(value.split('_')[1]);\r\n  }\r\n/**\r\n * @description This method is used to manage column filtering, expanded data for exporting.\r\n * @param ws work sheet\r\n * @returns custom generated worksheet to be used in export.\r\n */\r\n  writeSheetData(ws: XLSX.WorkSheet): XLSX.WorkSheet {\r\n    let displayedColumns = this.getDisplayedColumns();\r\n    var nMerges = this.getMergeIndex(ws['!merges'] || []);\r\n    var merges = ws['!merges'] || [];\r\n    let data: XLSX.WorkSheet = {\r\n      '!cols': [],\r\n      '!rows': [],\r\n      '!merges': nMerges,\r\n    };\r\n    var range = XLSX.utils.decode_range(ws['!ref'] || '');\r\n    let extracolumns = ['popup', 'delete', 'select', 'edit'];\r\n    let keys = Object.keys(ws);\r\n    let nKey = 'A';\r\n    keys.forEach((key, i) => {\r\n      if (ws[key]?.v && typeof ws[key]?.v === 'string') {\r\n        if (\r\n          !extracolumns.includes(ws[key].v.toLowerCase()) &&\r\n          displayedColumns.includes(ws[key].v.toLowerCase())\r\n        ) {\r\n          let lastRowIndex = range?.e?.r;\r\n          data[key] = ws[key];\r\n          let chr = key.charAt(0);\r\n          for (let j = 2; j <= lastRowIndex; j++) {\r\n            if (\r\n              ws[chr + (j + 1)] !== undefined &&\r\n              (typeof ws[chr + (j + 1)].v === 'string' ||\r\n                typeof ws[chr + (j + 1)].v === 'number')\r\n            ) {\r\n              data[nKey + j] = ws[chr + (j + 1)];\r\n            }\r\n          }\r\n          nKey = String.fromCharCode(nKey.charCodeAt(0) + 1);\r\n        }\r\n      }\r\n    });\r\n    if (this.rowSelection) {\r\n      let chr = 'A';\r\n      for (let i = 1; i < range.e.c + 1; i++) {\r\n        data[chr + 1] = data[String.fromCharCode(chr.charCodeAt(0) + 1) + 1];\r\n        chr = String.fromCharCode(chr.charCodeAt(0) + 1);\r\n        if (i == range.e.c) {\r\n          data[chr + 1] = undefined;\r\n        }\r\n      }\r\n    }\r\n    if (this.rowSelection && this.expandRows) {\r\n      merges.forEach((merge) => {\r\n        data['A' + merge.s.r] = ws['A' + (merge.s.r + 1)];\r\n      });\r\n    }\r\n    range.e.r--;\r\n    let nRef = XLSX.utils.encode_range(range);\r\n    data['!ref'] = nRef;\r\n    data['!fullref'] = nRef;\r\n    return data;\r\n  }\r\n  getMergeIndex(merges: any[]) {\r\n    var arr: any[] = [];\r\n    merges.forEach((element: any) => {\r\n      arr.push({\r\n        e: {\r\n          r: element.e.r == 0 ? element.e.r : element.e.r - 1,\r\n          c: element.e.c,\r\n        },\r\n        s: {\r\n          r: element.s.r == 0 ? element.s.r : element.s.r - 1,\r\n          c: element.s.c,\r\n        },\r\n      });\r\n    });\r\n    return arr;\r\n  }\r\n}\r\n","<mat-card class=\"main-table-ext-container mat-elevation-z8\" [style.width]=\"tableWidth\">\r\n    <mat-form-field class=\"global-search-field\" appearance=\"fill\" *ngIf=\"globalSearch\">\r\n        <mat-label>Search</mat-label>\r\n        <input matInput [ngModel]=\"globalFilter\" (ngModelChange)=\"applyGlobalFilter($event)\" placeholder=\"Ex. Mia\" #input>\r\n    </mat-form-field>\r\n    <mat-toolbar class=\"toolbar-container\" *ngIf=\"showToolbar\" [style.height]=\"toolbarHeight?toolbarHeight:'50px'\">\r\n        <span class=\"toolbar-title\" *ngIf=\"toolbarTitle\">{{toolbarTitle}}</span>\r\n        <ng-container *ngIf=\"toolbarTemplateRef\" [ngTemplateOutlet]=\"toolbarTemplateRef\"></ng-container>\r\n        <span class=\"example-spacer\"></span>\r\n        <ng-container *ngIf=\"rowSelection || multiRowSelection\">\r\n            <button class=\"hide-button\" mat-stroked-button color=\"primary\" (click)=\"hideSelectedRows()\">\r\n                Hide Rows\r\n            </button>\r\n            <button class=\"hide-button\" mat-stroked-button color=\"primary\" (click)=\"showHiddenRows()\">\r\n                Show All Rows\r\n            </button>\r\n        </ng-container>\r\n        <button *ngIf=\"columnHidable\" class=\"hide-button\" mat-stroked-button color=\"primary\"\r\n            (click)=\"openMenu('hideShow',$event)\" matTooltip=\"Column Visibility\" matTooltipPosition=\"above\">\r\n            <mat-icon>visibility</mat-icon>\r\n        </button>\r\n        <button *ngIf=\"columnPinnable\" class=\"pin-button\" mat-stroked-button color=\"primary\"\r\n            (click)=\"openMenu('columnPin',$event)\" matTooltip=\"Column Pinning\">\r\n            <mat-icon svgIcon=\"pinIcon\"></mat-icon>\r\n        </button>\r\n        <button *ngIf=\"exportButtonEnable\" class=\"export-button\" mat-stroked-button color=\"primary\"\r\n            (click)=\"openMenu('export',$event)\" matTooltip=\"Table Data Export\">\r\n            <mat-icon>import_export</mat-icon> <span>Export</span>\r\n            <mat-icon>expand_more</mat-icon>\r\n        </button>\r\n        <div style=\"visibility: hidden; position:fixed\" [matMenuTriggerFor]=\"menu\" [style.left.px]=\"menuX\"\r\n            [style.top.px]=\"menuY\"></div>\r\n    </mat-toolbar>\r\n    <mat-menu #menu=\"matMenu\" (closed)=\"menuClosed()\" id=\"exportMenu\">\r\n        <ng-container *ngIf=\"exportMenuCtrl\">\r\n            <mat-option (click)=\"exportTable('xlsx')\">Export to Excel</mat-option>\r\n            <mat-option (click)=\"exportTable('csv')\">Export to CSV</mat-option>\r\n        </ng-container>\r\n    </mat-menu>\r\n    <div style=\"visibility: hidden; position:fixed\" #columnMenuTrigger=\"matMenuTrigger\" [matMenuTriggerFor]=\"columnMenu\"\r\n        [style.left.px]=\"menuX\" [style.top.px]=\"menuY\">\r\n    </div>\r\n    <mat-menu #columnMenu=\"matMenu\" (closed)=\"resetMenuChecks()\">\r\n        <div class=\"toolbar-menu-container\" *ngIf=\"hideShowMenuCtrl\" [formGroup]=\"hideShowMenuGroup\"\r\n            (click)=\"$event.stopPropagation()\">\r\n            <h4 class=\"column-headers\">Visible Columns</h4>\r\n            <mat-form-field appearance=\"fill\" style=\"width: -webkit-fill-available;\">\r\n                <mat-label>Filter Columns</mat-label>\r\n                <input matInput [(ngModel)]=\"showHideFilter\" (ngModelChange)=\"filterColumns($event)\"\r\n                    [ngModelOptions]=\"{standalone: true}\">\r\n            </mat-form-field>\r\n            <div class=\"showHide-menu-columns-list\">\r\n                <div class=\"toolbar-menu-item\" *ngFor=\"let column of showHideColumnsArray\">\r\n                    <mat-checkbox color=\"primary\" class=\"toolbar-menu-checkbox\" style=\"width: max-content;\"\r\n                        [formControlName]=\"column.field\" (change)=\"setColumnHideShow()\">{{column.header}}</mat-checkbox>\r\n                </div>\r\n            </div>\r\n        </div>\r\n        <div class=\"toolbar-menu-container\" *ngIf=\"columnPinMenuCtrl\" (click)=\"$event.stopPropagation()\">\r\n            <h4 class=\"column-headers\">Pin Columns</h4>\r\n            <form class=\"example-form\">\r\n                <mat-form-field appearance=\"fill\" style=\"width: -webkit-fill-available;\">\r\n                    <mat-label>Filter Columns</mat-label>\r\n                    <input matInput [(ngModel)]=\"showHideFilter\" (ngModelChange)=\"filterColumns($event)\"\r\n                        [ngModelOptions]=\"{standalone: true}\">\r\n                </mat-form-field>\r\n            </form>\r\n            <div class=\"showHide-menu-columns-list\">\r\n                <app-column-pinning [columns]=\"showHideColumnsArray\"></app-column-pinning>\r\n            </div>\r\n        </div>\r\n    </mat-menu>\r\n\r\n    <mat-progress-bar *ngIf=\"loadingIndicator\" mode=\"indeterminate\"></mat-progress-bar>\r\n    <section id=\"tableContainer\" class=\"mat-table-ext-container\" (scroll)=\"onScroll($event)\"\r\n        [style.height]=\"tableHeight ? tableHeight :'max-content'\">\r\n        <table mat-table [id]=\"'matTableExt'+tableID\" [dataSource]=\"dataSource\" matSort cdkDropList\r\n            cdkDropListOrientation=\"horizontal\" multiTemplateDataRows (cdkDropListDropped)=\"onDrop($event)\"\r\n            (click)=\"saveCellEditing()\" [style.width]=\"scrollbarH?'max-content':'100%'\">\r\n            <!-- Row selection column -->\r\n            <ng-container matColumnDef=\"select\">\r\n                <th mat-header-cell *matHeaderCellDef cdkDragLockAxis=\"x\" cdkDrag [cdkDragDisabled]=\"!dndColumns\">\r\n                    <mat-checkbox (change)=\"$event ? toggleAllRows() : null\"\r\n                        [checked]=\"selection.hasValue() && isAllSelected()\"\r\n                        [indeterminate]=\"selection.hasValue() && !isAllSelected()\" [aria-label]=\"checkboxLabel()\">\r\n                    </mat-checkbox>\r\n                </th>\r\n                <td mat-cell *matCellDef=\"let row;let i = dataIndex\">\r\n                    <mat-checkbox (click)=\"$event.stopPropagation()\" (change)=\"$event ? setSelectedRows(row,i) : null\"\r\n                        [checked]=\"selection.isSelected(row)\" [aria-label]=\"checkboxLabel(row)\">\r\n                    </mat-checkbox>\r\n                </td>\r\n                <ng-container *ngIf=\"showFooterRow\">\r\n                    <td mat-footer-cell *matFooterCellDef></td>\r\n                </ng-container>\r\n            </ng-container>\r\n            <!--dynamic columns are being generated here-->\r\n            <div matColumnDef=\"{{column['field']}}\" [sticky]=\"column.pinned == 'left' ? true:false\"\r\n                [stickyEnd]=\"column.pinned == 'right' ? true:false\" *ngFor=\"let column of columnsArray; let i = index\">\r\n                <th mat-header-cell *matHeaderCellDef [style.width]=\"column.width\" [style.maxWidth]=\"column.maxWidth\"\r\n                    [style.minWidth]=\"column.minWidth\" cdkDragLockAxis=\"x\" cdkDrag [cdkDragDisabled]=\"!dndColumns\"\r\n                    [columnsResizable]=\"columnResizable\" [index]=\"i\">\r\n                    <span *ngIf=\"!headerTemplateRef\" matTooltip=\"{{column.headerTooltip?.value}}\"\r\n                        [matTooltipPosition]=\"column?.headerTooltip?.tooltipPosition!\" mat-sort-header\r\n                        [disabled]=\"!sorting || column.disabled === true\">{{column.header}}</span>\r\n                    <ng-container *ngIf=\"headerTemplateRef\" [ngTemplateOutlet]=\"headerTemplateRef\"\r\n                        [ngTemplateOutletContext]=\"{data:column}\"></ng-container>\r\n                    <ng-container *ngIf=\"column.headerTemplate\" [ngTemplateOutlet]=\"column.headerTemplate\"\r\n                        [ngTemplateOutletContext]=\"{data:column}\"></ng-container>\r\n                </th>\r\n                <td mat-cell *matCellDef=\"let row ;let i=dataIndex\">\r\n                    <div *ngIf=\"!row.editable && !cellEditing[i +'_'+column.field]\"\r\n                        (dblclick)=\"cellEditing[i +'_'+column.field] = inCellEditing;setCellData(row,i)\"\r\n                        matTooltip=\"{{column.cellTooltip?.value}}\"\r\n                        [matTooltipPosition]=\"column?.cellTooltip?.tooltipPosition!\">\r\n                        <span\r\n                            *ngIf=\"!cellTemplateRef && !column?.cellTemplate && !cellTemplateRefMap[column.field]\">{{row[column.field]}}</span>\r\n                        <ng-container *ngIf=\"cellTemplateRefMap[column.field]\"\r\n                            [ngTemplateOutlet]=\"cellTemplateRefMap[column.field]\"\r\n                            [ngTemplateOutletContext]=\"{row:row,column:column,index:i}\">\r\n                        </ng-container>\r\n                        <ng-container\r\n                            *ngIf=\"cellTemplateRef && column.cellTemplate && !cellTemplateRefMap[column.field]\"\r\n                            [ngTemplateOutlet]=\"column.cellTemplate\"\r\n                            [ngTemplateOutletContext]=\"{row:row,column:column,index:i}\">\r\n                        </ng-container>\r\n                        <ng-container\r\n                            *ngIf=\"!cellTemplateRef && column.cellTemplate && !cellTemplateRefMap[column.field]\"\r\n                            [ngTemplateOutlet]=\"column.cellTemplate\"\r\n                            [ngTemplateOutletContext]=\"{row:row,column:column,index:i}\">\r\n                        </ng-container>\r\n                        <ng-container\r\n                            *ngIf=\"cellTemplateRef && !column.cellTemplate && !cellTemplateRefMap[column.field]\"\r\n                            [ngTemplateOutlet]=\"cellTemplateRef\"\r\n                            [ngTemplateOutletContext]=\"{row:row,column:column,index:i}\">\r\n                        </ng-container>\r\n                    </div>\r\n                    <div *ngIf=\"row.editable || cellEditing[i +'_'+column.field]\" (click)=\"$event.stopPropagation()\">\r\n                        <ng-container *ngIf=\"inlineEditingTemplateRef && !cellEditing[i +'_'+column.field]\"\r\n                            [ngTemplateOutlet]=\"inlineEditingTemplateRef\"\r\n                            [ngTemplateOutletContext]=\"{data:getInlineEditingData(row,i,column)}\"></ng-container>\r\n                        <ng-container *ngIf=\"cellEditingTemplateRef && !(row.editable)\"\r\n                            [ngTemplateOutlet]=\"cellEditingTemplateRef\"\r\n                            [ngTemplateOutletContext]=\"{data:getInlineEditingData(row,i,column)}\"></ng-container>\r\n                        <ng-container *ngIf=\"!inlineEditingTemplateRef && (row.editable) && rowDataTemp['e'+i]\">\r\n                            <mat-form-field *ngIf=\"column.type == 'number'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <input matInput type=\"number\" [(ngModel)]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [ngModelOptions]=\"{standalone: true}\">\r\n                            </mat-form-field>\r\n                            <mat-form-field style=\"width: 100%;\" *ngIf=\"column.type == 'string'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <input matInput type=\"text\" [(ngModel)]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [ngModelOptions]=\"{standalone: true}\">\r\n                            </mat-form-field>\r\n                            <mat-form-field *ngIf=\"column.type == 'date'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <input matInput type=\"date\" [(ngModel)]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [ngModelOptions]=\"{standalone: true}\">\r\n                            </mat-form-field>\r\n                            <mat-form-field *ngIf=\"column.type == 'selection'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <mat-select [value]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [(ngModel)]=\"rowDataTemp['e'+i][column.field]\">\r\n                                    <mat-option *ngFor=\"let option of column.options\" [value]=\"option\">\r\n                                        {{option}}\r\n                                    </mat-option>\r\n                                </mat-select>\r\n                            </mat-form-field>\r\n                            <mat-checkbox (click)=\"$event.stopPropagation()\" *ngIf=\"column.type == 'boolean'\"\r\n                                color=\"primary\" [(ngModel)]=\"row[column.field]\"></mat-checkbox>\r\n                        </ng-container>\r\n                        <ng-container *ngIf=\"!cellEditingTemplateRef && cellEditing[i +'_'+column.field]\">\r\n                            <mat-form-field *ngIf=\"column.type == 'number'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <input matInput type=\"number\" [(ngModel)]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [ngModelOptions]=\"{standalone: true}\">\r\n                            </mat-form-field>\r\n                            <mat-form-field *ngIf=\"column.type == 'string'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <input matInput type=\"text\" [(ngModel)]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [ngModelOptions]=\"{standalone: true}\">\r\n                            </mat-form-field>\r\n                            <mat-form-field *ngIf=\"column.type == 'date'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <input matInput type=\"date\" [(ngModel)]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [ngModelOptions]=\"{standalone: true}\">\r\n                            </mat-form-field>\r\n                            <mat-form-field *ngIf=\"column.type == 'selection'\" appearance=\"outline\"\r\n                                class=\"inline-editing-field\">\r\n                                <mat-select [value]=\"rowDataTemp['e'+i][column.field]\"\r\n                                    [(ngModel)]=\"rowDataTemp['e'+i][column.field]\">\r\n                                    <mat-option *ngFor=\"let option of column.options\" [value]=\"option\">\r\n                                        {{option}}\r\n                                    </mat-option>\r\n                                </mat-select>\r\n                            </mat-form-field>\r\n                            <mat-checkbox (click)=\"$event.stopPropagation()\" *ngIf=\"column.type == 'boolean'\"\r\n                                color=\"primary\" [(ngModel)]=\"row[column.field]\"></mat-checkbox>\r\n                        </ng-container>\r\n                    </div>\r\n                </td>\r\n                <ng-container *ngIf=\"showFooterRow\">\r\n                    <td mat-footer-cell *matFooterCellDef> {{column.footerText}} </td>\r\n                </ng-container>\r\n            </div>\r\n            <ng-container matColumnDef=\"edit\" stickyEnd=\"false\">\r\n                <th mat-header-cell cdkDragLockAxis=\"x\" cdkDrag [cdkDragDisabled]=\"true\" *matHeaderCellDef\r\n                    class=\"action-column-cells\"> Edit </th>\r\n                <td mat-cell *matCellDef=\"let row; let i = dataIndex\" class=\"inline-edit-column-cell\">\r\n                    <mat-icon class=\"edit-column-icons\" *ngIf=\"!row.editable && !row.editmodal\" aria-hidden=\"false\"\r\n                        (click)=\"enableInlineEditing(row,i)\" fontIcon=\"edit_note\">\r\n                    </mat-icon>\r\n                    <div class=\"inline-editing-controls\" *ngIf=\"row.editable && !row.editmodal\">\r\n                        <mat-icon class=\"edit-column-icons\" aria-hidden=\"false\" (click)=\"saveInlineEditing(row,i)\"\r\n                            fontIcon=\"done\"></mat-icon>\r\n                        <mat-icon class=\"edit-column-icons\" aria-hidden=\"false\" (click)=\"cancelInlineEditing(row,i)\"\r\n                            fontIcon=\"close\"></mat-icon>\r\n                    </div>\r\n                </td>\r\n                <td mat-footer-cell *matFooterCellDef> edit </td>\r\n            </ng-container>\r\n            <ng-container matColumnDef=\"popup\" stickyEnd=\"false\">\r\n                <th mat-header-cell cdkDragLockAxis=\"x\" cdkDrag [cdkDragDisabled]=\"true\" *matHeaderCellDef\r\n                    class=\"action-column-cells\"> Popup\r\n                </th>\r\n                <td mat-cell *matCellDef=\"let row; let i = index\">\r\n                    <mat-icon aria-hidden=\"false\" (click)=\"openEditingDialog(row)\" fontIcon=\"edit\">\r\n                    </mat-icon>\r\n                </td>\r\n                <td mat-footer-cell *matFooterCellDef></td>\r\n            </ng-container>\r\n\r\n            <ng-container matColumnDef=\"delete\">\r\n                <th mat-header-cell cdkDragLockAxis=\"x\" cdkDrag [cdkDragDisabled]=\"true\" *matHeaderCellDef\r\n                    class=\"action-column-cells\"> Delete\r\n                </th>\r\n                <td mat-cell *matCellDef=\"let row;let i=dataIndex\">\r\n                    <mat-icon (click)=\"deleteRow(row,i)\" aria-hidden=\"false\" aria-label=\"Example home icon\"\r\n                        fontIcon=\"delete\">\r\n                    </mat-icon>\r\n                </td>\r\n                <td mat-footer-cell *matFooterCellDef></td>\r\n            </ng-container>\r\n            <!-- Expanded Content Column - The detail row is made up of this one column that spans across all columns -->\r\n            <ng-container *ngIf=\"expandRows\" matColumnDef=\"expandedDetail\">\r\n                <td mat-cell *matCellDef=\"let element;let i=dataIndex \"\r\n                    [attr.colspan]=\"columnsToDisplayWithExpand.length\">\r\n                    <div class=\"example-element-detail\"\r\n                        [@detailExpand]=\"element == expandedElement ? 'expanded' : 'collapsed'\">\r\n                        <ng-container *ngIf=\"expansionTemplateRef\" [ngTemplateOutlet]=\"expansionTemplateRef\"\r\n                            [ngTemplateOutletContext]=\"{$explicit:element,row:element,index:i}\">\r\n                        </ng-container>\r\n                    </div>\r\n                </td>\r\n            </ng-container>\r\n            <ng-container *ngFor=\"let ids of headersFiltersIds; let i=index\" [matColumnDef]=\"ids\">\r\n                <th mat-header-cell *matHeaderCellDef>\r\n                    <div class=\"filters-container\" [class.animate]=\"toggleFilters\">\r\n                        <app-filter-columns-component [obj]=\"columnsArray[returnIndex(ids)]\"\r\n                            (filterOutput)=\"applyColumnFilter($event,columnsArray[returnIndex(ids)])\"></app-filter-columns-component>\r\n                    </div>\r\n                </th>\r\n            </ng-container>\r\n            <tr mat-header-row *matHeaderRowDef=\" getDisplayedColumns(); sticky: stickyHeader\"></tr>\r\n            <tr mat-row *matRowDef=\"let row; columns:getDisplayedColumns(); let i=dataIndex;\" class=\"data-row\"\r\n                [ngClass]=\"{'data-row':expandRows,'stripedRows':(stripedRows &&  i % 2 == 1),'hoverClass':rowHover, 'hidden':hiddenCtrl.isSelected(row) && hideRows,'example-expanded-row':expandedElement === row}\"\r\n                (click)=\"expandRow(row, row !== expandedElement,i)\">\r\n            </tr>\r\n            <tr style=\"height: 0px;\" mat-header-row class=\"no-default-height\" *matHeaderRowDef=\"headersFiltersIds\">\r\n            </tr>\r\n            <ng-container *ngIf=\"expandRows\">\r\n                <tr style=\"height: 0px;\" mat-row *matRowDef=\"let row; columns: ['expandedDetail']\"\r\n                    [ngClass]=\"{'example-detail-row': (expandRows && row === expandedElement),'expand-row':row !== expandedElement}\">\r\n                </tr>\r\n            </ng-container>\r\n            <ng-container *ngIf=\"showFooterRow\">\r\n                <tr mat-footer-row *matFooterRowDef=\"getDisplayedColumns(); sticky: stickyFooter\"></tr>\r\n            </ng-container>\r\n        </table>\r\n    </section>\r\n    <mat-paginator *ngIf=\"showPaginator\" [pageSizeOptions]=\"pageSizeOptions\"\r\n        [showFirstLastButtons]=\"showFirstLastButtons\">\r\n    </mat-paginator>\r\n</mat-card>"]}