@c8y/ngx-components 1021.52.0 → 1021.54.4

package/esm2022/echart/charts.component.mjs

@@ -0,0 +1,560 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Component, ElementRef, EventEmitter, inject, Input, Output, ViewChild } from '@angular/core';
+import { BehaviorSubject, forkJoin, lastValueFrom, of } from 'rxjs';
+import { map, switchMap, tap } from 'rxjs/operators';
+import { CustomMeasurementService } from './services/custom-measurements.service';
+import { AlarmRealtimeService, CoreModule, DismissAlertStrategy, DynamicComponentAlert, DynamicComponentAlertAggregator, EventRealtimeService, gettext, MeasurementRealtimeService, WidgetTimeContextDateRangeService } from '@c8y/ngx-components';
+import { EchartsOptionsService } from './services/echarts-options.service';
+import { ChartRealtimeService } from './services/chart-realtime.service';
+import { ChartTypesService } from './services/chart-types.service';
+import { CommonModule } from '@angular/common';
+import { NGX_ECHARTS_CONFIG, NgxEchartsModule } from 'ngx-echarts';
+import { TooltipModule } from 'ngx-bootstrap/tooltip';
+import { PopoverModule } from 'ngx-bootstrap/popover';
+import { YAxisService } from './services/y-axis.service';
+import { ChartAlertsComponent } from './chart-alerts/chart-alerts.component';
+import { aggregationType, AlarmStatus } from '@c8y/client';
+import { ChartEventsService } from './services/chart-events.service';
+import { ChartAlarmsService } from './services/chart-alarms.service';
+import { AlarmSeverityToIconPipe, AlarmSeverityToLabelPipe, AlarmsModule } from '@c8y/ngx-components/alarms';
+import { INTERVALS } from '@c8y/ngx-components/interval-picker';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@c8y/ngx-components";
+import * as i3 from "ngx-echarts";
+export class ChartsComponent {
+    constructor() {
+        this.showLoadMore = false;
+        this.alarms = [];
+        this.events = [];
+        this.sliderZoomUsed = false;
+        this.configChangeOnZoomOut = new EventEmitter();
+        this.timeRangeChangeOnRealtime = new EventEmitter();
+        this.datapointOutOfSync = new EventEmitter();
+        this.updateAlarmsAndEvents = new EventEmitter();
+        this.isMarkedAreaEnabled = new EventEmitter();
+        this.configChangedSubject = new BehaviorSubject(null);
+        this.measurementService = inject(CustomMeasurementService);
+        this.echartsOptionsService = inject(EchartsOptionsService);
+        this.chartRealtimeService = inject(ChartRealtimeService);
+        this.chartEventsService = inject(ChartEventsService);
+        this.chartAlarmsService = inject(ChartAlarmsService);
+        this.widgetTimeContextDateRangeService = inject(WidgetTimeContextDateRangeService);
+        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());
+            }
+            return this.getChartOptions(datapointsWithValues);
+        }), tap(v => {
+            if (v['empty']) {
+                return;
+            }
+            this.chartRealtimeService.stopRealtime();
+            this.startRealtimeIfPossible();
+            if (this.echartsInstance) {
+                this.echartsInstance.setOption(v, true);
+                const options = this.echartsInstance.getOption();
+                const dataZoom = options['dataZoom'][0];
+                if (dataZoom.start !== 0) {
+                    this.showLoadMore = false;
+                }
+            }
+            this.sliderZoomUsed = false;
+        }));
+    }
+    ngOnChanges() {
+        this.configChangedSubject.next();
+    }
+    ngOnInit() {
+        if (this.alerts) {
+            this.alerts.setAlertGroupDismissStrategy('warning', DismissAlertStrategy.TEMPORARY_OR_PERMANENT);
+        }
+    }
+    ngOnDestroy() {
+        this.chartRealtimeService.stopRealtime();
+    }
+    onChartInit(ec) {
+        this.echartsInstance = ec;
+        this.echartsOptionsService.echartsInstance = this.echartsInstance;
+        this.startRealtimeIfPossible();
+        const dataZoomHandler = (evt) => {
+            if (evt.batch?.[0]?.start === 0 || evt['start'] === 0) {
+                this.showLoadMore = true;
+            }
+            const options = this.echartsInstance.getOption();
+            const dataZoom = options['dataZoom'][0];
+            this.sliderZoomUsed = true;
+            this.configChangeOnZoomOut.emit({
+                dateFrom: new Date(dataZoom['startValue']),
+                dateTo: new Date(dataZoom['endValue']),
+                interval: 'custom'
+            });
+            this.echartsInstance.setOption(options);
+            this.chartRealtimeService.stopRealtime();
+        };
+        const debouncedDataZoomHandler = this.config.realtime
+            ? dataZoomHandler
+            : this.debounce(dataZoomHandler, 1000);
+        this.echartsInstance.on('dataZoom', debouncedDataZoomHandler);
+        this.echartsInstance.on('click', this.onChartClick.bind(this));
+        let originalFormatter = null;
+        this.echartsInstance.on('mouseover', (params) => {
+            if (params?.componentType !== 'markLine' && params?.componentType !== 'markPoint') {
+                return;
+            }
+            const options = this.echartsInstance.getOption();
+            if (!options.tooltip || !Array.isArray(options.tooltip) || !options.tooltip[0]) {
+                return;
+            }
+            originalFormatter = originalFormatter ?? options['tooltip'][0].formatter;
+            const updatedOptions = {
+                tooltip: options['tooltip'][0]
+            };
+            if (!updatedOptions.tooltip) {
+                return;
+            }
+            updatedOptions.tooltip.formatter = (tooltipParams) => {
+                return this.echartsOptionsService.getTooltipFormatterForAlarmAndEvents(tooltipParams, params, this.events, this.alarms);
+            };
+            this.echartsInstance.setOption(updatedOptions);
+        });
+        this.echartsInstance.on('mouseout', () => {
+            const options = this.echartsInstance.getOption();
+            if (originalFormatter) {
+                options['tooltip'][0].formatter = originalFormatter;
+                this.echartsInstance.setOption(options);
+            }
+        });
+    }
+    onChartClick(params) {
+        const options = this.echartsInstance.getOption();
+        if (!this.isAlarmClick(params)) {
+            this.echartsInstance.setOption({
+                tooltip: { triggerOn: 'mousemove' },
+                series: [
+                    {
+                        markArea: {
+                            data: []
+                        },
+                        markLine: {
+                            data: []
+                        }
+                    }
+                ]
+            });
+            return;
+        }
+        const clickedAlarms = this.alarms.filter(alarm => alarm.type === params.data.itemType);
+        this.isMarkedAreaEnabled.emit(this.hasMarkArea(options));
+        const updatedOptions = !this.hasMarkArea(options)
+            ? {
+                tooltip: {
+                    enterable: true,
+                    triggerOn: 'click'
+                },
+                series: [
+                    {
+                        markArea: {
+                            label: {
+                                show: false
+                            },
+                            data: this.getMarkedAreaData(clickedAlarms)
+                        },
+                        markLine: {
+                            showSymbol: true,
+                            symbol: ['none', 'none'],
+                            data: this.getMarkedLineData(clickedAlarms)
+                        }
+                    }
+                ]
+            }
+            : // if markArea already exists, remove it and remove lastUpdated from markLine
+                {
+                    tooltip: { triggerOn: 'mousemove' },
+                    series: [
+                        {
+                            markArea: {
+                                data: []
+                            },
+                            markLine: {
+                                data: []
+                            }
+                        }
+                    ]
+                };
+        this.echartsInstance.setOption(updatedOptions);
+    }
+    isAlarmClick(params) {
+        return this.alarms.some(alarm => alarm.type === params.data.itemType);
+    }
+    hasMarkArea(options) {
+        return options?.series?.[0]?.markArea?.data?.length > 0;
+    }
+    saveAsImage() {
+        this.echartsInstance.setOption({
+            legend: {
+                show: true
+            }
+        });
+        const url = this.echartsInstance.getDataURL({
+            pixelRatio: 2,
+            backgroundColor: '#fff',
+            type: 'png'
+        });
+        const link = document.createElement('a');
+        link.href = url;
+        link.download = 'datapoints-graph-screenshot';
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+        this.echartsInstance.setOption({
+            legend: {
+                show: false
+            }
+        });
+    }
+    loadMoreData() {
+        const currentTimeRangeInMs = this.echartsOptionsService.calculateExtendedIntervalInMs(this.config.interval || 'custom', {
+            dateTo: this.widgetTimeContextDateRangeService.initialTimeRange().dateTo,
+            dateFrom: this.widgetTimeContextDateRangeService.initialTimeRange().dateFrom
+        });
+        this.widgetTimeContextDateRangeService.updateInitialTimeRange({
+            dateFrom: new Date(new Date(this.widgetTimeContextDateRangeService.initialTimeRange().dateFrom).valueOf() -
+                currentTimeRangeInMs / 4).toISOString(),
+            dateTo: this.widgetTimeContextDateRangeService.initialTimeRange().dateTo,
+            interval: 'custom'
+        });
+        const options = this.echartsInstance.getOption();
+        const dataZoom = options['dataZoom'][0];
+        this.configChangeOnZoomOut.emit({
+            dateFrom: new Date(dataZoom['startValue']),
+            dateTo: new Date(dataZoom['endValue']),
+            interval: 'custom'
+        });
+        this.showLoadMore = false;
+    }
+    debounce(func, wait) {
+        let timeout;
+        return (...args) => {
+            clearTimeout(timeout);
+            timeout = setTimeout(() => func(...args), wait);
+        };
+    }
+    getDefaultChartOptions() {
+        return {
+            title: {
+                text: gettext('No data available')
+            },
+            empty: true,
+            xAxis: {
+                type: 'category',
+                data: []
+            },
+            yAxis: {
+                type: 'value'
+            },
+            series: []
+        };
+    }
+    getMarkedAreaData(clickedAlarms) {
+        const timeRange = this.getTimeRange();
+        const clearedAlarmColor = 'rgba(221,255,221,1.00)';
+        const activeAlarmColor = 'rgba(255, 173, 177, 0.4)';
+        return clickedAlarms.map(clickedAlarm => {
+            return [
+                {
+                    name: clickedAlarm.type,
+                    xAxis: clickedAlarm.creationTime,
+                    itemStyle: {
+                        color: clickedAlarm.status === AlarmStatus.CLEARED ? clearedAlarmColor : activeAlarmColor
+                    }
+                },
+                {
+                    xAxis: clickedAlarm['lastUpdated'] === clickedAlarm.creationTime ||
+                        clickedAlarm.status !== AlarmStatus.CLEARED
+                        ? timeRange.dateTo
+                        : clickedAlarm['lastUpdated']
+                }
+            ];
+        });
+    }
+    getMarkedLineData(clickedAlarms) {
+        return clickedAlarms.reduce((acc, alarm) => {
+            const isClickedAlarmCleared = alarm.status === AlarmStatus.CLEARED;
+            if (isClickedAlarmCleared) {
+                return acc.concat([
+                    {
+                        xAxis: alarm.creationTime,
+                        itemType: alarm.type,
+                        label: {
+                            show: false,
+                            formatter: () => alarm.type
+                        },
+                        itemStyle: { color: alarm['color'] }
+                    },
+                    {
+                        xAxis: alarm['lastUpdated'],
+                        itemType: alarm.type,
+                        label: {
+                            show: false,
+                            formatter: () => alarm.type
+                        },
+                        itemStyle: { color: alarm['color'] }
+                    }
+                ]);
+            }
+            return acc.concat([
+                {
+                    xAxis: alarm.creationTime,
+                    itemType: alarm.type,
+                    label: {
+                        show: false,
+                        formatter: () => alarm.type
+                    },
+                    itemStyle: { color: alarm['color'] }
+                }
+            ]);
+        }, []);
+    }
+    async loadAlarmsAndEvents(customTimeRange) {
+        const timeRange = this.getTimeRange();
+        const updatedTimeRange = {
+            lastUpdatedFrom: customTimeRange ? customTimeRange.dateFrom : timeRange.dateFrom,
+            createdTo: customTimeRange ? customTimeRange.dateTo : timeRange.dateTo
+        };
+        if (!this.config.alarmsEventsConfigs)
+            return;
+        const visibleAlarmsOrEvents = this.config.alarmsEventsConfigs?.filter(alarmOrEvent => !alarmOrEvent.__hidden && alarmOrEvent.__active);
+        const alarms = visibleAlarmsOrEvents?.filter(alarmOrEvent => alarmOrEvent.timelineType === 'ALARM');
+        const events = visibleAlarmsOrEvents?.filter(alarmOrEvent => alarmOrEvent.timelineType === 'EVENT');
+        const [listedEvents, listedAlarms] = await Promise.all([
+            this.chartEventsService.listEvents(updatedTimeRange, events),
+            this.chartAlarmsService.listAlarms(updatedTimeRange, alarms)
+        ]);
+        this.events = listedEvents;
+        this.alarms = listedAlarms;
+        await this.addActiveAlarms(alarms);
+        this.updateAlarmsAndEvents.emit(this.config.alarmsEventsConfigs);
+    }
+    startRealtimeIfPossible() {
+        const activeDatapoints = this.config?.datapoints?.filter(dp => dp.__active);
+        if (activeDatapoints && this.config.realtime && this.echartsInstance) {
+            this.chartRealtimeService.startRealtime(this.echartsInstance, activeDatapoints, this.getTimeRange(), dp => this.datapointOutOfSync.emit(dp), timeRange => this.timeRangeChangeOnRealtime.emit(timeRange), this.config.alarmsEventsConfigs, {
+                displayMarkedLine: this.config.displayMarkedLine || false,
+                displayMarkedPoint: this.config.displayMarkedPoint || false
+            });
+        }
+    }
+    /*
+    This method should check and add active alarms from the begining of time to the alarm array
+    */
+    async addActiveAlarms(alarms) {
+        const timeRange = this.getTimeRange();
+        const params = {
+            dateFrom: '1970-01-01T01:00:00+01:00',
+            dateTo: timeRange.dateTo,
+            status: AlarmStatus.ACTIVE
+        };
+        const activeAlarms = await this.chartAlarmsService.listAlarms(params, alarms);
+        this.config.activeAlarmTypesOutOfRange = [];
+        // iterate through the activeAlarms and check if the alarm is in the alarms array, if not update the config.activeAlarmTypesOutOfRange prop
+        activeAlarms.forEach(activeAlarm => {
+            const alarmType = activeAlarm.type;
+            const alarm = this.alarms.find(alarm => alarm.type === alarmType);
+            if (!alarm && this.config.activeAlarmTypesOutOfRange) {
+                this.config.activeAlarmTypesOutOfRange.push(alarmType);
+            }
+        });
+    }
+    async getChartOptions(datapointsWithValues) {
+        const timeRange = { ...this.getTimeRange(), interval: this.config.interval };
+        if (!this.widgetTimeContextDateRangeService.initialTimeRange()) {
+            this.widgetTimeContextDateRangeService.updateInitialTimeRange(timeRange);
+            const aggregatedDatapoints = await lastValueFrom(this.fetchSeriesForDatapoints$({
+                dateFrom: new Date(new Date(timeRange.dateFrom).valueOf() -
+                    this.echartsOptionsService.calculateExtendedIntervalInMs(this.config.interval || 'custom', {
+                        dateFrom: timeRange.dateFrom,
+                        dateTo: timeRange.dateTo
+                    })).toISOString(),
+                dateTo: timeRange.dateTo
+            }));
+            return this.echartsOptionsService.getChartOptions(datapointsWithValues, timeRange, {
+                YAxis: this.config.yAxisSplitLines || false,
+                XAxis: this.config.xAxisSplitLines || false
+            }, this.events, this.alarms, {
+                displayMarkedLine: this.config.displayMarkedLine || false,
+                displayMarkedPoint: this.config.displayMarkedPoint || false,
+                mergeMatchingDatapoints: this.config.mergeMatchingDatapoints || false,
+                showLabelAndUnit: this.config.showLabelAndUnit || false,
+                showSlider: this.config.showSlider || false
+            }, undefined, aggregatedDatapoints);
+        }
+        else {
+            const aggregatedDatapoints = await lastValueFrom(this.fetchSeriesForDatapoints$({
+                dateFrom: new Date(new Date(this.widgetTimeContextDateRangeService.initialTimeRange().dateFrom).valueOf() -
+                    this.echartsOptionsService.calculateExtendedIntervalInMs(this.config.interval || 'custom', {
+                        dateFrom: this.widgetTimeContextDateRangeService.initialTimeRange().dateFrom,
+                        dateTo: this.widgetTimeContextDateRangeService.initialTimeRange().dateTo
+                    })).toISOString(),
+                dateTo: new Date(this.widgetTimeContextDateRangeService.initialTimeRange().dateTo).toISOString()
+            }));
+            return this.echartsOptionsService.getChartOptions(datapointsWithValues, this.widgetTimeContextDateRangeService.initialTimeRange(), {
+                YAxis: this.config.yAxisSplitLines || false,
+                XAxis: this.config.xAxisSplitLines || false
+            }, this.events, this.alarms, {
+                displayMarkedLine: this.config.displayMarkedLine || false,
+                displayMarkedPoint: this.config.displayMarkedPoint || false,
+                mergeMatchingDatapoints: this.config.mergeMatchingDatapoints || false,
+                showLabelAndUnit: this.config.showLabelAndUnit || false,
+                showSlider: this.config.showSlider || false
+            }, timeRange, aggregatedDatapoints, true);
+        }
+    }
+    fetchSeriesForDatapoints$(customTimeRange) {
+        const activeDatapoints = this.config?.datapoints?.filter(dp => dp.__active);
+        if (!activeDatapoints || activeDatapoints.length === 0) {
+            return of([]);
+        }
+        const datapointsWithValuesRequests = [];
+        const timeRange = this.getTimeRange(60_000);
+        for (const dp of activeDatapoints) {
+            const request = this.measurementService
+                .listSeries$({
+                ...(customTimeRange ? customTimeRange : timeRange),
+                source: dp.__target?.id || '',
+                series: [`${dp.fragment}.${dp.series}`],
+                ...(this.config.aggregation || customTimeRange
+                    ? {
+                        aggregationType: customTimeRange ? aggregationType.HOURLY : this.config.aggregation
+                    }
+                    : {})
+            })
+                .pipe(map(res => {
+                const values = res.data.values;
+                if (res.data.truncated && this.config.dateFrom) {
+                    values[new Date(this.config.dateFrom).toISOString()] = [{ min: null, max: null }];
+                }
+                else {
+                    if (this.alerts) {
+                        this.alerts.clear();
+                    }
+                }
+                return { ...dp, values, truncated: res.data.truncated };
+            }));
+            datapointsWithValuesRequests.push(request);
+        }
+        return forkJoin(datapointsWithValuesRequests).pipe(tap((dpsWithValues) => {
+            if (dpsWithValues.some(dp => dp['truncated'])) {
+                this.addTruncatedDataAlert();
+            }
+        }));
+    }
+    addTruncatedDataAlert() {
+        if (this.alerts?.alertGroups.find(a => a.type === 'warning')?.value?.alerts?.length) {
+            return;
+        }
+        const alert = new DynamicComponentAlert({
+            type: 'warning',
+            text: gettext('Truncated data. Change aggregation or select shorter date range.')
+        });
+        this.alerts?.addAlerts(alert);
+    }
+    getTimeRange(additionalPadding) {
+        let timeRange;
+        if (this.config.widgetInstanceGlobalTimeContext ||
+            (this.config.interval === 'custom' && !this.config.realtime)) {
+            timeRange = {
+                dateFrom: new Date(this.config.dateFrom),
+                dateTo: new Date(this.config.dateTo)
+            };
+        }
+        else {
+            let timeRangeInMs = 0;
+            if (this.config.interval && this.config.interval !== 'custom') {
+                timeRangeInMs = INTERVALS.find(i => i.id === this.config.interval)?.timespanInMs || 0;
+            }
+            else if (this.config.realtime) {
+                timeRangeInMs =
+                    new Date(this.config.dateTo).valueOf() -
+                        new Date(this.config.dateFrom).valueOf();
+            }
+            const now = new Date();
+            timeRange = {
+                dateFrom: new Date(now.valueOf() - timeRangeInMs),
+                dateTo: now
+            };
+        }
+        if (additionalPadding) {
+            timeRange.dateFrom = new Date(timeRange.dateFrom.valueOf() - additionalPadding);
+            timeRange.dateTo = new Date(timeRange.dateTo.valueOf() + additionalPadding);
+        }
+        return {
+            dateFrom: timeRange.dateFrom.toISOString(),
+            dateTo: timeRange.dateTo.toISOString()
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: ChartsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: ChartsComponent, isStandalone: true, selector: "c8y-charts", inputs: { config: "config", alerts: "alerts" }, outputs: { configChangeOnZoomOut: "configChangeOnZoomOut", timeRangeChangeOnRealtime: "timeRangeChangeOnRealtime", datapointOutOfSync: "datapointOutOfSync", updateAlarmsAndEvents: "updateAlarmsAndEvents", isMarkedAreaEnabled: "isMarkedAreaEnabled" }, providers: [
+            {
+                provide: NGX_ECHARTS_CONFIG,
+                useFactory: () => ({ echarts: () => import('echarts') })
+            },
+            ChartRealtimeService,
+            MeasurementRealtimeService,
+            AlarmRealtimeService,
+            EventRealtimeService,
+            ChartTypesService,
+            EchartsOptionsService,
+            CustomMeasurementService,
+            YAxisService,
+            AlarmSeverityToIconPipe,
+            AlarmSeverityToLabelPipe
+        ], viewQueries: [{ propertyName: "chart", first: true, predicate: ["chart"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div\n  class=\"p-relative fit-h chart-container\"\n>\n  <div\n    class=\"fit-w fit-h\"\n    #chart\n    echarts\n    [options]=\"chartOption$ | async\"\n    (chartInit)=\"onChartInit($event)\"\n  ></div>\n\n  <c8y-chart-alerts [alerts]=\"alerts\"></c8y-chart-alerts>\n\n  <div *ngIf=\"showLoadMore\" class=\"chart-load-more\">\n    <button\n      class=\"btn btn-primary btn-sm btn-block\"\n      (click)=\"loadMoreData()\"\n    >\n      <i c8yIcon=\"restore\"></i>\n      {{ 'Load more' | translate }}\n    </button>\n  </div>\n</div>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "ngmodule", type: CoreModule }, { kind: "directive", type: i2.IconDirective, selector: "[c8yIcon]", inputs: ["c8yIcon"] }, { kind: "pipe", type: i2.C8yTranslatePipe, name: "translate" }, { kind: "ngmodule", type: NgxEchartsModule }, { kind: "directive", type: i3.NgxEchartsDirective, selector: "echarts, [echarts]", inputs: ["options", "theme", "initOpts", "merge", "autoResize", "loading", "loadingType", "loadingOpts"], outputs: ["chartInit", "optionsError", "chartClick", "chartDblClick", "chartMouseDown", "chartMouseMove", "chartMouseUp", "chartMouseOver", "chartMouseOut", "chartGlobalOut", "chartContextMenu", "chartHighlight", "chartDownplay", "chartSelectChanged", "chartLegendSelectChanged", "chartLegendSelected", "chartLegendUnselected", "chartLegendLegendSelectAll", "chartLegendLegendInverseSelect", "chartLegendScroll", "chartDataZoom", "chartDataRangeSelected", "chartGraphRoam", "chartGeoRoam", "chartTreeRoam", "chartTimelineChanged", "chartTimelinePlayChanged", "chartRestore", "chartDataViewChanged", "chartMagicTypeChanged", "chartGeoSelectChanged", "chartGeoSelected", "chartGeoUnselected", "chartAxisAreaSelected", "chartBrush", "chartBrushEnd", "chartBrushSelected", "chartGlobalCursorTaken", "chartRendered", "chartFinished"], exportAs: ["echarts"] }, { kind: "ngmodule", type: TooltipModule }, { kind: "ngmodule", type: PopoverModule }, { kind: "component", type: ChartAlertsComponent, selector: "c8y-chart-alerts", inputs: ["alerts"] }, { kind: "ngmodule", type: AlarmsModule }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: ChartsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'c8y-charts', providers: [
+                        {
+                            provide: NGX_ECHARTS_CONFIG,
+                            useFactory: () => ({ echarts: () => import('echarts') })
+                        },
+                        ChartRealtimeService,
+                        MeasurementRealtimeService,
+                        AlarmRealtimeService,
+                        EventRealtimeService,
+                        ChartTypesService,
+                        EchartsOptionsService,
+                        CustomMeasurementService,
+                        YAxisService,
+                        AlarmSeverityToIconPipe,
+                        AlarmSeverityToLabelPipe
+                    ], standalone: true, imports: [
+                        CommonModule,
+                        CoreModule,
+                        NgxEchartsModule,
+                        TooltipModule,
+                        PopoverModule,
+                        ChartAlertsComponent,
+                        AlarmsModule
+                    ], template: "<div\n  class=\"p-relative fit-h chart-container\"\n>\n  <div\n    class=\"fit-w fit-h\"\n    #chart\n    echarts\n    [options]=\"chartOption$ | async\"\n    (chartInit)=\"onChartInit($event)\"\n  ></div>\n\n  <c8y-chart-alerts [alerts]=\"alerts\"></c8y-chart-alerts>\n\n  <div *ngIf=\"showLoadMore\" class=\"chart-load-more\">\n    <button\n      class=\"btn btn-primary btn-sm btn-block\"\n      (click)=\"loadMoreData()\"\n    >\n      <i c8yIcon=\"restore\"></i>\n      {{ 'Load more' | translate }}\n    </button>\n  </div>\n</div>\n" }]
+        }], ctorParameters: () => [], propDecorators: { config: [{
+                type: Input
+            }], alerts: [{
+                type: Input
+            }], configChangeOnZoomOut: [{
+                type: Output
+            }], timeRangeChangeOnRealtime: [{
+                type: Output
+            }], datapointOutOfSync: [{
+                type: Output
+            }], updateAlarmsAndEvents: [{
+                type: Output
+            }], isMarkedAreaEnabled: [{
+                type: Output
+            }], chart: [{
+                type: ViewChild,
+                args: ['chart']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"charts.component.js","sourceRoot":"","sources":["../../../echart/charts.component.ts","../../../echart/charts.component.html"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport {\n  Component,\n  ElementRef,\n  EventEmitter,\n  inject,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  ViewChild\n} from '@angular/core';\nimport type { ECharts, EChartsOption, SeriesOption } from 'echarts';\nimport {\n  AlarmDetailsExtended,\n  AlarmOrEventExtended,\n  DatapointsGraphKPIDetails,\n  DatapointsGraphWidgetConfig,\n  DpWithValues,\n  EventDetailsExtended,\n  MarkLineData\n} from './models';\nimport { BehaviorSubject, forkJoin, lastValueFrom, Observable, of } from 'rxjs';\nimport { map, switchMap, tap } from 'rxjs/operators';\nimport { CustomMeasurementService } from './services/custom-measurements.service';\nimport {\n  AlarmRealtimeService,\n  CoreModule,\n  DismissAlertStrategy,\n  DynamicComponentAlert,\n  DynamicComponentAlertAggregator,\n  EventRealtimeService,\n  gettext,\n  MeasurementRealtimeService,\n  WidgetTimeContextDateRangeService\n} from '@c8y/ngx-components';\nimport { EchartsOptionsService } from './services/echarts-options.service';\nimport { ChartRealtimeService } from './services/chart-realtime.service';\nimport type {\n  CallbackDataParams,\n  ECActionEvent,\n  TooltipFormatterCallback\n} from 'echarts/types/src/util/types';\nimport { ChartTypesService } from './services/chart-types.service';\nimport { CommonModule } from '@angular/common';\nimport { NGX_ECHARTS_CONFIG, NgxEchartsModule } from 'ngx-echarts';\nimport { TooltipModule } from 'ngx-bootstrap/tooltip';\nimport { PopoverModule } from 'ngx-bootstrap/popover';\nimport { YAxisService } from './services/y-axis.service';\nimport { ChartAlertsComponent } from './chart-alerts/chart-alerts.component';\nimport { aggregationType, AlarmStatus, IAlarm, IEvent } from '@c8y/client';\nimport { ChartEventsService } from './services/chart-events.service';\nimport { ChartAlarmsService } from './services/chart-alarms.service';\nimport { EchartsCustomOptions } from './models/chart.model';\nimport { TopLevelFormatterParams } from 'echarts/types/src/component/tooltip/TooltipModel';\nimport {\n  AlarmSeverityToIconPipe,\n  AlarmSeverityToLabelPipe,\n  AlarmsModule\n} from '@c8y/ngx-components/alarms';\nimport { Interval, INTERVALS } from '@c8y/ngx-components/interval-picker';\n\n@Component({\n  selector: 'c8y-charts',\n  templateUrl: './charts.component.html',\n  providers: [\n    {\n      provide: NGX_ECHARTS_CONFIG,\n      useFactory: () => ({ echarts: () => import('echarts') })\n    },\n    ChartRealtimeService,\n    MeasurementRealtimeService,\n    AlarmRealtimeService,\n    EventRealtimeService,\n    ChartTypesService,\n    EchartsOptionsService,\n    CustomMeasurementService,\n    YAxisService,\n    AlarmSeverityToIconPipe,\n    AlarmSeverityToLabelPipe\n  ],\n  standalone: true,\n  imports: [\n    CommonModule,\n    CoreModule,\n    NgxEchartsModule,\n    TooltipModule,\n    PopoverModule,\n    ChartAlertsComponent,\n    AlarmsModule\n  ]\n})\nexport class ChartsComponent implements OnChanges, OnInit, OnDestroy {\n  chartOption$: Observable<EChartsOption>;\n  echartsInstance!: ECharts;\n  showLoadMore = false;\n  alarms: IAlarm[] = [];\n  events: IEvent[] = [];\n  sliderZoomUsed = false;\n  @Input() config!: DatapointsGraphWidgetConfig;\n  @Input() alerts!: DynamicComponentAlertAggregator;\n  @Output() configChangeOnZoomOut = new EventEmitter<{\n    dateFrom: Date;\n    dateTo: Date;\n    interval?: Interval['id'];\n  }>();\n  @Output() timeRangeChangeOnRealtime = new EventEmitter<\n    Pick<DatapointsGraphWidgetConfig, 'dateFrom' | 'dateTo'>\n  >();\n  @Output() datapointOutOfSync = new EventEmitter<DatapointsGraphKPIDetails>();\n  @Output() updateAlarmsAndEvents = new EventEmitter<AlarmOrEventExtended[]>();\n  @Output() isMarkedAreaEnabled = new EventEmitter<boolean>();\n  @ViewChild('chart') chart: ElementRef;\n  private configChangedSubject = new BehaviorSubject<void | null>(null);\n\n  private readonly measurementService = inject(CustomMeasurementService);\n  private readonly echartsOptionsService = inject(EchartsOptionsService);\n  private readonly chartRealtimeService = inject(ChartRealtimeService);\n  private readonly chartEventsService = inject(ChartEventsService);\n  private readonly chartAlarmsService = inject(ChartAlarmsService);\n  private readonly widgetTimeContextDateRangeService = inject(WidgetTimeContextDateRangeService);\n\n  constructor() {\n    this.chartOption$ = this.configChangedSubject.pipe(\n      switchMap(() => this.loadAlarmsAndEvents()),\n      switchMap(() => this.fetchSeriesForDatapoints$()),\n      switchMap((datapointsWithValues: DpWithValues[]) => {\n        if (datapointsWithValues.length === 0) {\n          this.echartsInstance?.clear();\n          this.showLoadMore = false;\n          return of(this.getDefaultChartOptions());\n        }\n        return this.getChartOptions(datapointsWithValues);\n      }),\n      tap(v => {\n        if (v['empty']) {\n          return;\n        }\n        this.chartRealtimeService.stopRealtime();\n        this.startRealtimeIfPossible();\n\n        if (this.echartsInstance) {\n          this.echartsInstance.setOption(v, true);\n          const options = this.echartsInstance.getOption();\n          const dataZoom = options['dataZoom'][0];\n          if (dataZoom.start !== 0) {\n            this.showLoadMore = false;\n          }\n        }\n        this.sliderZoomUsed = false;\n      })\n    );\n  }\n\n  ngOnChanges() {\n    this.configChangedSubject.next();\n  }\n\n  ngOnInit() {\n    if (this.alerts) {\n      this.alerts.setAlertGroupDismissStrategy(\n        'warning',\n        DismissAlertStrategy.TEMPORARY_OR_PERMANENT\n      );\n    }\n  }\n\n  ngOnDestroy() {\n    this.chartRealtimeService.stopRealtime();\n  }\n\n  onChartInit(ec: ECharts) {\n    this.echartsInstance = ec;\n    this.echartsOptionsService.echartsInstance = this.echartsInstance;\n    this.startRealtimeIfPossible();\n\n    const dataZoomHandler = (evt: ECActionEvent) => {\n      if (evt.batch?.[0]?.start === 0 || evt['start'] === 0) {\n        this.showLoadMore = true;\n      }\n\n      const options = this.echartsInstance.getOption();\n      const dataZoom = options['dataZoom'][0];\n      this.sliderZoomUsed = true;\n      this.configChangeOnZoomOut.emit({\n        dateFrom: new Date(dataZoom['startValue']),\n        dateTo: new Date(dataZoom['endValue']),\n        interval: 'custom'\n      });\n      this.echartsInstance.setOption(options);\n      this.chartRealtimeService.stopRealtime();\n    };\n\n    const debouncedDataZoomHandler = this.config.realtime\n      ? dataZoomHandler\n      : this.debounce(dataZoomHandler, 1000);\n\n    this.echartsInstance.on('dataZoom', debouncedDataZoomHandler);\n    this.echartsInstance.on('click', this.onChartClick.bind(this));\n\n    let originalFormatter:\n      | TooltipFormatterCallback<TopLevelFormatterParams>\n      | string\n      | null\n      | undefined = null;\n\n    this.echartsInstance.on('mouseover', (params: any) => {\n      if (params?.componentType !== 'markLine' && params?.componentType !== 'markPoint') {\n        return;\n      }\n\n      const options = this.echartsInstance.getOption() as EChartsOption;\n      if (!options.tooltip || !Array.isArray(options.tooltip) || !options.tooltip[0]) {\n        return;\n      }\n      originalFormatter = originalFormatter ?? options['tooltip'][0].formatter;\n\n      const updatedOptions: Partial<SeriesOption> = {\n        tooltip: options['tooltip'][0]\n      };\n\n      if (!updatedOptions.tooltip) {\n        return;\n      }\n      updatedOptions.tooltip.formatter = (tooltipParams: CallbackDataParams) => {\n        return this.echartsOptionsService.getTooltipFormatterForAlarmAndEvents(\n          tooltipParams,\n          params,\n          this.events,\n          this.alarms\n        );\n      };\n\n      this.echartsInstance.setOption(updatedOptions);\n    });\n\n    this.echartsInstance.on('mouseout', () => {\n      const options = this.echartsInstance.getOption() as EchartsCustomOptions;\n      if (originalFormatter) {\n        options['tooltip'][0].formatter = originalFormatter;\n        this.echartsInstance.setOption(options);\n      }\n    });\n  }\n\n  onChartClick(params: { data: { itemType: string } }): void {\n    const options = this.echartsInstance.getOption();\n    if (!this.isAlarmClick(params)) {\n      this.echartsInstance.setOption({\n        tooltip: { triggerOn: 'mousemove' },\n        series: [\n          {\n            markArea: {\n              data: []\n            },\n            markLine: {\n              data: []\n            }\n          }\n        ]\n      });\n      return;\n    }\n\n    const clickedAlarms = this.alarms.filter(alarm => alarm.type === params.data.itemType);\n\n    this.isMarkedAreaEnabled.emit(this.hasMarkArea(options));\n    const updatedOptions = !this.hasMarkArea(options)\n      ? {\n          tooltip: {\n            enterable: true,\n            triggerOn: 'click'\n          },\n          series: [\n            {\n              markArea: {\n                label: {\n                  show: false\n                },\n                data: this.getMarkedAreaData(clickedAlarms)\n              },\n              markLine: {\n                showSymbol: true,\n                symbol: ['none', 'none'],\n                data: this.getMarkedLineData(clickedAlarms)\n              }\n            }\n          ]\n        }\n      : // if markArea already exists, remove it and remove lastUpdated from markLine\n        {\n          tooltip: { triggerOn: 'mousemove' },\n          series: [\n            {\n              markArea: {\n                data: []\n              },\n              markLine: {\n                data: []\n              }\n            }\n          ]\n        };\n\n    this.echartsInstance.setOption(updatedOptions);\n  }\n\n  isAlarmClick(params: any): boolean {\n    return this.alarms.some(alarm => alarm.type === params.data.itemType);\n  }\n\n  hasMarkArea(options: any): boolean {\n    return options?.series?.[0]?.markArea?.data?.length > 0;\n  }\n\n  saveAsImage(): void {\n    this.echartsInstance.setOption({\n      legend: {\n        show: true\n      }\n    });\n    const url = this.echartsInstance.getDataURL({\n      pixelRatio: 2,\n      backgroundColor: '#fff',\n      type: 'png'\n    });\n    const link = document.createElement('a');\n    link.href = url;\n    link.download = 'datapoints-graph-screenshot';\n    document.body.appendChild(link);\n    link.click();\n    document.body.removeChild(link);\n    this.echartsInstance.setOption({\n      legend: {\n        show: false\n      }\n    });\n  }\n\n  loadMoreData(): void {\n    const currentTimeRangeInMs = this.echartsOptionsService.calculateExtendedIntervalInMs(\n      this.config.interval || 'custom',\n      {\n        dateTo: this.widgetTimeContextDateRangeService.initialTimeRange().dateTo,\n        dateFrom: this.widgetTimeContextDateRangeService.initialTimeRange().dateFrom\n      }\n    );\n    this.widgetTimeContextDateRangeService.updateInitialTimeRange({\n      dateFrom: new Date(\n        new Date(this.widgetTimeContextDateRangeService.initialTimeRange().dateFrom).valueOf() -\n          currentTimeRangeInMs / 4\n      ).toISOString(),\n      dateTo: this.widgetTimeContextDateRangeService.initialTimeRange().dateTo,\n      interval: 'custom'\n    });\n    const options = this.echartsInstance.getOption();\n    const dataZoom = options['dataZoom'][0];\n    this.configChangeOnZoomOut.emit({\n      dateFrom: new Date(dataZoom['startValue']),\n      dateTo: new Date(dataZoom['endValue']),\n      interval: 'custom'\n    });\n    this.showLoadMore = false;\n  }\n\n  debounce<T extends (...args: any[]) => void>(\n    func: T,\n    wait: number\n  ): (...args: Parameters<T>) => void {\n    let timeout: ReturnType<typeof setTimeout>;\n    return (...args: Parameters<T>) => {\n      clearTimeout(timeout);\n      timeout = setTimeout(() => func(...args), wait);\n    };\n  }\n\n  private getDefaultChartOptions(): EChartsOption {\n    return {\n      title: {\n        text: gettext('No data available')\n      },\n      empty: true,\n      xAxis: {\n        type: 'category',\n        data: []\n      },\n      yAxis: {\n        type: 'value'\n      },\n      series: []\n    };\n  }\n\n  private getMarkedAreaData(clickedAlarms: IAlarm[]) {\n    const timeRange = this.getTimeRange();\n    const clearedAlarmColor = 'rgba(221,255,221,1.00)';\n    const activeAlarmColor = 'rgba(255, 173, 177, 0.4)';\n\n    return clickedAlarms.map(clickedAlarm => {\n      return [\n        {\n          name: clickedAlarm.type,\n          xAxis: clickedAlarm.creationTime,\n          itemStyle: {\n            color:\n              clickedAlarm.status === AlarmStatus.CLEARED ? clearedAlarmColor : activeAlarmColor\n          }\n        },\n        {\n          xAxis:\n            clickedAlarm['lastUpdated'] === clickedAlarm.creationTime ||\n            clickedAlarm.status !== AlarmStatus.CLEARED\n              ? timeRange.dateTo\n              : clickedAlarm['lastUpdated']\n        }\n      ];\n    });\n  }\n\n  private getMarkedLineData(clickedAlarms: IAlarm[]) {\n    return clickedAlarms.reduce<MarkLineData[]>((acc, alarm) => {\n      const isClickedAlarmCleared = alarm.status === AlarmStatus.CLEARED;\n      if (isClickedAlarmCleared) {\n        return acc.concat([\n          {\n            xAxis: alarm.creationTime,\n            itemType: alarm.type,\n            label: {\n              show: false,\n              formatter: () => alarm.type\n            },\n            itemStyle: { color: alarm['color'] }\n          },\n          {\n            xAxis: alarm['lastUpdated'],\n            itemType: alarm.type,\n            label: {\n              show: false,\n              formatter: () => alarm.type\n            },\n            itemStyle: { color: alarm['color'] }\n          }\n        ]);\n      }\n      return acc.concat([\n        {\n          xAxis: alarm.creationTime,\n          itemType: alarm.type,\n          label: {\n            show: false,\n            formatter: () => alarm.type\n          },\n          itemStyle: { color: alarm['color'] }\n        }\n      ]);\n    }, []);\n  }\n\n  private async loadAlarmsAndEvents(customTimeRange?: any): Promise<void> {\n    const timeRange = this.getTimeRange();\n    const updatedTimeRange = {\n      lastUpdatedFrom: customTimeRange ? customTimeRange.dateFrom : timeRange.dateFrom,\n      createdTo: customTimeRange ? customTimeRange.dateTo : timeRange.dateTo\n    };\n    if (!this.config.alarmsEventsConfigs) return;\n    const visibleAlarmsOrEvents = this.config.alarmsEventsConfigs?.filter(\n      alarmOrEvent => !alarmOrEvent.__hidden && alarmOrEvent.__active\n    );\n    const alarms = visibleAlarmsOrEvents?.filter(\n      alarmOrEvent => alarmOrEvent.timelineType === 'ALARM'\n    ) as AlarmDetailsExtended[];\n    const events = visibleAlarmsOrEvents?.filter(\n      alarmOrEvent => alarmOrEvent.timelineType === 'EVENT'\n    ) as EventDetailsExtended[];\n\n    const [listedEvents, listedAlarms] = await Promise.all([\n      this.chartEventsService.listEvents(updatedTimeRange, events),\n      this.chartAlarmsService.listAlarms(updatedTimeRange, alarms)\n    ]);\n\n    this.events = listedEvents;\n    this.alarms = listedAlarms;\n    await this.addActiveAlarms(alarms);\n\n    this.updateAlarmsAndEvents.emit(this.config.alarmsEventsConfigs);\n  }\n\n  private startRealtimeIfPossible(): void {\n    const activeDatapoints = this.config?.datapoints?.filter(dp => dp.__active);\n    if (activeDatapoints && this.config.realtime && this.echartsInstance) {\n      this.chartRealtimeService.startRealtime(\n        this.echartsInstance,\n        activeDatapoints,\n        this.getTimeRange(),\n        dp => this.datapointOutOfSync.emit(dp),\n        timeRange => this.timeRangeChangeOnRealtime.emit(timeRange),\n        this.config.alarmsEventsConfigs,\n        {\n          displayMarkedLine: this.config.displayMarkedLine || false,\n          displayMarkedPoint: this.config.displayMarkedPoint || false\n        }\n      );\n    }\n  }\n\n  /*\n  This method should check and add active alarms from the begining of time to the alarm array\n  */\n  private async addActiveAlarms(alarms: AlarmDetailsExtended[]): Promise<void> {\n    const timeRange = this.getTimeRange();\n    const params = {\n      dateFrom: '1970-01-01T01:00:00+01:00',\n      dateTo: timeRange.dateTo,\n      status: AlarmStatus.ACTIVE\n    };\n\n    const activeAlarms = await this.chartAlarmsService.listAlarms(params, alarms);\n    this.config.activeAlarmTypesOutOfRange = [];\n    // iterate through the activeAlarms and check if the alarm is in the alarms array, if not update the config.activeAlarmTypesOutOfRange prop\n    activeAlarms.forEach(activeAlarm => {\n      const alarmType = activeAlarm.type;\n      const alarm = this.alarms.find(alarm => alarm.type === alarmType);\n      if (!alarm && this.config.activeAlarmTypesOutOfRange) {\n        this.config.activeAlarmTypesOutOfRange.push(alarmType);\n      }\n    });\n  }\n\n  private async getChartOptions(datapointsWithValues: DpWithValues[]): Promise<EChartsOption> {\n    const timeRange = { ...this.getTimeRange(), interval: this.config.interval };\n    if (!this.widgetTimeContextDateRangeService.initialTimeRange()) {\n      this.widgetTimeContextDateRangeService.updateInitialTimeRange(timeRange);\n      const aggregatedDatapoints = await lastValueFrom(\n        this.fetchSeriesForDatapoints$({\n          dateFrom: new Date(\n            new Date(timeRange.dateFrom).valueOf() -\n              this.echartsOptionsService.calculateExtendedIntervalInMs(\n                this.config.interval || 'custom',\n                {\n                  dateFrom: timeRange.dateFrom,\n                  dateTo: timeRange.dateTo\n                }\n              )\n          ).toISOString(),\n          dateTo: timeRange.dateTo\n        })\n      );\n      return this.echartsOptionsService.getChartOptions(\n        datapointsWithValues,\n        timeRange,\n        {\n          YAxis: this.config.yAxisSplitLines || false,\n          XAxis: this.config.xAxisSplitLines || false\n        },\n        this.events,\n        this.alarms,\n        {\n          displayMarkedLine: this.config.displayMarkedLine || false,\n          displayMarkedPoint: this.config.displayMarkedPoint || false,\n          mergeMatchingDatapoints: this.config.mergeMatchingDatapoints || false,\n          showLabelAndUnit: this.config.showLabelAndUnit || false,\n          showSlider: this.config.showSlider || false\n        },\n        undefined,\n        aggregatedDatapoints\n      );\n    } else {\n      const aggregatedDatapoints = await lastValueFrom(\n        this.fetchSeriesForDatapoints$({\n          dateFrom: new Date(\n            new Date(this.widgetTimeContextDateRangeService.initialTimeRange().dateFrom).valueOf() -\n              this.echartsOptionsService.calculateExtendedIntervalInMs(\n                this.config.interval || 'custom',\n                {\n                  dateFrom: this.widgetTimeContextDateRangeService.initialTimeRange().dateFrom,\n                  dateTo: this.widgetTimeContextDateRangeService.initialTimeRange().dateTo\n                }\n              )\n          ).toISOString(),\n          dateTo: new Date(\n            this.widgetTimeContextDateRangeService.initialTimeRange().dateTo\n          ).toISOString()\n        })\n      );\n      return this.echartsOptionsService.getChartOptions(\n        datapointsWithValues,\n        this.widgetTimeContextDateRangeService.initialTimeRange(),\n        {\n          YAxis: this.config.yAxisSplitLines || false,\n          XAxis: this.config.xAxisSplitLines || false\n        },\n        this.events,\n        this.alarms,\n        {\n          displayMarkedLine: this.config.displayMarkedLine || false,\n          displayMarkedPoint: this.config.displayMarkedPoint || false,\n          mergeMatchingDatapoints: this.config.mergeMatchingDatapoints || false,\n          showLabelAndUnit: this.config.showLabelAndUnit || false,\n          showSlider: this.config.showSlider || false\n        },\n        timeRange,\n        aggregatedDatapoints,\n        true\n      );\n    }\n  }\n\n  private fetchSeriesForDatapoints$(customTimeRange?: any): Observable<DpWithValues[]> {\n    const activeDatapoints = this.config?.datapoints?.filter(dp => dp.__active);\n    if (!activeDatapoints || activeDatapoints.length === 0) {\n      return of([]);\n    }\n    const datapointsWithValuesRequests: Observable<DpWithValues>[] = [];\n    const timeRange = this.getTimeRange(60_000);\n    for (const dp of activeDatapoints) {\n      const request = this.measurementService\n        .listSeries$({\n          ...(customTimeRange ? customTimeRange : timeRange),\n          source: dp.__target?.id || '',\n          series: [`${dp.fragment}.${dp.series}`],\n          ...(this.config.aggregation || customTimeRange\n            ? {\n                aggregationType: customTimeRange ? aggregationType.HOURLY : this.config.aggregation\n              }\n            : {})\n        })\n        .pipe(\n          map(res => {\n            const values = res.data.values;\n            if (res.data.truncated && this.config.dateFrom) {\n              values[new Date(this.config.dateFrom).toISOString()] = [{ min: null, max: null }];\n            } else {\n              if (this.alerts) {\n                this.alerts.clear();\n              }\n            }\n            return { ...dp, values, truncated: res.data.truncated };\n          })\n        );\n\n      datapointsWithValuesRequests.push(request);\n    }\n    return forkJoin(datapointsWithValuesRequests).pipe(\n      tap((dpsWithValues: DpWithValues[]) => {\n        if (dpsWithValues.some(dp => dp['truncated'])) {\n          this.addTruncatedDataAlert();\n        }\n      })\n    );\n  }\n\n  private addTruncatedDataAlert(): void {\n    if (this.alerts?.alertGroups.find(a => a.type === 'warning')?.value?.alerts?.length) {\n      return;\n    }\n    const alert = new DynamicComponentAlert({\n      type: 'warning',\n      text: gettext('Truncated data. Change aggregation or select shorter date range.')\n    });\n\n    this.alerts?.addAlerts(alert);\n  }\n\n  private getTimeRange(additionalPadding?: number): {\n    dateFrom: string;\n    dateTo: string;\n  } {\n    let timeRange: { dateFrom: Date; dateTo: Date };\n    if (\n      this.config.widgetInstanceGlobalTimeContext ||\n      (this.config.interval === 'custom' && !this.config.realtime)\n    ) {\n      timeRange = {\n        dateFrom: new Date(this.config.dateFrom as Date),\n        dateTo: new Date(this.config.dateTo as Date)\n      };\n    } else {\n      let timeRangeInMs = 0;\n      if (this.config.interval && this.config.interval !== 'custom') {\n        timeRangeInMs = INTERVALS.find(i => i.id === this.config.interval)?.timespanInMs || 0;\n      } else if (this.config.realtime) {\n        timeRangeInMs =\n          new Date(this.config.dateTo as Date).valueOf() -\n          new Date(this.config.dateFrom as Date).valueOf();\n      }\n      const now = new Date();\n      timeRange = {\n        dateFrom: new Date(now.valueOf() - timeRangeInMs),\n        dateTo: now\n      };\n    }\n    if (additionalPadding) {\n      timeRange.dateFrom = new Date(timeRange.dateFrom.valueOf() - additionalPadding);\n      timeRange.dateTo = new Date(timeRange.dateTo.valueOf() + additionalPadding);\n    }\n    return {\n      dateFrom: timeRange.dateFrom.toISOString(),\n      dateTo: timeRange.dateTo.toISOString()\n    };\n  }\n}\n","<div\n  class=\"p-relative fit-h chart-container\"\n>\n  <div\n    class=\"fit-w fit-h\"\n    #chart\n    echarts\n    [options]=\"chartOption$ | async\"\n    (chartInit)=\"onChartInit($event)\"\n  ></div>\n\n  <c8y-chart-alerts [alerts]=\"alerts\"></c8y-chart-alerts>\n\n  <div *ngIf=\"showLoadMore\" class=\"chart-load-more\">\n    <button\n      class=\"btn btn-primary btn-sm btn-block\"\n      (click)=\"loadMoreData()\"\n    >\n      <i c8yIcon=\"restore\"></i>\n      {{ 'Load more' | translate }}\n    </button>\n  </div>\n</div>\n"]}