@pega/angular-sdk-components 0.23.1

package/esm2022/lib/_components/template/list-view/list-view.component.mjs

@@ -0,0 +1,1198 @@
+/* eslint-disable max-classes-per-file */
+import { Component, Input, ViewChild, forwardRef } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { MatDatepickerModule } from '@angular/material/datepicker';
+import { MatOptionModule } from '@angular/material/core';
+import { MatSelectModule } from '@angular/material/select';
+import { MatCheckboxModule } from '@angular/material/checkbox';
+import { MatRadioModule } from '@angular/material/radio';
+import { MatIconModule } from '@angular/material/icon';
+import { MatMenuModule } from '@angular/material/menu';
+import { MatButtonModule } from '@angular/material/button';
+import { MatInputModule } from '@angular/material/input';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatPaginator, MatPaginatorModule } from '@angular/material/paginator';
+import { MatSort, MatSortModule } from '@angular/material/sort';
+import { MatTableDataSource, MatTableModule } from '@angular/material/table';
+import { DragDropModule, moveItemInArray, CdkDropList, CdkDrag } from '@angular/cdk/drag-drop';
+import { ComponentMapperComponent } from '../../../_bridge/component-mapper/component-mapper.component';
+import { getCurrencyOptions } from '../../../_helpers/currency-utils';
+import { getLocale, getSeconds } from '../../../_helpers/common';
+import { formatters } from '../../../_helpers/formatters/format-utils';
+import { useInit } from './listViewHelpers';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../_messages/progress-spinner.service";
+import * as i2 from "../../../_helpers/utils";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/form-field";
+import * as i5 from "@angular/material/input";
+import * as i6 from "@angular/material/table";
+import * as i7 from "@angular/material/sort";
+import * as i8 from "@angular/cdk/drag-drop";
+import * as i9 from "@angular/material/button";
+import * as i10 from "@angular/material/menu";
+import * as i11 from "@angular/material/icon";
+import * as i12 from "@angular/material/radio";
+import * as i13 from "@angular/material/checkbox";
+import * as i14 from "@angular/material/paginator";
+import * as i15 from "@angular/material/select";
+import * as i16 from "@angular/material/core";
+import * as i17 from "@angular/material/datepicker";
+const SELECTION_MODE = { SINGLE: 'single', MULTI: 'multi' };
+export 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 ListViewComponent {
+    constructor(psService, utils) {
+        this.psService = psService;
+        this.utils = utils;
+        this.bInForm$ = true;
+        this.displayedColumns$ = Array();
+        this.groupByColumns$ = [];
+        this.repeatListData = [];
+        this.bShowSearch$ = false;
+        this.bColumnReorder$ = false;
+        this.bGrouping$ = false;
+        this.arrowSvgIcon$ = '';
+        this.arrowDirection = 'down';
+        this.filterByColumns = [];
+        this.bShowFilterPopover$ = false;
+        this.bContains$ = true;
+        this.bDateTime$ = false;
+        this.filterContainsLabel$ = '';
+        this.filterContainsType$ = 'contains';
+        this.bIsDate$ = false;
+        this.bIsDateTime$ = false;
+        this.bIsTime$ = false;
+        this.arFilterMainButtons$ = [];
+        this.arFilterSecondaryButtons$ = [];
+        this.filters = {};
+        this.selectParam = [];
+        this.ref = {};
+        this.listContext = {};
+        this.query = null;
+        this.xRayApis = PCore.getDebugger().getXRayRuntime();
+        this.xRayUid = this.xRayApis.startXRay();
+    }
+    ngOnInit() {
+        this.configProps$ = this.pConn$.getConfigProps();
+        /** By default, pyGUID is used for Data classes and pyID is for Work classes as row-id/key */
+        const defRowID = this.configProps$?.referenceType === 'Case' ? 'pyID' : 'pyGUID';
+        /** If compositeKeys is defined, use dynamic value, else fallback to pyID or pyGUID. */
+        this.compositeKeys = this.configProps$?.compositeKeys;
+        this.rowID = this.compositeKeys && this.compositeKeys?.length === 1 ? this.compositeKeys[0] : defRowID;
+        this.bShowSearch$ = this.utils.getBooleanValue(this.configProps$.globalSearch ? this.configProps$.globalSearch : this.payload.globalSearch);
+        this.bColumnReorder$ = this.utils.getBooleanValue(this.configProps$.reorderFields);
+        this.bGrouping$ = this.utils.getBooleanValue(this.configProps$.grouping);
+        this.showDynamicFields = this.configProps$?.showDynamicFields;
+        this.menuSvgIcon$ = this.utils.getImageSrc('more', this.utils.getSDKStaticContentUrl());
+        this.arrowDownSvgIcon$ = this.utils.getImageSrc('arrow-down', this.utils.getSDKStaticContentUrl());
+        this.arrowUpSvgIcon$ = this.utils.getImageSrc('arrow-up', this.utils.getSDKStaticContentUrl());
+        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.selectionMode = this.configProps$.selectionMode;
+        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());
+        setTimeout(() => {
+            PCore.getPubSubUtils().subscribe(PCore.getConstants().PUB_SUB_EVENTS.EVENT_DASHBOARD_FILTER_CHANGE, data => {
+                this.processFilterChange(data);
+            }, `dashboard-component-${'id'}`, false, this.pConn$.getContextName());
+            PCore.getPubSubUtils().subscribe(PCore.getConstants().PUB_SUB_EVENTS.EVENT_DASHBOARD_FILTER_CLEAR_ALL, () => {
+                this.filters = {};
+                this.processFilterClear();
+            }, `dashboard-component-${'id'}`, false, this.pConn$.getContextName());
+        }, 0);
+        if (this.configProps$) {
+            if (!this.payload) {
+                this.payload = { referenceList: this.configProps$.referenceList };
+            }
+            useInit({
+                pConn$: this.pConn$,
+                bInForm$: this.bInForm$,
+                ...this.payload,
+                listContext: this.listContext,
+                ref: this.ref,
+                showDynamicFields: this.showDynamicFields,
+                xRayUid: this.xRayUid,
+                cosmosTableRef: this.cosmosTableRef,
+                selectionMode: this.selectionMode
+            }).then(response => {
+                this.listContext = response;
+                this.getListData();
+            });
+        }
+    }
+    getFieldFromFilter(filter, dateRange = false) {
+        let fieldValue;
+        if (dateRange) {
+            fieldValue = filter?.AND[0]?.condition.lhs.field;
+        }
+        else {
+            fieldValue = filter?.condition.lhs.field;
+        }
+        return fieldValue;
+    }
+    // Will be triggered when EVENT_DASHBOARD_FILTER_CHANGE fires
+    processFilterChange(data) {
+        const { filterId, filterExpression } = data;
+        let dashboardFilterPayload = {
+            query: {
+                filter: {},
+                select: []
+            }
+        };
+        this.filters[filterId] = filterExpression;
+        let isDateRange = !!data.filterExpression?.AND;
+        // Will be AND by default but making it dynamic in case we support dynamic relational ops in future
+        const relationalOp = 'AND';
+        let field = this.getFieldFromFilter(filterExpression, isDateRange);
+        const selectParam = [];
+        // Constructing the select parameters list (will be sent in dashboardFilterPayload)
+        this.displayedColumns$?.forEach(col => {
+            selectParam.push({
+                field: col
+            });
+        });
+        // Checking if the triggered filter is applicable for this list
+        if (data.filterExpression !== null && !(this.displayedColumns$?.length && this.displayedColumns$?.includes(field))) {
+            return;
+        }
+        // This is a flag which will be used to reset dashboardFilterPayload in case we don't find any valid filters
+        let validFilter = false;
+        let index = 1;
+        // Iterating over the current filters list to create filter data which will be POSTed
+        const filterKeys = Object.keys(this.filters);
+        const filterValues = Object.values(this.filters);
+        for (let filterIndex = 0; filterIndex < filterKeys.length; filterIndex++) {
+            const filter = filterValues[filterIndex];
+            // If the filter is null then we can skip this iteration
+            if (filter === null) {
+                // eslint-disable-next-line no-continue
+                continue;
+            }
+            // Checking if the filter is of type- Date Range
+            isDateRange = !!filter?.AND;
+            field = this.getFieldFromFilter(filter, isDateRange);
+            if (!(this.displayedColumns$?.length && this.displayedColumns$?.includes(field))) {
+                // eslint-disable-next-line no-continue
+                continue;
+            }
+            // If we reach here that implies we've at least one valid filter, hence setting the flag
+            validFilter = true;
+            /** Below are the 2 cases for- Text & Date-Range filter types where we'll construct filter data which will be sent in the dashboardFilterPayload
+             * In Constellation DX Components, through Repeating Structures they might be using several APIs to do it. We're doing it here
+             */
+            if (isDateRange) {
+                dashboardFilterPayload = this.filterBasedOnDateRange(dashboardFilterPayload, filter, relationalOp, selectParam, index);
+            }
+            else {
+                dashboardFilterPayload.query.filter.filterConditions = {
+                    ...dashboardFilterPayload.query.filter.filterConditions,
+                    [`T${index++}`]: { ...filter.condition, ignoreCase: true }
+                };
+                if (dashboardFilterPayload.query.filter.logic) {
+                    dashboardFilterPayload.query.filter.logic = `${dashboardFilterPayload.query.filter.logic} ${relationalOp} T${index - 1}`;
+                }
+                else {
+                    dashboardFilterPayload.query.filter.logic = `T${index - 1}`;
+                }
+                dashboardFilterPayload.query.select = selectParam;
+            }
+        }
+        // Reset the dashboardFilterPayload if we end up with no valid filters for the list
+        if (!validFilter) {
+            dashboardFilterPayload = undefined;
+        }
+        this.filterPayload = dashboardFilterPayload;
+        this.getListData();
+    }
+    filterBasedOnDateRange(dashboardFilterPayload, filter, relationalOp, selectParam, index) {
+        const dateRelationalOp = filter?.AND ? 'AND' : 'OR';
+        dashboardFilterPayload.query.filter.filterConditions = {
+            ...dashboardFilterPayload.query.filter.filterConditions,
+            [`T${index++}`]: { ...filter[relationalOp][0].condition },
+            [`T${index++}`]: { ...filter[relationalOp][1].condition }
+        };
+        if (dashboardFilterPayload.query.filter.logic) {
+            dashboardFilterPayload.query.filter.logic = `${dashboardFilterPayload.query.filter.logic} ${relationalOp} (T${index - 2} ${dateRelationalOp} T${index - 1})`;
+        }
+        else {
+            dashboardFilterPayload.query.filter.logic = `(T${index - 2} ${relationalOp} T${index - 1})`;
+        }
+        dashboardFilterPayload.query.select = selectParam;
+        return dashboardFilterPayload;
+    }
+    processFilterClear() {
+        this.filterPayload = undefined;
+        this.getListData();
+    }
+    getFieldsMetadata(refList) {
+        // @ts-ignore - 3rd parameter "associationFilter" should be optional for getDataViewMetadata method
+        return PCore.getAnalyticsUtils().getDataViewMetadata(refList, this.showDynamicFields);
+    }
+    getListData() {
+        // @ts-ignore - Property 'getComponentConfig' is private and only accessible within class 'C11nEnv'
+        const componentConfig = this.pConn$.getComponentConfig();
+        if (this.configProps$) {
+            this.preparePayload();
+            const refList = this.configProps$.referenceList;
+            const fieldsMetaDataPromise = this.getFieldsMetadata(refList);
+            // returns a promise
+            const payload = this.payload || this.filterPayload || {};
+            const dataViewParameters = this.payload.parameters;
+            const workListDataPromise = !this.bInForm$
+                ? // @ts-ignore - 3rd parameter "context" should be optional in getData method
+                    PCore.getDataApiUtils().getData(refList, payload)
+                : PCore.getDataPageUtils().getDataAsync(refList, this.pConn$.getContextName(), payload.dataViewParameters ? payload.dataViewParameters : dataViewParameters, this.paging, this.query);
+            this.bShowFilterPopover$ = false;
+            this.psService.sendMessage(true);
+            Promise.all([fieldsMetaDataPromise, workListDataPromise])
+                .then((results) => {
+                const fieldsMetaData = results[0];
+                const workListData = results[1];
+                this.fields$ = this.configProps$.presets[0].children[0].children;
+                // this is an unresovled version of this.fields$, need unresolved, so can get the property reference
+                const columnFields = componentConfig.presets[0].children[0].children;
+                const tableDataResults = !this.bInForm$ ? workListData.data.data : workListData.data;
+                const columns = this.getHeaderCells(columnFields, this.fieldDefs);
+                this.fields$ = this.updateFields(this.fields$, fieldsMetaData.data.fields, columns);
+                this.displayedColumns$ = columns.map(col => {
+                    return col.id;
+                });
+                this.response = tableDataResults;
+                this.updatedRefList = this.updateData(tableDataResults, this.fields$);
+                if (this.selectionMode === SELECTION_MODE.SINGLE && this.updatedRefList?.length > 0) {
+                    this.displayedColumns$?.unshift('select');
+                    this.singleSelectionMode = true;
+                }
+                else if (this.selectionMode === SELECTION_MODE.MULTI && this.updatedRefList?.length > 0) {
+                    this.displayedColumns$?.unshift('select');
+                    this.multiSelectionMode = true;
+                }
+                this.repeatList$ = new MatTableDataSource(this.updatedRefList);
+                this.repeatList$.filterPredicate = this.customFilterPredicate.bind(this);
+                // keeping an original copy to get back after possible sorts, filters and groupBy
+                this.repeatListData = this.repeatList$.data.slice();
+                this.repeatList$.paginator = this.paginator;
+                this.repeatList$.sort = this.sort;
+                this.psService.sendMessage(false);
+            })
+                .catch(() => {
+                console.error("Couldn't fetch either the fieldsMetaData or workListData");
+                this.psService.sendMessage(false);
+            });
+        }
+    }
+    preparePayload() {
+        const { fieldDefs, itemKey, patchQueryFields } = this.listContext.meta;
+        this.fieldDefs = fieldDefs;
+        let listFields = fieldDefs ? this.buildSelect(fieldDefs, undefined, patchQueryFields, this.payload?.compositeKeys) : [];
+        listFields = this.addItemKeyInSelect(fieldDefs, itemKey, listFields, this.payload?.compositeKeys);
+        if (this.payload.query) {
+            this.query = this.payload.query;
+        }
+        else if (listFields?.length && this.listContext.meta.isQueryable) {
+            if (this.filterPayload) {
+                this.query = {
+                    select: listFields,
+                    filter: this.filterPayload?.query?.filter
+                };
+            }
+            else {
+                this.query = { select: listFields };
+            }
+        }
+        else if (this.filterPayload) {
+            this.query = this.filterPayload?.query;
+        }
+    }
+    // ngOnChanges(changes) {
+    //   if (changes && changes.payload) {
+    //     const currentPayloadVal = changes.payload?.currentValue;
+    //     const previousPayloadVal = changes.payload?.previousValue;
+    //     if (currentPayloadVal !== previousPayloadVal) {
+    //       this.getListData();
+    //     }
+    //   }
+    // }
+    ngOnDestroy() {
+        PCore.getPubSubUtils().unsubscribe(PCore.getConstants().PUB_SUB_EVENTS.EVENT_DASHBOARD_FILTER_CHANGE, `dashboard-component-${'id'}`, this.pConn$.getContextName());
+        PCore.getPubSubUtils().unsubscribe(PCore.getConstants().PUB_SUB_EVENTS.EVENT_DASHBOARD_FILTER_CLEAR_ALL, `dashboard-component-${'id'}`, this.pConn$.getContextName());
+    }
+    // ngAfterViewInit() {
+    //   // paginator has to exist for this to work,
+    //   // so called after init (paginator drawn)
+    //   // Calls are now in workListData promise
+    //   // this.repeatList$.paginator = this.paginator;
+    //   // this.repeatList$.sort = this.sort;
+    // }
+    drop(event) {
+        moveItemInArray(this.displayedColumns$, event.previousIndex, event.currentIndex);
+    }
+    updateFields(arFields, arColumns, fields) {
+        const arReturn = arFields;
+        arReturn.forEach((field, i) => {
+            field.config = { ...field.config, ...fields[i], name: fields[i].id };
+        });
+        return arReturn;
+    }
+    applySearch(event) {
+        const filterValue = event.target.value;
+        this.searchFilter = filterValue.trim().toLowerCase();
+        if (this.groupByColumns$.length > 0) {
+            this.repeatList$.data = this.repeatListData.slice();
+            this.repeatList$.filter = this.searchFilter;
+            const repeatData = this.repeatList$.sortData(this.repeatList$.filteredData, this.repeatList$.sort);
+            this.repeatList$.data = this.addGroups(repeatData, this.groupByColumns$);
+            this.perfFilter = performance.now().toString();
+            this.repeatList$.filter = this.perfFilter;
+        }
+        else {
+            this.repeatList$.filter = this.searchFilter;
+        }
+        if (this.repeatList$.paginator) {
+            this.repeatList$.paginator.firstPage();
+        }
+    }
+    fieldOnChange(row) {
+        const value = row[this.rowID];
+        const reqObj = {};
+        if (this.compositeKeys?.length > 1) {
+            const index = this.response.findIndex(element => element[this.rowID] === value);
+            const selectedRow = this.response[index];
+            this.compositeKeys.forEach(element => {
+                reqObj[element] = selectedRow[element];
+            });
+        }
+        else {
+            reqObj[this.rowID] = value;
+        }
+        this.pConn$?.getListActions?.()?.setSelectedRows([reqObj]);
+    }
+    onCheckboxClick(row, event) {
+        const value = row[this.rowID];
+        const checked = event?.checked;
+        const reqObj = {};
+        if (this.compositeKeys?.length > 1) {
+            const index = this.response.findIndex(element => element[this.rowID] === value);
+            const selectedRow = this.response[index];
+            this.compositeKeys.forEach(element => {
+                reqObj[element] = selectedRow[element];
+            });
+            reqObj.$selected = checked;
+        }
+        else {
+            reqObj[this.rowID] = value;
+            reqObj.$selected = checked;
+        }
+        this.pConn$?.getListActions()?.setSelectedRows([reqObj]);
+    }
+    // rowClick(row) {
+    //   switch (this.configProps$.rowClickAction) {
+    //     case 'openAssignment':
+    //       this.psService.sendMessage(true);
+    //       this.openAssignment(row);
+    //       break;
+    //   }
+    // }
+    _getIconStyle(level) {
+        let sReturn = '';
+        let nLevel = parseInt(level, 10);
+        nLevel--;
+        nLevel *= 15;
+        sReturn = `padding-left: ${nLevel}px; vertical-align: middle`;
+        return sReturn;
+    }
+    _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 '';
+    }
+    _showButton(name, row) {
+        let bReturn = false;
+        const { pxRefObjectClass, pzInsKey, pxRefObjectKey } = row;
+        switch (name) {
+            case 'pxTaskLabel':
+                if (pxRefObjectClass != '' && pzInsKey != '') {
+                    bReturn = true;
+                }
+                break;
+            case 'pxRefObjectInsName':
+                if (pxRefObjectClass != '' && pxRefObjectKey != '') {
+                    bReturn = true;
+                }
+                break;
+            default:
+                break;
+        }
+        return bReturn;
+    }
+    _listViewClick(column, row) {
+        const name = column.id;
+        if (column.displayAsLink) {
+            const { pxObjClass } = row;
+            let { pzInsKey } = row;
+            if (column.isAssociation) {
+                const associationCategory = name.split(':')[0];
+                pzInsKey = row[`${associationCategory}:pzInsKey`];
+            }
+            if (column.isAssignmentLink) {
+                this.pConn$.getActionsApi().openAssignment(pzInsKey, pxObjClass, {
+                    containerName: 'primary',
+                    channelName: ''
+                });
+            }
+            else {
+                this.pConn$.getActionsApi().openWorkByHandle(pzInsKey, pxObjClass);
+            }
+        }
+        else {
+            switch (name) {
+                case 'pxTaskLabel':
+                    this.openAssignment(row);
+                    break;
+                case 'pxRefObjectInsName':
+                    this.openWork(row);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    compare(a, b, isAsc) {
+        return (a < b ? -1 : 1) * (isAsc ? 1 : -1);
+    }
+    _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();
+    }
+    clearOutArrows(event, columnData) {
+        const arImages = event.srcElement.parentElement.getElementsByTagName('img');
+        for (const theImage of arImages) {
+            // let theImage = arImages[i]
+            const arrow = theImage.getAttribute('arrow');
+            if (arrow) {
+                const arrowId = theImage.getAttribute('arrowid');
+                if (arrow != 'none' && arrowId != columnData.config.name) {
+                    theImage.setAttribute('arrow', 'none');
+                    theImage.src = '';
+                }
+            }
+        }
+    }
+    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;
+            }
+        }
+        switch (this.arrowDirection) {
+            case 'up':
+                if (aValue < bValue) {
+                    return -1;
+                }
+                if (aValue > bValue) {
+                    return 1;
+                }
+                break;
+            case 'down':
+                if (aValue > bValue) {
+                    return -1;
+                }
+                if (aValue < bValue) {
+                    return 1;
+                }
+                break;
+            default:
+                break;
+        }
+        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 pathIndex = 0; pathIndex < eventPath.length; pathIndex++) {
+            if (eventPath[pathIndex].className == 'psdk-modal-file-top' ||
+                eventPath[pathIndex].tagName == 'BUTTON' ||
+                eventPath[pathIndex].tagName == 'MAT-OPTION' ||
+                eventPath[pathIndex].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') {
+                let filterValue;
+                switch (filterObj.type) {
+                    case 'Date':
+                    case 'DateTime':
+                    case 'Time':
+                        bKeep = this.filterDataWithDate(item, filterObj, filterValue);
+                        break;
+                    default:
+                        bKeep = this.filterDataWithCommonTypes(item, filterObj, filterValue);
+                        break;
+                }
+            }
+            // if don't keep stop filtering
+            if (!bKeep) {
+                break;
+            }
+        }
+        return bKeep;
+    }
+    filterDataWithDate(item, filterObj, filterValue) {
+        let bKeep;
+        let value = item[filterObj.ref] != null ?? item[filterObj.ref] != '' ? getSeconds(item[filterObj.ref]) : null;
+        filterValue = filterObj.containsFilterValue != null && filterObj.containsFilterValue != '' ? getSeconds(filterObj.containsFilterValue) : null;
+        switch (filterObj.containsFilter) {
+            case 'notequal':
+                // becasue filterValue is in minutes, need to have a range of less than 60 secons
+                if (value != null && filterValue != null) {
+                    // get rid of millisecons
+                    value /= 1000;
+                    filterValue /= 1000;
+                    const diff = value - filterValue;
+                    if (diff >= 0 && diff < 60) {
+                        bKeep = false;
+                    }
+                }
+                break;
+            case 'after':
+                if (value < filterValue) {
+                    bKeep = false;
+                }
+                break;
+            case 'before':
+                if (value > filterValue) {
+                    bKeep = false;
+                }
+                break;
+            case 'null':
+                if (value != null) {
+                    bKeep = false;
+                }
+                break;
+            case 'notnull':
+                if (value == null) {
+                    bKeep = false;
+                }
+                break;
+            default:
+                break;
+        }
+        return bKeep;
+    }
+    filterDataWithCommonTypes(item, filterObj, filterValue) {
+        let bKeep;
+        const value = item[filterObj.ref].toLowerCase();
+        filterValue = filterObj.containsFilterValue.toLowerCase();
+        switch (filterObj.containsFilter) {
+            case 'contains':
+                if (value.indexOf(filterValue) < 0) {
+                    bKeep = false;
+                }
+                break;
+            case 'equals':
+                if (value != filterValue) {
+                    bKeep = false;
+                }
+                break;
+            case 'startswith':
+                if (value.indexOf(filterValue) != 0) {
+                    bKeep = false;
+                }
+                break;
+            default:
+                break;
+        }
+        return bKeep;
+    }
+    filterSortGroupBy() {
+        // get original data set
+        let theData = this.repeatListData.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));
+        const reGroupData = this.addGroups(theData, this.groupByColumns$);
+        this.repeatList$.data = [];
+        this.repeatList$.data.push(...reGroupData);
+        if (this.searchFilter && this.searchFilter != '') {
+            this.repeatList$.filter = this.searchFilter;
+        }
+        else {
+            this.perfFilter = performance.now().toString();
+            this.repeatList$.filter = this.perfFilter;
+        }
+        this.repeatList$.filter = '';
+        if (this.repeatList$.paginator) {
+            this.repeatList$.paginator.firstPage();
+        }
+    }
+    //
+    // Grouping code inspired by this example
+    // https://stackblitz.com/edit/angular-material-table-row-grouping
+    //
+    _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);
+        }
+    }
+    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.repeatList$.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.repeatList$.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;
+    }
+    updateData(listData, fieldData) {
+        const returnList = new Array();
+        listData.forEach(row => {
+            // copy
+            const rowData = JSON.parse(JSON.stringify(row));
+            for (let fieldIndex = 0; fieldIndex < fieldData.length; fieldIndex++) {
+                const config = fieldData[fieldIndex].config;
+                let fieldName;
+                let formattedDate;
+                let myFormat;
+                let theCurrencyOptions;
+                switch (fieldData[fieldIndex].type) {
+                    case 'Date':
+                        fieldName = config.name;
+                        myFormat = config.formatter;
+                        if (!myFormat) {
+                            myFormat = 'Date';
+                        }
+                        formattedDate = this.utils.generateDate(rowData[fieldName], myFormat);
+                        rowData[fieldName] = formattedDate;
+                        break;
+                    case 'DateTime':
+                        fieldName = config.name;
+                        myFormat = config.formatter;
+                        if (!myFormat) {
+                            myFormat = 'DateTime-Long';
+                        }
+                        formattedDate = this.utils.generateDateTime(rowData[fieldName], myFormat);
+                        rowData[fieldName] = formattedDate;
+                        break;
+                    case 'Currency':
+                        fieldName = config.name;
+                        theCurrencyOptions = getCurrencyOptions(PCore.getEnvironmentInfo().getLocale());
+                        // eslint-disable-next-line no-case-declarations
+                        const defaultOptions = {
+                            locale: getLocale(),
+                            position: 'before',
+                            decPlaces: 2
+                        };
+                        // eslint-disable-next-line no-case-declarations
+                        const params = { ...defaultOptions, ...theCurrencyOptions };
+                        rowData[fieldName] = formatters.Currency(rowData[fieldName], params);
+                        // val = format(value, column.type, theCurrencyOptions);
+                        break;
+                    default:
+                        break;
+                }
+            }
+            returnList.push(rowData);
+        });
+        return returnList;
+    }
+    openAssignment(row) {
+        const { pxRefObjectClass, pzInsKey } = row;
+        const sTarget = this.pConn$.getContainerName();
+        const options = { containerName: sTarget };
+        this.pConn$.getActionsApi().openAssignment(pzInsKey, pxRefObjectClass, options);
+    }
+    openWork(row) {
+        const pxRefObjectClass = row.pxRefObjectClass || row.pxObjClass;
+        const { pxRefObjectKey } = row;
+        if (pxRefObjectClass !== '' && pxRefObjectKey !== '') {
+            this.pConn$.getActionsApi().openWorkByHandle(pxRefObjectKey, pxRefObjectClass);
+        }
+    }
+    initializeData(data) {
+        data.forEach((item, idx) => {
+            item.__original_index = idx;
+            item.__level = 1;
+        });
+        return data;
+    }
+    getType(field) {
+        const { config = {}, type } = field;
+        const { formatType } = config;
+        if (formatType === 'datetime' || formatType === 'date') {
+            // currently cosmos has only support for date ... it also need to support dateTime
+            return 'date';
+        }
+        return type.toLowerCase();
+    }
+    initializeColumns(fields = []) {
+        return fields.map((field, originalColIndex) => ({
+            ...field,
+            type: this.getType(field),
+            name: field.config.value.substring(4),
+            label: field.config.label.substring(3),
+            id: originalColIndex,
+            groupingEnabled: true,
+            grouped: false,
+            minWidth: 50,
+            cellRenderer: this.getType(field) === 'text' ? null : field.type,
+            filter: true
+        }));
+    }
+    getHeaderCells(colFields, fields) {
+        const AssignDashObjects = ['Assign-Worklist', 'Assign-WorkBasket'];
+        return colFields.map((field, index) => {
+            let theField = field.config.value.substring(field.config.value.indexOf(' ') + 1);
+            if (theField.indexOf('.') === 0) {
+                theField = theField.substring(1);
+            }
+            const colIndex = fields.findIndex(ele => ele.name === theField);
+            const displayAsLink = field.config.displayAsLink;
+            const headerRow = {};
+            headerRow.id = fields[index].id;
+            headerRow.type = field.type;
+            headerRow.displayAsLink = displayAsLink;
+            headerRow.numeric = field.type === 'Decimal' || field.type === 'Integer' || field.type === 'Percentage' || field.type === 'Currency' || false;
+            headerRow.disablePadding = false;
+            headerRow.label = fields[index].label;
+            if (colIndex > -1) {
+                headerRow.classID = fields[colIndex].classID;
+            }
+            if (displayAsLink) {
+                headerRow.isAssignmentLink = AssignDashObjects.includes(headerRow.classID);
+                if (field.config.value?.startsWith('@CA')) {
+                    headerRow.isAssociation = true;
+                }
+            }
+            return headerRow;
+        });
+    }
+    buildSelect(fieldDefs, colId, patchQueryFields = [], compositeKeys = []) {
+        const listFields = [];
+        if (colId) {
+            const field = this.getField(fieldDefs, colId);
+            listFields.push({
+                field: field.name
+            });
+        }
+        else {
+            // NOTE: If we ever decide to not set up all the `fieldDefs` on select, ensure that the fields
+            //  corresponding to `state.groups` are set up. Needed in Client-mode grouping/pagination.
+            fieldDefs.forEach(field => {
+                if (!listFields.find(f => f.field === field.name)) {
+                    listFields.push({
+                        field: field.name
+                    });
+                }
+            });
+            patchQueryFields.forEach(k => {
+                if (!listFields.find(f => f.field === k)) {
+                    listFields.push({
+                        field: k
+                    });
+                }
+            });
+        }
+        compositeKeys.forEach(k => {
+            if (!listFields.find(f => f.field === k)) {
+                listFields.push({
+                    field: k
+                });
+            }
+        });
+        return listFields;
+    }
+    getField(fieldDefs, columnId) {
+        const fieldsMap = this.getFieldsMap(fieldDefs);
+        return fieldsMap.get(columnId);
+    }
+    getFieldsMap(fieldDefs) {
+        const fieldsMap = new Map();
+        fieldDefs.forEach(element => {
+            fieldsMap.set(element.id, element);
+        });
+        return fieldsMap;
+    }
+    addItemKeyInSelect(fieldDefs, itemKey, select, compositeKeys) {
+        const elementFound = this.getField(fieldDefs, itemKey);
+        if (itemKey &&
+            !elementFound &&
+            Array.isArray(select) &&
+            !(compositeKeys !== null && compositeKeys?.length) &&
+            !select.find(sel => sel.field === itemKey)) {
+            return [
+                ...select,
+                {
+                    field: itemKey
+                }
+            ];
+        }
+        return select;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ListViewComponent, deps: [{ token: i1.ProgressSpinnerService }, { token: i2.Utils }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: ListViewComponent, isStandalone: true, selector: "app-list-view", inputs: { pConn$: "pConn$", bInForm$: "bInForm$", payload: "payload" }, viewQueries: [{ propertyName: "paginator", first: true, predicate: MatPaginator, descendants: true }, { propertyName: "sort", first: true, predicate: MatSort, descendants: true }], ngImport: i0, template: "<div class=\"psdk-list-header\">\n  <div>\n    <mat-form-field class=\"psdk-search\" *ngIf=\"bShowSearch$\">\n      <mat-label><img class=\"psdk-icon-search\" src=\"{{ searchIcon$ }}\" /> <span class=\"psdk-search-label\">Search</span> </mat-label>\n      <input matInput id=\"search\" (keyup)=\"applySearch($event)\" placeholder=\"\" />\n    </mat-form-field>\n\n    <div *ngIf=\"!bInForm$\" class=\"psdk-outer-div-in-form\">\n      <div class=\"psdk-inner-div-in-form\" *ngIf=\"bColumnReorder$\">\n        <div>\n          <table\n            mat-table\n            id=\"list-view\"\n            [dataSource]=\"repeatList$\"\n            matSort\n            cdkDropList\n            cdkDropListOrientation=\"horizontal\"\n            (cdkDropListDropped)=\"drop($event)\"\n          >\n            <ng-container *ngFor=\"let dCol of fields$\" [matColumnDef]=\"dCol.config.name\" sticky=\"true\">\n              <th mat-header-cell *matHeaderCellDef class=\"psdk-mat-header\" (click)=\"_headerSortClick($event, dCol)\" arrowPosition=\"before\" cdkDrag>\n                {{ dCol.config.label }}\n                <div class=\"psdk-mat-header-filter\">\n                  <img class=\"psdk-filter-svg-icon\" name=\"filterOnIcon\" />\n                </div>\n                <div class=\"psdk-mat-header-arrow\">\n                  <img class=\"psdk-arrow-svg-icon\" arrow=\"none\" [attr.arrowid]=\"dCol.config.name\" />\n                </div>\n                <div class=\"psdk-mat-header-button\" (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 *ngIf=\"!_showUnGroupBy(dCol) && bGrouping$\" 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; index as i\">\n                <button\n                  *ngIf=\"_showButton(dCol.config.name, dCol); else regular\"\n                  mat-button\n                  color=\"primary\"\n                  (click)=\"_listViewClick(dCol.config, element)\"\n                >\n                  {{ element[dCol.config.name] }}\n                </button>\n                <ng-template #regular>\n                  {{ element[dCol.config.name] || '---' }}\n                </ng-template>\n              </td>\n            </ng-container>\n\n            <tr mat-header-row *matHeaderRowDef=\"displayedColumns$; sticky: true\"></tr>\n            <tr mat-row *matRowDef=\"let row; columns: displayedColumns$\"></tr>\n\n            <!-- Group header -->\n            <ng-container matColumnDef=\"groupHeader\">\n              <td mat-cell colspan=\"999\" *matCellDef=\"let group\">\n                <mat-icon *ngIf=\"group.expanded\" [attr.style]=\"_getIconStyle(group.level)\">expand_less</mat-icon>\n                <mat-icon *ngIf=\"!group.expanded\" [attr.style]=\"_getIconStyle(group.level)\">expand_more</mat-icon>\n                <strong\n                  >{{ _getGroupName(groupByColumns$[group.level - 1]) }}: {{ group[groupByColumns$[group.level - 1]] }} ({{\n                    group.totalCounts\n                  }})</strong\n                >\n              </td>\n            </ng-container>\n\n            <tr mat-row *matRowDef=\"let row; columns: ['groupHeader']; when: isGroup\" (click)=\"_groupHeaderClick(row)\"></tr>\n          </table>\n        </div>\n      </div>\n      <div class=\"psdk-inner-div-in-form\" *ngIf=\"!bColumnReorder$\">\n        <div>\n          <table mat-table id=\"list-view\" [dataSource]=\"repeatList$\" matSort>\n            <ng-container *ngFor=\"let dCol of fields$\" [matColumnDef]=\"dCol.config.name\" sticky=\"true\">\n              <th mat-header-cell *matHeaderCellDef class=\"psdk-mat-header\" (click)=\"_headerSortClick($event, dCol)\" arrowPosition=\"before\">\n                {{ dCol.config.label }}\n                <div class=\"psdk-mat-header-filter\">\n                  <img class=\"psdk-filter-svg-icon\" name=\"filterOnIcon\" />\n                </div>\n                <div class=\"psdk-mat-header-arrow\">\n                  <img class=\"psdk-arrow-svg-icon\" arrow=\"none\" [attr.arrowid]=\"dCol.config.name\" />\n                </div>\n                <div class=\"psdk-mat-header-button\" (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 *ngIf=\"!_showUnGroupBy(dCol) && bGrouping$\" 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; index as i\">\n                <button\n                  *ngIf=\"_showButton(dCol.config.name, dCol); else regular\"\n                  mat-button\n                  color=\"primary\"\n                  (click)=\"_listViewClick(dCol.config, element)\"\n                >\n                  {{ element[dCol.config.name] }}\n                </button>\n                <ng-template #regular>\n                  {{ element[dCol.config.name] }}\n                </ng-template>\n              </td>\n            </ng-container>\n\n            <tr mat-header-row *matHeaderRowDef=\"displayedColumns$; sticky: true\"></tr>\n            <tr mat-row *matRowDef=\"let row; columns: displayedColumns$\"></tr>\n\n            <!-- Group header -->\n            <ng-container matColumnDef=\"groupHeader\">\n              <td mat-cell colspan=\"999\" *matCellDef=\"let group\">\n                <mat-icon *ngIf=\"group.expanded\" [attr.style]=\"_getIconStyle(group.level)\">expand_less</mat-icon>\n                <mat-icon *ngIf=\"!group.expanded\" [attr.style]=\"_getIconStyle(group.level)\">expand_more</mat-icon>\n                <strong\n                  >{{ _getGroupName(groupByColumns$[group.level - 1]) }}: {{ group[groupByColumns$[group.level - 1]] }} ({{\n                    group.totalCounts\n                  }})</strong\n                >\n              </td>\n            </ng-container>\n\n            <tr mat-row *matRowDef=\"let row; columns: ['groupHeader']; when: isGroup\" (click)=\"_groupHeaderClick(row)\"></tr>\n          </table>\n        </div>\n      </div>\n    </div>\n    <div *ngIf=\"bInForm$\">\n      <div>\n        <div class=\"psdk-inner-div-in-form\">\n          <table id=\"list-view\" *ngIf=\"repeatListData.length > 0\" mat-table [dataSource]=\"repeatList$\" matSort>\n            <ng-container *ngIf=\"singleSelectionMode\" matColumnDef=\"select\">\n              <th mat-header-cell *matHeaderCellDef></th>\n              <td mat-cell *matCellDef=\"let row\">\n                <mat-radio-button [value]=\"row[rowID]\" (change)=\"fieldOnChange(row)\"></mat-radio-button>\n              </td>\n            </ng-container>\n            <ng-container *ngIf=\"multiSelectionMode\" matColumnDef=\"select\">\n              <th mat-header-cell *matHeaderCellDef></th>\n              <td mat-cell *matCellDef=\"let row\">\n                <mat-checkbox [value]=\"row[rowID]\" (change)=\"onCheckboxClick(row, $event)\"></mat-checkbox>\n              </td>\n            </ng-container>\n            <ng-container *ngFor=\"let dCol of fields$\" [matColumnDef]=\"dCol.config.name\">\n              <th mat-header-cell *matHeaderCellDef mat-sort-header (click)=\"_headerSortClick($event, dCol)\" arrowPosition=\"before\">\n                {{ dCol.config.label }}\n              </th>\n              <td mat-cell *matCellDef=\"let element\">{{ element[dCol.config.name] }}</td>\n            </ng-container>\n\n            <tr mat-header-row *matHeaderRowDef=\"displayedColumns$\"></tr>\n            <tr mat-row *matRowDef=\"let row; columns: displayedColumns$\"></tr>\n          </table>\n          <div *ngIf=\"repeatListData?.length === 0\">\n            <table id=\"list-view\" *ngIf=\"repeatListData?.length === 0\" mat-table [dataSource]=\"repeatList$\">\n              <ng-container *ngFor=\"let dCol of fields$\" [matColumnDef]=\"dCol.config.name\">\n                <th mat-header-cell *matHeaderCellDef>{{ dCol.config.label }}</th>\n              </ng-container>\n              <tr mat-header-row *matHeaderRowDef=\"displayedColumns$\"></tr>\n            </table>\n          </div>\n          <div class=\"psdk-no-records\" *ngIf=\"repeatListData?.length === 0\">No Records Found.</div>\n        </div>\n      </div>\n    </div>\n\n    <mat-paginator id=\"pagination\" *ngIf=\"bInForm$\" [pageSizeOptions]=\"[10, 20, 50, 100, 500, 1000]\" showFirstLastButtons></mat-paginator>\n    <mat-paginator id=\"pagination\" *ngIf=\"!bInForm$\" [pageSizeOptions]=\"[10, 20, 50, 100, 500]\" showFirstLastButtons></mat-paginator>\n  </div>\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</div>\n", styles: [".psdk-list-header{background-color:#fff;padding:1rem;margin:.5rem;border-radius:.6125rem}table{width:100%}::ng-deep .mat-sort-header-content{white-space:nowrap}::ng-deep td.mat-mdc-cell{white-space:nowrap}::ng-deep th.mat-mdc-header-cell,td.mat-mdc-cell,td.mat-mdc-footer-cell{padding:0rem .188rem}::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:nowrap;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;padding-right:.625rem}.psdk-icon-search{vertical-align:sub;padding:.125rem;min-width:unset;width:1.1rem}.psdk-outer-div-in-form{padding:1rem;overflow:hidden}.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}.psdk-no-records{height:56px;justify-content:center;display:flex;align-items:center;border:1px solid lightgray;border-top:none}.psdk-table-field-link{color:#673ab7;padding:0;cursor:pointer;border:0;background-color:transparent;align-items:center}\n"], dependencies: [{ kind: "ngmodule", type: i0.forwardRef(function () { return CommonModule; }) }, { kind: "directive", type: i0.forwardRef(function () { return i3.NgForOf; }), selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i0.forwardRef(function () { return i3.NgIf; }), selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatFormFieldModule; }) }, { kind: "component", type: i0.forwardRef(function () { return i4.MatFormField; }), selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i0.forwardRef(function () { return i4.MatLabel; }), selector: "mat-label" }, { kind: "directive", type: i0.forwardRef(function () { return i4.MatSuffix; }), selector: "[matSuffix], [matIconSuffix], [matTextSuffix]", inputs: ["matTextSuffix"] }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatInputModule; }) }, { kind: "directive", type: i0.forwardRef(function () { return i5.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: "ngmodule", type: i0.forwardRef(function () { return MatTableModule; }) }, { kind: "component", type: i0.forwardRef(function () { return i6.MatTable; }), selector: "mat-table, table[mat-table]", exportAs: ["matTable"] }, { kind: "directive", type: i0.forwardRef(function () { return i6.MatHeaderCellDef; }), selector: "[matHeaderCellDef]" }, { kind: "directive", type: i0.forwardRef(function () { return i6.MatHeaderRowDef; }), selector: "[matHeaderRowDef]", inputs: ["matHeaderRowDef", "matHeaderRowDefSticky"] }, { kind: "directive", type: i0.forwardRef(function () { return i6.MatColumnDef; }), selector: "[matColumnDef]", inputs: ["sticky", "matColumnDef"] }, { kind: "directive", type: i0.forwardRef(function () { return i6.MatCellDef; }), selector: "[matCellDef]" }, { kind: "directive", type: i0.forwardRef(function () { return i6.MatRowDef; }), selector: "[matRowDef]", inputs: ["matRowDefColumns", "matRowDefWhen"] }, { kind: "directive", type: i0.forwardRef(function () { return i6.MatHeaderCell; }), selector: "mat-header-cell, th[mat-header-cell]" }, { kind: "directive", type: i0.forwardRef(function () { return i6.MatCell; }), selector: "mat-cell, td[mat-cell]" }, { kind: "component", type: i0.forwardRef(function () { return i6.MatHeaderRow; }), selector: "mat-header-row, tr[mat-header-row]", exportAs: ["matHeaderRow"] }, { kind: "component", type: i0.forwardRef(function () { return i6.MatRow; }), selector: "mat-row, tr[mat-row]", exportAs: ["matRow"] }, { 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 DragDropModule; }) }, { kind: "directive", type: i0.forwardRef(function () { return i8.CdkDropList; }), selector: "[cdkDropList], cdk-drop-list", inputs: ["cdkDropListConnectedTo", "cdkDropListData", "cdkDropListOrientation", "id", "cdkDropListLockAxis", "cdkDropListDisabled", "cdkDropListSortingDisabled", "cdkDropListEnterPredicate", "cdkDropListSortPredicate", "cdkDropListAutoScrollDisabled", "cdkDropListAutoScrollStep"], outputs: ["cdkDropListDropped", "cdkDropListEntered", "cdkDropListExited", "cdkDropListSorted"], exportAs: ["cdkDropList"] }, { kind: "directive", type: i0.forwardRef(function () { return i8.CdkDrag; }), selector: "[cdkDrag]", inputs: ["cdkDragData", "cdkDragLockAxis", "cdkDragRootElement", "cdkDragBoundary", "cdkDragStartDelay", "cdkDragFreeDragPosition", "cdkDragDisabled", "cdkDragConstrainPosition", "cdkDragPreviewClass", "cdkDragPreviewContainer"], outputs: ["cdkDragStarted", "cdkDragReleased", "cdkDragEnded", "cdkDragEntered", "cdkDragExited", "cdkDragDropped", "cdkDragMoved"], exportAs: ["cdkDrag"] }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatButtonModule; }) }, { kind: "component", type: i0.forwardRef(function () { return i9.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 i9.MatIconButton; }), selector: "button[mat-icon-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatMenuModule; }) }, { kind: "component", type: i0.forwardRef(function () { return i10.MatMenu; }), selector: "mat-menu", exportAs: ["matMenu"] }, { kind: "component", type: i0.forwardRef(function () { return i10.MatMenuItem; }), selector: "[mat-menu-item]", inputs: ["disabled", "disableRipple", "role"], exportAs: ["matMenuItem"] }, { kind: "directive", type: i0.forwardRef(function () { return i10.MatMenuTrigger; }), selector: "[mat-menu-trigger-for], [matMenuTriggerFor]", exportAs: ["matMenuTrigger"] }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatIconModule; }) }, { kind: "component", type: i0.forwardRef(function () { return i11.MatIcon; }), selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatRadioModule; }) }, { kind: "component", type: i0.forwardRef(function () { return i12.MatRadioButton; }), selector: "mat-radio-button", inputs: ["disableRipple", "tabIndex"], exportAs: ["matRadioButton"] }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatCheckboxModule; }) }, { kind: "component", type: i0.forwardRef(function () { return i13.MatCheckbox; }), selector: "mat-checkbox", inputs: ["disableRipple", "color", "tabIndex"], exportAs: ["matCheckbox"] }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatPaginatorModule; }) }, { kind: "component", type: i0.forwardRef(function () { return i14.MatPaginator; }), selector: "mat-paginator", inputs: ["disabled"], exportAs: ["matPaginator"] }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatSelectModule; }) }, { kind: "component", type: i0.forwardRef(function () { return i15.MatSelect; }), selector: "mat-select", inputs: ["disabled", "disableRipple", "tabIndex", "panelWidth", "hideSingleSelectionIndicator"], exportAs: ["matSelect"] }, { kind: "component", type: i0.forwardRef(function () { return i16.MatOption; }), selector: "mat-option", exportAs: ["matOption"] }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatOptionModule; }) }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatDatepickerModule; }) }, { kind: "component", type: i0.forwardRef(function () { return i17.MatDatepicker; }), selector: "mat-datepicker", exportAs: ["matDatepicker"] }, { kind: "directive", type: i0.forwardRef(function () { return i17.MatDatepickerInput; }), selector: "input[matDatepicker]", inputs: ["matDatepicker", "min", "max", "matDatepickerFilter"], exportAs: ["matDatepickerInput"] }, { kind: "component", type: i0.forwardRef(function () { return i17.MatDatepickerToggle; }), selector: "mat-datepicker-toggle", inputs: ["for", "tabIndex", "aria-label", "disabled", "disableRipple"], exportAs: ["matDatepickerToggle"] }, { 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: ListViewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-list-view', standalone: true, imports: [
+                        CommonModule,
+                        MatFormFieldModule,
+                        MatInputModule,
+                        MatTableModule,
+                        MatSortModule,
+                        DragDropModule,
+                        CdkDropList,
+                        CdkDrag,
+                        MatButtonModule,
+                        MatMenuModule,
+                        MatIconModule,
+                        MatRadioModule,
+                        MatCheckboxModule,
+                        MatPaginatorModule,
+                        MatSelectModule,
+                        MatOptionModule,
+                        MatDatepickerModule,
+                        forwardRef(() => ComponentMapperComponent)
+                    ], template: "<div class=\"psdk-list-header\">\n  <div>\n    <mat-form-field class=\"psdk-search\" *ngIf=\"bShowSearch$\">\n      <mat-label><img class=\"psdk-icon-search\" src=\"{{ searchIcon$ }}\" /> <span class=\"psdk-search-label\">Search</span> </mat-label>\n      <input matInput id=\"search\" (keyup)=\"applySearch($event)\" placeholder=\"\" />\n    </mat-form-field>\n\n    <div *ngIf=\"!bInForm$\" class=\"psdk-outer-div-in-form\">\n      <div class=\"psdk-inner-div-in-form\" *ngIf=\"bColumnReorder$\">\n        <div>\n          <table\n            mat-table\n            id=\"list-view\"\n            [dataSource]=\"repeatList$\"\n            matSort\n            cdkDropList\n            cdkDropListOrientation=\"horizontal\"\n            (cdkDropListDropped)=\"drop($event)\"\n          >\n            <ng-container *ngFor=\"let dCol of fields$\" [matColumnDef]=\"dCol.config.name\" sticky=\"true\">\n              <th mat-header-cell *matHeaderCellDef class=\"psdk-mat-header\" (click)=\"_headerSortClick($event, dCol)\" arrowPosition=\"before\" cdkDrag>\n                {{ dCol.config.label }}\n                <div class=\"psdk-mat-header-filter\">\n                  <img class=\"psdk-filter-svg-icon\" name=\"filterOnIcon\" />\n                </div>\n                <div class=\"psdk-mat-header-arrow\">\n                  <img class=\"psdk-arrow-svg-icon\" arrow=\"none\" [attr.arrowid]=\"dCol.config.name\" />\n                </div>\n                <div class=\"psdk-mat-header-button\" (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 *ngIf=\"!_showUnGroupBy(dCol) && bGrouping$\" 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; index as i\">\n                <button\n                  *ngIf=\"_showButton(dCol.config.name, dCol); else regular\"\n                  mat-button\n                  color=\"primary\"\n                  (click)=\"_listViewClick(dCol.config, element)\"\n                >\n                  {{ element[dCol.config.name] }}\n                </button>\n                <ng-template #regular>\n                  {{ element[dCol.config.name] || '---' }}\n                </ng-template>\n              </td>\n            </ng-container>\n\n            <tr mat-header-row *matHeaderRowDef=\"displayedColumns$; sticky: true\"></tr>\n            <tr mat-row *matRowDef=\"let row; columns: displayedColumns$\"></tr>\n\n            <!-- Group header -->\n            <ng-container matColumnDef=\"groupHeader\">\n              <td mat-cell colspan=\"999\" *matCellDef=\"let group\">\n                <mat-icon *ngIf=\"group.expanded\" [attr.style]=\"_getIconStyle(group.level)\">expand_less</mat-icon>\n                <mat-icon *ngIf=\"!group.expanded\" [attr.style]=\"_getIconStyle(group.level)\">expand_more</mat-icon>\n                <strong\n                  >{{ _getGroupName(groupByColumns$[group.level - 1]) }}: {{ group[groupByColumns$[group.level - 1]] }} ({{\n                    group.totalCounts\n                  }})</strong\n                >\n              </td>\n            </ng-container>\n\n            <tr mat-row *matRowDef=\"let row; columns: ['groupHeader']; when: isGroup\" (click)=\"_groupHeaderClick(row)\"></tr>\n          </table>\n        </div>\n      </div>\n      <div class=\"psdk-inner-div-in-form\" *ngIf=\"!bColumnReorder$\">\n        <div>\n          <table mat-table id=\"list-view\" [dataSource]=\"repeatList$\" matSort>\n            <ng-container *ngFor=\"let dCol of fields$\" [matColumnDef]=\"dCol.config.name\" sticky=\"true\">\n              <th mat-header-cell *matHeaderCellDef class=\"psdk-mat-header\" (click)=\"_headerSortClick($event, dCol)\" arrowPosition=\"before\">\n                {{ dCol.config.label }}\n                <div class=\"psdk-mat-header-filter\">\n                  <img class=\"psdk-filter-svg-icon\" name=\"filterOnIcon\" />\n                </div>\n                <div class=\"psdk-mat-header-arrow\">\n                  <img class=\"psdk-arrow-svg-icon\" arrow=\"none\" [attr.arrowid]=\"dCol.config.name\" />\n                </div>\n                <div class=\"psdk-mat-header-button\" (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 *ngIf=\"!_showUnGroupBy(dCol) && bGrouping$\" 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; index as i\">\n                <button\n                  *ngIf=\"_showButton(dCol.config.name, dCol); else regular\"\n                  mat-button\n                  color=\"primary\"\n                  (click)=\"_listViewClick(dCol.config, element)\"\n                >\n                  {{ element[dCol.config.name] }}\n                </button>\n                <ng-template #regular>\n                  {{ element[dCol.config.name] }}\n                </ng-template>\n              </td>\n            </ng-container>\n\n            <tr mat-header-row *matHeaderRowDef=\"displayedColumns$; sticky: true\"></tr>\n            <tr mat-row *matRowDef=\"let row; columns: displayedColumns$\"></tr>\n\n            <!-- Group header -->\n            <ng-container matColumnDef=\"groupHeader\">\n              <td mat-cell colspan=\"999\" *matCellDef=\"let group\">\n                <mat-icon *ngIf=\"group.expanded\" [attr.style]=\"_getIconStyle(group.level)\">expand_less</mat-icon>\n                <mat-icon *ngIf=\"!group.expanded\" [attr.style]=\"_getIconStyle(group.level)\">expand_more</mat-icon>\n                <strong\n                  >{{ _getGroupName(groupByColumns$[group.level - 1]) }}: {{ group[groupByColumns$[group.level - 1]] }} ({{\n                    group.totalCounts\n                  }})</strong\n                >\n              </td>\n            </ng-container>\n\n            <tr mat-row *matRowDef=\"let row; columns: ['groupHeader']; when: isGroup\" (click)=\"_groupHeaderClick(row)\"></tr>\n          </table>\n        </div>\n      </div>\n    </div>\n    <div *ngIf=\"bInForm$\">\n      <div>\n        <div class=\"psdk-inner-div-in-form\">\n          <table id=\"list-view\" *ngIf=\"repeatListData.length > 0\" mat-table [dataSource]=\"repeatList$\" matSort>\n            <ng-container *ngIf=\"singleSelectionMode\" matColumnDef=\"select\">\n              <th mat-header-cell *matHeaderCellDef></th>\n              <td mat-cell *matCellDef=\"let row\">\n                <mat-radio-button [value]=\"row[rowID]\" (change)=\"fieldOnChange(row)\"></mat-radio-button>\n              </td>\n            </ng-container>\n            <ng-container *ngIf=\"multiSelectionMode\" matColumnDef=\"select\">\n              <th mat-header-cell *matHeaderCellDef></th>\n              <td mat-cell *matCellDef=\"let row\">\n                <mat-checkbox [value]=\"row[rowID]\" (change)=\"onCheckboxClick(row, $event)\"></mat-checkbox>\n              </td>\n            </ng-container>\n            <ng-container *ngFor=\"let dCol of fields$\" [matColumnDef]=\"dCol.config.name\">\n              <th mat-header-cell *matHeaderCellDef mat-sort-header (click)=\"_headerSortClick($event, dCol)\" arrowPosition=\"before\">\n                {{ dCol.config.label }}\n              </th>\n              <td mat-cell *matCellDef=\"let element\">{{ element[dCol.config.name] }}</td>\n            </ng-container>\n\n            <tr mat-header-row *matHeaderRowDef=\"displayedColumns$\"></tr>\n            <tr mat-row *matRowDef=\"let row; columns: displayedColumns$\"></tr>\n          </table>\n          <div *ngIf=\"repeatListData?.length === 0\">\n            <table id=\"list-view\" *ngIf=\"repeatListData?.length === 0\" mat-table [dataSource]=\"repeatList$\">\n              <ng-container *ngFor=\"let dCol of fields$\" [matColumnDef]=\"dCol.config.name\">\n                <th mat-header-cell *matHeaderCellDef>{{ dCol.config.label }}</th>\n              </ng-container>\n              <tr mat-header-row *matHeaderRowDef=\"displayedColumns$\"></tr>\n            </table>\n          </div>\n          <div class=\"psdk-no-records\" *ngIf=\"repeatListData?.length === 0\">No Records Found.</div>\n        </div>\n      </div>\n    </div>\n\n    <mat-paginator id=\"pagination\" *ngIf=\"bInForm$\" [pageSizeOptions]=\"[10, 20, 50, 100, 500, 1000]\" showFirstLastButtons></mat-paginator>\n    <mat-paginator id=\"pagination\" *ngIf=\"!bInForm$\" [pageSizeOptions]=\"[10, 20, 50, 100, 500]\" showFirstLastButtons></mat-paginator>\n  </div>\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</div>\n", styles: [".psdk-list-header{background-color:#fff;padding:1rem;margin:.5rem;border-radius:.6125rem}table{width:100%}::ng-deep .mat-sort-header-content{white-space:nowrap}::ng-deep td.mat-mdc-cell{white-space:nowrap}::ng-deep th.mat-mdc-header-cell,td.mat-mdc-cell,td.mat-mdc-footer-cell{padding:0rem .188rem}::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:nowrap;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;padding-right:.625rem}.psdk-icon-search{vertical-align:sub;padding:.125rem;min-width:unset;width:1.1rem}.psdk-outer-div-in-form{padding:1rem;overflow:hidden}.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}.psdk-no-records{height:56px;justify-content:center;display:flex;align-items:center;border:1px solid lightgray;border-top:none}.psdk-table-field-link{color:#673ab7;padding:0;cursor:pointer;border:0;background-color:transparent;align-items:center}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ProgressSpinnerService }, { type: i2.Utils }]; }, propDecorators: { paginator: [{
+                type: ViewChild,
+                args: [MatPaginator]
+            }], sort: [{
+                type: ViewChild,
+                args: [MatSort]
+            }], pConn$: [{
+                type: Input
+            }], bInForm$: [{
+                type: Input
+            }], payload: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list-view.component.js","sourceRoot":"","sources":["../../../../../../../packages/angular-sdk-components/src/lib/_components/template/list-view/list-view.component.ts","../../../../../../../packages/angular-sdk-components/src/lib/_components/template/list-view/list-view.component.html"],"names":[],"mappings":"AAAA,yCAAyC;AACzC,OAAO,EAAE,SAAS,EAAU,KAAK,EAAE,SAAS,EAAE,UAAU,EAAa,MAAM,eAAe,CAAC;AAC3F,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAC/E,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC7E,OAAO,EAAE,cAAc,EAAe,eAAe,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAG5G,OAAO,EAAE,wBAAwB,EAAE,MAAM,8DAA8D,CAAC;AACxG,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,UAAU,EAAE,MAAM,2CAA2C,CAAC;AAEvE,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;;;;;;;;;;;;;;;;;;;AAI5C,MAAM,cAAc,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;AAgB5D,MAAM,OAAO,KAAK;IAAlB;QACE,UAAK,GAAG,CAAC,CAAC;QAEV,aAAQ,GAAG,IAAI,CAAC;QAChB,gBAAW,GAAG,CAAC,CAAC;IAIlB,CAAC;IAHC,IAAI,OAAO;QACT,OAAO,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACvE,CAAC;CACF;AA4BD,MAAM,OAAO,iBAAiB;IA+E5B,YACU,SAAiC,EACjC,KAAY;QADZ,cAAS,GAAT,SAAS,CAAwB;QACjC,UAAK,GAAL,KAAK,CAAO;QA5Eb,aAAQ,GAAG,IAAI,CAAC;QAMzB,sBAAiB,GAAG,KAAK,EAAO,CAAC;QACjC,oBAAe,GAAa,EAAE,CAAC;QAM/B,mBAAc,GAAU,EAAE,CAAC;QAI3B,iBAAY,GAAG,KAAK,CAAC;QACrB,oBAAe,GAAG,KAAK,CAAC;QACxB,eAAU,GAAG,KAAK,CAAC;QAMnB,kBAAa,GAAG,EAAE,CAAC;QAUnB,mBAAc,GAAG,MAAM,CAAC;QAExB,oBAAe,GAAU,EAAE,CAAC;QAC5B,wBAAmB,GAAG,KAAK,CAAC;QAC5B,eAAU,GAAG,IAAI,CAAC;QAClB,eAAU,GAAG,KAAK,CAAC;QAEnB,yBAAoB,GAAG,EAAE,CAAC;QAC1B,wBAAmB,GAAG,UAAU,CAAC;QAGjC,aAAQ,GAAG,KAAK,CAAC;QACjB,iBAAY,GAAG,KAAK,CAAC;QACrB,aAAQ,GAAG,KAAK,CAAC;QAKjB,yBAAoB,GAAU,EAAE,CAAC;QACjC,8BAAyB,GAAU,EAAE,CAAC;QAQtC,YAAO,GAAQ,EAAE,CAAC;QAClB,gBAAW,GAAU,EAAE,CAAC;QAExB,QAAG,GAAQ,EAAE,CAAC;QAEd,gBAAW,GAAQ,EAAE,CAAC;QACtB,UAAK,GAAQ,IAAI,CAAC;QAGlB,aAAQ,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC,cAAc,EAAE,CAAC;QAChD,YAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;IAKjC,CAAC;IAEJ,QAAQ;QACN,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,cAAc,EAAmB,CAAC;QAClE,6FAA6F;QAC7F,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,EAAE,aAAa,KAAK,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC;QACjF,uFAAuF;QACvF,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,YAAY,EAAE,aAAa,CAAC;QACtD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,aAAa,EAAE,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;QACvG,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;QAC5I,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;QACnF,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QACzE,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,YAAY,EAAE,iBAAiB,CAAC;QAE9D,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,sBAAsB,EAAE,CAAC,CAAC;QACxF,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,sBAAsB,EAAE,CAAC,CAAC;QACnG,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,sBAAsB,EAAE,CAAC,CAAC;QAE/F,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,sBAAsB,EAAE,CAAC,CAAC;QAC5F,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,sBAAsB,EAAE,CAAC,CAAC;QACjG,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,sBAAsB,EAAE,CAAC,CAAC;QAE1F,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC;QAErD,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC3F,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;QAEhG,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,sBAAsB,EAAE,CAAC,CAAC;QACzF,UAAU,CAAC,GAAG,EAAE;YACd,KAAK,CAAC,cAAc,EAAE,CAAC,SAAS,CAC9B,KAAK,CAAC,YAAY,EAAE,CAAC,cAAc,CAAC,6BAA6B,EACjE,IAAI,CAAC,EAAE;gBACL,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;YACjC,CAAC,EACD,uBAAuB,IAAI,EAAE,EAC7B,KAAK,EACL,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAC7B,CAAC;YACF,KAAK,CAAC,cAAc,EAAE,CAAC,SAAS,CAC9B,KAAK,CAAC,YAAY,EAAE,CAAC,cAAc,CAAC,gCAAgC,EACpE,GAAG,EAAE;gBACH,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;gBAClB,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC5B,CAAC,EACD,uBAAuB,IAAI,EAAE,EAC7B,KAAK,EACL,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAC7B,CAAC;QACJ,CAAC,EAAE,CAAC,CAAC,CAAC;QACN,IAAI,IAAI,CAAC,YAAY,EAAE;YACrB,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;gBACjB,IAAI,CAAC,OAAO,GAAG,EAAE,aAAa,EAAE,IAAI,CAAC,YAAY,CAAC,aAAa,EAAE,CAAC;aACnE;YACD,OAAO,CAAC;gBACN,MAAM,EAAE,IAAI,CAAC,MAAM;gBACnB,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,GAAG,IAAI,CAAC,OAAO;gBACf,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC7B,GAAG,EAAE,IAAI,CAAC,GAAG;gBACb,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;gBACzC,OAAO,EAAE,IAAI,CAAC,OAAO;gBACrB,cAAc,EAAE,IAAI,CAAC,cAAc;gBACnC,aAAa,EAAE,IAAI,CAAC,aAAa;aAClC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;gBACjB,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC;gBAC5B,IAAI,CAAC,WAAW,EAAE,CAAC;YACrB,CAAC,CAAC,CAAC;SACJ;IACH,CAAC;IAED,kBAAkB,CAAC,MAAM,EAAE,SAAS,GAAG,KAAK;QAC1C,IAAI,UAAU,CAAC;QACf,IAAI,SAAS,EAAE;YACb,UAAU,GAAG,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC;SAClD;aAAM;YACL,UAAU,GAAG,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC;SAC1C;QACD,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,6DAA6D;IAC7D,mBAAmB,CAAC,IAAI;QACtB,MAAM,EAAE,QAAQ,EAAE,gBAAgB,EAAE,GAAG,IAAI,CAAC;QAC5C,IAAI,sBAAsB,GAAQ;YAChC,KAAK,EAAE;gBACL,MAAM,EAAE,EAAE;gBACV,MAAM,EAAE,EAAE;aACX;SACF,CAAC;QAEF,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,gBAAgB,CAAC;QAC1C,IAAI,WAAW,GAAG,CAAC,CAAC,IAAI,CAAC,gBAAgB,EAAE,GAAG,CAAC;QAC/C,mGAAmG;QACnG,MAAM,YAAY,GAAG,KAAK,CAAC;QAE3B,IAAI,KAAK,GAAG,IAAI,CAAC,kBAAkB,CAAC,gBAAgB,EAAE,WAAW,CAAC,CAAC;QACnE,MAAM,WAAW,GAAU,EAAE,CAAC;QAC9B,mFAAmF;QACnF,IAAI,CAAC,iBAAiB,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE;YACpC,WAAW,CAAC,IAAI,CAAC;gBACf,KAAK,EAAE,GAAG;aACX,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,+DAA+D;QAC/D,IAAI,IAAI,CAAC,gBAAgB,KAAK,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,iBAAiB,EAAE,MAAM,IAAI,IAAI,CAAC,iBAAiB,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE;YAClH,OAAO;SACR;QACD,4GAA4G;QAC5G,IAAI,WAAW,GAAG,KAAK,CAAC;QAExB,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,qFAAqF;QACrF,MAAM,UAAU,GAAU,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACpD,MAAM,YAAY,GAAU,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACxD,KAAK,IAAI,WAAW,GAAG,CAAC,EAAE,WAAW,GAAG,UAAU,CAAC,MAAM,EAAE,WAAW,EAAE,EAAE;YACxE,MAAM,MAAM,GAAG,YAAY,CAAC,WAAW,CAAC,CAAC;YACzC,wDAAwD;YACxD,IAAI,MAAM,KAAK,IAAI,EAAE;gBACnB,uCAAuC;gBACvC,SAAS;aACV;YAED,gDAAgD;YAChD,WAAW,GAAG,CAAC,CAAC,MAAM,EAAE,GAAG,CAAC;YAC5B,KAAK,GAAG,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;YAErD,IAAI,CAAC,CAAC,IAAI,CAAC,iBAAiB,EAAE,MAAM,IAAI,IAAI,CAAC,iBAAiB,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE;gBAChF,uCAAuC;gBACvC,SAAS;aACV;YACD,wFAAwF;YACxF,WAAW,GAAG,IAAI,CAAC;YACnB;;eAEG;YACH,IAAI,WAAW,EAAE;gBACf,sBAAsB,GAAG,IAAI,CAAC,sBAAsB,CAAC,sBAAsB,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;aACxH;iBAAM;gBACL,sBAAsB,CAAC,KAAK,CAAC,MAAM,CAAC,gBAAgB,GAAG;oBACrD,GAAG,sBAAsB,CAAC,KAAK,CAAC,MAAM,CAAC,gBAAgB;oBACvD,CAAC,IAAI,KAAK,EAAE,EAAE,CAAC,EAAE,EAAE,GAAG,MAAM,CAAC,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE;iBAC3D,CAAC;gBAEF,IAAI,sBAAsB,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE;oBAC7C,sBAAsB,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,GAAG,GAAG,sBAAsB,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,IAAI,YAAY,KAAK,KAAK,GAAG,CAAC,EAAE,CAAC;iBAC1H;qBAAM;oBACL,sBAAsB,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,GAAG,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;iBAC7D;gBAED,sBAAsB,CAAC,KAAK,CAAC,MAAM,GAAG,WAAW,CAAC;aACnD;SACF;QAED,mFAAmF;QACnF,IAAI,CAAC,WAAW,EAAE;YAChB,sBAAsB,GAAG,SAAS,CAAC;SACpC;QACD,IAAI,CAAC,aAAa,GAAG,sBAAsB,CAAC;QAC5C,IAAI,CAAC,WAAW,EAAE,CAAC;IACrB,CAAC;IAED,sBAAsB,CAAC,sBAAsB,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,KAAK;QACrF,MAAM,gBAAgB,GAAG,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;QACpD,sBAAsB,CAAC,KAAK,CAAC,MAAM,CAAC,gBAAgB,GAAG;YACrD,GAAG,sBAAsB,CAAC,KAAK,CAAC,MAAM,CAAC,gBAAgB;YACvD,CAAC,IAAI,KAAK,EAAE,EAAE,CAAC,EAAE,EAAE,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE;YACzD,CAAC,IAAI,KAAK,EAAE,EAAE,CAAC,EAAE,EAAE,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE;SAC1D,CAAC;QACF,IAAI,sBAAsB,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE;YAC7C,sBAAsB,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,GAAG,GAAG,sBAAsB,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,IAAI,YAAY,MAAM,KAAK,GAAG,CAAC,IAAI,gBAAgB,KACzI,KAAK,GAAG,CACV,GAAG,CAAC;SACL;aAAM;YACL,sBAAsB,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,GAAG,KAAK,KAAK,GAAG,CAAC,IAAI,YAAY,KAAK,KAAK,GAAG,CAAC,GAAG,CAAC;SAC7F;QAED,sBAAsB,CAAC,KAAK,CAAC,MAAM,GAAG,WAAW,CAAC;QAElD,OAAO,sBAAsB,CAAC;IAChC,CAAC;IAED,kBAAkB;QAChB,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC;QAC/B,IAAI,CAAC,WAAW,EAAE,CAAC;IACrB,CAAC;IAED,iBAAiB,CAAC,OAAO;QACvB,mGAAmG;QACnG,OAAO,KAAK,CAAC,iBAAiB,EAAE,CAAC,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;IACxF,CAAC;IAED,WAAW;QACT,mGAAmG;QACnG,MAAM,eAAe,GAAG,IAAI,CAAC,MAAM,CAAC,kBAAkB,EAAE,CAAC;QACzD,IAAI,IAAI,CAAC,YAAY,EAAE;YACrB,IAAI,CAAC,cAAc,EAAE,CAAC;YACtB,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC;YAChD,MAAM,qBAAqB,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;YAC9D,oBAAoB;YACpB,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,aAAa,IAAI,EAAE,CAAC;YACzD,MAAM,kBAAkB,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;YAEnD,MAAM,mBAAmB,GAAG,CAAC,IAAI,CAAC,QAAQ;gBACxC,CAAC,CAAC,4EAA4E;oBAC5E,KAAK,CAAC,eAAe,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC;gBACnD,CAAC,CAAC,KAAK,CAAC,gBAAgB,EAAE,CAAC,YAAY,CACnC,OAAO,EACP,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,EAC5B,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,kBAAkB,EAC5E,IAAI,CAAC,MAAM,EACX,IAAI,CAAC,KAAK,CACX,CAAC;YAEN,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;YAEjC,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;YAEjC,OAAO,CAAC,GAAG,CAAC,CAAC,qBAAqB,EAAE,mBAAmB,CAAC,CAAC;iBACtD,IAAI,CAAC,CAAC,OAAY,EAAE,EAAE;gBACrB,MAAM,cAAc,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;gBAClC,MAAM,YAAY,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;gBAEhC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;gBACjE,oGAAoG;gBACpG,MAAM,YAAY,GAAG,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;gBAErE,MAAM,gBAAgB,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC;gBAErF,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;gBAClE,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,EAAE,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBACpF,IAAI,CAAC,iBAAiB,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;oBACzC,OAAO,GAAG,CAAC,EAAE,CAAC;gBAChB,CAAC,CAAC,CAAC;gBACH,IAAI,CAAC,QAAQ,GAAG,gBAAgB,CAAC;gBACjC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,UAAU,CAAC,gBAAgB,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;gBACtE,IAAI,IAAI,CAAC,aAAa,KAAK,cAAc,CAAC,MAAM,IAAI,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,CAAC,EAAE;oBACnF,IAAI,CAAC,iBAAiB,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;oBAC1C,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;iBACjC;qBAAM,IAAI,IAAI,CAAC,aAAa,KAAK,cAAc,CAAC,KAAK,IAAI,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,CAAC,EAAE;oBACzF,IAAI,CAAC,iBAAiB,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;oBAC1C,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;iBAChC;gBAED,IAAI,CAAC,WAAW,GAAG,IAAI,kBAAkB,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;gBAC/D,IAAI,CAAC,WAAW,CAAC,eAAe,GAAG,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAEzE,iFAAiF;gBACjF,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;gBAEpD,IAAI,CAAC,WAAW,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;gBAC5C,IAAI,CAAC,WAAW,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;gBAClC,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;YACpC,CAAC,CAAC;iBACD,KAAK,CAAC,GAAG,EAAE;gBACV,OAAO,CAAC,KAAK,CAAC,0DAA0D,CAAC,CAAC;gBAC1E,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;YACpC,CAAC,CAAC,CAAC;SACN;IACH,CAAC;IAED,cAAc;QACZ,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,gBAAgB,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;QACvE,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,UAAU,GAAG,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,SAAS,EAAE,gBAAgB,EAAE,IAAI,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACxH,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;QAClG,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE;YACtB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;SACjC;aAAM,IAAI,UAAU,EAAE,MAAM,IAAI,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,EAAE;YAClE,IAAI,IAAI,CAAC,aAAa,EAAE;gBACtB,IAAI,CAAC,KAAK,GAAG;oBACX,MAAM,EAAE,UAAU;oBAClB,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,KAAK,EAAE,MAAM;iBAC1C,CAAC;aACH;iBAAM;gBACL,IAAI,CAAC,KAAK,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;aACrC;SACF;aAAM,IAAI,IAAI,CAAC,aAAa,EAAE;YAC7B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,aAAa,EAAE,KAAK,CAAC;SACxC;IACH,CAAC;IACD,yBAAyB;IACzB,sCAAsC;IACtC,+DAA+D;IAC/D,iEAAiE;IACjE,sDAAsD;IACtD,4BAA4B;IAC5B,QAAQ;IACR,MAAM;IACN,IAAI;IAEJ,WAAW;QACT,KAAK,CAAC,cAAc,EAAE,CAAC,WAAW,CAChC,KAAK,CAAC,YAAY,EAAE,CAAC,cAAc,CAAC,6BAA6B,EACjE,uBAAuB,IAAI,EAAE,EAC7B,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAC7B,CAAC;QACF,KAAK,CAAC,cAAc,EAAE,CAAC,WAAW,CAChC,KAAK,CAAC,YAAY,EAAE,CAAC,cAAc,CAAC,gCAAgC,EACpE,uBAAuB,IAAI,EAAE,EAC7B,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAC7B,CAAC;IACJ,CAAC;IAED,sBAAsB;IACtB,gDAAgD;IAChD,8CAA8C;IAC9C,6CAA6C;IAC7C,oDAAoD;IACpD,0CAA0C;IAC1C,IAAI;IAEJ,IAAI,CAAC,KAA4B;QAC/B,eAAe,CAAC,IAAI,CAAC,iBAAiB,EAAE,KAAK,CAAC,aAAa,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;IACnF,CAAC;IAED,YAAY,CAAC,QAAe,EAAE,SAAS,EAAE,MAAM;QAC7C,MAAM,QAAQ,GAAG,QAAQ,CAAC;QAC1B,QAAQ,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;YAC5B,KAAK,CAAC,MAAM,GAAG,EAAE,GAAG,KAAK,CAAC,MAAM,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;QACvE,CAAC,CAAC,CAAC;QACH,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,WAAW,CAAC,KAAY;QACtB,MAAM,WAAW,GAAI,KAAK,CAAC,MAA2B,CAAC,KAAK,CAAC;QAC7D,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QAErD,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE;YACnC,IAAI,CAAC,WAAW,CAAC,IAAI,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;YACpD,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC;YAC5C,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,IAAI,CAAC,WAAW,CAAC,IAAe,CAAC,CAAC;YAC9G,IAAI,CAAC,WAAW,CAAC,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;YAEzE,IAAI,CAAC,UAAU,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC;YAC/C,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC;SAC3C;aAAM;YACL,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC;SAC7C;QAED,IAAI,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE;YAC9B,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,SAAS,EAAE,CAAC;SACxC;IACH,CAAC;IAED,aAAa,CAAC,GAAG;QACf,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC9B,MAAM,MAAM,GAAG,EAAE,CAAC;QAClB,IAAI,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,CAAC,EAAE;YAClC,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC,CAAC;YAChF,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YACzC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;gBACnC,MAAM,CAAC,OAAO,CAAC,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;YACzC,CAAC,CAAC,CAAC;SACJ;aAAM;YACL,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;SAC5B;QACD,IAAI,CAAC,MAAM,EAAE,cAAc,EAAE,EAAE,EAAE,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IAC7D,CAAC;IAED,eAAe,CAAC,GAAG,EAAE,KAAK;QACxB,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC9B,MAAM,OAAO,GAAG,KAAK,EAAE,OAAO,CAAC;QAC/B,MAAM,MAAM,GAAQ,EAAE,CAAC;QACvB,IAAI,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,CAAC,EAAE;YAClC,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC,CAAC;YAChF,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YACzC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;gBACnC,MAAM,CAAC,OAAO,CAAC,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;YACzC,CAAC,CAAC,CAAC;YACH,MAAM,CAAC,SAAS,GAAG,OAAO,CAAC;SAC5B;aAAM;YACL,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;YAC3B,MAAM,CAAC,SAAS,GAAG,OAAO,CAAC;SAC5B;QACD,IAAI,CAAC,MAAM,EAAE,cAAc,EAAE,EAAE,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IAC3D,CAAC;IAED,kBAAkB;IAClB,gDAAgD;IAChD,6BAA6B;IAC7B,0CAA0C;IAC1C,kCAAkC;IAClC,eAAe;IACf,MAAM;IACN,IAAI;IAEJ,aAAa,CAAC,KAAK;QACjB,IAAI,OAAO,GAAG,EAAE,CAAC;QACjB,IAAI,MAAM,GAAG,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACjC,MAAM,EAAE,CAAC;QACT,MAAM,IAAI,EAAE,CAAC;QACb,OAAO,GAAG,iBAAiB,MAAM,4BAA4B,CAAC;QAE9D,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,aAAa,CAAC,SAAS;QACrB,KAAK,IAAI,UAAU,GAAG,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE;YACvE,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;YACvC,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,IAAI,SAAS,EAAE;gBAClC,OAAO,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC;aAC3B;SACF;QACD,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,WAAW,CAAC,IAAI,EAAE,GAAG;QACnB,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,MAAM,EAAE,gBAAgB,EAAE,QAAQ,EAAE,cAAc,EAAE,GAAG,GAAG,CAAC;QAC3D,QAAQ,IAAI,EAAE;YACZ,KAAK,aAAa;gBAChB,IAAI,gBAAgB,IAAI,EAAE,IAAI,QAAQ,IAAI,EAAE,EAAE;oBAC5C,OAAO,GAAG,IAAI,CAAC;iBAChB;gBACD,MAAM;YACR,KAAK,oBAAoB;gBACvB,IAAI,gBAAgB,IAAI,EAAE,IAAI,cAAc,IAAI,EAAE,EAAE;oBAClD,OAAO,GAAG,IAAI,CAAC;iBAChB;gBACD,MAAM;YACR;gBACE,MAAM;SACT;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,cAAc,CAAC,MAAM,EAAE,GAAG;QACxB,MAAM,IAAI,GAAG,MAAM,CAAC,EAAE,CAAC;QACvB,IAAI,MAAM,CAAC,aAAa,EAAE;YACxB,MAAM,EAAE,UAAU,EAAE,GAAG,GAAG,CAAC;YAC3B,IAAI,EAAE,QAAQ,EAAE,GAAG,GAAG,CAAC;YACvB,IAAI,MAAM,CAAC,aAAa,EAAE;gBACxB,MAAM,mBAAmB,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC/C,QAAQ,GAAG,GAAG,CAAC,GAAG,mBAAmB,WAAW,CAAC,CAAC;aACnD;YACD,IAAI,MAAM,CAAC,gBAAgB,EAAE;gBAC3B,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC,cAAc,CAAC,QAAQ,EAAE,UAAU,EAAE;oBAC/D,aAAa,EAAE,SAAS;oBACxB,WAAW,EAAE,EAAE;iBAChB,CAAC,CAAC;aACJ;iBAAM;gBACL,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC,gBAAgB,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;aACpE;SACF;aAAM;YACL,QAAQ,IAAI,EAAE;gBACZ,KAAK,aAAa;oBAChB,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;oBACzB,MAAM;gBACR,KAAK,oBAAoB;oBACvB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;oBACnB,MAAM;gBACR;oBACE,MAAM;aACT;SACF;IACH,CAAC;IAED,OAAO,CAAC,CAAkB,EAAE,CAAkB,EAAE,KAAc;QAC5D,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7C,CAAC;IAED,gBAAgB,CAAC,KAAK,EAAE,UAAU;QAChC,yCAAyC;QAEzC,qFAAqF;QACrF,oEAAoE;QACpE,oDAAoD;QAEpD,0CAA0C;QAE1C,uBAAuB;QACvB,eAAe;QACf,+CAA+C;QAC/C,gDAAgD;QAChD,aAAa;QACb,iBAAiB;QACjB,2BAA2B;QAC3B,gDAAgD;QAChD,aAAa;QACb,aAAa;QACb,6CAA6C;QAC7C,8CAA8C;QAC9C,aAAa;QACb,IAAI;QAEJ,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC,IAAI,CAAC;QACnC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC;QACzC,0DAA0D;QAC1D,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,KAAK,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;QAEnE,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC3B,CAAC;IAED,cAAc,CAAC,KAAK,EAAE,UAAU;QAC9B,MAAM,QAAQ,GAAG,KAAK,CAAC,UAAU,CAAC,aAAa,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;QAE5E,KAAK,MAAM,QAAQ,IAAI,QAAQ,EAAE;YAC/B,6BAA6B;YAC7B,MAAM,KAAK,GAAG,QAAQ,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;YAC7C,IAAI,KAAK,EAAE;gBACT,MAAM,OAAO,GAAG,QAAQ,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;gBACjD,IAAI,KAAK,IAAI,MAAM,IAAI,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,EAAE;oBACxD,QAAQ,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;oBACvC,QAAQ,CAAC,GAAG,GAAG,EAAE,CAAC;iBACnB;aACF;SACF;IACH,CAAC;IAED,WAAW,CAAC,CAAC,EAAE,CAAC;QACd,IAAI,MAAM,GAAG,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAChC,IAAI,MAAM,GAAG,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAEhC,IAAI,IAAI,CAAC,WAAW,IAAI,MAAM,IAAI,IAAI,CAAC,WAAW,IAAI,UAAU,EAAE;YAChE,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;YAC5B,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;SAC7B;QAED,IAAI,IAAI,CAAC,UAAU,IAAI,oBAAoB,EAAE;YAC3C,MAAM,MAAM,GAAG,IAAI,CAAC,iCAAiC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;YACtE,IAAI,MAAM,KAAK,SAAS,EAAE;gBACxB,OAAO,MAAM,CAAC;aACf;SACF;QAED,QAAQ,IAAI,CAAC,cAAc,EAAE;YAC3B,KAAK,IAAI;gBACP,IAAI,MAAM,GAAG,MAAM,EAAE;oBACnB,OAAO,CAAC,CAAC,CAAC;iBACX;gBACD,IAAI,MAAM,GAAG,MAAM,EAAE;oBACnB,OAAO,CAAC,CAAC;iBACV;gBACD,MAAM;YACR,KAAK,MAAM;gBACT,IAAI,MAAM,GAAG,MAAM,EAAE;oBACnB,OAAO,CAAC,CAAC,CAAC;iBACX;gBACD,IAAI,MAAM,GAAG,MAAM,EAAE;oBACnB,OAAO,CAAC,CAAC;iBACV;gBACD,MAAM;YACR;gBACE,MAAM;SACT;QAED,OAAO,CAAC,CAAC;IACX,CAAC;IAED,iCAAiC,CAAC,MAAM,EAAE,MAAM;QAC9C,MAAM,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAClC,MAAM,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAClC,QAAQ,IAAI,CAAC,cAAc,EAAE;YAC3B,KAAK,IAAI;gBACP,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE;oBAC7B,IAAI,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;wBAAE,OAAO,CAAC,CAAC,CAAC;oBACvC,IAAI,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;wBAAE,OAAO,CAAC,CAAC;oBACtC,OAAO,CAAC,CAAC;iBACV;gBACD,OAAO,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YACjC,KAAK,MAAM;gBACT,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE;oBAC7B,IAAI,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;wBAAE,OAAO,CAAC,CAAC,CAAC;oBACvC,IAAI,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;wBAAE,OAAO,CAAC,CAAC;oBACtC,OAAO,CAAC,CAAC;iBACV;gBACD,OAAO,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YACjC;gBACE,MAAM;SACT;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,mBAAmB,CAAC,IAAI;QACtB,QAAQ,IAAI,EAAE;YACZ,KAAK,MAAM;gBACT,IAAI,CAAC,mBAAmB,GAAG,UAAU,CAAC;gBACtC,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;gBACxB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;gBACvB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;gBACrB,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;gBAC1B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;gBACtB,MAAM;YACR,KAAK,UAAU;gBACb,IAAI,CAAC,mBAAmB,GAAG,UAAU,CAAC;gBACtC,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;gBACxB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;gBACvB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;gBACtB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;gBACzB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;gBACtB,MAAM;YACR,KAAK,MAAM;gBACT,IAAI,CAAC,mBAAmB,GAAG,UAAU,CAAC;gBACtC,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;gBACxB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;gBACvB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;gBACtB,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;gBAC1B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;gBACrB,MAAM;YACR;gBACE,IAAI,CAAC,mBAAmB,GAAG,UAAU,CAAC;gBACtC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;gBACvB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;gBACxB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;gBACtB,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;gBAC1B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;gBACtB,MAAM;SACT;IACH,CAAC;IAED,OAAO,CAAC,KAAK,EAAE,UAAU;QACvB,yBAAyB;QACzB,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QAE/D,IAAI,CAAC,oBAAoB,GAAG,UAAU,CAAC;QACvC,IAAI,CAAC,oBAAoB,GAAG,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC;QAEpD,UAAU,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,mBAAmB,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YAE1C,IAAI,CAAC,2BAA2B,CAAC,UAAU,CAAC,CAAC;YAE7C,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;QAClC,CAAC,CAAC,CAAC;IACL,CAAC;IAED,UAAU,CAAC,KAAU;QACnB,IAAI,QAAQ,GAAG,KAAK,CAAC;QAErB,6EAA6E;QAC7E,yBAAyB;QACzB,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC;QAC7B,KAAK,IAAI,SAAS,GAAG,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE;YACjE,IACE,SAAS,CAAC,SAAS,CAAC,CAAC,SAAS,IAAI,qBAAqB;gBACvD,SAAS,CAAC,SAAS,CAAC,CAAC,OAAO,IAAI,QAAQ;gBACxC,SAAS,CAAC,SAAS,CAAC,CAAC,OAAO,IAAI,YAAY;gBAC5C,SAAS,CAAC,SAAS,CAAC,CAAC,OAAO,IAAI,WAAW,EAC3C;gBACA,QAAQ,GAAG,IAAI,CAAC;gBAChB,MAAM;aACP;SACF;QACD,IAAI,CAAC,QAAQ,EAAE;YACb,oCAAoC;YAEpC,MAAM,CAAC,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;SACnE;IACH,CAAC;IAED,mBAAmB,CAAC,KAAK;QACvB,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC,KAAK,CAAC;IACzC,CAAC;IAED,oBAAoB,CAAC,KAAK;QACxB,IAAI,CAAC,oBAAoB,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC;IACjD,CAAC;IAED,wBAAwB,CAAC,KAAK,EAAE,KAAK;QACnC,IAAI,CAAC,oBAAoB,GAAG,KAAK,CAAC;IACpC,CAAC;IAED,4BAA4B,CAAC,KAAK;QAChC,IAAI,CAAC,oBAAoB,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC;IACjD,CAAC;IAED,wBAAwB,CAAC,KAAK;QAC5B,IAAI,CAAC,oBAAoB,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC;IACjD,CAAC;IAED,0BAA0B,CAAC,KAAU;QACnC,gBAAgB;QAChB,QAAQ,KAAK,CAAC,MAAM,EAAE;YACpB,KAAK,QAAQ;gBACX,IAAI,CAAC,oBAAoB,GAAG,EAAE,CAAC;gBAC/B,MAAM;YACR,KAAK,QAAQ;gBACX,IAAI,CAAC,oBAAoB,EAAE,CAAC;gBAC5B,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACzB,MAAM;YACR;gBACE,MAAM;SACT;QAED,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;QAEjC,MAAM,CAAC,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IACpE,CAAC;IAED,oBAAoB;QAClB,IAAI,MAAM,GAAG,KAAK,CAAC;QACnB,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,eAAe,EAAE;YAC5C,IAAI,SAAS,CAAC,GAAG,KAAK,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,IAAI,EAAE;gBAC3D,SAAS,CAAC,IAAI,GAAG,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC;gBAChD,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC,mBAAmB,CAAC;gBACpD,SAAS,CAAC,mBAAmB,GAAG,IAAI,CAAC,oBAAoB,CAAC;gBAE1D,MAAM,GAAG,IAAI,CAAC;gBACd,MAAM;aACP;SACF;QAED,IAAI,CAAC,MAAM,EAAE;YACX,SAAS;YACT,MAAM,SAAS,GAAQ,EAAE,CAAC;YAC1B,SAAS,CAAC,GAAG,GAAG,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,IAAI,CAAC;YACtD,SAAS,CAAC,IAAI,GAAG,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC;YAChD,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC,mBAAmB,CAAC;YACpD,SAAS,CAAC,mBAAmB,GAAG,IAAI,CAAC,oBAAoB,CAAC;YAE1D,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;SACtC;QAED,mDAAmD;QACnD,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,eAAe,EAAE;YAC5C,MAAM,mBAAmB,GAAG,SAAS,CAAC,mBAAmB,CAAC;YAC1D,MAAM,cAAc,GAAG,SAAS,CAAC,cAAc,CAAC;YAChD,MAAM,SAAS,GAAG,SAAS,CAAC,GAAG,CAAC;YAChC,MAAM,WAAW,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;YAC9D,MAAM,WAAW,GAAG,QAAQ,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC;YAC/D,MAAM,SAAS,GAAQ,WAAW,CAAC,WAAW,CAAC,CAAC;YAChD,IAAI,mBAAmB,IAAI,EAAE,IAAI,cAAc,IAAI,MAAM,IAAI,cAAc,IAAI,SAAS,EAAE;gBACxF,aAAa;gBACb,SAAS,CAAC,GAAG,GAAG,EAAE,CAAC;aACpB;iBAAM;gBACL,YAAY;gBACZ,SAAS,CAAC,GAAG,GAAG,IAAI,CAAC,gBAAgB,CAAC;aACvC;SACF;IACH,CAAC;IAED,2BAA2B,CAAC,UAAU;QACpC,gEAAgE;QAEhE,IAAI,MAAM,GAAG,KAAK,CAAC;QACnB,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,eAAe,EAAE;YAC5C,IAAI,SAAS,CAAC,GAAG,KAAK,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,IAAI,EAAE;gBAC3D,IAAI,CAAC,mBAAmB,GAAG,SAAS,CAAC,cAAc,CAAC;gBACpD,IAAI,CAAC,oBAAoB,GAAG,SAAS,CAAC,mBAAmB,CAAC;gBAE1D,MAAM,GAAG,IAAI,CAAC;gBACd,MAAM;aACP;SACF;QAED,IAAI,CAAC,MAAM,EAAE;YACX,QAAQ,UAAU,CAAC,IAAI,EAAE;gBACvB,KAAK,MAAM,CAAC;gBACZ,KAAK,UAAU,CAAC;gBAChB,KAAK,MAAM;oBACT,IAAI,CAAC,mBAAmB,GAAG,UAAU,CAAC;oBACtC,MAAM;gBACR;oBACE,IAAI,CAAC,mBAAmB,GAAG,UAAU,CAAC;oBACtC,MAAM;aACT;YAED,IAAI,CAAC,oBAAoB,GAAG,EAAE,CAAC;SAChC;IACH,CAAC;IAED,UAAU,CAAC,IAAS;QAClB,IAAI,KAAK,GAAG,IAAI,CAAC;QACjB,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,eAAe,EAAE;YAC5C,IAAI,SAAS,CAAC,mBAAmB,IAAI,EAAE,IAAI,SAAS,CAAC,cAAc,IAAI,MAAM,IAAI,SAAS,CAAC,cAAc,IAAI,SAAS,EAAE;gBACtH,IAAI,WAAgB,CAAC;gBAErB,QAAQ,SAAS,CAAC,IAAI,EAAE;oBACtB,KAAK,MAAM,CAAC;oBACZ,KAAK,UAAU,CAAC;oBAChB,KAAK,MAAM;wBACT,KAAK,GAAG,IAAI,CAAC,kBAAkB,CAAC,IAAI,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC;wBAC9D,MAAM;oBACR;wBACE,KAAK,GAAG,IAAI,CAAC,yBAAyB,CAAC,IAAI,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC;wBACrE,MAAM;iBACT;aACF;YAED,+BAA+B;YAC/B,IAAI,CAAC,KAAK,EAAE;gBACV,MAAM;aACP;SACF;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED,kBAAkB,CAAC,IAAI,EAAE,SAAS,EAAE,WAAW;QAC7C,IAAI,KAAK,CAAC;QACV,IAAI,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,IAAI,IAAI,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAC9G,WAAW,GAAG,SAAS,CAAC,mBAAmB,IAAI,IAAI,IAAI,SAAS,CAAC,mBAAmB,IAAI,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,SAAS,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAE9I,QAAQ,SAAS,CAAC,cAAc,EAAE;YAChC,KAAK,UAAU;gBACb,iFAAiF;gBACjF,IAAI,KAAK,IAAI,IAAI,IAAI,WAAW,IAAI,IAAI,EAAE;oBACxC,yBAAyB;oBACzB,KAAK,IAAI,IAAI,CAAC;oBACd,WAAW,IAAI,IAAI,CAAC;oBAEpB,MAAM,IAAI,GAAG,KAAK,GAAG,WAAW,CAAC;oBACjC,IAAI,IAAI,IAAI,CAAC,IAAI,IAAI,GAAG,EAAE,EAAE;wBAC1B,KAAK,GAAG,KAAK,CAAC;qBACf;iBACF;gBACD,MAAM;YACR,KAAK,OAAO;gBACV,IAAI,KAAK,GAAG,WAAW,EAAE;oBACvB,KAAK,GAAG,KAAK,CAAC;iBACf;gBACD,MAAM;YACR,KAAK,QAAQ;gBACX,IAAI,KAAK,GAAG,WAAW,EAAE;oBACvB,KAAK,GAAG,KAAK,CAAC;iBACf;gBACD,MAAM;YACR,KAAK,MAAM;gBACT,IAAI,KAAK,IAAI,IAAI,EAAE;oBACjB,KAAK,GAAG,KAAK,CAAC;iBACf;gBACD,MAAM;YACR,KAAK,SAAS;gBACZ,IAAI,KAAK,IAAI,IAAI,EAAE;oBACjB,KAAK,GAAG,KAAK,CAAC;iBACf;gBACD,MAAM;YACR;gBACE,MAAM;SACT;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED,yBAAyB,CAAC,IAAI,EAAE,SAAS,EAAE,WAAW;QACpD,IAAI,KAAK,CAAC;QACV,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;QAChD,WAAW,GAAG,SAAS,CAAC,mBAAmB,CAAC,WAAW,EAAE,CAAC;QAE1D,QAAQ,SAAS,CAAC,cAAc,EAAE;YAChC,KAAK,UAAU;gBACb,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE;oBAClC,KAAK,GAAG,KAAK,CAAC;iBACf;gBACD,MAAM;YACR,KAAK,QAAQ;gBACX,IAAI,KAAK,IAAI,WAAW,EAAE;oBACxB,KAAK,GAAG,KAAK,CAAC;iBACf;gBACD,MAAM;YACR,KAAK,YAAY;gBACf,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE;oBACnC,KAAK,GAAG,KAAK,CAAC;iBACf;gBACD,MAAM;YACR;gBACE,MAAM;SACT;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED,iBAAiB;QACf,wBAAwB;QACxB,IAAI,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;QAE1C,oCAAoC;QACpC,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QAErD,kCAAkC;QAClC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QAE1C,MAAM,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;QAElE,IAAI,CAAC,WAAW,CAAC,IAAI,GAAG,EAAE,CAAC;QAC3B,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC,CAAC;QAE3C,IAAI,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,YAAY,IAAI,EAAE,EAAE;YAChD,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC;SAC7C;aAAM;YACL,IAAI,CAAC,UAAU,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC;YAC/C,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC;SAC3C;QACD,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,EAAE,CAAC;QAE7B,IAAI,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE;YAC9B,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,SAAS,EAAE,CAAC;SACxC;IACH,CAAC;IAED,EAAE;IACF,yCAAyC;IACzC,kEAAkE;IAClE,EAAE;IAEF,cAAc,CAAC,UAAU;QACvB,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,eAAe,EAAE;YACtC,IAAI,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,EAAE;gBACjC,OAAO,IAAI,CAAC;aACb;SACF;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED,QAAQ,CAAC,KAAK,EAAE,UAAU;QACxB,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAEtD,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC3B,CAAC;IAED,UAAU,CAAC,KAAK,EAAE,UAAU;QAC1B,2BAA2B;QAC3B,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAEvD,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC3B,CAAC;IAED,kBAAkB,CAAC,KAAK,EAAE,GAAG;QAC3B,IAAI,KAAK,GAAkB,IAAI,CAAC;QAChC,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,eAAe,EAAE;YACzC,IAAI,MAAM,KAAK,KAAK,EAAE;gBACpB,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;aACjD;SACF;QACD,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,CAAC,EAAE;YAC/B,IAAI,CAAC,GAAG,EAAE;gBACR,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;aACvC;SACF;aAAM,IAAI,GAAG,EAAE;YACd,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SAClC;IACH,CAAC;IAED,SAAS,CAAC,IAAW,EAAE,cAAwB;QAC7C,MAAM,SAAS,GAAG,IAAI,KAAK,EAAE,CAAC;QAC9B,SAAS,CAAC,QAAQ,GAAG,IAAI,CAAC;QAC1B,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,EAAE,cAAc,EAAE,SAAS,CAAC,CAAC;IAC9D,CAAC;IAED,WAAW,CAAC,IAAW,EAAE,KAAa,EAAE,cAAwB,EAAE,MAAa;QAC7E,IAAI,KAAK,IAAI,cAAc,CAAC,MAAM,EAAE;YAClC,OAAO,IAAI,CAAC;SACb;QACD,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAC1B,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;YACb,MAAM,MAAM,GAAG,IAAI,KAAK,EAAE,CAAC;YAC3B,MAAM,CAAC,KAAK,GAAG,KAAK,GAAG,CAAC,CAAC;YACzB,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC;YACvB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC,EAAE,EAAE;gBAC/B,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;aACpD;YACD,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC,EACF,IAAI,CAAC,SAAS,CACf,CAAC;QAEF,MAAM,aAAa,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;QAC5C,IAAI,SAAS,GAAU,EAAE,CAAC;QAC1B,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YACrB,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,aAAa,CAAC,KAAK,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC;YACpF,KAAK,CAAC,WAAW,GAAG,WAAW,CAAC,MAAM,CAAC;YACvC,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,KAAK,GAAG,CAAC,EAAE,cAAc,EAAE,KAAK,CAAC,CAAC;YACjF,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YACxB,SAAS,GAAG,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACzC,CAAC,CAAC,CAAC;QACH,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,QAAQ,CAAC,CAAC,EAAE,GAAG;QACb,MAAM,IAAI,GAAG,EAAE,CAAC;QAChB,OAAO,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;YACrB,MAAM,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;YACpB,mEAAmE;YACnE,OAAO,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;QAC3D,CAAC,CAAC,CAAC;IACL,CAAC;IAED,OAAO,CAAC,KAAK,EAAE,IAAI;QACjB,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED,iBAAiB,CAAC,GAAG;QACnB,GAAG,CAAC,QAAQ,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC;QAC7B,gCAAgC;QAChC,IAAI,CAAC,UAAU,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC;QAC/C,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC;IAC5C,CAAC;IAED,iCAAiC;IACjC,qBAAqB,CAAC,IAAiB,EAAE,MAAc;QACrD,OAAO,IAAI,YAAY,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,2BAA2B,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IAC/F,CAAC;IAED,iBAAiB,CAAC,IAAS;QACzB,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE;YACnD,IAAI,CAAC,CAAC,GAAG,YAAY,KAAK,CAAC,EAAE;gBAC3B,OAAO,KAAK,CAAC;aACd;YACD,IAAI,KAAK,GAAG,IAAI,CAAC;YACjB,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;gBACpC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC,MAAM,CAAC,EAAE;oBACjE,KAAK,GAAG,KAAK,CAAC;iBACf;YACH,CAAC,CAAC,CAAC;YACH,OAAO,KAAK,CAAC;QACf,CAAC,CAAC,CAAC;QAEH,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE;YAC1B,OAAO,IAAI,CAAC;SACb;QACD,MAAM,MAAM,GAAG,SAAS,CAAC,CAAC,CAAU,CAAC;QACrC,OAAO,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,QAAQ,CAAC;IAC3C,CAAC;IAED,2BAA2B,CAAC,IAAI,EAAE,MAAM;QACtC,6CAA6C;QAC7C,IAAI,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QAE5C,IAAI,QAAQ,IAAI,MAAM,IAAI,MAAM,IAAI,EAAE,IAAI,MAAM,IAAI,IAAI,CAAC,UAAU,EAAE;YACnE,gCAAgC;YAEhC,qCAAqC;YACrC,QAAQ,GAAG,KAAK,CAAC;YACjB,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,iBAAiB,EAAE;gBACxC,uBAAuB;gBACvB,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;oBACxE,QAAQ,GAAG,IAAI,CAAC;oBAChB,MAAM;iBACP;aACF;SACF;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,UAAU,CAAC,QAAe,EAAE,SAAgB;QAC1C,MAAM,UAAU,GAAU,IAAI,KAAK,EAAO,CAAC;QAC3C,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;YACrB,OAAO;YACP,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC;YAEhD,KAAK,IAAI,UAAU,GAAG,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE;gBACpE,MAAM,MAAM,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC;gBAC5C,IAAI,SAAS,CAAC;gBACd,IAAI,aAAa,CAAC;gBAClB,IAAI,QAAQ,CAAC;gBACb,IAAI,kBAAkB,CAAC;gBAEvB,QAAQ,SAAS,CAAC,UAAU,CAAC,CAAC,IAAI,EAAE;oBAClC,KAAK,MAAM;wBACT,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC;wBACxB,QAAQ,GAAG,MAAM,CAAC,SAAS,CAAC;wBAC5B,IAAI,CAAC,QAAQ,EAAE;4BACb,QAAQ,GAAG,MAAM,CAAC;yBACnB;wBACD,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,CAAC;wBAEtE,OAAO,CAAC,SAAS,CAAC,GAAG,aAAa,CAAC;wBACnC,MAAM;oBACR,KAAK,UAAU;wBACb,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC;wBACxB,QAAQ,GAAG,MAAM,CAAC,SAAS,CAAC;wBAC5B,IAAI,CAAC,QAAQ,EAAE;4BACb,QAAQ,GAAG,eAAe,CAAC;yBAC5B;wBACD,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,CAAC;wBAE1E,OAAO,CAAC,SAAS,CAAC,GAAG,aAAa,CAAC;wBACnC,MAAM;oBACR,KAAK,UAAU;wBACb,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC;wBACxB,kBAAkB,GAAG,kBAAkB,CAAC,KAAK,CAAC,kBAAkB,EAAE,CAAC,SAAS,EAAY,CAAC,CAAC;wBAC1F,gDAAgD;wBAChD,MAAM,cAAc,GAAG;4BACrB,MAAM,EAAE,SAAS,EAAE;4BACnB,QAAQ,EAAE,QAAQ;4BAClB,SAAS,EAAE,CAAC;yBACb,CAAC;wBACF,gDAAgD;wBAChD,MAAM,MAAM,GAAG,EAAE,GAAG,cAAc,EAAE,GAAG,kBAAkB,EAAE,CAAC;wBAC5D,OAAO,CAAC,SAAS,CAAC,GAAG,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC,CAAC;wBACrE,wDAAwD;wBACxD,MAAM;oBACR;wBACE,MAAM;iBACT;aACF;YACD,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC3B,CAAC,CAAC,CAAC;QAEH,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,cAAc,CAAC,GAAG;QAChB,MAAM,EAAE,gBAAgB,EAAE,QAAQ,EAAE,GAAG,GAAG,CAAC;QAC3C,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;QAC/C,MAAM,OAAO,GAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,CAAC;QAChD,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC,cAAc,CAAC,QAAQ,EAAE,gBAAgB,EAAE,OAAO,CAAC,CAAC;IAClF,CAAC;IAED,QAAQ,CAAC,GAAG;QACV,MAAM,gBAAgB,GAAG,GAAG,CAAC,gBAAgB,IAAI,GAAG,CAAC,UAAU,CAAC;QAChE,MAAM,EAAE,cAAc,EAAE,GAAG,GAAG,CAAC;QAC/B,IAAI,gBAAgB,KAAK,EAAE,IAAI,cAAc,KAAK,EAAE,EAAE;YACpD,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC,gBAAgB,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC;SAChF;IACH,CAAC;IAED,cAAc,CAAC,IAAI;QACjB,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE;YACzB,IAAI,CAAC,gBAAgB,GAAG,GAAG,CAAC;YAC5B,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;QACnB,CAAC,CAAC,CAAC;QAEH,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,CAAC,KAAK;QACX,MAAM,EAAE,MAAM,GAAG,EAAE,EAAE,IAAI,EAAE,GAAG,KAAK,CAAC;QACpC,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,CAAC;QAC9B,IAAI,UAAU,KAAK,UAAU,IAAI,UAAU,KAAK,MAAM,EAAE;YACtD,kFAAkF;YAClF,OAAO,MAAM,CAAC;SACf;QAED,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;IAC5B,CAAC;IAED,iBAAiB,CAAC,MAAM,GAAG,EAAE;QAC3B,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,KAAU,EAAE,gBAAgB,EAAE,EAAE,CAAC,CAAC;YACnD,GAAG,KAAK;YACR,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;YACzB,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;YACrC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;YACtC,EAAE,EAAE,gBAAgB;YACpB,eAAe,EAAE,IAAI;YACrB,OAAO,EAAE,KAAK;YACd,QAAQ,EAAE,EAAE;YACZ,YAAY,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI;YAChE,MAAM,EAAE,IAAI;SACb,CAAC,CAAC,CAAC;IACN,CAAC;IAED,cAAc,CAAC,SAAS,EAAE,MAAM;QAC9B,MAAM,iBAAiB,GAAG,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,CAAC;QACnE,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,KAAU,EAAE,KAAK,EAAE,EAAE;YACzC,IAAI,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;YACjF,IAAI,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;gBAC/B,QAAQ,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;aAClC;YACD,MAAM,QAAQ,GAAG,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC;YAChE,MAAM,aAAa,GAAG,KAAK,CAAC,MAAM,CAAC,aAAa,CAAC;YACjD,MAAM,SAAS,GAAQ,EAAE,CAAC;YAC1B,SAAS,CAAC,EAAE,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;YAChC,SAAS,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;YAC5B,SAAS,CAAC,aAAa,GAAG,aAAa,CAAC;YACxC,SAAS,CAAC,OAAO,GAAG,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,IAAI,KAAK,CAAC,IAAI,KAAK,UAAU,IAAI,KAAK,CAAC;YAC9I,SAAS,CAAC,cAAc,GAAG,KAAK,CAAC;YACjC,SAAS,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC;YACtC,IAAI,QAAQ,GAAG,CAAC,CAAC,EAAE;gBACjB,SAAS,CAAC,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC;aAC9C;YACD,IAAI,aAAa,EAAE;gBACjB,SAAS,CAAC,gBAAgB,GAAG,iBAAiB,CAAC,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;gBAC3E,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE,UAAU,CAAC,KAAK,CAAC,EAAE;oBACzC,SAAS,CAAC,aAAa,GAAG,IAAI,CAAC;iBAChC;aACF;YACD,OAAO,SAAS,CAAC;QACnB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,WAAW,CAAC,SAAS,EAAE,KAAK,EAAE,gBAAgB,GAAG,EAAE,EAAE,aAAa,GAAG,EAAE;QACrE,MAAM,UAAU,GAAQ,EAAE,CAAC;QAC3B,IAAI,KAAK,EAAE;YACT,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;YAC9C,UAAU,CAAC,IAAI,CAAC;gBACd,KAAK,EAAE,KAAK,CAAC,IAAI;aAClB,CAAC,CAAC;SACJ;aAAM;YACL,8FAA8F;YAC9F,0FAA0F;YAC1F,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;gBACxB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,KAAK,CAAC,IAAI,CAAC,EAAE;oBACjD,UAAU,CAAC,IAAI,CAAC;wBACd,KAAK,EAAE,KAAK,CAAC,IAAI;qBAClB,CAAC,CAAC;iBACJ;YACH,CAAC,CAAC,CAAC;YACH,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;gBAC3B,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,EAAE;oBACxC,UAAU,CAAC,IAAI,CAAC;wBACd,KAAK,EAAE,CAAC;qBACT,CAAC,CAAC;iBACJ;YACH,CAAC,CAAC,CAAC;SACJ;QAED,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;YACxB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,EAAE;gBACxC,UAAU,CAAC,IAAI,CAAC;oBACd,KAAK,EAAE,CAAC;iBACT,CAAC,CAAC;aACJ;QACH,CAAC,CAAC,CAAC;QACH,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,QAAQ,CAAC,SAAS,EAAE,QAAQ;QAC1B,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;QAC/C,OAAO,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACjC,CAAC;IAED,YAAY,CAAC,SAAS;QACpB,MAAM,SAAS,GAAG,IAAI,GAAG,EAAE,CAAC;QAC5B,SAAS,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;YAC1B,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;QACrC,CAAC,CAAC,CAAC;QACH,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,kBAAkB,CAAC,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa;QAC1D,MAAM,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QAEvD,IACE,OAAO;YACP,CAAC,YAAY;YACb,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;YACrB,CAAC,CAAC,aAAa,KAAK,IAAI,IAAI,aAAa,EAAE,MAAM,CAAC;YAClD,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,KAAK,KAAK,OAAO,CAAC,EAC1C;YACA,OAAO;gBACL,GAAG,MAAM;gBACT;oBACE,KAAK,EAAE,OAAO;iBACf;aACF,CAAC;SACH;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;+GA9yCU,iBAAiB;mGAAjB,iBAAiB,4LACjB,YAAY,uEACZ,OAAO,gDClFpB,yraA6PA,4rEDjMI,YAAY,oXACZ,kBAAkB,ukBAClB,cAAc,wbACd,cAAc,67CACd,aAAa,skBACb,cAAc,kkCAGd,eAAe,6hBACf,aAAa,8iBACb,aAAa,kQACb,cAAc,gQACd,iBAAiB,+PACjB,kBAAkB,wOAClB,eAAe,8aACf,eAAe,qEACf,mBAAmB,iqBACF,wBAAwB;;4FAGhC,iBAAiB;kBA1B7B,SAAS;+BACE,eAAe,cAGb,IAAI,WACP;wBACP,YAAY;wBACZ,kBAAkB;wBAClB,cAAc;wBACd,cAAc;wBACd,aAAa;wBACb,cAAc;wBACd,WAAW;wBACX,OAAO;wBACP,eAAe;wBACf,aAAa;wBACb,aAAa;wBACb,cAAc;wBACd,iBAAiB;wBACjB,kBAAkB;wBAClB,eAAe;wBACf,eAAe;wBACf,mBAAmB;wBACnB,UAAU,CAAC,GAAG,EAAE,CAAC,wBAAwB,CAAC;qBAC3C;iIAGwB,SAAS;sBAAjC,SAAS;uBAAC,YAAY;gBACH,IAAI;sBAAvB,SAAS;uBAAC,OAAO;gBAET,MAAM;sBAAd,KAAK;gBACG,QAAQ;sBAAhB,KAAK;gBACG,OAAO;sBAAf,KAAK","sourcesContent":["/* eslint-disable max-classes-per-file */\nimport { Component, OnInit, Input, ViewChild, forwardRef, OnDestroy } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { MatDatepickerModule } from '@angular/material/datepicker';\nimport { MatOptionModule } from '@angular/material/core';\nimport { MatSelectModule } from '@angular/material/select';\nimport { MatCheckboxModule } from '@angular/material/checkbox';\nimport { MatRadioModule } from '@angular/material/radio';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatMenuModule } from '@angular/material/menu';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatInputModule } from '@angular/material/input';\nimport { MatFormFieldModule } from '@angular/material/form-field';\nimport { MatPaginator, MatPaginatorModule } from '@angular/material/paginator';\nimport { MatSort, MatSortModule } from '@angular/material/sort';\nimport { MatTableDataSource, MatTableModule } from '@angular/material/table';\nimport { DragDropModule, CdkDragDrop, moveItemInArray, CdkDropList, CdkDrag } from '@angular/cdk/drag-drop';\nimport { ProgressSpinnerService } from '../../../_messages/progress-spinner.service';\nimport { Utils } from '../../../_helpers/utils';\nimport { ComponentMapperComponent } from '../../../_bridge/component-mapper/component-mapper.component';\nimport { getCurrencyOptions } from '../../../_helpers/currency-utils';\nimport { getLocale, getSeconds } from '../../../_helpers/common';\nimport { formatters } from '../../../_helpers/formatters/format-utils';\n\nimport { useInit } from './listViewHelpers';\n\ndeclare const window: any;\n\nconst SELECTION_MODE = { SINGLE: 'single', MULTI: 'multi' };\n\ninterface ListViewProps {\n  // If any, enter additional props that only exist on this component\n  globalSearch?: boolean;\n  referenceList?: any;\n  rowClickAction?: any;\n  selectionMode?: string;\n  referenceType?: string;\n  compositeKeys?: any;\n  showDynamicFields?: boolean;\n  presets?: any;\n  reorderFields: string | boolean;\n  grouping: string | boolean;\n}\n\nexport class 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-list-view',\n  templateUrl: './list-view.component.html',\n  styleUrls: ['./list-view.component.scss'],\n  standalone: true,\n  imports: [\n    CommonModule,\n    MatFormFieldModule,\n    MatInputModule,\n    MatTableModule,\n    MatSortModule,\n    DragDropModule,\n    CdkDropList,\n    CdkDrag,\n    MatButtonModule,\n    MatMenuModule,\n    MatIconModule,\n    MatRadioModule,\n    MatCheckboxModule,\n    MatPaginatorModule,\n    MatSelectModule,\n    MatOptionModule,\n    MatDatepickerModule,\n    forwardRef(() => ComponentMapperComponent)\n  ]\n})\nexport class ListViewComponent implements OnInit, OnDestroy {\n  @ViewChild(MatPaginator) paginator: MatPaginator;\n  @ViewChild(MatSort) sort: MatSort;\n\n  @Input() pConn$: typeof PConnect;\n  @Input() bInForm$ = true;\n  @Input() payload;\n\n  repeatList$: MatTableDataSource<any>;\n  fields$: any[];\n\n  displayedColumns$ = Array<any>();\n  groupByColumns$: string[] = [];\n\n  configProps$: ListViewProps;\n\n  updatedRefList: any;\n\n  repeatListData: any[] = [];\n\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  compareType: string;\n  compareRef: string;\n  arrowDirection = 'down';\n\n  filterByColumns: any[] = [];\n  bShowFilterPopover$ = false;\n  bContains$ = true;\n  bDateTime$ = false;\n\n  filterContainsLabel$ = '';\n  filterContainsType$ = 'contains';\n  filterContainsValue$: any;\n\n  bIsDate$ = false;\n  bIsDateTime$ = false;\n  bIsTime$ = false;\n\n  currentFilterRefData: any;\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  showDynamicFields: any;\n  filters: any = {};\n  selectParam: any[] = [];\n  filterPayload: any;\n  ref: any = {};\n  cosmosTableRef: any;\n  listContext: any = {};\n  query: any = null;\n  paging: any;\n  fieldDefs: any;\n  xRayApis = PCore.getDebugger().getXRayRuntime();\n  xRayUid = this.xRayApis.startXRay();\n\n  constructor(\n    private psService: ProgressSpinnerService,\n    private utils: Utils\n  ) {}\n\n  ngOnInit(): void {\n    this.configProps$ = this.pConn$.getConfigProps() as ListViewProps;\n    /** By default, pyGUID is used for Data classes and pyID is for Work classes as row-id/key */\n    const defRowID = this.configProps$?.referenceType === 'Case' ? 'pyID' : 'pyGUID';\n    /** If compositeKeys is defined, use dynamic value, else fallback to pyID or pyGUID. */\n    this.compositeKeys = this.configProps$?.compositeKeys;\n    this.rowID = this.compositeKeys && this.compositeKeys?.length === 1 ? this.compositeKeys[0] : defRowID;\n    this.bShowSearch$ = this.utils.getBooleanValue(this.configProps$.globalSearch ? this.configProps$.globalSearch : this.payload.globalSearch);\n    this.bColumnReorder$ = this.utils.getBooleanValue(this.configProps$.reorderFields);\n    this.bGrouping$ = this.utils.getBooleanValue(this.configProps$.grouping);\n    this.showDynamicFields = this.configProps$?.showDynamicFields;\n\n    this.menuSvgIcon$ = this.utils.getImageSrc('more', this.utils.getSDKStaticContentUrl());\n    this.arrowDownSvgIcon$ = this.utils.getImageSrc('arrow-down', this.utils.getSDKStaticContentUrl());\n    this.arrowUpSvgIcon$ = this.utils.getImageSrc('arrow-up', this.utils.getSDKStaticContentUrl());\n\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\n    this.selectionMode = this.configProps$.selectionMode;\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    setTimeout(() => {\n      PCore.getPubSubUtils().subscribe(\n        PCore.getConstants().PUB_SUB_EVENTS.EVENT_DASHBOARD_FILTER_CHANGE,\n        data => {\n          this.processFilterChange(data);\n        },\n        `dashboard-component-${'id'}`,\n        false,\n        this.pConn$.getContextName()\n      );\n      PCore.getPubSubUtils().subscribe(\n        PCore.getConstants().PUB_SUB_EVENTS.EVENT_DASHBOARD_FILTER_CLEAR_ALL,\n        () => {\n          this.filters = {};\n          this.processFilterClear();\n        },\n        `dashboard-component-${'id'}`,\n        false,\n        this.pConn$.getContextName()\n      );\n    }, 0);\n    if (this.configProps$) {\n      if (!this.payload) {\n        this.payload = { referenceList: this.configProps$.referenceList };\n      }\n      useInit({\n        pConn$: this.pConn$,\n        bInForm$: this.bInForm$,\n        ...this.payload,\n        listContext: this.listContext,\n        ref: this.ref,\n        showDynamicFields: this.showDynamicFields,\n        xRayUid: this.xRayUid,\n        cosmosTableRef: this.cosmosTableRef,\n        selectionMode: this.selectionMode\n      }).then(response => {\n        this.listContext = response;\n        this.getListData();\n      });\n    }\n  }\n\n  getFieldFromFilter(filter, dateRange = false) {\n    let fieldValue;\n    if (dateRange) {\n      fieldValue = filter?.AND[0]?.condition.lhs.field;\n    } else {\n      fieldValue = filter?.condition.lhs.field;\n    }\n    return fieldValue;\n  }\n\n  // Will be triggered when EVENT_DASHBOARD_FILTER_CHANGE fires\n  processFilterChange(data) {\n    const { filterId, filterExpression } = data;\n    let dashboardFilterPayload: any = {\n      query: {\n        filter: {},\n        select: []\n      }\n    };\n\n    this.filters[filterId] = filterExpression;\n    let isDateRange = !!data.filterExpression?.AND;\n    // Will be AND by default but making it dynamic in case we support dynamic relational ops in future\n    const relationalOp = 'AND';\n\n    let field = this.getFieldFromFilter(filterExpression, isDateRange);\n    const selectParam: any[] = [];\n    // Constructing the select parameters list (will be sent in dashboardFilterPayload)\n    this.displayedColumns$?.forEach(col => {\n      selectParam.push({\n        field: col\n      });\n    });\n\n    // Checking if the triggered filter is applicable for this list\n    if (data.filterExpression !== null && !(this.displayedColumns$?.length && this.displayedColumns$?.includes(field))) {\n      return;\n    }\n    // This is a flag which will be used to reset dashboardFilterPayload in case we don't find any valid filters\n    let validFilter = false;\n\n    let index = 1;\n    // Iterating over the current filters list to create filter data which will be POSTed\n    const filterKeys: any[] = Object.keys(this.filters);\n    const filterValues: any[] = Object.values(this.filters);\n    for (let filterIndex = 0; filterIndex < filterKeys.length; filterIndex++) {\n      const filter = filterValues[filterIndex];\n      // If the filter is null then we can skip this iteration\n      if (filter === null) {\n        // eslint-disable-next-line no-continue\n        continue;\n      }\n\n      // Checking if the filter is of type- Date Range\n      isDateRange = !!filter?.AND;\n      field = this.getFieldFromFilter(filter, isDateRange);\n\n      if (!(this.displayedColumns$?.length && this.displayedColumns$?.includes(field))) {\n        // eslint-disable-next-line no-continue\n        continue;\n      }\n      // If we reach here that implies we've at least one valid filter, hence setting the flag\n      validFilter = true;\n      /** Below are the 2 cases for- Text & Date-Range filter types where we'll construct filter data which will be sent in the dashboardFilterPayload\n       * In Constellation DX Components, through Repeating Structures they might be using several APIs to do it. We're doing it here\n       */\n      if (isDateRange) {\n        dashboardFilterPayload = this.filterBasedOnDateRange(dashboardFilterPayload, filter, relationalOp, selectParam, index);\n      } else {\n        dashboardFilterPayload.query.filter.filterConditions = {\n          ...dashboardFilterPayload.query.filter.filterConditions,\n          [`T${index++}`]: { ...filter.condition, ignoreCase: true }\n        };\n\n        if (dashboardFilterPayload.query.filter.logic) {\n          dashboardFilterPayload.query.filter.logic = `${dashboardFilterPayload.query.filter.logic} ${relationalOp} T${index - 1}`;\n        } else {\n          dashboardFilterPayload.query.filter.logic = `T${index - 1}`;\n        }\n\n        dashboardFilterPayload.query.select = selectParam;\n      }\n    }\n\n    // Reset the dashboardFilterPayload if we end up with no valid filters for the list\n    if (!validFilter) {\n      dashboardFilterPayload = undefined;\n    }\n    this.filterPayload = dashboardFilterPayload;\n    this.getListData();\n  }\n\n  filterBasedOnDateRange(dashboardFilterPayload, filter, relationalOp, selectParam, index) {\n    const dateRelationalOp = filter?.AND ? 'AND' : 'OR';\n    dashboardFilterPayload.query.filter.filterConditions = {\n      ...dashboardFilterPayload.query.filter.filterConditions,\n      [`T${index++}`]: { ...filter[relationalOp][0].condition },\n      [`T${index++}`]: { ...filter[relationalOp][1].condition }\n    };\n    if (dashboardFilterPayload.query.filter.logic) {\n      dashboardFilterPayload.query.filter.logic = `${dashboardFilterPayload.query.filter.logic} ${relationalOp} (T${index - 2} ${dateRelationalOp} T${\n        index - 1\n      })`;\n    } else {\n      dashboardFilterPayload.query.filter.logic = `(T${index - 2} ${relationalOp} T${index - 1})`;\n    }\n\n    dashboardFilterPayload.query.select = selectParam;\n\n    return dashboardFilterPayload;\n  }\n\n  processFilterClear() {\n    this.filterPayload = undefined;\n    this.getListData();\n  }\n\n  getFieldsMetadata(refList) {\n    // @ts-ignore - 3rd parameter \"associationFilter\" should be optional for getDataViewMetadata method\n    return PCore.getAnalyticsUtils().getDataViewMetadata(refList, this.showDynamicFields);\n  }\n\n  getListData() {\n    // @ts-ignore - Property 'getComponentConfig' is private and only accessible within class 'C11nEnv'\n    const componentConfig = this.pConn$.getComponentConfig();\n    if (this.configProps$) {\n      this.preparePayload();\n      const refList = this.configProps$.referenceList;\n      const fieldsMetaDataPromise = this.getFieldsMetadata(refList);\n      // returns a promise\n      const payload = this.payload || this.filterPayload || {};\n      const dataViewParameters = this.payload.parameters;\n\n      const workListDataPromise = !this.bInForm$\n        ? // @ts-ignore - 3rd parameter \"context\" should be optional in getData method\n          PCore.getDataApiUtils().getData(refList, payload)\n        : PCore.getDataPageUtils().getDataAsync(\n            refList,\n            this.pConn$.getContextName(),\n            payload.dataViewParameters ? payload.dataViewParameters : dataViewParameters,\n            this.paging,\n            this.query\n          );\n\n      this.bShowFilterPopover$ = false;\n\n      this.psService.sendMessage(true);\n\n      Promise.all([fieldsMetaDataPromise, workListDataPromise])\n        .then((results: any) => {\n          const fieldsMetaData = results[0];\n          const workListData = results[1];\n\n          this.fields$ = this.configProps$.presets[0].children[0].children;\n          // this is an unresovled version of this.fields$, need unresolved, so can get the property reference\n          const columnFields = componentConfig.presets[0].children[0].children;\n\n          const tableDataResults = !this.bInForm$ ? workListData.data.data : workListData.data;\n\n          const columns = this.getHeaderCells(columnFields, this.fieldDefs);\n          this.fields$ = this.updateFields(this.fields$, fieldsMetaData.data.fields, columns);\n          this.displayedColumns$ = columns.map(col => {\n            return col.id;\n          });\n          this.response = tableDataResults;\n          this.updatedRefList = this.updateData(tableDataResults, this.fields$);\n          if (this.selectionMode === SELECTION_MODE.SINGLE && this.updatedRefList?.length > 0) {\n            this.displayedColumns$?.unshift('select');\n            this.singleSelectionMode = true;\n          } else if (this.selectionMode === SELECTION_MODE.MULTI && this.updatedRefList?.length > 0) {\n            this.displayedColumns$?.unshift('select');\n            this.multiSelectionMode = true;\n          }\n\n          this.repeatList$ = new MatTableDataSource(this.updatedRefList);\n          this.repeatList$.filterPredicate = this.customFilterPredicate.bind(this);\n\n          // keeping an original copy to get back after possible sorts, filters and groupBy\n          this.repeatListData = this.repeatList$.data.slice();\n\n          this.repeatList$.paginator = this.paginator;\n          this.repeatList$.sort = this.sort;\n          this.psService.sendMessage(false);\n        })\n        .catch(() => {\n          console.error(\"Couldn't fetch either the fieldsMetaData or workListData\");\n          this.psService.sendMessage(false);\n        });\n    }\n  }\n\n  preparePayload() {\n    const { fieldDefs, itemKey, patchQueryFields } = this.listContext.meta;\n    this.fieldDefs = fieldDefs;\n    let listFields = fieldDefs ? this.buildSelect(fieldDefs, undefined, patchQueryFields, this.payload?.compositeKeys) : [];\n    listFields = this.addItemKeyInSelect(fieldDefs, itemKey, listFields, this.payload?.compositeKeys);\n    if (this.payload.query) {\n      this.query = this.payload.query;\n    } else if (listFields?.length && this.listContext.meta.isQueryable) {\n      if (this.filterPayload) {\n        this.query = {\n          select: listFields,\n          filter: this.filterPayload?.query?.filter\n        };\n      } else {\n        this.query = { select: listFields };\n      }\n    } else if (this.filterPayload) {\n      this.query = this.filterPayload?.query;\n    }\n  }\n  // ngOnChanges(changes) {\n  //   if (changes && changes.payload) {\n  //     const currentPayloadVal = changes.payload?.currentValue;\n  //     const previousPayloadVal = changes.payload?.previousValue;\n  //     if (currentPayloadVal !== previousPayloadVal) {\n  //       this.getListData();\n  //     }\n  //   }\n  // }\n\n  ngOnDestroy() {\n    PCore.getPubSubUtils().unsubscribe(\n      PCore.getConstants().PUB_SUB_EVENTS.EVENT_DASHBOARD_FILTER_CHANGE,\n      `dashboard-component-${'id'}`,\n      this.pConn$.getContextName()\n    );\n    PCore.getPubSubUtils().unsubscribe(\n      PCore.getConstants().PUB_SUB_EVENTS.EVENT_DASHBOARD_FILTER_CLEAR_ALL,\n      `dashboard-component-${'id'}`,\n      this.pConn$.getContextName()\n    );\n  }\n\n  // ngAfterViewInit() {\n  //   // paginator has to exist for this to work,\n  //   // so called after init (paginator drawn)\n  //   // Calls are now in workListData promise\n  //   // this.repeatList$.paginator = this.paginator;\n  //   // this.repeatList$.sort = this.sort;\n  // }\n\n  drop(event: CdkDragDrop<string[]>) {\n    moveItemInArray(this.displayedColumns$, event.previousIndex, event.currentIndex);\n  }\n\n  updateFields(arFields: any[], arColumns, fields): any[] {\n    const arReturn = arFields;\n    arReturn.forEach((field, i) => {\n      field.config = { ...field.config, ...fields[i], name: fields[i].id };\n    });\n    return arReturn;\n  }\n\n  applySearch(event: Event) {\n    const filterValue = (event.target as HTMLInputElement).value;\n    this.searchFilter = filterValue.trim().toLowerCase();\n\n    if (this.groupByColumns$.length > 0) {\n      this.repeatList$.data = this.repeatListData.slice();\n      this.repeatList$.filter = this.searchFilter;\n      const repeatData = this.repeatList$.sortData(this.repeatList$.filteredData, this.repeatList$.sort as MatSort);\n      this.repeatList$.data = this.addGroups(repeatData, this.groupByColumns$);\n\n      this.perfFilter = performance.now().toString();\n      this.repeatList$.filter = this.perfFilter;\n    } else {\n      this.repeatList$.filter = this.searchFilter;\n    }\n\n    if (this.repeatList$.paginator) {\n      this.repeatList$.paginator.firstPage();\n    }\n  }\n\n  fieldOnChange(row) {\n    const value = row[this.rowID];\n    const reqObj = {};\n    if (this.compositeKeys?.length > 1) {\n      const index = this.response.findIndex(element => element[this.rowID] === value);\n      const selectedRow = this.response[index];\n      this.compositeKeys.forEach(element => {\n        reqObj[element] = selectedRow[element];\n      });\n    } else {\n      reqObj[this.rowID] = value;\n    }\n    this.pConn$?.getListActions?.()?.setSelectedRows([reqObj]);\n  }\n\n  onCheckboxClick(row, event) {\n    const value = row[this.rowID];\n    const checked = event?.checked;\n    const reqObj: any = {};\n    if (this.compositeKeys?.length > 1) {\n      const index = this.response.findIndex(element => element[this.rowID] === value);\n      const selectedRow = this.response[index];\n      this.compositeKeys.forEach(element => {\n        reqObj[element] = selectedRow[element];\n      });\n      reqObj.$selected = checked;\n    } else {\n      reqObj[this.rowID] = value;\n      reqObj.$selected = checked;\n    }\n    this.pConn$?.getListActions()?.setSelectedRows([reqObj]);\n  }\n\n  // rowClick(row) {\n  //   switch (this.configProps$.rowClickAction) {\n  //     case 'openAssignment':\n  //       this.psService.sendMessage(true);\n  //       this.openAssignment(row);\n  //       break;\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  _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  _showButton(name, row) {\n    let bReturn = false;\n    const { pxRefObjectClass, pzInsKey, pxRefObjectKey } = row;\n    switch (name) {\n      case 'pxTaskLabel':\n        if (pxRefObjectClass != '' && pzInsKey != '') {\n          bReturn = true;\n        }\n        break;\n      case 'pxRefObjectInsName':\n        if (pxRefObjectClass != '' && pxRefObjectKey != '') {\n          bReturn = true;\n        }\n        break;\n      default:\n        break;\n    }\n\n    return bReturn;\n  }\n\n  _listViewClick(column, row) {\n    const name = column.id;\n    if (column.displayAsLink) {\n      const { pxObjClass } = row;\n      let { pzInsKey } = row;\n      if (column.isAssociation) {\n        const associationCategory = name.split(':')[0];\n        pzInsKey = row[`${associationCategory}:pzInsKey`];\n      }\n      if (column.isAssignmentLink) {\n        this.pConn$.getActionsApi().openAssignment(pzInsKey, pxObjClass, {\n          containerName: 'primary',\n          channelName: ''\n        });\n      } else {\n        this.pConn$.getActionsApi().openWorkByHandle(pzInsKey, pxObjClass);\n      }\n    } else {\n      switch (name) {\n        case 'pxTaskLabel':\n          this.openAssignment(row);\n          break;\n        case 'pxRefObjectInsName':\n          this.openWork(row);\n          break;\n        default:\n          break;\n      }\n    }\n  }\n\n  compare(a: number | string, b: number | string, isAsc: boolean) {\n    return (a < b ? -1 : 1) * (isAsc ? 1 : -1);\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  clearOutArrows(event, columnData) {\n    const arImages = event.srcElement.parentElement.getElementsByTagName('img');\n\n    for (const theImage of arImages) {\n      // let theImage = arImages[i]\n      const arrow = theImage.getAttribute('arrow');\n      if (arrow) {\n        const arrowId = theImage.getAttribute('arrowid');\n        if (arrow != 'none' && arrowId != columnData.config.name) {\n          theImage.setAttribute('arrow', 'none');\n          theImage.src = '';\n        }\n      }\n    }\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    switch (this.arrowDirection) {\n      case 'up':\n        if (aValue < bValue) {\n          return -1;\n        }\n        if (aValue > bValue) {\n          return 1;\n        }\n        break;\n      case 'down':\n        if (aValue > bValue) {\n          return -1;\n        }\n        if (aValue < bValue) {\n          return 1;\n        }\n        break;\n      default:\n        break;\n    }\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 pathIndex = 0; pathIndex < eventPath.length; pathIndex++) {\n      if (\n        eventPath[pathIndex].className == 'psdk-modal-file-top' ||\n        eventPath[pathIndex].tagName == 'BUTTON' ||\n        eventPath[pathIndex].tagName == 'MAT-OPTION' ||\n        eventPath[pathIndex].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        let filterValue: any;\n\n        switch (filterObj.type) {\n          case 'Date':\n          case 'DateTime':\n          case 'Time':\n            bKeep = this.filterDataWithDate(item, filterObj, filterValue);\n            break;\n          default:\n            bKeep = this.filterDataWithCommonTypes(item, filterObj, filterValue);\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  filterDataWithDate(item, filterObj, filterValue) {\n    let bKeep;\n    let value = item[filterObj.ref] != null ?? item[filterObj.ref] != '' ? getSeconds(item[filterObj.ref]) : null;\n    filterValue = filterObj.containsFilterValue != null && filterObj.containsFilterValue != '' ? getSeconds(filterObj.containsFilterValue) : null;\n\n    switch (filterObj.containsFilter) {\n      case 'notequal':\n        // becasue filterValue is in minutes, need to have a range of less than 60 secons\n        if (value != null && filterValue != null) {\n          // get rid of millisecons\n          value /= 1000;\n          filterValue /= 1000;\n\n          const diff = value - filterValue;\n          if (diff >= 0 && diff < 60) {\n            bKeep = false;\n          }\n        }\n        break;\n      case 'after':\n        if (value < filterValue) {\n          bKeep = false;\n        }\n        break;\n      case 'before':\n        if (value > filterValue) {\n          bKeep = false;\n        }\n        break;\n      case 'null':\n        if (value != null) {\n          bKeep = false;\n        }\n        break;\n      case 'notnull':\n        if (value == null) {\n          bKeep = false;\n        }\n        break;\n      default:\n        break;\n    }\n\n    return bKeep;\n  }\n\n  filterDataWithCommonTypes(item, filterObj, filterValue) {\n    let bKeep;\n    const value = item[filterObj.ref].toLowerCase();\n    filterValue = filterObj.containsFilterValue.toLowerCase();\n\n    switch (filterObj.containsFilter) {\n      case 'contains':\n        if (value.indexOf(filterValue) < 0) {\n          bKeep = false;\n        }\n        break;\n      case 'equals':\n        if (value != filterValue) {\n          bKeep = false;\n        }\n        break;\n      case 'startswith':\n        if (value.indexOf(filterValue) != 0) {\n          bKeep = false;\n        }\n        break;\n      default:\n        break;\n    }\n\n    return bKeep;\n  }\n\n  filterSortGroupBy() {\n    // get original data set\n    let theData = this.repeatListData.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\n    const reGroupData = this.addGroups(theData, this.groupByColumns$);\n\n    this.repeatList$.data = [];\n    this.repeatList$.data.push(...reGroupData);\n\n    if (this.searchFilter && this.searchFilter != '') {\n      this.repeatList$.filter = this.searchFilter;\n    } else {\n      this.perfFilter = performance.now().toString();\n      this.repeatList$.filter = this.perfFilter;\n    }\n    this.repeatList$.filter = '';\n\n    if (this.repeatList$.paginator) {\n      this.repeatList$.paginator.firstPage();\n    }\n  }\n\n  //\n  // Grouping code inspired by this example\n  // https://stackblitz.com/edit/angular-material-table-row-grouping\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  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.repeatList$.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.repeatList$.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  updateData(listData: any[], fieldData: any[]): any[] {\n    const returnList: any[] = new Array<any>();\n    listData.forEach(row => {\n      // copy\n      const rowData = JSON.parse(JSON.stringify(row));\n\n      for (let fieldIndex = 0; fieldIndex < fieldData.length; fieldIndex++) {\n        const config = fieldData[fieldIndex].config;\n        let fieldName;\n        let formattedDate;\n        let myFormat;\n        let theCurrencyOptions;\n\n        switch (fieldData[fieldIndex].type) {\n          case 'Date':\n            fieldName = config.name;\n            myFormat = config.formatter;\n            if (!myFormat) {\n              myFormat = 'Date';\n            }\n            formattedDate = this.utils.generateDate(rowData[fieldName], myFormat);\n\n            rowData[fieldName] = formattedDate;\n            break;\n          case 'DateTime':\n            fieldName = config.name;\n            myFormat = config.formatter;\n            if (!myFormat) {\n              myFormat = 'DateTime-Long';\n            }\n            formattedDate = this.utils.generateDateTime(rowData[fieldName], myFormat);\n\n            rowData[fieldName] = formattedDate;\n            break;\n          case 'Currency':\n            fieldName = config.name;\n            theCurrencyOptions = getCurrencyOptions(PCore.getEnvironmentInfo().getLocale() as string);\n            // eslint-disable-next-line no-case-declarations\n            const defaultOptions = {\n              locale: getLocale(),\n              position: 'before',\n              decPlaces: 2\n            };\n            // eslint-disable-next-line no-case-declarations\n            const params = { ...defaultOptions, ...theCurrencyOptions };\n            rowData[fieldName] = formatters.Currency(rowData[fieldName], params);\n            // val = format(value, column.type, theCurrencyOptions);\n            break;\n          default:\n            break;\n        }\n      }\n      returnList.push(rowData);\n    });\n\n    return returnList;\n  }\n\n  openAssignment(row) {\n    const { pxRefObjectClass, pzInsKey } = row;\n    const sTarget = this.pConn$.getContainerName();\n    const options: any = { containerName: sTarget };\n    this.pConn$.getActionsApi().openAssignment(pzInsKey, pxRefObjectClass, options);\n  }\n\n  openWork(row) {\n    const pxRefObjectClass = row.pxRefObjectClass || row.pxObjClass;\n    const { pxRefObjectKey } = row;\n    if (pxRefObjectClass !== '' && pxRefObjectKey !== '') {\n      this.pConn$.getActionsApi().openWorkByHandle(pxRefObjectKey, pxRefObjectClass);\n    }\n  }\n\n  initializeData(data) {\n    data.forEach((item, idx) => {\n      item.__original_index = idx;\n      item.__level = 1;\n    });\n\n    return data;\n  }\n\n  getType(field) {\n    const { config = {}, type } = field;\n    const { formatType } = config;\n    if (formatType === 'datetime' || formatType === 'date') {\n      // currently cosmos has only support for date ... it also need to support dateTime\n      return 'date';\n    }\n\n    return type.toLowerCase();\n  }\n\n  initializeColumns(fields = []) {\n    return fields.map((field: any, originalColIndex) => ({\n      ...field,\n      type: this.getType(field),\n      name: field.config.value.substring(4),\n      label: field.config.label.substring(3),\n      id: originalColIndex,\n      groupingEnabled: true,\n      grouped: false,\n      minWidth: 50,\n      cellRenderer: this.getType(field) === 'text' ? null : field.type,\n      filter: true\n    }));\n  }\n\n  getHeaderCells(colFields, fields) {\n    const AssignDashObjects = ['Assign-Worklist', 'Assign-WorkBasket'];\n    return colFields.map((field: any, index) => {\n      let theField = field.config.value.substring(field.config.value.indexOf(' ') + 1);\n      if (theField.indexOf('.') === 0) {\n        theField = theField.substring(1);\n      }\n      const colIndex = fields.findIndex(ele => ele.name === theField);\n      const displayAsLink = field.config.displayAsLink;\n      const headerRow: any = {};\n      headerRow.id = fields[index].id;\n      headerRow.type = field.type;\n      headerRow.displayAsLink = displayAsLink;\n      headerRow.numeric = field.type === 'Decimal' || field.type === 'Integer' || field.type === 'Percentage' || field.type === 'Currency' || false;\n      headerRow.disablePadding = false;\n      headerRow.label = fields[index].label;\n      if (colIndex > -1) {\n        headerRow.classID = fields[colIndex].classID;\n      }\n      if (displayAsLink) {\n        headerRow.isAssignmentLink = AssignDashObjects.includes(headerRow.classID);\n        if (field.config.value?.startsWith('@CA')) {\n          headerRow.isAssociation = true;\n        }\n      }\n      return headerRow;\n    });\n  }\n\n  buildSelect(fieldDefs, colId, patchQueryFields = [], compositeKeys = []) {\n    const listFields: any = [];\n    if (colId) {\n      const field = this.getField(fieldDefs, colId);\n      listFields.push({\n        field: field.name\n      });\n    } else {\n      // NOTE: If we ever decide to not set up all the `fieldDefs` on select, ensure that the fields\n      //  corresponding to `state.groups` are set up. Needed in Client-mode grouping/pagination.\n      fieldDefs.forEach(field => {\n        if (!listFields.find(f => f.field === field.name)) {\n          listFields.push({\n            field: field.name\n          });\n        }\n      });\n      patchQueryFields.forEach(k => {\n        if (!listFields.find(f => f.field === k)) {\n          listFields.push({\n            field: k\n          });\n        }\n      });\n    }\n\n    compositeKeys.forEach(k => {\n      if (!listFields.find(f => f.field === k)) {\n        listFields.push({\n          field: k\n        });\n      }\n    });\n    return listFields;\n  }\n\n  getField(fieldDefs, columnId) {\n    const fieldsMap = this.getFieldsMap(fieldDefs);\n    return fieldsMap.get(columnId);\n  }\n\n  getFieldsMap(fieldDefs) {\n    const fieldsMap = new Map();\n    fieldDefs.forEach(element => {\n      fieldsMap.set(element.id, element);\n    });\n    return fieldsMap;\n  }\n\n  addItemKeyInSelect(fieldDefs, itemKey, select, compositeKeys) {\n    const elementFound = this.getField(fieldDefs, itemKey);\n\n    if (\n      itemKey &&\n      !elementFound &&\n      Array.isArray(select) &&\n      !(compositeKeys !== null && compositeKeys?.length) &&\n      !select.find(sel => sel.field === itemKey)\n    ) {\n      return [\n        ...select,\n        {\n          field: itemKey\n        }\n      ];\n    }\n\n    return select;\n  }\n}\n","<div class=\"psdk-list-header\">\n  <div>\n    <mat-form-field class=\"psdk-search\" *ngIf=\"bShowSearch$\">\n      <mat-label><img class=\"psdk-icon-search\" src=\"{{ searchIcon$ }}\" /> <span class=\"psdk-search-label\">Search</span> </mat-label>\n      <input matInput id=\"search\" (keyup)=\"applySearch($event)\" placeholder=\"\" />\n    </mat-form-field>\n\n    <div *ngIf=\"!bInForm$\" class=\"psdk-outer-div-in-form\">\n      <div class=\"psdk-inner-div-in-form\" *ngIf=\"bColumnReorder$\">\n        <div>\n          <table\n            mat-table\n            id=\"list-view\"\n            [dataSource]=\"repeatList$\"\n            matSort\n            cdkDropList\n            cdkDropListOrientation=\"horizontal\"\n            (cdkDropListDropped)=\"drop($event)\"\n          >\n            <ng-container *ngFor=\"let dCol of fields$\" [matColumnDef]=\"dCol.config.name\" sticky=\"true\">\n              <th mat-header-cell *matHeaderCellDef class=\"psdk-mat-header\" (click)=\"_headerSortClick($event, dCol)\" arrowPosition=\"before\" cdkDrag>\n                {{ dCol.config.label }}\n                <div class=\"psdk-mat-header-filter\">\n                  <img class=\"psdk-filter-svg-icon\" name=\"filterOnIcon\" />\n                </div>\n                <div class=\"psdk-mat-header-arrow\">\n                  <img class=\"psdk-arrow-svg-icon\" arrow=\"none\" [attr.arrowid]=\"dCol.config.name\" />\n                </div>\n                <div class=\"psdk-mat-header-button\" (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 *ngIf=\"!_showUnGroupBy(dCol) && bGrouping$\" 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; index as i\">\n                <button\n                  *ngIf=\"_showButton(dCol.config.name, dCol); else regular\"\n                  mat-button\n                  color=\"primary\"\n                  (click)=\"_listViewClick(dCol.config, element)\"\n                >\n                  {{ element[dCol.config.name] }}\n                </button>\n                <ng-template #regular>\n                  {{ element[dCol.config.name] || '---' }}\n                </ng-template>\n              </td>\n            </ng-container>\n\n            <tr mat-header-row *matHeaderRowDef=\"displayedColumns$; sticky: true\"></tr>\n            <tr mat-row *matRowDef=\"let row; columns: displayedColumns$\"></tr>\n\n            <!-- Group header -->\n            <ng-container matColumnDef=\"groupHeader\">\n              <td mat-cell colspan=\"999\" *matCellDef=\"let group\">\n                <mat-icon *ngIf=\"group.expanded\" [attr.style]=\"_getIconStyle(group.level)\">expand_less</mat-icon>\n                <mat-icon *ngIf=\"!group.expanded\" [attr.style]=\"_getIconStyle(group.level)\">expand_more</mat-icon>\n                <strong\n                  >{{ _getGroupName(groupByColumns$[group.level - 1]) }}: {{ group[groupByColumns$[group.level - 1]] }} ({{\n                    group.totalCounts\n                  }})</strong\n                >\n              </td>\n            </ng-container>\n\n            <tr mat-row *matRowDef=\"let row; columns: ['groupHeader']; when: isGroup\" (click)=\"_groupHeaderClick(row)\"></tr>\n          </table>\n        </div>\n      </div>\n      <div class=\"psdk-inner-div-in-form\" *ngIf=\"!bColumnReorder$\">\n        <div>\n          <table mat-table id=\"list-view\" [dataSource]=\"repeatList$\" matSort>\n            <ng-container *ngFor=\"let dCol of fields$\" [matColumnDef]=\"dCol.config.name\" sticky=\"true\">\n              <th mat-header-cell *matHeaderCellDef class=\"psdk-mat-header\" (click)=\"_headerSortClick($event, dCol)\" arrowPosition=\"before\">\n                {{ dCol.config.label }}\n                <div class=\"psdk-mat-header-filter\">\n                  <img class=\"psdk-filter-svg-icon\" name=\"filterOnIcon\" />\n                </div>\n                <div class=\"psdk-mat-header-arrow\">\n                  <img class=\"psdk-arrow-svg-icon\" arrow=\"none\" [attr.arrowid]=\"dCol.config.name\" />\n                </div>\n                <div class=\"psdk-mat-header-button\" (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 *ngIf=\"!_showUnGroupBy(dCol) && bGrouping$\" 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; index as i\">\n                <button\n                  *ngIf=\"_showButton(dCol.config.name, dCol); else regular\"\n                  mat-button\n                  color=\"primary\"\n                  (click)=\"_listViewClick(dCol.config, element)\"\n                >\n                  {{ element[dCol.config.name] }}\n                </button>\n                <ng-template #regular>\n                  {{ element[dCol.config.name] }}\n                </ng-template>\n              </td>\n            </ng-container>\n\n            <tr mat-header-row *matHeaderRowDef=\"displayedColumns$; sticky: true\"></tr>\n            <tr mat-row *matRowDef=\"let row; columns: displayedColumns$\"></tr>\n\n            <!-- Group header -->\n            <ng-container matColumnDef=\"groupHeader\">\n              <td mat-cell colspan=\"999\" *matCellDef=\"let group\">\n                <mat-icon *ngIf=\"group.expanded\" [attr.style]=\"_getIconStyle(group.level)\">expand_less</mat-icon>\n                <mat-icon *ngIf=\"!group.expanded\" [attr.style]=\"_getIconStyle(group.level)\">expand_more</mat-icon>\n                <strong\n                  >{{ _getGroupName(groupByColumns$[group.level - 1]) }}: {{ group[groupByColumns$[group.level - 1]] }} ({{\n                    group.totalCounts\n                  }})</strong\n                >\n              </td>\n            </ng-container>\n\n            <tr mat-row *matRowDef=\"let row; columns: ['groupHeader']; when: isGroup\" (click)=\"_groupHeaderClick(row)\"></tr>\n          </table>\n        </div>\n      </div>\n    </div>\n    <div *ngIf=\"bInForm$\">\n      <div>\n        <div class=\"psdk-inner-div-in-form\">\n          <table id=\"list-view\" *ngIf=\"repeatListData.length > 0\" mat-table [dataSource]=\"repeatList$\" matSort>\n            <ng-container *ngIf=\"singleSelectionMode\" matColumnDef=\"select\">\n              <th mat-header-cell *matHeaderCellDef></th>\n              <td mat-cell *matCellDef=\"let row\">\n                <mat-radio-button [value]=\"row[rowID]\" (change)=\"fieldOnChange(row)\"></mat-radio-button>\n              </td>\n            </ng-container>\n            <ng-container *ngIf=\"multiSelectionMode\" matColumnDef=\"select\">\n              <th mat-header-cell *matHeaderCellDef></th>\n              <td mat-cell *matCellDef=\"let row\">\n                <mat-checkbox [value]=\"row[rowID]\" (change)=\"onCheckboxClick(row, $event)\"></mat-checkbox>\n              </td>\n            </ng-container>\n            <ng-container *ngFor=\"let dCol of fields$\" [matColumnDef]=\"dCol.config.name\">\n              <th mat-header-cell *matHeaderCellDef mat-sort-header (click)=\"_headerSortClick($event, dCol)\" arrowPosition=\"before\">\n                {{ dCol.config.label }}\n              </th>\n              <td mat-cell *matCellDef=\"let element\">{{ element[dCol.config.name] }}</td>\n            </ng-container>\n\n            <tr mat-header-row *matHeaderRowDef=\"displayedColumns$\"></tr>\n            <tr mat-row *matRowDef=\"let row; columns: displayedColumns$\"></tr>\n          </table>\n          <div *ngIf=\"repeatListData?.length === 0\">\n            <table id=\"list-view\" *ngIf=\"repeatListData?.length === 0\" mat-table [dataSource]=\"repeatList$\">\n              <ng-container *ngFor=\"let dCol of fields$\" [matColumnDef]=\"dCol.config.name\">\n                <th mat-header-cell *matHeaderCellDef>{{ dCol.config.label }}</th>\n              </ng-container>\n              <tr mat-header-row *matHeaderRowDef=\"displayedColumns$\"></tr>\n            </table>\n          </div>\n          <div class=\"psdk-no-records\" *ngIf=\"repeatListData?.length === 0\">No Records Found.</div>\n        </div>\n      </div>\n    </div>\n\n    <mat-paginator id=\"pagination\" *ngIf=\"bInForm$\" [pageSizeOptions]=\"[10, 20, 50, 100, 500, 1000]\" showFirstLastButtons></mat-paginator>\n    <mat-paginator id=\"pagination\" *ngIf=\"!bInForm$\" [pageSizeOptions]=\"[10, 20, 50, 100, 500]\" showFirstLastButtons></mat-paginator>\n  </div>\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</div>\n"]}