node-opcua-service-subscription 2.55.0 → 2.59.0

package/.mocharc.yml

@@ -1,9 +1,9 @@
-require:
- - ../../node_modules/source-map-support/register
- - ../../node_modules/ts-node/register
- - ../../node_modules/should
-
-recursive: true
-extension:
- - ts 
- - js
+require:
+ - ../../node_modules/source-map-support/register
+ - ../../node_modules/ts-node/register
+ - ../../node_modules/should
+
+recursive: true
+extension:
+ - ts 
+ - js

package/LICENSE

@@ -1,20 +1,20 @@
-The MIT License (MIT)
-
-Copyright (c) 2014-2021 Etienne Rossignon
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+The MIT License (MIT)
+
+Copyright (c) 2014-2021 Etienne Rossignon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-service-subscription",
-    "version": "2.55.0",
+    "version": "2.59.0",
     "description": "pure nodejs OPCUA SDK - module -service-subscription",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
@@ -12,28 +12,28 @@
     },
     "dependencies": {
         "node-opcua-assert": "2.55.0",
-        "node-opcua-basic-types": "2.55.0",
+        "node-opcua-basic-types": "2.57.0",
         "node-opcua-binary-stream": "2.55.0",
-        "node-opcua-data-value": "2.55.0",
-        "node-opcua-extension-object": "2.55.0",
-        "node-opcua-factory": "2.55.0",
+        "node-opcua-data-value": "2.59.0",
+        "node-opcua-extension-object": "2.57.0",
+        "node-opcua-factory": "2.57.0",
         "node-opcua-nodeid": "2.55.0",
-        "node-opcua-service-filter": "2.55.0",
-        "node-opcua-service-read": "2.55.0",
-        "node-opcua-service-secure-channel": "2.55.0",
-        "node-opcua-types": "2.55.0",
-        "node-opcua-variant": "2.55.0"
+        "node-opcua-service-filter": "2.59.0",
+        "node-opcua-service-read": "2.59.0",
+        "node-opcua-service-secure-channel": "2.59.0",
+        "node-opcua-types": "2.59.0",
+        "node-opcua-variant": "2.59.0"
     },
     "devDependencies": {
         "node-opcua-buffer-utils": "2.55.0",
-        "node-opcua-data-model": "2.55.0",
+        "node-opcua-data-model": "2.57.0",
         "node-opcua-debug": "2.55.0",
-        "node-opcua-numeric-range": "2.55.0",
-        "node-opcua-packet-analyzer": "2.55.0",
-        "node-opcua-secure-channel": "2.55.0",
-        "node-opcua-service-history": "2.55.0",
-        "node-opcua-service-translate-browse-path": "2.55.0",
-        "node-opcua-status-code": "2.55.0",
+        "node-opcua-numeric-range": "2.57.0",
+        "node-opcua-packet-analyzer": "2.57.0",
+        "node-opcua-secure-channel": "2.59.0",
+        "node-opcua-service-history": "2.59.0",
+        "node-opcua-service-translate-browse-path": "2.59.0",
+        "node-opcua-status-code": "2.56.0",
         "node-opcua-variant": "2.49.0",
         "should": "^13.2.3"
     },
@@ -52,5 +52,5 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "28fdbfe1c5306fd0e69758ccacfa2c6d1722115c"
+    "gitHead": "ea10265745d3d4b8af249a4e13288ad71232706f"
 }

package/source/deadband_checker.ts

