node-opcua-address-space 2.97.0 → 2.98.1

package/distHelpers/add_event_generator_object.js

@@ -1,65 +1,65 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.add_eventGeneratorObject = void 0;
-/**
- * @module node-opcua-address-space
- */
-const node_opcua_status_code_1 = require("node-opcua-status-code");
-const node_opcua_variant_1 = require("node-opcua-variant");
-function add_eventGeneratorObject(namespace, parentFolder) {
-    const myEvtType = namespace.addEventType({
-        browseName: "MyEventType",
-        subtypeOf: "BaseEventType" // should be implicit
-    });
-    const myObject = namespace.addObject({
-        browseName: "EventGeneratorObject",
-        eventNotifier: 1,
-        organizedBy: parentFolder
-    });
-    myObject.addReference({
-        nodeId: myEvtType,
-        referenceType: "AlwaysGeneratesEvent"
-    });
-    const method = namespace.addMethod(myObject, {
-        browseName: "EventGeneratorMethod",
-        inputArguments: [
-            {
-                dataType: node_opcua_variant_1.DataType.String,
-                description: { text: "Event Message" },
-                name: "message"
-            },
-            {
-                dataType: node_opcua_variant_1.DataType.UInt32,
-                description: { text: "Event Severity" },
-                name: "severity"
-            }
-        ],
-        outputArguments: []
-    });
-    method.bindMethod((inputArguments, context, callback) => {
-        // xx console.log("In Event Generator Method");
-        // xx console.log(this.toString());
-        // xx console.log(context.object.toString());
-        // xx console.log("inputArguments ", inputArguments[0].toString());
-        const message = inputArguments[0].value || "Hello from Event Generator Object";
-        const severity = inputArguments[1].value || 0;
-        const myEventType = namespace.addressSpace.findEventType("MyEventType", namespace.index);
-        context.object.raiseEvent(myEventType, {
-            message: {
-                dataType: node_opcua_variant_1.DataType.LocalizedText,
-                value: { text: message }
-            },
-            severity: {
-                dataType: node_opcua_variant_1.DataType.UInt32,
-                value: severity
-            }
-        });
-        const callMethodResult = {
-            outputArguments: [],
-            statusCode: node_opcua_status_code_1.StatusCodes.Good
-        };
-        callback(null, callMethodResult);
-    });
-}
-exports.add_eventGeneratorObject = add_eventGeneratorObject;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.add_eventGeneratorObject = void 0;
+/**
+ * @module node-opcua-address-space
+ */
+const node_opcua_status_code_1 = require("node-opcua-status-code");
+const node_opcua_variant_1 = require("node-opcua-variant");
+function add_eventGeneratorObject(namespace, parentFolder) {
+    const myEvtType = namespace.addEventType({
+        browseName: "MyEventType",
+        subtypeOf: "BaseEventType" // should be implicit
+    });
+    const myObject = namespace.addObject({
+        browseName: "EventGeneratorObject",
+        eventNotifier: 1,
+        organizedBy: parentFolder
+    });
+    myObject.addReference({
+        nodeId: myEvtType,
+        referenceType: "AlwaysGeneratesEvent"
+    });
+    const method = namespace.addMethod(myObject, {
+        browseName: "EventGeneratorMethod",
+        inputArguments: [
+            {
+                dataType: node_opcua_variant_1.DataType.String,
+                description: { text: "Event Message" },
+                name: "message"
+            },
+            {
+                dataType: node_opcua_variant_1.DataType.UInt32,
+                description: { text: "Event Severity" },
+                name: "severity"
+            }
+        ],
+        outputArguments: []
+    });
+    method.bindMethod((inputArguments, context, callback) => {
+        // xx console.log("In Event Generator Method");
+        // xx console.log(this.toString());
+        // xx console.log(context.object.toString());
+        // xx console.log("inputArguments ", inputArguments[0].toString());
+        const message = inputArguments[0].value || "Hello from Event Generator Object";
+        const severity = inputArguments[1].value || 0;
+        const myEventType = namespace.addressSpace.findEventType("MyEventType", namespace.index);
+        context.object.raiseEvent(myEventType, {
+            message: {
+                dataType: node_opcua_variant_1.DataType.LocalizedText,
+                value: { text: message }
+            },
+            severity: {
+                dataType: node_opcua_variant_1.DataType.UInt32,
+                value: severity
+            }
+        });
+        const callMethodResult = {
+            outputArguments: [],
+            statusCode: node_opcua_status_code_1.StatusCodes.Good
+        };
+        callback(null, callMethodResult);
+    });
+}
+exports.add_eventGeneratorObject = add_eventGeneratorObject;
 //# sourceMappingURL=add_event_generator_object.js.map

