@c8y/ngx-components 1021.22.68 → 1021.22.69

package/core/common/interval-based-reload.abstract.d.ts

@@ -1,11 +1,18 @@
 import { EventEmitter } from '@angular/core';
 import { BehaviorSubject, Subscription } from 'rxjs';
 import { CountdownIntervalComponent } from '../countdown-interval';
+import { GainsightService } from '../product-experience';
+export declare const WIDGET_TYPE_VALUES: {
+    readonly ALARMS: "alarms";
+    readonly DATA_POINTS_TABLE: "dataPointsTable";
+};
+type WidgetType = (typeof WIDGET_TYPE_VALUES)[keyof typeof WIDGET_TYPE_VALUES];
 /**
  * Abstract class representing an interval reload functionality.
  * This class provides methods and properties for managing an interval-based reload mechanism.
  */
 export declare abstract class IntervalBasedReload {
+    protected gainsightService: GainsightService;
     abstract countdownIntervalComponent: CountdownIntervalComponent;
     /**
      * Holds the subscription to a countdown observable.
@@ -91,8 +98,9 @@ export declare abstract class IntervalBasedReload {
      *   is set to false.
      *
      * @param $event - The MouseEvent that triggered this method.
+     * @param widgetType - The type of the widget that triggered the event
      */
-    onToggleCountdownButtonState($event: MouseEvent): void;
+    onToggleCountdownButtonState($event: MouseEvent, widgetType: WidgetType): void;
     /**
      * 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.
@@ -126,5 +134,8 @@ export declare abstract class IntervalBasedReload {
      * Updates the countdown button tooltip text based on the state of the interval refresh toggle state.
      */
     protected abstract updateCountdownButtonTooltipText(): void;
+    private triggerGainsightEvent;
+    private determineComponentName;
 }
+export {};
 //# sourceMappingURL=interval-based-reload.abstract.d.ts.map

