node-opcua-address-space 2.74.0 → 2.76.1

package/source/interfaces/alarms_and_conditions/condition_snapshot.ts

@@ -1,47 +1,29 @@
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
 import { EventEmitter } from "events";
 import { Variant } from "node-opcua-variant";
-import { IEventData, UAVariable, BaseNode, ISessionContext, UAObject } from "node-opcua-address-space-base";
-import { assert } from "node-opcua-assert";
+import { IEventData, UAVariable, BaseNode } from "node-opcua-address-space-base";
 import { UInt16 } from "node-opcua-basic-types";
-import { coerceLocalizedText, LocalizedText, LocalizedTextLike, NodeClass } from "node-opcua-data-model";
-import { DataValue } from "node-opcua-data-value";
-import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
-import { NodeId, sameNodeId } from "node-opcua-nodeid";
-import { UAAcknowledgeableCondition } from "node-opcua-nodeset-ua";
-import { StatusCode, StatusCodes } from "node-opcua-status-code";
-import { SimpleAttributeOperand, TimeZoneDataType } from "node-opcua-types";
-import * as utils from "node-opcua-utils";
+import { LocalizedText, LocalizedTextLike } from "node-opcua-data-model";
+import { NodeId } from "node-opcua-nodeid";
+import { StatusCode } from "node-opcua-status-code";
+import { TimeZoneDataType } from "node-opcua-types";
 import { UtcTime } from "../state_machine/ua_state_machine_type";
 
 export interface ConditionSnapshot {
     on(eventName: "value_changed", eventHandler: (node: UAVariable, variant: Variant) => void): this;
 }
-/**
- * @module node-opcua-address-space.AlarmsAndConditions
- */
 
-function normalizeName(str: string): string {
-    return str.split(".").map(utils.lowerFirstLetter).join(".");
-}
 
 export interface ConditionSnapshot extends EventEmitter {
     // static normalizeName = normalizeName;
 
     condition: BaseNode;
-    eventData: IEventData| null;
-    branchId: NodeId| null;
-
-    /**
-     * @method resolveSelectClause
-     * @param selectClause {SelectClause}
-     */
-    resolveSelectClause(selectClause: SimpleAttributeOperand): NodeId | null;
-
-    /**
-     *
-     */
-    readValue(sessionContext: ISessionContext, nodeId: NodeId, selectClause: SimpleAttributeOperand): Variant;
+    eventData: IEventData | null;
+    branchId: NodeId | null;
 
+   
     /**
      * @method getBrandId
      * @return {NodeId}
@@ -293,5 +275,5 @@ export interface ConditionSnapshot extends EventEmitter {
     /**
      * @private
      */
-    _constructEventData(): IEventData 
+    _constructEventData(): IEventData;
 }

package/source/interfaces/alarms_and_conditions/deviation_stuff.ts

@@ -1,16 +1,18 @@
 import { UAVariableT, UAVariable, IAddressSpace } from "node-opcua-address-space-base";
 import { DataType } from "node-opcua-basic-types";
 import { DataValue } from "node-opcua-data-value";
-import { NodeId } from "node-opcua-nodeid";
+import { SetPointSupport } from "./install_setpoint_options";
 
-export interface DeviationStuff {
-    setpointNode: UAVariableT<NodeId, DataType.NodeId>;
-    setpointNodeNode: UAVariable;
+export interface DeviationStuff extends SetPointSupport {
+    
+    
     _onSetpointDataValueChange(dataValue: DataValue): void;
     _setStateBasedOnInputValue(value: any): void;
-    getSetpointNodeNode(): UAVariable;
+    
+    getSetpointNodeNode(): UAVariableT<number, DataType.Double> | UAVariableT<number, DataType.Float> | undefined ;
+
     getInputNodeValue(): any;
     getSetpointValue(): number | null;
 
     readonly addressSpace: IAddressSpace;
-}
+}

package/source/interfaces/alarms_and_conditions/install_setpoint_options.ts

@@ -3,5 +3,14 @@ import { DataType } from "node-opcua-basic-types";
 import { NodeId } from "node-opcua-nodeid";
 
 export interface InstallSetPointOptions {
+    
+    // the set point used in the deviation calculation. 
+    // In cases where the Alarm is generated by an underlying system and if the Variable is not in the AddressSpace
+    // a NULL NodeId shall be provided.
+    setpointNode?: UAVariableT<number, DataType.Double> | UAVariableT<number, DataType.Float> | null;
+}
+
+export interface SetPointSupport {
+    setpointNodeNode?: UAVariableT<number, DataType.Double> | UAVariableT<number, DataType.Float>;
     setpointNode: UAVariableT<NodeId, DataType.NodeId>;
 }