package/distHelpers/alarms_and_conditions_demo.d.ts

@@ -1,9 +1,9 @@
-import { AddressSpace, UANonExclusiveLimitAlarmEx, UAExclusiveLimitAlarmEx, UAVariable } from "..";
-export interface IAlarmTestData {
-    tankLevel: UAVariable;
-    tankLevelCondition: UAExclusiveLimitAlarmEx;
-    tankLevel2: UAVariable;
-    tankLevelCondition2: UANonExclusiveLimitAlarmEx;
-    tankTripCondition: null;
-}
-export declare function construct_demo_alarm_in_address_space(test: IAlarmTestData, addressSpace: AddressSpace): void;
+import { AddressSpace, UANonExclusiveLimitAlarmEx, UAExclusiveLimitAlarmEx, UAVariable } from "..";
+export interface IAlarmTestData {
+    tankLevel: UAVariable;
+    tankLevelCondition: UAExclusiveLimitAlarmEx;
+    tankLevel2: UAVariable;
+    tankLevelCondition2: UANonExclusiveLimitAlarmEx;
+    tankTripCondition: null;
+}
+export declare function construct_demo_alarm_in_address_space(test: IAlarmTestData, addressSpace: AddressSpace): void;

package/distHelpers/alarms_and_conditions_demo.js

