node-opcua-aggregates 2.98.0 → 2.98.2

package/dist/count.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCountData = void 0;
+const node_opcua_data_value_1 = require("node-opcua-data-value");
+const node_opcua_status_code_1 = require("node-opcua-status-code");
+const node_opcua_variant_1 = require("node-opcua-variant");
+const common_1 = require("./common");
+const interval_1 = require("./interval");
+/**
+ * The Count Aggregate retrieves a count of all the raw values within an interval.
+ *  If one or more raw values are non-Good, they are not included in the count, and the Aggregate
+ *  StatusCode is determined using the StatusCode Calculation for non-time based Aggregates.
+ * If no Good data exists for an interval, the count is zero.
+ */
+function calculateCountValue(interval, options) {
+    const indexStart = interval.index;
+    let statusCode = node_opcua_status_code_1.StatusCodes.Good;
+    let isPartial = interval.isPartial;
+    let nbBad = 0;
+    let nbGood = 0;
+    let nbUncertain = 0;
+    let badDuration = 0;
+    let uncertainDuration = 0;
+    let goodDuration = 0;
+    for (let i = indexStart; i < indexStart + interval.count; i++) {
+        const dataValue = interval.dataValues[i];
+        if (dataValue.statusCode.equals(node_opcua_status_code_1.StatusCodes.BadNoData)) {
+            isPartial = true;
+            continue;
+        }
+        const regionDuration = interval.regionDuration(i);
+        if (dataValue.statusCode.isBad()) {
+            nbBad++;
+            badDuration += regionDuration;
+        }
+        else if ((0, interval_1.isUncertain)(dataValue.statusCode)) {
+            nbUncertain++;
+            uncertainDuration += regionDuration;
+        }
+        else if (dataValue.statusCode.isGoodish()) {
+            nbGood++;
+            goodDuration += regionDuration;
+        }
+    }
+    const partialFlag = isPartial ? node_opcua_status_code_1.extraStatusCodeBits.HistorianPartial : 0;
+    // console.log(" ", goodDuration, uncertainDuration, badDuration);
+    if (nbBad > 0) {
+        const duration = interval.duration();
+        if (options.treatUncertainAsBad) {
+            badDuration += uncertainDuration;
+        }
+        const actualPercentDataBad = (badDuration / duration) * 100.0;
+        const percentDataBad = options.percentDataBad === undefined ? 100 : options.percentDataBad;
+        if (actualPercentDataBad >= percentDataBad) {
+            return new node_opcua_data_value_1.DataValue({
+                sourceTimestamp: interval.startTime,
+                statusCode: node_opcua_status_code_1.StatusCodes.Bad
+            });
+        }
+    }
+    if (nbUncertain > 0 || nbBad > 0) {
+        statusCode = node_opcua_status_code_1.StatusCode.makeStatusCode(node_opcua_status_code_1.StatusCodes.UncertainDataSubNormal, node_opcua_status_code_1.extraStatusCodeBits.HistorianCalculated | partialFlag);
+    }
+    else {
+        statusCode = node_opcua_status_code_1.StatusCode.makeStatusCode(node_opcua_status_code_1.StatusCodes.Good, node_opcua_status_code_1.extraStatusCodeBits.HistorianCalculated | partialFlag);
+    }
+    if (nbUncertain === 0 && nbGood === 0) {
+        statusCode = node_opcua_status_code_1.StatusCodes.BadNoData;
+        return new node_opcua_data_value_1.DataValue({
+            sourceTimestamp: interval.startTime,
+            statusCode: statusCode
+        });
+    }
+    return new node_opcua_data_value_1.DataValue({
+        sourceTimestamp: interval.startTime,
+        statusCode: statusCode,
+        value: {
+            dataType: node_opcua_variant_1.DataType.UInt32,
+            value: nbGood
+        }
+    });
+}
+function getCountData(node, processingInterval, startDate, endDate, callback) {
+    (0, common_1.getAggregateData)(node, processingInterval, startDate, endDate, calculateCountValue, callback);
+}
+exports.getCountData = getCountData;
+//# sourceMappingURL=count.js.map