package/source/interfaces/alarms_and_conditions/instantiate_exclusive_deviation_alarm_options.ts

@@ -0,0 +1,4 @@
+import { InstallSetPointOptions } from "./install_setpoint_options";
+import { InstantiateLimitAlarmOptions } from "./instantiate_limit_alarm_options";
+
+export interface InstantiateExclusiveDeviationAlarmOptions extends InstantiateLimitAlarmOptions, InstallSetPointOptions {}

package/source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options.ts

@@ -2,9 +2,9 @@ import { UAVariable } from "node-opcua-address-space-base";
 import { InstantiateAlarmConditionOptions } from "./instantiate_alarm_condition_options";
 
 export interface InstantiateLimitAlarmOptions extends InstantiateAlarmConditionOptions {
-    highHighLimit: number;
+    highHighLimit?: number;
     highLimit: number;
     lowLimit: number;
-    lowLowLimit: number;
+    lowLowLimit?: number;
     inputNode: UAVariable;
 }

package/source/interfaces/alarms_and_conditions/instantiate_non_exclusive_deviation_alarm_options.ts

@@ -0,0 +1,4 @@
+import { InstallSetPointOptions } from "./install_setpoint_options";
+import { InstantiateLimitAlarmOptions } from "./instantiate_limit_alarm_options";
+
+export interface InstantiateNonExclusiveDeviationAlarmOptions extends InstantiateLimitAlarmOptions, InstallSetPointOptions {}

package/source/interfaces/alarms_and_conditions/instantiate_non_exclusive_limit_alarm_options.ts

@@ -0,0 +1,4 @@
+import { InstallSetPointOptions } from "./install_setpoint_options";
+import { InstantiateLimitAlarmOptions } from "./instantiate_limit_alarm_options";
+
+export interface InstantiateNonExclusiveLimitAlarmOptions extends InstantiateLimitAlarmOptions, InstallSetPointOptions {}

package/source/interfaces/alarms_and_conditions/instantiate_off_normal_alarm_options.ts

@@ -1,6 +1,21 @@
+import { UAVariable } from "node-opcua-address-space-base";
 import { NodeIdLike } from "node-opcua-nodeid";
 import { InstantiateAlarmConditionOptions } from "./instantiate_alarm_condition_options";
 
 export interface InstantiateOffNormalAlarmOptions extends InstantiateAlarmConditionOptions {
-    normalState: NodeIdLike;
+    /**
+     * 
+     * https://reference.opcfoundation.org/v105/Core/docs/Part9/5.8.23/#5.8.23.2
+     * 
+     * The NormalState Property is a Property that points to a Variable which has a value that corresponds 
+     * to one of the possible values of the Variable pointed to by the InputNode Property where the NormalState 
+     * Property Variable value is the value that is considered to be the normal state of the Variable
+     * pointed to by the InputNode Property. 
+     * 
+     * When the value of the Variable referenced by the InputNode Property is not equal to the value of 
+     * the NormalState Property the Alarm is Active. If this Variable is not in the AddressSpace,
+     * a NULL NodeId shall be provided.
+     * 
+     */
+    normalState?: NodeIdLike | UAVariable | null;
 }

package/source/interfaces/alarms_and_conditions/ua_certificate_expiration_alarm_ex.ts

@@ -28,4 +28,9 @@ export interface UACertificateExpirationAlarmEx
     setExpirationLimit(value: number): void;
     setCertificate(certificate: Certificate | null): void;
     getCertificate(): Certificate | null;
+
+    /**
+     * update the    status of the alarm
+     */
+    update(): void;
 }

package/source/interfaces/alarms_and_conditions/ua_exclusive_deviation_alarm_ex.ts

@@ -15,6 +15,7 @@ export interface UAExclusiveDeviationAlarmEx
             | "shelvingState"
             | "silenceState"
             | "suppressedState"
+            | "setpointNode"
         >,
         UAExclusiveLimitAlarmEx,
         DeviationStuff {}

package/source/interfaces/alarms_and_conditions/ua_non_exclusive_deviation_alarm_ex.ts

@@ -26,6 +26,5 @@ export interface UANonExclusiveDeviationAlarmEx
         >,
         UANonExclusiveLimitAlarmEx,
         DeviationStuff {
-    setpointNode: UAVariableT<NodeId, DataType.NodeId>;
-    setpointNodeNode: UAVariable;
+    setpointNodeNode: UAVariableT<number, DataType.Double> | UAVariableT<number, DataType.Float>;
 }

