node-opcua-aggregates 2.178.0 → 2.179.0

package/source/calculate_bad_good.ts

@@ -1,14 +1,13 @@
 import { extraStatusCodeBits, StatusCode, StatusCodes } from "node-opcua-status-code";
 
-import { Interval, AggregateConfigurationOptions, isUncertain } from "./interval";
-
+import { type AggregateConfigurationOptions, type Interval, isUncertain } from "./interval";
 
 const a = (s: StatusCode | undefined, options: AggregateConfigurationOptions) =>
     !s || s === StatusCodes.BadNoData
         ? StatusCodes.BadNoData
         : s.isBad() || (options.treatUncertainAsBad && isUncertain(s))
-        ? StatusCodes.Bad
-        : StatusCodes.Good;
+          ? StatusCodes.Bad
+          : StatusCodes.Good;
 
 function findLowBound(
     interval: Interval,
@@ -17,7 +16,7 @@ function findLowBound(
     const indexStart: number = interval.index;
 
     const initialValue = interval.dataValues[indexStart];
-    if (initialValue.sourceTimestamp!.getTime() === interval.startTime.getTime()) {
+    if (initialValue.sourceTimestamp?.getTime() === interval.startTime.getTime()) {
         return { previousStatus: initialValue.statusCode, previousTime: interval.startTime.getTime(), indexStart: indexStart + 1 };
     }
     const previousStatus =
@@ -28,7 +27,6 @@ function findLowBound(
     return { previousStatus, previousTime, indexStart };
 }
 
-// eslint-disable-next-line max-statements, complexity
 export function calculateBadAndGood(
     interval: Interval,
     options: AggregateConfigurationOptions
@@ -82,7 +80,10 @@ export function calculateBadAndGood(
         if (currentStatus === StatusCodes.BadNoData) {
             partialFlag = extraStatusCodeBits.HistorianPartial;
         }
-        const currentTime = dataValue.sourceTimestamp!.getTime();
+        if (!dataValue.sourceTimestamp) {
+            throw new Error("calculateBadAndGood: dataValue is missing a sourceTimestamp");
+        }
+        const currentTime = dataValue.sourceTimestamp.getTime();
 
         // debugLog(" ", dataValue.sourceTimestamp?.toISOString(), dataValue.statusCode.toString(), dataValue.value.value);
 
@@ -125,12 +126,10 @@ export function calculateBadAndGood(
     const percentGood = (durationGood / effectiveProcessingInterval) * 100;
     const percentBad = (durationBad / effectiveProcessingInterval) * 100;
 
-    let percentDataGood = options.percentDataGood === undefined ? 100 : options.percentDataGood;
     const percentDataBad = options.percentDataBad === undefined ? 100 : options.percentDataBad;
 
     if (percentBad >= percentDataBad || (nbGood === 0 && nbUncertain === 0)) {
         durationGood = 0; // BAD
-        percentDataGood = -1;
         // const statusCode = StatusCodes.Bad;
         //return { durationGood, durationBad, durationUnknown, percentBad, percentGood, statusCode };
     }

package/source/common.ts

@@ -1,15 +1,15 @@
 /**
  * @module node-opca-aggregates
  */
-import { SessionContext, UAVariable, ContinuationPointManager, ContinuationPoint } from "node-opcua-address-space";
+import { type ContinuationPoint, ContinuationPointManager, SessionContext, type UAVariable } from "node-opcua-address-space";
 import { NodeClass } from "node-opcua-data-model";
 import { DataValue } from "node-opcua-data-value";
-import { HistoryData, HistoryReadResult, ReadRawModifiedDetails } from "node-opcua-service-history";
-import { StatusCode, StatusCodes } from "node-opcua-status-code";
 import { coerceNodeId } from "node-opcua-nodeid";
+import { type HistoryData, type HistoryReadResult, ReadRawModifiedDetails } from "node-opcua-service-history";
+import { StatusCode } from "node-opcua-status-code";
 
 import { getAggregateConfiguration } from "./aggregates";
-import { getInterval, Interval, AggregateConfigurationOptionsEx } from "./interval";
+import { type AggregateConfigurationOptionsEx, getInterval, type Interval } from "./interval";
 
 /**
  * @internal
@@ -40,7 +40,7 @@ function processAggregateData(
         const dataValue = lambda(interval, aggregateConfiguration);
 
         /* c8 ignore next */
-        if (!dataValue || !dataValue.sourceTimestamp) {
+        if (!dataValue?.sourceTimestamp) {
             // const dataValue = interval.interpolatedValue(aggregateConfiguration);
             throw Error("invalid DataValue");
         }
@@ -63,12 +63,14 @@ export function getAggregateData(
 ): void {
     /* c8 ignore next */
     if (node.nodeClass !== NodeClass.Variable) {
-        return callback(new Error("node must be UAVariable"));
+        callback(new Error("node must be UAVariable"));
+        return;
     }
 
     /* c8 ignore next */
     if (processingInterval <= 0) {
-        return callback(new Error("Invalid processing interval, shall be greater than 0"));
+        callback(new Error("Invalid processing interval, shall be greater than 0"));
+        return;
     }
 
     const continuationPointManager = new ContinuationPointManager();
@@ -99,7 +101,10 @@ export function getAggregateData(
             if (err) {
                 return callback(err);
             }
-            const historyData = result!.historyData as HistoryData;
+            if (!result) {
+                return callback(new Error("getAggregateData: expecting a result when err is null"));
+            }
+            const historyData = result.historyData as HistoryData;
 
             const dataValues = historyData.dataValues || [];
 
@@ -109,9 +114,12 @@ export function getAggregateData(
 }
 
 export function interpolateValue(dataValue1: DataValue, dataValue2: DataValue, date: Date): DataValue {
-    const t0 = dataValue1.sourceTimestamp!.getTime();
+    if (!dataValue1.sourceTimestamp || !dataValue2.sourceTimestamp) {
+        throw new Error("interpolateValue: both dataValues must have a sourceTimestamp");
+    }
+    const t0 = dataValue1.sourceTimestamp.getTime();
     const t = date.getTime();
-    const t1 = dataValue2.sourceTimestamp!.getTime();
+    const t1 = dataValue2.sourceTimestamp.getTime();
     const coef1 = (t - t0) / (t1 - t0);
     const coef2 = (t1 - t) / (t1 - t0);
     const value = dataValue1.value.clone();

package/source/count.ts

@@ -1,10 +1,10 @@
-import { UAVariable } from "node-opcua-address-space";
+import type { UAVariable } from "node-opcua-address-space";
 import { DataValue } from "node-opcua-data-value";
 import { extraStatusCodeBits, StatusCode, StatusCodes } from "node-opcua-status-code";
 import { DataType } from "node-opcua-variant";
 
 import { getAggregateData } from "./common";
-import { Interval, AggregateConfigurationOptions, isUncertain } from "./interval";
+import { type AggregateConfigurationOptions, type Interval, isUncertain } from "./interval";
 
 /**
  * The Count Aggregate retrieves a count of all the raw values within an interval.
@@ -22,7 +22,7 @@ function calculateCountValue(interval: Interval, options: AggregateConfiguration
     let nbUncertain = 0;
     let badDuration = 0;
     let uncertainDuration = 0;
-    let goodDuration = 0;
+    let _goodDuration = 0;
     for (let i = indexStart; i < indexStart + interval.count; i++) {
         const dataValue = interval.dataValues[i];
         if (dataValue.statusCode.equals(StatusCodes.BadNoData)) {
@@ -38,7 +38,7 @@ function calculateCountValue(interval: Interval, options: AggregateConfiguration
             uncertainDuration += regionDuration;
         } else if (dataValue.statusCode.isGoodish()) {
             nbGood++;
-            goodDuration += regionDuration;
+            _goodDuration += regionDuration;
         }
     }
 

package/source/duration_bad.ts

@@ -1,11 +1,10 @@
-import { UAVariable } from "node-opcua-address-space";
+import type { UAVariable } from "node-opcua-address-space";
 import { DataValue } from "node-opcua-data-value";
-import { DataType } from "node-opcua-variant";
 import { StatusCodes } from "node-opcua-status-code";
-
-import { getAggregateData } from "./common";
-import { Interval, AggregateConfigurationOptions } from "./interval";
+import { DataType } from "node-opcua-variant";
 import { calculateBadAndGood } from "./calculate_bad_good";
+import { getAggregateData } from "./common";
+import type { AggregateConfigurationOptions, Interval } from "./interval";
 
 function calculateDurationBad(interval: Interval, options: AggregateConfigurationOptions): DataValue {
     const { durationBad, durationUnknown, statusCode } = calculateBadAndGood(interval, options);

package/source/duration_good.ts

@@ -1,15 +1,14 @@
-import { UAVariable } from "node-opcua-address-space";
+import type { UAVariable } from "node-opcua-address-space";
 import { DataValue } from "node-opcua-data-value";
-import { DataType } from "node-opcua-variant";
 import { StatusCodes } from "node-opcua-status-code";
-
-import { getAggregateData } from "./common";
-import { Interval, AggregateConfigurationOptions } from "./interval";
+import { DataType } from "node-opcua-variant";
 import { calculateBadAndGood } from "./calculate_bad_good";
+import { getAggregateData } from "./common";
+import type { AggregateConfigurationOptions, Interval } from "./interval";
 
 function calculateDurationGood(interval: Interval, options: AggregateConfigurationOptions): DataValue {
     const { durationGood, durationUnknown, statusCode } = calculateBadAndGood(interval, options);
-    if (durationUnknown>0  && durationGood ===0) {
+    if (durationUnknown > 0 && durationGood === 0) {
         return new DataValue({
             sourceTimestamp: interval.startTime,
             statusCode: StatusCodes.Bad

package/source/index.ts

@@ -1,22 +1,23 @@
 /**
  * @module node-opca-aggregates
  */
+
+export { AggregateFunction } from "node-opcua-constants";
 export {
+    addAggregateFunctionSupport,
+    addAggregateStandardFunctionSupport,
     addAggregateSupport,
-    installAggregateConfigurationOptions,
     getAggregateConfiguration,
-    addAggregateStandardFunctionSupport,
-    addAggregateFunctionSupport
+    installAggregateConfigurationOptions
 } from "./aggregates";
-export * from "./interpolate";
-export * from "./minmax";
-export * from "./interval";
-export * from "./common";
 export * from "./average";
-export * from "./read_processed_details";
-export { AggregateFunction } from "node-opcua-constants";
+export * from "./common";
 export { getCountData } from "./count";
-export { getPercentGoodData } from "./percent_good";
-export { getPercentBadData } from "./percent_bad";
 export { getDurationBadData } from "./duration_bad";
 export { getDurationGoodData } from "./duration_good";
+export * from "./interpolate";
+export * from "./interval";
+export * from "./minmax";
+export { getPercentBadData } from "./percent_bad";
+export { getPercentGoodData } from "./percent_good";
+export * from "./read_processed_details";

package/source/interpolate.ts

@@ -37,18 +37,13 @@
 // Bound Bad                   Does not return a Bad bound except as noted above
 // Bound Uncertain             Returned Uncertain_DataSubNormal if any Bad value(s) was/were skipped to
 //                             calculate the bounding value.
-import { UAVariable } from "node-opcua-address-space";
+import type { UAVariable } from "node-opcua-address-space";
 import { assert } from "node-opcua-assert";
 import { DataValue } from "node-opcua-data-value";
 import { StatusCode, StatusCodes } from "node-opcua-status-code";
 
 import { getAggregateData, interpolateValue } from "./common";
-import {
-    _findGoodDataValueBefore,
-    adjustProcessingOptions,
-    AggregateConfigurationOptionsEx,
-    Interval,
-} from "./interval";
+import { _findGoodDataValueBefore, type AggregateConfigurationOptionsEx, adjustProcessingOptions, type Interval } from "./interval";
 
 /*
  For any intervals containing regions where the StatusCodes are Bad,
@@ -63,10 +58,10 @@ import {
 export function interpolatedValue(interval: Interval, options: AggregateConfigurationOptionsEx): DataValue {
     options = adjustProcessingOptions(options);
 
-    assert(Object.prototype.hasOwnProperty.call(options, "useSlopedExtrapolation"));
-    assert(Object.prototype.hasOwnProperty.call(options, "treatUncertainAsBad"));
+    assert(Object.hasOwn(options, "useSlopedExtrapolation"));
+    assert(Object.hasOwn(options, "treatUncertainAsBad"));
 
-    const bTreatUncertainAsBad = options.treatUncertainAsBad!;
+    const bTreatUncertainAsBad = options.treatUncertainAsBad || false;
 
     const steppedValue = (previousDataValue: DataValue): DataValue => {
         if (!previousDataValue.statusCode) {
@@ -105,7 +100,6 @@ export function interpolatedValue(interval: Interval, options: AggregateConfigur
         // else interpolate
         const interpVal = interpolateValue(prev2.dataValue, prev1.dataValue, interval.startTime);
 
-        // tslint:disable:no-bitwise
         if (prev2.index + 1 < prev1.index || prev1.index < interval.dataValues.length - 1) {
             // some bad data exist in between = change status code
             const mask = 0x0000ffffff;
@@ -163,7 +157,6 @@ export function interpolatedValue(interval: Interval, options: AggregateConfigur
     const interpolatedDataValue = interpolateValue(before.dataValue, next.dataValue, interval.startTime);
 
     if (before.index + 1 < next.index || !next.dataValue.statusCode.isGood() || !before.dataValue.statusCode.isGood()) {
-        // tslint:disable:no-bitwise
         // some bad data exist in between = change status code
         const mask = 0x0000ffffff;
         const extraBits = interpolatedDataValue.statusCode.value & mask;

package/source/interval.ts

@@ -2,25 +2,31 @@
  * @module node-opca-aggregates
  */
 import { DataValue } from "node-opcua-data-value";
-import { StatusCode, StatusCodes } from "node-opcua-status-code";
-import { AggregateConfigurationOptions } from "node-opcua-types";
+import { type StatusCode, StatusCodes } from "node-opcua-status-code";
+import type { AggregateConfigurationOptions } from "node-opcua-types";
+
 export { AggregateConfigurationOptions } from "node-opcua-types";
 
 export interface AggregateConfigurationOptionsEx extends AggregateConfigurationOptions {
     stepped?: boolean;
 }
 
-
 export function isGoodish2(statusCode: StatusCode, { treatUncertainAsBad }: { treatUncertainAsBad?: boolean }): boolean {
     if (statusCode.isGoodish()) return true;
     if (isUncertain(statusCode)) return !treatUncertainAsBad;
     return false;
 }
 
-
 export function isUncertain(statusCode: StatusCode): boolean {
     return (statusCode.value & 0x40000000) === 0x40000000 && statusCode.value !== StatusCodes.BadNoData.value;
 }
+function sourceTimestampMs(dataValue: DataValue): number {
+    if (!dataValue.sourceTimestamp) {
+        throw new Error("expecting dataValue to have a sourceTimestamp");
+    }
+    return dataValue.sourceTimestamp.getTime();
+}
+
 export interface IntervalOptions {
     startTime: Date;
     dataValues: DataValue[];
@@ -86,9 +92,9 @@ export function adjustProcessingOptions(options: AggregateConfigurationOptionsEx
     options = options || {};
     options.treatUncertainAsBad = options.treatUncertainAsBad || false;
     options.useSlopedExtrapolation = options.useSlopedExtrapolation || false;
-    options.stepped = options.stepped! || false;
-    options.percentDataBad = parseInt(options.percentDataBad as any, 10);
-    options.percentDataGood = parseInt(options.percentDataGood as any, 10);
+    options.stepped = options.stepped || false;
+    options.percentDataBad = parseInt(String(options.percentDataBad ?? 0), 10);
+    options.percentDataGood = parseInt(String(options.percentDataGood ?? 0), 10);
     return options;
 }
 
@@ -126,7 +132,7 @@ export class Interval {
             return false;
         }
         const dataValue1 = this.dataValues[index];
-        return this.startTime.getTime() === dataValue1!.sourceTimestamp!.getTime();
+        return this.startTime.getTime() === sourceTimestampMs(dataValue1);
     }
 
     /**
@@ -144,14 +150,14 @@ export class Interval {
 
     public toString(): string {
         let str = "";
-        str += "startTime " + this.startTime.toUTCString() + "\n";
-        str += "start     " + this.index + "  ";
-        str += "count     " + this.count + " ";
-        str += "isPartial " + this.isPartial + "\n";
+        str += `startTime ${this.startTime.toUTCString()}\n`;
+        str += `start     ${this.index}  `;
+        str += `count     ${this.count} `;
+        str += `isPartial ${this.isPartial}\n`;
         if (this.index >= 0) {
             for (let i = this.index; i < this.index + this.count; i++) {
                 const dataValue = this.dataValues[i];
-                str += " " + dataValue.sourceTimestamp!.toUTCString() + dataValue.statusCode.toString();
+                str += ` ${dataValue.sourceTimestamp?.toUTCString()}${dataValue.statusCode.toString()}`;
                 str += dataValue.value ? dataValue.value.toString() : "";
                 str += "\n";
             }
@@ -170,16 +176,16 @@ export class Interval {
         if (i < 0) {
             return e;
         }
-        const lastTimestamp = this.dataValues[i].sourceTimestamp!;
-        return Math.min(e, lastTimestamp.getTime() + 1);
+        const lastTimestamp = this.dataValues[i].sourceTimestamp;
+        return lastTimestamp ? Math.min(e, lastTimestamp.getTime() + 1) : e;
     }
 
     /**
-     * 
+     *
      * @returns the interval duration
      */
     duration() {
-        const t1 = this.dataValues[this.index].sourceTimestamp!.getTime();
+        const t1 = sourceTimestampMs(this.dataValues[this.index]);
         const e = this.getEffectiveEndTime();
         return e - t1;
     }
@@ -188,9 +194,9 @@ export class Interval {
      * returns the region duration starting at index and finishing at index+1 or end limit of the interval
      */
     regionDuration(index: number): number {
-        const t1 = this.dataValues[index].sourceTimestamp!.getTime();
+        const t1 = sourceTimestampMs(this.dataValues[index]);
         const e = this.getEffectiveEndTime();
-        const t2 = index < this.dataValues.length - 1 ? Math.min(this.dataValues[index + 1].sourceTimestamp!.getTime(), e) : e;
+        const t2 = index < this.dataValues.length - 1 ? Math.min(sourceTimestampMs(this.dataValues[index + 1]), e) : e;
         return t2 - t1;
     }
 }
@@ -199,7 +205,7 @@ export function getInterval(startTime: Date, processingInterval: number, indexHi
     let count = 0;
     let index = -1;
     for (let i = indexHint; i < dataValues.length; i++) {
-        if (dataValues[i].sourceTimestamp!.getTime() < startTime.getTime()) {
+        if (sourceTimestampMs(dataValues[i]) < startTime.getTime()) {
             continue;
         }
         index = i;
@@ -208,7 +214,7 @@ export function getInterval(startTime: Date, processingInterval: number, indexHi
 
     if (index >= 0) {
         for (let i = index; i < dataValues.length; i++) {
-            if (dataValues[i].sourceTimestamp!.getTime() >= startTime.getTime() + processingInterval) {
+            if (sourceTimestampMs(dataValues[i]) >= startTime.getTime() + processingInterval) {
                 break;
             }
             count++;
@@ -219,11 +225,11 @@ export function getInterval(startTime: Date, processingInterval: number, indexHi
     let isPartial = false;
     if (
         index + count >= dataValues.length &&
-        dataValues[dataValues.length - 1].sourceTimestamp!.getTime() < startTime.getTime() + processingInterval
+        sourceTimestampMs(dataValues[dataValues.length - 1]) < startTime.getTime() + processingInterval
     ) {
         isPartial = true;
     }
-    if (index <= 0 && dataValues[0].sourceTimestamp!.getTime() > startTime.getTime()) {
+    if (index <= 0 && sourceTimestampMs(dataValues[0]) > startTime.getTime()) {
         isPartial = true;
     }
 

package/source/minmax.ts

@@ -52,18 +52,17 @@
 // No End Bound             Not Applicable
 // Bound Bad                Not Applicable
 // Bound Uncertain          Not Applicable
-import { UAVariable } from "node-opcua-address-space";
+import type { UAVariable } from "node-opcua-address-space";
 import { DataValue } from "node-opcua-data-value";
 import { StatusCode, StatusCodes } from "node-opcua-status-code";
-import { Variant } from "node-opcua-variant";
+import type { Variant } from "node-opcua-variant";
 
 import { getAggregateData } from "./common";
-import { AggregateConfigurationOptions, Interval } from "./interval";
+import type { AggregateConfigurationOptions, Interval } from "./interval";
 
-// eslint-disable-next-line max-statements
 function calculateIntervalMinOrMaxValue(
     interval: Interval,
-    options: AggregateConfigurationOptions,
+    _options: AggregateConfigurationOptions,
     predicate: (a: Variant, b: Variant) => "equal" | "select" | "reject"
 ): DataValue {
     //   debugLog(interval.toString());
@@ -94,7 +93,7 @@ function calculateIntervalMinOrMaxValue(
         if (!selectedValue) {
             selectedValue = dataValue.value;
             counter = 1;
-            if (i === indexStart && dataValue.sourceTimestamp!.getTime() === interval.startTime.getTime()) {
+            if (i === indexStart && dataValue.sourceTimestamp?.getTime() === interval.startTime.getTime()) {
                 isRaw = true;
             }
             continue;
@@ -138,7 +137,7 @@ function calculateIntervalMinOrMaxValue(
     return new DataValue({
         sourceTimestamp: interval.startTime,
         statusCode: statusCode as StatusCode,
-        value: selectedValue!
+        value: selectedValue
     });
 }
 
@@ -217,7 +216,7 @@ export function getMinData(
     endDate: Date,
     callback: (err: Error | null, dataValues?: DataValue[]) => void
 ): void {
-    return getAggregateData(node, processingInterval, startDate, endDate, calculateIntervalMinValue, callback);
+    getAggregateData(node, processingInterval, startDate, endDate, calculateIntervalMinValue, callback);
 }
 
 export function getMaxData(
@@ -227,5 +226,5 @@ export function getMaxData(
     endDate: Date,
     callback: (err: Error | null, dataValues?: DataValue[]) => void
 ): void {
-    return getAggregateData(node, processingInterval, startDate, endDate, calculateIntervalMaxValue, callback);
+    getAggregateData(node, processingInterval, startDate, endDate, calculateIntervalMaxValue, callback);
 }

package/source/percent_bad.ts

@@ -1,10 +1,9 @@
-import { UAVariable } from "node-opcua-address-space";
+import type { UAVariable } from "node-opcua-address-space";
 import { DataValue } from "node-opcua-data-value";
 import { DataType } from "node-opcua-variant";
-
-import { getAggregateData } from "./common";
-import { Interval, AggregateConfigurationOptions } from "./interval";
 import { calculateBadAndGood } from "./calculate_bad_good";
+import { getAggregateData } from "./common";
+import type { AggregateConfigurationOptions, Interval } from "./interval";
 
 function calculatePercentBad(interval: Interval, options: AggregateConfigurationOptions): DataValue {
     const { percentBad, statusCode } = calculateBadAndGood(interval, options);

package/source/percent_good.ts

@@ -1,11 +1,10 @@
-import { UAVariable } from "node-opcua-address-space";
+import type { UAVariable } from "node-opcua-address-space";
 import { DataValue } from "node-opcua-data-value";
-import { DataType } from "node-opcua-variant";
 import { StatusCodes } from "node-opcua-status-code";
-
-import { getAggregateData } from "./common";
-import { Interval, AggregateConfigurationOptions } from "./interval";
+import { DataType } from "node-opcua-variant";
 import { calculateBadAndGood } from "./calculate_bad_good";
+import { getAggregateData } from "./common";
+import type { AggregateConfigurationOptions, Interval } from "./interval";
 
 function calculatePercentGood(interval: Interval, options: AggregateConfigurationOptions): DataValue {
     //

package/source/read_processed_details.ts

@@ -1,21 +1,19 @@
+import type { ContinuationData, ISessionContext, UAVariable } from "node-opcua-address-space";
 import { AggregateFunction } from "node-opcua-constants";
-import { ISessionContext, UAVariable, ContinuationData } from "node-opcua-address-space";
-import { NumericRange } from "node-opcua-numeric-range";
-import { QualifiedNameLike } from "node-opcua-data-model";
-import { CallbackT, StatusCodes } from "node-opcua-status-code";
-import { DataValue } from "node-opcua-data-value";
-import { NodeId } from "node-opcua-nodeid";
-import { HistoryData, HistoryReadResult, ReadProcessedDetails } from "node-opcua-service-history";
-
-import { getMinData, getMaxData } from "./minmax";
-
-import { getInterpolatedData } from "./interpolate";
+import type { QualifiedNameLike } from "node-opcua-data-model";
+import type { DataValue } from "node-opcua-data-value";
+import type { NodeId } from "node-opcua-nodeid";
+import type { NumericRange } from "node-opcua-numeric-range";
+import { HistoryData, HistoryReadResult, type ReadProcessedDetails } from "node-opcua-service-history";
+import { type CallbackT, StatusCodes } from "node-opcua-status-code";
 import { getAverageData } from "./average";
 import { getCountData } from "./count";
+import { getDurationBadData } from "./duration_bad";
+import { getDurationGoodData } from "./duration_good";
+import { getInterpolatedData } from "./interpolate";
+import { getMaxData, getMinData } from "./minmax";
 import { getPercentBadData } from "./percent_bad";
 import { getPercentGoodData } from "./percent_good";
-import { getDurationGoodData } from "./duration_good";
-import { getDurationBadData } from "./duration_bad";
 
 function _buildResult(err: Error | null, dataValues: DataValue[] | undefined, callback2: CallbackT<HistoryReadResult>) {
     if (err) {
@@ -85,11 +83,11 @@ function applyAggregate(
 }
 export function readProcessedDetails(
     variable: UAVariable,
-    context: ISessionContext,
+    _context: ISessionContext,
     historyReadDetails: ReadProcessedDetails,
-    indexRange: NumericRange | null,
-    dataEncoding: QualifiedNameLike | null,
-    continuationData: ContinuationData,
+    _indexRange: NumericRange | null,
+    _dataEncoding: QualifiedNameLike | null,
+    _continuationData: ContinuationData,
     callback: CallbackT<HistoryReadResult>
 ): void {
     // OPC Unified Architecture, Part 11 27 Release 1.03
@@ -143,12 +141,14 @@ export function readProcessedDetails(
     const startTime = historyReadDetails.startTime;
     const endTime = historyReadDetails.endTime;
     if (!startTime || !endTime) {
-        return callback(null, new HistoryReadResult({ statusCode: StatusCodes.BadInvalidArgument }));
+        callback(null, new HistoryReadResult({ statusCode: StatusCodes.BadInvalidArgument }));
+        return;
     }
     if (startTime.getTime() === endTime.getTime()) {
         // Start = End Int = Anything No intervals. Returns a Bad_InvalidArgument StatusCode,
         // regardless of whether there is data at the specified time or not
-        return callback(null, new HistoryReadResult({ statusCode: StatusCodes.BadInvalidArgument }));
+        callback(null, new HistoryReadResult({ statusCode: StatusCodes.BadInvalidArgument }));
+        return;
     }
 
     const aggregateTypes: NodeId[] = historyReadDetails.aggregateType || [];
@@ -157,9 +157,9 @@ export function readProcessedDetails(
     // starting at startTime and ending at endTime.
     const processingInterval = historyReadDetails.processingInterval || endTime.getTime() - startTime.getTime();
 
-    // tslint:disable-next-line: prefer-for-of
-    if (!historyReadDetails.aggregateType || historyReadDetails.aggregateType.length !== 1) {
-        return callback(null, new HistoryReadResult({ statusCode: StatusCodes.BadInternalError }));
+    if (historyReadDetails.aggregateType?.length !== 1) {
+        callback(null, new HistoryReadResult({ statusCode: StatusCodes.BadInternalError }));
+        return;
     }
-    return applyAggregate(variable, processingInterval, startTime, endTime, aggregateTypes[0], callback);
+    applyAggregate(variable, processingInterval, startTime, endTime, aggregateTypes[0], callback);
 }