@@ -1,163 +1,163 @@
-/**
- * @module node-opcua-service-subscription
- */
-import { assert } from "node-opcua-assert";
-
-import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
-
-export enum DeadbandType {
-    None = 0x00,
-    Absolute = 0x01,
-    Percent = 0x02,
-    Invalid = 0x1000
-}
-
-export type NumberType = number | number[];
-
-export interface PseudoRange {
-    low: number;
-    high: number;
-}
-
-/**
- * @returns true if the difference between value1 and value2 is greater than absoluteDeadband
- */
-function _isOutsideDeadbandScalar(value1: NumberType, value2: NumberType, dataType: DataType, absoluteDeadband: number): boolean {
-    let diff;
-    if (dataType === DataType.UInt64 || dataType === DataType.Int64) {
-        // istanbul ignore next
-        if (!(value1 instanceof Array && value2 instanceof Array)) {
-            throw new Error("Invalid");
-        }
-        const h1 = value1[0]; // high
-        const h2 = value2[0];
-        if (h1 !== h2) {
-            diff = (h1 - h2) * 4294967295;
-            if (Math.abs(diff) > absoluteDeadband) {
-                return true;
-            }
-        }
-        diff = value1[1] - value2[1];
-        assert(typeof diff === "number" && isFinite(diff));
-        return Math.abs(diff) > absoluteDeadband;
-    }
-    // istanbul ignore next
-    if (!(typeof value1 === "number" && typeof value2 === "number")) {
-        throw new Error(
-            "Invalid value in _isOutsideDeadbandScalar > expecting number only but got " + typeof value1 + " " + typeof value2
-        );
-    }
-    diff = value2 - value1;
-    assert(typeof diff === "number" && isFinite(diff));
-    return Math.abs(diff) > absoluteDeadband;
-}
-function isOutsideDeadbandVariant(v1: Variant, v2: Variant, absoluteDeadBand: number): boolean {
-    assert(isFinite(absoluteDeadBand));
-
-    if (v1.arrayType === VariantArrayType.Array) {
-        if (v1.dataType !== v2.dataType) {
-            return true;
-        }
-        if (v1.value.length !== v2.value.length) {
-            return true;
-        }
-
-        const n = v1.value.length;
-        let i = 0;
-        for (i = 0; i < n; i++) {
-            if (_isOutsideDeadbandScalar(v1.value[i], v2.value[i], v1.dataType, absoluteDeadBand)) {
-                return true;
-            }
-        }
-        return false;
-    } else {
-        assert(v1.arrayType === VariantArrayType.Scalar);
-        if(v1.dataType !== v2.dataType) {
-            return true;
-        }
-        return _isOutsideDeadbandScalar(v1.value, v2.value, v1.dataType, absoluteDeadBand);
-    }
-}
-function isOnEdgeOfRangeScalar(currentValue: NumberType, newValue: NumberType, dataType: DataType, range: PseudoRange): boolean {
-    if (dataType === DataType.UInt64 || dataType === DataType.Int64) {
-        // istanbul ignore next
-        if (!(currentValue instanceof Array && newValue instanceof Array)) {
-            throw new Error("Invalid");
-        }
-        currentValue = currentValue[1];
-        newValue = newValue[1];
-    }
-    if (/*currentValue !== range.low && */ newValue <= range.low) {
-        return true;
-    }
-    if (/*currentValue !== range.high && */ newValue >= range.high) {
-        return true;
-    }
-    return false;
-}
-
-function isOnEdgeOfRange(currentValue: Variant, newValue: Variant, range: PseudoRange): boolean {
-    if (currentValue.arrayType === VariantArrayType.Array) {
-        const n = currentValue.value.length;
-        let i = 0;
-        for (i = 0; i < n; i++) {
-            if (isOnEdgeOfRangeScalar(currentValue.value[i], newValue.value[i], newValue.dataType, range)) {
-                return true;
-            }
-        }
-        return false;
-    } else {
-        assert(currentValue.arrayType === VariantArrayType.Scalar);
-        assert(currentValue.dataType === newValue.dataType);
-        return isOnEdgeOfRangeScalar(currentValue.value, newValue.value, currentValue.dataType, range);
-    }
-}
-
-/**
- * @method isOutsideDeadbandNone
- * @return true if the element is in deadBand
- */
-export function isOutsideDeadbandNone(variant1: Variant, variant2: Variant): boolean {
-    // No Deadband calculation should be applied.
-    return variant1.value !== variant2.value;
-}
-/**
- * @method isOutsideDeadbandAbsolute
- * @return true if the element is in deadBand
- */
-export function isOutsideDeadbandAbsolute(variant1: Variant, variant2: Variant, deadbandValue: number): boolean {
-    // No Deadband calculation should be applied.
-    return isOutsideDeadbandVariant(variant1, variant2, deadbandValue);
-}
-
-/**
- * @method isOutsideDeadband
- * @return true if the element is outside deadBand
- */
-export function isOutsideDeadbandPercent(variant1: Variant, variant2: Variant, deadbandValue: number, range: PseudoRange): boolean {
-    // The range of the deadbandValue is from 0.0 to 100.0 Percent.
-    assert(deadbandValue >= 0 && deadbandValue <= 100);
-
-    if (isOnEdgeOfRange(variant1, variant2, range)) {
-        return true;
-    }
-
-    // DeadbandType = PercentDeadband
-    // For this type of deadband the deadbandValue is defined as the percentage of the EURange. That is,
-    // it applies only to AnalogItems with an EURange Property that defines the typical value range for the
-    // item. This range shall be multiplied with the deadbandValue and then compared to the actual value change
-    // to determine the need for a data change notification. The following pseudo code shows how the deadband
-    // is calculated:
-    //      DataChange if (absolute value of (last cached value - current value) >
-    //                                          (deadbandValue/100.0) * ((high-low) of EURange)))
-    //
-    // Specifying a deadbandValue outside of this range will be rejected and reported with the
-    // StatusCode BadDeadbandFilterInvalid (see Table 27).
-    // If the Value of the MonitoredItem is an array, then the deadband calculation logic shall be applied to
-    // each element of the array. If an element that requires a DataChange is found, then no further
-    // deadband checking is necessary and the entire array shall be returned.
-    const valueRange = Math.abs(range.high - range.low);
-    assert(typeof valueRange === "number");
-    const value = (deadbandValue / 100) * valueRange;
-    return isOutsideDeadbandAbsolute(variant1, variant2, value);
-}
+/**
+ * @module node-opcua-service-subscription
+ */
+import { assert } from "node-opcua-assert";
+
+import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
+
+export enum DeadbandType {
+    None = 0x00,
+    Absolute = 0x01,
+    Percent = 0x02,
+    Invalid = 0x1000
+}
+
+export type NumberType = number | number[];
+
+export interface PseudoRange {
+    low: number;
+    high: number;
+}
+
+/**
+ * @returns true if the difference between value1 and value2 is greater than absoluteDeadband
+ */
+function _isOutsideDeadbandScalar(value1: NumberType, value2: NumberType, dataType: DataType, absoluteDeadband: number): boolean {
+    let diff;
+    if (dataType === DataType.UInt64 || dataType === DataType.Int64) {
+        // istanbul ignore next
+        if (!(value1 instanceof Array && value2 instanceof Array)) {
+            throw new Error("Invalid");
+        }
+        const h1 = value1[0]; // high
+        const h2 = value2[0];
+        if (h1 !== h2) {
+            diff = (h1 - h2) * 4294967295;
+            if (Math.abs(diff) > absoluteDeadband) {
+                return true;
+            }
+        }
+        diff = value1[1] - value2[1];
+        assert(typeof diff === "number" && isFinite(diff));
+        return Math.abs(diff) > absoluteDeadband;
+    }
+    // istanbul ignore next
+    if (!(typeof value1 === "number" && typeof value2 === "number")) {
+        throw new Error(
+            "Invalid value in _isOutsideDeadbandScalar > expecting number only but got " + typeof value1 + " " + typeof value2
+        );
+    }
+    diff = value2 - value1;
+    assert(typeof diff === "number" && isFinite(diff));
+    return Math.abs(diff) > absoluteDeadband;
+}
+function isOutsideDeadbandVariant(v1: Variant, v2: Variant, absoluteDeadBand: number): boolean {
+    assert(isFinite(absoluteDeadBand));
+
+    if (v1.arrayType === VariantArrayType.Array) {
+        if (v1.dataType !== v2.dataType) {
+            return true;
+        }
+        if (v1.value.length !== v2.value.length) {
+            return true;
+        }
+
+        const n = v1.value.length;
+        let i = 0;
+        for (i = 0; i < n; i++) {
+            if (_isOutsideDeadbandScalar(v1.value[i], v2.value[i], v1.dataType, absoluteDeadBand)) {
+                return true;
+            }
+        }
+        return false;
+    } else {
+        assert(v1.arrayType === VariantArrayType.Scalar);
+        if(v1.dataType !== v2.dataType) {
+            return true;
+        }
+        return _isOutsideDeadbandScalar(v1.value, v2.value, v1.dataType, absoluteDeadBand);
+    }
+}
+function isOnEdgeOfRangeScalar(currentValue: NumberType, newValue: NumberType, dataType: DataType, range: PseudoRange): boolean {
+    if (dataType === DataType.UInt64 || dataType === DataType.Int64) {
+        // istanbul ignore next
+        if (!(currentValue instanceof Array && newValue instanceof Array)) {
+            throw new Error("Invalid");
+        }
+        currentValue = currentValue[1];
+        newValue = newValue[1];
+    }
+    if (/*currentValue !== range.low && */ newValue <= range.low) {
+        return true;
+    }
+    if (/*currentValue !== range.high && */ newValue >= range.high) {
+        return true;
+    }
+    return false;
+}
+
+function isOnEdgeOfRange(currentValue: Variant, newValue: Variant, range: PseudoRange): boolean {
+    if (currentValue.arrayType === VariantArrayType.Array) {
+        const n = currentValue.value.length;
+        let i = 0;
+        for (i = 0; i < n; i++) {
+            if (isOnEdgeOfRangeScalar(currentValue.value[i], newValue.value[i], newValue.dataType, range)) {
+                return true;
+            }
+        }
+        return false;
+    } else {
+        assert(currentValue.arrayType === VariantArrayType.Scalar);
+        assert(currentValue.dataType === newValue.dataType);
+        return isOnEdgeOfRangeScalar(currentValue.value, newValue.value, currentValue.dataType, range);
+    }
+}
+
+/**
+ * @method isOutsideDeadbandNone
+ * @return true if the element is in deadBand
+ */
+export function isOutsideDeadbandNone(variant1: Variant, variant2: Variant): boolean {
+    // No Deadband calculation should be applied.
+    return variant1.value !== variant2.value;
+}
+/**
+ * @method isOutsideDeadbandAbsolute
+ * @return true if the element is in deadBand
+ */
+export function isOutsideDeadbandAbsolute(variant1: Variant, variant2: Variant, deadbandValue: number): boolean {
+    // No Deadband calculation should be applied.
+    return isOutsideDeadbandVariant(variant1, variant2, deadbandValue);
+}
+
+/**
+ * @method isOutsideDeadband
+ * @return true if the element is outside deadBand
+ */
+export function isOutsideDeadbandPercent(variant1: Variant, variant2: Variant, deadbandValue: number, range: PseudoRange): boolean {
+    // The range of the deadbandValue is from 0.0 to 100.0 Percent.
+    assert(deadbandValue >= 0 && deadbandValue <= 100);
+
+    if (isOnEdgeOfRange(variant1, variant2, range)) {
+        return true;
+    }
+
+    // DeadbandType = PercentDeadband
+    // For this type of deadband the deadbandValue is defined as the percentage of the EURange. That is,
+    // it applies only to AnalogItems with an EURange Property that defines the typical value range for the
+    // item. This range shall be multiplied with the deadbandValue and then compared to the actual value change
+    // to determine the need for a data change notification. The following pseudo code shows how the deadband
+    // is calculated:
+    //      DataChange if (absolute value of (last cached value - current value) >
+    //                                          (deadbandValue/100.0) * ((high-low) of EURange)))
+    //
+    // Specifying a deadbandValue outside of this range will be rejected and reported with the
+    // StatusCode BadDeadbandFilterInvalid (see Table 27).
+    // If the Value of the MonitoredItem is an array, then the deadband calculation logic shall be applied to
+    // each element of the array. If an element that requires a DataChange is found, then no further
+    // deadband checking is necessary and the entire array shall be returned.
+    const valueRange = Math.abs(range.high - range.low);
+    assert(typeof valueRange === "number");
+    const value = (deadbandValue / 100) * valueRange;
+    return isOutsideDeadbandAbsolute(variant1, variant2, value);
+}

