node-opcua-aggregates 2.71.0 → 2.72.2

package/dist/common.js

@@ -1,100 +1,100 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.interpolateValue = exports.getAggregateData = void 0;
-/**
- * @module node-opca-aggregates
- */
-const node_opcua_address_space_1 = require("node-opcua-address-space");
-const node_opcua_data_model_1 = require("node-opcua-data-model");
-const node_opcua_data_value_1 = require("node-opcua-data-value");
-const node_opcua_service_history_1 = require("node-opcua-service-history");
-const node_opcua_status_code_1 = require("node-opcua-status-code");
-const node_opcua_nodeid_1 = require("node-opcua-nodeid");
-const aggregates_1 = require("./aggregates");
-const interval_1 = require("./interval");
-/**
- * @internal
- * @param node
- * @param processingInterval
- * @param startDate
- * @param endDate
- * @param dataValues
- * @param lambda
- * @param callback
- */
-function processAggregateData(node, processingInterval, startDate, endDate, dataValues, lambda, callback) {
-    const aggregateConfiguration = (0, aggregates_1.getAggregateConfiguration)(node);
-    const results = [];
-    const tstart = startDate.getTime();
-    const tend = endDate.getTime();
-    const indexHint = 0;
-    for (let t = tstart; t < tend; t += processingInterval) {
-        const sourceTimestamp = new Date();
-        sourceTimestamp.setTime(t);
-        const interval = (0, interval_1.getInterval)(sourceTimestamp, processingInterval, indexHint, dataValues);
-        const dataValue = lambda(interval, aggregateConfiguration);
-        /* istanbul ignore next */
-        if (!dataValue || !dataValue.sourceTimestamp) {
-            // const dataValue = interval.interpolatedValue(aggregateConfiguration);
-            throw Error("invalid DataValue");
-        }
-        results.push(dataValue);
-    }
-    setImmediate(() => {
-        callback(null, results);
-    });
-}
-function getAggregateData(node, processingInterval, startDate, endDate, lambda, callback) {
-    /* istanbul ignore next */
-    if (node.nodeClass !== node_opcua_data_model_1.NodeClass.Variable) {
-        throw new Error("node must be UAVariable");
-    }
-    /* istanbul ignore next */
-    if (processingInterval <= 0) {
-        throw new Error("Invalid processing interval, shall be greater than 0");
-    }
-    const continuationPointManager = new node_opcua_address_space_1.ContinuationPointManager();
-    const context = new node_opcua_address_space_1.SessionContext({
-        session: {
-            continuationPointManager,
-            getSessionId: () => (0, node_opcua_nodeid_1.coerceNodeId)("i=0")
-        }
-    });
-    const historyReadDetails = new node_opcua_service_history_1.ReadRawModifiedDetails({
-        endTime: endDate,
-        startTime: startDate,
-        isReadModified: false,
-        numValuesPerNode: 0
-        // returnBounds: true,
-    });
-    const indexRange = null;
-    const dataEncoding = null;
-    const continuationPoint = null;
-    node.historyRead(context, historyReadDetails, indexRange, dataEncoding, { continuationPoint }, (err, result) => {
-        /* istanbul ignore next */
-        if (err) {
-            return callback(err);
-        }
-        const historyData = result.historyData;
-        const dataValues = historyData.dataValues || [];
-        processAggregateData(node, processingInterval, startDate, endDate, dataValues, lambda, callback);
-    });
-}
-exports.getAggregateData = getAggregateData;
-function interpolateValue(dataValue1, dataValue2, date) {
-    const t0 = dataValue1.sourceTimestamp.getTime();
-    const t = date.getTime();
-    const t1 = dataValue2.sourceTimestamp.getTime();
-    const coef1 = (t - t0) / (t1 - t0);
-    const coef2 = (t1 - t) / (t1 - t0);
-    const value = dataValue1.value.clone();
-    value.value = coef2 * dataValue1.value.value + coef1 * dataValue2.value.value;
-    const statusCode = node_opcua_status_code_1.StatusCode.makeStatusCode(dataValue1.statusCode, "HistorianInterpolated");
-    return new node_opcua_data_value_1.DataValue({
-        sourceTimestamp: date,
-        statusCode,
-        value
-    });
-}
-exports.interpolateValue = interpolateValue;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpolateValue = exports.getAggregateData = void 0;
+/**
+ * @module node-opca-aggregates
+ */
+const node_opcua_address_space_1 = require("node-opcua-address-space");
+const node_opcua_data_model_1 = require("node-opcua-data-model");
+const node_opcua_data_value_1 = require("node-opcua-data-value");
+const node_opcua_service_history_1 = require("node-opcua-service-history");
+const node_opcua_status_code_1 = require("node-opcua-status-code");
+const node_opcua_nodeid_1 = require("node-opcua-nodeid");
+const aggregates_1 = require("./aggregates");
+const interval_1 = require("./interval");
+/**
+ * @internal
+ * @param node
+ * @param processingInterval
+ * @param startDate
+ * @param endDate
+ * @param dataValues
+ * @param lambda
+ * @param callback
+ */
+function processAggregateData(node, processingInterval, startDate, endDate, dataValues, lambda, callback) {
+    const aggregateConfiguration = (0, aggregates_1.getAggregateConfiguration)(node);
+    const results = [];
+    const tstart = startDate.getTime();
+    const tend = endDate.getTime();
+    const indexHint = 0;
+    for (let t = tstart; t < tend; t += processingInterval) {
+        const sourceTimestamp = new Date();
+        sourceTimestamp.setTime(t);
+        const interval = (0, interval_1.getInterval)(sourceTimestamp, processingInterval, indexHint, dataValues);
+        const dataValue = lambda(interval, aggregateConfiguration);
+        /* istanbul ignore next */
+        if (!dataValue || !dataValue.sourceTimestamp) {
+            // const dataValue = interval.interpolatedValue(aggregateConfiguration);
+            throw Error("invalid DataValue");
+        }
+        results.push(dataValue);
+    }
+    setImmediate(() => {
+        callback(null, results);
+    });
+}
+function getAggregateData(node, processingInterval, startDate, endDate, lambda, callback) {
+    /* istanbul ignore next */
+    if (node.nodeClass !== node_opcua_data_model_1.NodeClass.Variable) {
+        throw new Error("node must be UAVariable");
+    }
+    /* istanbul ignore next */
+    if (processingInterval <= 0) {
+        throw new Error("Invalid processing interval, shall be greater than 0");
+    }
+    const continuationPointManager = new node_opcua_address_space_1.ContinuationPointManager();
+    const context = new node_opcua_address_space_1.SessionContext({
+        session: {
+            continuationPointManager,
+            getSessionId: () => (0, node_opcua_nodeid_1.coerceNodeId)("i=0")
+        }
+    });
+    const historyReadDetails = new node_opcua_service_history_1.ReadRawModifiedDetails({
+        endTime: endDate,
+        startTime: startDate,
+        isReadModified: false,
+        numValuesPerNode: 0
+        // returnBounds: true,
+    });
+    const indexRange = null;
+    const dataEncoding = null;
+    const continuationPoint = null;
+    node.historyRead(context, historyReadDetails, indexRange, dataEncoding, { continuationPoint }, (err, result) => {
+        /* istanbul ignore next */
+        if (err) {
+            return callback(err);
+        }
+        const historyData = result.historyData;
+        const dataValues = historyData.dataValues || [];
+        processAggregateData(node, processingInterval, startDate, endDate, dataValues, lambda, callback);
+    });
+}
+exports.getAggregateData = getAggregateData;
+function interpolateValue(dataValue1, dataValue2, date) {
+    const t0 = dataValue1.sourceTimestamp.getTime();
+    const t = date.getTime();
+    const t1 = dataValue2.sourceTimestamp.getTime();
+    const coef1 = (t - t0) / (t1 - t0);
+    const coef2 = (t1 - t) / (t1 - t0);
+    const value = dataValue1.value.clone();
+    value.value = coef2 * dataValue1.value.value + coef1 * dataValue2.value.value;
+    const statusCode = node_opcua_status_code_1.StatusCode.makeStatusCode(dataValue1.statusCode, "HistorianInterpolated");
+    return new node_opcua_data_value_1.DataValue({
+        sourceTimestamp: date,
+        statusCode,
+        value
+    });
+}
+exports.interpolateValue = interpolateValue;
 //# sourceMappingURL=common.js.map

