node-opcua-address-space 2.74.0 → 2.75.0

package/src/alarms_and_conditions/ua_limit_alarm_impl.ts

@@ -14,9 +14,7 @@ import { UAShelvedStateMachineEx } from "../../source";
 import { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
 import { UALimitAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_limit_alarm_ex";
 import { NamespacePrivate } from "../namespace_private";
-import {
-    UAAlarmConditionImpl
-} from "./ua_alarm_condition_impl";
+import { UAAlarmConditionImpl } from "./ua_alarm_condition_impl";
 
 const warningLog = make_warningLog("AlarmsAndConditions");
 
@@ -35,11 +33,11 @@ const uaLimitAlarmInputSupportedDataType: DataType[] = [
     DataType.UInt32
 ];
 
-export interface UALimitAlarmImpl extends UALimitAlarmEx  {
+export interface UALimitAlarmImpl extends UALimitAlarmEx {
     shelvingState?: UAShelvedStateMachineEx;
 }
 export class UALimitAlarmImpl extends UAAlarmConditionImpl implements UALimitAlarmEx {
-   /**
+    /**
      * @method (static)UALimitAlarm.instantiate
      * @param namespace {INamespace}
      * @param limitAlarmTypeId
@@ -127,8 +125,8 @@ export class UALimitAlarmImpl extends UAAlarmConditionImpl implements UALimitAla
             throw new Error(message);
         }
 
-        if (Object.prototype.hasOwnProperty.call(options, "highHighLimit")) {
-            alarmNode.setHighHighLimit(options.highHighLimit);
+        if (Object.prototype.hasOwnProperty.call(options, "highHighLimit") && options.highHighLimit !== undefined) {
+            alarmNode.setHighHighLimit(options.highHighLimit!);
         }
         if (Object.prototype.hasOwnProperty.call(options, "highLimit")) {
             alarmNode.setHighLimit(options.highLimit);
@@ -136,7 +134,7 @@ export class UALimitAlarmImpl extends UAAlarmConditionImpl implements UALimitAla
         if (Object.prototype.hasOwnProperty.call(options, "lowLimit")) {
             alarmNode.setLowLimit(options.lowLimit);
         }
-        if (Object.prototype.hasOwnProperty.call(options, "lowLowLimit")) {
+        if (Object.prototype.hasOwnProperty.call(options, "lowLowLimit") && options.lowLowLimit != undefined) {
             alarmNode.setLowLowLimit(options.lowLowLimit);
         }
 

package/src/alarms_and_conditions/ua_non_exclusive_deviation_alarm_impl.ts

@@ -6,8 +6,8 @@ import { assert } from "node-opcua-assert";
 
 import { DataValue } from "node-opcua-data-value";
 import { NodeId } from "node-opcua-nodeid";
-import { VariantOptions } from "node-opcua-variant";
-import { UAVariable } from "node-opcua-address-space-base";
+import { DataType, VariantOptions } from "node-opcua-variant";
+import { UAVariable, UAVariableT } from "node-opcua-address-space-base";
 import { NamespacePrivate } from "../namespace_private";
 import { AddressSpace } from "../address_space";
 import { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
@@ -20,6 +20,8 @@ import {
 } from "./deviation_alarm_helper";
 import { UALimitAlarmImpl } from "./ua_limit_alarm_impl";
 import { UANonExclusiveLimitAlarmImpl } from "./ua_non_exclusive_limit_alarm_impl";
+
+
 export declare interface UANonExclusiveDeviationAlarmImpl extends UANonExclusiveLimitAlarmImpl, UANonExclusiveDeviationAlarmEx {
     on(eventName: string, eventHandler: any): this;
     get addressSpace(): AddressSpace;
@@ -63,7 +65,7 @@ export class UANonExclusiveDeviationAlarmImpl extends UANonExclusiveLimitAlarmIm
         super._setStateBasedOnInputValue(value - setpointValue);
     }
 
-    public getSetpointNodeNode(): UAVariable {
+    public getSetpointNodeNode(): UAVariableT<number, DataType.Double> | UAVariableT<number, DataType.Float> | undefined  {
         return DeviationAlarmHelper_getSetpointNodeNode.call(this);
     }
 

package/src/alarms_and_conditions/ua_off_normal_alarm_impl.ts

@@ -12,7 +12,7 @@ import { DataType, VariantOptions } from "node-opcua-variant";
 import { InstantiateOffNormalAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_off_normal_alarm_options";
 import { UADiscreteAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_discrete_alarm_ex";
 import { AddressSpacePrivate } from "../address_space_private";
-import {  UADiscreteAlarmImpl } from "./ua_discrete_alarm_impl";
+import { UADiscreteAlarmImpl } from "./ua_discrete_alarm_impl";
 
 function isEqual(value1: any, value2: any) {
     return value1 === value2;
@@ -39,7 +39,6 @@ export declare interface UAOffNormalAlarmEx
     setNormalStateValue(value: any): void;
 }
 
-
 export declare interface UAOffNormalAlarmImpl extends UAOffNormalAlarmEx, UADiscreteAlarmImpl {
     on(eventName: string, eventHandler: any): this;
 }
@@ -103,21 +102,24 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
          * If this Variable is not in the AddressSpace, a NULL NodeId shall be provided.
          *
          */
-        const normalState = addressSpace._coerceNode(options.normalState) as UAVariable | null;
-        const normalStateNodeId = normalState ? normalState.nodeId : new NodeId();
-        alarmNode.normalState.setValueFromSource({ dataType: DataType.NodeId, value: normalStateNodeId });
-        alarmNode.normalState.on("value_changed", (newDataValue: DataValue /*, oldDataValue: DataValue*/) => {
-            // The node that contains the normalState value has changed.
-            //   we must remove the listener on current normalState and replace
-            //   normalState with the new one and set listener again
-            //   to do:
-        });
-
-        if (normalState) {
-            // install normalState monitoring for change
-            normalState.on("value_changed", (newDataValue: DataValue /*, oldDataValue: DataValue*/) => {
-                alarmNode._onNormalStateDataValueChange(newDataValue);
+        if (options.normalState) {
+            const normalState = addressSpace._coerceNode(options.normalState) as UAVariable | null;
+            const normalStateNodeId = normalState ? normalState.nodeId : new NodeId();
+            alarmNode.normalState.setValueFromSource({ dataType: DataType.NodeId, value: normalStateNodeId });
+            alarmNode.normalState.on("value_changed", (newDataValue: DataValue /*, oldDataValue: DataValue*/) => {
+                // The node that contains the normalState value has changed.
+                //   we must remove the listener on current normalState and replace
+                //   normalState with the new one and set listener again
+                //   to do:
             });
+            if (normalState) {
+                // install normalState monitoring for change
+                normalState.on("value_changed", (newDataValue: DataValue /*, oldDataValue: DataValue*/) => {
+                    alarmNode._onNormalStateDataValueChange(newDataValue);
+                });
+            }
+        } else {
+            alarmNode.normalState.setValueFromSource({ dataType: DataType.NodeId, value: NodeId.nullNodeId });
         }
 
         alarmNode._mayBe_updateAlarmState();

package/src/event_data.ts

@@ -2,16 +2,16 @@
  * @module node-opcua-address-space.Private
  */
 import { assert } from "node-opcua-assert";
-import { AttributeIds, NodeClass } from "node-opcua-data-model";
-import { DataValue } from "node-opcua-data-value";
-import { NodeId } from "node-opcua-nodeid";
-import { constructBrowsePathFromQualifiedName } from "node-opcua-service-translate-browse-path";
+import { coerceExpandedNodeId, NodeId, sameNodeId } from "node-opcua-nodeid";
 import { StatusCodes } from "node-opcua-status-code";
-import { SimpleAttributeOperand } from "node-opcua-types";
-import { DataType, Variant, VariantLike } from "node-opcua-variant";
+import { BrowsePath, BrowsePathResult } from "node-opcua-types";
+import { Variant, VariantLike } from "node-opcua-variant";
 
-import { ISessionContext, BaseNode, IEventData, UAVariable } from "node-opcua-address-space-base";
+import { BaseNode, IEventData } from "node-opcua-address-space-base";
+import { lowerFirstLetter } from "node-opcua-utils";
 
+type NodeIdString = string;
+type FullBrowsePath = string;
 /**
  * @class EventData
  * @param eventTypeNode {BaseNode}
@@ -21,91 +21,61 @@ export class EventData implements IEventData {
     public eventId: NodeId;
     public $eventDataSource: BaseNode;
 
-    private __nodes: { [key: string]: Variant };
+    public $cache: {
+        __values: { [key: NodeIdString]: Variant };
+        __nodeIdToNode: { [key: NodeIdString]: BaseNode };
+        __pathToNodeId: { [key: FullBrowsePath]: NodeId };
+        __nodeIdToFullPath: { [key: NodeIdString]: FullBrowsePath };
+    };
 
     constructor(eventTypeNode: BaseNode) {
-        this.__nodes = {};
+        this.$cache = {
+            __values: {},
+            __nodeIdToNode: {},
+            __pathToNodeId: {},
+            __nodeIdToFullPath: {}
+        };
+
         this.eventId = new NodeId();
         this.$eventDataSource = eventTypeNode;
     }
 
-    /**
-     * @method resolveSelectClause
-     * @param selectClause {SimpleAttributeOperand}
-     * @return {NodeId|null}
-     */
-    public resolveSelectClause(selectClause: SimpleAttributeOperand): NodeId | null {
-        assert(selectClause instanceof SimpleAttributeOperand);
-        const addressSpace = this.$eventDataSource.addressSpace;
-
-        if (selectClause.browsePath!.length === 0 && selectClause.attributeId === AttributeIds.NodeId) {
-            assert(!"Cannot use resolveSelectClause on this selectClause as it has no browsePath");
-        }
-        // navigate to the innerNode specified by the browsePath [ QualifiedName]
-        const browsePath = constructBrowsePathFromQualifiedName(this.$eventDataSource, selectClause.browsePath);
+    public _createValue(fullBrowsePath: string, node: BaseNode, variant: VariantLike): void {
+        const eventData = this as any;
+        assert(!eventData[fullBrowsePath], "already exists " + fullBrowsePath);
 
-        // xx console.log(self.$eventDataSource.browseName.toString());
-        // xx console.log("xx browse Path", browsePath.toString());
+        const lowerName = fullBrowsePath.split(".").map(lowerFirstLetter).join(".");
 
-        const browsePathResult = addressSpace.browsePath(browsePath);
+        eventData[lowerName] = Variant.coerce(variant);
 
-        // xx console.log(" br",
-        //    self.$eventDataSource.nodeId.toString(),
-        //    selectClause.browsePath.toString(),
-        //    browsePathResult.targets[0] ? browsePathResult.targets[0].targetId.toString() : "!!!NOT FOUND!!!"é)
+        this.$cache.__pathToNodeId[fullBrowsePath] = node.nodeId;
+        this.$cache.__nodeIdToNode[node.nodeId.toString()] = node;
+        this.$cache.__nodeIdToFullPath[node.nodeId.toString()] = fullBrowsePath;
+        this.$cache.__values[node.nodeId.toString()] = eventData[lowerName];
+    }
 
-        if (browsePathResult.statusCode !== StatusCodes.Good) {
-            return null;
-        }
-        if (!browsePathResult.targets) {
+    public _browse(browsePath: BrowsePath): BrowsePathResult | null {
+        if (!sameNodeId(browsePath.startingNode, this.$eventDataSource.nodeId)) {
             return null;
         }
-        // istanbul ignore next
-        if (browsePathResult.targets.length !== 1) {
-            // xx console.log("selectClause ",selectClause.toString());
-            // xx console.log("browsePathResult ",browsePathResult.toString());
-            // xx throw new Error("browsePathResult.targets.length !== 1"  + browsePathResult.targets.length);
-        }
-        return browsePathResult.targets[0].targetId;
+        const fullBrowsePath = (browsePath.relativePath.elements || []).map((b=>b.targetName.toString())).join(".");
+        const nodeId = this.$cache.__pathToNodeId[fullBrowsePath];
+        if (!nodeId) return null;
+        return new BrowsePathResult({
+            statusCode: StatusCodes.Good,
+            targets: [{
+                remainingPathIndex: 0,
+                targetId: coerceExpandedNodeId(nodeId),
+            }]
+        })
     }
 
-    public setValue(lowerName: string, node: BaseNode, variant: VariantLike): void {
-        const eventData = this as any;
-        eventData[lowerName] = Variant.coerce(variant); /// _coerceVariant(variant);
-        eventData.__nodes[node.nodeId.toString()] = eventData[lowerName];
-    }
-    /**
-     * @method readValue
-     * @param nodeId {NodeId}
-     * @param selectClause {SimpleAttributeOperand}
-     * @return {Variant}
-     */
-    public readValue(sessionContext: ISessionContext, nodeId: NodeId, selectClause: SimpleAttributeOperand): Variant {
-        assert(nodeId instanceof NodeId);
-        assert(selectClause instanceof SimpleAttributeOperand);
-        assert(nodeId instanceof NodeId);
-        const addressSpace = this.$eventDataSource.addressSpace;
-
-        const node = addressSpace.findNode(nodeId)!;
-        const key = node.nodeId.toString();
-
-        // if the value exists in cache ... we read it from cache...
-        const cached_value = this.__nodes[key];
+    public _readValue(nodeId: NodeId): Variant | null {
+        const key = nodeId.toString();
+        const cached_value = this.$cache.__values[key];
         if (cached_value) {
             return cached_value;
         }
-
-        if (node.nodeClass === NodeClass.Variable && selectClause.attributeId === AttributeIds.Value) {
-            const nodeVariable = node as UAVariable;
-            return prepare(nodeVariable.readValue(sessionContext, selectClause.indexRange));
-        }
-        return prepare(node.readAttribute(sessionContext, selectClause.attributeId));
-    }
-}
-
-function prepare(dataValue: DataValue): Variant {
-    if (dataValue.statusCode === StatusCodes.Good) {
-        return dataValue.value;
+        return null;
     }
-    return new Variant({ dataType: DataType.StatusCode, value: dataValue.statusCode });
-}
+}

package/src/index_current.ts

@@ -7,7 +7,6 @@ export * from "../source/helpers/dump_tools";
 export * from "../source/helpers/adjust_browse_direction";
 export * from "../source/pseudo_session";
 export * from "../source/helpers/make_optionals_map";
-export * from "../source/helpers/check_event_clause";
 export * from "../source/helpers/argument_list";
 export * from "../source/helpers/call_helpers";
 export * from "../source/helpers/ensure_secure_access";

package/src/namespace_impl.ts

@@ -28,7 +28,7 @@ import {
     RolePermissionTypeOptions
 } from "node-opcua-types";
 import * as utils from "node-opcua-utils";
-import { DataType, Variant, VariantArrayType, verifyRankAndDimensions } from "node-opcua-variant";
+import { DataType, Variant, VariantArrayType, VariantOptions, verifyRankAndDimensions } from "node-opcua-variant";
 import {
     AddBaseNodeOptions,
     AddEnumerationTypeOptions,
@@ -67,7 +67,14 @@ import {
 } from "../source/address_space_ts";
 import { UAStateMachineEx } from "../source/interfaces/state_machine/ua_state_machine_type";
 import { UATransitionEx } from "../source/interfaces/state_machine/ua_transition_ex";
-import { UATwoStateDiscreteEx, UAYArrayItemEx } from "../source";
+import {
+    InstantiateAlarmConditionOptions,
+    InstantiateExclusiveLimitAlarmOptions,
+    InstantiateLimitAlarmOptions,
+    InstantiateOffNormalAlarmOptions,
+    UATwoStateDiscreteEx,
+    UAYArrayItemEx
+} from "../source";
 import { AddAnalogDataItemOptions, AddDataItemOptions } from "../source/namespace_data_access";
 import { UATwoStateVariableEx } from "../source/ua_two_state_variable_ex";
 import { UAMultiStateValueDiscreteEx } from "../source/interfaces/data_access/ua_multistate_value_discrete_ex";
@@ -79,22 +86,19 @@ import { UALimitAlarmEx } from "../source/interfaces/alarms_and_conditions/ua_li
 import { UANonExclusiveDeviationAlarmEx } from "../source/interfaces/alarms_and_conditions/ua_non_exclusive_deviation_alarm_ex";
 import { UANonExclusiveLimitAlarmEx } from "../source/interfaces/alarms_and_conditions/ua_non_exclusive_limit_alarm_ex";
 import { UAConditionEx } from "../source/interfaces/alarms_and_conditions/ua_condition_ex";
+import { InstantiateExclusiveDeviationAlarmOptions } from "../source/interfaces/alarms_and_conditions/instantiate_exclusive_deviation_alarm_options";
+import { InstantiateNonExclusiveLimitAlarmOptions } from "../source/interfaces/alarms_and_conditions/instantiate_non_exclusive_limit_alarm_options";
+import { InstantiateNonExclusiveDeviationAlarmOptions } from "../source/interfaces/alarms_and_conditions/instantiate_non_exclusive_deviation_alarm_options";
 
 import { _handle_delete_node_model_change_event, _handle_model_change_event } from "./address_space_change_event_tools";
 import { AddressSpacePrivate } from "./address_space_private";
 import { UAConditionImpl } from "./alarms_and_conditions/ua_condition_impl";
 import { UADiscreteAlarmImpl } from "./alarms_and_conditions/ua_discrete_alarm_impl";
-import {
-    UAExclusiveDeviationAlarmImpl
-} from "./alarms_and_conditions/ua_exclusive_deviation_alarm_impl";
-import {  UAExclusiveLimitAlarmImpl } from "./alarms_and_conditions/ua_exclusive_limit_alarm_impl";
-import {  UALimitAlarmImpl } from "./alarms_and_conditions/ua_limit_alarm_impl";
-import {
-    UANonExclusiveDeviationAlarmImpl
-} from "./alarms_and_conditions/ua_non_exclusive_deviation_alarm_impl";
-import {
-    UANonExclusiveLimitAlarmImpl
-} from "./alarms_and_conditions/ua_non_exclusive_limit_alarm_impl";
+import { UAExclusiveDeviationAlarmImpl } from "./alarms_and_conditions/ua_exclusive_deviation_alarm_impl";
+import { UAExclusiveLimitAlarmImpl } from "./alarms_and_conditions/ua_exclusive_limit_alarm_impl";
+import { UALimitAlarmImpl } from "./alarms_and_conditions/ua_limit_alarm_impl";
+import { UANonExclusiveDeviationAlarmImpl } from "./alarms_and_conditions/ua_non_exclusive_deviation_alarm_impl";
+import { UANonExclusiveLimitAlarmImpl } from "./alarms_and_conditions/ua_non_exclusive_limit_alarm_impl";
 import { UAAcknowledgeableConditionImpl, UAAlarmConditionImpl } from "./alarms_and_conditions";
 import { UAOffNormalAlarmEx, UAOffNormalAlarmImpl } from "./alarms_and_conditions/ua_off_normal_alarm_impl";
 import { add_dataItem_stuff } from "./data_access/add_dataItem_stuff";
@@ -1541,52 +1545,69 @@ export class NamespaceImpl implements NamespacePrivate {
 
     public instantiateAcknowledgeableCondition(
         conditionTypeId: UAEventType | NodeId | string,
-        options: any,
-        data: any
+        options: InstantiateAlarmConditionOptions,
+        data?: Record<string, VariantOptions>
     ): UAAcknowledgeableConditionImpl {
         return UAAcknowledgeableConditionImpl.instantiate(this, conditionTypeId, options, data);
     }
 
     public instantiateAlarmCondition(
         alarmConditionTypeId: UAEventType | NodeId | string,
-        options: any,
-        data: any
+        options: InstantiateAlarmConditionOptions,
+        data?: Record<string, VariantOptions>
     ): UAAlarmConditionEx {
         return UAAlarmConditionImpl.instantiate(this, alarmConditionTypeId, options, data);
     }
 
-    public instantiateLimitAlarm(limitAlarmTypeId: UAEventType | NodeId | string, options: any, data: any): UALimitAlarmEx {
+    public instantiateLimitAlarm(
+        limitAlarmTypeId: UAEventType | NodeId | string,
+        options: InstantiateLimitAlarmOptions,
+        data?: Record<string, VariantOptions>
+    ): UALimitAlarmEx {
         return UALimitAlarmImpl.instantiate(this, limitAlarmTypeId, options, data);
     }
 
     public instantiateExclusiveLimitAlarm(
         exclusiveLimitAlarmTypeId: UAEventType | NodeId | string,
-        options: any,
-        data: any
+        options: InstantiateLimitAlarmOptions,
+        data?: Record<string, VariantOptions>
     ): UAExclusiveLimitAlarmEx {
         return UAExclusiveLimitAlarmImpl.instantiate(this, exclusiveLimitAlarmTypeId, options, data);
     }
 
-    public instantiateExclusiveDeviationAlarm(options: any, data: any): UAExclusiveDeviationAlarmEx {
+    public instantiateExclusiveDeviationAlarm(
+        options: InstantiateExclusiveDeviationAlarmOptions,
+        data?: Record<string, VariantOptions>
+    ): UAExclusiveDeviationAlarmEx {
         return UAExclusiveDeviationAlarmImpl.instantiate(this, "ExclusiveDeviationAlarmType", options, data);
     }
 
     public instantiateNonExclusiveLimitAlarm(
         nonExclusiveLimitAlarmTypeId: UAEventType | NodeId | string,
-        options: any,
-        data: any
+        options: InstantiateNonExclusiveLimitAlarmOptions,
+        data?: Record<string, VariantOptions>
     ): UANonExclusiveLimitAlarmEx {
         return UANonExclusiveLimitAlarmImpl.instantiate(this, nonExclusiveLimitAlarmTypeId, options, data);
     }
 
-    public instantiateNonExclusiveDeviationAlarm(options: any, data: any): UANonExclusiveDeviationAlarmEx {
+    public instantiateNonExclusiveDeviationAlarm(
+        options: InstantiateNonExclusiveDeviationAlarmOptions,
+        data?: Record<string, VariantOptions>
+    ): UANonExclusiveDeviationAlarmEx {
         return UANonExclusiveDeviationAlarmImpl.instantiate(this, "NonExclusiveDeviationAlarmType", options, data);
     }
 
-    public instantiateDiscreteAlarm(discreteAlarmType: UAEventType | NodeId | string, options: any, data: any): UADiscreteAlarmEx {
+    public instantiateDiscreteAlarm(
+        discreteAlarmType: UAEventType | NodeId | string,
+        options: InstantiateAlarmConditionOptions,
+        data?: Record<string, VariantOptions>
+    ): UADiscreteAlarmEx {
         return UADiscreteAlarmImpl.instantiate(this, discreteAlarmType, options, data);
     }
-    public instantiateOffNormalAlarm(options: any, data: any): UAOffNormalAlarmEx {
+    public instantiateOffNormalAlarm(
+        options: InstantiateOffNormalAlarmOptions,
+        data?: Record<string, VariantOptions>
+    ): UAOffNormalAlarmEx {
         return UAOffNormalAlarmImpl.instantiate(this, "OffNormalAlarmType", options, data);
     }
 

package/src/state_machine/ua_two_state_variable.ts

@@ -297,7 +297,7 @@ export class UATwoStateVariableImpl extends UAVariableImplT<LocalizedText, DataT
         // for which state or sub-state should be used. It is up to the Server and will depend on the
         // semantics of the StateMachineType
         //
-        // EffectiveDisplayName will be constructed by adding the EnableState
+        // EffectiveDisplayName will be constructed by adding the EnabledState
         // and the State of the addTrue state
         if (this.effectiveDisplayName) {
             this.id.on("value_changed", () => {

package/src/ua_object_impl.ts

@@ -156,8 +156,7 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
         // coerce EventType
         eventTypeNode = addressSpace.findEventType(eventType as UAEventType) as UAEventType;
         const baseEventType = addressSpace.findEventType("BaseEventType")!;
-        assert(eventTypeNode.isSupertypeOf(baseEventType));
-
+   
         data.$eventDataSource = eventTypeNode;
         data.sourceNode = data.sourceNode || { dataType: DataType.NodeId, value: this.nodeId };
 

package/test_helpers/alarms_and_conditions_demo.ts

@@ -69,7 +69,10 @@ export function construct_demo_alarm_in_address_space(test: IAlarmTestData, addr
         optionals: [
             "ConfirmedState",
             "Confirm" // confirm state and confirm Method
-        ]
+        ],
+
+        setpointNode: null,
+
     }) as UAExclusiveLimitAlarmEx;
 
     assert(tankLevelCondition.browseName.toString() === "1:TankLevelCondition");

package/source/helpers/check_event_clause.ts

@@ -1,55 +0,0 @@
-/**
- * @module node-opcua-address-space
- */
-// tslint:disable:no-console
-import { NodeClass } from "node-opcua-data-model";
-import { SimpleAttributeOperand } from "node-opcua-service-filter";
-import { constructBrowsePathFromQualifiedName } from "node-opcua-service-translate-browse-path";
-import { StatusCode, StatusCodes } from "node-opcua-status-code";
-import { BaseNode, UAObjectType } from "node-opcua-address-space-base";
-
-/**
- * @method checkSelectClause
- * @param parentNode
- * @param selectClause
- * @return {Array<StatusCode>}
- */
-export function checkSelectClause(parentNode: BaseNode, selectClause: SimpleAttributeOperand): StatusCode {
-    //
-    const addressSpace = parentNode.addressSpace;
-
-    // istanbul ignore next
-    if (selectClause.typeDefinitionId.isEmpty()) {
-        return StatusCodes.Good;
-    }
-    const eventTypeNode = addressSpace.findEventType(selectClause.typeDefinitionId)!;
-
-    if (!eventTypeNode || !(eventTypeNode.nodeClass === NodeClass.ObjectType)) {
-        // xx console.log("eventTypeNode = ",selectClause.typeDefinitionId.toString());
-        // xx console.log("eventTypeNode = ",eventTypeNode);
-        // istanbul ignore next
-        if (eventTypeNode) {
-            console.log(eventTypeNode.toString());
-        }
-    }
-
-    // istanbul ignore next
-    if (eventTypeNode.nodeClass !== NodeClass.ObjectType) {
-        throw new Error("Expecting a ObjectType");
-    }
-
-    // navigate to the innerNode specified by the browsePath [ QualifiedName]
-    const browsePath = constructBrowsePathFromQualifiedName(eventTypeNode, selectClause.browsePath);
-    const browsePathResult = addressSpace.browsePath(browsePath);
-    return browsePathResult.statusCode;
-}
-
-/**
- * @method checkSelectClauses
- * @param eventTypeNode
- * @param selectClauses
- * @return an array of StatusCode
- */
-export function checkSelectClauses(eventTypeNode: UAObjectType, selectClauses: SimpleAttributeOperand[]): StatusCode[] {
-    return selectClauses.map(checkSelectClause.bind(null, eventTypeNode));
-}