@agorapulse/ui-charts 2.5.0 → 13.0.2

package/agorapulse-ui-charts.d.ts

@@ -1,4 +1,5 @@
 /**
  * Generated bundle index. Do not edit.
  */
+/// <amd-module name="@agorapulse/ui-charts" />
 export * from './index';

package/esm2020/src/lib/agorapulse-ui-charts.module.mjs

@@ -0,0 +1,60 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { MatListModule } from '@angular/material/list';
+import { HighchartsChartModule } from 'highcharts-angular';
+import { ChartBarComponent } from './chart-bar/chart-bar.component';
+import { ChartColumnComponent } from './chart-column/chart-column.component';
+import { ChartMetricsListComponent } from './chart-metrics-list/chart-metrics-list.component';
+import { ChartHeatmapComponent } from './chart-heatmap/chart-heatmap.component';
+import { ChartSplineComponent } from './chart-spline/chart-spline.component';
+import { ChartPieComponent } from './chart-pie/chart-pie.component';
+import * as i0 from "@angular/core";
+export class AgorapulseUiChartsModule {
+}
+/** @nocollapse */ /** @nocollapse */ AgorapulseUiChartsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: AgorapulseUiChartsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ /** @nocollapse */ AgorapulseUiChartsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: AgorapulseUiChartsModule, declarations: [ChartBarComponent,
+        ChartColumnComponent,
+        ChartHeatmapComponent,
+        ChartMetricsListComponent,
+        ChartSplineComponent,
+        ChartPieComponent], imports: [CommonModule,
+        HighchartsChartModule,
+        MatListModule], exports: [ChartBarComponent,
+        ChartColumnComponent,
+        ChartHeatmapComponent,
+        ChartMetricsListComponent,
+        ChartSplineComponent,
+        ChartPieComponent] });
+/** @nocollapse */ /** @nocollapse */ AgorapulseUiChartsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: AgorapulseUiChartsModule, providers: [], imports: [[
+            CommonModule,
+            HighchartsChartModule,
+            MatListModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: AgorapulseUiChartsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        ChartBarComponent,
+                        ChartColumnComponent,
+                        ChartHeatmapComponent,
+                        ChartMetricsListComponent,
+                        ChartSplineComponent,
+                        ChartPieComponent
+                    ],
+                    imports: [
+                        CommonModule,
+                        HighchartsChartModule,
+                        MatListModule
+                    ],
+                    exports: [
+                        ChartBarComponent,
+                        ChartColumnComponent,
+                        ChartHeatmapComponent,
+                        ChartMetricsListComponent,
+                        ChartSplineComponent,
+                        ChartPieComponent
+                    ],
+                    providers: []
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/lib/chart-bar/chart-bar-options.model.mjs

@@ -0,0 +1,80 @@
+import { ChartOptions, mergeDeep } from '../chart-options';
+export class ChartBarOptions extends ChartOptions {
+    static build(options) {
+        const seriesOptions = {
+            borderRadiusTopLeft: 100,
+            borderRadiusTopRight: 100,
+            borderWidth: 0
+        };
+        const defaultColumnOptions = {
+            chart: {
+                type: 'bar'
+            },
+            xAxis: {
+                categories: undefined,
+                gridLineWidth: 0,
+                lineWidth: 0,
+                reversed: false,
+                tickWidth: 0,
+                labels: {
+                    align: 'center',
+                    formatter() {
+                        if (this.value && this.value.toString().length > 16) {
+                            return this.value.toString().substring(0, 15) + '...';
+                        }
+                        return this.value.toString();
+                    },
+                    style: {
+                        width: 100
+                    }
+                },
+                type: 'category'
+            },
+            yAxis: {
+                type: 'linear',
+                minTickInterval: 1
+            },
+            plotOptions: {
+                bar: {
+                    maxPointWidth: 18,
+                    pointWidth: 20
+                },
+                series: seriesOptions
+            }
+        };
+        return super.build(mergeDeep(defaultColumnOptions, options));
+    }
+    static configureBar(series, categories, options, opposite, color, labelDateFormat) {
+        ChartOptions.configure(series, options, color, labelDateFormat);
+        if (categories && categories.length) {
+            options.xAxis.categories = categories;
+        }
+        if (opposite && series.length === 2) {
+            const negativeSerie = series[0];
+            negativeSerie.borderRadiusBottomLeft = 100;
+            negativeSerie.borderRadiusBottomRight = 100;
+            negativeSerie.borderRadiusTopLeft = 0;
+            negativeSerie.borderRadiusTopRight = 0;
+            negativeSerie.data = negativeSerie.data.map((point) => {
+                if (point && isNaN(point)) {
+                    return {
+                        ...point,
+                        y: -Math.abs(point.y)
+                    };
+                }
+                else if (!isNaN(point)) {
+                    return -Math.abs(point);
+                }
+                return point;
+            });
+            options.plotOptions.series.stacking = 'normal';
+            options.yAxis.labels.formatter = function () {
+                return Math.abs(+this.value) + '%';
+            };
+            options.tooltip.pointFormatter = function () {
+                return `<div style="font-size: 14px; color: #344563; margin: 6px 8px 0 8px;"><span style="color:${this.color};">\u25CF</span> ${this.series.name}: <b>${Math.abs(this.y) + '%'}</b></div>`;
+            };
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart-bar-options.model.js","sourceRoot":"","sources":["../../../../../../libs/ui-charts/src/lib/chart-bar/chart-bar-options.model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAE,SAAS,EAAC,MAAM,kBAAkB,CAAC;AAKzD,MAAM,OAAO,eAAgB,SAAQ,YAAY;IAE7C,MAAM,CAAC,KAAK,CAAC,OAAgB;QACzB,MAAM,aAAa,GAA6B;YAC5C,mBAAmB,EAAE,GAAG;YACxB,oBAAoB,EAAE,GAAG;YACzB,WAAW,EAAE,CAAC;SACjB,CAAC;QACF,MAAM,oBAAoB,GAAY;YAClC,KAAK,EAAE;gBACH,IAAI,EAAE,KAAK;aACd;YACD,KAAK,EAAE;gBACH,UAAU,EAAE,SAAS;gBACrB,aAAa,EAAE,CAAC;gBAChB,SAAS,EAAE,CAAC;gBACZ,QAAQ,EAAE,KAAK;gBACf,SAAS,EAAE,CAAC;gBACZ,MAAM,EAAE;oBACJ,KAAK,EAAE,QAAQ;oBACf,SAAS;wBACL,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,MAAM,GAAG,EAAE,EAAE;4BACjD,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,KAAK,CAAC;yBACzD;wBACD,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;oBACjC,CAAC;oBACD,KAAK,EAAE;wBACH,KAAK,EAAE,GAAG;qBACb;iBACJ;gBACD,IAAI,EAAE,UAAU;aACnB;YACD,KAAK,EAAE;gBACH,IAAI,EAAE,QAAQ;gBACd,eAAe,EAAE,CAAC;aACrB;YACD,WAAW,EAAE;gBACT,GAAG,EAAE;oBACD,aAAa,EAAE,EAAE;oBACjB,UAAU,EAAE,EAAE;iBACjB;gBACD,MAAM,EAAE,aAAa;aACxB;SACJ,CAAC;QACF,OAAO,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,oBAAoB,EAAE,OAAO,CAAC,CAAC,CAAC;IACjE,CAAC;IAED,MAAM,CAAC,YAAY,CAAC,MAA0B,EAC1B,UAAoB,EACpB,OAAgB,EAChB,QAAiB,EACjB,KAAiB,EACjB,eAAwB;QACxC,YAAY,CAAC,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC;QAChE,IAAI,UAAU,IAAI,UAAU,CAAC,MAAM,EAAE;YAChC,OAAO,CAAC,KAAsB,CAAC,UAAU,GAAG,UAAU,CAAC;SAC3D;QACD,IAAI,QAAQ,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;YACjC,MAAM,aAAa,GAAI,MAAM,CAAC,CAAC,CAA6B,CAAC;YAC7D,aAAa,CAAC,sBAAsB,GAAG,GAAG,CAAC;YAC3C,aAAa,CAAC,uBAAuB,GAAG,GAAG,CAAC;YAC5C,aAAa,CAAC,mBAAmB,GAAG,CAAC,CAAC;YACtC,aAAa,CAAC,oBAAoB,GAAG,CAAC,CAAC;YACvC,aAAa,CAAC,IAAI,GAAG,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,KAAU,EAAE,EAAE;gBACvD,IAAI,KAAK,IAAI,KAAK,CAAC,KAAK,CAAC,EAAE;oBACvB,OAAO;wBACH,GAAG,KAAK;wBACR,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;qBACxB,CAAC;iBACL;qBAAM,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;oBACtB,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;iBAC3B;gBACD,OAAO,KAAK,CAAC;YACjB,CAAC,CAAC,CAAC;YACH,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,QAAQ,GAAG,QAAQ,CAAC;YAC9C,OAAO,CAAC,KAAsB,CAAC,MAAM,CAAC,SAAS,GAAG;gBAC/C,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC;YACvC,CAAC,CAAC;YACF,OAAO,CAAC,OAAO,CAAC,cAAc,GAAG;gBAC7B,OAAO,2FAA2F,IAAI,CAAC,KAAK,oBAAoB,IAAI,CAAC,MAAM,CAAC,IAAI,QAAQ,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,GAAG,YAAY,CAAC;YAC/L,CAAC,CAAC;SACL;IACL,CAAC;CACJ","sourcesContent":["import {ChartOptions, mergeDeep} from '../chart-options';\nimport {Options, SeriesBarOptions, XAxisOptions, YAxisOptions} from 'highcharts';\nimport {PlotRoundedSeriesOptions, SeriesRoundedBarOptions} from './../highchart-series.model';\nimport {ChartColor} from './../chart-colors';\n\nexport class ChartBarOptions extends ChartOptions {\n\n    static build(options: Options): Options {\n        const seriesOptions: PlotRoundedSeriesOptions = {\n            borderRadiusTopLeft: 100,\n            borderRadiusTopRight: 100,\n            borderWidth: 0\n        };\n        const defaultColumnOptions: Options = {\n            chart: {\n                type: 'bar'\n            },\n            xAxis: {\n                categories: undefined,\n                gridLineWidth: 0,\n                lineWidth: 0,\n                reversed: false,\n                tickWidth: 0,\n                labels: {\n                    align: 'center',\n                    formatter(): string {\n                        if (this.value && this.value.toString().length > 16) {\n                            return this.value.toString().substring(0, 15) + '...';\n                        }\n                        return this.value.toString();\n                    },\n                    style: {\n                        width: 100\n                    }\n                },\n                type: 'category'\n            },\n            yAxis: {\n                type: 'linear',\n                minTickInterval: 1\n            },\n            plotOptions: {\n                bar: {\n                    maxPointWidth: 18,\n                    pointWidth: 20\n                },\n                series: seriesOptions\n            }\n        };\n        return super.build(mergeDeep(defaultColumnOptions, options));\n    }\n\n    static configureBar(series: SeriesBarOptions[],\n                        categories: string[],\n                        options: Options,\n                        opposite: boolean,\n                        color: ChartColor,\n                        labelDateFormat?: string): void {\n        ChartOptions.configure(series, options, color, labelDateFormat);\n        if (categories && categories.length) {\n            (options.xAxis as XAxisOptions).categories = categories;\n        }\n        if (opposite && series.length === 2) {\n            const negativeSerie = (series[0] as SeriesRoundedBarOptions);\n            negativeSerie.borderRadiusBottomLeft = 100;\n            negativeSerie.borderRadiusBottomRight = 100;\n            negativeSerie.borderRadiusTopLeft = 0;\n            negativeSerie.borderRadiusTopRight = 0;\n            negativeSerie.data = negativeSerie.data.map((point: any) => {\n                if (point && isNaN(point)) {\n                    return {\n                        ...point,\n                        y: -Math.abs(point.y)\n                    };\n                } else if (!isNaN(point)) {\n                    return -Math.abs(point);\n                }\n                return point;\n            });\n            options.plotOptions.series.stacking = 'normal';\n            (options.yAxis as YAxisOptions).labels.formatter = function(): string {\n                return Math.abs(+this.value) + '%';\n            };\n            options.tooltip.pointFormatter = function(): string {\n                return `<div style=\"font-size: 14px; color: #344563; margin: 6px 8px 0 8px;\"><span style=\"color:${this.color};\">\\u25CF</span> ${this.series.name}: <b>${Math.abs(this.y) + '%'}</b></div>`;\n            };\n        }\n    }\n}\n"]}

package/esm2020/src/lib/chart-bar/chart-bar.component.mjs

@@ -0,0 +1,58 @@
+import { Component, Input, ViewChild } from '@angular/core';
+import { Chart } from 'highcharts';
+import { ChartBarOptions } from './chart-bar-options.model';
+import { ChartColor } from '../chart-colors';
+import * as i0 from "@angular/core";
+export class ChartBarComponent {
+    constructor() {
+        this.categories = [];
+        this.chartOptions = {}; // https://api.highcharts.com/highcharts/
+        this.color = ChartColor.ElectricBlue;
+        this.lastWidth = 0;
+    }
+    ngOnChanges(changes) {
+        if ((changes.series && !changes.series.firstChange) || (changes.color && !changes.color.firstChange)) {
+            this.initChart();
+        }
+    }
+    ngAfterViewChecked() {
+        if (this.chartRef && this.chartRef.nativeElement.clientWidth != this.lastWidth) {
+            this.lastWidth = this.chartRef.nativeElement.clientWidth;
+            if (this.chart) {
+                this.chart.reflow();
+            }
+            else if (this.series && this.series.length) {
+                this.initChart();
+            }
+        }
+    }
+    initChart() {
+        if (this.series) {
+            const chartOptions = ChartBarOptions.build(this.chartOptions);
+            ChartBarOptions.configureBar(this.series, this.categories, chartOptions, this.opposite, this.color, this.labelDateFormat);
+            this.chart = new Chart(this.chartRef.nativeElement, chartOptions);
+        }
+    }
+}
+/** @nocollapse */ /** @nocollapse */ ChartBarComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ChartBarComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ /** @nocollapse */ ChartBarComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: ChartBarComponent, selector: "ap-chart-bar", inputs: { categories: "categories", chartOptions: "chartOptions", color: "color", labelDateFormat: "labelDateFormat", opposite: "opposite", series: "series" }, viewQueries: [{ propertyName: "chartRef", first: true, predicate: ["chart"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div #chart></div>\n" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ChartBarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ap-chart-bar', template: "<div #chart></div>\n" }]
+        }], propDecorators: { chartRef: [{
+                type: ViewChild,
+                args: ['chart']
+            }], categories: [{
+                type: Input
+            }], chartOptions: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], labelDateFormat: [{
+                type: Input
+            }], opposite: [{
+                type: Input
+            }], series: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/lib/chart-column/chart-column-options.model.mjs

@@ -0,0 +1,104 @@
+import { ChartOptions, mergeDeep } from '../chart-options';
+import { dateFormat } from 'highcharts';
+export class ChartColumnOptions extends ChartOptions {
+    static buildColumn(options, simple) {
+        const defaultColumnOptions = {
+            chart: {
+                type: 'column'
+            },
+            legend: {
+                symbolHeight: 10
+            },
+            plotOptions: {
+                column: {
+                    stacking: 'normal',
+                    borderWidth: 0,
+                    maxPointWidth: 20,
+                    events: {
+                        hide() {
+                            ChartColumnOptions.redrawWithRoundedColumns(this.chart);
+                        },
+                        show() {
+                            ChartColumnOptions.redrawWithRoundedColumns(this.chart);
+                        }
+                    }
+                }
+            },
+            xAxis: {
+                type: 'datetime'
+            }
+        };
+        const simpleColumnOptions = {
+            chart: {
+                type: 'column',
+                height: '80px'
+            },
+            credits: {
+                enabled: false
+            },
+            plotOptions: {
+                column: {
+                    events: {
+                        hide() {
+                            ChartColumnOptions.redrawWithRoundedColumns(this.chart);
+                        },
+                        show() {
+                            ChartColumnOptions.redrawWithRoundedColumns(this.chart);
+                        }
+                    },
+                }
+            },
+            xAxis: {
+                type: 'datetime',
+                crosshair: true,
+                labels: {
+                    enabled: false,
+                    formatter() {
+                        return dateFormat('%m/%d', +this.value);
+                    }
+                },
+                lineWidth: 0,
+                tickWidth: 0,
+                gridLineWidth: 0
+            },
+            yAxis: {
+                min: 0,
+                labels: {
+                    enabled: false
+                },
+                gridLineWidth: 0
+            }
+        };
+        return super.build(mergeDeep(simple ? simpleColumnOptions : defaultColumnOptions, options));
+    }
+    static redrawWithRoundedColumns(chart) {
+        chart.series.map((serie, serieIndex, arr) => {
+            ChartColumnOptions.roundSerie(arr, serie.options, serieIndex);
+        });
+        chart.redraw(true);
+    }
+    static roundSerie(series, serie, serieIndex) {
+        const roundedOptionMap = [];
+        let borderRadius = 0;
+        if (serie.data) {
+            serie.data.forEach((point, columnIndex) => {
+                // Check if all previous stacked data at the same abscissa (located higher on the graph) are missing or have a value of 0
+                // if so, it means that this point is the visual top of the column, so we should round it
+                const roundedColumnEnabled = series.slice(0, serieIndex)
+                    .every(otherSerie => {
+                    if (otherSerie.visible === false) {
+                        return true;
+                    }
+                    const pointAtSameAbscissa = otherSerie.options
+                        .data.find(otherPoint => otherPoint[0] === point[0]);
+                    return !pointAtSameAbscissa || pointAtSameAbscissa[1] === 0;
+                });
+                borderRadius = roundedColumnEnabled ? 100 : 0;
+                roundedOptionMap[columnIndex] = borderRadius;
+            });
+            serie.borderRadiusTopLeft = roundedOptionMap;
+            serie.borderRadiusTopRight = roundedOptionMap;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart-column-options.model.js","sourceRoot":"","sources":["../../../../../../libs/ui-charts/src/lib/chart-column/chart-column-options.model.ts"],"names":[],"mappings":"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","sourcesContent":["import {ChartOptions, mergeDeep} from '../chart-options';\nimport {Chart, dateFormat, Options, Series} from 'highcharts';\nimport {SeriesRoundedColumnOptions} from '../highchart-series.model';\n\nexport class ChartColumnOptions extends ChartOptions {\n\n    static buildColumn(options: Options, simple: boolean): Options {\n        const defaultColumnOptions: Options = {\n            chart: {\n                type: 'column'\n            },\n            legend: {\n                symbolHeight: 10\n            },\n            plotOptions: {\n                column: {\n                    stacking: 'normal',\n                    borderWidth: 0,\n                    maxPointWidth: 20,\n                    events: {\n                        hide(): void {\n                            ChartColumnOptions.redrawWithRoundedColumns(this.chart);\n                        },\n                        show(): void {\n                            ChartColumnOptions.redrawWithRoundedColumns(this.chart);\n                        }\n                    }\n                }\n            },\n            xAxis: {\n                type: 'datetime'\n            }\n        };\n        const simpleColumnOptions: Options = {\n            chart: {\n                type: 'column',\n                height: '80px'\n            },\n            credits: {\n                enabled: false\n            },\n            plotOptions: {\n                column: {\n                    events: {\n                        hide(): void {\n                            ChartColumnOptions.redrawWithRoundedColumns(this.chart);\n                        },\n                        show(): void {\n                            ChartColumnOptions.redrawWithRoundedColumns(this.chart);\n                        }\n                    },\n                }\n            },\n            xAxis: {\n                type: 'datetime',\n                crosshair: true,\n                labels: {\n                    enabled: false,\n                    formatter(): string {\n                        return dateFormat('%m/%d', +this.value);\n                    }\n                },\n                lineWidth: 0,\n                tickWidth: 0,\n                gridLineWidth: 0\n            },\n            yAxis: {\n                min: 0,\n                labels: {\n                    enabled: false\n                },\n                gridLineWidth: 0\n            }\n        };\n        return super.build(mergeDeep(simple ? simpleColumnOptions : defaultColumnOptions, options));\n    }\n\n    static redrawWithRoundedColumns(chart: Chart): void {\n        chart.series.map((serie, serieIndex: number, arr) => {\n            ChartColumnOptions.roundSerie(arr, serie.options as SeriesRoundedColumnOptions, serieIndex);\n        });\n        chart.redraw(true);\n    }\n\n    static roundSerie(series: Series[], serie: SeriesRoundedColumnOptions, serieIndex: number): void {\n        const roundedOptionMap = [];\n        let borderRadius = 0;\n        if (serie.data) {\n            serie.data.forEach((point, columnIndex) => {\n                // Check if all previous stacked data at the same abscissa (located higher on the graph) are missing or have a value of 0\n                // if so, it means that this point is the visual top of the column, so we should round it\n                const roundedColumnEnabled = series.slice(0, serieIndex)\n                    .every(otherSerie => {\n                        if (otherSerie.visible === false) {\n                            return true;\n                        }\n                        const pointAtSameAbscissa = (otherSerie.options as SeriesRoundedColumnOptions)\n                            .data.find(otherPoint => otherPoint[0] === point[0]);\n                        return !pointAtSameAbscissa || pointAtSameAbscissa[1] === 0;\n                    });\n                borderRadius = roundedColumnEnabled ? 100 : 0;\n                roundedOptionMap[columnIndex] = borderRadius;\n            });\n            serie.borderRadiusTopLeft = roundedOptionMap;\n            serie.borderRadiusTopRight = roundedOptionMap;\n        }\n    }\n}\n"]}

package/esm2020/src/lib/chart-column/chart-column.component.mjs

@@ -0,0 +1,59 @@
+import { Component, Input, ViewChild } from '@angular/core';
+import { ChartColumnOptions } from './chart-column-options.model';
+import { ChartColor } from '../chart-colors';
+import { Chart } from 'highcharts';
+import * as i0 from "@angular/core";
+export class ChartColumnComponent {
+    constructor() {
+        this.chartOptions = {}; // https://api.highcharts.com/highcharts/
+        this.color = ChartColor.ElectricBlue;
+        this.simple = false;
+        this.lastWidth = 0;
+    }
+    ngOnChanges(changes) {
+        if ((changes.series && !changes.series.firstChange) || (changes.color && !changes.color.firstChange)) {
+            this.initChart();
+        }
+    }
+    ngAfterViewChecked() {
+        if (this.chartRef && this.chartRef.nativeElement.clientWidth != this.lastWidth) {
+            this.lastWidth = this.chartRef.nativeElement.clientWidth;
+            if (this.chart) {
+                this.chart.reflow();
+            }
+            else if (this.series && this.series.length) {
+                this.initChart();
+            }
+        }
+    }
+    initChart() {
+        if (this.series) {
+            const chartOptions = ChartColumnOptions.buildColumn(this.chartOptions, this.simple);
+            ChartColumnOptions.configure(this.series, chartOptions, this.color, this.labelDateFormat);
+            this.chart = new Chart(this.chartRef.nativeElement, chartOptions);
+            if (this.chart) {
+                ChartColumnOptions.redrawWithRoundedColumns(this.chart);
+            }
+        }
+    }
+}
+/** @nocollapse */ /** @nocollapse */ ChartColumnComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ChartColumnComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ /** @nocollapse */ ChartColumnComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: ChartColumnComponent, selector: "ap-chart-column", inputs: { chartOptions: "chartOptions", color: "color", labelDateFormat: "labelDateFormat", series: "series", simple: "simple" }, viewQueries: [{ propertyName: "chartRef", first: true, predicate: ["chart"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div #chart></div>\n" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ChartColumnComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ap-chart-column', template: "<div #chart></div>\n" }]
+        }], propDecorators: { chartRef: [{
+                type: ViewChild,
+                args: ['chart']
+            }], chartOptions: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], labelDateFormat: [{
+                type: Input
+            }], series: [{
+                type: Input
+            }], simple: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/lib/chart-heatmap/chart-heatmap.component.mjs

@@ -0,0 +1,55 @@
+import { Component, Input, ViewChild } from '@angular/core';
+import { mapChart } from 'highcharts/highmaps';
+import { ChartHeatmapOptions } from './chart-heatmap-options.model';
+import * as i0 from "@angular/core";
+export class ChartHeatmapComponent {
+    constructor() {
+        this.categoriesX = [];
+        this.categoriesY = [];
+        this.chartOptions = {}; // https://api.highcharts.com/highcharts/
+        this.lastWidth = 0;
+    }
+    ngOnChanges(changes) {
+        if ((changes.series && !changes.series.firstChange)) {
+            this.initChart();
+        }
+    }
+    ngAfterViewChecked() {
+        if (this.chartRef && this.chartRef.nativeElement.clientWidth != this.lastWidth) {
+            this.lastWidth = this.chartRef.nativeElement.clientWidth;
+            if (this.chart) {
+                this.chart.reflow();
+            }
+            else if (this.series && this.series.length) {
+                this.initChart();
+            }
+        }
+    }
+    initChart() {
+        if (this.series) {
+            const chartOptions = ChartHeatmapOptions.build(this.chartOptions);
+            ChartHeatmapOptions.configureHeatmap(this.categoriesX, this.categoriesY, this.series, chartOptions, this.labelDateFormat);
+            mapChart(this.chartRef.nativeElement, chartOptions);
+        }
+    }
+}
+/** @nocollapse */ /** @nocollapse */ ChartHeatmapComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ChartHeatmapComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ /** @nocollapse */ ChartHeatmapComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: ChartHeatmapComponent, selector: "ap-chart-heatmap", inputs: { categoriesX: "categoriesX", categoriesY: "categoriesY", chartOptions: "chartOptions", labelDateFormat: "labelDateFormat", series: "series" }, viewQueries: [{ propertyName: "chartRef", first: true, predicate: ["chart"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div #chart></div>\n" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ChartHeatmapComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ap-chart-heatmap', template: "<div #chart></div>\n" }]
+        }], propDecorators: { chartRef: [{
+                type: ViewChild,
+                args: ['chart']
+            }], categoriesX: [{
+                type: Input
+            }], categoriesY: [{
+                type: Input
+            }], chartOptions: [{
+                type: Input
+            }], labelDateFormat: [{
+                type: Input
+            }], series: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/lib/chart-metrics-list/chart-metrics-list.component.mjs

@@ -0,0 +1,23 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { ChartMetricType } from '../chart-metric';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/list";
+import * as i2 from "@angular/material/divider";
+import * as i3 from "@angular/common";
+export class ChartMetricsListComponent {
+    constructor() {
+        this.ChartMetricType = ChartMetricType;
+        this.digitsInfo = '1.0-1';
+    }
+}
+/** @nocollapse */ /** @nocollapse */ ChartMetricsListComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ChartMetricsListComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ /** @nocollapse */ ChartMetricsListComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: ChartMetricsListComponent, selector: "ap-chart-metrics-list", inputs: { metrics: "metrics", locale: "locale" }, ngImport: i0, template: "<mat-list>\n    <ng-container *ngIf=\"metrics\">\n        <mat-list-item *ngFor=\"let metric of metrics; let i = index\"\n                       [ngClass]=\"{'chart-metric-total': metric.type == ChartMetricType.total}\">\n            <div class=\"chart-metric-name metric-label\"\n                 *ngIf=\"!metric.children\">\n                {{metric.name}}\n            </div>\n            <div class=\"chart-metric-name\"\n                 *ngIf=\"metric.children\">\n                <span class=\"metric-label\">\n                    {{metric.name}}\n                </span>\n                <span class=\"chart-metric-children\">\n                    <span *ngFor=\"let item of metric.children\">\n                        <span class=\"child-label\">{{item.name}}</span>: <span class=\"child-value\">{{item.value}}</span>\n                    </span>\n                </span>\n            </div>\n            <div class=\"chart-metric-value metric-label\">\n                {{metric.value | number: digitsInfo: locale}}\n            </div>\n            <mat-divider *ngIf=\"i < metrics.length - 1\"></mat-divider>\n        </mat-list-item>\n    </ng-container>\n</mat-list>\n", styles: ["[color=facebook]{color:#1877f2}[bgcolor=facebook],[hcolor=facebook]:hover{background-color:#1877f2}[border=facebook]{border:1px solid #1877f2}[color=google]{color:#4e85e8}[bgcolor=google],[hcolor=google]:hover{background-color:#4e85e8}[border=google]{border:1px solid #4e85e8}[color=instagram]{color:#e1306c}[bgcolor=instagram],[hcolor=instagram]:hover{background-color:#e1306c}[border=instagram]{border:1px solid #e1306c}[color=instagrammagenta]{color:#c13584}[bgcolor=instagrammagenta],[hcolor=instagrammagenta]:hover{background-color:#c13584}[border=instagrammagenta]{border:1px solid #c13584}[color=instagramblue]{color:#5851db}[bgcolor=instagramblue],[hcolor=instagramblue]:hover{background-color:#5851db}[border=instagramblue]{border:1px solid #5851db}[color=instagrampurple]{color:#833ab4}[bgcolor=instagrampurple],[hcolor=instagrampurple]:hover{background-color:#833ab4}[border=instagrampurple]{border:1px solid #833ab4}[color=instagramorange]{color:#f56040}[bgcolor=instagramorange],[hcolor=instagramorange]:hover{background-color:#f56040}[border=instagramorange]{border:1px solid #f56040}[color=instagramyellow]{color:#ffdc80}[bgcolor=instagramyellow],[hcolor=instagramyellow]:hover{background-color:#ffdc80}[border=instagramyellow]{border:1px solid #ffdc80}[color=linkedin]{color:#2c67bc}[bgcolor=linkedin],[hcolor=linkedin]:hover{background-color:#2c67bc}[border=linkedin]{border:1px solid #2c67bc}[color=twitter]{color:#55acee}[bgcolor=twitter],[hcolor=twitter]:hover{background-color:#55acee}[border=twitter]{border:1px solid #55acee}[color=youtube]{color:red}[bgcolor=youtube],[hcolor=youtube]:hover{background-color:red}[border=youtube]{border:1px solid #ff0000}[color=blood-orange]{color:#ff4d00}[bgcolor=blood-orange],[hcolor=blood-orange]:hover{background-color:#ff4d00}[border=blood-orange]{border:1px solid #ff4d00}[color=pinkish-orange]{color:#ff7b49}[bgcolor=pinkish-orange],[hcolor=pinkish-orange]:hover{background-color:#ff7b49}[border=pinkish-orange]{border:1px solid #ff7b49}[color=charcoal-grey]{color:#2a2f34}[bgcolor=charcoal-grey],[hcolor=charcoal-grey]:hover{background-color:#2a2f34}[border=charcoal-grey]{border:1px solid #2a2f34}[color=azure]{color:#00aeef}[bgcolor=azure],[hcolor=azure]:hover{background-color:#00aeef}[border=azure]{border:1px solid #00aeef}[color=light-azure]{color:#eaf5fd}[bgcolor=light-azure],[hcolor=light-azure]:hover{background-color:#eaf5fd}[border=light-azure]{border:1px solid #eaf5fd}[color=blue-grey]{color:#8d98a9}[bgcolor=blue-grey],[hcolor=blue-grey]:hover{background-color:#8d98a9}[border=blue-grey]{border:1px solid #8d98a9}[color=silver]{color:#ced0da}[bgcolor=silver],[hcolor=silver]:hover{background-color:#ced0da}[border=silver]{border:1px solid #ced0da}[color=pale-grey]{color:#dfe3e9}[bgcolor=pale-grey],[hcolor=pale-grey]:hover{background-color:#dfe3e9}[border=pale-grey]{border:1px solid #dfe3e9}[color=grey-white]{color:#f5f7f8}[bgcolor=grey-white],[hcolor=grey-white]:hover{background-color:#f5f7f8}[border=grey-white]{border:1px solid #f5f7f8}[color=cool-grey]{color:#b4bbc6}[bgcolor=cool-grey],[hcolor=cool-grey]:hover{background-color:#b4bbc6}[border=cool-grey]{border:1px solid #b4bbc6}[color=black]{color:#344563}[bgcolor=black],[hcolor=black]:hover{background-color:#344563}[border=black]{border:1px solid #344563}[color=grey-blue]{color:#68768c}[bgcolor=grey-blue],[hcolor=grey-blue]:hover{background-color:#68768c}[border=grey-blue]{border:1px solid #68768c}[color=strawberry]{color:#f4282d}[bgcolor=strawberry],[hcolor=strawberry]:hover{background-color:#f4282d}[border=strawberry]{border:1px solid #f4282d}[color=light-strawberry]{color:#f8eded}[bgcolor=light-strawberry],[hcolor=light-strawberry]:hover{background-color:#f8eded}[border=light-strawberry]{border:1px solid #f8eded}[color=white]{color:#fff}[bgcolor=white],[hcolor=white]:hover{background-color:#fff}[border=white]{border:1px solid #ffffff}[color=cool-green]{color:#33c15d}[bgcolor=cool-green],[hcolor=cool-green]:hover{background-color:#33c15d}[border=cool-green]{border:1px solid #33c15d}[color=light-green]{color:#ebfaef}[bgcolor=light-green],[hcolor=light-green]:hover{background-color:#ebfaef}[border=light-green]{border:1px solid #ebfaef}[color=transparent]{color:transparent}[bgcolor=transparent],[hcolor=transparent]:hover{background-color:transparent}[border=transparent]{border:1px solid transparent}[color=c0]{color:#a566a5}[bgcolor=c0],[hcolor=c0]:hover{background-color:#a566a5}[border=c0]{border:1px solid #A566A5}[color=c1]{color:#c7ab82}[bgcolor=c1],[hcolor=c1]:hover{background-color:#c7ab82}[border=c1]{border:1px solid #C7AB82}[color=c2]{color:#f2713c}[bgcolor=c2],[hcolor=c2]:hover{background-color:#f2713c}[border=c2]{border:1px solid #F2713C}[color=c3]{color:#ffd006}[bgcolor=c3],[hcolor=c3]:hover{background-color:#ffd006}[border=c3]{border:1px solid #FFD006}[color=c4]{color:#94c5aa}[bgcolor=c4],[hcolor=c4]:hover{background-color:#94c5aa}[border=c4]{border:1px solid #94C5AA}[color=c5]{color:#2a9d8f}[bgcolor=c5],[hcolor=c5]:hover{background-color:#2a9d8f}[border=c5]{border:1px solid #2A9D8F}[color=c6]{color:#78acd8}[bgcolor=c6],[hcolor=c6]:hover{background-color:#78acd8}[border=c6]{border:1px solid #78ACD8}[color=c7]{color:#525a9e}[bgcolor=c7],[hcolor=c7]:hover{background-color:#525a9e}[border=c7]{border:1px solid #525A9E}[color=c8]{color:#6a2459}[bgcolor=c8],[hcolor=c8]:hover{background-color:#6a2459}[border=c8]{border:1px solid #6A2459}[color=c9]{color:#74729e}[bgcolor=c9],[hcolor=c9]:hover{background-color:#74729e}[border=c9]{border:1px solid #74729E}.metric-label{font-size:14px;color:#5d6a82}.chart-metric-total .metric-label{font-size:16px;color:#344563!important;font-weight:700}.chart-metric-name .chart-metric-children{color:#aeb5c1;font-size:14px}.chart-metric-name .chart-metric-children .child-label{margin-left:16px}.chart-metric-value{justify-content:left;flex:1 0 0;flex-direction:row;text-align:end;color:#344563}.mat-list-item{height:35px}.mat-list-item ::ng-deep .mat-list-item-content{padding:0}\n"], components: [{ type: i1.MatList, selector: "mat-list, mat-action-list", inputs: ["disableRipple", "disabled"], exportAs: ["matList"] }, { type: i1.MatListItem, selector: "mat-list-item, a[mat-list-item], button[mat-list-item]", inputs: ["disableRipple", "disabled"], exportAs: ["matListItem"] }, { type: i2.MatDivider, selector: "mat-divider", inputs: ["vertical", "inset"] }], directives: [{ type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], pipes: { "number": i3.DecimalPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ChartMetricsListComponent, decorators: [{
+            type: Component,
+            args: [{ changeDetection: ChangeDetectionStrategy.OnPush, selector: "ap-chart-metrics-list", template: "<mat-list>\n    <ng-container *ngIf=\"metrics\">\n        <mat-list-item *ngFor=\"let metric of metrics; let i = index\"\n                       [ngClass]=\"{'chart-metric-total': metric.type == ChartMetricType.total}\">\n            <div class=\"chart-metric-name metric-label\"\n                 *ngIf=\"!metric.children\">\n                {{metric.name}}\n            </div>\n            <div class=\"chart-metric-name\"\n                 *ngIf=\"metric.children\">\n                <span class=\"metric-label\">\n                    {{metric.name}}\n                </span>\n                <span class=\"chart-metric-children\">\n                    <span *ngFor=\"let item of metric.children\">\n                        <span class=\"child-label\">{{item.name}}</span>: <span class=\"child-value\">{{item.value}}</span>\n                    </span>\n                </span>\n            </div>\n            <div class=\"chart-metric-value metric-label\">\n                {{metric.value | number: digitsInfo: locale}}\n            </div>\n            <mat-divider *ngIf=\"i < metrics.length - 1\"></mat-divider>\n        </mat-list-item>\n    </ng-container>\n</mat-list>\n", styles: ["[color=facebook]{color:#1877f2}[bgcolor=facebook],[hcolor=facebook]:hover{background-color:#1877f2}[border=facebook]{border:1px solid #1877f2}[color=google]{color:#4e85e8}[bgcolor=google],[hcolor=google]:hover{background-color:#4e85e8}[border=google]{border:1px solid #4e85e8}[color=instagram]{color:#e1306c}[bgcolor=instagram],[hcolor=instagram]:hover{background-color:#e1306c}[border=instagram]{border:1px solid #e1306c}[color=instagrammagenta]{color:#c13584}[bgcolor=instagrammagenta],[hcolor=instagrammagenta]:hover{background-color:#c13584}[border=instagrammagenta]{border:1px solid #c13584}[color=instagramblue]{color:#5851db}[bgcolor=instagramblue],[hcolor=instagramblue]:hover{background-color:#5851db}[border=instagramblue]{border:1px solid #5851db}[color=instagrampurple]{color:#833ab4}[bgcolor=instagrampurple],[hcolor=instagrampurple]:hover{background-color:#833ab4}[border=instagrampurple]{border:1px solid #833ab4}[color=instagramorange]{color:#f56040}[bgcolor=instagramorange],[hcolor=instagramorange]:hover{background-color:#f56040}[border=instagramorange]{border:1px solid #f56040}[color=instagramyellow]{color:#ffdc80}[bgcolor=instagramyellow],[hcolor=instagramyellow]:hover{background-color:#ffdc80}[border=instagramyellow]{border:1px solid #ffdc80}[color=linkedin]{color:#2c67bc}[bgcolor=linkedin],[hcolor=linkedin]:hover{background-color:#2c67bc}[border=linkedin]{border:1px solid #2c67bc}[color=twitter]{color:#55acee}[bgcolor=twitter],[hcolor=twitter]:hover{background-color:#55acee}[border=twitter]{border:1px solid #55acee}[color=youtube]{color:red}[bgcolor=youtube],[hcolor=youtube]:hover{background-color:red}[border=youtube]{border:1px solid #ff0000}[color=blood-orange]{color:#ff4d00}[bgcolor=blood-orange],[hcolor=blood-orange]:hover{background-color:#ff4d00}[border=blood-orange]{border:1px solid #ff4d00}[color=pinkish-orange]{color:#ff7b49}[bgcolor=pinkish-orange],[hcolor=pinkish-orange]:hover{background-color:#ff7b49}[border=pinkish-orange]{border:1px solid #ff7b49}[color=charcoal-grey]{color:#2a2f34}[bgcolor=charcoal-grey],[hcolor=charcoal-grey]:hover{background-color:#2a2f34}[border=charcoal-grey]{border:1px solid #2a2f34}[color=azure]{color:#00aeef}[bgcolor=azure],[hcolor=azure]:hover{background-color:#00aeef}[border=azure]{border:1px solid #00aeef}[color=light-azure]{color:#eaf5fd}[bgcolor=light-azure],[hcolor=light-azure]:hover{background-color:#eaf5fd}[border=light-azure]{border:1px solid #eaf5fd}[color=blue-grey]{color:#8d98a9}[bgcolor=blue-grey],[hcolor=blue-grey]:hover{background-color:#8d98a9}[border=blue-grey]{border:1px solid #8d98a9}[color=silver]{color:#ced0da}[bgcolor=silver],[hcolor=silver]:hover{background-color:#ced0da}[border=silver]{border:1px solid #ced0da}[color=pale-grey]{color:#dfe3e9}[bgcolor=pale-grey],[hcolor=pale-grey]:hover{background-color:#dfe3e9}[border=pale-grey]{border:1px solid #dfe3e9}[color=grey-white]{color:#f5f7f8}[bgcolor=grey-white],[hcolor=grey-white]:hover{background-color:#f5f7f8}[border=grey-white]{border:1px solid #f5f7f8}[color=cool-grey]{color:#b4bbc6}[bgcolor=cool-grey],[hcolor=cool-grey]:hover{background-color:#b4bbc6}[border=cool-grey]{border:1px solid #b4bbc6}[color=black]{color:#344563}[bgcolor=black],[hcolor=black]:hover{background-color:#344563}[border=black]{border:1px solid #344563}[color=grey-blue]{color:#68768c}[bgcolor=grey-blue],[hcolor=grey-blue]:hover{background-color:#68768c}[border=grey-blue]{border:1px solid #68768c}[color=strawberry]{color:#f4282d}[bgcolor=strawberry],[hcolor=strawberry]:hover{background-color:#f4282d}[border=strawberry]{border:1px solid #f4282d}[color=light-strawberry]{color:#f8eded}[bgcolor=light-strawberry],[hcolor=light-strawberry]:hover{background-color:#f8eded}[border=light-strawberry]{border:1px solid #f8eded}[color=white]{color:#fff}[bgcolor=white],[hcolor=white]:hover{background-color:#fff}[border=white]{border:1px solid #ffffff}[color=cool-green]{color:#33c15d}[bgcolor=cool-green],[hcolor=cool-green]:hover{background-color:#33c15d}[border=cool-green]{border:1px solid #33c15d}[color=light-green]{color:#ebfaef}[bgcolor=light-green],[hcolor=light-green]:hover{background-color:#ebfaef}[border=light-green]{border:1px solid #ebfaef}[color=transparent]{color:transparent}[bgcolor=transparent],[hcolor=transparent]:hover{background-color:transparent}[border=transparent]{border:1px solid transparent}[color=c0]{color:#a566a5}[bgcolor=c0],[hcolor=c0]:hover{background-color:#a566a5}[border=c0]{border:1px solid #A566A5}[color=c1]{color:#c7ab82}[bgcolor=c1],[hcolor=c1]:hover{background-color:#c7ab82}[border=c1]{border:1px solid #C7AB82}[color=c2]{color:#f2713c}[bgcolor=c2],[hcolor=c2]:hover{background-color:#f2713c}[border=c2]{border:1px solid #F2713C}[color=c3]{color:#ffd006}[bgcolor=c3],[hcolor=c3]:hover{background-color:#ffd006}[border=c3]{border:1px solid #FFD006}[color=c4]{color:#94c5aa}[bgcolor=c4],[hcolor=c4]:hover{background-color:#94c5aa}[border=c4]{border:1px solid #94C5AA}[color=c5]{color:#2a9d8f}[bgcolor=c5],[hcolor=c5]:hover{background-color:#2a9d8f}[border=c5]{border:1px solid #2A9D8F}[color=c6]{color:#78acd8}[bgcolor=c6],[hcolor=c6]:hover{background-color:#78acd8}[border=c6]{border:1px solid #78ACD8}[color=c7]{color:#525a9e}[bgcolor=c7],[hcolor=c7]:hover{background-color:#525a9e}[border=c7]{border:1px solid #525A9E}[color=c8]{color:#6a2459}[bgcolor=c8],[hcolor=c8]:hover{background-color:#6a2459}[border=c8]{border:1px solid #6A2459}[color=c9]{color:#74729e}[bgcolor=c9],[hcolor=c9]:hover{background-color:#74729e}[border=c9]{border:1px solid #74729E}.metric-label{font-size:14px;color:#5d6a82}.chart-metric-total .metric-label{font-size:16px;color:#344563!important;font-weight:700}.chart-metric-name .chart-metric-children{color:#aeb5c1;font-size:14px}.chart-metric-name .chart-metric-children .child-label{margin-left:16px}.chart-metric-value{justify-content:left;flex:1 0 0;flex-direction:row;text-align:end;color:#344563}.mat-list-item{height:35px}.mat-list-item ::ng-deep .mat-list-item-content{padding:0}\n"] }]
+        }], propDecorators: { metrics: [{
+                type: Input
+            }], locale: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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