@c8y/ngx-components 1021.13.3 → 1021.21.0

package/esm2022/widgets/implementations/datapoints-table/datapoints-table-config/datapoints-table-config.service.mjs

@@ -0,0 +1,124 @@
+import { Injectable } from '@angular/core';
+import { AGGREGATION_VALUES } from '@c8y/ngx-components';
+import { TIME_RANGE_INTERVAL_UNITS_VALUES } from '@c8y/ngx-components/datapoints-export-selector';
+import { INTERVALS } from '@c8y/ngx-components/interval-picker';
+import * as i0 from "@angular/core";
+export class DatapointsTableConfigService {
+    /**
+     * Determines the interval between two dates.
+     *
+     * @param dateFrom - The starting date in ISO 8601 string format.
+     * @param dateTo - The ending date in ISO 8601 string format.
+     * @returns The time range interval unit.
+     */
+    // TODO same method is in datapoints export component. Consider moving it to a shared service, or reuse it here
+    // when DPT will be integrating with MTM-59689.
+    // Integration task: MTM-60221
+    // tests are already added in MTM-60217
+    determineInterval(dateFrom, dateTo) {
+        const from = new Date(dateFrom);
+        const to = new Date(dateTo);
+        const differenceInMilliseconds = to.getTime() - from.getTime();
+        const [minutes, hours, days, weeks, months, custom] = INTERVALS;
+        const intervals = [
+            { value: minutes.timespanInMs, id: minutes.id }, // milliseconds in one minute
+            { value: hours.timespanInMs, id: hours.id }, // milliseconds in one hour
+            { value: days.timespanInMs, id: days.id }, // milliseconds in one day
+            { value: weeks.timespanInMs, id: weeks.id }, // milliseconds in one week
+            { value: months.timespanInMs, id: months.id } // approximation for milliseconds in one month
+        ];
+        const interval = intervals.find(interval => differenceInMilliseconds <= interval.value);
+        return interval ? interval.id : custom.id;
+    }
+    /**
+     * Updates the disabled state of aggregation options based on the current value of the time interval form control.
+     *
+     * This method:
+     * - Retrieves the current date range from the form controls.
+     * - Determines the current time interval based on the date range.
+     * - Sets the disabled state for each aggregation option based on predefined conditions.
+     *
+     * The disabled state is stored in the `disabledAggregationOptions` object,
+     * where the key is the aggregation value and the value is a boolean indicating whether the option should be disabled.
+     *
+     * The `disabledConditions` object defines the conditions under which each aggregation option should be disabled.
+     *
+     * @param dateFrom - The starting date of the range.
+     * @param dateTo - The ending date of the range.
+     * @param aggregationValuesArr - An array of aggregation options.
+     * @returns An object containing the disabled state of each aggregation option.
+     */
+    // TODO similar method is in datapoints export component. Consider moving it to a shared service when DPT will be integrating with MTM-59689.
+    // Integration task: MTM-60221
+    // tests are already added in MTM-60217
+    updateDisabledStateOfAggregationOptionEntries(dateFrom, dateTo, aggregationValuesArr) {
+        const currentInterval = this.determineInterval(dateFrom, dateTo);
+        const disabledConditions = {
+            [AGGREGATION_VALUES.daily]: [
+                TIME_RANGE_INTERVAL_UNITS_VALUES.minutes,
+                TIME_RANGE_INTERVAL_UNITS_VALUES.hours,
+                TIME_RANGE_INTERVAL_UNITS_VALUES.days
+            ],
+            [AGGREGATION_VALUES.hourly]: [
+                TIME_RANGE_INTERVAL_UNITS_VALUES.minutes,
+                TIME_RANGE_INTERVAL_UNITS_VALUES.hours
+            ],
+            [AGGREGATION_VALUES.minutely]: [TIME_RANGE_INTERVAL_UNITS_VALUES.minutes]
+        };
+        const disabledAggregationOptions = {};
+        for (const aggregationValue of aggregationValuesArr) {
+            disabledAggregationOptions[aggregationValue] =
+                disabledConditions[aggregationValue]?.includes(currentInterval) ?? false;
+        }
+        return disabledAggregationOptions;
+    }
+    /**
+     * Determines the new aggregation value based on the current value and disabled options.
+     *
+     * Goal is to switch to the next available aggregation option if the current one is disabled.
+     * - If the current option is disabled, sets the control to the first available (non-disabled) option based on the following order:
+     *   - If the current value is `DAILY`, it switches to `HOURLY` if it's not disabled, otherwise to `MINUTELY` if `HOURLY` is also disabled.
+     *   - If the current value is `HOURLY`, it switches to `MINUTELY` if it's not disabled.
+     *   - If all options are disabled, it sets the value to `NONE`.
+     *
+     * @param currentValue - The current aggregation option.
+     * @param disabledOptions - An object containing disabled options.
+     * @returns The new aggregation option.
+     */
+    determineNewAggregationValue(currentValue, disabledOptions) {
+        const { daily, hourly, minutely, none } = AGGREGATION_VALUES;
+        if (!disabledOptions[currentValue]) {
+            return currentValue; // Return the current value if it's not disabled
+        }
+        if (currentValue === daily) {
+            return !disabledOptions[hourly] ? hourly : !disabledOptions[minutely] ? minutely : none;
+        }
+        if (currentValue === hourly) {
+            return !disabledOptions[minutely] ? minutely : none;
+        }
+        return none; // Fallback to 'none' if all else fails
+    }
+    /**
+     * Determines the aggregation value based on the provided interval.
+     *
+     * @param interval - The time range interval.
+     * @returns The corresponding aggregation value.
+     */
+    determineAggregationValue(interval) {
+        const aggregationMap = {
+            [TIME_RANGE_INTERVAL_UNITS_VALUES.minutes]: AGGREGATION_VALUES.none,
+            [TIME_RANGE_INTERVAL_UNITS_VALUES.hours]: AGGREGATION_VALUES.minutely,
+            [TIME_RANGE_INTERVAL_UNITS_VALUES.days]: AGGREGATION_VALUES.hourly
+        };
+        return aggregationMap[interval] || AGGREGATION_VALUES.daily;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DatapointsTableConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DatapointsTableConfigService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DatapointsTableConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datapoints-table-config.service.js","sourceRoot":"","sources":["../../../../../../widgets/implementations/datapoints-table/datapoints-table-config/datapoints-table-config.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  AGGREGATION_VALUES,\n  AggregationOption,\n  AggregationOptionStatus\n} from '@c8y/ngx-components';\nimport {\n  TIME_RANGE_INTERVAL_UNITS_VALUES,\n  TimeRangeInterval\n} from '@c8y/ngx-components/datapoints-export-selector';\nimport { INTERVALS } from '@c8y/ngx-components/interval-picker';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DatapointsTableConfigService {\n  /**\n   * Determines the interval between two dates.\n   *\n   * @param dateFrom - The starting date in ISO 8601 string format.\n   * @param dateTo - The ending date in ISO 8601 string format.\n   * @returns The time range interval unit.\n   */\n  // TODO same method is in datapoints export component. Consider moving it to a shared service, or reuse it here\n  // when DPT will be integrating with MTM-59689.\n  // Integration task: MTM-60221\n  // tests are already added in MTM-60217\n  determineInterval(dateFrom: string, dateTo: string): TimeRangeInterval {\n    const from = new Date(dateFrom);\n    const to = new Date(dateTo);\n    const differenceInMilliseconds = to.getTime() - from.getTime();\n\n    const [minutes, hours, days, weeks, months, custom] = INTERVALS;\n\n    const intervals = [\n      { value: minutes.timespanInMs, id: minutes.id }, // milliseconds in one minute\n      { value: hours.timespanInMs, id: hours.id }, // milliseconds in one hour\n      { value: days.timespanInMs, id: days.id }, // milliseconds in one day\n      { value: weeks.timespanInMs, id: weeks.id }, // milliseconds in one week\n      { value: months.timespanInMs, id: months.id } // approximation for milliseconds in one month\n    ];\n\n    const interval = intervals.find(interval => differenceInMilliseconds <= interval.value);\n\n    return interval ? interval.id : custom.id;\n  }\n\n  /**\n   * Updates the disabled state of aggregation options based on the current value of the time interval form control.\n   *\n   * This method:\n   * - Retrieves the current date range from the form controls.\n   * - Determines the current time interval based on the date range.\n   * - Sets the disabled state for each aggregation option based on predefined conditions.\n   *\n   * The disabled state is stored in the `disabledAggregationOptions` object,\n   * where the key is the aggregation value and the value is a boolean indicating whether the option should be disabled.\n   *\n   * The `disabledConditions` object defines the conditions under which each aggregation option should be disabled.\n   *\n   * @param dateFrom - The starting date of the range.\n   * @param dateTo - The ending date of the range.\n   * @param aggregationValuesArr - An array of aggregation options.\n   * @returns An object containing the disabled state of each aggregation option.\n   */\n  // TODO similar method is in datapoints export component. Consider moving it to a shared service when DPT will be integrating with MTM-59689.\n  // Integration task: MTM-60221\n  // tests are already added in MTM-60217\n  updateDisabledStateOfAggregationOptionEntries(\n    dateFrom: string,\n    dateTo: string,\n    aggregationValuesArr: readonly AggregationOption[]\n  ): AggregationOptionStatus {\n    const currentInterval = this.determineInterval(dateFrom, dateTo);\n\n    const disabledConditions = {\n      [AGGREGATION_VALUES.daily]: [\n        TIME_RANGE_INTERVAL_UNITS_VALUES.minutes,\n        TIME_RANGE_INTERVAL_UNITS_VALUES.hours,\n        TIME_RANGE_INTERVAL_UNITS_VALUES.days\n      ],\n      [AGGREGATION_VALUES.hourly]: [\n        TIME_RANGE_INTERVAL_UNITS_VALUES.minutes,\n        TIME_RANGE_INTERVAL_UNITS_VALUES.hours\n      ],\n      [AGGREGATION_VALUES.minutely]: [TIME_RANGE_INTERVAL_UNITS_VALUES.minutes]\n    };\n\n    const disabledAggregationOptions = {};\n\n    for (const aggregationValue of aggregationValuesArr) {\n      disabledAggregationOptions[aggregationValue] =\n        disabledConditions[aggregationValue]?.includes(currentInterval) ?? false;\n    }\n\n    return disabledAggregationOptions;\n  }\n\n  /**\n   * Determines the new aggregation value based on the current value and disabled options.\n   *\n   * Goal is to switch to the next available aggregation option if the current one is disabled.\n   * - If the current option is disabled, sets the control to the first available (non-disabled) option based on the following order:\n   *   - If the current value is `DAILY`, it switches to `HOURLY` if it's not disabled, otherwise to `MINUTELY` if `HOURLY` is also disabled.\n   *   - If the current value is `HOURLY`, it switches to `MINUTELY` if it's not disabled.\n   *   - If all options are disabled, it sets the value to `NONE`.\n   *\n   * @param currentValue - The current aggregation option.\n   * @param disabledOptions - An object containing disabled options.\n   * @returns The new aggregation option.\n   */\n  determineNewAggregationValue(\n    currentValue: AggregationOption,\n    disabledOptions: AggregationOptionStatus\n  ): AggregationOption {\n    const { daily, hourly, minutely, none } = AGGREGATION_VALUES;\n\n    if (!disabledOptions[currentValue]) {\n      return currentValue; // Return the current value if it's not disabled\n    }\n\n    if (currentValue === daily) {\n      return !disabledOptions[hourly] ? hourly : !disabledOptions[minutely] ? minutely : none;\n    }\n\n    if (currentValue === hourly) {\n      return !disabledOptions[minutely] ? minutely : none;\n    }\n\n    return none; // Fallback to 'none' if all else fails\n  }\n\n  /**\n   * Determines the aggregation value based on the provided interval.\n   *\n   * @param interval - The time range interval.\n   * @returns The corresponding aggregation value.\n   */\n  determineAggregationValue(interval: TimeRangeInterval): AggregationOption {\n    const aggregationMap = {\n      [TIME_RANGE_INTERVAL_UNITS_VALUES.minutes]: AGGREGATION_VALUES.none,\n      [TIME_RANGE_INTERVAL_UNITS_VALUES.hours]: AGGREGATION_VALUES.minutely,\n      [TIME_RANGE_INTERVAL_UNITS_VALUES.days]: AGGREGATION_VALUES.hourly\n    };\n\n    return aggregationMap[interval] || AGGREGATION_VALUES.daily;\n  }\n}\n"]}

package/esm2022/widgets/implementations/datapoints-table/datapoints-table-view/adjust-aggregated-time-range.pipe.mjs

@@ -0,0 +1,191 @@
+import { Pipe } from '@angular/core';
+import { aggregationType as AggregationTypeEnum } from '@c8y/client';
+import * as i0 from "@angular/core";
+/**
+ * A pipe that adjusts the aggregated time range based on the aggregation type.
+ *
+ * ```html
+ * '9:00' | adjustAggregatedTimeRange: config.aggregation (e.g.:HOURLY)
+ * ```
+ * The output will be '9:00-10:00'.
+ */
+export class AdjustAggregatedTimeRangePipe {
+    /**
+     * Transforms the input time based on the aggregation type.
+     * @param inputTime The input time string.
+     * @param aggregationType The type of aggregation (optional).
+     * @returns The transformed time string.
+     */
+    transform(inputTime, aggregationType) {
+        if (!aggregationType) {
+            return inputTime;
+        }
+        if (aggregationType === AggregationTypeEnum.DAILY) {
+            return '';
+        }
+        const date = this.createDateFromInput(inputTime);
+        const isTwelveHoursFormat = this.isTwelveHoursFormat(inputTime);
+        switch (aggregationType) {
+            case AggregationTypeEnum.HOURLY:
+                return this.getHourlyTimeRange(date, isTwelveHoursFormat);
+            case AggregationTypeEnum.MINUTELY:
+                return this.getMinutelyTimeRange(date, isTwelveHoursFormat);
+            default:
+                throw new Error('Unsupported aggregation type');
+        }
+    }
+    /**
+     * Creates a date object from the input time string.
+     * @param inputTime The input time string.
+     * @returns The created Date object.
+     */
+    createDateFromInput(inputTime) {
+        const defaultDate = '1970-01-01 ';
+        const isPM = /PM/i.test(inputTime);
+        const cleanedTime = inputTime.replace(/AM|PM/i, '').trim();
+        this.validateTimeFormat(cleanedTime, inputTime);
+        const dateTimeString = `${defaultDate}${cleanedTime}`;
+        const date = new Date(dateTimeString);
+        if (isNaN(date.getTime())) {
+            throw new Error('Invalid input time');
+        }
+        return this.adjustForPMTime(date, isPM);
+    }
+    /**
+     * Validates if the time string matches the required format and has valid values.
+     * @param time The time string to validate.
+     * @param originalInput The original input string (including AM/PM if present).
+     * @throws Error if the time format is invalid or values are out of range.
+     */
+    validateTimeFormat(time, originalInput) {
+        const parts = time.split(':');
+        this.validateTimeParts(parts);
+        const [hoursStr, minutesStr, secondsStr] = parts;
+        this.validateTimeDigits(hoursStr, minutesStr, secondsStr);
+        const { hours, minutes, seconds } = this.parseTimeComponents(hoursStr, minutesStr, secondsStr);
+        this.validateTimeRanges(hours, minutes, seconds);
+        this.validateTimeFormat24Hour(hours, originalInput);
+    }
+    validateTimeParts(parts) {
+        if (parts.length < 2 || parts.length > 3) {
+            throw new Error('Invalid input time');
+        }
+    }
+    validateTimeDigits(hoursStr, minutesStr, secondsStr) {
+        if (!this.isValidNumberString(hoursStr) ||
+            !this.isValidNumberString(minutesStr) ||
+            (secondsStr !== undefined && !this.isValidNumberString(secondsStr))) {
+            throw new Error('Invalid input time');
+        }
+    }
+    parseTimeComponents(hoursStr, minutesStr, secondsStr) {
+        return {
+            hours: Number(hoursStr),
+            minutes: Number(minutesStr),
+            seconds: secondsStr ? Number(secondsStr) : 0
+        };
+    }
+    validateTimeRanges(hours, minutes, seconds) {
+        if (hours > 23 || hours < 0 || minutes > 59 || minutes < 0 || seconds > 59 || seconds < 0) {
+            throw new Error('Invalid input time');
+        }
+    }
+    validateTimeFormat24Hour(hours, originalInput) {
+        if (hours > 12 && this.hasAmPm(originalInput)) {
+            throw new Error('Invalid input time');
+        }
+    }
+    /**
+     * Checks if string contains only digits and is 1-2 characters long.
+     * @param value String to check
+     * @returns boolean indicating if string is valid
+     */
+    isValidNumberString(value) {
+        return (value.length > 0 &&
+            value.length <= 2 &&
+            value.split('').every(char => char >= '0' && char <= '9'));
+    }
+    /**
+     * Checks if the input time has AM/PM markers.
+     * @param input The input time string to check.
+     * @returns boolean indicating if the input contains AM/PM.
+     */
+    hasAmPm(input) {
+        return /AM|PM/i.test(input);
+    }
+    /**
+     * Adjusts the date for PM times by adding 12 hours when necessary.
+     * @param date The date object to adjust.
+     * @param isPM Boolean indicating if the time is PM.
+     * @returns The adjusted Date object.
+     */
+    adjustForPMTime(date, isPM) {
+        const hours = date.getHours();
+        if (isPM && hours < 12) {
+            date.setHours(hours + 12);
+        }
+        else if (!isPM && hours === 12) {
+            date.setHours(0);
+        }
+        return date;
+    }
+    /**
+     * Checks if the input time is in twelve hours format.
+     * @param inputTime The input time string.
+     * @returns True if the input time is in twelve hours format, false otherwise.
+     */
+    isTwelveHoursFormat(inputTime) {
+        return /AM|PM/i.test(inputTime);
+    }
+    /**
+     * Gets the hourly time range for the given date.
+     * @param date The date object.
+     * @param twelveHoursFormat Indicates whether to use twelve hours format.
+     * @returns The hourly time range string.
+     */
+    getHourlyTimeRange(date, twelveHoursFormat) {
+        const nextHour = new Date(date.getTime());
+        nextHour.setHours(date.getHours() + 1);
+        return `${this.formatTime(date, twelveHoursFormat, true)}-${this.formatTime(nextHour, twelveHoursFormat, true)}`;
+    }
+    /**
+     * Gets the minutely time range for the given date.
+     * @param date The date object.
+     * @param twelveHoursFormat Indicates whether to use twelve hours format.
+     * @returns The minutely time range string.
+     */
+    getMinutelyTimeRange(date, twelveHoursFormat) {
+        const nextMinute = new Date(date.getTime());
+        nextMinute.setMinutes(date.getMinutes() + 1);
+        return `${this.formatTime(date, twelveHoursFormat, false)}-${this.formatTime(nextMinute, twelveHoursFormat, false)}`;
+    }
+    /**
+     * Formats the given date into a time string.
+     * @param date The date to format.
+     * @param usePeriod Indicates whether to include the period (AM/PM) in the formatted time.
+     * @param useHourOnly Indicates whether to include only the hour part in the formatted time.
+     * @returns The formatted time string.
+     */
+    formatTime(date, usePeriod, useHourOnly) {
+        const hours = date.getHours();
+        const minutes = date.getMinutes().toString().padStart(2, '0');
+        if (usePeriod) {
+            const period = hours >= 12 ? 'PM' : 'AM';
+            const formattedHours = hours % 12 === 0 ? 12 : hours % 12;
+            return `${formattedHours}:${useHourOnly ? '00' : minutes} ${period}`;
+        }
+        else {
+            return `${hours.toString().padStart(2, '0')}:${useHourOnly ? '00' : minutes}`;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: AdjustAggregatedTimeRangePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.9", ngImport: i0, type: AdjustAggregatedTimeRangePipe, isStandalone: true, name: "adjustAggregatedTimeRange" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: AdjustAggregatedTimeRangePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'adjustAggregatedTimeRange',
+                    standalone: true
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"adjust-aggregated-time-range.pipe.js","sourceRoot":"","sources":["../../../../../../widgets/implementations/datapoints-table/datapoints-table-view/adjust-aggregated-time-range.pipe.ts"],"names":[],"mappings":"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","sourcesContent":["import { Pipe, PipeTransform } from '@angular/core';\nimport { aggregationType as AggregationTypeEnum } from '@c8y/client';\nimport { AggregationOption } from '@c8y/ngx-components';\n\n/**\n * A pipe that adjusts the aggregated time range based on the aggregation type.\n *\n * ```html\n * '9:00' | adjustAggregatedTimeRange: config.aggregation (e.g.:HOURLY)\n * ```\n * The output will be '9:00-10:00'.\n */\n@Pipe({\n  name: 'adjustAggregatedTimeRange',\n  standalone: true\n})\nexport class AdjustAggregatedTimeRangePipe implements PipeTransform {\n  /**\n   * Transforms the input time based on the aggregation type.\n   * @param inputTime The input time string.\n   * @param aggregationType The type of aggregation (optional).\n   * @returns The transformed time string.\n   */\n  transform(inputTime: string, aggregationType?: AggregationOption): string {\n    if (!aggregationType) {\n      return inputTime;\n    }\n\n    if (aggregationType === AggregationTypeEnum.DAILY) {\n      return '';\n    }\n\n    const date = this.createDateFromInput(inputTime);\n    const isTwelveHoursFormat = this.isTwelveHoursFormat(inputTime);\n\n    switch (aggregationType) {\n      case AggregationTypeEnum.HOURLY:\n        return this.getHourlyTimeRange(date, isTwelveHoursFormat);\n      case AggregationTypeEnum.MINUTELY:\n        return this.getMinutelyTimeRange(date, isTwelveHoursFormat);\n      default:\n        throw new Error('Unsupported aggregation type');\n    }\n  }\n\n  /**\n   * Creates a date object from the input time string.\n   * @param inputTime The input time string.\n   * @returns The created Date object.\n   */\n  private createDateFromInput(inputTime: string): Date {\n    const defaultDate = '1970-01-01 ';\n    const isPM = /PM/i.test(inputTime);\n    const cleanedTime = inputTime.replace(/AM|PM/i, '').trim();\n\n    this.validateTimeFormat(cleanedTime, inputTime);\n\n    const dateTimeString = `${defaultDate}${cleanedTime}`;\n    const date = new Date(dateTimeString);\n\n    if (isNaN(date.getTime())) {\n      throw new Error('Invalid input time');\n    }\n\n    return this.adjustForPMTime(date, isPM);\n  }\n\n  /**\n   * Validates if the time string matches the required format and has valid values.\n   * @param time The time string to validate.\n   * @param originalInput The original input string (including AM/PM if present).\n   * @throws Error if the time format is invalid or values are out of range.\n   */\n  private validateTimeFormat(time: string, originalInput: string): void {\n    const parts = time.split(':');\n    this.validateTimeParts(parts);\n\n    const [hoursStr, minutesStr, secondsStr] = parts;\n    this.validateTimeDigits(hoursStr, minutesStr, secondsStr);\n\n    const { hours, minutes, seconds } = this.parseTimeComponents(hoursStr, minutesStr, secondsStr);\n    this.validateTimeRanges(hours, minutes, seconds);\n    this.validateTimeFormat24Hour(hours, originalInput);\n  }\n\n  private validateTimeParts(parts: string[]): void {\n    if (parts.length < 2 || parts.length > 3) {\n      throw new Error('Invalid input time');\n    }\n  }\n\n  private validateTimeDigits(hoursStr: string, minutesStr: string, secondsStr?: string): void {\n    if (\n      !this.isValidNumberString(hoursStr) ||\n      !this.isValidNumberString(minutesStr) ||\n      (secondsStr !== undefined && !this.isValidNumberString(secondsStr))\n    ) {\n      throw new Error('Invalid input time');\n    }\n  }\n\n  private parseTimeComponents(hoursStr: string, minutesStr: string, secondsStr?: string) {\n    return {\n      hours: Number(hoursStr),\n      minutes: Number(minutesStr),\n      seconds: secondsStr ? Number(secondsStr) : 0\n    };\n  }\n\n  private validateTimeRanges(hours: number, minutes: number, seconds: number): void {\n    if (hours > 23 || hours < 0 || minutes > 59 || minutes < 0 || seconds > 59 || seconds < 0) {\n      throw new Error('Invalid input time');\n    }\n  }\n\n  private validateTimeFormat24Hour(hours: number, originalInput: string): void {\n    if (hours > 12 && this.hasAmPm(originalInput)) {\n      throw new Error('Invalid input time');\n    }\n  }\n\n  /**\n   * Checks if string contains only digits and is 1-2 characters long.\n   * @param value String to check\n   * @returns boolean indicating if string is valid\n   */\n  private isValidNumberString(value: string): boolean {\n    return (\n      value.length > 0 &&\n      value.length <= 2 &&\n      value.split('').every(char => char >= '0' && char <= '9')\n    );\n  }\n\n  /**\n   * Checks if the input time has AM/PM markers.\n   * @param input The input time string to check.\n   * @returns boolean indicating if the input contains AM/PM.\n   */\n  private hasAmPm(input: string): boolean {\n    return /AM|PM/i.test(input);\n  }\n\n  /**\n   * Adjusts the date for PM times by adding 12 hours when necessary.\n   * @param date The date object to adjust.\n   * @param isPM Boolean indicating if the time is PM.\n   * @returns The adjusted Date object.\n   */\n  private adjustForPMTime(date: Date, isPM: boolean): Date {\n    const hours = date.getHours();\n    if (isPM && hours < 12) {\n      date.setHours(hours + 12);\n    } else if (!isPM && hours === 12) {\n      date.setHours(0);\n    }\n    return date;\n  }\n\n  /**\n   * Checks if the input time is in twelve hours format.\n   * @param inputTime The input time string.\n   * @returns True if the input time is in twelve hours format, false otherwise.\n   */\n  private isTwelveHoursFormat(inputTime: string): boolean {\n    return /AM|PM/i.test(inputTime);\n  }\n\n  /**\n   * Gets the hourly time range for the given date.\n   * @param date The date object.\n   * @param twelveHoursFormat Indicates whether to use twelve hours format.\n   * @returns The hourly time range string.\n   */\n  private getHourlyTimeRange(date: Date, twelveHoursFormat: boolean): string {\n    const nextHour = new Date(date.getTime());\n    nextHour.setHours(date.getHours() + 1);\n    return `${this.formatTime(date, twelveHoursFormat, true)}-${this.formatTime(nextHour, twelveHoursFormat, true)}`;\n  }\n\n  /**\n   * Gets the minutely time range for the given date.\n   * @param date The date object.\n   * @param twelveHoursFormat Indicates whether to use twelve hours format.\n   * @returns The minutely time range string.\n   */\n  private getMinutelyTimeRange(date: Date, twelveHoursFormat: boolean): string {\n    const nextMinute = new Date(date.getTime());\n    nextMinute.setMinutes(date.getMinutes() + 1);\n    return `${this.formatTime(date, twelveHoursFormat, false)}-${this.formatTime(nextMinute, twelveHoursFormat, false)}`;\n  }\n\n  /**\n   * Formats the given date into a time string.\n   * @param date The date to format.\n   * @param usePeriod Indicates whether to include the period (AM/PM) in the formatted time.\n   * @param useHourOnly Indicates whether to include only the hour part in the formatted time.\n   * @returns The formatted time string.\n   */\n  private formatTime(date: Date, usePeriod: boolean, useHourOnly: boolean): string {\n    const hours = date.getHours();\n    const minutes = date.getMinutes().toString().padStart(2, '0');\n    if (usePeriod) {\n      const period = hours >= 12 ? 'PM' : 'AM';\n      const formattedHours = hours % 12 === 0 ? 12 : hours % 12;\n      return `${formattedHours}:${useHourOnly ? '00' : minutes} ${period}`;\n    } else {\n      return `${hours.toString().padStart(2, '0')}:${useHourOnly ? '00' : minutes}`;\n    }\n  }\n}\n"]}

package/esm2022/widgets/implementations/datapoints-table/datapoints-table-view/apply-range-class.pipe.mjs

@@ -0,0 +1,36 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Applies CSS classes based on the value's range.
+ */
+export class ApplyRangeClassPipe {
+    /**
+     * Transforms the input value based on the specified ranges.
+     *
+     * @param value - Initial value used to determine the CSS class.
+     * @param ranges - An object containing the min and max range values for yellow and red colors.
+     * @returns The CSS class to be applied.
+     */
+    transform(value, ranges) {
+        if (value == null) {
+            return;
+        }
+        if (value >= ranges.yellowRangeMin && value < ranges.yellowRangeMax) {
+            return 'text-warning';
+        }
+        else if (value >= ranges.redRangeMin && value <= ranges.redRangeMax) {
+            return 'text-danger';
+        }
+        return 'default';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: ApplyRangeClassPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.9", ngImport: i0, type: ApplyRangeClassPipe, isStandalone: true, name: "applyRangeClass" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: ApplyRangeClassPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'applyRangeClass',
+                    standalone: true
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/widgets/implementations/datapoints-table/datapoints-table-view/column-title.pipe.mjs

@@ -0,0 +1,45 @@
+import { Pipe } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { RENDER_TYPES_LABELS } from '../datapoints-table-widget.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+/**
+ * Creates a column header title message.
+ *
+ * ```html
+ * title="{{ header | columnTitle }}"
+ * ```
+ * The output will be e.g.: 'c8y_Temperature → T [T] (Area)'.
+ */
+export class ColumnTitlePipe {
+    constructor(translateService) {
+        this.translateService = translateService;
+    }
+    /**
+     * Transforms the column header into a formatted string with label and optionally unit and render type.
+     *
+     * @param columnHeader - The column header object.
+     * @returns The formatted string with label, unit, and render type.
+     */
+    transform(columnHeader) {
+        const label = columnHeader.label.trim();
+        const unit = columnHeader.unit ? `[${columnHeader.unit.trim()}]` : '';
+        const renderType = columnHeader.renderType
+            ? this.translateService.instant(RENDER_TYPES_LABELS[columnHeader.renderType])
+            : '';
+        if (!renderType) {
+            return `${label} ${unit}`.trim();
+        }
+        return `${label} ${unit} (${renderType})`.trim();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: ColumnTitlePipe, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.9", ngImport: i0, type: ColumnTitlePipe, isStandalone: true, name: "columnTitle" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: ColumnTitlePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'columnTitle',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.TranslateService }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,116 @@
+import { ChangeDetectorRef, Component, EventEmitter, Injector, Input, Output, ViewChild } from '@angular/core';
+import { CommonModule, CountdownIntervalComponent, CountdownIntervalModule, IntervalBasedReload, ListGroupModule, gettext } from '@c8y/ngx-components';
+import { TranslateService } from '@ngx-translate/core';
+import { TooltipModule } from 'ngx-bootstrap/tooltip';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+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, injector, translateService) {
+        super();
+        this.cdRef = cdRef;
+        this.injector = injector;
+        this.translateService = translateService;
+        /**
+         * @inheritdoc
+         */
+        this.onCountdownEnded = new EventEmitter();
+        /**
+         * @inheritdoc
+         */
+        this.manuallyDisabledCountdown = false;
+    }
+    ngOnChanges(changes) {
+        if (this.isDisabled && this.isAutoRefreshEnabled) {
+            this.isIntervalRefreshToggleOn = false;
+            this.disableCountdown();
+            return;
+        }
+        if (this.isExportModalOpen && this.canDisableCountdownWhenModalIsOpen()) {
+            this.isIntervalRefreshToggleOn = !this.isIntervalRefreshToggleOn;
+            this.disableCountdown();
+        }
+        else {
+            if (this.canStartCountdown(changes)) {
+                this.isIntervalRefreshToggleOn = true;
+                this.startCountdown(this.injector);
+            }
+            if (this.canHandleScrolling()) {
+                this.handleScrolling();
+            }
+        }
+    }
+    /**
+     * @inheritdoc
+     */
+    countdownEnded() {
+        /**
+         * @inheritdoc
+         */
+        this.autoRefreshList();
+    }
+    reload() {
+        /**
+         * @inheritdoc
+         */
+        this.autoRefreshList();
+    }
+    /**
+     * @inheritdoc
+     */
+    enableCountdown() {
+        this.hideCountdown = false;
+        // Prevents the countdown from getting stuck on an initial value.
+        this.cdRef.detectChanges();
+        this.startCountdown(this.injector);
+    }
+    /**
+     * @inheritdoc
+     */
+    updateCountdownButtonTooltipText() {
+        this.toggleCountdownButtonTooltipText = this.isIntervalRefreshToggleOn
+            ? this.translateService.instant(gettext('Disable auto refresh'))
+            : this.translateService.instant(gettext('Enable auto refresh'));
+    }
+    canStartCountdown(changes) {
+        const { isAutoRefreshEnabled, refreshInterval } = changes;
+        return ((isAutoRefreshEnabled || refreshInterval) &&
+            (this.isAutoRefreshEnabled || !!this.refreshInterval));
+    }
+    canHandleScrolling() {
+        return !this.manuallyDisabledCountdown && this.isAutoRefreshEnabled;
+    }
+    canDisableCountdownWhenModalIsOpen() {
+        return (this.isAutoRefreshEnabled &&
+            !!this.refreshInterval &&
+            !this.manuallyDisabledCountdown &&
+            !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: i0.Injector }, { token: i1.TranslateService }], 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", isDisabled: "isDisabled", isLoading: "isLoading", isScrolling: "isScrolling", isExportModalOpen: "isExportModalOpen", refreshInterval: "refreshInterval" }, outputs: { onCountdownEnded: "onCountdownEnded" }, viewQueries: [{ propertyName: "countdownIntervalComponent", first: true, predicate: CountdownIntervalComponent, descendants: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<div class=\"d-flex a-i-center p-t-4 p-b-4\">\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]=\"isDisabled\"\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]=\"isDisabled\"\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]=\"isLoading()\"\n        (click)=\"reload()\"\n        data-cy=\"c8y-data-points-table-widget--reload-button\"\n      >\n        <i\n          c8yIcon=\"refresh\"\n          [ngClass]=\"{ 'icon-spin': isLoading() }\"\n        ></i>\n      </button>\n    </div>\n  </div>\n</div>\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: "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: "<div class=\"d-flex a-i-center p-t-4 p-b-4\">\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]=\"isDisabled\"\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]=\"isDisabled\"\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]=\"isLoading()\"\n        (click)=\"reload()\"\n        data-cy=\"c8y-data-points-table-widget--reload-button\"\n      >\n        <i\n          c8yIcon=\"refresh\"\n          [ngClass]=\"{ 'icon-spin': isLoading() }\"\n        ></i>\n      </button>\n    </div>\n  </div>\n</div>\n" }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.Injector }, { type: i1.TranslateService }], propDecorators: { countdownIntervalComponent: [{
+                type: ViewChild,
+                args: [CountdownIntervalComponent, { static: false }]
+            }], isAutoRefreshEnabled: [{
+                type: Input
+            }], isDisabled: [{
+                type: Input
+            }], isLoading: [{
+                type: Input
+            }], isScrolling: [{
+                type: Input
+            }], isExportModalOpen: [{
+                type: Input
+            }], refreshInterval: [{
+                type: Input
+            }], 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  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  Injector,\n  Input,\n  OnChanges,\n  Output,\n  Signal,\n  SimpleChanges,\n  ViewChild\n} from '@angular/core';\nimport {\n  CommonModule,\n  CountdownIntervalComponent,\n  CountdownIntervalModule,\n  IntervalBasedReload,\n  ListGroupModule,\n  gettext\n} from '@c8y/ngx-components';\nimport { TranslateService } from '@ngx-translate/core';\nimport { TooltipModule } from 'ngx-bootstrap/tooltip';\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 extends IntervalBasedReload implements OnChanges {\n  @ViewChild(CountdownIntervalComponent, { static: false })\n  countdownIntervalComponent: CountdownIntervalComponent;\n  /**\n   * @inheritdoc\n   */\n  @Input() isAutoRefreshEnabled: boolean;\n\n  @Input() isDisabled: boolean;\n  /**\n   * @inheritdoc\n   */\n  @Input() isLoading: Signal<boolean>;\n\n  @Input() isScrolling: boolean;\n\n  @Input() isExportModalOpen: boolean;\n  /**\n   * @inheritdoc\n   */\n  @Input() refreshInterval: number;\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  constructor(\n    private cdRef: ChangeDetectorRef,\n    private injector: Injector,\n    private translateService: TranslateService\n  ) {\n    super();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (this.isDisabled && 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(this.injector);\n      }\n\n      if (this.canHandleScrolling()) {\n        this.handleScrolling();\n      }\n    }\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(this.injector);\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","<div class=\"d-flex a-i-center p-t-4 p-b-4\">\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]=\"isDisabled\"\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]=\"isDisabled\"\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]=\"isLoading()\"\n        (click)=\"reload()\"\n        data-cy=\"c8y-data-points-table-widget--reload-button\"\n      >\n        <i\n          c8yIcon=\"refresh\"\n          [ngClass]=\"{ 'icon-spin': isLoading() }\"\n        ></i>\n      </button>\n    </div>\n  </div>\n</div>\n"]}