@c8y/ngx-components 1021.52.0 → 1021.54.2

package/esm2022/echart/services/y-axis.service.mjs

@@ -0,0 +1,150 @@
+import { Injectable } from '@angular/core';
+import { AppStateService } from '@c8y/ngx-components';
+import * as i0 from "@angular/core";
+import * as i1 from "@c8y/ngx-components";
+export class YAxisService {
+    constructor(appStateService) {
+        this.appStateService = appStateService;
+        this.Y_AXIS_OFFSET = 48;
+        this.intlNumberFormatCompliantLocale = this.appStateService.state.lang.replace('_', '-');
+    }
+    getYAxis(datapointsWithValues, YAxisOptions) {
+        const YAxisPlacement = this.getYAxisPlacement(datapointsWithValues);
+        const matchingDpSet = new Set();
+        const firstOccurrence = new Set();
+        return datapointsWithValues.map((dp, index) => {
+            const isDefined = (value) => value !== null && value !== undefined;
+            const isMatchingDp = (dp1, dp2) => dp1.min === dp2.min &&
+                dp1.max === dp2.max &&
+                isDefined(dp1.min) &&
+                isDefined(dp1.max) &&
+                isDefined(dp2.min) &&
+                isDefined(dp2.max);
+            const matchingDpRange = datapointsWithValues.some((dp2, index2) => isMatchingDp(dp, dp2) && index2 < index);
+            const anyMatchingDp = datapointsWithValues.some((dp2, index2) => isMatchingDp(dp, dp2) && index2 !== index);
+            if (anyMatchingDp &&
+                !matchingDpRange &&
+                YAxisOptions.mergeMatchingDatapoints &&
+                !firstOccurrence.has(dp)) {
+                firstOccurrence.add(dp);
+            }
+            if (firstOccurrence.has(dp)) {
+                datapointsWithValues.forEach(dp2 => {
+                    if (isMatchingDp(dp, dp2)) {
+                        matchingDpSet.add(dp2);
+                    }
+                });
+            }
+            return {
+                name: YAxisOptions.showLabelAndUnit
+                    ? YAxisOptions.mergeMatchingDatapoints
+                        ? firstOccurrence.has(dp)
+                            ? Array.from(matchingDpSet)
+                                .map(dp => `{${dp.__target?.id}|${dp.unit}}`)
+                                .join(' /')
+                            : matchingDpRange
+                                ? ''
+                                : `${dp.label} [${dp.unit}]`
+                        : `${dp.label} [${dp.unit}]`
+                    : '',
+                nameLocation: 'middle',
+                nameGap: 20,
+                nameTextStyle: {
+                    // add rich text to support multiple colors for different dp units
+                    rich: {
+                        ...Array.from(matchingDpSet).reduce((acc, dp) => {
+                            const accKey = `${dp.__target?.id}`;
+                            acc[accKey] = {
+                                color: dp.color
+                            };
+                            return acc;
+                        }, {})
+                    }
+                },
+                type: 'value',
+                animation: true,
+                axisLine: {
+                    show: matchingDpRange && YAxisOptions.mergeMatchingDatapoints ? false : true,
+                    lineStyle: {
+                        color: firstOccurrence.has(dp) ? 'black' : dp.color
+                    },
+                    onZero: false
+                },
+                axisLabel: {
+                    fontSize: 10,
+                    show: !matchingDpRange || !YAxisOptions.mergeMatchingDatapoints,
+                    formatter: val => {
+                        if (dp.min != undefined && dp.max != undefined) {
+                            const range = dp.max - dp.min;
+                            const decimalPlaces = this.getDecimalPlaces(range);
+                            return val.toFixed(decimalPlaces);
+                        }
+                        return new Intl.NumberFormat(this.intlNumberFormatCompliantLocale, {
+                            notation: 'compact',
+                            compactDisplay: 'short'
+                        }).format(val);
+                    }
+                },
+                splitLine: {
+                    show: YAxisOptions.showSplitLines && !matchingDpRange,
+                    lineStyle: { color: dp.color, opacity: 0.4, type: 'dashed' }
+                },
+                position: YAxisPlacement.get(dp)?.position,
+                offset: YAxisPlacement.get(dp)?.offset,
+                axisTick: {
+                    show: !matchingDpRange || !YAxisOptions.mergeMatchingDatapoints
+                },
+                axisPointer: {
+                    show: false,
+                    label: {
+                        show: false
+                    }
+                },
+                ...(dp.min && { min: dp.min }),
+                ...(dp.max && { max: dp.max })
+            };
+        });
+    }
+    getDecimalPlaces(num) {
+        const numStr = num.toString();
+        const decimalIndex = numStr.indexOf('.');
+        if (decimalIndex === -1) {
+            return 0;
+        }
+        return numStr.length - decimalIndex - 1;
+    }
+    getYAxisPlacement(datapointsWithValues) {
+        const YAxisPositions = new Map();
+        datapointsWithValues.forEach(dp => {
+            const position = this.getYAxisPosition(dp, datapointsWithValues);
+            YAxisPositions.set(dp, { position });
+        });
+        const dpLeft = datapointsWithValues.filter(dp => YAxisPositions.get(dp).position === 'left');
+        const dpRight = datapointsWithValues.filter(dp => YAxisPositions.get(dp).position === 'right');
+        const YAxisPlacement = new Map();
+        YAxisPositions.forEach(({ position }, key) => {
+            const offset = (position === 'left' ? dpLeft : dpRight).indexOf(key) * this.Y_AXIS_OFFSET;
+            YAxisPlacement.set(key, { position: position, offset });
+        });
+        return YAxisPlacement;
+    }
+    getYAxisPosition(datapoint, datapointsWithValues) {
+        if (datapoint.yAxisType) {
+            return datapoint.yAxisType;
+        }
+        const currentIndex = datapointsWithValues.indexOf(datapoint);
+        const otherIndexLeft = datapointsWithValues.findIndex(dp => dp !== datapoint && (!dp.yAxisType || dp.yAxisType === 'left'));
+        if (otherIndexLeft > -1 && otherIndexLeft < currentIndex) {
+            return 'right';
+        }
+        else {
+            return 'left';
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: YAxisService, deps: [{ token: i1.AppStateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: YAxisService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: YAxisService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.AppStateService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"y-axis.service.js","sourceRoot":"","sources":["../../../../echart/services/y-axis.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { DatapointAxisType, DpWithValues, YAxisOptions } from '../models';\nimport type { YAXisOption } from 'echarts/types/src/coord/cartesian/AxisModel';\nimport { AppStateService } from '@c8y/ngx-components';\n\n@Injectable()\nexport class YAxisService {\n  Y_AXIS_OFFSET = 48;\n  private intlNumberFormatCompliantLocale: string;\n\n  constructor(private appStateService: AppStateService) {\n    this.intlNumberFormatCompliantLocale = this.appStateService.state.lang.replace('_', '-');\n  }\n\n  getYAxis(datapointsWithValues: DpWithValues[], YAxisOptions: YAxisOptions): YAXisOption[] {\n    const YAxisPlacement: Map<DpWithValues, { position: DatapointAxisType; offset: number }> =\n      this.getYAxisPlacement(datapointsWithValues);\n\n    const matchingDpSet = new Set<DpWithValues>();\n    const firstOccurrence = new Set<DpWithValues>();\n\n    return datapointsWithValues.map((dp, index) => {\n      const isDefined = (value: number | undefined) => value !== null && value !== undefined;\n      const isMatchingDp = (dp1: DpWithValues, dp2: DpWithValues) =>\n        dp1.min === dp2.min &&\n        dp1.max === dp2.max &&\n        isDefined(dp1.min) &&\n        isDefined(dp1.max) &&\n        isDefined(dp2.min) &&\n        isDefined(dp2.max);\n\n      const matchingDpRange = datapointsWithValues.some(\n        (dp2, index2) => isMatchingDp(dp, dp2) && index2 < index\n      );\n\n      const anyMatchingDp = datapointsWithValues.some(\n        (dp2, index2) => isMatchingDp(dp, dp2) && index2 !== index\n      );\n\n      if (\n        anyMatchingDp &&\n        !matchingDpRange &&\n        YAxisOptions.mergeMatchingDatapoints &&\n        !firstOccurrence.has(dp)\n      ) {\n        firstOccurrence.add(dp);\n      }\n\n      if (firstOccurrence.has(dp)) {\n        datapointsWithValues.forEach(dp2 => {\n          if (isMatchingDp(dp, dp2)) {\n            matchingDpSet.add(dp2);\n          }\n        });\n      }\n\n      return {\n        name: YAxisOptions.showLabelAndUnit\n          ? YAxisOptions.mergeMatchingDatapoints\n            ? firstOccurrence.has(dp)\n              ? Array.from(matchingDpSet)\n                  .map(dp => `{${dp.__target?.id}|${dp.unit}}`)\n                  .join(' /')\n              : matchingDpRange\n                ? ''\n                : `${dp.label} [${dp.unit}]`\n            : `${dp.label} [${dp.unit}]`\n          : '',\n        nameLocation: 'middle',\n        nameGap: 20,\n        nameTextStyle: {\n          // add rich text to support multiple colors for different dp units\n          rich: {\n            ...Array.from(matchingDpSet).reduce((acc, dp) => {\n              const accKey = `${dp.__target?.id}`;\n              acc[accKey] = {\n                color: dp.color\n              };\n              return acc;\n            }, {})\n          }\n        },\n        type: 'value',\n        animation: true,\n        axisLine: {\n          show: matchingDpRange && YAxisOptions.mergeMatchingDatapoints ? false : true,\n          lineStyle: {\n            color: firstOccurrence.has(dp) ? 'black' : dp.color\n          },\n          onZero: false\n        },\n        axisLabel: {\n          fontSize: 10,\n          show: !matchingDpRange || !YAxisOptions.mergeMatchingDatapoints,\n          formatter: val => {\n            if (dp.min != undefined && dp.max != undefined) {\n              const range = dp.max - dp.min;\n              const decimalPlaces = this.getDecimalPlaces(range);\n              return val.toFixed(decimalPlaces);\n            }\n\n            return new Intl.NumberFormat(this.intlNumberFormatCompliantLocale, {\n              notation: 'compact',\n              compactDisplay: 'short'\n            }).format(val);\n          }\n        },\n        splitLine: {\n          show: YAxisOptions.showSplitLines && !matchingDpRange,\n          lineStyle: { color: dp.color, opacity: 0.4, type: 'dashed' }\n        },\n        position: YAxisPlacement.get(dp)?.position,\n        offset: YAxisPlacement.get(dp)?.offset,\n        axisTick: {\n          show: !matchingDpRange || !YAxisOptions.mergeMatchingDatapoints\n        },\n        axisPointer: {\n          show: false,\n          label: {\n            show: false\n          }\n        },\n        ...(dp.min && { min: dp.min }),\n        ...(dp.max && { max: dp.max })\n      };\n    });\n  }\n\n  private getDecimalPlaces(num: number): number {\n    const numStr = num.toString();\n    const decimalIndex = numStr.indexOf('.');\n    if (decimalIndex === -1) {\n      return 0;\n    }\n    return numStr.length - decimalIndex - 1;\n  }\n\n  private getYAxisPlacement(\n    datapointsWithValues: DpWithValues[]\n  ): Map<DpWithValues, { position: DatapointAxisType; offset: number }> {\n    const YAxisPositions = new Map<DpWithValues, { position: DatapointAxisType }>();\n\n    datapointsWithValues.forEach(dp => {\n      const position = this.getYAxisPosition(dp, datapointsWithValues);\n      YAxisPositions.set(dp, { position });\n    });\n\n    const dpLeft = datapointsWithValues.filter(dp => YAxisPositions.get(dp).position === 'left');\n    const dpRight = datapointsWithValues.filter(dp => YAxisPositions.get(dp).position === 'right');\n\n    const YAxisPlacement = new Map<DpWithValues, { position: DatapointAxisType; offset: number }>();\n    YAxisPositions.forEach(({ position }, key) => {\n      const offset = (position === 'left' ? dpLeft : dpRight).indexOf(key) * this.Y_AXIS_OFFSET;\n      YAxisPlacement.set(key, { position: position, offset });\n    });\n\n    return YAxisPlacement;\n  }\n\n  private getYAxisPosition(\n    datapoint: DatapointAxisType,\n    datapointsWithValues: DpWithValues[]\n  ): DatapointAxisType {\n    if (datapoint.yAxisType) {\n      return datapoint.yAxisType;\n    }\n    const currentIndex = datapointsWithValues.indexOf(datapoint);\n    const otherIndexLeft = datapointsWithValues.findIndex(\n      dp => dp !== datapoint && (!dp.yAxisType || dp.yAxisType === 'left')\n    );\n    if (otherIndexLeft > -1 && otherIndexLeft < currentIndex) {\n      return 'right';\n    } else {\n      return 'left';\n    }\n  }\n}\n"]}

package/esm2022/interval-picker/interval-picker.component.mjs

@@ -55,14 +55,14 @@ export class IntervalPickerComponent {
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: IntervalPickerComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'c8y-interval-picker', providers: [
+            args: [{ selector: 'c8y-interval-picker', standalone: true, imports: [CommonModule, FormsModule, A11yModule, ReactiveFormsModule, BsDropdownModule], providers: [
                         {
                             provide: NG_VALUE_ACCESSOR,
                             useExisting: forwardRef(() => IntervalPickerComponent),
                             multi: true
                         }
-                    ], standalone: true, imports: [CommonModule, FormsModule, A11yModule, ReactiveFormsModule, BsDropdownModule], template: "<li\n  *ngFor=\"let interval of translatedIntervals\"\n  [ngClass]=\"{\n    active: interval.id === value\n  }\"\n>\n  <button\n    type=\"button\"\n    (click)=\"onChange(interval.id)\"\n  >\n    <span\n      [ngClass]=\"{\n        'text-primary': interval.id === value\n      }\"\n    >\n      <span\n        c8yIcon=\"check\"\n        [ngStyle]=\"{ visibility: interval.id === value ? 'visible' : 'hidden' }\"\n      ></span>\n      {{ interval.title }}\n    </span>\n  </button>\n</li>\n" }]
+                    ], template: "<li\n  *ngFor=\"let interval of translatedIntervals\"\n  [ngClass]=\"{\n    active: interval.id === value\n  }\"\n>\n  <button\n    type=\"button\"\n    (click)=\"onChange(interval.id)\"\n  >\n    <span\n      [ngClass]=\"{\n        'text-primary': interval.id === value\n      }\"\n    >\n      <span\n        c8yIcon=\"check\"\n        [ngStyle]=\"{ visibility: interval.id === value ? 'visible' : 'hidden' }\"\n      ></span>\n      {{ interval.title }}\n    </span>\n  </button>\n</li>\n" }]
         }], ctorParameters: () => [{ type: i1.TranslateService }], propDecorators: { INTERVALS: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJ2YWwtcGlja2VyLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2ludGVydmFsLXBpY2tlci9pbnRlcnZhbC1waWNrZXIuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vaW50ZXJ2YWwtcGlja2VyL2ludGVydmFsLXBpY2tlci5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBRSxLQUFLLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDN0QsT0FBTyxFQUVMLGlCQUFpQixFQUNqQixXQUFXLEVBQ1gsbUJBQW1CLEVBQ3BCLE1BQU0sZ0JBQWdCLENBQUM7QUFDeEIsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQzFELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUMvQyxPQUFPLEVBQWlDLFNBQVMsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ25GLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHFCQUFxQixDQUFDOzs7O0FBZXZELE1BQU0sT0FBTyx1QkFBdUI7SUFTbEMsWUFBb0IsU0FBMkI7UUFBM0IsY0FBUyxHQUFULFNBQVMsQ0FBa0I7UUFSdEMsY0FBUyxHQUF1QyxTQUFTLENBQUM7UUFHbkUsWUFBTyxHQUFHLEtBQUssQ0FBQztRQUNoQixhQUFRLEdBQUcsS0FBSyxDQUFDO1FBRWpCLHdCQUFtQixHQUFvQyxFQUFFLENBQUM7UUFXMUQsZ0VBQWdFO1FBQ2hFLGFBQVEsR0FBRyxDQUFDLENBQUMsRUFBRSxHQUFFLENBQUMsQ0FBQztRQUNuQixnRUFBZ0U7UUFDaEUsY0FBUyxHQUFHLEdBQUcsRUFBRSxHQUFFLENBQUMsQ0FBQztJQVo2QixDQUFDO0lBRW5ELFFBQVE7UUFDTixJQUFJLENBQUMsbUJBQW1CLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxDQUFDO1lBQ3pELEdBQUcsUUFBUTtZQUNYLEtBQUssRUFBRSxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDO1NBQzlDLENBQUMsQ0FBQyxDQUFDO0lBQ04sQ0FBQztJQU9ELFVBQVUsQ0FBQyxLQUFxQjtRQUM5QixJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztJQUNyQixDQUFDO0lBRUQsZ0JBQWdCLENBQUMsRUFBTztRQUN0QixJQUFJLENBQUMsUUFBUSxHQUFHLEVBQUUsQ0FBQztJQUNyQixDQUFDO0lBRUQsaUJBQWlCLENBQUMsU0FBYztRQUM5QixJQUFJLENBQUMsU0FBUyxHQUFHLFNBQVMsQ0FBQztJQUM3QixDQUFDO0lBRUQsYUFBYTtRQUNYLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDbEIsSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQ2pCLElBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFDO1FBQ3RCLENBQUM7SUFDSCxDQUFDO0lBRUQsZ0JBQWdCLENBQUMsUUFBaUI7UUFDaEMsSUFBSSxDQUFDLFFBQVEsR0FBRyxRQUFRLENBQUM7SUFDM0IsQ0FBQzs4R0E1Q1UsdUJBQXVCO2tHQUF2Qix1QkFBdUIsc0dBUnZCO1lBQ1Q7Z0JBQ0UsT0FBTyxFQUFFLGlCQUFpQjtnQkFDMUIsV0FBVyxFQUFFLFVBQVUsQ0FBQyxHQUFHLEVBQUUsQ0FBQyx1QkFBdUIsQ0FBQztnQkFDdEQsS0FBSyxFQUFFLElBQUk7YUFDWjtTQUNGLDBCQ3hCSCw2ZUF1QkEsMkNETlksWUFBWSw4VUFBRSxXQUFXLDhCQUFFLFVBQVUsOEJBQUUsbUJBQW1CLDhCQUFFLGdCQUFnQjs7MkZBUzNFLHVCQUF1QjtrQkFibkMsU0FBUzsrQkFDRSxxQkFBcUIsY0FFbkIsSUFBSSxXQUNQLENBQUMsWUFBWSxFQUFFLFdBQVcsRUFBRSxVQUFVLEVBQUUsbUJBQW1CLEVBQUUsZ0JBQWdCLENBQUMsYUFDNUU7d0JBQ1Q7NEJBQ0UsT0FBTyxFQUFFLGlCQUFpQjs0QkFDMUIsV0FBVyxFQUFFLFVBQVUsQ0FBQyxHQUFHLEVBQUUsd0JBQXdCLENBQUM7NEJBQ3RELEtBQUssRUFBRSxJQUFJO3lCQUNaO3FCQUNGO3FGQUdRLFNBQVM7c0JBQWpCLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIGZvcndhcmRSZWYsIElucHV0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge1xuICBDb250cm9sVmFsdWVBY2Nlc3NvcixcbiAgTkdfVkFMVUVfQUNDRVNTT1IsXG4gIEZvcm1zTW9kdWxlLFxuICBSZWFjdGl2ZUZvcm1zTW9kdWxlXG59IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBCc0Ryb3Bkb3duTW9kdWxlIH0gZnJvbSAnbmd4LWJvb3RzdHJhcC9kcm9wZG93bic7XG5pbXBvcnQgeyBBMTF5TW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY2RrL2ExMXknO1xuaW1wb3J0IHsgQWxhcm1GaWx0ZXJJbnRlcnZhbCwgSW50ZXJ2YWwsIElOVEVSVkFMUyB9IGZyb20gJy4vaW50ZXJ2YWwtcGlja2VyLm1vZGVsJztcbmltcG9ydCB7IFRyYW5zbGF0ZVNlcnZpY2UgfSBmcm9tICdAbmd4LXRyYW5zbGF0ZS9jb3JlJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnYzh5LWludGVydmFsLXBpY2tlcicsXG4gIHRlbXBsYXRlVXJsOiAnLi9pbnRlcnZhbC1waWNrZXIuY29tcG9uZW50Lmh0bWwnLFxuICBzdGFuZGFsb25lOiB0cnVlLFxuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlLCBGb3Jtc01vZHVsZSwgQTExeU1vZHVsZSwgUmVhY3RpdmVGb3Jtc01vZHVsZSwgQnNEcm9wZG93bk1vZHVsZV0sXG4gIHByb3ZpZGVyczogW1xuICAgIHtcbiAgICAgIHByb3ZpZGU6IE5HX1ZBTFVFX0FDQ0VTU09SLFxuICAgICAgdXNlRXhpc3Rpbmc6IGZvcndhcmRSZWYoKCkgPT4gSW50ZXJ2YWxQaWNrZXJDb21wb25lbnQpLFxuICAgICAgbXVsdGk6IHRydWVcbiAgICB9XG4gIF1cbn0pXG5leHBvcnQgY2xhc3MgSW50ZXJ2YWxQaWNrZXJDb21wb25lbnQgaW1wbGVtZW50cyBDb250cm9sVmFsdWVBY2Nlc3NvciB7XG4gIEBJbnB1dCgpIElOVEVSVkFMUzogSW50ZXJ2YWxbXSB8IEFsYXJtRmlsdGVySW50ZXJ2YWxbXSA9IElOVEVSVkFMUztcblxuICB2YWx1ZTogSW50ZXJ2YWxbJ2lkJ107XG4gIHRvdWNoZWQgPSBmYWxzZTtcbiAgZGlzYWJsZWQgPSBmYWxzZTtcblxuICB0cmFuc2xhdGVkSW50ZXJ2YWxzOiB7IGlkOiBzdHJpbmc7IHRpdGxlOiBzdHJpbmcgfVtdID0gW107XG5cbiAgY29uc3RydWN0b3IocHJpdmF0ZSB0cmFuc2xhdGU6IFRyYW5zbGF0ZVNlcnZpY2UpIHt9XG5cbiAgbmdPbkluaXQoKSB7XG4gICAgdGhpcy50cmFuc2xhdGVkSW50ZXJ2YWxzID0gdGhpcy5JTlRFUlZBTFMubWFwKGludGVydmFsID0+ICh7XG4gICAgICAuLi5pbnRlcnZhbCxcbiAgICAgIHRpdGxlOiB0aGlzLnRyYW5zbGF0ZS5pbnN0YW50KGludGVydmFsLnRpdGxlKVxuICAgIH0pKTtcbiAgfVxuXG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tZW1wdHktZnVuY3Rpb25cbiAgb25DaGFuZ2UgPSBfID0+IHt9O1xuICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLWVtcHR5LWZ1bmN0aW9uXG4gIG9uVG91Y2hlZCA9ICgpID0+IHt9O1xuXG4gIHdyaXRlVmFsdWUodmFsdWU6IEludGVydmFsWydpZCddKSB7XG4gICAgdGhpcy52YWx1ZSA9IHZhbHVlO1xuICB9XG5cbiAgcmVnaXN0ZXJPbkNoYW5nZShmbjogYW55KTogdm9pZCB7XG4gICAgdGhpcy5vbkNoYW5nZSA9IGZuO1xuICB9XG5cbiAgcmVnaXN0ZXJPblRvdWNoZWQob25Ub3VjaGVkOiBhbnkpIHtcbiAgICB0aGlzLm9uVG91Y2hlZCA9IG9uVG91Y2hlZDtcbiAgfVxuXG4gIG1hcmtBc1RvdWNoZWQoKSB7XG4gICAgaWYgKCF0aGlzLnRvdWNoZWQpIHtcbiAgICAgIHRoaXMub25Ub3VjaGVkKCk7XG4gICAgICB0aGlzLnRvdWNoZWQgPSB0cnVlO1xuICAgIH1cbiAgfVxuXG4gIHNldERpc2FibGVkU3RhdGUoZGlzYWJsZWQ6IGJvb2xlYW4pIHtcbiAgICB0aGlzLmRpc2FibGVkID0gZGlzYWJsZWQ7XG4gIH1cbn1cbiIsIjxsaVxuICAqbmdGb3I9XCJsZXQgaW50ZXJ2YWwgb2YgdHJhbnNsYXRlZEludGVydmFsc1wiXG4gIFtuZ0NsYXNzXT1cIntcbiAgICBhY3RpdmU6IGludGVydmFsLmlkID09PSB2YWx1ZVxuICB9XCJcbj5cbiAgPGJ1dHRvblxuICAgIHR5cGU9XCJidXR0b25cIlxuICAgIChjbGljayk9XCJvbkNoYW5nZShpbnRlcnZhbC5pZClcIlxuICA+XG4gICAgPHNwYW5cbiAgICAgIFtuZ0NsYXNzXT1cIntcbiAgICAgICAgJ3RleHQtcHJpbWFyeSc6IGludGVydmFsLmlkID09PSB2YWx1ZVxuICAgICAgfVwiXG4gICAgPlxuICAgICAgPHNwYW5cbiAgICAgICAgYzh5SWNvbj1cImNoZWNrXCJcbiAgICAgICAgW25nU3R5bGVdPVwieyB2aXNpYmlsaXR5OiBpbnRlcnZhbC5pZCA9PT0gdmFsdWUgPyAndmlzaWJsZScgOiAnaGlkZGVuJyB9XCJcbiAgICAgID48L3NwYW4+XG4gICAgICB7eyBpbnRlcnZhbC50aXRsZSB9fVxuICAgIDwvc3Bhbj5cbiAgPC9idXR0b24+XG48L2xpPlxuIl19

package/esm2022/interval-picker/interval-picker.model.mjs

@@ -48,4 +48,4 @@ export const INTERVAL_VALUES = Object.keys(INTERVAL_TITLES).reduce((acc, key) =>
     ...acc,
     [key]: key
 }), {});
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/report-dashboard/index.mjs