@@ -1,116 +1,116 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.construct_demo_alarm_in_address_space = void 0;
-/**
- * @module node-opcua-address-space
- */
-const node_opcua_assert_1 = require("node-opcua-assert");
-function construct_demo_alarm_in_address_space(test, addressSpace) {
-    const a = addressSpace;
-    if (a.construct_demo_alarm_in_address_space_called) {
-        return;
-    }
-    a.construct_demo_alarm_in_address_space_called = true;
-    addressSpace.installAlarmsAndConditionsService();
-    const namespace = addressSpace.getOwnNamespace();
-    const tank = namespace.addObject({
-        browseName: "Tank",
-        description: "The Object representing the Tank",
-        eventNotifier: 0x01,
-        notifierOf: addressSpace.rootFolder.objects.server,
-        organizedBy: addressSpace.rootFolder.objects
-    });
-    (0, node_opcua_assert_1.assert)(tank.getNotifiers().length === 0, "expecting a notifier now");
-    const tankLevel = namespace.addVariable({
-        browseName: "TankLevel",
-        componentOf: tank,
-        dataType: "Double",
-        description: "Fill level in percentage (0% to 100%) of the water tank",
-        eventSourceOf: tank,
-        value: { dataType: "Double", value: 0.5 }
-    });
-    //    assert(tank.getNotifiers().length === 1, "expecting a notifier now");
-    // --------------------------------------------------------------------------------
-    // Let's create a exclusive Limit Alarm that automatically raise itself
-    // when the tank level is out of limit
-    // --------------------------------------------------------------------------------
-    const exclusiveLimitAlarmType = addressSpace.findEventType("ExclusiveLimitAlarmType");
-    if (!exclusiveLimitAlarmType) {
-        throw new Error("cannot find ExclusiveLimitAlarmType in namespace 0");
-    }
-    const tankLevelCondition = namespace.instantiateExclusiveLimitAlarm(exclusiveLimitAlarmType, {
-        browseName: "TankLevelCondition",
-        componentOf: tank,
-        conditionName: "TankLevelCondition",
-        conditionSource: tankLevel,
-        highHighLimit: 0.9,
-        highLimit: 0.8,
-        inputNode: tankLevel,
-        lowLimit: 0.2,
-        optionals: [
-            "ConfirmedState",
-            "Confirm" // confirm state and confirm Method
-        ],
-        setpointNode: null,
-    });
-    (0, node_opcua_assert_1.assert)(tankLevelCondition.browseName.toString() === "1:TankLevelCondition");
-    (0, node_opcua_assert_1.assert)(tankLevel.findReferences("HasCondition").length === 1);
-    (0, node_opcua_assert_1.assert)(tankLevel.findReferencesAsObject("HasCondition", true).length === 1);
-    const conditionName = tankLevel.findReferencesAsObject("HasCondition", true)[0].browseName.toString();
-    const conditionTypeDefinition = tankLevel.findReferencesAsObject("HasCondition", true)[0].typeDefinitionObj.browseName.toString();
-    const conditionJavascriptClass = tankLevel.findReferencesAsObject("HasCondition", true)[0].constructor.name.toString();
-    if (false) {
-        console.log(conditionName, conditionTypeDefinition, conditionJavascriptClass);
-    }
-    (0, node_opcua_assert_1.assert)("1:TankLevelCondition" === conditionName);
-    (0, node_opcua_assert_1.assert)("ExclusiveLimitAlarmType" === conditionTypeDefinition);
-    (0, node_opcua_assert_1.assert)("UAExclusiveLimitAlarmImpl" === conditionJavascriptClass);
-    // ----------------------------------------------------------------
-    // tripAlarm that signals that the "Tank lid" is opened
-    const tripAlarmType = addressSpace.findEventType("TripAlarmType");
-    const tankTripCondition = null;
-    // to
-    // ---------------------------
-    // create a retain condition
-    // xx tankLevelCondition.currentBranch().setRetain(true);
-    // xx tankLevelCondition.raiseNewCondition({message: "Tank is almost 70% full",
-    //                                          severity: 100, quality: StatusCodes.Good});
-    // -------------------------------------------------------------
-    // Let's create a second variable with no Exclusive alarm
-    // -------------------------------------------------------------
-    const tankLevel2 = namespace.addVariable({
-        browseName: "tankLevel2",
-        componentOf: tank,
-        dataType: "Double",
-        description: "Fill level in percentage (0% to 100%) of the water tank",
-        eventSourceOf: tank,
-        value: { dataType: "Double", value: 0.5 }
-    });
-    const nonExclusiveLimitAlarmType = addressSpace.findEventType("NonExclusiveLimitAlarmType");
-    if (!nonExclusiveLimitAlarmType) {
-        throw new Error("!!");
-    }
-    const tankLevelCondition2 = namespace.instantiateNonExclusiveLimitAlarm(nonExclusiveLimitAlarmType, {
-        browseName: "TankLevelCondition2",
-        componentOf: tank,
-        conditionName: "TankLevel2",
-        conditionSource: tankLevel2,
-        highHighLimit: 0.9,
-        highLimit: 0.8,
-        inputNode: tankLevel2,
-        lowLimit: 0.2,
-        optionals: [
-            "ConfirmedState",
-            "Confirm" // confirm state and confirm Method
-        ]
-    });
-    (0, node_opcua_assert_1.assert)(tankLevel2.findReferences("HasCondition").length === 1);
-    (0, node_opcua_assert_1.assert)(tankLevel2.findReferencesAsObject("HasCondition", true).length === 1);
-    test.tankLevel = tankLevel;
-    test.tankLevelCondition = tankLevelCondition;
-    test.tankLevel2 = tankLevel2;
-    test.tankLevelCondition2 = tankLevelCondition2;
-    test.tankTripCondition = tankTripCondition;
-}
-exports.construct_demo_alarm_in_address_space = construct_demo_alarm_in_address_space;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.construct_demo_alarm_in_address_space = void 0;
+/**
+ * @module node-opcua-address-space
+ */
+const node_opcua_assert_1 = require("node-opcua-assert");
+function construct_demo_alarm_in_address_space(test, addressSpace) {
+    const a = addressSpace;
+    if (a.construct_demo_alarm_in_address_space_called) {
+        return;
+    }
+    a.construct_demo_alarm_in_address_space_called = true;
+    addressSpace.installAlarmsAndConditionsService();
+    const namespace = addressSpace.getOwnNamespace();
+    const tank = namespace.addObject({
+        browseName: "Tank",
+        description: "The Object representing the Tank",
+        eventNotifier: 0x01,
+        notifierOf: addressSpace.rootFolder.objects.server,
+        organizedBy: addressSpace.rootFolder.objects
+    });
+    (0, node_opcua_assert_1.assert)(tank.getNotifiers().length === 0, "expecting a notifier now");
+    const tankLevel = namespace.addVariable({
+        browseName: "TankLevel",
+        componentOf: tank,
+        dataType: "Double",
+        description: "Fill level in percentage (0% to 100%) of the water tank",
+        eventSourceOf: tank,
+        value: { dataType: "Double", value: 0.5 }
+    });
+    //    assert(tank.getNotifiers().length === 1, "expecting a notifier now");
+    // --------------------------------------------------------------------------------
+    // Let's create a exclusive Limit Alarm that automatically raise itself
+    // when the tank level is out of limit
+    // --------------------------------------------------------------------------------
+    const exclusiveLimitAlarmType = addressSpace.findEventType("ExclusiveLimitAlarmType");
+    if (!exclusiveLimitAlarmType) {
+        throw new Error("cannot find ExclusiveLimitAlarmType in namespace 0");
+    }
+    const tankLevelCondition = namespace.instantiateExclusiveLimitAlarm(exclusiveLimitAlarmType, {
+        browseName: "TankLevelCondition",
+        componentOf: tank,
+        conditionName: "TankLevelCondition",
+        conditionSource: tankLevel,
+        highHighLimit: 0.9,
+        highLimit: 0.8,
+        inputNode: tankLevel,
+        lowLimit: 0.2,
+        optionals: [
+            "ConfirmedState",
+            "Confirm" // confirm state and confirm Method
+        ],
+        setpointNode: null,
+    });
+    (0, node_opcua_assert_1.assert)(tankLevelCondition.browseName.toString() === "1:TankLevelCondition");
+    (0, node_opcua_assert_1.assert)(tankLevel.findReferences("HasCondition").length === 1);
+    (0, node_opcua_assert_1.assert)(tankLevel.findReferencesAsObject("HasCondition", true).length === 1);
+    const conditionName = tankLevel.findReferencesAsObject("HasCondition", true)[0].browseName.toString();
+    const conditionTypeDefinition = tankLevel.findReferencesAsObject("HasCondition", true)[0].typeDefinitionObj.browseName.toString();
+    const conditionJavascriptClass = tankLevel.findReferencesAsObject("HasCondition", true)[0].constructor.name.toString();
+    if (false) {
+        console.log(conditionName, conditionTypeDefinition, conditionJavascriptClass);
+    }
+    (0, node_opcua_assert_1.assert)("1:TankLevelCondition" === conditionName);
+    (0, node_opcua_assert_1.assert)("ExclusiveLimitAlarmType" === conditionTypeDefinition);
+    (0, node_opcua_assert_1.assert)("UAExclusiveLimitAlarmImpl" === conditionJavascriptClass);
+    // ----------------------------------------------------------------
+    // tripAlarm that signals that the "Tank lid" is opened
+    const tripAlarmType = addressSpace.findEventType("TripAlarmType");
+    const tankTripCondition = null;
+    // to
+    // ---------------------------
+    // create a retain condition
+    // xx tankLevelCondition.currentBranch().setRetain(true);
+    // xx tankLevelCondition.raiseNewCondition({message: "Tank is almost 70% full",
+    //                                          severity: 100, quality: StatusCodes.Good});
+    // -------------------------------------------------------------
+    // Let's create a second variable with no Exclusive alarm
+    // -------------------------------------------------------------
+    const tankLevel2 = namespace.addVariable({
+        browseName: "tankLevel2",
+        componentOf: tank,
+        dataType: "Double",
+        description: "Fill level in percentage (0% to 100%) of the water tank",
+        eventSourceOf: tank,
+        value: { dataType: "Double", value: 0.5 }
+    });
+    const nonExclusiveLimitAlarmType = addressSpace.findEventType("NonExclusiveLimitAlarmType");
+    if (!nonExclusiveLimitAlarmType) {
+        throw new Error("!!");
+    }
+    const tankLevelCondition2 = namespace.instantiateNonExclusiveLimitAlarm(nonExclusiveLimitAlarmType, {
+        browseName: "TankLevelCondition2",
+        componentOf: tank,
+        conditionName: "TankLevel2",
+        conditionSource: tankLevel2,
+        highHighLimit: 0.9,
+        highLimit: 0.8,
+        inputNode: tankLevel2,
+        lowLimit: 0.2,
+        optionals: [
+            "ConfirmedState",
+            "Confirm" // confirm state and confirm Method
+        ]
+    });
+    (0, node_opcua_assert_1.assert)(tankLevel2.findReferences("HasCondition").length === 1);
+    (0, node_opcua_assert_1.assert)(tankLevel2.findReferencesAsObject("HasCondition", true).length === 1);
+    test.tankLevel = tankLevel;
+    test.tankLevelCondition = tankLevelCondition;
+    test.tankLevel2 = tankLevel2;
+    test.tankLevelCondition2 = tankLevelCondition2;
+    test.tankTripCondition = tankTripCondition;
+}
+exports.construct_demo_alarm_in_address_space = construct_demo_alarm_in_address_space;
 //# sourceMappingURL=alarms_and_conditions_demo.js.map

