node-opcua-address-space 2.167.0 → 2.169.0

package/src/alarms_and_conditions/ua_alarm_condition_impl.ts

@@ -1,23 +1,21 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
-import { isEqual } from "lodash";
-
+import { isDeepStrictEqual as isEqual } from "node:util";
+import type { BaseNode, INamespace, UAEventType, UAVariable } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import { NodeClass } from "node-opcua-data-model";
-import { DataValue } from "node-opcua-data-value";
+import type { DataValue } from "node-opcua-data-value";
+import { make_debugLog } from "node-opcua-debug";
 import { NodeId, sameNodeId } from "node-opcua-nodeid";
 import { StatusCodes } from "node-opcua-status-code";
-import { DataType, VariantOptions } from "node-opcua-variant";
-import { make_debugLog } from "node-opcua-debug";
-import { BaseNode, INamespace, UAEventType, UAVariable } from "node-opcua-address-space-base";
-
+import { DataType, type VariantOptions } from "node-opcua-variant";
+import type { ConditionInfo } from "../../source/interfaces/alarms_and_conditions/condition_info_i";
+import type { InstantiateAlarmConditionOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_alarm_condition_options";
+import type { UAAlarmConditionEx } from "../../source/interfaces/alarms_and_conditions/ua_alarm_condition_ex";
+import type { AddressSpacePrivate } from "../address_space_private";
+import { _clear_timer_if_any, UAShelvedStateMachineExImpl } from "../state_machine/ua_shelving_state_machine_ex";
 import { _install_TwoStateVariable_machinery } from "../state_machine/ua_two_state_variable";
-import { UAShelvedStateMachineExImpl, _clear_timer_if_any } from "../state_machine/ua_shelving_state_machine_ex";
-import { AddressSpacePrivate } from "../address_space_private";
-import { ConditionInfo } from "../../source/interfaces/alarms_and_conditions/condition_info_i";
-import { UAAlarmConditionEx } from "../../source/interfaces/alarms_and_conditions/ua_alarm_condition_ex";
-import { InstantiateAlarmConditionOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_alarm_condition_options";
 
 import { ConditionInfoImpl } from "./condition_info_impl";
 import { UAAcknowledgeableConditionImpl } from "./ua_acknowledgeable_condition_impl";
@@ -35,7 +33,7 @@ export declare interface UAAlarmConditionImpl extends UAAlarmConditionEx, UAAckn
 }
 
 export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl implements UAAlarmConditionEx {
-    public static MaxDuration = Math.pow(2, 31);
+    public static MaxDuration = 2 ** 31;
 
     public static instantiate(
         namespace: INamespace,
@@ -45,12 +43,12 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
     ): UAAlarmConditionImpl {
         const addressSpace = namespace.addressSpace;
         // xx assert(Object.prototype.hasOwnProperty.call(options,"conditionOf")); // must provide a conditionOf
-        assert(Object.prototype.hasOwnProperty.call(options, "inputNode")); // must provide a inputNode
+        assert(Object.hasOwn(options, "inputNode")); // must provide a inputNode
         const alarmConditionType = addressSpace.findEventType(alarmConditionTypeId);
 
         /* c8 ignore next */
         if (!alarmConditionType) {
-            throw new Error(" cannot find Alarm Condition Type for " + alarmConditionTypeId);
+            throw new Error(` cannot find Alarm Condition Type for ${alarmConditionTypeId}`);
         }
 
         const alarmConditionTypeBase = addressSpace.findEventType("AlarmConditionType");
@@ -60,9 +58,9 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
         }
 
         options.optionals = options.optionals || [];
-        if (Object.prototype.hasOwnProperty.call(options, "maxTimeShelved")) {
+        if (Object.hasOwn(options, "maxTimeShelved")) {
             options.optionals.push("MaxTimeShelved");
-            assert(isFinite(options.maxTimeShelved!));
+            assert(Number.isFinite(options.maxTimeShelved!));
         }
 
         assert(alarmConditionTypeBase === alarmConditionType || alarmConditionType.isSubtypeOf(alarmConditionTypeBase));
@@ -142,12 +140,12 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
          *
          */
         if (alarmNode.suppressedState) {
-            alarmNode.suppressedState.on("value_changed", (newDataValue: DataValue) => {
+            alarmNode.suppressedState.on("value_changed", (_newDataValue: DataValue) => {
                 _update_suppressedOrShelved(alarmNode);
             });
         }
         if (alarmNode.shelvingState) {
-            alarmNode.shelvingState.currentState.on("value_changed", (newDataValue: DataValue) => {
+            alarmNode.shelvingState.currentState.on("value_changed", (_newDataValue: DataValue) => {
                 _update_suppressedOrShelved(alarmNode);
             });
         }
@@ -220,7 +218,7 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
     public isSuppressedOrShelved(): boolean {
         let suppressed = false;
         if (this.suppressedState) {
-            suppressed = this.suppressedState.id!.readValue().value.value;
+            suppressed = this.suppressedState.id?.readValue().value.value;
         }
         let shelved = false;
         if (this.shelvingState) {
@@ -241,8 +239,8 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
      * note: duration must be greater than 10ms and lesser than 2**31 ms
      */
     public setMaxTimeShelved(duration: number): void {
-        if (duration < 10 || duration >= Math.pow(2, 31)) {
-            throw new Error(" Invalid maxTimeShelved duration: " + duration + "  must be [10,2**31] ");
+        if (duration < 10 || duration >= 2 ** 31) {
+            throw new Error(` Invalid maxTimeShelved duration: ${duration}  must be [10,2**31] `);
         }
         this.maxTimeShelved?.setValueFromSource({
             dataType: "Duration", // <= Duration is basic Type Double! ( milliseconds)
@@ -280,7 +278,7 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
         return this.addressSpace.findNode(nodeId) as UAVariable | null;
     }
     /**
-     * 
+     *
      */
     public getInputNodeValue(): any | null {
         const node = this.getInputNodeNode();
@@ -297,7 +295,7 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
         this._onInputDataValueChange(dataValue);
     }
 
-    protected _onInputDataValueChange(newValue: DataValue): void {
+    protected _onInputDataValueChange(_newValue: DataValue): void {
         /**  */
     }
 
@@ -397,9 +395,9 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
      */
     public _calculateConditionInfo(
         stateData: string | null,
-        isActive: boolean,
+        _isActive: boolean,
         value: string,
-        oldCondition: ConditionInfo
+        _oldCondition: ConditionInfo
     ): ConditionInfo {
         if (!stateData) {
             return new ConditionInfoImpl({
@@ -410,7 +408,7 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
             });
         } else {
             return new ConditionInfoImpl({
-                message: "Condition is " + value + " and state is " + stateData,
+                message: `Condition is ${value} and state is ${stateData}`,
                 quality: StatusCodes.Good,
                 retain: true,
                 severity: 150
@@ -441,7 +439,7 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
             debugLog("oldConditionInfo", oldConditionInfo);
             debugLog("oldConditionInfo", newConditionInfo);
             throw new Error(
-                "condition values have not change, shall we really raise an event ? alarm " + this.browseName.toString()
+                `condition values have not change, shall we really raise an event ? alarm ${this.browseName.toString()}`
             );
         }
         assert(!isEqual(oldConditionInfo, newConditionInfo), "condition values have not change, shall we really raise an event ?");

package/src/alarms_and_conditions/ua_certificate_expiration_alarm_impl.ts

@@ -1,16 +1,17 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
-import { Certificate, exploreCertificate, makeSHA1Thumbprint } from "node-opcua-crypto/web";
-import { DateTime, getMinOPCUADate, isMinDate, StatusCodes } from "node-opcua-basic-types";
-import { make_warningLog } from "node-opcua-debug";
-import { NodeId } from "node-opcua-nodeid";
-import { DataType, Variant, VariantOptions } from "node-opcua-variant";
-import { INamespace, UAObject, UAProperty, UAVariable } from "node-opcua-address-space-base";
+
+import type { INamespace, UAObject, UAProperty, UAVariable } from "node-opcua-address-space-base";
+import { type DateTime, getMinOPCUADate, isMinDate, StatusCodes } from "node-opcua-basic-types";
 import { ObjectTypeIds } from "node-opcua-constants";
+import { type Certificate, exploreCertificate, makeSHA1Thumbprint } from "node-opcua-crypto/web";
 import { makeAccessLevelExFlag } from "node-opcua-data-model";
-import { UACertificateExpirationAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_certificate_expiration_alarm_ex";
-import { InstantiateOffNormalAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_off_normal_alarm_options";
+import { make_warningLog } from "node-opcua-debug";
+import type { NodeId } from "node-opcua-nodeid";
+import { DataType } from "node-opcua-variant";
+import type { InstantiateOffNormalAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_off_normal_alarm_options";
+import type { UACertificateExpirationAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_certificate_expiration_alarm_ex";
 import { registerNodePromoter } from "../../source/loader/register_node_promoter";
 import { UASystemOffNormalAlarmImpl } from "./ua_system_off_normal_alarm_impl";
 
@@ -18,7 +19,7 @@ const warningLog = make_warningLog("AlarmsAndConditions");
 
 const ellipsis = (arg0: string, arg1 = 4) => {
     arg1 = Math.max(arg1, 4);
-    return arg0.length <= arg1 ? arg0 : arg0.slice(0, arg1 / 2) + "..." + arg0.slice(arg0.length - arg1 / 2);
+    return arg0.length <= arg1 ? arg0 : `${arg0.slice(0, arg1 / 2)}...${arg0.slice(arg0.length - arg1 / 2)}`;
 };
 const d = (d: Date) => {
     return d.toISOString();
@@ -31,24 +32,22 @@ export function instantiateCertificateExpirationAlarm(
     return UACertificateExpirationAlarmImpl.instantiate(namespace, alarmType, options);
 }
 
-interface UACertificateExpirationAlarmImpl {
-    expirationDate: UAProperty<Date, /*z*/ DataType.DateTime>;
-    expirationLimit?: UAProperty<number, /*z*/ DataType.Double>;
-    certificateType: UAProperty<NodeId, /*z*/ DataType.NodeId>;
-    certificate: UAProperty<Buffer, /*z*/ DataType.ByteString>;
-}
-
 // This Simple DataType is a Double that defines an interval of time in milliseconds (fractions can be used to define sub-millisecond values).
 // Negative values are generally invalid but may have special meanings where the Duration is used.
 export const OneDayDuration = 1000 * 60 * 60 * 24;
 export const TwoWeeksDuration = OneDayDuration * 2 * 7;
 
 /**
- * This UACertificateExpirationAlarm (SystemOffNormalAlarmType) is raised by the Server when the Server’s
+ * This UACertificateExpirationAlarm (SystemOffNormalAlarmType) is raised by the Server when the Server's
  * Certificate is within the ExpirationLimit
  * of expiration. This alarm automatically returns to normal when the certificate is updated.
  */
 class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implements UACertificateExpirationAlarmEx {
+    declare expirationDate: UAProperty<Date, DataType.DateTime>;
+    declare expirationLimit: UAProperty<number, DataType.Double> | undefined;
+    declare certificateType: UAProperty<NodeId, DataType.NodeId>;
+    declare certificate: UAProperty<Buffer, DataType.ByteString>;
+
     private timer: NodeJS.Timeout | null = null;
 
     public static instantiate(
@@ -57,7 +56,6 @@ class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implem
         options: InstantiateOffNormalAlarmOptions
         // data?: Record<string, VariantOptions>
     ): UACertificateExpirationAlarmImpl {
-        
         const alarm = UASystemOffNormalAlarmImpl.instantiate(
             namespace,
             alarmType || "CertificateExpirationAlarmType",
@@ -78,7 +76,7 @@ class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implem
         this.raiseNewCondition({
             message,
             quality: StatusCodes.Good,
-            retain: isActive ? true : false,
+            retain: !!isActive,
             severity
         });
     }
@@ -92,7 +90,7 @@ class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implem
             warningLog(`expiry alarm ${this.nodeId.toString()}  has no enabledState property`);
             return;
         }
-        
+
         const expirationDate = this.getExpirationDate();
 
         const now = new Date();
@@ -104,7 +102,7 @@ class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implem
         const certificate = this.getCertificate();
 
         if (!expirationDate || (isMinDate(expirationDate) && !certificate)) {
-            if (!this.currentBranch() || this.currentBranch().getActiveState()) {
+            if (this.currentBranch()?.getActiveState()) {
                 this.updateAlarmState2(true, 255, "certificate is missing");
             }
             return;
@@ -147,11 +145,11 @@ class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implem
         if (!this.expirationLimit) {
             return TwoWeeksDuration;
         }
-        const dataValue = this.expirationLimit!.readValue();
-        if ((dataValue as any).dataType === DataType.Null) {
+        const dataValue = this.expirationLimit.readValue();
+        if ((dataValue.value.dataType as DataType) === DataType.Null) {
             return TwoWeeksDuration;
         }
-        return (this.expirationLimit?.readValue().value.value as number) || 0;
+        return (dataValue.value.value as number) || 0;
     }
 
     public setExpirationLimit(value: number): void {
@@ -163,7 +161,7 @@ class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implem
     }
 
     public getCertificate(): Certificate | null {
-        return (this.getChildByName("Certificate") as UAVariable)?.readValue().value.value as Certificate || null;
+        return ((this.getChildByName("Certificate") as UAVariable)?.readValue().value.value as Certificate) || null;
     }
 
     private _extractAndSetExpiryDate(certificate: Certificate | null): void {
@@ -193,20 +191,28 @@ class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implem
             this.timer = null;
         }
     }
-    
+
     private _startTimer() {
         this.timer = setTimeout(() => {
             if (!this.timer) return;
             this.update();
             this._startTimer();
         }, OneDayDuration / 48);
+        // don't keep the process alive just for this monitoring timer
+        if (this.timer && typeof this.timer.unref === "function") {
+            this.timer.unref();
+        }
     }
 
     _post_initialize() {
+        // ensure _branch0 is created (base UAConditionImpl)
+        if (!this.currentBranch()) {
+            this.post_initialize();
+        }
         if (this.expirationLimit) {
             this.expirationLimit.accessLevel = makeAccessLevelExFlag("CurrentRead | CurrentWrite");
             this.expirationLimit.userAccessLevel = makeAccessLevelExFlag("CurrentRead | CurrentWrite");
-            this.expirationLimit.on("value_changed", (dataValue) => {
+            this.expirationLimit.on("value_changed", (_dataValue) => {
                 // make sure we re-evaluate the certificate
                 const certificate = this.getCertificate();
                 this.setCertificate(certificate);

package/src/alarms_and_conditions/ua_condition_impl.ts

@@ -185,7 +185,7 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
         const statusCode = inner_func(eventId, comment, branch, conditionNode);
 
         // record also who did the call
-        branch.setClientUserId(context.userIdentity || "<unknown client user id>");
+        branch.setClientUserId(context.getUserName());
 
         callback(null, {
             statusCode

package/src/base_node_impl.ts

@@ -2,9 +2,9 @@
  * @module node-opcua-address-space
  */
 
+import { isDeepStrictEqual as isEqual } from "node:util";
 import { EventEmitter } from "node:events";
 import chalk from "chalk";
-import { isEqual } from "lodash";
 
 import type {
     AddReferenceOpts,
@@ -749,15 +749,15 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
         // The type of reference to follow from the current node.
         // The current path cannot be followed any further if the referenceTypeId is not available on the Node instance.
         // If not specified then all References are included and the parameter includeSubtypes is ignored.
-        assert(Object.prototype.hasOwnProperty.call(relativePathElement, "referenceTypeId"));
+        assert(Object.hasOwn(relativePathElement, "referenceTypeId"));
 
         // Indicates whether the inverse Reference should be followed.
         // The inverse reference is followed if this value is TRUE.
-        assert(Object.prototype.hasOwnProperty.call(relativePathElement, "isInverse"));
+        assert(Object.hasOwn(relativePathElement, "isInverse"));
 
         // Indicates whether subtypes of the ReferenceType should be followed.
         // Subtypes are included if this value is TRUE.
-        assert(Object.prototype.hasOwnProperty.call(relativePathElement, "includeSubtypes"));
+        assert(Object.hasOwn(relativePathElement, "includeSubtypes"));
 
         const references = this.allReferences();
 
@@ -772,7 +772,7 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
             ) {
                 return false;
             }
-            assert(Object.prototype.hasOwnProperty.call(reference, "isForward"));
+            assert(Object.hasOwn(reference, "isForward"));
             const referenceType = resolveReferenceType(this.addressSpace, reference);
             const referenceTypeId = referenceType.nodeId;
 
@@ -807,7 +807,7 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
                 // compare QualifiedName
 
                 const key = obj.nodeId.toString();
-                if (!Object.prototype.hasOwnProperty.call(nodeIdsMap, key)) {
+                if (!Object.hasOwn(nodeIdsMap, key)) {
                     nodeIds.push(obj.nodeId);
                     nodeIdsMap[key] = obj;
                 }
@@ -915,9 +915,9 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
     public removeReference(referenceOpts: AddReferenceOpts): void {
         const _private = BaseNode_getPrivate(this);
 
-        assert(Object.prototype.hasOwnProperty.call(referenceOpts, "referenceType"));
+        assert(Object.hasOwn(referenceOpts, "referenceType"));
         // xx isForward is optional : assert(Object.prototype.hasOwnProperty.call(reference,"isForward"));
-        assert(Object.prototype.hasOwnProperty.call(referenceOpts, "nodeId"));
+        assert(Object.hasOwn(referenceOpts, "nodeId"));
 
         const addressSpace = this.addressSpace as AddressSpacePrivate;
 
@@ -1007,7 +1007,7 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
         const childNode = resolveReferenceNode(addressSpace, reference);
 
         const name = lowerFirstLetter(childNode.browseName.name || "");
-        if (Object.prototype.hasOwnProperty.call(reservedNames, name)) {
+        if (Object.hasOwn(reservedNames, name)) {
             // c8 ignore next
             if (doDebug) {
                 // tslint:disable-next-line:no-console
@@ -1016,7 +1016,7 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
             return;
         }
         /* c8 ignore next */
-        if (!Object.prototype.hasOwnProperty.call(this, name)) {
+        if (!Object.hasOwn(this, name)) {
             return;
         }
 
@@ -1031,6 +1031,19 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
         return options.toString();
     }
 
+    public toJSON(): Record<string, string | undefined | null> {
+        return {
+            nodeId: this.nodeId.toString(),
+            nodeClass: NodeClass[this.nodeClass],
+            browseName: this.browseName.toString(),
+            displayName: this.displayName.length ? this.displayName[0].text : ""
+        };
+    }
+
+    public [Symbol.for("nodejs.util.inspect.custom")](): string {
+        return this.toString();
+    }
+
     /**
      * @property isFalseSubStateOf
      * @type {BaseNode|null}
@@ -1285,9 +1298,9 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
     private __addReference(referenceOpts: AddReferenceOpts): UAReference {
         const addressSpace = this.addressSpace as AddressSpacePrivate;
         const _private = BaseNode_getPrivate(this);
-        assert(Object.prototype.hasOwnProperty.call(referenceOpts, "referenceType"));
+        assert(Object.hasOwn(referenceOpts, "referenceType"));
         // xx isForward is optional : assert(Object.prototype.hasOwnProperty.call(reference,"isForward"));
-        assert(Object.prototype.hasOwnProperty.call(referenceOpts, "nodeId"));
+        assert(Object.hasOwn(referenceOpts, "nodeId"));
 
         const reference: UAReference = addressSpace.normalizeReferenceTypes([referenceOpts])[0];
         assert(reference instanceof ReferenceImpl);
@@ -1821,7 +1834,7 @@ function install_components_as_object_properties(parentObj: BaseNode) {
         // assumption: we ignore namespace here .
         const name = lowerFirstLetter(child.browseName.name || "");
 
-        if (Object.prototype.hasOwnProperty.call(reservedNames, name)) {
+        if (Object.hasOwn(reservedNames, name)) {
             // ignore reserved names
             if (doDebug) {
                 debugLog(chalk.bgWhite.red(`Ignoring reserved keyword                                               ${name}`));
@@ -1832,7 +1845,7 @@ function install_components_as_object_properties(parentObj: BaseNode) {
         // ignore reserved names
         doDebug && debugLog(`Installing property ${name}`, " on ", parentObj.browseName.toString());
 
-        const hasProperty = Object.prototype.hasOwnProperty.call(parentObj, name);
+        const hasProperty = Object.hasOwn(parentObj, name);
         if (
             hasProperty &&
             (parentObj as unknown as Record<string, unknown>)[name] !== null &&