@pega/angular-sdk-components 0.23.1

package/esm2022/lib/_components/template/simple-table-manual/simple-table-manual.component.mjs

@@ -0,0 +1,760 @@
+/* eslint-disable max-classes-per-file */
+import { Component, Input, ViewChild, forwardRef } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { MatButtonModule } from '@angular/material/button';
+import { MatDatepickerModule } from '@angular/material/datepicker';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatInputModule } from '@angular/material/input';
+import { MatMenuModule } from '@angular/material/menu';
+import { MatOptionModule } from '@angular/material/core';
+import { MatSelectModule } from '@angular/material/select';
+import { MatSort, MatSortModule } from '@angular/material/sort';
+import { MatTableDataSource, MatTableModule } from '@angular/material/table';
+import isEqual from 'fast-deep-equal';
+import { ComponentMapperComponent } from '../../../_bridge/component-mapper/component-mapper.component';
+import { getReferenceList } from '../../../_helpers/field-group-utils';
+import { buildFieldsForTable, filterDataByCommonFields, filterDataByDate, getContext } from './helpers';
+import { getSeconds } from '../../../_helpers/common';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../_bridge/angular-pconnect";
+import * as i2 from "../../../_helpers/utils";
+import * as i3 from "../../../_services/datapage.service";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/material/table";
+import * as i6 from "@angular/material/button";
+import * as i7 from "@angular/material/sort";
+import * as i8 from "@angular/material/menu";
+import * as i9 from "@angular/material/form-field";
+import * as i10 from "@angular/material/datepicker";
+import * as i11 from "@angular/material/core";
+import * as i12 from "@angular/material/select";
+import * as i13 from "@angular/material/input";
+class Group {
+    constructor() {
+        this.level = 0;
+        this.expanded = true;
+        this.totalCounts = 0;
+    }
+    get visible() {
+        return !this.parent || (this.parent.visible && this.parent.expanded);
+    }
+}
+export class SimpleTableManualComponent {
+    constructor(angularPConnect, utils, dataPageService) {
+        this.angularPConnect = angularPConnect;
+        this.utils = utils;
+        this.dataPageService = dataPageService;
+        // Used with AngularPConnect
+        this.angularPConnectData = {};
+        this.bVisible$ = true;
+        this.displayedColumns = [];
+        this.originalData = [];
+        this.processedFields = [];
+        this.fieldDefs = [];
+        this.requestedReadOnlyMode = false;
+        this.readOnlyMode = false;
+        this.prevReferenceList = [];
+        this.label = '';
+        this.bShowSearch$ = false;
+        this.bColumnReorder$ = false;
+        this.bGrouping$ = false;
+        this.arrowSvgIcon$ = '';
+        this.groupByColumns$ = [];
+        this.arrowDirection = 'down';
+        this.filterByColumns = [];
+        this.filterContainsLabel$ = '';
+        this.filterContainsType$ = 'contains';
+        this.bShowFilterPopover$ = false;
+        this.bContains$ = true;
+        this.bDateTime$ = false;
+        this.bIsDate$ = false;
+        this.bIsDateTime$ = false;
+        this.bIsTime$ = false;
+        this.arFilterMainButtons$ = [];
+        this.arFilterSecondaryButtons$ = [];
+        this.allowEditingInModal = false;
+    }
+    ngOnInit() {
+        // First thing in initialization is registering and subscribing to the AngularPConnect service
+        this.angularPConnectData = this.angularPConnect.registerAndSubscribeComponent(this, this.onStateChange);
+        this.configProps$ = this.pConn$.getConfigProps();
+        // Then, continue on with other initialization
+        this.menuIconOverride$ = this.utils.getImageSrc('trash', this.utils.getSDKStaticContentUrl());
+        // call checkAndUpdate when initializing
+        this.checkAndUpdate();
+        this.filterSvgIcon$ = this.utils.getImageSrc('filter', this.utils.getSDKStaticContentUrl());
+        this.filterOnSvgIcon$ = this.utils.getImageSrc('filter-on', this.utils.getSDKStaticContentUrl());
+        this.groupBySvgIcon$ = this.utils.getImageSrc('row', this.utils.getSDKStaticContentUrl());
+        this.bGrouping$ = this.utils.getBooleanValue(this.configProps$.grouping);
+        this.menuSvgIcon$ = this.utils.getImageSrc('more', this.utils.getSDKStaticContentUrl());
+        this.arFilterMainButtons$.push({ actionID: 'submit', jsAction: 'submit', name: 'Submit' });
+        this.arFilterSecondaryButtons$.push({ actionID: 'cancel', jsAction: 'cancel', name: 'Cancel' });
+        this.searchIcon$ = this.utils.getImageSrc('search', this.utils.getSDKStaticContentUrl());
+        this.settingsSvgIcon$ = this.utils.getImageSrc('more', this.utils.getSDKStaticContentUrl());
+    }
+    ngOnDestroy() {
+        if (this.angularPConnectData.unsubscribeFn) {
+            this.angularPConnectData.unsubscribeFn();
+        }
+    }
+    checkAndUpdate() {
+        // Should always check the bridge to see if the component should
+        // update itself (re-render)
+        const bUpdateSelf = this.angularPConnect.shouldComponentUpdate(this);
+        // ONLY call updateSelf when the component should update
+        if (bUpdateSelf) {
+            this.updateSelf();
+        }
+    }
+    // updateSelf
+    updateSelf() {
+        // moved this from ngOnInit() and call this from there instead...
+        this.configProps$ = this.pConn$.resolveConfigProps(this.pConn$.getConfigProps());
+        if (this.configProps$.visibility != null) {
+            // eslint-disable-next-line no-multi-assign
+            this.bVisible$ = this.bVisible$ = this.utils.getBooleanValue(this.configProps$.visibility);
+        }
+        // NOTE: getConfigProps() has each child.config with datasource and value undefined
+        //  but getRawMetadata() has each child.config with datasource and value showing their unresolved values (ex: "@P thePropName")
+        //  We need to use the prop name as the "glue" to tie the Angular Material table dataSource, displayColumns and data together.
+        //  So, in the code below, we'll use the unresolved config.value (but replacing the space with an underscore to keep things happy)
+        const rawMetadata = this.pConn$.getRawMetadata();
+        // Adapted from Nebula
+        const { referenceList = [], // if referenceList not in configProps$, default to empy list
+        renderMode, children, // destructure children into an array var: "resolvedFields"
+        presets, allowTableEdit, label: labelProp, propertyLabel, fieldMetadata, editMode, addAndEditRowsWithin, viewForAddAndEditModal, editModeConfig, displayMode, useSeparateViewForEdit, viewForEditModal } = this.configProps$;
+        this.referenceListStr = getContext(this.pConn$).referenceListStr;
+        this.label = labelProp || propertyLabel;
+        this.parameters = fieldMetadata?.datasource?.parameters;
+        const hideAddRow = allowTableEdit === false;
+        const hideDeleteRow = allowTableEdit === false;
+        let { contextClass } = this.configProps$;
+        this.referenceList = referenceList;
+        if (!contextClass) {
+            // @ts-ignore - Property 'getComponentConfig' is private and only accessible within class 'C11nEnv'
+            let listName = this.pConn$.getComponentConfig().referenceList;
+            listName = PCore.getAnnotationUtils().getPropertyName(listName);
+            // @ts-ignore - Property 'getFieldMetadata' is private and only accessible within class 'C11nEnv'
+            contextClass = this.pConn$.getFieldMetadata(listName)?.pageClass;
+        }
+        this.contextClass = contextClass;
+        const resolvedFields = children?.[0]?.children || presets?.[0].children?.[0].children;
+        // get raw config as @P and other annotations are processed and don't appear in the resolved config.
+        //  Destructure "raw" children into array var: "rawFields"
+        //  NOTE: when config.listType == "associated", the property can be found in either
+        //    config.value (ex: "@P .DeclarantChoice") or
+        //    config.datasource (ex: "@ASSOCIATED .DeclarantChoice")
+        //  Neither of these appear in the resolved (this.configProps$)
+        const rawConfig = rawMetadata?.config;
+        const rawFields = rawConfig?.children?.[0]?.children || rawConfig?.presets?.[0].children?.[0]?.children;
+        this.rawFields = rawFields;
+        // At this point, fields has resolvedFields and rawFields we can use
+        // start of from Nebula
+        // get context name and referenceList which will be used to prepare config of PConnect
+        // const { contextName, referenceListStr, pageReferenceForRows } = getContext(this.pConn$);
+        const resolvedList = getReferenceList(this.pConn$);
+        this.pageReference = `${this.pConn$.getPageReference()}${resolvedList}`;
+        this.pConn$.setReferenceList(resolvedList);
+        // This gives up the "properties" we need to map to row/column values later
+        // const processedData = populateRowKey(referenceList);
+        this.requestedReadOnlyMode = renderMode === 'ReadOnly';
+        this.readOnlyMode = renderMode === 'ReadOnly';
+        this.editableMode = renderMode === 'Editable';
+        const isDisplayModeEnabled = displayMode === 'DISPLAY_ONLY';
+        this.showAddRowButton = !this.readOnlyMode && !hideAddRow;
+        this.allowEditingInModal =
+            (editMode ? editMode === 'modal' : addAndEditRowsWithin === 'modal') && !(renderMode === 'ReadOnly' || isDisplayModeEnabled);
+        const showDeleteButton = this.editableMode && !hideDeleteRow;
+        this.defaultView = editModeConfig ? editModeConfig.defaultView : viewForAddAndEditModal;
+        this.bUseSeparateViewForEdit = editModeConfig ? editModeConfig.useSeparateViewForEdit : useSeparateViewForEdit;
+        this.editView = editModeConfig ? editModeConfig.editView : viewForEditModal;
+        // const showDeleteButton = !this.readOnlyMode && !hideDeleteRow;
+        // Nebula has other handling for isReadOnlyMode but has Cosmos-specific code
+        //  so ignoring that for now...
+        // fieldDefs will be an array where each entry will have a "name" which will be the
+        //  "resolved" property name (that we can use as the colId) though it's not really
+        //  resolved. The buildFieldsForTable helper just removes the "@P " (which is what
+        //  Nebula does). It will also have the "label", and "meta" contains the original,
+        //  unchanged config info. For now, much of the info here is carried over from
+        //  Nebula and we may not end up using it all.
+        this.fieldDefs = buildFieldsForTable(rawFields, resolvedFields, showDeleteButton);
+        // end of from Nebula
+        // Here, we use the "name" field in fieldDefs since that has the assoicated property
+        //  (if one exists for the field). If no "name", use "cellRenderer" (typically get DELETE_ICON)
+        //  for our columns.
+        this.displayedColumns = this.fieldDefs?.map(field => {
+            return field.name ? field.name : field.cellRenderer;
+        });
+        // And now we can process the resolvedFields to add in the "name"
+        //  from from the fieldDefs. This "name" is the value that
+        //  we'll share to connect things together in the table.
+        this.processedFields = [];
+        this.processedFields = resolvedFields.map((field, i) => {
+            field.config.name = this.displayedColumns[i]; // .config["value"].replace(/ ./g,"_");   // replace space dot with underscore
+            return field;
+        });
+        // for adding rows to table when editable and not modal view
+        if (this.prevReferenceList.length !== this.referenceList.length && this.editableMode && !this.allowEditingInModal) {
+            this.buildElementsForTable();
+        }
+        // for edit and adding rows in modal view and to generate readonly list
+        if (!isEqual(this.prevReferenceList, this.referenceList) && (this.readOnlyMode || this.allowEditingInModal)) {
+            this.generateRowsData();
+        }
+        this.prevReferenceList = this.referenceList;
+        // These are the data structures referred to in the html file.
+        //  These are the relationships that make the table work
+        //  displayedColumns: key/value pairs where key is order of column and
+        //    value is the property shown in that column. Ex: 1: "FirstName"
+        //  processedFields: key/value pairs where each key is order of column
+        //    and each value is an object of more detailed information about that
+        //    column.
+        //  rowData: array of each row's key/value pairs. Inside each row,
+        //    each key is an entry in displayedColumns: ex: "FirstName": "Charles"
+        //    Ex: { 1: {config: {label: "First Name", readOnly: true: name: "FirstName"}}, type: "TextInput" }
+        //    The "type" indicates the type of component that should be used for editing (when editing is enabled)
+        //
+        //  Note that the "property" shown in the column ("FirstName" in the above examples) is what
+        //  ties the 3 data structures together.
+    }
+    getResultsText() {
+        const recordsCount = this.readOnlyMode ? this.rowData?.data.length : this.referenceList?.length;
+        return `${recordsCount} result${recordsCount > 1 ? 's' : ''}`;
+    }
+    sortCompare(a, b) {
+        let aValue = a[this.compareRef];
+        let bValue = b[this.compareRef];
+        if (this.compareType == 'Date' || this.compareType == 'DateTime') {
+            aValue = getSeconds(aValue);
+            bValue = getSeconds(bValue);
+        }
+        if (this.compareRef == 'pxRefObjectInsName') {
+            const result = this.compareByColumnPxRefObjectInsName(aValue, bValue);
+            if (result !== undefined) {
+                return result;
+            }
+        }
+        if (aValue === bValue) {
+            return 0;
+        }
+        if (this.arrowDirection === 'up')
+            return aValue - bValue;
+        if (this.arrowDirection === 'down')
+            return bValue - aValue;
+        return 0;
+    }
+    compareByColumnPxRefObjectInsName(aValue, bValue) {
+        const prefixX = aValue.split('-');
+        const prefixY = bValue.split('-');
+        switch (this.arrowDirection) {
+            case 'up':
+                if (prefixX[0] !== prefixY[0]) {
+                    if (prefixX[0] < prefixY[0])
+                        return -1;
+                    if (prefixX[0] > prefixY[0])
+                        return 1;
+                    return 0;
+                }
+                return prefixX[1] - prefixY[1];
+            case 'down':
+                if (prefixX[0] !== prefixY[0]) {
+                    if (prefixX[0] > prefixY[0])
+                        return -1;
+                    if (prefixX[0] < prefixY[0])
+                        return 1;
+                    return 0;
+                }
+                return prefixY[1] - prefixX[1];
+            default:
+                break;
+        }
+        return undefined;
+    }
+    updateFilterDisplay(type) {
+        switch (type) {
+            case 'Date':
+                this.filterContainsType$ = 'notequal';
+                this.bContains$ = false;
+                this.bDateTime$ = true;
+                this.bIsDate$ = true;
+                this.bIsDateTime$ = false;
+                this.bIsTime$ = false;
+                break;
+            case 'DateTime':
+                this.filterContainsType$ = 'notequal';
+                this.bContains$ = false;
+                this.bDateTime$ = true;
+                this.bIsDate$ = false;
+                this.bIsDateTime$ = true;
+                this.bIsTime$ = false;
+                break;
+            case 'Time':
+                this.filterContainsType$ = 'notequal';
+                this.bContains$ = false;
+                this.bDateTime$ = true;
+                this.bIsDate$ = false;
+                this.bIsDateTime$ = false;
+                this.bIsTime$ = true;
+                break;
+            default:
+                this.filterContainsType$ = 'contains';
+                this.bContains$ = true;
+                this.bDateTime$ = false;
+                this.bIsDate$ = false;
+                this.bIsDateTime$ = false;
+                this.bIsTime$ = false;
+                break;
+        }
+    }
+    _filter(event, columnData) {
+        // add clickAway listener
+        window.addEventListener('mouseup', this._clickAway.bind(this));
+        this.currentFilterRefData = columnData;
+        this.filterContainsLabel$ = columnData.config.label;
+        setTimeout(() => {
+            this.updateFilterDisplay(columnData.type);
+            this.updateFilterVarsWithCurrent(columnData);
+            this.bShowFilterPopover$ = true;
+        });
+    }
+    _clickAway(event) {
+        let bInPopUp = false;
+        // run through list of elements in path, if menu not in th path, then want to
+        // hide (toggle) the menu
+        const eventPath = event.path;
+        for (let eventIndex = 0; eventIndex < eventPath.length; eventIndex++) {
+            if (eventPath[eventIndex].className == 'psdk-modal-file-top' ||
+                eventPath[eventIndex].tagName == 'BUTTON' ||
+                eventPath[eventIndex].tagName == 'MAT-OPTION' ||
+                eventPath[eventIndex].tagName == 'MAT-INPUT') {
+                bInPopUp = true;
+                break;
+            }
+        }
+        if (!bInPopUp) {
+            // this.bShowFilterPopover$ = false;
+            window.removeEventListener('mouseup', this._clickAway.bind(this));
+        }
+    }
+    _filterContainsType(event) {
+        this.filterContainsType$ = event.value;
+    }
+    _filterContainsValue(event) {
+        this.filterContainsValue$ = event.target.value;
+    }
+    _filterContainsDateValue(event, value) {
+        this.filterContainsValue$ = value;
+    }
+    _filterContainsDateTimeValue(event) {
+        this.filterContainsValue$ = event.target.value;
+    }
+    _filterContainsTimeValue(event) {
+        this.filterContainsValue$ = event.target.value;
+    }
+    _onFilterActionButtonClick(event) {
+        // modal buttons
+        switch (event.action) {
+            case 'cancel':
+                this.currentFilterRefData = [];
+                break;
+            case 'submit':
+                this.updateFilterWithInfo();
+                this.filterSortGroupBy();
+                break;
+            default:
+                break;
+        }
+        this.bShowFilterPopover$ = false;
+        window.removeEventListener('mouseup', this._clickAway.bind(this));
+    }
+    updateFilterWithInfo() {
+        let bFound = false;
+        for (const filterObj of this.filterByColumns) {
+            if (filterObj.ref === this.currentFilterRefData.config.name) {
+                filterObj.type = this.currentFilterRefData.type;
+                filterObj.containsFilter = this.filterContainsType$;
+                filterObj.containsFilterValue = this.filterContainsValue$;
+                bFound = true;
+                break;
+            }
+        }
+        if (!bFound) {
+            // add in
+            const filterObj = {};
+            filterObj.ref = this.currentFilterRefData.config.name;
+            filterObj.type = this.currentFilterRefData.type;
+            filterObj.containsFilter = this.filterContainsType$;
+            filterObj.containsFilterValue = this.filterContainsValue$;
+            this.filterByColumns.push(filterObj);
+        }
+        // iterate through filters and update filterOn icon
+        for (const filterObj of this.filterByColumns) {
+            const containsFilterValue = filterObj.containsFilterValue;
+            const containsFilter = filterObj.containsFilter;
+            const filterRef = filterObj.ref;
+            const filterIndex = this.displayedColumns.indexOf(filterRef);
+            const arFilterImg = document.getElementsByName('filterOnIcon');
+            const filterImg = arFilterImg[filterIndex];
+            if (containsFilterValue == '' && containsFilter != 'null' && containsFilter != 'notnull') {
+                // clear icon
+                filterImg.src = '';
+            }
+            else {
+                // show icon
+                filterImg.src = this.filterOnSvgIcon$;
+            }
+        }
+    }
+    updateFilterVarsWithCurrent(columnData) {
+        // find current ref, if exists, move data to variable to display
+        let bFound = false;
+        for (const filterObj of this.filterByColumns) {
+            if (filterObj.ref === this.currentFilterRefData.config.name) {
+                this.filterContainsType$ = filterObj.containsFilter;
+                this.filterContainsValue$ = filterObj.containsFilterValue;
+                bFound = true;
+                break;
+            }
+        }
+        if (!bFound) {
+            switch (columnData.type) {
+                case 'Date':
+                case 'DateTime':
+                case 'Time':
+                    this.filterContainsType$ = 'notequal';
+                    break;
+                default:
+                    this.filterContainsType$ = 'contains';
+                    break;
+            }
+            this.filterContainsValue$ = '';
+        }
+    }
+    filterData(item) {
+        let bKeep = true;
+        for (const filterObj of this.filterByColumns) {
+            if (filterObj.containsFilterValue != '' || filterObj.containsFilter == 'null' || filterObj.containsFilter == 'notnull') {
+                switch (filterObj.type) {
+                    case 'Date':
+                    case 'DateTime':
+                    case 'Time':
+                        bKeep = filterDataByDate(item, filterObj);
+                        break;
+                    default:
+                        bKeep = filterDataByCommonFields(item, filterObj);
+                        break;
+                }
+            }
+            // if don't keep stop filtering
+            if (!bKeep) {
+                break;
+            }
+        }
+        return bKeep;
+    }
+    filterSortGroupBy() {
+        let theData = this.originalData.slice();
+        // last filter config data is global
+        theData = theData.filter(this.filterData.bind(this));
+        // last sort config data is global
+        theData.sort(this.sortCompare.bind(this));
+        this.rowData.data = theData;
+    }
+    _headerSortClick(event, columnData) {
+        // images 0 - filter, 1 - arrow, 2 - more
+        /** Commenting this code for now as it is giving errors not sure if it ever worked */
+        // let arrowImage = event.srcElement.getElementsByTagName('img')[1];
+        // let arrowAttr = arrowImage.getAttribute('arrow');
+        // this.clearOutArrows(event, columnData);
+        // switch (arrowAttr) {
+        //   case 'up':
+        //     arrowImage.src = this.arrowDownSvgIcon$;
+        //     arrowImage.setAttribute('arrow', 'down');
+        //     break;
+        //   case 'down':
+        //     arrowImage.src = '';
+        //     arrowImage.setAttribute('arrow', 'none');
+        //     break;
+        //   default:
+        //     arrowImage.src = this.arrowUpSvgIcon$;
+        //     arrowImage.setAttribute('arrow', 'up');
+        //     break;
+        // }
+        this.compareType = columnData.type;
+        this.compareRef = columnData.config.name;
+        // this.arrowDirection = arrowImage.getAttribute('arrow');
+        this.arrowDirection = this.arrowDirection === 'up' ? 'down' : 'up';
+        this.filterSortGroupBy();
+    }
+    _showUnGroupBy(columnData) {
+        for (const val of this.groupByColumns$) {
+            if (val == columnData.config.name) {
+                return true;
+            }
+        }
+        return false;
+    }
+    _groupBy(event, columnData) {
+        this.checkGroupByColumn(columnData.config.name, true);
+        this.filterSortGroupBy();
+    }
+    _unGroupBy(event, columnData) {
+        // event.stopPropagation();
+        this.checkGroupByColumn(columnData.config.name, false);
+        this.filterSortGroupBy();
+    }
+    checkGroupByColumn(field, add) {
+        let found = null;
+        for (const column of this.groupByColumns$) {
+            if (column === field) {
+                found = this.groupByColumns$.indexOf(column, 0);
+            }
+        }
+        if (found != null && found >= 0) {
+            if (!add) {
+                this.groupByColumns$.splice(found, 1);
+            }
+        }
+        else if (add) {
+            this.groupByColumns$.push(field);
+        }
+    }
+    _getGroupName(fieldName) {
+        for (let fieldIndex = 0; fieldIndex < this.fields$.length; fieldIndex++) {
+            const field = this.fields$[fieldIndex];
+            if (field.config.name == fieldName) {
+                return field.config.label;
+            }
+        }
+        return '';
+    }
+    addGroups(data, groupByColumns) {
+        const rootGroup = new Group();
+        rootGroup.expanded = true;
+        return this.getSublevel(data, 0, groupByColumns, rootGroup);
+    }
+    getSublevel(data, level, groupByColumns, parent) {
+        if (level >= groupByColumns.length) {
+            return data;
+        }
+        const groups = this.uniqueBy(data.map(row => {
+            const result = new Group();
+            result.level = level + 1;
+            result.parent = parent;
+            for (let i = 0; i <= level; i++) {
+                result[groupByColumns[i]] = row[groupByColumns[i]];
+            }
+            return result;
+        }), JSON.stringify);
+        const currentColumn = groupByColumns[level];
+        let subGroups = [];
+        groups.forEach(group => {
+            const rowsInGroup = data.filter(row => group[currentColumn] === row[currentColumn]);
+            group.totalCounts = rowsInGroup.length;
+            const subGroup = this.getSublevel(rowsInGroup, level + 1, groupByColumns, group);
+            subGroup.unshift(group);
+            subGroups = subGroups.concat(subGroup);
+        });
+        return subGroups;
+    }
+    uniqueBy(a, key) {
+        const seen = {};
+        return a.filter(item => {
+            const k = key(item);
+            // eslint-disable-next-line no-return-assign, no-prototype-builtins
+            return seen.hasOwnProperty(k) ? false : (seen[k] = true);
+        });
+    }
+    isGroup(index, item) {
+        return item.level;
+    }
+    _groupHeaderClick(row) {
+        row.expanded = !row.expanded;
+        // this.repeatList$.filter = "";
+        this.perfFilter = performance.now().toString();
+        this.rowData.filter = this.perfFilter;
+    }
+    // below is for grid row grouping
+    customFilterPredicate(data, filter) {
+        return data instanceof Group ? data.visible : this.getDataRowVisibleWithFilter(data, filter);
+    }
+    getDataRowVisible(data) {
+        const groupRows = this.rowData.data.filter(row => {
+            if (!(row instanceof Group)) {
+                return false;
+            }
+            let match = true;
+            this.groupByColumns$.forEach(column => {
+                if (!row[column] || !data[column] || row[column] !== data[column]) {
+                    match = false;
+                }
+            });
+            return match;
+        });
+        if (groupRows.length === 0) {
+            return true;
+        }
+        const parent = groupRows[0];
+        return parent.visible && parent.expanded;
+    }
+    getDataRowVisibleWithFilter(data, filter) {
+        // fist check if row is visible with grouping
+        let bVisible = this.getDataRowVisible(data);
+        if (bVisible && filter && filter != '' && filter != this.perfFilter) {
+            // now check if row is filtered.
+            // assume not there unless we find it
+            bVisible = false;
+            for (const col of this.displayedColumns) {
+                // filter is lower case
+                if (data[col] && data[col].toString().toLowerCase().indexOf(filter) >= 0) {
+                    bVisible = true;
+                    break;
+                }
+            }
+        }
+        return bVisible;
+    }
+    getDisplayColumns(fields = []) {
+        return fields.map((field) => {
+            let theField = field.config.value.substring(field.config.value.indexOf(' ') + 1);
+            if (theField.indexOf('.') == 0) {
+                theField = theField.substring(1);
+            }
+            return theField;
+        });
+    }
+    _getIconStyle(level) {
+        let sReturn = '';
+        let nLevel = parseInt(level, 10);
+        nLevel--;
+        nLevel *= 15;
+        sReturn = `padding-left: ${nLevel}px; vertical-align: middle`;
+        return sReturn;
+    }
+    // Callback passed when subscribing to store change
+    onStateChange() {
+        this.checkAndUpdate();
+    }
+    // return the value that should be shown as the contents for the given row data
+    //  of the given row field
+    getRowValue(inRowData, inColKey) {
+        // See what data (if any) we have to display
+        const refKeys = inColKey.split('.');
+        let valBuilder = inRowData;
+        for (const key of refKeys) {
+            valBuilder = valBuilder[key];
+        }
+        return valBuilder;
+    }
+    generateRowsData() {
+        const { dataPageName, referenceList } = this.configProps$;
+        const context = this.pConn$.getContextName();
+        // if dataPageName property value exists then make a datapage fetch call and get the list of data.
+        if (dataPageName) {
+            this.dataPageService.getDataPageData(dataPageName, this.parameters, context).then(listData => {
+                const data = this.formatRowsData(listData);
+                this.originalData = data;
+                this.rowData = new MatTableDataSource(data);
+            });
+        }
+        else {
+            // The referenceList prop has the JSON data for each row to be displayed
+            //  in the table. So, iterate over referenceList to create the dataRows that
+            //  we're using as the table's dataSource
+            const data = this.formatRowsData(referenceList);
+            this.originalData = data;
+            this.rowData = new MatTableDataSource(data);
+        }
+    }
+    formatRowsData(data) {
+        return data?.map(item => {
+            return this.displayedColumns.reduce((dataForRow, colKey) => {
+                dataForRow[colKey] = this.getRowValue(item, colKey);
+                return dataForRow;
+            }, {});
+        });
+    }
+    addRecord() {
+        if (this.allowEditingInModal && this.defaultView) {
+            this.pConn$
+                .getActionsApi()
+                .openEmbeddedDataModal(this.defaultView, this.pConn$, this.referenceListStr, this.referenceList.length, PCore.getConstants().RESOURCE_STATUS.CREATE);
+        }
+        else if (PCore.getPCoreVersion()?.includes('8.7')) {
+            this.pConn$.getListActions().insert({ classID: this.contextClass }, this.referenceList.length, this.pageReference);
+        }
+        else {
+            // @ts-ignore - second parameter "pageRef" is optional for insert method
+            this.pConn$.getListActions().insert({ classID: this.contextClass }, this.referenceList.length);
+        }
+    }
+    editRecord(data, index) {
+        if (data) {
+            this.pConn$
+                .getActionsApi()
+                .openEmbeddedDataModal(this.bUseSeparateViewForEdit ? this.editView : this.defaultView, this.pConn$, this.referenceListStr, index, PCore.getConstants().RESOURCE_STATUS.UPDATE);
+        }
+    }
+    deleteRecord(index) {
+        if (PCore.getPCoreVersion()?.includes('8.7')) {
+            this.pConn$.getListActions().deleteEntry(index, this.pageReference);
+        }
+        else {
+            // @ts-ignore - second parameter "pageRef" is optional for deleteEntry method
+            this.pConn$.getListActions().deleteEntry(index);
+        }
+    }
+    buildElementsForTable() {
+        const context = this.pConn$.getContextName();
+        const eleData = [];
+        this.referenceList.forEach((element, index) => {
+            const data = [];
+            this.rawFields?.forEach(item => {
+                const referenceListData = getReferenceList(this.pConn$);
+                const isDatapage = referenceListData.startsWith('D_');
+                const pageReferenceValue = isDatapage
+                    ? `${referenceListData}[${index}]`
+                    : `${this.pConn$.getPageReference()}${referenceListData.substring(referenceListData.lastIndexOf('.'))}[${index}]`;
+                const config = {
+                    meta: item,
+                    options: {
+                        context,
+                        pageReference: pageReferenceValue,
+                        referenceList: referenceListData,
+                        hasForm: true
+                    }
+                };
+                const view = PCore.createPConnect(config);
+                data.push(view);
+            });
+            eleData.push(data);
+        });
+        this.elementsData = eleData;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SimpleTableManualComponent, deps: [{ token: i1.AngularPConnectService }, { token: i2.Utils }, { token: i3.DatapageService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: SimpleTableManualComponent, isStandalone: true, selector: "app-simple-table-manual", inputs: { pConn$: "pConn$", formGroup$: "formGroup$" }, viewQueries: [{ propertyName: "sort", first: true, predicate: MatSort, descendants: true }], ngImport: i0, template: "<ng-container *ngIf=\"bVisible$\">\n  <div class=\"simple-table-wrapper\">\n    <h3 *ngIf=\"label\" className=\"label\" style=\"font-weight: bold\">\n      {{ label }} <span class=\"results-count\">{{ getResultsText() }}</span>\n    </h3>\n    <table *ngIf=\"readOnlyMode || allowEditingInModal\" mat-table [dataSource]=\"rowData\" class=\"mat-elevation-z8\" id=\"readonly-table\" matSort>\n      <ng-container *ngFor=\"let dCol of processedFields\" [matColumnDef]=\"dCol.config.name\">\n        <th mat-header-cell *matHeaderCellDef mat-sort-header (click)=\"_headerSortClick($event, dCol)\" arrowPosition=\"before\">\n          <div>{{ dCol.config.label }}</div>\n          <div class=\"psdk-mat-header-filter\">\n            <img class=\"psdk-filter-svg-icon\" name=\"filterOnIcon\" />\n          </div>\n          <div (click)=\"$event.stopPropagation()\">\n            <button mat-icon-button [matMenuTriggerFor]=\"groupMenu\">\n              <img class=\"psdk-list-view-svg-icon\" src=\"{{ menuSvgIcon$ }}\" />\n            </button>\n            <mat-menu #groupMenu>\n              <button mat-menu-item (click)=\"_groupBy($event, dCol)\">\n                <img class=\"psdk-list-view-svg-icon\" src=\"{{ groupBySvgIcon$ }}\" /><span>Group By</span>\n              </button>\n              <button *ngIf=\"_showUnGroupBy(dCol) && bGrouping$\" mat-menu-item (click)=\"_unGroupBy($event, dCol)\">\n                <img class=\"psdk-list-view-svg-icon\" src=\"{{ groupBySvgIcon$ }}\" /><span>Ungroup</span>\n              </button>\n              <button mat-menu-item (click)=\"_filter($event, dCol)\">\n                <img class=\"psdk-list-view-svg-icon\" src=\"{{ filterSvgIcon$ }}\" /><span>Filter</span>\n              </button>\n            </mat-menu>\n          </div>\n        </th>\n        <td mat-cell *matCellDef=\"let element\">{{ element[dCol.config.name] }}</td>\n      </ng-container>\n      <ng-container matColumnDef=\"DeleteIcon\">\n        <div *ngIf=\"allowEditingInModal\">\n          <th mat-header-cell *matHeaderCellDef></th>\n          <td mat-cell *matCellDef=\"let element; index as j\">\n            <div class=\"header-icon\">\n              <button mat-icon-button [matMenuTriggerFor]=\"utilityMenu\">\n                <img class=\"psdk-utility-card-actions-svg-icon\" src=\"{{ settingsSvgIcon$ }}\" />\n              </button>\n              <mat-menu #utilityMenu=\"matMenu\" overlapTrigger=\"false\">\n                <button mat-menu-item (click)=\"editRecord(element, j)\">Edit</button>\n                <button mat-menu-item (click)=\"deleteRecord(j)\">Delete</button>\n              </mat-menu>\n            </div>\n          </td>\n        </div>\n      </ng-container>\n      <tr mat-header-row *matHeaderRowDef=\"displayedColumns\"></tr>\n      <tr mat-row *matRowDef=\"let row; columns: displayedColumns\"></tr>\n    </table>\n    <table *ngIf=\"editableMode && !allowEditingInModal\" mat-table [dataSource]=\"elementsData\" class=\"mat-elevation-z8\" id=\"editable-table\">\n      <ng-container *ngFor=\"let dCol of fieldDefs; let i = index\">\n        <ng-container *ngIf=\"dCol.name != 'DeleteIcon'\" [matColumnDef]=\"dCol.name\">\n          <th mat-header-cell *matHeaderCellDef class=\"psdk-mat-header\">{{ dCol.label }}</th>\n          <td mat-cell *matCellDef=\"let element\">\n            <component-mapper\n              [name]=\"element[i].getPConnect().getComponentName()\"\n              [props]=\"{\n                pConn$: element[i].getPConnect(),\n                formGroup$: formGroup$\n              }\"\n              errorMsg=\"Table wants component not yet available: {{ element[i].getPConnect().getComponentName() }}\"\n            ></component-mapper>\n          </td>\n        </ng-container>\n      </ng-container>\n      <ng-container matColumnDef=\"DeleteIcon\">\n        <th mat-header-cell *matHeaderCellDef></th>\n        <td mat-cell *matCellDef=\"let element; index as j\">\n          <button id=\"delete-button\" mat-icon-button (click)=\"deleteRecord(j)\">\n            <img class=\"psdk-utility-card-action-svg-icon\" src=\"{{ menuIconOverride$ }}\" />\n          </button>\n        </td>\n      </ng-container>\n      <tr mat-header-row *matHeaderRowDef=\"displayedColumns\"></tr>\n      <tr mat-row *matRowDef=\"let row; columns: displayedColumns\"></tr>\n    </table>\n    <div class=\"psdk-no-records\" id=\"no-records\" *ngIf=\"editableMode && referenceList?.length === 0\">No Records Found.</div>\n    <div class=\"psdk-no-records\" id=\"no-records\" *ngIf=\"readOnlyMode && rowData?.data?.length === 0\">No Records Found.</div>\n  </div>\n  <button *ngIf=\"showAddRowButton\" mat-button color=\"primary\" style=\"font-size: 16px\" (click)=\"addRecord()\">+ Add</button>\n</ng-container>\n\n<!-- pop overs for filters-->\n<div *ngIf=\"bShowFilterPopover$\" class=\"psdk-dialog-background\">\n  <div class=\"psdk-modal-file-top\">\n    <h4>\n      Filter:<b> {{ filterContainsLabel$ }}</b>\n    </h4>\n    <div *ngIf=\"bContains$\">\n      <mat-form-field class=\"psdk-full-width\">\n        <mat-select [value]=\"filterContainsType$\" (selectionChange)=\"_filterContainsType($event)\">\n          <mat-option value=\"contains\">Contains</mat-option>\n          <mat-option value=\"equals\">Equals</mat-option>\n          <mat-option value=\"startswith\">Starts with</mat-option>\n        </mat-select>\n      </mat-form-field>\n\n      <mat-form-field class=\"psdk-full-width\">\n        <input matInput type=\"text\" [value]=\"filterContainsValue$\" (change)=\"_filterContainsValue($event)\" />\n      </mat-form-field>\n    </div>\n\n    <div *ngIf=\"bDateTime$\">\n      <mat-form-field class=\"psdk-full-width\">\n        <mat-select [value]=\"filterContainsType$\" (selectionChange)=\"_filterContainsType($event)\">\n          <mat-option value=\"notequal\">is not equal to</mat-option>\n          <mat-option value=\"after\">after</mat-option>\n          <mat-option value=\"before\">before</mat-option>\n          <mat-option value=\"null\">is null</mat-option>\n          <mat-option value=\"notnull\">is not null</mat-option>\n        </mat-select>\n      </mat-form-field>\n\n      <mat-form-field *ngIf=\"bIsDate$ && filterContainsType$ !== 'null' && filterContainsType$ != 'notnull'\" class=\"psdk-full-width\">\n        <mat-label>Date</mat-label>\n        <input\n          matInput\n          #dateInput\n          [matDatepicker]=\"pegadate\"\n          type=\"text\"\n          [value]=\"filterContainsValue$\"\n          (dateChange)=\"_filterContainsDateValue($event, dateInput.value)\"\n        />\n        <mat-datepicker-toggle matSuffix [for]=\"pegadate\"></mat-datepicker-toggle>\n        <mat-datepicker #pegadate [startAt]=\"filterContainsValue$\"></mat-datepicker>\n      </mat-form-field>\n\n      <mat-form-field *ngIf=\"bIsDateTime$ && filterContainsType$ !== 'null' && filterContainsType$ != 'notnull'\" class=\"psdk-full-width\">\n        <mat-label>Date time</mat-label>\n        <input matInput type=\"datetime-local\" [value]=\"filterContainsValue$\" (change)=\"_filterContainsDateTimeValue($event)\" />\n      </mat-form-field>\n\n      <mat-form-field *ngIf=\"bIsTime$ && filterContainsType$ !== 'null' && filterContainsType$ != 'notnull'\" class=\"psdk-full-width\">\n        <mat-label>Time</mat-label>\n        <input matInput type=\"time\" [value]=\"filterContainsValue$\" (change)=\"_filterContainsTimeValue($event)\" />\n      </mat-form-field>\n    </div>\n\n    <component-mapper\n      name=\"ActionButtons\"\n      [props]=\"{ arMainButtons$: arFilterMainButtons$, arSecondaryButtons$: arFilterSecondaryButtons$ }\"\n      [parent]=\"this\"\n      [outputEvents]=\"{ actionButtonClick: _onFilterActionButtonClick }\"\n    ></component-mapper>\n  </div>\n</div>\n", styles: [".simple-table-wrapper{width:100%;margin-top:.5rem;margin-bottom:.5rem}table{width:100%}::ng-deep .mat-sort-header-content{white-space:normal}::ng-deep td.mat-mdc-cell{white-space:normal}::ng-deep th.mat-mdc-header-cell,td.mat-mdc-cell,td.mat-mdc-footer-cell{border-right:1px solid lightgray;padding:8px!important}::ng-deep .mat-mdc-button{padding:0;text-align:left}.mat-mdc-icon-button{width:-moz-fit-content;width:fit-content}.mat-mdc-row .mat-mdc-cell{text-align:left}.psdk-mat-header{white-space:normal;padding-right:5px}.psdk-mat-header-button{display:inline-grid}.psdk-mat-header-arrow,.psdk-mat-header-filter{display:inline-grid;vertical-align:middle}.psdk-full-width{width:100%}.psdk-search{padding-left:.625rem}.psdk-icon-search{vertical-align:sub;padding:0rem .125rem;min-width:unset;width:1.1rem}.psdk-outer-div-in-form{display:inline-grid}.psdk-inner-div-in-form{height:auto;position:relative;width:100%;overflow:auto;max-height:550px;min-height:auto}.psdk-list-view-svg-icon{width:1.4rem;display:inline-block;vertical-align:middle;filter:invert(23%) sepia(23%) saturate(6785%) hue-rotate(250deg) brightness(93%) contrast(88%)}.psdk-filter-svg-icon,.psdk-arrow-svg-icon{width:1rem;display:inline-block;vertical-align:middle;filter:invert(55%) sepia(25%) saturate(0%) hue-rotate(269deg) brightness(87%) contrast(91%)}.psdk-filter-popover{display:table;margin:auto;min-width:100px;background-color:#fff;border:1px solid black;border-radius:10px;padding:20px;box-shadow:0 0 10px 3px #777;position:absolute;z-index:99}.psdk-dialog-background{display:flex;flex-direction:column;justify-content:center;align-items:center;height:100%;width:100%;background-color:#64646466;position:fixed;z-index:999;top:0;left:0}.psdk-modal-file-top{display:table;margin:auto;min-width:150px;background-color:#fff;border:1px solid black;border-radius:10px;padding:20px;box-shadow:0 0 10px 3px #777}tr.mat-mdc-row{cursor:pointer}tr.mat-mdc-header-row{background:#f5f5f5}.psdk-data-readonly{margin-top:.625rem;width:100%}.psdk-no-records{height:56px;justify-content:center;display:flex;align-items:center;border:1px solid lightgray;border-top:none;background:white}.psdk-utility-card-action-svg-icon{width:1.4rem}.label{margin:8px}.results-count{opacity:.7;font-size:.8rem;font-weight:700;margin-inline-start:.625rem}\n"], dependencies: [{ kind: "ngmodule", type: i0.forwardRef(function () { return CommonModule; }) }, { kind: "directive", type: i0.forwardRef(function () { return i4.NgForOf; }), selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i0.forwardRef(function () { return i4.NgIf; }), selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatTableModule; }) }, { kind: "component", type: i0.forwardRef(function () { return i5.MatTable; }), selector: "mat-table, table[mat-table]", exportAs: ["matTable"] }, { kind: "directive", type: i0.forwardRef(function () { return i5.MatHeaderCellDef; }), selector: "[matHeaderCellDef]" }, { kind: "directive", type: i0.forwardRef(function () { return i5.MatHeaderRowDef; }), selector: "[matHeaderRowDef]", inputs: ["matHeaderRowDef", "matHeaderRowDefSticky"] }, { kind: "directive", type: i0.forwardRef(function () { return i5.MatColumnDef; }), selector: "[matColumnDef]", inputs: ["sticky", "matColumnDef"] }, { kind: "directive", type: i0.forwardRef(function () { return i5.MatCellDef; }), selector: "[matCellDef]" }, { kind: "directive", type: i0.forwardRef(function () { return i5.MatRowDef; }), selector: "[matRowDef]", inputs: ["matRowDefColumns", "matRowDefWhen"] }, { kind: "directive", type: i0.forwardRef(function () { return i5.MatHeaderCell; }), selector: "mat-header-cell, th[mat-header-cell]" }, { kind: "directive", type: i0.forwardRef(function () { return i5.MatCell; }), selector: "mat-cell, td[mat-cell]" }, { kind: "component", type: i0.forwardRef(function () { return i5.MatHeaderRow; }), selector: "mat-header-row, tr[mat-header-row]", exportAs: ["matHeaderRow"] }, { kind: "component", type: i0.forwardRef(function () { return i5.MatRow; }), selector: "mat-row, tr[mat-row]", exportAs: ["matRow"] }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatButtonModule; }) }, { kind: "component", type: i0.forwardRef(function () { return i6.MatButton; }), selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "component", type: i0.forwardRef(function () { return i6.MatIconButton; }), selector: "button[mat-icon-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatSortModule; }) }, { kind: "directive", type: i0.forwardRef(function () { return i7.MatSort; }), selector: "[matSort]", inputs: ["matSortDisabled", "matSortActive", "matSortStart", "matSortDirection", "matSortDisableClear"], outputs: ["matSortChange"], exportAs: ["matSort"] }, { kind: "component", type: i0.forwardRef(function () { return i7.MatSortHeader; }), selector: "[mat-sort-header]", inputs: ["disabled", "mat-sort-header", "arrowPosition", "start", "sortActionDescription", "disableClear"], exportAs: ["matSortHeader"] }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatMenuModule; }) }, { kind: "component", type: i0.forwardRef(function () { return i8.MatMenu; }), selector: "mat-menu", exportAs: ["matMenu"] }, { kind: "component", type: i0.forwardRef(function () { return i8.MatMenuItem; }), selector: "[mat-menu-item]", inputs: ["disabled", "disableRipple", "role"], exportAs: ["matMenuItem"] }, { kind: "directive", type: i0.forwardRef(function () { return i8.MatMenuTrigger; }), selector: "[mat-menu-trigger-for], [matMenuTriggerFor]", exportAs: ["matMenuTrigger"] }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatFormFieldModule; }) }, { kind: "component", type: i0.forwardRef(function () { return i9.MatFormField; }), selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i0.forwardRef(function () { return i9.MatLabel; }), selector: "mat-label" }, { kind: "directive", type: i0.forwardRef(function () { return i9.MatSuffix; }), selector: "[matSuffix], [matIconSuffix], [matTextSuffix]", inputs: ["matTextSuffix"] }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatDatepickerModule; }) }, { kind: "component", type: i0.forwardRef(function () { return i10.MatDatepicker; }), selector: "mat-datepicker", exportAs: ["matDatepicker"] }, { kind: "directive", type: i0.forwardRef(function () { return i10.MatDatepickerInput; }), selector: "input[matDatepicker]", inputs: ["matDatepicker", "min", "max", "matDatepickerFilter"], exportAs: ["matDatepickerInput"] }, { kind: "component", type: i0.forwardRef(function () { return i10.MatDatepickerToggle; }), selector: "mat-datepicker-toggle", inputs: ["for", "tabIndex", "aria-label", "disabled", "disableRipple"], exportAs: ["matDatepickerToggle"] }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatOptionModule; }) }, { kind: "component", type: i0.forwardRef(function () { return i11.MatOption; }), selector: "mat-option", exportAs: ["matOption"] }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatSelectModule; }) }, { kind: "component", type: i0.forwardRef(function () { return i12.MatSelect; }), selector: "mat-select", inputs: ["disabled", "disableRipple", "tabIndex", "panelWidth", "hideSingleSelectionIndicator"], exportAs: ["matSelect"] }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatInputModule; }) }, { kind: "directive", type: i0.forwardRef(function () { return i13.MatInput; }), selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "component", type: i0.forwardRef(function () { return ComponentMapperComponent; }), selector: "component-mapper", inputs: ["name", "props", "errorMsg", "outputEvents", "parent"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SimpleTableManualComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-simple-table-manual', standalone: true, imports: [
+                        CommonModule,
+                        MatTableModule,
+                        MatButtonModule,
+                        MatSortModule,
+                        MatMenuModule,
+                        MatFormFieldModule,
+                        MatDatepickerModule,
+                        MatOptionModule,
+                        MatSelectModule,
+                        MatInputModule,
+                        forwardRef(() => ComponentMapperComponent)
+                    ], template: "<ng-container *ngIf=\"bVisible$\">\n  <div class=\"simple-table-wrapper\">\n    <h3 *ngIf=\"label\" className=\"label\" style=\"font-weight: bold\">\n      {{ label }} <span class=\"results-count\">{{ getResultsText() }}</span>\n    </h3>\n    <table *ngIf=\"readOnlyMode || allowEditingInModal\" mat-table [dataSource]=\"rowData\" class=\"mat-elevation-z8\" id=\"readonly-table\" matSort>\n      <ng-container *ngFor=\"let dCol of processedFields\" [matColumnDef]=\"dCol.config.name\">\n        <th mat-header-cell *matHeaderCellDef mat-sort-header (click)=\"_headerSortClick($event, dCol)\" arrowPosition=\"before\">\n          <div>{{ dCol.config.label }}</div>\n          <div class=\"psdk-mat-header-filter\">\n            <img class=\"psdk-filter-svg-icon\" name=\"filterOnIcon\" />\n          </div>\n          <div (click)=\"$event.stopPropagation()\">\n            <button mat-icon-button [matMenuTriggerFor]=\"groupMenu\">\n              <img class=\"psdk-list-view-svg-icon\" src=\"{{ menuSvgIcon$ }}\" />\n            </button>\n            <mat-menu #groupMenu>\n              <button mat-menu-item (click)=\"_groupBy($event, dCol)\">\n                <img class=\"psdk-list-view-svg-icon\" src=\"{{ groupBySvgIcon$ }}\" /><span>Group By</span>\n              </button>\n              <button *ngIf=\"_showUnGroupBy(dCol) && bGrouping$\" mat-menu-item (click)=\"_unGroupBy($event, dCol)\">\n                <img class=\"psdk-list-view-svg-icon\" src=\"{{ groupBySvgIcon$ }}\" /><span>Ungroup</span>\n              </button>\n              <button mat-menu-item (click)=\"_filter($event, dCol)\">\n                <img class=\"psdk-list-view-svg-icon\" src=\"{{ filterSvgIcon$ }}\" /><span>Filter</span>\n              </button>\n            </mat-menu>\n          </div>\n        </th>\n        <td mat-cell *matCellDef=\"let element\">{{ element[dCol.config.name] }}</td>\n      </ng-container>\n      <ng-container matColumnDef=\"DeleteIcon\">\n        <div *ngIf=\"allowEditingInModal\">\n          <th mat-header-cell *matHeaderCellDef></th>\n          <td mat-cell *matCellDef=\"let element; index as j\">\n            <div class=\"header-icon\">\n              <button mat-icon-button [matMenuTriggerFor]=\"utilityMenu\">\n                <img class=\"psdk-utility-card-actions-svg-icon\" src=\"{{ settingsSvgIcon$ }}\" />\n              </button>\n              <mat-menu #utilityMenu=\"matMenu\" overlapTrigger=\"false\">\n                <button mat-menu-item (click)=\"editRecord(element, j)\">Edit</button>\n                <button mat-menu-item (click)=\"deleteRecord(j)\">Delete</button>\n              </mat-menu>\n            </div>\n          </td>\n        </div>\n      </ng-container>\n      <tr mat-header-row *matHeaderRowDef=\"displayedColumns\"></tr>\n      <tr mat-row *matRowDef=\"let row; columns: displayedColumns\"></tr>\n    </table>\n    <table *ngIf=\"editableMode && !allowEditingInModal\" mat-table [dataSource]=\"elementsData\" class=\"mat-elevation-z8\" id=\"editable-table\">\n      <ng-container *ngFor=\"let dCol of fieldDefs; let i = index\">\n        <ng-container *ngIf=\"dCol.name != 'DeleteIcon'\" [matColumnDef]=\"dCol.name\">\n          <th mat-header-cell *matHeaderCellDef class=\"psdk-mat-header\">{{ dCol.label }}</th>\n          <td mat-cell *matCellDef=\"let element\">\n            <component-mapper\n              [name]=\"element[i].getPConnect().getComponentName()\"\n              [props]=\"{\n                pConn$: element[i].getPConnect(),\n                formGroup$: formGroup$\n              }\"\n              errorMsg=\"Table wants component not yet available: {{ element[i].getPConnect().getComponentName() }}\"\n            ></component-mapper>\n          </td>\n        </ng-container>\n      </ng-container>\n      <ng-container matColumnDef=\"DeleteIcon\">\n        <th mat-header-cell *matHeaderCellDef></th>\n        <td mat-cell *matCellDef=\"let element; index as j\">\n          <button id=\"delete-button\" mat-icon-button (click)=\"deleteRecord(j)\">\n            <img class=\"psdk-utility-card-action-svg-icon\" src=\"{{ menuIconOverride$ }}\" />\n          </button>\n        </td>\n      </ng-container>\n      <tr mat-header-row *matHeaderRowDef=\"displayedColumns\"></tr>\n      <tr mat-row *matRowDef=\"let row; columns: displayedColumns\"></tr>\n    </table>\n    <div class=\"psdk-no-records\" id=\"no-records\" *ngIf=\"editableMode && referenceList?.length === 0\">No Records Found.</div>\n    <div class=\"psdk-no-records\" id=\"no-records\" *ngIf=\"readOnlyMode && rowData?.data?.length === 0\">No Records Found.</div>\n  </div>\n  <button *ngIf=\"showAddRowButton\" mat-button color=\"primary\" style=\"font-size: 16px\" (click)=\"addRecord()\">+ Add</button>\n</ng-container>\n\n<!-- pop overs for filters-->\n<div *ngIf=\"bShowFilterPopover$\" class=\"psdk-dialog-background\">\n  <div class=\"psdk-modal-file-top\">\n    <h4>\n      Filter:<b> {{ filterContainsLabel$ }}</b>\n    </h4>\n    <div *ngIf=\"bContains$\">\n      <mat-form-field class=\"psdk-full-width\">\n        <mat-select [value]=\"filterContainsType$\" (selectionChange)=\"_filterContainsType($event)\">\n          <mat-option value=\"contains\">Contains</mat-option>\n          <mat-option value=\"equals\">Equals</mat-option>\n          <mat-option value=\"startswith\">Starts with</mat-option>\n        </mat-select>\n      </mat-form-field>\n\n      <mat-form-field class=\"psdk-full-width\">\n        <input matInput type=\"text\" [value]=\"filterContainsValue$\" (change)=\"_filterContainsValue($event)\" />\n      </mat-form-field>\n    </div>\n\n    <div *ngIf=\"bDateTime$\">\n      <mat-form-field class=\"psdk-full-width\">\n        <mat-select [value]=\"filterContainsType$\" (selectionChange)=\"_filterContainsType($event)\">\n          <mat-option value=\"notequal\">is not equal to</mat-option>\n          <mat-option value=\"after\">after</mat-option>\n          <mat-option value=\"before\">before</mat-option>\n          <mat-option value=\"null\">is null</mat-option>\n          <mat-option value=\"notnull\">is not null</mat-option>\n        </mat-select>\n      </mat-form-field>\n\n      <mat-form-field *ngIf=\"bIsDate$ && filterContainsType$ !== 'null' && filterContainsType$ != 'notnull'\" class=\"psdk-full-width\">\n        <mat-label>Date</mat-label>\n        <input\n          matInput\n          #dateInput\n          [matDatepicker]=\"pegadate\"\n          type=\"text\"\n          [value]=\"filterContainsValue$\"\n          (dateChange)=\"_filterContainsDateValue($event, dateInput.value)\"\n        />\n        <mat-datepicker-toggle matSuffix [for]=\"pegadate\"></mat-datepicker-toggle>\n        <mat-datepicker #pegadate [startAt]=\"filterContainsValue$\"></mat-datepicker>\n      </mat-form-field>\n\n      <mat-form-field *ngIf=\"bIsDateTime$ && filterContainsType$ !== 'null' && filterContainsType$ != 'notnull'\" class=\"psdk-full-width\">\n        <mat-label>Date time</mat-label>\n        <input matInput type=\"datetime-local\" [value]=\"filterContainsValue$\" (change)=\"_filterContainsDateTimeValue($event)\" />\n      </mat-form-field>\n\n      <mat-form-field *ngIf=\"bIsTime$ && filterContainsType$ !== 'null' && filterContainsType$ != 'notnull'\" class=\"psdk-full-width\">\n        <mat-label>Time</mat-label>\n        <input matInput type=\"time\" [value]=\"filterContainsValue$\" (change)=\"_filterContainsTimeValue($event)\" />\n      </mat-form-field>\n    </div>\n\n    <component-mapper\n      name=\"ActionButtons\"\n      [props]=\"{ arMainButtons$: arFilterMainButtons$, arSecondaryButtons$: arFilterSecondaryButtons$ }\"\n      [parent]=\"this\"\n      [outputEvents]=\"{ actionButtonClick: _onFilterActionButtonClick }\"\n    ></component-mapper>\n  </div>\n</div>\n", styles: [".simple-table-wrapper{width:100%;margin-top:.5rem;margin-bottom:.5rem}table{width:100%}::ng-deep .mat-sort-header-content{white-space:normal}::ng-deep td.mat-mdc-cell{white-space:normal}::ng-deep th.mat-mdc-header-cell,td.mat-mdc-cell,td.mat-mdc-footer-cell{border-right:1px solid lightgray;padding:8px!important}::ng-deep .mat-mdc-button{padding:0;text-align:left}.mat-mdc-icon-button{width:-moz-fit-content;width:fit-content}.mat-mdc-row .mat-mdc-cell{text-align:left}.psdk-mat-header{white-space:normal;padding-right:5px}.psdk-mat-header-button{display:inline-grid}.psdk-mat-header-arrow,.psdk-mat-header-filter{display:inline-grid;vertical-align:middle}.psdk-full-width{width:100%}.psdk-search{padding-left:.625rem}.psdk-icon-search{vertical-align:sub;padding:0rem .125rem;min-width:unset;width:1.1rem}.psdk-outer-div-in-form{display:inline-grid}.psdk-inner-div-in-form{height:auto;position:relative;width:100%;overflow:auto;max-height:550px;min-height:auto}.psdk-list-view-svg-icon{width:1.4rem;display:inline-block;vertical-align:middle;filter:invert(23%) sepia(23%) saturate(6785%) hue-rotate(250deg) brightness(93%) contrast(88%)}.psdk-filter-svg-icon,.psdk-arrow-svg-icon{width:1rem;display:inline-block;vertical-align:middle;filter:invert(55%) sepia(25%) saturate(0%) hue-rotate(269deg) brightness(87%) contrast(91%)}.psdk-filter-popover{display:table;margin:auto;min-width:100px;background-color:#fff;border:1px solid black;border-radius:10px;padding:20px;box-shadow:0 0 10px 3px #777;position:absolute;z-index:99}.psdk-dialog-background{display:flex;flex-direction:column;justify-content:center;align-items:center;height:100%;width:100%;background-color:#64646466;position:fixed;z-index:999;top:0;left:0}.psdk-modal-file-top{display:table;margin:auto;min-width:150px;background-color:#fff;border:1px solid black;border-radius:10px;padding:20px;box-shadow:0 0 10px 3px #777}tr.mat-mdc-row{cursor:pointer}tr.mat-mdc-header-row{background:#f5f5f5}.psdk-data-readonly{margin-top:.625rem;width:100%}.psdk-no-records{height:56px;justify-content:center;display:flex;align-items:center;border:1px solid lightgray;border-top:none;background:white}.psdk-utility-card-action-svg-icon{width:1.4rem}.label{margin:8px}.results-count{opacity:.7;font-size:.8rem;font-weight:700;margin-inline-start:.625rem}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.AngularPConnectService }, { type: i2.Utils }, { type: i3.DatapageService }]; }, propDecorators: { sort: [{
+                type: ViewChild,
+                args: [MatSort]
+            }], pConn$: [{
+                type: Input
+            }], formGroup$: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"simple-table-manual.component.js","sourceRoot":"","sources":["../../../../../../../packages/angular-sdk-components/src/lib/_components/template/simple-table-manual/simple-table-manual.component.ts","../../../../../../../packages/angular-sdk-components/src/lib/_components/template/simple-table-manual/simple-table-manual.component.html"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable max-classes-per-file */\nimport { Component, OnInit, Input, ViewChild, forwardRef, OnDestroy } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { FormGroup } from '@angular/forms';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatDatepickerModule } from '@angular/material/datepicker';\nimport { MatFormFieldModule } from '@angular/material/form-field';\nimport { MatInputModule } from '@angular/material/input';\nimport { MatMenuModule } from '@angular/material/menu';\nimport { MatOptionModule } from '@angular/material/core';\nimport { MatSelectModule } from '@angular/material/select';\nimport { MatSort, MatSortModule } from '@angular/material/sort';\nimport { MatTableDataSource, MatTableModule } from '@angular/material/table';\nimport isEqual from 'fast-deep-equal';\n\nimport { ComponentMapperComponent } from '../../../_bridge/component-mapper/component-mapper.component';\nimport { AngularPConnectData, AngularPConnectService } from '../../../_bridge/angular-pconnect';\nimport { DatapageService } from '../../../_services/datapage.service';\nimport { getReferenceList } from '../../../_helpers/field-group-utils';\nimport { buildFieldsForTable, filterDataByCommonFields, filterDataByDate, getContext } from './helpers';\nimport { Utils } from '../../../_helpers/utils';\nimport { getSeconds } from '../../../_helpers/common';\n\ndeclare const window: any;\n\ninterface SimpleTableManualProps {\n  // If any, enter additional props that only exist on this component\n  visibility?: boolean;\n  grouping?: any;\n  referenceList?: any[];\n  children?: any[];\n  renderMode?: string;\n  presets?: any[];\n  label?: string;\n  showLabel?: boolean;\n  dataPageName?: string;\n  contextClass?: string;\n  propertyLabel?: string;\n  fieldMetadata?: any;\n  allowTableEdit?: boolean;\n  editMode?: string;\n  addAndEditRowsWithin?: any;\n  viewForAddAndEditModal?: any;\n  editModeConfig?: any;\n  displayMode?: string;\n  useSeparateViewForEdit: any;\n  viewForEditModal: any;\n}\n\nclass Group {\n  level = 0;\n  parent: Group;\n  expanded = true;\n  totalCounts = 0;\n  get visible(): boolean {\n    return !this.parent || (this.parent.visible && this.parent.expanded);\n  }\n}\n\n@Component({\n  selector: 'app-simple-table-manual',\n  templateUrl: './simple-table-manual.component.html',\n  styleUrls: ['./simple-table-manual.component.scss'],\n  standalone: true,\n  imports: [\n    CommonModule,\n    MatTableModule,\n    MatButtonModule,\n    MatSortModule,\n    MatMenuModule,\n    MatFormFieldModule,\n    MatDatepickerModule,\n    MatOptionModule,\n    MatSelectModule,\n    MatInputModule,\n    forwardRef(() => ComponentMapperComponent)\n  ]\n})\nexport class SimpleTableManualComponent implements OnInit, OnDestroy {\n  @ViewChild(MatSort) sort: MatSort;\n\n  @Input() pConn$: typeof PConnect;\n  @Input() formGroup$: FormGroup;\n\n  // Used with AngularPConnect\n  angularPConnectData: AngularPConnectData = {};\n  configProps$: SimpleTableManualProps;\n  fields$: any[];\n\n  bVisible$ = true;\n  displayedColumns: string[] = [];\n  rowData: MatTableDataSource<any>;\n  originalData: any[] = [];\n  processedFields: any[] = [];\n  fieldDefs: any[] = [];\n  requestedReadOnlyMode = false;\n  readOnlyMode = false;\n  editableMode: boolean;\n  menuIconOverride$: string;\n  pageReference: string;\n  referenceList: any;\n  contextClass: any;\n  showAddRowButton: boolean;\n  prevReferenceList: any[] = [];\n  elementsData: MatTableDataSource<any>;\n  rawFields: any;\n  label?: string = '';\n  searchIcon$: string;\n\n  bShowSearch$ = false;\n  bColumnReorder$ = false;\n  bGrouping$ = false;\n\n  perfFilter: string;\n  searchFilter: string;\n\n  menuSvgIcon$: string;\n  arrowSvgIcon$ = '';\n  arrowDownSvgIcon$: string;\n  arrowUpSvgIcon$: string;\n\n  filterSvgIcon$: string;\n  filterOnSvgIcon$: string;\n  groupBySvgIcon$: string;\n\n  groupByColumns$: string[] = [];\n  compareType: string;\n  compareRef: string;\n  arrowDirection = 'down';\n  filterByColumns: any[] = [];\n  currentFilterRefData: any;\n  filterContainsLabel$ = '';\n  filterContainsType$ = 'contains';\n  filterContainsValue$: any;\n  bShowFilterPopover$ = false;\n  bContains$ = true;\n  bDateTime$ = false;\n\n  bIsDate$ = false;\n  bIsDateTime$ = false;\n  bIsTime$ = false;\n  currentFilterImageEl: any;\n\n  arFilterMainButtons$: any[] = [];\n  arFilterSecondaryButtons$: any[] = [];\n  selectionMode: string;\n  singleSelectionMode: boolean;\n  multiSelectionMode: boolean;\n  rowID: any;\n  response: any;\n  compositeKeys: any;\n  parameters: any;\n  allowEditingInModal = false;\n  defaultView: any;\n  referenceListStr: any;\n  bUseSeparateViewForEdit: any;\n  editView: any;\n  settingsSvgIcon$: string;\n\n  constructor(\n    private angularPConnect: AngularPConnectService,\n    private utils: Utils,\n    private dataPageService: DatapageService\n  ) {}\n\n  ngOnInit(): void {\n    // First thing in initialization is registering and subscribing to the AngularPConnect service\n    this.angularPConnectData = this.angularPConnect.registerAndSubscribeComponent(this, this.onStateChange);\n    this.configProps$ = this.pConn$.getConfigProps() as SimpleTableManualProps;\n    // Then, continue on with other initialization\n    this.menuIconOverride$ = this.utils.getImageSrc('trash', this.utils.getSDKStaticContentUrl());\n    // call checkAndUpdate when initializing\n    this.checkAndUpdate();\n    this.filterSvgIcon$ = this.utils.getImageSrc('filter', this.utils.getSDKStaticContentUrl());\n    this.filterOnSvgIcon$ = this.utils.getImageSrc('filter-on', this.utils.getSDKStaticContentUrl());\n    this.groupBySvgIcon$ = this.utils.getImageSrc('row', this.utils.getSDKStaticContentUrl());\n    this.bGrouping$ = this.utils.getBooleanValue(this.configProps$.grouping);\n    this.menuSvgIcon$ = this.utils.getImageSrc('more', this.utils.getSDKStaticContentUrl());\n\n    this.arFilterMainButtons$.push({ actionID: 'submit', jsAction: 'submit', name: 'Submit' });\n    this.arFilterSecondaryButtons$.push({ actionID: 'cancel', jsAction: 'cancel', name: 'Cancel' });\n\n    this.searchIcon$ = this.utils.getImageSrc('search', this.utils.getSDKStaticContentUrl());\n\n    this.settingsSvgIcon$ = this.utils.getImageSrc('more', this.utils.getSDKStaticContentUrl());\n  }\n\n  ngOnDestroy(): void {\n    if (this.angularPConnectData.unsubscribeFn) {\n      this.angularPConnectData.unsubscribeFn();\n    }\n  }\n\n  checkAndUpdate() {\n    // Should always check the bridge to see if the component should\n    // update itself (re-render)\n    const bUpdateSelf = this.angularPConnect.shouldComponentUpdate(this);\n\n    // ONLY call updateSelf when the component should update\n    if (bUpdateSelf) {\n      this.updateSelf();\n    }\n  }\n\n  // updateSelf\n  updateSelf(): void {\n    // moved this from ngOnInit() and call this from there instead...\n    this.configProps$ = this.pConn$.resolveConfigProps(this.pConn$.getConfigProps()) as SimpleTableManualProps;\n\n    if (this.configProps$.visibility != null) {\n      // eslint-disable-next-line no-multi-assign\n      this.bVisible$ = this.bVisible$ = this.utils.getBooleanValue(this.configProps$.visibility);\n    }\n\n    // NOTE: getConfigProps() has each child.config with datasource and value undefined\n    //  but getRawMetadata() has each child.config with datasource and value showing their unresolved values (ex: \"@P thePropName\")\n    //  We need to use the prop name as the \"glue\" to tie the Angular Material table dataSource, displayColumns and data together.\n    //  So, in the code below, we'll use the unresolved config.value (but replacing the space with an underscore to keep things happy)\n    const rawMetadata: any = this.pConn$.getRawMetadata();\n\n    // Adapted from Nebula\n    const {\n      referenceList = [], // if referenceList not in configProps$, default to empy list\n      renderMode,\n      children, // destructure children into an array var: \"resolvedFields\"\n      presets,\n      allowTableEdit,\n      label: labelProp,\n      propertyLabel,\n      fieldMetadata,\n      editMode,\n      addAndEditRowsWithin,\n      viewForAddAndEditModal,\n      editModeConfig,\n      displayMode,\n      useSeparateViewForEdit,\n      viewForEditModal\n    } = this.configProps$;\n\n    this.referenceListStr = getContext(this.pConn$).referenceListStr;\n    this.label = labelProp || propertyLabel;\n    this.parameters = fieldMetadata?.datasource?.parameters;\n\n    const hideAddRow = allowTableEdit === false;\n    const hideDeleteRow = allowTableEdit === false;\n    let { contextClass } = this.configProps$;\n    this.referenceList = referenceList;\n    if (!contextClass) {\n      // @ts-ignore - Property 'getComponentConfig' is private and only accessible within class 'C11nEnv'\n      let listName = this.pConn$.getComponentConfig().referenceList;\n      listName = PCore.getAnnotationUtils().getPropertyName(listName);\n      // @ts-ignore - Property 'getFieldMetadata' is private and only accessible within class 'C11nEnv'\n      contextClass = this.pConn$.getFieldMetadata(listName)?.pageClass;\n    }\n    this.contextClass = contextClass;\n\n    const resolvedFields = children?.[0]?.children || presets?.[0].children?.[0].children;\n    // get raw config as @P and other annotations are processed and don't appear in the resolved config.\n    //  Destructure \"raw\" children into array var: \"rawFields\"\n    //  NOTE: when config.listType == \"associated\", the property can be found in either\n    //    config.value (ex: \"@P .DeclarantChoice\") or\n    //    config.datasource (ex: \"@ASSOCIATED .DeclarantChoice\")\n    //  Neither of these appear in the resolved (this.configProps$)\n    const rawConfig = rawMetadata?.config;\n    const rawFields = rawConfig?.children?.[0]?.children || rawConfig?.presets?.[0].children?.[0]?.children;\n    this.rawFields = rawFields;\n    // At this point, fields has resolvedFields and rawFields we can use\n\n    // start of from Nebula\n    // get context name and referenceList which will be used to prepare config of PConnect\n    // const { contextName, referenceListStr, pageReferenceForRows } = getContext(this.pConn$);\n\n    const resolvedList = getReferenceList(this.pConn$);\n    this.pageReference = `${this.pConn$.getPageReference()}${resolvedList}`;\n    this.pConn$.setReferenceList(resolvedList);\n\n    // This gives up the \"properties\" we need to map to row/column values later\n    // const processedData = populateRowKey(referenceList);\n\n    this.requestedReadOnlyMode = renderMode === 'ReadOnly';\n    this.readOnlyMode = renderMode === 'ReadOnly';\n    this.editableMode = renderMode === 'Editable';\n    const isDisplayModeEnabled = displayMode === 'DISPLAY_ONLY';\n    this.showAddRowButton = !this.readOnlyMode && !hideAddRow;\n    this.allowEditingInModal =\n      (editMode ? editMode === 'modal' : addAndEditRowsWithin === 'modal') && !(renderMode === 'ReadOnly' || isDisplayModeEnabled);\n    const showDeleteButton = this.editableMode && !hideDeleteRow;\n    this.defaultView = editModeConfig ? editModeConfig.defaultView : viewForAddAndEditModal;\n    this.bUseSeparateViewForEdit = editModeConfig ? editModeConfig.useSeparateViewForEdit : useSeparateViewForEdit;\n    this.editView = editModeConfig ? editModeConfig.editView : viewForEditModal;\n    // const showDeleteButton = !this.readOnlyMode && !hideDeleteRow;\n\n    // Nebula has other handling for isReadOnlyMode but has Cosmos-specific code\n    //  so ignoring that for now...\n    // fieldDefs will be an array where each entry will have a \"name\" which will be the\n    //  \"resolved\" property name (that we can use as the colId) though it's not really\n    //  resolved. The buildFieldsForTable helper just removes the \"@P \" (which is what\n    //  Nebula does). It will also have the \"label\", and \"meta\" contains the original,\n    //  unchanged config info. For now, much of the info here is carried over from\n    //  Nebula and we may not end up using it all.\n    this.fieldDefs = buildFieldsForTable(rawFields, resolvedFields, showDeleteButton);\n\n    // end of from Nebula\n\n    // Here, we use the \"name\" field in fieldDefs since that has the assoicated property\n    //  (if one exists for the field). If no \"name\", use \"cellRenderer\" (typically get DELETE_ICON)\n    //  for our columns.\n    this.displayedColumns = this.fieldDefs?.map(field => {\n      return field.name ? field.name : field.cellRenderer;\n    });\n\n    // And now we can process the resolvedFields to add in the \"name\"\n    //  from from the fieldDefs. This \"name\" is the value that\n    //  we'll share to connect things together in the table.\n\n    this.processedFields = [];\n\n    this.processedFields = resolvedFields.map((field, i) => {\n      field.config.name = this.displayedColumns[i]; // .config[\"value\"].replace(/ ./g,\"_\");   // replace space dot with underscore\n      return field;\n    });\n\n    // for adding rows to table when editable and not modal view\n    if (this.prevReferenceList.length !== this.referenceList.length && this.editableMode && !this.allowEditingInModal) {\n      this.buildElementsForTable();\n    }\n\n    // for edit and adding rows in modal view and to generate readonly list\n    if (!isEqual(this.prevReferenceList, this.referenceList) && (this.readOnlyMode || this.allowEditingInModal)) {\n      this.generateRowsData();\n    }\n\n    this.prevReferenceList = this.referenceList;\n\n    // These are the data structures referred to in the html file.\n    //  These are the relationships that make the table work\n    //  displayedColumns: key/value pairs where key is order of column and\n    //    value is the property shown in that column. Ex: 1: \"FirstName\"\n    //  processedFields: key/value pairs where each key is order of column\n    //    and each value is an object of more detailed information about that\n    //    column.\n    //  rowData: array of each row's key/value pairs. Inside each row,\n    //    each key is an entry in displayedColumns: ex: \"FirstName\": \"Charles\"\n    //    Ex: { 1: {config: {label: \"First Name\", readOnly: true: name: \"FirstName\"}}, type: \"TextInput\" }\n    //    The \"type\" indicates the type of component that should be used for editing (when editing is enabled)\n    //\n    //  Note that the \"property\" shown in the column (\"FirstName\" in the above examples) is what\n    //  ties the 3 data structures together.\n  }\n\n  getResultsText() {\n    const recordsCount = this.readOnlyMode ? this.rowData?.data.length : this.referenceList?.length;\n    return `${recordsCount} result${recordsCount > 1 ? 's' : ''}`;\n  }\n\n  sortCompare(a, b): number {\n    let aValue = a[this.compareRef];\n    let bValue = b[this.compareRef];\n\n    if (this.compareType == 'Date' || this.compareType == 'DateTime') {\n      aValue = getSeconds(aValue);\n      bValue = getSeconds(bValue);\n    }\n\n    if (this.compareRef == 'pxRefObjectInsName') {\n      const result = this.compareByColumnPxRefObjectInsName(aValue, bValue);\n      if (result !== undefined) {\n        return result;\n      }\n    }\n\n    if (aValue === bValue) {\n      return 0;\n    }\n\n    if (this.arrowDirection === 'up') return aValue - bValue;\n    if (this.arrowDirection === 'down') return bValue - aValue;\n\n    return 0;\n  }\n\n  compareByColumnPxRefObjectInsName(aValue, bValue) {\n    const prefixX = aValue.split('-');\n    const prefixY = bValue.split('-');\n    switch (this.arrowDirection) {\n      case 'up':\n        if (prefixX[0] !== prefixY[0]) {\n          if (prefixX[0] < prefixY[0]) return -1;\n          if (prefixX[0] > prefixY[0]) return 1;\n          return 0;\n        }\n        return prefixX[1] - prefixY[1];\n      case 'down':\n        if (prefixX[0] !== prefixY[0]) {\n          if (prefixX[0] > prefixY[0]) return -1;\n          if (prefixX[0] < prefixY[0]) return 1;\n          return 0;\n        }\n        return prefixY[1] - prefixX[1];\n      default:\n        break;\n    }\n\n    return undefined;\n  }\n\n  updateFilterDisplay(type) {\n    switch (type) {\n      case 'Date':\n        this.filterContainsType$ = 'notequal';\n        this.bContains$ = false;\n        this.bDateTime$ = true;\n        this.bIsDate$ = true;\n        this.bIsDateTime$ = false;\n        this.bIsTime$ = false;\n        break;\n      case 'DateTime':\n        this.filterContainsType$ = 'notequal';\n        this.bContains$ = false;\n        this.bDateTime$ = true;\n        this.bIsDate$ = false;\n        this.bIsDateTime$ = true;\n        this.bIsTime$ = false;\n        break;\n      case 'Time':\n        this.filterContainsType$ = 'notequal';\n        this.bContains$ = false;\n        this.bDateTime$ = true;\n        this.bIsDate$ = false;\n        this.bIsDateTime$ = false;\n        this.bIsTime$ = true;\n        break;\n      default:\n        this.filterContainsType$ = 'contains';\n        this.bContains$ = true;\n        this.bDateTime$ = false;\n        this.bIsDate$ = false;\n        this.bIsDateTime$ = false;\n        this.bIsTime$ = false;\n        break;\n    }\n  }\n\n  _filter(event, columnData) {\n    // add clickAway listener\n    window.addEventListener('mouseup', this._clickAway.bind(this));\n\n    this.currentFilterRefData = columnData;\n    this.filterContainsLabel$ = columnData.config.label;\n\n    setTimeout(() => {\n      this.updateFilterDisplay(columnData.type);\n\n      this.updateFilterVarsWithCurrent(columnData);\n\n      this.bShowFilterPopover$ = true;\n    });\n  }\n\n  _clickAway(event: any) {\n    let bInPopUp = false;\n\n    // run through list of elements in path, if menu not in th path, then want to\n    // hide (toggle) the menu\n    const eventPath = event.path;\n    for (let eventIndex = 0; eventIndex < eventPath.length; eventIndex++) {\n      if (\n        eventPath[eventIndex].className == 'psdk-modal-file-top' ||\n        eventPath[eventIndex].tagName == 'BUTTON' ||\n        eventPath[eventIndex].tagName == 'MAT-OPTION' ||\n        eventPath[eventIndex].tagName == 'MAT-INPUT'\n      ) {\n        bInPopUp = true;\n        break;\n      }\n    }\n    if (!bInPopUp) {\n      // this.bShowFilterPopover$ = false;\n\n      window.removeEventListener('mouseup', this._clickAway.bind(this));\n    }\n  }\n\n  _filterContainsType(event) {\n    this.filterContainsType$ = event.value;\n  }\n\n  _filterContainsValue(event) {\n    this.filterContainsValue$ = event.target.value;\n  }\n\n  _filterContainsDateValue(event, value) {\n    this.filterContainsValue$ = value;\n  }\n\n  _filterContainsDateTimeValue(event) {\n    this.filterContainsValue$ = event.target.value;\n  }\n\n  _filterContainsTimeValue(event) {\n    this.filterContainsValue$ = event.target.value;\n  }\n\n  _onFilterActionButtonClick(event: any) {\n    // modal buttons\n    switch (event.action) {\n      case 'cancel':\n        this.currentFilterRefData = [];\n        break;\n      case 'submit':\n        this.updateFilterWithInfo();\n        this.filterSortGroupBy();\n        break;\n      default:\n        break;\n    }\n\n    this.bShowFilterPopover$ = false;\n\n    window.removeEventListener('mouseup', this._clickAway.bind(this));\n  }\n\n  updateFilterWithInfo() {\n    let bFound = false;\n    for (const filterObj of this.filterByColumns) {\n      if (filterObj.ref === this.currentFilterRefData.config.name) {\n        filterObj.type = this.currentFilterRefData.type;\n        filterObj.containsFilter = this.filterContainsType$;\n        filterObj.containsFilterValue = this.filterContainsValue$;\n\n        bFound = true;\n        break;\n      }\n    }\n\n    if (!bFound) {\n      // add in\n      const filterObj: any = {};\n      filterObj.ref = this.currentFilterRefData.config.name;\n      filterObj.type = this.currentFilterRefData.type;\n      filterObj.containsFilter = this.filterContainsType$;\n      filterObj.containsFilterValue = this.filterContainsValue$;\n\n      this.filterByColumns.push(filterObj);\n    }\n\n    // iterate through filters and update filterOn icon\n    for (const filterObj of this.filterByColumns) {\n      const containsFilterValue = filterObj.containsFilterValue;\n      const containsFilter = filterObj.containsFilter;\n      const filterRef = filterObj.ref;\n      const filterIndex = this.displayedColumns.indexOf(filterRef);\n      const arFilterImg = document.getElementsByName('filterOnIcon');\n      const filterImg: any = arFilterImg[filterIndex];\n      if (containsFilterValue == '' && containsFilter != 'null' && containsFilter != 'notnull') {\n        // clear icon\n        filterImg.src = '';\n      } else {\n        // show icon\n        filterImg.src = this.filterOnSvgIcon$;\n      }\n    }\n  }\n\n  updateFilterVarsWithCurrent(columnData) {\n    // find current ref, if exists, move data to variable to display\n\n    let bFound = false;\n    for (const filterObj of this.filterByColumns) {\n      if (filterObj.ref === this.currentFilterRefData.config.name) {\n        this.filterContainsType$ = filterObj.containsFilter;\n        this.filterContainsValue$ = filterObj.containsFilterValue;\n\n        bFound = true;\n        break;\n      }\n    }\n\n    if (!bFound) {\n      switch (columnData.type) {\n        case 'Date':\n        case 'DateTime':\n        case 'Time':\n          this.filterContainsType$ = 'notequal';\n          break;\n        default:\n          this.filterContainsType$ = 'contains';\n          break;\n      }\n\n      this.filterContainsValue$ = '';\n    }\n  }\n\n  filterData(item: any) {\n    let bKeep = true;\n    for (const filterObj of this.filterByColumns) {\n      if (filterObj.containsFilterValue != '' || filterObj.containsFilter == 'null' || filterObj.containsFilter == 'notnull') {\n        switch (filterObj.type) {\n          case 'Date':\n          case 'DateTime':\n          case 'Time':\n            bKeep = filterDataByDate(item, filterObj);\n            break;\n          default:\n            bKeep = filterDataByCommonFields(item, filterObj);\n            break;\n        }\n      }\n\n      // if don't keep stop filtering\n      if (!bKeep) {\n        break;\n      }\n    }\n\n    return bKeep;\n  }\n\n  filterSortGroupBy() {\n    let theData = this.originalData.slice();\n\n    // last filter config data is global\n    theData = theData.filter(this.filterData.bind(this));\n\n    // last sort config data is global\n    theData.sort(this.sortCompare.bind(this));\n    this.rowData.data = theData;\n  }\n\n  _headerSortClick(event, columnData) {\n    // images 0 - filter, 1 - arrow, 2 - more\n\n    /** Commenting this code for now as it is giving errors not sure if it ever worked */\n    // let arrowImage = event.srcElement.getElementsByTagName('img')[1];\n    // let arrowAttr = arrowImage.getAttribute('arrow');\n\n    // this.clearOutArrows(event, columnData);\n\n    // switch (arrowAttr) {\n    //   case 'up':\n    //     arrowImage.src = this.arrowDownSvgIcon$;\n    //     arrowImage.setAttribute('arrow', 'down');\n    //     break;\n    //   case 'down':\n    //     arrowImage.src = '';\n    //     arrowImage.setAttribute('arrow', 'none');\n    //     break;\n    //   default:\n    //     arrowImage.src = this.arrowUpSvgIcon$;\n    //     arrowImage.setAttribute('arrow', 'up');\n    //     break;\n    // }\n\n    this.compareType = columnData.type;\n    this.compareRef = columnData.config.name;\n    // this.arrowDirection = arrowImage.getAttribute('arrow');\n    this.arrowDirection = this.arrowDirection === 'up' ? 'down' : 'up';\n\n    this.filterSortGroupBy();\n  }\n\n  _showUnGroupBy(columnData): boolean {\n    for (const val of this.groupByColumns$) {\n      if (val == columnData.config.name) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  _groupBy(event, columnData) {\n    this.checkGroupByColumn(columnData.config.name, true);\n\n    this.filterSortGroupBy();\n  }\n\n  _unGroupBy(event, columnData) {\n    // event.stopPropagation();\n    this.checkGroupByColumn(columnData.config.name, false);\n\n    this.filterSortGroupBy();\n  }\n\n  checkGroupByColumn(field, add) {\n    let found: number | null = null;\n    for (const column of this.groupByColumns$) {\n      if (column === field) {\n        found = this.groupByColumns$.indexOf(column, 0);\n      }\n    }\n    if (found != null && found >= 0) {\n      if (!add) {\n        this.groupByColumns$.splice(found, 1);\n      }\n    } else if (add) {\n      this.groupByColumns$.push(field);\n    }\n  }\n\n  _getGroupName(fieldName) {\n    for (let fieldIndex = 0; fieldIndex < this.fields$.length; fieldIndex++) {\n      const field = this.fields$[fieldIndex];\n      if (field.config.name == fieldName) {\n        return field.config.label;\n      }\n    }\n    return '';\n  }\n\n  addGroups(data: any[], groupByColumns: string[]): any[] {\n    const rootGroup = new Group();\n    rootGroup.expanded = true;\n    return this.getSublevel(data, 0, groupByColumns, rootGroup);\n  }\n\n  getSublevel(data: any[], level: number, groupByColumns: string[], parent: Group): any[] {\n    if (level >= groupByColumns.length) {\n      return data;\n    }\n    const groups = this.uniqueBy(\n      data.map(row => {\n        const result = new Group();\n        result.level = level + 1;\n        result.parent = parent;\n        for (let i = 0; i <= level; i++) {\n          result[groupByColumns[i]] = row[groupByColumns[i]];\n        }\n        return result;\n      }),\n      JSON.stringify\n    );\n\n    const currentColumn = groupByColumns[level];\n    let subGroups: any = [];\n    groups.forEach(group => {\n      const rowsInGroup = data.filter(row => group[currentColumn] === row[currentColumn]);\n      group.totalCounts = rowsInGroup.length;\n      const subGroup = this.getSublevel(rowsInGroup, level + 1, groupByColumns, group);\n      subGroup.unshift(group);\n      subGroups = subGroups.concat(subGroup);\n    });\n    return subGroups;\n  }\n\n  uniqueBy(a, key) {\n    const seen = {};\n    return a.filter(item => {\n      const k = key(item);\n      // eslint-disable-next-line no-return-assign, no-prototype-builtins\n      return seen.hasOwnProperty(k) ? false : (seen[k] = true);\n    });\n  }\n\n  isGroup(index, item): boolean {\n    return item.level;\n  }\n\n  _groupHeaderClick(row) {\n    row.expanded = !row.expanded;\n    // this.repeatList$.filter = \"\";\n    this.perfFilter = performance.now().toString();\n    this.rowData.filter = this.perfFilter;\n  }\n\n  // below is for grid row grouping\n  customFilterPredicate(data: any | Group, filter: string): boolean {\n    return data instanceof Group ? data.visible : this.getDataRowVisibleWithFilter(data, filter);\n  }\n\n  getDataRowVisible(data: any): boolean {\n    const groupRows = this.rowData.data.filter(row => {\n      if (!(row instanceof Group)) {\n        return false;\n      }\n      let match = true;\n      this.groupByColumns$.forEach(column => {\n        if (!row[column] || !data[column] || row[column] !== data[column]) {\n          match = false;\n        }\n      });\n      return match;\n    });\n\n    if (groupRows.length === 0) {\n      return true;\n    }\n    const parent = groupRows[0] as Group;\n    return parent.visible && parent.expanded;\n  }\n\n  getDataRowVisibleWithFilter(data, filter) {\n    // fist check if row is visible with grouping\n    let bVisible = this.getDataRowVisible(data);\n\n    if (bVisible && filter && filter != '' && filter != this.perfFilter) {\n      // now check if row is filtered.\n\n      // assume not there unless we find it\n      bVisible = false;\n      for (const col of this.displayedColumns) {\n        // filter is lower case\n        if (data[col] && data[col].toString().toLowerCase().indexOf(filter) >= 0) {\n          bVisible = true;\n          break;\n        }\n      }\n    }\n\n    return bVisible;\n  }\n\n  getDisplayColumns(fields = []) {\n    return fields.map((field: any) => {\n      let theField = field.config.value.substring(field.config.value.indexOf(' ') + 1);\n      if (theField.indexOf('.') == 0) {\n        theField = theField.substring(1);\n      }\n\n      return theField;\n    });\n  }\n\n  _getIconStyle(level): string {\n    let sReturn = '';\n    let nLevel = parseInt(level, 10);\n    nLevel--;\n    nLevel *= 15;\n    sReturn = `padding-left: ${nLevel}px; vertical-align: middle`;\n\n    return sReturn;\n  }\n\n  // Callback passed when subscribing to store change\n  onStateChange() {\n    this.checkAndUpdate();\n  }\n\n  // return the value that should be shown as the contents for the given row data\n  //  of the given row field\n  getRowValue(inRowData: Object, inColKey: string): any {\n    // See what data (if any) we have to display\n    const refKeys: string[] = inColKey.split('.');\n    let valBuilder = inRowData;\n    for (const key of refKeys) {\n      valBuilder = valBuilder[key];\n    }\n    return valBuilder;\n  }\n\n  generateRowsData() {\n    const { dataPageName, referenceList } = this.configProps$;\n    const context = this.pConn$.getContextName();\n    // if dataPageName property value exists then make a datapage fetch call and get the list of data.\n    if (dataPageName) {\n      this.dataPageService.getDataPageData(dataPageName, this.parameters, context).then(listData => {\n        const data = this.formatRowsData(listData);\n        this.originalData = data;\n        this.rowData = new MatTableDataSource(data);\n      });\n    } else {\n      // The referenceList prop has the JSON data for each row to be displayed\n      //  in the table. So, iterate over referenceList to create the dataRows that\n      //  we're using as the table's dataSource\n      const data = this.formatRowsData(referenceList);\n      this.originalData = data;\n      this.rowData = new MatTableDataSource(data);\n    }\n  }\n\n  formatRowsData(data) {\n    return data?.map(item => {\n      return this.displayedColumns.reduce((dataForRow, colKey) => {\n        dataForRow[colKey] = this.getRowValue(item, colKey);\n        return dataForRow;\n      }, {});\n    });\n  }\n\n  addRecord() {\n    if (this.allowEditingInModal && this.defaultView) {\n      this.pConn$\n        .getActionsApi()\n        .openEmbeddedDataModal(\n          this.defaultView,\n          this.pConn$,\n          this.referenceListStr,\n          this.referenceList.length,\n          PCore.getConstants().RESOURCE_STATUS.CREATE\n        );\n    } else if (PCore.getPCoreVersion()?.includes('8.7')) {\n      this.pConn$.getListActions().insert({ classID: this.contextClass }, this.referenceList.length, this.pageReference);\n    } else {\n      // @ts-ignore - second parameter \"pageRef\" is optional for insert method\n      this.pConn$.getListActions().insert({ classID: this.contextClass }, this.referenceList.length);\n    }\n  }\n\n  editRecord(data, index) {\n    if (data) {\n      this.pConn$\n        .getActionsApi()\n        .openEmbeddedDataModal(\n          this.bUseSeparateViewForEdit ? this.editView : this.defaultView,\n          this.pConn$,\n          this.referenceListStr,\n          index,\n          PCore.getConstants().RESOURCE_STATUS.UPDATE\n        );\n    }\n  }\n\n  deleteRecord(index) {\n    if (PCore.getPCoreVersion()?.includes('8.7')) {\n      this.pConn$.getListActions().deleteEntry(index, this.pageReference);\n    } else {\n      // @ts-ignore - second parameter \"pageRef\" is optional for deleteEntry method\n      this.pConn$.getListActions().deleteEntry(index);\n    }\n  }\n\n  buildElementsForTable() {\n    const context = this.pConn$.getContextName();\n    const eleData: any = [];\n    this.referenceList.forEach((element, index) => {\n      const data: any = [];\n      this.rawFields?.forEach(item => {\n        const referenceListData = getReferenceList(this.pConn$);\n        const isDatapage = referenceListData.startsWith('D_');\n        const pageReferenceValue = isDatapage\n          ? `${referenceListData}[${index}]`\n          : `${this.pConn$.getPageReference()}${referenceListData.substring(referenceListData.lastIndexOf('.'))}[${index}]`;\n        const config = {\n          meta: item,\n          options: {\n            context,\n            pageReference: pageReferenceValue,\n            referenceList: referenceListData,\n            hasForm: true\n          }\n        };\n        const view = PCore.createPConnect(config);\n        data.push(view);\n      });\n      eleData.push(data);\n    });\n    this.elementsData = eleData;\n  }\n}\n","<ng-container *ngIf=\"bVisible$\">\n  <div class=\"simple-table-wrapper\">\n    <h3 *ngIf=\"label\" className=\"label\" style=\"font-weight: bold\">\n      {{ label }} <span class=\"results-count\">{{ getResultsText() }}</span>\n    </h3>\n    <table *ngIf=\"readOnlyMode || allowEditingInModal\" mat-table [dataSource]=\"rowData\" class=\"mat-elevation-z8\" id=\"readonly-table\" matSort>\n      <ng-container *ngFor=\"let dCol of processedFields\" [matColumnDef]=\"dCol.config.name\">\n        <th mat-header-cell *matHeaderCellDef mat-sort-header (click)=\"_headerSortClick($event, dCol)\" arrowPosition=\"before\">\n          <div>{{ dCol.config.label }}</div>\n          <div class=\"psdk-mat-header-filter\">\n            <img class=\"psdk-filter-svg-icon\" name=\"filterOnIcon\" />\n          </div>\n          <div (click)=\"$event.stopPropagation()\">\n            <button mat-icon-button [matMenuTriggerFor]=\"groupMenu\">\n              <img class=\"psdk-list-view-svg-icon\" src=\"{{ menuSvgIcon$ }}\" />\n            </button>\n            <mat-menu #groupMenu>\n              <button mat-menu-item (click)=\"_groupBy($event, dCol)\">\n                <img class=\"psdk-list-view-svg-icon\" src=\"{{ groupBySvgIcon$ }}\" /><span>Group By</span>\n              </button>\n              <button *ngIf=\"_showUnGroupBy(dCol) && bGrouping$\" mat-menu-item (click)=\"_unGroupBy($event, dCol)\">\n                <img class=\"psdk-list-view-svg-icon\" src=\"{{ groupBySvgIcon$ }}\" /><span>Ungroup</span>\n              </button>\n              <button mat-menu-item (click)=\"_filter($event, dCol)\">\n                <img class=\"psdk-list-view-svg-icon\" src=\"{{ filterSvgIcon$ }}\" /><span>Filter</span>\n              </button>\n            </mat-menu>\n          </div>\n        </th>\n        <td mat-cell *matCellDef=\"let element\">{{ element[dCol.config.name] }}</td>\n      </ng-container>\n      <ng-container matColumnDef=\"DeleteIcon\">\n        <div *ngIf=\"allowEditingInModal\">\n          <th mat-header-cell *matHeaderCellDef></th>\n          <td mat-cell *matCellDef=\"let element; index as j\">\n            <div class=\"header-icon\">\n              <button mat-icon-button [matMenuTriggerFor]=\"utilityMenu\">\n                <img class=\"psdk-utility-card-actions-svg-icon\" src=\"{{ settingsSvgIcon$ }}\" />\n              </button>\n              <mat-menu #utilityMenu=\"matMenu\" overlapTrigger=\"false\">\n                <button mat-menu-item (click)=\"editRecord(element, j)\">Edit</button>\n                <button mat-menu-item (click)=\"deleteRecord(j)\">Delete</button>\n              </mat-menu>\n            </div>\n          </td>\n        </div>\n      </ng-container>\n      <tr mat-header-row *matHeaderRowDef=\"displayedColumns\"></tr>\n      <tr mat-row *matRowDef=\"let row; columns: displayedColumns\"></tr>\n    </table>\n    <table *ngIf=\"editableMode && !allowEditingInModal\" mat-table [dataSource]=\"elementsData\" class=\"mat-elevation-z8\" id=\"editable-table\">\n      <ng-container *ngFor=\"let dCol of fieldDefs; let i = index\">\n        <ng-container *ngIf=\"dCol.name != 'DeleteIcon'\" [matColumnDef]=\"dCol.name\">\n          <th mat-header-cell *matHeaderCellDef class=\"psdk-mat-header\">{{ dCol.label }}</th>\n          <td mat-cell *matCellDef=\"let element\">\n            <component-mapper\n              [name]=\"element[i].getPConnect().getComponentName()\"\n              [props]=\"{\n                pConn$: element[i].getPConnect(),\n                formGroup$: formGroup$\n              }\"\n              errorMsg=\"Table wants component not yet available: {{ element[i].getPConnect().getComponentName() }}\"\n            ></component-mapper>\n          </td>\n        </ng-container>\n      </ng-container>\n      <ng-container matColumnDef=\"DeleteIcon\">\n        <th mat-header-cell *matHeaderCellDef></th>\n        <td mat-cell *matCellDef=\"let element; index as j\">\n          <button id=\"delete-button\" mat-icon-button (click)=\"deleteRecord(j)\">\n            <img class=\"psdk-utility-card-action-svg-icon\" src=\"{{ menuIconOverride$ }}\" />\n          </button>\n        </td>\n      </ng-container>\n      <tr mat-header-row *matHeaderRowDef=\"displayedColumns\"></tr>\n      <tr mat-row *matRowDef=\"let row; columns: displayedColumns\"></tr>\n    </table>\n    <div class=\"psdk-no-records\" id=\"no-records\" *ngIf=\"editableMode && referenceList?.length === 0\">No Records Found.</div>\n    <div class=\"psdk-no-records\" id=\"no-records\" *ngIf=\"readOnlyMode && rowData?.data?.length === 0\">No Records Found.</div>\n  </div>\n  <button *ngIf=\"showAddRowButton\" mat-button color=\"primary\" style=\"font-size: 16px\" (click)=\"addRecord()\">+ Add</button>\n</ng-container>\n\n<!-- pop overs for filters-->\n<div *ngIf=\"bShowFilterPopover$\" class=\"psdk-dialog-background\">\n  <div class=\"psdk-modal-file-top\">\n    <h4>\n      Filter:<b> {{ filterContainsLabel$ }}</b>\n    </h4>\n    <div *ngIf=\"bContains$\">\n      <mat-form-field class=\"psdk-full-width\">\n        <mat-select [value]=\"filterContainsType$\" (selectionChange)=\"_filterContainsType($event)\">\n          <mat-option value=\"contains\">Contains</mat-option>\n          <mat-option value=\"equals\">Equals</mat-option>\n          <mat-option value=\"startswith\">Starts with</mat-option>\n        </mat-select>\n      </mat-form-field>\n\n      <mat-form-field class=\"psdk-full-width\">\n        <input matInput type=\"text\" [value]=\"filterContainsValue$\" (change)=\"_filterContainsValue($event)\" />\n      </mat-form-field>\n    </div>\n\n    <div *ngIf=\"bDateTime$\">\n      <mat-form-field class=\"psdk-full-width\">\n        <mat-select [value]=\"filterContainsType$\" (selectionChange)=\"_filterContainsType($event)\">\n          <mat-option value=\"notequal\">is not equal to</mat-option>\n          <mat-option value=\"after\">after</mat-option>\n          <mat-option value=\"before\">before</mat-option>\n          <mat-option value=\"null\">is null</mat-option>\n          <mat-option value=\"notnull\">is not null</mat-option>\n        </mat-select>\n      </mat-form-field>\n\n      <mat-form-field *ngIf=\"bIsDate$ && filterContainsType$ !== 'null' && filterContainsType$ != 'notnull'\" class=\"psdk-full-width\">\n        <mat-label>Date</mat-label>\n        <input\n          matInput\n          #dateInput\n          [matDatepicker]=\"pegadate\"\n          type=\"text\"\n          [value]=\"filterContainsValue$\"\n          (dateChange)=\"_filterContainsDateValue($event, dateInput.value)\"\n        />\n        <mat-datepicker-toggle matSuffix [for]=\"pegadate\"></mat-datepicker-toggle>\n        <mat-datepicker #pegadate [startAt]=\"filterContainsValue$\"></mat-datepicker>\n      </mat-form-field>\n\n      <mat-form-field *ngIf=\"bIsDateTime$ && filterContainsType$ !== 'null' && filterContainsType$ != 'notnull'\" class=\"psdk-full-width\">\n        <mat-label>Date time</mat-label>\n        <input matInput type=\"datetime-local\" [value]=\"filterContainsValue$\" (change)=\"_filterContainsDateTimeValue($event)\" />\n      </mat-form-field>\n\n      <mat-form-field *ngIf=\"bIsTime$ && filterContainsType$ !== 'null' && filterContainsType$ != 'notnull'\" class=\"psdk-full-width\">\n        <mat-label>Time</mat-label>\n        <input matInput type=\"time\" [value]=\"filterContainsValue$\" (change)=\"_filterContainsTimeValue($event)\" />\n      </mat-form-field>\n    </div>\n\n    <component-mapper\n      name=\"ActionButtons\"\n      [props]=\"{ arMainButtons$: arFilterMainButtons$, arSecondaryButtons$: arFilterSecondaryButtons$ }\"\n      [parent]=\"this\"\n      [outputEvents]=\"{ actionButtonClick: _onFilterActionButtonClick }\"\n    ></component-mapper>\n  </div>\n</div>\n"]}