package/distHelpers/assertHasMatchingReference.d.ts

@@ -1,19 +1,19 @@
-import { AddReferenceOpts, BaseNode } from "..";
-/**
- * asserts that the provided reference exists in the node references
- *
- * @method assertHasMatchingReference
- *
- * @param node
- * @param reference (Reference}
- * @param reference.referenceType {String}
- * @param reference.nodeId        {NodeId}
- * @param reference.isForward     {Boolean}
- *
- * @example:
- *
- *     assertHasMatchingReference(node,{ referenceType: "Organizes",i sForward:true, nodeId: "ns=1,i=12" });
- *
- *
- */
-export declare function assertHasMatchingReference(node: BaseNode, reference: AddReferenceOpts): void;
+import { AddReferenceOpts, BaseNode } from "..";
+/**
+ * asserts that the provided reference exists in the node references
+ *
+ * @method assertHasMatchingReference
+ *
+ * @param node
+ * @param reference (Reference}
+ * @param reference.referenceType {String}
+ * @param reference.nodeId        {NodeId}
+ * @param reference.isForward     {Boolean}
+ *
+ * @example:
+ *
+ *     assertHasMatchingReference(node,{ referenceType: "Organizes",i sForward:true, nodeId: "ns=1,i=12" });
+ *
+ *
+ */
+export declare function assertHasMatchingReference(node: BaseNode, reference: AddReferenceOpts): void;

