@lumeer/pivot 0.0.1 → 0.0.3

package/fesm2022/lumeer-pivot.mjs

@@ -0,0 +1,1644 @@
+import * as i0 from '@angular/core';
+import { Directive, Pipe, Injectable, EventEmitter, TemplateRef, Component, ChangeDetectionStrategy, Input, Output, ContentChild, NgModule } from '@angular/core';
+import { cleanQueryAttribute, DataAggregator, UnknownConstraint, ConstraintType, attributesResourcesAttributesMap, aggregateDataResources, AttributesResourceType, dataAggregationConstraint, DataAggregationType, PercentageConstraint, aggregateDataValues, isValueAggregation, NumberConstraint } from '@lumeer/data-filters';
+import { deepObjectsEquals, hex2rgba, isArray, isNotNullOrUndefined, flattenMatrix, uniqueValues, flattenValues, shadeColor, deepObjectCopy, isNullOrUndefined, isNumeric, toNumber } from '@lumeer/utils';
+import { BehaviorSubject, filter, throttleTime, asyncScheduler, map, tap } from 'rxjs';
+import * as i1 from '@angular/common';
+import { CommonModule } from '@angular/common';
+
+var LmrPivotConfigVersion;
+(function (LmrPivotConfigVersion) {
+    LmrPivotConfigVersion["V1"] = "1";
+})(LmrPivotConfigVersion || (LmrPivotConfigVersion = {}));
+var LmrPivotValueType;
+(function (LmrPivotValueType) {
+    LmrPivotValueType["Default"] = "default";
+    LmrPivotValueType["ColumnPercentage"] = "column";
+    LmrPivotValueType["RowPercentage"] = "row";
+    LmrPivotValueType["AllPercentage"] = "all";
+})(LmrPivotValueType || (LmrPivotValueType = {}));
+
+const COLOR_GRAY100 = '#f8f9fa';
+const COLOR_GRAY200 = '#ecf0f1';
+const COLOR_GRAY300 = '#dee2e6';
+const COLOR_GRAY400 = '#ced4da';
+const COLOR_GRAY500 = '#b4bcc2';
+const COLOR_GRAY600 = '#95a5a6';
+const COLOR_GRAY700 = '#7b8a8b';
+const COLOR_GRAY800 = '#343a40';
+const COLOR_GRAY900 = '#212529';
+const COLOR_PRIMARY = '#253746';
+const COLOR_LIGHT = COLOR_GRAY200;
+
+/*
+ * Lumeer: Modern Data Definition and Processing Platform
+ *
+ * Copyright (C) since 2017 Lumeer.io, s.r.o. and/or its affiliates.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+function pivotAttributesAreSame(a1, a2) {
+    return deepObjectsEquals(cleanQueryAttribute(a1), cleanQueryAttribute(a2));
+}
+function isPivotConfigChanged(viewConfig, currentConfig) {
+    if (!!viewConfig.mergeTables !== !!currentConfig.mergeTables && (currentConfig.stemsConfigs || []).length > 1) {
+        return true;
+    }
+    return pivotStemConfigsHasChanged(viewConfig.stemsConfigs || [], currentConfig.stemsConfigs || []);
+}
+function pivotStemConfigsHasChanged(s1, s2) {
+    if (s1.length !== s2.length) {
+        return true;
+    }
+    return s1.some((stemConfig, index) => pivotStemConfigHasChanged(stemConfig, s2[index]));
+}
+function pivotStemConfigHasChanged(s1, s2) {
+    return (!deepObjectsEquals(s1.rowAttributes || [], s2.rowAttributes || []) ||
+        !deepObjectsEquals(s1.columnAttributes || [], s2.columnAttributes || []) ||
+        !deepObjectsEquals(s1.valueAttributes || [], s2.valueAttributes || []));
+}
+function createDefaultPivotConfig(query) {
+    const stems = (query && query.stems) || [];
+    const stemsConfigs = stems.map(stem => createDefaultPivotStemConfig(stem));
+    return { version: LmrPivotConfigVersion.V1, stemsConfigs: stemsConfigs, mergeTables: true };
+}
+function createDefaultPivotStemConfig(stem) {
+    return { stem, rowAttributes: [], columnAttributes: [], valueAttributes: [] };
+}
+function pivotConfigIsEmpty(config) {
+    return (config.stemsConfigs || []).every(stemConfig => pivotStemConfigIsEmpty(stemConfig));
+}
+function pivotStemConfigIsEmpty(config) {
+    return (((config && config.rowAttributes) || []).length === 0 &&
+        ((config && config.columnAttributes) || []).length === 0 &&
+        ((config && config.valueAttributes) || []).length === 0);
+}
+function contrastColor(color, returnCodes, opacity) {
+    if (!color) {
+        return returnCodes ? returnCodes.dark : COLOR_PRIMARY;
+    }
+    const f = parseInt(color.indexOf('#') === 0 ? color.slice(1) : color, 16), R = f >> 16, G = (f >> 8) & 0x00ff, B = f & 0x0000ff;
+    const luminance = (0.299 * R + 0.587 * G + 0.114 * B) / 255;
+    if (luminance > 0.5) {
+        return returnCodes ? returnCodes.dark : hex2rgba(COLOR_PRIMARY, opacity || 1);
+    }
+    else {
+        return returnCodes ? returnCodes.light : hex2rgba(COLOR_LIGHT, opacity || 1);
+    }
+}
+
+/*
+ * Lumeer: Modern Data Definition and Processing Platform
+ *
+ * Copyright (C) since 2017 Lumeer.io, s.r.o. and/or its affiliates.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+var PivotConfigType;
+(function (PivotConfigType) {
+    PivotConfigType[PivotConfigType["Values"] = 0] = "Values";
+    PivotConfigType[PivotConfigType["Rows"] = 1] = "Rows";
+    PivotConfigType[PivotConfigType["Columns"] = 2] = "Columns";
+    PivotConfigType[PivotConfigType["RowsAndColumns"] = 3] = "RowsAndColumns";
+})(PivotConfigType || (PivotConfigType = {}));
+class PivotDataConverter {
+    collections;
+    linkTypes;
+    collectionsAttributesMap;
+    linkTypesAttributesMap;
+    data;
+    config;
+    transform;
+    constraintData;
+    dataAggregator;
+    constructor() {
+        this.dataAggregator = new DataAggregator((value, constraint, data, aggregatorAttribute) => this.formatPivotValue(value, constraint, data, aggregatorAttribute));
+    }
+    formatPivotValue(value, constraint, constraintData, aggregatorAttribute) {
+        const pivotConstraint = aggregatorAttribute.data && aggregatorAttribute.data;
+        const overrideConstraint = pivotConstraint && this.transform?.checkValidConstraintOverride?.(constraint, pivotConstraint);
+        const finalConstraint = overrideConstraint || constraint || new UnknownConstraint();
+        return this.formatDataValue(finalConstraint.createDataValue(value, constraintData), finalConstraint);
+    }
+    formatDataValue(dataValue, constraint) {
+        switch (constraint.type) {
+            case ConstraintType.DateTime:
+                return dataValue.format();
+            default:
+                return dataValue.serialize();
+        }
+    }
+    updateData(config, transform, collections, linkTypes, data, constraintData) {
+        this.config = config;
+        this.transform = transform;
+        this.collections = collections;
+        this.linkTypes = linkTypes;
+        this.collectionsAttributesMap = attributesResourcesAttributesMap(collections);
+        this.linkTypesAttributesMap = attributesResourcesAttributesMap(linkTypes);
+        this.data = data;
+        this.constraintData = constraintData;
+    }
+    createData(config, transform, collections, linkTypes, data, query, constraintData) {
+        this.updateData(config, transform, collections, linkTypes, data, constraintData);
+        const { stemsConfigs, stems } = this.filterEmptyConfigs(config, query);
+        const mergeData = this.createPivotMergeData(config.mergeTables, stemsConfigs, stems);
+        const ableToMerge = mergeData.length <= 1;
+        const pivotData = this.mergePivotData(mergeData);
+        return { data: pivotData, constraintData, ableToMerge, mergeTables: config.mergeTables };
+    }
+    filterEmptyConfigs(config, query) {
+        return (config.stemsConfigs || []).reduce(({ stemsConfigs, stems }, stemConfig, index) => {
+            if (!pivotStemConfigIsEmpty(stemConfig)) {
+                const stem = (query.stems || [])[index];
+                stemsConfigs.push(stemConfig);
+                stems.push(stem);
+            }
+            return { stemsConfigs, stems };
+        }, { stemsConfigs: [], stems: [] });
+    }
+    createPivotMergeData(mergeTables, stemsConfigs, stems) {
+        return stemsConfigs.reduce((mergeData, stemConfig, index) => {
+            const configType = getPivotStemConfigType(stemConfig);
+            const mergeDataIndex = mergeData.findIndex(data => data.type === configType && canMergeConfigsByType(data.type, data.configs[0], stemConfig));
+            if (mergeTables && mergeDataIndex >= 0) {
+                mergeData[mergeDataIndex].configs.push(stemConfig);
+                mergeData[mergeDataIndex].stems.push(stems[index]);
+                mergeData[mergeDataIndex].stemsIndexes.push(index);
+            }
+            else {
+                mergeData.push({ configs: [stemConfig], stems: [stems[index]], stemsIndexes: [index], type: configType });
+            }
+            return mergeData;
+        }, []);
+    }
+    mergePivotData(mergeData) {
+        return mergeData.reduce((stemData, data) => {
+            if (data.type === PivotConfigType.Values) {
+                stemData.push(this.convertValueAttributes(data.configs, data.stems, data.stemsIndexes));
+            }
+            else {
+                stemData.push(this.transformStems(data.configs, data.stems, data.stemsIndexes));
+            }
+            return stemData;
+        }, []);
+    }
+    transformStems(configs, queryStems, stemsIndexes) {
+        const pivotColors = { rows: [], columns: [], values: [] };
+        const mergedValueAttributes = [];
+        let mergedAggregatedData = null;
+        let additionalData;
+        for (let i = 0; i < configs.length; i++) {
+            const config = configs[i];
+            const queryStem = queryStems[i];
+            const stemIndex = stemsIndexes[i];
+            const stemData = this.data?.dataByStems?.[stemIndex];
+            this.dataAggregator.updateData(this.collections, stemData?.documents || [], this.linkTypes, stemData?.linkInstances || [], queryStem, this.constraintData);
+            const rowAttributes = (config.rowAttributes || []).map(attribute => this.convertPivotRowColumnAttribute(attribute));
+            const columnAttributes = (config.columnAttributes || []).map(attribute => this.convertPivotRowColumnAttribute(attribute));
+            const valueAttributes = (config.valueAttributes || []).map(attribute => this.convertPivotAttribute(attribute));
+            pivotColors.rows.push(...this.getAttributesColors(config.rowAttributes));
+            pivotColors.columns.push(...this.getAttributesColors(config.columnAttributes));
+            pivotColors.values.push(...this.getAttributesColors(config.valueAttributes));
+            const aggregatedData = this.dataAggregator.aggregate(rowAttributes, columnAttributes, valueAttributes);
+            mergedAggregatedData = this.mergeAggregatedData(mergedAggregatedData, aggregatedData);
+            const filteredValueAttributes = (config.valueAttributes || []).filter(valueAttr => !mergedValueAttributes.some(merAttr => deepObjectsEquals(valueAttr, merAttr)));
+            mergedValueAttributes.push(...filteredValueAttributes);
+            if (!additionalData) {
+                additionalData = {
+                    rowShowSums: (config.rowAttributes || []).map(attr => attr.showSums),
+                    rowSticky: this.mapStickyValues((config.rowAttributes || []).map(attr => !!attr.sticky)),
+                    rowSorts: (config.rowAttributes || []).map(attr => attr.sort),
+                    rowAttributes: (config.rowAttributes || []).map(attr => this.pivotAttributeAttribute(attr)),
+                    columnShowSums: (config.columnAttributes || []).map(attr => attr.showSums),
+                    columnSticky: this.mapStickyValues((config.columnAttributes || []).map(attr => !!attr.sticky)),
+                    columnSorts: (config.columnAttributes || []).map(attr => attr.sort),
+                    columnAttributes: (config.columnAttributes || []).map(attr => this.pivotAttributeAttribute(attr)),
+                };
+            }
+        }
+        return this.convertAggregatedData(mergedAggregatedData, mergedValueAttributes, pivotColors, additionalData);
+    }
+    mapStickyValues(values) {
+        // we support only sticky rows/columns in a row
+        return values.reduce((stickyValues, sticky, index) => {
+            stickyValues.push(sticky && (index === 0 || stickyValues[index - 1]));
+            return stickyValues;
+        }, []);
+    }
+    pivotAttributeConstraint(pivotAttribute) {
+        const attribute = this.findAttributeByPivotAttribute(pivotAttribute);
+        const constraint = attribute && attribute.constraint;
+        const overrideConstraint = pivotAttribute.constraint &&
+            this.transform?.checkValidConstraintOverride?.(constraint, pivotAttribute.constraint);
+        return overrideConstraint || constraint;
+    }
+    pivotAttributeAttribute(pivotAttribute) {
+        const attribute = this.findAttributeByPivotAttribute(pivotAttribute);
+        if (attribute) {
+            const constraint = attribute?.constraint;
+            const overrideConstraint = pivotAttribute.constraint &&
+                this.transform?.checkValidConstraintOverride?.(constraint, pivotAttribute.constraint);
+            return { ...attribute, constraint: overrideConstraint || constraint || new UnknownConstraint() };
+        }
+        return undefined;
+    }
+    mergeAggregatedData(a1, a2) {
+        if (!a1 || !a2) {
+            return a1 || a2;
+        }
+        this.mergeMaps(a1.map, a2.map);
+        this.mergeMaps(a1.columnsMap, a2.columnsMap);
+        return {
+            map: a1.map,
+            columnsMap: a1.columnsMap,
+            rowLevels: Math.max(a1.rowLevels, a2.rowLevels),
+            columnLevels: Math.max(a1.columnLevels, a2.columnLevels),
+        };
+    }
+    mergeMaps(m1, m2) {
+        Object.keys(m2).forEach(key => {
+            if (m1[key]) {
+                if (isArray(m1[key]) && isArray(m2[key])) {
+                    m1[key].push(...m2[key]);
+                }
+                else if (!isArray(m1[key]) && !isArray(m2[key])) {
+                    this.mergeMaps(m1[key], m2[key]);
+                }
+            }
+            else {
+                m1[key] = m2[key];
+            }
+        });
+    }
+    getAttributesColors(attributes) {
+        return (attributes || []).map(attribute => {
+            const resource = this.dataAggregator.getNextCollectionResource(attribute.resourceIndex);
+            return resource && resource.color;
+        });
+    }
+    convertPivotRowColumnAttribute(pivotAttribute) {
+        return { ...this.convertPivotAttribute(pivotAttribute), data: pivotAttribute.constraint };
+    }
+    convertPivotAttribute(pivotAttribute) {
+        return { resourceIndex: pivotAttribute.resourceIndex, attributeId: pivotAttribute.attributeId };
+    }
+    convertValueAttributes(configs, stems, stemsIndexes) {
+        const data = configs.reduce((allData, config, index) => {
+            const stem = stems[index];
+            const stemIndex = stemsIndexes[index];
+            const stemData = this.data?.dataByStems?.[stemIndex];
+            this.dataAggregator.updateData(this.collections, stemData?.documents || [], this.linkTypes, stemData?.linkInstances || [], stem, this.constraintData);
+            const valueAttributes = config.valueAttributes || [];
+            allData.valueTypes.push(...valueAttributes.map(attr => attr.valueType));
+            const valueColors = this.getAttributesColors(valueAttributes);
+            const { titles, constraints } = this.createValueTitles(valueAttributes);
+            allData.titles.push(...titles);
+            allData.constraints.push(...constraints);
+            const { headers } = this.convertMapToPivotDataHeader({}, 0, [], valueColors, [], titles, allData.headers.length);
+            allData.headers.push(...headers);
+            allData.aggregations = [...(valueAttributes || []).map(valueAttribute => valueAttribute.aggregation)];
+            const { values, dataResources } = (valueAttributes || []).reduce((aggregator, valueAttribute, index) => {
+                const dataResources = this.findDataResourcesByPivotAttribute(valueAttribute);
+                const attribute = this.findAttributeByPivotAttribute(valueAttribute);
+                const value = aggregateDataResources(valueAttribute.aggregation, dataResources, attribute, true);
+                aggregator.values.push(value);
+                aggregator.dataResources.push(dataResources);
+                return aggregator;
+            }, { values: [], dataResources: [] });
+            allData.values.push(...values);
+            allData.dataResources.push(...dataResources);
+            return allData;
+        }, { titles: [], constraints: [], headers: [], values: [], dataResources: [], valueTypes: [], aggregations: [] });
+        return {
+            columnHeaders: data.headers,
+            rowHeaders: [],
+            valueTitles: data.titles,
+            values: [data.values],
+            dataResources: [data.dataResources],
+            valuesConstraints: data.constraints,
+            valueTypes: data.valueTypes,
+            valueAggregations: data.aggregations,
+            rowShowSums: [],
+            rowSticky: [],
+            rowSorts: [],
+            columnShowSums: [],
+            columnSticky: [],
+            columnSorts: [],
+            hasAdditionalColumnLevel: true,
+        };
+    }
+    findDataResourcesByPivotAttribute(pivotAttribute) {
+        if (pivotAttribute.resourceType === AttributesResourceType.Collection) {
+            return (this.data?.uniqueDocuments || []).filter(document => document.collectionId === pivotAttribute.resourceId);
+        }
+        else if (pivotAttribute.resourceType === AttributesResourceType.LinkType) {
+            return (this.data?.uniqueLinkInstances || []).filter(link => link.linkTypeId === pivotAttribute.resourceId);
+        }
+        return [];
+    }
+    convertAggregatedData(aggregatedData, valueAttributes, pivotColors, additionalData) {
+        const rowData = this.convertMapToPivotDataHeader(aggregatedData.map, aggregatedData.rowLevels, pivotColors.rows, pivotColors.values, additionalData.rowAttributes);
+        const { titles: valueTitles, constraints: valuesConstraints } = this.createValueTitles(valueAttributes);
+        const columnData = this.convertMapToPivotDataHeader(aggregatedData.rowLevels > 0 ? aggregatedData.columnsMap : aggregatedData.map, aggregatedData.columnLevels, pivotColors.columns, pivotColors.values, additionalData.columnAttributes, valueTitles);
+        const values = this.initMatrix(rowData.maxIndex + 1, columnData.maxIndex + 1);
+        const dataResources = this.initMatrix(rowData.maxIndex + 1, columnData.maxIndex + 1);
+        if ((valueAttributes || []).length > 0) {
+            this.fillValues(values, dataResources, rowData.headers, columnData.headers, valueAttributes, aggregatedData);
+        }
+        const valueAggregations = (valueAttributes || []).map(valueAttribute => valueAttribute.aggregation);
+        const hasAdditionalColumnLevel = (aggregatedData.columnLevels === 0 && valueTitles.length > 0) ||
+            (aggregatedData.columnLevels > 0 && valueTitles.length > 1);
+        return {
+            rowHeaders: rowData.headers,
+            columnHeaders: columnData.headers,
+            valueTitles,
+            values,
+            dataResources,
+            valuesConstraints,
+            valueAggregations,
+            ...additionalData,
+            valueTypes: valueAttributes.map(attr => attr.valueType),
+            hasAdditionalColumnLevel,
+        };
+    }
+    convertMapToPivotDataHeader(map, levels, colors, valueColors, attributes, valueTitles, additionalNum = 0) {
+        const headers = [];
+        const data = { maxIndex: 0 };
+        if (levels === 0) {
+            if ((valueTitles || []).length > 0) {
+                headers.push(...valueTitles.map((title, index) => ({
+                    title,
+                    targetIndex: index + additionalNum,
+                    color: valueColors[index],
+                    isValueHeader: true,
+                })));
+                data.maxIndex = valueTitles.length - 1 + additionalNum;
+            }
+        }
+        else {
+            let currentIndex = additionalNum;
+            Object.keys(map).forEach((title, index) => {
+                const attribute = attributes && attributes[0];
+                if (levels === 1 && (valueTitles || []).length <= 1) {
+                    headers.push({
+                        title,
+                        targetIndex: currentIndex,
+                        color: colors[0],
+                        constraint: attribute?.constraint || new UnknownConstraint(),
+                        isValueHeader: false,
+                        attributeName: attribute?.name,
+                    });
+                    data.maxIndex = Math.max(data.maxIndex, currentIndex);
+                }
+                else {
+                    headers.push({
+                        title,
+                        color: colors[0],
+                        constraint: attribute?.constraint || new UnknownConstraint(),
+                        isValueHeader: false,
+                        attributeName: attribute?.name,
+                    });
+                }
+                this.iterateThroughPivotDataHeader(map[title], headers[index], currentIndex, 1, levels, colors, valueColors, valueTitles || [], attributes, data);
+                currentIndex += this.numChildren(map[title], levels - 1, (valueTitles && valueTitles.length) || 1);
+            });
+        }
+        return { headers, maxIndex: data.maxIndex };
+    }
+    iterateThroughPivotDataHeader(currentMap, header, headerIndex, level, maxLevels, colors, valueColors, valueTitles, attributes, additionalData) {
+        if (level === maxLevels) {
+            if ((valueTitles || []).length > 1) {
+                header.children = valueTitles.map((title, index) => ({
+                    title,
+                    targetIndex: headerIndex + index,
+                    color: valueColors[index],
+                    isValueHeader: true,
+                }));
+                additionalData.maxIndex = Math.max(additionalData.maxIndex, headerIndex + valueTitles.length - 1);
+            }
+            return;
+        }
+        header.children = [];
+        let currentIndex = headerIndex;
+        Object.keys(currentMap).forEach((title, index) => {
+            const attribute = attributes && attributes[level];
+            if (level + 1 === maxLevels && (valueTitles || []).length <= 1) {
+                header.children.push({
+                    title,
+                    targetIndex: currentIndex,
+                    color: colors[level],
+                    constraint: attribute?.constraint || new UnknownConstraint(),
+                    isValueHeader: false,
+                    attributeName: attribute?.name,
+                });
+                additionalData.maxIndex = Math.max(additionalData.maxIndex, currentIndex);
+            }
+            else {
+                header.children.push({
+                    title,
+                    color: colors[level],
+                    constraint: attribute?.constraint || new UnknownConstraint(),
+                    isValueHeader: false,
+                    attributeName: attribute?.name,
+                });
+            }
+            this.iterateThroughPivotDataHeader(currentMap[title], header.children?.[index], currentIndex, level + 1, maxLevels, colors, valueColors, valueTitles, attributes, additionalData);
+            currentIndex += this.numChildren(currentMap[title], maxLevels - (level + 1), (valueTitles && valueTitles.length) || 1);
+        });
+    }
+    numChildren(map, maxLevels, numTitles) {
+        if (maxLevels === 0) {
+            return numTitles;
+        }
+        const keys = Object.keys(map || {});
+        if (maxLevels === 1) {
+            return keys.length * numTitles;
+        }
+        const count = keys.reduce((sum, key) => sum + this.numChildrenRecursive(map[key], 1, maxLevels), 0);
+        return count * numTitles;
+    }
+    numChildrenRecursive(map, level, maxLevels) {
+        if (level >= maxLevels) {
+            return 0;
+        }
+        const keys = Object.keys(map || {});
+        if (level + 1 === maxLevels) {
+            return keys.length;
+        }
+        return keys.reduce((sum, key) => sum + this.numChildrenRecursive(map[key], level + 1, maxLevels), 0);
+    }
+    createValueTitles(valueAttributes) {
+        return (valueAttributes || []).reduce(({ titles, constraints }, pivotAttribute) => {
+            const attribute = this.findAttributeByPivotAttribute(pivotAttribute);
+            constraints.push(dataAggregationConstraint(pivotAttribute.aggregation) || this.pivotAttributeConstraint(pivotAttribute));
+            const title = this.createValueTitle(pivotAttribute.aggregation, attribute?.name || '');
+            titles.push(title);
+            return { titles, constraints };
+        }, { titles: [], constraints: [] });
+    }
+    createValueTitle(aggregation, attributeName) {
+        const valueAggregationTitle = this.transform?.translateAggregation?.(aggregation) || aggregation.toString();
+        return `${valueAggregationTitle} ${attributeName || ''}`.trim();
+    }
+    initMatrix(rows, columns) {
+        const matrix = [];
+        for (let i = 0; i < rows; i++) {
+            matrix[i] = [];
+            for (let j = 0; j < columns; j++) {
+                matrix[i][j] = undefined;
+            }
+        }
+        return matrix;
+    }
+    fillValues(values, dataResources, rowHeaders, columnHeaders, valueAttributes, aggregatedData) {
+        if (rowHeaders.length > 0) {
+            this.iterateThroughRowHeaders(values, dataResources, rowHeaders, columnHeaders, valueAttributes, aggregatedData.map);
+        }
+        else {
+            this.iterateThroughColumnHeaders(values, dataResources, columnHeaders, 0, valueAttributes, aggregatedData.map);
+        }
+    }
+    iterateThroughRowHeaders(values, dataResources, rowHeaders, columnHeaders, valueAttributes, currentMap) {
+        for (const rowHeader of rowHeaders) {
+            const rowHeaderMap = currentMap[rowHeader.title] || {};
+            if (rowHeader.children) {
+                this.iterateThroughRowHeaders(values, dataResources, rowHeader.children, columnHeaders, valueAttributes, rowHeaderMap);
+            }
+            else if (isNotNullOrUndefined(rowHeader.targetIndex) && columnHeaders.length > 0) {
+                this.iterateThroughColumnHeaders(values, dataResources, columnHeaders, rowHeader.targetIndex, valueAttributes, rowHeaderMap);
+            }
+        }
+    }
+    iterateThroughColumnHeaders(values, dataResources, columnHeaders, rowIndex, valueAttributes, currentMap) {
+        for (const columnHeader of columnHeaders) {
+            if (columnHeader.children) {
+                this.iterateThroughColumnHeaders(values, dataResources, columnHeader.children, rowIndex, valueAttributes, currentMap[columnHeader.title] || {});
+            }
+            else if (isNotNullOrUndefined(columnHeader.targetIndex)) {
+                const aggregatedDataValues = isArray(currentMap) ? currentMap : currentMap[columnHeader.title];
+                if (valueAttributes.length) {
+                    const valueIndex = columnHeader.targetIndex % valueAttributes.length;
+                    const { value, dataResources: aggregatedDataResources } = this.aggregateValue(valueAttributes[valueIndex], aggregatedDataValues);
+                    values[rowIndex][columnHeader.targetIndex] = value;
+                    dataResources[rowIndex][columnHeader.targetIndex] = aggregatedDataResources || [];
+                }
+            }
+        }
+    }
+    aggregateValue(valueAttribute, aggregatedDataValues) {
+        const resourceAggregatedDataValues = (aggregatedDataValues || []).filter(agg => agg.resourceId === valueAttribute.resourceId && agg.type === valueAttribute.resourceType);
+        if (resourceAggregatedDataValues.length) {
+            const dataResources = flattenMatrix(resourceAggregatedDataValues.map(val => val.objects));
+            const attribute = this.pivotAttributeAttribute(valueAttribute);
+            if (valueAttribute.aggregation === DataAggregationType.Join) {
+                // values will be joined in pivot-table-converter
+                const values = (dataResources || []).map((resource) => resource.data?.[attribute?.id || '']);
+                return { value: uniqueValues(flattenValues(values)), dataResources };
+            }
+            const value = attribute && aggregateDataResources(valueAttribute.aggregation, dataResources, attribute, true);
+            return { value, dataResources };
+        }
+        return {};
+    }
+    findAttributeByPivotAttribute(valueAttribute) {
+        if (valueAttribute.resourceType === AttributesResourceType.Collection) {
+            return this.collectionsAttributesMap?.[valueAttribute.resourceId]?.[valueAttribute.attributeId];
+        }
+        else if (valueAttribute.resourceType === AttributesResourceType.LinkType) {
+            return this.linkTypesAttributesMap?.[valueAttribute.resourceId]?.[valueAttribute.attributeId];
+        }
+        return undefined;
+    }
+}
+function getPivotStemConfigType(stemConfig) {
+    const rowLength = (stemConfig.rowAttributes || []).length;
+    const columnLength = (stemConfig.columnAttributes || []).length;
+    if (rowLength > 0 && columnLength > 0) {
+        return PivotConfigType.RowsAndColumns;
+    }
+    else if (rowLength > 0) {
+        return PivotConfigType.Rows;
+    }
+    else if (columnLength > 0) {
+        return PivotConfigType.Columns;
+    }
+    return PivotConfigType.Values;
+}
+function canMergeConfigsByType(type, c1, c2) {
+    if (type === PivotConfigType.Rows) {
+        return (c1.rowAttributes || []).length === (c2.rowAttributes || []).length;
+    }
+    else if (type === PivotConfigType.Columns) {
+        return (c1.columnAttributes || []).length === (c2.columnAttributes || []).length;
+    }
+    return ((c1.rowAttributes || []).length === (c2.rowAttributes || []).length &&
+        (c1.columnAttributes || []).length === (c2.columnAttributes || []).length);
+}
+
+/*
+ * Lumeer: Modern Data Definition and Processing Platform
+ *
+ * Copyright (C) since 2017 Lumeer.io, s.r.o. and/or its affiliates.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+class PivotTableConverter {
+    static emptyClass = 'pivot-empty-cell';
+    static dataClass = 'pivot-data-cell';
+    static groupDataClass = 'pivot-data-group-cell';
+    static rowHeaderClass = 'pivot-row-header-cell';
+    static rowGroupHeaderClass = 'pivot-row-group-header-cell';
+    static columnHeaderClass = 'pivot-column-header-cell';
+    static columnGroupHeaderClass = 'pivot-column-group-header-cell';
+    groupColors = [COLOR_GRAY100, COLOR_GRAY200, COLOR_GRAY300, COLOR_GRAY400, COLOR_GRAY500];
+    percentageConstraint = new PercentageConstraint({ decimals: 2 });
+    data;
+    strings;
+    values;
+    dataResources;
+    constraintData;
+    rowLevels;
+    rowsTransformationArray;
+    columnLevels;
+    columnsTransformationArray;
+    valueTypeInfo;
+    nonStickyRowIndex;
+    createTables(pivotData, strings) {
+        if (!pivotData) {
+            return [{ cells: [] }];
+        }
+        this.strings = strings;
+        this.constraintData = pivotData.constraintData;
+        return (pivotData.data || []).map(d => {
+            if (this.dataAreEmpty(d)) {
+                return { cells: [] };
+            }
+            this.updateData(d);
+            return this.transformData();
+        });
+    }
+    dataAreEmpty(data) {
+        return (data.rowHeaders || []).length === 0 && (data.columnHeaders || []).length === 0;
+    }
+    updateData(data) {
+        const numberOfSums = Math.max(1, (data.valueTitles || []).length);
+        this.valueTypeInfo = getValuesTypeInfo(data.values, data.valueTypes, numberOfSums);
+        this.data = preparePivotData(data, this.constraintData, this.valueTypeInfo);
+        this.nonStickyRowIndex = this.data.rowSticky?.findIndex(sticky => !sticky) || 0;
+        this.values = data.values || [];
+        this.dataResources = data.dataResources || [];
+        this.rowLevels = (data.rowShowSums || []).length;
+        this.columnLevels = (data.columnShowSums || []).length + (data.hasAdditionalColumnLevel ? 1 : 0);
+        const hasValue = (data.valueTitles || []).length > 0;
+        if ((this.data.rowHeaders || []).length > 0) {
+            this.rowsTransformationArray = createTransformationMap(this.data.rowHeaders, this.rowShowSums, this.columnLevels, 1);
+        }
+        else {
+            this.rowsTransformationArray = hasValue ? [this.columnLevels] : [];
+        }
+        if ((this.data.columnHeaders || []).length > 0) {
+            this.columnsTransformationArray = createTransformationMap(this.data.columnHeaders, this.columnShowSums, this.rowLevels, numberOfSums);
+        }
+        else {
+            this.columnsTransformationArray = hasValue ? [this.rowLevels] : [];
+        }
+    }
+    get rowShowSums() {
+        return this.data.rowShowSums;
+    }
+    get columnShowSums() {
+        return this.data.columnShowSums;
+    }
+    transformData() {
+        const cells = this.initCells();
+        const rowGroups = this.fillCellsByRows(cells);
+        const columnGroups = this.fillCellsByColumns(cells);
+        this.fillCellsByGroupIntersection(cells, rowGroups, columnGroups);
+        return { cells };
+    }
+    fillCellsByRows(cells) {
+        const rowGroups = [];
+        this.iterateAndFillCellsByRows(cells, rowGroups, this.data.rowHeaders, this.columnLevels, this.rowShowSums, 0);
+        return rowGroups;
+    }
+    iterateAndFillCellsByRows(cells, rowGroupsInfo, headers, startIndex, showSums, level, parentHeader) {
+        let currentIndex = startIndex;
+        for (const header of headers) {
+            const rowSpan = getDirectHeaderChildCount(header, level, showSums);
+            cells[currentIndex][level] = {
+                value: header.title,
+                cssClass: PivotTableConverter.rowHeaderClass,
+                isHeader: true,
+                stickyStart: this.isRowLevelSticky(level),
+                rowSpan,
+                colSpan: 1,
+                background: this.getHeaderBackground(header, level),
+                constraint: header.constraint,
+                label: header.attributeName,
+            };
+            if (header.children) {
+                this.iterateAndFillCellsByRows(cells, rowGroupsInfo, header.children, currentIndex, showSums, level + 1, header);
+            }
+            else if (isNotNullOrUndefined(header.targetIndex)) {
+                this.fillCellsForRow(cells, header.targetIndex);
+            }
+            currentIndex += getHeaderChildCount(header, level, showSums);
+        }
+        if (showSums[level]) {
+            const background = this.getSummaryBackground(level);
+            const summary = level === 0 ? this.strings.summaryString : this.strings.headerSummaryString;
+            const columnIndex = Math.max(level - 1, 0);
+            let colSpan = this.rowLevels - columnIndex;
+            const stickyStart = this.isRowLevelSticky(columnIndex);
+            // split row group header cell because of correct sticky scroll
+            if (stickyStart && this.nonStickyRowIndex > 0 && colSpan > 1) {
+                const newColspan = this.nonStickyRowIndex - columnIndex;
+                cells[currentIndex][this.nonStickyRowIndex] = {
+                    value: undefined,
+                    constraint: undefined,
+                    label: undefined,
+                    cssClass: PivotTableConverter.rowGroupHeaderClass,
+                    isHeader: true,
+                    rowSpan: 1,
+                    colSpan: colSpan - newColspan,
+                    background,
+                    summary: undefined,
+                };
+                colSpan = newColspan;
+            }
+            cells[currentIndex][columnIndex] = {
+                value: parentHeader?.title,
+                constraint: parentHeader?.constraint,
+                label: parentHeader?.attributeName,
+                cssClass: PivotTableConverter.rowGroupHeaderClass,
+                isHeader: true,
+                stickyStart,
+                rowSpan: 1,
+                colSpan,
+                background,
+                summary,
+            };
+            const rowIndexes = getTargetIndexesForHeaders(headers);
+            const transformedRowIndexes = rowIndexes
+                .map(v => this.rowsTransformationArray[v])
+                .filter(v => isNotNullOrUndefined(v));
+            rowGroupsInfo[currentIndex] = { background, indexes: transformedRowIndexes, level };
+            this.fillCellsForGroupedRow(cells, rowIndexes, currentIndex, background);
+        }
+    }
+    getHeaderBackground(header, level) {
+        if (header?.color) {
+            return shadeColor(header.color, this.getLevelOpacity(level));
+        }
+        return undefined;
+    }
+    getLevelOpacity(level) {
+        return Math.min(80, 50 + level * 5) / 100;
+    }
+    isRowLevelSticky(level) {
+        return this.data?.rowSticky?.[level];
+    }
+    isColumnLevelSticky(level) {
+        const maxLevel = Math.min(level, (this.data?.columnSticky?.length ?? Number.MAX_SAFE_INTEGER) - 1);
+        return this.data?.columnSticky?.[maxLevel];
+    }
+    getSummaryBackground(level) {
+        const index = Math.min(level, this.groupColors.length - 1);
+        return this.groupColors[index];
+    }
+    fillCellsForRow(cells, row) {
+        const rowIndexInCells = this.rowsTransformationArray[row];
+        if (isNotNullOrUndefined(rowIndexInCells)) {
+            for (let column = 0; column < this.columnsTransformationArray.length; column++) {
+                const columnIndexInCells = this.columnsTransformationArray[column];
+                if (isNotNullOrUndefined(columnIndexInCells)) {
+                    const value = this.data.values[row][column];
+                    const dataResources = this.dataResources?.[row]?.[column] || [];
+                    const formattedValue = this.aggregateOrFormatSingleValue(value, column);
+                    const stringValue = isNotNullOrUndefined(formattedValue) ? String(formattedValue) : '';
+                    cells[rowIndexInCells][columnIndexInCells] = {
+                        value: stringValue,
+                        dataResources,
+                        rowSpan: 1,
+                        colSpan: 1,
+                        cssClass: PivotTableConverter.dataClass,
+                        isHeader: false,
+                    };
+                }
+            }
+        }
+    }
+    getValueIndexForColumns(columns) {
+        return columns[0] % this.data.valueTitles.length;
+    }
+    formatValueByValueType(value, valueIndex) {
+        const valueType = (this.data.valueTypes || [])[valueIndex];
+        if (!valueType || valueType === LmrPivotValueType.Default) {
+            return this.formatValueByConstraint(value, valueIndex);
+        }
+        if ([LmrPivotValueType.AllPercentage, LmrPivotValueType.ColumnPercentage, LmrPivotValueType.RowPercentage].includes(valueType)) {
+            return this.formatValueByPercentage(value);
+        }
+        return this.formatValueByConstraint(value, valueIndex);
+    }
+    formatGroupedValueByValueType(value, rows, columns) {
+        const valueIndex = columns[0] % this.data.valueTitles.length;
+        const valueType = this.data.valueTypes && this.data.valueTypes[valueIndex];
+        const valueTypeInfo = this.valueTypeInfo[valueIndex];
+        if (!valueTypeInfo || !valueType || valueType === LmrPivotValueType.Default) {
+            return this.formatValueByConstraint(value, valueIndex);
+        }
+        if (valueType === LmrPivotValueType.AllPercentage) {
+            return this.formatValueByPercentage(divideValues(value, valueTypeInfo.sum));
+        }
+        else if (valueType === LmrPivotValueType.ColumnPercentage) {
+            const columnsDividers = columns.reduce((dividers, column) => {
+                dividers.push(valueTypeInfo.sumsColumns[column]);
+                return dividers;
+            }, []);
+            const columnsDivider = aggregateDataValues(DataAggregationType.Sum, columnsDividers);
+            return this.formatValueByPercentage(divideValues(value, columnsDivider));
+        }
+        else if (valueType === LmrPivotValueType.RowPercentage) {
+            const rowsDividers = rows.reduce((dividers, row) => {
+                dividers.push(valueTypeInfo.sumsRows[row]);
+                return dividers;
+            }, []);
+            const rowsDivider = aggregateDataValues(DataAggregationType.Sum, rowsDividers);
+            return this.formatValueByPercentage(divideValues(value, rowsDivider));
+        }
+        return this.formatValueByConstraint(value, valueIndex);
+    }
+    formatValueByPercentage(value) {
+        return this.percentageConstraint.createDataValue(value).format();
+    }
+    formatValueByConstraint(value, valueIndex) {
+        const constraint = this.data.valuesConstraints?.[valueIndex] || this.valueTypeInfo[valueIndex]?.defaultConstraint;
+        if (constraint) {
+            return constraint.createDataValue(value, this.constraintData).preview();
+        }
+        return value;
+    }
+    fillCellsForGroupedRow(cells, rows, rowIndexInCells, background) {
+        for (let column = 0; column < this.columnsTransformationArray.length; column++) {
+            const columnIndexInCells = this.columnsTransformationArray[column];
+            if (isNotNullOrUndefined(columnIndexInCells)) {
+                const { values, dataResources } = this.getGroupedValuesForRowsAndCols(rows, [column]);
+                const formattedValue = this.aggregateAndFormatDataValues(values, rows, [column]);
+                cells[rowIndexInCells][columnIndexInCells] = {
+                    value: String(formattedValue),
+                    dataResources,
+                    colSpan: 1,
+                    rowSpan: 1,
+                    cssClass: PivotTableConverter.groupDataClass,
+                    isHeader: false,
+                    background,
+                };
+            }
+        }
+    }
+    getGroupedValuesForRowsAndCols(rows, columns) {
+        const values = [];
+        const dataResources = [];
+        for (const row of rows) {
+            for (const column of columns) {
+                const rowColumnValue = this.values[row][column];
+                if (isArray(rowColumnValue)) {
+                    values.push(...rowColumnValue);
+                }
+                else {
+                    values.push(rowColumnValue);
+                }
+                dataResources.push(...(this.dataResources?.[row]?.[column] || []));
+            }
+        }
+        return { values, dataResources };
+    }
+    fillCellsByColumns(cells) {
+        const columnGroups = [];
+        this.iterateAndFillCellsByColumns(cells, columnGroups, this.data.columnHeaders, this.rowLevels, this.columnShowSums, 0);
+        return columnGroups;
+    }
+    iterateAndFillCellsByColumns(cells, columnGroupsInfo, headers, startIndex, showSums, level, parentHeader) {
+        let currentIndex = startIndex;
+        const numberOfSums = Math.max(1, this.data.valueTitles.length);
+        for (const header of headers) {
+            const colSpan = getDirectHeaderChildCount(header, level, showSums, numberOfSums);
+            cells[level][currentIndex] = {
+                value: header.title,
+                cssClass: PivotTableConverter.columnHeaderClass,
+                isHeader: true,
+                rowSpan: 1,
+                colSpan,
+                stickyTop: this.isColumnLevelSticky(level),
+                background: this.getHeaderBackground(header, level),
+                constraint: header.constraint,
+                label: header.attributeName,
+            };
+            if (header.children) {
+                this.iterateAndFillCellsByColumns(cells, columnGroupsInfo, header.children, currentIndex, showSums, level + 1, header);
+            }
+            else if (isNotNullOrUndefined(header.targetIndex)) {
+                this.fillCellsForColumn(cells, header.targetIndex);
+            }
+            currentIndex += getHeaderChildCount(header, level, showSums, numberOfSums);
+        }
+        if (showSums[level]) {
+            const background = this.getSummaryBackground(level);
+            const summary = level === 0 ? this.strings.summaryString : this.strings.headerSummaryString;
+            const numberOfValues = this.data.valueTitles.length;
+            const rowIndex = Math.max(level - 1, 0);
+            const shouldAddValueHeaders = numberOfValues > 1;
+            cells[rowIndex][currentIndex] = {
+                value: parentHeader?.title,
+                constraint: parentHeader?.constraint,
+                label: parentHeader?.attributeName,
+                cssClass: PivotTableConverter.columnGroupHeaderClass,
+                isHeader: true,
+                stickyTop: this.isColumnLevelSticky(level),
+                rowSpan: this.columnLevels - rowIndex - (shouldAddValueHeaders ? 1 : 0),
+                colSpan: numberOfSums,
+                background,
+                summary,
+            };
+            if (numberOfValues > 0) {
+                for (let i = 0; i < numberOfValues; i++) {
+                    const columnIndexInCells = currentIndex + i;
+                    if (shouldAddValueHeaders) {
+                        const valueTitle = this.data.valueTitles[i];
+                        cells[this.columnLevels - 1][columnIndexInCells] = {
+                            value: valueTitle,
+                            cssClass: PivotTableConverter.columnGroupHeaderClass,
+                            isHeader: true,
+                            stickyTop: this.isColumnLevelSticky(level),
+                            rowSpan: 1,
+                            colSpan: 1,
+                            background,
+                        };
+                    }
+                    const columnsIndexes = getTargetIndexesForHeaders(headers);
+                    const valueColumnsIndexes = columnsIndexes.filter(index => index % numberOfValues === i);
+                    const transformedColumnIndexes = valueColumnsIndexes
+                        .map(v => this.columnsTransformationArray[v])
+                        .filter(v => isNotNullOrUndefined(v));
+                    columnGroupsInfo[columnIndexInCells] = { background, indexes: transformedColumnIndexes, level };
+                    this.fillCellsForGroupedColumn(cells, valueColumnsIndexes, columnIndexInCells, background);
+                }
+            }
+            else {
+                columnGroupsInfo[currentIndex] = { background, indexes: [], level };
+            }
+        }
+    }
+    fillCellsForGroupedColumn(cells, columns, columnIndexInCells, background) {
+        for (let row = 0; row < this.rowsTransformationArray.length; row++) {
+            const rowIndexInCells = this.rowsTransformationArray[row];
+            if (isNotNullOrUndefined(rowIndexInCells)) {
+                const { values, dataResources } = this.getGroupedValuesForRowsAndCols([row], columns);
+                const formattedValue = this.aggregateAndFormatDataValues(values, [row], columns);
+                cells[rowIndexInCells][columnIndexInCells] = {
+                    value: String(formattedValue),
+                    dataResources,
+                    colSpan: 1,
+                    rowSpan: 1,
+                    cssClass: PivotTableConverter.groupDataClass,
+                    isHeader: false,
+                    background,
+                };
+            }
+        }
+    }
+    aggregateAndFormatDataValues(values, rows, columns) {
+        const aggregation = this.aggregationByColumns(columns);
+        if (aggregation === DataAggregationType.Join) {
+            const valueIndex = this.getValueIndexForColumns(columns);
+            const constraint = this.data.valuesConstraints?.[valueIndex] || this.valueTypeInfo[valueIndex]?.defaultConstraint;
+            return aggregateDataValues(aggregation, values, constraint, false, this.constraintData);
+        }
+        const aggregatedValue = aggregateDataValues(aggregation, values);
+        return this.formatGroupedValueByValueType(aggregatedValue, rows, columns);
+    }
+    aggregationByColumns(columns) {
+        const valueIndex = columns[0] % this.data.valueTitles.length;
+        const aggregation = this.data.valueAggregations?.[valueIndex];
+        return isValueAggregation(aggregation) ? aggregation : DataAggregationType.Sum;
+    }
+    fillCellsForColumn(cells, column) {
+        const columnIndexInCells = this.columnsTransformationArray[column];
+        if (isNotNullOrUndefined(columnIndexInCells)) {
+            for (let row = 0; row < this.rowsTransformationArray.length; row++) {
+                const rowIndexInCells = this.rowsTransformationArray[row];
+                if (isNotNullOrUndefined(rowIndexInCells)) {
+                    const value = this.data.values[row][column];
+                    const dataResources = this.dataResources?.[row]?.[column] || [];
+                    const formattedValue = this.aggregateOrFormatSingleValue(value, column);
+                    const stringValue = isNotNullOrUndefined(formattedValue) ? String(formattedValue) : '';
+                    cells[rowIndexInCells][columnIndexInCells] = {
+                        value: stringValue,
+                        dataResources,
+                        rowSpan: 1,
+                        colSpan: 1,
+                        cssClass: PivotTableConverter.dataClass,
+                        isHeader: false,
+                    };
+                }
+            }
+        }
+    }
+    aggregateOrFormatSingleValue(value, column) {
+        const aggregation = this.aggregationByColumns([column]);
+        const valueIndex = this.getValueIndexForColumns([column]);
+        if (aggregation === DataAggregationType.Join) {
+            const constraint = this.data.valuesConstraints?.[valueIndex] || this.valueTypeInfo[valueIndex]?.defaultConstraint;
+            return aggregateDataValues(aggregation, [value], constraint, false, this.constraintData);
+        }
+        return this.formatValueByValueType(value, valueIndex);
+    }
+    fillCellsByGroupIntersection(cells, rowGroupsInfo, columnGroupsInfo) {
+        const rowsCount = cells.length;
+        const columnsCount = (cells[0] && cells[0].length) || 0;
+        for (let i = 0; i < rowGroupsInfo.length; i++) {
+            const rowGroupInfo = rowGroupsInfo[i];
+            if (rowGroupInfo) {
+                for (let j = 0; j < columnGroupsInfo.length; j++) {
+                    if (columnGroupsInfo[j]) {
+                        // it's enough to fill group values only from row side
+                        const { rowsIndexes, columnsIndexes } = this.getValuesIndexesFromCellsIndexes(rowGroupInfo.indexes, columnGroupsInfo[j].indexes);
+                        const { values, dataResources } = this.getGroupedValuesForRowsAndCols(rowsIndexes, columnsIndexes);
+                        const formattedValue = this.aggregateAndFormatDataValues(values, rowsIndexes, columnsIndexes);
+                        cells[i][j] = {
+                            value: String(formattedValue),
+                            dataResources,
+                            colSpan: 1,
+                            rowSpan: 1,
+                            cssClass: PivotTableConverter.groupDataClass,
+                            isHeader: false,
+                        };
+                    }
+                }
+                this.fillRowWithColor(cells, i, rowGroupInfo, columnsCount);
+            }
+        }
+        for (let j = 0; j < columnGroupsInfo.length; j++) {
+            if (columnGroupsInfo[j]) {
+                this.fillColumnWithColor(cells, j, columnGroupsInfo[j], rowGroupsInfo, rowsCount);
+            }
+        }
+    }
+    getValuesIndexesFromCellsIndexes(rows, columns) {
+        const rowsIndexes = rows
+            .map(row => this.rowsTransformationArray.findIndex(tRow => tRow === row))
+            .filter(index => index >= 0);
+        const columnsIndexes = columns
+            .map(column => this.columnsTransformationArray.findIndex(tColumn => tColumn === column))
+            .filter(index => index >= 0);
+        return { rowsIndexes, columnsIndexes };
+    }
+    fillRowWithColor(cells, row, rowGroupInfo, columnsCount) {
+        for (let i = this.rowLevels; i < columnsCount; i++) {
+            cells[row][i] && (cells[row][i].background = rowGroupInfo.background);
+        }
+    }
+    fillColumnWithColor(cells, column, columnGroupInfo, rowGroupsInfo, rowCount) {
+        for (let i = this.columnLevels; i < rowCount; i++) {
+            const rowGroupInfo = rowGroupsInfo[i];
+            if (!rowGroupInfo || rowGroupInfo.level > columnGroupInfo.level) {
+                cells[i][column] && (cells[i][column].background = columnGroupInfo.background);
+            }
+        }
+    }
+    initCells() {
+        const rows = this.getRowsCount() + this.columnLevels;
+        const columns = this.getColumnsCount() + this.rowLevels;
+        const matrix = [];
+        for (let i = 0; i < rows; i++) {
+            matrix[i] = [];
+            for (let j = 0; j < columns; j++) {
+                if (i >= this.columnLevels && j >= this.rowLevels) {
+                    const isDataClass = this.rowsTransformationArray.includes(i) && this.columnsTransformationArray.includes(j);
+                    matrix[i][j] = {
+                        value: '',
+                        dataResources: [],
+                        cssClass: isDataClass ? PivotTableConverter.dataClass : PivotTableConverter.groupDataClass,
+                        rowSpan: 1,
+                        colSpan: 1,
+                        isHeader: false,
+                    };
+                }
+                else {
+                    matrix[i][j] = undefined;
+                }
+            }
+        }
+        if (this.rowLevels > 0 && this.columnLevels > 0) {
+            for (let i = 0; i < this.columnLevels; i++) {
+                for (let j = 0; j < this.rowLevels; j++) {
+                    matrix[i][j] = {
+                        value: '',
+                        cssClass: PivotTableConverter.emptyClass,
+                        rowSpan: 1,
+                        colSpan: 1,
+                        stickyStart: this.isRowLevelSticky(j),
+                        stickyTop: this.isColumnLevelSticky(i),
+                        isHeader: false,
+                    };
+                }
+            }
+        }
+        return matrix;
+    }
+    getRowsCount() {
+        if (this.data.rowHeaders.length === 0 && (this.data.valueTitles || []).length > 0) {
+            return 1;
+        }
+        return getHeadersChildCount(this.data.rowHeaders, this.rowShowSums);
+    }
+    getColumnsCount() {
+        if (this.data.columnHeaders.length === 0 && (this.data.valueTitles || []).length > 0) {
+            return 1;
+        }
+        const numberOfSums = Math.max(1, (this.data.valueTitles || []).length);
+        return getHeadersChildCount(this.data.columnHeaders, this.columnShowSums, numberOfSums);
+    }
+}
+function preparePivotData(data, constraintData, valueTypeInfo) {
+    const numberOfSums = Math.max(1, (data.valueTitles || []).length);
+    const values = computeValuesByValueType(data.values, data.valueTypes, numberOfSums, valueTypeInfo);
+    return sortPivotData({ ...data, values }, constraintData);
+}
+function computeValuesByValueType(values, valueTypes, numValues, valueTypeInfo) {
+    const rowsIndexes = [...Array(values.length).keys()];
+    const modifiedValues = deepObjectCopy(values);
+    for (let i = 0; i < numValues; i++) {
+        const valueType = valueTypes && valueTypes[i];
+        if (!valueType || valueType === LmrPivotValueType.Default) {
+            continue;
+        }
+        const columnsCount = (values[0] && values[0].length) || 0;
+        const columnIndexes = [...Array(columnsCount).keys()].filter(key => key % numValues === i);
+        const info = valueTypeInfo[i];
+        for (const row of rowsIndexes) {
+            for (const column of columnIndexes) {
+                if (valueType === LmrPivotValueType.AllPercentage) {
+                    modifiedValues[row][column] = divideValues(values[row][column], info.sum);
+                }
+                else if (valueType === LmrPivotValueType.RowPercentage) {
+                    modifiedValues[row][column] = divideValues(values[row][column], info.sumsRows[row]);
+                }
+                else if (valueType === LmrPivotValueType.ColumnPercentage) {
+                    modifiedValues[row][column] = divideValues(values[row][column], info.sumsColumns[column]);
+                }
+            }
+        }
+    }
+    return modifiedValues;
+}
+function getValuesTypeInfo(values, valueTypes, numValues) {
+    const valueTypeInfo = [];
+    const rowsIndexes = [...Array(values.length).keys()];
+    for (let i = 0; i < numValues; i++) {
+        const valueType = valueTypes && valueTypes[i];
+        const columnsCount = (values[0] && values[0].length) || 0;
+        const columnIndexes = [...Array(columnsCount).keys()].filter(key => key % numValues === i);
+        valueTypeInfo[i] = getValueTypeInfo(values, valueType, rowsIndexes, columnIndexes);
+    }
+    return valueTypeInfo;
+}
+function getValueTypeInfo(values, type, rows, columns) {
+    const containsDecimal = containsDecimalValue(values, rows, columns);
+    const valueTypeInfo = {
+        defaultConstraint: containsDecimal ? new NumberConstraint({ decimals: 2 }) : null,
+    };
+    if (type === LmrPivotValueType.AllPercentage) {
+        return { ...valueTypeInfo, sum: getNumericValuesSummary(values, rows, columns) };
+    }
+    else if (type === LmrPivotValueType.RowPercentage) {
+        return {
+            ...valueTypeInfo,
+            sumsRows: rows.reduce((arr, row) => {
+                arr[row] = getNumericValuesSummary(values, [row], columns);
+                return arr;
+            }, []),
+        };
+    }
+    else if (type === LmrPivotValueType.ColumnPercentage) {
+        return {
+            ...valueTypeInfo,
+            sumsColumns: columns.reduce((arr, column) => {
+                arr[column] = getNumericValuesSummary(values, rows, [column]);
+                return arr;
+            }, []),
+        };
+    }
+    return { ...valueTypeInfo };
+}
+function containsDecimalValue(values, rows, columns) {
+    for (const row of rows) {
+        for (const column of columns) {
+            if (isValueDecimal(values[row][column])) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function isValueDecimal(value) {
+    if (isNullOrUndefined(value)) {
+        return false;
+    }
+    if (isNumeric(value)) {
+        return toNumber(value) % 1 !== 0;
+    }
+    return false;
+}
+function createTransformationMap(headers, showSums, additionalNum, numberOfSums) {
+    const array = [];
+    iterateThroughTransformationMap(headers, additionalNum, array, 0, showSums, numberOfSums);
+    return array;
+}
+function iterateThroughTransformationMap(headers, additionalNum, array, level, showSums, numberOfSums) {
+    let additional = additionalNum;
+    for (let i = 0; i < headers.length; i++) {
+        const header = headers[i];
+        if (header.children) {
+            iterateThroughTransformationMap(header.children, additional, array, level + 1, showSums, numberOfSums);
+            additional += getHeaderChildCount(header, level, showSums, numberOfSums);
+        }
+        else if (isNotNullOrUndefined(header.targetIndex)) {
+            array[header.targetIndex] = i + additional;
+        }
+    }
+}
+function getTargetIndexesForHeaders(headers) {
+    const allRows = (headers || []).reduce((rows, header) => {
+        rows.push(...getTargetIndexesForHeader(header));
+        return rows;
+    }, []);
+    return uniqueValues(allRows);
+}
+function getTargetIndexesForHeader(pivotDataHeader) {
+    if (pivotDataHeader.children) {
+        return pivotDataHeader.children.reduce((rows, header) => {
+            rows.push(...getTargetIndexesForHeader(header));
+            return rows;
+        }, []);
+    }
+    return [pivotDataHeader.targetIndex];
+}
+function getHeadersChildCount(headers, showSums, numberOfSums = 1) {
+    return (headers || []).reduce((sum, header) => sum + getHeaderChildCount(header, 0, showSums, numberOfSums), showSums[0] ? numberOfSums : 0);
+}
+function getHeaderChildCount(pivotDataHeader, level, showSums, numberOfSums = 1, includeChild = true) {
+    if (pivotDataHeader.children) {
+        return pivotDataHeader.children.reduce((sum, header) => sum + getHeaderChildCount(header, level + 1, showSums, numberOfSums, includeChild), showSums[level + 1] ? numberOfSums : 0);
+    }
+    return includeChild ? 1 : 0;
+}
+function getDirectHeaderChildCount(pivotDataHeader, level, showSums, numberOfSums = 1) {
+    if (pivotDataHeader.children) {
+        return pivotDataHeader.children.reduce((sum, header) => sum + getHeaderChildCount(header, level + 1, showSums, numberOfSums), 0);
+    }
+    return 1;
+}
+function sortPivotData(data, constraintData) {
+    return {
+        ...data,
+        rowHeaders: sortPivotRowDataHeaders(data.rowHeaders, data.rowSorts, data, constraintData),
+        columnHeaders: sortPivotColumnDataHeaders(data.columnHeaders, data.columnSorts, data, constraintData),
+    };
+}
+function sortPivotRowDataHeaders(rowHeaders, rowSorts, pivotData, constraintData) {
+    return sortPivotDataHeadersRecursive(rowHeaders, 0, rowSorts, pivotData.columnHeaders, pivotData.values, pivotData.valueTitles || [], true, constraintData);
+}
+function sortPivotColumnDataHeaders(columnHeaders, columnSorts, pivotData, constraintData) {
+    return sortPivotDataHeadersRecursive(columnHeaders, 0, columnSorts, pivotData.rowHeaders, pivotData.values, pivotData.valueTitles || [], false, constraintData);
+}
+function sortPivotDataHeadersRecursive(headers, index, sorts, otherSideHeaders, values, valueTitles, isRows, constraintData) {
+    // we don't want to sort values headers
+    if (!isRows && isValuesHeaders(headers, valueTitles)) {
+        return headers;
+    }
+    const sort = sorts && sorts[index];
+    const constraint = getConstraintForSort(sort, headers);
+    const valuesMap = createHeadersValuesMap(headers, sort, otherSideHeaders, values, valueTitles, isRows);
+    return headers
+        .map(header => ({
+        ...header,
+        children: header.children &&
+            sortPivotDataHeadersRecursive(header.children, index + 1, sorts, otherSideHeaders, values, valueTitles, isRows, constraintData),
+    }))
+        .sort((r1, r2) => {
+        const r1Value = constraint.createDataValue(valuesMap[r1.title], constraintData);
+        const r2Value = constraint.createDataValue(valuesMap[r2.title], constraintData);
+        const multiplier = !sort || sort.asc ? 1 : -1;
+        return r1Value.compareTo(r2Value) * multiplier;
+    });
+}
+function getConstraintForSort(sort, headers) {
+    if ((sort?.list?.values || []).length > 0) {
+        // sort is done by values in columns
+        return new NumberConstraint({});
+    }
+    return ((headers || [])[0] && (headers || [])[0].constraint) || new UnknownConstraint();
+}
+function isValuesHeaders(headers, valueTitles) {
+    return (valueTitles.length > 1 &&
+        (headers || []).every((header, index) => isNotNullOrUndefined(header.targetIndex) && header.title === valueTitles[index]));
+}
+function createHeadersValuesMap(headers, sort, otherSideHeaders, values, valueTitles, isRows) {
+    const sortTargetIndexes = sortValueTargetIndexes(sort, otherSideHeaders, valueTitles);
+    if (!sortTargetIndexes) {
+        return (headers || []).reduce((valuesMap, header) => {
+            valuesMap[header.title] = header.title;
+            return valuesMap;
+        }, {});
+    }
+    return (headers || []).reduce((valuesMap, header) => {
+        const rows = isRows ? getTargetIndexesForHeader(header) : sortTargetIndexes;
+        const columns = isRows ? sortTargetIndexes : getTargetIndexesForHeader(header);
+        valuesMap[header.title] = getNumericValuesSummary(values, rows, columns);
+        return valuesMap;
+    }, {});
+}
+function getNumericValuesSummary(values, rows, columns) {
+    let sum = 0;
+    for (const row of rows) {
+        for (const column of columns) {
+            const value = values[row][column];
+            if (isNotNullOrUndefined(value) && isNumeric(value)) {
+                sum += toNumber(value);
+            }
+        }
+    }
+    return sum;
+}
+function sortValueTargetIndexes(sort, otherSideHeaders, valueTitles) {
+    if (sort && sort.list) {
+        let valueIndex = valueTitles.findIndex(title => title === sort.list.valueTitle);
+        if (valueIndex === -1) {
+            if (valueTitles.length === 1) {
+                valueIndex = 0;
+            }
+            else {
+                return null;
+            }
+        }
+        let pivotHeader = null;
+        let currentOtherSideHeaders = otherSideHeaders;
+        for (const value of sort.list.values || []) {
+            if (value.isSummary) {
+                const indexes = getTargetIndexesForHeaders(currentOtherSideHeaders || []) || [];
+                return filterIndexesByMod(indexes, valueTitles.length, valueIndex);
+            }
+            pivotHeader = (currentOtherSideHeaders || []).find(header => header.title === value.title);
+            if (!pivotHeader) {
+                break;
+            }
+            currentOtherSideHeaders = pivotHeader.children || [];
+        }
+        if (pivotHeader) {
+            const targetIndexes = isNotNullOrUndefined(pivotHeader.targetIndex)
+                ? [pivotHeader.targetIndex]
+                : getTargetIndexesForHeaders(currentOtherSideHeaders);
+            return filterIndexesByMod(targetIndexes, valueTitles.length, valueIndex);
+        }
+    }
+    return null;
+}
+function filterIndexesByMod(indexes, mod, value) {
+    return (indexes || []).filter(index => index % mod === value);
+}
+function divideValues(value, divider) {
+    if (isNullOrUndefined(value)) {
+        return null;
+    }
+    if (isNumeric(value) && isNumeric(divider)) {
+        if (divider !== 0) {
+            return value / divider;
+        }
+        else {
+            return 0;
+        }
+    }
+    return null;
+}
+
+class LmrEmptyTablesTemplateDirective {
+    template;
+    constructor(template) {
+        this.template = template;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LmrEmptyTablesTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: LmrEmptyTablesTemplateDirective, selector: "[lmr-empty-tables-tmp]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LmrEmptyTablesTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[lmr-empty-tables-tmp]' }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });
+class LmrTableCellTemplateDirective {
+    template;
+    constructor(template) {
+        this.template = template;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LmrTableCellTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: LmrTableCellTemplateDirective, selector: "[lmr-table-cell-tmp]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LmrTableCellTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[lmr-table-cell-tmp]' }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });
+
+/*
+ * Lumeer: Modern Data Definition and Processing Platform
+ *
+ * Copyright (C) since 2017 Lumeer.io, s.r.o. and/or its affiliates.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+class PivotDataEmptyPipe {
+    transform(value) {
+        let anythingToDisplay = false;
+        value?.data?.forEach(d => {
+            anythingToDisplay = anythingToDisplay || d.columnHeaders?.length > 0 || d.rowHeaders?.length > 0;
+        });
+        return !anythingToDisplay;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PivotDataEmptyPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: PivotDataEmptyPipe, name: "pivotDataEmpty" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PivotDataEmptyPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'pivotDataEmpty',
+                }]
+        }] });
+
+/*
+ * Lumeer: Modern Data Definition and Processing Platform
+ *
+ * Copyright (C) since 2017 Lumeer.io, s.r.o. and/or its affiliates.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+class PivotTableCellHasValuePipe {
+    transform(cell) {
+        return isNotNullOrUndefined(cell.value) && String(cell.value).trim() !== '';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PivotTableCellHasValuePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: PivotTableCellHasValuePipe, name: "pivotTableCellHasValue" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PivotTableCellHasValuePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'pivotTableCellHasValue',
+                }]
+        }] });
+
+/*
+ * Lumeer: Modern Data Definition and Processing Platform
+ *
+ * Copyright (C) since 2017 Lumeer.io, s.r.o. and/or its affiliates.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+class ContrastColorPipe {
+    transform(color, returnCodes, opacity) {
+        return contrastColor(color, returnCodes, opacity);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ContrastColorPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: ContrastColorPipe, name: "contrastColor" });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ContrastColorPipe, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ContrastColorPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'contrastColor',
+                }]
+        }, {
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class LmrPivotTableComponent {
+    collections;
+    data;
+    linkTypes;
+    query;
+    constraintData;
+    config;
+    transform;
+    strings;
+    cellClick = new EventEmitter();
+    pivotDataChange = new EventEmitter();
+    emptyTablesTemplate;
+    tableCellTemplate;
+    pivotTransformer = new PivotDataConverter();
+    pivotTableConverter = new PivotTableConverter();
+    dataSubject = new BehaviorSubject(null);
+    pivotData$;
+    pivotTables$;
+    ngOnInit() {
+        const observable = this.dataSubject.pipe(filter(data => !!data));
+        this.pivotData$ = observable.pipe(throttleTime(200, asyncScheduler, { trailing: true, leading: true }), map(data => this.handleData(data)), tap(data => this.pivotDataChange.emit(data)));
+        this.pivotTables$ = this.pivotData$.pipe(map(data => this.pivotTableConverter.createTables(data, this.strings)));
+    }
+    handleData(data) {
+        return this.pivotTransformer.createData(data.config, data.transform, data.collections, data.linkTypes, data.data, data.query, data.constraintData);
+    }
+    ngOnChanges(changes) {
+        this.dataSubject.next({
+            config: this.config,
+            transform: this.transform,
+            collections: this.collections,
+            linkTypes: this.linkTypes,
+            data: this.data,
+            query: this.query,
+            constraintData: this.constraintData,
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LmrPivotTableComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: LmrPivotTableComponent, selector: "lmr-pivot-table", inputs: { collections: "collections", data: "data", linkTypes: "linkTypes", query: "query", constraintData: "constraintData", config: "config", transform: "transform", strings: "strings" }, outputs: { cellClick: "cellClick", pivotDataChange: "pivotDataChange" }, queries: [{ propertyName: "emptyTablesTemplate", first: true, predicate: LmrEmptyTablesTemplateDirective, descendants: true, read: TemplateRef }, { propertyName: "tableCellTemplate", first: true, predicate: LmrTableCellTemplateDirective, descendants: true, read: TemplateRef }], usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"{pivotTables: pivotTables$ | async, pivotData: pivotData$ | async} as data\">\n  <ng-container *ngIf=\"data.pivotTables?.length && !(data.pivotData | pivotDataEmpty)\">\n    <table *ngFor=\"let pivotTable of data.pivotTables; let first\"\n           class=\"table table-without-padding table-borderless table-md\"\n           [class.mt-4]=\"!first\">\n      <tr *ngFor=\"let rowCells of pivotTable.cells; let rowIndex = index\">\n\n        <ng-container *ngFor=\"let cell of rowCells; let cellIndex = index\">\n          <td *ngIf=\"cell && {hasValue: cell | pivotTableCellHasValue} as cellData\"\n              class=\"cell {{cell.constraint ? (cell.constraint.type | lowercase) : ''}} text-truncate\"\n              [style.max-width.px]=\"300\"\n              [class.sticky-start]=\"cell.stickyStart\"\n              [class.sticky-top]=\"cell.stickyTop\"\n              [rowSpan]=\"cell.rowSpan\"\n              [colSpan]=\"cell.colSpan\"\n              [style.top.px]=\"cell.stickyTop ? (rowIndex * 40) : undefined\"\n              [style.left.px]=\"cell.stickyStart ? (cellIndex * 150) : undefined\"\n              [ngClass]=\"cell.cssClass\"\n              [style.background]=\"cell.background\"\n              [style.color]=\"cell.background && (cell.background | contrastColor)\">\n            <ng-container *ngIf=\"cell.summary\">\n              <div class=\"d-flex align-items-center h-100\">\n                <span class=\"summary\" [class.me-2]=\"cellData.hasValue\">{{cell.summary}}</span>\n                <ng-container *ngIf=\"cellData.hasValue\">\n                  <ng-template #defaultTableCellTemplate>\n                  <span class=\"flex-grow-1 h-100 text-truncate d-inline-block\">\n                    {{ cell.value }}\n                  </span>\n                  </ng-template>\n\n                  <ng-template\n                    [ngTemplateOutlet]=\"tableCellTemplate || defaultTableCellTemplate\"\n                    [ngTemplateOutletContext]=\"{ value: cell.value, cell: cell }\">\n                  </ng-template>\n                </ng-container>\n              </div>\n            </ng-container>\n            <ng-container *ngIf=\"!cell.summary\">\n              <ng-container *ngIf=\"cellData.hasValue\">\n                <ng-template #defaultTableCellTemplate>\n                  <span class=\"d-inline-block\">\n                    {{ cell.value }}\n                  </span>\n                </ng-template>\n\n                <ng-template\n                  [ngTemplateOutlet]=\"tableCellTemplate || defaultTableCellTemplate\"\n                  [ngTemplateOutletContext]=\"{ value: cell.value, cell: cell }\">\n                </ng-template>\n              </ng-container>\n              <ng-container *ngIf=\"!cellData.hasValue\">&nbsp;</ng-container>\n            </ng-container>\n          </td>\n        </ng-container>\n      </tr>\n    </table>\n  </ng-container>\n\n  <ng-container *ngIf=\"!data.pivotTables?.length || (data.pivotData | pivotDataEmpty)\">\n    <ng-template #defaultEmptyTablesTemplate>\n      <div>&nbsp;</div>\n    </ng-template>\n\n    <ng-template\n      [ngTemplateOutlet]=\"emptyTablesTemplate || defaultEmptyTablesTemplate\"\n      [ngTemplateOutletContext]=\"{  }\">\n    </ng-template>\n  </ng-container>\n</ng-container>\n", styles: [".table{border-spacing:0;border-collapse:separate}.pivot-data-cell,.pivot-data-group-cell{text-align:right}.pivot-column-header-cell,.pivot-row-header-cell,.pivot-data-group-cell,.pivot-row-group-header-cell,.pivot-column-group-header-cell{font-weight:700;border:1px #f8f9fa solid}.pivot-row-header-cell.sticky-start,.pivot-row-group-header-cell.sticky-start,.pivot-empty-cell.sticky-start{position:sticky;width:150px;min-width:150px;max-width:150px!important;z-index:9}.pivot-column-header-cell.sticky-top,.pivot-column-group-header-cell.sticky-top,.pivot-empty-cell.sticky-top{position:sticky;z-index:10}.pivot-empty-cell{background:white;border:1px white solid}.pivot-empty-cell.sticky-top{z-index:11}.cell.color{padding:0!important;height:30px}.cell.color .summary{padding-left:.5rem}\n"], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "pipe", type: i1.LowerCasePipe, name: "lowercase" }, { kind: "pipe", type: PivotDataEmptyPipe, name: "pivotDataEmpty" }, { kind: "pipe", type: PivotTableCellHasValuePipe, name: "pivotTableCellHasValue" }, { kind: "pipe", type: ContrastColorPipe, name: "contrastColor" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LmrPivotTableComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lmr-pivot-table', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngIf=\"{pivotTables: pivotTables$ | async, pivotData: pivotData$ | async} as data\">\n  <ng-container *ngIf=\"data.pivotTables?.length && !(data.pivotData | pivotDataEmpty)\">\n    <table *ngFor=\"let pivotTable of data.pivotTables; let first\"\n           class=\"table table-without-padding table-borderless table-md\"\n           [class.mt-4]=\"!first\">\n      <tr *ngFor=\"let rowCells of pivotTable.cells; let rowIndex = index\">\n\n        <ng-container *ngFor=\"let cell of rowCells; let cellIndex = index\">\n          <td *ngIf=\"cell && {hasValue: cell | pivotTableCellHasValue} as cellData\"\n              class=\"cell {{cell.constraint ? (cell.constraint.type | lowercase) : ''}} text-truncate\"\n              [style.max-width.px]=\"300\"\n              [class.sticky-start]=\"cell.stickyStart\"\n              [class.sticky-top]=\"cell.stickyTop\"\n              [rowSpan]=\"cell.rowSpan\"\n              [colSpan]=\"cell.colSpan\"\n              [style.top.px]=\"cell.stickyTop ? (rowIndex * 40) : undefined\"\n              [style.left.px]=\"cell.stickyStart ? (cellIndex * 150) : undefined\"\n              [ngClass]=\"cell.cssClass\"\n              [style.background]=\"cell.background\"\n              [style.color]=\"cell.background && (cell.background | contrastColor)\">\n            <ng-container *ngIf=\"cell.summary\">\n              <div class=\"d-flex align-items-center h-100\">\n                <span class=\"summary\" [class.me-2]=\"cellData.hasValue\">{{cell.summary}}</span>\n                <ng-container *ngIf=\"cellData.hasValue\">\n                  <ng-template #defaultTableCellTemplate>\n                  <span class=\"flex-grow-1 h-100 text-truncate d-inline-block\">\n                    {{ cell.value }}\n                  </span>\n                  </ng-template>\n\n                  <ng-template\n                    [ngTemplateOutlet]=\"tableCellTemplate || defaultTableCellTemplate\"\n                    [ngTemplateOutletContext]=\"{ value: cell.value, cell: cell }\">\n                  </ng-template>\n                </ng-container>\n              </div>\n            </ng-container>\n            <ng-container *ngIf=\"!cell.summary\">\n              <ng-container *ngIf=\"cellData.hasValue\">\n                <ng-template #defaultTableCellTemplate>\n                  <span class=\"d-inline-block\">\n                    {{ cell.value }}\n                  </span>\n                </ng-template>\n\n                <ng-template\n                  [ngTemplateOutlet]=\"tableCellTemplate || defaultTableCellTemplate\"\n                  [ngTemplateOutletContext]=\"{ value: cell.value, cell: cell }\">\n                </ng-template>\n              </ng-container>\n              <ng-container *ngIf=\"!cellData.hasValue\">&nbsp;</ng-container>\n            </ng-container>\n          </td>\n        </ng-container>\n      </tr>\n    </table>\n  </ng-container>\n\n  <ng-container *ngIf=\"!data.pivotTables?.length || (data.pivotData | pivotDataEmpty)\">\n    <ng-template #defaultEmptyTablesTemplate>\n      <div>&nbsp;</div>\n    </ng-template>\n\n    <ng-template\n      [ngTemplateOutlet]=\"emptyTablesTemplate || defaultEmptyTablesTemplate\"\n      [ngTemplateOutletContext]=\"{  }\">\n    </ng-template>\n  </ng-container>\n</ng-container>\n", styles: [".table{border-spacing:0;border-collapse:separate}.pivot-data-cell,.pivot-data-group-cell{text-align:right}.pivot-column-header-cell,.pivot-row-header-cell,.pivot-data-group-cell,.pivot-row-group-header-cell,.pivot-column-group-header-cell{font-weight:700;border:1px #f8f9fa solid}.pivot-row-header-cell.sticky-start,.pivot-row-group-header-cell.sticky-start,.pivot-empty-cell.sticky-start{position:sticky;width:150px;min-width:150px;max-width:150px!important;z-index:9}.pivot-column-header-cell.sticky-top,.pivot-column-group-header-cell.sticky-top,.pivot-empty-cell.sticky-top{position:sticky;z-index:10}.pivot-empty-cell{background:white;border:1px white solid}.pivot-empty-cell.sticky-top{z-index:11}.cell.color{padding:0!important;height:30px}.cell.color .summary{padding-left:.5rem}\n"] }]
+        }], propDecorators: { collections: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], linkTypes: [{
+                type: Input
+            }], query: [{
+                type: Input
+            }], constraintData: [{
+                type: Input
+            }], config: [{
+                type: Input
+            }], transform: [{
+                type: Input
+            }], strings: [{
+                type: Input
+            }], cellClick: [{
+                type: Output
+            }], pivotDataChange: [{
+                type: Output
+            }], emptyTablesTemplate: [{
+                type: ContentChild,
+                args: [LmrEmptyTablesTemplateDirective, { read: TemplateRef }]
+            }], tableCellTemplate: [{
+                type: ContentChild,
+                args: [LmrTableCellTemplateDirective, { read: TemplateRef }]
+            }] } });
+
+class LmrPivotTableModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LmrPivotTableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: LmrPivotTableModule, declarations: [LmrPivotTableComponent,
+            PivotDataEmptyPipe,
+            PivotTableCellHasValuePipe,
+            ContrastColorPipe,
+            LmrEmptyTablesTemplateDirective,
+            LmrTableCellTemplateDirective], imports: [CommonModule], exports: [LmrPivotTableComponent,
+            LmrEmptyTablesTemplateDirective,
+            LmrTableCellTemplateDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LmrPivotTableModule, imports: [CommonModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LmrPivotTableModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        LmrPivotTableComponent,
+                        PivotDataEmptyPipe,
+                        PivotTableCellHasValuePipe,
+                        ContrastColorPipe,
+                        LmrEmptyTablesTemplateDirective,
+                        LmrTableCellTemplateDirective,
+                    ],
+                    imports: [
+                        CommonModule,
+                    ],
+                    exports: [
+                        LmrPivotTableComponent,
+                        LmrEmptyTablesTemplateDirective,
+                        LmrTableCellTemplateDirective,
+                    ]
+                }]
+        }] });
+
+/*
+ * Public API Surface of lmr-pivot-table
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { LmrEmptyTablesTemplateDirective, LmrPivotConfigVersion, LmrPivotTableComponent, LmrPivotTableModule, LmrPivotValueType, LmrTableCellTemplateDirective, contrastColor, createDefaultPivotConfig, createDefaultPivotStemConfig, isPivotConfigChanged, pivotAttributesAreSame, pivotConfigIsEmpty, pivotStemConfigIsEmpty };
+//# sourceMappingURL=lumeer-pivot.mjs.map