@c8y/ngx-components 1021.13.3 → 1021.22.0

package/esm2022/core/common/humanize-app-name.pipe.mjs

@@ -2,7 +2,7 @@ import { Pipe } from '@angular/core';
 import { TranslateService } from '@ngx-translate/core';
 import { find, get, isUndefined, negate } from 'lodash-es';
 import { of } from 'rxjs';
-import { gettext } from '../i18n/gettext';
+import { gettext } from '@c8y/ngx-components/gettext';
 import { internalApps } from './humanize-app-name.model';
 import * as i0 from "@angular/core";
 import * as i1 from "@ngx-translate/core";
@@ -57,4 +57,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImpor
             type: Pipe,
             args: [{ name: 'humanizeAppName', standalone: true }]
         }], ctorParameters: () => [{ type: i1.TranslateService }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/common/index.mjs

@@ -64,4 +64,8 @@ export * from './virtual-scroll/virtual-scroll-window-strategy';
 export * from './virtual-scroll/virtual-scroll-window.directive';
 export * from './virtual-scroll/virtual-scroller-wrapper.component';
 export * from './zip.service';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9jb3JlL2NvbW1vbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUMzRCxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsNkNBQTZDLENBQUM7QUFDNUQsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsMENBQTBDLENBQUM7QUFDekQsY0FBYyxtREFBbUQsQ0FBQztBQUNsRSxjQUFjLHFEQUFxRCxDQUFDO0FBQ3BFLGNBQWMsNkNBQTZDLENBQUM7QUFDNUQsY0FBYyxpREFBaUQsQ0FBQztBQUNoRSxjQUFjLGtEQUFrRCxDQUFDO0FBQ2pFLGNBQWMscURBQXFELENBQUM7QUFDcEUsY0FBYyxlQUFlLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSB7IEFwcGxpY2F0aW9uT3B0aW9ucyB9IGZyb20gJ0BjOHkvb3B0aW9ucyc7XG5leHBvcnQgeyBQbHVnaW5zRXhwb3J0U2NvcGVzIH0gZnJvbSAnLi9BcHBsaWNhdGlvbk9wdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9hc3NldC1saW5rLnBpcGUnO1xuZXhwb3J0ICogZnJvbSAnLi9ieXRlcy5waXBlJztcbmV4cG9ydCAqIGZyb20gJy4vY29sb3Iuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbW1vbi5jb25zdGFudHMnO1xuZXhwb3J0ICogZnJvbSAnLi9jb21tb24ubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50LW91dGxldC5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9kYXRlLnBpcGUnO1xuZXhwb3J0ICogZnJvbSAnLi9kZXZpY2Uuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2Ryb3Bkb3duLWRpcmVjdGlvbi5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9lbXB0eS1zdGF0ZS9lbXB0eS1zdGF0ZS1jb250ZXh0LmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2VtcHR5LXN0YXRlL2VtcHR5LXN0YXRlLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2V4dGVuc2lvbi1ob29rcyc7XG5leHBvcnQgKiBmcm9tICcuL2ZpbGVzLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JPZi5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JPZi5tb2RlbCc7XG5leHBvcnQgKiBmcm9tICcuL2dlbmVyaWMtZmlsZS1pY29uLnBpcGUnO1xuZXhwb3J0ICogZnJvbSAnLi9nZW8uc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2dldC1ncm91cC1pY29uLnBpcGUnO1xuZXhwb3J0ICogZnJvbSAnLi9nbG9iYWwtY29uZmlnLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9ncm91cC1mcmFnbWVudC5tb2RlbCc7XG5leHBvcnQgKiBmcm9tICcuL2dyb3VwLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9odW1hbml6ZS1hcHAtbmFtZS5tb2RlbCc7XG5leHBvcnQgKiBmcm9tICcuL2h1bWFuaXplLWFwcC1uYW1lLnBpcGUnO1xuZXhwb3J0ICogZnJvbSAnLi9odW1hbml6ZS5waXBlJztcbmV4cG9ydCAqIGZyb20gJy4vaWNvbi5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9pZi1hbGxvd2VkLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2xvYWQtbW9yZS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9sb2FkLW1vcmUubW9kZWwnO1xuZXhwb3J0ICogZnJvbSAnLi9sb2FkaW5nLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL21hbmFnZWQtb2JqZWN0LXR5cGUnO1xuZXhwb3J0ICogZnJvbSAnLi9tYXAtZnVuY3Rpb24ucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL21hcmtkb3duLXRvLWh0bWwucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL21lbW9pemUuZGVjb3JhdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vbW8tbmFtZS5waXBlJztcbmV4cG9ydCAqIGZyb20gJy4vbnVtYmVyLnBpcGUnO1xuZXhwb3J0ICogZnJvbSAnLi9vcGVyYXRpb24tcmVzdWx0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL29wdGlvbnMuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL291dGxldC5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9wZXJtaXNzaW9ucy5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcHJvZ3Jlc3MtYmFyLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3JlbGF0aXZlLXRpbWUucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL3JldHJ5LXdpdGgtZGVsYXkub3BlcmF0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlLXJlZ2lzdHJ5Lm1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZS1yZWdpc3RyeS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc2hvcnRlbi11c2VyLW5hbWUucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL3Nob3VsZC1zaG93LW1vLnBpcGUnO1xuZXhwb3J0ICogZnJvbSAnLi9zaG93LWlmLWZpbHRlci5waXBlJztcbmV4cG9ydCAqIGZyb20gJy4vc2tpcC1saW5rLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3N0YXRlLXNlcnZpY2UuYWJzdHJhY3QnO1xuZXhwb3J0ICogZnJvbSAnLi9zdGF0dXMubW9kZWwnO1xuZXhwb3J0ICogZnJvbSAnLi9zdHJpbmdpZnktb2JqZWN0LnBpcGUnO1xuZXhwb3J0ICogZnJvbSAnLi90YWJzZXQtYXJpYS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi90ZW5hbnQtdWkuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3RleHRhcmVhLWF1dG9yZXNpemUuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vdGhyb3R0bGUuZGVjb3JhdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vdWktc3RhdGUuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3VzZXItbmFtZS1pbml0aWFscy5waXBlJztcbmV4cG9ydCAqIGZyb20gJy4vdXNlci1wcmVmZXJlbmNlcy91c2VyLXByZWZlcmVuY2UubW9kZWwnO1xuZXhwb3J0ICogZnJvbSAnLi91c2VyLXByZWZlcmVuY2VzL3VzZXItcHJlZmVyZW5jZXMtc3RvcmFnZS1sb2NhbCc7XG5leHBvcnQgKiBmcm9tICcuL3VzZXItcHJlZmVyZW5jZXMvdXNlci1wcmVmZXJlbmNlcy1zdG9yZS1pbnZlbnRvcnknO1xuZXhwb3J0ICogZnJvbSAnLi91c2VyLXByZWZlcmVuY2VzL3VzZXItcHJlZmVyZW5jZXMuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3ZpcnR1YWwtc2Nyb2xsL3ZpcnR1YWwtc2Nyb2xsLXdpbmRvdy1zdHJhdGVneSc7XG5leHBvcnQgKiBmcm9tICcuL3ZpcnR1YWwtc2Nyb2xsL3ZpcnR1YWwtc2Nyb2xsLXdpbmRvdy5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi92aXJ0dWFsLXNjcm9sbC92aXJ0dWFsLXNjcm9sbGVyLXdyYXBwZXIuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vemlwLnNlcnZpY2UnO1xuIl19
+export * from './aggregation/aggregation.service';
+export * from './aggregation/aggregation.model';
+export * from './inter-app.service';
+export * from './interval-based-reload.abstract';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/common/inter-app.service.mjs

@@ -0,0 +1,76 @@
+import { inject, Injectable } from '@angular/core';
+import { combineLatest, firstValueFrom, map } from 'rxjs';
+import { AppStateService } from './ui-state.service';
+import { gettext } from '@c8y/ngx-components/gettext';
+import { TranslateService } from '@ngx-translate/core';
+import { AlertService } from '../alert/alert.service';
+import * as i0 from "@angular/core";
+export const SupportedApps = {
+    devicemanagement: 'devicemanagement-application-key',
+    cockpit: 'cockpit-application-key',
+    administration: 'administration-application-key'
+};
+/**
+ * Service that provides methods to interact with other applications.
+ * It allows retrieving a specific app by key, checking its availability, verifying if it is not the current application,
+ * determining if a link to another app should be shown, and navigating to it.
+ */
+export class InterAppService {
+    constructor() {
+        this.stateService = inject(AppStateService);
+        this.alertService = inject(AlertService);
+        this.translateService = inject(TranslateService);
+    }
+    /**
+     * Retrieve application by its key as observable.
+     * @param key {SupportedAppKey} - Application key.
+     * @returns Observable of Application
+     */
+    getApp$(key) {
+        return this.stateService.currentAppsOfUser.pipe(map(apps => apps.find(app => app.key === key)));
+    }
+    /**
+     * Checks if current application is the same as the one that key is provided
+     * @param key {SupportedAppKey} - Application key.
+     * @returns Observable of boolean; true if current app matches provided key.
+     */
+    isCurrentApp$(key) {
+        return this.stateService.currentApplication.pipe(map(app => app?.key === key));
+    }
+    /**
+     * Checks if other (other than current) application link should be displayed. It consists of two conditions:
+     * - app that link leads to exists and is available for current user
+     * - app link leads to app that is not current app
+     * @param appKey {SupportedAppKey} - Application key that link leads to.
+     * @returns Observable of boolean; only true when app that link leads to is available and app link leads to app that is not current app
+     */
+    shouldShowAppLink$(appKey) {
+        return combineLatest([
+            this.getApp$(appKey).pipe(map(Boolean)),
+            this.isCurrentApp$(appKey).pipe(map(val => !val))
+        ]).pipe(map(([linkedAppIsAvailable, linkLeadsToOtherAppThanCurrent]) => linkedAppIsAvailable && linkLeadsToOtherAppThanCurrent));
+    }
+    /**
+     * Navigates to app by provided app key
+     * @param appKey {SupportedAppKey} - Application key that links leads to.
+     * @param path {string} - Additional path in target application.
+     */
+    async navigateToApp(appKey, path) {
+        const contextPath = await firstValueFrom(this.getApp$(appKey).pipe(map(app => app?.contextPath)));
+        if (!contextPath) {
+            const msg = this.translateService.instant(gettext('Application with key "{{appKey}}" not found.'), { appKey });
+            this.alertService.danger(msg);
+            return;
+        }
+        const baseUrl = `/apps/${contextPath}`;
+        const url = path ? `${baseUrl}/${path}` : baseUrl;
+        window.open(url, '_blank', 'noopener,noreferrer');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: InterAppService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: InterAppService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: InterAppService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/common/interval-based-reload.abstract.mjs

@@ -0,0 +1,110 @@
+import { effect, runInInjectionContext } from '@angular/core';
+/**
+ * Abstract class representing an interval reload functionality.
+ * This class provides methods and properties for managing an interval-based reload mechanism.
+ */
+export class IntervalBasedReload {
+    /**
+     * Stops the countdown and triggers a refresh action.
+     * This function is responsible for halting the countdown interval component's operation.
+     * After stopping the countdown, it emits an `onCountdownEnded` event.
+     * This event is used to inform external components that the countdown has ended,
+     * typically prompting them to reload or refresh their data.
+     */
+    autoRefreshList() {
+        if (this.isIntervalRefreshToggleOn && this.isAutoRefreshEnabled) {
+            this.countdownIntervalComponent.stop();
+        }
+        this.onCountdownEnded.emit();
+    }
+    /**
+     * Manages the countdown timer's visibility and state in response to user scrolling.
+     *
+     * This method toggles the countdown timer based on the user's scrolling behavior. It uses
+     * the `disableCountdown` and `enableCountdown` methods for handling the countdown state.
+     *
+     * - If the user is scrolling down while the countdown is visible (`isScrolling` is true and
+     *   `hideCountdown` is false), `disableCountdown` is called to stop and hide the countdown,
+     *   and `isIntervalRefreshToggleOn` is set to false.
+     *
+     * - If the user has stopped scrolling, the countdown subscription is closed, and the countdown
+     *   is hidden (`!isScrolling`, `countdownSubscription?.closed`, `hideCountdown`), `enableCountdown`
+     *   is called to show and restart the countdown, and `isIntervalRefreshToggleOn` is set to true.
+     */
+    handleScrolling() {
+        // Checks if the user has scrolled down while the countdown is visible
+        const onUserScrollDownHide = this.isScrolling && !this.hideCountdown;
+        if (onUserScrollDownHide) {
+            this.disableCountdown();
+            this.isIntervalRefreshToggleOn = false;
+            return;
+        }
+        // Checks if the user has stopped scrolling and the countdown is currently hidden
+        const onUserScrollTopShow = !this.isScrolling && this.hideCountdown;
+        if (onUserScrollTopShow) {
+            this.isIntervalRefreshToggleOn = true;
+            this.enableCountdown();
+        }
+    }
+    /**
+     * Handles the toggle state of the countdown on button click.
+     *
+     * This method is triggered by a mouse event, typically a click on the countdown toggle button.
+     * It toggles `isIntervalRefreshToggleOn` to reflect the current state of the countdown timer.
+     *
+     * - If `isIntervalRefreshToggleOn` is set to false, indicating that the countdown should be stopped,
+     *   `disableCountdown` is called, and `manuallyDisabledCountdown` is set to true.
+     *
+     * - If `isIntervalRefreshToggleOn` is true and the countdown subscription is closed, indicating that
+     *   the countdown can be started, `enableCountdown` is called, and `manuallyDisabledCountdown`
+     *   is set to false.
+     *
+     * @param $event - The MouseEvent that triggered this method.
+     */
+    onToggleCountdownButtonState($event) {
+        $event.preventDefault();
+        this.isIntervalRefreshToggleOn = !this.isIntervalRefreshToggleOn;
+        this.updateCountdownButtonTooltipText();
+        if (!this.isIntervalRefreshToggleOn) {
+            this.disableCountdown();
+            this.manuallyDisabledCountdown = true;
+            return;
+        }
+        if (this.isIntervalRefreshToggleOn) {
+            this.enableCountdown();
+            this.manuallyDisabledCountdown = false;
+        }
+    }
+    /**
+     * This function listens for changes in the `isLoading` observable, filtering out any truthy values.
+     * Once a falsy value is detected (indicating that loading has finished), it attempts to start the countdown.
+     *
+     * IMPORTANT: If the widget's configuration (refreshInterval, check template) is not set prior to executing countdownIntervalComponent?.start,
+     * the countdown interval will not start!
+     *
+     * @param injector - The injector used to provide necessary dependencies
+     *                   within the `runInInjectionContext`.
+     */
+    startCountdown(injector) {
+        runInInjectionContext(injector, () => {
+            effect(() => {
+                if (!this.isLoading()) {
+                    this.countdownIntervalComponent?.start();
+                }
+            });
+        });
+    }
+    /**
+     * Disables and hides the countdown timer.
+     *
+     * This method stops the ongoing countdown process by
+     * stopping the `countdownIntervalComponent` if it exists. It then hides the countdown timer
+     * by setting `hideCountdown` to true. This method encapsulates the logic required to halt and
+     * conceal the countdown timer.
+     */
+    disableCountdown() {
+        this.countdownIntervalComponent?.stop();
+        this.hideCountdown = true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interval-based-reload.abstract.js","sourceRoot":"","sources":["../../../../core/common/interval-based-reload.abstract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,MAAM,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAG9F;;;GAGG;AACH,MAAM,OAAgB,mBAAmB;IAqCvC;;;;;;OAMG;IACH,eAAe;QACb,IAAI,IAAI,CAAC,yBAAyB,IAAI,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAChE,IAAI,CAAC,0BAA0B,CAAC,IAAI,EAAE,CAAC;QACzC,CAAC;QACD,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC;IAC/B,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,eAAe;QACb,sEAAsE;QACtE,MAAM,oBAAoB,GAAG,IAAI,CAAC,WAAW,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC;QAErE,IAAI,oBAAoB,EAAE,CAAC;YACzB,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACxB,IAAI,CAAC,yBAAyB,GAAG,KAAK,CAAC;YACvC,OAAO;QACT,CAAC;QAED,iFAAiF;QACjF,MAAM,mBAAmB,GAAG,CAAC,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,aAAa,CAAC;QAEpE,IAAI,mBAAmB,EAAE,CAAC;YACxB,IAAI,CAAC,yBAAyB,GAAG,IAAI,CAAC;YACtC,IAAI,CAAC,eAAe,EAAE,CAAC;QACzB,CAAC;IACH,CAAC;IAOD;;;;;;;;;;;;;;OAcG;IACH,4BAA4B,CAAC,MAAkB;QAC7C,MAAM,CAAC,cAAc,EAAE,CAAC;QACxB,IAAI,CAAC,yBAAyB,GAAG,CAAC,IAAI,CAAC,yBAAyB,CAAC;QACjE,IAAI,CAAC,gCAAgC,EAAE,CAAC;QAExC,IAAI,CAAC,IAAI,CAAC,yBAAyB,EAAE,CAAC;YACpC,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACxB,IAAI,CAAC,yBAAyB,GAAG,IAAI,CAAC;YACtC,OAAO;QACT,CAAC;QAED,IAAI,IAAI,CAAC,yBAAyB,EAAE,CAAC;YACnC,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,IAAI,CAAC,yBAAyB,GAAG,KAAK,CAAC;QACzC,CAAC;IACH,CAAC;IAED;;;;;;;;;OASG;IACH,cAAc,CAAC,QAAkB;QAC/B,qBAAqB,CAAC,QAAQ,EAAE,GAAG,EAAE;YACnC,MAAM,CAAC,GAAG,EAAE;gBACV,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;oBACtB,IAAI,CAAC,0BAA0B,EAAE,KAAK,EAAE,CAAC;gBAC3C,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAYD;;;;;;;OAOG;IACH,gBAAgB;QACd,IAAI,CAAC,0BAA0B,EAAE,IAAI,EAAE,CAAC;QACxC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;IAC5B,CAAC;CAMF","sourcesContent":["import { EventEmitter, Injector, Signal, effect, runInInjectionContext } from '@angular/core';\nimport { CountdownIntervalComponent } from '../countdown-interval';\n\n/**\n * Abstract class representing an interval reload functionality.\n * This class provides methods and properties for managing an interval-based reload mechanism.\n */\nexport abstract class IntervalBasedReload {\n  abstract countdownIntervalComponent: CountdownIntervalComponent;\n  /**\n   * Indicates whether auto-refresh is enabled for the datapoints reload component that is set in widget config.\n   */\n  isAutoRefreshEnabled: boolean;\n  /**\n   * Current isLoading state. Based on it next countdown cycle is being started.\n   */\n  abstract isLoading: Signal<boolean>;\n  /**\n   * Indicates whether the alarm list is being scrolled or not.\n   */\n  abstract isScrolling: boolean;\n  /**\n   * Current refresh interval set in a widget config.\n   */\n  abstract refreshInterval: number;\n  /**\n   * Indicates that a countdown cycle has ended.\n   */\n  abstract onCountdownEnded: EventEmitter<void>;\n  /**\n   * Indicates the current state of an interval refresh toggle button.\n   */\n  abstract isIntervalRefreshToggleOn: boolean;\n\n  abstract toggleCountdownButtonTooltipText: string;\n  /**\n   * Indicates whether the countdown has been manually disabled by the user.\n   */\n  protected abstract manuallyDisabledCountdown: boolean;\n  /**\n   * Controls the visibility of the countdown timer component in the current component's UI.\n   */\n  protected abstract hideCountdown: boolean;\n\n  /**\n   * Stops the countdown and triggers a refresh action.\n   * This function is responsible for halting the countdown interval component's operation.\n   * After stopping the countdown, it emits an `onCountdownEnded` event.\n   * This event is used to inform external components that the countdown has ended,\n   * typically prompting them to reload or refresh their data.\n   */\n  autoRefreshList(): void {\n    if (this.isIntervalRefreshToggleOn && this.isAutoRefreshEnabled) {\n      this.countdownIntervalComponent.stop();\n    }\n    this.onCountdownEnded.emit();\n  }\n\n  /**\n   * Manages the countdown timer's visibility and state in response to user scrolling.\n   *\n   * This method toggles the countdown timer based on the user's scrolling behavior. It uses\n   * the `disableCountdown` and `enableCountdown` methods for handling the countdown state.\n   *\n   * - If the user is scrolling down while the countdown is visible (`isScrolling` is true and\n   *   `hideCountdown` is false), `disableCountdown` is called to stop and hide the countdown,\n   *   and `isIntervalRefreshToggleOn` is set to false.\n   *\n   * - If the user has stopped scrolling, the countdown subscription is closed, and the countdown\n   *   is hidden (`!isScrolling`, `countdownSubscription?.closed`, `hideCountdown`), `enableCountdown`\n   *   is called to show and restart the countdown, and `isIntervalRefreshToggleOn` is set to true.\n   */\n  handleScrolling(): void {\n    // Checks if the user has scrolled down while the countdown is visible\n    const onUserScrollDownHide = this.isScrolling && !this.hideCountdown;\n\n    if (onUserScrollDownHide) {\n      this.disableCountdown();\n      this.isIntervalRefreshToggleOn = false;\n      return;\n    }\n\n    // Checks if the user has stopped scrolling and the countdown is currently hidden\n    const onUserScrollTopShow = !this.isScrolling && this.hideCountdown;\n\n    if (onUserScrollTopShow) {\n      this.isIntervalRefreshToggleOn = true;\n      this.enableCountdown();\n    }\n  }\n\n  abstract reload(): void;\n  /**\n   * Wrapper method where it's name better describes a context where it was called.\n   */\n  abstract countdownEnded(): void;\n  /**\n   * Handles the toggle state of the countdown on button click.\n   *\n   * This method is triggered by a mouse event, typically a click on the countdown toggle button.\n   * It toggles `isIntervalRefreshToggleOn` to reflect the current state of the countdown timer.\n   *\n   * - If `isIntervalRefreshToggleOn` is set to false, indicating that the countdown should be stopped,\n   *   `disableCountdown` is called, and `manuallyDisabledCountdown` is set to true.\n   *\n   * - If `isIntervalRefreshToggleOn` is true and the countdown subscription is closed, indicating that\n   *   the countdown can be started, `enableCountdown` is called, and `manuallyDisabledCountdown`\n   *   is set to false.\n   *\n   * @param $event - The MouseEvent that triggered this method.\n   */\n  onToggleCountdownButtonState($event: MouseEvent): void {\n    $event.preventDefault();\n    this.isIntervalRefreshToggleOn = !this.isIntervalRefreshToggleOn;\n    this.updateCountdownButtonTooltipText();\n\n    if (!this.isIntervalRefreshToggleOn) {\n      this.disableCountdown();\n      this.manuallyDisabledCountdown = true;\n      return;\n    }\n\n    if (this.isIntervalRefreshToggleOn) {\n      this.enableCountdown();\n      this.manuallyDisabledCountdown = false;\n    }\n  }\n\n  /**\n   * This function listens for changes in the `isLoading` observable, filtering out any truthy values.\n   * Once a falsy value is detected (indicating that loading has finished), it attempts to start the countdown.\n   *\n   * IMPORTANT: If the widget's configuration (refreshInterval, check template) is not set prior to executing countdownIntervalComponent?.start,\n   * the countdown interval will not start!\n   *\n   * @param injector - The injector used to provide necessary dependencies\n   *                   within the `runInInjectionContext`.\n   */\n  startCountdown(injector: Injector): void {\n    runInInjectionContext(injector, () => {\n      effect(() => {\n        if (!this.isLoading()) {\n          this.countdownIntervalComponent?.start();\n        }\n      });\n    });\n  }\n\n  /**\n   * Enables and starts the countdown timer.\n   *\n   * This method makes the countdown visible (`hideCountdown` is set to false) and then\n   * starts the countdown process. It ensures the countdown timer is updated immediately\n   * by triggering change detection with `cdRef.detectChanges()` before starting the countdown.\n   * This method encapsulates the logic required to initiate the countdown timer.\n   */\n  abstract enableCountdown(): void;\n\n  /**\n   * Disables and hides the countdown timer.\n   *\n   * This method stops the ongoing countdown process by\n   * stopping the `countdownIntervalComponent` if it exists. It then hides the countdown timer\n   * by setting `hideCountdown` to true. This method encapsulates the logic required to halt and\n   * conceal the countdown timer.\n   */\n  disableCountdown(): void {\n    this.countdownIntervalComponent?.stop();\n    this.hideCountdown = true;\n  }\n\n  /**\n   * Updates the countdown button tooltip text based on the state of the interval refresh toggle state.\n   */\n  protected abstract updateCountdownButtonTooltipText(): void;\n}\n"]}

package/esm2022/core/countdown-interval/countdown-interval.component.mjs

@@ -110,14 +110,14 @@ export class CountdownIntervalComponent {
         });
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: CountdownIntervalComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: CountdownIntervalComponent, selector: "c8y-countdown-interval", inputs: { countdownInterval: "countdownInterval" }, outputs: { countdownEnded: "countdownEnded" }, ngImport: i0, template: "<div\n  class=\"time-elapsed\"\n  [style.--timescope]=\"countdownInterval + 'ms'\"\n  [title]=\"'{{ secondsLeft }} s / {{ interval }} s' | translate: { secondsLeft: secondsUntilRefresh$ | async, interval: countdownInterval / 1000 }\"\n>\n  <svg\n    [ngClass]=\"{ 'time-on': runSpinner$ | async }\"\n    viewBox=\"0 0 40 40\"\n    fill=\"none\"\n    xmlns=\"http://www.w3.org/2000/svg\"\n  >\n    <circle\n      cx=\"20\"\n      cy=\"20\"\n      r=\"15.8\"\n      stroke=\"var(--c8y-brand-primary)\"\n      stroke-width=\"6\"\n    />\n  </svg>\n\n  <span>{{ secondsUntilRefresh$ | async }}</span>\n</div>\n", dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "pipe", type: i2.TranslatePipe, name: "translate" }] }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: CountdownIntervalComponent, selector: "c8y-countdown-interval", inputs: { countdownInterval: "countdownInterval" }, outputs: { countdownEnded: "countdownEnded" }, ngImport: i0, template: "<div\n  class=\"time-elapsed\"\n  data-cy=\"c8y-countdown-interval--countdown\"\n  [style.--timescope]=\"countdownInterval + 'ms'\"\n  [title]=\"'{{ secondsLeft }} s / {{ interval }} s' | translate: { secondsLeft: secondsUntilRefresh$ | async, interval: countdownInterval / 1000 }\"\n>\n  <svg\n    [ngClass]=\"{ 'time-on': runSpinner$ | async }\"\n    viewBox=\"0 0 40 40\"\n    fill=\"none\"\n    xmlns=\"http://www.w3.org/2000/svg\"\n  >\n    <circle\n      cx=\"20\"\n      cy=\"20\"\n      r=\"15.8\"\n      stroke=\"var(--c8y-brand-primary)\"\n      stroke-width=\"6\"\n    />\n  </svg>\n\n  <span>{{ secondsUntilRefresh$ | async }}</span>\n</div>\n", dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "pipe", type: i2.TranslatePipe, name: "translate" }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: CountdownIntervalComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'c8y-countdown-interval', template: "<div\n  class=\"time-elapsed\"\n  [style.--timescope]=\"countdownInterval + 'ms'\"\n  [title]=\"'{{ secondsLeft }} s / {{ interval }} s' | translate: { secondsLeft: secondsUntilRefresh$ | async, interval: countdownInterval / 1000 }\"\n>\n  <svg\n    [ngClass]=\"{ 'time-on': runSpinner$ | async }\"\n    viewBox=\"0 0 40 40\"\n    fill=\"none\"\n    xmlns=\"http://www.w3.org/2000/svg\"\n  >\n    <circle\n      cx=\"20\"\n      cy=\"20\"\n      r=\"15.8\"\n      stroke=\"var(--c8y-brand-primary)\"\n      stroke-width=\"6\"\n    />\n  </svg>\n\n  <span>{{ secondsUntilRefresh$ | async }}</span>\n</div>\n" }]
+            args: [{ selector: 'c8y-countdown-interval', template: "<div\n  class=\"time-elapsed\"\n  data-cy=\"c8y-countdown-interval--countdown\"\n  [style.--timescope]=\"countdownInterval + 'ms'\"\n  [title]=\"'{{ secondsLeft }} s / {{ interval }} s' | translate: { secondsLeft: secondsUntilRefresh$ | async, interval: countdownInterval / 1000 }\"\n>\n  <svg\n    [ngClass]=\"{ 'time-on': runSpinner$ | async }\"\n    viewBox=\"0 0 40 40\"\n    fill=\"none\"\n    xmlns=\"http://www.w3.org/2000/svg\"\n  >\n    <circle\n      cx=\"20\"\n      cy=\"20\"\n      r=\"15.8\"\n      stroke=\"var(--c8y-brand-primary)\"\n      stroke-width=\"6\"\n    />\n  </svg>\n\n  <span>{{ secondsUntilRefresh$ | async }}</span>\n</div>\n" }]
         }], propDecorators: { countdownInterval: [{
                 type: Input
             }], countdownEnded: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"countdown-interval.component.js","sourceRoot":"","sources":["../../../../core/countdown-interval/countdown-interval.component.ts","../../../../core/countdown-interval/countdown-interval.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnDestroy, OnInit, Output } from '@angular/core';\nimport { BehaviorSubject, fromEvent, Observable, of, Subject, Subscription, timer } from 'rxjs';\nimport { debounceTime, filter, first, mapTo, switchMap, takeUntil, tap } from 'rxjs/operators';\n\n/**\n * Component to count down specific time interval, then emit when countdown ends.\n * Next countdown is started right after previous one.\n */\n@Component({\n  selector: 'c8y-countdown-interval',\n  templateUrl: './countdown-interval.component.html'\n})\nexport class CountdownIntervalComponent implements OnInit, OnDestroy {\n  /**\n   * Time in milliseconds to count down from.\n   */\n  @Input() set countdownInterval(value: number) {\n    this._countdownInterval = Math.max(value, this.MINIMUM_INTERVAL);\n  }\n\n  get countdownInterval(): number {\n    return this._countdownInterval || this.MINIMUM_INTERVAL;\n  }\n  /**\n   * Emits when countdown ends.\n   */\n  @Output() countdownEnded = new EventEmitter<void>();\n\n  runSpinner$ = new BehaviorSubject(false);\n  secondsUntilRefresh$: BehaviorSubject<string>;\n\n  private _countdownInterval: number;\n  private destroy$ = new Subject<void>();\n  private readonly MINIMUM_INTERVAL = 5_000;\n  private readonly ONE_SECOND = 1000; // One second in milliseconds\n  private start$ = new Subject();\n  private countdownSubscription: Subscription;\n\n  ngOnInit(): void {\n    this.secondsUntilRefresh$ = new BehaviorSubject(`${Math.floor(this.countdownInterval / 1000)}`);\n    this.start$\n      .pipe(debounceTime(100), takeUntil(this.destroy$))\n      .subscribe(() => this.initializeCountdownInterval());\n  }\n\n  ngOnDestroy(): void {\n    this.destroy$.next();\n    this.destroy$.complete();\n  }\n\n  start(): void {\n    this.countdownSubscription?.unsubscribe();\n    this.start$.next(null);\n  }\n\n  stop(stopAtZero = false): void {\n    this.countdownSubscription?.unsubscribe();\n    this.runSpinner$.next(false);\n    if (stopAtZero) {\n      this.secondsUntilRefresh$.next('0');\n    } else {\n      this.secondsUntilRefresh$.next(`${Math.floor(this.countdownInterval / 1000)}`);\n    }\n  }\n\n  reset(): void {\n    this.stop();\n    this.start();\n  }\n\n  /**\n   * Initializes the countdown timer.\n   * Kicks off the timer logic and activates any associated UI elements.\n   */\n  private initializeCountdownInterval(): void {\n    const timerStart$ = new Subject<void>();\n    const documentHiddenEvent$ = this.createDocumentHiddenEventStream();\n\n    const interval$ = this.createIntervalStream(timerStart$, documentHiddenEvent$);\n\n    this.subscribeToInterval(interval$);\n\n    timerStart$.next();\n    this.runSpinner$.next(true);\n  }\n\n  /**\n   * Creates an Observable stream that emits events when the document's visibility changes.\n   * @returns An Observable emitting `null` whenever the visibility of the document changes.\n   */\n  private createDocumentHiddenEventStream(): Observable<null> {\n    return fromEvent<null>(document, 'visibilitychange').pipe(\n      mapTo(null),\n      takeUntil(this.destroy$)\n    );\n  }\n\n  /**\n   * Creates the main interval Observable for the countdown timer.\n   * @param timerStart$ - A Subject to signal the start of the timer.\n   * @param documentHiddenEvent$ - An Observable for document visibility changes.\n   * @returns An Observable that orchestrates the timer logic.\n   */\n  private createIntervalStream(\n    timerStart$: Subject<void>,\n    documentHiddenEvent$: Observable<null>\n  ): Observable<null> {\n    return timerStart$.pipe(\n      switchMap(() => this.createTimer()),\n      switchMap(() => (document.hidden ? documentHiddenEvent$ : of(null))),\n      takeUntil(this.destroy$)\n    );\n  }\n\n  /**\n   * Creates a timer Observable that emits every second.\n   * @returns An Observable that emits a number every second, starting from 0.\n   */\n  private createTimer(): Observable<number> {\n    return timer(0, this.ONE_SECOND).pipe(\n      tap(value => this.updateRemainingTime(value)),\n      filter(value => value >= this.countdownInterval / this.ONE_SECOND),\n      first()\n    );\n  }\n\n  /**\n   * Updates the remaining time in the countdown.\n   * @param value - The current timer value in seconds.\n   */\n  private updateRemainingTime(value: number): void {\n    const remainingSeconds = Math.floor(this.countdownInterval / this.ONE_SECOND - value);\n    this.secondsUntilRefresh$.next(`${remainingSeconds}`);\n  }\n\n  /**\n   * Subscribes to the interval Observable and sets up the event handlers for the countdown.\n   * @param interval$ - The countdown interval Observable to subscribe to.\n   */\n  private subscribeToInterval(interval$: Observable<null>): void {\n    this.countdownSubscription = interval$.pipe(takeUntil(this.destroy$)).subscribe(() => {\n      this.countdownEnded.emit();\n    });\n  }\n}\n","<div\n  class=\"time-elapsed\"\n  [style.--timescope]=\"countdownInterval + 'ms'\"\n  [title]=\"'{{ secondsLeft }} s / {{ interval }} s' | translate: { secondsLeft: secondsUntilRefresh$ | async, interval: countdownInterval / 1000 }\"\n>\n  <svg\n    [ngClass]=\"{ 'time-on': runSpinner$ | async }\"\n    viewBox=\"0 0 40 40\"\n    fill=\"none\"\n    xmlns=\"http://www.w3.org/2000/svg\"\n  >\n    <circle\n      cx=\"20\"\n      cy=\"20\"\n      r=\"15.8\"\n      stroke=\"var(--c8y-brand-primary)\"\n      stroke-width=\"6\"\n    />\n  </svg>\n\n  <span>{{ secondsUntilRefresh$ | async }}</span>\n</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"countdown-interval.component.js","sourceRoot":"","sources":["../../../../core/countdown-interval/countdown-interval.component.ts","../../../../core/countdown-interval/countdown-interval.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnDestroy, OnInit, Output } from '@angular/core';\nimport { BehaviorSubject, fromEvent, Observable, of, Subject, Subscription, timer } from 'rxjs';\nimport { debounceTime, filter, first, mapTo, switchMap, takeUntil, tap } from 'rxjs/operators';\n\n/**\n * Component to count down specific time interval, then emit when countdown ends.\n * Next countdown is started right after previous one.\n */\n@Component({\n  selector: 'c8y-countdown-interval',\n  templateUrl: './countdown-interval.component.html'\n})\nexport class CountdownIntervalComponent implements OnInit, OnDestroy {\n  /**\n   * Time in milliseconds to count down from.\n   */\n  @Input() set countdownInterval(value: number) {\n    this._countdownInterval = Math.max(value, this.MINIMUM_INTERVAL);\n  }\n\n  get countdownInterval(): number {\n    return this._countdownInterval || this.MINIMUM_INTERVAL;\n  }\n  /**\n   * Emits when countdown ends.\n   */\n  @Output() countdownEnded = new EventEmitter<void>();\n\n  runSpinner$ = new BehaviorSubject(false);\n  secondsUntilRefresh$: BehaviorSubject<string>;\n\n  private _countdownInterval: number;\n  private destroy$ = new Subject<void>();\n  private readonly MINIMUM_INTERVAL = 5_000;\n  private readonly ONE_SECOND = 1000; // One second in milliseconds\n  private start$ = new Subject();\n  private countdownSubscription: Subscription;\n\n  ngOnInit(): void {\n    this.secondsUntilRefresh$ = new BehaviorSubject(`${Math.floor(this.countdownInterval / 1000)}`);\n    this.start$\n      .pipe(debounceTime(100), takeUntil(this.destroy$))\n      .subscribe(() => this.initializeCountdownInterval());\n  }\n\n  ngOnDestroy(): void {\n    this.destroy$.next();\n    this.destroy$.complete();\n  }\n\n  start(): void {\n    this.countdownSubscription?.unsubscribe();\n    this.start$.next(null);\n  }\n\n  stop(stopAtZero = false): void {\n    this.countdownSubscription?.unsubscribe();\n    this.runSpinner$.next(false);\n    if (stopAtZero) {\n      this.secondsUntilRefresh$.next('0');\n    } else {\n      this.secondsUntilRefresh$.next(`${Math.floor(this.countdownInterval / 1000)}`);\n    }\n  }\n\n  reset(): void {\n    this.stop();\n    this.start();\n  }\n\n  /**\n   * Initializes the countdown timer.\n   * Kicks off the timer logic and activates any associated UI elements.\n   */\n  private initializeCountdownInterval(): void {\n    const timerStart$ = new Subject<void>();\n    const documentHiddenEvent$ = this.createDocumentHiddenEventStream();\n\n    const interval$ = this.createIntervalStream(timerStart$, documentHiddenEvent$);\n\n    this.subscribeToInterval(interval$);\n\n    timerStart$.next();\n    this.runSpinner$.next(true);\n  }\n\n  /**\n   * Creates an Observable stream that emits events when the document's visibility changes.\n   * @returns An Observable emitting `null` whenever the visibility of the document changes.\n   */\n  private createDocumentHiddenEventStream(): Observable<null> {\n    return fromEvent<null>(document, 'visibilitychange').pipe(\n      mapTo(null),\n      takeUntil(this.destroy$)\n    );\n  }\n\n  /**\n   * Creates the main interval Observable for the countdown timer.\n   * @param timerStart$ - A Subject to signal the start of the timer.\n   * @param documentHiddenEvent$ - An Observable for document visibility changes.\n   * @returns An Observable that orchestrates the timer logic.\n   */\n  private createIntervalStream(\n    timerStart$: Subject<void>,\n    documentHiddenEvent$: Observable<null>\n  ): Observable<null> {\n    return timerStart$.pipe(\n      switchMap(() => this.createTimer()),\n      switchMap(() => (document.hidden ? documentHiddenEvent$ : of(null))),\n      takeUntil(this.destroy$)\n    );\n  }\n\n  /**\n   * Creates a timer Observable that emits every second.\n   * @returns An Observable that emits a number every second, starting from 0.\n   */\n  private createTimer(): Observable<number> {\n    return timer(0, this.ONE_SECOND).pipe(\n      tap(value => this.updateRemainingTime(value)),\n      filter(value => value >= this.countdownInterval / this.ONE_SECOND),\n      first()\n    );\n  }\n\n  /**\n   * Updates the remaining time in the countdown.\n   * @param value - The current timer value in seconds.\n   */\n  private updateRemainingTime(value: number): void {\n    const remainingSeconds = Math.floor(this.countdownInterval / this.ONE_SECOND - value);\n    this.secondsUntilRefresh$.next(`${remainingSeconds}`);\n  }\n\n  /**\n   * Subscribes to the interval Observable and sets up the event handlers for the countdown.\n   * @param interval$ - The countdown interval Observable to subscribe to.\n   */\n  private subscribeToInterval(interval$: Observable<null>): void {\n    this.countdownSubscription = interval$.pipe(takeUntil(this.destroy$)).subscribe(() => {\n      this.countdownEnded.emit();\n    });\n  }\n}\n","<div\n  class=\"time-elapsed\"\n  data-cy=\"c8y-countdown-interval--countdown\"\n  [style.--timescope]=\"countdownInterval + 'ms'\"\n  [title]=\"'{{ secondsLeft }} s / {{ interval }} s' | translate: { secondsLeft: secondsUntilRefresh$ | async, interval: countdownInterval / 1000 }\"\n>\n  <svg\n    [ngClass]=\"{ 'time-on': runSpinner$ | async }\"\n    viewBox=\"0 0 40 40\"\n    fill=\"none\"\n    xmlns=\"http://www.w3.org/2000/svg\"\n  >\n    <circle\n      cx=\"20\"\n      cy=\"20\"\n      r=\"15.8\"\n      stroke=\"var(--c8y-brand-primary)\"\n      stroke-width=\"6\"\n    />\n  </svg>\n\n  <span>{{ secondsUntilRefresh$ | async }}</span>\n</div>\n"]}

package/esm2022/core/dashboard/dashboard-child.component.mjs

@@ -13,8 +13,9 @@ import * as i4 from "@angular/common";
 import * as i5 from "@angular/cdk/drag-drop";
 import * as i6 from "ngx-bootstrap/dropdown";
 import * as i7 from "ngx-bootstrap/tooltip";
-import * as i8 from "./wiget-time-context/widget-time-context-icon-bar/widget-time-context-icon-bar.component";
-import * as i9 from "../i18n/c8y-translate.pipe";
+import * as i8 from "./widget-auto-refresh-context/widget-auto-refresh-context-icon-bar.component";
+import * as i9 from "./wiget-time-context/widget-time-context-icon-bar/widget-time-context-icon-bar.component";
+import * as i10 from "@ngx-translate/core";
 /**
  * A dashboard child allows to position elements
  * correctly on a grid.
@@ -250,13 +251,13 @@ export class DashboardChildComponent {
         return false;
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DashboardChildComponent, deps: [{ token: i1.DashboardComponent }, { token: i2.DomSanitizer }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: DashboardChildComponent, selector: "c8y-dashboard-child", inputs: { x: "x", y: "y", width: "width", height: "height", data: "data", margin: "margin", useIntersection: "useIntersection", isFrozen: "isFrozen", canToggleFullscreen: "canToggleFullscreen", editMode: "editMode", class: "class" }, outputs: { changeStart: "changeStart", changeEnd: "changeEnd", toggleFullscreen: "toggleFullscreen" }, host: { properties: { "class.fullscreen": "this.fullscreen", "attr.style": "this.inlineStyle" }, classAttribute: "dashboard-grid-child" }, queries: [{ propertyName: "templateActions", predicate: DashboardChildActionComponent }], usesOnChanges: true, ngImport: i0, template: "<div cdkDropList>\n  <div\n    class=\"card-placeholder\"\n    *ngIf=\"isResize\"\n  ></div>\n  <div\n    [ngStyle]=\"{ width: _pxWidth, height: _pxHeight }\"\n    [ngClass]=\"klasses\"\n    cdkDrag\n    (cdkDragStarted)=\"dragStarted($event)\"\n    (cdkDragEnded)=\"reset($event)\"\n    [cdkDragDisabled]=\"(isOneColumnView$ | async) || !editMode || fullscreen\"\n  >\n    <div\n      class=\"card-header-actions card-header-grid\"\n      [ngClass]=\"{\n        'drag-handle': editMode && !fullscreen,\n        draggableCursor: editMode && !fullscreen\n      }\"\n      cdkDragHandle\n    >\n      <ng-content select=\"c8y-dashboard-child-title\"></ng-content>\n      <div\n        class=\"header-actions d-flex a-i-center\"\n        *ngIf=\"actions.length > 0\"\n      >\n        <c8y-widget-time-context-icon-bar\n          *ngIf=\"data?.config?.displaySettings && data?.config?.widgetInstanceGlobalTimeContext\"\n          [config]=\"data.config\"\n        ></c8y-widget-time-context-icon-bar>\n\n        <button\n          class=\"btn btn-icon\"\n          [tooltip]=\"fullscreen ? ('Exit full screen' | translate) : ('Full screen' | translate)\"\n          delay=\"500\"\n          container=\"body\"\n          [attr.aria-label]=\"'Full screen' | translate\"\n          [disabled]=\"editMode || !canToggleFullscreen\"\n          (click)=\"toggleFullscreen.next()\"\n          data-cy=\"c8y-dashboard-child--settings-fullscreen\"\n        >\n          <i [c8yIcon]=\"fullscreen ? 'compress' : 'expand'\"></i>\n        </button>\n        <div\n          class=\"optionsBtn dropdown\"\n          placement=\"bottom right\"\n          dropdown\n          [container]=\"'body'\"\n        >\n          <button\n            class=\"btn btn-icon c8y-dropdown\"\n            title=\"{{ 'Settings' | translate }}\"\n            aria-haspopup=\"true\"\n            *ngIf=\"editMode\"\n            data-cy=\"c8y-dashboard-child--settings\"\n            (click)=\"(false)\"\n            dropdownToggle\n          >\n            <i [c8yIcon]=\"'cog'\"></i>\n          </button>\n          <button\n            class=\"btn btn-icon\"\n            [attr.aria-label]=\"'Click &quot;Edit widgets&quot; to unlock' | translate\"\n            tooltip=\"{{ 'Click &quot;Edit widgets&quot; to unlock' | translate }}\"\n            container=\"body\"\n            *ngIf=\"!editMode\"\n            (click)=\"(false)\"\n            data-cy=\"c8y-dashboard-child--settings-locked\"\n          >\n            <i [c8yIcon]=\"'lock'\"></i>\n          </button>\n          <ul\n            class=\"dropdown-menu dropdown-menu-right\"\n            data-cy=\"c8y-dashboard-child--actions-dropdown\"\n            style=\"right: -1px\"\n            *dropdownMenu\n          >\n            <ng-container *ngFor=\"let action of actions\">\n              <ng-container *ngTemplateOutlet=\"action.template\"></ng-container>\n            </ng-container>\n          </ul>\n        </div>\n      </div>\n    </div>\n    <div class=\"card-inner-scroll\">\n      <ng-content></ng-content>\n    </div>\n    <div\n      class=\"resize-handle hidden-xs\"\n      *ngIf=\"editMode && !isDragging && !fullscreen\"\n      cdkDrag\n      [cdkDragDisabled]=\"!editMode || fullscreen\"\n      (cdkDragStarted)=\"resizeStarted($event)\"\n      (cdkDragEnded)=\"reset($event)\"\n    ></div>\n    <div\n      class=\"resize-icon hidden-xs\"\n      *ngIf=\"editMode && !isDragging && !fullscreen\"\n    ></div>\n\n    <div\n      class=\"card-placeholder\"\n      *cdkDragPlaceholder\n    ></div>\n  </div>\n</div>\n", dependencies: [{ kind: "directive", type: i3.IconDirective, selector: "[c8yIcon]", inputs: ["c8yIcon"] }, { kind: "directive", type: i4.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i4.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i4.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "directive", type: i5.CdkDropList, selector: "[cdkDropList], cdk-drop-list", inputs: ["cdkDropListConnectedTo", "cdkDropListData", "cdkDropListOrientation", "id", "cdkDropListLockAxis", "cdkDropListDisabled", "cdkDropListSortingDisabled", "cdkDropListEnterPredicate", "cdkDropListSortPredicate", "cdkDropListAutoScrollDisabled", "cdkDropListAutoScrollStep", "cdkDropListElementContainer"], outputs: ["cdkDropListDropped", "cdkDropListEntered", "cdkDropListExited", "cdkDropListSorted"], exportAs: ["cdkDropList"] }, { kind: "directive", type: i5.CdkDrag, selector: "[cdkDrag]", inputs: ["cdkDragData", "cdkDragLockAxis", "cdkDragRootElement", "cdkDragBoundary", "cdkDragStartDelay", "cdkDragFreeDragPosition", "cdkDragDisabled", "cdkDragConstrainPosition", "cdkDragPreviewClass", "cdkDragPreviewContainer", "cdkDragScale"], outputs: ["cdkDragStarted", "cdkDragReleased", "cdkDragEnded", "cdkDragEntered", "cdkDragExited", "cdkDragDropped", "cdkDragMoved"], exportAs: ["cdkDrag"] }, { kind: "directive", type: i5.CdkDragHandle, selector: "[cdkDragHandle]", inputs: ["cdkDragHandleDisabled"] }, { kind: "directive", type: i5.CdkDragPlaceholder, selector: "ng-template[cdkDragPlaceholder]", inputs: ["data"] }, { kind: "directive", type: i6.BsDropdownMenuDirective, selector: "[bsDropdownMenu],[dropdownMenu]", exportAs: ["bs-dropdown-menu"] }, { kind: "directive", type: i6.BsDropdownToggleDirective, selector: "[bsDropdownToggle],[dropdownToggle]", exportAs: ["bs-dropdown-toggle"] }, { kind: "directive", type: i6.BsDropdownDirective, selector: "[bsDropdown], [dropdown]", inputs: ["placement", "triggers", "container", "dropup", "autoClose", "isAnimated", "insideClick", "isDisabled", "isOpen"], outputs: ["isOpenChange", "onShown", "onHidden"], exportAs: ["bs-dropdown"] }, { kind: "directive", type: i7.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: i8.WidgetTimeContextIconBar, selector: "c8y-widget-time-context-icon-bar", inputs: ["config"] }, { kind: "pipe", type: i9.C8yTranslatePipe, name: "translate" }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }] }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: DashboardChildComponent, selector: "c8y-dashboard-child", inputs: { x: "x", y: "y", width: "width", height: "height", data: "data", margin: "margin", useIntersection: "useIntersection", isFrozen: "isFrozen", canToggleFullscreen: "canToggleFullscreen", editMode: "editMode", class: "class" }, outputs: { changeStart: "changeStart", changeEnd: "changeEnd", toggleFullscreen: "toggleFullscreen" }, host: { properties: { "class.fullscreen": "this.fullscreen", "attr.style": "this.inlineStyle" }, classAttribute: "dashboard-grid-child" }, queries: [{ propertyName: "templateActions", predicate: DashboardChildActionComponent }], usesOnChanges: true, ngImport: i0, template: "<div cdkDropList>\n  <div\n    class=\"card-placeholder\"\n    *ngIf=\"isResize\"\n  ></div>\n  <div\n    [ngStyle]=\"{ width: _pxWidth, height: _pxHeight }\"\n    [ngClass]=\"klasses\"\n    cdkDrag\n    (cdkDragStarted)=\"dragStarted($event)\"\n    (cdkDragEnded)=\"reset($event)\"\n    [cdkDragDisabled]=\"(isOneColumnView$ | async) || !editMode || fullscreen\"\n  >\n    <div\n      class=\"card-header-actions card-header-grid\"\n      [ngClass]=\"{\n        'drag-handle': editMode && !fullscreen,\n        draggableCursor: editMode && !fullscreen\n      }\"\n      cdkDragHandle\n    >\n      <ng-content select=\"c8y-dashboard-child-title\"></ng-content>\n      <div\n        class=\"header-actions d-flex a-i-center\"\n        *ngIf=\"actions.length > 0\"\n      >\n        <c8y-widget-time-context-icon-bar\n          *ngIf=\"data?.config?.displaySettings && data?.config?.widgetInstanceGlobalTimeContext\"\n          [config]=\"data.config\"\n        ></c8y-widget-time-context-icon-bar>\n        <c8y-widget-auto-refresh-context-icon-bar\n          *ngIf=\"\n            data?.config?.widgetInstanceGlobalAutoRefreshContext &&\n            data?.config?.displaySettings.globalAutoRefreshContext\n          \"\n        ></c8y-widget-auto-refresh-context-icon-bar>\n\n        <button\n          class=\"btn btn-icon\"\n          [attr.aria-label]=\"'Full screen' | translate\"\n          [tooltip]=\"fullscreen ? ('Exit full screen' | translate) : ('Full screen' | translate)\"\n          delay=\"500\"\n          container=\"body\"\n          [disabled]=\"editMode || !canToggleFullscreen\"\n          (click)=\"toggleFullscreen.next()\"\n          data-cy=\"c8y-dashboard-child--settings-fullscreen\"\n        >\n          <i [c8yIcon]=\"fullscreen ? 'compress' : 'expand'\"></i>\n        </button>\n        <div\n          class=\"optionsBtn dropdown\"\n          placement=\"bottom right\"\n          dropdown\n          [container]=\"'body'\"\n        >\n          <button\n            class=\"btn btn-icon c8y-dropdown\"\n            title=\"{{ 'Settings' | translate }}\"\n            aria-haspopup=\"true\"\n            *ngIf=\"editMode\"\n            data-cy=\"c8y-dashboard-child--settings\"\n            (click)=\"(false)\"\n            dropdownToggle\n          >\n            <i [c8yIcon]=\"'cog'\"></i>\n          </button>\n          <button\n            class=\"btn btn-icon\"\n            [attr.aria-label]=\"'Click &quot;Edit widgets&quot; to unlock' | translate\"\n            tooltip=\"{{ 'Click &quot;Edit widgets&quot; to unlock' | translate }}\"\n            container=\"body\"\n            *ngIf=\"!editMode\"\n            (click)=\"(false)\"\n            data-cy=\"c8y-dashboard-child--settings-locked\"\n          >\n            <i [c8yIcon]=\"'lock'\"></i>\n          </button>\n          <ul\n            class=\"dropdown-menu dropdown-menu-right\"\n            data-cy=\"c8y-dashboard-child--actions-dropdown\"\n            style=\"right: -1px\"\n            *dropdownMenu\n          >\n            <ng-container *ngFor=\"let action of actions\">\n              <ng-container *ngTemplateOutlet=\"action.template\"></ng-container>\n            </ng-container>\n          </ul>\n        </div>\n      </div>\n    </div>\n    <div class=\"card-inner-scroll\">\n      <ng-content></ng-content>\n    </div>\n    <div\n      class=\"resize-handle hidden-xs\"\n      *ngIf=\"editMode && !isDragging && !fullscreen\"\n      cdkDrag\n      [cdkDragDisabled]=\"!editMode || fullscreen\"\n      (cdkDragStarted)=\"resizeStarted($event)\"\n      (cdkDragEnded)=\"reset($event)\"\n    ></div>\n    <div\n      class=\"resize-icon hidden-xs\"\n      *ngIf=\"editMode && !isDragging && !fullscreen\"\n    ></div>\n\n    <div\n      class=\"card-placeholder\"\n      *cdkDragPlaceholder\n    ></div>\n  </div>\n</div>\n", dependencies: [{ kind: "directive", type: i3.IconDirective, selector: "[c8yIcon]", inputs: ["c8yIcon"] }, { kind: "directive", type: i4.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i4.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i4.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "directive", type: i5.CdkDropList, selector: "[cdkDropList], cdk-drop-list", inputs: ["cdkDropListConnectedTo", "cdkDropListData", "cdkDropListOrientation", "id", "cdkDropListLockAxis", "cdkDropListDisabled", "cdkDropListSortingDisabled", "cdkDropListEnterPredicate", "cdkDropListSortPredicate", "cdkDropListAutoScrollDisabled", "cdkDropListAutoScrollStep", "cdkDropListElementContainer"], outputs: ["cdkDropListDropped", "cdkDropListEntered", "cdkDropListExited", "cdkDropListSorted"], exportAs: ["cdkDropList"] }, { kind: "directive", type: i5.CdkDrag, selector: "[cdkDrag]", inputs: ["cdkDragData", "cdkDragLockAxis", "cdkDragRootElement", "cdkDragBoundary", "cdkDragStartDelay", "cdkDragFreeDragPosition", "cdkDragDisabled", "cdkDragConstrainPosition", "cdkDragPreviewClass", "cdkDragPreviewContainer", "cdkDragScale"], outputs: ["cdkDragStarted", "cdkDragReleased", "cdkDragEnded", "cdkDragEntered", "cdkDragExited", "cdkDragDropped", "cdkDragMoved"], exportAs: ["cdkDrag"] }, { kind: "directive", type: i5.CdkDragHandle, selector: "[cdkDragHandle]", inputs: ["cdkDragHandleDisabled"] }, { kind: "directive", type: i5.CdkDragPlaceholder, selector: "ng-template[cdkDragPlaceholder]", inputs: ["data"] }, { kind: "directive", type: i6.BsDropdownMenuDirective, selector: "[bsDropdownMenu],[dropdownMenu]", exportAs: ["bs-dropdown-menu"] }, { kind: "directive", type: i6.BsDropdownToggleDirective, selector: "[bsDropdownToggle],[dropdownToggle]", exportAs: ["bs-dropdown-toggle"] }, { kind: "directive", type: i6.BsDropdownDirective, selector: "[bsDropdown], [dropdown]", inputs: ["placement", "triggers", "container", "dropup", "autoClose", "isAnimated", "insideClick", "isDisabled", "isOpen"], outputs: ["isOpenChange", "onShown", "onHidden"], exportAs: ["bs-dropdown"] }, { kind: "directive", type: i7.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: i8.WidgetAutoRefreshContextIconBarComponent, selector: "c8y-widget-auto-refresh-context-icon-bar" }, { kind: "component", type: i9.WidgetTimeContextIconBar, selector: "c8y-widget-time-context-icon-bar", inputs: ["config"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }, { kind: "pipe", type: i10.TranslatePipe, name: "translate" }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DashboardChildComponent, decorators: [{
             type: Component,
             args: [{ selector: 'c8y-dashboard-child', host: {
                         class: 'dashboard-grid-child'
-                    }, template: "<div cdkDropList>\n  <div\n    class=\"card-placeholder\"\n    *ngIf=\"isResize\"\n  ></div>\n  <div\n    [ngStyle]=\"{ width: _pxWidth, height: _pxHeight }\"\n    [ngClass]=\"klasses\"\n    cdkDrag\n    (cdkDragStarted)=\"dragStarted($event)\"\n    (cdkDragEnded)=\"reset($event)\"\n    [cdkDragDisabled]=\"(isOneColumnView$ | async) || !editMode || fullscreen\"\n  >\n    <div\n      class=\"card-header-actions card-header-grid\"\n      [ngClass]=\"{\n        'drag-handle': editMode && !fullscreen,\n        draggableCursor: editMode && !fullscreen\n      }\"\n      cdkDragHandle\n    >\n      <ng-content select=\"c8y-dashboard-child-title\"></ng-content>\n      <div\n        class=\"header-actions d-flex a-i-center\"\n        *ngIf=\"actions.length > 0\"\n      >\n        <c8y-widget-time-context-icon-bar\n          *ngIf=\"data?.config?.displaySettings && data?.config?.widgetInstanceGlobalTimeContext\"\n          [config]=\"data.config\"\n        ></c8y-widget-time-context-icon-bar>\n\n        <button\n          class=\"btn btn-icon\"\n          [tooltip]=\"fullscreen ? ('Exit full screen' | translate) : ('Full screen' | translate)\"\n          delay=\"500\"\n          container=\"body\"\n          [attr.aria-label]=\"'Full screen' | translate\"\n          [disabled]=\"editMode || !canToggleFullscreen\"\n          (click)=\"toggleFullscreen.next()\"\n          data-cy=\"c8y-dashboard-child--settings-fullscreen\"\n        >\n          <i [c8yIcon]=\"fullscreen ? 'compress' : 'expand'\"></i>\n        </button>\n        <div\n          class=\"optionsBtn dropdown\"\n          placement=\"bottom right\"\n          dropdown\n          [container]=\"'body'\"\n        >\n          <button\n            class=\"btn btn-icon c8y-dropdown\"\n            title=\"{{ 'Settings' | translate }}\"\n            aria-haspopup=\"true\"\n            *ngIf=\"editMode\"\n            data-cy=\"c8y-dashboard-child--settings\"\n            (click)=\"(false)\"\n            dropdownToggle\n          >\n            <i [c8yIcon]=\"'cog'\"></i>\n          </button>\n          <button\n            class=\"btn btn-icon\"\n            [attr.aria-label]=\"'Click &quot;Edit widgets&quot; to unlock' | translate\"\n            tooltip=\"{{ 'Click &quot;Edit widgets&quot; to unlock' | translate }}\"\n            container=\"body\"\n            *ngIf=\"!editMode\"\n            (click)=\"(false)\"\n            data-cy=\"c8y-dashboard-child--settings-locked\"\n          >\n            <i [c8yIcon]=\"'lock'\"></i>\n          </button>\n          <ul\n            class=\"dropdown-menu dropdown-menu-right\"\n            data-cy=\"c8y-dashboard-child--actions-dropdown\"\n            style=\"right: -1px\"\n            *dropdownMenu\n          >\n            <ng-container *ngFor=\"let action of actions\">\n              <ng-container *ngTemplateOutlet=\"action.template\"></ng-container>\n            </ng-container>\n          </ul>\n        </div>\n      </div>\n    </div>\n    <div class=\"card-inner-scroll\">\n      <ng-content></ng-content>\n    </div>\n    <div\n      class=\"resize-handle hidden-xs\"\n      *ngIf=\"editMode && !isDragging && !fullscreen\"\n      cdkDrag\n      [cdkDragDisabled]=\"!editMode || fullscreen\"\n      (cdkDragStarted)=\"resizeStarted($event)\"\n      (cdkDragEnded)=\"reset($event)\"\n    ></div>\n    <div\n      class=\"resize-icon hidden-xs\"\n      *ngIf=\"editMode && !isDragging && !fullscreen\"\n    ></div>\n\n    <div\n      class=\"card-placeholder\"\n      *cdkDragPlaceholder\n    ></div>\n  </div>\n</div>\n" }]
+                    }, template: "<div cdkDropList>\n  <div\n    class=\"card-placeholder\"\n    *ngIf=\"isResize\"\n  ></div>\n  <div\n    [ngStyle]=\"{ width: _pxWidth, height: _pxHeight }\"\n    [ngClass]=\"klasses\"\n    cdkDrag\n    (cdkDragStarted)=\"dragStarted($event)\"\n    (cdkDragEnded)=\"reset($event)\"\n    [cdkDragDisabled]=\"(isOneColumnView$ | async) || !editMode || fullscreen\"\n  >\n    <div\n      class=\"card-header-actions card-header-grid\"\n      [ngClass]=\"{\n        'drag-handle': editMode && !fullscreen,\n        draggableCursor: editMode && !fullscreen\n      }\"\n      cdkDragHandle\n    >\n      <ng-content select=\"c8y-dashboard-child-title\"></ng-content>\n      <div\n        class=\"header-actions d-flex a-i-center\"\n        *ngIf=\"actions.length > 0\"\n      >\n        <c8y-widget-time-context-icon-bar\n          *ngIf=\"data?.config?.displaySettings && data?.config?.widgetInstanceGlobalTimeContext\"\n          [config]=\"data.config\"\n        ></c8y-widget-time-context-icon-bar>\n        <c8y-widget-auto-refresh-context-icon-bar\n          *ngIf=\"\n            data?.config?.widgetInstanceGlobalAutoRefreshContext &&\n            data?.config?.displaySettings.globalAutoRefreshContext\n          \"\n        ></c8y-widget-auto-refresh-context-icon-bar>\n\n        <button\n          class=\"btn btn-icon\"\n          [attr.aria-label]=\"'Full screen' | translate\"\n          [tooltip]=\"fullscreen ? ('Exit full screen' | translate) : ('Full screen' | translate)\"\n          delay=\"500\"\n          container=\"body\"\n          [disabled]=\"editMode || !canToggleFullscreen\"\n          (click)=\"toggleFullscreen.next()\"\n          data-cy=\"c8y-dashboard-child--settings-fullscreen\"\n        >\n          <i [c8yIcon]=\"fullscreen ? 'compress' : 'expand'\"></i>\n        </button>\n        <div\n          class=\"optionsBtn dropdown\"\n          placement=\"bottom right\"\n          dropdown\n          [container]=\"'body'\"\n        >\n          <button\n            class=\"btn btn-icon c8y-dropdown\"\n            title=\"{{ 'Settings' | translate }}\"\n            aria-haspopup=\"true\"\n            *ngIf=\"editMode\"\n            data-cy=\"c8y-dashboard-child--settings\"\n            (click)=\"(false)\"\n            dropdownToggle\n          >\n            <i [c8yIcon]=\"'cog'\"></i>\n          </button>\n          <button\n            class=\"btn btn-icon\"\n            [attr.aria-label]=\"'Click &quot;Edit widgets&quot; to unlock' | translate\"\n            tooltip=\"{{ 'Click &quot;Edit widgets&quot; to unlock' | translate }}\"\n            container=\"body\"\n            *ngIf=\"!editMode\"\n            (click)=\"(false)\"\n            data-cy=\"c8y-dashboard-child--settings-locked\"\n          >\n            <i [c8yIcon]=\"'lock'\"></i>\n          </button>\n          <ul\n            class=\"dropdown-menu dropdown-menu-right\"\n            data-cy=\"c8y-dashboard-child--actions-dropdown\"\n            style=\"right: -1px\"\n            *dropdownMenu\n          >\n            <ng-container *ngFor=\"let action of actions\">\n              <ng-container *ngTemplateOutlet=\"action.template\"></ng-container>\n            </ng-container>\n          </ul>\n        </div>\n      </div>\n    </div>\n    <div class=\"card-inner-scroll\">\n      <ng-content></ng-content>\n    </div>\n    <div\n      class=\"resize-handle hidden-xs\"\n      *ngIf=\"editMode && !isDragging && !fullscreen\"\n      cdkDrag\n      [cdkDragDisabled]=\"!editMode || fullscreen\"\n      (cdkDragStarted)=\"resizeStarted($event)\"\n      (cdkDragEnded)=\"reset($event)\"\n    ></div>\n    <div\n      class=\"resize-icon hidden-xs\"\n      *ngIf=\"editMode && !isDragging && !fullscreen\"\n    ></div>\n\n    <div\n      class=\"card-placeholder\"\n      *cdkDragPlaceholder\n    ></div>\n  </div>\n</div>\n" }]
         }], ctorParameters: () => [{ type: i1.DashboardComponent }, { type: i2.DomSanitizer }, { type: i0.ElementRef }], propDecorators: { templateActions: [{
                 type: ContentChildren,
                 args: [DashboardChildActionComponent]
@@ -295,4 +296,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImpor
                 type: HostBinding,
                 args: ['attr.style']
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard-child.component.js","sourceRoot":"","sources":["../../../../core/dashboard/dashboard-child.component.ts","../../../../core/dashboard/dashboard-child.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CdkDrag, CdkDragEnd, CdkDragStart } from '@angular/cdk/drag-drop';\nimport {\n  Component,\n  ContentChildren,\n  ElementRef,\n  EventEmitter,\n  HostBinding,\n  Input,\n  Output\n} from '@angular/core';\nimport { DomSanitizer } from '@angular/platform-browser';\nimport { Observable, Subscription, fromEvent } from 'rxjs';\nimport { DashboardChildActionComponent } from './dashboard-child-action.component';\nimport { DashboardChildChange } from './dashboard-child-change';\nimport { DashboardComponent } from './dashboard.component';\nimport { DashboardChildDimension, Widget } from './dashboard.model';\nimport { debounceTime, map, startWith } from 'rxjs/operators';\n\n/**\n * A dashboard child allows to position elements\n * correctly on a grid.\n *\n * By setting `c8y-dashboard-child-actions` and\n * `c8y-dashboard-child-title` on the element you can add\n * custom actions or a custom title to the current child.\n *\n * By adding the correct branded classes, you can define\n * the look and feel of the child. By default it is displayed\n * as a card.\n *\n * ```html\n *   <c8y-dashboard-child\n *     #cpWidget3\n *     [x]=\"0\"\n *     [y]=\"3\"\n *     [width]=\"4\"\n *     [height]=\"4\"\n *     [class]=\"'card-dashboard panel-content-transparent'\"\n *   >\n *     <c8y-dashboard-child-title *ngIf=\"showTitle\">\n *       <span>Transparent!</span>\n *     </c8y-dashboard-child-title>\n *     <c8y-dashboard-child-action>\n *       <a href=\"\" (click)=\"showTitle = !showTitle; (false)\">\n *         <i [c8yIcon]=\"'heading'\"></i> Hide/show title\n *       </a>\n *     </c8y-dashboard-child-action>\n *     x: {{ cpWidget3.x }}<br />\n *     y: {{ cpWidget3.y }}<br />\n *     width: {{ cpWidget3.width }}<br />\n *     height: {{ cpWidget3.height }}<br />\n *   </c8y-dashboard-child>\n * ```\n */\n@Component({\n  selector: 'c8y-dashboard-child',\n  templateUrl: './dashboard-child.component.html',\n  host: {\n    class: 'dashboard-grid-child'\n  }\n})\nexport class DashboardChildComponent implements DashboardChildDimension {\n  actions: DashboardChildActionComponent[] = [];\n  @ContentChildren(DashboardChildActionComponent) set templateActions(\n    actions: DashboardChildActionComponent[]\n  ) {\n    this.addActions(actions, true);\n  }\n  dragSource: CdkDrag;\n  isResize = false;\n  isDragging = false;\n  klasses = {};\n\n  _pxWidth = '100%';\n  _pxHeight = '100%';\n\n  @HostBinding('class.fullscreen')\n  fullscreen = false;\n  readonly MD_BOOTSTRAP_BREAKPOINT_READONLY_CLASS_PROPERTY = 768;\n\n  /**\n   * The x position of the child.\n   */\n  @Input() x;\n\n  /**\n   * The y position of the child.\n   */\n  @Input() y;\n\n  /**\n   * The width of the component in grid-columns.\n   */\n  @Input() width = 1;\n\n  /**\n   * The height of the component in grid-rows.\n   */\n  @Input() height = 1;\n\n  /**\n   * The data object can be used as a dataTransfer object for events of the child.\n   */\n  @Input() data: Widget | any;\n\n  /**\n   * The margin of the child in pixel.\n   */\n  @Input() margin = 12;\n\n  /**\n   * The child content is initialized, as soon it is scrolled into viewport\n   */\n  @Input() useIntersection = false;\n\n  /**\n   * If a dashboard is frozen, all children cannot be moved\n   * or resized.\n   * @deprecated use editMode.\n   */\n  @Input()\n  set isFrozen(value: boolean) {\n    this.editMode = !value;\n  }\n\n  @Input()\n  canToggleFullscreen = true;\n\n  /**\n   * If a dashboard editing is disabled no widgets can be moved, edited, removed\n   * or added.\n   */\n  @Input() editMode = false;\n\n  /**\n   * An event fired if a child change is started (dragging or resizing)\n   */\n  @Output() changeStart = new EventEmitter<DashboardChildComponent>();\n\n  /**\n   * An event fired if a child change is ended\n   */\n  @Output() changeEnd = new EventEmitter<DashboardChildComponent>();\n\n  /**\n   * An event fired if the fullscreen toggle button was pressed.\n   */\n  @Output() toggleFullscreen = new EventEmitter<void>();\n\n  /**\n   * All classes added to this child\n   */\n  @Input()\n  class: string[] | { [key: string]: boolean } = {};\n\n  /**\n   * Updates the pixel width of the child (used for resizing)\n   */\n  set pxWidth(value) {\n    this._pxWidth = `${value}px`;\n  }\n\n  /**\n   * Updates the pixel height of the child (used for resizing)\n   */\n  set pxHeight(value) {\n    this._pxHeight = `${value}px`;\n  }\n\n  /**\n   * Triggers on every resize and returns true if in one column view (mobile view)\n   */\n  isOneColumnView$: Observable<boolean> = fromEvent(window, 'resize').pipe(\n    map(_ => {\n      return (\n        document.documentElement.clientWidth <= this.MD_BOOTSTRAP_BREAKPOINT_READONLY_CLASS_PROPERTY\n      );\n    }),\n    debounceTime(200),\n    startWith(\n      document.documentElement.clientWidth <= this.MD_BOOTSTRAP_BREAKPOINT_READONLY_CLASS_PROPERTY\n    )\n  );\n\n  /**\n   * An indicator if the child is intersected (that mean visible for the user)\n   */\n  intersected = false;\n\n  /**\n   * Tells if the last change was a dragging or resizing event;\n   */\n  lastChange: 'drag' | 'resize' = null;\n\n  /**\n   * nasty workaround for that issue:\n   * https://github.com/angular/angular/issues/9343\n   */\n  @HostBinding('attr.style')\n  get inlineStyle() {\n    return this.sanitizer.bypassSecurityTrustStyle(`\n    grid-column-start: ${this.x + 1};\n    grid-row-start: ${this.y + 1};\n    grid-column-end: span ${this.width};\n    grid-row-end: span ${this.height};\n    display: block;\n    margin: ${this.margin || 12}px;\n    order: ${this.getOrder()};\n    `);\n  }\n\n  /**\n   * The observable subscription which is listen to\n   * on changes (drag or resize).\n   */\n  changeSubscription: Subscription;\n\n  constructor(\n    public dashboard: DashboardComponent,\n    private sanitizer: DomSanitizer,\n    public element: ElementRef\n  ) {}\n\n  ngOnChanges(): void {\n    this.klasses = {\n      card: true,\n      'card-dashboard': true,\n      'on-resize': this.isResize,\n      ...this.class\n    };\n  }\n\n  ngOnInit(): void {\n    if (this.x === undefined || this.y === undefined) {\n      setTimeout(() => this.setDynamicDimension());\n    }\n    if (this.useIntersection && 'IntersectionObserver' in window) {\n      const intersectionObserver = new IntersectionObserver(\n        events => (this.intersected = this.childInView(events, intersectionObserver))\n      );\n      intersectionObserver.observe(this.element.nativeElement);\n    } else {\n      this.intersected = true;\n    }\n  }\n\n  ngAfterViewInit() {\n    this.dashboard.children.push(this);\n  }\n\n  setDynamicDimension() {\n    const ds = new DashboardChildChange(this);\n    const { x, y } = ds.findFreeDimension();\n    this.x = x;\n    this.y = y;\n\n    this.dashboard.emitChange(this);\n  }\n\n  resizeStarted($event: CdkDragStart) {\n    this.isResize = true;\n    this.dashboard.updateRectSize();\n    this.dragSource = $event.source;\n    const positioning = new DashboardChildChange(this);\n    this.changeSubscription = positioning.resize$.subscribe();\n    this.changeStart.emit(this);\n    this.ngOnChanges();\n  }\n\n  dragStarted($event: CdkDragStart) {\n    this.isDragging = true;\n    this.dashboard.updateRectSize();\n    this.dragSource = $event.source;\n    const positioning = new DashboardChildChange(this);\n    this.changeSubscription = positioning.drag$.subscribe();\n    this.changeStart.emit(this);\n  }\n\n  reset($event?: CdkDragEnd) {\n    this.lastChange = this.isResize ? 'resize' : 'drag';\n    this.isResize = false;\n    this.isDragging = false;\n    this._pxWidth = '100%';\n    this._pxHeight = '100%';\n    this.ngOnChanges();\n    if ($event) {\n      $event.source.reset();\n    }\n    if (this.changeSubscription) {\n      this.changeSubscription.unsubscribe();\n      this.dashboard.emitChange(this);\n      this.changeEnd.emit(this);\n    }\n  }\n\n  ngOnDestroy() {\n    if (this.changeSubscription) {\n      this.changeSubscription.unsubscribe();\n    }\n    this.removeSelfFromDashboard();\n  }\n\n  addActions(actions: DashboardChildActionComponent[], prepend = false) {\n    if (prepend) {\n      this.actions = [...actions, ...this.actions];\n    } else {\n      this.actions = [...this.actions, ...actions];\n    }\n  }\n\n  private removeSelfFromDashboard() {\n    const i = this.dashboard.children.indexOf(this);\n\n    if (i >= 0) {\n      this.dashboard.children.splice(i, 1);\n    }\n  }\n\n  private getOrder() {\n    return `${Math.round((this.y + (this.x + 1) / 100) * 100)}`;\n  }\n\n  private childInView(events, observer) {\n    const intersectingEvent = events.find(event => event.isIntersecting);\n    if (intersectingEvent) {\n      observer.unobserve(intersectingEvent.target);\n      return true;\n    }\n    return false;\n  }\n}\n","<div cdkDropList>\n  <div\n    class=\"card-placeholder\"\n    *ngIf=\"isResize\"\n  ></div>\n  <div\n    [ngStyle]=\"{ width: _pxWidth, height: _pxHeight }\"\n    [ngClass]=\"klasses\"\n    cdkDrag\n    (cdkDragStarted)=\"dragStarted($event)\"\n    (cdkDragEnded)=\"reset($event)\"\n    [cdkDragDisabled]=\"(isOneColumnView$ | async) || !editMode || fullscreen\"\n  >\n    <div\n      class=\"card-header-actions card-header-grid\"\n      [ngClass]=\"{\n        'drag-handle': editMode && !fullscreen,\n        draggableCursor: editMode && !fullscreen\n      }\"\n      cdkDragHandle\n    >\n      <ng-content select=\"c8y-dashboard-child-title\"></ng-content>\n      <div\n        class=\"header-actions d-flex a-i-center\"\n        *ngIf=\"actions.length > 0\"\n      >\n        <c8y-widget-time-context-icon-bar\n          *ngIf=\"data?.config?.displaySettings && data?.config?.widgetInstanceGlobalTimeContext\"\n          [config]=\"data.config\"\n        ></c8y-widget-time-context-icon-bar>\n\n        <button\n          class=\"btn btn-icon\"\n          [tooltip]=\"fullscreen ? ('Exit full screen' | translate) : ('Full screen' | translate)\"\n          delay=\"500\"\n          container=\"body\"\n          [attr.aria-label]=\"'Full screen' | translate\"\n          [disabled]=\"editMode || !canToggleFullscreen\"\n          (click)=\"toggleFullscreen.next()\"\n          data-cy=\"c8y-dashboard-child--settings-fullscreen\"\n        >\n          <i [c8yIcon]=\"fullscreen ? 'compress' : 'expand'\"></i>\n        </button>\n        <div\n          class=\"optionsBtn dropdown\"\n          placement=\"bottom right\"\n          dropdown\n          [container]=\"'body'\"\n        >\n          <button\n            class=\"btn btn-icon c8y-dropdown\"\n            title=\"{{ 'Settings' | translate }}\"\n            aria-haspopup=\"true\"\n            *ngIf=\"editMode\"\n            data-cy=\"c8y-dashboard-child--settings\"\n            (click)=\"(false)\"\n            dropdownToggle\n          >\n            <i [c8yIcon]=\"'cog'\"></i>\n          </button>\n          <button\n            class=\"btn btn-icon\"\n            [attr.aria-label]=\"'Click &quot;Edit widgets&quot; to unlock' | translate\"\n            tooltip=\"{{ 'Click &quot;Edit widgets&quot; to unlock' | translate }}\"\n            container=\"body\"\n            *ngIf=\"!editMode\"\n            (click)=\"(false)\"\n            data-cy=\"c8y-dashboard-child--settings-locked\"\n          >\n            <i [c8yIcon]=\"'lock'\"></i>\n          </button>\n          <ul\n            class=\"dropdown-menu dropdown-menu-right\"\n            data-cy=\"c8y-dashboard-child--actions-dropdown\"\n            style=\"right: -1px\"\n            *dropdownMenu\n          >\n            <ng-container *ngFor=\"let action of actions\">\n              <ng-container *ngTemplateOutlet=\"action.template\"></ng-container>\n            </ng-container>\n          </ul>\n        </div>\n      </div>\n    </div>\n    <div class=\"card-inner-scroll\">\n      <ng-content></ng-content>\n    </div>\n    <div\n      class=\"resize-handle hidden-xs\"\n      *ngIf=\"editMode && !isDragging && !fullscreen\"\n      cdkDrag\n      [cdkDragDisabled]=\"!editMode || fullscreen\"\n      (cdkDragStarted)=\"resizeStarted($event)\"\n      (cdkDragEnded)=\"reset($event)\"\n    ></div>\n    <div\n      class=\"resize-icon hidden-xs\"\n      *ngIf=\"editMode && !isDragging && !fullscreen\"\n    ></div>\n\n    <div\n      class=\"card-placeholder\"\n      *cdkDragPlaceholder\n    ></div>\n  </div>\n</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard-child.component.js","sourceRoot":"","sources":["../../../../core/dashboard/dashboard-child.component.ts","../../../../core/dashboard/dashboard-child.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CdkDrag, CdkDragEnd, CdkDragStart } from '@angular/cdk/drag-drop';\nimport {\n  Component,\n  ContentChildren,\n  ElementRef,\n  EventEmitter,\n  HostBinding,\n  Input,\n  Output\n} from '@angular/core';\nimport { DomSanitizer } from '@angular/platform-browser';\nimport { Observable, Subscription, fromEvent } from 'rxjs';\nimport { DashboardChildActionComponent } from './dashboard-child-action.component';\nimport { DashboardChildChange } from './dashboard-child-change';\nimport { DashboardComponent } from './dashboard.component';\nimport { DashboardChildDimension, Widget } from './dashboard.model';\nimport { debounceTime, map, startWith } from 'rxjs/operators';\n\n/**\n * A dashboard child allows to position elements\n * correctly on a grid.\n *\n * By setting `c8y-dashboard-child-actions` and\n * `c8y-dashboard-child-title` on the element you can add\n * custom actions or a custom title to the current child.\n *\n * By adding the correct branded classes, you can define\n * the look and feel of the child. By default it is displayed\n * as a card.\n *\n * ```html\n *   <c8y-dashboard-child\n *     #cpWidget3\n *     [x]=\"0\"\n *     [y]=\"3\"\n *     [width]=\"4\"\n *     [height]=\"4\"\n *     [class]=\"'card-dashboard panel-content-transparent'\"\n *   >\n *     <c8y-dashboard-child-title *ngIf=\"showTitle\">\n *       <span>Transparent!</span>\n *     </c8y-dashboard-child-title>\n *     <c8y-dashboard-child-action>\n *       <a href=\"\" (click)=\"showTitle = !showTitle; (false)\">\n *         <i [c8yIcon]=\"'heading'\"></i> Hide/show title\n *       </a>\n *     </c8y-dashboard-child-action>\n *     x: {{ cpWidget3.x }}<br />\n *     y: {{ cpWidget3.y }}<br />\n *     width: {{ cpWidget3.width }}<br />\n *     height: {{ cpWidget3.height }}<br />\n *   </c8y-dashboard-child>\n * ```\n */\n@Component({\n  selector: 'c8y-dashboard-child',\n  templateUrl: './dashboard-child.component.html',\n  host: {\n    class: 'dashboard-grid-child'\n  }\n})\nexport class DashboardChildComponent implements DashboardChildDimension {\n  actions: DashboardChildActionComponent[] = [];\n  @ContentChildren(DashboardChildActionComponent) set templateActions(\n    actions: DashboardChildActionComponent[]\n  ) {\n    this.addActions(actions, true);\n  }\n  dragSource: CdkDrag;\n  isResize = false;\n  isDragging = false;\n  klasses = {};\n\n  _pxWidth = '100%';\n  _pxHeight = '100%';\n\n  @HostBinding('class.fullscreen')\n  fullscreen = false;\n  readonly MD_BOOTSTRAP_BREAKPOINT_READONLY_CLASS_PROPERTY = 768;\n\n  /**\n   * The x position of the child.\n   */\n  @Input() x;\n\n  /**\n   * The y position of the child.\n   */\n  @Input() y;\n\n  /**\n   * The width of the component in grid-columns.\n   */\n  @Input() width = 1;\n\n  /**\n   * The height of the component in grid-rows.\n   */\n  @Input() height = 1;\n\n  /**\n   * The data object can be used as a dataTransfer object for events of the child.\n   */\n  @Input() data: Widget | any;\n\n  /**\n   * The margin of the child in pixel.\n   */\n  @Input() margin = 12;\n\n  /**\n   * The child content is initialized, as soon it is scrolled into viewport\n   */\n  @Input() useIntersection = false;\n\n  /**\n   * If a dashboard is frozen, all children cannot be moved\n   * or resized.\n   * @deprecated use editMode.\n   */\n  @Input()\n  set isFrozen(value: boolean) {\n    this.editMode = !value;\n  }\n\n  @Input()\n  canToggleFullscreen = true;\n\n  /**\n   * If a dashboard editing is disabled no widgets can be moved, edited, removed\n   * or added.\n   */\n  @Input() editMode = false;\n\n  /**\n   * An event fired if a child change is started (dragging or resizing)\n   */\n  @Output() changeStart = new EventEmitter<DashboardChildComponent>();\n\n  /**\n   * An event fired if a child change is ended\n   */\n  @Output() changeEnd = new EventEmitter<DashboardChildComponent>();\n\n  /**\n   * An event fired if the fullscreen toggle button was pressed.\n   */\n  @Output() toggleFullscreen = new EventEmitter<void>();\n\n  /**\n   * All classes added to this child\n   */\n  @Input()\n  class: string[] | { [key: string]: boolean } = {};\n\n  /**\n   * Updates the pixel width of the child (used for resizing)\n   */\n  set pxWidth(value) {\n    this._pxWidth = `${value}px`;\n  }\n\n  /**\n   * Updates the pixel height of the child (used for resizing)\n   */\n  set pxHeight(value) {\n    this._pxHeight = `${value}px`;\n  }\n\n  /**\n   * Triggers on every resize and returns true if in one column view (mobile view)\n   */\n  isOneColumnView$: Observable<boolean> = fromEvent(window, 'resize').pipe(\n    map(_ => {\n      return (\n        document.documentElement.clientWidth <= this.MD_BOOTSTRAP_BREAKPOINT_READONLY_CLASS_PROPERTY\n      );\n    }),\n    debounceTime(200),\n    startWith(\n      document.documentElement.clientWidth <= this.MD_BOOTSTRAP_BREAKPOINT_READONLY_CLASS_PROPERTY\n    )\n  );\n\n  /**\n   * An indicator if the child is intersected (that mean visible for the user)\n   */\n  intersected = false;\n\n  /**\n   * Tells if the last change was a dragging or resizing event;\n   */\n  lastChange: 'drag' | 'resize' = null;\n\n  /**\n   * nasty workaround for that issue:\n   * https://github.com/angular/angular/issues/9343\n   */\n  @HostBinding('attr.style')\n  get inlineStyle() {\n    return this.sanitizer.bypassSecurityTrustStyle(`\n    grid-column-start: ${this.x + 1};\n    grid-row-start: ${this.y + 1};\n    grid-column-end: span ${this.width};\n    grid-row-end: span ${this.height};\n    display: block;\n    margin: ${this.margin || 12}px;\n    order: ${this.getOrder()};\n    `);\n  }\n\n  /**\n   * The observable subscription which is listen to\n   * on changes (drag or resize).\n   */\n  changeSubscription: Subscription;\n\n  constructor(\n    public dashboard: DashboardComponent,\n    private sanitizer: DomSanitizer,\n    public element: ElementRef\n  ) {}\n\n  ngOnChanges(): void {\n    this.klasses = {\n      card: true,\n      'card-dashboard': true,\n      'on-resize': this.isResize,\n      ...this.class\n    };\n  }\n\n  ngOnInit(): void {\n    if (this.x === undefined || this.y === undefined) {\n      setTimeout(() => this.setDynamicDimension());\n    }\n    if (this.useIntersection && 'IntersectionObserver' in window) {\n      const intersectionObserver = new IntersectionObserver(\n        events => (this.intersected = this.childInView(events, intersectionObserver))\n      );\n      intersectionObserver.observe(this.element.nativeElement);\n    } else {\n      this.intersected = true;\n    }\n  }\n\n  ngAfterViewInit() {\n    this.dashboard.children.push(this);\n  }\n\n  setDynamicDimension() {\n    const ds = new DashboardChildChange(this);\n    const { x, y } = ds.findFreeDimension();\n    this.x = x;\n    this.y = y;\n\n    this.dashboard.emitChange(this);\n  }\n\n  resizeStarted($event: CdkDragStart) {\n    this.isResize = true;\n    this.dashboard.updateRectSize();\n    this.dragSource = $event.source;\n    const positioning = new DashboardChildChange(this);\n    this.changeSubscription = positioning.resize$.subscribe();\n    this.changeStart.emit(this);\n    this.ngOnChanges();\n  }\n\n  dragStarted($event: CdkDragStart) {\n    this.isDragging = true;\n    this.dashboard.updateRectSize();\n    this.dragSource = $event.source;\n    const positioning = new DashboardChildChange(this);\n    this.changeSubscription = positioning.drag$.subscribe();\n    this.changeStart.emit(this);\n  }\n\n  reset($event?: CdkDragEnd) {\n    this.lastChange = this.isResize ? 'resize' : 'drag';\n    this.isResize = false;\n    this.isDragging = false;\n    this._pxWidth = '100%';\n    this._pxHeight = '100%';\n    this.ngOnChanges();\n    if ($event) {\n      $event.source.reset();\n    }\n    if (this.changeSubscription) {\n      this.changeSubscription.unsubscribe();\n      this.dashboard.emitChange(this);\n      this.changeEnd.emit(this);\n    }\n  }\n\n  ngOnDestroy() {\n    if (this.changeSubscription) {\n      this.changeSubscription.unsubscribe();\n    }\n    this.removeSelfFromDashboard();\n  }\n\n  addActions(actions: DashboardChildActionComponent[], prepend = false) {\n    if (prepend) {\n      this.actions = [...actions, ...this.actions];\n    } else {\n      this.actions = [...this.actions, ...actions];\n    }\n  }\n\n  private removeSelfFromDashboard() {\n    const i = this.dashboard.children.indexOf(this);\n\n    if (i >= 0) {\n      this.dashboard.children.splice(i, 1);\n    }\n  }\n\n  private getOrder() {\n    return `${Math.round((this.y + (this.x + 1) / 100) * 100)}`;\n  }\n\n  private childInView(events, observer) {\n    const intersectingEvent = events.find(event => event.isIntersecting);\n    if (intersectingEvent) {\n      observer.unobserve(intersectingEvent.target);\n      return true;\n    }\n    return false;\n  }\n}\n","<div cdkDropList>\n  <div\n    class=\"card-placeholder\"\n    *ngIf=\"isResize\"\n  ></div>\n  <div\n    [ngStyle]=\"{ width: _pxWidth, height: _pxHeight }\"\n    [ngClass]=\"klasses\"\n    cdkDrag\n    (cdkDragStarted)=\"dragStarted($event)\"\n    (cdkDragEnded)=\"reset($event)\"\n    [cdkDragDisabled]=\"(isOneColumnView$ | async) || !editMode || fullscreen\"\n  >\n    <div\n      class=\"card-header-actions card-header-grid\"\n      [ngClass]=\"{\n        'drag-handle': editMode && !fullscreen,\n        draggableCursor: editMode && !fullscreen\n      }\"\n      cdkDragHandle\n    >\n      <ng-content select=\"c8y-dashboard-child-title\"></ng-content>\n      <div\n        class=\"header-actions d-flex a-i-center\"\n        *ngIf=\"actions.length > 0\"\n      >\n        <c8y-widget-time-context-icon-bar\n          *ngIf=\"data?.config?.displaySettings && data?.config?.widgetInstanceGlobalTimeContext\"\n          [config]=\"data.config\"\n        ></c8y-widget-time-context-icon-bar>\n        <c8y-widget-auto-refresh-context-icon-bar\n          *ngIf=\"\n            data?.config?.widgetInstanceGlobalAutoRefreshContext &&\n            data?.config?.displaySettings.globalAutoRefreshContext\n          \"\n        ></c8y-widget-auto-refresh-context-icon-bar>\n\n        <button\n          class=\"btn btn-icon\"\n          [attr.aria-label]=\"'Full screen' | translate\"\n          [tooltip]=\"fullscreen ? ('Exit full screen' | translate) : ('Full screen' | translate)\"\n          delay=\"500\"\n          container=\"body\"\n          [disabled]=\"editMode || !canToggleFullscreen\"\n          (click)=\"toggleFullscreen.next()\"\n          data-cy=\"c8y-dashboard-child--settings-fullscreen\"\n        >\n          <i [c8yIcon]=\"fullscreen ? 'compress' : 'expand'\"></i>\n        </button>\n        <div\n          class=\"optionsBtn dropdown\"\n          placement=\"bottom right\"\n          dropdown\n          [container]=\"'body'\"\n        >\n          <button\n            class=\"btn btn-icon c8y-dropdown\"\n            title=\"{{ 'Settings' | translate }}\"\n            aria-haspopup=\"true\"\n            *ngIf=\"editMode\"\n            data-cy=\"c8y-dashboard-child--settings\"\n            (click)=\"(false)\"\n            dropdownToggle\n          >\n            <i [c8yIcon]=\"'cog'\"></i>\n          </button>\n          <button\n            class=\"btn btn-icon\"\n            [attr.aria-label]=\"'Click &quot;Edit widgets&quot; to unlock' | translate\"\n            tooltip=\"{{ 'Click &quot;Edit widgets&quot; to unlock' | translate }}\"\n            container=\"body\"\n            *ngIf=\"!editMode\"\n            (click)=\"(false)\"\n            data-cy=\"c8y-dashboard-child--settings-locked\"\n          >\n            <i [c8yIcon]=\"'lock'\"></i>\n          </button>\n          <ul\n            class=\"dropdown-menu dropdown-menu-right\"\n            data-cy=\"c8y-dashboard-child--actions-dropdown\"\n            style=\"right: -1px\"\n            *dropdownMenu\n          >\n            <ng-container *ngFor=\"let action of actions\">\n              <ng-container *ngTemplateOutlet=\"action.template\"></ng-container>\n            </ng-container>\n          </ul>\n        </div>\n      </div>\n    </div>\n    <div class=\"card-inner-scroll\">\n      <ng-content></ng-content>\n    </div>\n    <div\n      class=\"resize-handle hidden-xs\"\n      *ngIf=\"editMode && !isDragging && !fullscreen\"\n      cdkDrag\n      [cdkDragDisabled]=\"!editMode || fullscreen\"\n      (cdkDragStarted)=\"resizeStarted($event)\"\n      (cdkDragEnded)=\"reset($event)\"\n    ></div>\n    <div\n      class=\"resize-icon hidden-xs\"\n      *ngIf=\"editMode && !isDragging && !fullscreen\"\n    ></div>\n\n    <div\n      class=\"card-placeholder\"\n      *cdkDragPlaceholder\n    ></div>\n  </div>\n</div>\n"]}