@@ -1,4 +1,5 @@
 export * from './report-dashboard.module';
 export * from './report-dashboard-navigation.factory';
 export * from './report-dashboard.guard';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9yZXBvcnQtZGFzaGJvYXJkL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9yZXBvcnQtZGFzaGJvYXJkLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL3JlcG9ydC1kYXNoYm9hcmQtbmF2aWdhdGlvbi5mYWN0b3J5JztcbmV4cG9ydCAqIGZyb20gJy4vcmVwb3J0LWRhc2hib2FyZC5ndWFyZCc7XG4iXX0=
+export * from './report-dashboard.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9yZXBvcnQtZGFzaGJvYXJkL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsNEJBQTRCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3JlcG9ydC1kYXNoYm9hcmQubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vcmVwb3J0LWRhc2hib2FyZC1uYXZpZ2F0aW9uLmZhY3RvcnknO1xuZXhwb3J0ICogZnJvbSAnLi9yZXBvcnQtZGFzaGJvYXJkLmd1YXJkJztcbmV4cG9ydCAqIGZyb20gJy4vcmVwb3J0LWRhc2hib2FyZC5zZXJ2aWNlJztcbiJdfQ==

package/esm2022/time-context/c8y-ngx-components-time-context.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYzh5LW5neC1jb21wb25lbnRzLXRpbWUtY29udGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RpbWUtY29udGV4dC9jOHktbmd4LWNvbXBvbmVudHMtdGltZS1jb250ZXh0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2022/time-context/index.mjs