package/dist/index.d.ts

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

@@ -1,33 +1,33 @@
-"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.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; } });
-__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; } });
+"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.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; } });
+__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/interpolate.d.ts

@@ -1,16 +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;
+/**
+ * @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

@@ -1,131 +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 (!(0, interval_1.isBad)(dataValue1.statusCode) && interval.hasRawDataAsStart()) {
-        return dataValue1;
-    }
-    // find the first non-Bad Raw value before the timestamp;
-    // find previous good value
-    const before = interval.beforeStartDataValue(bTreatUncertainAsBad);
-    if ((0, interval_1.isBad)(before.dataValue.statusCode)) {
-        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 || !(0, interval_1.isGood)(next.dataValue.statusCode) || !(0, interval_1.isGood)(before.dataValue.statusCode)) {
-        // 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;
+"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 (!(0, interval_1.isBad)(dataValue1.statusCode) && interval.hasRawDataAsStart()) {
+        return dataValue1;
+    }
+    // find the first non-Bad Raw value before the timestamp;
+    // find previous good value
+    const before = interval.beforeStartDataValue(bTreatUncertainAsBad);
+    if ((0, interval_1.isBad)(before.dataValue.statusCode)) {
+        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 || !(0, interval_1.isGood)(next.dataValue.statusCode) || !(0, interval_1.isGood)(before.dataValue.statusCode)) {
+        // 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