package/core/common/interval-based-reload.abstract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interval-based-reload.abstract.d.ts","sourceRoot":"","sources":["../../../core/common/interval-based-reload.abstract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAU,YAAY,EAAO,MAAM,MAAM,CAAC;AAClE,OAAO,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AAEnE;;;GAGG;AACH,8BAAsB,mBAAmB;IACvC,QAAQ,CAAC,0BAA0B,EAAE,0BAA0B,CAAC;IAChE;;OAEG;IACH,SAAS,CAAC,qBAAqB,EAAE,YAAY,CAAC;IAC9C;;OAEG;IACH,oBAAoB,EAAE,OAAO,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IACpC;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC;IAC7C;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B;;OAEG;IACH,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC;;OAEG;IACH,QAAQ,CAAC,gBAAgB,EAAE,YAAY,CAAC,IAAI,CAAC,CAAC;IAC9C;;OAEG;IACH,QAAQ,CAAC,yBAAyB,EAAE,OAAO,CAAC;IAE5C,QAAQ,CAAC,gCAAgC,EAAE,MAAM,CAAC;IAClD;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,yBAAyB,EAAE,OAAO,CAAC;IACtD;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAE1C;;;;;;OAMG;IACH,eAAe,IAAI,IAAI;IAOvB;;;;;;;;;;;;;OAaG;IACH,eAAe,IAAI,IAAI;IAoBvB,QAAQ,CAAC,MAAM,IAAI,IAAI;IACvB;;OAEG;IACH,QAAQ,CAAC,cAAc,IAAI,IAAI;IAE/B;;;;;;;;;;;;;;OAcG;IACH,4BAA4B,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAmBtD;;;;;;;;;OASG;IACH,cAAc,IAAI,IAAI;IAWtB;;;;;;;OAOG;IACH,QAAQ,CAAC,eAAe,IAAI,IAAI;IAEhC;;;;;;;OAOG;IACH,gBAAgB,IAAI,IAAI;IAMxB;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,gCAAgC,IAAI,IAAI;CAC5D"}
+{"version":3,"file":"interval-based-reload.abstract.d.ts","sourceRoot":"","sources":["../../../core/common/interval-based-reload.abstract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAU,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,eAAe,EAAU,YAAY,EAAO,MAAM,MAAM,CAAC;AAClE,OAAO,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAmBzD,eAAO,MAAM,kBAAkB;;;CAGrB,CAAC;AAEX,KAAK,UAAU,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC;AAE/E;;;GAGG;AACH,8BAAsB,mBAAmB;IACvC,SAAS,CAAC,gBAAgB,mBAA4B;IAEtD,QAAQ,CAAC,0BAA0B,EAAE,0BAA0B,CAAC;IAChE;;OAEG;IACH,SAAS,CAAC,qBAAqB,EAAE,YAAY,CAAC;IAC9C;;OAEG;IACH,oBAAoB,EAAE,OAAO,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IACpC;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC;IAC7C;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B;;OAEG;IACH,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC;;OAEG;IACH,QAAQ,CAAC,gBAAgB,EAAE,YAAY,CAAC,IAAI,CAAC,CAAC;IAC9C;;OAEG;IACH,QAAQ,CAAC,yBAAyB,EAAE,OAAO,CAAC;IAE5C,QAAQ,CAAC,gCAAgC,EAAE,MAAM,CAAC;IAClD;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,yBAAyB,EAAE,OAAO,CAAC;IACtD;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAE1C;;;;;;OAMG;IACH,eAAe,IAAI,IAAI;IAOvB;;;;;;;;;;;;;OAaG;IACH,eAAe,IAAI,IAAI;IAoBvB,QAAQ,CAAC,MAAM,IAAI,IAAI;IACvB;;OAEG;IACH,QAAQ,CAAC,cAAc,IAAI,IAAI;IAE/B;;;;;;;;;;;;;;;OAeG;IACH,4BAA4B,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,GAAG,IAAI;IA+B9E;;;;;;;;;OASG;IACH,cAAc,IAAI,IAAI;IAWtB;;;;;;;OAOG;IACH,QAAQ,CAAC,eAAe,IAAI,IAAI;IAEhC;;;;;;;OAOG;IACH,gBAAgB,IAAI,IAAI;IAMxB;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,gCAAgC,IAAI,IAAI;IAE3D,OAAO,CAAC,qBAAqB;IAc7B,OAAO,CAAC,sBAAsB;CAU/B"}

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

@@ -1,9 +1,34 @@
+import { inject } from '@angular/core';
 import { filter, tap } from 'rxjs';
+import { GainsightService } from '../product-experience';
+const PRODUCT_EXPERIENCE_INTERVAL_BASED_RELOAD = {
+    EVENTS: {
+        INTERVAL_BASED_RELOAD: 'intervalBasedReload'
+    },
+    COMPONENTS: {
+        ALARM_WIDGET_ALARM_RELOAD: 'alarm-widget-alarms-reload',
+        DATAPOINTS_RELOAD: 'datapoints-reload'
+    },
+    ACTIONS: {
+        MANUALLY_CHANGED_COUNTDOWN_STATE: 'manuallyChangedCountdownState'
+    },
+    RESULT: {
+        MANUALLY_PAUSED_COUNTDOWN: 'manuallyPausedCountdown',
+        MANUALLY_RESUMED_COUNTDOWN: 'manuallyResumedCountdown'
+    }
+};
+export const WIDGET_TYPE_VALUES = {
+    ALARMS: 'alarms',
+    DATA_POINTS_TABLE: 'dataPointsTable'
+};
 /**
  * Abstract class representing an interval reload functionality.
  * This class provides methods and properties for managing an interval-based reload mechanism.
  */
 export class IntervalBasedReload {
+    constructor() {
+        this.gainsightService = inject(GainsightService);
+    }
     /**
      * Stops the countdown and triggers a refresh action.
      * This function is responsible for halting the countdown interval component's operation.
@@ -60,20 +85,23 @@ export class IntervalBasedReload {
      *   is set to false.
      *
      * @param $event - The MouseEvent that triggered this method.
+     * @param widgetType - The type of the widget that triggered the event
      */
-    onToggleCountdownButtonState($event) {
+    onToggleCountdownButtonState($event, widgetType) {
         $event.preventDefault();
         this.isIntervalRefreshToggleOn = !this.isRefreshDisabled && !this.isIntervalRefreshToggleOn;
         this.updateCountdownButtonTooltipText();
         if (!this.isIntervalRefreshToggleOn) {
             this.disableCountdown();
             this.manuallyDisabledCountdown = true;
+            this.triggerGainsightEvent(widgetType, PRODUCT_EXPERIENCE_INTERVAL_BASED_RELOAD.ACTIONS.MANUALLY_CHANGED_COUNTDOWN_STATE, PRODUCT_EXPERIENCE_INTERVAL_BASED_RELOAD.RESULT.MANUALLY_PAUSED_COUNTDOWN);
             return;
         }
         const onRefreshToggleOn = this.isIntervalRefreshToggleOn && this.countdownSubscription.closed;
         if (onRefreshToggleOn) {
             this.enableCountdown();
             this.manuallyDisabledCountdown = false;
+            this.triggerGainsightEvent(widgetType, PRODUCT_EXPERIENCE_INTERVAL_BASED_RELOAD.ACTIONS.MANUALLY_CHANGED_COUNTDOWN_STATE, PRODUCT_EXPERIENCE_INTERVAL_BASED_RELOAD.RESULT.MANUALLY_RESUMED_COUNTDOWN);
         }
     }
     /**
@@ -106,5 +134,25 @@ export class IntervalBasedReload {
         this.countdownIntervalComponent?.stop();
         this.hideCountdown = true;
     }
+    triggerGainsightEvent(widgetType, action, result) {
+        if (widgetType) {
+            this.gainsightService.triggerEvent(PRODUCT_EXPERIENCE_INTERVAL_BASED_RELOAD.EVENTS.INTERVAL_BASED_RELOAD, {
+                action,
+                result,
+                component: this.determineComponentName(widgetType),
+                widget: widgetType
+            });
+        }
+    }
+    determineComponentName(widgetType) {
+        switch (widgetType) {
+            case WIDGET_TYPE_VALUES.ALARMS:
+                return PRODUCT_EXPERIENCE_INTERVAL_BASED_RELOAD.COMPONENTS.ALARM_WIDGET_ALARM_RELOAD;
+            case WIDGET_TYPE_VALUES.DATA_POINTS_TABLE:
+                return PRODUCT_EXPERIENCE_INTERVAL_BASED_RELOAD.COMPONENTS.DATAPOINTS_RELOAD;
+            default:
+                return '';
+        }
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interval-based-reload.abstract.js","sourceRoot":"","sources":["../../../../core/common/interval-based-reload.abstract.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,MAAM,EAAgB,GAAG,EAAE,MAAM,MAAM,CAAC;AAGlE;;;GAGG;AACH,MAAM,OAAgB,mBAAmB;IA8CvC;;;;;;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,GACvB,CAAC,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,qBAAqB,EAAE,MAAM,IAAI,IAAI,CAAC,aAAa,CAAC;QAEhF,IAAI,mBAAmB,EAAE,CAAC;YACxB,IAAI,CAAC,yBAAyB,GAAG,IAAI,CAAC;YACtC,IAAI,CAAC,eAAe,EAAE,CAAC;QACzB,CAAC;IACH,CAAC;IAQD;;;;;;;;;;;;;;OAcG;IACH,4BAA4B,CAAC,MAAkB;QAC7C,MAAM,CAAC,cAAc,EAAE,CAAC;QACxB,IAAI,CAAC,yBAAyB,GAAG,CAAC,IAAI,CAAC,iBAAiB,IAAI,CAAC,IAAI,CAAC,yBAAyB,CAAC;QAC5F,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,MAAM,iBAAiB,GAAG,IAAI,CAAC,yBAAyB,IAAI,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC;QAE9F,IAAI,iBAAiB,EAAE,CAAC;YACtB,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,IAAI,CAAC,yBAAyB,GAAG,KAAK,CAAC;QACzC,CAAC;IACH,CAAC;IAED;;;;;;;;;OASG;IACH,cAAc;QACZ,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,SAAS;aACxC,IAAI,CACH,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,EACxC,GAAG,CAAC,GAAG,EAAE;YACP,IAAI,CAAC,0BAA0B,EAAE,KAAK,EAAE,CAAC;QAC3C,CAAC,CAAC,CACH;aACA,SAAS,EAAE,CAAC;IACjB,CAAC;IAYD;;;;;;;OAOG;IACH,gBAAgB;QACd,IAAI,CAAC,qBAAqB,CAAC,WAAW,EAAE,CAAC;QACzC,IAAI,CAAC,0BAA0B,EAAE,IAAI,EAAE,CAAC;QACxC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;IAC5B,CAAC;CAMF","sourcesContent":["import { EventEmitter } from '@angular/core';\nimport { BehaviorSubject, filter, Subscription, tap } from 'rxjs';\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   * Holds the subscription to a countdown observable.\n   */\n  protected countdownSubscription: Subscription;\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   * Indicates whether refreshing should be enabled or disabled.\n   * It's 'true' when user is not allowed to view a measurement.\n   */\n  abstract isRefreshDisabled: boolean;\n  /**\n   * Current isLoading state. Based on it next countdown cycle is being started.\n   */\n  abstract isLoading: BehaviorSubject<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 =\n      !this.isScrolling && this.countdownSubscription?.closed && 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  /**\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.isRefreshDisabled && !this.isIntervalRefreshToggleOn;\n    this.updateCountdownButtonTooltipText();\n\n    if (!this.isIntervalRefreshToggleOn) {\n      this.disableCountdown();\n      this.manuallyDisabledCountdown = true;\n      return;\n    }\n\n    const onRefreshToggleOn = this.isIntervalRefreshToggleOn && this.countdownSubscription.closed;\n\n    if (onRefreshToggleOn) {\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(): void {\n    this.countdownSubscription = this.isLoading\n      .pipe(\n        filter(isLoading => !Boolean(isLoading)),\n        tap(() => {\n          this.countdownIntervalComponent?.start();\n        })\n      )\n      .subscribe();\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.countdownSubscription.unsubscribe();\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"]}
+//# 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,EAAgB,MAAM,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAmB,MAAM,EAAgB,GAAG,EAAE,MAAM,MAAM,CAAC;AAElE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD,MAAM,wCAAwC,GAAG;IAC/C,MAAM,EAAE;QACN,qBAAqB,EAAE,qBAAqB;KAC7C;IACD,UAAU,EAAE;QACV,yBAAyB,EAAE,4BAA4B;QACvD,iBAAiB,EAAE,mBAAmB;KACvC;IACD,OAAO,EAAE;QACP,gCAAgC,EAAE,+BAA+B;KAClE;IACD,MAAM,EAAE;QACN,yBAAyB,EAAE,yBAAyB;QACpD,0BAA0B,EAAE,0BAA0B;KACvD;CACO,CAAC;AAEX,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,MAAM,EAAE,QAAQ;IAChB,iBAAiB,EAAE,iBAAiB;CAC5B,CAAC;AAIX;;;GAGG;AACH,MAAM,OAAgB,mBAAmB;IAAzC;QACY,qBAAgB,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC;IA8NxD,CAAC;IA/KC;;;;;;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,GACvB,CAAC,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,qBAAqB,EAAE,MAAM,IAAI,IAAI,CAAC,aAAa,CAAC;QAEhF,IAAI,mBAAmB,EAAE,CAAC;YACxB,IAAI,CAAC,yBAAyB,GAAG,IAAI,CAAC;YACtC,IAAI,CAAC,eAAe,EAAE,CAAC;QACzB,CAAC;IACH,CAAC;IAQD;;;;;;;;;;;;;;;OAeG;IACH,4BAA4B,CAAC,MAAkB,EAAE,UAAsB;QACrE,MAAM,CAAC,cAAc,EAAE,CAAC;QACxB,IAAI,CAAC,yBAAyB,GAAG,CAAC,IAAI,CAAC,iBAAiB,IAAI,CAAC,IAAI,CAAC,yBAAyB,CAAC;QAC5F,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;YAEtC,IAAI,CAAC,qBAAqB,CACxB,UAAU,EACV,wCAAwC,CAAC,OAAO,CAAC,gCAAgC,EACjF,wCAAwC,CAAC,MAAM,CAAC,yBAAyB,CAC1E,CAAC;YACF,OAAO;QACT,CAAC;QAED,MAAM,iBAAiB,GAAG,IAAI,CAAC,yBAAyB,IAAI,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC;QAE9F,IAAI,iBAAiB,EAAE,CAAC;YACtB,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,IAAI,CAAC,yBAAyB,GAAG,KAAK,CAAC;YAEvC,IAAI,CAAC,qBAAqB,CACxB,UAAU,EACV,wCAAwC,CAAC,OAAO,CAAC,gCAAgC,EACjF,wCAAwC,CAAC,MAAM,CAAC,0BAA0B,CAC3E,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;;;;;;;OASG;IACH,cAAc;QACZ,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,SAAS;aACxC,IAAI,CACH,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,EACxC,GAAG,CAAC,GAAG,EAAE;YACP,IAAI,CAAC,0BAA0B,EAAE,KAAK,EAAE,CAAC;QAC3C,CAAC,CAAC,CACH;aACA,SAAS,EAAE,CAAC;IACjB,CAAC;IAYD;;;;;;;OAOG;IACH,gBAAgB;QACd,IAAI,CAAC,qBAAqB,CAAC,WAAW,EAAE,CAAC;QACzC,IAAI,CAAC,0BAA0B,EAAE,IAAI,EAAE,CAAC;QACxC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;IAC5B,CAAC;IAOO,qBAAqB,CAAC,UAAsB,EAAE,MAAc,EAAE,MAAc;QAClF,IAAI,UAAU,EAAE,CAAC;YACf,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAChC,wCAAwC,CAAC,MAAM,CAAC,qBAAqB,EACrE;gBACE,MAAM;gBACN,MAAM;gBACN,SAAS,EAAE,IAAI,CAAC,sBAAsB,CAAC,UAAU,CAAC;gBAClD,MAAM,EAAE,UAAU;aACnB,CACF,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,sBAAsB,CAAC,UAAsB;QACnD,QAAQ,UAAU,EAAE,CAAC;YACnB,KAAK,kBAAkB,CAAC,MAAM;gBAC5B,OAAO,wCAAwC,CAAC,UAAU,CAAC,yBAAyB,CAAC;YACvF,KAAK,kBAAkB,CAAC,iBAAiB;gBACvC,OAAO,wCAAwC,CAAC,UAAU,CAAC,iBAAiB,CAAC;YAC/E;gBACE,OAAO,EAAE,CAAC;QACd,CAAC;IACH,CAAC;CACF","sourcesContent":["import { EventEmitter, inject } from '@angular/core';\nimport { BehaviorSubject, filter, Subscription, tap } from 'rxjs';\nimport { CountdownIntervalComponent } from '../countdown-interval';\nimport { GainsightService } from '../product-experience';\n\nconst PRODUCT_EXPERIENCE_INTERVAL_BASED_RELOAD = {\n  EVENTS: {\n    INTERVAL_BASED_RELOAD: 'intervalBasedReload'\n  },\n  COMPONENTS: {\n    ALARM_WIDGET_ALARM_RELOAD: 'alarm-widget-alarms-reload',\n    DATAPOINTS_RELOAD: 'datapoints-reload'\n  },\n  ACTIONS: {\n    MANUALLY_CHANGED_COUNTDOWN_STATE: 'manuallyChangedCountdownState'\n  },\n  RESULT: {\n    MANUALLY_PAUSED_COUNTDOWN: 'manuallyPausedCountdown',\n    MANUALLY_RESUMED_COUNTDOWN: 'manuallyResumedCountdown'\n  }\n} as const;\n\nexport const WIDGET_TYPE_VALUES = {\n  ALARMS: 'alarms',\n  DATA_POINTS_TABLE: 'dataPointsTable'\n} as const;\n\ntype WidgetType = (typeof WIDGET_TYPE_VALUES)[keyof typeof WIDGET_TYPE_VALUES];\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  protected gainsightService = inject(GainsightService);\n\n  abstract countdownIntervalComponent: CountdownIntervalComponent;\n  /**\n   * Holds the subscription to a countdown observable.\n   */\n  protected countdownSubscription: Subscription;\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   * Indicates whether refreshing should be enabled or disabled.\n   * It's 'true' when user is not allowed to view a measurement.\n   */\n  abstract isRefreshDisabled: boolean;\n  /**\n   * Current isLoading state. Based on it next countdown cycle is being started.\n   */\n  abstract isLoading: BehaviorSubject<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 =\n      !this.isScrolling && this.countdownSubscription?.closed && 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  /**\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   * @param widgetType - The type of the widget that triggered the event\n   */\n  onToggleCountdownButtonState($event: MouseEvent, widgetType: WidgetType): void {\n    $event.preventDefault();\n    this.isIntervalRefreshToggleOn = !this.isRefreshDisabled && !this.isIntervalRefreshToggleOn;\n    this.updateCountdownButtonTooltipText();\n\n    if (!this.isIntervalRefreshToggleOn) {\n      this.disableCountdown();\n      this.manuallyDisabledCountdown = true;\n\n      this.triggerGainsightEvent(\n        widgetType,\n        PRODUCT_EXPERIENCE_INTERVAL_BASED_RELOAD.ACTIONS.MANUALLY_CHANGED_COUNTDOWN_STATE,\n        PRODUCT_EXPERIENCE_INTERVAL_BASED_RELOAD.RESULT.MANUALLY_PAUSED_COUNTDOWN\n      );\n      return;\n    }\n\n    const onRefreshToggleOn = this.isIntervalRefreshToggleOn && this.countdownSubscription.closed;\n\n    if (onRefreshToggleOn) {\n      this.enableCountdown();\n      this.manuallyDisabledCountdown = false;\n\n      this.triggerGainsightEvent(\n        widgetType,\n        PRODUCT_EXPERIENCE_INTERVAL_BASED_RELOAD.ACTIONS.MANUALLY_CHANGED_COUNTDOWN_STATE,\n        PRODUCT_EXPERIENCE_INTERVAL_BASED_RELOAD.RESULT.MANUALLY_RESUMED_COUNTDOWN\n      );\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(): void {\n    this.countdownSubscription = this.isLoading\n      .pipe(\n        filter(isLoading => !Boolean(isLoading)),\n        tap(() => {\n          this.countdownIntervalComponent?.start();\n        })\n      )\n      .subscribe();\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.countdownSubscription.unsubscribe();\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  private triggerGainsightEvent(widgetType: WidgetType, action: string, result: string): void {\n    if (widgetType) {\n      this.gainsightService.triggerEvent(\n        PRODUCT_EXPERIENCE_INTERVAL_BASED_RELOAD.EVENTS.INTERVAL_BASED_RELOAD,\n        {\n          action,\n          result,\n          component: this.determineComponentName(widgetType),\n          widget: widgetType\n        }\n      );\n    }\n  }\n\n  private determineComponentName(widgetType: WidgetType): string {\n    switch (widgetType) {\n      case WIDGET_TYPE_VALUES.ALARMS:\n        return PRODUCT_EXPERIENCE_INTERVAL_BASED_RELOAD.COMPONENTS.ALARM_WIDGET_ALARM_RELOAD;\n      case WIDGET_TYPE_VALUES.DATA_POINTS_TABLE:\n        return PRODUCT_EXPERIENCE_INTERVAL_BASED_RELOAD.COMPONENTS.DATAPOINTS_RELOAD;\n      default:\n        return '';\n    }\n  }\n}\n"]}

package/esm2022/widgets/implementations/alarms/alarm-widget-alarms-reload.component.mjs

@@ -1,5 +1,5 @@
 import { ChangeDetectorRef, Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';
-import { CountdownIntervalComponent, gettext, IntervalBasedReload, WidgetGlobalAutoRefreshService } from '@c8y/ngx-components';
+import { CountdownIntervalComponent, gettext, IntervalBasedReload, WIDGET_TYPE_VALUES, WidgetGlobalAutoRefreshService, GainsightService } from '@c8y/ngx-components';
 import { AlarmsViewService } from '@c8y/ngx-components/alarms';
 import { TranslateService } from '@ngx-translate/core';
 import { BehaviorSubject } from 'rxjs';
@@ -12,13 +12,15 @@ import * as i3 from "@c8y/ngx-components";
 import * as i4 from "@angular/common";
 import * as i5 from "ngx-bootstrap/tooltip";
 export class AlarmWidgetAlarmsReloadComponent extends IntervalBasedReload {
-    constructor(alarmsViewService, cdRef, translateService, widgetGlobalAutoRefreshService) {
+    constructor(alarmsViewService, cdRef, translateService, widgetGlobalAutoRefreshService, gainsightService) {
         super();
         this.alarmsViewService = alarmsViewService;
         this.cdRef = cdRef;
         this.translateService = translateService;
         this.widgetGlobalAutoRefreshService = widgetGlobalAutoRefreshService;
+        this.gainsightService = gainsightService;
         this.REALTIME_UPDATE_ALARMS_MESSAGE = this.alarmsViewService.REALTIME_UPDATE_ALARMS_MESSAGE;
+        this.WIDGET_TYPE_VALUES = WIDGET_TYPE_VALUES;
         /**
          * @inheritdoc
          */
@@ -157,13 +159,13 @@ export class AlarmWidgetAlarmsReloadComponent extends IntervalBasedReload {
             ? this.translateService.instant(gettext('Disable auto refresh'))
             : this.translateService.instant(gettext('Enable auto refresh'));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: AlarmWidgetAlarmsReloadComponent, deps: [{ token: i1.AlarmsViewService }, { token: i0.ChangeDetectorRef }, { token: i2.TranslateService }, { token: i3.WidgetGlobalAutoRefreshService }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: AlarmWidgetAlarmsReloadComponent, selector: "c8y-alarm-widget-alarms-reload", inputs: { isIntervalRefresh: "isIntervalRefresh", refreshInterval: "refreshInterval", config: "config", isLoading: "isLoading", isScrolling: "isScrolling", isRefreshDisabled: "isRefreshDisabled" }, outputs: { onCountdownEnded: "onCountdownEnded", onRealTimeToggleChanged: "onRealTimeToggleChanged" }, viewQueries: [{ propertyName: "countdownIntervalComponent", first: true, predicate: CountdownIntervalComponent, descendants: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<div\n  class=\"m-l-auto d-flex p-t-4 p-b-4\"\n  *ngIf=\"!globalAutoRefreshEnabled\"\n>\n  <div class=\"m-l-auto d-flex a-i-center\">\n    <label\n      class=\"m-b-0 m-r-8 text-label-small text-truncate flex-no-shrink\"\n      title=\" {{ 'Auto refresh' | translate }}\"\n      *ngIf=\"isIntervalRefresh && refreshInterval && config.isAutoRefreshEnabled\"\n    >\n      {{ 'Auto refresh' | translate }}\n    </label>\n    <div class=\"input-group\">\n      <label\n        class=\"toggle-countdown\"\n        [class.toggle-countdown-disabled]=\"isRefreshDisabled\"\n        [attr.aria-label]=\"toggleCountdownButtonTooltipText\"\n        [tooltip]=\"toggleCountdownButtonTooltipText\"\n        placement=\"bottom\"\n        *ngIf=\"isIntervalRefresh && refreshInterval && config.isAutoRefreshEnabled\"\n        [adaptivePosition]=\"false\"\n        [container]=\"'body'\"\n        [delay]=\"500\"\n      >\n        <input\n          type=\"checkbox\"\n          data-cy=\"c8y-alarms-widget--interval-toggle-button\"\n          (click)=\"onToggleCountdownButtonState($event)\"\n        />\n        <c8y-countdown-interval\n          *ngIf=\"isIntervalRefreshToggleOn\"\n          [countdownInterval]=\"refreshInterval\"\n          (countdownEnded)=\"countdownEnded()\"\n        ></c8y-countdown-interval>\n        <i\n          c8yIcon=\"pause\"\n          *ngIf=\"!isIntervalRefreshToggleOn\"\n        ></i>\n      </label>\n\n      <div class=\"input-group-btn\">\n        <button\n          class=\"btn btn-default\"\n          [attr.aria-label]=\"'Refresh' | translate\"\n          [tooltip]=\"\n            !isNewAlarmMessageCleared\n              ? (REALTIME_UPDATE_ALARMS_MESSAGE | translate)\n              : ('Refresh' | translate)\n          \"\n          placement=\"bottom\"\n          type=\"button\"\n          [adaptivePosition]=\"false\"\n          [container]=\"'body'\"\n          [delay]=\"500\"\n          [disabled]=\"isRefreshDisabled || (isLoading | async)\"\n          (click)=\"reload()\"\n          data-cy=\"c8y-alarms-widget--reload-button\"\n        >\n          <span\n            class=\"tag tag--info m-r-8\"\n            *ngIf=\"!isNewAlarmMessageCleared\"\n          >\n            {{ 'New alarms' | translate }}\n          </span>\n          <i\n            c8yIcon=\"refresh\"\n            [ngClass]=\"{ 'icon-spin': isLoading | async }\"\n          ></i>\n        </button>\n      </div>\n      <div\n        class=\"input-group-btn input-group-btn--last\"\n        *ngIf=\"!isIntervalRefresh\"\n      >\n        <button\n          class=\"c8y-realtime btn btn-default\"\n          [attr.aria-label]=\"realtimeIconTitle\"\n          [tooltip]=\"realtimeIconTitle\"\n          placement=\"bottom\"\n          type=\"button\"\n          [container]=\"'body'\"\n          (click)=\"toggleRealtimeState()\"\n          [disabled]=\"isRefreshDisabled\"\n        >\n          <span\n            class=\"c8y-pulse m-0\"\n            [ngClass]=\"{\n              active: isRealtimeToggleOn,\n              inactive: !isRealtimeToggleOn\n            }\"\n          ></span>\n        </button>\n      </div>\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.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.CountdownIntervalComponent, selector: "c8y-countdown-interval", inputs: ["countdownInterval"], outputs: ["countdownEnded"] }, { kind: "directive", type: i5.TooltipDirective, selector: "[tooltip], [tooltipHtml]", inputs: ["adaptivePosition", "tooltip", "placement", "triggers", "container", "containerClass", "boundariesElement", "isOpen", "isDisabled", "delay", "tooltipHtml", "tooltipPlacement", "tooltipIsOpen", "tooltipEnable", "tooltipAppendToBody", "tooltipAnimation", "tooltipClass", "tooltipContext", "tooltipPopupDelay", "tooltipFadeDuration", "tooltipTrigger"], outputs: ["tooltipChange", "onShown", "onHidden", "tooltipStateChanged"], exportAs: ["bs-tooltip"] }, { kind: "pipe", type: i3.C8yTranslatePipe, name: "translate" }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: AlarmWidgetAlarmsReloadComponent, deps: [{ token: i1.AlarmsViewService }, { token: i0.ChangeDetectorRef }, { token: i2.TranslateService }, { token: i3.WidgetGlobalAutoRefreshService }, { token: i3.GainsightService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: AlarmWidgetAlarmsReloadComponent, selector: "c8y-alarm-widget-alarms-reload", inputs: { isIntervalRefresh: "isIntervalRefresh", refreshInterval: "refreshInterval", config: "config", isLoading: "isLoading", isScrolling: "isScrolling", isRefreshDisabled: "isRefreshDisabled" }, outputs: { onCountdownEnded: "onCountdownEnded", onRealTimeToggleChanged: "onRealTimeToggleChanged" }, viewQueries: [{ propertyName: "countdownIntervalComponent", first: true, predicate: CountdownIntervalComponent, descendants: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<div\n  class=\"m-l-auto d-flex p-t-4 p-b-4\"\n  *ngIf=\"!globalAutoRefreshEnabled\"\n>\n  <div class=\"m-l-auto d-flex a-i-center\">\n    <label\n      class=\"m-b-0 m-r-8 text-label-small text-truncate flex-no-shrink\"\n      title=\" {{ 'Auto refresh' | translate }}\"\n      *ngIf=\"isIntervalRefresh && refreshInterval && config.isAutoRefreshEnabled\"\n    >\n      {{ 'Auto refresh' | translate }}\n    </label>\n    <div class=\"input-group\">\n      <label\n        class=\"toggle-countdown\"\n        [class.toggle-countdown-disabled]=\"isRefreshDisabled\"\n        [attr.aria-label]=\"toggleCountdownButtonTooltipText\"\n        [tooltip]=\"toggleCountdownButtonTooltipText\"\n        placement=\"bottom\"\n        *ngIf=\"isIntervalRefresh && refreshInterval && config.isAutoRefreshEnabled\"\n        [adaptivePosition]=\"false\"\n        [container]=\"'body'\"\n        [delay]=\"500\"\n      >\n        <input\n          type=\"checkbox\"\n          data-cy=\"c8y-alarms-widget--interval-toggle-button\"\n          (click)=\"onToggleCountdownButtonState($event, WIDGET_TYPE_VALUES.ALARMS)\"\n        />\n        <c8y-countdown-interval\n          *ngIf=\"isIntervalRefreshToggleOn\"\n          [countdownInterval]=\"refreshInterval\"\n          (countdownEnded)=\"countdownEnded()\"\n        ></c8y-countdown-interval>\n        <i\n          c8yIcon=\"pause\"\n          *ngIf=\"!isIntervalRefreshToggleOn\"\n        ></i>\n      </label>\n\n      <div class=\"input-group-btn\">\n        <button\n          class=\"btn btn-default\"\n          [attr.aria-label]=\"'Refresh' | translate\"\n          [tooltip]=\"\n            !isNewAlarmMessageCleared\n              ? (REALTIME_UPDATE_ALARMS_MESSAGE | translate)\n              : ('Refresh' | translate)\n          \"\n          placement=\"bottom\"\n          type=\"button\"\n          [adaptivePosition]=\"false\"\n          [container]=\"'body'\"\n          [delay]=\"500\"\n          [disabled]=\"isRefreshDisabled || (isLoading | async)\"\n          (click)=\"reload()\"\n          data-cy=\"c8y-alarms-widget--reload-button\"\n        >\n          <span\n            class=\"tag tag--info m-r-8\"\n            *ngIf=\"!isNewAlarmMessageCleared\"\n          >\n            {{ 'New alarms' | translate }}\n          </span>\n          <i\n            c8yIcon=\"refresh\"\n            [ngClass]=\"{ 'icon-spin': isLoading | async }\"\n          ></i>\n        </button>\n      </div>\n      <div\n        class=\"input-group-btn input-group-btn--last\"\n        *ngIf=\"!isIntervalRefresh\"\n      >\n        <button\n          class=\"c8y-realtime btn btn-default\"\n          [attr.aria-label]=\"realtimeIconTitle\"\n          [tooltip]=\"realtimeIconTitle\"\n          placement=\"bottom\"\n          type=\"button\"\n          [container]=\"'body'\"\n          (click)=\"toggleRealtimeState()\"\n          [disabled]=\"isRefreshDisabled\"\n          data-cy=\"c8y-alarms-widget--realtime-indicator\"\n        >\n          <span\n            class=\"c8y-pulse m-0\"\n            [ngClass]=\"{\n              active: isRealtimeToggleOn,\n              inactive: !isRealtimeToggleOn\n            }\"\n          ></span>\n        </button>\n      </div>\n    </div>\n  </div>\n</div>", dependencies: [{ kind: "directive", type: i3.IconDirective, selector: "[c8yIcon]", inputs: ["c8yIcon"] }, { kind: "directive", type: i4.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.CountdownIntervalComponent, selector: "c8y-countdown-interval", inputs: ["countdownInterval"], outputs: ["countdownEnded"] }, { kind: "directive", type: i5.TooltipDirective, selector: "[tooltip], [tooltipHtml]", inputs: ["adaptivePosition", "tooltip", "placement", "triggers", "container", "containerClass", "boundariesElement", "isOpen", "isDisabled", "delay", "tooltipHtml", "tooltipPlacement", "tooltipIsOpen", "tooltipEnable", "tooltipAppendToBody", "tooltipAnimation", "tooltipClass", "tooltipContext", "tooltipPopupDelay", "tooltipFadeDuration", "tooltipTrigger"], outputs: ["tooltipChange", "onShown", "onHidden", "tooltipStateChanged"], exportAs: ["bs-tooltip"] }, { kind: "pipe", type: i3.C8yTranslatePipe, name: "translate" }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: AlarmWidgetAlarmsReloadComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'c8y-alarm-widget-alarms-reload', template: "<div\n  class=\"m-l-auto d-flex p-t-4 p-b-4\"\n  *ngIf=\"!globalAutoRefreshEnabled\"\n>\n  <div class=\"m-l-auto d-flex a-i-center\">\n    <label\n      class=\"m-b-0 m-r-8 text-label-small text-truncate flex-no-shrink\"\n      title=\" {{ 'Auto refresh' | translate }}\"\n      *ngIf=\"isIntervalRefresh && refreshInterval && config.isAutoRefreshEnabled\"\n    >\n      {{ 'Auto refresh' | translate }}\n    </label>\n    <div class=\"input-group\">\n      <label\n        class=\"toggle-countdown\"\n        [class.toggle-countdown-disabled]=\"isRefreshDisabled\"\n        [attr.aria-label]=\"toggleCountdownButtonTooltipText\"\n        [tooltip]=\"toggleCountdownButtonTooltipText\"\n        placement=\"bottom\"\n        *ngIf=\"isIntervalRefresh && refreshInterval && config.isAutoRefreshEnabled\"\n        [adaptivePosition]=\"false\"\n        [container]=\"'body'\"\n        [delay]=\"500\"\n      >\n        <input\n          type=\"checkbox\"\n          data-cy=\"c8y-alarms-widget--interval-toggle-button\"\n          (click)=\"onToggleCountdownButtonState($event)\"\n        />\n        <c8y-countdown-interval\n          *ngIf=\"isIntervalRefreshToggleOn\"\n          [countdownInterval]=\"refreshInterval\"\n          (countdownEnded)=\"countdownEnded()\"\n        ></c8y-countdown-interval>\n        <i\n          c8yIcon=\"pause\"\n          *ngIf=\"!isIntervalRefreshToggleOn\"\n        ></i>\n      </label>\n\n      <div class=\"input-group-btn\">\n        <button\n          class=\"btn btn-default\"\n          [attr.aria-label]=\"'Refresh' | translate\"\n          [tooltip]=\"\n            !isNewAlarmMessageCleared\n              ? (REALTIME_UPDATE_ALARMS_MESSAGE | translate)\n              : ('Refresh' | translate)\n          \"\n          placement=\"bottom\"\n          type=\"button\"\n          [adaptivePosition]=\"false\"\n          [container]=\"'body'\"\n          [delay]=\"500\"\n          [disabled]=\"isRefreshDisabled || (isLoading | async)\"\n          (click)=\"reload()\"\n          data-cy=\"c8y-alarms-widget--reload-button\"\n        >\n          <span\n            class=\"tag tag--info m-r-8\"\n            *ngIf=\"!isNewAlarmMessageCleared\"\n          >\n            {{ 'New alarms' | translate }}\n          </span>\n          <i\n            c8yIcon=\"refresh\"\n            [ngClass]=\"{ 'icon-spin': isLoading | async }\"\n          ></i>\n        </button>\n      </div>\n      <div\n        class=\"input-group-btn input-group-btn--last\"\n        *ngIf=\"!isIntervalRefresh\"\n      >\n        <button\n          class=\"c8y-realtime btn btn-default\"\n          [attr.aria-label]=\"realtimeIconTitle\"\n          [tooltip]=\"realtimeIconTitle\"\n          placement=\"bottom\"\n          type=\"button\"\n          [container]=\"'body'\"\n          (click)=\"toggleRealtimeState()\"\n          [disabled]=\"isRefreshDisabled\"\n        >\n          <span\n            class=\"c8y-pulse m-0\"\n            [ngClass]=\"{\n              active: isRealtimeToggleOn,\n              inactive: !isRealtimeToggleOn\n            }\"\n          ></span>\n        </button>\n      </div>\n    </div>\n  </div>\n</div>\n" }]
-        }], ctorParameters: () => [{ type: i1.AlarmsViewService }, { type: i0.ChangeDetectorRef }, { type: i2.TranslateService }, { type: i3.WidgetGlobalAutoRefreshService }], propDecorators: { isIntervalRefresh: [{
+            args: [{ selector: 'c8y-alarm-widget-alarms-reload', template: "<div\n  class=\"m-l-auto d-flex p-t-4 p-b-4\"\n  *ngIf=\"!globalAutoRefreshEnabled\"\n>\n  <div class=\"m-l-auto d-flex a-i-center\">\n    <label\n      class=\"m-b-0 m-r-8 text-label-small text-truncate flex-no-shrink\"\n      title=\" {{ 'Auto refresh' | translate }}\"\n      *ngIf=\"isIntervalRefresh && refreshInterval && config.isAutoRefreshEnabled\"\n    >\n      {{ 'Auto refresh' | translate }}\n    </label>\n    <div class=\"input-group\">\n      <label\n        class=\"toggle-countdown\"\n        [class.toggle-countdown-disabled]=\"isRefreshDisabled\"\n        [attr.aria-label]=\"toggleCountdownButtonTooltipText\"\n        [tooltip]=\"toggleCountdownButtonTooltipText\"\n        placement=\"bottom\"\n        *ngIf=\"isIntervalRefresh && refreshInterval && config.isAutoRefreshEnabled\"\n        [adaptivePosition]=\"false\"\n        [container]=\"'body'\"\n        [delay]=\"500\"\n      >\n        <input\n          type=\"checkbox\"\n          data-cy=\"c8y-alarms-widget--interval-toggle-button\"\n          (click)=\"onToggleCountdownButtonState($event, WIDGET_TYPE_VALUES.ALARMS)\"\n        />\n        <c8y-countdown-interval\n          *ngIf=\"isIntervalRefreshToggleOn\"\n          [countdownInterval]=\"refreshInterval\"\n          (countdownEnded)=\"countdownEnded()\"\n        ></c8y-countdown-interval>\n        <i\n          c8yIcon=\"pause\"\n          *ngIf=\"!isIntervalRefreshToggleOn\"\n        ></i>\n      </label>\n\n      <div class=\"input-group-btn\">\n        <button\n          class=\"btn btn-default\"\n          [attr.aria-label]=\"'Refresh' | translate\"\n          [tooltip]=\"\n            !isNewAlarmMessageCleared\n              ? (REALTIME_UPDATE_ALARMS_MESSAGE | translate)\n              : ('Refresh' | translate)\n          \"\n          placement=\"bottom\"\n          type=\"button\"\n          [adaptivePosition]=\"false\"\n          [container]=\"'body'\"\n          [delay]=\"500\"\n          [disabled]=\"isRefreshDisabled || (isLoading | async)\"\n          (click)=\"reload()\"\n          data-cy=\"c8y-alarms-widget--reload-button\"\n        >\n          <span\n            class=\"tag tag--info m-r-8\"\n            *ngIf=\"!isNewAlarmMessageCleared\"\n          >\n            {{ 'New alarms' | translate }}\n          </span>\n          <i\n            c8yIcon=\"refresh\"\n            [ngClass]=\"{ 'icon-spin': isLoading | async }\"\n          ></i>\n        </button>\n      </div>\n      <div\n        class=\"input-group-btn input-group-btn--last\"\n        *ngIf=\"!isIntervalRefresh\"\n      >\n        <button\n          class=\"c8y-realtime btn btn-default\"\n          [attr.aria-label]=\"realtimeIconTitle\"\n          [tooltip]=\"realtimeIconTitle\"\n          placement=\"bottom\"\n          type=\"button\"\n          [container]=\"'body'\"\n          (click)=\"toggleRealtimeState()\"\n          [disabled]=\"isRefreshDisabled\"\n          data-cy=\"c8y-alarms-widget--realtime-indicator\"\n        >\n          <span\n            class=\"c8y-pulse m-0\"\n            [ngClass]=\"{\n              active: isRealtimeToggleOn,\n              inactive: !isRealtimeToggleOn\n            }\"\n          ></span>\n        </button>\n      </div>\n    </div>\n  </div>\n</div>" }]
+        }], ctorParameters: () => [{ type: i1.AlarmsViewService }, { type: i0.ChangeDetectorRef }, { type: i2.TranslateService }, { type: i3.WidgetGlobalAutoRefreshService }, { type: i3.GainsightService }], propDecorators: { isIntervalRefresh: [{
                 type: Input
             }], refreshInterval: [{
                 type: Input
@@ -183,4 +185,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImpor
                 type: ViewChild,
                 args: [CountdownIntervalComponent, { static: false }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alarm-widget-alarms-reload.component.js","sourceRoot":"","sources":["../../../../../widgets/implementations/alarms/alarm-widget-alarms-reload.component.ts","../../../../../widgets/implementations/alarms/alarm-widget-alarms-reload.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  SimpleChanges,\n  ViewChild\n} from '@angular/core';\nimport {\n  CountdownIntervalComponent,\n  gettext,\n  IntervalBasedReload,\n  WidgetGlobalAutoRefreshService\n} from '@c8y/ngx-components';\nimport { AlarmsViewService } from '@c8y/ngx-components/alarms';\nimport { TranslateService } from '@ngx-translate/core';\nimport { BehaviorSubject, Subscription } from 'rxjs';\nimport { tap } from 'rxjs/operators';\nimport { AlarmListWidgetConfig, GLOBAL_INTERVAL_OPTION } from './alarm-list-widget.model';\n\n@Component({\n  selector: 'c8y-alarm-widget-alarms-reload',\n  templateUrl: './alarm-widget-alarms-reload.component.html'\n})\nexport class AlarmWidgetAlarmsReloadComponent\n  extends IntervalBasedReload\n  implements OnInit, AfterViewInit, OnChanges, OnDestroy\n{\n  readonly REALTIME_UPDATE_ALARMS_MESSAGE = this.alarmsViewService.REALTIME_UPDATE_ALARMS_MESSAGE;\n\n  /**\n   * State of this boolean depends on an Application Options \"alarmsRefreshType\" setting.\n   */\n  @Input() isIntervalRefresh: boolean;\n  /**\n   * @inheritdoc\n   */\n  @Input() refreshInterval: number;\n  /**\n   * Alarm widgets config.\n   */\n  @Input() config: AlarmListWidgetConfig;\n  /**\n   * @inheritdoc\n   */\n  @Input() isLoading: BehaviorSubject<boolean>;\n  /**\n   * Indicates whether the alarm list is being scrolled or not.\n   */\n  @Input() isScrolling: boolean;\n  /**\n   * @inheritdoc\n   */\n  @Input() isRefreshDisabled: boolean;\n  /**\n   * @inheritdoc\n   */\n  @Output() onCountdownEnded = new EventEmitter<void>();\n  /**\n   * Emitted to indicate that the widgets realtime button state has changed.\n   */\n  @Output() onRealTimeToggleChanged: EventEmitter<boolean> = new EventEmitter<boolean>();\n\n  @ViewChild(CountdownIntervalComponent, { static: false })\n  countdownIntervalComponent: CountdownIntervalComponent;\n  /**\n   * @inheritdoc\n   */\n  protected hideCountdown: boolean;\n  /**\n   * Tooltip for a new realtime alarm indicator.\n   */\n  realtimeIconTitle: string;\n  /**\n   * Indicates whether the countdown has been cleared already.\n   */\n  isNewAlarmMessageCleared = true;\n  /**\n   * @inheritdoc\n   */\n  isIntervalRefreshToggleOn: boolean;\n  /**\n   * Indicates the current state of an realtime toggle button.\n   */\n  isRealtimeToggleOn: boolean;\n  /**\n   * Holds the subscription to a countdown observable.\n   */\n  countdownSubscription: Subscription;\n  /**\n   * @inheritdoc\n   */\n  protected manuallyDisabledCountdown = false;\n\n  toggleCountdownButtonTooltipText: string;\n  globalAutoRefreshEnabled: boolean;\n\n  constructor(\n    private alarmsViewService: AlarmsViewService,\n    private cdRef: ChangeDetectorRef,\n    private translateService: TranslateService,\n    private widgetGlobalAutoRefreshService: WidgetGlobalAutoRefreshService\n  ) {\n    super();\n  }\n\n  ngOnInit() {\n    if (!this.isIntervalRefresh) {\n      this.isRealtimeToggleOn = this.config.isAutoRefreshEnabled;\n      this.realtimeIconTitle = this.getRealtimeIconTitle();\n    } else {\n      this.isIntervalRefreshToggleOn =\n        !this.isRefreshDisabled && (this.config.isAutoRefreshEnabled || !!this.refreshInterval);\n      this.updateCountdownButtonTooltipText();\n    }\n  }\n\n  ngAfterViewInit() {\n    if (this.isIntervalRefresh && this.refreshInterval) {\n      this.startCountdown();\n    }\n\n    if (this.globalAutoRefreshEnabled) {\n      this.widgetGlobalAutoRefreshService.countdownActions.countdownEnded$\n        .pipe(tap(() => this.onCountdownEnded.emit()))\n        .subscribe();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    const { isDisabled, config } = changes;\n    if (config) {\n      this.globalAutoRefreshEnabled = this.config.refreshOption === GLOBAL_INTERVAL_OPTION;\n    }\n    if (isDisabled) {\n      this.isIntervalRefreshToggleOn =\n        !this.isRefreshDisabled && (this.config.isAutoRefreshEnabled || !!this.refreshInterval);\n      this.updateCountdownButtonTooltipText(gettext('Disabled'));\n    }\n\n    if (\n      !this.isIntervalRefresh ||\n      this.manuallyDisabledCountdown ||\n      !this.config.isAutoRefreshEnabled\n    ) {\n      return;\n    }\n\n    this.handleScrolling();\n  }\n\n  ngOnDestroy() {\n    if (this.countdownSubscription) {\n      this.countdownSubscription.unsubscribe();\n    }\n  }\n\n  /**\n   * @inheritdoc\n   */\n  countdownEnded(): void {\n    /**\n     * @inheritdoc\n     */\n    this.autoRefreshList();\n  }\n\n  reload(): void {\n    if (this.isIntervalRefresh) {\n      this.autoRefreshList();\n    } else {\n      this.onCountdownEnded.emit();\n      this.isNewAlarmMessageCleared = true;\n    }\n  }\n\n  /**\n   * Toggles the real-time state of the component.\n   *\n   * This method switches the `isRealtimeToggleOn` state between true and false.\n   * When the state is toggled, it emits the current state through `onRealTimeToggleChanged` event.\n   * It also updates the `realtimeIconTitle` based on the new state.\n   */\n  toggleRealtimeState(): void {\n    this.isRealtimeToggleOn = !this.isRealtimeToggleOn;\n    this.onRealTimeToggleChanged.emit(this.isRealtimeToggleOn);\n    this.realtimeIconTitle = this.getRealtimeIconTitle();\n  }\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.config.isAutoRefreshEnabled) {\n      this.countdownIntervalComponent.stop();\n    }\n    this.onCountdownEnded.emit();\n  }\n\n  /**\n   * Sets the tooltip message for a new realtime alarm indicator.\n   * @returns Tooltip message.\n   */\n  getRealtimeIconTitle(): string {\n    return this.isRealtimeToggleOn\n      ? this.translateService.instant(gettext('Realtime active'))\n      : this.translateService.instant(gettext('Realtime inactive'));\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  enableCountdown(): void {\n    this.hideCountdown = false;\n    // Prevents the countdown from getting stuck on an initial value.\n    this.cdRef.detectChanges();\n    this.startCountdown();\n  }\n\n  /**\n   * @inheritdoc\n   */\n  protected updateCountdownButtonTooltipText(customText?: string): void {\n    if (customText) {\n      this.toggleCountdownButtonTooltipText = customText;\n      return;\n    }\n    this.toggleCountdownButtonTooltipText = this.isIntervalRefreshToggleOn\n      ? this.translateService.instant(gettext('Disable auto refresh'))\n      : this.translateService.instant(gettext('Enable auto refresh'));\n  }\n}\n","<div\n  class=\"m-l-auto d-flex p-t-4 p-b-4\"\n  *ngIf=\"!globalAutoRefreshEnabled\"\n>\n  <div class=\"m-l-auto d-flex a-i-center\">\n    <label\n      class=\"m-b-0 m-r-8 text-label-small text-truncate flex-no-shrink\"\n      title=\" {{ 'Auto refresh' | translate }}\"\n      *ngIf=\"isIntervalRefresh && refreshInterval && config.isAutoRefreshEnabled\"\n    >\n      {{ 'Auto refresh' | translate }}\n    </label>\n    <div class=\"input-group\">\n      <label\n        class=\"toggle-countdown\"\n        [class.toggle-countdown-disabled]=\"isRefreshDisabled\"\n        [attr.aria-label]=\"toggleCountdownButtonTooltipText\"\n        [tooltip]=\"toggleCountdownButtonTooltipText\"\n        placement=\"bottom\"\n        *ngIf=\"isIntervalRefresh && refreshInterval && config.isAutoRefreshEnabled\"\n        [adaptivePosition]=\"false\"\n        [container]=\"'body'\"\n        [delay]=\"500\"\n      >\n        <input\n          type=\"checkbox\"\n          data-cy=\"c8y-alarms-widget--interval-toggle-button\"\n          (click)=\"onToggleCountdownButtonState($event)\"\n        />\n        <c8y-countdown-interval\n          *ngIf=\"isIntervalRefreshToggleOn\"\n          [countdownInterval]=\"refreshInterval\"\n          (countdownEnded)=\"countdownEnded()\"\n        ></c8y-countdown-interval>\n        <i\n          c8yIcon=\"pause\"\n          *ngIf=\"!isIntervalRefreshToggleOn\"\n        ></i>\n      </label>\n\n      <div class=\"input-group-btn\">\n        <button\n          class=\"btn btn-default\"\n          [attr.aria-label]=\"'Refresh' | translate\"\n          [tooltip]=\"\n            !isNewAlarmMessageCleared\n              ? (REALTIME_UPDATE_ALARMS_MESSAGE | translate)\n              : ('Refresh' | translate)\n          \"\n          placement=\"bottom\"\n          type=\"button\"\n          [adaptivePosition]=\"false\"\n          [container]=\"'body'\"\n          [delay]=\"500\"\n          [disabled]=\"isRefreshDisabled || (isLoading | async)\"\n          (click)=\"reload()\"\n          data-cy=\"c8y-alarms-widget--reload-button\"\n        >\n          <span\n            class=\"tag tag--info m-r-8\"\n            *ngIf=\"!isNewAlarmMessageCleared\"\n          >\n            {{ 'New alarms' | translate }}\n          </span>\n          <i\n            c8yIcon=\"refresh\"\n            [ngClass]=\"{ 'icon-spin': isLoading | async }\"\n          ></i>\n        </button>\n      </div>\n      <div\n        class=\"input-group-btn input-group-btn--last\"\n        *ngIf=\"!isIntervalRefresh\"\n      >\n        <button\n          class=\"c8y-realtime btn btn-default\"\n          [attr.aria-label]=\"realtimeIconTitle\"\n          [tooltip]=\"realtimeIconTitle\"\n          placement=\"bottom\"\n          type=\"button\"\n          [container]=\"'body'\"\n          (click)=\"toggleRealtimeState()\"\n          [disabled]=\"isRefreshDisabled\"\n        >\n          <span\n            class=\"c8y-pulse m-0\"\n            [ngClass]=\"{\n              active: isRealtimeToggleOn,\n              inactive: !isRealtimeToggleOn\n            }\"\n          ></span>\n        </button>\n      </div>\n    </div>\n  </div>\n</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alarm-widget-alarms-reload.component.js","sourceRoot":"","sources":["../../../../../widgets/implementations/alarms/alarm-widget-alarms-reload.component.ts","../../../../../widgets/implementations/alarms/alarm-widget-alarms-reload.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  SimpleChanges,\n  ViewChild\n} from '@angular/core';\nimport {\n  CountdownIntervalComponent,\n  gettext,\n  IntervalBasedReload,\n  WIDGET_TYPE_VALUES,\n  WidgetGlobalAutoRefreshService,\n  GainsightService\n} from '@c8y/ngx-components';\nimport { AlarmsViewService } from '@c8y/ngx-components/alarms';\nimport { TranslateService } from '@ngx-translate/core';\nimport { BehaviorSubject, Subscription } from 'rxjs';\nimport { tap } from 'rxjs/operators';\nimport { AlarmListWidgetConfig, GLOBAL_INTERVAL_OPTION } from './alarm-list-widget.model';\n\n@Component({\n  selector: 'c8y-alarm-widget-alarms-reload',\n  templateUrl: './alarm-widget-alarms-reload.component.html'\n})\nexport class AlarmWidgetAlarmsReloadComponent\n  extends IntervalBasedReload\n  implements OnInit, AfterViewInit, OnChanges, OnDestroy\n{\n  readonly REALTIME_UPDATE_ALARMS_MESSAGE = this.alarmsViewService.REALTIME_UPDATE_ALARMS_MESSAGE;\n  readonly WIDGET_TYPE_VALUES = WIDGET_TYPE_VALUES;\n\n  /**\n   * State of this boolean depends on an Application Options \"alarmsRefreshType\" setting.\n   */\n  @Input() isIntervalRefresh: boolean;\n  /**\n   * @inheritdoc\n   */\n  @Input() refreshInterval: number;\n  /**\n   * Alarm widgets config.\n   */\n  @Input() config: AlarmListWidgetConfig;\n  /**\n   * @inheritdoc\n   */\n  @Input() isLoading: BehaviorSubject<boolean>;\n  /**\n   * Indicates whether the alarm list is being scrolled or not.\n   */\n  @Input() isScrolling: boolean;\n  /**\n   * @inheritdoc\n   */\n  @Input() isRefreshDisabled: boolean;\n  /**\n   * @inheritdoc\n   */\n  @Output() onCountdownEnded = new EventEmitter<void>();\n  /**\n   * Emitted to indicate that the widgets realtime button state has changed.\n   */\n  @Output() onRealTimeToggleChanged: EventEmitter<boolean> = new EventEmitter<boolean>();\n\n  @ViewChild(CountdownIntervalComponent, { static: false })\n  countdownIntervalComponent: CountdownIntervalComponent;\n  /**\n   * @inheritdoc\n   */\n  protected hideCountdown: boolean;\n  /**\n   * Tooltip for a new realtime alarm indicator.\n   */\n  realtimeIconTitle: string;\n  /**\n   * Indicates whether the countdown has been cleared already.\n   */\n  isNewAlarmMessageCleared = true;\n  /**\n   * @inheritdoc\n   */\n  isIntervalRefreshToggleOn: boolean;\n  /**\n   * Indicates the current state of an realtime toggle button.\n   */\n  isRealtimeToggleOn: boolean;\n  /**\n   * Holds the subscription to a countdown observable.\n   */\n  countdownSubscription: Subscription;\n  /**\n   * @inheritdoc\n   */\n  protected manuallyDisabledCountdown = false;\n\n  toggleCountdownButtonTooltipText: string;\n  globalAutoRefreshEnabled: boolean;\n\n  constructor(\n    private alarmsViewService: AlarmsViewService,\n    private cdRef: ChangeDetectorRef,\n    private translateService: TranslateService,\n    private widgetGlobalAutoRefreshService: WidgetGlobalAutoRefreshService,\n    protected gainsightService: GainsightService\n  ) {\n    super();\n  }\n\n  ngOnInit() {\n    if (!this.isIntervalRefresh) {\n      this.isRealtimeToggleOn = this.config.isAutoRefreshEnabled;\n      this.realtimeIconTitle = this.getRealtimeIconTitle();\n    } else {\n      this.isIntervalRefreshToggleOn =\n        !this.isRefreshDisabled && (this.config.isAutoRefreshEnabled || !!this.refreshInterval);\n      this.updateCountdownButtonTooltipText();\n    }\n  }\n\n  ngAfterViewInit() {\n    if (this.isIntervalRefresh && this.refreshInterval) {\n      this.startCountdown();\n    }\n\n    if (this.globalAutoRefreshEnabled) {\n      this.widgetGlobalAutoRefreshService.countdownActions.countdownEnded$\n        .pipe(tap(() => this.onCountdownEnded.emit()))\n        .subscribe();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    const { isDisabled, config } = changes;\n    if (config) {\n      this.globalAutoRefreshEnabled = this.config.refreshOption === GLOBAL_INTERVAL_OPTION;\n    }\n    if (isDisabled) {\n      this.isIntervalRefreshToggleOn =\n        !this.isRefreshDisabled && (this.config.isAutoRefreshEnabled || !!this.refreshInterval);\n      this.updateCountdownButtonTooltipText(gettext('Disabled'));\n    }\n\n    if (\n      !this.isIntervalRefresh ||\n      this.manuallyDisabledCountdown ||\n      !this.config.isAutoRefreshEnabled\n    ) {\n      return;\n    }\n\n    this.handleScrolling();\n  }\n\n  ngOnDestroy() {\n    if (this.countdownSubscription) {\n      this.countdownSubscription.unsubscribe();\n    }\n  }\n\n  /**\n   * @inheritdoc\n   */\n  countdownEnded(): void {\n    /**\n     * @inheritdoc\n     */\n    this.autoRefreshList();\n  }\n\n  reload(): void {\n    if (this.isIntervalRefresh) {\n      this.autoRefreshList();\n    } else {\n      this.onCountdownEnded.emit();\n      this.isNewAlarmMessageCleared = true;\n    }\n  }\n\n  /**\n   * Toggles the real-time state of the component.\n   *\n   * This method switches the `isRealtimeToggleOn` state between true and false.\n   * When the state is toggled, it emits the current state through `onRealTimeToggleChanged` event.\n   * It also updates the `realtimeIconTitle` based on the new state.\n   */\n  toggleRealtimeState(): void {\n    this.isRealtimeToggleOn = !this.isRealtimeToggleOn;\n    this.onRealTimeToggleChanged.emit(this.isRealtimeToggleOn);\n    this.realtimeIconTitle = this.getRealtimeIconTitle();\n  }\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.config.isAutoRefreshEnabled) {\n      this.countdownIntervalComponent.stop();\n    }\n    this.onCountdownEnded.emit();\n  }\n\n  /**\n   * Sets the tooltip message for a new realtime alarm indicator.\n   * @returns Tooltip message.\n   */\n  getRealtimeIconTitle(): string {\n    return this.isRealtimeToggleOn\n      ? this.translateService.instant(gettext('Realtime active'))\n      : this.translateService.instant(gettext('Realtime inactive'));\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  enableCountdown(): void {\n    this.hideCountdown = false;\n    // Prevents the countdown from getting stuck on an initial value.\n    this.cdRef.detectChanges();\n    this.startCountdown();\n  }\n\n  /**\n   * @inheritdoc\n   */\n  protected updateCountdownButtonTooltipText(customText?: string): void {\n    if (customText) {\n      this.toggleCountdownButtonTooltipText = customText;\n      return;\n    }\n    this.toggleCountdownButtonTooltipText = this.isIntervalRefreshToggleOn\n      ? this.translateService.instant(gettext('Disable auto refresh'))\n      : this.translateService.instant(gettext('Enable auto refresh'));\n  }\n}\n","<div\n  class=\"m-l-auto d-flex p-t-4 p-b-4\"\n  *ngIf=\"!globalAutoRefreshEnabled\"\n>\n  <div class=\"m-l-auto d-flex a-i-center\">\n    <label\n      class=\"m-b-0 m-r-8 text-label-small text-truncate flex-no-shrink\"\n      title=\" {{ 'Auto refresh' | translate }}\"\n      *ngIf=\"isIntervalRefresh && refreshInterval && config.isAutoRefreshEnabled\"\n    >\n      {{ 'Auto refresh' | translate }}\n    </label>\n    <div class=\"input-group\">\n      <label\n        class=\"toggle-countdown\"\n        [class.toggle-countdown-disabled]=\"isRefreshDisabled\"\n        [attr.aria-label]=\"toggleCountdownButtonTooltipText\"\n        [tooltip]=\"toggleCountdownButtonTooltipText\"\n        placement=\"bottom\"\n        *ngIf=\"isIntervalRefresh && refreshInterval && config.isAutoRefreshEnabled\"\n        [adaptivePosition]=\"false\"\n        [container]=\"'body'\"\n        [delay]=\"500\"\n      >\n        <input\n          type=\"checkbox\"\n          data-cy=\"c8y-alarms-widget--interval-toggle-button\"\n          (click)=\"onToggleCountdownButtonState($event, WIDGET_TYPE_VALUES.ALARMS)\"\n        />\n        <c8y-countdown-interval\n          *ngIf=\"isIntervalRefreshToggleOn\"\n          [countdownInterval]=\"refreshInterval\"\n          (countdownEnded)=\"countdownEnded()\"\n        ></c8y-countdown-interval>\n        <i\n          c8yIcon=\"pause\"\n          *ngIf=\"!isIntervalRefreshToggleOn\"\n        ></i>\n      </label>\n\n      <div class=\"input-group-btn\">\n        <button\n          class=\"btn btn-default\"\n          [attr.aria-label]=\"'Refresh' | translate\"\n          [tooltip]=\"\n            !isNewAlarmMessageCleared\n              ? (REALTIME_UPDATE_ALARMS_MESSAGE | translate)\n              : ('Refresh' | translate)\n          \"\n          placement=\"bottom\"\n          type=\"button\"\n          [adaptivePosition]=\"false\"\n          [container]=\"'body'\"\n          [delay]=\"500\"\n          [disabled]=\"isRefreshDisabled || (isLoading | async)\"\n          (click)=\"reload()\"\n          data-cy=\"c8y-alarms-widget--reload-button\"\n        >\n          <span\n            class=\"tag tag--info m-r-8\"\n            *ngIf=\"!isNewAlarmMessageCleared\"\n          >\n            {{ 'New alarms' | translate }}\n          </span>\n          <i\n            c8yIcon=\"refresh\"\n            [ngClass]=\"{ 'icon-spin': isLoading | async }\"\n          ></i>\n        </button>\n      </div>\n      <div\n        class=\"input-group-btn input-group-btn--last\"\n        *ngIf=\"!isIntervalRefresh\"\n      >\n        <button\n          class=\"c8y-realtime btn btn-default\"\n          [attr.aria-label]=\"realtimeIconTitle\"\n          [tooltip]=\"realtimeIconTitle\"\n          placement=\"bottom\"\n          type=\"button\"\n          [container]=\"'body'\"\n          (click)=\"toggleRealtimeState()\"\n          [disabled]=\"isRefreshDisabled\"\n          data-cy=\"c8y-alarms-widget--realtime-indicator\"\n        >\n          <span\n            class=\"c8y-pulse m-0\"\n            [ngClass]=\"{\n              active: isRealtimeToggleOn,\n              inactive: !isRealtimeToggleOn\n            }\"\n          ></span>\n        </button>\n      </div>\n    </div>\n  </div>\n</div>"]}

package/esm2022/widgets/implementations/datapoints-table/datapoints-table-view/datapoints-reload/datapoints-reload.component.mjs

@@ -1,5 +1,5 @@
 import { ChangeDetectorRef, Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';
-import { CommonModule, CountdownIntervalComponent, CountdownIntervalModule, IntervalBasedReload, ListGroupModule, WidgetGlobalAutoRefreshService, gettext } from '@c8y/ngx-components';
+import { CommonModule, CountdownIntervalComponent, CountdownIntervalModule, GainsightService, IntervalBasedReload, ListGroupModule, WIDGET_TYPE_VALUES, WidgetGlobalAutoRefreshService, gettext } from '@c8y/ngx-components';
 import { TranslateService } from '@ngx-translate/core';
 import { TooltipModule } from 'ngx-bootstrap/tooltip';
 import { BehaviorSubject, Subject, takeUntil, tap } from 'rxjs';
@@ -9,11 +9,13 @@ import * as i2 from "@c8y/ngx-components";
 import * as i3 from "@angular/common";
 import * as i4 from "ngx-bootstrap/tooltip";
 export class DatapointsReloadComponent extends IntervalBasedReload {
-    constructor(cdRef, translateService, widgetGlobalAutoRefreshService) {
+    constructor(cdRef, translateService, widgetGlobalAutoRefreshService, gainsightService) {
         super();
         this.cdRef = cdRef;
         this.translateService = translateService;
         this.widgetGlobalAutoRefreshService = widgetGlobalAutoRefreshService;
+        this.gainsightService = gainsightService;
+        this.WIDGET_TYPE_VALUES = WIDGET_TYPE_VALUES;
         /**
          * @inheritdoc
          */
@@ -109,13 +111,13 @@ export class DatapointsReloadComponent extends IntervalBasedReload {
             !this.isScrolling &&
             !this.hideCountdown);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DatapointsReloadComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.TranslateService }, { token: i2.WidgetGlobalAutoRefreshService }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: DatapointsReloadComponent, isStandalone: true, selector: "c8y-datapoints-reload", inputs: { isAutoRefreshEnabled: "isAutoRefreshEnabled", isRefreshDisabled: "isRefreshDisabled", isLoading: "isLoading", isScrolling: "isScrolling", isExportModalOpen: "isExportModalOpen", refreshInterval: "refreshInterval", widgetInstanceGlobalAutoRefreshContext: "widgetInstanceGlobalAutoRefreshContext" }, outputs: { onCountdownEnded: "onCountdownEnded" }, viewQueries: [{ propertyName: "countdownIntervalComponent", first: true, predicate: CountdownIntervalComponent, descendants: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"!widgetInstanceGlobalAutoRefreshContext\">\n  <div class=\"a-i-center input-group p-t-4 p-b-4 max-width-fit m-l-auto\">\n    <label\n      class=\"m-b-0 m-r-8 text-label-small text-truncate flex-no-shrink\"\n      title=\" {{ 'Auto refresh' | translate }}\"\n      *ngIf=\"refreshInterval && isAutoRefreshEnabled\"\n    >\n      {{ 'Auto refresh' | translate }}\n    </label>\n    <div class=\"input-group\">\n      <label\n        class=\"toggle-countdown\"\n        [class.toggle-countdown-disabled]=\"isRefreshDisabled\"\n        [attr.aria-label]=\"toggleCountdownButtonTooltipText\"\n        [tooltip]=\"toggleCountdownButtonTooltipText\"\n        placement=\"bottom\"\n        *ngIf=\"refreshInterval && isAutoRefreshEnabled\"\n        [adaptivePosition]=\"false\"\n        [container]=\"'body'\"\n        [delay]=\"500\"\n      >\n        <input\n          type=\"checkbox\"\n          [checked]=\"isIntervalRefreshToggleOn\"\n          [disabled]=\"isRefreshDisabled\"\n          data-cy=\"c8y-data-points-table-widget--interval-toggle-button\"\n          (click)=\"onToggleCountdownButtonState($event)\"\n        />\n\n        <c8y-countdown-interval\n          *ngIf=\"isIntervalRefreshToggleOn\"\n          [countdownInterval]=\"refreshInterval\"\n          (countdownEnded)=\"countdownEnded()\"\n        ></c8y-countdown-interval>\n        <i\n          c8yIcon=\"pause\"\n          *ngIf=\"!isIntervalRefreshToggleOn\"\n        ></i>\n      </label>\n\n      <div class=\"input-group-btn\">\n        <button\n          class=\"btn btn-default\"\n          [attr.aria-label]=\"'Refresh' | translate\"\n          [tooltip]=\"'Refresh' | translate\"\n          placement=\"bottom\"\n          type=\"button\"\n          [adaptivePosition]=\"false\"\n          [container]=\"'body'\"\n          [delay]=\"500\"\n          [disabled]=\"isRefreshDisabled || (isLoading | async)\"\n          (click)=\"reload()\"\n          data-cy=\"c8y-data-points-table-widget--reload-button\"\n        >\n          <i\n            c8yIcon=\"refresh\"\n            [ngClass]=\"{ 'icon-spin': isLoading | async }\"\n          ></i>\n        </button>\n      </div>\n    </div>\n  </div>\n</ng-container>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.IconDirective, selector: "[c8yIcon]", inputs: ["c8yIcon"] }, { kind: "pipe", type: i2.C8yTranslatePipe, name: "translate" }, { kind: "directive", type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }, { kind: "ngmodule", type: CountdownIntervalModule }, { kind: "component", type: i2.CountdownIntervalComponent, selector: "c8y-countdown-interval", inputs: ["countdownInterval"], outputs: ["countdownEnded"] }, { kind: "ngmodule", type: ListGroupModule }, { kind: "ngmodule", type: TooltipModule }, { kind: "directive", type: i4.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"] }] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DatapointsReloadComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.TranslateService }, { token: i2.WidgetGlobalAutoRefreshService }, { token: i2.GainsightService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: DatapointsReloadComponent, isStandalone: true, selector: "c8y-datapoints-reload", inputs: { isAutoRefreshEnabled: "isAutoRefreshEnabled", isRefreshDisabled: "isRefreshDisabled", isLoading: "isLoading", isScrolling: "isScrolling", isExportModalOpen: "isExportModalOpen", refreshInterval: "refreshInterval", widgetInstanceGlobalAutoRefreshContext: "widgetInstanceGlobalAutoRefreshContext" }, outputs: { onCountdownEnded: "onCountdownEnded" }, viewQueries: [{ propertyName: "countdownIntervalComponent", first: true, predicate: CountdownIntervalComponent, descendants: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"!widgetInstanceGlobalAutoRefreshContext\">\n  <div class=\"a-i-center input-group p-t-4 p-b-4 max-width-fit m-l-auto\">\n    <label\n      class=\"m-b-0 m-r-8 text-label-small text-truncate flex-no-shrink\"\n      title=\" {{ 'Auto refresh' | translate }}\"\n      *ngIf=\"refreshInterval && isAutoRefreshEnabled\"\n    >\n      {{ 'Auto refresh' | translate }}\n    </label>\n    <div class=\"input-group\">\n      <label\n        class=\"toggle-countdown\"\n        [class.toggle-countdown-disabled]=\"isRefreshDisabled\"\n        [attr.aria-label]=\"toggleCountdownButtonTooltipText\"\n        [tooltip]=\"toggleCountdownButtonTooltipText\"\n        placement=\"bottom\"\n        *ngIf=\"refreshInterval && isAutoRefreshEnabled\"\n        [adaptivePosition]=\"false\"\n        [container]=\"'body'\"\n        [delay]=\"500\"\n      >\n        <input\n          type=\"checkbox\"\n          [checked]=\"isIntervalRefreshToggleOn\"\n          [disabled]=\"isRefreshDisabled\"\n          data-cy=\"c8y-data-points-table-widget--interval-toggle-button\"\n          (click)=\"onToggleCountdownButtonState($event, WIDGET_TYPE_VALUES.DATA_POINTS_TABLE)\"\n        />\n\n        <c8y-countdown-interval\n          *ngIf=\"isIntervalRefreshToggleOn\"\n          [countdownInterval]=\"refreshInterval\"\n          (countdownEnded)=\"countdownEnded()\"\n        ></c8y-countdown-interval>\n        <i\n          c8yIcon=\"pause\"\n          *ngIf=\"!isIntervalRefreshToggleOn\"\n        ></i>\n      </label>\n\n      <div class=\"input-group-btn\">\n        <button\n          class=\"btn btn-default\"\n          [attr.aria-label]=\"'Refresh' | translate\"\n          [tooltip]=\"'Refresh' | translate\"\n          placement=\"bottom\"\n          type=\"button\"\n          [adaptivePosition]=\"false\"\n          [container]=\"'body'\"\n          [delay]=\"500\"\n          [disabled]=\"isRefreshDisabled || (isLoading | async)\"\n          (click)=\"reload()\"\n          data-cy=\"c8y-data-points-table-widget--reload-button\"\n        >\n          <i\n            c8yIcon=\"refresh\"\n            [ngClass]=\"{ 'icon-spin': isLoading | async }\"\n          ></i>\n        </button>\n      </div>\n    </div>\n  </div>\n</ng-container>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.IconDirective, selector: "[c8yIcon]", inputs: ["c8yIcon"] }, { kind: "pipe", type: i2.C8yTranslatePipe, name: "translate" }, { kind: "directive", type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }, { kind: "ngmodule", type: CountdownIntervalModule }, { kind: "component", type: i2.CountdownIntervalComponent, selector: "c8y-countdown-interval", inputs: ["countdownInterval"], outputs: ["countdownEnded"] }, { kind: "ngmodule", type: ListGroupModule }, { kind: "ngmodule", type: TooltipModule }, { kind: "directive", type: i4.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"] }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DatapointsReloadComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'c8y-datapoints-reload', standalone: true, imports: [CommonModule, CountdownIntervalModule, ListGroupModule, TooltipModule], template: "<ng-container *ngIf=\"!widgetInstanceGlobalAutoRefreshContext\">\n  <div class=\"a-i-center input-group p-t-4 p-b-4 max-width-fit m-l-auto\">\n    <label\n      class=\"m-b-0 m-r-8 text-label-small text-truncate flex-no-shrink\"\n      title=\" {{ 'Auto refresh' | translate }}\"\n      *ngIf=\"refreshInterval && isAutoRefreshEnabled\"\n    >\n      {{ 'Auto refresh' | translate }}\n    </label>\n    <div class=\"input-group\">\n      <label\n        class=\"toggle-countdown\"\n        [class.toggle-countdown-disabled]=\"isRefreshDisabled\"\n        [attr.aria-label]=\"toggleCountdownButtonTooltipText\"\n        [tooltip]=\"toggleCountdownButtonTooltipText\"\n        placement=\"bottom\"\n        *ngIf=\"refreshInterval && isAutoRefreshEnabled\"\n        [adaptivePosition]=\"false\"\n        [container]=\"'body'\"\n        [delay]=\"500\"\n      >\n        <input\n          type=\"checkbox\"\n          [checked]=\"isIntervalRefreshToggleOn\"\n          [disabled]=\"isRefreshDisabled\"\n          data-cy=\"c8y-data-points-table-widget--interval-toggle-button\"\n          (click)=\"onToggleCountdownButtonState($event)\"\n        />\n\n        <c8y-countdown-interval\n          *ngIf=\"isIntervalRefreshToggleOn\"\n          [countdownInterval]=\"refreshInterval\"\n          (countdownEnded)=\"countdownEnded()\"\n        ></c8y-countdown-interval>\n        <i\n          c8yIcon=\"pause\"\n          *ngIf=\"!isIntervalRefreshToggleOn\"\n        ></i>\n      </label>\n\n      <div class=\"input-group-btn\">\n        <button\n          class=\"btn btn-default\"\n          [attr.aria-label]=\"'Refresh' | translate\"\n          [tooltip]=\"'Refresh' | translate\"\n          placement=\"bottom\"\n          type=\"button\"\n          [adaptivePosition]=\"false\"\n          [container]=\"'body'\"\n          [delay]=\"500\"\n          [disabled]=\"isRefreshDisabled || (isLoading | async)\"\n          (click)=\"reload()\"\n          data-cy=\"c8y-data-points-table-widget--reload-button\"\n        >\n          <i\n            c8yIcon=\"refresh\"\n            [ngClass]=\"{ 'icon-spin': isLoading | async }\"\n          ></i>\n        </button>\n      </div>\n    </div>\n  </div>\n</ng-container>\n" }]
-        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i1.TranslateService }, { type: i2.WidgetGlobalAutoRefreshService }], propDecorators: { countdownIntervalComponent: [{
+            args: [{ selector: 'c8y-datapoints-reload', standalone: true, imports: [CommonModule, CountdownIntervalModule, ListGroupModule, TooltipModule], template: "<ng-container *ngIf=\"!widgetInstanceGlobalAutoRefreshContext\">\n  <div class=\"a-i-center input-group p-t-4 p-b-4 max-width-fit m-l-auto\">\n    <label\n      class=\"m-b-0 m-r-8 text-label-small text-truncate flex-no-shrink\"\n      title=\" {{ 'Auto refresh' | translate }}\"\n      *ngIf=\"refreshInterval && isAutoRefreshEnabled\"\n    >\n      {{ 'Auto refresh' | translate }}\n    </label>\n    <div class=\"input-group\">\n      <label\n        class=\"toggle-countdown\"\n        [class.toggle-countdown-disabled]=\"isRefreshDisabled\"\n        [attr.aria-label]=\"toggleCountdownButtonTooltipText\"\n        [tooltip]=\"toggleCountdownButtonTooltipText\"\n        placement=\"bottom\"\n        *ngIf=\"refreshInterval && isAutoRefreshEnabled\"\n        [adaptivePosition]=\"false\"\n        [container]=\"'body'\"\n        [delay]=\"500\"\n      >\n        <input\n          type=\"checkbox\"\n          [checked]=\"isIntervalRefreshToggleOn\"\n          [disabled]=\"isRefreshDisabled\"\n          data-cy=\"c8y-data-points-table-widget--interval-toggle-button\"\n          (click)=\"onToggleCountdownButtonState($event, WIDGET_TYPE_VALUES.DATA_POINTS_TABLE)\"\n        />\n\n        <c8y-countdown-interval\n          *ngIf=\"isIntervalRefreshToggleOn\"\n          [countdownInterval]=\"refreshInterval\"\n          (countdownEnded)=\"countdownEnded()\"\n        ></c8y-countdown-interval>\n        <i\n          c8yIcon=\"pause\"\n          *ngIf=\"!isIntervalRefreshToggleOn\"\n        ></i>\n      </label>\n\n      <div class=\"input-group-btn\">\n        <button\n          class=\"btn btn-default\"\n          [attr.aria-label]=\"'Refresh' | translate\"\n          [tooltip]=\"'Refresh' | translate\"\n          placement=\"bottom\"\n          type=\"button\"\n          [adaptivePosition]=\"false\"\n          [container]=\"'body'\"\n          [delay]=\"500\"\n          [disabled]=\"isRefreshDisabled || (isLoading | async)\"\n          (click)=\"reload()\"\n          data-cy=\"c8y-data-points-table-widget--reload-button\"\n        >\n          <i\n            c8yIcon=\"refresh\"\n            [ngClass]=\"{ 'icon-spin': isLoading | async }\"\n          ></i>\n        </button>\n      </div>\n    </div>\n  </div>\n</ng-container>\n" }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i1.TranslateService }, { type: i2.WidgetGlobalAutoRefreshService }, { type: i2.GainsightService }], propDecorators: { countdownIntervalComponent: [{
                 type: ViewChild,
                 args: [CountdownIntervalComponent, { static: false }]
             }], isAutoRefreshEnabled: [{
@@ -135,4 +137,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImpor
             }], onCountdownEnded: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datapoints-reload.component.js","sourceRoot":"","sources":["../../../../../../../widgets/implementations/datapoints-table/datapoints-table-view/datapoints-reload/datapoints-reload.component.ts","../../../../../../../widgets/implementations/datapoints-table/datapoints-table-view/datapoints-reload/datapoints-reload.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Output,\n  SimpleChanges,\n  ViewChild\n} from '@angular/core';\nimport {\n  CommonModule,\n  CountdownIntervalComponent,\n  CountdownIntervalModule,\n  IntervalBasedReload,\n  ListGroupModule,\n  WidgetGlobalAutoRefreshService,\n  gettext\n} from '@c8y/ngx-components';\nimport { TranslateService } from '@ngx-translate/core';\nimport { TooltipModule } from 'ngx-bootstrap/tooltip';\nimport { BehaviorSubject, Subject, takeUntil, tap } from 'rxjs';\n\n@Component({\n  selector: 'c8y-datapoints-reload',\n  templateUrl: './datapoints-reload.component.html',\n  standalone: true,\n  imports: [CommonModule, CountdownIntervalModule, ListGroupModule, TooltipModule]\n})\nexport class DatapointsReloadComponent\n  extends IntervalBasedReload\n  implements OnChanges, AfterViewInit, OnDestroy\n{\n  @ViewChild(CountdownIntervalComponent, { static: false })\n  countdownIntervalComponent: CountdownIntervalComponent;\n  /**\n   * @inheritdoc\n   */\n  @Input() isAutoRefreshEnabled: boolean;\n  /**\n   * @inheritdoc\n   */\n  @Input() isRefreshDisabled = false;\n  /**\n   * @inheritdoc\n   */\n  @Input() isLoading: BehaviorSubject<boolean>;\n\n  @Input() isScrolling: boolean;\n\n  @Input() isExportModalOpen: boolean;\n  /**\n   * @inheritdoc\n   */\n  @Input() refreshInterval: number;\n\n  @Input() widgetInstanceGlobalAutoRefreshContext: boolean;\n  /**\n   * @inheritdoc\n   */\n  @Output() onCountdownEnded = new EventEmitter<void>();\n  /**\n   * @inheritdoc\n   */\n  isIntervalRefreshToggleOn: boolean;\n\n  toggleCountdownButtonTooltipText: string;\n  /**\n   * @inheritdoc\n   */\n  protected manuallyDisabledCountdown = false;\n  /**\n   * @inheritdoc\n   */\n  protected hideCountdown: boolean;\n\n  protected destroy$ = new Subject<void>();\n\n  constructor(\n    private cdRef: ChangeDetectorRef,\n    private translateService: TranslateService,\n    private widgetGlobalAutoRefreshService: WidgetGlobalAutoRefreshService\n  ) {\n    super();\n  }\n\n  ngAfterViewInit() {\n    if (this.widgetInstanceGlobalAutoRefreshContext) {\n      this.widgetGlobalAutoRefreshService.countdownActions.countdownEnded$\n        .pipe(\n          takeUntil(this.destroy$),\n          tap(() => this.onCountdownEnded.emit())\n        )\n        .subscribe();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (this.isRefreshDisabled && this.isAutoRefreshEnabled) {\n      this.isIntervalRefreshToggleOn = false;\n      this.disableCountdown();\n      return;\n    }\n\n    if (this.isExportModalOpen && this.canDisableCountdownWhenModalIsOpen()) {\n      this.isIntervalRefreshToggleOn = !this.isIntervalRefreshToggleOn;\n      this.disableCountdown();\n    } else {\n      if (this.canStartCountdown(changes)) {\n        this.isIntervalRefreshToggleOn = true;\n        this.startCountdown();\n      }\n\n      if (this.canHandleScrolling()) {\n        this.handleScrolling();\n      }\n    }\n  }\n\n  ngOnDestroy(): void {\n    if (this.countdownSubscription) {\n      this.countdownSubscription.unsubscribe();\n    }\n    this.destroy$.next();\n    this.destroy$.complete();\n  }\n\n  /**\n   * @inheritdoc\n   */\n  countdownEnded(): void {\n    /**\n     * @inheritdoc\n     */\n    this.autoRefreshList();\n  }\n\n  reload(): void {\n    /**\n     * @inheritdoc\n     */\n    this.autoRefreshList();\n  }\n\n  /**\n   * @inheritdoc\n   */\n  enableCountdown(): void {\n    this.hideCountdown = false;\n    // Prevents the countdown from getting stuck on an initial value.\n    this.cdRef.detectChanges();\n    this.startCountdown();\n  }\n\n  /**\n   * @inheritdoc\n   */\n  protected updateCountdownButtonTooltipText(): void {\n    this.toggleCountdownButtonTooltipText = this.isIntervalRefreshToggleOn\n      ? this.translateService.instant(gettext('Disable auto refresh'))\n      : this.translateService.instant(gettext('Enable auto refresh'));\n  }\n\n  private canStartCountdown(changes: SimpleChanges): boolean {\n    const { isAutoRefreshEnabled, refreshInterval } = changes;\n    return (\n      (isAutoRefreshEnabled || refreshInterval) &&\n      (this.isAutoRefreshEnabled || !!this.refreshInterval)\n    );\n  }\n\n  private canHandleScrolling(): boolean {\n    return !this.manuallyDisabledCountdown && this.isAutoRefreshEnabled;\n  }\n\n  private canDisableCountdownWhenModalIsOpen(): boolean {\n    return (\n      this.isAutoRefreshEnabled &&\n      !!this.refreshInterval &&\n      !this.manuallyDisabledCountdown &&\n      !this.isScrolling &&\n      !this.hideCountdown\n    );\n  }\n}\n","<ng-container *ngIf=\"!widgetInstanceGlobalAutoRefreshContext\">\n  <div class=\"a-i-center input-group p-t-4 p-b-4 max-width-fit m-l-auto\">\n    <label\n      class=\"m-b-0 m-r-8 text-label-small text-truncate flex-no-shrink\"\n      title=\" {{ 'Auto refresh' | translate }}\"\n      *ngIf=\"refreshInterval && isAutoRefreshEnabled\"\n    >\n      {{ 'Auto refresh' | translate }}\n    </label>\n    <div class=\"input-group\">\n      <label\n        class=\"toggle-countdown\"\n        [class.toggle-countdown-disabled]=\"isRefreshDisabled\"\n        [attr.aria-label]=\"toggleCountdownButtonTooltipText\"\n        [tooltip]=\"toggleCountdownButtonTooltipText\"\n        placement=\"bottom\"\n        *ngIf=\"refreshInterval && isAutoRefreshEnabled\"\n        [adaptivePosition]=\"false\"\n        [container]=\"'body'\"\n        [delay]=\"500\"\n      >\n        <input\n          type=\"checkbox\"\n          [checked]=\"isIntervalRefreshToggleOn\"\n          [disabled]=\"isRefreshDisabled\"\n          data-cy=\"c8y-data-points-table-widget--interval-toggle-button\"\n          (click)=\"onToggleCountdownButtonState($event)\"\n        />\n\n        <c8y-countdown-interval\n          *ngIf=\"isIntervalRefreshToggleOn\"\n          [countdownInterval]=\"refreshInterval\"\n          (countdownEnded)=\"countdownEnded()\"\n        ></c8y-countdown-interval>\n        <i\n          c8yIcon=\"pause\"\n          *ngIf=\"!isIntervalRefreshToggleOn\"\n        ></i>\n      </label>\n\n      <div class=\"input-group-btn\">\n        <button\n          class=\"btn btn-default\"\n          [attr.aria-label]=\"'Refresh' | translate\"\n          [tooltip]=\"'Refresh' | translate\"\n          placement=\"bottom\"\n          type=\"button\"\n          [adaptivePosition]=\"false\"\n          [container]=\"'body'\"\n          [delay]=\"500\"\n          [disabled]=\"isRefreshDisabled || (isLoading | async)\"\n          (click)=\"reload()\"\n          data-cy=\"c8y-data-points-table-widget--reload-button\"\n        >\n          <i\n            c8yIcon=\"refresh\"\n            [ngClass]=\"{ 'icon-spin': isLoading | async }\"\n          ></i>\n        </button>\n      </div>\n    </div>\n  </div>\n</ng-container>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datapoints-reload.component.js","sourceRoot":"","sources":["../../../../../../../widgets/implementations/datapoints-table/datapoints-table-view/datapoints-reload/datapoints-reload.component.ts","../../../../../../../widgets/implementations/datapoints-table/datapoints-table-view/datapoints-reload/datapoints-reload.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Output,\n  SimpleChanges,\n  ViewChild\n} from '@angular/core';\nimport {\n  CommonModule,\n  CountdownIntervalComponent,\n  CountdownIntervalModule,\n  GainsightService,\n  IntervalBasedReload,\n  ListGroupModule,\n  WIDGET_TYPE_VALUES,\n  WidgetGlobalAutoRefreshService,\n  gettext\n} from '@c8y/ngx-components';\nimport { TranslateService } from '@ngx-translate/core';\nimport { TooltipModule } from 'ngx-bootstrap/tooltip';\nimport { BehaviorSubject, Subject, takeUntil, tap } from 'rxjs';\n\n@Component({\n  selector: 'c8y-datapoints-reload',\n  templateUrl: './datapoints-reload.component.html',\n  standalone: true,\n  imports: [CommonModule, CountdownIntervalModule, ListGroupModule, TooltipModule]\n})\nexport class DatapointsReloadComponent\n  extends IntervalBasedReload\n  implements OnChanges, AfterViewInit, OnDestroy\n{\n  readonly WIDGET_TYPE_VALUES = WIDGET_TYPE_VALUES;\n\n  @ViewChild(CountdownIntervalComponent, { static: false })\n  countdownIntervalComponent: CountdownIntervalComponent;\n  /**\n   * @inheritdoc\n   */\n  @Input() isAutoRefreshEnabled: boolean;\n  /**\n   * @inheritdoc\n   */\n  @Input() isRefreshDisabled = false;\n  /**\n   * @inheritdoc\n   */\n  @Input() isLoading: BehaviorSubject<boolean>;\n\n  @Input() isScrolling: boolean;\n\n  @Input() isExportModalOpen: boolean;\n  /**\n   * @inheritdoc\n   */\n  @Input() refreshInterval: number;\n\n  @Input() widgetInstanceGlobalAutoRefreshContext: boolean;\n  /**\n   * @inheritdoc\n   */\n  @Output() onCountdownEnded = new EventEmitter<void>();\n  /**\n   * @inheritdoc\n   */\n  isIntervalRefreshToggleOn: boolean;\n\n  toggleCountdownButtonTooltipText: string;\n  /**\n   * @inheritdoc\n   */\n  protected manuallyDisabledCountdown = false;\n  /**\n   * @inheritdoc\n   */\n  protected hideCountdown: boolean;\n\n  protected destroy$ = new Subject<void>();\n\n  constructor(\n    private cdRef: ChangeDetectorRef,\n    private translateService: TranslateService,\n    private widgetGlobalAutoRefreshService: WidgetGlobalAutoRefreshService,\n    protected gainsightService: GainsightService\n  ) {\n    super();\n  }\n\n  ngAfterViewInit() {\n    if (this.widgetInstanceGlobalAutoRefreshContext) {\n      this.widgetGlobalAutoRefreshService.countdownActions.countdownEnded$\n        .pipe(\n          takeUntil(this.destroy$),\n          tap(() => this.onCountdownEnded.emit())\n        )\n        .subscribe();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (this.isRefreshDisabled && this.isAutoRefreshEnabled) {\n      this.isIntervalRefreshToggleOn = false;\n      this.disableCountdown();\n      return;\n    }\n\n    if (this.isExportModalOpen && this.canDisableCountdownWhenModalIsOpen()) {\n      this.isIntervalRefreshToggleOn = !this.isIntervalRefreshToggleOn;\n      this.disableCountdown();\n    } else {\n      if (this.canStartCountdown(changes)) {\n        this.isIntervalRefreshToggleOn = true;\n        this.startCountdown();\n      }\n\n      if (this.canHandleScrolling()) {\n        this.handleScrolling();\n      }\n    }\n  }\n\n  ngOnDestroy(): void {\n    if (this.countdownSubscription) {\n      this.countdownSubscription.unsubscribe();\n    }\n    this.destroy$.next();\n    this.destroy$.complete();\n  }\n\n  /**\n   * @inheritdoc\n   */\n  countdownEnded(): void {\n    /**\n     * @inheritdoc\n     */\n    this.autoRefreshList();\n  }\n\n  reload(): void {\n    /**\n     * @inheritdoc\n     */\n    this.autoRefreshList();\n  }\n\n  /**\n   * @inheritdoc\n   */\n  enableCountdown(): void {\n    this.hideCountdown = false;\n    // Prevents the countdown from getting stuck on an initial value.\n    this.cdRef.detectChanges();\n    this.startCountdown();\n  }\n\n  /**\n   * @inheritdoc\n   */\n  protected updateCountdownButtonTooltipText(): void {\n    this.toggleCountdownButtonTooltipText = this.isIntervalRefreshToggleOn\n      ? this.translateService.instant(gettext('Disable auto refresh'))\n      : this.translateService.instant(gettext('Enable auto refresh'));\n  }\n\n  private canStartCountdown(changes: SimpleChanges): boolean {\n    const { isAutoRefreshEnabled, refreshInterval } = changes;\n    return (\n      (isAutoRefreshEnabled || refreshInterval) &&\n      (this.isAutoRefreshEnabled || !!this.refreshInterval)\n    );\n  }\n\n  private canHandleScrolling(): boolean {\n    return !this.manuallyDisabledCountdown && this.isAutoRefreshEnabled;\n  }\n\n  private canDisableCountdownWhenModalIsOpen(): boolean {\n    return (\n      this.isAutoRefreshEnabled &&\n      !!this.refreshInterval &&\n      !this.manuallyDisabledCountdown &&\n      !this.isScrolling &&\n      !this.hideCountdown\n    );\n  }\n}\n","<ng-container *ngIf=\"!widgetInstanceGlobalAutoRefreshContext\">\n  <div class=\"a-i-center input-group p-t-4 p-b-4 max-width-fit m-l-auto\">\n    <label\n      class=\"m-b-0 m-r-8 text-label-small text-truncate flex-no-shrink\"\n      title=\" {{ 'Auto refresh' | translate }}\"\n      *ngIf=\"refreshInterval && isAutoRefreshEnabled\"\n    >\n      {{ 'Auto refresh' | translate }}\n    </label>\n    <div class=\"input-group\">\n      <label\n        class=\"toggle-countdown\"\n        [class.toggle-countdown-disabled]=\"isRefreshDisabled\"\n        [attr.aria-label]=\"toggleCountdownButtonTooltipText\"\n        [tooltip]=\"toggleCountdownButtonTooltipText\"\n        placement=\"bottom\"\n        *ngIf=\"refreshInterval && isAutoRefreshEnabled\"\n        [adaptivePosition]=\"false\"\n        [container]=\"'body'\"\n        [delay]=\"500\"\n      >\n        <input\n          type=\"checkbox\"\n          [checked]=\"isIntervalRefreshToggleOn\"\n          [disabled]=\"isRefreshDisabled\"\n          data-cy=\"c8y-data-points-table-widget--interval-toggle-button\"\n          (click)=\"onToggleCountdownButtonState($event, WIDGET_TYPE_VALUES.DATA_POINTS_TABLE)\"\n        />\n\n        <c8y-countdown-interval\n          *ngIf=\"isIntervalRefreshToggleOn\"\n          [countdownInterval]=\"refreshInterval\"\n          (countdownEnded)=\"countdownEnded()\"\n        ></c8y-countdown-interval>\n        <i\n          c8yIcon=\"pause\"\n          *ngIf=\"!isIntervalRefreshToggleOn\"\n        ></i>\n      </label>\n\n      <div class=\"input-group-btn\">\n        <button\n          class=\"btn btn-default\"\n          [attr.aria-label]=\"'Refresh' | translate\"\n          [tooltip]=\"'Refresh' | translate\"\n          placement=\"bottom\"\n          type=\"button\"\n          [adaptivePosition]=\"false\"\n          [container]=\"'body'\"\n          [delay]=\"500\"\n          [disabled]=\"isRefreshDisabled || (isLoading | async)\"\n          (click)=\"reload()\"\n          data-cy=\"c8y-data-points-table-widget--reload-button\"\n        >\n          <i\n            c8yIcon=\"refresh\"\n            [ngClass]=\"{ 'icon-spin': isLoading | async }\"\n          ></i>\n        </button>\n      </div>\n    </div>\n  </div>\n</ng-container>\n"]}