@competer/primeng-table 0.0.0-stage → 14.2.0

package/esm2020/lib/components/ecs-primeng-table/ecs-primeng-table.mjs

@@ -0,0 +1,1411 @@
+import { ECSPrimengTableI18nService } from '../../services/i18n.service';
+import { ECSTableTranslatePipe } from '../../pipes/ui-translate.pipe';
+import { Component, EventEmitter, HostListener, Input, ChangeDetectorRef, inject, Output, ViewChild, ViewEncapsulation } from '@angular/core';
+import { TranslateModule } from '@ngx-translate/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+// PrimeNG imports
+import { TableModule } from 'primeng/table';
+import { ButtonModule } from 'primeng/button';
+import { TooltipModule } from 'primeng/tooltip';
+import { InputTextModule } from 'primeng/inputtext';
+import { MultiSelectModule } from 'primeng/multiselect';
+import { CheckboxModule } from 'primeng/checkbox';
+import { PaginatorModule } from 'primeng/paginator';
+import { OverlayPanelModule } from 'primeng/overlaypanel';
+import { MenuModule } from 'primeng/menu';
+import { DeviceType, CellOverflowBehaviour, DataAlignHorizontal, DataAlignVertical, DataType, FrozenColumnAlign, TableViewSaveMode } from '../../enums';
+import { DEFAULT_TABLE_OPTIONS } from '../../interfaces';
+import { dataAlignHorizontalAsText, dataAlignVerticalAsText, dataTypeAsText, frozenColumnAlignAsText } from '../../utils';
+import { ECSPrimengTableStateService } from '../../services';
+import { TableCell } from '../table-cell/table-cell';
+import { TablePredefinedFilters } from '../table-predefined-filters/table-predefined-filters';
+import { TableButton } from '../table-button/table-button';
+import { ColumnSelector } from "../column-selector/column-selector";
+import { ExportExcel } from '../export-excel/export-excel';
+import { finalize, firstValueFrom, Observable, Subject, takeUntil } from 'rxjs';
+import { ViewsManagement } from "../views-management/views-management";
+import { TreeTableState } from '../../utils/tree-table-state';
+import * as i0 from "@angular/core";
+import * as i1 from "./ecs-primeng-table.service";
+import * as i2 from "../../services";
+import * as i3 from "@ngx-translate/core";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/forms";
+import * as i6 from "primeng/table";
+import * as i7 from "primeng/api";
+import * as i8 from "primeng/button";
+import * as i9 from "primeng/tooltip";
+import * as i10 from "primeng/inputtext";
+import * as i11 from "primeng/multiselect";
+import * as i12 from "primeng/checkbox";
+import * as i13 from "primeng/paginator";
+import * as i14 from "primeng/overlaypanel";
+import * as i15 from "primeng/menu";
+export class ECSPrimengTable {
+    constructor(tableService, notification) {
+        this.tableService = tableService;
+        this.notification = notification;
+        this.i18n = inject(ECSPrimengTableI18nService);
+        this.changeDetector = inject(ChangeDetectorRef, { optional: true });
+        this.stateScope = inject(ECSPrimengTableStateService, { optional: true });
+        this.destroy$ = new Subject();
+        this.initialStateApplied = false;
+        this.destroyed = false;
+        this.tableOptions = DEFAULT_TABLE_OPTIONS;
+        this.treeStateRestored = false;
+        this.onRowCheckboxChange = new EventEmitter(); // Emitter that returns the column selected and if it was selected or unselected
+        this.onRowSelect = new EventEmitter;
+        this.onRowUnselect = new EventEmitter;
+        this.onDataEndUpdate = new EventEmitter();
+        this.viewsModalShow = false;
+        this.tableViewCurrentSelectedAlias = null;
+        this.tableViewsFirstFetchDone = false;
+        this.excelReportTitle = "";
+        this.showExportModal = false;
+        this.showColumnSelector = false;
+        this.selectedRowsCheckbox = []; // An array to keep all the selected rows
+        this.selectAllLoading = false;
+        this.selectionQueryKey = '';
+        this.globalSearchText = null; // The text used by the global search
+        this.appliedGlobalSearchText = null;
+        this.globalSearchManaged = false;
+        this.tableViewsList = [];
+        this.tableViews_menuItems = [];
+        this.DataType = DataType;
+        this.CellOverflowBehaviour = CellOverflowBehaviour;
+        this.DataAlignHorizontal = DataAlignHorizontal;
+        this.DataAlignVertical = DataAlignVertical;
+        this.FrozenColumnAlign = FrozenColumnAlign;
+        this.TableViewSaveMode = TableViewSaveMode;
+        this.currentPage = 0; // The current page we are at
+        this.currentRowsPerPage = 0; // The current rows per page selected
+        this.allowedRowsPerPage = []; // The different values of rows per page allowed
+        this.totalRecords = 0; // The number of total records that are available (taking into account the filters)
+        this.totalRecordsNotFiltered = 0; // The total number of records available if no filters were applied
+        this.dateFormat = "dd-MMM-yyyy HH:mm:ss zzzz";
+        this.dateTimezone = "+00:00";
+        this.dateCulture = "en-US";
+        this.exportDateFormat = "dd-MMM-yyyy HH:mm:ss";
+        this.columns = [];
+        this.columnsCantBeHidden = [];
+        this.columnsSelected = [];
+        this.columnModalData = [];
+        this.filteredColumnData = [];
+        this.predefinedFiltersSelectedValuesCollection = {}; // Contains a collection of the predefined column filters selection (possible values come from 'predefinedFiltersCollection')
+        this.tableLazyLoadEventInformation = {}; // Data of the last lazy load event of the table
+        this.initialConfigurationFetched = false;
+        this.maxViews = 0;
+        this.deviceType = DeviceType.Desktop;
+        this.columnSelectionCustomized = false;
+        this.headerMenuItems = [];
+        this.rowMenuItems = [];
+        this.i18n.changes.pipe(takeUntil(this.destroy$)).subscribe(() => {
+            this.headerMenuItems = this.translateMenuItems(this.headerMenuItems);
+            this.rowMenuItems = this.translateMenuItems(this.rowMenuItems);
+            this.changeDetector?.markForCheck();
+        });
+    }
+    /** The applied query stays separate from text being typed during the debounce. */
+    get effectiveGlobalSearchText() {
+        return this.globalSearchManaged ? this.appliedGlobalSearchText : this.globalSearchText;
+    }
+    cancelGlobalSearch() {
+        if (this.globalSearchTimer !== undefined)
+            clearTimeout(this.globalSearchTimer);
+        this.globalSearchTimer = undefined;
+    }
+    restoreGlobalSearch(value) {
+        this.cancelGlobalSearch();
+        this.globalSearchText = value;
+        this.appliedGlobalSearchText = value || null;
+        this.globalSearchManaged = true;
+    }
+    globalSearchOption(value) {
+        return typeof value === 'number' && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+    }
+    onGlobalSearchInput(value) {
+        if (this.destroyed)
+            return;
+        this.cancelGlobalSearch();
+        if (!this.globalSearchManaged)
+            this.appliedGlobalSearchText = this.globalSearchText || null;
+        this.globalSearchManaged = true;
+        this.globalSearchText = value;
+        const minLength = this.globalSearchOption(this.tableOptions.globalFilter?.minLength);
+        const delay = this.globalSearchOption(this.tableOptions.globalFilter?.debounceTime);
+        const trimmed = value.trim();
+        const effective = trimmed.length >= minLength ? (trimmed || null) : null;
+        if (effective === (this.appliedGlobalSearchText?.trim() || null))
+            return;
+        const apply = () => {
+            this.globalSearchTimer = undefined;
+            if (this.destroyed)
+                return;
+            this.appliedGlobalSearchText = effective;
+            this.currentPage = 0;
+            this.dt.first = 0;
+            if (minLength === 0 && delay === 0) {
+                // Keep PrimeNG's existing filtering behavior when the feature is not configured.
+                this.dt.filterGlobal(value, 'contains');
+            }
+            else {
+                // Own the global delay so it is not added to PrimeNG's column-filter delay.
+                this.dt.filters = { ...this.dt.filters, global: { value: effective, matchMode: 'contains' } };
+                this.fetchTableData({ ...this.tableLazyLoadEventInformation, first: 0,
+                    rows: this.currentRowsPerPage, filters: this.dt.filters });
+            }
+        };
+        if (effective === null || delay === 0)
+            apply();
+        else
+            this.globalSearchTimer = setTimeout(apply, delay);
+    }
+    ngOnInit() {
+        this.i18n.connectPrimeNG();
+        if (this.tableOptions.tree)
+            this.treeState = new TreeTableState(this.tableOptions.tree);
+        this.validateStatePersistence();
+        this.updateResponsiveViewport();
+        this.fetchTableConfiguration();
+    }
+    ngAfterViewInit() {
+        this.calculateScrollHeight();
+        this.changeDetector?.detectChanges();
+    }
+    get compactHeader() {
+        return !!this.tableOptions.responsive?.headerMenu && this.deviceType !== DeviceType.Desktop;
+    }
+    get compactRows() {
+        return !!this.tableOptions.responsive?.rowMenu && this.deviceType !== DeviceType.Desktop;
+    }
+    get actionColumnWidth() {
+        return this.compactRows ? 56 : (this.tableOptions.rows?.action?.width ?? 150);
+    }
+    getColumnHeaderGroups(columns) {
+        if (!columns.some(column => column.headerGroup?.trim()))
+            return [];
+        const groups = [];
+        for (const column of columns) {
+            const label = column.headerGroup?.trim() ?? '';
+            const frozenColumnAlign = column.frozenColumnAlign ?? FrozenColumnAlign.Noone;
+            const previous = groups[groups.length - 1];
+            if (previous && previous.label === label && previous.frozenColumnAlign === frozenColumnAlign) {
+                previous.colspan++;
+            }
+            else {
+                groups.push({ field: column.field, label, colspan: 1, frozenColumnAlign });
+            }
+        }
+        return groups;
+    }
+    isInitiallyVisible(column) {
+        if (!column.canBeHidden)
+            return true;
+        if (column.startHidden)
+            return false;
+        const devices = column.visibleOnlyIn;
+        return !devices?.length || devices.some(device => device === this.deviceType || String(device).toLowerCase() === DeviceType[this.deviceType].toLowerCase());
+    }
+    updateResponsiveViewport() {
+        const options = this.tableOptions.responsive;
+        const tablet = options?.tabletMinWidth ?? 768;
+        const desktop = options?.desktopMinWidth ?? 1200;
+        if (!Number.isFinite(tablet) || !Number.isFinite(desktop) || tablet <= 0 || desktop <= tablet) {
+            throw new Error('ECS table responsive widths must be finite and 0 < tabletMinWidth < desktopMinWidth.');
+        }
+        const width = typeof window === 'undefined' ? desktop : window.innerWidth;
+        const next = width < tablet ? DeviceType.Mobile : width < desktop ? DeviceType.Tablet : DeviceType.Desktop;
+        if (next === this.deviceType)
+            return;
+        this.deviceType = next;
+        this.responsiveHeaderMenu?.hide();
+        this.responsiveRowMenu?.hide();
+        if (!this.initialConfigurationFetched || this.columnSelectionCustomized ||
+            !this.columns.some(column => column.visibleOnlyIn?.length))
+            return;
+        const selected = this.columns.filter(column => column.canBeHidden && this.isInitiallyVisible(column));
+        const shown = this.tableService.orderColumnsWithFrozens(this.columnsCantBeHidden.concat(selected));
+        const previous = this.tableOptions.columns?.shown ?? [];
+        if (shown.length === previous.length && shown.every((column, i) => column.field === previous[i].field))
+            return;
+        this.columnsSelected = selected;
+        this.tableOptions.columns.shown = shown;
+        this.showColumnSelector = false;
+        // Request newly visible fields without resetting filters, sorting or pagination.
+        if (this.initialStateApplied)
+            this.fetchTableData(this.tableLazyLoadEventInformation);
+    }
+    buttonVisible(button, row) {
+        return (button.visibleCondition?.(row) ?? true) &&
+            ((button.enabledCondition?.(row) ?? true) || !button.conditionFailHide);
+    }
+    hasRowMenuActions(row) {
+        return (this.tableOptions.rows?.action?.buttons ?? []).some(button => this.buttonVisible(button, row));
+    }
+    buttonMenuItems(buttons, row) {
+        return buttons.filter(button => this.buttonVisible(button, row)).map((button, index) => ({
+            label: button.label || button.tooltip || 'Action {{number}}',
+            _uiParams: { number: index + 1 },
+            icon: button.icon,
+            disabled: !(button.enabledCondition?.(row) ?? true),
+            command: () => {
+                if (this.buttonVisible(button, row) && (button.enabledCondition?.(row) ?? true) && button.action) {
+                    this.tableService.handleButtonsClick(button.action, row);
+                }
+            }
+        }));
+    }
+    closeResponsiveMenus() {
+        this.responsiveHeaderMenu?.hide();
+        this.responsiveRowMenu?.hide();
+    }
+    openRowMenu(event, row) {
+        event.stopPropagation();
+        this.responsiveHeaderMenu?.hide();
+        if (this.responsiveRowMenu?.visible && this.rowMenuRow === row) {
+            this.responsiveRowMenu.hide();
+            return;
+        }
+        // Use one overlay for all rows. Replacing the model binds every action to this row.
+        this.rowMenuRow = row;
+        this.rowMenuItems = this.translateMenuItems(this.buttonMenuItems(this.tableOptions.rows?.action?.buttons ?? [], row));
+        const wasOpen = this.responsiveRowMenu?.visible;
+        this.responsiveRowMenu?.show(event);
+        if (wasOpen)
+            this.responsiveRowMenu?.alignOverlay();
+    }
+    translateMenuItems(items) {
+        return items.map(item => {
+            if (item['_literalLabel'])
+                return item;
+            const key = item['_uiLabelKey'] ?? item.label;
+            return { ...item, _uiLabelKey: key, label: this.i18n.text(key, item['_uiParams']) };
+        });
+    }
+    openHeaderMenu(event) {
+        this.responsiveRowMenu?.hide();
+        const options = this.tableOptions;
+        const items = [];
+        if (options.columns?.selectorEnabled)
+            items.push({ label: 'Modify columns', icon: options.columns.selectorIcon, command: () => this.columnSelectorShow() });
+        if (options.header?.clearSortsEnabled)
+            items.push({ label: 'Clear sorts', icon: options.header.clearSortsIcon, disabled: !this.hasToClearSorts(this.dt), command: () => this.clearSorts(this.dt) });
+        if (options.header?.clearFiltersEnabled)
+            items.push({ label: 'Clear filters', icon: options.header.clearFiltersIcon, disabled: !this.hasToClearFilters(this.dt, this.globalSearchText), command: () => this.clearFilters(this.dt) });
+        if (this.tableViewsEnabled()) {
+            items.push({ label: this.tableViewCurrentSelectedAlias || options.views?.noViewSelectedText || 'Select a view', _literalLabel: !!this.tableViewCurrentSelectedAlias, icon: 'pi pi-bookmark', command: () => { this.viewsModalShow = true; } });
+            items.push({ label: 'Apply view again', icon: options.views?.reloadViewButtonIcon || 'pi pi-refresh', disabled: !this.tableViewCurrentSelectedAlias, command: () => this.viewLoad(this.tableViewCurrentSelectedAlias) });
+        }
+        if (options.excelReport?.url?.trim())
+            items.push({ label: 'Export to Excel', icon: 'pi pi-file-excel', command: () => this.openExcelExport() });
+        if (options.resetTableView?.enabled)
+            items.push({ label: 'Reset table view', icon: options.resetTableView.icon, command: () => this.resetTableView() });
+        items.push({ label: 'Refresh data', icon: 'pi pi-refresh', command: () => this.refreshData(event) });
+        items.push(...this.buttonMenuItems(options.header?.buttons ?? [], null));
+        this.headerMenuItems = this.translateMenuItems(items);
+        this.responsiveHeaderMenu?.toggle(event);
+    }
+    validateStatePersistence() {
+        if (!this.tableOptions.statePersistence?.enabled)
+            return;
+        if (!this.tableOptions.statePersistence.key?.trim() || !this.stateScope) {
+            throw new Error('ECS table statePersistence requires a non-empty key and ECSPrimengTableStateService provided on a parent scope component.');
+        }
+    }
+    ngOnDestroy() {
+        this.cancelGlobalSearch();
+        this.destroyed = true;
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.treeState?.cancel();
+        const options = this.tableOptions.statePersistence;
+        const key = options?.key?.trim();
+        if (!key || !this.stateScope)
+            return;
+        if (!options?.enabled) {
+            this.stateScope.clear(key);
+            return;
+        }
+        if (!this.initialStateApplied || !this.dt)
+            return;
+        const filters = structuredClone(this.dt.filters ?? {});
+        delete filters['global'];
+        delete filters['selector'];
+        this.stateScope.set(key, {
+            configurationUrl: this.tableOptions.urlTableConfiguration ?? '',
+            dataUrl: this.tableOptions.urlTableData ?? '',
+            filters,
+            multiSortMeta: structuredClone(this.dt.multiSortMeta ?? []),
+            globalSearchText: this.effectiveGlobalSearchText,
+            currentPage: this.currentPage,
+            currentRowsPerPage: this.currentRowsPerPage,
+            treeMode: this.treeState?.mode,
+            treeExpandedKeys: this.treeState ? [...this.treeState.expanded] : undefined,
+            treeChildPages: this.treeState?.snapshotPages()
+        });
+    }
+    restoreNavigationState() {
+        this.validateStatePersistence();
+        const options = this.tableOptions.statePersistence;
+        const key = options?.key?.trim();
+        if (!options?.enabled) {
+            if (key)
+                this.stateScope?.clear(key);
+            return false;
+        }
+        const state = this.stateScope.get(key);
+        if (!state)
+            return false;
+        if (state.configurationUrl !== this.tableOptions.urlTableConfiguration ||
+            state.dataUrl !== this.tableOptions.urlTableData || state.treeMode !== this.treeState?.mode) {
+            this.stateScope.clear(key);
+            return false;
+        }
+        const fields = new Set(this.columns.map(column => column.field));
+        const filters = {};
+        for (const [field, filter] of Object.entries(state.filters)) {
+            if (fields.has(field))
+                filters[field] = filter;
+        }
+        this.currentRowsPerPage = this.allowedRowsPerPage.includes(state.currentRowsPerPage)
+            ? state.currentRowsPerPage : this.currentRowsPerPage;
+        this.currentPage = this.currentRowsPerPage === state.currentRowsPerPage
+            ? Math.max(0, state.currentPage) : 0;
+        this.restoreGlobalSearch(state.globalSearchText);
+        this.treeState?.restore(state.treeExpandedKeys, state.treeChildPages);
+        this.treeStateRestored = !!this.treeState;
+        if (this.globalSearchText) {
+            filters['global'] = { value: this.globalSearchText, matchMode: 'contains' };
+        }
+        const sorts = state.multiSortMeta.filter(sort => fields.has(sort.field));
+        this.dt.filters = { ...this.dt.filters, ...structuredClone(filters) };
+        // Keep initialStateApplied=false while PrimeNG setters can emit lazy-load events.
+        this.dt.multiSortMeta = sorts;
+        this.dt.first = this.currentPage * this.currentRowsPerPage;
+        this.dt.rows = this.currentRowsPerPage;
+        this.tableLazyLoadEventInformation = {
+            first: this.dt.first,
+            rows: this.currentRowsPerPage,
+            filters: this.dt.filters,
+            multiSortMeta: sorts
+        };
+        this.restorePredefinedSelections(filters);
+        return true;
+    }
+    restorePredefinedSelections(filters) {
+        this.predefinedFiltersSelectedValuesCollection = {};
+        for (const column of this.columns) {
+            const key = column.filterPredefinedValuesName;
+            if (!key)
+                continue;
+            const criteria = filters[column.field];
+            const value = (Array.isArray(criteria) ? criteria[0] : criteria)?.value;
+            if (value === null || value === undefined)
+                continue;
+            this.predefinedFiltersSelectedValuesCollection[key] =
+                (this.tableOptions.predefinedFilters?.[key] ?? []).filter(option => Array.isArray(value) ? value.includes(option.value) : value === option.value);
+        }
+    }
+    onResize() {
+        this.updateResponsiveViewport();
+        this.calculateScrollHeight();
+    }
+    calculateScrollHeight() {
+        if (this.tableOptions.verticalScroll?.cssFormula) {
+            return;
+        }
+        if (this.tableOptions.verticalScroll?.fitToContainer && this.tableContainer && this.paginatorContainer && this.headerContainer) {
+            const containerRect = this.tableContainer.nativeElement.getBoundingClientRect();
+            const paginatorHeight = this.paginatorContainer.nativeElement.offsetHeight;
+            const headerHeight = this.headerContainer.nativeElement.offsetHeight;
+            const viewportHeight = window.innerHeight;
+            const topOffset = containerRect.top + window.scrollY;
+            this.tableOptions.verticalScroll.height = (viewportHeight - topOffset - paginatorHeight - headerHeight) - 60;
+        }
+    }
+    get scrollHeightValue() {
+        if (this.tableOptions.verticalScroll?.cssFormula) {
+            return this.tableOptions.verticalScroll.cssFormula;
+        }
+        const height = this.tableOptions.verticalScroll?.height;
+        return height && height > 0 ? `${height}px` : '';
+    }
+    /**
+     * Updates the table data and, if needed, retrieves the initial table configuration from an external source.
+     *
+     * Also allows resetting the table to its original state before any user manipulations.
+     *
+     * @param {boolean} [resetTableView=false] Optional.
+     * - `true`: resets the table state before loading data.
+     * - `false`: refreshes data using the current configuration (and retrieves initial configuration if necessary).
+     *
+     * **_Behavior_**
+     * - The table is automatically set to `isActive = true`.
+     * - If the initial configuration has not been fetched, it will fetch it and then update the data.
+     * - If the initial configuration is already fetched, it will just update the data.
+     * - If `resetTableView` is true and the configuration is already initialized, the table will be reset to its original state before updating the data.
+     */
+    updateData(resetTableView = false) {
+        this.tableOptions.isActive = true; // Enable table actions: the table is now active and can perform updates
+        if (!this.initialConfigurationFetched || resetTableView) { // If initial configuration hasn't been fetched yet or a reset is explicitly requested
+            if (this.initialConfigurationFetched && resetTableView) { // Reset the table only if it was already initialized and a reset is explicitly requested
+                this.resetTableView(); // Reset table state (filters, pagination, sorting, etc.) and then refresh data
+            }
+            else { // We only need to get the table configuration without reseting the view
+                this.fetchTableConfiguration(); // Fetch the initial table configuration before updating data
+            }
+        }
+        else { // Table is already initialized and no reset requested, just refresh the data
+            this.fetchTableData(this.tableLazyLoadEventInformation); // Update table rows using the last lazy load event
+        }
+    }
+    canFetchData() {
+        return !this.destroyed
+            && !!this.tableOptions.isActive
+            && !!this.tableOptions.urlTableConfiguration?.trim()
+            && !!this.tableOptions.urlTableData?.trim();
+    }
+    fetchTableConfiguration(resetTableView = false) {
+        if (!this.canFetchData()) {
+            return;
+        }
+        this.tableService.fetchTableConfiguration(this.tableOptions.urlTableConfiguration)
+            .pipe(takeUntil(this.destroy$)).subscribe({
+            next: (response) => {
+                this.handleTableConfigurationResponse(response.body, resetTableView);
+            },
+            error: (err) => this.tableService.handleTableError(err, 'Columns Error')
+        });
+    }
+    handleTableConfigurationResponse(body, resetTableView = false) {
+        this.allowedRowsPerPage = body.allowedItemsPerPage; // Update the number of rows allowed per page
+        this.currentRowsPerPage = Math.min(...this.allowedRowsPerPage); // Update the current rows per page to use the minimum value of allowed rows per page by default
+        this.columns = body.columnsInfo; // Update columns with fetched data
+        this.columnsCantBeHidden = this.columns.filter((col) => !col.canBeHidden); // Filter columns that cannot be hidden
+        this.columnSelectionCustomized = false;
+        this.columnsSelected = this.columns.filter(col => col.canBeHidden && this.isInitiallyVisible(col)); // Selected columns that are not hidden by default
+        this.tableOptions.columns.shown = this.tableService.orderColumnsWithFrozens(this.columnsCantBeHidden.concat(this.columnsSelected));
+        this.dateFormat = body.dateFormat;
+        this.dateTimezone = body.dateTimezone;
+        this.dateCulture = body.dateCulture;
+        this.exportDateFormat = body.exportDateFormat;
+        this.currentPage = 0;
+        this.initialConfigurationFetched = true;
+        this.maxViews = body.maxViews;
+        if (resetTableView) {
+            this.tableOptions.isActive = false;
+            this.clearFilters(this.dt, true);
+            this.clearSorts(this.dt, true);
+            this.dt.tableWidthState = this.initialTableWidth;
+            this.dt.columnWidthsState = this.initialColumnWidths;
+            this.dt.restoreColumnWidths();
+            this.tableLazyLoadEventInformation.multiSortMeta = [];
+            this.tableOptions.isActive = true;
+            this.initialStateApplied = true;
+            this.tableLazyLoadEventInformation.first = 0;
+            this.tableLazyLoadEventInformation.rows = this.currentRowsPerPage;
+            this.fetchTableData(this.tableLazyLoadEventInformation);
+        }
+        else {
+            setTimeout(() => {
+                if (this.destroyed)
+                    return;
+                this.initialColumnWidths = this.tableService.computeColumnWidths(this.dt);
+                this.initialTableWidth = this.tableService.computeTableWidth(this.dt);
+            }, 0);
+            this.fetchTableViews();
+        }
+    }
+    refreshData(event) {
+        this.fetchTableData(this.tableLazyLoadEventInformation);
+    }
+    tableViewsEnabled() {
+        const views = this.tableOptions.views;
+        if (views?.saveMode === TableViewSaveMode.None) { // saveMode must be different from noone
+            return false;
+        }
+        if (!views?.saveKey?.trim()) { // saveKey must exist and must not be empty after trim
+            return false;
+        }
+        if (this.maxViews <= 0) { // maxViews must be greater than 0
+            return false;
+        }
+        if (views?.saveMode === TableViewSaveMode.DatabaseStorage) { // If saveMode is database, urlGet and urlSave must exist and must not be empty after trim
+            if (!views?.urlGet?.trim() || !views?.urlSave?.trim()) {
+                return false;
+            }
+        }
+        return true; // All checks passed, views are enabled
+    }
+    fetchTableViews() {
+        if (!this.tableViewsEnabled()) {
+            this.startInitialDataLoad();
+            return;
+        }
+        const tableViews = this.tableService.fetchTableViews(this.tableOptions.views.saveMode, this.tableOptions.views.urlGet, this.tableOptions.views.saveKey);
+        if (tableViews instanceof Observable) {
+            tableViews.pipe(takeUntil(this.destroy$)).subscribe({
+                next: (response) => {
+                    let parsedResult = response.body.map((item) => ({
+                        viewAlias: item.viewAlias,
+                        viewData: JSON.parse(item.viewData),
+                        lastActive: item.lastActive
+                    }));
+                    this.tableViewListProcess(parsedResult);
+                },
+                error: (err) => {
+                    this.tableService.handleTableError(err, 'Views get error');
+                    this.startInitialDataLoad();
+                }
+            });
+        }
+        else {
+            this.tableViewListProcess(tableViews);
+        }
+    }
+    tableViewListProcess(tableViews) {
+        this.tableViewsList = [...tableViews];
+        if (this.tableViewsList.length > 0) {
+            this.tableService.sortViews(this.tableViewsList);
+        }
+        this.tableViews_menuItems = [...this.tableService.updateViewsMenuItems(this.tableViewsList)];
+        this.startInitialDataLoad();
+    }
+    startInitialDataLoad() {
+        if (this.initialStateApplied || this.destroyed)
+            return;
+        const restored = this.restoreNavigationState();
+        this.initialStateApplied = true;
+        const viewToStartup = restored ? undefined : this.tableViewsList.find(v => v.lastActive);
+        if (viewToStartup) { // If there is a view that needs to be loaded on startup
+            this.viewLoad(viewToStartup.viewAlias);
+        }
+        else {
+            this.fetchTableData(this.tableLazyLoadEventInformation);
+        }
+    }
+    viewLoad(tableViewAlias) {
+        const viewToLoad = this.tableViewsList.find(v => v.viewAlias === tableViewAlias);
+        if (!viewToLoad) {
+            this.notification.showToast("error", this.i18n.text("VIEW TO LOAD DOESN'T EXIST"), this.i18n.text("The view to load doesn't exist"));
+            return;
+        }
+        this.columnSelectionCustomized = true;
+        let viewData = viewToLoad.viewData;
+        this.treeState?.restore(viewData.treeExpandedKeys, viewData.treeChildPages);
+        this.treeStateRestored = !!this.treeState;
+        this.columnsSelected = viewData.columnsShown
+            .map(data => this.columns.find((col) => col.field === data.field))
+            .filter((col) => col !== undefined)
+            .filter(col => !this.columnsCantBeHidden.includes(col));
+        this.tableOptions.columns.shown = this.tableService.orderColumnsWithFrozens(this.columnsCantBeHidden.concat(this.columnsSelected));
+        this.currentPage = viewData.currentPage;
+        this.currentRowsPerPage = viewData.currentRowsPerPage;
+        this.restoreGlobalSearch(viewData.globalSearchText);
+        this.tableOptions.isActive = false;
+        this.tableLazyLoadEventInformation.multiSortMeta = [...(viewData.multiSortMeta ?? [])];
+        this.dt.multiSortMeta = [...(viewData.multiSortMeta ?? [])];
+        this.dt.sortMultiple();
+        this.dt.first = this.currentPage * this.currentRowsPerPage;
+        this.dt.rows = this.currentRowsPerPage;
+        this.tableLazyLoadEventInformation.first = this.dt.first;
+        this.tableLazyLoadEventInformation.rows = this.currentRowsPerPage;
+        this.tableOptions.isActive = true;
+        this.tableLazyLoadEventInformation.filters = structuredClone(viewData.filters);
+        this.dt.filters = structuredClone(viewData.filters);
+        this.restorePredefinedSelections(viewData.filters);
+        this.dt.tableWidthState = viewData.tableWidth;
+        this.dt.columnWidthsState = viewData.columnsWidth;
+        this.tableViewCurrentSelectedAlias = tableViewAlias;
+        this.notification.showToast("info", this.i18n.text("TABLE VIEW RESTORED"), this.i18n.text("The table view '{{value0}}' has been restored.", { value0: this.tableViewCurrentSelectedAlias }));
+        this.viewsModalShow = false;
+        this.fetchTableData(this.tableLazyLoadEventInformation);
+    }
+    viewCreate(viewAlias) {
+        if (this.tableViewsList.length >= this.maxViews) {
+            this.notification.showToast("error", this.i18n.text("NO MORE VIEWS ALLOWED"), this.i18n.text("You have created the maximum number of allowed views for this table"));
+            return;
+        }
+        let viewData = this.generateViewData();
+        let newView = {
+            lastActive: false,
+            viewAlias: viewAlias,
+            viewData: viewData
+        };
+        this.tableViewsList.push(newView);
+        this.tableService.sortViews(this.tableViewsList);
+        this.tableViews_menuItems = [...this.tableService.updateViewsMenuItems(this.tableViewsList)];
+        this.tableViewCurrentSelectedAlias = viewAlias;
+        this.viewsSave(0);
+    }
+    viewDelete(viewAlias) {
+        const index = this.tableViewsList.findIndex(v => v.viewAlias === viewAlias);
+        if (index === -1) {
+            this.notification.showToast("error", this.i18n.text("Table view delete failed"), this.i18n.text("The table view could not be deleted since it was not found."));
+            return;
+        }
+        this.tableViewsList.splice(index, 1);
+        this.tableViews_menuItems = [...this.tableService.updateViewsMenuItems(this.tableViewsList)];
+        if (this.tableViewCurrentSelectedAlias === viewAlias) {
+            this.tableViewCurrentSelectedAlias = null;
+        }
+        this.viewsSave(3);
+    }
+    viewEditAlias(event) {
+        const index = this.tableViewsList.findIndex(v => v.viewAlias === event.viewAliasOld);
+        if (index === -1) {
+            this.notification.showToast("error", this.i18n.text("Table view alias change failed"), this.i18n.text("The table view alias could not be changed since it was not found."));
+            return;
+        }
+        this.tableViewsList[index].viewAlias = event.viewAliasNew;
+        this.tableService.sortViews(this.tableViewsList);
+        this.tableViews_menuItems = [...this.tableService.updateViewsMenuItems(this.tableViewsList)];
+        if (this.tableViewCurrentSelectedAlias === event.viewAliasOld) {
+            this.tableViewCurrentSelectedAlias = event.viewAliasNew;
+        }
+        this.viewsSave(2);
+    }
+    viewUpdateData(viewAlias) {
+        const index = this.tableViewsList.findIndex(v => v.viewAlias === viewAlias);
+        if (index === -1) {
+            this.notification.showToast("error", this.i18n.text("Table view not found"), this.i18n.text("The table view to update data from was not found."));
+            return;
+        }
+        let viewData = this.generateViewData();
+        this.tableViewsList[index].viewData = viewData;
+        this.viewsSave(1);
+    }
+    viewUpdateActiveStartup(viewAlias) {
+        const index = this.tableViewsList.findIndex(v => v.viewAlias === viewAlias);
+        if (index === -1) {
+            this.notification.showToast("error", this.i18n.text("Table view not found"), this.i18n.text("The table view to update data from was not found."));
+            return;
+        }
+        let newStatus = !this.tableViewsList[index].lastActive;
+        this.tableViewsList.forEach(v => v.lastActive = false);
+        this.tableViewsList[index].lastActive = newStatus;
+        this.tableViews_menuItems = [...this.tableService.updateViewsMenuItems(this.tableViewsList)];
+        this.viewsSave(4);
+    }
+    viewsSave(endMessage) {
+        let tableView = JSON.stringify(this.tableViewsList);
+        switch (this.tableOptions.views.saveMode) {
+            case TableViewSaveMode.SessionStorage:
+                sessionStorage.setItem(this.tableOptions.views.saveKey, tableView);
+                break;
+            case TableViewSaveMode.LocalStorage:
+                localStorage.setItem(this.tableOptions.views.saveKey, tableView);
+                break;
+            case TableViewSaveMode.DatabaseStorage:
+                const saveObsv = this.tableService.viewsSaveToDatabase(this.tableViewsList, this.tableOptions.views.urlSave, this.tableOptions.views.saveKey);
+                saveObsv.subscribe({
+                    next: (response) => {
+                        this.viewsSaveEnd(endMessage);
+                    },
+                    error: (err) => this.tableService.handleTableError(err, 'Views save error')
+                });
+                return;
+            default:
+                this.notification.showToast("error", this.i18n.text("NOT IMPLEMENTED"), this.i18n.text("This type os save view has not been implemented yet."));
+                return;
+        }
+        this.viewsSaveEnd(endMessage);
+    }
+    viewsSaveEnd(endMessage) {
+        this.changeDetector?.markForCheck();
+        switch (endMessage) {
+            case 0: // NEW VIEW
+                this.notification.showToast("info", this.i18n.text("Table view created"), this.i18n.text("New table view has been created."));
+                this.viewsModalShow = false;
+                break;
+            case 1: // UPDATE VIEW
+                this.notification.showToast("info", this.i18n.text("Table view data updated"), this.i18n.text("The table view data was updated."));
+                break;
+            case 2: // UPDATE ALIAS
+                this.notification.showToast("info", this.i18n.text("Table view name updated"), this.i18n.text("The table view alias was updated."));
+                break;
+            case 3: // DELETE VIEW
+                this.notification.showToast("info", this.i18n.text("Table view delete"), this.i18n.text("The table view was deleted."));
+                break;
+            case 4: // DELETE VIEW
+                this.notification.showToast("info", this.i18n.text("Table view active on startup"), this.i18n.text("Changed the view that will be active on startup."));
+                break;
+        }
+    }
+    fetchTableData(event) {
+        if (!this.canFetchData()) {
+            return;
+        }
+        if (!this.initialConfigurationFetched || !this.initialStateApplied) {
+            return;
+        }
+        this.responsiveRowMenu?.hide();
+        this.tableLazyLoadEventInformation = event; // Store the event information for later use
+        if (event.rows != null && event.rows !== undefined) {
+            this.currentRowsPerPage = event.rows;
+        }
+        if (event.first != null && event.first !== undefined && event.rows != null && event.rows !== undefined) {
+            this.currentPage = event.first / event.rows;
+        }
+        let filtersWithoutGlobalAndSelectedRows = this.modifyFiltersWithoutGlobalAndSelectedRows(this.tableLazyLoadEventInformation.filters); // Create filters excluding the global filter
+        filtersWithoutGlobalAndSelectedRows = this.revertDateTimeZoneFilters(filtersWithoutGlobalAndSelectedRows);
+        const requestData = {
+            page: this.currentPage,
+            pageSize: this.currentRowsPerPage,
+            sort: this.tableLazyLoadEventInformation.multiSortMeta,
+            filter: filtersWithoutGlobalAndSelectedRows,
+            globalFilter: this.effectiveGlobalSearchText,
+            columns: this.tableOptions.columns.shown.map(col => col.field),
+            dateFormat: this.dateFormat,
+            dateTimezone: this.dateTimezone,
+            dateCulture: this.dateCulture,
+            exportDateFormat: this.exportDateFormat
+        };
+        const selectionKey = JSON.stringify({ ...requestData, page: 0, pageSize: 0, sort: null });
+        if (selectionKey !== this.selectionQueryKey)
+            this.matchingSelectionKeys = undefined;
+        this.selectionQueryKey = selectionKey;
+        this.selectionQuery = structuredClone(requestData);
+        if (this.treeState) {
+            const tree = this.treeState;
+            if (!this.treeStateRestored)
+                tree.restore([...tree.expanded], tree.snapshotPages());
+            this.treeStateRestored = false;
+            const structural = [tree.options.keyExpr, tree.options.parentIdExpr, tree.options.hasItemsExpr, 'rowID'];
+            requestData.columns = [...new Set([...requestData.columns, ...structural.filter((field) => !!field)])];
+            this.treeQuery = structuredClone(requestData);
+            const loading = tree.load(this.currentPage, this.currentRowsPerPage, this.treeFetcher(requestData));
+            this.tableOptions.data = [];
+            loading.then(updated => {
+                if (updated && !this.destroyed)
+                    this.syncTreeRows();
+            }).catch(error => {
+                if (!this.destroyed)
+                    this.tableService.handleTableError(error, 'Tree data error');
+            }).finally(() => {
+                if (!this.destroyed) {
+                    this.changeDetector?.markForCheck();
+                    this.onDataEndUpdate.emit();
+                }
+            });
+            return;
+        }
+        this.tableService.fetchTableData(this.tableOptions.urlTableData, requestData)
+            .pipe(takeUntil(this.destroy$), finalize(() => {
+            if (this.destroyed)
+                return;
+            this.onDataEndUpdate.emit(); // This is always executed after data update.
+        }))
+            .subscribe({
+            next: (response) => this.handleTableDataResponse(response.body),
+            error: (err) => this.tableService.handleTableError(err, 'Columns Error')
+        });
+    }
+    modifyFiltersWithoutGlobalAndSelectedRows(filters, overrideOption = -1) {
+        let filtersWithoutGlobalAndSelectedRows = structuredClone(filters ?? {}); // Create a copy of filters to delete the global.
+        if (filtersWithoutGlobalAndSelectedRows.hasOwnProperty('global')) { // If there is an entry with the global filter
+            delete filtersWithoutGlobalAndSelectedRows['global']; // Remove the global filter
+        }
+        this.selectorRowFilterBuilder(filtersWithoutGlobalAndSelectedRows, overrideOption);
+        return filtersWithoutGlobalAndSelectedRows; // Return the filters without global array
+    }
+    resetTableView() {
+        this.cancelGlobalSearch();
+        const key = this.tableOptions.statePersistence?.key?.trim();
+        if (key)
+            this.stateScope?.clear(key);
+        this.treeState?.restore();
+        this.treeStateRestored = !!this.treeState;
+        this.initialStateApplied = false;
+        this.tableViewCurrentSelectedAlias = '';
+        this.fetchTableConfiguration(true);
+    }
+    selectorRowFilterBuilder(filtersWithoutGlobalAndSelectedRows, overrideOption = -1) {
+        if (filtersWithoutGlobalAndSelectedRows.hasOwnProperty('selector') || overrideOption === 1 || overrideOption === 2) {
+            const selectorFilter = filtersWithoutGlobalAndSelectedRows['selector']?.[0];
+            let filterType = null;
+            if (overrideOption < 0 || overrideOption > 2) {
+                filterType = selectorFilter?.value ?? null;
+            }
+            else {
+                switch (overrideOption) {
+                    case 0: // All
+                        filterType = null;
+                        break;
+                    case 1: // Only selected rows
+                        filterType = true;
+                        break;
+                    case 2: // Only NOT selected
+                        filterType = false;
+                        break;
+                }
+            }
+            if (!filtersWithoutGlobalAndSelectedRows.hasOwnProperty('rowID')) {
+                filtersWithoutGlobalAndSelectedRows['rowID'] = [
+                    {
+                        "value": null,
+                        "matchMode": "in",
+                        "operator": "or"
+                    }
+                ];
+            }
+            const idFilter = filtersWithoutGlobalAndSelectedRows['rowID'][0];
+            if (filterType === true) {
+                idFilter.matchMode = "in";
+                idFilter.value = this.selectedRowsCheckbox;
+            }
+            else if (filterType === false) {
+                idFilter.operator = "and";
+                idFilter.matchMode = "notIn";
+                idFilter.value = this.selectedRowsCheckbox;
+            }
+            else if (filterType === null) {
+                idFilter.value = null;
+                idFilter.matchMode = "in";
+            }
+        }
+    }
+    revertDateTimeZoneFilters(inputFilter) {
+        this.tableOptions.columns.shown.forEach((column) => {
+            if (column.dataType === DataType.Date) { // If its date type
+                if (inputFilter.hasOwnProperty(column.field)) {
+                    const originalDate = inputFilter[column.field][0].value;
+                    if (originalDate !== null && originalDate instanceof Date) {
+                        const utcDate = new Date(Date.UTC(originalDate.getFullYear(), originalDate.getMonth(), originalDate.getDate()));
+                        inputFilter[column.field][0].value = utcDate;
+                    }
+                }
+            }
+        });
+        return inputFilter;
+    }
+    handleTableDataResponse(body) {
+        this.tableOptions.data = body.data; // Update the table data
+        this.totalRecords = body.totalRecords; // Update the total number of records
+        this.totalRecordsNotFiltered = body.totalRecordsNotFiltered; // Update the total records not filtered
+        this.currentPage = body.page; // Update the current page
+    }
+    generateViewData() {
+        const view = this.tableService.viewGenerateData(this.dt, this.effectiveGlobalSearchText, this.currentPage, this.currentRowsPerPage, this.modifyFiltersWithoutGlobalAndSelectedRows.bind(this));
+        if (this.treeState) {
+            view.treeExpandedKeys = [...this.treeState.expanded];
+            view.treeChildPages = this.treeState.snapshotPages();
+        }
+        return view;
+    }
+    treeFetcher(query) {
+        return async (request) => {
+            const response = await firstValueFrom(this.tableService.fetchTableData(this.tableOptions.urlTableData, { ...structuredClone(query), ...request }).pipe(takeUntil(this.destroy$)));
+            if (!response.body)
+                throw new Error('Empty tree response.');
+            return response.body;
+        };
+    }
+    syncTreeRows() {
+        const tree = this.treeState;
+        this.tableOptions.data = tree.visible;
+        this.totalRecords = tree.totalRecords;
+        this.totalRecordsNotFiltered = tree.totalRecordsNotFiltered;
+        this.currentPage = tree.page;
+        this.changeDetector?.markForCheck();
+    }
+    async toggleTreeRow(event, row) {
+        event.stopPropagation();
+        if (!this.treeState || !this.treeQuery || this.treeState.loading)
+            return;
+        try {
+            const update = this.treeState.toggle(row, this.treeFetcher(this.treeQuery));
+            this.changeDetector?.markForCheck();
+            await update;
+            if (!this.destroyed)
+                this.syncTreeRows();
+        }
+        catch (error) {
+            if (!this.destroyed)
+                this.tableService.handleTableError(error, 'Tree data error');
+        }
+        finally {
+            if (!this.destroyed) {
+                this.changeDetector?.markForCheck();
+                this.onDataEndUpdate.emit();
+            }
+        }
+    }
+    async loadMoreTreeRows(event, row) {
+        event.stopPropagation();
+        if (!this.treeState || !this.treeQuery || this.treeState.loading)
+            return;
+        try {
+            await this.treeState.loadMore(row, this.treeFetcher(this.treeQuery));
+            if (!this.destroyed)
+                this.syncTreeRows();
+        }
+        catch (error) {
+            if (!this.destroyed)
+                this.tableService.handleTableError(error, 'Tree data error');
+        }
+    }
+    get treeColumn() {
+        const columns = this.tableOptions.columns?.shown ?? [];
+        return columns.find(column => column.field === this.treeState?.options.column)?.field ?? columns[0]?.field;
+    }
+    treePageChange(event) {
+        this.fetchTableData({ ...this.tableLazyLoadEventInformation, first: event.first ?? 0,
+            rows: event.rows ?? this.currentRowsPerPage });
+    }
+    clearFilters(dt, force = false, onlyGlobalFilter = false) {
+        this.cancelGlobalSearch();
+        let hasToClear = this.hasToClearFilters(dt, this.globalSearchText, force);
+        if (hasToClear) {
+            if (!onlyGlobalFilter) {
+                this.predefinedFiltersSelectedValuesCollection = {};
+                for (const key in dt.filters) {
+                    if (dt.filters.hasOwnProperty(key)) {
+                        const filters = dt.filters[key];
+                        if (Array.isArray(filters)) {
+                            filters.forEach(filter => {
+                                filter.value = null; // Set value to null
+                            });
+                        }
+                        else {
+                            filters.value = null; // Set value to null
+                        }
+                    }
+                }
+                let filters = { ...this.dt.filters };
+                dt.columns?.forEach(element => {
+                    dt.filter(null, element.field, element.matchMode);
+                });
+                this.dt.filters = filters;
+            }
+            this.restoreGlobalSearch(null);
+            if (this.globalSearchOption(this.tableOptions.globalFilter?.minLength) > 0 ||
+                this.globalSearchOption(this.tableOptions.globalFilter?.debounceTime) > 0) {
+                this.currentPage = 0;
+                dt.first = 0;
+                dt.filters = { ...dt.filters, global: { value: null, matchMode: 'contains' } };
+                this.fetchTableData({ ...this.tableLazyLoadEventInformation, first: 0,
+                    rows: this.currentRowsPerPage, filters: dt.filters });
+            }
+            else
+                dt.filterGlobal('', '');
+        }
+    }
+    clearSorts(dt, force = false) {
+        let hasToClear = this.hasToClearSorts(dt, force);
+        if (hasToClear) {
+            dt.multiSortMeta = [];
+            dt.sortMultiple();
+        }
+    }
+    hasToClearSorts(dt, force = false) {
+        let hasToClear = false;
+        const hasSorts = (dt.multiSortMeta && dt.multiSortMeta.length > 0);
+        if (force || hasSorts) {
+            hasToClear = true;
+        }
+        return hasToClear;
+    }
+    hasToClearFilters(dt, globalSearchText, force = false) {
+        let hasToClear = false;
+        const filtersWithoutGlobalAndSelectedRows = this.modifyFiltersWithoutGlobalAndSelectedRows(dt.filters);
+        const hasFilters = this.hasFilters(filtersWithoutGlobalAndSelectedRows);
+        const hasGlobalFilter = (globalSearchText && globalSearchText.trim() !== "");
+        if (force || hasFilters || hasGlobalFilter) {
+            hasToClear = true;
+        }
+        return hasToClear;
+    }
+    /**
+     * Determines whether there are active filters based on the provided filter rules.
+     *
+     * @param {any} filterRules An object representing filter rules for each column.
+     *   The keys are column names, and the values are arrays of filter rules.
+     *   Each filter rule has the following properties:
+     *     - `field`: The field or property name of the column.
+     *     - `value`: The filter value entered by the user.
+     *     - Other properties depending on the type of filter (e.g., `matchMode` for string filters).
+     * @returns {boolean} `true` if at least one active filter is found, otherwise `false`.
+     */
+    hasFilters(filterRules) {
+        for (const columnName of Object.keys(filterRules)) { // Iterate over each column name in the filter rules
+            const columnFilters = filterRules[columnName]; // Get the filter rules for the current column
+            for (const filterRule of columnFilters) { // Iterate over each filter rule for the current column
+                if (filterRule.value !== null && filterRule.value !== "") { // Check if the filter value is not null or an empty string
+                    return true; // At least one active filter found
+                }
+            }
+        }
+        return false; // No active filters found
+    }
+    getColumnStyle(col, headerCols = false) {
+        return this.tableService.getColumnStyle(col, headerCols);
+    }
+    getPredefinedFilterValues(columnKeyName) {
+        return this.tableOptions.predefinedFilters?.[columnKeyName] || []; // Return the predefined filter values or an empty array if the option name does not exist
+    }
+    getFrozenColumnAlignAsText(frozenColumnAlign) {
+        return frozenColumnAlignAsText(frozenColumnAlign);
+    }
+    getDataTypeAsText(dataType) {
+        return dataTypeAsText(dataType);
+    }
+    /**
+     * Updates the filters of a PrimeNG data table based on predefined filter changes.
+     *
+     * @param {string} filterName - The name of the filter to be updated.
+     * @param {IPrimengPredefinedFilter[]} selectedValues - An array of selected predefined filter values.
+     */
+    onPredefinedFilterChange(filterName, selectedValues) {
+        const filters = { ...this.dt.filters }; // Create a shallow copy of the current filters to avoid mutating the original filters directly
+        const newValue = selectedValues && selectedValues.length ? selectedValues.map(value => value.value) : null; // Convert empty selection to null so PrimeNG removes the filter instead of applying an empty array
+        if (Array.isArray(filters[filterName])) { // Check if the filter for the given filterName is an array
+            filters[filterName].forEach(criteria => {
+                criteria.value = newValue; // Update the value of each criteria with the values from selectedValues
+            });
+        }
+        else if (filters[filterName]) { // Check if the filter for the given filterName exists and is not an array
+            const criteria = filters[filterName]; // Cast the filter criteria to FilterMetadata
+            criteria.value = newValue; // Update the value of the criteria with the values from selectedValues
+        }
+        this.dt.filters = filters; // Update the data table's filters with the modified filters object
+        this.dt._filter(); // Trigger the filtering operation on the data table to apply the new filters
+    }
+    /**
+     * Checks if the provided column metadata matches a specific style of the predefined filters
+     * that need to be applied to an item on a row.
+     *
+     * @param {IprimengColumnsMetadata} colMetadata - The metadata of the column being checked.
+     * @param {any} value - The value to be matched against the predefined filter values.
+     * @returns {any} The matching predefined filter value if found, otherwise null.
+     */
+    getPredfinedFilterMatch(colMetadata, value) {
+        if (colMetadata.filterPredefinedValuesName && colMetadata.filterPredefinedValuesName.length > 0) { // Check if the column uses predefined filter values
+            const options = this.getPredefinedFilterValues(colMetadata.filterPredefinedValuesName); // Get the predefined filter values based on the name
+            return options.find(option => option.value === value); // Return the matching option if found
+        }
+        return null; // Return null if the column does not use predefined filter values
+    }
+    copyToClipboardStart(event) {
+        if ((this.tableOptions.copyToClipboardTime ?? 0) > 0) {
+            const cellContent = event.target.innerText;
+            this.copyCellDataTimer = setTimeout(() => {
+                navigator.clipboard.writeText(cellContent).then(() => {
+                    this.notification.clearToasts();
+                    this.notification.showToast("info", this.i18n.text("CELL CONTENT COPIED"), this.i18n.text("The cell content has been copied to your clipboard."));
+                }).catch(err => {
+                    this.notification.clearToasts();
+                    this.notification.showToast("error", this.i18n.text("CELL CONTENT COPIED"), this.i18n.text("The cell content failed to copy to your clipboard with error: {{value0}}", { value0: err }));
+                });
+            }, (this.tableOptions.copyToClipboardTime ?? 0) * 1000);
+        }
+    }
+    copyToClipboardCancel() {
+        if ((this.tableOptions.copyToClipboardTime ?? 0) > 0) {
+            clearTimeout(this.copyCellDataTimer);
+        }
+    }
+    getDataAlignHorizontalAsText(dataAlignHorizontal) {
+        return dataAlignHorizontalAsText(dataAlignHorizontal);
+    }
+    getDataAlignVerticalAsText(dataAlignVertical) {
+        return dataAlignVerticalAsText(dataAlignVertical);
+    }
+    isRowCheckboxSelected(rowID) {
+        return this.selectedRowsCheckbox.includes(rowID);
+    }
+    get allMatchingRowsSelected() {
+        if (!this.matchingSelectionKeys?.length)
+            return false;
+        const selected = new Set(this.selectedRowsCheckbox);
+        return this.matchingSelectionKeys.every(key => selected.has(key));
+    }
+    get matchingRowsPartiallySelected() {
+        if (this.allMatchingRowsSelected)
+            return false;
+        if (!this.matchingSelectionKeys)
+            return this.selectedRowsCheckbox.length > 0;
+        const selected = new Set(this.selectedRowsCheckbox);
+        return this.matchingSelectionKeys.some(key => selected.has(key));
+    }
+    async toggleAllMatchingRows(checked) {
+        const options = this.tableOptions.rows?.checkboxSelector;
+        if (!options?.enabled || !options.selectAllEnabled || !options.urlSelectAll ||
+            !this.selectionQuery || this.selectAllLoading)
+            return;
+        const queryKey = this.selectionQueryKey;
+        this.selectAllLoading = true;
+        try {
+            const response = await firstValueFrom(this.tableService.fetchSelectionKeys(options.urlSelectAll, structuredClone(this.selectionQuery)).pipe(takeUntil(this.destroy$)));
+            if (this.destroyed || queryKey !== this.selectionQueryKey)
+                return;
+            if (!Array.isArray(response.body) || response.body.some(key => typeof key !== 'string' && typeof key !== 'number'))
+                throw new Error('Invalid selection identifiers.');
+            const disabledKeys = new Set((this.tableOptions.data ?? [])
+                .filter(row => !(options.enabledCondition?.(row) ?? true)).map(row => row.rowID));
+            const keys = [...new Set(response.body)].filter(key => !disabledKeys.has(key));
+            this.matchingSelectionKeys = keys;
+            const selected = new Set(this.selectedRowsCheckbox);
+            const changed = keys.filter(key => selected.has(key) !== checked);
+            for (const key of changed) {
+                if (checked)
+                    selected.add(key);
+                else
+                    selected.delete(key);
+            }
+            this.selectedRowsCheckbox = [...selected];
+            for (const rowID of changed)
+                this.onRowCheckboxChange.emit({ rowID, selected: checked });
+        }
+        catch (error) {
+            if (!this.destroyed)
+                this.tableService.handleTableError(error, 'Selection error');
+        }
+        finally {
+            this.selectAllLoading = false;
+            this.changeDetector?.markForCheck();
+        }
+    }
+    onRowChekboxChange(event, rowID) {
+        if (event.checked) { // Add the selected item
+            if (!this.selectedRowsCheckbox.includes(rowID))
+                this.selectedRowsCheckbox.push(rowID);
+        }
+        else { // Remove the selected item
+            this.selectedRowsCheckbox = this.selectedRowsCheckbox.filter(selectedId => selectedId !== rowID);
+        }
+        this.onRowCheckboxChange.emit({
+            rowID: rowID,
+            selected: event.checked
+        });
+    }
+    rowSelect(event) {
+        this.onRowSelect.emit({
+            rowID: event.data.rowID,
+            rowData: event.data
+        });
+    }
+    rowUnselect(event) {
+        this.onRowUnselect.emit({
+            rowID: event.data.rowID,
+            rowData: event.data
+        });
+    }
+    pageChange(event) {
+        this.currentPage = event.rows ? event.first / event.rows : 0;
+        this.currentRowsPerPage = event.rows ? event.rows : 0;
+    }
+    columnSelectorShow() {
+        this.tableOptions.columns?.selectorOrderByColumnName;
+        let tempData = this.columns.map(column => {
+            const isSelected = this.columnsSelected.some(selectedColumn => selectedColumn.field === column.field) || this.columnsCantBeHidden.some(selectedColumn => selectedColumn.field === column.field);
+            const isSelectDisabled = this.columnsCantBeHidden.some(selectedColumn => selectedColumn.field === column.field);
+            return {
+                field: column.field,
+                header: column.header,
+                selected: isSelected,
+                selectDisabled: isSelectDisabled,
+                cellOverflowBehaviour: column.cellOverflowBehaviour,
+                cellOverflowBehaviourDisabled: !column.cellOverflowBehaviourAllowUserEdit,
+                dataAlignHorizontal: column.dataAlignHorizontal,
+                dataAlignHorizontalDisabled: !column.dataAlignHorizontalAllowUserEdit,
+                dataAlignVertical: column.dataAlignVertical,
+                dataAlignVerticalDisabled: !column.dataAlignVerticalAllowUserEdit
+            };
+        });
+        this.columnModalData = [...tempData];
+        this.filteredColumnData = this.columnModalData;
+        this.showColumnSelector = true;
+    }
+    applyColumnModalChanges(selectedColumns) {
+        this.columnSelectionCustomized = true;
+        const existingColumns = this.dt.columns;
+        const columnsToKeep = new Set();
+        this.columnsCantBeHidden.forEach(col => columnsToKeep.add(col.field));
+        selectedColumns.forEach(col => columnsToKeep.add(col.field));
+        const finalColumns = [];
+        existingColumns.forEach(col => {
+            if (columnsToKeep.has(col.field)) {
+                finalColumns.push(col);
+            }
+        });
+        selectedColumns.forEach(col => {
+            const matchingColumn = this.columns.find(c => c.field === col.field);
+            if (matchingColumn && !finalColumns.find(c => c.field === matchingColumn.field)) {
+                finalColumns.push(matchingColumn);
+            }
+        });
+        let prevColsToShow = this.tableOptions.columns.shown;
+        this.tableOptions.columns.shown = this.tableService.orderColumnsWithFrozens(finalColumns);
+        let sameColumnsAsBefore = prevColsToShow.length === this.tableOptions.columns.shown.length &&
+            prevColsToShow.every((prevCol, index) => prevCol.field === this.tableOptions.columns.shown[index].field);
+        this.columnsSelected = this.tableOptions.columns.shown.filter(column => !this.columnsCantBeHidden.some(nonSelectable => nonSelectable.field === column.field));
+        this.updateColumnsSpecialProperties(this.columnModalData);
+        if (!sameColumnsAsBefore) {
+            this.tableOptions.isActive = false;
+            this.clearSorts(this.dt, true);
+            this.clearFilters(this.dt, true, false);
+            setTimeout(() => {
+                this.tableOptions.isActive = true;
+            }, 1);
+        }
+    }
+    updateColumnsSpecialProperties(columnsSource) {
+        const allColumns = [this.columns, this.tableOptions.columns.shown, this.columnsSelected, this.columnsCantBeHidden];
+        const columnModalDataMap = new Map(columnsSource.map((item) => [item.field, {
+                cellOverflowBehaviour: item.cellOverflowBehaviour,
+                dataAlignHorizontal: item.dataAlignHorizontal,
+                dataAlignVertical: item.dataAlignVertical,
+                width: item.width
+            }]));
+        const updatedFields = new Set(); // To track updated fields
+        allColumns.forEach((columnList) => {
+            columnList.forEach((col) => {
+                if (columnModalDataMap.has(col.field) && !updatedFields.has(col.field)) {
+                    const columnData = columnModalDataMap.get(col.field);
+                    if (columnData) {
+                        col.cellOverflowBehaviour = columnData.cellOverflowBehaviour;
+                        col.dataAlignHorizontal = columnData.dataAlignHorizontal;
+                        col.dataAlignVertical = columnData.dataAlignVertical;
+                        col.width = columnData.width;
+                        updatedFields.add(col.field);
+                    }
+                }
+            });
+        });
+    }
+    openExcelExport() {
+        const defaultTitle = this.tableOptions.excelReport?.defaultTitle?.trim();
+        const allowEdit = this.tableOptions.excelReport?.titleAllowUserEdit === true;
+        this.excelReportTitle = this.i18n.text((!defaultTitle && !allowEdit) ? 'Report' : defaultTitle);
+        this.showExportModal = true;
+    }
+    generateExcelReport(event) {
+        if (!this.tableOptions.excelReport?.url?.trim()) {
+            return;
+        }
+        let filtersWithoutGlobalAndSelectedRows = this.modifyFiltersWithoutGlobalAndSelectedRows(this.tableLazyLoadEventInformation.filters, event.selectedRows); // Create filters excluding the global filter
+        filtersWithoutGlobalAndSelectedRows = this.revertDateTimeZoneFilters(filtersWithoutGlobalAndSelectedRows);
+        const filtersMustBeApplied = (event.selectedRows === 1 || event.selectedRows === 2)
+            ? true
+            : event.applyFilters;
+        const requestData = {
+            page: this.currentPage,
+            pageSize: this.currentRowsPerPage,
+            sort: this.tableLazyLoadEventInformation.multiSortMeta,
+            filter: filtersWithoutGlobalAndSelectedRows,
+            globalFilter: this.effectiveGlobalSearchText,
+            columns: this.tableOptions.columns.shown.map(col => col.field),
+            dateFormat: this.dateFormat,
+            dateTimezone: this.dateTimezone,
+            dateCulture: this.dateCulture,
+            exportDateFormat: this.exportDateFormat,
+            allColumns: event.allColumns,
+            applyFilters: filtersMustBeApplied,
+            applySorts: event.applySorts,
+            filename: event.filename,
+            useIconInBools: event.useIconInBools
+        };
+        if (this.treeState)
+            Object.assign(requestData, { expandedKeys: [...this.treeState.expanded] });
+        this.tableService.fetchExcelReport(this.tableOptions.excelReport.url, requestData).subscribe({
+            next: (response) => {
+                this.tableService.downloadFile(response.body, event.filename, 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
+                this.showExportModal = false;
+            },
+            error: (err) => this.tableService.handleTableError(err, 'Excel export error')
+        });
+    }
+    updateIconBlobsForCollections() {
+        Object.keys(this.tableOptions.predefinedFilters ?? {}).forEach(key => {
+            const filters = this.tableOptions.predefinedFilters?.[key];
+            if (Array.isArray(filters) && filters.length > 0) {
+                filters.forEach(filter => {
+                    if (filter.imageBlobSourceEndpoint && !filter.imageBlob) {
+                        filter.imageBlob = undefined;
+                        filter.imageBlobFetchError = false;
+                        this.tableService.getIconBlob(filter.imageBlobSourceEndpoint).subscribe({
+                            next: (response) => {
+                                filter.imageBlob = response.body;
+                                this.showExportModal = false;
+                            },
+                            error: () => {
+                                filter.imageBlobFetchError = true;
+                            }
+                        });
+                    }
+                });
+            }
+            else {
+                console.warn(`Filters for key ${key} is not an array:`, filters);
+            }
+        });
+    }
+    ecsTrack1(index, button) { return button; }
+    ecsTrack2(index, button) { return index; }
+    ecsTrack3(index, group) { return group.field; }
+    ecsTrack4(index, col) { return col.header; }
+    ecsTrack5(index, col) { return col.field; }
+}
+ECSPrimengTable.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ECSPrimengTable, deps: [{ token: i1.ECSPrimengTableService }, { token: i2.ECSPrimengTableNotificationService }], target: i0.ɵɵFactoryTarget.Component });
+ECSPrimengTable.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: ECSPrimengTable, isStandalone: true, selector: "ecs-primeng-table", inputs: { tableOptions: "tableOptions" }, outputs: { onRowCheckboxChange: "onRowCheckboxChange", onRowSelect: "onRowSelect", onRowUnselect: "onRowUnselect", onDataEndUpdate: "onDataEndUpdate" }, host: { listeners: { "document:keydown.escape": "closeResponsiveMenus()", "window:resize": "onResize()" } }, viewQueries: [{ propertyName: "dt", first: true, predicate: ["dt"], descendants: true }, { propertyName: "tableContainer", first: true, predicate: ["tableContainer"], descendants: true }, { propertyName: "headerContainer", first: true, predicate: ["headerContainer"], descendants: true }, { propertyName: "paginatorContainer", first: true, predicate: ["paginatorContainer"], descendants: true }, { propertyName: "responsiveHeaderMenu", first: true, predicate: ["responsiveHeaderMenu"], descendants: true }, { propertyName: "responsiveRowMenu", first: true, predicate: ["responsiveRowMenu"], descendants: true }], ngImport: i0, template: "<div #tableContainer>\r\n    <p-table #dt\r\n        styleClass=\"p-datatable-sm p-datatable-gridlines p-datatable-striped\"\r\n        sortMode=\"multiple\"\r\n        [resizableColumns]=\"true\" columnResizeMode=\"expand\"\r\n        [reorderableColumns]=\"true\"\r\n        [scrollable]=\"true\" [scrollHeight]=\"scrollHeightValue\"\r\n        [columns]=\"tableOptions.columns?.shown ?? []\" [value]=\"tableOptions.data ?? []\" dataKey=\"rowID\" \r\n        [paginator]=\"!treeState\" [loading]=\"treeState?.loading ?? false\" paginatorDropdownAppendTo=\"body\" [first]=\"currentPage * currentRowsPerPage\" [rows]=\"currentRowsPerPage\" [totalRecords]=\"totalRecords\"\r\n        [rowsPerPageOptions]=\"allowedRowsPerPage\" [showCurrentPageReport]=\"false\" (onPage)=\"pageChange($event)\"\r\n        [selectionMode]=\"tableOptions.rows?.singleSelector?.enabled ? 'single' : ''\" [metaKeySelection]=\"tableOptions.rows?.singleSelector?.metakey ?? true\" [(selection)]=\"rowSelection\" (onRowSelect)=\"rowSelect($event)\" (onRowUnselect)=\"rowUnselect($event)\"\r\n        [lazy]=\"true\" (onLazyLoad)=\"fetchTableData($event)\">\r\n\r\n        <!--TEMPLATE FOR THE ACTIONS HEADER COLUMN-->\r\n        <ng-template #actionColumnHeaderTemplate>\r\n            <ng-container *ngIf=\"(tableOptions.rows?.action?.buttons?.length ?? 0) > 0\">\r\n                <th [ngStyle]=\"{\r\n                        'text-align': 'center',\r\n                        'vertical-align': 'middle',\r\n                        'max-width': actionColumnWidth + 'px',\r\n                        'min-width': actionColumnWidth + 'px',\r\n                        'width': actionColumnWidth + 'px'\r\n                    }\"\r\n                    pResizableColumn [pResizableColumnDisabled]=\"!tableOptions.rows?.action?.resizable\" pFrozenColumn [frozen]=\"tableOptions.rows?.action?.frozen ?? false\"\r\n                    [alignFrozen]=\"getFrozenColumnAlignAsText(tableOptions.rows?.action?.positionRight ? FrozenColumnAlign.Right : FrozenColumnAlign.Left)\" id=\"actions-header\"\r\n                    [attr.scope]=\"'col'\">\r\n                    {{ (tableOptions.rows?.action?.header ?? '') | ecsTranslate }}\r\n                </th>\r\n            </ng-container>\r\n        </ng-template>\r\n\r\n        <!--TEMPLATE FOR THE ACTIONS ROW COLUMN-->\r\n        <ng-template #actionColumnTemplate let-rowData=\"rowData\">\r\n            <ng-container *ngIf=\"(tableOptions.rows?.action?.buttons?.length ?? 0) > 0\">\r\n                <td \r\n                    [ngStyle]=\"{\r\n                        'text-align': (getDataAlignHorizontalAsText(tableOptions.rows?.action?.horizontalAlignment ?? DataAlignHorizontal.Center)),\r\n                        'vertical-align': (getDataAlignVerticalAsText(tableOptions.rows?.action?.verticalAlignment ?? DataAlignVertical.Middle)),\r\n                        'max-width': actionColumnWidth + 'px',\r\n                        'min-width': actionColumnWidth + 'px',\r\n                        'width': actionColumnWidth + 'px'\r\n                    }\"\r\n                    pFrozenColumn [frozen]=\"tableOptions.rows?.action?.frozen ?? false\"\r\n                    [alignFrozen]=\"getFrozenColumnAlignAsText(tableOptions.rows?.action?.positionRight ? FrozenColumnAlign.Right : FrozenColumnAlign.Left)\">\r\n                    <ng-container *ngIf=\"compactRows; else ecsElse0\">\r\n                        <ng-container *ngIf=\"hasRowMenuActions(rowData)\">\r\n                            <button pButton type=\"button\" icon=\"pi pi-ellipsis-v\" [attr.aria-label]=\"(tableOptions.responsive?.rowMenuLabel || 'Row actions') | ecsTranslate\"\r\n                                aria-haspopup=\"menu\" [attr.aria-expanded]=\"responsiveRowMenu.visible && rowMenuRow === rowData\"\r\n                                (click)=\"openRowMenu($event, rowData)\" class=\"ecs-responsive-trigger\"></button>\r\n                        </ng-container>\r\n                    </ng-container><ng-template #ecsElse0>\r\n                    <ng-container *ngFor=\"let button of tableOptions.rows?.action?.buttons; trackBy: ecsTrack1; let $index = index; let $first = first; let $last = last; let $even = even; let $odd = odd; let $count = count; let last = last\">\r\n                        <ecs-table-button [button]=\"button\" [rowData]=\"rowData\" [isActionButton]=\"true\" [isLastActionButton]=\"last\"></ecs-table-button>\r\n                    </ng-container>\r\n                    </ng-template>\r\n                </td>\r\n            </ng-container>\r\n        </ng-template>\r\n\r\n        <!-- TEMPLATE FOR THE ROW CHECKBOX SELECTOR HEADER COLUMN -->\r\n        <ng-template #rowSelectorColumnHeaderTemplate>\r\n            <th \r\n                [ngStyle]=\"{\r\n                    'text-align': 'center',\r\n                    'vertical-align': 'middle',\r\n                    'max-width': (tableOptions.rows?.checkboxSelector?.width ?? 150) + 'px',\r\n                    'min-width': (tableOptions.rows?.checkboxSelector?.width ?? 150) + 'px',\r\n                    'width': (tableOptions.rows?.checkboxSelector?.width ?? 150) + 'px'\r\n                }\"\r\n                id=\"rowSelector-header\"  [attr.scope]=\"'col'\" pResizableColumn [pResizableColumnDisabled]=\"!tableOptions.rows?.checkboxSelector?.resizable\" pFrozenColumn \r\n                [frozen]=\"tableOptions.rows?.checkboxSelector?.frozen ?? false\" [alignFrozen]=\"getFrozenColumnAlignAsText(tableOptions.rows?.checkboxSelector?.positionRight ? FrozenColumnAlign.Right : FrozenColumnAlign.Left)\">\r\n                    <div style=\"display: flex; justify-content: space-between; align-items: center;\">\r\n                        <ng-container *ngIf=\"tableOptions.rows?.checkboxSelector?.selectAllEnabled\">\r\n                            <input type=\"checkbox\" class=\"ecs-select-all\" [checked]=\"allMatchingRowsSelected\"\r\n                                [indeterminate]=\"matchingRowsPartiallySelected\"\r\n                                [disabled]=\"selectAllLoading || !tableOptions.rows?.checkboxSelector?.urlSelectAll\"\r\n                                [attr.aria-label]=\"'Select all filtered rows' | ecsTranslate\"\r\n                                [pTooltip]=\"'Select all filtered rows' | ecsTranslate\"\r\n                                (change)=\"toggleAllMatchingRows($any($event.target).checked)\">\r\n                        </ng-container>\r\n                        {{ (tableOptions.rows?.checkboxSelector?.header ?? '') | ecsTranslate }}\r\n                        <p-columnFilter type=\"boolean\" field=\"selector\" display=\"menu\" [showButtons]=\"false\"></p-columnFilter>\r\n                    </div>\r\n            </th>\r\n        </ng-template>\r\n\r\n        <!--TEMPLATE FOR THE ROW CHECKBOX SELECTOR COLUMN-->\r\n        <ng-template #rowSelectorColumnTemplate let-rowData=\"rowData\">\r\n            <td \r\n            [ngStyle]=\"{\r\n                'text-align': (getDataAlignHorizontalAsText(tableOptions.rows?.checkboxSelector?.horizontalAlignment ?? DataAlignHorizontal.Center)),\r\n                'vertical-align': (getDataAlignVerticalAsText(tableOptions.rows?.checkboxSelector?.verticalAlignment ?? DataAlignVertical.Middle)),\r\n                'max-width': (tableOptions.rows?.checkboxSelector?.width ?? 150) + 'px',\r\n                'min-width': (tableOptions.rows?.checkboxSelector?.width ?? 150) + 'px',\r\n                'width': (tableOptions.rows?.checkboxSelector?.width ?? 150) + 'px'\r\n            }\"\r\n            pFrozenColumn [frozen]=\"tableOptions.rows?.checkboxSelector?.frozen ?? false\" \r\n            [alignFrozen]=\"getFrozenColumnAlignAsText(tableOptions.rows?.checkboxSelector?.positionRight ? FrozenColumnAlign.Right : FrozenColumnAlign.Left)\">\r\n            <p-checkbox \r\n                [disabled]=\"!(tableOptions.rows?.checkboxSelector?.enabledCondition?.(rowData) ?? true)\"\r\n                [binary]=\"true\"\r\n                [ngModel]=\"isRowCheckboxSelected(rowData.rowID)\"\r\n                (onChange)=\"onRowChekboxChange($event, rowData.rowID)\"></p-checkbox>\r\n            </td>\r\n        </ng-template>\r\n\r\n\r\n        <!-- LOGIC FOR DRAWING TABLE ACTIONS ABOVE THE HEADER -->\r\n        <ng-template pTemplate=\"caption\">\r\n            <div #headerContainer [class.ecs-compact-header]=\"compactHeader\" style=\"display: flex; justify-content: space-between; align-items: center;\">\r\n                <ng-container *ngIf=\"compactHeader; else ecsElse1\">\r\n                    <ng-container *ngIf=\"tableOptions.globalFilter?.enabled\">\r\n                        <span class=\"ecs-global-search ecs-responsive-search\">\r\n                            <span class=\"ecs-input-icon\"><i class=\"pi pi-search\"></i></span>\r\n                            <input pInputText type=\"text\" [attr.aria-label]=\"'Search keyword' | ecsTranslate\" [placeholder]=\"'Search keyword' | ecsTranslate\" autocomplete=\"off\"\r\n                                [maxlength]=\"tableOptions.globalFilter?.maxLength ?? null\" [ngModel]=\"globalSearchText\"\r\n                                (ngModelChange)=\"onGlobalSearchInput($event)\"/>\r\n                            <ng-container *ngIf=\"globalSearchText\">\r\n                                <span class=\"ecs-input-icon\" position=\"right\"><button type=\"button\" class=\"ecs-clear-search\" [attr.aria-label]=\"'Clear search' | ecsTranslate\" (click)=\"clearFilters(dt, true, true)\"><i class=\"pi pi-times\"></i></button></span>\r\n                            </ng-container>\r\n                        </span>\r\n                    </ng-container>\r\n                    <ng-container *ngIf=\"tableOptions.description?.text\">\r\n                        <i [class]=\"tableOptions.description!.icon\" [pTooltip]=\"(tableOptions.description!.text) | ecsTranslate\" [escape]=\"false\"></i>\r\n                    </ng-container>\r\n                    <button pButton type=\"button\" icon=\"pi pi-bars\" [attr.aria-label]=\"(tableOptions.responsive?.headerMenuLabel || 'Table actions') | ecsTranslate\"\r\n                        aria-haspopup=\"menu\" [attr.aria-expanded]=\"responsiveHeaderMenu.visible\"\r\n                        (click)=\"openHeaderMenu($event)\" class=\"ecs-responsive-trigger ecs-header-menu-trigger\"></button>\r\n                </ng-container><ng-template #ecsElse1>\r\n\r\n                <div style=\"display: flex; align-items: center; gap: 10px;\">\r\n                    <!--CHOOSE COLUMNS TO SHOW-->\r\n                    <ng-container *ngIf=\"tableOptions.columns?.selectorEnabled\">\r\n                        <p-button [icon]=\"tableOptions.columns?.selectorIcon ?? 'pi pi-pencil'\" (onClick)=\"columnSelectorShow()\" [pTooltip]=\"'Modify columns' | ecsTranslate\"\r\n                            [showDelay]=\"700\" tooltipPosition=\"top\" styleClass=\"p-button-icon-only\"></p-button>\r\n                    </ng-container>\r\n                    <!--CLEAR SORTS AND FILTERS-->\r\n                    <ng-container *ngIf=\"tableOptions.header?.clearSortsEnabled\">\r\n                        <p-button [icon]=\"tableOptions.header?.clearSortsIcon ?? 'pi pi-sort-alt-slash'\" (onClick)=\"clearSorts(dt)\" [disabled]=\"!hasToClearSorts(dt)\"\r\n                            [pTooltip]=\"'Clear sorts' | ecsTranslate\" [showDelay]=\"700\" tooltipPosition=\"top\" styleClass=\"p-button-icon-only\"></p-button>\r\n                    </ng-container>\r\n                    <ng-container *ngIf=\"tableOptions.header?.clearFiltersEnabled\">\r\n                        <p-button\r\n                            [icon]=\"tableOptions.header?.clearFiltersIcon ?? 'pi pi-filter-slash'\" (onClick)=\"clearFilters(dt)\" [disabled]=\"!hasToClearFilters(dt, globalSearchText)\"\r\n                            [pTooltip]=\"'Clear filters' | ecsTranslate\" [showDelay]=\"700\" tooltipPosition=\"top\" styleClass=\"p-button-icon-only\"></p-button>\r\n                    </ng-container>\r\n\r\n                    <!--TABLE DESCRIPTION-->\r\n                    <ng-container *ngIf=\"tableOptions.description?.text\"> <!-- If a table description text is provided -->\r\n                        <ng-container *ngIf=\"!tableOptions.description!.tooltip; else ecsElse2\"> <!-- The table description must be shown as text next to the icon -->\r\n                            <i [class]=\"tableOptions.description!.icon\"></i>\r\n                            <span [innerHTML]=\"(tableOptions.description!.text) | ecsTranslate\"></span>\r\n                        </ng-container><ng-template #ecsElse2>\r\n                            <i [escape]=\"false\" [pTooltip]=\"(tableOptions.description!.text) | ecsTranslate\" tooltipPosition=\"right\" [class]=\"tableOptions.description!.icon\"></i>\r\n                        </ng-template>\r\n                    </ng-container>\r\n                </div>\r\n\r\n                <!--TABLE VIEWS-->\r\n                <ng-container *ngIf=\"tableViewsEnabled()\">\r\n                    <div style=\"display: flex; align-items: center; gap: 10px;\">\r\n                        <span class=\"p-buttonset ecs-view-buttons\">\r\n                            <p-button (click)=\"viewsModalShow=true;\"\r\n                                [label]=\"tableViewCurrentSelectedAlias \r\n                                    ? tableViewCurrentSelectedAlias \r\n                                    : ((tableOptions.views?.noViewSelectedText || '--- Select a view ---') | ecsTranslate)\"\r\n                                [class]=\"'viewButton' + (tableOptions.views?.selectViewButtonClass ? ' ' + tableOptions.views!.selectViewButtonClass : '')\"></p-button>\r\n                            <p-button (click)=\"viewLoad(tableViewCurrentSelectedAlias!)\"  [disabled]=\"!tableViewCurrentSelectedAlias\" [pTooltip]=\"'Apply view again' | ecsTranslate\" [showDelay]=\"700\" tooltipPosition=\"top\"\r\n                                [icon]=\"tableOptions.views?.reloadViewButtonIcon || 'pi pi-refresh'\"\r\n                                [class]=\"tableOptions.views?.reloadViewButtonClass || ''\"></p-button>\r\n                        </span>\r\n                    </div>\r\n                </ng-container>\r\n\r\n                <div style=\"display: flex; align-items: center; gap: 10px;\">\r\n                    <!--GLOBAL FILTER-->\r\n                    <ng-container *ngIf=\"tableOptions.globalFilter?.enabled\">\r\n                        <span class=\"ecs-global-search ml-auto\">\r\n                            <span class=\"ecs-input-icon\">\r\n                                <i class=\"pi pi-search\"></i>\r\n                            </span>\r\n                            <input pInputText type=\"text\" \r\n                                (ngModelChange)=\"onGlobalSearchInput($event)\" autocomplete=\"off\"\r\n                                [maxlength]=\"tableOptions.globalFilter?.maxLength ?? null\" [placeholder]=\"'Search keyword' | ecsTranslate\" [ngModel]=\"globalSearchText\"\r\n                                style=\"width: 220px;\"/>\r\n                            <!-- Right icon (only if there is text) -->\r\n                            <ng-container *ngIf=\"globalSearchText\">\r\n                                <span class=\"ecs-input-icon\" position=\"right\">\r\n                                    <i class=\"pi pi-times\" style=\"cursor: pointer;\"  (click)=\"clearFilters(dt, true, true); $event.stopPropagation()\"></i>\r\n                                </span>\r\n                            </ng-container>\r\n                        </span>\r\n                    </ng-container>\r\n\r\n                    <!--EXPORT DATA-->\r\n                    <ng-container *ngIf=\"tableOptions.excelReport?.url?.trim()\">\r\n                        <p-button icon=\"pi pi-file-excel\" (onClick)=\"openExcelExport()\"\r\n                            [pTooltip]=\"'Export to Excel' | ecsTranslate\" [showDelay]=\"700\" tooltipPosition=\"top\" styleClass=\"p-button-icon-only\"></p-button>\r\n                    </ng-container>\r\n\r\n                    <!--RESET TABLE VIEW-->\r\n                    <ng-container *ngIf=\"tableOptions.resetTableView?.enabled\">\r\n                        <p-button [icon]=\"tableOptions.resetTableView?.icon ?? 'pi pi-eraser'\" (click)=\"resetTableView()\" [pTooltip]=\"'Reset table view' | ecsTranslate\" [showDelay]=\"700\"\r\n                            tooltipPosition=\"top\" styleClass=\"p-button-icon-only\"></p-button>\r\n                    </ng-container>\r\n\r\n                    <!--REFRESH DATA-->\r\n                    <p-button icon=\"pi pi-refresh\" (onClick)=\"refreshData($event)\" [pTooltip]=\"'Refresh data' | ecsTranslate\" [showDelay]=\"700\"\r\n                        tooltipPosition=\"top\" styleClass=\"p-button-icon-only\"></p-button>\r\n                    \r\n                    <!-- HEADER ACTION BUTTONS -->\r\n                    <ng-container *ngIf=\"(tableOptions.header?.buttons?.length ?? 0) > 0\">\r\n                        <td style=\"display: flex; justify-content: center; align-items: center; gap: 10px;\">\r\n                            <ng-container *ngFor=\"let button of tableOptions.header?.buttons; trackBy: ecsTrack2; let $index = index; let $first = first; let $last = last; let $even = even; let $odd = odd; let $count = count\">\r\n                                <ecs-table-button [button]=\"button\" [rowData]=\"null\"></ecs-table-button>\r\n                            </ng-container>\r\n                        </td>\r\n                    </ng-container>\r\n                </div>\r\n                </ng-template>\r\n            </div>\r\n        </ng-template>\r\n\r\n        <!-- LOGIC FOR DRAWING TABLE HEADERS -->\r\n        <ng-template pTemplate=\"header\" let-columns>\r\n            <ng-container *ngIf=\"getColumnHeaderGroups(columns) as headerGroups\">\r\n            <ng-container *ngIf=\"headerGroups.length\">\r\n                <tr class=\"ecs-column-groups\">\r\n                    <ng-container *ngIf=\"(tableOptions.rows?.action?.buttons?.length ?? 0) > 0 && !tableOptions.rows?.action?.positionRight\">\r\n                        <td aria-hidden=\"true\" pFrozenColumn [frozen]=\"tableOptions.rows?.action?.frozen ?? false\" alignFrozen=\"left\"\r\n                            [style.width.px]=\"actionColumnWidth\" [style.min-width.px]=\"actionColumnWidth\"></td>\r\n                    </ng-container>\r\n                    <ng-container *ngIf=\"tableOptions.rows?.checkboxSelector?.enabled && !tableOptions.rows?.checkboxSelector?.positionRight\">\r\n                        <td aria-hidden=\"true\" pFrozenColumn [frozen]=\"tableOptions.rows?.checkboxSelector?.frozen ?? false\" alignFrozen=\"left\"\r\n                            [style.width.px]=\"tableOptions.rows?.checkboxSelector?.width ?? 150\" [style.min-width.px]=\"tableOptions.rows?.checkboxSelector?.width ?? 150\"></td>\r\n                    </ng-container>\r\n                    <ng-container *ngFor=\"let group of headerGroups; trackBy: ecsTrack3; let $index = index; let $first = first; let $last = last; let $even = even; let $odd = odd; let $count = count\">\r\n                        <td [attr.colspan]=\"group.colspan\" role=\"columnheader\" [attr.aria-colspan]=\"group.colspan\" style=\"text-align: center; vertical-align: middle;\"\r\n                            pFrozenColumn [frozen]=\"group.frozenColumnAlign !== FrozenColumnAlign.Noone\"\r\n                            [alignFrozen]=\"getFrozenColumnAlignAsText(group.frozenColumnAlign)\">\r\n                            {{ group.label | translate }}\r\n                        </td>\r\n                    </ng-container>\r\n                    <ng-container *ngIf=\"tableOptions.rows?.checkboxSelector?.enabled && tableOptions.rows?.checkboxSelector?.positionRight\">\r\n                        <td aria-hidden=\"true\" pFrozenColumn [frozen]=\"tableOptions.rows?.checkboxSelector?.frozen ?? false\" alignFrozen=\"right\"\r\n                            [style.width.px]=\"tableOptions.rows?.checkboxSelector?.width ?? 150\" [style.min-width.px]=\"tableOptions.rows?.checkboxSelector?.width ?? 150\"></td>\r\n                    </ng-container>\r\n                    <ng-container *ngIf=\"(tableOptions.rows?.action?.buttons?.length ?? 0) > 0 && tableOptions.rows?.action?.positionRight\">\r\n                        <td aria-hidden=\"true\" pFrozenColumn [frozen]=\"tableOptions.rows?.action?.frozen ?? false\" alignFrozen=\"right\"\r\n                            [style.width.px]=\"actionColumnWidth\" [style.min-width.px]=\"actionColumnWidth\"></td>\r\n                    </ng-container>\r\n                </tr>\r\n            </ng-container>\r\n            <tr>\r\n                <ng-container *ngIf=\"!tableOptions.rows?.action?.positionRight\">\r\n                    <ng-container *ngTemplateOutlet=\"actionColumnHeaderTemplate\"></ng-container>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"tableOptions.rows?.checkboxSelector?.enabled && !tableOptions.rows?.checkboxSelector?.positionRight\">\r\n                    <ng-container [ngTemplateOutlet]=\"rowSelectorColumnHeaderTemplate\"></ng-container>\r\n                </ng-container>\r\n                <ng-container *ngFor=\"let col of columns; trackBy: ecsTrack4; let $index = index; let $first = first; let $last = last; let $even = even; let $odd = odd; let $count = count\">\r\n                    <th [ngStyle]=\"getColumnStyle(col, true)\"\r\n                        pResizableColumn [pResizableColumnDisabled]=\"!col.canBeResized ? true : false\"\r\n                        pReorderableColumn [pReorderableColumnDisabled]=\"!col.canBeReordered ? true : false\"\r\n                        pFrozenColumn [frozen]=\"col.frozenColumnAlign === FrozenColumnAlign.Left || col.frozenColumnAlign === FrozenColumnAlign.Right\" [alignFrozen]=\"getFrozenColumnAlignAsText(col.frozenColumnAlign)\"\r\n                        [pSortableColumn]=\"col.field\" [pSortableColumnDisabled]=\"!col.canBeSorted ? true : false\"\r\n                        style=\"text-align: center;\"\r\n                        [id]=\"col.field + '-header'\" [attr.scope]=\"'col'\">\r\n                        <div style=\"display: flex; justify-content: space-between; align-items: center; width: 100%;\">\r\n                            <div style=\"margin-right: 15px;\">\r\n                                <span>{{ col.header | translate }}</span>\r\n                            </div>\r\n                            <div style=\"display: flex; align-items: center; gap: 5px;\">\r\n                                <ng-container *ngIf=\"col.canBeSorted\">\r\n                                    <p-sortIcon [field]=\"col.field\"></p-sortIcon>\r\n                                </ng-container>\r\n                                <ng-container *ngIf=\"col.canBeFiltered\">\r\n                                    <ng-container *ngIf=\"!col.filterPredefinedValuesName || col.filterPredefinedValuesName.length === 0; else ecsElse3\">\r\n                                        <p-columnFilter [type]=\"getDataTypeAsText(col.dataType)\" [field]=\"col.field\" display=\"menu\" [showButtons]=\"false\" (click)=\"$event.stopPropagation()\"></p-columnFilter>\r\n                                    </ng-container><ng-template #ecsElse3>\r\n                                        <p-columnFilter\r\n                                            [type]=\"getDataTypeAsText(col.dataType)\" [field]=\"col.field\" display=\"menu\"\r\n                                            (click)=\"$event.stopPropagation()\"\r\n                                            [showButtons]=\"false\" matchMode=\"in\" operator=\"or\" [showMatchModes]=\"false\"\r\n                                            [showOperator]=\"false\" [showAddButton]=\"false\" [showClearButton]=\"false\" [showApplyButton]=\"false\">\r\n                                            <ng-template pTemplate=\"filter\">\r\n                                                <p-multiSelect\r\n                                                    [style]=\"{ minWidth: '400px' }\" [(ngModel)]=\"predefinedFiltersSelectedValuesCollection[col.filterPredefinedValuesName]\"\r\n                                                    [options]=\"getPredefinedFilterValues(col.filterPredefinedValuesName)\" [placeholder]=\"'Any value' | ecsTranslate\"\r\n                                                    (onChange)=\"onPredefinedFilterChange(col.field, $event.value)\" optionLabel=\"name\">\r\n                                                    <ng-template pTemplate=\"item\" let-option >\r\n                                                        <div style=\"display: inline-block; vertical-align: middle;\">\r\n                                                            <ecs-table-predefined-filters [option]=\"option\" [col]=\"col\" [selectable]=\"false\" [rowData]=\"null\"></ecs-table-predefined-filters>\r\n                                                        </div>\r\n                                                    </ng-template>\r\n                                                </p-multiSelect>\r\n                                            </ng-template>\r\n                                        </p-columnFilter>\r\n                                    </ng-template>\r\n                                </ng-container>\r\n                                <ng-container *ngIf=\"col.columnDescription && col.columnDescription.length > 0\">\r\n                                    <i [pTooltip]=\"(col.columnDescription) | ecsTranslate\" tooltipPosition=\"top\" [class]=\"tableOptions.columnDescriptionIcon || 'pi pi-info-circle'\"></i>\r\n                                </ng-container>\r\n                            </div>\r\n                        </div>\r\n                    </th>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"tableOptions.rows?.checkboxSelector?.enabled && tableOptions.rows?.checkboxSelector?.positionRight\">\r\n                    <ng-container [ngTemplateOutlet]=\"rowSelectorColumnHeaderTemplate\"></ng-container>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"tableOptions.rows?.action?.positionRight\">\r\n                    <ng-container *ngTemplateOutlet=\"actionColumnHeaderTemplate\"></ng-container>\r\n                </ng-container>\r\n            </tr>\r\n            </ng-container>\r\n        </ng-template>\r\n\r\n        <!-- LOGIC FOR DRAWING TABLE DATA WHEN THERE IS CONTENTS -->\r\n        <ng-template pTemplate=\"body\" let-rowData let-columns=\"columns\">\r\n            <ng-container *ngIf=\"treeState?.isMore(rowData); else ecsElse4\">\r\n                <tr class=\"ecs-tree-more-row\">\r\n                    <td colspan=\"999\">\r\n                        <p-button icon=\"pi pi-plus\" styleClass=\"p-button-text\" [label]=\"'Load more children' | ecsTranslate\"\r\n                            (onClick)=\"loadMoreTreeRows($event, rowData)\" ></p-button>\r\n                    </td>\r\n                </tr>\r\n            </ng-container><ng-template #ecsElse4>\r\n            <tr [pSelectableRow]=\"rowData\" [ngClass]=\"tableOptions.rows?.class?.(rowData)\" [ngStyle]=\"tableOptions.rows?.style?.(rowData)\"\r\n                [attr.aria-level]=\"treeState ? treeState.depth(rowData) + 1 : null\"\r\n                [attr.aria-expanded]=\"treeState?.hasChildren(rowData) ? treeState?.isExpanded(rowData) : null\">\r\n                <ng-container *ngIf=\"!tableOptions.rows?.action?.positionRight\">\r\n                    <ng-container *ngTemplateOutlet=\"actionColumnTemplate; context: { rowData: rowData }\"></ng-container>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"tableOptions.rows?.checkboxSelector?.enabled && !tableOptions.rows?.checkboxSelector?.positionRight\">\r\n                    <ng-container [ngTemplateOutlet]=\"rowSelectorColumnTemplate\" [ngTemplateOutletContext]=\"{ rowData: rowData }\"></ng-container>\r\n                </ng-container>\r\n                <ng-container *ngFor=\"let col of columns; trackBy: ecsTrack5; let $index = index; let $first = first; let $last = last; let $even = even; let $odd = odd; let $count = count\">\r\n                    <td (mousedown)=\"col.dataType !== DataType.Boolean && copyToClipboardStart($event)\" (mouseup)=\"copyToClipboardCancel()\"\r\n                        [ngStyle]=\"getColumnStyle(col)\" pFrozenColumn [frozen]=\"col.frozenColumnAlign === FrozenColumnAlign.Left || col.frozenColumnAlign === FrozenColumnAlign.Right\" \r\n                        [alignFrozen]=\"getFrozenColumnAlignAsText(col.frozenColumnAlign)\" [style.text-align]=\"getDataAlignHorizontalAsText(col.dataAlignHorizontal)\" [style.vertical-align]=\"getDataAlignVerticalAsText(col.dataAlignVertical)\">\r\n                        <ng-container *ngIf=\"treeState && col.field === treeColumn; else ecsElse5\">\r\n                            <div class=\"ecs-tree-cell\" [style.padding-inline-start.px]=\"treeState.depth(rowData) * 20\">\r\n                                <button type=\"button\" class=\"ecs-tree-toggle\" [class.ecs-tree-leaf]=\"!treeState.hasChildren(rowData)\"\r\n                                    [disabled]=\"!treeState.hasChildren(rowData) || treeState.isLoading(rowData) || treeState.loading\"\r\n                                    [attr.aria-label]=\"(treeState.isExpanded(rowData) ? 'Collapse node' : 'Expand node') | ecsTranslate\"\r\n                                    [attr.aria-expanded]=\"treeState.hasChildren(rowData) ? treeState.isExpanded(rowData) : null\"\r\n                                    [pTooltip]=\"(treeState.isExpanded(rowData) ? 'Collapse node' : 'Expand node') | ecsTranslate\"\r\n                                    (mousedown)=\"$event.stopPropagation()\" (mouseup)=\"$event.stopPropagation()\"\r\n                                    (click)=\"toggleTreeRow($event, rowData)\">\r\n                                    <i [class]=\"treeState.isLoading(rowData) ? 'pi pi-spinner pi-spin' : treeState.isExpanded(rowData) ? 'pi pi-chevron-down' : 'pi pi-chevron-right'\" aria-hidden=\"true\"></i>\r\n                                </button>\r\n                                <ecs-table-cell [col]=\"col\" [rowData]=\"rowData\" [globalSearchText]=\"effectiveGlobalSearchText\"\r\n                                    [dateFormat]=\"dateFormat\" [dateTimezone]=\"dateTimezone\" [dateCulture]=\"dateCulture\"\r\n                                    [predefinedFiltersCollection]=\"tableOptions.predefinedFilters\" ></ecs-table-cell>\r\n                            </div>\r\n                        </ng-container><ng-template #ecsElse5>\r\n                        <ecs-table-cell [col]=\"col\" [rowData]=\"rowData\" [globalSearchText]=\"effectiveGlobalSearchText\"\r\n                            [dateFormat]=\"dateFormat\" [dateTimezone]=\"dateTimezone\" [dateCulture]=\"dateCulture\"\r\n                            [predefinedFiltersCollection]=\"tableOptions.predefinedFilters\"></ecs-table-cell>\r\n                        </ng-template>\r\n                    </td>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"tableOptions.rows?.checkboxSelector?.enabled && tableOptions.rows?.checkboxSelector?.positionRight\">\r\n                    <ng-container [ngTemplateOutlet]=\"rowSelectorColumnTemplate\" [ngTemplateOutletContext]=\"{ rowData: rowData }\"></ng-container>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"tableOptions.rows?.action?.positionRight\">\r\n                    <ng-container *ngTemplateOutlet=\"actionColumnTemplate; context: { rowData: rowData }\"></ng-container>\r\n                </ng-container>\r\n            </tr>\r\n            </ng-template>\r\n        </ng-template>\r\n\r\n        <!-- LOGIC FOR DRAWING TABLE DATA WHEN THERE IS NO CONTENTS -->\r\n        <ng-template pTemplate=\"emptymessage\">\r\n            <tr>\r\n                <td colspan=\"999\">{{ 'No data found for the current filter criteria.' | ecsTranslate }}</td>\r\n            </tr>\r\n        </ng-template>\r\n\r\n        <!-- SHOW CUSTOM RECORDS REPORT -->\r\n        <ng-template pTemplate=\"paginatorleft\">\r\n            <div #paginatorContainer>\r\n                <div style=\"display: flex; align-items: center; gap: 10px;\">\r\n                    <ng-container *ngIf=\"tableOptions.legend?.content\">\r\n                        <ecs-table-button [button]=\"tableOptions.legend?.button\" [rowData]=\"null\" [overrideAction]=\"op.toggle.bind(op)\"></ecs-table-button>\r\n                        <p-overlayPanel #op>\r\n                            <div [innerHTML]=\"(tableOptions.legend?.content) | ecsTranslate\"></div>\r\n                        </p-overlayPanel>\r\n                    </ng-container>\r\n                    <span>{{ 'Showing {{count}} records of {{total}} available records' | ecsTranslate: { count: totalRecords, total: totalRecordsNotFiltered } }}</span>\r\n                </div>\r\n            </div>\r\n        </ng-template>\r\n    </p-table>\r\n    <ng-container *ngIf=\"treeState\">\r\n        <div #paginatorContainer class=\"ecs-tree-paginator\">\r\n            <ng-container *ngIf=\"tableOptions.legend?.content\">\r\n                <ecs-table-button [button]=\"tableOptions.legend?.button\" [rowData]=\"null\" [overrideAction]=\"treeLegend.toggle.bind(treeLegend)\" ></ecs-table-button>\r\n                <p-overlayPanel #treeLegend><div [innerHTML]=\"(tableOptions.legend?.content) | ecsTranslate\"></div></p-overlayPanel>\r\n            </ng-container>\r\n            <span>{{ 'Showing {{count}} root nodes of {{total}} available root nodes' | ecsTranslate: { count: totalRecords, total: totalRecordsNotFiltered } }}</span>\r\n            <p-paginator [first]=\"currentPage * currentRowsPerPage\" [rows]=\"currentRowsPerPage\" [totalRecords]=\"totalRecords\"\r\n                [rowsPerPageOptions]=\"allowedRowsPerPage\" dropdownAppendTo=\"body\" (onPageChange)=\"treePageChange($event)\" ></p-paginator>\r\n        </div>\r\n    </ng-container>\r\n</div>\r\n<ecs-column-selector [visible]=\"showColumnSelector\" [columnModalData]=\"columnModalData\" [filteredColumnData]=\"filteredColumnData\" [orderByHeader]=\"tableOptions.columns?.selectorOrderByColumnName === true\" (visibleChange)=\"showColumnSelector=false\" (applyChanges)=\"applyColumnModalChanges($event)\"></ecs-column-selector>\r\n<ecs-export-excel [visible]=\"showExportModal\" [rowCheckboxSelectorActive]=\"tableOptions.rows?.checkboxSelector?.enabled ?? false\" [excelReportTitle]=\"excelReportTitle\" [allowTitleUserEdit]=\"tableOptions.excelReport?.titleAllowUserEdit ?? false\" (visibleChange)=\"showExportModal=false\" (exportToExcel)=\"generateExcelReport($event)\"></ecs-export-excel>\r\n<ecs-views-management [visible]=\"viewsModalShow\" [tableViews_menuItems]=\"tableViews_menuItems\" \r\n    (onViewSelect)=\"viewLoad($event)\" (onViewCreate)=\"viewCreate($event)\" (onViewDelete)=\"viewDelete($event)\" (onViewEditAlias)=\"viewEditAlias($event)\" (onViewUpdateData)=\"viewUpdateData($event)\" (onViewUpdateActiveStartup)=\"viewUpdateActiveStartup($event)\"\r\n    (visibleChange)=\"viewsModalShow=false\"></ecs-views-management>\r\n<!-- Body-level overlays avoid clipping inside scrollable and frozen table cells. -->\r\n<p-menu #responsiveHeaderMenu [model]=\"headerMenuItems\" [popup]=\"true\" appendTo=\"body\" styleClass=\"ecs-responsive-menu\"></p-menu>\r\n<p-menu #responsiveRowMenu [model]=\"rowMenuItems\" [popup]=\"true\" appendTo=\"body\" styleClass=\"ecs-responsive-menu\"></p-menu>\r\n", styles: [".highlighted-text{background-color:#ff0;color:#000;border-radius:2px}.excel-export-tooltip .bool-icon{text-shadow:0 0 2px white,0 0 3px white}.excel-export-tooltip .bool-true{color:green}.excel-export-tooltip .bool-false{color:red}.p-datatable-column-filter-button.p-button-icon-only.p-button-rounded,.p-datatable-column-filter-clear-button.p-button-icon-only.p-button-rounded{height:var(--p-icon-size)!important;width:var(--p-icon-size)!important;border-radius:0!important}.ecs-view-buttons{display:inline-flex;align-items:center;flex-wrap:nowrap}.ecs-view-buttons>p-button{display:inline-flex;flex:0 0 auto}.viewButton{width:200px}.viewButton .p-button{width:100%;justify-content:center}.viewButton .p-button-label{display:block;width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;text-align:center}.ecs-compact-header{gap:.5rem;min-width:0}.ecs-header-menu-trigger{margin-left:auto;flex:0 0 auto}.ecs-responsive-trigger{min-width:44px;min-height:44px}.ecs-global-search{display:inline-flex;align-items:center;gap:8px;min-width:0}.ecs-global-search>.ecs-input-icon{display:inline-flex;flex:0 0 auto}.ecs-global-search input{min-width:0}.ecs-responsive-search{flex:1 1 220px;min-width:0;max-width:320px}.ecs-responsive-search input{width:100%;padding-right:2.5rem}.ecs-clear-search{border:0;background:transparent;color:inherit;cursor:pointer}.ecs-responsive-menu{max-width:calc(100vw - 16px);max-height:calc(100dvh - 32px);overflow-y:auto}.ecs-responsive-menu .p-menu-item-link{min-height:44px;white-space:normal}.ecs-tree-cell{display:flex;align-items:center;gap:4px;min-width:0}.ecs-tree-cell>ecs-table-cell{flex:1;min-width:0}.ecs-tree-toggle{width:32px;height:32px;flex:0 0 32px;border:0;background:transparent;color:inherit;cursor:pointer}.ecs-tree-toggle:focus-visible{outline:2px solid var(--p-primary-color);outline-offset:1px}.ecs-tree-leaf{visibility:hidden}.ecs-tree-paginator{display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:8px}.p-datatable-thead>.ecs-column-groups>td{padding:var(--p-datatable-header-cell-padding);background:var(--p-datatable-header-cell-background);color:var(--p-datatable-header-cell-color);font-weight:var(--p-datatable-column-title-font-weight);border:1px solid var(--p-datatable-header-cell-border-color);white-space:normal;overflow-wrap:anywhere}\n"], dependencies: [{ kind: "pipe", type: ECSTableTranslatePipe, name: "ecsTranslate" }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i3.TranslatePipe, name: "translate" }, { kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i4.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i4.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i4.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i5.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: i5.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i5.MaxLengthValidator, selector: "[maxlength][formControlName],[maxlength][formControl],[maxlength][ngModel]", inputs: ["maxlength"] }, { kind: "directive", type: i5.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: TableModule }, { kind: "component", type: i6.Table, selector: "p-table", inputs: ["frozenColumns", "frozenValue", "style", "styleClass", "tableStyle", "tableStyleClass", "paginator", "pageLinks", "rowsPerPageOptions", "alwaysShowPaginator", "paginatorPosition", "paginatorDropdownAppendTo", "paginatorDropdownScrollHeight", "currentPageReportTemplate", "showCurrentPageReport", "showJumpToPageDropdown", "showJumpToPageInput", "showFirstLastIcon", "showPageLinks", "defaultSortOrder", "sortMode", "resetPageOnSort", "selectionMode", "selectionPageOnly", "contextMenuSelection", "contextMenuSelectionMode", "dataKey", "metaKeySelection", "rowSelectable", "rowTrackBy", "lazy", "lazyLoadOnInit", "compareSelectionBy", "csvSeparator", "exportFilename", "filters", "globalFilterFields", "filterDelay", "filterLocale", "expandedRowKeys", "editingRowKeys", "rowExpandMode", "scrollable", "scrollDirection", "rowGroupMode", "scrollHeight", "virtualScroll", "virtualScrollItemSize", "virtualScrollOptions", "virtualScrollDelay", "frozenWidth", "responsive", "contextMenu", "resizableColumns", "columnResizeMode", "reorderableColumns", "loading", "loadingIcon", "showLoader", "rowHover", "customSort", "showInitialSortBadge", "autoLayout", "exportFunction", "exportHeader", "stateKey", "stateStorage", "editMode", "groupRowsBy", "groupRowsByOrder", "responsiveLayout", "breakpoint", "virtualRowHeight", "value", "columns", "first", "rows", "totalRecords", "sortField", "sortOrder", "multiSortMeta", "selection", "selectAll"], outputs: ["selectAllChange", "selectionChange", "contextMenuSelectionChange", "onRowSelect", "onRowUnselect", "onPage", "onSort", "onFilter", "onLazyLoad", "onRowExpand", "onRowCollapse", "onContextMenuSelect", "onColResize", "onColReorder", "onRowReorder", "onEditInit", "onEditComplete", "onEditCancel", "onHeaderCheckboxToggle", "sortFunction", "firstChange", "rowsChange", "onStateSave", "onStateRestore"] }, { kind: "directive", type: i7.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "directive", type: i6.SortableColumn, selector: "[pSortableColumn]", inputs: ["pSortableColumn", "pSortableColumnDisabled"] }, { kind: "directive", type: i6.FrozenColumn, selector: "[pFrozenColumn]", inputs: ["frozen", "alignFrozen"] }, { kind: "directive", type: i6.SelectableRow, selector: "[pSelectableRow]", inputs: ["pSelectableRow", "pSelectableRowIndex", "pSelectableRowDisabled"] }, { kind: "directive", type: i6.ResizableColumn, selector: "[pResizableColumn]", inputs: ["pResizableColumnDisabled"] }, { kind: "directive", type: i6.ReorderableColumn, selector: "[pReorderableColumn]", inputs: ["pReorderableColumnDisabled"] }, { kind: "component", type: i6.SortIcon, selector: "p-sortIcon", inputs: ["field"] }, { kind: "component", type: i6.ColumnFilter, selector: "p-columnFilter", inputs: ["field", "type", "display", "showMenu", "matchMode", "operator", "showOperator", "showClearButton", "showApplyButton", "showMatchModes", "showAddButton", "hideOnClear", "placeholder", "matchModeOptions", "maxConstraints", "minFractionDigits", "maxFractionDigits", "prefix", "suffix", "locale", "localeMatcher", "currency", "currencyDisplay", "useGrouping", "showButtons"] }, { kind: "ngmodule", type: ButtonModule }, { kind: "directive", type: i8.ButtonDirective, selector: "[pButton]", inputs: ["iconPos", "loadingIcon", "label", "icon", "loading"] }, { kind: "component", type: i8.Button, selector: "p-button", inputs: ["type", "iconPos", "icon", "badge", "label", "disabled", "loading", "loadingIcon", "style", "styleClass", "badgeClass", "ariaLabel"], outputs: ["onClick", "onFocus", "onBlur"] }, { kind: "ngmodule", type: TooltipModule }, { kind: "directive", type: i9.Tooltip, selector: "[pTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "fitContent", "pTooltip", "tooltipDisabled", "tooltipOptions"] }, { kind: "ngmodule", type: InputTextModule }, { kind: "directive", type: i10.InputText, selector: "[pInputText]" }, { kind: "ngmodule", type: MultiSelectModule }, { kind: "component", type: i11.MultiSelect, selector: "p-multiSelect", inputs: ["style", "styleClass", "panelStyle", "panelStyleClass", "inputId", "disabled", "readonly", "group", "filter", "filterPlaceHolder", "filterLocale", "overlayVisible", "tabindex", "appendTo", "dataKey", "name", "label", "ariaLabelledBy", "displaySelectedLabel", "maxSelectedLabels", "selectionLimit", "selectedItemsLabel", "showToggleAll", "emptyFilterMessage", "emptyMessage", "resetFilterOnHide", "dropdownIcon", "optionLabel", "optionValue", "optionDisabled", "optionGroupLabel", "optionGroupChildren", "showHeader", "filterBy", "scrollHeight", "lazy", "virtualScroll", "virtualScrollItemSize", "virtualScrollOptions", "overlayOptions", "ariaFilterLabel", "filterMatchMode", "tooltip", "tooltipPosition", "tooltipPositionStyle", "tooltipStyleClass", "autofocusFilter", "display", "autocomplete", "showClear", "autoZIndex", "baseZIndex", "showTransitionOptions", "hideTransitionOptions", "defaultLabel", "placeholder", "options", "filterValue", "itemSize"], outputs: ["onChange", "onFilter", "onFocus", "onBlur", "onClick", "onClear", "onPanelShow", "onPanelHide", "onLazyLoad"] }, { kind: "ngmodule", type: CheckboxModule }, { kind: "component", type: i12.Checkbox, selector: "p-checkbox", inputs: ["value", "name", "disabled", "binary", "label", "ariaLabelledBy", "ariaLabel", "tabindex", "inputId", "style", "styleClass", "labelStyleClass", "formControl", "checkboxIcon", "readonly", "required", "trueValue", "falseValue"], outputs: ["onChange"] }, { kind: "ngmodule", type: PaginatorModule }, { kind: "component", type: i13.Paginator, selector: "p-paginator", inputs: ["pageLinkSize", "style", "styleClass", "alwaysShow", "templateLeft", "templateRight", "dropdownAppendTo", "dropdownScrollHeight", "currentPageReportTemplate", "showCurrentPageReport", "showFirstLastIcon", "totalRecords", "rows", "rowsPerPageOptions", "showJumpToPageDropdown", "showJumpToPageInput", "showPageLinks", "dropdownItemTemplate", "first"], outputs: ["onPageChange"] }, { kind: "component", type: TableCell, selector: "ecs-table-cell", inputs: ["col", "rowData", "globalSearchText", "predefinedFiltersCollection", "dateFormat", "dateTimezone", "dateCulture"] }, { kind: "component", type: TablePredefinedFilters, selector: "ecs-table-predefined-filters", inputs: ["option", "col", "selectable", "rowData", "globalSearchText"] }, { kind: "component", type: TableButton, selector: "ecs-table-button", inputs: ["button", "rowData", "isActionButton", "isLastActionButton", "overrideAction"] }, { kind: "component", type: ColumnSelector, selector: "ecs-column-selector", inputs: ["orderByHeader", "visible", "columnModalData", "filteredColumnData"], outputs: ["visibleChange", "applyChanges"] }, { kind: "component", type: ExportExcel, selector: "ecs-export-excel", inputs: ["visible", "rowCheckboxSelectorActive", "excelReportTitle", "allowTitleUserEdit"], outputs: ["exportToExcel", "visibleChange"] }, { kind: "component", type: ViewsManagement, selector: "ecs-views-management", inputs: ["visible", "tableViews_menuItems"], outputs: ["onViewSelect", "onViewDelete", "onViewUpdateData", "onViewUpdateActiveStartup", "onViewEditAlias", "onViewCreate", "visibleChange"] }, { kind: "ngmodule", type: OverlayPanelModule }, { kind: "component", type: i14.OverlayPanel, selector: "p-overlayPanel", inputs: ["dismissable", "showCloseIcon", "style", "styleClass", "appendTo", "autoZIndex", "ariaCloseLabel", "baseZIndex", "focusOnShow", "showTransitionOptions", "hideTransitionOptions"], outputs: ["onShow", "onHide"] }, { kind: "ngmodule", type: MenuModule }, { kind: "component", type: i15.Menu, selector: "p-menu", inputs: ["model", "popup", "style", "styleClass", "appendTo", "autoZIndex", "baseZIndex", "showTransitionOptions", "hideTransitionOptions"], outputs: ["onShow", "onHide"] }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ECSPrimengTable, decorators: [{
+            type: Component,
+            args: [{ selector: 'ecs-primeng-table', imports: [
+                        ECSTableTranslatePipe,
+                        TranslateModule,
+                        CommonModule,
+                        FormsModule,
+                        TableModule,
+                        ButtonModule,
+                        TooltipModule,
+                        InputTextModule,
+                        MultiSelectModule,
+                        CheckboxModule,
+                        PaginatorModule,
+                        TableCell,
+                        TablePredefinedFilters,
+                        TableButton,
+                        ColumnSelector,
+                        ExportExcel,
+                        ViewsManagement,
+                        OverlayPanelModule,
+                        MenuModule
+                    ], standalone: true, encapsulation: ViewEncapsulation.None, template: "<div #tableContainer>\r\n    <p-table #dt\r\n        styleClass=\"p-datatable-sm p-datatable-gridlines p-datatable-striped\"\r\n        sortMode=\"multiple\"\r\n        [resizableColumns]=\"true\" columnResizeMode=\"expand\"\r\n        [reorderableColumns]=\"true\"\r\n        [scrollable]=\"true\" [scrollHeight]=\"scrollHeightValue\"\r\n        [columns]=\"tableOptions.columns?.shown ?? []\" [value]=\"tableOptions.data ?? []\" dataKey=\"rowID\" \r\n        [paginator]=\"!treeState\" [loading]=\"treeState?.loading ?? false\" paginatorDropdownAppendTo=\"body\" [first]=\"currentPage * currentRowsPerPage\" [rows]=\"currentRowsPerPage\" [totalRecords]=\"totalRecords\"\r\n        [rowsPerPageOptions]=\"allowedRowsPerPage\" [showCurrentPageReport]=\"false\" (onPage)=\"pageChange($event)\"\r\n        [selectionMode]=\"tableOptions.rows?.singleSelector?.enabled ? 'single' : ''\" [metaKeySelection]=\"tableOptions.rows?.singleSelector?.metakey ?? true\" [(selection)]=\"rowSelection\" (onRowSelect)=\"rowSelect($event)\" (onRowUnselect)=\"rowUnselect($event)\"\r\n        [lazy]=\"true\" (onLazyLoad)=\"fetchTableData($event)\">\r\n\r\n        <!--TEMPLATE FOR THE ACTIONS HEADER COLUMN-->\r\n        <ng-template #actionColumnHeaderTemplate>\r\n            <ng-container *ngIf=\"(tableOptions.rows?.action?.buttons?.length ?? 0) > 0\">\r\n                <th [ngStyle]=\"{\r\n                        'text-align': 'center',\r\n                        'vertical-align': 'middle',\r\n                        'max-width': actionColumnWidth + 'px',\r\n                        'min-width': actionColumnWidth + 'px',\r\n                        'width': actionColumnWidth + 'px'\r\n                    }\"\r\n                    pResizableColumn [pResizableColumnDisabled]=\"!tableOptions.rows?.action?.resizable\" pFrozenColumn [frozen]=\"tableOptions.rows?.action?.frozen ?? false\"\r\n                    [alignFrozen]=\"getFrozenColumnAlignAsText(tableOptions.rows?.action?.positionRight ? FrozenColumnAlign.Right : FrozenColumnAlign.Left)\" id=\"actions-header\"\r\n                    [attr.scope]=\"'col'\">\r\n                    {{ (tableOptions.rows?.action?.header ?? '') | ecsTranslate }}\r\n                </th>\r\n            </ng-container>\r\n        </ng-template>\r\n\r\n        <!--TEMPLATE FOR THE ACTIONS ROW COLUMN-->\r\n        <ng-template #actionColumnTemplate let-rowData=\"rowData\">\r\n            <ng-container *ngIf=\"(tableOptions.rows?.action?.buttons?.length ?? 0) > 0\">\r\n                <td \r\n                    [ngStyle]=\"{\r\n                        'text-align': (getDataAlignHorizontalAsText(tableOptions.rows?.action?.horizontalAlignment ?? DataAlignHorizontal.Center)),\r\n                        'vertical-align': (getDataAlignVerticalAsText(tableOptions.rows?.action?.verticalAlignment ?? DataAlignVertical.Middle)),\r\n                        'max-width': actionColumnWidth + 'px',\r\n                        'min-width': actionColumnWidth + 'px',\r\n                        'width': actionColumnWidth + 'px'\r\n                    }\"\r\n                    pFrozenColumn [frozen]=\"tableOptions.rows?.action?.frozen ?? false\"\r\n                    [alignFrozen]=\"getFrozenColumnAlignAsText(tableOptions.rows?.action?.positionRight ? FrozenColumnAlign.Right : FrozenColumnAlign.Left)\">\r\n                    <ng-container *ngIf=\"compactRows; else ecsElse0\">\r\n                        <ng-container *ngIf=\"hasRowMenuActions(rowData)\">\r\n                            <button pButton type=\"button\" icon=\"pi pi-ellipsis-v\" [attr.aria-label]=\"(tableOptions.responsive?.rowMenuLabel || 'Row actions') | ecsTranslate\"\r\n                                aria-haspopup=\"menu\" [attr.aria-expanded]=\"responsiveRowMenu.visible && rowMenuRow === rowData\"\r\n                                (click)=\"openRowMenu($event, rowData)\" class=\"ecs-responsive-trigger\"></button>\r\n                        </ng-container>\r\n                    </ng-container><ng-template #ecsElse0>\r\n                    <ng-container *ngFor=\"let button of tableOptions.rows?.action?.buttons; trackBy: ecsTrack1; let $index = index; let $first = first; let $last = last; let $even = even; let $odd = odd; let $count = count; let last = last\">\r\n                        <ecs-table-button [button]=\"button\" [rowData]=\"rowData\" [isActionButton]=\"true\" [isLastActionButton]=\"last\"></ecs-table-button>\r\n                    </ng-container>\r\n                    </ng-template>\r\n                </td>\r\n            </ng-container>\r\n        </ng-template>\r\n\r\n        <!-- TEMPLATE FOR THE ROW CHECKBOX SELECTOR HEADER COLUMN -->\r\n        <ng-template #rowSelectorColumnHeaderTemplate>\r\n            <th \r\n                [ngStyle]=\"{\r\n                    'text-align': 'center',\r\n                    'vertical-align': 'middle',\r\n                    'max-width': (tableOptions.rows?.checkboxSelector?.width ?? 150) + 'px',\r\n                    'min-width': (tableOptions.rows?.checkboxSelector?.width ?? 150) + 'px',\r\n                    'width': (tableOptions.rows?.checkboxSelector?.width ?? 150) + 'px'\r\n                }\"\r\n                id=\"rowSelector-header\"  [attr.scope]=\"'col'\" pResizableColumn [pResizableColumnDisabled]=\"!tableOptions.rows?.checkboxSelector?.resizable\" pFrozenColumn \r\n                [frozen]=\"tableOptions.rows?.checkboxSelector?.frozen ?? false\" [alignFrozen]=\"getFrozenColumnAlignAsText(tableOptions.rows?.checkboxSelector?.positionRight ? FrozenColumnAlign.Right : FrozenColumnAlign.Left)\">\r\n                    <div style=\"display: flex; justify-content: space-between; align-items: center;\">\r\n                        <ng-container *ngIf=\"tableOptions.rows?.checkboxSelector?.selectAllEnabled\">\r\n                            <input type=\"checkbox\" class=\"ecs-select-all\" [checked]=\"allMatchingRowsSelected\"\r\n                                [indeterminate]=\"matchingRowsPartiallySelected\"\r\n                                [disabled]=\"selectAllLoading || !tableOptions.rows?.checkboxSelector?.urlSelectAll\"\r\n                                [attr.aria-label]=\"'Select all filtered rows' | ecsTranslate\"\r\n                                [pTooltip]=\"'Select all filtered rows' | ecsTranslate\"\r\n                                (change)=\"toggleAllMatchingRows($any($event.target).checked)\">\r\n                        </ng-container>\r\n                        {{ (tableOptions.rows?.checkboxSelector?.header ?? '') | ecsTranslate }}\r\n                        <p-columnFilter type=\"boolean\" field=\"selector\" display=\"menu\" [showButtons]=\"false\"></p-columnFilter>\r\n                    </div>\r\n            </th>\r\n        </ng-template>\r\n\r\n        <!--TEMPLATE FOR THE ROW CHECKBOX SELECTOR COLUMN-->\r\n        <ng-template #rowSelectorColumnTemplate let-rowData=\"rowData\">\r\n            <td \r\n            [ngStyle]=\"{\r\n                'text-align': (getDataAlignHorizontalAsText(tableOptions.rows?.checkboxSelector?.horizontalAlignment ?? DataAlignHorizontal.Center)),\r\n                'vertical-align': (getDataAlignVerticalAsText(tableOptions.rows?.checkboxSelector?.verticalAlignment ?? DataAlignVertical.Middle)),\r\n                'max-width': (tableOptions.rows?.checkboxSelector?.width ?? 150) + 'px',\r\n                'min-width': (tableOptions.rows?.checkboxSelector?.width ?? 150) + 'px',\r\n                'width': (tableOptions.rows?.checkboxSelector?.width ?? 150) + 'px'\r\n            }\"\r\n            pFrozenColumn [frozen]=\"tableOptions.rows?.checkboxSelector?.frozen ?? false\" \r\n            [alignFrozen]=\"getFrozenColumnAlignAsText(tableOptions.rows?.checkboxSelector?.positionRight ? FrozenColumnAlign.Right : FrozenColumnAlign.Left)\">\r\n            <p-checkbox \r\n                [disabled]=\"!(tableOptions.rows?.checkboxSelector?.enabledCondition?.(rowData) ?? true)\"\r\n                [binary]=\"true\"\r\n                [ngModel]=\"isRowCheckboxSelected(rowData.rowID)\"\r\n                (onChange)=\"onRowChekboxChange($event, rowData.rowID)\"></p-checkbox>\r\n            </td>\r\n        </ng-template>\r\n\r\n\r\n        <!-- LOGIC FOR DRAWING TABLE ACTIONS ABOVE THE HEADER -->\r\n        <ng-template pTemplate=\"caption\">\r\n            <div #headerContainer [class.ecs-compact-header]=\"compactHeader\" style=\"display: flex; justify-content: space-between; align-items: center;\">\r\n                <ng-container *ngIf=\"compactHeader; else ecsElse1\">\r\n                    <ng-container *ngIf=\"tableOptions.globalFilter?.enabled\">\r\n                        <span class=\"ecs-global-search ecs-responsive-search\">\r\n                            <span class=\"ecs-input-icon\"><i class=\"pi pi-search\"></i></span>\r\n                            <input pInputText type=\"text\" [attr.aria-label]=\"'Search keyword' | ecsTranslate\" [placeholder]=\"'Search keyword' | ecsTranslate\" autocomplete=\"off\"\r\n                                [maxlength]=\"tableOptions.globalFilter?.maxLength ?? null\" [ngModel]=\"globalSearchText\"\r\n                                (ngModelChange)=\"onGlobalSearchInput($event)\"/>\r\n                            <ng-container *ngIf=\"globalSearchText\">\r\n                                <span class=\"ecs-input-icon\" position=\"right\"><button type=\"button\" class=\"ecs-clear-search\" [attr.aria-label]=\"'Clear search' | ecsTranslate\" (click)=\"clearFilters(dt, true, true)\"><i class=\"pi pi-times\"></i></button></span>\r\n                            </ng-container>\r\n                        </span>\r\n                    </ng-container>\r\n                    <ng-container *ngIf=\"tableOptions.description?.text\">\r\n                        <i [class]=\"tableOptions.description!.icon\" [pTooltip]=\"(tableOptions.description!.text) | ecsTranslate\" [escape]=\"false\"></i>\r\n                    </ng-container>\r\n                    <button pButton type=\"button\" icon=\"pi pi-bars\" [attr.aria-label]=\"(tableOptions.responsive?.headerMenuLabel || 'Table actions') | ecsTranslate\"\r\n                        aria-haspopup=\"menu\" [attr.aria-expanded]=\"responsiveHeaderMenu.visible\"\r\n                        (click)=\"openHeaderMenu($event)\" class=\"ecs-responsive-trigger ecs-header-menu-trigger\"></button>\r\n                </ng-container><ng-template #ecsElse1>\r\n\r\n                <div style=\"display: flex; align-items: center; gap: 10px;\">\r\n                    <!--CHOOSE COLUMNS TO SHOW-->\r\n                    <ng-container *ngIf=\"tableOptions.columns?.selectorEnabled\">\r\n                        <p-button [icon]=\"tableOptions.columns?.selectorIcon ?? 'pi pi-pencil'\" (onClick)=\"columnSelectorShow()\" [pTooltip]=\"'Modify columns' | ecsTranslate\"\r\n                            [showDelay]=\"700\" tooltipPosition=\"top\" styleClass=\"p-button-icon-only\"></p-button>\r\n                    </ng-container>\r\n                    <!--CLEAR SORTS AND FILTERS-->\r\n                    <ng-container *ngIf=\"tableOptions.header?.clearSortsEnabled\">\r\n                        <p-button [icon]=\"tableOptions.header?.clearSortsIcon ?? 'pi pi-sort-alt-slash'\" (onClick)=\"clearSorts(dt)\" [disabled]=\"!hasToClearSorts(dt)\"\r\n                            [pTooltip]=\"'Clear sorts' | ecsTranslate\" [showDelay]=\"700\" tooltipPosition=\"top\" styleClass=\"p-button-icon-only\"></p-button>\r\n                    </ng-container>\r\n                    <ng-container *ngIf=\"tableOptions.header?.clearFiltersEnabled\">\r\n                        <p-button\r\n                            [icon]=\"tableOptions.header?.clearFiltersIcon ?? 'pi pi-filter-slash'\" (onClick)=\"clearFilters(dt)\" [disabled]=\"!hasToClearFilters(dt, globalSearchText)\"\r\n                            [pTooltip]=\"'Clear filters' | ecsTranslate\" [showDelay]=\"700\" tooltipPosition=\"top\" styleClass=\"p-button-icon-only\"></p-button>\r\n                    </ng-container>\r\n\r\n                    <!--TABLE DESCRIPTION-->\r\n                    <ng-container *ngIf=\"tableOptions.description?.text\"> <!-- If a table description text is provided -->\r\n                        <ng-container *ngIf=\"!tableOptions.description!.tooltip; else ecsElse2\"> <!-- The table description must be shown as text next to the icon -->\r\n                            <i [class]=\"tableOptions.description!.icon\"></i>\r\n                            <span [innerHTML]=\"(tableOptions.description!.text) | ecsTranslate\"></span>\r\n                        </ng-container><ng-template #ecsElse2>\r\n                            <i [escape]=\"false\" [pTooltip]=\"(tableOptions.description!.text) | ecsTranslate\" tooltipPosition=\"right\" [class]=\"tableOptions.description!.icon\"></i>\r\n                        </ng-template>\r\n                    </ng-container>\r\n                </div>\r\n\r\n                <!--TABLE VIEWS-->\r\n                <ng-container *ngIf=\"tableViewsEnabled()\">\r\n                    <div style=\"display: flex; align-items: center; gap: 10px;\">\r\n                        <span class=\"p-buttonset ecs-view-buttons\">\r\n                            <p-button (click)=\"viewsModalShow=true;\"\r\n                                [label]=\"tableViewCurrentSelectedAlias \r\n                                    ? tableViewCurrentSelectedAlias \r\n                                    : ((tableOptions.views?.noViewSelectedText || '--- Select a view ---') | ecsTranslate)\"\r\n                                [class]=\"'viewButton' + (tableOptions.views?.selectViewButtonClass ? ' ' + tableOptions.views!.selectViewButtonClass : '')\"></p-button>\r\n                            <p-button (click)=\"viewLoad(tableViewCurrentSelectedAlias!)\"  [disabled]=\"!tableViewCurrentSelectedAlias\" [pTooltip]=\"'Apply view again' | ecsTranslate\" [showDelay]=\"700\" tooltipPosition=\"top\"\r\n                                [icon]=\"tableOptions.views?.reloadViewButtonIcon || 'pi pi-refresh'\"\r\n                                [class]=\"tableOptions.views?.reloadViewButtonClass || ''\"></p-button>\r\n                        </span>\r\n                    </div>\r\n                </ng-container>\r\n\r\n                <div style=\"display: flex; align-items: center; gap: 10px;\">\r\n                    <!--GLOBAL FILTER-->\r\n                    <ng-container *ngIf=\"tableOptions.globalFilter?.enabled\">\r\n                        <span class=\"ecs-global-search ml-auto\">\r\n                            <span class=\"ecs-input-icon\">\r\n                                <i class=\"pi pi-search\"></i>\r\n                            </span>\r\n                            <input pInputText type=\"text\" \r\n                                (ngModelChange)=\"onGlobalSearchInput($event)\" autocomplete=\"off\"\r\n                                [maxlength]=\"tableOptions.globalFilter?.maxLength ?? null\" [placeholder]=\"'Search keyword' | ecsTranslate\" [ngModel]=\"globalSearchText\"\r\n                                style=\"width: 220px;\"/>\r\n                            <!-- Right icon (only if there is text) -->\r\n                            <ng-container *ngIf=\"globalSearchText\">\r\n                                <span class=\"ecs-input-icon\" position=\"right\">\r\n                                    <i class=\"pi pi-times\" style=\"cursor: pointer;\"  (click)=\"clearFilters(dt, true, true); $event.stopPropagation()\"></i>\r\n                                </span>\r\n                            </ng-container>\r\n                        </span>\r\n                    </ng-container>\r\n\r\n                    <!--EXPORT DATA-->\r\n                    <ng-container *ngIf=\"tableOptions.excelReport?.url?.trim()\">\r\n                        <p-button icon=\"pi pi-file-excel\" (onClick)=\"openExcelExport()\"\r\n                            [pTooltip]=\"'Export to Excel' | ecsTranslate\" [showDelay]=\"700\" tooltipPosition=\"top\" styleClass=\"p-button-icon-only\"></p-button>\r\n                    </ng-container>\r\n\r\n                    <!--RESET TABLE VIEW-->\r\n                    <ng-container *ngIf=\"tableOptions.resetTableView?.enabled\">\r\n                        <p-button [icon]=\"tableOptions.resetTableView?.icon ?? 'pi pi-eraser'\" (click)=\"resetTableView()\" [pTooltip]=\"'Reset table view' | ecsTranslate\" [showDelay]=\"700\"\r\n                            tooltipPosition=\"top\" styleClass=\"p-button-icon-only\"></p-button>\r\n                    </ng-container>\r\n\r\n                    <!--REFRESH DATA-->\r\n                    <p-button icon=\"pi pi-refresh\" (onClick)=\"refreshData($event)\" [pTooltip]=\"'Refresh data' | ecsTranslate\" [showDelay]=\"700\"\r\n                        tooltipPosition=\"top\" styleClass=\"p-button-icon-only\"></p-button>\r\n                    \r\n                    <!-- HEADER ACTION BUTTONS -->\r\n                    <ng-container *ngIf=\"(tableOptions.header?.buttons?.length ?? 0) > 0\">\r\n                        <td style=\"display: flex; justify-content: center; align-items: center; gap: 10px;\">\r\n                            <ng-container *ngFor=\"let button of tableOptions.header?.buttons; trackBy: ecsTrack2; let $index = index; let $first = first; let $last = last; let $even = even; let $odd = odd; let $count = count\">\r\n                                <ecs-table-button [button]=\"button\" [rowData]=\"null\"></ecs-table-button>\r\n                            </ng-container>\r\n                        </td>\r\n                    </ng-container>\r\n                </div>\r\n                </ng-template>\r\n            </div>\r\n        </ng-template>\r\n\r\n        <!-- LOGIC FOR DRAWING TABLE HEADERS -->\r\n        <ng-template pTemplate=\"header\" let-columns>\r\n            <ng-container *ngIf=\"getColumnHeaderGroups(columns) as headerGroups\">\r\n            <ng-container *ngIf=\"headerGroups.length\">\r\n                <tr class=\"ecs-column-groups\">\r\n                    <ng-container *ngIf=\"(tableOptions.rows?.action?.buttons?.length ?? 0) > 0 && !tableOptions.rows?.action?.positionRight\">\r\n                        <td aria-hidden=\"true\" pFrozenColumn [frozen]=\"tableOptions.rows?.action?.frozen ?? false\" alignFrozen=\"left\"\r\n                            [style.width.px]=\"actionColumnWidth\" [style.min-width.px]=\"actionColumnWidth\"></td>\r\n                    </ng-container>\r\n                    <ng-container *ngIf=\"tableOptions.rows?.checkboxSelector?.enabled && !tableOptions.rows?.checkboxSelector?.positionRight\">\r\n                        <td aria-hidden=\"true\" pFrozenColumn [frozen]=\"tableOptions.rows?.checkboxSelector?.frozen ?? false\" alignFrozen=\"left\"\r\n                            [style.width.px]=\"tableOptions.rows?.checkboxSelector?.width ?? 150\" [style.min-width.px]=\"tableOptions.rows?.checkboxSelector?.width ?? 150\"></td>\r\n                    </ng-container>\r\n                    <ng-container *ngFor=\"let group of headerGroups; trackBy: ecsTrack3; let $index = index; let $first = first; let $last = last; let $even = even; let $odd = odd; let $count = count\">\r\n                        <td [attr.colspan]=\"group.colspan\" role=\"columnheader\" [attr.aria-colspan]=\"group.colspan\" style=\"text-align: center; vertical-align: middle;\"\r\n                            pFrozenColumn [frozen]=\"group.frozenColumnAlign !== FrozenColumnAlign.Noone\"\r\n                            [alignFrozen]=\"getFrozenColumnAlignAsText(group.frozenColumnAlign)\">\r\n                            {{ group.label | translate }}\r\n                        </td>\r\n                    </ng-container>\r\n                    <ng-container *ngIf=\"tableOptions.rows?.checkboxSelector?.enabled && tableOptions.rows?.checkboxSelector?.positionRight\">\r\n                        <td aria-hidden=\"true\" pFrozenColumn [frozen]=\"tableOptions.rows?.checkboxSelector?.frozen ?? false\" alignFrozen=\"right\"\r\n                            [style.width.px]=\"tableOptions.rows?.checkboxSelector?.width ?? 150\" [style.min-width.px]=\"tableOptions.rows?.checkboxSelector?.width ?? 150\"></td>\r\n                    </ng-container>\r\n                    <ng-container *ngIf=\"(tableOptions.rows?.action?.buttons?.length ?? 0) > 0 && tableOptions.rows?.action?.positionRight\">\r\n                        <td aria-hidden=\"true\" pFrozenColumn [frozen]=\"tableOptions.rows?.action?.frozen ?? false\" alignFrozen=\"right\"\r\n                            [style.width.px]=\"actionColumnWidth\" [style.min-width.px]=\"actionColumnWidth\"></td>\r\n                    </ng-container>\r\n                </tr>\r\n            </ng-container>\r\n            <tr>\r\n                <ng-container *ngIf=\"!tableOptions.rows?.action?.positionRight\">\r\n                    <ng-container *ngTemplateOutlet=\"actionColumnHeaderTemplate\"></ng-container>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"tableOptions.rows?.checkboxSelector?.enabled && !tableOptions.rows?.checkboxSelector?.positionRight\">\r\n                    <ng-container [ngTemplateOutlet]=\"rowSelectorColumnHeaderTemplate\"></ng-container>\r\n                </ng-container>\r\n                <ng-container *ngFor=\"let col of columns; trackBy: ecsTrack4; let $index = index; let $first = first; let $last = last; let $even = even; let $odd = odd; let $count = count\">\r\n                    <th [ngStyle]=\"getColumnStyle(col, true)\"\r\n                        pResizableColumn [pResizableColumnDisabled]=\"!col.canBeResized ? true : false\"\r\n                        pReorderableColumn [pReorderableColumnDisabled]=\"!col.canBeReordered ? true : false\"\r\n                        pFrozenColumn [frozen]=\"col.frozenColumnAlign === FrozenColumnAlign.Left || col.frozenColumnAlign === FrozenColumnAlign.Right\" [alignFrozen]=\"getFrozenColumnAlignAsText(col.frozenColumnAlign)\"\r\n                        [pSortableColumn]=\"col.field\" [pSortableColumnDisabled]=\"!col.canBeSorted ? true : false\"\r\n                        style=\"text-align: center;\"\r\n                        [id]=\"col.field + '-header'\" [attr.scope]=\"'col'\">\r\n                        <div style=\"display: flex; justify-content: space-between; align-items: center; width: 100%;\">\r\n                            <div style=\"margin-right: 15px;\">\r\n                                <span>{{ col.header | translate }}</span>\r\n                            </div>\r\n                            <div style=\"display: flex; align-items: center; gap: 5px;\">\r\n                                <ng-container *ngIf=\"col.canBeSorted\">\r\n                                    <p-sortIcon [field]=\"col.field\"></p-sortIcon>\r\n                                </ng-container>\r\n                                <ng-container *ngIf=\"col.canBeFiltered\">\r\n                                    <ng-container *ngIf=\"!col.filterPredefinedValuesName || col.filterPredefinedValuesName.length === 0; else ecsElse3\">\r\n                                        <p-columnFilter [type]=\"getDataTypeAsText(col.dataType)\" [field]=\"col.field\" display=\"menu\" [showButtons]=\"false\" (click)=\"$event.stopPropagation()\"></p-columnFilter>\r\n                                    </ng-container><ng-template #ecsElse3>\r\n                                        <p-columnFilter\r\n                                            [type]=\"getDataTypeAsText(col.dataType)\" [field]=\"col.field\" display=\"menu\"\r\n                                            (click)=\"$event.stopPropagation()\"\r\n                                            [showButtons]=\"false\" matchMode=\"in\" operator=\"or\" [showMatchModes]=\"false\"\r\n                                            [showOperator]=\"false\" [showAddButton]=\"false\" [showClearButton]=\"false\" [showApplyButton]=\"false\">\r\n                                            <ng-template pTemplate=\"filter\">\r\n                                                <p-multiSelect\r\n                                                    [style]=\"{ minWidth: '400px' }\" [(ngModel)]=\"predefinedFiltersSelectedValuesCollection[col.filterPredefinedValuesName]\"\r\n                                                    [options]=\"getPredefinedFilterValues(col.filterPredefinedValuesName)\" [placeholder]=\"'Any value' | ecsTranslate\"\r\n                                                    (onChange)=\"onPredefinedFilterChange(col.field, $event.value)\" optionLabel=\"name\">\r\n                                                    <ng-template pTemplate=\"item\" let-option >\r\n                                                        <div style=\"display: inline-block; vertical-align: middle;\">\r\n                                                            <ecs-table-predefined-filters [option]=\"option\" [col]=\"col\" [selectable]=\"false\" [rowData]=\"null\"></ecs-table-predefined-filters>\r\n                                                        </div>\r\n                                                    </ng-template>\r\n                                                </p-multiSelect>\r\n                                            </ng-template>\r\n                                        </p-columnFilter>\r\n                                    </ng-template>\r\n                                </ng-container>\r\n                                <ng-container *ngIf=\"col.columnDescription && col.columnDescription.length > 0\">\r\n                                    <i [pTooltip]=\"(col.columnDescription) | ecsTranslate\" tooltipPosition=\"top\" [class]=\"tableOptions.columnDescriptionIcon || 'pi pi-info-circle'\"></i>\r\n                                </ng-container>\r\n                            </div>\r\n                        </div>\r\n                    </th>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"tableOptions.rows?.checkboxSelector?.enabled && tableOptions.rows?.checkboxSelector?.positionRight\">\r\n                    <ng-container [ngTemplateOutlet]=\"rowSelectorColumnHeaderTemplate\"></ng-container>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"tableOptions.rows?.action?.positionRight\">\r\n                    <ng-container *ngTemplateOutlet=\"actionColumnHeaderTemplate\"></ng-container>\r\n                </ng-container>\r\n            </tr>\r\n            </ng-container>\r\n        </ng-template>\r\n\r\n        <!-- LOGIC FOR DRAWING TABLE DATA WHEN THERE IS CONTENTS -->\r\n        <ng-template pTemplate=\"body\" let-rowData let-columns=\"columns\">\r\n            <ng-container *ngIf=\"treeState?.isMore(rowData); else ecsElse4\">\r\n                <tr class=\"ecs-tree-more-row\">\r\n                    <td colspan=\"999\">\r\n                        <p-button icon=\"pi pi-plus\" styleClass=\"p-button-text\" [label]=\"'Load more children' | ecsTranslate\"\r\n                            (onClick)=\"loadMoreTreeRows($event, rowData)\" ></p-button>\r\n                    </td>\r\n                </tr>\r\n            </ng-container><ng-template #ecsElse4>\r\n            <tr [pSelectableRow]=\"rowData\" [ngClass]=\"tableOptions.rows?.class?.(rowData)\" [ngStyle]=\"tableOptions.rows?.style?.(rowData)\"\r\n                [attr.aria-level]=\"treeState ? treeState.depth(rowData) + 1 : null\"\r\n                [attr.aria-expanded]=\"treeState?.hasChildren(rowData) ? treeState?.isExpanded(rowData) : null\">\r\n                <ng-container *ngIf=\"!tableOptions.rows?.action?.positionRight\">\r\n                    <ng-container *ngTemplateOutlet=\"actionColumnTemplate; context: { rowData: rowData }\"></ng-container>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"tableOptions.rows?.checkboxSelector?.enabled && !tableOptions.rows?.checkboxSelector?.positionRight\">\r\n                    <ng-container [ngTemplateOutlet]=\"rowSelectorColumnTemplate\" [ngTemplateOutletContext]=\"{ rowData: rowData }\"></ng-container>\r\n                </ng-container>\r\n                <ng-container *ngFor=\"let col of columns; trackBy: ecsTrack5; let $index = index; let $first = first; let $last = last; let $even = even; let $odd = odd; let $count = count\">\r\n                    <td (mousedown)=\"col.dataType !== DataType.Boolean && copyToClipboardStart($event)\" (mouseup)=\"copyToClipboardCancel()\"\r\n                        [ngStyle]=\"getColumnStyle(col)\" pFrozenColumn [frozen]=\"col.frozenColumnAlign === FrozenColumnAlign.Left || col.frozenColumnAlign === FrozenColumnAlign.Right\" \r\n                        [alignFrozen]=\"getFrozenColumnAlignAsText(col.frozenColumnAlign)\" [style.text-align]=\"getDataAlignHorizontalAsText(col.dataAlignHorizontal)\" [style.vertical-align]=\"getDataAlignVerticalAsText(col.dataAlignVertical)\">\r\n                        <ng-container *ngIf=\"treeState && col.field === treeColumn; else ecsElse5\">\r\n                            <div class=\"ecs-tree-cell\" [style.padding-inline-start.px]=\"treeState.depth(rowData) * 20\">\r\n                                <button type=\"button\" class=\"ecs-tree-toggle\" [class.ecs-tree-leaf]=\"!treeState.hasChildren(rowData)\"\r\n                                    [disabled]=\"!treeState.hasChildren(rowData) || treeState.isLoading(rowData) || treeState.loading\"\r\n                                    [attr.aria-label]=\"(treeState.isExpanded(rowData) ? 'Collapse node' : 'Expand node') | ecsTranslate\"\r\n                                    [attr.aria-expanded]=\"treeState.hasChildren(rowData) ? treeState.isExpanded(rowData) : null\"\r\n                                    [pTooltip]=\"(treeState.isExpanded(rowData) ? 'Collapse node' : 'Expand node') | ecsTranslate\"\r\n                                    (mousedown)=\"$event.stopPropagation()\" (mouseup)=\"$event.stopPropagation()\"\r\n                                    (click)=\"toggleTreeRow($event, rowData)\">\r\n                                    <i [class]=\"treeState.isLoading(rowData) ? 'pi pi-spinner pi-spin' : treeState.isExpanded(rowData) ? 'pi pi-chevron-down' : 'pi pi-chevron-right'\" aria-hidden=\"true\"></i>\r\n                                </button>\r\n                                <ecs-table-cell [col]=\"col\" [rowData]=\"rowData\" [globalSearchText]=\"effectiveGlobalSearchText\"\r\n                                    [dateFormat]=\"dateFormat\" [dateTimezone]=\"dateTimezone\" [dateCulture]=\"dateCulture\"\r\n                                    [predefinedFiltersCollection]=\"tableOptions.predefinedFilters\" ></ecs-table-cell>\r\n                            </div>\r\n                        </ng-container><ng-template #ecsElse5>\r\n                        <ecs-table-cell [col]=\"col\" [rowData]=\"rowData\" [globalSearchText]=\"effectiveGlobalSearchText\"\r\n                            [dateFormat]=\"dateFormat\" [dateTimezone]=\"dateTimezone\" [dateCulture]=\"dateCulture\"\r\n                            [predefinedFiltersCollection]=\"tableOptions.predefinedFilters\"></ecs-table-cell>\r\n                        </ng-template>\r\n                    </td>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"tableOptions.rows?.checkboxSelector?.enabled && tableOptions.rows?.checkboxSelector?.positionRight\">\r\n                    <ng-container [ngTemplateOutlet]=\"rowSelectorColumnTemplate\" [ngTemplateOutletContext]=\"{ rowData: rowData }\"></ng-container>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"tableOptions.rows?.action?.positionRight\">\r\n                    <ng-container *ngTemplateOutlet=\"actionColumnTemplate; context: { rowData: rowData }\"></ng-container>\r\n                </ng-container>\r\n            </tr>\r\n            </ng-template>\r\n        </ng-template>\r\n\r\n        <!-- LOGIC FOR DRAWING TABLE DATA WHEN THERE IS NO CONTENTS -->\r\n        <ng-template pTemplate=\"emptymessage\">\r\n            <tr>\r\n                <td colspan=\"999\">{{ 'No data found for the current filter criteria.' | ecsTranslate }}</td>\r\n            </tr>\r\n        </ng-template>\r\n\r\n        <!-- SHOW CUSTOM RECORDS REPORT -->\r\n        <ng-template pTemplate=\"paginatorleft\">\r\n            <div #paginatorContainer>\r\n                <div style=\"display: flex; align-items: center; gap: 10px;\">\r\n                    <ng-container *ngIf=\"tableOptions.legend?.content\">\r\n                        <ecs-table-button [button]=\"tableOptions.legend?.button\" [rowData]=\"null\" [overrideAction]=\"op.toggle.bind(op)\"></ecs-table-button>\r\n                        <p-overlayPanel #op>\r\n                            <div [innerHTML]=\"(tableOptions.legend?.content) | ecsTranslate\"></div>\r\n                        </p-overlayPanel>\r\n                    </ng-container>\r\n                    <span>{{ 'Showing {{count}} records of {{total}} available records' | ecsTranslate: { count: totalRecords, total: totalRecordsNotFiltered } }}</span>\r\n                </div>\r\n            </div>\r\n        </ng-template>\r\n    </p-table>\r\n    <ng-container *ngIf=\"treeState\">\r\n        <div #paginatorContainer class=\"ecs-tree-paginator\">\r\n            <ng-container *ngIf=\"tableOptions.legend?.content\">\r\n                <ecs-table-button [button]=\"tableOptions.legend?.button\" [rowData]=\"null\" [overrideAction]=\"treeLegend.toggle.bind(treeLegend)\" ></ecs-table-button>\r\n                <p-overlayPanel #treeLegend><div [innerHTML]=\"(tableOptions.legend?.content) | ecsTranslate\"></div></p-overlayPanel>\r\n            </ng-container>\r\n            <span>{{ 'Showing {{count}} root nodes of {{total}} available root nodes' | ecsTranslate: { count: totalRecords, total: totalRecordsNotFiltered } }}</span>\r\n            <p-paginator [first]=\"currentPage * currentRowsPerPage\" [rows]=\"currentRowsPerPage\" [totalRecords]=\"totalRecords\"\r\n                [rowsPerPageOptions]=\"allowedRowsPerPage\" dropdownAppendTo=\"body\" (onPageChange)=\"treePageChange($event)\" ></p-paginator>\r\n        </div>\r\n    </ng-container>\r\n</div>\r\n<ecs-column-selector [visible]=\"showColumnSelector\" [columnModalData]=\"columnModalData\" [filteredColumnData]=\"filteredColumnData\" [orderByHeader]=\"tableOptions.columns?.selectorOrderByColumnName === true\" (visibleChange)=\"showColumnSelector=false\" (applyChanges)=\"applyColumnModalChanges($event)\"></ecs-column-selector>\r\n<ecs-export-excel [visible]=\"showExportModal\" [rowCheckboxSelectorActive]=\"tableOptions.rows?.checkboxSelector?.enabled ?? false\" [excelReportTitle]=\"excelReportTitle\" [allowTitleUserEdit]=\"tableOptions.excelReport?.titleAllowUserEdit ?? false\" (visibleChange)=\"showExportModal=false\" (exportToExcel)=\"generateExcelReport($event)\"></ecs-export-excel>\r\n<ecs-views-management [visible]=\"viewsModalShow\" [tableViews_menuItems]=\"tableViews_menuItems\" \r\n    (onViewSelect)=\"viewLoad($event)\" (onViewCreate)=\"viewCreate($event)\" (onViewDelete)=\"viewDelete($event)\" (onViewEditAlias)=\"viewEditAlias($event)\" (onViewUpdateData)=\"viewUpdateData($event)\" (onViewUpdateActiveStartup)=\"viewUpdateActiveStartup($event)\"\r\n    (visibleChange)=\"viewsModalShow=false\"></ecs-views-management>\r\n<!-- Body-level overlays avoid clipping inside scrollable and frozen table cells. -->\r\n<p-menu #responsiveHeaderMenu [model]=\"headerMenuItems\" [popup]=\"true\" appendTo=\"body\" styleClass=\"ecs-responsive-menu\"></p-menu>\r\n<p-menu #responsiveRowMenu [model]=\"rowMenuItems\" [popup]=\"true\" appendTo=\"body\" styleClass=\"ecs-responsive-menu\"></p-menu>\r\n", styles: [".highlighted-text{background-color:#ff0;color:#000;border-radius:2px}.excel-export-tooltip .bool-icon{text-shadow:0 0 2px white,0 0 3px white}.excel-export-tooltip .bool-true{color:green}.excel-export-tooltip .bool-false{color:red}.p-datatable-column-filter-button.p-button-icon-only.p-button-rounded,.p-datatable-column-filter-clear-button.p-button-icon-only.p-button-rounded{height:var(--p-icon-size)!important;width:var(--p-icon-size)!important;border-radius:0!important}.ecs-view-buttons{display:inline-flex;align-items:center;flex-wrap:nowrap}.ecs-view-buttons>p-button{display:inline-flex;flex:0 0 auto}.viewButton{width:200px}.viewButton .p-button{width:100%;justify-content:center}.viewButton .p-button-label{display:block;width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;text-align:center}.ecs-compact-header{gap:.5rem;min-width:0}.ecs-header-menu-trigger{margin-left:auto;flex:0 0 auto}.ecs-responsive-trigger{min-width:44px;min-height:44px}.ecs-global-search{display:inline-flex;align-items:center;gap:8px;min-width:0}.ecs-global-search>.ecs-input-icon{display:inline-flex;flex:0 0 auto}.ecs-global-search input{min-width:0}.ecs-responsive-search{flex:1 1 220px;min-width:0;max-width:320px}.ecs-responsive-search input{width:100%;padding-right:2.5rem}.ecs-clear-search{border:0;background:transparent;color:inherit;cursor:pointer}.ecs-responsive-menu{max-width:calc(100vw - 16px);max-height:calc(100dvh - 32px);overflow-y:auto}.ecs-responsive-menu .p-menu-item-link{min-height:44px;white-space:normal}.ecs-tree-cell{display:flex;align-items:center;gap:4px;min-width:0}.ecs-tree-cell>ecs-table-cell{flex:1;min-width:0}.ecs-tree-toggle{width:32px;height:32px;flex:0 0 32px;border:0;background:transparent;color:inherit;cursor:pointer}.ecs-tree-toggle:focus-visible{outline:2px solid var(--p-primary-color);outline-offset:1px}.ecs-tree-leaf{visibility:hidden}.ecs-tree-paginator{display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:8px}.p-datatable-thead>.ecs-column-groups>td{padding:var(--p-datatable-header-cell-padding);background:var(--p-datatable-header-cell-background);color:var(--p-datatable-header-cell-color);font-weight:var(--p-datatable-column-title-font-weight);border:1px solid var(--p-datatable-header-cell-border-color);white-space:normal;overflow-wrap:anywhere}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ECSPrimengTableService }, { type: i2.ECSPrimengTableNotificationService }]; }, propDecorators: { tableOptions: [{
+                type: Input
+            }], onRowCheckboxChange: [{
+                type: Output
+            }], onRowSelect: [{
+                type: Output
+            }], onRowUnselect: [{
+                type: Output
+            }], onDataEndUpdate: [{
+                type: Output
+            }], dt: [{
+                type: ViewChild,
+                args: ['dt']
+            }], tableContainer: [{
+                type: ViewChild,
+                args: ['tableContainer', { static: false }]
+            }], headerContainer: [{
+                type: ViewChild,
+                args: ['headerContainer', { static: false }]
+            }], paginatorContainer: [{
+                type: ViewChild,
+                args: ['paginatorContainer', { static: false }]
+            }], responsiveHeaderMenu: [{
+                type: ViewChild,
+                args: ['responsiveHeaderMenu']
+            }], responsiveRowMenu: [{
+                type: ViewChild,
+                args: ['responsiveRowMenu']
+            }], closeResponsiveMenus: [{
+                type: HostListener,
+                args: ['document:keydown.escape']
+            }], onResize: [{
+                type: HostListener,
+                args: ['window:resize']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ecs-primeng-table.js","sourceRoot":"","sources":["../../../../../../projects/ecs-primeng-table/src/lib/components/ecs-primeng-table/ecs-primeng-table.ts","../../../../../../projects/ecs-primeng-table/src/lib/components/ecs-primeng-table/ecs-primeng-table.html"],"names":[],"mappings":"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","sourcesContent":["import { ECSPrimengTableI18nService } from '../../services/i18n.service';\r\nimport { ECSTableTranslatePipe } from '../../pipes/ui-translate.pipe';\r\nimport { AfterViewInit, Component, ElementRef, EventEmitter, HostListener, Input, OnInit, OnDestroy, ChangeDetectorRef, inject, Output, ViewChild, ViewEncapsulation } from '@angular/core';\r\nimport { TranslateModule } from '@ngx-translate/core';\r\nimport { CommonModule } from '@angular/common';\r\nimport { FormsModule } from '@angular/forms';\r\nimport { HttpResponse } from '@angular/common/http';\r\n\r\n// PrimeNG imports\r\nimport { Table, TableModule } from 'primeng/table';\r\nimport { LazyLoadEvent } from 'primeng/api';\r\nimport { ButtonModule } from 'primeng/button';\r\nimport { TooltipModule } from 'primeng/tooltip';\r\nimport { InputTextModule } from 'primeng/inputtext';\r\nimport { MultiSelectModule } from 'primeng/multiselect';\r\nimport { CheckboxModule } from 'primeng/checkbox';\r\nimport { PaginatorModule } from 'primeng/paginator';\r\nimport { FilterMetadata, MenuItem } from 'primeng/api';\r\nimport { OverlayPanelModule } from 'primeng/overlaypanel';\r\nimport { Menu, MenuModule } from 'primeng/menu';\r\n\r\nimport { ECSPrimengTableService } from './ecs-primeng-table.service';\r\nimport { DeviceType, CellOverflowBehaviour, DataAlignHorizontal, DataAlignVertical, DataType, FrozenColumnAlign, TableViewSaveMode } from '../../enums';\r\nimport { ITableButton, IColumnMetadata, IPredefinedFilter, ITableConfiguration, ITablePagedResponse, ITableQueryRequest, IExcelExportRequest, ITableView, ITableViewData, ITableOptions, DEFAULT_TABLE_OPTIONS } from '../../interfaces';\r\nimport { dataAlignHorizontalAsText, dataAlignVerticalAsText, dataTypeAsText, frozenColumnAlignAsText } from '../../utils';\r\nimport { ECSPrimengTableNotificationService, ECSPrimengTableStateService } from '../../services';\r\nimport { TableCell } from '../table-cell/table-cell';\r\nimport { TablePredefinedFilters } from '../table-predefined-filters/table-predefined-filters';\r\nimport { TableButton } from '../table-button/table-button';\r\nimport { ColumnSelector } from \"../column-selector/column-selector\";\r\nimport { ExportExcel } from '../export-excel/export-excel';\r\nimport { finalize, firstValueFrom, Observable, Subject, takeUntil } from 'rxjs';\r\nimport { ViewsManagement } from \"../views-management/views-management\";\r\nimport { ITreeRequest, ITreeResponse, TreeRow, TreeTableState } from '../../utils/tree-table-state';\r\n\r\ntype TableLazyLoadEvent = Omit<LazyLoadEvent, 'filters'> & {\r\n  filters?: Record<string, FilterMetadata | FilterMetadata[]>;\r\n};\r\ninterface TablePageEvent { first: number; rows: number; }\r\ninterface TableRowSelectEvent<T> { data: T; }\r\ninterface TableRowUnSelectEvent<T> { data: T; }\r\ninterface TableMenuItem extends MenuItem {\r\n  _literalLabel?: boolean;\r\n  _uiLabelKey?: string;\r\n  _uiParams?: Record<string, any>;\r\n}\r\n\r\n@Component({\r\n  selector: 'ecs-primeng-table',\r\n  imports: [\r\n    ECSTableTranslatePipe,\r\n    TranslateModule,\r\n    CommonModule,\r\n    FormsModule,\r\n    TableModule,\r\n    ButtonModule,\r\n    TooltipModule,\r\n    InputTextModule,\r\n    MultiSelectModule,\r\n    CheckboxModule,\r\n    PaginatorModule,\r\n    TableCell,\r\n    TablePredefinedFilters,\r\n    TableButton,\r\n    ColumnSelector,\r\n    ExportExcel,\r\n    ViewsManagement,\r\n    OverlayPanelModule,\r\n    MenuModule\r\n  ],\r\n  standalone: true,\r\n  templateUrl: './ecs-primeng-table.html',\r\n  styleUrls: ['./ecs-primeng-table.scss'],\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class ECSPrimengTable implements OnInit, AfterViewInit, OnDestroy {\r\n  private readonly i18n = inject(ECSPrimengTableI18nService);\r\n  private readonly changeDetector = inject(ChangeDetectorRef, { optional: true });\r\n  private readonly stateScope = inject(ECSPrimengTableStateService, { optional: true });\r\n  private readonly destroy$ = new Subject<void>();\r\n  private initialStateApplied = false;\r\n  private destroyed = false;\r\n\r\n  constructor(\r\n    private tableService: ECSPrimengTableService,\r\n    private notification: ECSPrimengTableNotificationService\r\n  ) {\r\n    this.i18n.changes.pipe(takeUntil(this.destroy$)).subscribe(() => {\r\n      this.headerMenuItems = this.translateMenuItems(this.headerMenuItems);\r\n      this.rowMenuItems = this.translateMenuItems(this.rowMenuItems);\r\n      this.changeDetector?.markForCheck();\r\n    });\r\n  }\r\n  @Input() tableOptions: ITableOptions = DEFAULT_TABLE_OPTIONS;\r\n  treeState?: TreeTableState;\r\n  private treeQuery?: ITableQueryRequest;\r\n  private treeStateRestored = false;\r\n  @Output() onRowCheckboxChange = new EventEmitter<{\r\n    rowID: any,\r\n    selected: boolean\r\n  }>(); // Emitter that returns the column selected and if it was selected or unselected\r\n  @Output() onRowSelect = new EventEmitter<{\r\n    rowID: any,\r\n    rowData: any\r\n  }>\r\n  @Output() onRowUnselect = new EventEmitter<{\r\n    rowID: any,\r\n    rowData: any\r\n  }>\r\n  @Output() onDataEndUpdate = new EventEmitter<void>();\r\n  viewsModalShow:boolean = false;\r\n  tableViewCurrentSelectedAlias: string | null = null;\r\n  tableViewsFirstFetchDone: boolean = false;\r\n  excelReportTitle: string = \"\";\r\n  showExportModal: boolean = false;\r\n  showColumnSelector: boolean = false;\r\n  selectedRowsCheckbox: any[] = []; // An array to keep all the selected rows\r\n  selectAllLoading = false;\r\n  private selectionQuery?: ITableQueryRequest;\r\n  private selectionQueryKey = '';\r\n  private matchingSelectionKeys?: any[];\r\n  @ViewChild('dt') dt!: Table; // Get the reference to the object table\r\n  \r\n  globalSearchText: string | null = null; // The text used by the global search\r\n  private appliedGlobalSearchText: string | null = null;\r\n  private globalSearchManaged = false;\r\n  private globalSearchTimer?: ReturnType<typeof setTimeout>;\r\n\r\n  /** The applied query stays separate from text being typed during the debounce. */\r\n  get effectiveGlobalSearchText(): string | null {\r\n    return this.globalSearchManaged ? this.appliedGlobalSearchText : this.globalSearchText;\r\n  }\r\n\r\n  private cancelGlobalSearch(): void {\r\n    if (this.globalSearchTimer !== undefined) clearTimeout(this.globalSearchTimer);\r\n    this.globalSearchTimer = undefined;\r\n  }\r\n\r\n  private restoreGlobalSearch(value: string | null): void {\r\n    this.cancelGlobalSearch();\r\n    this.globalSearchText = value;\r\n    this.appliedGlobalSearchText = value || null;\r\n    this.globalSearchManaged = true;\r\n  }\r\n\r\n  private globalSearchOption(value: number | undefined): number {\r\n    return typeof value === 'number' && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;\r\n  }\r\n\r\n  onGlobalSearchInput(value: string): void {\r\n    if (this.destroyed) return;\r\n    this.cancelGlobalSearch();\r\n    if (!this.globalSearchManaged) this.appliedGlobalSearchText = this.globalSearchText || null;\r\n    this.globalSearchManaged = true;\r\n    this.globalSearchText = value;\r\n    const minLength = this.globalSearchOption(this.tableOptions.globalFilter?.minLength);\r\n    const delay = this.globalSearchOption(this.tableOptions.globalFilter?.debounceTime);\r\n    const trimmed = value.trim();\r\n    const effective = trimmed.length >= minLength ? (trimmed || null) : null;\r\n    if (effective === (this.appliedGlobalSearchText?.trim() || null)) return;\r\n    const apply = () => {\r\n      this.globalSearchTimer = undefined;\r\n      if (this.destroyed) return;\r\n      this.appliedGlobalSearchText = effective;\r\n      this.currentPage = 0;\r\n      this.dt.first = 0;\r\n      if (minLength === 0 && delay === 0) {\r\n        // Keep PrimeNG's existing filtering behavior when the feature is not configured.\r\n        this.dt.filterGlobal(value, 'contains');\r\n      } else {\r\n        // Own the global delay so it is not added to PrimeNG's column-filter delay.\r\n        this.dt.filters = { ...this.dt.filters, global: { value: effective, matchMode: 'contains' } };\r\n        this.fetchTableData({ ...this.tableLazyLoadEventInformation, first: 0,\r\n          rows: this.currentRowsPerPage, filters: this.dt.filters });\r\n      }\r\n    };\r\n    if (effective === null || delay === 0) apply();\r\n    else this.globalSearchTimer = setTimeout(apply, delay);\r\n  }\r\n  tableViewsList: ITableView[] = [];\r\n  tableViews_menuItems: any[] = [];\r\n\r\n  DataType = DataType;\r\n  CellOverflowBehaviour = CellOverflowBehaviour;\r\n  DataAlignHorizontal = DataAlignHorizontal;\r\n  DataAlignVertical = DataAlignVertical;\r\n  FrozenColumnAlign = FrozenColumnAlign;\r\n  TableViewSaveMode = TableViewSaveMode;\r\n\r\n  rowSelection: any;\r\n  currentPage: number = 0; // The current page we are at\r\n  currentRowsPerPage: number = 0; // The current rows per page selected\r\n  allowedRowsPerPage: number[] = []; // The different values of rows per page allowed\r\n  totalRecords: number = 0; // The number of total records that are available (taking into account the filters)\r\n  totalRecordsNotFiltered: number = 0; // The total number of records available if no filters were applied\r\n\r\n  dateFormat: string = \"dd-MMM-yyyy HH:mm:ss zzzz\";\r\n  dateTimezone: string = \"+00:00\";\r\n  dateCulture: string = \"en-US\";\r\n  exportDateFormat: string = \"dd-MMM-yyyy HH:mm:ss\"\r\n\r\n  columns: IColumnMetadata[] = [];\r\n  columnsCantBeHidden: IColumnMetadata[] = [];\r\n  columnsSelected: IColumnMetadata[] = [];\r\n  columnModalData: any[] = []; \r\n  filteredColumnData: any[] = []; \r\n  private initialColumnWidths: any;\r\n  private initialTableWidth: any;\r\n  predefinedFiltersSelectedValuesCollection: { [key: string]: any[] } = {}; // Contains a collection of the predefined column filters selection (possible values come from 'predefinedFiltersCollection')\r\n  private copyCellDataTimer: any; // A timer that handles the amount of time left to copy the cell data to the clipboard\r\n  tableLazyLoadEventInformation: TableLazyLoadEvent = {}; // Data of the last lazy load event of the table\r\n  private initialConfigurationFetched: boolean = false;\r\n  private maxViews = 0;\r\n  ngOnInit(): void {\r\n    this.i18n.connectPrimeNG();\r\n    if (this.tableOptions.tree) this.treeState = new TreeTableState(this.tableOptions.tree);\r\n    this.validateStatePersistence();\r\n    this.updateResponsiveViewport();\r\n    this.fetchTableConfiguration();\r\n  }\r\n  @ViewChild('tableContainer', { static: false }) tableContainer!: ElementRef;\r\n  @ViewChild('headerContainer', { static: false }) headerContainer!: ElementRef;\r\n  @ViewChild('paginatorContainer', { static: false }) paginatorContainer!: ElementRef;\r\n  ngAfterViewInit() {\r\n    this.calculateScrollHeight();\r\n    this.changeDetector?.detectChanges();\r\n  }\r\n\r\n  deviceType: DeviceType = DeviceType.Desktop;\r\n  private columnSelectionCustomized = false;\r\n  headerMenuItems: MenuItem[] = [];\r\n  rowMenuItems: MenuItem[] = [];\r\n  rowMenuRow: any;\r\n  @ViewChild('responsiveHeaderMenu') responsiveHeaderMenu?: Menu;\r\n  @ViewChild('responsiveRowMenu') responsiveRowMenu?: Menu;\r\n\r\n  get compactHeader(): boolean {\r\n    return !!this.tableOptions.responsive?.headerMenu && this.deviceType !== DeviceType.Desktop;\r\n  }\r\n\r\n  get compactRows(): boolean {\r\n    return !!this.tableOptions.responsive?.rowMenu && this.deviceType !== DeviceType.Desktop;\r\n  }\r\n\r\n  get actionColumnWidth(): number {\r\n    return this.compactRows ? 56 : (this.tableOptions.rows?.action?.width ?? 150);\r\n  }\r\n\r\n  getColumnHeaderGroups(columns: IColumnMetadata[]): { field: string; label: string; colspan: number; frozenColumnAlign: FrozenColumnAlign }[] {\r\n    if (!columns.some(column => column.headerGroup?.trim())) return [];\r\n    const groups: { field: string; label: string; colspan: number; frozenColumnAlign: FrozenColumnAlign }[] = [];\r\n    for (const column of columns) {\r\n      const label = column.headerGroup?.trim() ?? '';\r\n      const frozenColumnAlign = column.frozenColumnAlign ?? FrozenColumnAlign.Noone;\r\n      const previous = groups[groups.length - 1];\r\n      if (previous && previous.label === label && previous.frozenColumnAlign === frozenColumnAlign) {\r\n        previous.colspan++;\r\n      } else {\r\n        groups.push({ field: column.field, label, colspan: 1, frozenColumnAlign });\r\n      }\r\n    }\r\n    return groups;\r\n  }\r\n\r\n  private isInitiallyVisible(column: IColumnMetadata): boolean {\r\n    if (!column.canBeHidden) return true;\r\n    if (column.startHidden) return false;\r\n    const devices = column.visibleOnlyIn;\r\n    return !devices?.length || devices.some(device =>\r\n      device === this.deviceType || String(device).toLowerCase() === DeviceType[this.deviceType].toLowerCase());\r\n  }\r\n\r\n  private updateResponsiveViewport(): void {\r\n    const options = this.tableOptions.responsive;\r\n    const tablet = options?.tabletMinWidth ?? 768;\r\n    const desktop = options?.desktopMinWidth ?? 1200;\r\n    if (!Number.isFinite(tablet) || !Number.isFinite(desktop) || tablet <= 0 || desktop <= tablet) {\r\n      throw new Error('ECS table responsive widths must be finite and 0 < tabletMinWidth < desktopMinWidth.');\r\n    }\r\n    const width = typeof window === 'undefined' ? desktop : window.innerWidth;\r\n    const next = width < tablet ? DeviceType.Mobile : width < desktop ? DeviceType.Tablet : DeviceType.Desktop;\r\n    if (next === this.deviceType) return;\r\n    this.deviceType = next;\r\n    this.responsiveHeaderMenu?.hide();\r\n    this.responsiveRowMenu?.hide();\r\n    if (!this.initialConfigurationFetched || this.columnSelectionCustomized ||\r\n        !this.columns.some(column => column.visibleOnlyIn?.length)) return;\r\n    const selected = this.columns.filter(column => column.canBeHidden && this.isInitiallyVisible(column));\r\n    const shown = this.tableService.orderColumnsWithFrozens(this.columnsCantBeHidden.concat(selected));\r\n    const previous = this.tableOptions.columns?.shown ?? [];\r\n    if (shown.length === previous.length && shown.every((column, i) => column.field === previous[i].field)) return;\r\n    this.columnsSelected = selected;\r\n    this.tableOptions.columns!.shown = shown;\r\n    this.showColumnSelector = false;\r\n    // Request newly visible fields without resetting filters, sorting or pagination.\r\n    if (this.initialStateApplied) this.fetchTableData(this.tableLazyLoadEventInformation);\r\n  }\r\n\r\n  private buttonVisible(button: ITableButton, row: any): boolean {\r\n    return (button.visibleCondition?.(row) ?? true) &&\r\n      ((button.enabledCondition?.(row) ?? true) || !button.conditionFailHide);\r\n  }\r\n\r\n  hasRowMenuActions(row: any): boolean {\r\n    return (this.tableOptions.rows?.action?.buttons ?? []).some(button => this.buttonVisible(button, row));\r\n  }\r\n\r\n  private buttonMenuItems(buttons: ITableButton[], row: any): MenuItem[] {\r\n    return buttons.filter(button => this.buttonVisible(button, row)).map((button, index) => ({\r\n      label: button.label || button.tooltip || 'Action {{number}}',\r\n      _uiParams: { number: index + 1 },\r\n      icon: button.icon,\r\n      disabled: !(button.enabledCondition?.(row) ?? true),\r\n      command: () => {\r\n        if (this.buttonVisible(button, row) && (button.enabledCondition?.(row) ?? true) && button.action) {\r\n          this.tableService.handleButtonsClick(button.action, row);\r\n        }\r\n      }\r\n    }));\r\n  }\r\n\r\n  @HostListener('document:keydown.escape')\r\n  closeResponsiveMenus(): void {\r\n    this.responsiveHeaderMenu?.hide();\r\n    this.responsiveRowMenu?.hide();\r\n  }\r\n\r\n  openRowMenu(event: Event, row: any): void {\r\n    event.stopPropagation();\r\n    this.responsiveHeaderMenu?.hide();\r\n    if (this.responsiveRowMenu?.visible && this.rowMenuRow === row) {\r\n      this.responsiveRowMenu.hide();\r\n      return;\r\n    }\r\n    // Use one overlay for all rows. Replacing the model binds every action to this row.\r\n    this.rowMenuRow = row;\r\n    this.rowMenuItems = this.translateMenuItems(this.buttonMenuItems(this.tableOptions.rows?.action?.buttons ?? [], row));\r\n    const wasOpen = this.responsiveRowMenu?.visible;\r\n    this.responsiveRowMenu?.show(event);\r\n    if (wasOpen) this.responsiveRowMenu?.alignOverlay();\r\n  }\r\n\r\n  private translateMenuItems(items: TableMenuItem[]): TableMenuItem[] {\r\n    return items.map(item => {\r\n      if (item['_literalLabel']) return item;\r\n      const key = item['_uiLabelKey'] ?? item.label;\r\n      return { ...item, _uiLabelKey: key, label: this.i18n.text(key, item['_uiParams']) };\r\n    });\r\n  }\r\n\r\n  openHeaderMenu(event: Event): void {\r\n    this.responsiveRowMenu?.hide();\r\n    const options = this.tableOptions;\r\n    const items: TableMenuItem[] = [];\r\n    if (options.columns?.selectorEnabled) items.push({ label: 'Modify columns', icon: options.columns.selectorIcon, command: () => this.columnSelectorShow() });\r\n    if (options.header?.clearSortsEnabled) items.push({ label: 'Clear sorts', icon: options.header.clearSortsIcon, disabled: !this.hasToClearSorts(this.dt), command: () => this.clearSorts(this.dt) });\r\n    if (options.header?.clearFiltersEnabled) items.push({ label: 'Clear filters', icon: options.header.clearFiltersIcon, disabled: !this.hasToClearFilters(this.dt, this.globalSearchText), command: () => this.clearFilters(this.dt) });\r\n    if (this.tableViewsEnabled()) {\r\n      items.push({ label: this.tableViewCurrentSelectedAlias || options.views?.noViewSelectedText || 'Select a view', _literalLabel: !!this.tableViewCurrentSelectedAlias, icon: 'pi pi-bookmark', command: () => { this.viewsModalShow = true; } });\r\n      items.push({ label: 'Apply view again', icon: options.views?.reloadViewButtonIcon || 'pi pi-refresh', disabled: !this.tableViewCurrentSelectedAlias, command: () => this.viewLoad(this.tableViewCurrentSelectedAlias!) });\r\n    }\r\n    if (options.excelReport?.url?.trim()) items.push({ label: 'Export to Excel', icon: 'pi pi-file-excel', command: () => this.openExcelExport() });\r\n    if (options.resetTableView?.enabled) items.push({ label: 'Reset table view', icon: options.resetTableView.icon, command: () => this.resetTableView() });\r\n    items.push({ label: 'Refresh data', icon: 'pi pi-refresh', command: () => this.refreshData(event) });\r\n    items.push(...this.buttonMenuItems(options.header?.buttons ?? [], null));\r\n    this.headerMenuItems = this.translateMenuItems(items);\r\n    this.responsiveHeaderMenu?.toggle(event);\r\n  }\r\n\r\n  private validateStatePersistence(): void {\r\n    if (!this.tableOptions.statePersistence?.enabled) return;\r\n    if (!this.tableOptions.statePersistence.key?.trim() || !this.stateScope) {\r\n      throw new Error('ECS table statePersistence requires a non-empty key and ECSPrimengTableStateService provided on a parent scope component.');\r\n    }\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.cancelGlobalSearch();\r\n    this.destroyed = true;\r\n    this.destroy$.next();\r\n    this.destroy$.complete();\r\n    this.treeState?.cancel();\r\n    const options = this.tableOptions.statePersistence;\r\n    const key = options?.key?.trim();\r\n    if (!key || !this.stateScope) return;\r\n    if (!options?.enabled) {\r\n      this.stateScope.clear(key);\r\n      return;\r\n    }\r\n    if (!this.initialStateApplied || !this.dt) return;\r\n    const filters = structuredClone(this.dt.filters ?? {});\r\n    delete filters['global'];\r\n    delete filters['selector'];\r\n    this.stateScope.set(key, {\r\n      configurationUrl: this.tableOptions.urlTableConfiguration ?? '',\r\n      dataUrl: this.tableOptions.urlTableData ?? '',\r\n      filters,\r\n      multiSortMeta: structuredClone(this.dt.multiSortMeta ?? []),\r\n      globalSearchText: this.effectiveGlobalSearchText,\r\n      currentPage: this.currentPage,\r\n      currentRowsPerPage: this.currentRowsPerPage,\r\n      treeMode: this.treeState?.mode,\r\n      treeExpandedKeys: this.treeState ? [...this.treeState.expanded] : undefined,\r\n      treeChildPages: this.treeState?.snapshotPages()\r\n    });\r\n  }\r\n\r\n  private restoreNavigationState(): boolean {\r\n    this.validateStatePersistence();\r\n    const options = this.tableOptions.statePersistence;\r\n    const key = options?.key?.trim();\r\n    if (!options?.enabled) {\r\n      if (key) this.stateScope?.clear(key);\r\n      return false;\r\n    }\r\n    const state = this.stateScope!.get(key!);\r\n    if (!state) return false;\r\n    if (state.configurationUrl !== this.tableOptions.urlTableConfiguration ||\r\n      state.dataUrl !== this.tableOptions.urlTableData || state.treeMode !== this.treeState?.mode) {\r\n      this.stateScope!.clear(key!);\r\n      return false;\r\n    }\r\n    const fields = new Set(this.columns.map(column => column.field));\r\n    const filters: Record<string, FilterMetadata | FilterMetadata[]> = {};\r\n    for (const [field, filter] of Object.entries(state.filters)) {\r\n      if (fields.has(field)) filters[field] = filter;\r\n    }\r\n    this.currentRowsPerPage = this.allowedRowsPerPage.includes(state.currentRowsPerPage)\r\n      ? state.currentRowsPerPage : this.currentRowsPerPage;\r\n    this.currentPage = this.currentRowsPerPage === state.currentRowsPerPage\r\n      ? Math.max(0, state.currentPage) : 0;\r\n    this.restoreGlobalSearch(state.globalSearchText);\r\n    this.treeState?.restore(state.treeExpandedKeys, state.treeChildPages);\r\n    this.treeStateRestored = !!this.treeState;\r\n    if (this.globalSearchText) {\r\n      filters['global'] = { value: this.globalSearchText, matchMode: 'contains' };\r\n    }\r\n    const sorts = state.multiSortMeta.filter(sort => fields.has(sort.field));\r\n    this.dt.filters = { ...this.dt.filters, ...structuredClone(filters) };\r\n    // Keep initialStateApplied=false while PrimeNG setters can emit lazy-load events.\r\n    this.dt.multiSortMeta = sorts;\r\n    this.dt.first = this.currentPage * this.currentRowsPerPage;\r\n    this.dt.rows = this.currentRowsPerPage;\r\n    this.tableLazyLoadEventInformation = {\r\n      first: this.dt.first,\r\n      rows: this.currentRowsPerPage,\r\n      filters: this.dt.filters,\r\n      multiSortMeta: sorts\r\n    };\r\n    this.restorePredefinedSelections(filters);\r\n    return true;\r\n  }\r\n\r\n  private restorePredefinedSelections(filters: Record<string, FilterMetadata | FilterMetadata[]>): void {\r\n    this.predefinedFiltersSelectedValuesCollection = {};\r\n    for (const column of this.columns) {\r\n      const key = column.filterPredefinedValuesName;\r\n      if (!key) continue;\r\n      const criteria = filters[column.field];\r\n      const value = (Array.isArray(criteria) ? criteria[0] : criteria)?.value;\r\n      if (value === null || value === undefined) continue;\r\n      this.predefinedFiltersSelectedValuesCollection[key] =\r\n        (this.tableOptions.predefinedFilters?.[key] ?? []).filter(option =>\r\n          Array.isArray(value) ? value.includes(option.value) : value === option.value\r\n        );\r\n    }\r\n  }\r\n\r\n  @HostListener('window:resize')\r\n  onResize() {\r\n    this.updateResponsiveViewport();\r\n    this.calculateScrollHeight();\r\n  }\r\n  \r\n  private calculateScrollHeight(){\r\n    if (this.tableOptions.verticalScroll?.cssFormula) {\r\n      return;\r\n    }\r\n    if (this.tableOptions.verticalScroll?.fitToContainer && this.tableContainer && this.paginatorContainer && this.headerContainer) {\r\n      const containerRect = this.tableContainer.nativeElement.getBoundingClientRect();\r\n      const paginatorHeight = this.paginatorContainer.nativeElement.offsetHeight;\r\n      const headerHeight = this.headerContainer.nativeElement.offsetHeight;\r\n      const viewportHeight = window.innerHeight;\r\n      const topOffset = containerRect.top + window.scrollY;\r\n      this.tableOptions.verticalScroll.height = (viewportHeight - topOffset - paginatorHeight - headerHeight)-60;\r\n    }\r\n  }\r\n  get scrollHeightValue(): string {\r\n    if (this.tableOptions.verticalScroll?.cssFormula) {\r\n      return this.tableOptions.verticalScroll.cssFormula;\r\n    }\r\n    const height = this.tableOptions.verticalScroll?.height;\r\n    return height && height > 0 ? `${height}px` : '';\r\n  }\r\n\r\n  /**\r\n   * Updates the table data and, if needed, retrieves the initial table configuration from an external source.\r\n   * \r\n   * Also allows resetting the table to its original state before any user manipulations.\r\n   *\r\n   * @param {boolean} [resetTableView=false] Optional.\r\n   * - `true`: resets the table state before loading data.\r\n   * - `false`: refreshes data using the current configuration (and retrieves initial configuration if necessary).\r\n   *\r\n   * **_Behavior_**\r\n   * - The table is automatically set to `isActive = true`.\r\n   * - If the initial configuration has not been fetched, it will fetch it and then update the data.\r\n   * - If the initial configuration is already fetched, it will just update the data.\r\n   * - If `resetTableView` is true and the configuration is already initialized, the table will be reset to its original state before updating the data.\r\n   */\r\n  updateData(resetTableView: boolean = false): void {\r\n    this.tableOptions.isActive = true; // Enable table actions: the table is now active and can perform updates\r\n    if (!this.initialConfigurationFetched || resetTableView) { // If initial configuration hasn't been fetched yet or a reset is explicitly requested\r\n      if(this.initialConfigurationFetched && resetTableView) { // Reset the table only if it was already initialized and a reset is explicitly requested\r\n        this.resetTableView(); // Reset table state (filters, pagination, sorting, etc.) and then refresh data\r\n      } else { // We only need to get the table configuration without reseting the view\r\n        this.fetchTableConfiguration(); // Fetch the initial table configuration before updating data\r\n      }\r\n    } else { // Table is already initialized and no reset requested, just refresh the data\r\n      this.fetchTableData(this.tableLazyLoadEventInformation); // Update table rows using the last lazy load event\r\n    }\r\n  }\r\n\r\n  private canFetchData(): boolean {\r\n    return !this.destroyed\r\n      && !!this.tableOptions.isActive\r\n      && !!this.tableOptions.urlTableConfiguration?.trim()\r\n      && !!this.tableOptions.urlTableData?.trim();\r\n  }\r\n\r\n  private fetchTableConfiguration(resetTableView: boolean = false): void {\r\n    if(!this.canFetchData()){\r\n      return;\r\n    }\r\n    this.tableService.fetchTableConfiguration(this.tableOptions.urlTableConfiguration!)\r\n      .pipe(takeUntil(this.destroy$)).subscribe({\r\n      next: (response: HttpResponse<ITableConfiguration>) => {\r\n        this.handleTableConfigurationResponse(response.body!, resetTableView);\r\n      },\r\n      error: (err) => this.tableService.handleTableError(err, 'Columns Error')\r\n    });\r\n  }\r\n\r\n  private handleTableConfigurationResponse(body: ITableConfiguration, resetTableView: boolean = false): void {\r\n    this.allowedRowsPerPage = body.allowedItemsPerPage; // Update the number of rows allowed per page\r\n    this.currentRowsPerPage = Math.min(...this.allowedRowsPerPage); // Update the current rows per page to use the minimum value of allowed rows per page by default\r\n    this.columns = body.columnsInfo; // Update columns with fetched data\r\n    this.columnsCantBeHidden = this.columns.filter((col: any) => !col.canBeHidden); // Filter columns that cannot be hidden\r\n    this.columnSelectionCustomized = false;\r\n    this.columnsSelected = this.columns.filter(col => col.canBeHidden && this.isInitiallyVisible(col)); // Selected columns that are not hidden by default\r\n    this.tableOptions.columns!.shown = this.tableService.orderColumnsWithFrozens(this.columnsCantBeHidden.concat(this.columnsSelected));\r\n    this.dateFormat = body.dateFormat;\r\n    this.dateTimezone = body.dateTimezone;\r\n    this.dateCulture = body.dateCulture;\r\n    this.exportDateFormat = body.exportDateFormat;\r\n    this.currentPage = 0;\r\n    this.initialConfigurationFetched = true;\r\n    this.maxViews = body.maxViews;\r\n    if(resetTableView){\r\n      this.tableOptions.isActive = false\r\n      this.clearFilters(this.dt, true);\r\n      this.clearSorts(this.dt, true);\r\n      this.dt.tableWidthState = this.initialTableWidth;\r\n      this.dt.columnWidthsState = this.initialColumnWidths;\r\n      this.dt.restoreColumnWidths()\r\n      this.tableLazyLoadEventInformation.multiSortMeta=[];\r\n      this.tableOptions.isActive = true;\r\n      this.initialStateApplied = true;\r\n      this.tableLazyLoadEventInformation.first = 0;\r\n      this.tableLazyLoadEventInformation.rows = this.currentRowsPerPage;\r\n      this.fetchTableData(this.tableLazyLoadEventInformation);\r\n    } else {\r\n      setTimeout(() => {\r\n        if (this.destroyed) return;\r\n        this.initialColumnWidths = this.tableService.computeColumnWidths(this.dt);\r\n        this.initialTableWidth = this.tableService.computeTableWidth(this.dt);\r\n      }, 0);\r\n      this.fetchTableViews();\r\n    }\r\n  }\r\n\r\n  refreshData(event: any){\r\n    this.fetchTableData(this.tableLazyLoadEventInformation);\r\n  }\r\n\r\n  tableViewsEnabled(): boolean {\r\n    const views = this.tableOptions.views;\r\n    if (views?.saveMode === TableViewSaveMode.None) { // saveMode must be different from noone\r\n      return false;\r\n    }\r\n    if (!views?.saveKey?.trim()) { // saveKey must exist and must not be empty after trim\r\n      return false;\r\n    }\r\n    if (this.maxViews <= 0) { // maxViews must be greater than 0\r\n      return false;\r\n    }\r\n    if (views?.saveMode === TableViewSaveMode.DatabaseStorage) { // If saveMode is database, urlGet and urlSave must exist and must not be empty after trim\r\n      if (!views?.urlGet?.trim() || !views?.urlSave?.trim()) {\r\n        return false;\r\n      }\r\n    }\r\n    return true; // All checks passed, views are enabled\r\n  }\r\n\r\n  private fetchTableViews(): void {\r\n    if(!this.tableViewsEnabled()){\r\n      this.startInitialDataLoad();\r\n      return;\r\n    }\r\n    const tableViews = this.tableService.fetchTableViews(this.tableOptions.views!.saveMode!, this.tableOptions.views!.urlGet!, this.tableOptions.views!.saveKey!);\r\n    if (tableViews instanceof Observable) {\r\n      tableViews.pipe(takeUntil(this.destroy$)).subscribe({\r\n        next: (response: HttpResponse<ITableView[]>) => {\r\n           let parsedResult = response.body!.map((item: any) => ({\r\n            viewAlias: item.viewAlias,\r\n            viewData: JSON.parse(item.viewData),\r\n            lastActive: item.lastActive\r\n          }));\r\n          this.tableViewListProcess(parsedResult);\r\n        },\r\n        error: (err) => {\r\n          this.tableService.handleTableError(err, 'Views get error');\r\n          this.startInitialDataLoad();\r\n        }\r\n      });\r\n    } else {\r\n        this.tableViewListProcess(tableViews);\r\n    }\r\n  }\r\n\r\n  private tableViewListProcess(tableViews: ITableView[]){\r\n    this.tableViewsList = [...tableViews];\r\n    if(this.tableViewsList.length > 0){\r\n      this.tableService.sortViews(this.tableViewsList);\r\n    }\r\n    this.tableViews_menuItems=[...this.tableService.updateViewsMenuItems(this.tableViewsList)];\r\n    this.startInitialDataLoad();\r\n  }\r\n\r\n  private startInitialDataLoad(): void {\r\n    if (this.initialStateApplied || this.destroyed) return;\r\n    const restored = this.restoreNavigationState();\r\n    this.initialStateApplied = true;\r\n    const viewToStartup = restored ? undefined : this.tableViewsList.find(v => v.lastActive);\r\n    if (viewToStartup) { // If there is a view that needs to be loaded on startup\r\n      this.viewLoad(viewToStartup.viewAlias);\r\n    } else {\r\n      this.fetchTableData(this.tableLazyLoadEventInformation);\r\n    }\r\n  }\r\n\r\n  viewLoad(tableViewAlias: string): void {\r\n    const viewToLoad: ITableView | undefined = this.tableViewsList.find(v => v.viewAlias === tableViewAlias);\r\n    if(!viewToLoad){\r\n      this.notification.showToast(\"error\", this.i18n.text(\"VIEW TO LOAD DOESN'T EXIST\"), this.i18n.text(\"The view to load doesn't exist\"));\r\n      return;\r\n    }\r\n    this.columnSelectionCustomized = true;\r\n    let viewData: ITableViewData = viewToLoad.viewData;\r\n    this.treeState?.restore(viewData.treeExpandedKeys, viewData.treeChildPages);\r\n    this.treeStateRestored = !!this.treeState;\r\n    this.columnsSelected = viewData.columnsShown\r\n        .map(data => this.columns.find((col: any) => col.field === data.field))\r\n        .filter((col): col is IColumnMetadata => col !== undefined)\r\n        .filter(col => !this.columnsCantBeHidden.includes(col));\r\n    this.tableOptions.columns!.shown = this.tableService.orderColumnsWithFrozens(this.columnsCantBeHidden.concat(this.columnsSelected));\r\n    this.currentPage = viewData.currentPage;\r\n    this.currentRowsPerPage = viewData.currentRowsPerPage;\r\n    this.restoreGlobalSearch(viewData.globalSearchText);\r\n    this.tableOptions.isActive = false;\r\n    this.tableLazyLoadEventInformation.multiSortMeta = [...(viewData.multiSortMeta ?? [])];\r\n    this.dt.multiSortMeta = [...(viewData.multiSortMeta ?? [])];\r\n    this.dt.sortMultiple();\r\n    this.dt.first = this.currentPage * this.currentRowsPerPage;\r\n    this.dt.rows = this.currentRowsPerPage;\r\n    this.tableLazyLoadEventInformation.first = this.dt.first;\r\n    this.tableLazyLoadEventInformation.rows = this.currentRowsPerPage;\r\n    this.tableOptions.isActive = true;\r\n    this.tableLazyLoadEventInformation.filters = structuredClone(viewData.filters);\r\n    this.dt.filters = structuredClone(viewData.filters);\r\n    this.restorePredefinedSelections(viewData.filters);\r\n    this.dt.tableWidthState = viewData.tableWidth;\r\n    this.dt.columnWidthsState = viewData.columnsWidth;\r\n    this.tableViewCurrentSelectedAlias = tableViewAlias;\r\n    this.notification.showToast(\"info\", this.i18n.text(\"TABLE VIEW RESTORED\"), this.i18n.text(\"The table view '{{value0}}' has been restored.\", { value0: this.tableViewCurrentSelectedAlias }));\r\n    this.viewsModalShow = false;\r\n    this.fetchTableData(this.tableLazyLoadEventInformation);\r\n  }\r\n\r\n  viewCreate(viewAlias: string){\r\n    if(this.tableViewsList.length >= this.maxViews){\r\n      this.notification.showToast(\"error\", this.i18n.text(\"NO MORE VIEWS ALLOWED\"), this.i18n.text(\"You have created the maximum number of allowed views for this table\"));\r\n      return;\r\n    }\r\n    let viewData: ITableViewData = this.generateViewData();\r\n    let newView: ITableView = {\r\n      lastActive: false,\r\n      viewAlias: viewAlias,\r\n      viewData: viewData\r\n    }\r\n    this.tableViewsList.push(newView);\r\n    this.tableService.sortViews(this.tableViewsList);\r\n    this.tableViews_menuItems=[...this.tableService.updateViewsMenuItems(this.tableViewsList)];\r\n    this.tableViewCurrentSelectedAlias = viewAlias;\r\n    this.viewsSave(0);\r\n  }\r\n\r\n  viewDelete(viewAlias: string){\r\n    const index = this.tableViewsList.findIndex(v => v.viewAlias === viewAlias);\r\n    if (index === -1) {\r\n      this.notification.showToast(\"error\", this.i18n.text(\"Table view delete failed\"), this.i18n.text(\"The table view could not be deleted since it was not found.\"));\r\n      return;\r\n    }\r\n    this.tableViewsList.splice(index, 1);\r\n    this.tableViews_menuItems=[...this.tableService.updateViewsMenuItems(this.tableViewsList)];\r\n    if(this.tableViewCurrentSelectedAlias === viewAlias){\r\n      this.tableViewCurrentSelectedAlias = null;\r\n    }\r\n    this.viewsSave(3);\r\n  }\r\n\r\n  viewEditAlias(event: { viewAliasOld: string; viewAliasNew: string }){\r\n    const index = this.tableViewsList.findIndex(v => v.viewAlias === event.viewAliasOld);\r\n    if (index === -1) {\r\n      this.notification.showToast(\"error\", this.i18n.text(\"Table view alias change failed\"), this.i18n.text(\"The table view alias could not be changed since it was not found.\"));\r\n      return;\r\n    }\r\n    this.tableViewsList[index].viewAlias = event.viewAliasNew;\r\n    this.tableService.sortViews(this.tableViewsList);\r\n    this.tableViews_menuItems=[...this.tableService.updateViewsMenuItems(this.tableViewsList)];\r\n    if(this.tableViewCurrentSelectedAlias === event.viewAliasOld){\r\n      this.tableViewCurrentSelectedAlias = event.viewAliasNew;\r\n    }\r\n    this.viewsSave(2);\r\n  }\r\n\r\n  viewUpdateData(viewAlias: string){\r\n    const index = this.tableViewsList.findIndex(v => v.viewAlias === viewAlias);\r\n    if (index === -1) {\r\n      this.notification.showToast(\"error\", this.i18n.text(\"Table view not found\"), this.i18n.text(\"The table view to update data from was not found.\"));\r\n      return;\r\n    }\r\n    let viewData: ITableViewData = this.generateViewData();\r\n    this.tableViewsList[index].viewData = viewData;\r\n    this.viewsSave(1);\r\n  }\r\n\r\n  viewUpdateActiveStartup(viewAlias: string){\r\n    const index = this.tableViewsList.findIndex(v => v.viewAlias === viewAlias);\r\n    if (index === -1) {\r\n      this.notification.showToast(\"error\", this.i18n.text(\"Table view not found\"), this.i18n.text(\"The table view to update data from was not found.\"));\r\n      return;\r\n    }\r\n    let newStatus: boolean = !this.tableViewsList[index].lastActive;\r\n    this.tableViewsList.forEach(v => v.lastActive = false);\r\n    this.tableViewsList[index].lastActive = newStatus;\r\n    this.tableViews_menuItems=[...this.tableService.updateViewsMenuItems(this.tableViewsList)];\r\n    this.viewsSave(4);\r\n  }\r\n\r\n  viewsSave(endMessage: number): void{\r\n    let tableView: string = JSON.stringify(this.tableViewsList);\r\n    switch(this.tableOptions.views!.saveMode){\r\n      case TableViewSaveMode.SessionStorage:\r\n        sessionStorage.setItem(this.tableOptions.views!.saveKey!, tableView);\r\n      break;\r\n      case TableViewSaveMode.LocalStorage:\r\n        localStorage.setItem(this.tableOptions.views!.saveKey!, tableView);\r\n      break;\r\n      case TableViewSaveMode.DatabaseStorage:\r\n        const saveObsv = this.tableService.viewsSaveToDatabase(this.tableViewsList, this.tableOptions.views!.urlSave!, this.tableOptions.views!.saveKey!);\r\n        saveObsv.subscribe({\r\n          next: (response: HttpResponse<any>) => {\r\n            this.viewsSaveEnd(endMessage);\r\n          },\r\n          error: (err) => this.tableService.handleTableError(err, 'Views save error')\r\n        });\r\n      return;\r\n      default:\r\n        this.notification.showToast(\"error\", this.i18n.text(\"NOT IMPLEMENTED\"), this.i18n.text(\"This type os save view has not been implemented yet.\"));\r\n        return;\r\n    }\r\n    this.viewsSaveEnd(endMessage);\r\n  }\r\n  viewsSaveEnd(endMessage: number){\r\n    this.changeDetector?.markForCheck();\r\n    switch(endMessage){\r\n      case 0: // NEW VIEW\r\n        this.notification.showToast(\"info\", this.i18n.text(\"Table view created\"), this.i18n.text(\"New table view has been created.\"));\r\n        this.viewsModalShow = false;\r\n        break;\r\n      case 1: // UPDATE VIEW\r\n        this.notification.showToast(\"info\", this.i18n.text(\"Table view data updated\"), this.i18n.text(\"The table view data was updated.\"));\r\n        break;\r\n      case 2: // UPDATE ALIAS\r\n        this.notification.showToast(\"info\", this.i18n.text(\"Table view name updated\"), this.i18n.text(\"The table view alias was updated.\"));\r\n        break;\r\n      case 3: // DELETE VIEW\r\n        this.notification.showToast(\"info\", this.i18n.text(\"Table view delete\"), this.i18n.text(\"The table view was deleted.\"));\r\n        break;\r\n      case 4: // DELETE VIEW\r\n        this.notification.showToast(\"info\", this.i18n.text(\"Table view active on startup\"), this.i18n.text(\"Changed the view that will be active on startup.\"));\r\n        break;\r\n    }\r\n  }\r\n\r\n  fetchTableData(event: TableLazyLoadEvent): void {\r\n    if(!this.canFetchData()){\r\n      return;\r\n    }\r\n    if (!this.initialConfigurationFetched || !this.initialStateApplied) {\r\n      return;\r\n    }\r\n    this.responsiveRowMenu?.hide();\r\n    this.tableLazyLoadEventInformation = event; // Store the event information for later use\r\n    if (event.rows != null && event.rows !== undefined) {\r\n      this.currentRowsPerPage = event.rows;\r\n    }\r\n    if (event.first != null && event.first !== undefined && event.rows != null && event.rows !== undefined) {\r\n      this.currentPage = event.first / event.rows;\r\n    }\r\n    let filtersWithoutGlobalAndSelectedRows = this.modifyFiltersWithoutGlobalAndSelectedRows(this.tableLazyLoadEventInformation.filters); // Create filters excluding the global filter\r\n    filtersWithoutGlobalAndSelectedRows=this.revertDateTimeZoneFilters(filtersWithoutGlobalAndSelectedRows);\r\n    const requestData: ITableQueryRequest = {\r\n      page: this.currentPage, // Set the current page number\r\n      pageSize: this.currentRowsPerPage, // Set the number of rows per page\r\n      sort: this.tableLazyLoadEventInformation.multiSortMeta, // Set the sorting information\r\n      filter: filtersWithoutGlobalAndSelectedRows, // Set the filters excluding the global filter\r\n      globalFilter: this.effectiveGlobalSearchText, // Use the applied query, not pending input\r\n      columns: this.tableOptions.columns!.shown!.map(col => col.field), // Set the columns to show\r\n      dateFormat: this.dateFormat,\r\n      dateTimezone: this.dateTimezone,\r\n      dateCulture: this.dateCulture,\r\n      exportDateFormat: this.exportDateFormat\r\n    };\r\n    const selectionKey = JSON.stringify({ ...requestData, page: 0, pageSize: 0, sort: null });\r\n    if (selectionKey !== this.selectionQueryKey) this.matchingSelectionKeys = undefined;\r\n    this.selectionQueryKey = selectionKey;\r\n    this.selectionQuery = structuredClone(requestData);\r\n    if (this.treeState) {\r\n      const tree = this.treeState;\r\n      if (!this.treeStateRestored) tree.restore([...tree.expanded], tree.snapshotPages());\r\n      this.treeStateRestored = false;\r\n      const structural = [tree.options.keyExpr, tree.options.parentIdExpr, tree.options.hasItemsExpr, 'rowID'];\r\n      requestData.columns = [...new Set([...requestData.columns!, ...structural.filter((field): field is string => !!field)])];\r\n      this.treeQuery = structuredClone(requestData);\r\n      const loading = tree.load(this.currentPage, this.currentRowsPerPage, this.treeFetcher(requestData));\r\n      this.tableOptions.data = [];\r\n      loading.then(updated => {\r\n        if (updated && !this.destroyed) this.syncTreeRows();\r\n      }).catch(error => {\r\n        if (!this.destroyed) this.tableService.handleTableError(error, 'Tree data error');\r\n      }).finally(() => {\r\n        if (!this.destroyed) {\r\n          this.changeDetector?.markForCheck();\r\n          this.onDataEndUpdate.emit();\r\n        }\r\n      });\r\n      return;\r\n    }\r\n    this.tableService.fetchTableData(this.tableOptions.urlTableData!, requestData)\r\n      .pipe(\r\n        takeUntil(this.destroy$),\r\n        finalize(() => {\r\n          if (this.destroyed) return;\r\n          this.onDataEndUpdate.emit(); // This is always executed after data update.\r\n        })\r\n      )\r\n      .subscribe({\r\n        next: (response: HttpResponse<ITablePagedResponse>) => this.handleTableDataResponse(response.body!),\r\n        error: (err) => this.tableService.handleTableError(err, 'Columns Error')\r\n      });\r\n  }\r\n\r\n  modifyFiltersWithoutGlobalAndSelectedRows(filters: any, overrideOption: number = -1): any {\r\n    let filtersWithoutGlobalAndSelectedRows = structuredClone(filters ?? {}); // Create a copy of filters to delete the global.\r\n    if (filtersWithoutGlobalAndSelectedRows.hasOwnProperty('global')) { // If there is an entry with the global filter\r\n      delete filtersWithoutGlobalAndSelectedRows['global']; // Remove the global filter\r\n    }\r\n    this.selectorRowFilterBuilder(filtersWithoutGlobalAndSelectedRows, overrideOption);\r\n    return filtersWithoutGlobalAndSelectedRows; // Return the filters without global array\r\n  }\r\n\r\n  resetTableView(): void {\r\n    this.cancelGlobalSearch();\r\n    const key = this.tableOptions.statePersistence?.key?.trim();\r\n    if (key) this.stateScope?.clear(key);\r\n    this.treeState?.restore();\r\n    this.treeStateRestored = !!this.treeState;\r\n    this.initialStateApplied = false;\r\n    this.tableViewCurrentSelectedAlias = '';\r\n    this.fetchTableConfiguration(true);\r\n  }\r\n\r\n  private selectorRowFilterBuilder(filtersWithoutGlobalAndSelectedRows: any, overrideOption: number = -1): void {\r\n    if (filtersWithoutGlobalAndSelectedRows.hasOwnProperty('selector') || overrideOption === 1 || overrideOption === 2) {\r\n      const selectorFilter = filtersWithoutGlobalAndSelectedRows['selector']?.[0];\r\n      let filterType: boolean | null = null;\r\n      if(overrideOption<0 || overrideOption>2){\r\n        filterType = selectorFilter?.value ?? null;\r\n      } else {\r\n        switch (overrideOption){\r\n          case 0: // All\r\n            filterType = null;\r\n            break;\r\n          case 1: // Only selected rows\r\n            filterType = true;\r\n            break;\r\n          case 2: // Only NOT selected\r\n            filterType = false;\r\n            break;\r\n        }\r\n      }\r\n      if (!filtersWithoutGlobalAndSelectedRows.hasOwnProperty('rowID')) {\r\n          filtersWithoutGlobalAndSelectedRows['rowID'] = [\r\n              {\r\n                  \"value\": null,\r\n                  \"matchMode\": \"in\",\r\n                  \"operator\": \"or\"\r\n              }\r\n          ];\r\n      }\r\n      const idFilter = filtersWithoutGlobalAndSelectedRows['rowID'][0];\r\n      if (filterType === true) {\r\n          idFilter.matchMode = \"in\";\r\n          idFilter.value = this.selectedRowsCheckbox;\r\n      } else if (filterType === false) {\r\n          idFilter.operator = \"and\"\r\n          idFilter.matchMode = \"notIn\";\r\n          idFilter.value = this.selectedRowsCheckbox;\r\n      } else if (filterType === null) {\r\n          idFilter.value = null;\r\n          idFilter.matchMode = \"in\";\r\n      }\r\n    }\r\n  }\r\n\r\n  revertDateTimeZoneFilters(inputFilter: any){\r\n    this.tableOptions.columns!.shown!.forEach((column) => {\r\n      if (column.dataType === DataType.Date) { // If its date type\r\n        if (inputFilter.hasOwnProperty(column.field)) {\r\n          const originalDate = inputFilter[column.field][0].value;\r\n          if(originalDate !== null && originalDate instanceof Date){\r\n            const utcDate = new Date(Date.UTC(originalDate.getFullYear(), originalDate.getMonth(), originalDate.getDate()))\r\n            inputFilter[column.field][0].value=utcDate;\r\n          }\r\n        }\r\n      }\r\n    });\r\n    return inputFilter;\r\n  }\r\n\r\n  handleTableDataResponse(body: ITablePagedResponse): void{\r\n    this.tableOptions.data = body.data; // Update the table data\r\n    this.totalRecords = body.totalRecords; // Update the total number of records\r\n    this.totalRecordsNotFiltered = body.totalRecordsNotFiltered; // Update the total records not filtered\r\n    this.currentPage = body.page; // Update the current page\r\n  }\r\n\r\n  private generateViewData(): ITableViewData {\r\n    const view = this.tableService.viewGenerateData(this.dt, this.effectiveGlobalSearchText, this.currentPage,\r\n      this.currentRowsPerPage, this.modifyFiltersWithoutGlobalAndSelectedRows.bind(this));\r\n    if (this.treeState) {\r\n      view.treeExpandedKeys = [...this.treeState.expanded];\r\n      view.treeChildPages = this.treeState.snapshotPages();\r\n    }\r\n    return view;\r\n  }\r\n\r\n  private treeFetcher(query: ITableQueryRequest): (request: ITreeRequest) => Promise<ITreeResponse> {\r\n    return async request => {\r\n      const response = await firstValueFrom(this.tableService.fetchTableData(this.tableOptions.urlTableData!,\r\n        { ...structuredClone(query), ...request }).pipe(takeUntil(this.destroy$)));\r\n      if (!response.body) throw new Error('Empty tree response.');\r\n      return response.body as ITreeResponse;\r\n    };\r\n  }\r\n\r\n  private syncTreeRows(): void {\r\n    const tree = this.treeState!;\r\n    this.tableOptions.data = tree.visible;\r\n    this.totalRecords = tree.totalRecords;\r\n    this.totalRecordsNotFiltered = tree.totalRecordsNotFiltered;\r\n    this.currentPage = tree.page;\r\n    this.changeDetector?.markForCheck();\r\n  }\r\n\r\n  async toggleTreeRow(event: Event, row: TreeRow): Promise<void> {\r\n    event.stopPropagation();\r\n    if (!this.treeState || !this.treeQuery || this.treeState.loading) return;\r\n    try {\r\n      const update = this.treeState.toggle(row, this.treeFetcher(this.treeQuery));\r\n      this.changeDetector?.markForCheck();\r\n      await update;\r\n      if (!this.destroyed) this.syncTreeRows();\r\n    } catch (error) {\r\n      if (!this.destroyed) this.tableService.handleTableError(error, 'Tree data error');\r\n    } finally {\r\n      if (!this.destroyed) { this.changeDetector?.markForCheck(); this.onDataEndUpdate.emit(); }\r\n    }\r\n  }\r\n\r\n  async loadMoreTreeRows(event: Event, row: TreeRow): Promise<void> {\r\n    event.stopPropagation();\r\n    if (!this.treeState || !this.treeQuery || this.treeState.loading) return;\r\n    try {\r\n      await this.treeState.loadMore(row, this.treeFetcher(this.treeQuery));\r\n      if (!this.destroyed) this.syncTreeRows();\r\n    } catch (error) {\r\n      if (!this.destroyed) this.tableService.handleTableError(error, 'Tree data error');\r\n    }\r\n  }\r\n\r\n  get treeColumn(): string | undefined {\r\n    const columns = this.tableOptions.columns?.shown ?? [];\r\n    return columns.find(column => column.field === this.treeState?.options.column)?.field ?? columns[0]?.field;\r\n  }\r\n\r\n  treePageChange(event: { first?: number; rows?: number }): void {\r\n    this.fetchTableData({ ...this.tableLazyLoadEventInformation, first: event.first ?? 0,\r\n      rows: event.rows ?? this.currentRowsPerPage });\r\n  }\r\n\r\n  clearFilters(dt: Table, force: boolean = false, onlyGlobalFilter: boolean = false): void{\r\n    this.cancelGlobalSearch();\r\n    let hasToClear = this.hasToClearFilters(dt, this.globalSearchText, force);\r\n    if(hasToClear){\r\n      if(!onlyGlobalFilter){\r\n        this.predefinedFiltersSelectedValuesCollection = {};\r\n        for (const key in dt.filters) {\r\n          if (dt.filters.hasOwnProperty(key)) {\r\n            const filters = dt.filters[key];\r\n            if (Array.isArray(filters)) {\r\n              filters.forEach(filter => {\r\n                filter.value = null;  // Set value to null\r\n              });\r\n            } else {\r\n              filters.value = null; // Set value to null\r\n            }\r\n          }\r\n        }\r\n        let filters = {...this.dt.filters};\r\n        dt.columns?.forEach(\r\n          element => {\r\n            dt.filter(null, element.field, element.matchMode)\r\n          }\r\n        );\r\n        this.dt.filters = filters;\r\n      }\r\n      this.restoreGlobalSearch(null);\r\n      if (this.globalSearchOption(this.tableOptions.globalFilter?.minLength) > 0 ||\r\n          this.globalSearchOption(this.tableOptions.globalFilter?.debounceTime) > 0) {\r\n        this.currentPage = 0;\r\n        dt.first = 0;\r\n        dt.filters = { ...dt.filters, global: { value: null, matchMode: 'contains' } };\r\n        this.fetchTableData({ ...this.tableLazyLoadEventInformation, first: 0,\r\n          rows: this.currentRowsPerPage, filters: dt.filters });\r\n      } else dt.filterGlobal('','');\r\n    }\r\n  }\r\n\r\n  clearSorts(dt: Table, force: boolean = false): void{\r\n    let hasToClear = this.hasToClearSorts(dt, force);\r\n    if(hasToClear){\r\n      dt.multiSortMeta = [];\r\n      dt.sortMultiple();\r\n    }\r\n  }\r\n  hasToClearSorts(dt: Table, force: boolean = false): boolean{\r\n    let hasToClear: boolean = false;\r\n    const hasSorts = (dt.multiSortMeta && dt.multiSortMeta.length > 0);\r\n    if(force || hasSorts){\r\n      hasToClear = true;\r\n    }\r\n    return hasToClear;\r\n  }\r\n  hasToClearFilters(dt: Table, globalSearchText: string|null, force:boolean = false): boolean{\r\n    let hasToClear: boolean = false;\r\n    const filtersWithoutGlobalAndSelectedRows = this.modifyFiltersWithoutGlobalAndSelectedRows(dt.filters)\r\n    const hasFilters = this.hasFilters(filtersWithoutGlobalAndSelectedRows);\r\n    const hasGlobalFilter = (globalSearchText && globalSearchText.trim() !== \"\");\r\n    if(force || hasFilters || hasGlobalFilter){\r\n      hasToClear = true;\r\n    }\r\n    return hasToClear;\r\n  }\r\n\r\n  /**\r\n   * Determines whether there are active filters based on the provided filter rules.\r\n   *\r\n   * @param {any} filterRules An object representing filter rules for each column.\r\n   *   The keys are column names, and the values are arrays of filter rules.\r\n   *   Each filter rule has the following properties:\r\n   *     - `field`: The field or property name of the column.\r\n   *     - `value`: The filter value entered by the user.\r\n   *     - Other properties depending on the type of filter (e.g., `matchMode` for string filters).\r\n   * @returns {boolean} `true` if at least one active filter is found, otherwise `false`.\r\n   */\r\n  private hasFilters(filterRules: any): boolean {\r\n    for (const columnName of Object.keys(filterRules)) { // Iterate over each column name in the filter rules\r\n        const columnFilters = filterRules[columnName]; // Get the filter rules for the current column\r\n        for (const filterRule of columnFilters) { // Iterate over each filter rule for the current column\r\n            if (filterRule.value !== null && filterRule.value !== \"\") { // Check if the filter value is not null or an empty string\r\n                return true; // At least one active filter found\r\n            }\r\n        }\r\n    }\r\n    return false; // No active filters found\r\n  }\r\n\r\n  getColumnStyle(col: any, headerCols: boolean = false): Record<string, string> {\r\n    return this.tableService.getColumnStyle(col, headerCols);\r\n  }\r\n\r\n  getPredefinedFilterValues(columnKeyName: string): IPredefinedFilter[] {\r\n    return this.tableOptions.predefinedFilters?.[columnKeyName] || []; // Return the predefined filter values or an empty array if the option name does not exist\r\n  }\r\n\r\n  getFrozenColumnAlignAsText(frozenColumnAlign: FrozenColumnAlign): string {\r\n    return frozenColumnAlignAsText(frozenColumnAlign);\r\n  }\r\n\r\n  getDataTypeAsText(dataType: DataType): string {\r\n    return dataTypeAsText(dataType);\r\n  }\r\n\r\n  /**\r\n   * Updates the filters of a PrimeNG data table based on predefined filter changes.\r\n   *\r\n   * @param {string} filterName - The name of the filter to be updated.\r\n   * @param {IPrimengPredefinedFilter[]} selectedValues - An array of selected predefined filter values.\r\n   */\r\n  onPredefinedFilterChange(filterName: string, selectedValues: IPredefinedFilter[]): void {\r\n    const filters = { ...this.dt.filters }; // Create a shallow copy of the current filters to avoid mutating the original filters directly\r\n    const newValue = selectedValues && selectedValues.length ? selectedValues.map(value => value.value) : null; // Convert empty selection to null so PrimeNG removes the filter instead of applying an empty array\r\n    if (Array.isArray(filters[filterName])) { // Check if the filter for the given filterName is an array\r\n      (filters[filterName] as FilterMetadata[]).forEach(criteria => { // If it is an array, iterate over each filter criteria\r\n          criteria.value = newValue; // Update the value of each criteria with the values from selectedValues\r\n      });\r\n    } else if (filters[filterName]) { // Check if the filter for the given filterName exists and is not an array\r\n      const criteria = filters[filterName] as FilterMetadata; // Cast the filter criteria to FilterMetadata\r\n      criteria.value = newValue; // Update the value of the criteria with the values from selectedValues\r\n    }\r\n    this.dt.filters = filters; // Update the data table's filters with the modified filters object\r\n    this.dt._filter(); // Trigger the filtering operation on the data table to apply the new filters\r\n  }\r\n\r\n  /**\r\n   * Checks if the provided column metadata matches a specific style of the predefined filters \r\n   * that need to be applied to an item on a row.\r\n   *\r\n   * @param {IprimengColumnsMetadata} colMetadata - The metadata of the column being checked.\r\n   * @param {any} value - The value to be matched against the predefined filter values.\r\n   * @returns {any} The matching predefined filter value if found, otherwise null.\r\n   */\r\n  getPredfinedFilterMatch(colMetadata: IColumnMetadata, value: any): any {\r\n    if (colMetadata.filterPredefinedValuesName && colMetadata.filterPredefinedValuesName.length > 0) { // Check if the column uses predefined filter values\r\n        const options = this.getPredefinedFilterValues(colMetadata.filterPredefinedValuesName); // Get the predefined filter values based on the name\r\n        return options.find(option => option.value === value); // Return the matching option if found\r\n    }\r\n    return null; // Return null if the column does not use predefined filter values\r\n  }\r\n\r\n  copyToClipboardStart(event: MouseEvent) {\r\n    if((this.tableOptions.copyToClipboardTime ?? 0) > 0) {\r\n      const cellContent = (event.target as HTMLElement).innerText;\r\n      this.copyCellDataTimer = setTimeout(() => {\r\n        navigator.clipboard.writeText(cellContent).then(() => {\r\n          this.notification.clearToasts();\r\n          this.notification.showToast(\"info\", this.i18n.text(\"CELL CONTENT COPIED\"), this.i18n.text(\"The cell content has been copied to your clipboard.\"));\r\n        }).catch(err => {\r\n          this.notification.clearToasts();\r\n          this.notification.showToast(\"error\", this.i18n.text(\"CELL CONTENT COPIED\"), this.i18n.text(\"The cell content failed to copy to your clipboard with error: {{value0}}\", { value0: err }));\r\n        });\r\n      }, (this.tableOptions.copyToClipboardTime ?? 0) * 1000 );\r\n    }\r\n  }\r\n\r\n  copyToClipboardCancel(){\r\n    if((this.tableOptions.copyToClipboardTime ?? 0) > 0) {\r\n      clearTimeout(this.copyCellDataTimer);\r\n    }\r\n  }\r\n\r\n  getDataAlignHorizontalAsText(dataAlignHorizontal: DataAlignHorizontal){\r\n    return dataAlignHorizontalAsText(dataAlignHorizontal);\r\n  }\r\n  getDataAlignVerticalAsText(dataAlignVertical: DataAlignVertical){\r\n    return dataAlignVerticalAsText(dataAlignVertical);\r\n  }\r\n\r\n  isRowCheckboxSelected(rowID: any): boolean {\r\n    return this.selectedRowsCheckbox.includes(rowID);\r\n  }\r\n\r\n  get allMatchingRowsSelected(): boolean {\r\n    if (!this.matchingSelectionKeys?.length) return false;\r\n    const selected = new Set(this.selectedRowsCheckbox);\r\n    return this.matchingSelectionKeys.every(key => selected.has(key));\r\n  }\r\n\r\n  get matchingRowsPartiallySelected(): boolean {\r\n    if (this.allMatchingRowsSelected) return false;\r\n    if (!this.matchingSelectionKeys) return this.selectedRowsCheckbox.length > 0;\r\n    const selected = new Set(this.selectedRowsCheckbox);\r\n    return this.matchingSelectionKeys.some(key => selected.has(key));\r\n  }\r\n\r\n  async toggleAllMatchingRows(checked: boolean): Promise<void> {\r\n    const options = this.tableOptions.rows?.checkboxSelector;\r\n    if (!options?.enabled || !options.selectAllEnabled || !options.urlSelectAll ||\r\n        !this.selectionQuery || this.selectAllLoading) return;\r\n    const queryKey = this.selectionQueryKey;\r\n    this.selectAllLoading = true;\r\n    try {\r\n      const response = await firstValueFrom(this.tableService.fetchSelectionKeys(options.urlSelectAll,\r\n        structuredClone(this.selectionQuery)).pipe(takeUntil(this.destroy$)));\r\n      if (this.destroyed || queryKey !== this.selectionQueryKey) return;\r\n      if (!Array.isArray(response.body) || response.body.some(key =>\r\n          typeof key !== 'string' && typeof key !== 'number')) throw new Error('Invalid selection identifiers.');\r\n      const disabledKeys = new Set((this.tableOptions.data ?? [])\r\n        .filter(row => !(options.enabledCondition?.(row) ?? true)).map(row => row.rowID));\r\n      const keys = [...new Set(response.body)].filter(key => !disabledKeys.has(key));\r\n      this.matchingSelectionKeys = keys;\r\n      const selected = new Set(this.selectedRowsCheckbox);\r\n      const changed = keys.filter(key => selected.has(key) !== checked);\r\n      for (const key of changed) {\r\n        if (checked) selected.add(key); else selected.delete(key);\r\n      }\r\n      this.selectedRowsCheckbox = [...selected];\r\n      for (const rowID of changed) this.onRowCheckboxChange.emit({ rowID, selected: checked });\r\n    } catch (error) {\r\n      if (!this.destroyed) this.tableService.handleTableError(error, 'Selection error');\r\n    } finally {\r\n      this.selectAllLoading = false;\r\n      this.changeDetector?.markForCheck();\r\n    }\r\n  }\r\n\r\n  onRowChekboxChange(event: any, rowID: any): void {\r\n    if (event.checked) { // Add the selected item\r\n        if (!this.selectedRowsCheckbox.includes(rowID)) this.selectedRowsCheckbox.push(rowID);\r\n    } else { // Remove the selected item\r\n        this.selectedRowsCheckbox = this.selectedRowsCheckbox.filter(selectedId => selectedId !== rowID);\r\n    }\r\n    this.onRowCheckboxChange.emit({\r\n      rowID: rowID,\r\n      selected: event.checked\r\n    });\r\n  }\r\n  rowSelect(event: TableRowSelectEvent<any>): void{\r\n    this.onRowSelect.emit({\r\n      rowID: event.data.rowID,\r\n      rowData: event.data\r\n    });\r\n  }\r\n  rowUnselect(event: TableRowUnSelectEvent<any>): void{\r\n    this.onRowUnselect.emit({\r\n      rowID: event.data.rowID,\r\n      rowData: event.data\r\n    });\r\n  }\r\n  pageChange(event: TablePageEvent): void {\r\n    this.currentPage = event.rows ? event.first / event.rows : 0;\r\n    this.currentRowsPerPage = event.rows ? event.rows : 0;\r\n  }\r\n\r\n  columnSelectorShow(){\r\n    this.tableOptions.columns?.selectorOrderByColumnName\r\n    let tempData = this.columns.map(column => {\r\n      const isSelected = this.columnsSelected.some(selectedColumn => selectedColumn.field === column.field) || this.columnsCantBeHidden.some(selectedColumn => selectedColumn.field === column.field);\r\n      const isSelectDisabled =  this.columnsCantBeHidden.some(selectedColumn => selectedColumn.field === column.field);\r\n      return {\r\n        field: column.field,\r\n        header: column.header,\r\n        selected: isSelected,\r\n        selectDisabled: isSelectDisabled,\r\n        cellOverflowBehaviour: column.cellOverflowBehaviour,\r\n        cellOverflowBehaviourDisabled: !column.cellOverflowBehaviourAllowUserEdit,\r\n        dataAlignHorizontal: column.dataAlignHorizontal,\r\n        dataAlignHorizontalDisabled: !column.dataAlignHorizontalAllowUserEdit,\r\n        dataAlignVertical: column.dataAlignVertical,\r\n        dataAlignVerticalDisabled: !column.dataAlignVerticalAllowUserEdit\r\n      };\r\n    });\r\n    this.columnModalData = [...tempData];\r\n    this.filteredColumnData = this.columnModalData;\r\n    this.showColumnSelector=true;\r\n  }\r\n\r\n  applyColumnModalChanges(selectedColumns: IColumnMetadata[]) {\r\n    this.columnSelectionCustomized = true;\r\n    const existingColumns = this.dt.columns!;\r\n    const columnsToKeep = new Set<string>();\r\n\r\n    this.columnsCantBeHidden.forEach(col => columnsToKeep.add(col.field));\r\n    selectedColumns.forEach(col => columnsToKeep.add(col.field));\r\n\r\n    const finalColumns: IColumnMetadata[] = [];\r\n    existingColumns.forEach(col => {\r\n      if (columnsToKeep.has(col.field)) {\r\n        finalColumns.push(col);\r\n      }\r\n    });\r\n\r\n    selectedColumns.forEach(col => {\r\n      const matchingColumn = this.columns.find(c => c.field === col.field);\r\n      if (matchingColumn && !finalColumns.find(c => c.field === matchingColumn.field)) {\r\n        finalColumns.push(matchingColumn);\r\n      }\r\n    });\r\n\r\n    let prevColsToShow = this.tableOptions.columns!.shown;\r\n    this.tableOptions.columns!.shown = this.tableService.orderColumnsWithFrozens(finalColumns);\r\n\r\n    let sameColumnsAsBefore =\r\n      prevColsToShow!.length === this.tableOptions.columns!.shown.length &&\r\n      prevColsToShow!.every((prevCol, index) => prevCol.field === this.tableOptions.columns!.shown![index].field);\r\n\r\n    this.columnsSelected = this.tableOptions.columns!.shown.filter(\r\n      column => !this.columnsCantBeHidden.some(nonSelectable => nonSelectable.field === column.field)\r\n    );\r\n\r\n    this.updateColumnsSpecialProperties(this.columnModalData);\r\n\r\n    if (!sameColumnsAsBefore) {\r\n      this.tableOptions.isActive = false;\r\n      this.clearSorts(this.dt, true);\r\n      this.clearFilters(this.dt, true, false);\r\n      setTimeout(() => {\r\n        this.tableOptions.isActive = true;\r\n      }, 1);\r\n    }\r\n  }\r\n\r\n  private updateColumnsSpecialProperties(columnsSource: any[]){\r\n    const allColumns = [this.columns, this.tableOptions.columns!.shown!, this.columnsSelected, this.columnsCantBeHidden];\r\n    const columnModalDataMap = new Map(columnsSource.map((item: any) => [item.field, { \r\n        cellOverflowBehaviour: item.cellOverflowBehaviour, \r\n        dataAlignHorizontal: item.dataAlignHorizontal,\r\n        dataAlignVertical: item.dataAlignVertical,\r\n        width: item.width\r\n    }]));\r\n    const updatedFields = new Set(); // To track updated fields\r\n    allColumns.forEach((columnList) => {\r\n        columnList.forEach((col: any) => {\r\n            if (columnModalDataMap.has(col.field) && !updatedFields.has(col.field)) {\r\n                const columnData = columnModalDataMap.get(col.field);\r\n                if (columnData) {\r\n                    col.cellOverflowBehaviour = columnData.cellOverflowBehaviour;\r\n                    col.dataAlignHorizontal = columnData.dataAlignHorizontal;\r\n                    col.dataAlignVertical = columnData.dataAlignVertical;\r\n                    col.width = columnData.width;\r\n                    updatedFields.add(col.field);\r\n                }\r\n            }\r\n        });\r\n    });\r\n  }\r\n\r\n  openExcelExport(){\r\n    const defaultTitle = this.tableOptions.excelReport?.defaultTitle?.trim();\r\n    const allowEdit = this.tableOptions.excelReport?.titleAllowUserEdit === true;\r\n    this.excelReportTitle = this.i18n.text((!defaultTitle && !allowEdit) ? 'Report' : defaultTitle!);\r\n    this.showExportModal=true;\r\n  }\r\n  generateExcelReport(event: any){\r\n    if(!this.tableOptions.excelReport?.url?.trim()){\r\n      return;\r\n    }\r\n    let filtersWithoutGlobalAndSelectedRows = this.modifyFiltersWithoutGlobalAndSelectedRows(this.tableLazyLoadEventInformation.filters, event.selectedRows); // Create filters excluding the global filter\r\n    filtersWithoutGlobalAndSelectedRows=this.revertDateTimeZoneFilters(filtersWithoutGlobalAndSelectedRows);\r\n    const filtersMustBeApplied: boolean = (event.selectedRows === 1 || event.selectedRows === 2) \r\n    ? true \r\n    : event.applyFilters;\r\n    const requestData: IExcelExportRequest = {\r\n      page: this.currentPage, // Set the current page number\r\n      pageSize: this.currentRowsPerPage, // Set the number of rows per page\r\n      sort: this.tableLazyLoadEventInformation.multiSortMeta, // Set the sorting information\r\n      filter: filtersWithoutGlobalAndSelectedRows, // Set the filters excluding the global filter\r\n      globalFilter: this.effectiveGlobalSearchText, // Use the applied query, not pending input\r\n      columns: this.tableOptions.columns!.shown!.map(col => col.field), // Set the columns to show\r\n      dateFormat: this.dateFormat,\r\n      dateTimezone: this.dateTimezone,\r\n      dateCulture: this.dateCulture,\r\n      exportDateFormat: this.exportDateFormat,\r\n      allColumns: event.allColumns,\r\n      applyFilters: filtersMustBeApplied,\r\n      applySorts: event.applySorts,\r\n      filename: event.filename,\r\n      useIconInBools: event.useIconInBools\r\n    };\r\n    if (this.treeState) Object.assign(requestData, { expandedKeys: [...this.treeState.expanded] });\r\n    this.tableService.fetchExcelReport(this.tableOptions.excelReport.url, requestData).subscribe({\r\n      next: (response: HttpResponse<Blob>) => {\r\n        this.tableService.downloadFile(response.body!, event.filename, 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');\r\n        this.showExportModal=false;\r\n      },\r\n      error: (err) => this.tableService.handleTableError(err, 'Excel export error')\r\n    });\r\n  }\r\n\r\n  updateIconBlobsForCollections(): void {\r\n    Object.keys(this.tableOptions.predefinedFilters ?? {}).forEach(key => {\r\n      const filters = this.tableOptions.predefinedFilters?.[key];\r\n      if (Array.isArray(filters)  && filters.length > 0) {\r\n        filters.forEach(filter => {\r\n          if (filter.imageBlobSourceEndpoint && !filter.imageBlob) {\r\n            filter.imageBlob = undefined;\r\n            filter.imageBlobFetchError = false;\r\n            this.tableService.getIconBlob(filter.imageBlobSourceEndpoint).subscribe({\r\n              next: (response: HttpResponse<Blob>) => {\r\n                filter.imageBlob = response.body!;\r\n                this.showExportModal=false;\r\n              },\r\n              error: () => { // Handle error response\r\n                filter.imageBlobFetchError = true;\r\n              }\r\n            });\r\n          }\r\n        });\r\n      }else {\r\n        console.warn(`Filters for key ${key} is not an array:`, filters);\r\n      }\r\n    });\r\n  }\r\n\r\n  ecsTrack1(index: number, button: any): any { return button; }\r\n  ecsTrack2(index: number, button: any): any { return index; }\r\n  ecsTrack3(index: number, group: any): any { return group.field; }\r\n  ecsTrack4(index: number, col: any): any { return col.header; }\r\n  ecsTrack5(index: number, col: any): any { return col.field; }\r\n}\r\n","<div #tableContainer>\r\n    <p-table #dt\r\n        styleClass=\"p-datatable-sm p-datatable-gridlines p-datatable-striped\"\r\n        sortMode=\"multiple\"\r\n        [resizableColumns]=\"true\" columnResizeMode=\"expand\"\r\n        [reorderableColumns]=\"true\"\r\n        [scrollable]=\"true\" [scrollHeight]=\"scrollHeightValue\"\r\n        [columns]=\"tableOptions.columns?.shown ?? []\" [value]=\"tableOptions.data ?? []\" dataKey=\"rowID\" \r\n        [paginator]=\"!treeState\" [loading]=\"treeState?.loading ?? false\" paginatorDropdownAppendTo=\"body\" [first]=\"currentPage * currentRowsPerPage\" [rows]=\"currentRowsPerPage\" [totalRecords]=\"totalRecords\"\r\n        [rowsPerPageOptions]=\"allowedRowsPerPage\" [showCurrentPageReport]=\"false\" (onPage)=\"pageChange($event)\"\r\n        [selectionMode]=\"tableOptions.rows?.singleSelector?.enabled ? 'single' : ''\" [metaKeySelection]=\"tableOptions.rows?.singleSelector?.metakey ?? true\" [(selection)]=\"rowSelection\" (onRowSelect)=\"rowSelect($event)\" (onRowUnselect)=\"rowUnselect($event)\"\r\n        [lazy]=\"true\" (onLazyLoad)=\"fetchTableData($event)\">\r\n\r\n        <!--TEMPLATE FOR THE ACTIONS HEADER COLUMN-->\r\n        <ng-template #actionColumnHeaderTemplate>\r\n            <ng-container *ngIf=\"(tableOptions.rows?.action?.buttons?.length ?? 0) > 0\">\r\n                <th [ngStyle]=\"{\r\n                        'text-align': 'center',\r\n                        'vertical-align': 'middle',\r\n                        'max-width': actionColumnWidth + 'px',\r\n                        'min-width': actionColumnWidth + 'px',\r\n                        'width': actionColumnWidth + 'px'\r\n                    }\"\r\n                    pResizableColumn [pResizableColumnDisabled]=\"!tableOptions.rows?.action?.resizable\" pFrozenColumn [frozen]=\"tableOptions.rows?.action?.frozen ?? false\"\r\n                    [alignFrozen]=\"getFrozenColumnAlignAsText(tableOptions.rows?.action?.positionRight ? FrozenColumnAlign.Right : FrozenColumnAlign.Left)\" id=\"actions-header\"\r\n                    [attr.scope]=\"'col'\">\r\n                    {{ (tableOptions.rows?.action?.header ?? '') | ecsTranslate }}\r\n                </th>\r\n            </ng-container>\r\n        </ng-template>\r\n\r\n        <!--TEMPLATE FOR THE ACTIONS ROW COLUMN-->\r\n        <ng-template #actionColumnTemplate let-rowData=\"rowData\">\r\n            <ng-container *ngIf=\"(tableOptions.rows?.action?.buttons?.length ?? 0) > 0\">\r\n                <td \r\n                    [ngStyle]=\"{\r\n                        'text-align': (getDataAlignHorizontalAsText(tableOptions.rows?.action?.horizontalAlignment ?? DataAlignHorizontal.Center)),\r\n                        'vertical-align': (getDataAlignVerticalAsText(tableOptions.rows?.action?.verticalAlignment ?? DataAlignVertical.Middle)),\r\n                        'max-width': actionColumnWidth + 'px',\r\n                        'min-width': actionColumnWidth + 'px',\r\n                        'width': actionColumnWidth + 'px'\r\n                    }\"\r\n                    pFrozenColumn [frozen]=\"tableOptions.rows?.action?.frozen ?? false\"\r\n                    [alignFrozen]=\"getFrozenColumnAlignAsText(tableOptions.rows?.action?.positionRight ? FrozenColumnAlign.Right : FrozenColumnAlign.Left)\">\r\n                    <ng-container *ngIf=\"compactRows; else ecsElse0\">\r\n                        <ng-container *ngIf=\"hasRowMenuActions(rowData)\">\r\n                            <button pButton type=\"button\" icon=\"pi pi-ellipsis-v\" [attr.aria-label]=\"(tableOptions.responsive?.rowMenuLabel || 'Row actions') | ecsTranslate\"\r\n                                aria-haspopup=\"menu\" [attr.aria-expanded]=\"responsiveRowMenu.visible && rowMenuRow === rowData\"\r\n                                (click)=\"openRowMenu($event, rowData)\" class=\"ecs-responsive-trigger\"></button>\r\n                        </ng-container>\r\n                    </ng-container><ng-template #ecsElse0>\r\n                    <ng-container *ngFor=\"let button of tableOptions.rows?.action?.buttons; trackBy: ecsTrack1; let $index = index; let $first = first; let $last = last; let $even = even; let $odd = odd; let $count = count; let last = last\">\r\n                        <ecs-table-button [button]=\"button\" [rowData]=\"rowData\" [isActionButton]=\"true\" [isLastActionButton]=\"last\"></ecs-table-button>\r\n                    </ng-container>\r\n                    </ng-template>\r\n                </td>\r\n            </ng-container>\r\n        </ng-template>\r\n\r\n        <!-- TEMPLATE FOR THE ROW CHECKBOX SELECTOR HEADER COLUMN -->\r\n        <ng-template #rowSelectorColumnHeaderTemplate>\r\n            <th \r\n                [ngStyle]=\"{\r\n                    'text-align': 'center',\r\n                    'vertical-align': 'middle',\r\n                    'max-width': (tableOptions.rows?.checkboxSelector?.width ?? 150) + 'px',\r\n                    'min-width': (tableOptions.rows?.checkboxSelector?.width ?? 150) + 'px',\r\n                    'width': (tableOptions.rows?.checkboxSelector?.width ?? 150) + 'px'\r\n                }\"\r\n                id=\"rowSelector-header\"  [attr.scope]=\"'col'\" pResizableColumn [pResizableColumnDisabled]=\"!tableOptions.rows?.checkboxSelector?.resizable\" pFrozenColumn \r\n                [frozen]=\"tableOptions.rows?.checkboxSelector?.frozen ?? false\" [alignFrozen]=\"getFrozenColumnAlignAsText(tableOptions.rows?.checkboxSelector?.positionRight ? FrozenColumnAlign.Right : FrozenColumnAlign.Left)\">\r\n                    <div style=\"display: flex; justify-content: space-between; align-items: center;\">\r\n                        <ng-container *ngIf=\"tableOptions.rows?.checkboxSelector?.selectAllEnabled\">\r\n                            <input type=\"checkbox\" class=\"ecs-select-all\" [checked]=\"allMatchingRowsSelected\"\r\n                                [indeterminate]=\"matchingRowsPartiallySelected\"\r\n                                [disabled]=\"selectAllLoading || !tableOptions.rows?.checkboxSelector?.urlSelectAll\"\r\n                                [attr.aria-label]=\"'Select all filtered rows' | ecsTranslate\"\r\n                                [pTooltip]=\"'Select all filtered rows' | ecsTranslate\"\r\n                                (change)=\"toggleAllMatchingRows($any($event.target).checked)\">\r\n                        </ng-container>\r\n                        {{ (tableOptions.rows?.checkboxSelector?.header ?? '') | ecsTranslate }}\r\n                        <p-columnFilter type=\"boolean\" field=\"selector\" display=\"menu\" [showButtons]=\"false\"></p-columnFilter>\r\n                    </div>\r\n            </th>\r\n        </ng-template>\r\n\r\n        <!--TEMPLATE FOR THE ROW CHECKBOX SELECTOR COLUMN-->\r\n        <ng-template #rowSelectorColumnTemplate let-rowData=\"rowData\">\r\n            <td \r\n            [ngStyle]=\"{\r\n                'text-align': (getDataAlignHorizontalAsText(tableOptions.rows?.checkboxSelector?.horizontalAlignment ?? DataAlignHorizontal.Center)),\r\n                'vertical-align': (getDataAlignVerticalAsText(tableOptions.rows?.checkboxSelector?.verticalAlignment ?? DataAlignVertical.Middle)),\r\n                'max-width': (tableOptions.rows?.checkboxSelector?.width ?? 150) + 'px',\r\n                'min-width': (tableOptions.rows?.checkboxSelector?.width ?? 150) + 'px',\r\n                'width': (tableOptions.rows?.checkboxSelector?.width ?? 150) + 'px'\r\n            }\"\r\n            pFrozenColumn [frozen]=\"tableOptions.rows?.checkboxSelector?.frozen ?? false\" \r\n            [alignFrozen]=\"getFrozenColumnAlignAsText(tableOptions.rows?.checkboxSelector?.positionRight ? FrozenColumnAlign.Right : FrozenColumnAlign.Left)\">\r\n            <p-checkbox \r\n                [disabled]=\"!(tableOptions.rows?.checkboxSelector?.enabledCondition?.(rowData) ?? true)\"\r\n                [binary]=\"true\"\r\n                [ngModel]=\"isRowCheckboxSelected(rowData.rowID)\"\r\n                (onChange)=\"onRowChekboxChange($event, rowData.rowID)\"></p-checkbox>\r\n            </td>\r\n        </ng-template>\r\n\r\n\r\n        <!-- LOGIC FOR DRAWING TABLE ACTIONS ABOVE THE HEADER -->\r\n        <ng-template pTemplate=\"caption\">\r\n            <div #headerContainer [class.ecs-compact-header]=\"compactHeader\" style=\"display: flex; justify-content: space-between; align-items: center;\">\r\n                <ng-container *ngIf=\"compactHeader; else ecsElse1\">\r\n                    <ng-container *ngIf=\"tableOptions.globalFilter?.enabled\">\r\n                        <span class=\"ecs-global-search ecs-responsive-search\">\r\n                            <span class=\"ecs-input-icon\"><i class=\"pi pi-search\"></i></span>\r\n                            <input pInputText type=\"text\" [attr.aria-label]=\"'Search keyword' | ecsTranslate\" [placeholder]=\"'Search keyword' | ecsTranslate\" autocomplete=\"off\"\r\n                                [maxlength]=\"tableOptions.globalFilter?.maxLength ?? null\" [ngModel]=\"globalSearchText\"\r\n                                (ngModelChange)=\"onGlobalSearchInput($event)\"/>\r\n                            <ng-container *ngIf=\"globalSearchText\">\r\n                                <span class=\"ecs-input-icon\" position=\"right\"><button type=\"button\" class=\"ecs-clear-search\" [attr.aria-label]=\"'Clear search' | ecsTranslate\" (click)=\"clearFilters(dt, true, true)\"><i class=\"pi pi-times\"></i></button></span>\r\n                            </ng-container>\r\n                        </span>\r\n                    </ng-container>\r\n                    <ng-container *ngIf=\"tableOptions.description?.text\">\r\n                        <i [class]=\"tableOptions.description!.icon\" [pTooltip]=\"(tableOptions.description!.text) | ecsTranslate\" [escape]=\"false\"></i>\r\n                    </ng-container>\r\n                    <button pButton type=\"button\" icon=\"pi pi-bars\" [attr.aria-label]=\"(tableOptions.responsive?.headerMenuLabel || 'Table actions') | ecsTranslate\"\r\n                        aria-haspopup=\"menu\" [attr.aria-expanded]=\"responsiveHeaderMenu.visible\"\r\n                        (click)=\"openHeaderMenu($event)\" class=\"ecs-responsive-trigger ecs-header-menu-trigger\"></button>\r\n                </ng-container><ng-template #ecsElse1>\r\n\r\n                <div style=\"display: flex; align-items: center; gap: 10px;\">\r\n                    <!--CHOOSE COLUMNS TO SHOW-->\r\n                    <ng-container *ngIf=\"tableOptions.columns?.selectorEnabled\">\r\n                        <p-button [icon]=\"tableOptions.columns?.selectorIcon ?? 'pi pi-pencil'\" (onClick)=\"columnSelectorShow()\" [pTooltip]=\"'Modify columns' | ecsTranslate\"\r\n                            [showDelay]=\"700\" tooltipPosition=\"top\" styleClass=\"p-button-icon-only\"></p-button>\r\n                    </ng-container>\r\n                    <!--CLEAR SORTS AND FILTERS-->\r\n                    <ng-container *ngIf=\"tableOptions.header?.clearSortsEnabled\">\r\n                        <p-button [icon]=\"tableOptions.header?.clearSortsIcon ?? 'pi pi-sort-alt-slash'\" (onClick)=\"clearSorts(dt)\" [disabled]=\"!hasToClearSorts(dt)\"\r\n                            [pTooltip]=\"'Clear sorts' | ecsTranslate\" [showDelay]=\"700\" tooltipPosition=\"top\" styleClass=\"p-button-icon-only\"></p-button>\r\n                    </ng-container>\r\n                    <ng-container *ngIf=\"tableOptions.header?.clearFiltersEnabled\">\r\n                        <p-button\r\n                            [icon]=\"tableOptions.header?.clearFiltersIcon ?? 'pi pi-filter-slash'\" (onClick)=\"clearFilters(dt)\" [disabled]=\"!hasToClearFilters(dt, globalSearchText)\"\r\n                            [pTooltip]=\"'Clear filters' | ecsTranslate\" [showDelay]=\"700\" tooltipPosition=\"top\" styleClass=\"p-button-icon-only\"></p-button>\r\n                    </ng-container>\r\n\r\n                    <!--TABLE DESCRIPTION-->\r\n                    <ng-container *ngIf=\"tableOptions.description?.text\"> <!-- If a table description text is provided -->\r\n                        <ng-container *ngIf=\"!tableOptions.description!.tooltip; else ecsElse2\"> <!-- The table description must be shown as text next to the icon -->\r\n                            <i [class]=\"tableOptions.description!.icon\"></i>\r\n                            <span [innerHTML]=\"(tableOptions.description!.text) | ecsTranslate\"></span>\r\n                        </ng-container><ng-template #ecsElse2>\r\n                            <i [escape]=\"false\" [pTooltip]=\"(tableOptions.description!.text) | ecsTranslate\" tooltipPosition=\"right\" [class]=\"tableOptions.description!.icon\"></i>\r\n                        </ng-template>\r\n                    </ng-container>\r\n                </div>\r\n\r\n                <!--TABLE VIEWS-->\r\n                <ng-container *ngIf=\"tableViewsEnabled()\">\r\n                    <div style=\"display: flex; align-items: center; gap: 10px;\">\r\n                        <span class=\"p-buttonset ecs-view-buttons\">\r\n                            <p-button (click)=\"viewsModalShow=true;\"\r\n                                [label]=\"tableViewCurrentSelectedAlias \r\n                                    ? tableViewCurrentSelectedAlias \r\n                                    : ((tableOptions.views?.noViewSelectedText || '--- Select a view ---') | ecsTranslate)\"\r\n                                [class]=\"'viewButton' + (tableOptions.views?.selectViewButtonClass ? ' ' + tableOptions.views!.selectViewButtonClass : '')\"></p-button>\r\n                            <p-button (click)=\"viewLoad(tableViewCurrentSelectedAlias!)\"  [disabled]=\"!tableViewCurrentSelectedAlias\" [pTooltip]=\"'Apply view again' | ecsTranslate\" [showDelay]=\"700\" tooltipPosition=\"top\"\r\n                                [icon]=\"tableOptions.views?.reloadViewButtonIcon || 'pi pi-refresh'\"\r\n                                [class]=\"tableOptions.views?.reloadViewButtonClass || ''\"></p-button>\r\n                        </span>\r\n                    </div>\r\n                </ng-container>\r\n\r\n                <div style=\"display: flex; align-items: center; gap: 10px;\">\r\n                    <!--GLOBAL FILTER-->\r\n                    <ng-container *ngIf=\"tableOptions.globalFilter?.enabled\">\r\n                        <span class=\"ecs-global-search ml-auto\">\r\n                            <span class=\"ecs-input-icon\">\r\n                                <i class=\"pi pi-search\"></i>\r\n                            </span>\r\n                            <input pInputText type=\"text\" \r\n                                (ngModelChange)=\"onGlobalSearchInput($event)\" autocomplete=\"off\"\r\n                                [maxlength]=\"tableOptions.globalFilter?.maxLength ?? null\" [placeholder]=\"'Search keyword' | ecsTranslate\" [ngModel]=\"globalSearchText\"\r\n                                style=\"width: 220px;\"/>\r\n                            <!-- Right icon (only if there is text) -->\r\n                            <ng-container *ngIf=\"globalSearchText\">\r\n                                <span class=\"ecs-input-icon\" position=\"right\">\r\n                                    <i class=\"pi pi-times\" style=\"cursor: pointer;\"  (click)=\"clearFilters(dt, true, true); $event.stopPropagation()\"></i>\r\n                                </span>\r\n                            </ng-container>\r\n                        </span>\r\n                    </ng-container>\r\n\r\n                    <!--EXPORT DATA-->\r\n                    <ng-container *ngIf=\"tableOptions.excelReport?.url?.trim()\">\r\n                        <p-button icon=\"pi pi-file-excel\" (onClick)=\"openExcelExport()\"\r\n                            [pTooltip]=\"'Export to Excel' | ecsTranslate\" [showDelay]=\"700\" tooltipPosition=\"top\" styleClass=\"p-button-icon-only\"></p-button>\r\n                    </ng-container>\r\n\r\n                    <!--RESET TABLE VIEW-->\r\n                    <ng-container *ngIf=\"tableOptions.resetTableView?.enabled\">\r\n                        <p-button [icon]=\"tableOptions.resetTableView?.icon ?? 'pi pi-eraser'\" (click)=\"resetTableView()\" [pTooltip]=\"'Reset table view' | ecsTranslate\" [showDelay]=\"700\"\r\n                            tooltipPosition=\"top\" styleClass=\"p-button-icon-only\"></p-button>\r\n                    </ng-container>\r\n\r\n                    <!--REFRESH DATA-->\r\n                    <p-button icon=\"pi pi-refresh\" (onClick)=\"refreshData($event)\" [pTooltip]=\"'Refresh data' | ecsTranslate\" [showDelay]=\"700\"\r\n                        tooltipPosition=\"top\" styleClass=\"p-button-icon-only\"></p-button>\r\n                    \r\n                    <!-- HEADER ACTION BUTTONS -->\r\n                    <ng-container *ngIf=\"(tableOptions.header?.buttons?.length ?? 0) > 0\">\r\n                        <td style=\"display: flex; justify-content: center; align-items: center; gap: 10px;\">\r\n                            <ng-container *ngFor=\"let button of tableOptions.header?.buttons; trackBy: ecsTrack2; let $index = index; let $first = first; let $last = last; let $even = even; let $odd = odd; let $count = count\">\r\n                                <ecs-table-button [button]=\"button\" [rowData]=\"null\"></ecs-table-button>\r\n                            </ng-container>\r\n                        </td>\r\n                    </ng-container>\r\n                </div>\r\n                </ng-template>\r\n            </div>\r\n        </ng-template>\r\n\r\n        <!-- LOGIC FOR DRAWING TABLE HEADERS -->\r\n        <ng-template pTemplate=\"header\" let-columns>\r\n            <ng-container *ngIf=\"getColumnHeaderGroups(columns) as headerGroups\">\r\n            <ng-container *ngIf=\"headerGroups.length\">\r\n                <tr class=\"ecs-column-groups\">\r\n                    <ng-container *ngIf=\"(tableOptions.rows?.action?.buttons?.length ?? 0) > 0 && !tableOptions.rows?.action?.positionRight\">\r\n                        <td aria-hidden=\"true\" pFrozenColumn [frozen]=\"tableOptions.rows?.action?.frozen ?? false\" alignFrozen=\"left\"\r\n                            [style.width.px]=\"actionColumnWidth\" [style.min-width.px]=\"actionColumnWidth\"></td>\r\n                    </ng-container>\r\n                    <ng-container *ngIf=\"tableOptions.rows?.checkboxSelector?.enabled && !tableOptions.rows?.checkboxSelector?.positionRight\">\r\n                        <td aria-hidden=\"true\" pFrozenColumn [frozen]=\"tableOptions.rows?.checkboxSelector?.frozen ?? false\" alignFrozen=\"left\"\r\n                            [style.width.px]=\"tableOptions.rows?.checkboxSelector?.width ?? 150\" [style.min-width.px]=\"tableOptions.rows?.checkboxSelector?.width ?? 150\"></td>\r\n                    </ng-container>\r\n                    <ng-container *ngFor=\"let group of headerGroups; trackBy: ecsTrack3; let $index = index; let $first = first; let $last = last; let $even = even; let $odd = odd; let $count = count\">\r\n                        <td [attr.colspan]=\"group.colspan\" role=\"columnheader\" [attr.aria-colspan]=\"group.colspan\" style=\"text-align: center; vertical-align: middle;\"\r\n                            pFrozenColumn [frozen]=\"group.frozenColumnAlign !== FrozenColumnAlign.Noone\"\r\n                            [alignFrozen]=\"getFrozenColumnAlignAsText(group.frozenColumnAlign)\">\r\n                            {{ group.label | translate }}\r\n                        </td>\r\n                    </ng-container>\r\n                    <ng-container *ngIf=\"tableOptions.rows?.checkboxSelector?.enabled && tableOptions.rows?.checkboxSelector?.positionRight\">\r\n                        <td aria-hidden=\"true\" pFrozenColumn [frozen]=\"tableOptions.rows?.checkboxSelector?.frozen ?? false\" alignFrozen=\"right\"\r\n                            [style.width.px]=\"tableOptions.rows?.checkboxSelector?.width ?? 150\" [style.min-width.px]=\"tableOptions.rows?.checkboxSelector?.width ?? 150\"></td>\r\n                    </ng-container>\r\n                    <ng-container *ngIf=\"(tableOptions.rows?.action?.buttons?.length ?? 0) > 0 && tableOptions.rows?.action?.positionRight\">\r\n                        <td aria-hidden=\"true\" pFrozenColumn [frozen]=\"tableOptions.rows?.action?.frozen ?? false\" alignFrozen=\"right\"\r\n                            [style.width.px]=\"actionColumnWidth\" [style.min-width.px]=\"actionColumnWidth\"></td>\r\n                    </ng-container>\r\n                </tr>\r\n            </ng-container>\r\n            <tr>\r\n                <ng-container *ngIf=\"!tableOptions.rows?.action?.positionRight\">\r\n                    <ng-container *ngTemplateOutlet=\"actionColumnHeaderTemplate\"></ng-container>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"tableOptions.rows?.checkboxSelector?.enabled && !tableOptions.rows?.checkboxSelector?.positionRight\">\r\n                    <ng-container [ngTemplateOutlet]=\"rowSelectorColumnHeaderTemplate\"></ng-container>\r\n                </ng-container>\r\n                <ng-container *ngFor=\"let col of columns; trackBy: ecsTrack4; let $index = index; let $first = first; let $last = last; let $even = even; let $odd = odd; let $count = count\">\r\n                    <th [ngStyle]=\"getColumnStyle(col, true)\"\r\n                        pResizableColumn [pResizableColumnDisabled]=\"!col.canBeResized ? true : false\"\r\n                        pReorderableColumn [pReorderableColumnDisabled]=\"!col.canBeReordered ? true : false\"\r\n                        pFrozenColumn [frozen]=\"col.frozenColumnAlign === FrozenColumnAlign.Left || col.frozenColumnAlign === FrozenColumnAlign.Right\" [alignFrozen]=\"getFrozenColumnAlignAsText(col.frozenColumnAlign)\"\r\n                        [pSortableColumn]=\"col.field\" [pSortableColumnDisabled]=\"!col.canBeSorted ? true : false\"\r\n                        style=\"text-align: center;\"\r\n                        [id]=\"col.field + '-header'\" [attr.scope]=\"'col'\">\r\n                        <div style=\"display: flex; justify-content: space-between; align-items: center; width: 100%;\">\r\n                            <div style=\"margin-right: 15px;\">\r\n                                <span>{{ col.header | translate }}</span>\r\n                            </div>\r\n                            <div style=\"display: flex; align-items: center; gap: 5px;\">\r\n                                <ng-container *ngIf=\"col.canBeSorted\">\r\n                                    <p-sortIcon [field]=\"col.field\"></p-sortIcon>\r\n                                </ng-container>\r\n                                <ng-container *ngIf=\"col.canBeFiltered\">\r\n                                    <ng-container *ngIf=\"!col.filterPredefinedValuesName || col.filterPredefinedValuesName.length === 0; else ecsElse3\">\r\n                                        <p-columnFilter [type]=\"getDataTypeAsText(col.dataType)\" [field]=\"col.field\" display=\"menu\" [showButtons]=\"false\" (click)=\"$event.stopPropagation()\"></p-columnFilter>\r\n                                    </ng-container><ng-template #ecsElse3>\r\n                                        <p-columnFilter\r\n                                            [type]=\"getDataTypeAsText(col.dataType)\" [field]=\"col.field\" display=\"menu\"\r\n                                            (click)=\"$event.stopPropagation()\"\r\n                                            [showButtons]=\"false\" matchMode=\"in\" operator=\"or\" [showMatchModes]=\"false\"\r\n                                            [showOperator]=\"false\" [showAddButton]=\"false\" [showClearButton]=\"false\" [showApplyButton]=\"false\">\r\n                                            <ng-template pTemplate=\"filter\">\r\n                                                <p-multiSelect\r\n                                                    [style]=\"{ minWidth: '400px' }\" [(ngModel)]=\"predefinedFiltersSelectedValuesCollection[col.filterPredefinedValuesName]\"\r\n                                                    [options]=\"getPredefinedFilterValues(col.filterPredefinedValuesName)\" [placeholder]=\"'Any value' | ecsTranslate\"\r\n                                                    (onChange)=\"onPredefinedFilterChange(col.field, $event.value)\" optionLabel=\"name\">\r\n                                                    <ng-template pTemplate=\"item\" let-option >\r\n                                                        <div style=\"display: inline-block; vertical-align: middle;\">\r\n                                                            <ecs-table-predefined-filters [option]=\"option\" [col]=\"col\" [selectable]=\"false\" [rowData]=\"null\"></ecs-table-predefined-filters>\r\n                                                        </div>\r\n                                                    </ng-template>\r\n                                                </p-multiSelect>\r\n                                            </ng-template>\r\n                                        </p-columnFilter>\r\n                                    </ng-template>\r\n                                </ng-container>\r\n                                <ng-container *ngIf=\"col.columnDescription && col.columnDescription.length > 0\">\r\n                                    <i [pTooltip]=\"(col.columnDescription) | ecsTranslate\" tooltipPosition=\"top\" [class]=\"tableOptions.columnDescriptionIcon || 'pi pi-info-circle'\"></i>\r\n                                </ng-container>\r\n                            </div>\r\n                        </div>\r\n                    </th>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"tableOptions.rows?.checkboxSelector?.enabled && tableOptions.rows?.checkboxSelector?.positionRight\">\r\n                    <ng-container [ngTemplateOutlet]=\"rowSelectorColumnHeaderTemplate\"></ng-container>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"tableOptions.rows?.action?.positionRight\">\r\n                    <ng-container *ngTemplateOutlet=\"actionColumnHeaderTemplate\"></ng-container>\r\n                </ng-container>\r\n            </tr>\r\n            </ng-container>\r\n        </ng-template>\r\n\r\n        <!-- LOGIC FOR DRAWING TABLE DATA WHEN THERE IS CONTENTS -->\r\n        <ng-template pTemplate=\"body\" let-rowData let-columns=\"columns\">\r\n            <ng-container *ngIf=\"treeState?.isMore(rowData); else ecsElse4\">\r\n                <tr class=\"ecs-tree-more-row\">\r\n                    <td colspan=\"999\">\r\n                        <p-button icon=\"pi pi-plus\" styleClass=\"p-button-text\" [label]=\"'Load more children' | ecsTranslate\"\r\n                            (onClick)=\"loadMoreTreeRows($event, rowData)\" ></p-button>\r\n                    </td>\r\n                </tr>\r\n            </ng-container><ng-template #ecsElse4>\r\n            <tr [pSelectableRow]=\"rowData\" [ngClass]=\"tableOptions.rows?.class?.(rowData)\" [ngStyle]=\"tableOptions.rows?.style?.(rowData)\"\r\n                [attr.aria-level]=\"treeState ? treeState.depth(rowData) + 1 : null\"\r\n                [attr.aria-expanded]=\"treeState?.hasChildren(rowData) ? treeState?.isExpanded(rowData) : null\">\r\n                <ng-container *ngIf=\"!tableOptions.rows?.action?.positionRight\">\r\n                    <ng-container *ngTemplateOutlet=\"actionColumnTemplate; context: { rowData: rowData }\"></ng-container>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"tableOptions.rows?.checkboxSelector?.enabled && !tableOptions.rows?.checkboxSelector?.positionRight\">\r\n                    <ng-container [ngTemplateOutlet]=\"rowSelectorColumnTemplate\" [ngTemplateOutletContext]=\"{ rowData: rowData }\"></ng-container>\r\n                </ng-container>\r\n                <ng-container *ngFor=\"let col of columns; trackBy: ecsTrack5; let $index = index; let $first = first; let $last = last; let $even = even; let $odd = odd; let $count = count\">\r\n                    <td (mousedown)=\"col.dataType !== DataType.Boolean && copyToClipboardStart($event)\" (mouseup)=\"copyToClipboardCancel()\"\r\n                        [ngStyle]=\"getColumnStyle(col)\" pFrozenColumn [frozen]=\"col.frozenColumnAlign === FrozenColumnAlign.Left || col.frozenColumnAlign === FrozenColumnAlign.Right\" \r\n                        [alignFrozen]=\"getFrozenColumnAlignAsText(col.frozenColumnAlign)\" [style.text-align]=\"getDataAlignHorizontalAsText(col.dataAlignHorizontal)\" [style.vertical-align]=\"getDataAlignVerticalAsText(col.dataAlignVertical)\">\r\n                        <ng-container *ngIf=\"treeState && col.field === treeColumn; else ecsElse5\">\r\n                            <div class=\"ecs-tree-cell\" [style.padding-inline-start.px]=\"treeState.depth(rowData) * 20\">\r\n                                <button type=\"button\" class=\"ecs-tree-toggle\" [class.ecs-tree-leaf]=\"!treeState.hasChildren(rowData)\"\r\n                                    [disabled]=\"!treeState.hasChildren(rowData) || treeState.isLoading(rowData) || treeState.loading\"\r\n                                    [attr.aria-label]=\"(treeState.isExpanded(rowData) ? 'Collapse node' : 'Expand node') | ecsTranslate\"\r\n                                    [attr.aria-expanded]=\"treeState.hasChildren(rowData) ? treeState.isExpanded(rowData) : null\"\r\n                                    [pTooltip]=\"(treeState.isExpanded(rowData) ? 'Collapse node' : 'Expand node') | ecsTranslate\"\r\n                                    (mousedown)=\"$event.stopPropagation()\" (mouseup)=\"$event.stopPropagation()\"\r\n                                    (click)=\"toggleTreeRow($event, rowData)\">\r\n                                    <i [class]=\"treeState.isLoading(rowData) ? 'pi pi-spinner pi-spin' : treeState.isExpanded(rowData) ? 'pi pi-chevron-down' : 'pi pi-chevron-right'\" aria-hidden=\"true\"></i>\r\n                                </button>\r\n                                <ecs-table-cell [col]=\"col\" [rowData]=\"rowData\" [globalSearchText]=\"effectiveGlobalSearchText\"\r\n                                    [dateFormat]=\"dateFormat\" [dateTimezone]=\"dateTimezone\" [dateCulture]=\"dateCulture\"\r\n                                    [predefinedFiltersCollection]=\"tableOptions.predefinedFilters\" ></ecs-table-cell>\r\n                            </div>\r\n                        </ng-container><ng-template #ecsElse5>\r\n                        <ecs-table-cell [col]=\"col\" [rowData]=\"rowData\" [globalSearchText]=\"effectiveGlobalSearchText\"\r\n                            [dateFormat]=\"dateFormat\" [dateTimezone]=\"dateTimezone\" [dateCulture]=\"dateCulture\"\r\n                            [predefinedFiltersCollection]=\"tableOptions.predefinedFilters\"></ecs-table-cell>\r\n                        </ng-template>\r\n                    </td>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"tableOptions.rows?.checkboxSelector?.enabled && tableOptions.rows?.checkboxSelector?.positionRight\">\r\n                    <ng-container [ngTemplateOutlet]=\"rowSelectorColumnTemplate\" [ngTemplateOutletContext]=\"{ rowData: rowData }\"></ng-container>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"tableOptions.rows?.action?.positionRight\">\r\n                    <ng-container *ngTemplateOutlet=\"actionColumnTemplate; context: { rowData: rowData }\"></ng-container>\r\n                </ng-container>\r\n            </tr>\r\n            </ng-template>\r\n        </ng-template>\r\n\r\n        <!-- LOGIC FOR DRAWING TABLE DATA WHEN THERE IS NO CONTENTS -->\r\n        <ng-template pTemplate=\"emptymessage\">\r\n            <tr>\r\n                <td colspan=\"999\">{{ 'No data found for the current filter criteria.' | ecsTranslate }}</td>\r\n            </tr>\r\n        </ng-template>\r\n\r\n        <!-- SHOW CUSTOM RECORDS REPORT -->\r\n        <ng-template pTemplate=\"paginatorleft\">\r\n            <div #paginatorContainer>\r\n                <div style=\"display: flex; align-items: center; gap: 10px;\">\r\n                    <ng-container *ngIf=\"tableOptions.legend?.content\">\r\n                        <ecs-table-button [button]=\"tableOptions.legend?.button\" [rowData]=\"null\" [overrideAction]=\"op.toggle.bind(op)\"></ecs-table-button>\r\n                        <p-overlayPanel #op>\r\n                            <div [innerHTML]=\"(tableOptions.legend?.content) | ecsTranslate\"></div>\r\n                        </p-overlayPanel>\r\n                    </ng-container>\r\n                    <span>{{ 'Showing {{count}} records of {{total}} available records' | ecsTranslate: { count: totalRecords, total: totalRecordsNotFiltered } }}</span>\r\n                </div>\r\n            </div>\r\n        </ng-template>\r\n    </p-table>\r\n    <ng-container *ngIf=\"treeState\">\r\n        <div #paginatorContainer class=\"ecs-tree-paginator\">\r\n            <ng-container *ngIf=\"tableOptions.legend?.content\">\r\n                <ecs-table-button [button]=\"tableOptions.legend?.button\" [rowData]=\"null\" [overrideAction]=\"treeLegend.toggle.bind(treeLegend)\" ></ecs-table-button>\r\n                <p-overlayPanel #treeLegend><div [innerHTML]=\"(tableOptions.legend?.content) | ecsTranslate\"></div></p-overlayPanel>\r\n            </ng-container>\r\n            <span>{{ 'Showing {{count}} root nodes of {{total}} available root nodes' | ecsTranslate: { count: totalRecords, total: totalRecordsNotFiltered } }}</span>\r\n            <p-paginator [first]=\"currentPage * currentRowsPerPage\" [rows]=\"currentRowsPerPage\" [totalRecords]=\"totalRecords\"\r\n                [rowsPerPageOptions]=\"allowedRowsPerPage\" dropdownAppendTo=\"body\" (onPageChange)=\"treePageChange($event)\" ></p-paginator>\r\n        </div>\r\n    </ng-container>\r\n</div>\r\n<ecs-column-selector [visible]=\"showColumnSelector\" [columnModalData]=\"columnModalData\" [filteredColumnData]=\"filteredColumnData\" [orderByHeader]=\"tableOptions.columns?.selectorOrderByColumnName === true\" (visibleChange)=\"showColumnSelector=false\" (applyChanges)=\"applyColumnModalChanges($event)\"></ecs-column-selector>\r\n<ecs-export-excel [visible]=\"showExportModal\" [rowCheckboxSelectorActive]=\"tableOptions.rows?.checkboxSelector?.enabled ?? false\" [excelReportTitle]=\"excelReportTitle\" [allowTitleUserEdit]=\"tableOptions.excelReport?.titleAllowUserEdit ?? false\" (visibleChange)=\"showExportModal=false\" (exportToExcel)=\"generateExcelReport($event)\"></ecs-export-excel>\r\n<ecs-views-management [visible]=\"viewsModalShow\" [tableViews_menuItems]=\"tableViews_menuItems\" \r\n    (onViewSelect)=\"viewLoad($event)\" (onViewCreate)=\"viewCreate($event)\" (onViewDelete)=\"viewDelete($event)\" (onViewEditAlias)=\"viewEditAlias($event)\" (onViewUpdateData)=\"viewUpdateData($event)\" (onViewUpdateActiveStartup)=\"viewUpdateActiveStartup($event)\"\r\n    (visibleChange)=\"viewsModalShow=false\"></ecs-views-management>\r\n<!-- Body-level overlays avoid clipping inside scrollable and frozen table cells. -->\r\n<p-menu #responsiveHeaderMenu [model]=\"headerMenuItems\" [popup]=\"true\" appendTo=\"body\" styleClass=\"ecs-responsive-menu\"></p-menu>\r\n<p-menu #responsiveRowMenu [model]=\"rowMenuItems\" [popup]=\"true\" appendTo=\"body\" styleClass=\"ecs-responsive-menu\"></p-menu>\r\n"]}