package/source/loader/namespace_post_step.ts

@@ -1,24 +1,47 @@
 import { NodeClass } from "node-opcua-data-model";
 import { make_debugLog, checkDebugFlag } from "node-opcua-debug";
 
-import { UAObject, UAVariable, IAddressSpace, INamespace } from "node-opcua-address-space-base";
+import { UAObject, UAVariable, IAddressSpace, INamespace, UAVariableType } from "node-opcua-address-space-base";
 import { NamespacePrivate } from "../../src/namespace_private";
 
 const debugLog = make_debugLog(__filename);
 const doDebug = checkDebugFlag(__filename);
 
-export const g_promotableObject: { [key: string]: (node: any) => any } = {};
+export type Promoter = ((node: UAVariable) => UAVariable) | ((node: UAObject) => UAObject);
+
+export const g_promotableObject: {
+    [key: string]: {
+        promoter: Promoter;
+        onInstanceOnly: boolean;
+    };
+} = {};
+
+function parentIsObjectOrVariableType(node: UAVariable | UAObject): boolean {
+    if (node.parent && (node.parent.nodeClass === NodeClass.VariableType || node.parent?.nodeClass === NodeClass.ObjectType)) {
+        return true;
+    }
+    if (!node.parent) {
+        return false;
+    }
+    return parentIsObjectOrVariableType(node.parent as UAVariable | UAObject);
+}
 
 export async function promoteObjectAndVariablesInNamespace(namespace: INamespace): Promise<void> {
     const namespaceP = namespace as NamespacePrivate;
     for (const a of namespaceP.nodeIterator()) {
         if (a.nodeClass === NodeClass.Object || a.nodeClass === NodeClass.Variable) {
+            // skip object & variable that belong to a ObjectType or VariableType
             const aa = a as UAObject | UAVariable;
+
             if (aa.typeDefinition) {
                 const promoter = g_promotableObject[aa.typeDefinition.toString()];
                 if (promoter) {
+                    if (promoter.onInstanceOnly && parentIsObjectOrVariableType(aa)) {
+                        continue;
+                    }
                     const before = a.constructor.name;
-                    promoter(a as UAObject | UAVariable);
+
+                    promoter.promoter(a as any);
                     const after = a.constructor.name;
                     if (doDebug) {
                         debugLog(`promoting ${a.browseName.toString()} from ${before} to ${after}`);

package/source/loader/register_node_promoter.ts

@@ -1,11 +1,12 @@
 import { NodeIdLike, resolveNodeId } from "node-opcua-nodeid";
 import { UAObject, UAVariable } from "node-opcua-address-space-base";
 
-import { g_promotableObject } from "./namespace_post_step";
+import { g_promotableObject, Promoter } from "./namespace_post_step";
 
 export function registerNodePromoter(
-    nodeId: NodeIdLike,
-    promoter: ((node: UAVariable) => void) | ((node: UAObject) => void)
+    standardNodeId: number,
+    promoter: Promoter,
+    applyOnTypes = false
 ): void {
-    g_promotableObject[resolveNodeId(nodeId).toString()] = promoter;
+    g_promotableObject[resolveNodeId(standardNodeId).toString()] = { promoter, onInstanceOnly: applyOnTypes };
 }

package/source/namespace_alarm_and_condition.ts

@@ -1,14 +1,15 @@
-import { UAEventType } from "node-opcua-address-space-base";
 import { NodeId } from "node-opcua-nodeid";
-import { 
-    UAOffNormalAlarmEx 
-} from "../src/alarms_and_conditions/ua_off_normal_alarm_impl";
-import { 
-    UAAcknowledgeableConditionEx 
-} from "./interfaces/alarms_and_conditions/ua_acknowledgeable_condition_ex";
-import {
-    UAAlarmConditionEx,
-} from "./interfaces/alarms_and_conditions/ua_alarm_condition_ex";
+import { UAEventType } from "node-opcua-address-space-base";
+import { VariantOptions } from "node-opcua-variant";
+
+import { UAOffNormalAlarmEx } from "../src/alarms_and_conditions/ua_off_normal_alarm_impl";
+import { InstantiateAlarmConditionOptions } from "./interfaces/alarms_and_conditions/instantiate_alarm_condition_options";
+import { InstantiateExclusiveLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_exclusive_limit_alarm_options";
+import { InstantiateLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
+import { InstantiateNonExclusiveDeviationAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_non_exclusive_deviation_alarm_options";
+import { InstantiateOffNormalAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_off_normal_alarm_options";
+import { UAAcknowledgeableConditionEx } from "./interfaces/alarms_and_conditions/ua_acknowledgeable_condition_ex";
+import { UAAlarmConditionEx } from "./interfaces/alarms_and_conditions/ua_alarm_condition_ex";
 import { UAConditionEx } from "./interfaces/alarms_and_conditions/ua_condition_ex";
 import { UADiscreteAlarmEx } from "./interfaces/alarms_and_conditions/ua_discrete_alarm_ex";
 import { UAExclusiveDeviationAlarmEx } from "./interfaces/alarms_and_conditions/ua_exclusive_deviation_alarm_ex";
@@ -16,38 +17,62 @@ import { UAExclusiveLimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_e
 import { UALimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_limit_alarm_ex";
 import { UANonExclusiveDeviationAlarmEx } from "./interfaces/alarms_and_conditions/ua_non_exclusive_deviation_alarm_ex";
 import { UANonExclusiveLimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_non_exclusive_limit_alarm_ex";
+import { InstantiateNonExclusiveLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_non_exclusive_limit_alarm_options";
+import { InstantiateExclusiveDeviationAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_exclusive_deviation_alarm_options";
 
 export interface INamespaceAlarmAndCondition {
     // --- Alarms & Conditions -------------------------------------------------
-    instantiateCondition(conditionTypeId: UAEventType | NodeId | string, options: any, data?: any): UAConditionEx;
+    instantiateCondition(
+        conditionTypeId: UAEventType | NodeId | string,
+        options: any,
+        data?: Record<string, VariantOptions>
+    ): UAConditionEx;
 
     instantiateAcknowledgeableCondition(
         conditionTypeId: UAEventType | NodeId | string,
-        options: any,
-        data?: any
+        options: InstantiateAlarmConditionOptions,
+        data?: Record<string, VariantOptions>
     ): UAAcknowledgeableConditionEx;
 
-    instantiateAlarmCondition(alarmConditionTypeId: UAEventType | NodeId | string, options: any, data?: any): UAAlarmConditionEx;
+    instantiateAlarmCondition(
+        alarmConditionTypeId: UAEventType | NodeId | string,
+        options: InstantiateAlarmConditionOptions,
+        data?: Record<string, VariantOptions>
+    ): UAAlarmConditionEx;
 
-    instantiateLimitAlarm(limitAlarmTypeId: UAEventType | NodeId | string, options: any, data?: any): UALimitAlarmEx;
+    instantiateLimitAlarm(
+        limitAlarmTypeId: UAEventType | NodeId | string,
+        options: InstantiateLimitAlarmOptions,
+        data?: Record<string, VariantOptions>
+    ): UALimitAlarmEx;
 
     instantiateExclusiveLimitAlarm(
         exclusiveLimitAlarmTypeId: UAEventType | NodeId | string,
-        options: any,
-        data?: any
+        options: InstantiateExclusiveLimitAlarmOptions,
+        data?: Record<string, VariantOptions>
     ): UAExclusiveLimitAlarmEx;
 
-    instantiateExclusiveDeviationAlarm(options: any, data?: any): UAExclusiveDeviationAlarmEx;
+    instantiateExclusiveDeviationAlarm(
+        options: InstantiateExclusiveDeviationAlarmOptions,
+        data?: Record<string, VariantOptions>
+    ): UAExclusiveDeviationAlarmEx;
 
     instantiateNonExclusiveLimitAlarm(
         nonExclusiveLimitAlarmTypeId: UAEventType | NodeId | string,
-        options: any,
-        data?: any
+        options: InstantiateNonExclusiveLimitAlarmOptions,
+        data?: Record<string, VariantOptions>
     ): UANonExclusiveLimitAlarmEx;
 
-    instantiateNonExclusiveDeviationAlarm(options: any, data?: any): UANonExclusiveDeviationAlarmEx;
+    instantiateNonExclusiveDeviationAlarm(
+        options: InstantiateNonExclusiveDeviationAlarmOptions,
+        data?: Record<string, VariantOptions>
+    ): UANonExclusiveDeviationAlarmEx;
 
-    instantiateDiscreteAlarm(discreteAlarmType: UAEventType | NodeId | string, options: any, data?: any): UADiscreteAlarmEx;
+    instantiateDiscreteAlarm(
+        discreteAlarmType: UAEventType | NodeId | string,
+        options: InstantiateAlarmConditionOptions,
+        data?: Record<string, VariantOptions>
+    ): UADiscreteAlarmEx;
 
-    instantiateOffNormalAlarm(options: any, data?: any): UAOffNormalAlarmEx;
+    instantiateOffNormalAlarm(options: InstantiateOffNormalAlarmOptions, data?: Record<string, VariantOptions>): UAOffNormalAlarmEx;
 }

package/src/address_space.ts

@@ -740,20 +740,25 @@ export class AddressSpace implements AddressSpacePrivate {
             throw new Error("BaseObjectType must be defined in the address space");
         }
 
-        const visitedProperties: { [key: string]: any } = {};
-
-        function _process_var(self: BaseNode, prefix: string, node: BaseNode) {
-            const lowerName = prefix + lowerFirstLetter(node.browseName!.name!);
-            // istanbul ignore next
-            // xx if (doDebug) { debugLog("      " + lowerName.toString()); }
-
-            visitedProperties[lowerName] = node;
-            if (Object.prototype.hasOwnProperty.call(data, lowerName)) {
-                eventData.setValue(lowerName, node, data[lowerName] as VariantOptions);
-                // xx eventData[lowerName] = _coerceVariant(data[lowerName]);
+        const hasProperty = (data: any, propertyName: string): boolean => Object.prototype.hasOwnProperty.call(data, propertyName);
+
+        const visitedProperties: { [key: string]: number } = {};
+        const alreadyVisited=(key: string) => Object.prototype.hasOwnProperty.call(visitedProperties, key);
+        const markAsVisited=(key: string) => visitedProperties[key] = 1;
+
+        function _process_var(self: BaseNode, prefixLower: string, prefixStandard: string, node: BaseNode) {
+            const lowerName = prefixLower + lowerFirstLetter(node.browseName!.name!);
+            const fullBrowsePath = prefixStandard + node.browseName.toString();
+            if(alreadyVisited(lowerName)) {
+                return;
+            } 
+            markAsVisited(lowerName);
+
+            if (hasProperty(data, lowerName)) {
+                eventData._createValue(fullBrowsePath, node, data[lowerName] as VariantOptions);
             } else {
                 // add a property , but with a null variant
-                eventData.setValue(lowerName, node, { dataType: DataType.Null });
+                eventData._createValue(fullBrowsePath, node, { dataType: DataType.Null });
 
                 if (doDebug) {
                     if (node.modellingRule === "Mandatory") {
@@ -779,13 +784,13 @@ export class AddressSpace implements AddressSpacePrivate {
         }
 
         // verify that all elements of data are valid
-        function verify_data_is_valid(data1: { [key: string]: any }) {
+        function verify_data_is_valid(data1: Record<string, unknown>) {
             Object.keys(data1).map((k: string) => {
                 if (k === "$eventDataSource") {
                     return;
                 }
                 /* istanbul ignore next */
-                if (!Object.prototype.hasOwnProperty.call(visitedProperties, k)) {
+                if (!alreadyVisited(k)) {
                     throw new Error(
                         " cannot find property '" +
                             k +
@@ -839,7 +844,7 @@ export class AddressSpace implements AddressSpacePrivate {
                     continue;
                 }
 
-                _process_var(self, "", node);
+                _process_var(self, "", "", node);
 
                 // also store value in index
                 // xx eventData.__nodes[node.nodeId.toString()] = eventData[lowerName];
@@ -847,10 +852,11 @@ export class AddressSpace implements AddressSpacePrivate {
                 const children2 = node.getAggregates();
                 if (children2.length > 0) {
                     const lowerName = lowerFirstLetter(node.browseName.name!);
+                    const standardName = node.browseName.toString();
                     //  console.log(" Children to visit = ",lowerName,
                     //  children.map(function(a){ return a.browseName.toString();}).join(" "));
                     for (const child2 of children2) {
-                        _process_var(self, lowerName + ".", child2);
+                        _process_var(self, lowerName + ".", standardName + ".", child2);
                     }
                 }
             }

package/src/alarms_and_conditions/condition.ts

@@ -21,7 +21,7 @@ export function _setAckedState(
     if (ackedState && requestedAckedState) {
         return StatusCodes.BadConditionBranchAlreadyAcked;
     }
-    self._set_twoStateVariable("ackedState", requestedAckedState);
+    self._set_twoStateVariable("AckedState", requestedAckedState);
     return StatusCodes.Good;
 }