package/dist/count.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"count.js","sourceRoot":"","sources":["../source/count.ts"],"names":[],"mappings":"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"}

package/dist/duration_bad.d.ts

@@ -0,0 +1,4 @@
+import { UAVariable } from "node-opcua-address-space";
+import { DataValue } from "node-opcua-data-value";
+/**Retrieve the percentage of data (0 to 100) in the interval which has Bad StatusCode. */
+export declare function getDurationBadData(node: UAVariable, processingInterval: number, startDate: Date, endDate: Date, callback: (err: Error | null, dataValues?: DataValue[]) => void): void;

package/dist/duration_bad.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDurationBadData = void 0;
+const node_opcua_data_value_1 = require("node-opcua-data-value");
+const node_opcua_variant_1 = require("node-opcua-variant");
+const node_opcua_status_code_1 = require("node-opcua-status-code");
+const common_1 = require("./common");
+const calculate_bad_good_1 = require("./calculate_bad_good");
+function calculateDurationBad(interval, options) {
+    const { durationBad, durationUnknown, statusCode } = (0, calculate_bad_good_1.calculateBadAndGood)(interval, options);
+    if (durationUnknown > 0 && durationBad === 0) {
+        return new node_opcua_data_value_1.DataValue({
+            sourceTimestamp: interval.startTime,
+            statusCode: node_opcua_status_code_1.StatusCodes.Bad
+        });
+    }
+    const value = durationBad;
+    if (statusCode.isGoodish()) {
+        return new node_opcua_data_value_1.DataValue({
+            sourceTimestamp: interval.startTime,
+            statusCode,
+            value: { dataType: node_opcua_variant_1.DataType.Double, value }
+        });
+    }
+    return new node_opcua_data_value_1.DataValue({ sourceTimestamp: interval.startTime, statusCode, value: { dataType: node_opcua_variant_1.DataType.Null } });
+}
+/**Retrieve the percentage of data (0 to 100) in the interval which has Bad StatusCode. */
+function getDurationBadData(node, processingInterval, startDate, endDate, callback) {
+    (0, common_1.getAggregateData)(node, processingInterval, startDate, endDate, calculateDurationBad, callback);
+}
+exports.getDurationBadData = getDurationBadData;
+//# sourceMappingURL=duration_bad.js.map

package/dist/duration_bad.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration_bad.js","sourceRoot":"","sources":["../source/duration_bad.ts"],"names":[],"mappings":";;;AACA,iEAAkD;AAClD,2DAA8C;AAC9C,mEAAqD;AAErD,qCAA4C;AAE5C,6DAA2D;AAE3D,SAAS,oBAAoB,CAAC,QAAkB,EAAE,OAAsC;IACpF,MAAM,EAAE,WAAW,EAAE,eAAe,EAAE,UAAU,EAAE,GAAG,IAAA,wCAAmB,EAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC5F,IAAI,eAAe,GAAG,CAAC,IAAI,WAAW,KAAK,CAAC,EAAE;QAC1C,OAAO,IAAI,iCAAS,CAAC;YACjB,eAAe,EAAE,QAAQ,CAAC,SAAS;YACnC,UAAU,EAAE,oCAAW,CAAC,GAAG;SAC9B,CAAC,CAAC;KACN;IACD,MAAM,KAAK,GAAG,WAAW,CAAC;IAC1B,IAAI,UAAU,CAAC,SAAS,EAAE,EAAE;QACxB,OAAO,IAAI,iCAAS,CAAC;YACjB,eAAe,EAAE,QAAQ,CAAC,SAAS;YACnC,UAAU;YACV,KAAK,EAAE,EAAE,QAAQ,EAAE,6BAAQ,CAAC,MAAM,EAAE,KAAK,EAAE;SAC9C,CAAC,CAAC;KACN;IACD,OAAO,IAAI,iCAAS,CAAC,EAAE,eAAe,EAAE,QAAQ,CAAC,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,6BAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;AAClH,CAAC;AACD,0FAA0F;AAC1F,SAAgB,kBAAkB,CAC9B,IAAgB,EAChB,kBAA0B,EAC1B,SAAe,EACf,OAAa,EACb,QAA+D;IAE/D,IAAA,yBAAgB,EAAC,IAAI,EAAE,kBAAkB,EAAE,SAAS,EAAE,OAAO,EAAE,oBAAoB,EAAE,QAAQ,CAAC,CAAC;AACnG,CAAC;AARD,gDAQC"}