package/distHelpers/assertHasMatchingReference.js

@@ -1,41 +1,41 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertHasMatchingReference = void 0;
-/**
- * @module node-opcua-address-space
- */
-const node_opcua_assert_1 = require("node-opcua-assert");
-const node_opcua_nodeid_1 = require("node-opcua-nodeid");
-/**
- * asserts that the provided reference exists in the node references
- *
- * @method assertHasMatchingReference
- *
- * @param node
- * @param reference (Reference}
- * @param reference.referenceType {String}
- * @param reference.nodeId        {NodeId}
- * @param reference.isForward     {Boolean}
- *
- * @example:
- *
- *     assertHasMatchingReference(node,{ referenceType: "Organizes",i sForward:true, nodeId: "ns=1,i=12" });
- *
- *
- */
-function assertHasMatchingReference(node, reference) {
-    const addressSpace = node.addressSpace;
-    const normalizedReference = addressSpace.normalizeReferenceType(reference);
-    (0, node_opcua_assert_1.assert)(normalizedReference.referenceType instanceof node_opcua_nodeid_1.NodeId);
-    let refs = node.findReferences(normalizedReference.referenceType, normalizedReference.isForward);
-    refs = refs.filter((ref) => {
-        return (0, node_opcua_nodeid_1.sameNodeId)(ref.nodeId, normalizedReference.nodeId);
-    });
-    const dispOpts = { addressSpace };
-    if (refs.length !== 1) {
-        throw new Error(" Cannot find reference " + JSON.stringify(normalizedReference));
-    }
-    (0, node_opcua_assert_1.assert)(refs.length === 1);
-}
-exports.assertHasMatchingReference = assertHasMatchingReference;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertHasMatchingReference = void 0;
+/**
+ * @module node-opcua-address-space
+ */
+const node_opcua_assert_1 = require("node-opcua-assert");
+const node_opcua_nodeid_1 = require("node-opcua-nodeid");
+/**
+ * asserts that the provided reference exists in the node references
+ *
+ * @method assertHasMatchingReference
+ *
+ * @param node
+ * @param reference (Reference}
+ * @param reference.referenceType {String}
+ * @param reference.nodeId        {NodeId}
+ * @param reference.isForward     {Boolean}
+ *
+ * @example:
+ *
+ *     assertHasMatchingReference(node,{ referenceType: "Organizes",i sForward:true, nodeId: "ns=1,i=12" });
+ *
+ *
+ */
+function assertHasMatchingReference(node, reference) {
+    const addressSpace = node.addressSpace;
+    const normalizedReference = addressSpace.normalizeReferenceType(reference);
+    (0, node_opcua_assert_1.assert)(normalizedReference.referenceType instanceof node_opcua_nodeid_1.NodeId);
+    let refs = node.findReferences(normalizedReference.referenceType, normalizedReference.isForward);
+    refs = refs.filter((ref) => {
+        return (0, node_opcua_nodeid_1.sameNodeId)(ref.nodeId, normalizedReference.nodeId);
+    });
+    const dispOpts = { addressSpace };
+    if (refs.length !== 1) {
+        throw new Error(" Cannot find reference " + JSON.stringify(normalizedReference));
+    }
+    (0, node_opcua_assert_1.assert)(refs.length === 1);
+}
+exports.assertHasMatchingReference = assertHasMatchingReference;
 //# sourceMappingURL=assertHasMatchingReference.js.map