aril 1.1.73 → 1.1.74

package/esm2022/ui/charts/src/highCharts/column/column-chart.component.mjs

@@ -0,0 +1,117 @@
+import { Component, effect, input } from '@angular/core';
+import * as Highcharts from 'highcharts';
+import { HighchartsChartModule } from 'highcharts-angular';
+import * as i0 from "@angular/core";
+import * as i1 from "highcharts-angular";
+// Example Data
+// data = [
+// 	{ name: 'Kategori A', y: 200 },
+// 	{ name: 'Kategori B', y: 100 },
+// 	{ name: 'Kategori C', y: 500 },
+// 	{ name: 'Kategori D', y: 250 },
+// 	{ name: 'Kategori E', y: 400 },
+// ]
+export class ColumnHighChartComponent {
+    constructor() {
+        this.data = input.required();
+        this.title = input('');
+        this.categoriesTitle = input('');
+        this.valuesTitle = input('');
+        this.seriesName = input();
+        this.dateFormat = input();
+        this.width = input('460');
+        this.height = input('380');
+        this.series = input([]);
+        this.Highcharts = Highcharts;
+        this.chartOptions = {}; // Highcharts.Options
+        effect(() => {
+            if (this.data()) {
+                this.setChartOptions();
+            }
+        });
+    }
+    formatDate(name) {
+        const date = new Date(`${name.toString().slice(0, 4)}-${name.toString().slice(4, 6)}-${name.toString().slice(6, 8)}T` +
+            `${name.toString().slice(8, 10)}:${name.toString().slice(10, 12)}:${name.toString().slice(12, 14)}Z`);
+        switch (this.dateFormat()) {
+            case 'date':
+                return new Intl.DateTimeFormat('tr-TR', { day: '2-digit', month: 'long', year: 'numeric' }).format(date);
+            case 'month':
+                return new Intl.DateTimeFormat('tr-TR', { month: 'long', year: 'numeric' }).format(date).replace(' ', '/');
+            case 'year':
+                return new Intl.DateTimeFormat('tr-TR', { year: 'numeric' }).format(date);
+        }
+    }
+    setChartOptions() {
+        this.chartOptions = {
+            chart: {
+                type: 'column',
+                width: this.width(),
+                height: this.height()
+            },
+            title: {
+                text: this.title()
+            },
+            xAxis: {
+                categories: this.dateFormat() ?
+                    this.data().map((item) => this.formatDate(item.name))
+                    : this.data().map((item) => item.name),
+                title: {
+                    text: this.categoriesTitle()
+                }
+            },
+            yAxis: {
+                min: 0,
+                title: {
+                    text: this.valuesTitle()
+                }
+            },
+            tooltip: {
+                formatter: function () {
+                    return `
+						<strong>${this.point.category}</strong><br>
+						Değer: <b>${this.point.y.toLocaleString('tr-TR', {
+                        minimumFractionDigits: 2,
+                        maximumFractionDigits: 2
+                    })}</b>
+					`;
+                },
+                useHTML: true
+            },
+            series: this.series().length ?
+                this.series()
+                : [
+                    {
+                        name: this.seriesName(),
+                        data: this.data().map((item) => item.y)
+                    }
+                ],
+            legend: { enabled: this.seriesName() ? true : false },
+            credits: {
+                enabled: false
+            }
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ColumnHighChartComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "17.1.2", type: ColumnHighChartComponent, isStandalone: true, selector: "aril-column-highchart", inputs: { data: { classPropertyName: "data", publicName: "data", isSignal: true, isRequired: true, transformFunction: null }, title: { classPropertyName: "title", publicName: "title", isSignal: true, isRequired: false, transformFunction: null }, categoriesTitle: { classPropertyName: "categoriesTitle", publicName: "categoriesTitle", isSignal: true, isRequired: false, transformFunction: null }, valuesTitle: { classPropertyName: "valuesTitle", publicName: "valuesTitle", isSignal: true, isRequired: false, transformFunction: null }, seriesName: { classPropertyName: "seriesName", publicName: "seriesName", isSignal: true, isRequired: false, transformFunction: null }, dateFormat: { classPropertyName: "dateFormat", publicName: "dateFormat", isSignal: true, isRequired: false, transformFunction: null }, width: { classPropertyName: "width", publicName: "width", isSignal: true, isRequired: false, transformFunction: null }, height: { classPropertyName: "height", publicName: "height", isSignal: true, isRequired: false, transformFunction: null }, series: { classPropertyName: "series", publicName: "series", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: ` <highcharts-chart
+		style="width: 100%; display: block"
+		[Highcharts]="Highcharts"
+		[oneToOne]="true"
+		[options]="chartOptions">
+	</highcharts-chart>`, isInline: true, dependencies: [{ kind: "ngmodule", type: HighchartsChartModule }, { kind: "component", type: i1.HighchartsChartComponent, selector: "highcharts-chart", inputs: ["Highcharts", "constructorType", "callbackFunction", "oneToOne", "runOutsideAngular", "options", "update"], outputs: ["updateChange", "chartInstance"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ColumnHighChartComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    selector: 'aril-column-highchart',
+                    template: ` <highcharts-chart
+		style="width: 100%; display: block"
+		[Highcharts]="Highcharts"
+		[oneToOne]="true"
+		[options]="chartOptions">
+	</highcharts-chart>`,
+                    imports: [HighchartsChartModule]
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"column-chart.component.js","sourceRoot":"","sources":["../../../../../../../projects/aril/ui/charts/src/highCharts/column/column-chart.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, effect, input } from '@angular/core';\r\n\r\nimport * as Highcharts from 'highcharts';\r\nimport { HighchartsChartModule } from 'highcharts-angular';\r\n\r\ninterface dataItems {\r\n\tname: any;\r\n\ty: any;\r\n\tcolor?: string;\r\n\ttooltip?: string;\r\n\tselected?: boolean;\r\n}\r\n\r\n// Example Data\r\n// data = [\r\n// \t{ name: 'Kategori A', y: 200 },\r\n// \t{ name: 'Kategori B', y: 100 },\r\n// \t{ name: 'Kategori C', y: 500 },\r\n// \t{ name: 'Kategori D', y: 250 },\r\n// \t{ name: 'Kategori E', y: 400 },\r\n// ]\r\n\r\n@Component({\r\n\tstandalone: true,\r\n\tselector: 'aril-column-highchart',\r\n\ttemplate: ` <highcharts-chart\r\n\t\tstyle=\"width: 100%; display: block\"\r\n\t\t[Highcharts]=\"Highcharts\"\r\n\t\t[oneToOne]=\"true\"\r\n\t\t[options]=\"chartOptions\">\r\n\t</highcharts-chart>`,\r\n\r\n\timports: [HighchartsChartModule]\r\n})\r\nexport class ColumnHighChartComponent {\r\n\tconstructor() {\r\n\t\teffect(() => {\r\n\t\t\tif (this.data()) {\r\n\t\t\t\tthis.setChartOptions();\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\tdata = input.required<dataItems[]>();\r\n\ttitle = input<string>('');\r\n\tcategoriesTitle = input<string>('');\r\n\tvaluesTitle = input<string>('');\r\n\tseriesName = input<string>();\r\n\tdateFormat = input<string>();\r\n\twidth = input<string>('460');\r\n\theight = input<string>('380');\r\n\tseries = input<any>([]);\r\n\r\n\tHighcharts: typeof Highcharts = Highcharts;\r\n\tchartOptions: any = {}; // Highcharts.Options\r\n\r\n\tformatDate(name: any): any {\r\n\t\tconst date = new Date(\r\n\t\t\t`${name.toString().slice(0, 4)}-${name.toString().slice(4, 6)}-${name.toString().slice(6, 8)}T` +\r\n\t\t\t\t`${name.toString().slice(8, 10)}:${name.toString().slice(10, 12)}:${name.toString().slice(12, 14)}Z`\r\n\t\t);\r\n\r\n\t\tswitch (this.dateFormat()) {\r\n\t\t\tcase 'date':\r\n\t\t\t\treturn new Intl.DateTimeFormat('tr-TR', { day: '2-digit', month: 'long', year: 'numeric' }).format(date);\r\n\t\t\tcase 'month':\r\n\t\t\t\treturn new Intl.DateTimeFormat('tr-TR', { month: 'long', year: 'numeric' }).format(date).replace(' ', '/');\r\n\t\t\tcase 'year':\r\n\t\t\t\treturn new Intl.DateTimeFormat('tr-TR', { year: 'numeric' }).format(date);\r\n\t\t}\r\n\t}\r\n\r\n\tsetChartOptions() {\r\n\t\tthis.chartOptions = {\r\n\t\t\tchart: {\r\n\t\t\t\ttype: 'column',\r\n\t\t\t\twidth: this.width(),\r\n\t\t\t\theight: this.height()\r\n\t\t\t},\r\n\t\t\ttitle: {\r\n\t\t\t\ttext: this.title()\r\n\t\t\t},\r\n\t\t\txAxis: {\r\n\t\t\t\tcategories:\r\n\t\t\t\t\tthis.dateFormat() ?\r\n\t\t\t\t\t\tthis.data().map((item) => this.formatDate(item.name))\r\n\t\t\t\t\t:\tthis.data().map((item) => item.name),\r\n\t\t\t\ttitle: {\r\n\t\t\t\t\ttext: this.categoriesTitle()\r\n\t\t\t\t}\r\n\t\t\t},\r\n\t\t\tyAxis: {\r\n\t\t\t\tmin: 0,\r\n\t\t\t\ttitle: {\r\n\t\t\t\t\ttext: this.valuesTitle()\r\n\t\t\t\t}\r\n\t\t\t},\r\n\t\t\ttooltip: {\r\n\t\t\t\tformatter: function (this: any) {\r\n\t\t\t\t\treturn `\r\n\t\t\t\t\t\t<strong>${this.point.category}</strong><br>\r\n\t\t\t\t\t\tDeğer: <b>${this.point.y.toLocaleString('tr-TR', {\r\n\t\t\t\t\t\t\tminimumFractionDigits: 2,\r\n\t\t\t\t\t\t\tmaximumFractionDigits: 2\r\n\t\t\t\t\t\t})}</b>\r\n\t\t\t\t\t`;\r\n\t\t\t\t},\r\n\t\t\t\tuseHTML: true\r\n\t\t\t},\r\n\t\t\tseries:\r\n\t\t\t\tthis.series().length ?\r\n\t\t\t\t\tthis.series()\r\n\t\t\t\t:\t[\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tname: this.seriesName(),\r\n\t\t\t\t\t\t\tdata: this.data().map((item) => item.y)\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t],\r\n\t\t\tlegend: { enabled: this.seriesName() ? true : false },\r\n\t\t\tcredits: {\r\n\t\t\t\tenabled: false\r\n\t\t\t}\r\n\t\t};\r\n\t}\r\n}\r\n"]}

package/esm2022/ui/charts/src/highCharts/gauge/solid-gauge.component.mjs

@@ -0,0 +1,180 @@
+import { Component, computed, effect, input } from '@angular/core';
+import * as Highcharts from 'highcharts';
+import { HighchartsChartModule } from 'highcharts-angular';
+import highchartsMore from 'highcharts/highcharts-more';
+import solidGauge from 'highcharts/modules/solid-gauge';
+import NoDataToDisplay from 'highcharts/modules/no-data-to-display';
+import * as i0 from "@angular/core";
+import * as i1 from "highcharts-angular";
+highchartsMore(Highcharts);
+solidGauge(Highcharts);
+NoDataToDisplay(Highcharts);
+export class SolidGaugeChartComponent {
+    constructor() {
+        this.Highcharts = Highcharts;
+        this.data = input.required();
+        this.title = input.required();
+        this.loading = input(false);
+        this.chartCallback = (chart) => {
+            this.chart = chart;
+            if (this.loading()) {
+                this.chart.showLoading();
+            }
+        };
+        this.chartOptions = computed(() => {
+            const currentData = this.data();
+            if (!currentData || !currentData.data) {
+                return {
+                    chart: { type: 'solidgauge', backgroundColor: 'transparent' },
+                    title: { text: this.title(), style: { fontSize: '16px', textAlign: 'center', fontWeight: 'normal' } },
+                    noData: {
+                        style: {
+                            fontWeight: 'bold',
+                            fontSize: '16px',
+                            color: '#303030'
+                        },
+                        position: {
+                            align: 'center',
+                            verticalAlign: 'middle'
+                        },
+                        useHTML: true
+                    },
+                    series: []
+                };
+            }
+            const min = typeof currentData.min === 'number' ? currentData.min : 0;
+            const max = typeof currentData.max === 'number' ? currentData.max : 100;
+            const value = Number(currentData.data[0]?.value) || 0;
+            const percent = max !== min ? ((value / (max - min)) * 100).toFixed(1) : '0';
+            return {
+                chart: { type: 'solidgauge', backgroundColor: 'transparent', height: 300 },
+                title: {
+                    text: this.title(),
+                    align: 'center',
+                    style: { fontSize: '14px', fontWeight: 'normal', textAlign: 'left' }
+                },
+                pane: {
+                    size: '100%',
+                    startAngle: -120,
+                    endAngle: 120,
+                    background: [
+                        {
+                            outerRadius: '90%',
+                            innerRadius: '70%',
+                            backgroundColor: '#f5f5f5',
+                            borderWidth: 0,
+                            shape: 'arc'
+                        }
+                    ]
+                },
+                yAxis: {
+                    min,
+                    max,
+                    stops: [
+                        [0, '#DF5353'], // kırmızı
+                        [0.96, '#DDDF0D'], // sarı
+                        [0.99, '#55BF3B'], // yeşil
+                        [1, '#55BF3B'] // yeşil
+                    ],
+                    lineWidth: 0,
+                    tickPositions: [],
+                    minorTickLength: 0,
+                    labels: { enabled: false },
+                    plotBands: []
+                },
+                plotOptions: {
+                    solidgauge: {
+                        borderWidth: 24,
+                        dataLabels: {
+                            enabled: true,
+                            useHTML: true,
+                            borderWidth: 0,
+                            verticalAlign: 'middle',
+                            style: {
+                                fontSize: '2.5rem',
+                                fontWeight: 'bold',
+                                color: '#55BF3B',
+                                textAlign: 'center',
+                                lineHeight: '1'
+                            },
+                            formatter: function () {
+                                const currentDataControl = currentData.data[0];
+                                return currentDataControl[1] === Infinity ?
+                                    '∞'
+                                    : `<span style="color:#55BF3B;font-size:2.5rem;font-weight:bold;">${Highcharts.numberFormat(Number(this.y) || 0, 1)}%</span>`;
+                            }
+                        }
+                    }
+                },
+                noData: {
+                    style: { fontWeight: 'bold', fontSize: '16px', color: '#303030' },
+                    position: { align: 'center', verticalAlign: 'middle' },
+                    useHTML: true
+                },
+                loading: {
+                    hideDuration: 100,
+                    showDuration: 100,
+                    labelStyle: { color: 'gray', fontSize: '16px' },
+                    style: { backgroundColor: 'rgba(255,255,255,0.7)' }
+                },
+                series: [
+                    {
+                        type: 'solidgauge',
+                        data: [
+                            {
+                                y: parseFloat(percent),
+                                color: value < 70 ? '#55BF3B'
+                                    : value < 90 ? '#DDDF0D'
+                                        : '#DF5353'
+                            }
+                        ],
+                        dataLabels: {
+                            enabled: true
+                        }
+                    }
+                ]
+            };
+        });
+        effect(() => {
+            const isLoading = this.loading();
+            if (this.chart) {
+                if (isLoading) {
+                    this.chart.showLoading();
+                }
+                else {
+                    this.chart.hideLoading();
+                }
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: SolidGaugeChartComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "17.1.2", type: SolidGaugeChartComponent, isStandalone: true, selector: "aril-solid-gauge", inputs: { data: { classPropertyName: "data", publicName: "data", isSignal: true, isRequired: true, transformFunction: null }, title: { classPropertyName: "title", publicName: "title", isSignal: true, isRequired: true, transformFunction: null }, loading: { classPropertyName: "loading", publicName: "loading", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+		<highcharts-chart
+			style="display: block"
+			[Highcharts]="Highcharts"
+			[oneToOne]="true"
+			[runOutsideAngular]="true"
+			[options]="chartOptions()"
+			[callbackFunction]="chartCallback">
+		</highcharts-chart>
+	`, isInline: true, dependencies: [{ kind: "ngmodule", type: HighchartsChartModule }, { kind: "component", type: i1.HighchartsChartComponent, selector: "highcharts-chart", inputs: ["Highcharts", "constructorType", "callbackFunction", "oneToOne", "runOutsideAngular", "options", "update"], outputs: ["updateChange", "chartInstance"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: SolidGaugeChartComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'aril-solid-gauge',
+                    standalone: true,
+                    imports: [HighchartsChartModule],
+                    template: `
+		<highcharts-chart
+			style="display: block"
+			[Highcharts]="Highcharts"
+			[oneToOne]="true"
+			[runOutsideAngular]="true"
+			[options]="chartOptions()"
+			[callbackFunction]="chartCallback">
+		</highcharts-chart>
+	`
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"solid-gauge.component.js","sourceRoot":"","sources":["../../../../../../../projects/aril/ui/charts/src/highCharts/gauge/solid-gauge.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, computed, effect, input } from '@angular/core';\r\nimport * as Highcharts from 'highcharts';\r\nimport { HighchartsChartModule } from 'highcharts-angular';\r\nimport highchartsMore from 'highcharts/highcharts-more';\r\nimport solidGauge from 'highcharts/modules/solid-gauge';\r\nimport NoDataToDisplay from 'highcharts/modules/no-data-to-display';\r\n\r\nhighchartsMore(Highcharts);\r\nsolidGauge(Highcharts);\r\nNoDataToDisplay(Highcharts);\r\n\r\nexport interface SolidGaugeDataPoint {\r\n\tvalue: number;\r\n\tname: string;\r\n\ttitle: string;\r\n\tcolor?: string;\r\n}\r\n\r\nexport interface SolidGaugeData {\r\n\tdata: SolidGaugeDataPoint[];\r\n\tmin: number;\r\n\tmax: number;\r\n\ttitle: string;\r\n\tunit: string;\r\n\tcolors?: string[];\r\n\tstops?: number[];\r\n\tsize?: string;\r\n\tstartAngle?: number;\r\n\tendAngle?: number;\r\n\tinnerRadius?: string;\r\n\touterRadius?: string;\r\n\tbackgroundColor?: string;\r\n\tshowTooltip?: boolean;\r\n\tfontSize?: string;\r\n\tunitFontSize?: string;\r\n}\r\n\r\n@Component({\r\n\tselector: 'aril-solid-gauge',\r\n\tstandalone: true,\r\n\timports: [HighchartsChartModule],\r\n\ttemplate: `\r\n\t\t<highcharts-chart\r\n\t\t\tstyle=\"display: block\"\r\n\t\t\t[Highcharts]=\"Highcharts\"\r\n\t\t\t[oneToOne]=\"true\"\r\n\t\t\t[runOutsideAngular]=\"true\"\r\n\t\t\t[options]=\"chartOptions()\"\r\n\t\t\t[callbackFunction]=\"chartCallback\">\r\n\t\t</highcharts-chart>\r\n\t`\r\n})\r\nexport class SolidGaugeChartComponent {\r\n\tHighcharts: typeof Highcharts = Highcharts;\r\n\r\n\tdata = input.required<SolidGaugeData>();\r\n\ttitle = input.required<string>();\r\n\tloading = input(false);\r\n\r\n\tprivate chart?: Highcharts.Chart;\r\n\r\n\tconstructor() {\r\n\t\teffect(() => {\r\n\t\t\tconst isLoading = this.loading();\r\n\t\t\tif (this.chart) {\r\n\t\t\t\tif (isLoading) {\r\n\t\t\t\t\tthis.chart.showLoading();\r\n\t\t\t\t} else {\r\n\t\t\t\t\tthis.chart.hideLoading();\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\tchartCallback: Highcharts.ChartCallbackFunction = (chart) => {\r\n\t\tthis.chart = chart;\r\n\t\tif (this.loading()) {\r\n\t\t\tthis.chart.showLoading();\r\n\t\t}\r\n\t};\r\n\r\n\tchartOptions = computed<Highcharts.Options>(() => {\r\n\t\tconst currentData = this.data();\r\n\t\tif (!currentData || !currentData.data) {\r\n\t\t\treturn {\r\n\t\t\t\tchart: { type: 'solidgauge', backgroundColor: 'transparent' },\r\n\t\t\t\ttitle: { text: this.title(), style: { fontSize: '16px', textAlign: 'center', fontWeight: 'normal' } },\r\n\t\t\t\tnoData: {\r\n\t\t\t\t\tstyle: {\r\n\t\t\t\t\t\tfontWeight: 'bold',\r\n\t\t\t\t\t\tfontSize: '16px',\r\n\t\t\t\t\t\tcolor: '#303030'\r\n\t\t\t\t\t},\r\n\t\t\t\t\tposition: {\r\n\t\t\t\t\t\talign: 'center',\r\n\t\t\t\t\t\tverticalAlign: 'middle'\r\n\t\t\t\t\t},\r\n\t\t\t\t\tuseHTML: true\r\n\t\t\t\t},\r\n\t\t\t\tseries: []\r\n\t\t\t};\r\n\t\t}\r\n\r\n\t\tconst min = typeof currentData.min === 'number' ? currentData.min : 0;\r\n\t\tconst max = typeof currentData.max === 'number' ? currentData.max : 100;\r\n\t\tconst value = Number(currentData.data[0]?.value) || 0;\r\n\t\tconst percent = max !== min ? ((value / (max - min)) * 100).toFixed(1) : '0';\r\n\r\n\t\treturn {\r\n\t\t\tchart: { type: 'solidgauge', backgroundColor: 'transparent', height: 300 },\r\n\t\t\ttitle: {\r\n\t\t\t\ttext: this.title(),\r\n\t\t\t\talign: 'center',\r\n\t\t\t\tstyle: { fontSize: '14px', fontWeight: 'normal', textAlign: 'left' }\r\n\t\t\t},\r\n\t\t\tpane: {\r\n\t\t\t\tsize: '100%',\r\n\t\t\t\tstartAngle: -120,\r\n\t\t\t\tendAngle: 120,\r\n\t\t\t\tbackground: [\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\touterRadius: '90%',\r\n\t\t\t\t\t\tinnerRadius: '70%',\r\n\t\t\t\t\t\tbackgroundColor: '#f5f5f5',\r\n\t\t\t\t\t\tborderWidth: 0,\r\n\t\t\t\t\t\tshape: 'arc'\r\n\t\t\t\t\t}\r\n\t\t\t\t]\r\n\t\t\t},\r\n\t\t\tyAxis: {\r\n\t\t\t\tmin,\r\n\t\t\t\tmax,\r\n\t\t\t\tstops: [\r\n\t\t\t\t\t[0, '#DF5353'], // kırmızı\r\n\t\t\t\t\t[0.96, '#DDDF0D'], // sarı\r\n\t\t\t\t\t[0.99, '#55BF3B'], // yeşil\r\n\t\t\t\t\t[1, '#55BF3B'] // yeşil\r\n\t\t\t\t],\r\n\t\t\t\tlineWidth: 0,\r\n\t\t\t\ttickPositions: [],\r\n\t\t\t\tminorTickLength: 0,\r\n\t\t\t\tlabels: { enabled: false },\r\n\t\t\t\tplotBands: []\r\n\t\t\t},\r\n\t\t\tplotOptions: {\r\n\t\t\t\tsolidgauge: {\r\n\t\t\t\t\tborderWidth: 24,\r\n\t\t\t\t\tdataLabels: {\r\n\t\t\t\t\t\tenabled: true,\r\n\t\t\t\t\t\tuseHTML: true,\r\n\t\t\t\t\t\tborderWidth: 0,\r\n\t\t\t\t\t\tverticalAlign: 'middle',\r\n\t\t\t\t\t\tstyle: {\r\n\t\t\t\t\t\t\tfontSize: '2.5rem',\r\n\t\t\t\t\t\t\tfontWeight: 'bold',\r\n\t\t\t\t\t\t\tcolor: '#55BF3B',\r\n\t\t\t\t\t\t\ttextAlign: 'center',\r\n\t\t\t\t\t\t\tlineHeight: '1'\r\n\t\t\t\t\t\t},\r\n\t\t\t\t\t\tformatter: function () {\r\n\t\t\t\t\t\t\tconst currentDataControl: any = currentData.data[0];\r\n\t\t\t\t\t\t\treturn currentDataControl[1] === Infinity ?\r\n\t\t\t\t\t\t\t\t\t'∞'\r\n\t\t\t\t\t\t\t\t:\t`<span style=\"color:#55BF3B;font-size:2.5rem;font-weight:bold;\">${Highcharts.numberFormat(Number(this.y) || 0, 1)}%</span>`;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t},\r\n\t\t\tnoData: {\r\n\t\t\t\tstyle: { fontWeight: 'bold', fontSize: '16px', color: '#303030' },\r\n\t\t\t\tposition: { align: 'center', verticalAlign: 'middle' },\r\n\t\t\t\tuseHTML: true\r\n\t\t\t},\r\n\t\t\tloading: {\r\n\t\t\t\thideDuration: 100,\r\n\t\t\t\tshowDuration: 100,\r\n\t\t\t\tlabelStyle: { color: 'gray', fontSize: '16px' },\r\n\t\t\t\tstyle: { backgroundColor: 'rgba(255,255,255,0.7)' }\r\n\t\t\t},\r\n\t\t\tseries: [\r\n\t\t\t\t{\r\n\t\t\t\t\ttype: 'solidgauge',\r\n\t\t\t\t\tdata: [\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\ty: parseFloat(percent),\r\n\t\t\t\t\t\t\tcolor:\r\n\t\t\t\t\t\t\t\tvalue < 70 ? '#55BF3B'\r\n\t\t\t\t\t\t\t\t: value < 90 ? '#DDDF0D'\r\n\t\t\t\t\t\t\t\t: '#DF5353'\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t],\r\n\t\t\t\t\tdataLabels: {\r\n\t\t\t\t\t\tenabled: true\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t]\r\n\t\t};\r\n\t});\r\n}\r\n"]}

package/esm2022/ui/charts/src/highCharts/heatmap/heatMap-chart.component.mjs

@@ -0,0 +1,252 @@
+import { Component, effect, input } from '@angular/core';
+import * as Highcharts from 'highcharts';
+import { HighchartsChartModule } from 'highcharts-angular';
+import highchartsMore from 'highcharts/highcharts-more';
+import heatmap from 'highcharts/modules/heatmap';
+import NoDataToDisplay from 'highcharts/modules/no-data-to-display';
+import * as i0 from "@angular/core";
+import * as i1 from "highcharts-angular";
+highchartsMore(Highcharts);
+heatmap(Highcharts);
+NoDataToDisplay(Highcharts);
+export class HeatmapChartComponent {
+    constructor() {
+        this.Highcharts = Highcharts;
+        this.series = input.required();
+        this.title = input('Chart');
+        this.yAxisTitle = input('');
+        this.loading = input(false);
+        this.chartOptions = {};
+        this.xAxisCategories = [];
+        this.yAxisCategories = [];
+        this.chartCallback = (chart) => {
+            this.chart = chart;
+        };
+        effect(() => {
+            if (this.series()) {
+                this.setChartOptions();
+            }
+        });
+        effect(() => {
+            if (this.chart) {
+                const newSeries = this.prometheusToHighchartsSeries();
+                this.chart.update({
+                    series: newSeries,
+                    yAxis: { categories: this.yAxisCategories },
+                    xAxis: { categories: this.xAxisCategories }
+                }, true, true);
+            }
+        });
+        effect(() => {
+            if (this.chart) {
+                if (this.loading()) {
+                    this.chart.showLoading();
+                }
+                else {
+                    this.chart.hideLoading();
+                }
+            }
+        });
+        effect(() => {
+            if (this.chart) {
+                this.chart.update({
+                    title: {
+                        text: this.title()
+                    },
+                    yAxis: {
+                        title: {
+                            text: this.yAxisTitle()
+                        }
+                    }
+                });
+            }
+        });
+    }
+    setChartOptions() {
+        const series = this.prometheusToHighchartsSeries();
+        let minValue = Number.POSITIVE_INFINITY;
+        let maxValue = Number.NEGATIVE_INFINITY;
+        if (series && series.length && series[0].type === 'heatmap' && Array.isArray(series[0].data)) {
+            for (const d of series[0].data) {
+                const value = d[2];
+                if (typeof value === 'number') {
+                    if (value < minValue)
+                        minValue = value;
+                    if (value > maxValue)
+                        maxValue = value;
+                }
+            }
+        }
+        if (!isFinite(minValue))
+            minValue = 0;
+        if (!isFinite(maxValue))
+            maxValue = 1;
+        console.log("minValue", minValue);
+        console.log("maxValue", maxValue);
+        this.chartOptions = {
+            chart: {
+                type: 'heatmap',
+                marginTop: 40,
+                marginBottom: 80,
+                plotBorderWidth: 0
+            },
+            title: {
+                text: this.title() || 'Heatmap'
+            },
+            colorAxis: {
+                stops: [
+                    [0, '#73BF69'],
+                    [0.3, '#fffbbc'],
+                    [0.5, '#fffbbc'],
+                    [0.7, '#c4463a'],
+                    [0.9, '#c4463a'],
+                    [1, '#c4463a']
+                ],
+                min: minValue,
+                max: maxValue,
+                startOnTick: false,
+                endOnTick: false
+            },
+            tooltip: {
+                formatter: function () {
+                    const dateStr = Highcharts.dateFormat('%Y-%m-%d %H:%M', this.point.x);
+                    return '<b> Value </b>' + this.point.value?.toFixed(2) + '<br/><b> Time </b>' + dateStr;
+                },
+                enabled: true
+            },
+            legend: {
+                enabled: false
+            },
+            plotOptions: {
+                heatmap: {
+                    pointPadding: 5
+                },
+                series: {
+                    stickyTracking: false
+                }
+            },
+            noData: {
+                style: {
+                    fontWeight: 'bold',
+                    fontSize: '16px',
+                    color: '#303030'
+                },
+                position: {
+                    align: 'center',
+                    verticalAlign: 'middle'
+                },
+                useHTML: true
+            },
+            xAxis: {
+                type: 'datetime',
+                categories: this.xAxisCategories,
+                labels: {
+                    align: 'left',
+                    x: 5,
+                    y: 14,
+                    format: '{value:%H:00}',
+                    rotation: 0,
+                    step: 2
+                },
+                showLastLabel: false,
+                tickInterval: 2 * 3600 * 1000,
+                minTickInterval: 3600 * 1000
+            },
+            yAxis: {
+                categories: this.yAxisCategories,
+                title: {
+                    text: this.yAxisTitle()
+                }
+            },
+            series: series
+        };
+    }
+    epochToTimeString(epoch) {
+        const date = new Date(Number(epoch) * 1000);
+        const hours = date.getHours().toString().padStart(2, '0');
+        const minutes = date.getMinutes().toString().padStart(2, '0');
+        return `${hours}:${minutes}`;
+    }
+    prometheusToHighchartsSeries() {
+        const xCategorySet = new Set();
+        const yCategorySet = new Set();
+        const seriesData = this.series();
+        if (!seriesData) {
+            return [];
+        }
+        for (const key in seriesData) {
+            if (key === 'response') {
+                if (Object.prototype.hasOwnProperty.call(seriesData, key)) {
+                    const dataSet = seriesData[key];
+                    const result = dataSet?.result || dataSet?.data?.result;
+                    if (result) {
+                        for (const item of result) {
+                            yCategorySet.add(item.metric?.le);
+                            for (const itemValue of item.values) {
+                                xCategorySet.add(this.epochToTimeString(itemValue[0]));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        this.xAxisCategories = Array.from(xCategorySet);
+        this.yAxisCategories = Array.from(yCategorySet);
+        const data = [];
+        for (const key in seriesData) {
+            if (key === 'response') {
+                if (Object.prototype.hasOwnProperty.call(seriesData, key)) {
+                    const dataSet = seriesData[key];
+                    const result = dataSet?.result || dataSet?.data?.result;
+                    if (result) {
+                        for (const item of result) {
+                            const yValue = item.metric?.le;
+                            const yIndex = this.yAxisCategories.indexOf(yValue);
+                            for (const itemValue of item.values) {
+                                const epoch = Number(itemValue[0]);
+                                const date = new Date(epoch * 1000);
+                                const utcTime = Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes());
+                                const value = Number(itemValue[1]);
+                                data.push([utcTime, yIndex, value]);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return [
+            {
+                type: 'heatmap',
+                data: data,
+                colsize: 8 * 60 * 1000,
+                borderWidth: 1
+            }
+        ];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: HeatmapChartComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "17.1.2", type: HeatmapChartComponent, isStandalone: true, selector: "aril-heatmap-chart", inputs: { series: { classPropertyName: "series", publicName: "series", isSignal: true, isRequired: true, transformFunction: null }, title: { classPropertyName: "title", publicName: "title", isSignal: true, isRequired: false, transformFunction: null }, yAxisTitle: { classPropertyName: "yAxisTitle", publicName: "yAxisTitle", isSignal: true, isRequired: false, transformFunction: null }, loading: { classPropertyName: "loading", publicName: "loading", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+		<highcharts-chart
+			style="width: 100%; height: 100%; display: block"
+			[Highcharts]="Highcharts"
+			[options]="chartOptions"
+			[callbackFunction]="chartCallback">
+		</highcharts-chart>
+	`, isInline: true, dependencies: [{ kind: "ngmodule", type: HighchartsChartModule }, { kind: "component", type: i1.HighchartsChartComponent, selector: "highcharts-chart", inputs: ["Highcharts", "constructorType", "callbackFunction", "oneToOne", "runOutsideAngular", "options", "update"], outputs: ["updateChange", "chartInstance"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: HeatmapChartComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'aril-heatmap-chart',
+                    standalone: true,
+                    imports: [HighchartsChartModule],
+                    template: `
+		<highcharts-chart
+			style="width: 100%; height: 100%; display: block"
+			[Highcharts]="Highcharts"
+			[options]="chartOptions"
+			[callbackFunction]="chartCallback">
+		</highcharts-chart>
+	`
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"heatMap-chart.component.js","sourceRoot":"","sources":["../../../../../../../projects/aril/ui/charts/src/highCharts/heatmap/heatMap-chart.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,KAAK,UAAU,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,cAAc,MAAM,4BAA4B,CAAC;AACxD,OAAO,OAAO,MAAM,4BAA4B,CAAC;AACjD,OAAO,eAAe,MAAM,uCAAuC,CAAC;;;AAEpE,cAAc,CAAC,UAAU,CAAC,CAAC;AAC3B,OAAO,CAAC,UAAU,CAAC,CAAC;AACpB,eAAe,CAAC,UAAU,CAAC,CAAC;AA6B5B,MAAM,OAAO,qBAAqB;IAcjC;QAbA,eAAU,GAAsB,UAAU,CAAC;QAE3C,WAAM,GAAG,KAAK,CAAC,QAAQ,EAAO,CAAC;QAC/B,UAAK,GAAG,KAAK,CAAS,OAAO,CAAC,CAAC;QAC/B,eAAU,GAAG,KAAK,CAAS,EAAE,CAAC,CAAC;QAC/B,YAAO,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;QACvB,iBAAY,GAAuB,EAAE,CAAC;QAEtC,oBAAe,GAAU,EAAE,CAAC;QAC5B,oBAAe,GAAU,EAAE,CAAC;QAuJ5B,kBAAa,GAAqC,CAAC,KAAK,EAAE,EAAE;YAC3D,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACpB,CAAC,CAAC;QApJD,MAAM,CAAC,GAAG,EAAE;YACX,IAAI,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;gBACnB,IAAI,CAAC,eAAe,EAAE,CAAC;YACxB,CAAC;QACF,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,GAAG,EAAE;YACX,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBAChB,MAAM,SAAS,GAAG,IAAI,CAAC,4BAA4B,EAAE,CAAC;gBACtD,IAAI,CAAC,KAAK,CAAC,MAAM,CAChB;oBACC,MAAM,EAAE,SAAS;oBAEjB,KAAK,EAAE,EAAE,UAAU,EAAE,IAAI,CAAC,eAAe,EAAE;oBAC3C,KAAK,EAAE,EAAE,UAAU,EAAE,IAAI,CAAC,eAAe,EAAE;iBAC3C,EACD,IAAI,EACJ,IAAI,CACJ,CAAC;YACH,CAAC;QACF,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,GAAG,EAAE;YACX,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBAChB,IAAI,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;oBACpB,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;gBAC1B,CAAC;qBAAM,CAAC;oBACP,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;gBAC1B,CAAC;YACF,CAAC;QACF,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,GAAG,EAAE;YACX,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBAChB,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;oBACjB,KAAK,EAAE;wBACN,IAAI,EAAE,IAAI,CAAC,KAAK,EAAE;qBAClB;oBACD,KAAK,EAAE;wBACN,KAAK,EAAE;4BACN,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE;yBACvB;qBACD;iBACD,CAAC,CAAC;YACJ,CAAC;QACF,CAAC,CAAC,CAAC;IACJ,CAAC;IAED,eAAe;QACd,MAAM,MAAM,GAAG,IAAI,CAAC,4BAA4B,EAAE,CAAC;QACnD,IAAI,QAAQ,GAAG,MAAM,CAAC,iBAAiB,CAAC;QACxC,IAAI,QAAQ,GAAG,MAAM,CAAC,iBAAiB,CAAC;QACxC,IAAI,MAAM,IAAI,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC;YAC9F,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,IAAkB,EAAE,CAAC;gBAC9C,MAAM,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;gBACnB,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;oBAC/B,IAAI,KAAK,GAAG,QAAQ;wBAAE,QAAQ,GAAG,KAAK,CAAC;oBACvC,IAAI,KAAK,GAAG,QAAQ;wBAAE,QAAQ,GAAG,KAAK,CAAC;gBACxC,CAAC;YACF,CAAC;QACF,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC;YAAE,QAAQ,GAAG,CAAC,CAAC;QACtC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC;YAAE,QAAQ,GAAG,CAAC,CAAC;QAEtC,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;QAClC,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;QAElC,IAAI,CAAC,YAAY,GAAG;YACnB,KAAK,EAAE;gBACN,IAAI,EAAE,SAAS;gBACf,SAAS,EAAE,EAAE;gBACb,YAAY,EAAE,EAAE;gBAChB,eAAe,EAAE,CAAC;aAClB;YACD,KAAK,EAAE;gBACN,IAAI,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,SAAS;aAC/B;YACD,SAAS,EAAE;gBACV,KAAK,EAAE;oBACN,CAAC,CAAC,EAAE,SAAS,CAAC;oBACd,CAAC,GAAG,EAAE,SAAS,CAAC;oBAChB,CAAC,GAAG,EAAE,SAAS,CAAC;oBAChB,CAAC,GAAG,EAAE,SAAS,CAAC;oBAChB,CAAC,GAAG,EAAE,SAAS,CAAC;oBAChB,CAAC,CAAC,EAAE,SAAS,CAAC;iBACd;gBACD,GAAG,EAAE,QAAQ;gBACb,GAAG,EAAE,QAAQ;gBACb,WAAW,EAAE,KAAK;gBAClB,SAAS,EAAE,KAAK;aAChB;YACD,OAAO,EAAE;gBACR,SAAS,EAAE;oBACV,MAAM,OAAO,GAAG,UAAU,CAAC,UAAU,CAAC,gBAAgB,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;oBACtE,OAAO,gBAAgB,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,oBAAoB,GAAG,OAAO,CAAC;gBACzF,CAAC;gBACD,OAAO,EAAE,IAAI;aACb;YACD,MAAM,EAAE;gBACP,OAAO,EAAE,KAAK;aACd;YACD,WAAW,EAAE;gBACZ,OAAO,EAAE;oBACR,YAAY,EAAE,CAAC;iBACf;gBACD,MAAM,EAAE;oBACP,cAAc,EAAE,KAAK;iBACrB;aACD;YACD,MAAM,EAAE;gBACP,KAAK,EAAE;oBACN,UAAU,EAAE,MAAM;oBAClB,QAAQ,EAAE,MAAM;oBAChB,KAAK,EAAE,SAAS;iBAChB;gBACD,QAAQ,EAAE;oBACT,KAAK,EAAE,QAAQ;oBACf,aAAa,EAAE,QAAQ;iBACvB;gBACD,OAAO,EAAE,IAAI;aACb;YACD,KAAK,EAAE;gBACN,IAAI,EAAE,UAAU;gBAChB,UAAU,EAAE,IAAI,CAAC,eAAe;gBAChC,MAAM,EAAE;oBACP,KAAK,EAAE,MAAM;oBACb,CAAC,EAAE,CAAC;oBACJ,CAAC,EAAE,EAAE;oBACL,MAAM,EAAE,eAAe;oBACvB,QAAQ,EAAE,CAAC;oBACX,IAAI,EAAE,CAAC;iBACP;gBACD,aAAa,EAAE,KAAK;gBACpB,YAAY,EAAE,CAAC,GAAG,IAAI,GAAG,IAAI;gBAC7B,eAAe,EAAE,IAAI,GAAG,IAAI;aAC5B;YACD,KAAK,EAAE;gBACN,UAAU,EAAE,IAAI,CAAC,eAAe;gBAChC,KAAK,EAAE;oBACN,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE;iBACvB;aACD;YACD,MAAM,EAAE,MAAM;SACd,CAAC;IACH,CAAC;IAMD,iBAAiB,CAAC,KAAa;QAC9B,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;QAC5C,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAC1D,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAC9D,OAAO,GAAG,KAAK,IAAI,OAAO,EAAE,CAAC;IAC9B,CAAC;IAED,4BAA4B;QAC3B,MAAM,YAAY,GAAG,IAAI,GAAG,EAAU,CAAC;QACvC,MAAM,YAAY,GAAG,IAAI,GAAG,EAAU,CAAC;QACvC,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QAEjC,IAAI,CAAC,UAAU,EAAE,CAAC;YACjB,OAAO,EAAE,CAAC;QACX,CAAC;QAED,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;YAC9B,IAAI,GAAG,KAAK,UAAU,EAAE,CAAC;gBACxB,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,EAAE,GAAG,CAAC,EAAE,CAAC;oBAC3D,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;oBAChC,MAAM,MAAM,GAAG,OAAO,EAAE,MAAM,IAAI,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC;oBACxD,IAAI,MAAM,EAAE,CAAC;wBACZ,KAAK,MAAM,IAAI,IAAI,MAAM,EAAE,CAAC;4BAC3B,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;4BAClC,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;gCACrC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;4BACxD,CAAC;wBACF,CAAC;oBACF,CAAC;gBACF,CAAC;YACF,CAAC;QACF,CAAC;QAED,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAChD,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAEhD,MAAM,IAAI,GAAe,EAAE,CAAC;QAE5B,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;YAC9B,IAAI,GAAG,KAAK,UAAU,EAAE,CAAC;gBACxB,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,EAAE,GAAG,CAAC,EAAE,CAAC;oBAC3D,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;oBAChC,MAAM,MAAM,GAAG,OAAO,EAAE,MAAM,IAAI,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC;oBACxD,IAAI,MAAM,EAAE,CAAC;wBACZ,KAAK,MAAM,IAAI,IAAI,MAAM,EAAE,CAAC;4BAC3B,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;4BAC/B,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;4BACpD,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;gCACrC,MAAM,KAAK,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;gCACnC,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;gCACpC,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CACvB,IAAI,CAAC,cAAc,EAAE,EACrB,IAAI,CAAC,WAAW,EAAE,EAClB,IAAI,CAAC,UAAU,EAAE,EACjB,IAAI,CAAC,WAAW,EAAE,EAClB,IAAI,CAAC,aAAa,EAAE,CACpB,CAAC;gCACF,MAAM,KAAK,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;gCACnC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;4BACrC,CAAC;wBACF,CAAC;oBACF,CAAC;gBACF,CAAC;YACF,CAAC;QACF,CAAC;QAED,OAAO;YACN;gBACC,IAAI,EAAE,SAAS;gBACf,IAAI,EAAE,IAAI;gBACV,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,IAAI;gBACtB,WAAW,EAAE,CAAC;aACqB;SACpC,CAAC;IACH,CAAC;8GA/OW,qBAAqB;kGAArB,qBAAqB,ilBATvB;;;;;;;EAOT,2DARS,qBAAqB;;2FAUnB,qBAAqB;kBAbjC,SAAS;mBAAC;oBACV,QAAQ,EAAE,oBAAoB;oBAC9B,UAAU,EAAE,IAAI;oBAChB,OAAO,EAAE,CAAC,qBAAqB,CAAC;oBAChC,QAAQ,EAAE;;;;;;;EAOT;iBACD","sourcesContent":["import { Component, effect, input } from '@angular/core';\r\nimport * as Highcharts from 'highcharts';\r\nimport { HighchartsChartModule } from 'highcharts-angular';\r\nimport highchartsMore from 'highcharts/highcharts-more';\r\nimport heatmap from 'highcharts/modules/heatmap';\r\nimport NoDataToDisplay from 'highcharts/modules/no-data-to-display';\r\n\r\nhighchartsMore(Highcharts);\r\nheatmap(Highcharts);\r\nNoDataToDisplay(Highcharts);\r\n\r\nexport interface HeatmapPoint {\r\n\tx: number;\r\n\ty: number;\r\n\tvalue: number;\r\n}\r\n\r\nexport interface HeatmapData {\r\n\tdata: HeatmapPoint[];\r\n\txCategories?: string[];\r\n\tyCategories?: string[];\r\n\ttitle?: string;\r\n\tcolorAxis?: Highcharts.ColorAxisOptions;\r\n}\r\n\r\n@Component({\r\n\tselector: 'aril-heatmap-chart',\r\n\tstandalone: true,\r\n\timports: [HighchartsChartModule],\r\n\ttemplate: `\r\n\t\t<highcharts-chart\r\n\t\t\tstyle=\"width: 100%; height: 100%; display: block\"\r\n\t\t\t[Highcharts]=\"Highcharts\"\r\n\t\t\t[options]=\"chartOptions\"\r\n\t\t\t[callbackFunction]=\"chartCallback\">\r\n\t\t</highcharts-chart>\r\n\t`\r\n})\r\nexport class HeatmapChartComponent {\r\n\tHighcharts: typeof Highcharts = Highcharts;\r\n\r\n\tseries = input.required<any>();\r\n\ttitle = input<string>('Chart');\r\n\tyAxisTitle = input<string>('');\r\n\tloading = input(false);\r\n\tchartOptions: Highcharts.Options = {};\r\n\r\n\txAxisCategories: any[] = [];\r\n\tyAxisCategories: any[] = [];\r\n\r\n\tprivate chart?: Highcharts.Chart;\r\n\r\n\tconstructor() {\r\n\t\teffect(() => {\r\n\t\t\tif (this.series()) {\r\n\t\t\t\tthis.setChartOptions();\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\teffect(() => {\r\n\t\t\tif (this.chart) {\r\n\t\t\t\tconst newSeries = this.prometheusToHighchartsSeries();\r\n\t\t\t\tthis.chart.update(\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tseries: newSeries,\r\n\r\n\t\t\t\t\t\tyAxis: { categories: this.yAxisCategories },\r\n\t\t\t\t\t\txAxis: { categories: this.xAxisCategories }\r\n\t\t\t\t\t},\r\n\t\t\t\t\ttrue,\r\n\t\t\t\t\ttrue\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\teffect(() => {\r\n\t\t\tif (this.chart) {\r\n\t\t\t\tif (this.loading()) {\r\n\t\t\t\t\tthis.chart.showLoading();\r\n\t\t\t\t} else {\r\n\t\t\t\t\tthis.chart.hideLoading();\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\teffect(() => {\r\n\t\t\tif (this.chart) {\r\n\t\t\t\tthis.chart.update({\r\n\t\t\t\t\ttitle: {\r\n\t\t\t\t\t\ttext: this.title()\r\n\t\t\t\t\t},\r\n\t\t\t\t\tyAxis: {\r\n\t\t\t\t\t\ttitle: {\r\n\t\t\t\t\t\t\ttext: this.yAxisTitle()\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\tsetChartOptions() {\r\n\t\tconst series = this.prometheusToHighchartsSeries();\r\n\t\tlet minValue = Number.POSITIVE_INFINITY;\r\n\t\tlet maxValue = Number.NEGATIVE_INFINITY;\r\n\t\tif (series && series.length && series[0].type === 'heatmap' && Array.isArray(series[0].data)) {\r\n\t\t\tfor (const d of series[0].data as number[][]) {\r\n\t\t\t\tconst value = d[2];\r\n\t\t\t\tif (typeof value === 'number') {\r\n\t\t\t\t\tif (value < minValue) minValue = value;\r\n\t\t\t\t\tif (value > maxValue) maxValue = value;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t\tif (!isFinite(minValue)) minValue = 0;\r\n\t\tif (!isFinite(maxValue)) maxValue = 1;\r\n\r\n\t\tconsole.log(\"minValue\", minValue);\r\n\t\tconsole.log(\"maxValue\", maxValue);\r\n\r\n\t\tthis.chartOptions = {\r\n\t\t\tchart: {\r\n\t\t\t\ttype: 'heatmap',\r\n\t\t\t\tmarginTop: 40,\r\n\t\t\t\tmarginBottom: 80,\r\n\t\t\t\tplotBorderWidth: 0\r\n\t\t\t},\r\n\t\t\ttitle: {\r\n\t\t\t\ttext: this.title() || 'Heatmap'\r\n\t\t\t},\r\n\t\t\tcolorAxis: {\r\n\t\t\t\tstops: [\r\n\t\t\t\t\t[0, '#73BF69'],\r\n\t\t\t\t\t[0.3, '#fffbbc'],\r\n\t\t\t\t\t[0.5, '#fffbbc'],\r\n\t\t\t\t\t[0.7, '#c4463a'],\r\n\t\t\t\t\t[0.9, '#c4463a'],\r\n\t\t\t\t\t[1, '#c4463a']\r\n\t\t\t\t],\r\n\t\t\t\tmin: minValue,\r\n\t\t\t\tmax: maxValue,\r\n\t\t\t\tstartOnTick: false,\r\n\t\t\t\tendOnTick: false\r\n\t\t\t},\r\n\t\t\ttooltip: {\r\n\t\t\t\tformatter: function () {\r\n\t\t\t\t\tconst dateStr = Highcharts.dateFormat('%Y-%m-%d %H:%M', this.point.x);\r\n\t\t\t\t\treturn '<b> Value </b>' + this.point.value?.toFixed(2) + '<br/><b> Time </b>' + dateStr;\r\n\t\t\t\t},\r\n\t\t\t\tenabled: true\r\n\t\t\t},\r\n\t\t\tlegend: {\r\n\t\t\t\tenabled: false\r\n\t\t\t},\r\n\t\t\tplotOptions: {\r\n\t\t\t\theatmap: {\r\n\t\t\t\t\tpointPadding: 5\r\n\t\t\t\t},\r\n\t\t\t\tseries: {\r\n\t\t\t\t\tstickyTracking: false\r\n\t\t\t\t}\r\n\t\t\t},\r\n\t\t\tnoData: {\r\n\t\t\t\tstyle: {\r\n\t\t\t\t\tfontWeight: 'bold',\r\n\t\t\t\t\tfontSize: '16px',\r\n\t\t\t\t\tcolor: '#303030'\r\n\t\t\t\t},\r\n\t\t\t\tposition: {\r\n\t\t\t\t\talign: 'center',\r\n\t\t\t\t\tverticalAlign: 'middle'\r\n\t\t\t\t},\r\n\t\t\t\tuseHTML: true\r\n\t\t\t},\r\n\t\t\txAxis: {\r\n\t\t\t\ttype: 'datetime',\r\n\t\t\t\tcategories: this.xAxisCategories,\r\n\t\t\t\tlabels: {\r\n\t\t\t\t\talign: 'left',\r\n\t\t\t\t\tx: 5,\r\n\t\t\t\t\ty: 14,\r\n\t\t\t\t\tformat: '{value:%H:00}',\r\n\t\t\t\t\trotation: 0,\r\n\t\t\t\t\tstep: 2\r\n\t\t\t\t},\r\n\t\t\t\tshowLastLabel: false,\r\n\t\t\t\ttickInterval: 2 * 3600 * 1000,\r\n\t\t\t\tminTickInterval: 3600 * 1000\r\n\t\t\t},\r\n\t\t\tyAxis: {\r\n\t\t\t\tcategories: this.yAxisCategories,\r\n\t\t\t\ttitle: {\r\n\t\t\t\t\ttext: this.yAxisTitle()\r\n\t\t\t\t}\r\n\t\t\t},\r\n\t\t\tseries: series\r\n\t\t};\r\n\t}\r\n\r\n\tchartCallback: Highcharts.ChartCallbackFunction = (chart) => {\r\n\t\tthis.chart = chart;\r\n\t};\r\n\r\n\tepochToTimeString(epoch: number): string {\r\n\t\tconst date = new Date(Number(epoch) * 1000);\r\n\t\tconst hours = date.getHours().toString().padStart(2, '0');\r\n\t\tconst minutes = date.getMinutes().toString().padStart(2, '0');\r\n\t\treturn `${hours}:${minutes}`;\r\n\t}\r\n\r\n\tprometheusToHighchartsSeries(): Highcharts.SeriesOptionsType[] {\r\n\t\tconst xCategorySet = new Set<string>();\r\n\t\tconst yCategorySet = new Set<string>();\r\n\t\tconst seriesData = this.series();\r\n\r\n\t\tif (!seriesData) {\r\n\t\t\treturn [];\r\n\t\t}\r\n\r\n\t\tfor (const key in seriesData) {\r\n\t\t\tif (key === 'response') {\r\n\t\t\t\tif (Object.prototype.hasOwnProperty.call(seriesData, key)) {\r\n\t\t\t\t\tconst dataSet = seriesData[key];\r\n\t\t\t\t\tconst result = dataSet?.result || dataSet?.data?.result;\r\n\t\t\t\t\tif (result) {\r\n\t\t\t\t\t\tfor (const item of result) {\r\n\t\t\t\t\t\t\tyCategorySet.add(item.metric?.le);\r\n\t\t\t\t\t\t\tfor (const itemValue of item.values) {\r\n\t\t\t\t\t\t\t\txCategorySet.add(this.epochToTimeString(itemValue[0]));\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tthis.xAxisCategories = Array.from(xCategorySet);\r\n\t\tthis.yAxisCategories = Array.from(yCategorySet);\r\n\r\n\t\tconst data: number[][] = [];\r\n\r\n\t\tfor (const key in seriesData) {\r\n\t\t\tif (key === 'response') {\r\n\t\t\t\tif (Object.prototype.hasOwnProperty.call(seriesData, key)) {\r\n\t\t\t\t\tconst dataSet = seriesData[key];\r\n\t\t\t\t\tconst result = dataSet?.result || dataSet?.data?.result;\r\n\t\t\t\t\tif (result) {\r\n\t\t\t\t\t\tfor (const item of result) {\r\n\t\t\t\t\t\t\tconst yValue = item.metric?.le;\r\n\t\t\t\t\t\t\tconst yIndex = this.yAxisCategories.indexOf(yValue);\r\n\t\t\t\t\t\t\tfor (const itemValue of item.values) {\r\n\t\t\t\t\t\t\t\tconst epoch = Number(itemValue[0]);\r\n\t\t\t\t\t\t\t\tconst date = new Date(epoch * 1000);\r\n\t\t\t\t\t\t\t\tconst utcTime = Date.UTC(\r\n\t\t\t\t\t\t\t\t\tdate.getUTCFullYear(),\r\n\t\t\t\t\t\t\t\t\tdate.getUTCMonth(),\r\n\t\t\t\t\t\t\t\t\tdate.getUTCDate(),\r\n\t\t\t\t\t\t\t\t\tdate.getUTCHours(),\r\n\t\t\t\t\t\t\t\t\tdate.getUTCMinutes()\r\n\t\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\t\tconst value = Number(itemValue[1]);\r\n\t\t\t\t\t\t\t\tdata.push([utcTime, yIndex, value]);\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\treturn [\r\n\t\t\t{\r\n\t\t\t\ttype: 'heatmap',\r\n\t\t\t\tdata: data,\r\n\t\t\t\tcolsize: 8 * 60 * 1000,\r\n\t\t\t\tborderWidth: 1\r\n\t\t\t} as Highcharts.SeriesHeatmapOptions\r\n\t\t];\r\n\t}\r\n}\r\n"]}