package/dist/duration_good.d.ts

@@ -0,0 +1,4 @@
+import { UAVariable } from "node-opcua-address-space";
+import { DataValue } from "node-opcua-data-value";
+/**Retrieve the percentage of data (0 to 100) in the interval which has Bad StatusCode. */
+export declare function getDurationGoodData(node: UAVariable, processingInterval: number, startDate: Date, endDate: Date, callback: (err: Error | null, dataValues?: DataValue[]) => void): void;

package/dist/duration_good.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDurationGoodData = void 0;
+const node_opcua_data_value_1 = require("node-opcua-data-value");
+const node_opcua_variant_1 = require("node-opcua-variant");
+const node_opcua_status_code_1 = require("node-opcua-status-code");
+const common_1 = require("./common");
+const calculate_bad_good_1 = require("./calculate_bad_good");
+function calculateDurationGood(interval, options) {
+    const { durationGood, durationUnknown, statusCode } = (0, calculate_bad_good_1.calculateBadAndGood)(interval, options);
+    if (durationUnknown > 0 && durationGood === 0) {
+        return new node_opcua_data_value_1.DataValue({
+            sourceTimestamp: interval.startTime,
+            statusCode: node_opcua_status_code_1.StatusCodes.Bad
+        });
+    }
+    const value = durationGood;
+    if (statusCode.isGoodish()) {
+        return new node_opcua_data_value_1.DataValue({
+            sourceTimestamp: interval.startTime,
+            statusCode,
+            value: { dataType: node_opcua_variant_1.DataType.Double, value }
+        });
+    }
+    return new node_opcua_data_value_1.DataValue({ sourceTimestamp: interval.startTime, statusCode, value: { dataType: node_opcua_variant_1.DataType.Null } });
+}
+/**Retrieve the percentage of data (0 to 100) in the interval which has Bad StatusCode. */
+function getDurationGoodData(node, processingInterval, startDate, endDate, callback) {
+    (0, common_1.getAggregateData)(node, processingInterval, startDate, endDate, calculateDurationGood, callback);
+}
+exports.getDurationGoodData = getDurationGoodData;
+//# sourceMappingURL=duration_good.js.map

package/dist/duration_good.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration_good.js","sourceRoot":"","sources":["../source/duration_good.ts"],"names":[],"mappings":";;;AACA,iEAAkD;AAClD,2DAA8C;AAC9C,mEAAqD;AAErD,qCAA4C;AAE5C,6DAA2D;AAE3D,SAAS,qBAAqB,CAAC,QAAkB,EAAE,OAAsC;IACrF,MAAM,EAAE,YAAY,EAAE,eAAe,EAAE,UAAU,EAAE,GAAG,IAAA,wCAAmB,EAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC7F,IAAI,eAAe,GAAC,CAAC,IAAK,YAAY,KAAI,CAAC,EAAE;QACzC,OAAO,IAAI,iCAAS,CAAC;YACjB,eAAe,EAAE,QAAQ,CAAC,SAAS;YACnC,UAAU,EAAE,oCAAW,CAAC,GAAG;SAC9B,CAAC,CAAC;KACN;IACD,MAAM,KAAK,GAAG,YAAY,CAAC;IAC3B,IAAI,UAAU,CAAC,SAAS,EAAE,EAAE;QACxB,OAAO,IAAI,iCAAS,CAAC;YACjB,eAAe,EAAE,QAAQ,CAAC,SAAS;YACnC,UAAU;YACV,KAAK,EAAE,EAAE,QAAQ,EAAE,6BAAQ,CAAC,MAAM,EAAE,KAAK,EAAE;SAC9C,CAAC,CAAC;KACN;IACD,OAAO,IAAI,iCAAS,CAAC,EAAE,eAAe,EAAE,QAAQ,CAAC,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,6BAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;AAClH,CAAC;AACD,0FAA0F;AAC1F,SAAgB,mBAAmB,CAC/B,IAAgB,EAChB,kBAA0B,EAC1B,SAAe,EACf,OAAa,EACb,QAA+D;IAE/D,IAAA,yBAAgB,EAAC,IAAI,EAAE,kBAAkB,EAAE,SAAS,EAAE,OAAO,EAAE,qBAAqB,EAAE,QAAQ,CAAC,CAAC;AACpG,CAAC;AARD,kDAQC"}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @module node-opca-aggregates
+ */
+export { addAggregateSupport, installAggregateConfigurationOptions, getAggregateConfiguration, addAggregateStandardFunctionSupport, addAggregateFunctionSupport } 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";