@@ -0,0 +1,2 @@
+export * from './time-context.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90aW1lLWNvbnRleHQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywwQkFBMEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdGltZS1jb250ZXh0LmNvbXBvbmVudCc7XG4iXX0=

package/esm2022/time-context/time-context.component.mjs

@@ -0,0 +1,217 @@
+import { Component, DestroyRef, inject, Input, model, ViewChild } from '@angular/core';
+import { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
+import { FormBuilder } from '@angular/forms';
+import { CoreModule, DateTimePickerModule, RealtimeControlComponent, WidgetTimeContextDateRangeService } from '@c8y/ngx-components';
+import { INTERVAL_TITLES } from '@c8y/ngx-components/interval-picker';
+import { AggregationPickerComponent } from '@c8y/ngx-components';
+import { IntervalPickerComponent } from '@c8y/ngx-components/interval-picker';
+import { BsDatepickerModule } from 'ngx-bootstrap/datepicker';
+import { BsDropdownDirective, BsDropdownModule } from 'ngx-bootstrap/dropdown';
+import { TooltipModule } from 'ngx-bootstrap/tooltip';
+import { interval } from 'rxjs';
+import { DatapointExplorerService } from './time-context.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@c8y/ngx-components";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "ngx-bootstrap/dropdown";
+import * as i5 from "ngx-bootstrap/tooltip";
+export class TimeContextComponent {
+    #destroyRef;
+    constructor(widgetTimeContextDateRangeService) {
+        this.widgetTimeContextDateRangeService = widgetTimeContextDateRangeService;
+        this.datapointExplorerService = inject(DatapointExplorerService);
+        this.formBuilder = inject(FormBuilder);
+        this.#destroyRef = inject(DestroyRef);
+        this.DATE_FORMAT = 'short';
+        this.INTERVAL_TITLES = INTERVAL_TITLES;
+        this.REALTIME_INTERVAL = 1000;
+        this.form = this.createForm(this.datapointExplorerService.getDefaultContext());
+        this.valuesSignal = toSignal(this.form.controls.currentDateContextFromDate.valueChanges, {
+            initialValue: this.form.controls.currentDateContextFromDate.value
+        });
+        this.context = model(this.form.value);
+        const context = this.datapointExplorerService.getDefaultContext();
+        const { disabledAggregations } = this.datapointExplorerService.calculateAggregation(context.date, context.aggregation);
+        this.disabledAggregations = disabledAggregations;
+        this.subscribeToIntervalChange();
+        this.subscribeToRealtimeChange();
+        this.subscribeToAggregationChange();
+    }
+    ngOnChanges(changes) {
+        if (changes.changedDateContext && changes.changedDateContext.currentValue) {
+            this.update({
+                date: [this.changedDateContext.dateFrom, this.changedDateContext.dateTo],
+                interval: this.changedDateContext.interval,
+                realtime: this.changedDateContext.realtime || false,
+                aggregation: this.changedDateContext.aggregation
+            });
+            if (this.changedDateContext.realtime) {
+                this.form.controls.aggregation.disable();
+            }
+        }
+    }
+    applyDatetimeContext() {
+        this.update({
+            date: [
+                new Date(this.form.controls.temporaryUserSelectedFromDate.value),
+                new Date(this.form.controls.temporaryUserSelectedToDate.value)
+            ],
+            interval: 'custom',
+            realtime: this.form.value.realtime,
+            aggregation: this.form.value.aggregation
+        });
+    }
+    subscribeToIntervalChange() {
+        this.form.controls.currentDateContextInterval.valueChanges
+            .pipe(takeUntilDestroyed(this.#destroyRef))
+            .subscribe(interval => {
+            let date;
+            this.widgetTimeContextDateRangeService.updateInitialTimeRange(null);
+            if (interval === 'custom') {
+                date = [
+                    new Date(this.form.controls.currentDateContextFromDate.value),
+                    new Date(this.form.controls.currentDateContextToDate.value)
+                ];
+            }
+            else {
+                date = this.datapointExplorerService.getDateTimeContextByInterval(interval);
+                this.dropdown.isOpen = false;
+            }
+            this.update({
+                date,
+                interval,
+                realtime: this.form.value.realtime,
+                aggregation: this.form.value.aggregation
+            });
+        });
+    }
+    subscribeToRealtimeChange() {
+        this.form.controls.realtime.valueChanges
+            .pipe(takeUntilDestroyed(this.#destroyRef))
+            .subscribe(realtime => {
+            this.onRealtimeValueChange(realtime);
+            if (realtime) {
+                this.startRealtime();
+            }
+            else {
+                this.stopRealtime();
+            }
+        });
+    }
+    subscribeToAggregationChange() {
+        this.form.controls.aggregation.valueChanges
+            .pipe(takeUntilDestroyed(this.#destroyRef))
+            .subscribe(aggregation => {
+            this.update({
+                date: [
+                    new Date(this.form.value.currentDateContextFromDate),
+                    new Date(this.form.value.currentDateContextToDate)
+                ],
+                interval: this.form.value.currentDateContextInterval,
+                realtime: this.form.value.realtime,
+                aggregation
+            });
+        });
+    }
+    onRealtimeValueChange(realtime) {
+        let dateTimeContext;
+        if (this.form.value.currentDateContextInterval !== 'custom') {
+            dateTimeContext = this.datapointExplorerService.getDateTimeContextByInterval(this.form.value.currentDateContextInterval);
+        }
+        else {
+            const currentTimeSpanInMs = new Date(this.form.value.currentDateContextToDate).valueOf() -
+                new Date(this.form.value.currentDateContextFromDate).valueOf();
+            const dateTo = new Date();
+            const dateFrom = new Date(dateTo.valueOf() - currentTimeSpanInMs);
+            dateTimeContext = [dateFrom, dateTo];
+        }
+        this.update({
+            date: dateTimeContext,
+            interval: this.form.value.currentDateContextInterval,
+            realtime,
+            aggregation: null
+        });
+    }
+    startRealtime() {
+        this.form.controls.temporaryUserSelectedFromDate.disable();
+        this.form.controls.temporaryUserSelectedToDate.disable();
+        this.form.controls.aggregation.disable();
+        this.realtimeSubscription = interval(this.REALTIME_INTERVAL)
+            .pipe(takeUntilDestroyed(this.#destroyRef))
+            .subscribe(() => {
+            if (!this.form.value.realtime) {
+                this.realtimeSubscription.unsubscribe();
+                return;
+            }
+            const newDateFrom = new Date(new Date(this.form.value.currentDateContextFromDate).valueOf() + this.REALTIME_INTERVAL);
+            const newDateTo = new Date(new Date(this.form.value.currentDateContextToDate).valueOf() + this.REALTIME_INTERVAL);
+            this.updateFormValues({
+                date: [newDateFrom, newDateTo],
+                interval: this.form.value.currentDateContextInterval,
+                realtime: true,
+                aggregation: null
+            });
+        });
+    }
+    stopRealtime() {
+        this.realtimeSubscription?.unsubscribe();
+        this.form?.controls.temporaryUserSelectedFromDate.enable();
+        this.form?.controls.temporaryUserSelectedToDate.enable();
+        this.form?.controls.aggregation.enable();
+    }
+    update({ date, interval, realtime, aggregation }) {
+        const { selectedAggregation, disabledAggregations } = this.datapointExplorerService.calculateAggregation(date, aggregation);
+        this.disabledAggregations = disabledAggregations;
+        this.updateFormValues({ date, interval, realtime, aggregation: selectedAggregation });
+    }
+    createForm(context) {
+        return this.formBuilder.group({
+            temporaryUserSelectedFromDate: context.date[0].toISOString(),
+            temporaryUserSelectedToDate: context.date[1].toISOString(),
+            currentDateContextFromDate: context.date[0].toISOString(),
+            currentDateContextToDate: context.date[1].toISOString(),
+            currentDateContextInterval: context.interval || 'custom',
+            realtime: context.realtime,
+            aggregation: context.aggregation
+        });
+    }
+    updateFormValues({ date, interval, realtime, aggregation }) {
+        const newFormValues = {
+            temporaryUserSelectedFromDate: date[0].toISOString(),
+            temporaryUserSelectedToDate: date[1].toISOString(),
+            currentDateContextFromDate: date[0].toISOString(),
+            currentDateContextToDate: date[1].toISOString(),
+            realtime,
+            currentDateContextInterval: interval || 'custom',
+            aggregation: aggregation || null
+        };
+        this.context.set(newFormValues);
+        this.form.patchValue(newFormValues, {
+            emitEvent: false
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: TimeContextComponent, deps: [{ token: i1.WidgetTimeContextDateRangeService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.9", type: TimeContextComponent, isStandalone: true, selector: "c8y-time-context", inputs: { changedDateContext: { classPropertyName: "changedDateContext", publicName: "changedDateContext", isSignal: false, isRequired: false, transformFunction: null }, controlsAvailable: { classPropertyName: "controlsAvailable", publicName: "controlsAvailable", isSignal: false, isRequired: false, transformFunction: null }, context: { classPropertyName: "context", publicName: "context", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { context: "contextChange" }, viewQueries: [{ propertyName: "dropdown", first: true, predicate: BsDropdownDirective, descendants: true }], usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"controlsAvailable; else actionBarTemplate\">\n  <ng-container\n    [ngTemplateOutlet]=\"dateTimePicker\"\n    [ngTemplateOutletContext]=\"{\n      date: [form.value.currentDateContextFromDate, form.value.currentDateContextToDate]\n    }\"\n  ></ng-container>\n</ng-container>\n\n<ng-template #actionBarTemplate>\n  <c8y-action-bar-item\n    [groupId]=\"'timeContext'\"\n    [inGroupPriority]=\"1\"\n    [placement]=\"'left'\"\n  >\n    <ng-container\n      [ngTemplateOutlet]=\"dateTimePicker\"\n      [ngTemplateOutletContext]=\"{\n        date: [form.value.currentDateContextFromDate, form.value.currentDateContextToDate]\n      }\"\n    ></ng-container>\n  </c8y-action-bar-item>\n</ng-template>\n\n<ng-template\n  #dateTimePicker\n  let-date=\"date\"\n>\n  <form\n    class=\"d-flex gap-8 p-l-xs-16 p-r-xs-16 m-t-xs-8 m-b-xs-8\"\n    [formGroup]=\"form\"\n  >\n    <ng-container>\n      <div\n        class=\"dropdown flex-grow\"\n        #dropdown=\"bs-dropdown\"\n        dropdown\n        [insideClick]=\"true\"\n        *ngIf=\"date\"\n      >\n        <button\n          class=\"dropdown-toggle form-control l-h-tight d-flex a-i-center\"\n          attr.aria-label=\"{{ date[0] | c8yDate: DATE_FORMAT }} \u2014 {{\n            date[1] | c8yDate: DATE_FORMAT\n          }}\"\n          tooltip=\"{{ date[0] | c8yDate: DATE_FORMAT }} \u2014 {{ date[1] | c8yDate: DATE_FORMAT }}\"\n          placement=\"top\"\n          container=\"body\"\n          data-cy=\"widget-time-context--date-picker-dropdown-button\"\n          [adaptivePosition]=\"false\"\n          [delay]=\"500\"\n          dropdownToggle\n        >\n          <i\n            class=\"m-r-4\"\n            c8yIcon=\"schedule1\"\n          ></i>\n          <div class=\"d-col text-left fit-w\">\n            <span\n              class=\"text-12\"\n              data-cy=\"widget-time-context--selected-interval\"\n            >\n              {{ INTERVAL_TITLES[form.controls.currentDateContextInterval.value] | translate }}\n            </span>\n            <span\n              class=\"text-10 text-muted text-truncate\"\n              data-cy=\"widget-time-context--selected-time-range\"\n            >\n              {{ date[0] | c8yDate: DATE_FORMAT }} \u2014 {{ date[1] | c8yDate: DATE_FORMAT }}\n            </span>\n          </div>\n          <span class=\"caret m-r-16 m-l-4\"></span>\n        </button>\n\n        <ul\n          class=\"dropdown-menu dropdown-menu--date-range\"\n          *dropdownMenu\n        >\n          <c8y-interval-picker\n            class=\"d-contents\"\n            formControlName=\"currentDateContextInterval\"\n          ></c8y-interval-picker>\n\n          <ng-container *ngIf=\"form.controls.currentDateContextInterval.value === 'custom'\">\n            <div class=\"p-l-16 p-r-16\">\n              <c8y-form-group\n                [ngClass]=\"form.controls.temporaryUserSelectedFromDate.errors ? 'has-error' : ''\"\n              >\n                <label\n                  [title]=\"'From`date`' | translate\"\n                  for=\"temporaryUserSelectedFromDate\"\n                  translate\n                >\n                  From`date`\n                </label>\n                <c8y-date-time-picker\n                  id=\"temporaryUserSelectedFromDate\"\n                  [maxDate]=\"form.value.temporaryUserSelectedToDate\"\n                  [placeholder]=\"'From`date`' | translate\"\n                  [formControl]=\"form.controls.temporaryUserSelectedFromDate\"\n                  [ngClass]=\"form.controls.temporaryUserSelectedFromDate.errors ? 'has-error' : ''\"\n                ></c8y-date-time-picker>\n                <c8y-messages [show]=\"form.controls.temporaryUserSelectedFromDate.errors\">\n                  <c8y-message\n                    name=\"dateAfterRangeMax\"\n                    [text]=\"'This date is after the latest allowed date.' | translate\"\n                  ></c8y-message>\n                  <c8y-message\n                    name=\"invalidDateTime\"\n                    [text]=\"'This date is invalid.' | translate\"\n                  ></c8y-message>\n                </c8y-messages>\n              </c8y-form-group>\n\n              <c8y-form-group\n                [ngClass]=\"form.controls.temporaryUserSelectedToDate.errors ? 'has-error' : ''\"\n              >\n                <label\n                  [title]=\"'To`date`' | translate\"\n                  for=\"temporaryUserSelectedToDate\"\n                  translate\n                >\n                  To`date`\n                </label>\n                <c8y-date-time-picker\n                  id=\"temporaryUserSelectedToDate\"\n                  [minDate]=\"form.value.temporaryUserSelectedFromDate\"\n                  [placeholder]=\"'To`date`' | translate\"\n                  [formControl]=\"form.controls.temporaryUserSelectedToDate\"\n                  [ngClass]=\"form.controls.temporaryUserSelectedToDate.errors ? 'has-error' : ''\"\n                ></c8y-date-time-picker>\n                <c8y-messages [show]=\"form.controls.temporaryUserSelectedToDate.errors\">\n                  <c8y-message\n                    name=\"dateBeforeRangeMin\"\n                    [text]=\"'This date is before the earliest allowed date.' | translate\"\n                  ></c8y-message>\n                  <c8y-message\n                    name=\"invalidDateTime\"\n                    [text]=\"'This date is invalid.' | translate\"\n                  ></c8y-message>\n                </c8y-messages>\n              </c8y-form-group>\n            </div>\n\n            <div class=\"p-16 d-flex gap-8 separator-top\">\n              <button\n                class=\"btn btn-default btn-sm flex-grow\"\n                title=\"{{ 'Reset' | translate }}\"\n                type=\"button\"\n                (click)=\"dropdown.isOpen = false\"\n                [disabled]=\"form.value.realtime\"\n                translate\n              >\n                Reset\n              </button>\n\n              <button\n                class=\"btn btn-primary btn-sm flex-grow\"\n                title=\"{{ 'Apply' | translate }}\"\n                type=\"button\"\n                (click)=\"applyDatetimeContext(); dropdown.isOpen = false\"\n                [disabled]=\"\n                  (form.pristine && form.untouched) || form.invalid || form.value.realtime\n                \"\n                translate\n              >\n                Apply\n              </button>\n            </div>\n          </ng-container>\n        </ul>\n      </div>\n    </ng-container>\n\n    <div class=\"input-group w-auto\">\n      <c8y-realtime-control\n        class=\"form-control p-0 flex-no-grow w-auto\"\n        formControlName=\"realtime\"\n      ></c8y-realtime-control>\n\n      <c8y-aggregation-picker\n        *ngIf=\"controlsAvailable ? controlsAvailable.aggregation : true\"\n        formControlName=\"aggregation\"\n        [disabledAggregations]=\"disabledAggregations\"\n      ></c8y-aggregation-picker>\n    </div>\n  </form>\n</ng-template>\n", dependencies: [{ kind: "ngmodule", type: CoreModule }, { kind: "component", type: i1.ActionBarItemComponent, selector: "c8y-action-bar-item", inputs: ["placement", "priority", "itemClass", "injector", "groupId", "inGroupPriority"] }, { kind: "directive", type: i1.IconDirective, selector: "[c8yIcon]", inputs: ["c8yIcon"] }, { kind: "pipe", type: i1.C8yTranslatePipe, name: "translate" }, { kind: "directive", type: i1.C8yTranslateDirective, selector: "[translate],[ngx-translate]" }, { kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "pipe", type: i1.DatePipe, name: "c8yDate" }, { kind: "directive", type: i3.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "component", type: i1.FormGroupComponent, selector: "c8y-form-group", inputs: ["hasError", "hasWarning", "hasSuccess", "novalidation", "status"] }, { kind: "directive", type: i1.MessageDirective, selector: "c8y-message", inputs: ["name", "text"] }, { kind: "component", type: i1.MessagesComponent, selector: "c8y-messages", inputs: ["show", "defaults", "helpMessage"] }, { kind: "directive", type: i3.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "directive", type: i3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i3.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "component", type: i1.DateTimePickerComponent, selector: "c8y-date-time-picker", inputs: ["minDate", "maxDate", "placeholder", "dateInputFormat", "adaptivePosition", "size", "dateType", "config"], outputs: ["onDateSelected"] }, { kind: "ngmodule", type: BsDatepickerModule }, { kind: "ngmodule", type: DateTimePickerModule }, { kind: "ngmodule", type: BsDropdownModule }, { kind: "directive", type: i4.BsDropdownMenuDirective, selector: "[bsDropdownMenu],[dropdownMenu]", exportAs: ["bs-dropdown-menu"] }, { kind: "directive", type: i4.BsDropdownToggleDirective, selector: "[bsDropdownToggle],[dropdownToggle]", exportAs: ["bs-dropdown-toggle"] }, { kind: "directive", type: i4.BsDropdownDirective, selector: "[bsDropdown], [dropdown]", inputs: ["placement", "triggers", "container", "dropup", "autoClose", "isAnimated", "insideClick", "isDisabled", "isOpen"], outputs: ["isOpenChange", "onShown", "onHidden"], exportAs: ["bs-dropdown"] }, { kind: "component", type: AggregationPickerComponent, selector: "c8y-aggregation-picker", inputs: ["disabledAggregations"] }, { kind: "ngmodule", type: TooltipModule }, { kind: "directive", type: i5.TooltipDirective, selector: "[tooltip], [tooltipHtml]", inputs: ["adaptivePosition", "tooltip", "placement", "triggers", "container", "containerClass", "boundariesElement", "isOpen", "isDisabled", "delay", "tooltipHtml", "tooltipPlacement", "tooltipIsOpen", "tooltipEnable", "tooltipAppendToBody", "tooltipAnimation", "tooltipClass", "tooltipContext", "tooltipPopupDelay", "tooltipFadeDuration", "tooltipTrigger"], outputs: ["tooltipChange", "onShown", "onHidden", "tooltipStateChanged"], exportAs: ["bs-tooltip"] }, { kind: "component", type: IntervalPickerComponent, selector: "c8y-interval-picker", inputs: ["INTERVALS"] }, { kind: "component", type: RealtimeControlComponent, selector: "c8y-realtime-control" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: TimeContextComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'c8y-time-context', standalone: true, imports: [
+                        CoreModule,
+                        BsDatepickerModule,
+                        DateTimePickerModule,
+                        BsDropdownModule,
+                        AggregationPickerComponent,
+                        TooltipModule,
+                        IntervalPickerComponent,
+                        RealtimeControlComponent
+                    ], template: "<ng-container *ngIf=\"controlsAvailable; else actionBarTemplate\">\n  <ng-container\n    [ngTemplateOutlet]=\"dateTimePicker\"\n    [ngTemplateOutletContext]=\"{\n      date: [form.value.currentDateContextFromDate, form.value.currentDateContextToDate]\n    }\"\n  ></ng-container>\n</ng-container>\n\n<ng-template #actionBarTemplate>\n  <c8y-action-bar-item\n    [groupId]=\"'timeContext'\"\n    [inGroupPriority]=\"1\"\n    [placement]=\"'left'\"\n  >\n    <ng-container\n      [ngTemplateOutlet]=\"dateTimePicker\"\n      [ngTemplateOutletContext]=\"{\n        date: [form.value.currentDateContextFromDate, form.value.currentDateContextToDate]\n      }\"\n    ></ng-container>\n  </c8y-action-bar-item>\n</ng-template>\n\n<ng-template\n  #dateTimePicker\n  let-date=\"date\"\n>\n  <form\n    class=\"d-flex gap-8 p-l-xs-16 p-r-xs-16 m-t-xs-8 m-b-xs-8\"\n    [formGroup]=\"form\"\n  >\n    <ng-container>\n      <div\n        class=\"dropdown flex-grow\"\n        #dropdown=\"bs-dropdown\"\n        dropdown\n        [insideClick]=\"true\"\n        *ngIf=\"date\"\n      >\n        <button\n          class=\"dropdown-toggle form-control l-h-tight d-flex a-i-center\"\n          attr.aria-label=\"{{ date[0] | c8yDate: DATE_FORMAT }} \u2014 {{\n            date[1] | c8yDate: DATE_FORMAT\n          }}\"\n          tooltip=\"{{ date[0] | c8yDate: DATE_FORMAT }} \u2014 {{ date[1] | c8yDate: DATE_FORMAT }}\"\n          placement=\"top\"\n          container=\"body\"\n          data-cy=\"widget-time-context--date-picker-dropdown-button\"\n          [adaptivePosition]=\"false\"\n          [delay]=\"500\"\n          dropdownToggle\n        >\n          <i\n            class=\"m-r-4\"\n            c8yIcon=\"schedule1\"\n          ></i>\n          <div class=\"d-col text-left fit-w\">\n            <span\n              class=\"text-12\"\n              data-cy=\"widget-time-context--selected-interval\"\n            >\n              {{ INTERVAL_TITLES[form.controls.currentDateContextInterval.value] | translate }}\n            </span>\n            <span\n              class=\"text-10 text-muted text-truncate\"\n              data-cy=\"widget-time-context--selected-time-range\"\n            >\n              {{ date[0] | c8yDate: DATE_FORMAT }} \u2014 {{ date[1] | c8yDate: DATE_FORMAT }}\n            </span>\n          </div>\n          <span class=\"caret m-r-16 m-l-4\"></span>\n        </button>\n\n        <ul\n          class=\"dropdown-menu dropdown-menu--date-range\"\n          *dropdownMenu\n        >\n          <c8y-interval-picker\n            class=\"d-contents\"\n            formControlName=\"currentDateContextInterval\"\n          ></c8y-interval-picker>\n\n          <ng-container *ngIf=\"form.controls.currentDateContextInterval.value === 'custom'\">\n            <div class=\"p-l-16 p-r-16\">\n              <c8y-form-group\n                [ngClass]=\"form.controls.temporaryUserSelectedFromDate.errors ? 'has-error' : ''\"\n              >\n                <label\n                  [title]=\"'From`date`' | translate\"\n                  for=\"temporaryUserSelectedFromDate\"\n                  translate\n                >\n                  From`date`\n                </label>\n                <c8y-date-time-picker\n                  id=\"temporaryUserSelectedFromDate\"\n                  [maxDate]=\"form.value.temporaryUserSelectedToDate\"\n                  [placeholder]=\"'From`date`' | translate\"\n                  [formControl]=\"form.controls.temporaryUserSelectedFromDate\"\n                  [ngClass]=\"form.controls.temporaryUserSelectedFromDate.errors ? 'has-error' : ''\"\n                ></c8y-date-time-picker>\n                <c8y-messages [show]=\"form.controls.temporaryUserSelectedFromDate.errors\">\n                  <c8y-message\n                    name=\"dateAfterRangeMax\"\n                    [text]=\"'This date is after the latest allowed date.' | translate\"\n                  ></c8y-message>\n                  <c8y-message\n                    name=\"invalidDateTime\"\n                    [text]=\"'This date is invalid.' | translate\"\n                  ></c8y-message>\n                </c8y-messages>\n              </c8y-form-group>\n\n              <c8y-form-group\n                [ngClass]=\"form.controls.temporaryUserSelectedToDate.errors ? 'has-error' : ''\"\n              >\n                <label\n                  [title]=\"'To`date`' | translate\"\n                  for=\"temporaryUserSelectedToDate\"\n                  translate\n                >\n                  To`date`\n                </label>\n                <c8y-date-time-picker\n                  id=\"temporaryUserSelectedToDate\"\n                  [minDate]=\"form.value.temporaryUserSelectedFromDate\"\n                  [placeholder]=\"'To`date`' | translate\"\n                  [formControl]=\"form.controls.temporaryUserSelectedToDate\"\n                  [ngClass]=\"form.controls.temporaryUserSelectedToDate.errors ? 'has-error' : ''\"\n                ></c8y-date-time-picker>\n                <c8y-messages [show]=\"form.controls.temporaryUserSelectedToDate.errors\">\n                  <c8y-message\n                    name=\"dateBeforeRangeMin\"\n                    [text]=\"'This date is before the earliest allowed date.' | translate\"\n                  ></c8y-message>\n                  <c8y-message\n                    name=\"invalidDateTime\"\n                    [text]=\"'This date is invalid.' | translate\"\n                  ></c8y-message>\n                </c8y-messages>\n              </c8y-form-group>\n            </div>\n\n            <div class=\"p-16 d-flex gap-8 separator-top\">\n              <button\n                class=\"btn btn-default btn-sm flex-grow\"\n                title=\"{{ 'Reset' | translate }}\"\n                type=\"button\"\n                (click)=\"dropdown.isOpen = false\"\n                [disabled]=\"form.value.realtime\"\n                translate\n              >\n                Reset\n              </button>\n\n              <button\n                class=\"btn btn-primary btn-sm flex-grow\"\n                title=\"{{ 'Apply' | translate }}\"\n                type=\"button\"\n                (click)=\"applyDatetimeContext(); dropdown.isOpen = false\"\n                [disabled]=\"\n                  (form.pristine && form.untouched) || form.invalid || form.value.realtime\n                \"\n                translate\n              >\n                Apply\n              </button>\n            </div>\n          </ng-container>\n        </ul>\n      </div>\n    </ng-container>\n\n    <div class=\"input-group w-auto\">\n      <c8y-realtime-control\n        class=\"form-control p-0 flex-no-grow w-auto\"\n        formControlName=\"realtime\"\n      ></c8y-realtime-control>\n\n      <c8y-aggregation-picker\n        *ngIf=\"controlsAvailable ? controlsAvailable.aggregation : true\"\n        formControlName=\"aggregation\"\n        [disabledAggregations]=\"disabledAggregations\"\n      ></c8y-aggregation-picker>\n    </div>\n  </form>\n</ng-template>\n" }]
+        }], ctorParameters: () => [{ type: i1.WidgetTimeContextDateRangeService }], propDecorators: { changedDateContext: [{
+                type: Input
+            }], controlsAvailable: [{
+                type: Input
+            }], dropdown: [{
+                type: ViewChild,
+                args: [BsDropdownDirective]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"time-context.component.js","sourceRoot":"","sources":["../../../time-context/time-context.component.ts","../../../time-context/time-context.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  DestroyRef,\n  inject,\n  Input,\n  model,\n  SimpleChanges,\n  ViewChild\n} from '@angular/core';\nimport { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';\nimport { FormBuilder } from '@angular/forms';\nimport {\n  CoreModule,\n  DateTimeContext,\n  DateTimePickerModule,\n  RealtimeControlComponent,\n  WidgetTimeContextDateRangeService\n} from '@c8y/ngx-components';\nimport { INTERVAL_TITLES, Interval } from '@c8y/ngx-components/interval-picker';\nimport { AggregationPickerComponent } from '@c8y/ngx-components';\nimport { IntervalPickerComponent } from '@c8y/ngx-components/interval-picker';\nimport { BsDatepickerModule } from 'ngx-bootstrap/datepicker';\nimport { BsDropdownDirective, BsDropdownModule } from 'ngx-bootstrap/dropdown';\nimport { TooltipModule } from 'ngx-bootstrap/tooltip';\nimport { interval, Subscription } from 'rxjs';\nimport { DatapointExplorerService } from './time-context.service';\n\n@Component({\n  selector: 'c8y-time-context',\n  templateUrl: './time-context.component.html',\n  standalone: true,\n  imports: [\n    CoreModule,\n    BsDatepickerModule,\n    DateTimePickerModule,\n    BsDropdownModule,\n    AggregationPickerComponent,\n    TooltipModule,\n    IntervalPickerComponent,\n    RealtimeControlComponent\n  ]\n})\nexport class TimeContextComponent {\n  @Input() changedDateContext: {\n    dateFrom?: Date;\n    dateTo?: Date;\n    interval?: Interval['id'];\n    realtime?: boolean;\n    aggregation?: string;\n  };\n  @Input() controlsAvailable: any;\n  @ViewChild(BsDropdownDirective) dropdown: BsDropdownDirective;\n  datapointExplorerService = inject(DatapointExplorerService);\n  formBuilder = inject(FormBuilder);\n  #destroyRef = inject(DestroyRef);\n\n  readonly DATE_FORMAT = 'short';\n  readonly INTERVAL_TITLES = INTERVAL_TITLES;\n  readonly REALTIME_INTERVAL = 1000;\n  form = this.createForm(this.datapointExplorerService.getDefaultContext());\n  disabledAggregations;\n\n  readonly valuesSignal = toSignal(this.form.controls.currentDateContextFromDate.valueChanges, {\n    initialValue: this.form.controls.currentDateContextFromDate.value\n  });\n\n  context = model(this.form.value);\n\n  private realtimeSubscription: Subscription;\n\n  constructor(private widgetTimeContextDateRangeService: WidgetTimeContextDateRangeService) {\n    const context = this.datapointExplorerService.getDefaultContext();\n    const { disabledAggregations } = this.datapointExplorerService.calculateAggregation(\n      context.date,\n      context.aggregation\n    );\n    this.disabledAggregations = disabledAggregations;\n\n    this.subscribeToIntervalChange();\n    this.subscribeToRealtimeChange();\n    this.subscribeToAggregationChange();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes.changedDateContext && changes.changedDateContext.currentValue) {\n      this.update({\n        date: [this.changedDateContext.dateFrom, this.changedDateContext.dateTo],\n        interval: this.changedDateContext.interval,\n        realtime: this.changedDateContext.realtime || false,\n        aggregation: this.changedDateContext.aggregation\n      });\n      if (this.changedDateContext.realtime) {\n        this.form.controls.aggregation.disable();\n      }\n    }\n  }\n\n  applyDatetimeContext(): void {\n    this.update({\n      date: [\n        new Date(this.form.controls.temporaryUserSelectedFromDate.value),\n        new Date(this.form.controls.temporaryUserSelectedToDate.value)\n      ],\n      interval: 'custom',\n      realtime: this.form.value.realtime,\n      aggregation: this.form.value.aggregation\n    });\n  }\n\n  private subscribeToIntervalChange(): void {\n    this.form.controls.currentDateContextInterval.valueChanges\n      .pipe(takeUntilDestroyed(this.#destroyRef))\n      .subscribe(interval => {\n        let date: DateTimeContext;\n        this.widgetTimeContextDateRangeService.updateInitialTimeRange(null);\n        if (interval === 'custom') {\n          date = [\n            new Date(this.form.controls.currentDateContextFromDate.value),\n            new Date(this.form.controls.currentDateContextToDate.value)\n          ];\n        } else {\n          date = this.datapointExplorerService.getDateTimeContextByInterval(\n            interval as Interval['id']\n          );\n          this.dropdown.isOpen = false;\n        }\n        this.update({\n          date,\n          interval,\n          realtime: this.form.value.realtime,\n          aggregation: this.form.value.aggregation\n        });\n      });\n  }\n\n  private subscribeToRealtimeChange(): void {\n    this.form.controls.realtime.valueChanges\n      .pipe(takeUntilDestroyed(this.#destroyRef))\n      .subscribe(realtime => {\n        this.onRealtimeValueChange(realtime as boolean);\n\n        if (realtime) {\n          this.startRealtime();\n        } else {\n          this.stopRealtime();\n        }\n      });\n  }\n\n  private subscribeToAggregationChange() {\n    this.form.controls.aggregation.valueChanges\n      .pipe(takeUntilDestroyed(this.#destroyRef))\n      .subscribe(aggregation => {\n        this.update({\n          date: [\n            new Date(this.form.value.currentDateContextFromDate),\n            new Date(this.form.value.currentDateContextToDate)\n          ],\n          interval: this.form.value.currentDateContextInterval,\n          realtime: this.form.value.realtime,\n          aggregation\n        });\n      });\n  }\n\n  private onRealtimeValueChange(realtime: boolean): void {\n    let dateTimeContext: DateTimeContext;\n    if (this.form.value.currentDateContextInterval !== 'custom') {\n      dateTimeContext = this.datapointExplorerService.getDateTimeContextByInterval(\n        this.form.value.currentDateContextInterval as Interval['id']\n      );\n    } else {\n      const currentTimeSpanInMs =\n        new Date(this.form.value.currentDateContextToDate).valueOf() -\n        new Date(this.form.value.currentDateContextFromDate).valueOf();\n      const dateTo = new Date();\n      const dateFrom = new Date(dateTo.valueOf() - currentTimeSpanInMs);\n      dateTimeContext = [dateFrom, dateTo];\n    }\n\n    this.update({\n      date: dateTimeContext,\n      interval: this.form.value.currentDateContextInterval,\n      realtime,\n      aggregation: null\n    });\n  }\n\n  private startRealtime(): void {\n    this.form.controls.temporaryUserSelectedFromDate.disable();\n    this.form.controls.temporaryUserSelectedToDate.disable();\n    this.form.controls.aggregation.disable();\n\n    this.realtimeSubscription = interval(this.REALTIME_INTERVAL)\n      .pipe(takeUntilDestroyed(this.#destroyRef))\n      .subscribe(() => {\n        if (!this.form.value.realtime) {\n          this.realtimeSubscription.unsubscribe();\n          return;\n        }\n        const newDateFrom = new Date(\n          new Date(this.form.value.currentDateContextFromDate).valueOf() + this.REALTIME_INTERVAL\n        );\n        const newDateTo = new Date(\n          new Date(this.form.value.currentDateContextToDate).valueOf() + this.REALTIME_INTERVAL\n        );\n        this.updateFormValues({\n          date: [newDateFrom, newDateTo],\n          interval: this.form.value.currentDateContextInterval,\n          realtime: true,\n          aggregation: null\n        });\n      });\n  }\n\n  private stopRealtime(): void {\n    this.realtimeSubscription?.unsubscribe();\n    this.form?.controls.temporaryUserSelectedFromDate.enable();\n    this.form?.controls.temporaryUserSelectedToDate.enable();\n    this.form?.controls.aggregation.enable();\n  }\n\n  private update({ date, interval, realtime, aggregation }): void {\n    const { selectedAggregation, disabledAggregations } =\n      this.datapointExplorerService.calculateAggregation(date, aggregation);\n    this.disabledAggregations = disabledAggregations;\n    this.updateFormValues({ date, interval, realtime, aggregation: selectedAggregation });\n  }\n\n  private createForm(context) {\n    return this.formBuilder.group({\n      temporaryUserSelectedFromDate: context.date[0].toISOString() as string,\n      temporaryUserSelectedToDate: context.date[1].toISOString() as string,\n      currentDateContextFromDate: context.date[0].toISOString() as string,\n      currentDateContextToDate: context.date[1].toISOString() as string,\n      currentDateContextInterval: context.interval || 'custom',\n      realtime: context.realtime,\n      aggregation: context.aggregation\n    });\n  }\n\n  private updateFormValues({ date, interval, realtime, aggregation }): void {\n    const newFormValues = {\n      temporaryUserSelectedFromDate: date[0].toISOString() as string,\n      temporaryUserSelectedToDate: date[1].toISOString() as string,\n      currentDateContextFromDate: date[0].toISOString() as string,\n      currentDateContextToDate: date[1].toISOString() as string,\n      realtime,\n      currentDateContextInterval: interval || 'custom',\n      aggregation: aggregation || null\n    };\n\n    this.context.set(newFormValues);\n    this.form.patchValue(newFormValues, {\n      emitEvent: false\n    });\n  }\n}\n","<ng-container *ngIf=\"controlsAvailable; else actionBarTemplate\">\n  <ng-container\n    [ngTemplateOutlet]=\"dateTimePicker\"\n    [ngTemplateOutletContext]=\"{\n      date: [form.value.currentDateContextFromDate, form.value.currentDateContextToDate]\n    }\"\n  ></ng-container>\n</ng-container>\n\n<ng-template #actionBarTemplate>\n  <c8y-action-bar-item\n    [groupId]=\"'timeContext'\"\n    [inGroupPriority]=\"1\"\n    [placement]=\"'left'\"\n  >\n    <ng-container\n      [ngTemplateOutlet]=\"dateTimePicker\"\n      [ngTemplateOutletContext]=\"{\n        date: [form.value.currentDateContextFromDate, form.value.currentDateContextToDate]\n      }\"\n    ></ng-container>\n  </c8y-action-bar-item>\n</ng-template>\n\n<ng-template\n  #dateTimePicker\n  let-date=\"date\"\n>\n  <form\n    class=\"d-flex gap-8 p-l-xs-16 p-r-xs-16 m-t-xs-8 m-b-xs-8\"\n    [formGroup]=\"form\"\n  >\n    <ng-container>\n      <div\n        class=\"dropdown flex-grow\"\n        #dropdown=\"bs-dropdown\"\n        dropdown\n        [insideClick]=\"true\"\n        *ngIf=\"date\"\n      >\n        <button\n          class=\"dropdown-toggle form-control l-h-tight d-flex a-i-center\"\n          attr.aria-label=\"{{ date[0] | c8yDate: DATE_FORMAT }} — {{\n            date[1] | c8yDate: DATE_FORMAT\n          }}\"\n          tooltip=\"{{ date[0] | c8yDate: DATE_FORMAT }} — {{ date[1] | c8yDate: DATE_FORMAT }}\"\n          placement=\"top\"\n          container=\"body\"\n          data-cy=\"widget-time-context--date-picker-dropdown-button\"\n          [adaptivePosition]=\"false\"\n          [delay]=\"500\"\n          dropdownToggle\n        >\n          <i\n            class=\"m-r-4\"\n            c8yIcon=\"schedule1\"\n          ></i>\n          <div class=\"d-col text-left fit-w\">\n            <span\n              class=\"text-12\"\n              data-cy=\"widget-time-context--selected-interval\"\n            >\n              {{ INTERVAL_TITLES[form.controls.currentDateContextInterval.value] | translate }}\n            </span>\n            <span\n              class=\"text-10 text-muted text-truncate\"\n              data-cy=\"widget-time-context--selected-time-range\"\n            >\n              {{ date[0] | c8yDate: DATE_FORMAT }} — {{ date[1] | c8yDate: DATE_FORMAT }}\n            </span>\n          </div>\n          <span class=\"caret m-r-16 m-l-4\"></span>\n        </button>\n\n        <ul\n          class=\"dropdown-menu dropdown-menu--date-range\"\n          *dropdownMenu\n        >\n          <c8y-interval-picker\n            class=\"d-contents\"\n            formControlName=\"currentDateContextInterval\"\n          ></c8y-interval-picker>\n\n          <ng-container *ngIf=\"form.controls.currentDateContextInterval.value === 'custom'\">\n            <div class=\"p-l-16 p-r-16\">\n              <c8y-form-group\n                [ngClass]=\"form.controls.temporaryUserSelectedFromDate.errors ? 'has-error' : ''\"\n              >\n                <label\n                  [title]=\"'From`date`' | translate\"\n                  for=\"temporaryUserSelectedFromDate\"\n                  translate\n                >\n                  From`date`\n                </label>\n                <c8y-date-time-picker\n                  id=\"temporaryUserSelectedFromDate\"\n                  [maxDate]=\"form.value.temporaryUserSelectedToDate\"\n                  [placeholder]=\"'From`date`' | translate\"\n                  [formControl]=\"form.controls.temporaryUserSelectedFromDate\"\n                  [ngClass]=\"form.controls.temporaryUserSelectedFromDate.errors ? 'has-error' : ''\"\n                ></c8y-date-time-picker>\n                <c8y-messages [show]=\"form.controls.temporaryUserSelectedFromDate.errors\">\n                  <c8y-message\n                    name=\"dateAfterRangeMax\"\n                    [text]=\"'This date is after the latest allowed date.' | translate\"\n                  ></c8y-message>\n                  <c8y-message\n                    name=\"invalidDateTime\"\n                    [text]=\"'This date is invalid.' | translate\"\n                  ></c8y-message>\n                </c8y-messages>\n              </c8y-form-group>\n\n              <c8y-form-group\n                [ngClass]=\"form.controls.temporaryUserSelectedToDate.errors ? 'has-error' : ''\"\n              >\n                <label\n                  [title]=\"'To`date`' | translate\"\n                  for=\"temporaryUserSelectedToDate\"\n                  translate\n                >\n                  To`date`\n                </label>\n                <c8y-date-time-picker\n                  id=\"temporaryUserSelectedToDate\"\n                  [minDate]=\"form.value.temporaryUserSelectedFromDate\"\n                  [placeholder]=\"'To`date`' | translate\"\n                  [formControl]=\"form.controls.temporaryUserSelectedToDate\"\n                  [ngClass]=\"form.controls.temporaryUserSelectedToDate.errors ? 'has-error' : ''\"\n                ></c8y-date-time-picker>\n                <c8y-messages [show]=\"form.controls.temporaryUserSelectedToDate.errors\">\n                  <c8y-message\n                    name=\"dateBeforeRangeMin\"\n                    [text]=\"'This date is before the earliest allowed date.' | translate\"\n                  ></c8y-message>\n                  <c8y-message\n                    name=\"invalidDateTime\"\n                    [text]=\"'This date is invalid.' | translate\"\n                  ></c8y-message>\n                </c8y-messages>\n              </c8y-form-group>\n            </div>\n\n            <div class=\"p-16 d-flex gap-8 separator-top\">\n              <button\n                class=\"btn btn-default btn-sm flex-grow\"\n                title=\"{{ 'Reset' | translate }}\"\n                type=\"button\"\n                (click)=\"dropdown.isOpen = false\"\n                [disabled]=\"form.value.realtime\"\n                translate\n              >\n                Reset\n              </button>\n\n              <button\n                class=\"btn btn-primary btn-sm flex-grow\"\n                title=\"{{ 'Apply' | translate }}\"\n                type=\"button\"\n                (click)=\"applyDatetimeContext(); dropdown.isOpen = false\"\n                [disabled]=\"\n                  (form.pristine && form.untouched) || form.invalid || form.value.realtime\n                \"\n                translate\n              >\n                Apply\n              </button>\n            </div>\n          </ng-container>\n        </ul>\n      </div>\n    </ng-container>\n\n    <div class=\"input-group w-auto\">\n      <c8y-realtime-control\n        class=\"form-control p-0 flex-no-grow w-auto\"\n        formControlName=\"realtime\"\n      ></c8y-realtime-control>\n\n      <c8y-aggregation-picker\n        *ngIf=\"controlsAvailable ? controlsAvailable.aggregation : true\"\n        formControlName=\"aggregation\"\n        [disabledAggregations]=\"disabledAggregations\"\n      ></c8y-aggregation-picker>\n    </div>\n  </form>\n</ng-template>\n"]}