package/source/index.ts

@@ -1,45 +1,45 @@
-/**
- * @module node-opcua-service-subscription
- */
-export {
-    NotificationData,
-    MonitoringMode,
-    DataChangeTrigger,
-    CreateSubscriptionRequest, CreateSubscriptionResponse, CreateSubscriptionRequestOptions,
-    ModifySubscriptionRequest, ModifySubscriptionResponse, ModifySubscriptionRequestOptions,
-    MonitoringParameters, MonitoringParametersOptions,
-    MonitoredItemCreateRequest, MonitoredItemCreateResult, MonitoredItemCreateRequestOptions,
-    CreateMonitoredItemsRequest, CreateMonitoredItemsResponse, CreateMonitoredItemsRequestOptions,
-    SubscriptionAcknowledgement,
-    PublishRequest,
-    NotificationMessage,
-    DataChangeNotification,
-    StatusChangeNotification,
-    EventNotificationList,
-    PublishResponse,
-    RepublishRequest,
-    RepublishResponse,
-    DeleteMonitoredItemsRequest, DeleteMonitoredItemsResponse, DeleteMonitoredItemsRequestOptions,
-    SetPublishingModeRequest, SetPublishingModeResponse, SetPublishingModeRequestOptions,
-    DeleteSubscriptionsRequest, DeleteSubscriptionsResponse, DeleteSubscriptionsRequestOptions,
-    MonitoredItemNotification, MonitoredItemModifyRequest,
-    MonitoredItemModifyResult, ModifyMonitoredItemsRequest, ModifyMonitoredItemsRequestOptions,
-    ModifyMonitoredItemsResponse, SetMonitoringModeRequest, SetMonitoringModeRequestOptions,
-    SetMonitoringModeResponse, EventFilterResult,
-    ContentFilterResult, ContentFilterElementResult,
-    EventFieldList, DataChangeFilter, AggregateFilter,
-    SetTriggeringRequest, SetTriggeringResponse, SetTriggeringRequestOptions,
-    TransferResult, TransferSubscriptionsRequest, TransferSubscriptionsRequestOptions,
-    TransferSubscriptionsResponse
-
-} from "node-opcua-types";
-
-export * from "./deadband_checker";
-import { assert } from "node-opcua-assert";
-import { MonitoringParameters, PublishResponse } from "node-opcua-types";
-
-assert(PublishResponse.schema.fields[1].name === "subscriptionId");
-PublishResponse.schema.fields[1].defaultValue = 0xFFFFFFFF;
-
-assert(MonitoringParameters.schema.fields[0].name === "clientHandle");
-MonitoringParameters.schema.fields[0].defaultValue = 0xFFFFFFFF;
+/**
+ * @module node-opcua-service-subscription
+ */
+export {
+    NotificationData,
+    MonitoringMode,
+    DataChangeTrigger,
+    CreateSubscriptionRequest, CreateSubscriptionResponse, CreateSubscriptionRequestOptions,
+    ModifySubscriptionRequest, ModifySubscriptionResponse, ModifySubscriptionRequestOptions,
+    MonitoringParameters, MonitoringParametersOptions,
+    MonitoredItemCreateRequest, MonitoredItemCreateResult, MonitoredItemCreateRequestOptions,
+    CreateMonitoredItemsRequest, CreateMonitoredItemsResponse, CreateMonitoredItemsRequestOptions,
+    SubscriptionAcknowledgement,
+    PublishRequest,
+    NotificationMessage,
+    DataChangeNotification,
+    StatusChangeNotification,
+    EventNotificationList,
+    PublishResponse,
+    RepublishRequest,
+    RepublishResponse,
+    DeleteMonitoredItemsRequest, DeleteMonitoredItemsResponse, DeleteMonitoredItemsRequestOptions,
+    SetPublishingModeRequest, SetPublishingModeResponse, SetPublishingModeRequestOptions,
+    DeleteSubscriptionsRequest, DeleteSubscriptionsResponse, DeleteSubscriptionsRequestOptions,
+    MonitoredItemNotification, MonitoredItemModifyRequest,
+    MonitoredItemModifyResult, ModifyMonitoredItemsRequest, ModifyMonitoredItemsRequestOptions,
+    ModifyMonitoredItemsResponse, SetMonitoringModeRequest, SetMonitoringModeRequestOptions,
+    SetMonitoringModeResponse, EventFilterResult,
+    ContentFilterResult, ContentFilterElementResult,
+    EventFieldList, DataChangeFilter, AggregateFilter,
+    SetTriggeringRequest, SetTriggeringResponse, SetTriggeringRequestOptions,
+    TransferResult, TransferSubscriptionsRequest, TransferSubscriptionsRequestOptions,
+    TransferSubscriptionsResponse
+
+} from "node-opcua-types";
+
+export * from "./deadband_checker";
+import { assert } from "node-opcua-assert";
+import { MonitoringParameters, PublishResponse } from "node-opcua-types";
+
+assert(PublishResponse.schema.fields[1].name === "subscriptionId");
+PublishResponse.schema.fields[1].defaultValue = 0xFFFFFFFF;
+
+assert(MonitoringParameters.schema.fields[0].name === "clientHandle");
+MonitoringParameters.schema.fields[0].defaultValue = 0xFFFFFFFF;