package/dist/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateFunction = exports.addAggregateFunctionSupport = exports.addAggregateStandardFunctionSupport = exports.getAggregateConfiguration = exports.installAggregateConfigurationOptions = exports.addAggregateSupport = void 0;
+/**
+ * @module node-opca-aggregates
+ */
+var aggregates_1 = require("./aggregates");
+Object.defineProperty(exports, "addAggregateSupport", { enumerable: true, get: function () { return aggregates_1.addAggregateSupport; } });
+Object.defineProperty(exports, "installAggregateConfigurationOptions", { enumerable: true, get: function () { return aggregates_1.installAggregateConfigurationOptions; } });
+Object.defineProperty(exports, "getAggregateConfiguration", { enumerable: true, get: function () { return aggregates_1.getAggregateConfiguration; } });
+Object.defineProperty(exports, "addAggregateStandardFunctionSupport", { enumerable: true, get: function () { return aggregates_1.addAggregateStandardFunctionSupport; } });
+Object.defineProperty(exports, "addAggregateFunctionSupport", { enumerable: true, get: function () { return aggregates_1.addAggregateFunctionSupport; } });
+__exportStar(require("./interpolate"), exports);
+__exportStar(require("./minmax"), exports);
+__exportStar(require("./interval"), exports);
+__exportStar(require("./common"), exports);
+__exportStar(require("./average"), exports);
+__exportStar(require("./read_processed_details"), exports);
+var node_opcua_constants_1 = require("node-opcua-constants");
+Object.defineProperty(exports, "AggregateFunction", { enumerable: true, get: function () { return node_opcua_constants_1.AggregateFunction; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA;;GAEG;AACH,2CAMsB;AALlB,iHAAA,mBAAmB,OAAA;AACnB,kIAAA,oCAAoC,OAAA;AACpC,uHAAA,yBAAyB,OAAA;AACzB,iIAAA,mCAAmC,OAAA;AACnC,yHAAA,2BAA2B,OAAA;AAE/B,gDAA8B;AAC9B,2CAAyB;AACzB,6CAA2B;AAC3B,2CAAyB;AACzB,4CAA0B;AAC1B,2DAAyC;AACzC,6DAAyD;AAAhD,yHAAA,iBAAiB,OAAA"}

package/dist/interpolate.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @module node-opcua-aggregates
+ */
+import { UAVariable } from "node-opcua-address-space";
+import { DataValue } from "node-opcua-data-value";
+import { AggregateConfigurationOptionsEx, Interval } from "./interval";
+export declare function interpolatedValue(interval: Interval, options: AggregateConfigurationOptionsEx): DataValue;
+/**
+ *
+ * @param node
+ * @param processingInterval
+ * @param startDate
+ * @param endDate
+ * @param callback
+ */
+export declare function getInterpolatedData(node: UAVariable, processingInterval: number, startDate: Date, endDate: Date, callback: (err: Error | null, dataValues?: DataValue[]) => void): void;

package/dist/interpolate.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInterpolatedData = exports.interpolatedValue = void 0;
+const node_opcua_assert_1 = require("node-opcua-assert");
+const node_opcua_data_value_1 = require("node-opcua-data-value");
+const node_opcua_status_code_1 = require("node-opcua-status-code");
+const common_1 = require("./common");
+const interval_1 = require("./interval");
+/*
+ For any intervals containing regions where the StatusCodes are Bad,
+ the total duration of all Bad regions is calculated and divided by the width of the interval.
+ The resulting ratio is multiplied by 100 and compared to the PercentDataBad parameter.
+ The StatusCode for the interval is Bad if the ratio is greater than or equal to the PercentDataBad parameter.
+ For any interval which is not Bad, the total duration of all Good regions is then calculated and divided by
+ the width of the interval. The resulting ratio is multiplied by 100 and compared to the PercentDataGood parameter.
+ The StatusCode for the interval is Good if the ratio is greater than or equal to the PercentDataGood parameter.
+ If for an interval neither ratio applies then that interval is Uncertain_DataSubNormal.
+  */
+function interpolatedValue(interval, options) {
+    options = (0, interval_1.adjustProcessingOptions)(options);
+    (0, node_opcua_assert_1.assert)(Object.prototype.hasOwnProperty.call(options, "useSlopedExtrapolation"));
+    (0, node_opcua_assert_1.assert)(Object.prototype.hasOwnProperty.call(options, "treatUncertainAsBad"));
+    const bTreatUncertainAsBad = options.treatUncertainAsBad;
+    const steppedValue = (previousDataValue) => {
+        if (!previousDataValue.statusCode) {
+            throw new Error("Expecting statusCode");
+        }
+        const interpValue = new node_opcua_data_value_1.DataValue({
+            sourceTimestamp: interval.startTime,
+            statusCode: node_opcua_status_code_1.StatusCodes.Bad,
+            value: previousDataValue.value
+        });
+        interpValue.statusCode = node_opcua_status_code_1.StatusCode.makeStatusCode(node_opcua_status_code_1.StatusCodes.UncertainDataSubNormal, "HistorianInterpolated");
+        return interpValue;
+    };
+    if (interval.index === -1) {
+        // the interval is beyond end Data
+        // we need to find previous good value
+        // and second previous  good value to extrapolate
+        const prev1 = (0, interval_1._findGoodDataValueBefore)(interval.dataValues, interval.dataValues.length, bTreatUncertainAsBad);
+        if (prev1.index <= 0) {
+            return new node_opcua_data_value_1.DataValue({
+                sourceTimestamp: interval.startTime,
+                statusCode: node_opcua_status_code_1.StatusCodes.BadNoData,
+                value: undefined
+            });
+        }
+        if (!options.useSlopedExtrapolation) {
+            return steppedValue(prev1.dataValue);
+        }
+        const prev2 = (0, interval_1._findGoodDataValueBefore)(interval.dataValues, prev1.index, bTreatUncertainAsBad);
+        if (prev2.index <= 0) {
+            // use step value
+            return steppedValue(prev1.dataValue);
+        }
+        // else interpolate
+        const interpVal = (0, common_1.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;
+            const extraBits = interpVal.statusCode.value & mask;
+            interpVal.statusCode = node_opcua_status_code_1.StatusCode.makeStatusCode(node_opcua_status_code_1.StatusCodes.UncertainDataSubNormal, extraBits);
+        }
+        return interpVal;
+    }
+    /* istanbul ignore next */
+    if (interval.index < 0 && interval.count === 0) {
+        return new node_opcua_data_value_1.DataValue({
+            sourceTimestamp: interval.startTime,
+            statusCode: node_opcua_status_code_1.StatusCodes.BadNoData
+        });
+    }
+    const dataValue1 = interval.dataValues[interval.index];
+    // if a non-Bad Raw value exists at the timestamp then it is the bounding value;
+    if (!dataValue1.statusCode.isBad() && interval.hasRawDataAsStart()) {
+        return dataValue1;
+    }
+    // find the first non-Bad Raw value before the timestamp;
+    // find previous good value
+    const before = interval.beforeStartDataValue(bTreatUncertainAsBad);
+    if (before.dataValue.statusCode.isBad()) {
+        return new node_opcua_data_value_1.DataValue({
+            sourceTimestamp: interval.startTime,
+            statusCode: node_opcua_status_code_1.StatusCodes.BadNoData
+        });
+    }
+    if (options.stepped) {
+        if (before.index + 1 === interval.index) {
+            return new node_opcua_data_value_1.DataValue({
+                sourceTimestamp: interval.startTime,
+                statusCode: node_opcua_status_code_1.StatusCode.makeStatusCode(before.dataValue.statusCode, "HistorianInterpolated"),
+                value: before.dataValue.value
+            });
+        }
+        return steppedValue(before.dataValue);
+    }
+    // find the first non-Bad Raw value after the timestamp;
+    const next = interval.nextStartDataValue(bTreatUncertainAsBad);
+    //  draw a line between before value and after value;
+    // use point where the line crosses the timestamp as an estimate of the bounding value.
+    //   The calculation can be expressed with the following formula:
+    //    V bound = (T bound – T before)x( V after – V before)/( T after – T before) + V before
+    //    where V
+    //   x is a value at ‘x’ and Tx is the timestamp associated with Vx.
+    const interpolatedDataValue = (0, common_1.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;
+        interpolatedDataValue.statusCode = node_opcua_status_code_1.StatusCode.makeStatusCode(node_opcua_status_code_1.StatusCodes.UncertainDataSubNormal, extraBits);
+    }
+    // check if uncertain or bad value exist between before/next
+    // todo
+    return interpolatedDataValue;
+}
+exports.interpolatedValue = interpolatedValue;
+/**
+ *
+ * @param node
+ * @param processingInterval
+ * @param startDate
+ * @param endDate
+ * @param callback
+ */
+function getInterpolatedData(node, processingInterval, startDate, endDate, callback) {
+    (0, common_1.getAggregateData)(node, processingInterval, startDate, endDate, interpolatedValue, callback);
+}
+exports.getInterpolatedData = getInterpolatedData;
+//# sourceMappingURL=interpolate.js.map

package/dist/interpolate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpolate.js","sourceRoot":"","sources":["../source/interpolate.ts"],"names":[],"mappings":"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"}

package/dist/interval.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @module node-opca-aggregates
+ */
+import { DataValue } from "node-opcua-data-value";
+import { StatusCode } from "node-opcua-status-code";
+import { AggregateConfigurationOptions } from "node-opcua-types";
+export { AggregateConfigurationOptions } from "node-opcua-types";
+export interface AggregateConfigurationOptionsEx extends AggregateConfigurationOptions {
+    stepped?: boolean;
+}
+export declare function isGoodish2(statusCode: StatusCode, { treatUncertainAsBad }: {
+    treatUncertainAsBad?: boolean;
+}): boolean;
+export declare function isUncertain(statusCode: StatusCode): boolean;
+export interface IntervalOptions {
+    startTime: Date;
+    dataValues: DataValue[];
+    index: number;
+    count: number;
+    isPartial: boolean;
+    processingInterval: number;
+}
+interface DataValueWithIndex {
+    index: number;
+    dataValue: DataValue;
+}
+export declare function _findGoodDataValueBefore(dataValues: DataValue[], index: number, bTreatUncertainAsBad: boolean): DataValueWithIndex;
+export declare function _findGoodDataValueAfter(dataValues: DataValue[], index: number, bTreatUncertainAsBad: boolean): DataValueWithIndex;
+export declare function adjustProcessingOptions(options: AggregateConfigurationOptionsEx | null): AggregateConfigurationOptionsEx;
+export declare class Interval {
+    startTime: Date;
+    dataValues: DataValue[];
+    index: number;
+    count: number;
+    isPartial: boolean;
+    processingInterval: number;
+    constructor(options: IntervalOptions);
+    getPercentBad(): number;
+    /**
+     * returns true if a raw data exists at start
+     */
+    hasRawDataAsStart(): boolean;
+    /**
+     * Find the first good or uncertain dataValue
+     * just preceding this interval
+     * @returns {*}
+     */
+    beforeStartDataValue(bTreatUncertainAsBad: boolean): DataValueWithIndex;
+    nextStartDataValue(bTreatUncertainAsBad: boolean): DataValueWithIndex;
+    toString(): string;
+    getEffectiveEndTime(): number;
+    /**
+     *
+     * @returns the interval duration
+     */
+    duration(): number;
+    /**
+     * returns the region duration starting at index and finishing at index+1 or end limit of the interval
+     */
+    regionDuration(index: number): number;
+}
+export declare function getInterval(startTime: Date, processingInterval: number, indexHint: number, dataValues: DataValue[]): Interval;

package/dist/interval.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInterval = exports.Interval = exports.adjustProcessingOptions = exports._findGoodDataValueAfter = exports._findGoodDataValueBefore = exports.isUncertain = exports.isGoodish2 = void 0;
+/**
+ * @module node-opca-aggregates
+ */
+const node_opcua_data_value_1 = require("node-opcua-data-value");
+const node_opcua_status_code_1 = require("node-opcua-status-code");
+function isGoodish2(statusCode, { treatUncertainAsBad }) {
+    if (statusCode.isGoodish())
+        return true;
+    if (isUncertain(statusCode))
+        return !treatUncertainAsBad;
+    return false;
+}
+exports.isGoodish2 = isGoodish2;
+function isUncertain(statusCode) {
+    return (statusCode.value & 0x40000000) === 0x40000000 && statusCode.value !== node_opcua_status_code_1.StatusCodes.BadNoData.value;
+}
+exports.isUncertain = isUncertain;
+function _findGoodDataValueBefore(dataValues, index, bTreatUncertainAsBad) {
+    index--;
+    while (index >= 0) {
+        const dataValue1 = dataValues[index];
+        if (!bTreatUncertainAsBad && !dataValue1.statusCode.isBad()) {
+            return { index, dataValue: dataValue1 };
+        }
+        if (bTreatUncertainAsBad && dataValue1.statusCode.isGood()) {
+            return { index, dataValue: dataValue1 };
+        }
+        index -= 1;
+    }
+    // not found
+    return {
+        dataValue: new node_opcua_data_value_1.DataValue({ statusCode: node_opcua_status_code_1.StatusCodes.BadNoData }),
+        index: -1
+    };
+}
+exports._findGoodDataValueBefore = _findGoodDataValueBefore;
+function _findGoodDataValueAfter(dataValues, index, bTreatUncertainAsBad) {
+    while (index < dataValues.length) {
+        const dataValue1 = dataValues[index];
+        if (!bTreatUncertainAsBad && !dataValue1.statusCode.isBad()) {
+            return {
+                dataValue: dataValue1,
+                index
+            };
+        }
+        if (bTreatUncertainAsBad && dataValue1.statusCode.isGood()) {
+            return {
+                dataValue: dataValue1,
+                index
+            };
+        }
+        index += 1;
+    }
+    // not found
+    return {
+        dataValue: new node_opcua_data_value_1.DataValue({ statusCode: node_opcua_status_code_1.StatusCodes.BadNoData }),
+        index: -1
+    };
+}
+exports._findGoodDataValueAfter = _findGoodDataValueAfter;
+function adjustProcessingOptions(options) {
+    options = options || {};
+    options.treatUncertainAsBad = options.treatUncertainAsBad || false;
+    options.useSlopedExtrapolation = options.useSlopedExtrapolation || false;
+    options.stepped = options.stepped || false;
+    options.percentDataBad = parseInt(options.percentDataBad, 10);
+    options.percentDataGood = parseInt(options.percentDataGood, 10);
+    return options;
+}
+exports.adjustProcessingOptions = adjustProcessingOptions;
+class Interval {
+    // startTime
+    // dataValues
+    // index:       index of first dataValue inside the interval
+    // count:       number of dataValue inside the interval
+    constructor(options) {
+        this.startTime = options.startTime;
+        this.dataValues = options.dataValues;
+        this.index = options.index;
+        this.count = options.count;
+        this.isPartial = options.isPartial;
+        this.processingInterval = options.processingInterval;
+    }
+    getPercentBad() {
+        return 100;
+    }
+    /**
+     * returns true if a raw data exists at start
+     */
+    hasRawDataAsStart() {
+        const index = this.index;
+        if (index < 0) {
+            return false;
+        }
+        const dataValue1 = this.dataValues[index];
+        return this.startTime.getTime() === dataValue1.sourceTimestamp.getTime();
+    }
+    /**
+     * Find the first good or uncertain dataValue
+     * just preceding this interval
+     * @returns {*}
+     */
+    beforeStartDataValue(bTreatUncertainAsBad) {
+        return _findGoodDataValueBefore(this.dataValues, this.index, bTreatUncertainAsBad);
+    }
+    nextStartDataValue(bTreatUncertainAsBad) {
+        return _findGoodDataValueAfter(this.dataValues, this.index, bTreatUncertainAsBad);
+    }
+    toString() {
+        let str = "";
+        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.value ? dataValue.value.toString() : "";
+                str += "\n";
+            }
+        }
+        return str;
+    }
+    getEffectiveEndTime() {
+        const e = this.startTime.getTime() + this.processingInterval;
+        if (!this.dataValues || this.dataValues.length === 0) {
+            return e;
+        }
+        let i = this.dataValues.length - 1;
+        while (i >= 0 && this.dataValues[i].statusCode.equals(node_opcua_status_code_1.StatusCodes.BadNoData)) {
+            i--;
+        }
+        if (i < 0) {
+            return e;
+        }
+        const lastTimestamp = this.dataValues[i].sourceTimestamp;
+        return Math.min(e, lastTimestamp.getTime() + 1);
+    }
+    /**
+     *
+     * @returns the interval duration
+     */
+    duration() {
+        const t1 = this.dataValues[this.index].sourceTimestamp.getTime();
+        const e = this.getEffectiveEndTime();
+        return e - t1;
+    }
+    /**
+     * returns the region duration starting at index and finishing at index+1 or end limit of the interval
+     */
+    regionDuration(index) {
+        const t1 = this.dataValues[index].sourceTimestamp.getTime();
+        const e = this.getEffectiveEndTime();
+        const t2 = index < this.dataValues.length - 1 ? Math.min(this.dataValues[index + 1].sourceTimestamp.getTime(), e) : e;
+        return t2 - t1;
+    }
+}
+exports.Interval = Interval;
+function getInterval(startTime, processingInterval, indexHint, dataValues) {
+    let count = 0;
+    let index = -1;
+    for (let i = indexHint; i < dataValues.length; i++) {
+        if (dataValues[i].sourceTimestamp.getTime() < startTime.getTime()) {
+            continue;
+        }
+        index = i;
+        break;
+    }
+    if (index >= 0) {
+        for (let i = index; i < dataValues.length; i++) {
+            if (dataValues[i].sourceTimestamp.getTime() >= startTime.getTime() + processingInterval) {
+                break;
+            }
+            count++;
+        }
+    }
+    // check if interval is complete or partial (end or start)
+    let isPartial = false;
+    if (index + count >= dataValues.length &&
+        dataValues[dataValues.length - 1].sourceTimestamp.getTime() < startTime.getTime() + processingInterval) {
+        isPartial = true;
+    }
+    if (index <= 0 && dataValues[0].sourceTimestamp.getTime() > startTime.getTime()) {
+        isPartial = true;
+    }
+    return new Interval({
+        count,
+        dataValues,
+        index,
+        isPartial,
+        startTime,
+        processingInterval
+    });
+}
+exports.getInterval = getInterval;
+//# sourceMappingURL=interval.js.map