@c8y/ngx-components 1021.66.0 → 1021.70.1

package/esm2022/widgets/implementations/info-gauge/radial-gauge/radial-gauge.service.mjs

@@ -0,0 +1,369 @@
+import { Injectable } from '@angular/core';
+import { DatePipe } from '@c8y/ngx-components';
+import * as i0 from "@angular/core";
+import * as i1 from "@c8y/ngx-components";
+export class RadialGaugeService {
+    constructor(c8yDatePipe) {
+        this.c8yDatePipe = c8yDatePipe;
+        this.containerSize = 400;
+    }
+    setChart(chart) {
+        this.chart = chart;
+    }
+    getChartOptions(gaugeOptions, activeDatapointGauge, selectedPresetId, gaugeOptionsColors, rangeColors, measurement, fractionSize) {
+        const colorArray = this.getColorArray(activeDatapointGauge, rangeColors);
+        return {
+            series: [
+                {
+                    type: 'gauge',
+                    radius: gaugeOptions?.radius || '90%',
+                    center: gaugeOptions?.center || ['50%', '50%'],
+                    startAngle: gaugeOptions?.startAngle || 240,
+                    endAngle: gaugeOptions?.endAngle || 300,
+                    min: activeDatapointGauge?.min || 0,
+                    max: activeDatapointGauge?.max !== undefined && activeDatapointGauge?.max !== null
+                        ? activeDatapointGauge.max
+                        : 100,
+                    // Split properties
+                    splitNumber: gaugeOptions?.splitNumber || 10,
+                    splitLine: {
+                        distance: gaugeOptions?.splitLineDistanceRatio
+                            ? this.containerSize *
+                                gaugeOptions?.axisLineWidthRatio *
+                                gaugeOptions?.splitLineDistanceRatio
+                            : gaugeOptions?.splitLineDistance || -30,
+                        length: gaugeOptions?.splitLineLengthRatio
+                            ? this.containerSize *
+                                gaugeOptions?.axisLineWidthRatio *
+                                gaugeOptions?.splitLineLengthRatio
+                            : gaugeOptions?.splitLineLength || 30,
+                        lineStyle: {
+                            color: selectedPresetId === 'custom' || selectedPresetId === 'grade-rating'
+                                ? gaugeOptions?.splitLineColor
+                                : gaugeOptionsColors?.splitLineColor || '#fff',
+                            width: gaugeOptions?.splitLineWidth || 4
+                        }
+                    },
+                    // Tick properties
+                    axisTick: {
+                        show: gaugeOptions?.tickShow || false,
+                        distance: gaugeOptions?.tickDistanceRatio
+                            ? this.containerSize *
+                                gaugeOptions?.axisLineWidthRatio *
+                                gaugeOptions?.tickDistanceRatio
+                            : gaugeOptions?.tickDistance || -30,
+                        length: gaugeOptions?.tickLengthRatio
+                            ? this.containerSize *
+                                gaugeOptions?.axisLineWidthRatio *
+                                gaugeOptions?.tickLengthRatio
+                            : gaugeOptions?.tickLength || 8,
+                        lineStyle: {
+                            color: selectedPresetId === 'custom' || selectedPresetId === 'grade-rating'
+                                ? gaugeOptions.tickColor
+                                : gaugeOptionsColors?.tickColor || '#fff',
+                            width: gaugeOptions?.tickWidth || 2
+                        }
+                    },
+                    // Axis properties
+                    axisLine: {
+                        lineStyle: {
+                            width: gaugeOptions?.axisLineWidthRatio
+                                ? this.containerSize * gaugeOptions?.axisLineWidthRatio
+                                : gaugeOptions?.axisLineWidth || 30,
+                            color: colorArray
+                        }
+                    },
+                    axisLabel: {
+                        color: selectedPresetId === 'custom' || selectedPresetId === 'grade-rating'
+                            ? gaugeOptions.axisLabelColor
+                            : gaugeOptionsColors?.axisLabelColor || 'inherit',
+                        distance: gaugeOptions?.axisLabelDistanceRatio
+                            ? this.containerSize *
+                                gaugeOptions?.axisLineWidthRatio *
+                                gaugeOptions?.axisLabelDistanceRatio
+                            : gaugeOptions?.axisLabelDistance || 40,
+                        fontSize: gaugeOptions?.axisLabelFontSizeRatio
+                            ? this.clampRelative(gaugeOptions?.axisLabelFontSizeRatio, gaugeOptions?.axisLabelFontSizeMin, gaugeOptions?.axisLabelFontSizeMax)
+                            : gaugeOptions?.axisLabelFontSize || 16,
+                        fontWeight: 'bold',
+                        fontFamily: gaugeOptionsColors?.fontFamily
+                    },
+                    // pointer properties
+                    pointer: {
+                        ...(gaugeOptions?.pointerStyle !== 'default' && {
+                            icon: gaugeOptions?.pointerStyle
+                        }),
+                        show: gaugeOptions?.showPointer || false,
+                        length: gaugeOptions?.pointerLengthRatio
+                            ? gaugeOptions?.pointerLengthRatio *
+                                (this.containerSize * gaugeOptions?.axisLineWidthRatio)
+                            : gaugeOptions?.pointerLength || '65%',
+                        width: gaugeOptions?.pointerWidthRatio
+                            ? this.containerSize *
+                                gaugeOptions?.axisLineWidthRatio *
+                                gaugeOptions?.pointerWidthRatio
+                            : gaugeOptions?.pointerWidth || 40,
+                        offsetCenter: selectedPresetId === 'default'
+                            ? [0, this.containerSize * gaugeOptions?.axisLineWidthRatio * -1]
+                            : [0, gaugeOptions?.pointerOffset || -30],
+                        itemStyle: {
+                            color: selectedPresetId === 'custom'
+                                ? gaugeOptions.pointerColor
+                                : gaugeOptionsColors?.pointerColor || 'inherit'
+                        }
+                    },
+                    // Progress bar properties
+                    progress: {
+                        show: gaugeOptions?.progressBar || false,
+                        roundCap: gaugeOptions?.progressBarRoundCap || false,
+                        width: gaugeOptions?.progressBarWidthRatio
+                            ? this.containerSize *
+                                gaugeOptions?.axisLineWidthRatio *
+                                gaugeOptions?.progressBarWidthRatio
+                            : gaugeOptions?.progressBarWidth || 18,
+                        itemStyle: {
+                            color: selectedPresetId === 'custom'
+                                ? gaugeOptions.progressBarColor
+                                : gaugeOptionsColors?.progressBarColor || 'inherit'
+                        }
+                    },
+                    // Anchor properties
+                    anchor: gaugeOptions?.anchor
+                        ? {
+                            ...gaugeOptions.anchor,
+                            size: gaugeOptions?.anchor?.sizeRatio
+                                ? this.containerSize * gaugeOptions?.anchor?.sizeRatio
+                                : gaugeOptions?.anchor?.size || 45,
+                            itemStyle: {
+                                color: selectedPresetId === 'custom'
+                                    ? gaugeOptions.pointerColor
+                                    : gaugeOptionsColors?.pointerColor
+                            }
+                        }
+                        : undefined,
+                    // Detail properties
+                    detail: {
+                        show: gaugeOptions?.showDetail || false,
+                        valueAnimation: true,
+                        offsetCenter: gaugeOptions?.detailOffsetCenterYRatio
+                            ? [0, gaugeOptions?.detailOffsetCenterYRatio * this.containerSize]
+                            : gaugeOptions?.detailOffsetCenter || [0, 0],
+                        formatter: () => {
+                            const value = measurement?.value.toFixed(fractionSize) || 0;
+                            const unit = activeDatapointGauge?.unit || measurement?.unit || '';
+                            const date = new Date(measurement?.date);
+                            const formattedDate = this.c8yDatePipe.transform(date);
+                            return `{value|${value}}{unit|${unit}} \n {date|${formattedDate}} `;
+                        },
+                        color: 'inherit',
+                        lineHeight: gaugeOptions?.measurementValueFontRatio
+                            ? this.clampRelative(gaugeOptions?.measurementValueFontRatio * 0.9, gaugeOptions?.measurementValueFontSizeMin, gaugeOptions?.measurementValueFontSizeMax)
+                            : gaugeOptions?.measurementValueFontSize || 32,
+                        rich: {
+                            value: {
+                                fontSize: gaugeOptions?.measurementValueFontRatio
+                                    ? this.clampRelative(fractionSize > 5 || measurement?.value > 9999
+                                        ? gaugeOptions?.measurementValueFontRatio * 0.5
+                                        : gaugeOptions?.measurementValueFontRatio, gaugeOptions?.measurementValueFontSizeMin, gaugeOptions?.measurementValueFontSizeMax)
+                                    : gaugeOptions?.measurementValueFontSize || 32,
+                                fontWeight: 'bolder',
+                                fontFamily: gaugeOptionsColors?.fontFamily,
+                                color: selectedPresetId === 'custom'
+                                    ? gaugeOptions.measurementValueColor
+                                    : gaugeOptionsColors?.measurementValueColor || '#777'
+                            },
+                            unit: {
+                                fontSize: gaugeOptions?.unitFontRatio
+                                    ? this.clampRelative(gaugeOptions?.unitFontRatio, gaugeOptions?.unitFontMin, gaugeOptions?.unitFontMax)
+                                    : gaugeOptions?.unitFontSize || 20,
+                                fontFamily: gaugeOptionsColors?.fontFamily,
+                                color: selectedPresetId === 'custom'
+                                    ? gaugeOptions?.unitColor
+                                    : gaugeOptionsColors?.unitColor || '#999'
+                            },
+                            date: {
+                                fontSize: gaugeOptions?.dateFontRatio
+                                    ? this.clampRelative(gaugeOptions?.dateFontRatio, gaugeOptions?.dateFontSizeMin, gaugeOptions?.dateFontSizeMax)
+                                    : gaugeOptions?.dateFontSize || 12,
+                                fontFamily: gaugeOptionsColors?.fontFamily,
+                                color: selectedPresetId === 'custom'
+                                    ? gaugeOptions?.dateColor
+                                    : gaugeOptionsColors?.dateColor || '#555'
+                            }
+                        }
+                    },
+                    markPoint: {
+                        symbolSize: 0,
+                        offsetCenter: gaugeOptions?.detailOffsetCenter || [0, 0],
+                        data: [
+                            {
+                                x: '50%',
+                                y: '50%',
+                                label: {
+                                    show: gaugeOptions?.showMarkPoint,
+                                    formatter: () => {
+                                        const value = measurement?.value.toFixed(fractionSize) || 0;
+                                        const unit = activeDatapointGauge?.unit || measurement?.unit || '';
+                                        const date = new Date(measurement?.date);
+                                        const formattedDate = this.c8yDatePipe.transform(date);
+                                        return `{value|${value}}{unit|${unit}} \n {date|${formattedDate}} `;
+                                    },
+                                    color: '#fff',
+                                    align: 'center',
+                                    rich: {
+                                        value: {
+                                            fontSize: gaugeOptions?.measurementValueFontRatio
+                                                ? this.clampRelative(fractionSize > 5
+                                                    ? gaugeOptions?.measurementValueFontRatio * 0.5
+                                                    : gaugeOptions?.measurementValueFontRatio, fractionSize > 5
+                                                    ? gaugeOptions.measurementValueFontMin * 0.5
+                                                    : gaugeOptions?.measurementValueFontSizeMin, gaugeOptions?.measurementValueFontSizeMax)
+                                                : gaugeOptions?.measurementValueFontSize || 32,
+                                            fontFamily: gaugeOptionsColors?.fontFamily,
+                                            fontWeight: 'bolder',
+                                            color: gaugeOptionsColors?.knobFontColor || '#777'
+                                        },
+                                        unit: {
+                                            fontSize: gaugeOptions?.unitFontRatio
+                                                ? this.clampRelative(gaugeOptions?.unitFontRatio, gaugeOptions?.unitFontSizeMin, gaugeOptions?.unitFontSizeMax)
+                                                : gaugeOptions?.unitFontSize || 20,
+                                            fontFamily: gaugeOptionsColors?.fontFamily,
+                                            color: gaugeOptionsColors?.knobFontColor || '#999'
+                                        },
+                                        date: {
+                                            fontSize: gaugeOptions?.dateFontRatio
+                                                ? this.clampRelative(gaugeOptions?.dateFontRatio, gaugeOptions?.dateFontSizeMin, gaugeOptions?.dateFontSizeMax)
+                                                : gaugeOptions?.dateFontSize || 12,
+                                            fontFamily: gaugeOptionsColors?.fontFamily,
+                                            color: gaugeOptionsColors?.knobFontColor || '#555'
+                                        }
+                                    }
+                                }
+                            }
+                        ]
+                    },
+                    data: [
+                        {
+                            value: 0 || measurement?.value
+                        }
+                    ]
+                }
+            ]
+        };
+    }
+    updateRangeColors() {
+        if (!this.chart) {
+            return;
+        }
+        return {
+            default: getComputedStyle(this.chart.nativeElement).getPropertyValue('--c8y-form-control-border-color-default'),
+            yellow: getComputedStyle(this.chart.nativeElement).getPropertyValue('--c8y-palette-status-warning'),
+            red: getComputedStyle(this.chart.nativeElement).getPropertyValue('--c8y-palette-status-danger')
+        };
+    }
+    updateGaugeOptionsColors() {
+        if (!this.chart) {
+            return;
+        }
+        return {
+            splitLineColor: getComputedStyle(this.chart.nativeElement).getPropertyValue('--c8y-root-component-background-default'),
+            tickColor: getComputedStyle(this.chart.nativeElement).getPropertyValue('--c8y-root-component-background-default'),
+            axisLabelColor: getComputedStyle(this.chart.nativeElement).getPropertyValue('--c8y-root-component-color-default'),
+            pointerColor: getComputedStyle(this.chart.nativeElement).getPropertyValue('--c8y-root-component-color-default'),
+            knobColor: getComputedStyle(this.chart.nativeElement).getPropertyValue('--c8y-root-component-color-default'),
+            knobFontColor: getComputedStyle(this.chart.nativeElement).getPropertyValue('--c8y-root-component-background-default'),
+            measurementValueColor: getComputedStyle(this.chart.nativeElement).getPropertyValue('--c8y-root-component-color-default'),
+            unitColor: getComputedStyle(this.chart.nativeElement).getPropertyValue('--c8y-root-component-color-default'),
+            dateColor: getComputedStyle(this.chart.nativeElement).getPropertyValue('--c8y-root-component-text-muted'),
+            progressBarColor: getComputedStyle(this.chart.nativeElement).getPropertyValue('--c8y-root-component-brand-primary'),
+            fontFamily: getComputedStyle(document.body).getPropertyValue('font-family')
+        };
+    }
+    getColorArray(activeDatapointGauge, rangeColors) {
+        const min = activeDatapointGauge?.min ?? 0;
+        const max = activeDatapointGauge?.max ?? 100;
+        const range = max - min;
+        const yellowMin = activeDatapointGauge?.yellowRangeMin;
+        const yellowMax = activeDatapointGauge?.yellowRangeMax;
+        const redMin = activeDatapointGauge?.redRangeMin;
+        const redMax = activeDatapointGauge?.redRangeMax;
+        const ranges = [];
+        // First add red range
+        if (redMin != null && redMax != null && redMin < redMax) {
+            ranges.push({ start: redMin, end: redMax, color: rangeColors.red });
+        }
+        // Then add yellow, but clip out any overlap with red
+        if (yellowMin != null && yellowMax != null && yellowMin < yellowMax) {
+            const redRange = ranges.find(r => r.color === rangeColors.red);
+            if (!redRange ||
+                yellowMax <= redRange.start || // yellow ends before red
+                yellowMin >= redRange.end // yellow starts after red
+            ) {
+                // no overlap
+                ranges.push({ start: yellowMin, end: yellowMax, color: rangeColors.yellow });
+            }
+            else {
+                // partial overlap – split yellow into non-overlapping parts
+                if (yellowMin < redRange.start) {
+                    ranges.push({
+                        start: yellowMin,
+                        end: Math.min(yellowMax, redRange.start),
+                        color: rangeColors.yellow
+                    });
+                }
+                if (yellowMax > redRange.end) {
+                    ranges.push({
+                        start: Math.max(yellowMin, redRange.end),
+                        end: yellowMax,
+                        color: rangeColors.yellow
+                    });
+                }
+            }
+        }
+        // Sort by start position
+        ranges.sort((a, b) => a.start - b.start);
+        // Build segments
+        const segments = [];
+        let current = min;
+        for (const { start, end, color } of ranges) {
+            if (start > current) {
+                // Default fill before this range
+                segments.push([(start - min) / range, rangeColors.default]);
+            }
+            // Start color
+            segments.push([(start - min) / range, color]);
+            // End color
+            segments.push([(end - min) / range, color]);
+            current = Math.max(current, end);
+        }
+        // Fill remaining with default
+        if (current < max) {
+            segments.push([(current - min) / range, rangeColors.default]);
+        }
+        if (segments.length === 0 || segments[segments.length - 1][0] < 1) {
+            segments.push([1, rangeColors.default]);
+        }
+        return segments;
+    }
+    clampRelative(ratio, min, max) {
+        const clampedValue = this.containerSize * ratio;
+        if (clampedValue < min) {
+            return min;
+        }
+        else if (clampedValue > max) {
+            return max;
+        }
+        else {
+            return clampedValue;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RadialGaugeService, deps: [{ token: i1.DatePipe }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RadialGaugeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RadialGaugeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.DatePipe }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"radial-gauge.service.js","sourceRoot":"","sources":["../../../../../../widgets/implementations/info-gauge/radial-gauge/radial-gauge.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ElementRef, Injectable } from '@angular/core';\nimport { KPIDetails } from '@c8y/ngx-components/datapoint-selector';\nimport { GaugeOptions, GaugeOptionsColors } from '../info-gauge-widget-config/gauge.model';\nimport { IMeasurementValue } from '@c8y/client';\nimport { DatePipe } from '@c8y/ngx-components';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class RadialGaugeService {\n  private chart: ElementRef;\n  containerSize = 400;\n\n  constructor(private c8yDatePipe: DatePipe) {}\n\n  setChart(chart: ElementRef): void {\n    this.chart = chart;\n  }\n\n  getChartOptions(\n    gaugeOptions: GaugeOptions,\n    activeDatapointGauge: KPIDetails,\n    selectedPresetId: string,\n    gaugeOptionsColors: GaugeOptionsColors,\n    rangeColors: { default: string; yellow: string; red: string },\n    measurement: IMeasurementValue,\n    fractionSize: number\n  ) {\n    const colorArray = this.getColorArray(activeDatapointGauge, rangeColors);\n\n    return {\n      series: [\n        {\n          type: 'gauge',\n          radius: gaugeOptions?.radius || '90%',\n          center: gaugeOptions?.center || ['50%', '50%'],\n          startAngle: gaugeOptions?.startAngle || 240,\n          endAngle: gaugeOptions?.endAngle || 300,\n          min: activeDatapointGauge?.min || 0,\n          max:\n            activeDatapointGauge?.max !== undefined && activeDatapointGauge?.max !== null\n              ? activeDatapointGauge.max\n              : 100,\n\n          // Split properties\n          splitNumber: gaugeOptions?.splitNumber || 10,\n          splitLine: {\n            distance: gaugeOptions?.splitLineDistanceRatio\n              ? this.containerSize *\n                gaugeOptions?.axisLineWidthRatio *\n                gaugeOptions?.splitLineDistanceRatio\n              : gaugeOptions?.splitLineDistance || -30,\n\n            length: gaugeOptions?.splitLineLengthRatio\n              ? this.containerSize *\n                gaugeOptions?.axisLineWidthRatio *\n                gaugeOptions?.splitLineLengthRatio\n              : gaugeOptions?.splitLineLength || 30,\n\n            lineStyle: {\n              color:\n                selectedPresetId === 'custom' || selectedPresetId === 'grade-rating'\n                  ? gaugeOptions?.splitLineColor\n                  : gaugeOptionsColors?.splitLineColor || '#fff',\n              width: gaugeOptions?.splitLineWidth || 4\n            }\n          },\n\n          // Tick properties\n          axisTick: {\n            show: gaugeOptions?.tickShow || false,\n            distance: gaugeOptions?.tickDistanceRatio\n              ? this.containerSize *\n                gaugeOptions?.axisLineWidthRatio *\n                gaugeOptions?.tickDistanceRatio\n              : gaugeOptions?.tickDistance || -30,\n            length: gaugeOptions?.tickLengthRatio\n              ? this.containerSize *\n                gaugeOptions?.axisLineWidthRatio *\n                gaugeOptions?.tickLengthRatio\n              : gaugeOptions?.tickLength || 8,\n            lineStyle: {\n              color:\n                selectedPresetId === 'custom' || selectedPresetId === 'grade-rating'\n                  ? gaugeOptions.tickColor\n                  : gaugeOptionsColors?.tickColor || '#fff',\n              width: gaugeOptions?.tickWidth || 2\n            }\n          },\n\n          // Axis properties\n          axisLine: {\n            lineStyle: {\n              width: gaugeOptions?.axisLineWidthRatio\n                ? this.containerSize * gaugeOptions?.axisLineWidthRatio\n                : gaugeOptions?.axisLineWidth || 30,\n              color: colorArray\n            }\n          },\n\n          axisLabel: {\n            color:\n              selectedPresetId === 'custom' || selectedPresetId === 'grade-rating'\n                ? gaugeOptions.axisLabelColor\n                : gaugeOptionsColors?.axisLabelColor || 'inherit',\n            distance: gaugeOptions?.axisLabelDistanceRatio\n              ? this.containerSize *\n                gaugeOptions?.axisLineWidthRatio *\n                gaugeOptions?.axisLabelDistanceRatio\n              : gaugeOptions?.axisLabelDistance || 40,\n            fontSize: gaugeOptions?.axisLabelFontSizeRatio\n              ? this.clampRelative(\n                  gaugeOptions?.axisLabelFontSizeRatio,\n                  gaugeOptions?.axisLabelFontSizeMin,\n                  gaugeOptions?.axisLabelFontSizeMax\n                )\n              : gaugeOptions?.axisLabelFontSize || 16,\n            fontWeight: 'bold',\n            fontFamily: gaugeOptionsColors?.fontFamily\n          },\n\n          // pointer properties\n          pointer: {\n            ...(gaugeOptions?.pointerStyle !== 'default' && {\n              icon: gaugeOptions?.pointerStyle\n            }),\n            show: gaugeOptions?.showPointer || false,\n            length: gaugeOptions?.pointerLengthRatio\n              ? gaugeOptions?.pointerLengthRatio *\n                (this.containerSize * gaugeOptions?.axisLineWidthRatio)\n              : gaugeOptions?.pointerLength || '65%',\n            width: gaugeOptions?.pointerWidthRatio\n              ? this.containerSize *\n                gaugeOptions?.axisLineWidthRatio *\n                gaugeOptions?.pointerWidthRatio\n              : gaugeOptions?.pointerWidth || 40,\n            offsetCenter:\n              selectedPresetId === 'default'\n                ? [0, this.containerSize * gaugeOptions?.axisLineWidthRatio * -1]\n                : [0, gaugeOptions?.pointerOffset || -30],\n            itemStyle: {\n              color:\n                selectedPresetId === 'custom'\n                  ? gaugeOptions.pointerColor\n                  : gaugeOptionsColors?.pointerColor || 'inherit'\n            }\n          },\n\n          // Progress bar properties\n          progress: {\n            show: gaugeOptions?.progressBar || false,\n            roundCap: gaugeOptions?.progressBarRoundCap || false,\n            width: gaugeOptions?.progressBarWidthRatio\n              ? this.containerSize *\n                gaugeOptions?.axisLineWidthRatio *\n                gaugeOptions?.progressBarWidthRatio\n              : gaugeOptions?.progressBarWidth || 18,\n            itemStyle: {\n              color:\n                selectedPresetId === 'custom'\n                  ? gaugeOptions.progressBarColor\n                  : gaugeOptionsColors?.progressBarColor || 'inherit'\n            }\n          },\n\n          // Anchor properties\n          anchor: gaugeOptions?.anchor\n            ? {\n                ...gaugeOptions.anchor,\n                size: gaugeOptions?.anchor?.sizeRatio\n                  ? this.containerSize * gaugeOptions?.anchor?.sizeRatio\n                  : gaugeOptions?.anchor?.size || 45,\n                itemStyle: {\n                  color:\n                    selectedPresetId === 'custom'\n                      ? gaugeOptions.pointerColor\n                      : gaugeOptionsColors?.pointerColor\n                }\n              }\n            : undefined,\n\n          // Detail properties\n          detail: {\n            show: gaugeOptions?.showDetail || false,\n            valueAnimation: true,\n            offsetCenter: gaugeOptions?.detailOffsetCenterYRatio\n              ? [0, gaugeOptions?.detailOffsetCenterYRatio * this.containerSize]\n              : gaugeOptions?.detailOffsetCenter || [0, 0],\n\n            formatter: () => {\n              const value = measurement?.value.toFixed(fractionSize) || 0;\n              const unit = activeDatapointGauge?.unit || measurement?.unit || '';\n              const date = new Date(measurement?.date);\n              const formattedDate = this.c8yDatePipe.transform(date);\n              return `{value|${value}}{unit|${unit}} \\n {date|${formattedDate}} `;\n            },\n            color: 'inherit',\n            lineHeight: gaugeOptions?.measurementValueFontRatio\n              ? this.clampRelative(\n                  gaugeOptions?.measurementValueFontRatio * 0.9,\n                  gaugeOptions?.measurementValueFontSizeMin,\n                  gaugeOptions?.measurementValueFontSizeMax\n                )\n              : gaugeOptions?.measurementValueFontSize || 32,\n            rich: {\n              value: {\n                fontSize: gaugeOptions?.measurementValueFontRatio\n                  ? this.clampRelative(\n                      fractionSize > 5 || measurement?.value > 9999\n                        ? gaugeOptions?.measurementValueFontRatio * 0.5\n                        : gaugeOptions?.measurementValueFontRatio,\n                      gaugeOptions?.measurementValueFontSizeMin,\n                      gaugeOptions?.measurementValueFontSizeMax\n                    )\n                  : gaugeOptions?.measurementValueFontSize || 32,\n                fontWeight: 'bolder',\n                fontFamily: gaugeOptionsColors?.fontFamily,\n                color:\n                  selectedPresetId === 'custom'\n                    ? gaugeOptions.measurementValueColor\n                    : gaugeOptionsColors?.measurementValueColor || '#777'\n              },\n              unit: {\n                fontSize: gaugeOptions?.unitFontRatio\n                  ? this.clampRelative(\n                      gaugeOptions?.unitFontRatio,\n                      gaugeOptions?.unitFontMin,\n                      gaugeOptions?.unitFontMax\n                    )\n                  : gaugeOptions?.unitFontSize || 20,\n                fontFamily: gaugeOptionsColors?.fontFamily,\n                color:\n                  selectedPresetId === 'custom'\n                    ? gaugeOptions?.unitColor\n                    : gaugeOptionsColors?.unitColor || '#999'\n              },\n              date: {\n                fontSize: gaugeOptions?.dateFontRatio\n                  ? this.clampRelative(\n                      gaugeOptions?.dateFontRatio,\n                      gaugeOptions?.dateFontSizeMin,\n                      gaugeOptions?.dateFontSizeMax\n                    )\n                  : gaugeOptions?.dateFontSize || 12,\n                fontFamily: gaugeOptionsColors?.fontFamily,\n                color:\n                  selectedPresetId === 'custom'\n                    ? gaugeOptions?.dateColor\n                    : gaugeOptionsColors?.dateColor || '#555'\n              }\n            }\n          },\n          markPoint: {\n            symbolSize: 0,\n            offsetCenter: gaugeOptions?.detailOffsetCenter || [0, 0],\n            data: [\n              {\n                x: '50%',\n                y: '50%',\n                label: {\n                  show: gaugeOptions?.showMarkPoint,\n                  formatter: () => {\n                    const value = measurement?.value.toFixed(fractionSize) || 0;\n                    const unit = activeDatapointGauge?.unit || measurement?.unit || '';\n                    const date = new Date(measurement?.date);\n                    const formattedDate = this.c8yDatePipe.transform(date);\n                    return `{value|${value}}{unit|${unit}} \\n {date|${formattedDate}} `;\n                  },\n                  color: '#fff',\n                  align: 'center',\n                  rich: {\n                    value: {\n                      fontSize: gaugeOptions?.measurementValueFontRatio\n                        ? this.clampRelative(\n                            fractionSize > 5\n                              ? gaugeOptions?.measurementValueFontRatio * 0.5\n                              : gaugeOptions?.measurementValueFontRatio,\n                            fractionSize > 5\n                              ? gaugeOptions.measurementValueFontMin * 0.5\n                              : gaugeOptions?.measurementValueFontSizeMin,\n                            gaugeOptions?.measurementValueFontSizeMax\n                          )\n                        : gaugeOptions?.measurementValueFontSize || 32,\n                      fontFamily: gaugeOptionsColors?.fontFamily,\n                      fontWeight: 'bolder',\n                      color: gaugeOptionsColors?.knobFontColor || '#777'\n                    },\n                    unit: {\n                      fontSize: gaugeOptions?.unitFontRatio\n                        ? this.clampRelative(\n                            gaugeOptions?.unitFontRatio,\n                            gaugeOptions?.unitFontSizeMin,\n                            gaugeOptions?.unitFontSizeMax\n                          )\n                        : gaugeOptions?.unitFontSize || 20,\n                      fontFamily: gaugeOptionsColors?.fontFamily,\n                      color: gaugeOptionsColors?.knobFontColor || '#999'\n                    },\n                    date: {\n                      fontSize: gaugeOptions?.dateFontRatio\n                        ? this.clampRelative(\n                            gaugeOptions?.dateFontRatio,\n                            gaugeOptions?.dateFontSizeMin,\n                            gaugeOptions?.dateFontSizeMax\n                          )\n                        : gaugeOptions?.dateFontSize || 12,\n                      fontFamily: gaugeOptionsColors?.fontFamily,\n                      color: gaugeOptionsColors?.knobFontColor || '#555'\n                    }\n                  }\n                }\n              }\n            ]\n          },\n          data: [\n            {\n              value: 0 || measurement?.value\n            }\n          ]\n        }\n      ]\n    };\n  }\n\n  updateRangeColors(): any {\n    if (!this.chart) {\n      return;\n    }\n\n    return {\n      default: getComputedStyle(this.chart.nativeElement).getPropertyValue(\n        '--c8y-form-control-border-color-default'\n      ),\n      yellow: getComputedStyle(this.chart.nativeElement).getPropertyValue(\n        '--c8y-palette-status-warning'\n      ),\n      red: getComputedStyle(this.chart.nativeElement).getPropertyValue(\n        '--c8y-palette-status-danger'\n      )\n    };\n  }\n\n  updateGaugeOptionsColors(): any {\n    if (!this.chart) {\n      return;\n    }\n\n    return {\n      splitLineColor: getComputedStyle(this.chart.nativeElement).getPropertyValue(\n        '--c8y-root-component-background-default'\n      ),\n      tickColor: getComputedStyle(this.chart.nativeElement).getPropertyValue(\n        '--c8y-root-component-background-default'\n      ),\n      axisLabelColor: getComputedStyle(this.chart.nativeElement).getPropertyValue(\n        '--c8y-root-component-color-default'\n      ),\n      pointerColor: getComputedStyle(this.chart.nativeElement).getPropertyValue(\n        '--c8y-root-component-color-default'\n      ),\n      knobColor: getComputedStyle(this.chart.nativeElement).getPropertyValue(\n        '--c8y-root-component-color-default'\n      ),\n      knobFontColor: getComputedStyle(this.chart.nativeElement).getPropertyValue(\n        '--c8y-root-component-background-default'\n      ),\n      measurementValueColor: getComputedStyle(this.chart.nativeElement).getPropertyValue(\n        '--c8y-root-component-color-default'\n      ),\n      unitColor: getComputedStyle(this.chart.nativeElement).getPropertyValue(\n        '--c8y-root-component-color-default'\n      ),\n      dateColor: getComputedStyle(this.chart.nativeElement).getPropertyValue(\n        '--c8y-root-component-text-muted'\n      ),\n      progressBarColor: getComputedStyle(this.chart.nativeElement).getPropertyValue(\n        '--c8y-root-component-brand-primary'\n      ),\n      fontFamily: getComputedStyle(document.body).getPropertyValue('font-family')\n    };\n  }\n\n  private getColorArray(\n    activeDatapointGauge: KPIDetails,\n    rangeColors: { default: string; yellow: string; red: string }\n  ): [number, string][] {\n    const min = activeDatapointGauge?.min ?? 0;\n    const max = activeDatapointGauge?.max ?? 100;\n    const range = max - min;\n\n    const yellowMin = activeDatapointGauge?.yellowRangeMin;\n    const yellowMax = activeDatapointGauge?.yellowRangeMax;\n    const redMin = activeDatapointGauge?.redRangeMin;\n    const redMax = activeDatapointGauge?.redRangeMax;\n\n    type Range = { start: number; end: number; color: string };\n\n    const ranges: Range[] = [];\n\n    // First add red range\n    if (redMin != null && redMax != null && redMin < redMax) {\n      ranges.push({ start: redMin, end: redMax, color: rangeColors.red });\n    }\n\n    // Then add yellow, but clip out any overlap with red\n    if (yellowMin != null && yellowMax != null && yellowMin < yellowMax) {\n      const redRange = ranges.find(r => r.color === rangeColors.red);\n\n      if (\n        !redRange ||\n        yellowMax <= redRange.start || // yellow ends before red\n        yellowMin >= redRange.end // yellow starts after red\n      ) {\n        // no overlap\n        ranges.push({ start: yellowMin, end: yellowMax, color: rangeColors.yellow });\n      } else {\n        // partial overlap – split yellow into non-overlapping parts\n        if (yellowMin < redRange.start) {\n          ranges.push({\n            start: yellowMin,\n            end: Math.min(yellowMax, redRange.start),\n            color: rangeColors.yellow\n          });\n        }\n        if (yellowMax > redRange.end) {\n          ranges.push({\n            start: Math.max(yellowMin, redRange.end),\n            end: yellowMax,\n            color: rangeColors.yellow\n          });\n        }\n      }\n    }\n\n    // Sort by start position\n    ranges.sort((a, b) => a.start - b.start);\n\n    // Build segments\n    const segments: [number, string][] = [];\n    let current = min;\n\n    for (const { start, end, color } of ranges) {\n      if (start > current) {\n        // Default fill before this range\n        segments.push([(start - min) / range, rangeColors.default]);\n      }\n      // Start color\n      segments.push([(start - min) / range, color]);\n      // End color\n      segments.push([(end - min) / range, color]);\n\n      current = Math.max(current, end);\n    }\n\n    // Fill remaining with default\n    if (current < max) {\n      segments.push([(current - min) / range, rangeColors.default]);\n    }\n\n    if (segments.length === 0 || segments[segments.length - 1][0] < 1) {\n      segments.push([1, rangeColors.default]);\n    }\n\n    return segments;\n  }\n\n  private clampRelative(ratio: number, min: number, max: number): number {\n    const clampedValue = this.containerSize * ratio;\n    if (clampedValue < min) {\n      return min;\n    } else if (clampedValue > max) {\n      return max;\n    } else {\n      return clampedValue;\n    }\n  }\n}\n"]}

package/fesm2022/c8y-ngx-components-echart.mjs

@@ -1496,12 +1496,14 @@ class ChartsComponent {
         this.chartEventsService = inject(ChartEventsService);
         this.chartAlarmsService = inject(ChartAlarmsService);
         this.widgetTimeContextDateRangeService = inject(WidgetTimeContextDateRangeService);
+        this.loadedTimeRange = null;
         this.chartOption$ = this.configChangedSubject.pipe(switchMap(() => this.loadAlarmsAndEvents()), switchMap(() => this.fetchSeriesForDatapoints$()), switchMap((datapointsWithValues) => {
             if (datapointsWithValues.length === 0) {
                 this.echartsInstance?.clear();
                 this.showLoadMore = false;
                 return of(this.getDefaultChartOptions());
             }
+            this.loadedTimeRange = { ...this.getTimeRange() };
             return this.getChartOptions(datapointsWithValues);
         }), tap(v => {
             if (v['empty']) {
@@ -1510,7 +1512,13 @@ class ChartsComponent {
             this.chartRealtimeService.stopRealtime();
             this.startRealtimeIfPossible();
             if (this.echartsInstance) {
-                this.echartsInstance.setOption(v, true);
+                /**
+                 * * Set the chart options
+                 * First parameter is the options to set
+                 * Second parameter is a boolean to indicate that the chart should be re-rendered as we do not want to merge.
+                 * Third parameter is a boolean to indicate that we want to lazy load the chart.
+                 */
+                this.echartsInstance.setOption(v, true, true);
                 const options = this.echartsInstance.getOption();
                 const dataZoom = options['dataZoom'][0];
                 if (dataZoom.start !== 0) {
@@ -1520,7 +1528,16 @@ class ChartsComponent {
             this.sliderZoomUsed = false;
         }));
     }
-    ngOnChanges() {
+    ngOnChanges(changes) {
+        const currentTimeRange = this.getTimeRange();
+        // Check if the current time range is within the loaded time range to avoid unnecessary updates
+        if (this.loadedTimeRange &&
+            new Date(currentTimeRange.dateFrom) >= new Date(this.loadedTimeRange.dateFrom) &&
+            new Date(currentTimeRange.dateTo) <= new Date(this.loadedTimeRange.dateTo) &&
+            changes.config.previousValue?.dateFrom !== changes.config.currentValue.dateFrom &&
+            changes.config.previousValue?.dateTo !== changes.config.currentValue.dateTo) {
+            return;
+        }
         this.configChangedSubject.next();
     }
     ngOnInit() {
@@ -1662,6 +1679,36 @@ class ChartsComponent {
             timeout = setTimeout(() => func(...args), wait);
         };
     }
+    /**
+     * Toggles the visibility of a series in the chart based on the provided datapoint.
+     * @param datapoint - The datapoint to toggle visibility for.
+     */
+    toggleDatapointSeriesVisibility(datapoint) {
+        const series = this.echartsInstance.getOption().series;
+        const seriesToUpdate = series.find(s => s.datapointLabel === datapoint.label);
+        if (seriesToUpdate) {
+            this.echartsInstance.dispatchAction({
+                type: 'legendToggleSelect',
+                name: seriesToUpdate.name
+            });
+        }
+    }
+    /**
+     * Toggles the visibility of a series in the chart based on the provided alarm or event.
+     * @param alarmOrEvent - The alarm or event to toggle visibility for.
+     */
+    toggleAlarmEventSeriesVisibility(alarmOrEvent) {
+        const series = this.echartsInstance.getOption().series;
+        const seriesToUpdate = series.filter(s => s.name === `${alarmOrEvent.label}-markPoint` || s.name === `${alarmOrEvent.label}-markLine`);
+        if (seriesToUpdate) {
+            seriesToUpdate.forEach(s => {
+                this.echartsInstance.dispatchAction({
+                    type: 'legendToggleSelect',
+                    name: s.name
+                });
+            });
+        }
+    }
     getDefaultChartOptions() {
         return {
             title: {