@c8y/ngx-components 1021.51.1 → 1021.54.2

package/esm2022/echart/services/echarts-options.service.mjs

@@ -0,0 +1,857 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Injectable } from '@angular/core';
+import { DatePipe } from '@c8y/ngx-components';
+import { YAxisService } from './y-axis.service';
+import { ChartTypesService } from './chart-types.service';
+import { AlarmStatus } from '@c8y/client';
+import { ICONS_MAP } from '../models/svg-icons.model';
+import { Router } from '@angular/router';
+import { AlarmSeverityToIconPipe, AlarmSeverityToLabelPipe } from '@c8y/ngx-components/alarms';
+import { INTERVALS } from '@c8y/ngx-components/interval-picker';
+import * as i0 from "@angular/core";
+import * as i1 from "@c8y/ngx-components";
+import * as i2 from "./y-axis.service";
+import * as i3 from "./chart-types.service";
+import * as i4 from "@c8y/ngx-components/alarms";
+import * as i5 from "@angular/router";
+const INDEX_HTML = '/index.html';
+export class EchartsOptionsService {
+    constructor(datePipe, yAxisService, chartTypesService, severityIconPipe, severityLabelPipe, router) {
+        this.datePipe = datePipe;
+        this.yAxisService = yAxisService;
+        this.chartTypesService = chartTypesService;
+        this.severityIconPipe = severityIconPipe;
+        this.severityLabelPipe = severityLabelPipe;
+        this.router = router;
+        this.TOOLTIP_WIDTH = 300;
+    }
+    getChartOptions(datapointsWithValues, timeRange, showSplitLines, events, alarms, displayOptions, selectedTimeRange, aggregatedDatapoints, sliderZoomUsed = false) {
+        const yAxis = this.yAxisService.getYAxis(datapointsWithValues, {
+            showSplitLines: showSplitLines.YAxis,
+            mergeMatchingDatapoints: displayOptions.mergeMatchingDatapoints,
+            showLabelAndUnit: displayOptions.showLabelAndUnit
+        });
+        const leftAxis = yAxis.filter(yx => yx.position === 'left');
+        const gridLeft = leftAxis.length ? leftAxis.length * this.yAxisService.Y_AXIS_OFFSET : 16;
+        const rightAxis = yAxis.filter(yx => yx.position === 'right');
+        const gridRight = rightAxis.length ? rightAxis.length * this.yAxisService.Y_AXIS_OFFSET : 16;
+        let intervalInMs = this.calculateExtendedIntervalInMs(selectedTimeRange?.interval || timeRange.interval || 'hours', selectedTimeRange || timeRange);
+        if (sliderZoomUsed) {
+            intervalInMs = this.calculateExtendedIntervalInMs(timeRange.interval || 'hours', timeRange);
+        }
+        return {
+            grid: {
+                containLabel: false, // axis labels are not taken into account to calculate graph grid
+                left: gridLeft,
+                top: 16,
+                right: gridRight,
+                bottom: 68
+            },
+            dataZoom: [
+                {
+                    type: 'inside',
+                    // TODO: use 'none' only when this bug is fixed https://github.com/apache/echarts/issues/17858
+                    filterMode: datapointsWithValues.some(dp => dp.lineType === 'bars') ? 'filter' : 'none',
+                    zoomOnMouseWheel: true,
+                    startValue: selectedTimeRange
+                        ? selectedTimeRange.dateFrom.valueOf()
+                        : timeRange.dateFrom.valueOf(),
+                    endValue: selectedTimeRange
+                        ? selectedTimeRange.dateTo.valueOf()
+                        : timeRange.dateTo.valueOf()
+                },
+                {
+                    type: 'slider',
+                    show: displayOptions.showSlider,
+                    bottom: 8,
+                    realtime: false
+                }
+            ], // on realtime, 'none' will cause extending chart line to left edge of the chart
+            animation: false,
+            toolbox: {
+                show: true,
+                itemSize: 0, // toolbox is needed for zooming in action, but we provide our own buttons
+                feature: {
+                    dataZoom: {
+                        yAxisIndex: 'none'
+                    }
+                }
+            },
+            tooltip: {
+                trigger: 'axis',
+                axisPointer: {
+                    type: 'cross',
+                    snap: true
+                },
+                backgroundColor: 'rgba(255, 255, 255, 0.9)',
+                formatter: this.getTooltipFormatter(),
+                appendToBody: true,
+                position: this.tooltipPosition(),
+                transitionDuration: 0
+            },
+            legend: {
+                show: false
+            },
+            xAxis: {
+                min: new Date(timeRange.dateFrom).valueOf() - intervalInMs,
+                max: timeRange.dateTo,
+                type: 'time',
+                animation: false,
+                axisPointer: {
+                    label: {
+                        show: false
+                    }
+                },
+                axisLine: {
+                    // align X axis to 0 of Y axis of datapoint with lineType 'bars'
+                    onZeroAxisIndex: datapointsWithValues.findIndex(dp => dp.lineType === 'bars')
+                },
+                axisLabel: {
+                    hideOverlap: true,
+                    borderWidth: 2, // as there is no margin for labels spacing, transparent border is a workaround
+                    borderColor: 'transparent'
+                },
+                splitLine: {
+                    show: showSplitLines.XAxis,
+                    lineStyle: { opacity: 0.8, type: 'dashed', width: 2 }
+                }
+            },
+            yAxis,
+            series: [
+                ...this.getAggregatedSeries(aggregatedDatapoints || []).filter(series => series !== undefined),
+                ...this.getChartSeries(datapointsWithValues, events, alarms, displayOptions)
+            ]
+        };
+    }
+    calculateExtendedIntervalInMs(interval, selectedTimeRange) {
+        let intervalInMs = INTERVALS.find(i => i.id === interval).timespanInMs;
+        switch (interval) {
+            case 'minutes':
+                intervalInMs = INTERVALS.find(i => i.id === interval).timespanInMs * 60;
+                break;
+            case 'hours':
+                intervalInMs = INTERVALS.find(i => i.id === interval).timespanInMs * 24;
+                break;
+            case 'days':
+                intervalInMs = INTERVALS.find(i => i.id === interval).timespanInMs * 28;
+                break;
+            case 'weeks':
+                intervalInMs = INTERVALS.find(i => i.id === interval).timespanInMs * 12;
+                break;
+            case 'months':
+                intervalInMs = INTERVALS.find(i => i.id === interval).timespanInMs * 12;
+                break;
+            case 'custom':
+                intervalInMs =
+                    (new Date(selectedTimeRange.dateTo).valueOf() -
+                        new Date(selectedTimeRange.dateFrom).valueOf()) *
+                        12;
+                break;
+            default:
+                intervalInMs = INTERVALS.find(i => i.id === interval).timespanInMs;
+                break;
+        }
+        return intervalInMs;
+    }
+    getAggregatedSeries(aggregatedDatapoints) {
+        const series = [];
+        aggregatedDatapoints.forEach((dp, idx) => {
+            const renderType = dp.renderType || 'min';
+            if (renderType === 'area') {
+                series.push(this.getSingleSeries(dp, 'min', idx, true, 'aggr'));
+                series.push(this.getSingleSeries(dp, 'max', idx, true, 'aggr'));
+            }
+            else {
+                series.push(this.getSingleSeries(dp, renderType, idx, false, 'aggr'));
+            }
+        });
+        series.forEach((s) => {
+            s.datapointId = 'aggregated';
+            s.typeOfSeries = 'fake';
+            s.itemStyle = {
+                ...s.itemStyle,
+                opacity: 0
+            };
+            s.lineStyle = {
+                ...s.lineStyle,
+                opacity: 0
+            };
+        });
+        return [series[0]];
+    }
+    /**
+     * This method is used to get the series for alarms and events.
+     * @param dp - The data point.
+     * @param renderType - The render type.
+     * @param isMinMaxChart - If the chart is min max chart.
+     * @param items - All alarms or events which should be displayed on the chart.
+     * @param itemType - The item type.
+     * @param id - The id of the device
+     */
+    getAlarmOrEventSeries(dp, renderType, isMinMaxChart = false, items = [], itemType = 'alarm', displayOptions = { displayMarkedLine: true, displayMarkedPoint: true }, id, idx, realtime) {
+        if (!items.length) {
+            return [];
+        }
+        if (!displayOptions.displayMarkedLine && !displayOptions.displayMarkedPoint) {
+            return [];
+        }
+        //filter items that are not __hidden
+        const filteredItems = items.filter(item => !item['__hidden']);
+        const itemsByType = this.groupByType(filteredItems, 'type');
+        const isAlarm = itemType === 'alarm';
+        return Object.entries(itemsByType).flatMap(([type, itemsOfType]) => {
+            // Main series data
+            const mainData = itemsOfType.map(item => [item.creationTime, null, 'markLineFlag']);
+            // Is a specific datapoint template selected for this alarm/event type?
+            let isDpTemplateSelected = false;
+            // MarkPoint data
+            const markPointData = itemsOfType.reduce((acc, item) => {
+                isDpTemplateSelected =
+                    item['selectedDatapoint'] &&
+                        dp['__target'] &&
+                        item['selectedDatapoint']['fragment'] === dp['fragment'] &&
+                        item['selectedDatapoint']['series'] === dp['series'] &&
+                        item['selectedDatapoint']['target'] === dp['__target']['id'];
+                if (dp.__target?.id === item.source.id) {
+                    const isCleared = isAlarm && item.status === AlarmStatus.CLEARED;
+                    const isEvent = !isAlarm;
+                    return acc.concat(this.createMarkPoint(item, dp, isCleared, isEvent, realtime));
+                }
+                else {
+                    if (!item.creationTime) {
+                        return [];
+                    }
+                    return acc.concat([
+                        {
+                            coord: [item.creationTime, null],
+                            name: item.type,
+                            itemType: item.type,
+                            itemStyle: { color: item['color'] }
+                        }
+                    ]);
+                }
+            }, []);
+            // Construct series with markPoint
+            const seriesWithMarkPoint = {
+                id: `${type}/${dp.__target?.id}+${id ? id : ''}-markPoint`,
+                name: `${type}-markPoint`,
+                typeOfSeries: itemType,
+                data: mainData,
+                isDpTemplateSelected,
+                position: 'bottom',
+                silent: true,
+                markPoint: {
+                    showSymbol: true,
+                    symbolKeepAspect: true,
+                    data: markPointData
+                },
+                yAxisIndex: idx,
+                ...this.chartTypesService.getSeriesOptions(dp, isMinMaxChart, renderType)
+            };
+            const markLineData = this.createMarkLine(itemsOfType);
+            // Construct series with markLine
+            const seriesWithMarkLine = {
+                id: `${type}/${dp.__target?.id}+${id ? id : ''}-markLine`,
+                name: `${type}-markLine`,
+                typeOfSeries: itemType,
+                isDpTemplateSelected,
+                data: mainData,
+                markLine: {
+                    showSymbol: false,
+                    symbol: ['none', 'none'], // no symbol at the start/end of the line
+                    data: markLineData
+                },
+                ...this.chartTypesService.getSeriesOptions(dp, isMinMaxChart, renderType)
+            };
+            //depending on the options return only the required series
+            if (displayOptions.displayMarkedLine && displayOptions.displayMarkedPoint) {
+                return [seriesWithMarkLine, seriesWithMarkPoint];
+            }
+            else if (displayOptions.displayMarkedLine) {
+                return [seriesWithMarkLine];
+            }
+            else if (displayOptions.displayMarkedPoint) {
+                return [seriesWithMarkPoint];
+            }
+            else {
+                return null;
+            }
+        });
+    }
+    /**
+     * This method is used to get tooltip formatter for alarms and events.
+     * @param tooltipParams - The tooltip parameters.
+     * @param params - The parameters data.
+     * @param allEvents - All events.
+     * @param allAlarms - All alarms.
+     * @returns The formatted string for the tooltip.
+     */
+    getTooltipFormatterForAlarmAndEvents(tooltipParams, params, allEvents, allAlarms) {
+        if (!Array.isArray(tooltipParams)) {
+            return '';
+        }
+        const XAxisValue = tooltipParams[0].data[0];
+        const YAxisReadings = [];
+        const allSeries = this.echartsInstance?.getOption()['series'];
+        // filter out alarm and event series
+        const allDataPointSeries = allSeries.filter(series => series['typeOfSeries'] !== 'alarm' && series['typeOfSeries'] !== 'event');
+        this.processSeries(allDataPointSeries, XAxisValue, YAxisReadings);
+        // find event and alarm of the same type as the hovered markedLine or markedPoint
+        const event = allEvents.find(e => e.type === params.data.itemType);
+        const alarm = allAlarms.find(a => a.type === params.data.itemType);
+        let value = '';
+        if (event) {
+            value = this.processEvent(event);
+        }
+        if (alarm) {
+            this.processAlarm(alarm).then(alarmVal => {
+                value = alarmVal;
+                YAxisReadings.push(value);
+                const options = this.echartsInstance?.getOption();
+                if (!options.tooltip || !Array.isArray(options.tooltip)) {
+                    return;
+                }
+                const updatedOptions = {
+                    tooltip: options['tooltip'][0]
+                };
+                if (!updatedOptions.tooltip) {
+                    return;
+                }
+                updatedOptions.tooltip.formatter = `<div style="width: ${this.TOOLTIP_WIDTH}px">${YAxisReadings.join('')}</div>`;
+                updatedOptions.tooltip.transitionDuration = 0;
+                updatedOptions.tooltip.position = this.tooltipPosition();
+                this.echartsInstance?.setOption(updatedOptions);
+                return;
+            });
+        }
+        YAxisReadings.push(value);
+        return `<div style="width: 300px">${YAxisReadings.join('')}</div>`;
+    }
+    tooltipPosition() {
+        let lastPositionOfTooltip = {};
+        if (this.tooltipPositionCallback) {
+            return this.tooltipPositionCallback;
+        }
+        this.tooltipPositionCallback = (point, // position of mouse in chart [X, Y]; 0,0 is top left corner
+        _, // tooltip data
+        dom, // tooltip element
+        __, size // size of chart
+        ) => {
+            const offset = 10;
+            const [mouseX, mouseY] = point;
+            const chartWidth = size?.viewSize[0] || 0;
+            const chartHeight = size?.viewSize[1] || 0;
+            const tooltipWidth = size?.contentSize[0] || 0;
+            const tooltipHeight = size?.contentSize[1] || 0;
+            const tooltipRect = dom?.getBoundingClientRect();
+            const tooltipOverflowsBottomEdge = tooltipRect.bottom > window.innerHeight;
+            const tooltipOverflowsRightEdge = tooltipRect.right > window.innerWidth;
+            const tooltipWouldOverflowBottomEdgeOnPositionChange = !lastPositionOfTooltip.top &&
+                tooltipRect.bottom + 2 * offset + tooltipHeight > window.innerHeight;
+            const tooltipWouldOverflowRightEdgeOnPositionChange = !lastPositionOfTooltip.left &&
+                tooltipRect.right + 2 * offset + tooltipWidth > window.innerWidth;
+            let verticalPosition = {
+                top: mouseY + offset
+            };
+            let horizontalPosition = {
+                left: mouseX + offset
+            };
+            if (tooltipOverflowsBottomEdge || tooltipWouldOverflowBottomEdgeOnPositionChange) {
+                verticalPosition = {
+                    bottom: chartHeight - mouseY + offset
+                };
+            }
+            if (tooltipOverflowsRightEdge || tooltipWouldOverflowRightEdgeOnPositionChange) {
+                horizontalPosition = {
+                    right: chartWidth - mouseX + offset
+                };
+            }
+            lastPositionOfTooltip = {
+                ...verticalPosition,
+                ...horizontalPosition
+            };
+            return lastPositionOfTooltip;
+        };
+        return this.tooltipPositionCallback;
+    }
+    /**
+     * This method is used to add the data point info to the tooltip.
+     * @param allDataPointSeries - All the data point series.
+     * @param XAxisValue - The X Axis value.
+     * @param YAxisReadings - The Y Axis readings.
+     */
+    processSeries(allDataPointSeries, XAxisValue, YAxisReadings) {
+        allDataPointSeries.forEach((series) => {
+            let value = '';
+            if (series.id.endsWith('/min')) {
+                value = this.processMinSeries(series, allDataPointSeries, XAxisValue);
+            }
+            else if (!series.id.endsWith('/max')) {
+                value = this.processRegularSeries(series, XAxisValue);
+            }
+            if (value) {
+                YAxisReadings.push(`<div class="d-flex a-i-center p-b-8"><span class='dlt-c8y-icon-circle m-r-4' style='color: ${series.itemStyle.color};'></span>` + // color circle
+                    `<strong>${series.datapointLabel}</strong></div>` + // name
+                    `${value}` // single value or min-max range
+                );
+            }
+        });
+    }
+    /**
+     * This method is used to process the min series.
+     * @param series - The series.
+     * @param allDataPointSeries - All the data point series.
+     * @param XAxisValue - The X Axis value.
+     * @returns The processed value.
+     */
+    processMinSeries(series, allDataPointSeries, XAxisValue) {
+        const minValue = this.findValueForExactOrEarlierTimestamp(series.data, XAxisValue);
+        if (!minValue) {
+            return '';
+        }
+        const maxSeries = allDataPointSeries.find(s => s['id'] === series.id.replace('/min', '/max'));
+        const maxValue = this.findValueForExactOrEarlierTimestamp(maxSeries?.['data'], XAxisValue);
+        return (`<div class="d-flex a-i-center separator-top p-t-8 p-b-8"><label class="text-12 m-r-8 m-b-0">${this.datePipe.transform(minValue[0])}</label>` +
+            `<span class="m-l-auto text-12">${minValue[1]} — ${maxValue?.[1]}` +
+            (series.datapointUnit ? ` ${series.datapointUnit}` : '') +
+            `</span></div>`);
+    }
+    /**
+     * This method is used to process the regular series.
+     * @param series - The series.
+     * @param XAxisValue - The X Axis value.
+     * @returns The processed value.
+     */
+    processRegularSeries(series, XAxisValue) {
+        const seriesValue = this.findValueForExactOrEarlierTimestamp(series.data, XAxisValue);
+        if (!seriesValue) {
+            return '';
+        }
+        return (`<div class="d-flex a-i-center p-t-8 p-b-8 separator-top">` +
+            `<label class="m-b-0 m-r-8 text-12">${this.datePipe.transform(seriesValue[0])}</label><span class="m-l-auto text-12">` +
+            seriesValue[1]?.toString() +
+            (series.datapointUnit ? ` ${series.datapointUnit}` : '') +
+            `</span></div>`);
+    }
+    /**
+     * This method is used to process the event tooltip.
+     * @param event - The event object.
+     * @returns The processed value.
+     */
+    processEvent(event) {
+        let value = `<ul class="list-unstyled small separator-top">`;
+        value += `<li class="p-t-4 p-b-4 d-flex separator-bottom text-no-wrap"><label class="small m-b-0 m-r-8">Event type</label><code class="m-l-auto">${event.type}</code></li>`;
+        value += `<li class="p-t-4 p-b-4 d-flex separator-bottom text-no-wrap"><label class="small m-b-0 m-r-8">Event text</label><span class="m-l-auto">${event.text}<span></li>`;
+        value += `<li class="p-t-4 p-b-4 d-flex separator-bottom text-no-wrap"><label class="small m-b-0 m-r-8">Last update</label><span class="m-l-auto">${this.datePipe.transform(event['lastUpdated'])}<span></li>`;
+        value += `</ul>`;
+        return value;
+    }
+    /**
+     * This method is used to process the alarm tooltip.
+     * @param alarm - The alarm object.
+     * @returns The processed value.
+     */
+    async processAlarm(alarm) {
+        let value = `<ul class="list-unstyled small separator-top m-0">`;
+        value += `<li class="p-t-4 p-b-4 d-flex a-i-center separator-bottom text-no-wrap"><label class="text-label-small m-b-0 m-r-8">Alarm Severity</label>`;
+        value += `<span class="small d-inline-flex a-i-center gap-4 m-l-auto"><i class="stroked-icon icon-14 status dlt-c8y-icon-${this.severityIconPipe.transform(alarm.severity)} ${alarm.severity.toLowerCase()}" > </i> ${this.severityLabelPipe.transform(alarm.severity)} </span></li>`;
+        value += `<li class="p-t-4 p-b-4 d-flex separator-bottom text-no-wrap"><label class="text-label-small m-b-0 m-r-8">Alarm Type</label><span class="small m-l-auto"><code>${alarm.type}</code></span></li>`;
+        value += `<li class="p-t-4 p-b-4 d-flex separator-bottom text-no-wrap"><label class="text-label-small m-b-0 m-r-8">Message</label><span class="small m-l-auto" style="overflow: hidden; text-overflow: ellipsis;" title="${alarm.text}">${alarm.text}</span></li>`;
+        value += `<li class="p-t-4 p-b-4 d-flex separator-bottom text-no-wrap"><label class="text-label-small m-b-0 m-r-8">Last Updated</label><span class="small m-l-auto">${this.datePipe.transform(alarm['lastUpdated'])}</span></li>`;
+        const exists = await this.alarmRouteExists();
+        if (exists) {
+            const currentUrl = window.location.href;
+            const baseUrlIndex = currentUrl.indexOf(INDEX_HTML);
+            const baseUrl = currentUrl.substring(0, baseUrlIndex + INDEX_HTML.length);
+            value += `<li class="p-t-4 p-b-4 d-flex separator-bottom text-no-wrap"><label class="text-label-small m-b-0 m-r-8">Link</label><span class="small m-l-auto"><a href="${baseUrl}#/alarms/${alarm.id}">Alarm Details</a></span></li>`;
+        }
+        value += `<li class="p-t-4 p-b-4 d-flex text-no-wrap"><label class="text-label-small m-b-0 m-r-8">Alarm count</label><span class="small m-l-auto"><span class="badge badge-info">${alarm.count}</span></span></li>`;
+        value += `</ul>`;
+        return value;
+    }
+    async alarmRouteExists() {
+        const exists = this.router.config.some(route => {
+            return `${route.path}` === 'alarms';
+        });
+        return exists;
+    }
+    getChartSeries(datapointsWithValues, events, alarms, displayOptions) {
+        const series = [];
+        let eventSeries = [];
+        let alarmSeries = [];
+        datapointsWithValues.forEach((dp, idx) => {
+            const renderType = dp.renderType || 'min';
+            if (renderType === 'area') {
+                series.push(this.getSingleSeries(dp, 'min', idx, true));
+                series.push(this.getSingleSeries(dp, 'max', idx, true));
+            }
+            else {
+                series.push(this.getSingleSeries(dp, renderType, idx, false));
+            }
+            const newEventSeries = this.getAlarmOrEventSeries(dp, renderType, false, events, 'event', displayOptions, null, idx);
+            const newAlarmSeries = this.getAlarmOrEventSeries(dp, renderType, false, alarms, 'alarm', displayOptions, null, idx);
+            eventSeries = [...eventSeries, ...newEventSeries];
+            alarmSeries = [...alarmSeries, ...newAlarmSeries];
+        });
+        const deduplicateFilterCallback = (obj1, i, arr) => {
+            const duplicates = arr.filter(obj2 => obj1['id'] === obj2['id'] && i !== arr.indexOf(obj2));
+            if (duplicates.length > 0) {
+                return obj1['isDpTemplateSelected'];
+            }
+            return true;
+        };
+        const deduplicateFilterCallbackFallback = (obj1, i, arr) => arr.findIndex(obj2 => obj2['id'] === obj1['id']) === i;
+        let deduplicatedEvents = eventSeries.filter(deduplicateFilterCallback);
+        let deduplicatedAlarms = alarmSeries.filter(deduplicateFilterCallback);
+        if (deduplicatedAlarms.length === 0) {
+            deduplicatedAlarms = alarmSeries.filter(deduplicateFilterCallbackFallback);
+        }
+        if (deduplicatedEvents.length === 0) {
+            deduplicatedEvents = eventSeries.filter(deduplicateFilterCallbackFallback);
+        }
+        return [...series, ...deduplicatedEvents, ...deduplicatedAlarms];
+    }
+    groupByType(items, typeField) {
+        return items.reduce((grouped, item) => {
+            (grouped[item[typeField]] = grouped[item[typeField]] || []).push(item);
+            return grouped;
+        }, {});
+    }
+    /**
+     * This method interpolates between two data points. The goal is to place the markPoint on the chart in the right place.
+     * @param dpValuesArray array of data points
+     * @param targetTime time of the alarm or event
+     * @returns interpolated data point
+     */
+    interpolateBetweenTwoDps(dpValuesArray, targetTime) {
+        let maxValue;
+        let minValue;
+        return dpValuesArray.reduce((acc, curr, idx, arr) => {
+            if (new Date(curr.time).getTime() <= targetTime) {
+                if (idx === arr.length - 1) {
+                    return {
+                        time: targetTime,
+                        values: [{ min: minValue, max: maxValue }]
+                    };
+                }
+                const nextDp = arr[idx + 1];
+                if (new Date(nextDp.time).getTime() >= targetTime) {
+                    const timeDiff = new Date(nextDp.time).getTime() - new Date(curr.time).getTime();
+                    const targetTimeDiff = targetTime - new Date(curr.time).getTime();
+                    const minValueDiff = nextDp.values[0]?.min - curr.values[0]?.min;
+                    const maxValueDiff = nextDp.values[0]?.max - curr.values[0]?.max;
+                    minValue = curr.values[0]?.min + (minValueDiff * targetTimeDiff) / timeDiff;
+                    maxValue = curr.values[0]?.max + (maxValueDiff * targetTimeDiff) / timeDiff;
+                    return {
+                        time: targetTime,
+                        values: [{ min: minValue, max: maxValue }]
+                    };
+                }
+            }
+            return acc;
+        });
+    }
+    getClosestDpValueToTargetTime(dpValuesArray, targetTime) {
+        return dpValuesArray.reduce((prev, curr) => 
+        //should take the value closest to the target time, for realtime the current time would always change
+        Math.abs(new Date(curr.time).getTime() - targetTime) <
+            Math.abs(new Date(prev.time).getTime() - targetTime)
+            ? curr
+            : prev);
+    }
+    /**
+     * This method creates a markPoint on the chart which represents the icon of the alarm or event.
+     * @param item Single alarm or event
+     * @param dp Data point
+     * @param isCleared If the alarm is cleared in case of alarm
+     * @param isEvent If the item is an event
+     * @param realtime If the chart is in realtime mode
+     * @returns MarkPointDataItemOption[]
+     */
+    createMarkPoint(item, dp, isCleared, isEvent, realtime) {
+        // check if dp.values object is empty
+        if (!item.creationTime || Object.keys(dp.values).length === 0) {
+            return [];
+        }
+        const dpValuesArray = Object.entries(dp.values).map(([time, values]) => ({
+            time: new Date(time).getTime(),
+            values
+        }));
+        const creationTime = new Date(item.creationTime).getTime();
+        const lastUpdatedTime = new Date(item['lastUpdated']).getTime();
+        let coordCreationTime;
+        let coordLastUpdatedTime;
+        if (realtime) {
+            const lastValue = dpValuesArray[dpValuesArray.length - 1];
+            coordCreationTime = [
+                item.creationTime,
+                lastValue?.values[0]?.min ?? lastValue?.values[1] ?? null
+            ];
+            coordLastUpdatedTime = [
+                item['lastUpdated'],
+                lastValue?.values[0]?.min ?? lastValue?.values[1] ?? null
+            ];
+        }
+        else {
+            const closestDpValue = this.interpolateBetweenTwoDps(dpValuesArray, creationTime);
+            const dpValuesForNewAlarms = this.getClosestDpValueToTargetTime(dpValuesArray, creationTime);
+            const closestDpValueLastUpdated = this.interpolateBetweenTwoDps(dpValuesArray, lastUpdatedTime);
+            const dpValuesForNewAlarmsLastUpdated = this.getClosestDpValueToTargetTime(dpValuesArray, lastUpdatedTime);
+            coordCreationTime = [
+                item.creationTime,
+                closestDpValue?.values[0]?.min ??
+                    closestDpValue?.values[1] ??
+                    dpValuesForNewAlarms?.values[0]?.min ??
+                    dpValuesForNewAlarms?.values[1] ??
+                    null
+            ];
+            coordLastUpdatedTime = [
+                item['lastUpdated'],
+                closestDpValueLastUpdated?.values[0]?.min ??
+                    closestDpValueLastUpdated?.values[1] ??
+                    dpValuesForNewAlarmsLastUpdated?.values[0]?.min ??
+                    dpValuesForNewAlarmsLastUpdated?.values[1] ??
+                    null
+            ];
+        }
+        if (isEvent) {
+            return [
+                {
+                    coord: coordCreationTime,
+                    name: item.type,
+                    itemType: item.type,
+                    itemStyle: {
+                        color: item['color']
+                    },
+                    symbol: 'circle',
+                    symbolSize: 24
+                },
+                {
+                    coord: coordCreationTime,
+                    name: item.type,
+                    itemType: item.type,
+                    itemStyle: { color: 'white' },
+                    symbol: ICONS_MAP.EVENT,
+                    symbolSize: 16
+                }
+            ];
+        }
+        return isCleared
+            ? [
+                {
+                    coord: coordCreationTime,
+                    name: item.type,
+                    itemType: item.type,
+                    itemStyle: {
+                        color: item['color']
+                    },
+                    symbol: 'circle',
+                    symbolSize: 24
+                },
+                {
+                    coord: coordCreationTime,
+                    name: item.type,
+                    itemType: item.type,
+                    itemStyle: { color: 'white' },
+                    symbol: ICONS_MAP[item.severity],
+                    symbolSize: 16
+                },
+                {
+                    coord: coordLastUpdatedTime,
+                    name: item.type,
+                    itemType: item.type,
+                    itemStyle: {
+                        color: item['color']
+                    },
+                    symbol: 'circle',
+                    symbolSize: 24
+                },
+                {
+                    coord: coordLastUpdatedTime,
+                    name: item.type,
+                    itemType: item.type,
+                    itemStyle: { color: 'white' },
+                    symbol: ICONS_MAP.CLEARED,
+                    symbolSize: 16
+                }
+            ]
+            : [
+                {
+                    coord: coordCreationTime,
+                    name: item.type,
+                    itemType: item.type,
+                    itemStyle: {
+                        color: item['color']
+                    },
+                    symbol: 'circle',
+                    symbolSize: 24
+                },
+                {
+                    coord: coordCreationTime,
+                    name: item.type,
+                    itemType: item.type,
+                    itemStyle: { color: 'white' },
+                    symbol: ICONS_MAP[item.severity],
+                    symbolSize: 16
+                },
+                {
+                    coord: coordLastUpdatedTime,
+                    name: item.type,
+                    itemType: item.type,
+                    itemStyle: {
+                        color: item['color']
+                    },
+                    symbol: 'circle',
+                    symbolSize: 24
+                },
+                {
+                    coord: coordLastUpdatedTime,
+                    name: item.type,
+                    itemType: item.type,
+                    itemStyle: { color: 'white' },
+                    symbol: ICONS_MAP[item.severity],
+                    symbolSize: 16
+                }
+            ];
+    }
+    /**
+     * This method creates a markLine on the chart which represents the line between every alarm or event on the chart.
+     * @param items Array of alarms or events
+     * @returns MarkLineDataItemOptionBase[]
+     */
+    createMarkLine(items) {
+        return items.reduce((acc, item) => {
+            if (!item.creationTime) {
+                return acc;
+            }
+            if (item.creationTime === item['lastUpdated']) {
+                return acc.concat([
+                    {
+                        xAxis: item.creationTime,
+                        itemType: item.type,
+                        label: { show: false, formatter: () => item.type },
+                        itemStyle: { color: item['color'] }
+                    }
+                ]);
+            }
+            else {
+                return acc.concat([
+                    {
+                        xAxis: item.creationTime,
+                        itemType: item.type,
+                        label: { show: false, formatter: () => item.type },
+                        itemStyle: { color: item['color'] }
+                    },
+                    {
+                        xAxis: item['lastUpdated'],
+                        itemType: item.type,
+                        label: { show: false, formatter: () => item.type },
+                        itemStyle: { color: item['color'] }
+                    }
+                ]);
+            }
+        }, []);
+    }
+    getSingleSeries(dp, renderType, idx, isMinMaxChart = false, seriesType = '') {
+        const datapointId = dp.__target?.id + dp.fragment + dp.series;
+        return {
+            datapointId,
+            datapointUnit: dp.unit || '',
+            // 'id' property is needed as 'seriesId' in tooltip formatter
+            id: isMinMaxChart
+                ? `${datapointId}/${renderType}${seriesType}`
+                : `${datapointId}${seriesType}`,
+            name: `${dp.label} (${dp.__target?.['name']})`,
+            // datapointLabel used to proper display of tooltip
+            datapointLabel: dp.label || '',
+            data: Object.entries(dp.values).map(([dateString, values]) => {
+                return [dateString, values[0][renderType]];
+            }),
+            yAxisIndex: idx,
+            ...this.chartTypesService.getSeriesOptions(dp, isMinMaxChart, renderType)
+        };
+    }
+    /**
+     * This method creates a general tooltip formatter for the chart.
+     * @returns TooltipFormatterCallback<TopLevelFormatterParams>
+     */
+    getTooltipFormatter() {
+        return params => {
+            if (!Array.isArray(params) || !params[0]?.data) {
+                return '';
+            }
+            const data = params[0].data;
+            const XAxisValue = data[0];
+            const YAxisReadings = [];
+            const allSeries = this.echartsInstance?.getOption()['series'];
+            const allDataPointSeries = allSeries.filter(series => series['typeOfSeries'] !== 'alarm' &&
+                series['typeOfSeries'] !== 'event' &&
+                series['typeOfSeries'] !== 'fake');
+            allDataPointSeries.forEach((series) => {
+                let value;
+                const id = series['id'];
+                if (id.endsWith('/min')) {
+                    const minValue = this.findValueForExactOrEarlierTimestamp(series['data'], XAxisValue);
+                    if (!minValue) {
+                        return;
+                    }
+                    const maxSeries = allDataPointSeries.find(s => s['id'] === id.replace('/min', '/max'));
+                    if (!maxSeries) {
+                        return;
+                    }
+                    const maxValue = this.findValueForExactOrEarlierTimestamp(maxSeries['data'], XAxisValue);
+                    if (maxValue === null) {
+                        return;
+                    }
+                    value =
+                        `<div class="d-flex a-i-center separator-top p-t-8 p-b-8">` +
+                            `<label class="text-12 m-r-8 m-b-0">${this.datePipe.transform(minValue[0])}</label>` +
+                            `<div class="m-l-auto text-12" >${minValue[1]} — ${maxValue[1]}` +
+                            (series['datapointUnit'] ? ` ${series['datapointUnit']}` : '') +
+                            `</div></div>`;
+                }
+                else if (id.endsWith('/max')) {
+                    // do nothing, value is handled  in 'min' case
+                    return;
+                }
+                else {
+                    const seriesValue = this.findValueForExactOrEarlierTimestamp(series['data'], XAxisValue);
+                    if (!seriesValue) {
+                        return;
+                    }
+                    value =
+                        `<div class="d-flex a-i-center separator-top p-t-8 p-b-8">` +
+                            `<label class="text-12 m-r-8 m-b-0">${this.datePipe.transform(seriesValue[0])}</label>` +
+                            `<div class="m-l-auto text-12" >${seriesValue[1]?.toString()}` +
+                            (series['datapointUnit'] ? ` ${series['datapointUnit']}` : '') +
+                            `</div></div>`;
+                }
+                const itemStyle = series['itemStyle'];
+                YAxisReadings.push(`<div class="d-flex a-i-center p-b-8"><span class='dlt-c8y-icon-circle m-r-4' style='color: ${itemStyle.color}'></span>` + // color circle
+                    `<strong>${series['datapointLabel']} </strong></div>` + // name
+                    `${value}` // single value or min-max range
+                );
+            });
+            return `<div style="width: ${this.TOOLTIP_WIDTH}px">${YAxisReadings.join('')}</div>`;
+        };
+    }
+    findValueForExactOrEarlierTimestamp(values, timestampString) {
+        const timestamp = new Date(timestampString).valueOf();
+        return values.reduce((acc, curr) => {
+            if (new Date(curr[0]).valueOf() <= timestamp) {
+                if (acc === null ||
+                    Math.abs(new Date(curr[0]).valueOf() - timestamp) <
+                        Math.abs(new Date(acc[0]).valueOf() - timestamp)) {
+                    return curr;
+                }
+            }
+            return acc;
+        }, null);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: EchartsOptionsService, deps: [{ token: i1.DatePipe }, { token: i2.YAxisService }, { token: i3.ChartTypesService }, { token: i4.AlarmSeverityToIconPipe }, { token: i4.AlarmSeverityToLabelPipe }, { token: i5.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: EchartsOptionsService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: EchartsOptionsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.DatePipe }, { type: i2.YAxisService }, { type: i3.ChartTypesService }, { type: i4.AlarmSeverityToIconPipe }, { type: i4.AlarmSeverityToLabelPipe }, { type: i5.Router }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"echarts-options.service.js","sourceRoot":"","sources":["../../../../echart/services/echarts-options.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Injectable } from '@angular/core';\nimport { DatePipe } from '@c8y/ngx-components';\nimport type { EChartsOption, SeriesOption } from 'echarts';\nimport { ECharts } from 'echarts';\nimport {\n  DatapointChartRenderType,\n  DpWithValues,\n  DateString,\n  DpValuesItem,\n  MarkLineData,\n  MarkPointData,\n  SeriesDatapointInfo,\n  SeriesValue\n} from '../models';\nimport { YAxisService } from './y-axis.service';\nimport { ChartTypesService } from './chart-types.service';\nimport type { CallbackDataParams, TooltipFormatterCallback } from 'echarts/types/src/util/types';\nimport type { TopLevelFormatterParams } from 'echarts/types/src/component/tooltip/TooltipModel';\nimport { AlarmStatus, IAlarm, IEvent, SeverityType } from '@c8y/client';\nimport { ICONS_MAP } from '../models/svg-icons.model';\nimport { CustomSeriesOptions } from '../models/chart.model';\nimport { Router } from '@angular/router';\nimport { AlarmSeverityToIconPipe, AlarmSeverityToLabelPipe } from '@c8y/ngx-components/alarms';\nimport { Interval, INTERVALS } from '@c8y/ngx-components/interval-picker';\n\ntype TooltipPositionCallback = (\n  point: [number, number], // position of mouse in chart [X, Y]; 0,0 is top left corner\n  _: any, // tooltip data\n  dom: HTMLElement | unknown, // tooltip element\n  __: any, // valid only when mouse is on graphic elements; not relevant in our case\n  size: {\n    contentSize: [number, number]; // size of tooltip\n    viewSize: [number, number]; // size of the chart\n  } | null // size of chart\n) => Partial<Record<'top' | 'bottom' | 'left' | 'right', number>>;\n\nconst INDEX_HTML = '/index.html';\n\n@Injectable()\nexport class EchartsOptionsService {\n  echartsInstance: ECharts | undefined;\n  private TOOLTIP_WIDTH = 300;\n  private tooltipPositionCallback: TooltipPositionCallback | undefined;\n\n  constructor(\n    private datePipe: DatePipe,\n    private yAxisService: YAxisService,\n    private chartTypesService: ChartTypesService,\n    private severityIconPipe: AlarmSeverityToIconPipe,\n    private severityLabelPipe: AlarmSeverityToLabelPipe,\n    private router: Router\n  ) {}\n\n  getChartOptions(\n    datapointsWithValues: DpWithValues[],\n    timeRange: { dateFrom: string; dateTo: string; interval: Interval['id'] },\n    showSplitLines: { YAxis: boolean; XAxis: boolean },\n    events: IEvent[],\n    alarms: IAlarm[],\n    displayOptions: {\n      displayMarkedLine: boolean;\n      displayMarkedPoint: boolean;\n      mergeMatchingDatapoints: boolean;\n      showLabelAndUnit: boolean;\n      showSlider: boolean;\n    },\n    selectedTimeRange?: { dateFrom: string; dateTo: string; interval: Interval['id'] } | null,\n    aggregatedDatapoints?: DpWithValues[],\n    sliderZoomUsed = false\n  ): EChartsOption {\n    const yAxis = this.yAxisService.getYAxis(datapointsWithValues, {\n      showSplitLines: showSplitLines.YAxis,\n      mergeMatchingDatapoints: displayOptions.mergeMatchingDatapoints,\n      showLabelAndUnit: displayOptions.showLabelAndUnit\n    });\n    const leftAxis = yAxis.filter(yx => yx.position === 'left');\n    const gridLeft = leftAxis.length ? leftAxis.length * this.yAxisService.Y_AXIS_OFFSET : 16;\n    const rightAxis = yAxis.filter(yx => yx.position === 'right');\n    const gridRight = rightAxis.length ? rightAxis.length * this.yAxisService.Y_AXIS_OFFSET : 16;\n    let intervalInMs = this.calculateExtendedIntervalInMs(\n      selectedTimeRange?.interval || timeRange.interval || 'hours',\n      selectedTimeRange || timeRange\n    );\n    if (sliderZoomUsed) {\n      intervalInMs = this.calculateExtendedIntervalInMs(timeRange.interval || 'hours', timeRange);\n    }\n    return {\n      grid: {\n        containLabel: false, // axis labels are not taken into account to calculate graph grid\n        left: gridLeft,\n        top: 16,\n        right: gridRight,\n        bottom: 68\n      },\n      dataZoom: [\n        {\n          type: 'inside',\n          // TODO: use 'none' only when this bug is fixed https://github.com/apache/echarts/issues/17858\n          filterMode: datapointsWithValues.some(dp => dp.lineType === 'bars') ? 'filter' : 'none',\n          zoomOnMouseWheel: true,\n          startValue: selectedTimeRange\n            ? selectedTimeRange.dateFrom.valueOf()\n            : timeRange.dateFrom.valueOf(),\n          endValue: selectedTimeRange\n            ? selectedTimeRange.dateTo.valueOf()\n            : timeRange.dateTo.valueOf()\n        },\n        {\n          type: 'slider',\n          show: displayOptions.showSlider,\n          bottom: 8,\n          realtime: false\n        }\n      ], // on realtime, 'none' will cause extending chart line to left edge of the chart\n      animation: false,\n      toolbox: {\n        show: true,\n        itemSize: 0, // toolbox is needed for zooming in action, but we provide our own buttons\n        feature: {\n          dataZoom: {\n            yAxisIndex: 'none'\n          }\n        }\n      },\n      tooltip: {\n        trigger: 'axis',\n        axisPointer: {\n          type: 'cross',\n          snap: true\n        },\n        backgroundColor: 'rgba(255, 255, 255, 0.9)',\n        formatter: this.getTooltipFormatter(),\n        appendToBody: true,\n        position: this.tooltipPosition(),\n        transitionDuration: 0\n      },\n      legend: {\n        show: false\n      },\n      xAxis: {\n        min: new Date(timeRange.dateFrom).valueOf() - intervalInMs,\n        max: timeRange.dateTo,\n        type: 'time',\n        animation: false,\n        axisPointer: {\n          label: {\n            show: false\n          }\n        },\n        axisLine: {\n          // align X axis to 0 of Y axis of datapoint with lineType 'bars'\n          onZeroAxisIndex: datapointsWithValues.findIndex(dp => dp.lineType === 'bars')\n        },\n        axisLabel: {\n          hideOverlap: true,\n          borderWidth: 2, // as there is no margin for labels spacing, transparent border is a workaround\n          borderColor: 'transparent'\n        },\n        splitLine: {\n          show: showSplitLines.XAxis,\n          lineStyle: { opacity: 0.8, type: 'dashed', width: 2 }\n        }\n      },\n      yAxis,\n      series: [\n        ...this.getAggregatedSeries(aggregatedDatapoints || []).filter(\n          series => series !== undefined\n        ),\n        ...this.getChartSeries(datapointsWithValues, events, alarms, displayOptions)\n      ]\n    };\n  }\n\n  calculateExtendedIntervalInMs(interval: Interval['id'], selectedTimeRange): number {\n    let intervalInMs = INTERVALS.find(i => i.id === interval).timespanInMs;\n    switch (interval) {\n      case 'minutes':\n        intervalInMs = INTERVALS.find(i => i.id === interval).timespanInMs * 60;\n        break;\n      case 'hours':\n        intervalInMs = INTERVALS.find(i => i.id === interval).timespanInMs * 24;\n        break;\n      case 'days':\n        intervalInMs = INTERVALS.find(i => i.id === interval).timespanInMs * 28;\n        break;\n      case 'weeks':\n        intervalInMs = INTERVALS.find(i => i.id === interval).timespanInMs * 12;\n        break;\n      case 'months':\n        intervalInMs = INTERVALS.find(i => i.id === interval).timespanInMs * 12;\n        break;\n      case 'custom':\n        intervalInMs =\n          (new Date(selectedTimeRange.dateTo).valueOf() -\n            new Date(selectedTimeRange.dateFrom).valueOf()) *\n          12;\n        break;\n      default:\n        intervalInMs = INTERVALS.find(i => i.id === interval).timespanInMs;\n        break;\n    }\n    return intervalInMs;\n  }\n\n  getAggregatedSeries(aggregatedDatapoints: DpWithValues[]): SeriesOption[] {\n    const series: SeriesOption[] = [];\n    aggregatedDatapoints.forEach((dp, idx) => {\n      const renderType: DatapointChartRenderType = dp.renderType || 'min';\n      if (renderType === 'area') {\n        series.push(this.getSingleSeries(dp, 'min', idx, true, 'aggr'));\n        series.push(this.getSingleSeries(dp, 'max', idx, true, 'aggr'));\n      } else {\n        series.push(this.getSingleSeries(dp, renderType, idx, false, 'aggr'));\n      }\n    });\n\n    series.forEach((s: any) => {\n      s.datapointId = 'aggregated';\n      s.typeOfSeries = 'fake';\n      s.itemStyle = {\n        ...s.itemStyle,\n        opacity: 0\n      };\n      s.lineStyle = {\n        ...s.lineStyle,\n        opacity: 0\n      };\n    });\n\n    return [series[0]];\n  }\n\n  /**\n   * This method is used to get the series for alarms and events.\n   * @param dp - The data point.\n   * @param renderType - The render type.\n   * @param isMinMaxChart - If the chart is min max chart.\n   * @param items - All alarms or events which should be displayed on the chart.\n   * @param itemType - The item type.\n   * @param id - The id of the device\n   */\n  getAlarmOrEventSeries(\n    dp: DpWithValues,\n    renderType: DatapointChartRenderType,\n    isMinMaxChart = false,\n    items: IAlarm[] | IEvent[] = [],\n    itemType: 'alarm' | 'event' = 'alarm',\n    displayOptions = { displayMarkedLine: true, displayMarkedPoint: true },\n    id?: string | number,\n    idx?: number,\n    realtime?: boolean\n  ): CustomSeriesOptions[] {\n    if (!items.length) {\n      return [];\n    }\n\n    if (!displayOptions.displayMarkedLine && !displayOptions.displayMarkedPoint) {\n      return [];\n    }\n\n    //filter items that are not __hidden\n    const filteredItems: IAlarm[] | IEvent[] = items.filter(item => !item['__hidden']);\n    const itemsByType = this.groupByType(filteredItems, 'type');\n    const isAlarm = itemType === 'alarm';\n\n    return Object.entries(itemsByType).flatMap(\n      ([type, itemsOfType]: [string, (IAlarm | IEvent)[]]) => {\n        // Main series data\n        const mainData = itemsOfType.map(item => [item.creationTime, null, 'markLineFlag']);\n        // Is a specific datapoint template selected for this alarm/event type?\n        let isDpTemplateSelected = false;\n\n        // MarkPoint data\n        const markPointData = itemsOfType.reduce<MarkPointData[]>((acc, item) => {\n          isDpTemplateSelected =\n            item['selectedDatapoint'] &&\n            dp['__target'] &&\n            item['selectedDatapoint']['fragment'] === dp['fragment'] &&\n            item['selectedDatapoint']['series'] === dp['series'] &&\n            item['selectedDatapoint']['target'] === dp['__target']['id'];\n          if (dp.__target?.id === item.source.id) {\n            const isCleared = isAlarm && item.status === AlarmStatus.CLEARED;\n            const isEvent = !isAlarm;\n            return acc.concat(this.createMarkPoint(item, dp, isCleared, isEvent, realtime));\n          } else {\n            if (!item.creationTime) {\n              return [];\n            }\n            return acc.concat([\n              {\n                coord: [item.creationTime, null],\n                name: item.type,\n                itemType: item.type,\n                itemStyle: { color: item['color'] }\n              }\n            ]);\n          }\n        }, []);\n\n        // Construct series with markPoint\n        const seriesWithMarkPoint = {\n          id: `${type}/${dp.__target?.id}+${id ? id : ''}-markPoint`,\n          name: `${type}-markPoint`,\n          typeOfSeries: itemType,\n          data: mainData,\n          isDpTemplateSelected,\n          position: 'bottom',\n          silent: true,\n          markPoint: {\n            showSymbol: true,\n            symbolKeepAspect: true,\n            data: markPointData\n          },\n          yAxisIndex: idx,\n          ...this.chartTypesService.getSeriesOptions(dp, isMinMaxChart, renderType)\n        };\n\n        const markLineData = this.createMarkLine(itemsOfType);\n\n        // Construct series with markLine\n        const seriesWithMarkLine = {\n          id: `${type}/${dp.__target?.id}+${id ? id : ''}-markLine`,\n          name: `${type}-markLine`,\n          typeOfSeries: itemType,\n          isDpTemplateSelected,\n          data: mainData,\n          markLine: {\n            showSymbol: false,\n            symbol: ['none', 'none'], // no symbol at the start/end of the line\n            data: markLineData\n          },\n          ...this.chartTypesService.getSeriesOptions(dp, isMinMaxChart, renderType)\n        };\n\n        //depending on the options return only the required series\n        if (displayOptions.displayMarkedLine && displayOptions.displayMarkedPoint) {\n          return [seriesWithMarkLine, seriesWithMarkPoint];\n        } else if (displayOptions.displayMarkedLine) {\n          return [seriesWithMarkLine];\n        } else if (displayOptions.displayMarkedPoint) {\n          return [seriesWithMarkPoint];\n        } else {\n          return null;\n        }\n      }\n    ) as CustomSeriesOptions[];\n  }\n\n  /**\n   * This method is used to get tooltip formatter for alarms and events.\n   * @param tooltipParams - The tooltip parameters.\n   * @param params - The parameters data.\n   * @param allEvents - All events.\n   * @param allAlarms - All alarms.\n   * @returns The formatted string for the tooltip.\n   */\n  getTooltipFormatterForAlarmAndEvents(\n    tooltipParams: CallbackDataParams,\n    params: { data: { itemType: string } },\n    allEvents: IEvent[],\n    allAlarms: IAlarm[]\n  ): string {\n    if (!Array.isArray(tooltipParams)) {\n      return '';\n    }\n    const XAxisValue: string = tooltipParams[0].data[0];\n    const YAxisReadings: string[] = [];\n    const allSeries = this.echartsInstance?.getOption()['series'] as CustomSeriesOptions[];\n\n    // filter out alarm and event series\n    const allDataPointSeries = allSeries.filter(\n      series => series['typeOfSeries'] !== 'alarm' && series['typeOfSeries'] !== 'event'\n    );\n\n    this.processSeries(allDataPointSeries, XAxisValue, YAxisReadings);\n\n    // find event and alarm of the same type as the hovered markedLine or markedPoint\n    const event = allEvents.find(e => e.type === params.data.itemType);\n    const alarm = allAlarms.find(a => a.type === params.data.itemType);\n\n    let value = '';\n    if (event) {\n      value = this.processEvent(event);\n    }\n\n    if (alarm) {\n      this.processAlarm(alarm).then(alarmVal => {\n        value = alarmVal;\n        YAxisReadings.push(value);\n        const options = this.echartsInstance?.getOption() as EChartsOption;\n        if (!options.tooltip || !Array.isArray(options.tooltip)) {\n          return;\n        }\n        const updatedOptions: Partial<SeriesOption> = {\n          tooltip: options['tooltip'][0]\n        };\n\n        if (!updatedOptions.tooltip) {\n          return;\n        }\n        updatedOptions.tooltip.formatter = `<div style=\"width: ${this.TOOLTIP_WIDTH}px\">${YAxisReadings.join('')}</div>`;\n        updatedOptions.tooltip.transitionDuration = 0;\n        updatedOptions.tooltip.position = this.tooltipPosition();\n        this.echartsInstance?.setOption(updatedOptions);\n        return;\n      });\n    }\n    YAxisReadings.push(value);\n\n    return `<div style=\"width: 300px\">${YAxisReadings.join('')}</div>`;\n  }\n\n  private tooltipPosition(): TooltipPositionCallback {\n    let lastPositionOfTooltip: Partial<Record<'top' | 'bottom' | 'left' | 'right', number>> = {};\n    if (this.tooltipPositionCallback) {\n      return this.tooltipPositionCallback;\n    }\n\n    this.tooltipPositionCallback = (\n      point: [number, number], // position of mouse in chart [X, Y]; 0,0 is top left corner\n      _: any, // tooltip data\n      dom: HTMLElement | unknown, // tooltip element\n      __: any,\n      size: {\n        contentSize: [number, number]; // size of tooltip\n        viewSize: [number, number];\n      } | null // size of chart\n    ) => {\n      const offset = 10;\n      const [mouseX, mouseY] = point;\n      const chartWidth = size?.viewSize[0] || 0;\n      const chartHeight = size?.viewSize[1] || 0;\n      const tooltipWidth = size?.contentSize[0] || 0;\n      const tooltipHeight = size?.contentSize[1] || 0;\n      const tooltipRect = (dom as HTMLElement)?.getBoundingClientRect();\n      const tooltipOverflowsBottomEdge = tooltipRect.bottom > window.innerHeight;\n\n      const tooltipOverflowsRightEdge = tooltipRect.right > window.innerWidth;\n\n      const tooltipWouldOverflowBottomEdgeOnPositionChange =\n        !lastPositionOfTooltip.top &&\n        tooltipRect.bottom + 2 * offset + tooltipHeight > window.innerHeight;\n\n      const tooltipWouldOverflowRightEdgeOnPositionChange =\n        !lastPositionOfTooltip.left &&\n        tooltipRect.right + 2 * offset + tooltipWidth > window.innerWidth;\n\n      let verticalPosition: { top: number } | { bottom: number } = {\n        top: mouseY + offset\n      };\n      let horizontalPosition: { left: number } | { right: number } = {\n        left: mouseX + offset\n      };\n\n      if (tooltipOverflowsBottomEdge || tooltipWouldOverflowBottomEdgeOnPositionChange) {\n        verticalPosition = {\n          bottom: chartHeight - mouseY + offset\n        };\n      }\n      if (tooltipOverflowsRightEdge || tooltipWouldOverflowRightEdgeOnPositionChange) {\n        horizontalPosition = {\n          right: chartWidth - mouseX + offset\n        };\n      }\n\n      lastPositionOfTooltip = {\n        ...verticalPosition,\n        ...horizontalPosition\n      };\n      return lastPositionOfTooltip;\n    };\n    return this.tooltipPositionCallback;\n  }\n\n  /**\n   * This method is used to add the data point info to the tooltip.\n   * @param allDataPointSeries - All the data point series.\n   * @param XAxisValue - The X Axis value.\n   * @param YAxisReadings - The Y Axis readings.\n   */\n  private processSeries(\n    allDataPointSeries: CustomSeriesOptions[],\n    XAxisValue: string,\n    YAxisReadings: string[]\n  ): void {\n    allDataPointSeries.forEach((series: any) => {\n      let value = '';\n      if (series.id.endsWith('/min')) {\n        value = this.processMinSeries(series, allDataPointSeries, XAxisValue);\n      } else if (!series.id.endsWith('/max')) {\n        value = this.processRegularSeries(series, XAxisValue);\n      }\n\n      if (value) {\n        YAxisReadings.push(\n          `<div class=\"d-flex a-i-center p-b-8\"><span class='dlt-c8y-icon-circle m-r-4' style='color: ${series.itemStyle.color};'></span>` + // color circle\n            `<strong>${series.datapointLabel}</strong></div>` + // name\n            `${value}` // single value or min-max range\n        );\n      }\n    });\n  }\n\n  /**\n   * This method is used to process the min series.\n   * @param series - The series.\n   * @param allDataPointSeries - All the data point series.\n   * @param XAxisValue - The X Axis value.\n   * @returns The processed value.\n   */\n  private processMinSeries(\n    series: any,\n    allDataPointSeries: CustomSeriesOptions[],\n    XAxisValue: string\n  ): string {\n    const minValue = this.findValueForExactOrEarlierTimestamp(series.data, XAxisValue);\n    if (!minValue) {\n      return '';\n    }\n    const maxSeries = allDataPointSeries.find(s => s['id'] === series.id.replace('/min', '/max'));\n    const maxValue = this.findValueForExactOrEarlierTimestamp(\n      maxSeries?.['data'] as SeriesValue[],\n      XAxisValue\n    );\n    return (\n      `<div class=\"d-flex a-i-center separator-top p-t-8 p-b-8\"><label class=\"text-12 m-r-8 m-b-0\">${this.datePipe.transform(minValue[0])}</label>` +\n      `<span class=\"m-l-auto text-12\">${minValue[1]} — ${maxValue?.[1]}` +\n      (series.datapointUnit ? ` ${series.datapointUnit}` : '') +\n      `</span></div>`\n    );\n  }\n\n  /**\n   * This method is used to process the regular series.\n   * @param series - The series.\n   * @param XAxisValue - The X Axis value.\n   * @returns The processed value.\n   */\n  private processRegularSeries(series: any, XAxisValue: string): string {\n    const seriesValue = this.findValueForExactOrEarlierTimestamp(series.data, XAxisValue);\n    if (!seriesValue) {\n      return '';\n    }\n    return (\n      `<div class=\"d-flex a-i-center p-t-8 p-b-8 separator-top\">` +\n      `<label class=\"m-b-0 m-r-8 text-12\">${this.datePipe.transform(\n        seriesValue[0]\n      )}</label><span class=\"m-l-auto text-12\">` +\n      seriesValue[1]?.toString() +\n      (series.datapointUnit ? ` ${series.datapointUnit}` : '') +\n      `</span></div>`\n    );\n  }\n\n  /**\n   * This method is used to process the event tooltip.\n   * @param event - The event object.\n   * @returns The processed value.\n   */\n  private processEvent(event: IEvent): string {\n    let value = `<ul class=\"list-unstyled small separator-top\">`;\n    value += `<li class=\"p-t-4 p-b-4 d-flex separator-bottom text-no-wrap\"><label class=\"small m-b-0 m-r-8\">Event type</label><code class=\"m-l-auto\">${event.type}</code></li>`;\n    value += `<li class=\"p-t-4 p-b-4 d-flex separator-bottom text-no-wrap\"><label class=\"small m-b-0 m-r-8\">Event text</label><span class=\"m-l-auto\">${event.text}<span></li>`;\n    value += `<li class=\"p-t-4 p-b-4 d-flex separator-bottom text-no-wrap\"><label class=\"small m-b-0 m-r-8\">Last update</label><span class=\"m-l-auto\">${this.datePipe.transform(event['lastUpdated'])}<span></li>`;\n    value += `</ul>`;\n    return value;\n  }\n\n  /**\n   * This method is used to process the alarm tooltip.\n   * @param alarm - The alarm object.\n   * @returns The processed value.\n   */\n  private async processAlarm(alarm: IAlarm): Promise<string> {\n    let value = `<ul class=\"list-unstyled small separator-top m-0\">`;\n    value += `<li class=\"p-t-4 p-b-4 d-flex a-i-center separator-bottom text-no-wrap\"><label class=\"text-label-small m-b-0 m-r-8\">Alarm Severity</label>`;\n    value += `<span class=\"small d-inline-flex a-i-center gap-4 m-l-auto\"><i class=\"stroked-icon icon-14 status dlt-c8y-icon-${this.severityIconPipe.transform(alarm.severity)} ${alarm.severity.toLowerCase()}\" > </i> ${this.severityLabelPipe.transform(alarm.severity)} </span></li>`;\n    value += `<li class=\"p-t-4 p-b-4 d-flex separator-bottom text-no-wrap\"><label class=\"text-label-small m-b-0 m-r-8\">Alarm Type</label><span class=\"small m-l-auto\"><code>${alarm.type}</code></span></li>`;\n    value += `<li class=\"p-t-4 p-b-4 d-flex separator-bottom text-no-wrap\"><label class=\"text-label-small m-b-0 m-r-8\">Message</label><span class=\"small m-l-auto\" style=\"overflow: hidden; text-overflow: ellipsis;\" title=\"${alarm.text}\">${alarm.text}</span></li>`;\n    value += `<li class=\"p-t-4 p-b-4 d-flex separator-bottom text-no-wrap\"><label class=\"text-label-small m-b-0 m-r-8\">Last Updated</label><span class=\"small m-l-auto\">${this.datePipe.transform(alarm['lastUpdated'])}</span></li>`;\n    const exists = await this.alarmRouteExists();\n    if (exists) {\n      const currentUrl = window.location.href;\n      const baseUrlIndex = currentUrl.indexOf(INDEX_HTML);\n      const baseUrl = currentUrl.substring(0, baseUrlIndex + INDEX_HTML.length);\n      value += `<li class=\"p-t-4 p-b-4 d-flex separator-bottom text-no-wrap\"><label class=\"text-label-small m-b-0 m-r-8\">Link</label><span class=\"small m-l-auto\"><a href=\"${baseUrl}#/alarms/${alarm.id}\">Alarm Details</a></span></li>`;\n    }\n    value += `<li class=\"p-t-4 p-b-4 d-flex text-no-wrap\"><label class=\"text-label-small m-b-0 m-r-8\">Alarm count</label><span class=\"small m-l-auto\"><span class=\"badge badge-info\">${alarm.count}</span></span></li>`;\n    value += `</ul>`;\n    return value;\n  }\n\n  private async alarmRouteExists(): Promise<boolean> {\n    const exists = this.router.config.some(route => {\n      return `${route.path}` === 'alarms';\n    });\n    return exists;\n  }\n\n  private getChartSeries(\n    datapointsWithValues: DpWithValues[],\n    events: IEvent[],\n    alarms: IAlarm[],\n    displayOptions: { displayMarkedLine: boolean; displayMarkedPoint: boolean }\n  ): CustomSeriesOptions[] | SeriesOption[] {\n    const series: SeriesOption[] = [];\n    let eventSeries: CustomSeriesOptions[] = [];\n    let alarmSeries: CustomSeriesOptions[] = [];\n    datapointsWithValues.forEach((dp, idx) => {\n      const renderType: DatapointChartRenderType = dp.renderType || 'min';\n      if (renderType === 'area') {\n        series.push(this.getSingleSeries(dp, 'min', idx, true));\n        series.push(this.getSingleSeries(dp, 'max', idx, true));\n      } else {\n        series.push(this.getSingleSeries(dp, renderType, idx, false));\n      }\n\n      const newEventSeries = this.getAlarmOrEventSeries(\n        dp,\n        renderType,\n        false,\n        events,\n        'event',\n        displayOptions,\n        null,\n        idx\n      );\n      const newAlarmSeries = this.getAlarmOrEventSeries(\n        dp,\n        renderType,\n        false,\n        alarms,\n        'alarm',\n        displayOptions,\n        null,\n        idx\n      );\n      eventSeries = [...eventSeries, ...newEventSeries];\n      alarmSeries = [...alarmSeries, ...newAlarmSeries];\n    });\n    const deduplicateFilterCallback = (\n      obj1: CustomSeriesOptions,\n      i: number,\n      arr: SeriesOption[]\n    ): obj1 is CustomSeriesOptions => {\n      const duplicates = arr.filter(obj2 => obj1['id'] === obj2['id'] && i !== arr.indexOf(obj2));\n\n      if (duplicates.length > 0) {\n        return obj1['isDpTemplateSelected'] as boolean;\n      }\n\n      return true;\n    };\n\n    const deduplicateFilterCallbackFallback = (\n      obj1: SeriesOption,\n      i: number,\n      arr: SeriesOption[]\n    ): obj1 is SeriesOption => arr.findIndex(obj2 => obj2['id'] === obj1['id']) === i;\n\n    let deduplicatedEvents = eventSeries.filter(deduplicateFilterCallback);\n    let deduplicatedAlarms = alarmSeries.filter(deduplicateFilterCallback);\n    if (deduplicatedAlarms.length === 0) {\n      deduplicatedAlarms = alarmSeries.filter(deduplicateFilterCallbackFallback);\n    }\n    if (deduplicatedEvents.length === 0) {\n      deduplicatedEvents = eventSeries.filter(deduplicateFilterCallbackFallback);\n    }\n    return [...series, ...deduplicatedEvents, ...deduplicatedAlarms];\n  }\n\n  private groupByType(\n    items: IAlarm[] | IEvent[],\n    typeField: string\n  ): Record<string, IAlarm[] | IEvent[]> {\n    return items.reduce((grouped, item) => {\n      (grouped[item[typeField]] = grouped[item[typeField]] || []).push(item);\n      return grouped;\n    }, {} as any);\n  }\n\n  /**\n   * This method interpolates between two data points. The goal is to place the markPoint on the chart in the right place.\n   * @param dpValuesArray array of data points\n   * @param targetTime time of the alarm or event\n   * @returns interpolated data point\n   */\n  private interpolateBetweenTwoDps(\n    dpValuesArray: DpValuesItem[],\n    targetTime: number\n  ): DpValuesItem {\n    let maxValue: number;\n    let minValue: number;\n    return dpValuesArray.reduce((acc, curr, idx, arr) => {\n      if (new Date(curr.time).getTime() <= targetTime) {\n        if (idx === arr.length - 1) {\n          return {\n            time: targetTime,\n            values: [{ min: minValue, max: maxValue }]\n          };\n        }\n        const nextDp = arr[idx + 1];\n        if (new Date(nextDp.time).getTime() >= targetTime) {\n          const timeDiff = new Date(nextDp.time).getTime() - new Date(curr.time).getTime();\n          const targetTimeDiff = targetTime - new Date(curr.time).getTime();\n          const minValueDiff = nextDp.values[0]?.min - curr.values[0]?.min;\n          const maxValueDiff = nextDp.values[0]?.max - curr.values[0]?.max;\n          minValue = curr.values[0]?.min + (minValueDiff * targetTimeDiff) / timeDiff;\n          maxValue = curr.values[0]?.max + (maxValueDiff * targetTimeDiff) / timeDiff;\n          return {\n            time: targetTime,\n            values: [{ min: minValue, max: maxValue }]\n          };\n        }\n      }\n      return acc;\n    });\n  }\n\n  private getClosestDpValueToTargetTime(\n    dpValuesArray: DpValuesItem[],\n    targetTime: number\n  ): DpValuesItem {\n    return dpValuesArray.reduce((prev, curr) =>\n      //should take the value closest to the target time, for realtime the current time would always change\n      Math.abs(new Date(curr.time).getTime() - targetTime) <\n      Math.abs(new Date(prev.time).getTime() - targetTime)\n        ? curr\n        : prev\n    );\n  }\n\n  /**\n   * This method creates a markPoint on the chart which represents the icon of the alarm or event.\n   * @param item Single alarm or event\n   * @param dp Data point\n   * @param isCleared If the alarm is cleared in case of alarm\n   * @param isEvent If the item is an event\n   * @param realtime If the chart is in realtime mode\n   * @returns MarkPointDataItemOption[]\n   */\n  private createMarkPoint(\n    item: IAlarm | IEvent,\n    dp: DpWithValues,\n    isCleared: boolean,\n    isEvent: boolean,\n    realtime: boolean\n  ): MarkPointData[] {\n    // check if dp.values object is empty\n    if (!item.creationTime || Object.keys(dp.values).length === 0) {\n      return [];\n    }\n\n    const dpValuesArray: DpValuesItem[] = Object.entries(dp.values).map(([time, values]) => ({\n      time: new Date(time).getTime(),\n      values\n    }));\n    const creationTime = new Date(item.creationTime).getTime();\n    const lastUpdatedTime = new Date(item['lastUpdated']).getTime();\n\n    let coordCreationTime: any;\n    let coordLastUpdatedTime: any;\n\n    if (realtime) {\n      const lastValue = dpValuesArray[dpValuesArray.length - 1];\n      coordCreationTime = [\n        item.creationTime,\n        lastValue?.values[0]?.min ?? lastValue?.values[1] ?? null\n      ];\n      coordLastUpdatedTime = [\n        item['lastUpdated'],\n        lastValue?.values[0]?.min ?? lastValue?.values[1] ?? null\n      ];\n    } else {\n      const closestDpValue = this.interpolateBetweenTwoDps(dpValuesArray, creationTime);\n      const dpValuesForNewAlarms = this.getClosestDpValueToTargetTime(dpValuesArray, creationTime);\n      const closestDpValueLastUpdated = this.interpolateBetweenTwoDps(\n        dpValuesArray,\n        lastUpdatedTime\n      );\n      const dpValuesForNewAlarmsLastUpdated = this.getClosestDpValueToTargetTime(\n        dpValuesArray,\n        lastUpdatedTime\n      );\n\n      coordCreationTime = [\n        item.creationTime,\n        closestDpValue?.values[0]?.min ??\n          closestDpValue?.values[1] ??\n          dpValuesForNewAlarms?.values[0]?.min ??\n          dpValuesForNewAlarms?.values[1] ??\n          null\n      ];\n      coordLastUpdatedTime = [\n        item['lastUpdated'],\n        closestDpValueLastUpdated?.values[0]?.min ??\n          closestDpValueLastUpdated?.values[1] ??\n          dpValuesForNewAlarmsLastUpdated?.values[0]?.min ??\n          dpValuesForNewAlarmsLastUpdated?.values[1] ??\n          null\n      ];\n    }\n\n    if (isEvent) {\n      return [\n        {\n          coord: coordCreationTime,\n          name: item.type,\n          itemType: item.type,\n          itemStyle: {\n            color: item['color']\n          },\n          symbol: 'circle',\n          symbolSize: 24\n        },\n        {\n          coord: coordCreationTime,\n          name: item.type,\n          itemType: item.type,\n          itemStyle: { color: 'white' },\n          symbol: ICONS_MAP.EVENT,\n          symbolSize: 16\n        }\n      ];\n    }\n\n    return isCleared\n      ? [\n          {\n            coord: coordCreationTime,\n            name: item.type,\n            itemType: item.type,\n            itemStyle: {\n              color: item['color']\n            },\n            symbol: 'circle',\n            symbolSize: 24\n          },\n          {\n            coord: coordCreationTime,\n            name: item.type,\n            itemType: item.type,\n            itemStyle: { color: 'white' },\n            symbol: ICONS_MAP[item.severity as SeverityType],\n            symbolSize: 16\n          },\n          {\n            coord: coordLastUpdatedTime,\n            name: item.type,\n            itemType: item.type,\n            itemStyle: {\n              color: item['color']\n            },\n            symbol: 'circle',\n            symbolSize: 24\n          },\n          {\n            coord: coordLastUpdatedTime,\n            name: item.type,\n            itemType: item.type,\n            itemStyle: { color: 'white' },\n            symbol: ICONS_MAP.CLEARED,\n            symbolSize: 16\n          }\n        ]\n      : [\n          {\n            coord: coordCreationTime,\n            name: item.type,\n            itemType: item.type,\n            itemStyle: {\n              color: item['color']\n            },\n            symbol: 'circle',\n            symbolSize: 24\n          },\n          {\n            coord: coordCreationTime,\n            name: item.type,\n            itemType: item.type,\n            itemStyle: { color: 'white' },\n            symbol: ICONS_MAP[item.severity as SeverityType],\n            symbolSize: 16\n          },\n          {\n            coord: coordLastUpdatedTime,\n            name: item.type,\n            itemType: item.type,\n            itemStyle: {\n              color: item['color']\n            },\n            symbol: 'circle',\n            symbolSize: 24\n          },\n          {\n            coord: coordLastUpdatedTime,\n            name: item.type,\n            itemType: item.type,\n            itemStyle: { color: 'white' },\n            symbol: ICONS_MAP[item.severity as SeverityType],\n            symbolSize: 16\n          }\n        ];\n  }\n\n  /**\n   * This method creates a markLine on the chart which represents the line between every alarm or event on the chart.\n   * @param items Array of alarms or events\n   * @returns MarkLineDataItemOptionBase[]\n   */\n  private createMarkLine<T extends IAlarm | IEvent>(items: T[]): MarkLineData[] {\n    return items.reduce<MarkLineData[]>((acc, item) => {\n      if (!item.creationTime) {\n        return acc;\n      }\n      if (item.creationTime === item['lastUpdated']) {\n        return acc.concat([\n          {\n            xAxis: item.creationTime,\n            itemType: item.type,\n            label: { show: false, formatter: () => item.type },\n            itemStyle: { color: item['color'] }\n          }\n        ]);\n      } else {\n        return acc.concat([\n          {\n            xAxis: item.creationTime,\n            itemType: item.type,\n            label: { show: false, formatter: () => item.type },\n            itemStyle: { color: item['color'] }\n          },\n          {\n            xAxis: item['lastUpdated'],\n            itemType: item.type,\n            label: { show: false, formatter: () => item.type },\n            itemStyle: { color: item['color'] }\n          }\n        ]);\n      }\n    }, []);\n  }\n\n  private getSingleSeries(\n    dp: DpWithValues,\n    renderType: Exclude<DatapointChartRenderType, 'area'>,\n    idx: number,\n    isMinMaxChart = false,\n    seriesType = ''\n  ): SeriesOption & SeriesDatapointInfo {\n    const datapointId = dp.__target?.id + dp.fragment + dp.series;\n    return {\n      datapointId,\n      datapointUnit: dp.unit || '',\n      // 'id' property is needed as 'seriesId' in tooltip formatter\n      id: isMinMaxChart\n        ? `${datapointId}/${renderType}${seriesType}`\n        : `${datapointId}${seriesType}`,\n      name: `${dp.label} (${dp.__target?.['name']})`,\n      // datapointLabel used to proper display of tooltip\n      datapointLabel: dp.label || '',\n      data: Object.entries(dp.values).map(([dateString, values]) => {\n        return [dateString, values[0][renderType]];\n      }),\n      yAxisIndex: idx,\n      ...this.chartTypesService.getSeriesOptions(dp, isMinMaxChart, renderType)\n    };\n  }\n\n  /**\n   * This method creates a general tooltip formatter for the chart.\n   * @returns TooltipFormatterCallback<TopLevelFormatterParams>\n   */\n  private getTooltipFormatter(): TooltipFormatterCallback<TopLevelFormatterParams> {\n    return params => {\n      if (!Array.isArray(params) || !params[0]?.data) {\n        return '';\n      }\n      const data = params[0].data as [string, ...any[]];\n      const XAxisValue: string = data[0];\n      const YAxisReadings: string[] = [];\n      const allSeries = this.echartsInstance?.getOption()['series'] as CustomSeriesOptions[];\n\n      const allDataPointSeries = allSeries.filter(\n        series =>\n          series['typeOfSeries'] !== 'alarm' &&\n          series['typeOfSeries'] !== 'event' &&\n          series['typeOfSeries'] !== 'fake'\n      );\n\n      allDataPointSeries.forEach((series: CustomSeriesOptions) => {\n        let value: string;\n        const id = series['id'] as string;\n        if (id.endsWith('/min')) {\n          const minValue = this.findValueForExactOrEarlierTimestamp(\n            series['data'] as SeriesValue[],\n            XAxisValue\n          );\n          if (!minValue) {\n            return;\n          }\n          const maxSeries = allDataPointSeries.find(s => s['id'] === id.replace('/min', '/max'));\n          if (!maxSeries) {\n            return;\n          }\n          const maxValue = this.findValueForExactOrEarlierTimestamp(\n            maxSeries['data'] as SeriesValue[],\n            XAxisValue\n          );\n          if (maxValue === null) {\n            return;\n          }\n          value =\n            `<div class=\"d-flex a-i-center separator-top p-t-8 p-b-8\">` +\n            `<label class=\"text-12 m-r-8 m-b-0\">${this.datePipe.transform(minValue[0])}</label>` +\n            `<div class=\"m-l-auto text-12\" >${minValue[1]} — ${maxValue[1]}` +\n            (series['datapointUnit'] ? ` ${series['datapointUnit']}` : '') +\n            `</div></div>`;\n        } else if (id.endsWith('/max')) {\n          // do nothing, value is handled  in 'min' case\n          return;\n        } else {\n          const seriesValue = this.findValueForExactOrEarlierTimestamp(\n            series['data'] as SeriesValue[],\n            XAxisValue\n          );\n          if (!seriesValue) {\n            return;\n          }\n          value =\n            `<div class=\"d-flex a-i-center separator-top p-t-8 p-b-8\">` +\n            `<label class=\"text-12 m-r-8 m-b-0\">${this.datePipe.transform(seriesValue[0])}</label>` +\n            `<div class=\"m-l-auto text-12\" >${seriesValue[1]?.toString()}` +\n            (series['datapointUnit'] ? ` ${series['datapointUnit']}` : '') +\n            `</div></div>`;\n        }\n\n        const itemStyle = series['itemStyle'] as { color: string };\n\n        YAxisReadings.push(\n          `<div class=\"d-flex a-i-center p-b-8\"><span class='dlt-c8y-icon-circle m-r-4' style='color: ${itemStyle.color}'></span>` + // color circle\n            `<strong>${series['datapointLabel']} </strong></div>` + // name\n            `${value}` // single value or min-max range\n        );\n      });\n\n      return `<div style=\"width: ${this.TOOLTIP_WIDTH}px\">${YAxisReadings.join('')}</div>`;\n    };\n  }\n\n  private findValueForExactOrEarlierTimestamp(\n    values: SeriesValue[],\n    timestampString: DateString\n  ): SeriesValue | null {\n    const timestamp = new Date(timestampString).valueOf();\n    return values.reduce((acc: SeriesValue | null, curr: SeriesValue) => {\n      if (new Date(curr[0]).valueOf() <= timestamp) {\n        if (\n          acc === null ||\n          Math.abs(new Date(curr[0]).valueOf() - timestamp) <\n            Math.abs(new Date(acc[0]).valueOf() - timestamp)\n        ) {\n          return curr;\n        }\n      }\n      return acc;\n    }, null);\n  }\n}\n"]}