@smartbit4all/ng-client 5.0.21 → 6.0.1

package/esm2022/lib/smart-grid/smart-grid.component.mjs

@@ -0,0 +1,1035 @@
+import { SelectionModel } from '@angular/cdk/collections';
+import { FlatTreeControl } from '@angular/cdk/tree';
+import { Component, HostBinding, Inject, Input, ViewChild, ViewChildren, ViewContainerRef, } from '@angular/core';
+import { MatTreeFlatDataSource, MatTreeFlattener } from '@angular/material/tree';
+import { Subject, takeUntil } from 'rxjs';
+import { FilterExpressionOrderBy } from '../smart-filter-editor/api/model/filterExpressionOrderBy';
+import { SmartTable, SmartTableButtonType, SmartTableHeaderPropertyType, SmartTableInterfaceTypeEnum, SmartTableOrder, SmartTableType, SmarttableComponent, } from '../smart-table/projects';
+import { UiActionButtonType, } from '../view-context/api';
+import { COMPONENT_LIBRARY, ComponentLibrary, } from '../view-context/projects';
+import { GridSelectionMode, GridSelectionType, GridViewDescriptorKindEnum, } from './api/grid-api';
+import { TableLayoutDefinerComponent } from './components/table-layout-definer/table-layout-definer.component';
+import { GridUiActionType, SmartGridDataLayout, SmartGridType, SmartLayoutDef, } from './models/model';
+import { SmartGridService } from './smart-grid.service';
+import { FilterExpressionOrderByOrderEnum } from '../smart-filter/projects';
+import { SmartGridToolbarActionsUtil } from './smart-grid-toolbar-util';
+import { ExpandedRowRendererComponent } from './components/generic-component/expanded-row-renderer.component';
+import { SmartDatePipe, SmartDateTimePipe, SmartTimePipe } from '../shared/smarttable.date-pipe';
+import * as i0 from "@angular/core";
+import * as i1 from "./smart-grid.service";
+import * as i2 from "../component-factory-service/projects";
+import * as i3 from "@angular/material/dialog";
+import * as i4 from "../view-context/projects";
+import * as i5 from "../shared/smarttable.date-pipe";
+import * as i6 from "@angular/common";
+import * as i7 from "../smart-icon/smart-icon/smart-icon.component";
+import * as i8 from "@angular/material/icon";
+import * as i9 from "@angular/material/button";
+import * as i10 from "@angular/material/paginator";
+import * as i11 from "@angular/material/tree";
+import * as i12 from "@angular/material/checkbox";
+import * as i13 from "../smart-expandable-section/expandable-section.component";
+import * as i14 from "../view-context/smart-ui-action/ui-action-toolbar.component";
+import * as i15 from "../smart-form/widgets/directives/comparable-multiselect.directive";
+import * as i16 from "primeng/table";
+import * as i17 from "primeng/api";
+import * as i18 from "primeng/button";
+import * as i19 from "primeng/menu";
+import * as i20 from "primeng/tooltip";
+import * as i21 from "primeng/paginator";
+import * as i22 from "@angular/forms";
+import * as i23 from "primeng/multiselect";
+import * as i24 from "./components/smart-grid-card/smart-grid-card.component";
+import * as i25 from "./components/generic-component/expanded-row-renderer.component";
+export class SmartGridComponent {
+    get testId() {
+        return this.smartGrid?.gridModel?.identifier ?? null;
+    }
+    constructor(service, cfService, dialog, injector, uiActionDescriptorService, smartDatePipe, smartDateTimePipe, smartTimePipe, compLib, gridMenuIcon) {
+        this.service = service;
+        this.cfService = cfService;
+        this.dialog = dialog;
+        this.injector = injector;
+        this.uiActionDescriptorService = uiActionDescriptorService;
+        this.smartDatePipe = smartDatePipe;
+        this.smartDateTimePipe = smartDateTimePipe;
+        this.smartTimePipe = smartTimePipe;
+        this.compLib = compLib;
+        this.gridMenuIcon = gridMenuIcon;
+        // private readonly defaultPageSize: number = 10;
+        this.defaultPageSizeOptions = [5, 10, 25, 50];
+        this.componentLibrary = ComponentLibrary;
+        this._destroy$ = new Subject();
+        this.dev = false;
+        this.defaultActionToolbarId = SmartGridToolbarActionsUtil.defaultActionToolbarId;
+        this.expandedRows = {};
+        this.selectedRows = [];
+        this.pageSizeOptions = this.defaultPageSizeOptions;
+        this.selectionChanges = new Subject();
+        this.uiActionDescriptors = new Map();
+        this.cellToActionMap = {};
+        this.afterViewInitExecuted = false;
+        this.isBlocked = true;
+        this.getLevel = (node) => node.level ?? 0;
+        this.isExpandable = (node) => (node.children && node.children.length > 0 ? true : false);
+        this.getChildren = (node) => {
+            if (node.children) {
+                let rows = this.smartGrid?.gridModel.page.rows?.filter((row) => node.children?.some((child) => child === row.id));
+                if (rows) {
+                    return rows;
+                }
+            }
+            return [];
+        };
+        this.hasChild = (_, _nodeData) => this.isExpandable(_nodeData);
+        this.transformer = (row, level) => {
+            row.level = level;
+            return row;
+        };
+        //PRIMENG
+        this.columns = [];
+        this.service.gridModelChanged.subscribe(() => {
+            // called after every service call (load, save, refresh, etc.)
+            this.smartGrid.gridModel = this.service.gridModel;
+            this.render();
+            //Refresh expanded sections data
+            if (this.smartGrid.expandable) {
+                this.expandedRowsComps.forEach((rowComp) => rowComp.refreshRowData());
+            }
+        });
+    }
+    ngOnChanges(changes) {
+        if (changes['smartGrid']) {
+            this.smartGrid = changes['smartGrid'].currentValue;
+            this.service.paginator = this.smartGrid?.paginator;
+            this.setupToolbar();
+        }
+        if (changes['uuid']) {
+            if (changes['uuid'] && this.uuid === changes['uuid'].currentValue) {
+                this.expandedRows = {};
+            }
+            this.uuid = changes['uuid'].currentValue;
+        }
+        if (this.afterViewInitExecuted && this.uuid && this.smartGrid) {
+            this.refresh();
+        }
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    ngAfterViewInit() {
+        if (this.uuid && this.smartGrid) {
+            this.refresh();
+        }
+        this.afterViewInitExecuted = true;
+    }
+    /**
+     *
+     * @returns the selected rows of the table
+     */
+    getSelectedRows() {
+        if (!this.smartTable.selection)
+            throw new Error();
+        return this.smartTable.selection;
+    }
+    /**
+     * This method sends a GET request to the generic GridAPI and refreshes the presented
+     * grid with the newest one.
+     */
+    async refresh() {
+        this.setupToolbar();
+        // will cause this.service.gridModelChanged to fire
+        if (this.uuid) {
+            await this.service.load(this.uuid, this.smartGrid.gridIdentifier);
+        }
+    }
+    getStyle(row) {
+        if (row && row.style) {
+            let style = row.style;
+            let classesToAdd = [];
+            if (style.classesToAdd) {
+                style.classesToAdd.forEach((cl) => classesToAdd.push(cl));
+            }
+            if (!style.classesToRemove) {
+                return classesToAdd;
+            }
+            return classesToAdd.filter((cls) => !style.classesToRemove.includes(cls));
+        }
+        return [];
+    }
+    setupToolbar() {
+        // check if toolbar is available _and_ need set up
+        if (this.toolbar && this.smartGrid) {
+            let toolbarId = this.smartGrid?.gridIdentifier + '_toolbar';
+            if (toolbarId !== this.toolbar.id) {
+                this.toolbar.id = toolbarId;
+            }
+        }
+        if (this._headerToolbar && this.smartGrid) {
+            let headerToolbarId = this.smartGrid?.gridIdentifier + '_headerToolbar';
+            if (headerToolbarId !== this._headerToolbar.id) {
+                this._headerToolbar.id = headerToolbarId;
+            }
+        }
+    }
+    get headerToolbar() {
+        if (this.compLib === ComponentLibrary.PRIMENG) {
+            return this._headerToolbar;
+        }
+        else {
+            return this.componentRefTable?.instance.componentRefTable?.instance.headerToolbar;
+        }
+    }
+    async render() {
+        const gridModel = this.smartGrid?.gridModel;
+        if (gridModel) {
+            this.length = gridModel.totalRowCount;
+            this.pageSize = gridModel.pageSize;
+            this.pageIndex = gridModel.pageIndex ?? 0;
+            if (gridModel.pageSizeOptions && gridModel.pageSizeOptions.length > 0) {
+                this.pageSizeOptions = gridModel.pageSizeOptions;
+            }
+            else {
+                this.pageSizeOptions = this.defaultPageSizeOptions;
+            }
+            if (gridModel?.view?.descriptor?.showEditColumns) {
+                this.smartGrid.showEditColumns = gridModel?.view?.descriptor?.showEditColumns;
+            }
+            if (gridModel?.view?.descriptor?.columns) {
+                this.columnMetaByName = new Map(gridModel?.view?.descriptor?.columns.map((col) => [col.propertyName, col]));
+            }
+            else {
+                this.columnMetaByName = undefined;
+            }
+            let kind = gridModel?.view?.descriptor?.kind;
+            if (kind) {
+                let layoutDef;
+                if (kind === GridViewDescriptorKindEnum.TABLE) {
+                    layoutDef = SmartLayoutDef.TABLE;
+                }
+                else if (kind === GridViewDescriptorKindEnum.TREE) {
+                    layoutDef = SmartLayoutDef.TREE;
+                }
+                else if (kind === GridViewDescriptorKindEnum.CARDS) {
+                    layoutDef = SmartLayoutDef.CARD;
+                }
+                if (layoutDef) {
+                    this.smartGrid.layoutDef = layoutDef;
+                }
+            }
+            if (gridModel?.paginator === true || gridModel?.paginator === false) {
+                this.smartGrid.paginator = gridModel.paginator;
+                this.service.paginator = this.smartGrid.paginator;
+            }
+        }
+        else {
+            console.error('GridModel is undefined in component!');
+        }
+        if (!this.smartGrid.layoutDef) {
+            // fallback, default TABLE
+            this.smartGrid.layoutDef = SmartLayoutDef.TABLE;
+        }
+        if (this.smartGrid.layoutDef === SmartLayoutDef.TABLE) {
+            this.renderTable();
+        }
+        else if (this.smartGrid.layoutDef === SmartLayoutDef.EXPANDABLE) {
+            this.renderExpandableSections();
+        }
+        else if (this.smartGrid.layoutDef === SmartLayoutDef.CARD) {
+            this.renderCards();
+        }
+        else if (this.smartGrid.layoutDef === SmartLayoutDef.TREE) {
+            this.renderTree();
+        }
+        this.isBlocked = false;
+    }
+    clearTable() {
+        this.vcRefTable?.clear();
+        this.componentRefTable = undefined;
+    }
+    async renderTable() {
+        this.clearTree();
+        if (this.compLib === this.componentLibrary.PRIMENG) {
+            this.pageIndex = this.smartGrid?.gridModel.pageSize * this.smartGrid?.gridModel.pageIndex;
+            this.columns = [];
+            this.smartGrid?.gridModel.view?.orderedColumnNames.map((orderedCol) => {
+                this.smartGrid?.gridModel.view?.descriptor?.columns.map((colum) => {
+                    if (orderedCol === colum.propertyName) {
+                        this.columns.push(colum);
+                    }
+                });
+            });
+        }
+        let tableRow = this.smartGrid.gridModel.page.rows.map((item) => {
+            this.createCellToActionMap();
+            return item;
+        });
+        if (!tableRow.length) {
+            let placeHolderRow = {};
+            this.smartGrid.gridModel.view?.descriptor?.columns.map((meta) => {
+                placeHolderRow[meta.propertyName] = undefined;
+            });
+            this.smartGrid.gridModel.page.rows = [placeHolderRow];
+        }
+        if (this.smartGrid.tableConfig?.tableType) {
+            this.tableType = this.smartGrid.tableConfig.tableType;
+        }
+        else if (this.service.gridModel?.view?.descriptor?.selectionType) {
+            this.tableType =
+                this.service.gridModel.view.descriptor.selectionType === GridSelectionType.CHECKBOX
+                    ? SmartTableType.CHECK_BOX
+                    : SmartTableType.ROW_SELECT;
+        }
+        else {
+            this.tableType = SmartTableType.INHERITED;
+        }
+        if (this.smartGrid.layoutDef === SmartLayoutDef.TABLE) {
+            let tableConfig = {
+                ...this.smartGrid.tableConfig,
+                title: this.smartGrid?.gridModel.title,
+                tableRows: tableRow,
+                tableType: this.tableType,
+                customSmartTableHeaders: await this.constructHeader(),
+                expandable: this.smartGrid.expandable,
+                asyncOnExpand: this.smartGrid.expandable,
+                expandedComponent: this.smartGrid.expandedComponent,
+                type: SmartTableInterfaceTypeEnum.NORMAL,
+                sortable: true,
+                defaultActionCodes: this.smartGrid?.gridModel.defaultRowActions,
+                defaultActions: this.smartGrid?.gridModel.defaultRowActions?.map((code) => {
+                    return {
+                        type: code === '_actionSeparator_'
+                            ? SmartTableButtonType.SEPARATOR
+                            : SmartTableButtonType.NORMAL,
+                        callback: this.execute.bind(this),
+                        code: code,
+                        // label: this.buttonTranslator({ code: code }),
+                        translator: this.buttonTranslator.bind(this),
+                        // args: [
+                        //   {
+                        //     code: code,
+                        //   },
+                        // ],
+                    };
+                }),
+            };
+            if (this.smartGrid?.gridModel.view?.descriptor?.highlightProperty &&
+                this.smartGrid?.gridModel.view?.descriptor?.highlightClass) {
+                tableConfig.highlightClass = this.smartGrid.gridModel.view.descriptor.highlightClass;
+                tableConfig.highlightProperty = this.smartGrid.gridModel.view.descriptor.highlightProperty;
+            }
+            if (this.smartGrid.uiActionService &&
+                this.smartGrid.uiActionDescriptorService &&
+                this.smartGrid.serviceToUse &&
+                this.smartGrid.viewContextService) {
+                tableConfig.onSelection = this.onSelect.bind(this);
+                tableConfig.onAllSelection = this.onSelectAll.bind(this);
+            }
+            // Prepared for simple clicks
+            // if (!tableConfig.onRowClick) {
+            //   tableConfig.onRowClick = this.onClick.bind(this);
+            // }
+            if (!tableConfig.onRowDoubleClick) {
+                tableConfig.onRowDoubleClick = this.onDoubleClick.bind(this);
+            }
+            if (!tableConfig.isRowDisabledPropertyName) {
+                tableConfig.selectablePropertyName = 'selectable';
+            }
+            if (tableConfig.asyncOnExpand) {
+                tableConfig.rowExpander = this;
+            }
+            const selectionMode = this.service.gridModel.view?.descriptor?.selectionMode;
+            if (!tableConfig.selection &&
+                !tableConfig.selectionProperty &&
+                selectionMode !== GridSelectionMode.NONE) {
+                this.isMultiple = selectionMode === GridSelectionMode.MULTIPLE;
+                tableConfig.selectionProperty = 'id';
+                let selectedIds;
+                this.selectedRows = this.service.gridModel.page.rows.filter((gridRow) => gridRow.selected);
+                selectedIds = this.selectedRows.map((gridRow) => gridRow.id);
+                tableConfig.selection = new SelectionModel(this.isMultiple, selectedIds);
+                tableConfig.showCheckboxInHeader =
+                    typeof tableConfig.showCheckboxInHeader !== 'undefined'
+                        ? tableConfig.showCheckboxInHeader // keep if set
+                        : this.isMultiple; //if unset, turn it on for multiple selection
+            }
+            this.smartTable = new SmartTable(tableConfig, this.smartGrid?.gridIdentifier, this.smartGrid?.serviceToUse);
+            if (this.componentRefTable) {
+                this.componentRefTable.instance.updateSmartTable(this.smartTable);
+            }
+            else {
+                this.vcRefTable?.clear();
+                if (!this.vcRefTable) {
+                    return;
+                }
+                this.componentRefTable = this.cfService.createComponent(this.vcRefTable, SmarttableComponent, new Map([['smartTable', this.smartTable]]));
+                let subscription = this.componentRefTable.instance.sortEvent
+                    .pipe(takeUntil(this.componentRefTable.instance._destroy$))
+                    .subscribe((header) => {
+                    header.propertyName = header.propertyName.substring(5);
+                    switch (header.order) {
+                        case undefined:
+                            header.order = SmartTableOrder.ASC;
+                            break;
+                        case SmartTableOrder.ASC:
+                            header.order = SmartTableOrder.DESC;
+                            break;
+                        case SmartTableOrder.DESC:
+                            header.order = undefined;
+                            break;
+                    }
+                    let filter = this.smartGrid.gridModel.view.orderByList.find((filterExpression) => filterExpression.propertyName === header.propertyName);
+                    if (filter && !header.order) {
+                        let index = this.smartGrid.gridModel.view?.orderByList.indexOf(filter);
+                        this.smartGrid.gridModel.view?.orderByList.splice(index, 1);
+                    }
+                    else if (filter) {
+                        filter.order = header.order;
+                    }
+                    else {
+                        this.smartGrid.gridModel.view.orderByList.push({
+                            order: header.order,
+                            propertyName: header.propertyName,
+                        });
+                    }
+                    let gridUpdateData = {
+                        orderByList: this.smartGrid.gridModel.view.orderByList,
+                        orderedColumnNames: this.smartGrid.gridModel.view.orderedColumnNames,
+                    };
+                    this.service.sort(this.smartGrid, gridUpdateData);
+                });
+                this.componentRefTable.instance.smartTable.selection?.changed
+                    .pipe(takeUntil(this.componentRefTable.instance._destroy$))
+                    .subscribe((row) => {
+                    this.selectionChanges.next(row);
+                });
+            }
+        }
+    }
+    expand(rowId) { }
+    async expandAsync(rowIndex) {
+        if (this.smartGrid.gridModel.page.rows) {
+            let row = this.smartGrid.gridModel.page.rows[rowIndex];
+            if (row && row.id) {
+                return await this.service.expand(this.smartGrid, row.id);
+            }
+        }
+        return await this.service.expand(this.smartGrid, rowIndex.toString());
+    }
+    renderExpandableSections() {
+        this.expandableSections = this.smartGrid.gridModel.page.rows.map((item) => {
+            return {
+                title: '',
+                headerComponent: this.smartGrid.headerComponent,
+                headerInputName: this.smartGrid.headerComponentInputName,
+                headerData: item,
+                customComponent: this.smartGrid.expandableComponent,
+                inputName: this.smartGrid.expandableComponentInputName,
+                data: item,
+            };
+        });
+    }
+    renderCards() {
+        if (this.compLib === this.componentLibrary.PRIMENG) {
+            this.pageIndex = this.smartGrid?.gridModel.pageSize * this.smartGrid?.gridModel.pageIndex;
+            this.columns = [];
+            this.smartGrid?.gridModel.view?.orderedColumnNames.map((orderedCol) => {
+                this.smartGrid?.gridModel.view?.descriptor?.columns.map((colum) => {
+                    if (orderedCol === colum.propertyName) {
+                        this.columns.push(colum);
+                    }
+                });
+            });
+        }
+        if (!this.smartGrid.customComponent) {
+            let datalayoutDef = {
+                dataLayout: SmartGridDataLayout.COLUMN,
+                gridLayout: SmartGridDataLayout.COLUMN,
+                type: SmartGridType.CUSTOM,
+            };
+            this.smartGrid.dataLayoutDef = datalayoutDef;
+            this.smartGrid.customComponent = this.injector.get(this.smartGrid.gridIdentifier + 'Card');
+        }
+    }
+    isMultipleSelection() {
+        const selectionMode = this.service.gridModel.view?.descriptor?.selectionMode;
+        return selectionMode === GridSelectionMode.MULTIPLE;
+    }
+    clearTree() {
+        this.treeControl = undefined;
+        this.treeDataSource = undefined;
+        this.treeFlattener = undefined;
+        this.treeChecklistSelection = undefined;
+    }
+    renderTree() {
+        this.clearTable();
+        if (!this.treeDataSource) {
+            this.treeFlattener = new MatTreeFlattener(this.transformer, this.getLevel, this.isExpandable, this.getChildren);
+            this.treeControl = new FlatTreeControl(this.getLevel, this.isExpandable);
+            this.treeDataSource = new MatTreeFlatDataSource(this.treeControl, this.treeFlattener);
+            this.treeChecklistSelection = new SelectionModel(this.isMultipleSelection());
+        }
+        let nodes = this.treeControl?.dataNodes;
+        let expandedNodes;
+        if (nodes) {
+            expandedNodes = nodes
+                .filter((node) => this.treeControl?.isExpandable(node))
+                .filter((node) => this.treeControl?.isExpanded(node))
+                .map((node) => node.id);
+        }
+        else {
+            expandedNodes = [];
+        }
+        this.smartGrid.gridModel.page.rows.forEach((row) => (row.level = undefined));
+        this.treeDataSource.data = this.smartGrid.gridModel.page.rows.filter((row) => !row.parent);
+        this.treeChecklistSelection?.clear();
+        this.treeControl?.dataNodes.forEach((node) => {
+            if (node.selected) {
+                this.treeChecklistSelection?.select(node);
+            }
+        });
+        this.treeControl?.collapseAll();
+        expandedNodes.forEach((rowId) => {
+            let row = this.treeControl?.dataNodes.find((row) => rowId === row.id);
+            if (row) {
+                this.treeControl?.expand(row);
+            }
+        });
+    }
+    getTreeItem(row) {
+        let columns = this.smartGrid?.gridModel.view?.orderedColumnNames;
+        let data = row.data;
+        if (columns && columns.length > 0) {
+            return columns.map((col) => data[col]).join(' ');
+        }
+        return row.id;
+    }
+    /** Toggle the treeNode selection. Select/deselect all the descendants node */
+    treeNodeSelectionToggle(node) {
+        if (!this.treeChecklistSelection) {
+            return;
+        }
+        let selectionBefore = this.treeChecklistSelection.selected.map((row) => row.id);
+        this.treeChecklistSelection.toggle(node);
+        if (this.isMultipleSelection()) {
+            const descendants = this.treeControl.getDescendants(node);
+            this.treeChecklistSelection.isSelected(node)
+                ? this.treeChecklistSelection.select(...descendants)
+                : this.treeChecklistSelection.deselect(...descendants);
+            this.checkAllParentsSelection(node);
+        }
+        let selectionAfter = this.treeChecklistSelection.selected.map((row) => row.id);
+        let selectedIds = selectionAfter.filter((s) => !selectionBefore.includes(s));
+        let unselectedIds = selectionBefore.filter((s) => !selectionAfter.includes(s));
+        this.onSelectRows(selectedIds, unselectedIds);
+    }
+    checkAllParentsSelection(node) {
+        let parent = this.getParentNode(node);
+        while (parent) {
+            this.checkParentNodeSelection(parent);
+            parent = this.getParentNode(parent);
+        }
+    }
+    checkParentNodeSelection(node) {
+        if (!this.treeChecklistSelection) {
+            return;
+        }
+        const nodeSelected = this.treeChecklistSelection.isSelected(node);
+        const descAllSelected = this.descendantsAllSelected(node);
+        if (nodeSelected && !descAllSelected) {
+            this.treeChecklistSelection.deselect(node);
+        }
+        else if (!nodeSelected && descAllSelected) {
+            this.treeChecklistSelection.select(node);
+        }
+    }
+    /* Get the parent node of a node */
+    getParentNode(node) {
+        const currentLevel = this.getLevel(node);
+        if (currentLevel < 1) {
+            return null;
+        }
+        const startIndex = this.treeControl.dataNodes.indexOf(node) - 1;
+        for (let i = startIndex; i >= 0; i--) {
+            const currentNode = this.treeControl.dataNodes[i];
+            if (this.getLevel(currentNode) < currentLevel) {
+                return currentNode;
+            }
+        }
+        return null;
+    }
+    /** Whether all the descendants of the node are selected. */
+    descendantsAllSelected(node) {
+        if (!this.treeControl || !this.treeChecklistSelection) {
+            return false;
+        }
+        const descendants = this.treeControl.getDescendants(node);
+        const descAllSelected = descendants.length > 0 &&
+            descendants.every((child) => {
+                return this.treeChecklistSelection.isSelected(child);
+            });
+        return descAllSelected;
+    }
+    /** Whether part of the descendants are selected */
+    descendantsPartiallySelected(node) {
+        if (!this.treeControl || !this.treeChecklistSelection) {
+            return false;
+        }
+        const descendants = this.treeControl.getDescendants(node);
+        let result = descendants.some((child) => this.treeChecklistSelection.isSelected(child));
+        if (this.isMultipleSelection()) {
+            result = result && !this.descendantsAllSelected(node);
+        }
+        return result;
+    }
+    async constructHeader() {
+        if (this.smartGrid.gridModel.page.rows && this.smartGrid.gridModel.page.rows.length) {
+            await Promise.all(this.smartGrid.gridModel.page.rows.map(async (gridRow) => {
+                let newUiActions = gridRow.actions?.filter((uiAction) => !this.uiActionDescriptors.get(uiAction.code));
+                if (newUiActions) {
+                    await Promise.all(newUiActions.map(async (uiAction) => {
+                        let descriptor = await this.smartGrid.uiActionDescriptorService?.getActionDescriptor(uiAction);
+                        if (!descriptor) {
+                            descriptor = {
+                                title: uiAction.code ?? 'CODE',
+                                color: 'primary',
+                                type: UiActionButtonType.NORMAL,
+                            };
+                        }
+                        this.uiActionDescriptors.set(uiAction.code, structuredClone(descriptor));
+                    }));
+                }
+            }));
+        }
+        let orederedDescColumns = this.smartGrid.gridModel.view.orderedColumnNames.map((propertyName) => this.smartGrid.gridModel.view.descriptor.columns.find((colDescriptor) => colDescriptor.propertyName === propertyName)).flatMap((f) => f ?? []);
+        let header = await Promise.all(orederedDescColumns.map(async (descColumn) => {
+            let customTableHeader = this.smartGrid.tableConfig?.customSmartTableHeaders?.find((header) => header.propertyName === descColumn.propertyName);
+            let filterExpressionOrderByItem = this.smartGrid.gridModel.view?.orderByList?.find((filterExpression) => filterExpression.propertyName === descColumn.propertyName);
+            let order;
+            let orderNumber;
+            if (filterExpressionOrderByItem) {
+                order =
+                    filterExpressionOrderByItem.order === FilterExpressionOrderBy.OrderEnum.Asc
+                        ? SmartTableOrder.ASC
+                        : SmartTableOrder.DESC;
+                if (this.service.gridModel.view.orderByList.length > 1) {
+                    orderNumber = this.service.gridModel.view.orderByList.findIndex((filter) => filter.propertyName === descColumn.propertyName);
+                    orderNumber++;
+                }
+            }
+            const orignalLabel = customTableHeader?.label ?? descColumn.label;
+            let label = '';
+            if (!descColumn.hideLabel) {
+                if (this.smartGrid.translateService) {
+                    label = await this.smartGrid.translateService?.get(orignalLabel).toPromise();
+                }
+                else {
+                    label = orignalLabel;
+                }
+            }
+            let properties = customTableHeader?.properties;
+            if (!properties) {
+                properties = this.getSmartTableProperty(descColumn);
+            }
+            return {
+                ...customTableHeader,
+                label: label,
+                propertyName: 'data.' + descColumn.propertyName,
+                order,
+                orderNumber,
+                properties,
+                style: descColumn.style,
+            };
+        }));
+        let complement = this.smartGrid.tableConfig?.customSmartTableHeaders?.filter((tableHeader) => !header.some((tH) => tH.propertyName.includes(tableHeader.propertyName)));
+        if (complement) {
+            header.push(...complement);
+        }
+        if (this.smartGrid.options?.simpleButtons) {
+            this.smartGrid.options.simpleButtons.forEach((uiActionCode) => {
+                header.push({
+                    label: '',
+                    propertyName: 'simple_buttons',
+                    buttons: [
+                        {
+                            type: SmartTableButtonType.RAISED,
+                            callback: this.execute.bind(this),
+                            // label: this.buttonTranslator({ code: uiActionCode }),
+                            args: [
+                                {
+                                    code: uiActionCode,
+                                },
+                            ],
+                            color: 'primary',
+                            showButtonIf: (row) => row.actions.some((item) => {
+                                return item.code === uiActionCode;
+                            }),
+                        },
+                    ],
+                });
+            });
+        }
+        if (!header.some((header) => header.propertyName === 'my_menu')) {
+            if (this.smartGrid.options?.rowUiActionType === GridUiActionType.POPUP_MENU) {
+                let icon = this.gridMenuIcon ?? 'more_vert';
+                header.push({
+                    label: '',
+                    propertyName: 'my_menu',
+                    buttons: [
+                        {
+                            type: SmartTableButtonType.MENU,
+                            callback: this.execute.bind(this),
+                            icon: icon,
+                            menuItemButtonsPropertyName: 'actions',
+                            translator: this.buttonTranslator.bind(this),
+                            args: [],
+                        },
+                    ],
+                    isSortable: false,
+                });
+            }
+        }
+        return header;
+    }
+    getSmartTableProperty(descColumn) {
+        if (descColumn.typeClass === 'java.time.OffsetDateTime' ||
+            descColumn.typeClass === 'java.time.LocalDateTime') {
+            let dateFormat = descColumn.typeFormat ?? 'yyyy.MM.dd H:mm';
+            return {
+                type: SmartTableHeaderPropertyType.DATETIME,
+                dateFormat,
+            };
+        }
+        else if (descColumn.typeClass === 'java.time.LocalDate') {
+            let dateFormat = descColumn.typeFormat ?? 'yyyy.MM.dd';
+            return {
+                type: SmartTableHeaderPropertyType.DATE,
+                dateFormat,
+            };
+        }
+        else if (descColumn.typeClass === 'java.time.LocalTime') {
+            let dateFormat = descColumn.typeFormat ?? 'H:mm';
+            return {
+                type: SmartTableHeaderPropertyType.TIME,
+                dateFormat,
+            };
+        }
+        else if (descColumn.typeClass === 'java.lang.Boolean') {
+            return {
+                type: SmartTableHeaderPropertyType.CHECKBOX,
+            };
+        }
+        return undefined;
+    }
+    async onChangePage(event) {
+        let offset = event.pageSize * event.pageIndex;
+        let limit = event.pageSize;
+        this.pageIndex = event.pageIndex;
+        await this.service.setPage(this.smartGrid.gridModel.viewUuid, this.smartGrid.gridIdentifier, offset.toString(), limit.toString());
+    }
+    async onPrimeChangePage(event) {
+        let offset = event.first;
+        let limit = event.rows;
+        this.pageIndex = event.first;
+        await this.service.setPage(this.smartGrid.gridModel.viewUuid, this.smartGrid.gridIdentifier, offset.toString(), limit.toString());
+    }
+    async refreshPartialResults() {
+        await this.service.refresh(this.smartGrid.gridModel.viewUuid, this.smartGrid.gridIdentifier);
+    }
+    async execute(args, row, uiAction) {
+        let _uiAction;
+        if (!uiAction) {
+            uiAction = row.actions.filter((action) => action.code === args[0].code)[0];
+        }
+        _uiAction = { ...uiAction };
+        if (_uiAction.disabled) {
+            return;
+        }
+        _uiAction.params = {
+            ...uiAction.params,
+            model: row,
+        };
+        let uiActionModel = {
+            serviceToUse: this.smartGrid.serviceToUse,
+            uiAction: _uiAction,
+        };
+        if (this.smartGrid.options?.uiActionModelCallback) {
+            uiActionModel = this.smartGrid.options.uiActionModelCallback(uiActionModel);
+        }
+        this.smartGrid.uiActionService.execute(_uiAction, uiActionModel, {
+            widgetId: this.smartGrid.gridIdentifier,
+            nodeId: row.id,
+        });
+    }
+    buttonTranslator(uiAction) {
+        let desc = this.uiActionDescriptors.get(uiAction.code);
+        if (!desc) {
+            desc = {
+                title: uiAction.code,
+                type: UiActionButtonType.FLAT,
+                color: 'primary',
+            };
+        }
+        if (uiAction.descriptor) {
+            this.uiActionDescriptorService.mergeActionDescriptorIntoClient(uiAction.descriptor, desc);
+        }
+        return desc;
+    }
+    layoutDef() {
+        return SmartLayoutDef;
+    }
+    onClick(gridRow) {
+        this.handleOnClick(gridRow);
+    }
+    onDoubleClick(gridRow) {
+        this.handleOnClick(gridRow);
+    }
+    handleOnClick(gridRow) {
+        let defaultRowAction;
+        if (this.service.gridModel?.defaultRowActions) {
+            for (let index = 0; index < this.service.gridModel.defaultRowActions.length; index++) {
+                const defaultRowActionCode = this.service.gridModel.defaultRowActions[index];
+                defaultRowAction = gridRow.actions.find((uiAction) => uiAction.code === defaultRowActionCode);
+                if (defaultRowAction) {
+                    this.execute([], gridRow, defaultRowAction);
+                    return;
+                }
+            }
+        }
+    }
+    async onSelect(rowId) {
+        this.isBlocked = true;
+        const row = this.service.gridModel.page.rows?.find((gridRow) => gridRow.id === rowId);
+        const viewContextChange = await this.service.select(this.smartGrid, row);
+        this.smartGrid.viewContextService.handlePerformActionResponse(viewContextChange);
+        this.refresh();
+    }
+    async onSelectAll(selected) {
+        this.isBlocked = true;
+        const viewContextChange = await this.service.selectAll(this.smartGrid, selected);
+        this.smartGrid.viewContextService.handlePerformActionResponse(viewContextChange);
+        this.refresh();
+    }
+    async onSelectRows(selectedIds, unselectedIds) {
+        this.isBlocked = true;
+        let selected = selectedIds.filter((item) => item !== undefined);
+        let unselected = unselectedIds.filter((item) => item !== undefined);
+        const viewContextChange = await this.service.selectRows(this.smartGrid, selected, unselected);
+        this.smartGrid.viewContextService.handlePerformActionResponse(viewContextChange);
+        this.refresh();
+    }
+    async onRowSelect(event) {
+        await this.onSelect(event.data.id);
+    }
+    async onRowUnselect(event) {
+        await this.onSelect(event.data.id);
+    }
+    async onSelectAllRow(event) {
+        await this.onSelectAll(event.checked);
+    }
+    editColumns() {
+        let dialogData = {
+            content: {
+                title: 'Oszlopok testreszabása',
+            },
+            size: {},
+            customComponent: TableLayoutDefinerComponent,
+            customComponentInputs: {
+                config: {
+                    uuid: this.uuid,
+                    identifier: this.smartGrid.gridIdentifier,
+                    view: this.service.gridModel.view,
+                    service: this.service,
+                },
+            },
+        };
+        this.dialog.open(TableLayoutDefinerComponent, { data: dialogData });
+    }
+    onOptionsClick(event, row) {
+        this.menuButtons = [];
+        let menuActions = this.calculateMenuActions(row);
+        menuActions?.map(async (uiAction) => {
+            let desc = await this.uiActionDescriptorService.getActionDescriptor(uiAction);
+            this.menuButtons.push({
+                label: desc?.title ?? uiAction.code,
+                icon: desc?.icon,
+                automationId: uiAction.code,
+                command: () => {
+                    this.execute([], row, uiAction);
+                },
+            });
+        });
+        this.menu.toggle(event);
+    }
+    async gridSort(event) {
+        let orderByList = [];
+        event.multisortmeta?.map((meta, index) => {
+            if (this.previousmultiSortMeta && this.previousmultiSortMeta.length > 0) {
+                this.previousmultiSortMeta.map((order) => {
+                    if (meta.field === order.field && order.order != meta.order) {
+                        switch (order.order) {
+                            case -1:
+                                event.multisortmeta.splice(index, 1);
+                                break;
+                        }
+                    }
+                });
+            }
+            else {
+                this.previousmultiSortMeta = event.multisortmeta;
+            }
+        });
+        event.multisortmeta?.map((meta) => {
+            orderByList.push({
+                propertyName: meta.field,
+                order: meta.order === 1
+                    ? FilterExpressionOrderByOrderEnum.ASC
+                    : meta.order === -1
+                        ? FilterExpressionOrderByOrderEnum.DESC
+                        : undefined,
+            });
+        });
+        await this.service.sort(this.smartGrid, {
+            orderByList: orderByList,
+            orderedColumnNames: this.smartGrid?.gridModel.view?.orderedColumnNames,
+        });
+    }
+    lazyLoad(event) {
+        this.previousmultiSortMeta = [];
+        this.smartGrid?.gridModel.view?.orderByList.map((order) => {
+            this.previousmultiSortMeta?.push({
+                field: order.propertyName,
+                order: order.order === FilterExpressionOrderByOrderEnum.ASC ? 1 : -1,
+            });
+        });
+        event.multiSortMeta = this.previousmultiSortMeta;
+    }
+    async headerChange(event) {
+        let gridUpdateData = {
+            orderByList: this.smartGrid.gridModel.view.orderByList,
+            orderedColumnNames: this.getOrderColumNames(event.value),
+        };
+        await this.service.update(this.uuid, this.smartGrid?.gridIdentifier, gridUpdateData);
+    }
+    async onColOrder(event) {
+        let gridUpdateData = {
+            orderByList: this.smartGrid.gridModel.view.orderByList,
+            orderedColumnNames: this.getOrderColumNames(event.columns),
+        };
+        await this.service.update(this.uuid, this.smartGrid.gridIdentifier, gridUpdateData);
+    }
+    getOrderColumNames(columns) {
+        return columns.map((colum) => {
+            return colum.propertyName;
+        });
+    }
+    getColValue(col, row) {
+        if (row.icons[col]) {
+            return;
+        }
+        let retValue = '';
+        if (col.includes('.')) {
+            let pathArray = col.split('.');
+            let colValue = row.data;
+            pathArray.map((path) => {
+                if (colValue == undefined) {
+                    colValue = row.data[col];
+                    return;
+                }
+                else {
+                    colValue = colValue[path];
+                }
+            });
+            retValue = colValue;
+        }
+        else {
+            retValue = row.data[col];
+        }
+        if (this.columnMetaByName) {
+            let columnMeta = this.columnMetaByName.get(col);
+            if (columnMeta) {
+                let property = this.getSmartTableProperty(columnMeta);
+                switch (property?.type) {
+                    case SmartTableHeaderPropertyType.DATE:
+                        retValue = this.smartDatePipe.transform(retValue, property.dateFormat);
+                        break;
+                    case SmartTableHeaderPropertyType.DATETIME:
+                        retValue = this.smartDateTimePipe.transform(retValue, property.dateFormat);
+                        break;
+                    case SmartTableHeaderPropertyType.TIME:
+                        retValue = this.smartTimePipe.transform(retValue, property.dateFormat);
+                        break;
+                }
+            }
+        }
+        return retValue;
+    }
+    getImageResourceIcons(row, header) {
+        if (row?.icons) {
+            let iconCodes = row?.icons[header];
+            return iconCodes;
+        }
+        return [];
+    }
+    getImageResourceStyle(resource) {
+        return resource.style ? resource.style : {};
+    }
+    getRowColumnAction(row, columnName) {
+        return SmartGridToolbarActionsUtil.getActionModelsFromMap(this.cellToActionMap, row, columnName);
+    }
+    showCellToolbar(row, columnName) {
+        return SmartGridToolbarActionsUtil.showToolbar(row, columnName);
+    }
+    shouldShowOptionsButton(row) {
+        return SmartGridToolbarActionsUtil.showMenu(row, this.smartGrid?.gridModel.view?.orderedColumnNames);
+    }
+    calculateMenuActions(row) {
+        return SmartGridToolbarActionsUtil.calculateMenuActions(row, this.smartGrid?.gridModel.view?.orderedColumnNames);
+    }
+    createCellToActionMap() {
+        if (this.compLib === this.componentLibrary.PRIMENG && this.smartGrid?.gridModel.page.rows) {
+            this.cellToActionMap = SmartGridToolbarActionsUtil.calculateCellToActionMap(this.smartGrid?.gridModel.page.rows, this.smartGrid.serviceToUse, this.smartGrid.gridIdentifier);
+        }
+    }
+    rowTrackByFn(index, row) {
+        return row.id;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartGridComponent, deps: [{ token: i1.SmartGridService }, { token: i2.ComponentFactoryService }, { token: i3.MatDialog }, { token: i0.Injector }, { token: i4.UiActionDescriptorService }, { token: i5.SmartDatePipe }, { token: i5.SmartDateTimePipe }, { token: i5.SmartTimePipe }, { token: COMPONENT_LIBRARY }, { token: 'gridMenuIcon' }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.11", type: SmartGridComponent, selector: "smart-grid", inputs: { smartGrid: "smartGrid", uuid: "uuid", dev: "dev" }, host: { properties: { "attr.data-testid": "this.testId" } }, providers: [SmartGridService, SmartDatePipe, SmartDateTimePipe, SmartTimePipe], viewQueries: [{ propertyName: "vcRefTable", first: true, predicate: ["table"], descendants: true, read: ViewContainerRef }, { propertyName: "toolbar", first: true, predicate: ["toolbar"], descendants: true }, { propertyName: "_headerToolbar", first: true, predicate: ["headerToolbar"], descendants: true }, { propertyName: "menu", first: true, predicate: ["menu"], descendants: true }, { propertyName: "expandedRowsComps", predicate: ExpandedRowRendererComponent, descendants: true }], usesOnChanges: true, ngImport: i0, template: "@if(compLib === componentLibrary.PRIMENG) {\n\n<div *ngIf=\"smartGrid\" class=\"primeSmartGrid-container\">\n  <div class=\"smart-grid-toolbar\">\n    <smart-ui-action-toolbar #toolbar [id]=\"'grid_not_initialized'\"></smart-ui-action-toolbar>\n  </div>\n  <p-table\n    *ngIf=\"!smartGrid.layoutDef || smartGrid.layoutDef === layoutDef().TABLE\"\n    #pTable\n    [value]=\"smartGrid.gridModel.page.rows!\"\n    (onSort)=\"gridSort($event)\"\n    [customSort]=\"true\"\n    [sortMode]=\"'multiple'\"\n    [lazy]=\"true\"\n    (onLazyLoad)=\"lazyLoad($event)\"\n    [reorderableColumns]=\"smartGrid.gridModel.view?.descriptor?.showEditColumns\"\n    [columns]=\"columns\"\n    (onColReorder)=\"onColOrder($event)\"\n    (onRowSelect)=\"onRowSelect($event)\"\n    (onRowUnselect)=\"onRowUnselect($event)\"\n    [selection]=\"selectedRows\"\n    (onHeaderCheckboxToggle)=\"onSelectAllRow($event)\"\n    dataKey=\"id\"\n    [expandedRowKeys]=\"expandedRows\"\n    [rowExpandMode]=\"'multiple'\"\n    [rowTrackBy]=\"rowTrackByFn\"\n  >\n    <ng-template pTemplate=\"caption\">\n      <div class=\"tableCaption\">\n        <div *ngIf=\"smartGrid.gridModel.title\" class=\"captionTitle\">\n          {{ smartGrid.gridModel.title }}\n        </div>\n        <div *ngIf=\"smartGrid.gridModel.view?.descriptor?.showEditColumns\">\n          <p-multiSelect\n            display=\"chip\"\n            [options]=\"smartGrid.gridModel.view?.descriptor?.columns\"\n            optionLabel=\"label\"\n            [(ngModel)]=\"columns\"\n            selectedItemsLabel=\"{0} columns selected\"\n            [style]=\"{ 'min-width': '200px' }\"\n            placeholder=\"Choose Columns\"\n            (onChange)=\"headerChange($event)\"\n          />\n        </div>\n      </div>\n    </ng-template>\n    <ng-template pTemplate=\"header\">\n      <tr>\n        @if (smartGrid.gridModel.view?.descriptor?.showEditColumns) {\n        <th\n          *ngIf=\"isMultiple && (tableType === 'checkbox' || tableType === 'CheckBox')\"\n          style=\"width: 4rem\"\n        >\n          <p-tableHeaderCheckbox />\n        </th>\n        <th\n          *ngIf=\"!isMultiple && (tableType === 'checkbox' || tableType === 'CheckBox')\"\n          style=\"width: 4rem\"\n        ></th>\n        <th\n          [pSortableColumn]=\"col.propertyName\"\n          *ngFor=\"let col of columns\"\n          pReorderableColumn\n          [attr.data-testid]=\"col.propertyName\"\n        >\n          <p-sortIcon [field]=\"col.propertyName\" />\n          {{ col.label }}\n        </th>\n        } @else {\n        <th\n          *ngIf=\"isMultiple && (tableType === 'checkbox' || tableType === 'CheckBox')\"\n          style=\"width: 4rem\"\n        >\n          <p-tableHeaderCheckbox />\n        </th>\n        <th\n          *ngIf=\"!isMultiple && (tableType === 'checkbox' || tableType === 'CheckBox')\"\n          style=\"width: 4rem\"\n        ></th>\n        <th\n          [pSortableColumn]=\"col.propertyName\"\n          *ngFor=\"let col of columns\"\n          [attr.data-testid]=\"col.propertyName\"\n        >\n          <p-sortIcon [field]=\"col.propertyName\" />\n          {{ col.label }}\n        </th>\n        }\n\n        <th>\n          <smart-ui-action-toolbar\n            class=\"headerToolbar\"\n            #headerToolbar\n            [id]=\"'header_not_initialized'\"\n          ></smart-ui-action-toolbar>\n        </th>\n        <th *ngIf=\"smartGrid.expandable\"> </th>\n      </tr>\n    </ng-template>\n    <ng-template pTemplate=\"body\" let-row let-expanded=\"expanded\">\n      <tr\n        [ngClass]=\"getStyle(row)\"\n        [class.rowExpanded]=\"expanded\"\n        (dblclick)=\"onDoubleClick(row)\"\n        *ngIf=\"row && row.data\"\n        [attr.data-testid]=\"row.id ?? null\"\n      >\n        <td *ngIf=\"isMultiple && (tableType === 'checkbox' || tableType === 'CheckBox')\">\n          <p-tableCheckbox *ngIf=\"row.selectable != false\" [value]=\"row\" />\n        </td>\n        <td *ngIf=\"!isMultiple && (tableType === 'checkbox' || tableType === 'CheckBox')\">\n          <p-tableRadioButton [value]=\"row\" />\n        </td>\n        <td *ngFor=\"let col of smartGrid?.gridModel?.view?.orderedColumnNames\">\n          <div *ngIf=\"row.icons[col]\">\n            <div class=\"smart-table-icon-container\">\n              <div *ngFor=\"let ir of getImageResourceIcons(row, col)\">\n                <smart-icon [imageResource]=\"ir\"> </smart-icon>\n              </div>\n            </div>\n          </div>\n          <ng-container *ngIf=\"showCellToolbar(row, col)\">\n            <smart-ui-action-toolbar\n              [uiActionModels]=\"getRowColumnAction(row, col)\"\n            ></smart-ui-action-toolbar>\n          </ng-container>\n\n          <div *ngIf=\"!row.icons[col]\" [innerHtml]=\"getColValue(col, row)\"> </div>\n        </td>\n        <td>\n          <div class=\"menu-button\">\n            @if(showCellToolbar(row, defaultActionToolbarId)){\n            <smart-ui-action-toolbar\n              [uiActionModels]=\"getRowColumnAction(row, defaultActionToolbarId)\"\n            ></smart-ui-action-toolbar>\n            }\n            <p-button\n              [rounded]=\"true\"\n              [text]=\"true\"\n              *ngIf=\"shouldShowOptionsButton(row)\"\n              (onClick)=\"onOptionsClick($event, row)\"\n            >\n              <smart-icon icon=\"ellipsis-v\"></smart-icon>\n            </p-button>\n          </div>\n        </td>\n        <td *ngIf=\"smartGrid.expandable\">\n          <p-button\n            type=\"button\"\n            pRipple\n            [pRowToggler]=\"row\"\n            [text]=\"true\"\n            severity=\"secondary\"\n            [rounded]=\"true\"\n            [icon]=\"expanded ? 'pi pi-chevron-up' : 'pi pi-chevron-down'\"\n          />\n        </td>\n      </tr>\n    </ng-template>\n    @if(smartGrid.expandable){\n    <ng-template pTemplate=\"rowexpansion\" let-row>\n      <tr>\n        <td colspan=\"100%\">\n          <lib-expanded-row-renderer-component\n            [rowId]=\"row.id\"\n            [rowExpander]=\"this\"\n            [expandedComponent]=\"smartGrid.expandedComponent\"\n            [smartGrid]=\"this.smartGrid\"\n          ></lib-expanded-row-renderer-component>\n        </td>\n      </tr>\n    </ng-template>\n    }\n  </p-table>\n  <div\n    *ngIf=\"smartGrid.layoutDef === layoutDef().CARD && smartGrid.dataLayoutDef\"\n    class=\"cards-container\"\n    [ngStyle]=\"{\n      'grid-template-columns':\n        smartGrid.numberOfColumn !== undefined\n          ? 'repeat(' + smartGrid.numberOfColumn + ', 1fr)'\n          : ''\n    }\"\n  >\n    <app-smart-grid-card\n      class=\"smartGrid-card-container\"\n      *ngFor=\"let task of smartGrid.gridModel.page.rows\"\n      [item]=\"task\"\n      [smartGrid]=\"smartGrid\"\n      [onSelect]=\"onSelect.bind(this)\"\n    ></app-smart-grid-card>\n  </div>\n<div *ngIf=\"smartGrid.paginator\" class=\"paginator-row\">\n  <div class=\"paginator-wrap\">\n    <p-paginator\n      [first]=\"pageIndex!\"\n      [totalRecords]=\"length!\"\n      [rows]=\"pageSize\"\n      [rowsPerPageOptions]=\"pageSizeOptions\"\n      currentPageReportTemplate=\"{first} - {last} / {totalRecords}\"\n      (onPageChange)=\"onPrimeChangePage($event)\"\n      [showCurrentPageReport]=\"true\"\n      dropdownAppendTo=\"body\"\n    ></p-paginator>\n  </div>\n\n  <button\n    pButton\n    type=\"button\"\n    icon=\"pi pi-refresh\"\n    class=\"p-button-text\"\n    pTooltip=\"Friss\u00EDt\u00E9s\"\n    (click)=\"refreshPartialResults()\"\n    *ngIf=\"smartGrid.gridModel?.refreshEnabled\"\n  ></button>\n</div>\n  <p-menu #menu [model]=\"menuButtons\" [popup]=\"true\" appendTo=\"body\"> </p-menu>\n</div>\n}@else {\n<div *ngIf=\"smartGrid\" class=\"smartGrid-container\">\n  <div class=\"smart-grid-toolbar\">\n    <smart-ui-action-toolbar #toolbar [id]=\"'grid_not_initialized'\"></smart-ui-action-toolbar>\n    <button\n      (click)=\"editColumns()\"\n      mat-mini-fab\n      color=\"text-primary\"\n      *ngIf=\"smartGrid.showEditColumns\"\n    >\n      <mat-icon aria-hidden=\"false\" aria-label=\"Columns\" class=\"smart-grid-edit-icon\"\n        >view_columns</mat-icon\n      >\n    </button>\n  </div>\n  <!-- <div [ngClass]=\"isBlocked ? 'blocked' : ''\"></div> -->\n  <div class=\"smartGridContent\">\n    <div>\n      <div *ngIf=\"smartGrid.showResultCount\">\n        <div class=\"smartGrid-data-number\">\n          {{ smartGrid.gridModel.totalRowCount }}\n        </div>\n      </div>\n    </div>\n\n    <div class=\"smart-grid-table-container\">\n      <ng-template #table></ng-template>\n    </div>\n\n    <div *ngIf=\"smartGrid.layoutDef === layoutDef().EXPANDABLE\">\n      <smart-expandable-section\n        #gridExpandableSection\n        *ngFor=\"let expandableSection of expandableSections\"\n        [data]=\"expandableSection\"\n      ></smart-expandable-section>\n    </div>\n    <div\n      *ngIf=\"smartGrid.layoutDef === layoutDef().CARD && smartGrid.dataLayoutDef\"\n      class=\"cards-container\"\n      [ngStyle]=\"{\n        'grid-template-columns':\n          smartGrid.numberOfColumn !== undefined\n            ? 'repeat(' + smartGrid.numberOfColumn + ', 1fr)'\n            : ''\n      }\"\n    >\n      <app-smart-grid-card\n        class=\"smartGrid-card-container\"\n        *ngFor=\"let task of smartGrid.gridModel.page.rows\"\n        [item]=\"task\"\n        [smartGrid]=\"smartGrid\"\n        [onSelect]=\"onSelect.bind(this)\"\n      ></app-smart-grid-card>\n    </div>\n    <div\n      *ngIf=\"smartGrid.layoutDef === layoutDef().TREE && treeControl\"\n      class=\"tree-container\"\n      [ngStyle]=\"{\n        'grid-template-columns':\n          smartGrid.numberOfColumn !== undefined\n            ? 'repeat(' + smartGrid.numberOfColumn + ', 1fr)'\n            : ''\n      }\"\n    >\n      <mat-tree [dataSource]=\"treeDataSource!\" [treeControl]=\"treeControl!\">\n        <mat-tree-node\n          *matTreeNodeDef=\"let node\"\n          matTreeNodeToggle\n          matTreeNodePadding\n          matTreeNodePaddingIndent=\"24\"\n        >\n          <button mat-icon-button disabled class=\"tree-button\"></button>\n          <mat-checkbox\n            class=\"checklist-leaf-node\"\n            [checked]=\"treeChecklistSelection?.isSelected(node)\"\n            (change)=\"treeNodeSelectionToggle(node)\"\n            >{{ getTreeItem(node) }}</mat-checkbox\n          >\n        </mat-tree-node>\n\n        <mat-tree-node\n          *matTreeNodeDef=\"let node; when: hasChild\"\n          matTreeNodePadding\n          matTreeNodePaddingIndent=\"24\"\n        >\n          <button\n            mat-icon-button\n            matTreeNodeToggle\n            class=\"tree-button\"\n            [attr.aria-label]=\"'Toggle ' + node.item\"\n          >\n            <mat-icon class=\"mat-icon-rtl-mirror\">\n              {{ treeControl!.isExpanded(node) ? 'expand_more' : 'chevron_right' }}\n            </mat-icon>\n          </button>\n          <mat-checkbox\n            [checked]=\"treeChecklistSelection?.isSelected(node)\"\n            [indeterminate]=\"descendantsPartiallySelected(node)\"\n            (change)=\"treeNodeSelectionToggle(node)\"\n            >{{ getTreeItem(node) }}</mat-checkbox\n          >\n        </mat-tree-node>\n      </mat-tree>\n    </div>\n  </div>\n<div *ngIf=\"smartGrid.paginator\" class=\"paginator-row-material\">\n  <button\n   pButton\n   type=\"button\"\n   icon=\"pi pi-refresh\"\n   class=\"p-button-text\"\n   pTooltip=\"Friss\u00EDt\u00E9s\"\n   (click)=\"refreshPartialResults()\"\n   *ngIf=\"smartGrid.gridModel?.refreshEnabled\"\n ></button>\n  <mat-paginator\n    *ngIf=\"smartGrid.paginator && !treeControl\"\n    #paginator\n    [length]=\"length\"\n    [pageIndex]=\"pageIndex\"\n    [pageSize]=\"pageSize\"\n    [pageSizeOptions]=\"pageSizeOptions\"\n    (page)=\"onChangePage($event)\"\n  ></mat-paginator>\n  </div>\n</div>\n}\n", styles: [".smartGrid-container{position:relative;padding:1.5rem;display:flex;flex-direction:column;gap:1rem}.primeSmartGrid-container{display:flex;flex-direction:column;gap:1rem}.smartGrid-data-number{padding-bottom:1rem}.smart-table-icon-container{display:flex;flex-direction:row;justify-content:space-between;white-space:initial}.cards-container{display:grid;gap:1rem;padding:1rem}.smartGrid-card-container{height:auto;border:1px solid black;border-radius:8px}.smartGrid-container ::ng-deep .mat-form-field-appearance-legacy .mat-form-field-underline{bottom:0}.smartGridContent{width:100%;flex:1;overflow:auto}.blocked{position:absolute;width:calc(100% - 3rem);height:calc(100% - 3rem);z-index:110;background-color:#0003}.smart-grid-table-container{display:flex;flex-direction:column;gap:1rem}.smart-grid-toolbar{display:flex;flex-direction:row;justify-content:flex-end;align-items:center}.smart-grid-toolbar smart-ui-action-toolbar{width:100%}.smart-grid-edit-icon{color:var(--light-gray)}.tree-button{width:24px!important;height:24px!important}.menu-button{display:flex;flex-direction:row;justify-content:flex-end;text-align:-webkit-right;align-items:center}.headerToolbar ::ng-deep .uiActionButtonsContainer{justify-content:flex-end}.tableCaption{display:flex;flex-direction:row;justify-content:space-between}.tableCaption:has(*){padding:.5rem;border-top:1px solid #e9ecef;border-bottom:1px solid #e9ecef}:host ::ng-deep .p-datatable .p-datatable-thead>tr>th,:host ::ng-deep .p-datatable .p-datatable-header{padding:.5rem}.captionTitle{font-size:1.5rem;align-content:center}:host ::ng-deep .p-datatable-header:has(.tableCaption){padding:0;border:unset}.paginator-row{display:flex;align-items:center;align-self:center;gap:.25rem}.paginator-row-material{display:flex;align-items:center;align-self:flex-end;gap:.25rem}.paginator-wrap{flex:0 0 auto;min-width:0}:host ::ng-deep .paginator-wrap .p-paginator{width:auto}\n"], dependencies: [{ kind: "directive", type: i6.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i6.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i6.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "component", type: i7.SmartIconComponent, selector: "smart-icon", inputs: ["icon", "color", "imageResource"] }, { kind: "component", type: i8.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i9.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "component", type: i9.MatMiniFabButton, selector: "button[mat-mini-fab]", exportAs: ["matButton"] }, { kind: "component", type: i10.MatPaginator, selector: "mat-paginator", inputs: ["color", "pageIndex", "length", "pageSize", "pageSizeOptions", "hidePageSize", "showFirstLastButtons", "selectConfig", "disabled"], outputs: ["page"], exportAs: ["matPaginator"] }, { kind: "directive", type: i11.MatTreeNodeDef, selector: "[matTreeNodeDef]", inputs: ["matTreeNodeDefWhen", "matTreeNode"] }, { kind: "directive", type: i11.MatTreeNodePadding, selector: "[matTreeNodePadding]", inputs: ["matTreeNodePadding", "matTreeNodePaddingIndent"] }, { kind: "directive", type: i11.MatTreeNodeToggle, selector: "[matTreeNodeToggle]", inputs: ["matTreeNodeToggleRecursive"] }, { kind: "component", type: i11.MatTree, selector: "mat-tree", exportAs: ["matTree"] }, { kind: "directive", type: i11.MatTreeNode, selector: "mat-tree-node", inputs: ["disabled", "tabIndex"], exportAs: ["matTreeNode"] }, { kind: "component", type: i12.MatCheckbox, selector: "mat-checkbox", inputs: ["aria-label", "aria-labelledby", "aria-describedby", "id", "required", "labelPosition", "name", "value", "disableRipple", "tabIndex", "color", "checked", "disabled", "indeterminate"], outputs: ["change", "indeterminateChange"], exportAs: ["matCheckbox"] }, { kind: "component", type: i13.ExpandableSectionComponent, selector: "smart-expandable-section", inputs: ["data", "index"] }, { kind: "component", type: i14.UiActionToolbarComponent, selector: "smart-ui-action-toolbar", inputs: ["uiActionModels", "uiActionDescriptorService", "id", "scrollOnWrap", "toolbarPropertes"] }, { kind: "directive", type: i15.ComparableMultiselectDirective, selector: "p-multiSelect", inputs: ["compareWith"] }, { kind: "component", type: i16.Table, selector: "p-table", inputs: ["frozenColumns", "frozenValue", "style", "styleClass", "tableStyle", "tableStyleClass", "paginator", "pageLinks", "rowsPerPageOptions", "alwaysShowPaginator", "paginatorPosition", "paginatorStyleClass", "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", "paginatorLocale", "value", "columns", "first", "rows", "totalRecords", "sortField", "sortOrder", "multiSortMeta", "selection", "selectAll", "virtualRowHeight"], outputs: ["contextMenuSelectionChange", "selectAllChange", "selectionChange", "onRowSelect", "onRowUnselect", "onPage", "onSort", "onFilter", "onLazyLoad", "onRowExpand", "onRowCollapse", "onContextMenuSelect", "onColResize", "onColReorder", "onRowReorder", "onEditInit", "onEditComplete", "onEditCancel", "onHeaderCheckboxToggle", "sortFunction", "firstChange", "rowsChange", "onStateSave", "onStateRestore"] }, { kind: "directive", type: i17.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "directive", type: i16.SortableColumn, selector: "[pSortableColumn]", inputs: ["pSortableColumn", "pSortableColumnDisabled"] }, { kind: "directive", type: i16.RowToggler, selector: "[pRowToggler]", inputs: ["pRowToggler", "pRowTogglerDisabled"] }, { kind: "directive", type: i16.ReorderableColumn, selector: "[pReorderableColumn]", inputs: ["pReorderableColumnDisabled"] }, { kind: "component", type: i16.SortIcon, selector: "p-sortIcon", inputs: ["field"] }, { kind: "component", type: i16.TableRadioButton, selector: "p-tableRadioButton", inputs: ["disabled", "value", "index", "inputId", "name", "ariaLabel"] }, { kind: "component", type: i16.TableCheckbox, selector: "p-tableCheckbox", inputs: ["disabled", "value", "index", "inputId", "name", "required", "ariaLabel"] }, { kind: "component", type: i16.TableHeaderCheckbox, selector: "p-tableHeaderCheckbox", inputs: ["disabled", "inputId", "name", "ariaLabel"] }, { kind: "directive", type: i18.ButtonDirective, selector: "[pButton]", inputs: ["iconPos", "loadingIcon", "label", "icon", "loading", "severity", "raised", "rounded", "text", "outlined", "size", "plain"] }, { kind: "component", type: i18.Button, selector: "p-button", inputs: ["type", "iconPos", "icon", "badge", "label", "disabled", "loading", "loadingIcon", "raised", "rounded", "text", "plain", "severity", "outlined", "link", "tabindex", "size", "style", "styleClass", "badgeClass", "ariaLabel", "autofocus"], outputs: ["onClick", "onFocus", "onBlur"] }, { kind: "component", type: i19.Menu, selector: "p-menu", inputs: ["model", "popup", "style", "styleClass", "appendTo", "autoZIndex", "baseZIndex", "showTransitionOptions", "hideTransitionOptions", "ariaLabel", "ariaLabelledBy", "id", "tabindex"], outputs: ["onShow", "onHide", "onBlur", "onFocus"] }, { kind: "directive", type: i20.Tooltip, selector: "[pTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "autoHide", "fitContent", "hideOnEscape", "pTooltip", "tooltipDisabled", "tooltipOptions"] }, { kind: "component", type: i21.Paginator, selector: "p-paginator", inputs: ["pageLinkSize", "style", "styleClass", "alwaysShow", "dropdownAppendTo", "templateLeft", "templateRight", "appendTo", "dropdownScrollHeight", "currentPageReportTemplate", "showCurrentPageReport", "showFirstLastIcon", "totalRecords", "rows", "rowsPerPageOptions", "showJumpToPageDropdown", "showJumpToPageInput", "jumpToPageItemTemplate", "showPageLinks", "locale", "dropdownItemTemplate", "first"], outputs: ["onPageChange"] }, { kind: "directive", type: i22.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i22.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i23.MultiSelect, selector: "p-multiSelect", inputs: ["id", "ariaLabel", "style", "styleClass", "panelStyle", "panelStyleClass", "inputId", "disabled", "readonly", "group", "filter", "filterPlaceHolder", "filterLocale", "overlayVisible", "tabindex", "variant", "appendTo", "dataKey", "name", "ariaLabelledBy", "displaySelectedLabel", "maxSelectedLabels", "selectionLimit", "selectedItemsLabel", "showToggleAll", "emptyFilterMessage", "emptyMessage", "resetFilterOnHide", "dropdownIcon", "optionLabel", "optionValue", "optionDisabled", "optionGroupLabel", "optionGroupChildren", "showHeader", "filterBy", "scrollHeight", "lazy", "virtualScroll", "loading", "virtualScrollItemSize", "loadingIcon", "virtualScrollOptions", "overlayOptions", "ariaFilterLabel", "filterMatchMode", "tooltip", "tooltipPosition", "tooltipPositionStyle", "tooltipStyleClass", "autofocusFilter", "display", "autocomplete", "showClear", "autofocus", "autoZIndex", "baseZIndex", "showTransitionOptions", "hideTransitionOptions", "defaultLabel", "placeholder", "options", "filterValue", "itemSize", "selectAll", "focusOnHover", "filterFields", "selectOnFocus", "autoOptionFocus"], outputs: ["onChange", "onFilter", "onFocus", "onBlur", "onClick", "onClear", "onPanelShow", "onPanelHide", "onLazyLoad", "onRemove", "onSelectAllChange"] }, { kind: "component", type: i24.SmartGridCardComponent, selector: "app-smart-grid-card", inputs: ["item", "smartGrid", "onSelect"] }, { kind: "component", type: i25.ExpandedRowRendererComponent, selector: "lib-expanded-row-renderer-component", inputs: ["rowId", "rowExpander", "expandedComponent", "smartGrid"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartGridComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'smart-grid', providers: [SmartGridService, SmartDatePipe, SmartDateTimePipe, SmartTimePipe], template: "@if(compLib === componentLibrary.PRIMENG) {\n\n<div *ngIf=\"smartGrid\" class=\"primeSmartGrid-container\">\n  <div class=\"smart-grid-toolbar\">\n    <smart-ui-action-toolbar #toolbar [id]=\"'grid_not_initialized'\"></smart-ui-action-toolbar>\n  </div>\n  <p-table\n    *ngIf=\"!smartGrid.layoutDef || smartGrid.layoutDef === layoutDef().TABLE\"\n    #pTable\n    [value]=\"smartGrid.gridModel.page.rows!\"\n    (onSort)=\"gridSort($event)\"\n    [customSort]=\"true\"\n    [sortMode]=\"'multiple'\"\n    [lazy]=\"true\"\n    (onLazyLoad)=\"lazyLoad($event)\"\n    [reorderableColumns]=\"smartGrid.gridModel.view?.descriptor?.showEditColumns\"\n    [columns]=\"columns\"\n    (onColReorder)=\"onColOrder($event)\"\n    (onRowSelect)=\"onRowSelect($event)\"\n    (onRowUnselect)=\"onRowUnselect($event)\"\n    [selection]=\"selectedRows\"\n    (onHeaderCheckboxToggle)=\"onSelectAllRow($event)\"\n    dataKey=\"id\"\n    [expandedRowKeys]=\"expandedRows\"\n    [rowExpandMode]=\"'multiple'\"\n    [rowTrackBy]=\"rowTrackByFn\"\n  >\n    <ng-template pTemplate=\"caption\">\n      <div class=\"tableCaption\">\n        <div *ngIf=\"smartGrid.gridModel.title\" class=\"captionTitle\">\n          {{ smartGrid.gridModel.title }}\n        </div>\n        <div *ngIf=\"smartGrid.gridModel.view?.descriptor?.showEditColumns\">\n          <p-multiSelect\n            display=\"chip\"\n            [options]=\"smartGrid.gridModel.view?.descriptor?.columns\"\n            optionLabel=\"label\"\n            [(ngModel)]=\"columns\"\n            selectedItemsLabel=\"{0} columns selected\"\n            [style]=\"{ 'min-width': '200px' }\"\n            placeholder=\"Choose Columns\"\n            (onChange)=\"headerChange($event)\"\n          />\n        </div>\n      </div>\n    </ng-template>\n    <ng-template pTemplate=\"header\">\n      <tr>\n        @if (smartGrid.gridModel.view?.descriptor?.showEditColumns) {\n        <th\n          *ngIf=\"isMultiple && (tableType === 'checkbox' || tableType === 'CheckBox')\"\n          style=\"width: 4rem\"\n        >\n          <p-tableHeaderCheckbox />\n        </th>\n        <th\n          *ngIf=\"!isMultiple && (tableType === 'checkbox' || tableType === 'CheckBox')\"\n          style=\"width: 4rem\"\n        ></th>\n        <th\n          [pSortableColumn]=\"col.propertyName\"\n          *ngFor=\"let col of columns\"\n          pReorderableColumn\n          [attr.data-testid]=\"col.propertyName\"\n        >\n          <p-sortIcon [field]=\"col.propertyName\" />\n          {{ col.label }}\n        </th>\n        } @else {\n        <th\n          *ngIf=\"isMultiple && (tableType === 'checkbox' || tableType === 'CheckBox')\"\n          style=\"width: 4rem\"\n        >\n          <p-tableHeaderCheckbox />\n        </th>\n        <th\n          *ngIf=\"!isMultiple && (tableType === 'checkbox' || tableType === 'CheckBox')\"\n          style=\"width: 4rem\"\n        ></th>\n        <th\n          [pSortableColumn]=\"col.propertyName\"\n          *ngFor=\"let col of columns\"\n          [attr.data-testid]=\"col.propertyName\"\n        >\n          <p-sortIcon [field]=\"col.propertyName\" />\n          {{ col.label }}\n        </th>\n        }\n\n        <th>\n          <smart-ui-action-toolbar\n            class=\"headerToolbar\"\n            #headerToolbar\n            [id]=\"'header_not_initialized'\"\n          ></smart-ui-action-toolbar>\n        </th>\n        <th *ngIf=\"smartGrid.expandable\"> </th>\n      </tr>\n    </ng-template>\n    <ng-template pTemplate=\"body\" let-row let-expanded=\"expanded\">\n      <tr\n        [ngClass]=\"getStyle(row)\"\n        [class.rowExpanded]=\"expanded\"\n        (dblclick)=\"onDoubleClick(row)\"\n        *ngIf=\"row && row.data\"\n        [attr.data-testid]=\"row.id ?? null\"\n      >\n        <td *ngIf=\"isMultiple && (tableType === 'checkbox' || tableType === 'CheckBox')\">\n          <p-tableCheckbox *ngIf=\"row.selectable != false\" [value]=\"row\" />\n        </td>\n        <td *ngIf=\"!isMultiple && (tableType === 'checkbox' || tableType === 'CheckBox')\">\n          <p-tableRadioButton [value]=\"row\" />\n        </td>\n        <td *ngFor=\"let col of smartGrid?.gridModel?.view?.orderedColumnNames\">\n          <div *ngIf=\"row.icons[col]\">\n            <div class=\"smart-table-icon-container\">\n              <div *ngFor=\"let ir of getImageResourceIcons(row, col)\">\n                <smart-icon [imageResource]=\"ir\"> </smart-icon>\n              </div>\n            </div>\n          </div>\n          <ng-container *ngIf=\"showCellToolbar(row, col)\">\n            <smart-ui-action-toolbar\n              [uiActionModels]=\"getRowColumnAction(row, col)\"\n            ></smart-ui-action-toolbar>\n          </ng-container>\n\n          <div *ngIf=\"!row.icons[col]\" [innerHtml]=\"getColValue(col, row)\"> </div>\n        </td>\n        <td>\n          <div class=\"menu-button\">\n            @if(showCellToolbar(row, defaultActionToolbarId)){\n            <smart-ui-action-toolbar\n              [uiActionModels]=\"getRowColumnAction(row, defaultActionToolbarId)\"\n            ></smart-ui-action-toolbar>\n            }\n            <p-button\n              [rounded]=\"true\"\n              [text]=\"true\"\n              *ngIf=\"shouldShowOptionsButton(row)\"\n              (onClick)=\"onOptionsClick($event, row)\"\n            >\n              <smart-icon icon=\"ellipsis-v\"></smart-icon>\n            </p-button>\n          </div>\n        </td>\n        <td *ngIf=\"smartGrid.expandable\">\n          <p-button\n            type=\"button\"\n            pRipple\n            [pRowToggler]=\"row\"\n            [text]=\"true\"\n            severity=\"secondary\"\n            [rounded]=\"true\"\n            [icon]=\"expanded ? 'pi pi-chevron-up' : 'pi pi-chevron-down'\"\n          />\n        </td>\n      </tr>\n    </ng-template>\n    @if(smartGrid.expandable){\n    <ng-template pTemplate=\"rowexpansion\" let-row>\n      <tr>\n        <td colspan=\"100%\">\n          <lib-expanded-row-renderer-component\n            [rowId]=\"row.id\"\n            [rowExpander]=\"this\"\n            [expandedComponent]=\"smartGrid.expandedComponent\"\n            [smartGrid]=\"this.smartGrid\"\n          ></lib-expanded-row-renderer-component>\n        </td>\n      </tr>\n    </ng-template>\n    }\n  </p-table>\n  <div\n    *ngIf=\"smartGrid.layoutDef === layoutDef().CARD && smartGrid.dataLayoutDef\"\n    class=\"cards-container\"\n    [ngStyle]=\"{\n      'grid-template-columns':\n        smartGrid.numberOfColumn !== undefined\n          ? 'repeat(' + smartGrid.numberOfColumn + ', 1fr)'\n          : ''\n    }\"\n  >\n    <app-smart-grid-card\n      class=\"smartGrid-card-container\"\n      *ngFor=\"let task of smartGrid.gridModel.page.rows\"\n      [item]=\"task\"\n      [smartGrid]=\"smartGrid\"\n      [onSelect]=\"onSelect.bind(this)\"\n    ></app-smart-grid-card>\n  </div>\n<div *ngIf=\"smartGrid.paginator\" class=\"paginator-row\">\n  <div class=\"paginator-wrap\">\n    <p-paginator\n      [first]=\"pageIndex!\"\n      [totalRecords]=\"length!\"\n      [rows]=\"pageSize\"\n      [rowsPerPageOptions]=\"pageSizeOptions\"\n      currentPageReportTemplate=\"{first} - {last} / {totalRecords}\"\n      (onPageChange)=\"onPrimeChangePage($event)\"\n      [showCurrentPageReport]=\"true\"\n      dropdownAppendTo=\"body\"\n    ></p-paginator>\n  </div>\n\n  <button\n    pButton\n    type=\"button\"\n    icon=\"pi pi-refresh\"\n    class=\"p-button-text\"\n    pTooltip=\"Friss\u00EDt\u00E9s\"\n    (click)=\"refreshPartialResults()\"\n    *ngIf=\"smartGrid.gridModel?.refreshEnabled\"\n  ></button>\n</div>\n  <p-menu #menu [model]=\"menuButtons\" [popup]=\"true\" appendTo=\"body\"> </p-menu>\n</div>\n}@else {\n<div *ngIf=\"smartGrid\" class=\"smartGrid-container\">\n  <div class=\"smart-grid-toolbar\">\n    <smart-ui-action-toolbar #toolbar [id]=\"'grid_not_initialized'\"></smart-ui-action-toolbar>\n    <button\n      (click)=\"editColumns()\"\n      mat-mini-fab\n      color=\"text-primary\"\n      *ngIf=\"smartGrid.showEditColumns\"\n    >\n      <mat-icon aria-hidden=\"false\" aria-label=\"Columns\" class=\"smart-grid-edit-icon\"\n        >view_columns</mat-icon\n      >\n    </button>\n  </div>\n  <!-- <div [ngClass]=\"isBlocked ? 'blocked' : ''\"></div> -->\n  <div class=\"smartGridContent\">\n    <div>\n      <div *ngIf=\"smartGrid.showResultCount\">\n        <div class=\"smartGrid-data-number\">\n          {{ smartGrid.gridModel.totalRowCount }}\n        </div>\n      </div>\n    </div>\n\n    <div class=\"smart-grid-table-container\">\n      <ng-template #table></ng-template>\n    </div>\n\n    <div *ngIf=\"smartGrid.layoutDef === layoutDef().EXPANDABLE\">\n      <smart-expandable-section\n        #gridExpandableSection\n        *ngFor=\"let expandableSection of expandableSections\"\n        [data]=\"expandableSection\"\n      ></smart-expandable-section>\n    </div>\n    <div\n      *ngIf=\"smartGrid.layoutDef === layoutDef().CARD && smartGrid.dataLayoutDef\"\n      class=\"cards-container\"\n      [ngStyle]=\"{\n        'grid-template-columns':\n          smartGrid.numberOfColumn !== undefined\n            ? 'repeat(' + smartGrid.numberOfColumn + ', 1fr)'\n            : ''\n      }\"\n    >\n      <app-smart-grid-card\n        class=\"smartGrid-card-container\"\n        *ngFor=\"let task of smartGrid.gridModel.page.rows\"\n        [item]=\"task\"\n        [smartGrid]=\"smartGrid\"\n        [onSelect]=\"onSelect.bind(this)\"\n      ></app-smart-grid-card>\n    </div>\n    <div\n      *ngIf=\"smartGrid.layoutDef === layoutDef().TREE && treeControl\"\n      class=\"tree-container\"\n      [ngStyle]=\"{\n        'grid-template-columns':\n          smartGrid.numberOfColumn !== undefined\n            ? 'repeat(' + smartGrid.numberOfColumn + ', 1fr)'\n            : ''\n      }\"\n    >\n      <mat-tree [dataSource]=\"treeDataSource!\" [treeControl]=\"treeControl!\">\n        <mat-tree-node\n          *matTreeNodeDef=\"let node\"\n          matTreeNodeToggle\n          matTreeNodePadding\n          matTreeNodePaddingIndent=\"24\"\n        >\n          <button mat-icon-button disabled class=\"tree-button\"></button>\n          <mat-checkbox\n            class=\"checklist-leaf-node\"\n            [checked]=\"treeChecklistSelection?.isSelected(node)\"\n            (change)=\"treeNodeSelectionToggle(node)\"\n            >{{ getTreeItem(node) }}</mat-checkbox\n          >\n        </mat-tree-node>\n\n        <mat-tree-node\n          *matTreeNodeDef=\"let node; when: hasChild\"\n          matTreeNodePadding\n          matTreeNodePaddingIndent=\"24\"\n        >\n          <button\n            mat-icon-button\n            matTreeNodeToggle\n            class=\"tree-button\"\n            [attr.aria-label]=\"'Toggle ' + node.item\"\n          >\n            <mat-icon class=\"mat-icon-rtl-mirror\">\n              {{ treeControl!.isExpanded(node) ? 'expand_more' : 'chevron_right' }}\n            </mat-icon>\n          </button>\n          <mat-checkbox\n            [checked]=\"treeChecklistSelection?.isSelected(node)\"\n            [indeterminate]=\"descendantsPartiallySelected(node)\"\n            (change)=\"treeNodeSelectionToggle(node)\"\n            >{{ getTreeItem(node) }}</mat-checkbox\n          >\n        </mat-tree-node>\n      </mat-tree>\n    </div>\n  </div>\n<div *ngIf=\"smartGrid.paginator\" class=\"paginator-row-material\">\n  <button\n   pButton\n   type=\"button\"\n   icon=\"pi pi-refresh\"\n   class=\"p-button-text\"\n   pTooltip=\"Friss\u00EDt\u00E9s\"\n   (click)=\"refreshPartialResults()\"\n   *ngIf=\"smartGrid.gridModel?.refreshEnabled\"\n ></button>\n  <mat-paginator\n    *ngIf=\"smartGrid.paginator && !treeControl\"\n    #paginator\n    [length]=\"length\"\n    [pageIndex]=\"pageIndex\"\n    [pageSize]=\"pageSize\"\n    [pageSizeOptions]=\"pageSizeOptions\"\n    (page)=\"onChangePage($event)\"\n  ></mat-paginator>\n  </div>\n</div>\n}\n", styles: [".smartGrid-container{position:relative;padding:1.5rem;display:flex;flex-direction:column;gap:1rem}.primeSmartGrid-container{display:flex;flex-direction:column;gap:1rem}.smartGrid-data-number{padding-bottom:1rem}.smart-table-icon-container{display:flex;flex-direction:row;justify-content:space-between;white-space:initial}.cards-container{display:grid;gap:1rem;padding:1rem}.smartGrid-card-container{height:auto;border:1px solid black;border-radius:8px}.smartGrid-container ::ng-deep .mat-form-field-appearance-legacy .mat-form-field-underline{bottom:0}.smartGridContent{width:100%;flex:1;overflow:auto}.blocked{position:absolute;width:calc(100% - 3rem);height:calc(100% - 3rem);z-index:110;background-color:#0003}.smart-grid-table-container{display:flex;flex-direction:column;gap:1rem}.smart-grid-toolbar{display:flex;flex-direction:row;justify-content:flex-end;align-items:center}.smart-grid-toolbar smart-ui-action-toolbar{width:100%}.smart-grid-edit-icon{color:var(--light-gray)}.tree-button{width:24px!important;height:24px!important}.menu-button{display:flex;flex-direction:row;justify-content:flex-end;text-align:-webkit-right;align-items:center}.headerToolbar ::ng-deep .uiActionButtonsContainer{justify-content:flex-end}.tableCaption{display:flex;flex-direction:row;justify-content:space-between}.tableCaption:has(*){padding:.5rem;border-top:1px solid #e9ecef;border-bottom:1px solid #e9ecef}:host ::ng-deep .p-datatable .p-datatable-thead>tr>th,:host ::ng-deep .p-datatable .p-datatable-header{padding:.5rem}.captionTitle{font-size:1.5rem;align-content:center}:host ::ng-deep .p-datatable-header:has(.tableCaption){padding:0;border:unset}.paginator-row{display:flex;align-items:center;align-self:center;gap:.25rem}.paginator-row-material{display:flex;align-items:center;align-self:flex-end;gap:.25rem}.paginator-wrap{flex:0 0 auto;min-width:0}:host ::ng-deep .paginator-wrap .p-paginator{width:auto}\n"] }]
+        }], ctorParameters: () => [{ type: i1.SmartGridService }, { type: i2.ComponentFactoryService }, { type: i3.MatDialog }, { type: i0.Injector }, { type: i4.UiActionDescriptorService }, { type: i5.SmartDatePipe }, { type: i5.SmartDateTimePipe }, { type: i5.SmartTimePipe }, { type: i4.ComponentLibrary, decorators: [{
+                    type: Inject,
+                    args: [COMPONENT_LIBRARY]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['gridMenuIcon']
+                }] }], propDecorators: { smartGrid: [{
+                type: Input
+            }], uuid: [{
+                type: Input
+            }], testId: [{
+                type: HostBinding,
+                args: ['attr.data-testid']
+            }], dev: [{
+                type: Input
+            }], vcRefTable: [{
+                type: ViewChild,
+                args: ['table', { read: ViewContainerRef }]
+            }], toolbar: [{
+                type: ViewChild,
+                args: ['toolbar']
+            }], _headerToolbar: [{
+                type: ViewChild,
+                args: ['headerToolbar']
+            }], expandedRowsComps: [{
+                type: ViewChildren,
+                args: [ExpandedRowRendererComponent]
+            }], menu: [{
+                type: ViewChild,
+                args: ['menu']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smart-grid.component.js","sourceRoot":"","sources":["../../../../../projects/smart-ng-client/src/lib/smart-grid/smart-grid.component.ts","../../../../../projects/smart-ng-client/src/lib/smart-grid/smart-grid.component.html"],"names":[],"mappings":"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","sourcesContent":["import { SelectionModel } from '@angular/cdk/collections';\nimport { FlatTreeControl } from '@angular/cdk/tree';\nimport {\n  AfterViewInit,\n  Component,\n  ComponentRef,\n  EventEmitter,\n  HostBinding,\n  Inject,\n  Injector,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Output,\n  QueryList,\n  SimpleChanges,\n  ViewChild,\n  ViewChildren,\n  ViewContainerRef,\n} from '@angular/core';\nimport { MatDialog } from '@angular/material/dialog';\nimport { PageEvent } from '@angular/material/paginator';\nimport { MatTreeFlatDataSource, MatTreeFlattener } from '@angular/material/tree';\nimport { Subject, takeUntil } from 'rxjs';\nimport { ComponentFactoryService } from '../component-factory-service/projects';\nimport { SmartDialogData } from '../smart-dialog/projects';\nimport { ExpandableSection } from '../smart-expandable-section/projects';\nimport { FilterExpressionOrderBy } from '../smart-filter-editor/api/model/filterExpressionOrderBy';\nimport {\n  SmartTable,\n  SmartTableButtonType,\n  SmartTableHeader,\n  SmartTableHeaderProperties,\n  SmartTableHeaderPropertyType,\n  SmartTableInterface,\n  SmartTableInterfaceTypeEnum,\n  SmartTableOrder,\n  SmartTableType,\n  SmarttableComponent,\n} from '../smart-table/projects';\nimport {\n  ImageResource,\n  UiAction,\n  UiActionButtonType,\n  UiActionDescriptor,\n} from '../view-context/api';\nimport {\n  COMPONENT_LIBRARY,\n  ComponentLibrary,\n  UiActionDescriptorService,\n  UiActionModel,\n  UiActionToolbarComponent,\n} from '../view-context/projects';\nimport {\n  GridColumnMeta,\n  GridRow,\n  GridSelectionMode,\n  GridSelectionType,\n  GridUpdateData,\n  GridViewDescriptorKindEnum,\n} from './api/grid-api';\nimport { TableLayoutDefinerComponent } from './components/table-layout-definer/table-layout-definer.component';\nimport {\n  GridUiActionType,\n  SmartGrid,\n  SmartGridDataLayout,\n  SmartGridType,\n  SmartLayoutDef,\n} from './models/model';\nimport { SmartGridService } from './smart-grid.service';\nimport { MenuItem, SortMeta } from 'primeng/api';\nimport { Menu } from 'primeng/menu';\nimport {\n  RowToggler,\n  TableColumnReorderEvent,\n  TableHeaderCheckboxToggleEvent,\n  TableLazyLoadEvent,\n  TableRowExpandEvent,\n  TableRowSelectEvent,\n  TableRowUnSelectEvent,\n} from 'primeng/table';\nimport { FilterExpressionOrderByOrderEnum } from '../smart-filter/projects';\nimport { MultiSelectChangeEvent } from 'primeng/multiselect';\nimport { SmartGridToolbarActionsUtil } from './smart-grid-toolbar-util';\nimport { ExpandedRowRendererComponent } from './components/generic-component/expanded-row-renderer.component';\nimport { SmartDatePipe, SmartDateTimePipe, SmartTimePipe } from '../shared/smarttable.date-pipe';\n\n@Component({\n  selector: 'smart-grid',\n  templateUrl: './smart-grid.component.html',\n  styleUrls: ['./smart-grid.component.css'],\n  providers: [SmartGridService, SmartDatePipe, SmartDateTimePipe, SmartTimePipe],\n})\nexport class SmartGridComponent implements AfterViewInit, OnDestroy, OnChanges {\n  // private readonly defaultPageSize: number = 10;\n  private readonly defaultPageSizeOptions: number[] = [5, 10, 25, 50];\n  componentLibrary = ComponentLibrary;\n  private _destroy$: Subject<void> = new Subject();\n  @Input() smartGrid?: SmartGrid;\n  @Input() uuid?: string;\n\n  @HostBinding('attr.data-testid')\n  get testId(): string | null {\n    return this.smartGrid?.gridModel?.identifier ?? null;\n  }\n  @Input() dev: boolean = false;\n\n  // table\n  @ViewChild('table', { read: ViewContainerRef }) vcRefTable?: ViewContainerRef;\n  componentRefTable?: ComponentRef<SmarttableComponent>;\n  smartTable!: SmartTable<GridRow>;\n\n  // toolbar\n  @ViewChild('toolbar') toolbar?: UiActionToolbarComponent;\n  @ViewChild('headerToolbar') _headerToolbar?: UiActionToolbarComponent;\n  defaultActionToolbarId: string = SmartGridToolbarActionsUtil.defaultActionToolbarId;\n\n  // expandable\n  @ViewChildren(ExpandedRowRendererComponent)\n  expandedRowsComps!: QueryList<ExpandedRowRendererComponent>;\n\n  expandableSections?: ExpandableSection<any>[];\n  expandedRows = {};\n\n  // gridData\n  pageEvent?: PageEvent;\n  datasource?: null;\n  pageSize?: number;\n  length?: number;\n  pageIndex?: number;\n  values: any;\n  gridTable!: SmartTable<any>;\n  isMultiple?: boolean;\n  selectedRows: GridRow[] = [];\n  tableType?: any;\n  pageSizeOptions: number[] = this.defaultPageSizeOptions;\n  columnMetaByName?: Map<string, GridColumnMeta>;\n\n  selectionChanges: Subject<any> = new Subject();\n\n  uiActionDescriptors: Map<string, UiActionDescriptor> = new Map();\n  cellToActionMap: Record<string, UiActionModel[]> = {};\n\n  afterViewInitExecuted: boolean = false;\n  isBlocked: boolean = true;\n\n  // tree\n  treeControl?: FlatTreeControl<GridRow>;\n  treeFlattener?: MatTreeFlattener<GridRow, GridRow>;\n  treeDataSource?: MatTreeFlatDataSource<GridRow, GridRow>;\n  treeChecklistSelection?: SelectionModel<GridRow>;\n\n  constructor(\n    private service: SmartGridService,\n    private cfService: ComponentFactoryService,\n    private dialog: MatDialog,\n    private injector: Injector,\n    private uiActionDescriptorService: UiActionDescriptorService,\n    private smartDatePipe: SmartDatePipe,\n    private smartDateTimePipe: SmartDateTimePipe,\n    private smartTimePipe: SmartTimePipe,\n    @Inject(COMPONENT_LIBRARY) public compLib: ComponentLibrary,\n    @Inject('gridMenuIcon') private gridMenuIcon?: string\n  ) {\n    this.service.gridModelChanged.subscribe(() => {\n      // called after every service call (load, save, refresh, etc.)\n      this.smartGrid!.gridModel = this.service.gridModel;\n      this.render();\n\n      //Refresh expanded sections data\n      if (this.smartGrid!.expandable) {\n        this.expandedRowsComps.forEach((rowComp) => rowComp.refreshRowData());\n      }\n    });\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['smartGrid']) {\n      this.smartGrid = changes['smartGrid'].currentValue;\n      this.service.paginator = this.smartGrid?.paginator;\n      this.setupToolbar();\n    }\n    if (changes['uuid']) {\n      if (changes['uuid'] && this.uuid === changes['uuid'].currentValue) {\n        this.expandedRows = {};\n      }\n      this.uuid = changes['uuid'].currentValue;\n    }\n    if (this.afterViewInitExecuted && this.uuid && this.smartGrid) {\n      this.refresh();\n    }\n  }\n\n  ngOnDestroy(): void {\n    this._destroy$.next();\n    this._destroy$.complete();\n  }\n\n  ngAfterViewInit(): void {\n    if (this.uuid && this.smartGrid) {\n      this.refresh();\n    }\n    this.afterViewInitExecuted = true;\n  }\n\n  /**\n   *\n   * @returns the selected rows of the table\n   */\n  public getSelectedRows(): SelectionModel<GridRow> {\n    if (!this.smartTable.selection) throw new Error();\n    return this.smartTable!.selection!;\n  }\n\n  /**\n   * This method sends a GET request to the generic GridAPI and refreshes the presented\n   * grid with the newest one.\n   */\n  public async refresh(): Promise<void> {\n    this.setupToolbar();\n    // will cause this.service.gridModelChanged to fire\n    if (this.uuid) {\n      await this.service.load(this.uuid, this.smartGrid!.gridIdentifier);\n    }\n  }\n\n  getStyle(row: any): string[] {\n    if (row && row.style) {\n      let style = row.style;\n      let classesToAdd: Array<string> = [];\n\n      if (style.classesToAdd) {\n        style.classesToAdd.forEach((cl: string) => classesToAdd.push(cl));\n      }\n\n      if (!style.classesToRemove) {\n        return classesToAdd;\n      }\n      return classesToAdd.filter((cls) => !style.classesToRemove.includes(cls));\n    }\n    return [];\n  }\n\n  public setupToolbar() {\n    // check if toolbar is available _and_ need set up\n    if (this.toolbar && this.smartGrid) {\n      let toolbarId = this.smartGrid?.gridIdentifier + '_toolbar';\n      if (toolbarId !== this.toolbar.id) {\n        this.toolbar.id = toolbarId;\n      }\n    }\n\n    if (this._headerToolbar && this.smartGrid) {\n      let headerToolbarId = this.smartGrid?.gridIdentifier + '_headerToolbar';\n      if (headerToolbarId !== this._headerToolbar.id) {\n        this._headerToolbar.id = headerToolbarId;\n      }\n    }\n  }\n\n  get headerToolbar(): UiActionToolbarComponent | undefined {\n    if (this.compLib === ComponentLibrary.PRIMENG) {\n      return this._headerToolbar;\n    } else {\n      return this.componentRefTable?.instance.componentRefTable?.instance.headerToolbar;\n    }\n  }\n\n  private async render(): Promise<void> {\n    const gridModel = this.smartGrid?.gridModel;\n    if (gridModel) {\n      this.length = gridModel.totalRowCount;\n      this.pageSize = gridModel.pageSize;\n      this.pageIndex = gridModel.pageIndex ?? 0;\n      if (gridModel.pageSizeOptions && gridModel.pageSizeOptions.length > 0) {\n        this.pageSizeOptions = gridModel.pageSizeOptions;\n      } else {\n        this.pageSizeOptions = this.defaultPageSizeOptions;\n      }\n      if (gridModel?.view?.descriptor?.showEditColumns) {\n        this.smartGrid!.showEditColumns = gridModel?.view?.descriptor?.showEditColumns;\n      }\n      if (gridModel?.view?.descriptor?.columns) {\n        this.columnMetaByName = new Map(\n          gridModel?.view?.descriptor?.columns.map((col) => [col.propertyName, col])\n        );\n      } else {\n        this.columnMetaByName = undefined;\n      }\n\n      let kind = gridModel?.view?.descriptor?.kind;\n      if (kind) {\n        let layoutDef;\n        if (kind === GridViewDescriptorKindEnum.TABLE) {\n          layoutDef = SmartLayoutDef.TABLE;\n        } else if (kind === GridViewDescriptorKindEnum.TREE) {\n          layoutDef = SmartLayoutDef.TREE;\n        } else if (kind === GridViewDescriptorKindEnum.CARDS) {\n          layoutDef = SmartLayoutDef.CARD;\n        }\n        if (layoutDef) {\n          this.smartGrid!.layoutDef = layoutDef;\n        }\n      }\n      if (gridModel?.paginator === true || gridModel?.paginator === false) {\n        this.smartGrid!.paginator = gridModel.paginator;\n        this.service.paginator = this.smartGrid!.paginator;\n      }\n    } else {\n      console.error('GridModel is undefined in component!');\n    }\n    if (!this.smartGrid!.layoutDef) {\n      // fallback, default TABLE\n      this.smartGrid!.layoutDef = SmartLayoutDef.TABLE;\n    }\n    if (this.smartGrid!.layoutDef === SmartLayoutDef.TABLE) {\n      this.renderTable();\n    } else if (this.smartGrid!.layoutDef === SmartLayoutDef.EXPANDABLE) {\n      this.renderExpandableSections();\n    } else if (this.smartGrid!.layoutDef === SmartLayoutDef.CARD) {\n      this.renderCards();\n    } else if (this.smartGrid!.layoutDef === SmartLayoutDef.TREE) {\n      this.renderTree();\n    }\n    this.isBlocked = false;\n  }\n\n  private clearTable() {\n    this.vcRefTable?.clear();\n    this.componentRefTable = undefined;\n  }\n\n  private async renderTable(): Promise<void> {\n    this.clearTree();\n    if (this.compLib === this.componentLibrary.PRIMENG) {\n      this.pageIndex = this.smartGrid?.gridModel.pageSize! * this.smartGrid?.gridModel.pageIndex!;\n      this.columns = [];\n      this.smartGrid?.gridModel.view?.orderedColumnNames.map((orderedCol: string) => {\n        this.smartGrid?.gridModel.view?.descriptor?.columns.map((colum: GridColumnMeta) => {\n          if (orderedCol === colum.propertyName) {\n            this.columns.push(colum);\n          }\n        });\n      });\n    }\n\n    let tableRow = this.smartGrid!.gridModel!.page.rows!.map((item: any) => {\n      this.createCellToActionMap();\n      return item;\n    });\n\n    if (!tableRow.length) {\n      let placeHolderRow: any = {};\n      this.smartGrid!.gridModel.view?.descriptor?.columns.map((meta: GridColumnMeta) => {\n        placeHolderRow[meta.propertyName] = undefined;\n      });\n      this.smartGrid!.gridModel.page.rows = [placeHolderRow];\n    }\n\n    if (this.smartGrid!.tableConfig?.tableType) {\n      this.tableType = this.smartGrid!.tableConfig.tableType;\n    } else if (this.service.gridModel?.view?.descriptor?.selectionType) {\n      this.tableType =\n        this.service.gridModel.view.descriptor.selectionType === GridSelectionType.CHECKBOX\n          ? SmartTableType.CHECK_BOX\n          : SmartTableType.ROW_SELECT;\n    } else {\n      this.tableType = SmartTableType.INHERITED;\n    }\n    if (this.smartGrid!.layoutDef === SmartLayoutDef.TABLE) {\n      let tableConfig: SmartTableInterface<GridRow> = {\n        ...this.smartGrid!.tableConfig,\n        title: this.smartGrid?.gridModel.title,\n        tableRows: tableRow,\n        tableType: this.tableType,\n        customSmartTableHeaders: await this.constructHeader()!,\n        expandable: this.smartGrid!.expandable,\n        asyncOnExpand: this.smartGrid!.expandable,\n        expandedComponent: this.smartGrid!.expandedComponent,\n        type: SmartTableInterfaceTypeEnum.NORMAL,\n        sortable: true,\n        defaultActionCodes: this.smartGrid?.gridModel.defaultRowActions!,\n        defaultActions: this.smartGrid?.gridModel.defaultRowActions?.map((code: string) => {\n          return {\n            type:\n              code === '_actionSeparator_'\n                ? SmartTableButtonType.SEPARATOR\n                : SmartTableButtonType.NORMAL,\n            callback: this.execute.bind(this),\n            code: code,\n            // label: this.buttonTranslator({ code: code }),\n            translator: this.buttonTranslator.bind(this),\n            // args: [\n            //   {\n            //     code: code,\n            //   },\n            // ],\n          };\n        }),\n      };\n\n      if (\n        this.smartGrid?.gridModel.view?.descriptor?.highlightProperty &&\n        this.smartGrid?.gridModel.view?.descriptor?.highlightClass\n      ) {\n        tableConfig.highlightClass = this.smartGrid.gridModel.view.descriptor.highlightClass;\n        tableConfig.highlightProperty = this.smartGrid.gridModel.view.descriptor.highlightProperty;\n      }\n\n      if (\n        this.smartGrid!.uiActionService &&\n        this.smartGrid!.uiActionDescriptorService &&\n        this.smartGrid!.serviceToUse &&\n        this.smartGrid!.viewContextService\n      ) {\n        tableConfig.onSelection = this.onSelect.bind(this);\n        tableConfig.onAllSelection = this.onSelectAll.bind(this);\n      }\n\n      // Prepared for simple clicks\n      // if (!tableConfig.onRowClick) {\n      //   tableConfig.onRowClick = this.onClick.bind(this);\n      // }\n\n      if (!tableConfig.onRowDoubleClick) {\n        tableConfig.onRowDoubleClick = this.onDoubleClick.bind(this);\n      }\n\n      if (!tableConfig.isRowDisabledPropertyName) {\n        tableConfig.selectablePropertyName = 'selectable';\n      }\n\n      if (tableConfig.asyncOnExpand) {\n        tableConfig.rowExpander = this;\n      }\n\n      const selectionMode = this.service!.gridModel.view?.descriptor?.selectionMode;\n\n      if (\n        !tableConfig.selection &&\n        !tableConfig.selectionProperty &&\n        selectionMode !== GridSelectionMode.NONE\n      ) {\n        this.isMultiple = selectionMode === GridSelectionMode.MULTIPLE;\n\n        tableConfig.selectionProperty = 'id';\n        let selectedIds;\n        this.selectedRows = this.service.gridModel.page.rows!.filter(\n          (gridRow: GridRow) => gridRow.selected\n        );\n\n        selectedIds = this.selectedRows.map((gridRow: GridRow) => gridRow.id!);\n        tableConfig.selection = new SelectionModel<string>(this.isMultiple, selectedIds);\n        tableConfig.showCheckboxInHeader =\n          typeof tableConfig.showCheckboxInHeader !== 'undefined'\n            ? tableConfig.showCheckboxInHeader // keep if set\n            : this.isMultiple; //if unset, turn it on for multiple selection\n      }\n\n      this.smartTable = new SmartTable<any>(\n        tableConfig,\n        this.smartGrid?.gridIdentifier,\n        this.smartGrid?.serviceToUse\n      );\n\n      if (this.componentRefTable) {\n        this.componentRefTable.instance.updateSmartTable(this.smartTable);\n      } else {\n        this.vcRefTable?.clear();\n\n        if (!this.vcRefTable) {\n          return;\n        }\n        this.componentRefTable = this.cfService.createComponent(\n          this.vcRefTable!,\n          SmarttableComponent,\n          new Map<string, any>([['smartTable', this.smartTable]])\n        );\n\n        let subscription = this.componentRefTable.instance.sortEvent\n          .pipe(takeUntil(this.componentRefTable.instance._destroy$))\n          .subscribe((header: SmartTableHeader) => {\n            header.propertyName = header.propertyName.substring(5);\n\n            switch (header.order) {\n              case undefined:\n                header.order = SmartTableOrder.ASC;\n                break;\n              case SmartTableOrder.ASC:\n                header.order = SmartTableOrder.DESC;\n                break;\n              case SmartTableOrder.DESC:\n                header.order = undefined;\n                break;\n            }\n\n            let filter = this.smartGrid!.gridModel.view!.orderByList.find(\n              (filterExpression: FilterExpressionOrderBy) =>\n                filterExpression.propertyName === header.propertyName\n            );\n            if (filter && !header.order) {\n              let index = this.smartGrid!.gridModel.view?.orderByList.indexOf(filter);\n              this.smartGrid!.gridModel.view?.orderByList.splice(index!, 1);\n            } else if (filter) {\n              filter.order = header.order;\n            } else {\n              this.smartGrid!.gridModel.view!.orderByList.push({\n                order: header.order,\n                propertyName: header.propertyName,\n              });\n            }\n\n            let gridUpdateData: GridUpdateData = {\n              orderByList: this.smartGrid!.gridModel.view!.orderByList,\n              orderedColumnNames: this.smartGrid!.gridModel.view!.orderedColumnNames,\n            };\n            this.service.sort(this.smartGrid!, gridUpdateData);\n          });\n\n        this.componentRefTable.instance.smartTable.selection?.changed\n          .pipe(takeUntil(this.componentRefTable.instance._destroy$))\n          .subscribe((row: any) => {\n            this.selectionChanges.next(row);\n          });\n      }\n    }\n  }\n\n  public expand(rowId: number): any {}\n\n  public async expandAsync(rowIndex: number): Promise<any> {\n    if (this.smartGrid!.gridModel.page.rows) {\n      let row = this.smartGrid!.gridModel.page.rows[rowIndex];\n      if (row && row.id) {\n        return await this.service.expand(this.smartGrid!, row.id);\n      }\n    }\n    return await this.service.expand(this.smartGrid!, rowIndex.toString());\n  }\n\n  private renderExpandableSections(): void {\n    this.expandableSections = this.smartGrid!.gridModel!.page.rows!.map((item: any) => {\n      return {\n        title: '',\n        headerComponent: this.smartGrid!.headerComponent,\n        headerInputName: this.smartGrid!.headerComponentInputName,\n        headerData: item,\n        customComponent: this.smartGrid!.expandableComponent,\n        inputName: this.smartGrid!.expandableComponentInputName,\n        data: item,\n      };\n    });\n  }\n\n  private renderCards(): void {\n    if (this.compLib === this.componentLibrary.PRIMENG) {\n      this.pageIndex = this.smartGrid?.gridModel.pageSize! * this.smartGrid?.gridModel.pageIndex!;\n      this.columns = [];\n      this.smartGrid?.gridModel.view?.orderedColumnNames.map((orderedCol: string) => {\n        this.smartGrid?.gridModel.view?.descriptor?.columns.map((colum: GridColumnMeta) => {\n          if (orderedCol === colum.propertyName) {\n            this.columns.push(colum);\n          }\n        });\n      });\n    }\n    if (!this.smartGrid!.customComponent) {\n      let datalayoutDef = {\n        dataLayout: SmartGridDataLayout.COLUMN,\n        gridLayout: SmartGridDataLayout.COLUMN,\n        type: SmartGridType.CUSTOM,\n      };\n\n      this.smartGrid!.dataLayoutDef = datalayoutDef;\n      this.smartGrid!.customComponent = this.injector.get(this.smartGrid!.gridIdentifier + 'Card');\n    }\n  }\n\n  private isMultipleSelection(): boolean {\n    const selectionMode = this.service!.gridModel.view?.descriptor?.selectionMode;\n    return selectionMode === GridSelectionMode.MULTIPLE;\n  }\n\n  private clearTree() {\n    this.treeControl = undefined;\n    this.treeDataSource = undefined;\n    this.treeFlattener = undefined;\n    this.treeChecklistSelection = undefined;\n  }\n\n  private renderTree(): void {\n    this.clearTable();\n    if (!this.treeDataSource) {\n      this.treeFlattener = new MatTreeFlattener(\n        this.transformer,\n        this.getLevel,\n        this.isExpandable,\n        this.getChildren\n      );\n      this.treeControl = new FlatTreeControl<GridRow>(this.getLevel, this.isExpandable);\n      this.treeDataSource = new MatTreeFlatDataSource(this.treeControl, this.treeFlattener);\n      this.treeChecklistSelection = new SelectionModel<GridRow>(this.isMultipleSelection());\n    }\n    let nodes = this.treeControl?.dataNodes;\n    let expandedNodes: (string | undefined)[];\n    if (nodes) {\n      expandedNodes = nodes\n        .filter((node) => this.treeControl?.isExpandable(node))\n        .filter((node) => this.treeControl?.isExpanded(node))\n        .map((node) => node.id);\n    } else {\n      expandedNodes = [];\n    }\n    this.smartGrid!.gridModel.page.rows!.forEach((row: any) => (row.level = undefined));\n    this.treeDataSource.data = this.smartGrid!.gridModel.page.rows!.filter((row) => !row.parent);\n    this.treeChecklistSelection?.clear();\n    this.treeControl?.dataNodes.forEach((node) => {\n      if (node.selected) {\n        this.treeChecklistSelection?.select(node);\n      }\n    });\n    this.treeControl?.collapseAll();\n    expandedNodes.forEach((rowId) => {\n      let row = this.treeControl?.dataNodes.find((row) => rowId === row.id);\n      if (row) {\n        this.treeControl?.expand(row);\n      }\n    });\n  }\n\n  getLevel = (node: any) => node.level ?? 0;\n\n  isExpandable = (node: GridRow) => (node.children && node.children.length > 0 ? true : false);\n\n  getChildren = (node: GridRow): GridRow[] => {\n    if (node.children) {\n      let rows = this.smartGrid?.gridModel.page.rows?.filter((row) =>\n        node.children?.some((child) => child === row.id!)\n      );\n      if (rows) {\n        return rows;\n      }\n    }\n    return [];\n  };\n\n  hasChild = (_: number, _nodeData: GridRow) => this.isExpandable(_nodeData);\n\n  transformer = (row: GridRow, level: number) => {\n    (row as any).level = level;\n    return row;\n  };\n\n  getTreeItem(row: GridRow): string {\n    let columns: string[] | undefined = this.smartGrid?.gridModel.view?.orderedColumnNames;\n    let data: any = row.data!;\n    if (columns && columns.length > 0) {\n      return columns.map((col) => data[col]).join(' ');\n    }\n    return row.id!;\n  }\n\n  /** Toggle the treeNode selection. Select/deselect all the descendants node */\n  treeNodeSelectionToggle(node: GridRow): void {\n    if (!this.treeChecklistSelection) {\n      return;\n    }\n    let selectionBefore = this.treeChecklistSelection.selected.map((row) => row.id);\n    this.treeChecklistSelection.toggle(node);\n    if (this.isMultipleSelection()) {\n      const descendants = this.treeControl!.getDescendants(node);\n      this.treeChecklistSelection.isSelected(node)\n        ? this.treeChecklistSelection.select(...descendants)\n        : this.treeChecklistSelection.deselect(...descendants);\n      this.checkAllParentsSelection(node);\n    }\n    let selectionAfter = this.treeChecklistSelection.selected.map((row) => row.id);\n\n    let selectedIds = selectionAfter.filter((s) => !selectionBefore.includes(s));\n    let unselectedIds = selectionBefore.filter((s) => !selectionAfter.includes(s));\n    this.onSelectRows(selectedIds, unselectedIds);\n  }\n\n  checkAllParentsSelection(node: GridRow): void {\n    let parent: GridRow | null = this.getParentNode(node);\n    while (parent) {\n      this.checkParentNodeSelection(parent);\n      parent = this.getParentNode(parent);\n    }\n  }\n\n  checkParentNodeSelection(node: GridRow): void {\n    if (!this.treeChecklistSelection) {\n      return;\n    }\n    const nodeSelected = this.treeChecklistSelection.isSelected(node);\n    const descAllSelected = this.descendantsAllSelected(node);\n    if (nodeSelected && !descAllSelected) {\n      this.treeChecklistSelection.deselect(node);\n    } else if (!nodeSelected && descAllSelected) {\n      this.treeChecklistSelection.select(node);\n    }\n  }\n\n  /* Get the parent node of a node */\n  getParentNode(node: GridRow): GridRow | null {\n    const currentLevel = this.getLevel(node);\n\n    if (currentLevel < 1) {\n      return null;\n    }\n\n    const startIndex = this.treeControl!.dataNodes.indexOf(node) - 1;\n\n    for (let i = startIndex; i >= 0; i--) {\n      const currentNode = this.treeControl!.dataNodes[i];\n\n      if (this.getLevel(currentNode) < currentLevel) {\n        return currentNode;\n      }\n    }\n    return null;\n  }\n\n  /** Whether all the descendants of the node are selected. */\n  descendantsAllSelected(node: GridRow): boolean {\n    if (!this.treeControl || !this.treeChecklistSelection) {\n      return false;\n    }\n    const descendants = this.treeControl.getDescendants(node);\n    const descAllSelected =\n      descendants.length > 0 &&\n      descendants.every((child) => {\n        return this.treeChecklistSelection!.isSelected(child);\n      });\n    return descAllSelected;\n  }\n\n  /** Whether part of the descendants are selected */\n  descendantsPartiallySelected(node: GridRow): boolean {\n    if (!this.treeControl || !this.treeChecklistSelection) {\n      return false;\n    }\n    const descendants = this.treeControl.getDescendants(node);\n    let result = descendants.some((child) => this.treeChecklistSelection!.isSelected(child));\n    if (this.isMultipleSelection()) {\n      result = result && !this.descendantsAllSelected(node);\n    }\n    return result;\n  }\n\n  private async constructHeader(): Promise<SmartTableHeader[]> {\n    if (this.smartGrid!.gridModel.page.rows && this.smartGrid!.gridModel.page.rows.length) {\n      await Promise.all(\n        this.smartGrid!.gridModel.page.rows.map(async (gridRow: GridRow) => {\n          let newUiActions = gridRow.actions?.filter(\n            (uiAction: any) => !this.uiActionDescriptors.get(uiAction.code!)\n          );\n\n          if (newUiActions) {\n            await Promise.all(\n              newUiActions.map(async (uiAction: UiAction) => {\n                let descriptor: UiActionDescriptor =\n                  await this.smartGrid!.uiActionDescriptorService?.getActionDescriptor(uiAction);\n                if (!descriptor) {\n                  descriptor = {\n                    title: uiAction.code ?? 'CODE',\n                    color: 'primary',\n                    type: UiActionButtonType.NORMAL,\n                  };\n                }\n                this.uiActionDescriptors.set(uiAction.code!, structuredClone(descriptor));\n              })\n            );\n          }\n        })\n      );\n    }\n\n    let orederedDescColumns = this.smartGrid!.gridModel.view!.orderedColumnNames.map(\n      (propertyName: string) =>\n        this.smartGrid!.gridModel.view!.descriptor!.columns!.find(\n          (colDescriptor: GridColumnMeta) => colDescriptor.propertyName === propertyName\n        )\n    ).flatMap((f) => f ?? []);\n\n    let header = await Promise.all(\n      orederedDescColumns.map(async (descColumn: GridColumnMeta): Promise<SmartTableHeader> => {\n        let customTableHeader = this.smartGrid!.tableConfig?.customSmartTableHeaders?.find(\n          (header: SmartTableHeader) => header.propertyName === descColumn.propertyName\n        );\n        let filterExpressionOrderByItem = this.smartGrid!.gridModel.view?.orderByList?.find(\n          (filterExpression: FilterExpressionOrderBy) =>\n            filterExpression.propertyName === descColumn!.propertyName\n        );\n        let order;\n        let orderNumber;\n        if (filterExpressionOrderByItem) {\n          order =\n            filterExpressionOrderByItem.order === FilterExpressionOrderBy.OrderEnum.Asc\n              ? SmartTableOrder.ASC\n              : SmartTableOrder.DESC;\n          if (this.service.gridModel.view!.orderByList.length > 1) {\n            orderNumber = this.service.gridModel.view!.orderByList.findIndex(\n              (filter: FilterExpressionOrderBy) => filter.propertyName === descColumn!.propertyName\n            );\n            orderNumber++;\n          }\n        }\n        const orignalLabel = customTableHeader?.label ?? descColumn.label;\n        let label = '';\n        if (!descColumn.hideLabel) {\n          if (this.smartGrid!.translateService) {\n            label = await this.smartGrid!.translateService?.get(orignalLabel).toPromise();\n          } else {\n            label = orignalLabel;\n          }\n        }\n\n        let properties = customTableHeader?.properties;\n        if (!properties) {\n          properties = this.getSmartTableProperty(descColumn);\n        }\n\n        return {\n          ...customTableHeader,\n          label: label,\n          propertyName: 'data.' + descColumn.propertyName,\n          order,\n          orderNumber,\n          properties,\n          style: descColumn.style,\n        };\n      })\n    );\n\n    let complement = this.smartGrid!.tableConfig?.customSmartTableHeaders?.filter(\n      (tableHeader: SmartTableHeader) =>\n        !header.some((tH: SmartTableHeader) => tH.propertyName.includes(tableHeader.propertyName))\n    );\n\n    if (complement) {\n      header.push(...complement);\n    }\n\n    if (this.smartGrid!.options?.simpleButtons) {\n      this.smartGrid!.options.simpleButtons.forEach((uiActionCode: string) => {\n        header.push({\n          label: '',\n          propertyName: 'simple_buttons',\n          buttons: [\n            {\n              type: SmartTableButtonType.RAISED,\n              callback: this.execute.bind(this),\n              // label: this.buttonTranslator({ code: uiActionCode }),\n              args: [\n                {\n                  code: uiActionCode,\n                },\n              ],\n              color: 'primary',\n              showButtonIf: (row: any) =>\n                row.actions.some((item: any) => {\n                  return item.code === uiActionCode;\n                }),\n            },\n          ],\n        });\n      });\n    }\n\n    if (!header.some((header: SmartTableHeader) => header.propertyName === 'my_menu')) {\n      if (this.smartGrid!.options?.rowUiActionType === GridUiActionType.POPUP_MENU) {\n        let icon = this.gridMenuIcon ?? 'more_vert';\n        header.push({\n          label: '',\n          propertyName: 'my_menu',\n          buttons: [\n            {\n              type: SmartTableButtonType.MENU,\n              callback: this.execute.bind(this),\n              icon: icon,\n              menuItemButtonsPropertyName: 'actions',\n              translator: this.buttonTranslator.bind(this),\n              args: [],\n            },\n          ],\n          isSortable: false,\n        });\n      }\n    }\n\n    return header;\n  }\n\n  private getSmartTableProperty(descColumn: GridColumnMeta) {\n    if (\n      descColumn.typeClass === 'java.time.OffsetDateTime' ||\n      descColumn.typeClass === 'java.time.LocalDateTime'\n    ) {\n      let dateFormat = descColumn.typeFormat ?? 'yyyy.MM.dd H:mm';\n      return {\n        type: SmartTableHeaderPropertyType.DATETIME,\n        dateFormat,\n      };\n    } else if (descColumn.typeClass === 'java.time.LocalDate') {\n      let dateFormat = descColumn.typeFormat ?? 'yyyy.MM.dd';\n      return {\n        type: SmartTableHeaderPropertyType.DATE,\n        dateFormat,\n      };\n    } else if (descColumn.typeClass === 'java.time.LocalTime') {\n      let dateFormat = descColumn.typeFormat ?? 'H:mm';\n      return {\n        type: SmartTableHeaderPropertyType.TIME,\n        dateFormat,\n      };\n    } else if (descColumn.typeClass === 'java.lang.Boolean') {\n      return {\n        type: SmartTableHeaderPropertyType.CHECKBOX,\n      };\n    }\n\n    return undefined;\n  }\n\n  public async onChangePage(event: PageEvent): Promise<void> {\n    let offset = event.pageSize * event.pageIndex;\n    let limit = event.pageSize;\n    this.pageIndex = event.pageIndex;\n    await this.service.setPage(\n      this.smartGrid!.gridModel.viewUuid!,\n      this.smartGrid!.gridIdentifier,\n      offset.toString(),\n      limit.toString()\n    );\n  }\n\n  public async onPrimeChangePage(event: any): Promise<void> {\n    let offset = event.first;\n    let limit = event.rows;\n    this.pageIndex = event.first;\n    await this.service.setPage(\n      this.smartGrid!.gridModel.viewUuid!,\n      this.smartGrid!.gridIdentifier,\n      offset.toString(),\n      limit.toString()\n    );\n  }\n\n  async refreshPartialResults(): Promise<void> {\n    await this.service.refresh(this.smartGrid!.gridModel.viewUuid!, this.smartGrid!.gridIdentifier);\n  }\n\n  private async execute(args: any[], row: any, uiAction: any): Promise<void> {\n    let _uiAction: UiAction;\n\n    if (!uiAction) {\n      uiAction = row.actions.filter((action: UiAction) => action.code === args[0].code)[0];\n    }\n\n    _uiAction = { ...uiAction };\n    if (_uiAction.disabled) {\n      return;\n    }\n    _uiAction.params = {\n      ...uiAction.params,\n      model: row,\n    };\n\n    let uiActionModel: any = {\n      serviceToUse: this.smartGrid!.serviceToUse,\n      uiAction: _uiAction,\n    };\n\n    if (this.smartGrid!.options?.uiActionModelCallback) {\n      uiActionModel = this.smartGrid!.options!.uiActionModelCallback(uiActionModel);\n    }\n\n    this.smartGrid!.uiActionService.execute(_uiAction, uiActionModel, {\n      widgetId: this.smartGrid!.gridIdentifier,\n      nodeId: row.id,\n    });\n  }\n\n  private buttonTranslator(uiAction: UiAction): UiActionDescriptor {\n    let desc = this.uiActionDescriptors.get(uiAction.code!);\n    if (!desc) {\n      desc = {\n        title: uiAction.code!,\n        type: UiActionButtonType.FLAT,\n        color: 'primary',\n      };\n    }\n    if (uiAction.descriptor) {\n      this.uiActionDescriptorService.mergeActionDescriptorIntoClient(uiAction.descriptor!, desc);\n    }\n    return desc;\n  }\n\n  public layoutDef(): typeof SmartLayoutDef {\n    return SmartLayoutDef;\n  }\n\n  public onClick(gridRow: GridRow): void {\n    this.handleOnClick(gridRow);\n  }\n  public onDoubleClick(gridRow: GridRow): void {\n    this.handleOnClick(gridRow);\n  }\n\n  private handleOnClick(gridRow: GridRow): void {\n    let defaultRowAction: UiAction | undefined;\n    if (this.service.gridModel?.defaultRowActions) {\n      for (let index = 0; index < this.service.gridModel.defaultRowActions.length; index++) {\n        const defaultRowActionCode = this.service.gridModel.defaultRowActions[index];\n\n        defaultRowAction = gridRow.actions.find(\n          (uiAction: UiAction) => uiAction.code === defaultRowActionCode\n        );\n        if (defaultRowAction) {\n          this.execute([], gridRow, defaultRowAction);\n          return;\n        }\n      }\n    }\n  }\n\n  public async onSelect(rowId: any): Promise<void> {\n    this.isBlocked = true;\n    const row = this.service.gridModel.page.rows?.find((gridRow: GridRow) => gridRow.id === rowId);\n    const viewContextChange = await this.service.select(this.smartGrid!, row!);\n    this.smartGrid!.viewContextService.handlePerformActionResponse(viewContextChange);\n    this.refresh();\n  }\n\n  private async onSelectAll(selected: boolean): Promise<void> {\n    this.isBlocked = true;\n\n    const viewContextChange = await this.service.selectAll(this.smartGrid!, selected);\n    this.smartGrid!.viewContextService.handlePerformActionResponse(viewContextChange);\n\n    this.refresh();\n  }\n\n  private async onSelectRows(\n    selectedIds: (string | undefined)[],\n    unselectedIds: (string | undefined)[]\n  ): Promise<void> {\n    this.isBlocked = true;\n    let selected: string[] = selectedIds.filter((item): item is string => item !== undefined);\n    let unselected: string[] = unselectedIds.filter((item): item is string => item !== undefined);\n    const viewContextChange = await this.service.selectRows(this.smartGrid!, selected, unselected);\n    this.smartGrid!.viewContextService.handlePerformActionResponse(viewContextChange);\n    this.refresh();\n  }\n\n  async onRowSelect(event: TableRowSelectEvent) {\n    await this.onSelect(event.data.id);\n  }\n\n  async onRowUnselect(event: TableRowUnSelectEvent) {\n    await this.onSelect(event.data.id);\n  }\n\n  async onSelectAllRow(event: TableHeaderCheckboxToggleEvent) {\n    await this.onSelectAll(event.checked);\n  }\n\n  editColumns(): void {\n    let dialogData: SmartDialogData = {\n      content: {\n        title: 'Oszlopok testreszabása',\n      },\n      size: {},\n      customComponent: TableLayoutDefinerComponent,\n      customComponentInputs: {\n        config: {\n          uuid: this.uuid,\n          identifier: this.smartGrid!.gridIdentifier,\n          view: this.service.gridModel.view,\n          service: this.service,\n        },\n      },\n    };\n    this.dialog.open(TableLayoutDefinerComponent, { data: dialogData });\n  }\n\n  //PRIMENG\n  columns: GridColumnMeta[] = [];\n  menuButtons!: MenuItem[];\n  @ViewChild('menu') menu!: Menu;\n  onOptionsClick(event: Event, row: GridRow) {\n    this.menuButtons = [];\n\n    let menuActions = this.calculateMenuActions(row);\n\n    menuActions?.map(async (uiAction: any) => {\n      let desc = await this.uiActionDescriptorService.getActionDescriptor(uiAction);\n\n      this.menuButtons.push({\n        label: desc?.title ?? uiAction.code,\n        icon: desc?.icon,\n        automationId: uiAction.code,\n        command: () => {\n          this.execute([], row, uiAction);\n        },\n      });\n    });\n    this.menu.toggle(event);\n  }\n\n  previousmultiSortMeta?: SortMeta[];\n  async gridSort(event: any) {\n    let orderByList: Array<FilterExpressionOrderBy> = [];\n\n    event.multisortmeta?.map((meta: SortMeta, index: number) => {\n      if (this.previousmultiSortMeta && this.previousmultiSortMeta.length > 0) {\n        this.previousmultiSortMeta.map((order) => {\n          if (meta.field === order.field && order.order != meta.order) {\n            switch (order.order) {\n              case -1:\n                event.multisortmeta!.splice(index, 1);\n                break;\n            }\n          }\n        });\n      } else {\n        this.previousmultiSortMeta = event.multisortmeta;\n      }\n    });\n    event.multisortmeta?.map((meta: any) => {\n      orderByList.push({\n        propertyName: meta.field,\n        order:\n          meta.order === 1\n            ? FilterExpressionOrderByOrderEnum.ASC\n            : meta.order === -1\n              ? FilterExpressionOrderByOrderEnum.DESC\n              : undefined,\n      });\n    });\n\n    await this.service.sort(this.smartGrid!, {\n      orderByList: orderByList,\n      orderedColumnNames: this.smartGrid?.gridModel.view?.orderedColumnNames!,\n    });\n  }\n  lazyLoad(event?: TableLazyLoadEvent) {\n    this.previousmultiSortMeta = [];\n    this.smartGrid?.gridModel.view?.orderByList.map((order) => {\n      this.previousmultiSortMeta?.push({\n        field: order.propertyName!,\n        order: order.order === FilterExpressionOrderByOrderEnum.ASC ? 1 : -1,\n      });\n    });\n    event!.multiSortMeta = this.previousmultiSortMeta;\n  }\n\n  async headerChange(event: MultiSelectChangeEvent): Promise<void> {\n    let gridUpdateData: GridUpdateData = {\n      orderByList: this.smartGrid!.gridModel.view!.orderByList,\n      orderedColumnNames: this.getOrderColumNames(event.value!),\n    };\n\n    await this.service.update(this.uuid!, this.smartGrid?.gridIdentifier!, gridUpdateData);\n  }\n\n  async onColOrder(event: TableColumnReorderEvent): Promise<void> {\n    let gridUpdateData: GridUpdateData = {\n      orderByList: this.smartGrid!.gridModel.view!.orderByList,\n      orderedColumnNames: this.getOrderColumNames(event.columns!),\n    };\n    await this.service.update(this.uuid!, this.smartGrid!.gridIdentifier!, gridUpdateData);\n  }\n\n  getOrderColumNames(columns: GridColumnMeta[]): string[] {\n    return columns.map((colum: GridColumnMeta) => {\n      return colum.propertyName;\n    });\n  }\n\n  getColValue(col: string, row: any) {\n    if (row.icons[col]) {\n      return;\n    }\n\n    let retValue = '';\n    if (col.includes('.')) {\n      let pathArray = col.split('.');\n      let colValue = row.data;\n      pathArray.map((path) => {\n        if (colValue == undefined) {\n          colValue = row.data[col];\n          return;\n        } else {\n          colValue = colValue[path];\n        }\n      });\n      retValue = colValue;\n    } else {\n      retValue = row.data[col];\n    }\n\n    if (this.columnMetaByName) {\n      let columnMeta = this.columnMetaByName!.get(col);\n      if (columnMeta) {\n        let property = this.getSmartTableProperty(columnMeta);\n        switch (property?.type) {\n          case SmartTableHeaderPropertyType.DATE:\n            retValue = this.smartDatePipe.transform(retValue, property.dateFormat);\n            break;\n          case SmartTableHeaderPropertyType.DATETIME:\n            retValue = this.smartDateTimePipe.transform(retValue, property.dateFormat);\n            break;\n          case SmartTableHeaderPropertyType.TIME:\n            retValue = this.smartTimePipe.transform(retValue, property.dateFormat);\n            break;\n        }\n      }\n    }\n    return retValue;\n  }\n\n  getImageResourceIcons(row: any, header: string): ImageResource[] {\n    if (row?.icons) {\n      let iconCodes = row?.icons[header];\n      return iconCodes;\n    }\n    return [];\n  }\n  getImageResourceStyle(resource: ImageResource): any {\n    return resource.style ? resource.style : {};\n  }\n\n  getRowColumnAction(row: any, columnName: string): UiActionModel[] {\n    return SmartGridToolbarActionsUtil.getActionModelsFromMap(\n      this.cellToActionMap,\n      row,\n      columnName\n    );\n  }\n\n  showCellToolbar(row: any, columnName: string): boolean {\n    return SmartGridToolbarActionsUtil.showToolbar(row, columnName);\n  }\n\n  shouldShowOptionsButton(row: any): boolean {\n    return SmartGridToolbarActionsUtil.showMenu(\n      row,\n      this.smartGrid?.gridModel.view?.orderedColumnNames!\n    );\n  }\n\n  calculateMenuActions(row: GridRow): UiAction[] {\n    return SmartGridToolbarActionsUtil.calculateMenuActions(\n      row,\n      this.smartGrid?.gridModel.view?.orderedColumnNames!\n    );\n  }\n  createCellToActionMap() {\n    if (this.compLib === this.componentLibrary.PRIMENG && this.smartGrid?.gridModel.page.rows) {\n      this.cellToActionMap = SmartGridToolbarActionsUtil.calculateCellToActionMap(\n        this.smartGrid?.gridModel.page.rows!,\n        this.smartGrid.serviceToUse,\n        this.smartGrid.gridIdentifier\n      );\n    }\n  }\n  rowTrackByFn(index: number, row: any) {\n    return row.id;\n  }\n}\n","@if(compLib === componentLibrary.PRIMENG) {\n\n<div *ngIf=\"smartGrid\" class=\"primeSmartGrid-container\">\n  <div class=\"smart-grid-toolbar\">\n    <smart-ui-action-toolbar #toolbar [id]=\"'grid_not_initialized'\"></smart-ui-action-toolbar>\n  </div>\n  <p-table\n    *ngIf=\"!smartGrid.layoutDef || smartGrid.layoutDef === layoutDef().TABLE\"\n    #pTable\n    [value]=\"smartGrid.gridModel.page.rows!\"\n    (onSort)=\"gridSort($event)\"\n    [customSort]=\"true\"\n    [sortMode]=\"'multiple'\"\n    [lazy]=\"true\"\n    (onLazyLoad)=\"lazyLoad($event)\"\n    [reorderableColumns]=\"smartGrid.gridModel.view?.descriptor?.showEditColumns\"\n    [columns]=\"columns\"\n    (onColReorder)=\"onColOrder($event)\"\n    (onRowSelect)=\"onRowSelect($event)\"\n    (onRowUnselect)=\"onRowUnselect($event)\"\n    [selection]=\"selectedRows\"\n    (onHeaderCheckboxToggle)=\"onSelectAllRow($event)\"\n    dataKey=\"id\"\n    [expandedRowKeys]=\"expandedRows\"\n    [rowExpandMode]=\"'multiple'\"\n    [rowTrackBy]=\"rowTrackByFn\"\n  >\n    <ng-template pTemplate=\"caption\">\n      <div class=\"tableCaption\">\n        <div *ngIf=\"smartGrid.gridModel.title\" class=\"captionTitle\">\n          {{ smartGrid.gridModel.title }}\n        </div>\n        <div *ngIf=\"smartGrid.gridModel.view?.descriptor?.showEditColumns\">\n          <p-multiSelect\n            display=\"chip\"\n            [options]=\"smartGrid.gridModel.view?.descriptor?.columns\"\n            optionLabel=\"label\"\n            [(ngModel)]=\"columns\"\n            selectedItemsLabel=\"{0} columns selected\"\n            [style]=\"{ 'min-width': '200px' }\"\n            placeholder=\"Choose Columns\"\n            (onChange)=\"headerChange($event)\"\n          />\n        </div>\n      </div>\n    </ng-template>\n    <ng-template pTemplate=\"header\">\n      <tr>\n        @if (smartGrid.gridModel.view?.descriptor?.showEditColumns) {\n        <th\n          *ngIf=\"isMultiple && (tableType === 'checkbox' || tableType === 'CheckBox')\"\n          style=\"width: 4rem\"\n        >\n          <p-tableHeaderCheckbox />\n        </th>\n        <th\n          *ngIf=\"!isMultiple && (tableType === 'checkbox' || tableType === 'CheckBox')\"\n          style=\"width: 4rem\"\n        ></th>\n        <th\n          [pSortableColumn]=\"col.propertyName\"\n          *ngFor=\"let col of columns\"\n          pReorderableColumn\n          [attr.data-testid]=\"col.propertyName\"\n        >\n          <p-sortIcon [field]=\"col.propertyName\" />\n          {{ col.label }}\n        </th>\n        } @else {\n        <th\n          *ngIf=\"isMultiple && (tableType === 'checkbox' || tableType === 'CheckBox')\"\n          style=\"width: 4rem\"\n        >\n          <p-tableHeaderCheckbox />\n        </th>\n        <th\n          *ngIf=\"!isMultiple && (tableType === 'checkbox' || tableType === 'CheckBox')\"\n          style=\"width: 4rem\"\n        ></th>\n        <th\n          [pSortableColumn]=\"col.propertyName\"\n          *ngFor=\"let col of columns\"\n          [attr.data-testid]=\"col.propertyName\"\n        >\n          <p-sortIcon [field]=\"col.propertyName\" />\n          {{ col.label }}\n        </th>\n        }\n\n        <th>\n          <smart-ui-action-toolbar\n            class=\"headerToolbar\"\n            #headerToolbar\n            [id]=\"'header_not_initialized'\"\n          ></smart-ui-action-toolbar>\n        </th>\n        <th *ngIf=\"smartGrid.expandable\"> </th>\n      </tr>\n    </ng-template>\n    <ng-template pTemplate=\"body\" let-row let-expanded=\"expanded\">\n      <tr\n        [ngClass]=\"getStyle(row)\"\n        [class.rowExpanded]=\"expanded\"\n        (dblclick)=\"onDoubleClick(row)\"\n        *ngIf=\"row && row.data\"\n        [attr.data-testid]=\"row.id ?? null\"\n      >\n        <td *ngIf=\"isMultiple && (tableType === 'checkbox' || tableType === 'CheckBox')\">\n          <p-tableCheckbox *ngIf=\"row.selectable != false\" [value]=\"row\" />\n        </td>\n        <td *ngIf=\"!isMultiple && (tableType === 'checkbox' || tableType === 'CheckBox')\">\n          <p-tableRadioButton [value]=\"row\" />\n        </td>\n        <td *ngFor=\"let col of smartGrid?.gridModel?.view?.orderedColumnNames\">\n          <div *ngIf=\"row.icons[col]\">\n            <div class=\"smart-table-icon-container\">\n              <div *ngFor=\"let ir of getImageResourceIcons(row, col)\">\n                <smart-icon [imageResource]=\"ir\"> </smart-icon>\n              </div>\n            </div>\n          </div>\n          <ng-container *ngIf=\"showCellToolbar(row, col)\">\n            <smart-ui-action-toolbar\n              [uiActionModels]=\"getRowColumnAction(row, col)\"\n            ></smart-ui-action-toolbar>\n          </ng-container>\n\n          <div *ngIf=\"!row.icons[col]\" [innerHtml]=\"getColValue(col, row)\"> </div>\n        </td>\n        <td>\n          <div class=\"menu-button\">\n            @if(showCellToolbar(row, defaultActionToolbarId)){\n            <smart-ui-action-toolbar\n              [uiActionModels]=\"getRowColumnAction(row, defaultActionToolbarId)\"\n            ></smart-ui-action-toolbar>\n            }\n            <p-button\n              [rounded]=\"true\"\n              [text]=\"true\"\n              *ngIf=\"shouldShowOptionsButton(row)\"\n              (onClick)=\"onOptionsClick($event, row)\"\n            >\n              <smart-icon icon=\"ellipsis-v\"></smart-icon>\n            </p-button>\n          </div>\n        </td>\n        <td *ngIf=\"smartGrid.expandable\">\n          <p-button\n            type=\"button\"\n            pRipple\n            [pRowToggler]=\"row\"\n            [text]=\"true\"\n            severity=\"secondary\"\n            [rounded]=\"true\"\n            [icon]=\"expanded ? 'pi pi-chevron-up' : 'pi pi-chevron-down'\"\n          />\n        </td>\n      </tr>\n    </ng-template>\n    @if(smartGrid.expandable){\n    <ng-template pTemplate=\"rowexpansion\" let-row>\n      <tr>\n        <td colspan=\"100%\">\n          <lib-expanded-row-renderer-component\n            [rowId]=\"row.id\"\n            [rowExpander]=\"this\"\n            [expandedComponent]=\"smartGrid.expandedComponent\"\n            [smartGrid]=\"this.smartGrid\"\n          ></lib-expanded-row-renderer-component>\n        </td>\n      </tr>\n    </ng-template>\n    }\n  </p-table>\n  <div\n    *ngIf=\"smartGrid.layoutDef === layoutDef().CARD && smartGrid.dataLayoutDef\"\n    class=\"cards-container\"\n    [ngStyle]=\"{\n      'grid-template-columns':\n        smartGrid.numberOfColumn !== undefined\n          ? 'repeat(' + smartGrid.numberOfColumn + ', 1fr)'\n          : ''\n    }\"\n  >\n    <app-smart-grid-card\n      class=\"smartGrid-card-container\"\n      *ngFor=\"let task of smartGrid.gridModel.page.rows\"\n      [item]=\"task\"\n      [smartGrid]=\"smartGrid\"\n      [onSelect]=\"onSelect.bind(this)\"\n    ></app-smart-grid-card>\n  </div>\n<div *ngIf=\"smartGrid.paginator\" class=\"paginator-row\">\n  <div class=\"paginator-wrap\">\n    <p-paginator\n      [first]=\"pageIndex!\"\n      [totalRecords]=\"length!\"\n      [rows]=\"pageSize\"\n      [rowsPerPageOptions]=\"pageSizeOptions\"\n      currentPageReportTemplate=\"{first} - {last} / {totalRecords}\"\n      (onPageChange)=\"onPrimeChangePage($event)\"\n      [showCurrentPageReport]=\"true\"\n      dropdownAppendTo=\"body\"\n    ></p-paginator>\n  </div>\n\n  <button\n    pButton\n    type=\"button\"\n    icon=\"pi pi-refresh\"\n    class=\"p-button-text\"\n    pTooltip=\"Frissítés\"\n    (click)=\"refreshPartialResults()\"\n    *ngIf=\"smartGrid.gridModel?.refreshEnabled\"\n  ></button>\n</div>\n  <p-menu #menu [model]=\"menuButtons\" [popup]=\"true\" appendTo=\"body\"> </p-menu>\n</div>\n}@else {\n<div *ngIf=\"smartGrid\" class=\"smartGrid-container\">\n  <div class=\"smart-grid-toolbar\">\n    <smart-ui-action-toolbar #toolbar [id]=\"'grid_not_initialized'\"></smart-ui-action-toolbar>\n    <button\n      (click)=\"editColumns()\"\n      mat-mini-fab\n      color=\"text-primary\"\n      *ngIf=\"smartGrid.showEditColumns\"\n    >\n      <mat-icon aria-hidden=\"false\" aria-label=\"Columns\" class=\"smart-grid-edit-icon\"\n        >view_columns</mat-icon\n      >\n    </button>\n  </div>\n  <!-- <div [ngClass]=\"isBlocked ? 'blocked' : ''\"></div> -->\n  <div class=\"smartGridContent\">\n    <div>\n      <div *ngIf=\"smartGrid.showResultCount\">\n        <div class=\"smartGrid-data-number\">\n          {{ smartGrid.gridModel.totalRowCount }}\n        </div>\n      </div>\n    </div>\n\n    <div class=\"smart-grid-table-container\">\n      <ng-template #table></ng-template>\n    </div>\n\n    <div *ngIf=\"smartGrid.layoutDef === layoutDef().EXPANDABLE\">\n      <smart-expandable-section\n        #gridExpandableSection\n        *ngFor=\"let expandableSection of expandableSections\"\n        [data]=\"expandableSection\"\n      ></smart-expandable-section>\n    </div>\n    <div\n      *ngIf=\"smartGrid.layoutDef === layoutDef().CARD && smartGrid.dataLayoutDef\"\n      class=\"cards-container\"\n      [ngStyle]=\"{\n        'grid-template-columns':\n          smartGrid.numberOfColumn !== undefined\n            ? 'repeat(' + smartGrid.numberOfColumn + ', 1fr)'\n            : ''\n      }\"\n    >\n      <app-smart-grid-card\n        class=\"smartGrid-card-container\"\n        *ngFor=\"let task of smartGrid.gridModel.page.rows\"\n        [item]=\"task\"\n        [smartGrid]=\"smartGrid\"\n        [onSelect]=\"onSelect.bind(this)\"\n      ></app-smart-grid-card>\n    </div>\n    <div\n      *ngIf=\"smartGrid.layoutDef === layoutDef().TREE && treeControl\"\n      class=\"tree-container\"\n      [ngStyle]=\"{\n        'grid-template-columns':\n          smartGrid.numberOfColumn !== undefined\n            ? 'repeat(' + smartGrid.numberOfColumn + ', 1fr)'\n            : ''\n      }\"\n    >\n      <mat-tree [dataSource]=\"treeDataSource!\" [treeControl]=\"treeControl!\">\n        <mat-tree-node\n          *matTreeNodeDef=\"let node\"\n          matTreeNodeToggle\n          matTreeNodePadding\n          matTreeNodePaddingIndent=\"24\"\n        >\n          <button mat-icon-button disabled class=\"tree-button\"></button>\n          <mat-checkbox\n            class=\"checklist-leaf-node\"\n            [checked]=\"treeChecklistSelection?.isSelected(node)\"\n            (change)=\"treeNodeSelectionToggle(node)\"\n            >{{ getTreeItem(node) }}</mat-checkbox\n          >\n        </mat-tree-node>\n\n        <mat-tree-node\n          *matTreeNodeDef=\"let node; when: hasChild\"\n          matTreeNodePadding\n          matTreeNodePaddingIndent=\"24\"\n        >\n          <button\n            mat-icon-button\n            matTreeNodeToggle\n            class=\"tree-button\"\n            [attr.aria-label]=\"'Toggle ' + node.item\"\n          >\n            <mat-icon class=\"mat-icon-rtl-mirror\">\n              {{ treeControl!.isExpanded(node) ? 'expand_more' : 'chevron_right' }}\n            </mat-icon>\n          </button>\n          <mat-checkbox\n            [checked]=\"treeChecklistSelection?.isSelected(node)\"\n            [indeterminate]=\"descendantsPartiallySelected(node)\"\n            (change)=\"treeNodeSelectionToggle(node)\"\n            >{{ getTreeItem(node) }}</mat-checkbox\n          >\n        </mat-tree-node>\n      </mat-tree>\n    </div>\n  </div>\n<div *ngIf=\"smartGrid.paginator\" class=\"paginator-row-material\">\n  <button\n   pButton\n   type=\"button\"\n   icon=\"pi pi-refresh\"\n   class=\"p-button-text\"\n   pTooltip=\"Frissítés\"\n   (click)=\"refreshPartialResults()\"\n   *ngIf=\"smartGrid.gridModel?.refreshEnabled\"\n ></button>\n  <mat-paginator\n    *ngIf=\"smartGrid.paginator && !treeControl\"\n    #paginator\n    [length]=\"length\"\n    [pageIndex]=\"pageIndex\"\n    [pageSize]=\"pageSize\"\n    [pageSizeOptions]=\"pageSizeOptions\"\n    (page)=\"onChangePage($event)\"\n  ></mat-paginator>\n  </div>\n</div>\n}\n"]}