node-opcua-address-space 2.170.1 → 2.173.0

package/src/alarms_and_conditions/ua_acknowledgeable_condition_impl.ts

@@ -1,42 +1,49 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
-import { UAAcknowledgeableCondition_Base, UAAcknowledgeableCondition, UACondition } from "node-opcua-nodeset-ua";
+
+import type { INamespace, ISessionContext, ListenerSignature, RaiseEventData, UAEventType } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
-import { LocalizedText, LocalizedTextLike } from "node-opcua-data-model";
-import { NodeId } from "node-opcua-nodeid";
-import { CallbackT, StatusCode, StatusCodes } from "node-opcua-status-code";
-import { DataType, VariantLike, VariantOptions } from "node-opcua-variant";
-import { INamespace, RaiseEventData, ISessionContext, UAEventType, UAMethod } from "node-opcua-address-space-base";
-import { CallMethodResultOptions } from "node-opcua-service-call";
+import { coerceLocalizedText, LocalizedText, type LocalizedTextLike } from "node-opcua-data-model";
 import { make_debugLog } from "node-opcua-debug";
-
-import { AddressSpacePrivate } from "../address_space_private";
+import type { NodeId } from "node-opcua-nodeid";
+import type { UAAcknowledgeableCondition_Base } from "node-opcua-nodeset-ua";
+import type { CallMethodResultOptions } from "node-opcua-service-call";
+import { type CallbackT, type StatusCode, StatusCodes } from "node-opcua-status-code";
+import { DataType, type VariantLike, type VariantOptions } from "node-opcua-variant";
+import type { ConditionSnapshot } from "../../source/interfaces/alarms_and_conditions/condition_snapshot";
+import type { InstantiateAlarmConditionOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_alarm_condition_options";
+import type { UAAcknowledgeableConditionEx } from "../../source/interfaces/alarms_and_conditions/ua_acknowledgeable_condition_ex";
+import type { UAConditionEvents } from "../../source/interfaces/alarms_and_conditions/ua_condition_ex";
+import type { AddressSpacePrivate } from "../address_space_private";
 import { _install_TwoStateVariable_machinery } from "../state_machine/ua_two_state_variable";
-import { UAAcknowledgeableConditionEx } from "../../source/interfaces/alarms_and_conditions/ua_acknowledgeable_condition_ex";
-import { ConditionSnapshot } from "../../source/interfaces/alarms_and_conditions/condition_snapshot";
-import { InstantiateAlarmConditionOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_alarm_condition_options";
 import { ConditionSnapshotImpl } from "./condition_snapshot_impl";
-import {  UAConditionImpl } from "./ua_condition_impl";
+import { type UAConditionImpl, UAConditionImplBase } from "./ua_condition_impl";
 
 const debugLog = make_debugLog(__filename);
-const doDebug = false;;
-export declare interface UAAcknowledgeableConditionImpl extends UAAcknowledgeableConditionEx, UAConditionImpl {
-    on(eventName: string, eventHandler: any): this;
-    once(eventName: string, eventHandler: any): this;
+const doDebug = false;
 
-}
 
-export class UAAcknowledgeableConditionImpl extends UAConditionImpl implements UAAcknowledgeableConditionEx {
+const $ = (a: UAAcknowledgeableConditionImplBase): UAAcknowledgeableConditionEx => a as unknown as UAAcknowledgeableConditionEx;
+
+
+export interface UAAcknowegeableConditionEvents extends UAConditionEvents  {
+    acknowledged: (eventId: Buffer | null, comment: LocalizedText | null, branch: ConditionSnapshot) => void;
+    confirmed: (eventId: Buffer | null, comment: LocalizedText | null, branch: ConditionSnapshot) => void;
+}
+export class UAAcknowledgeableConditionImplBase<
+    T extends UAAcknowegeableConditionEvents & ListenerSignature<T>  = UAAcknowegeableConditionEvents
+> extends UAConditionImplBase<T> {
     /**
      */
+
     public static instantiate(
         namespace: INamespace,
         conditionTypeId: UAEventType | NodeId | string,
         options: InstantiateAlarmConditionOptions,
         data?: Record<string, VariantOptions>
     ): UAAcknowledgeableConditionImpl {
-        const conditionNode = UAConditionImpl.instantiate(
+        const conditionNode = UAConditionImplBase.instantiate(
             namespace,
             conditionTypeId,
             options,
@@ -180,7 +187,7 @@ export class UAAcknowledgeableConditionImpl extends UAConditionImpl implements U
             return statusCode;
         }
 
-        if (this.confirmedState) {
+        if ($(this).confirmedState) {
             // alarm has a confirmed state !
             // we should be waiting for confirmation now
             branch.setConfirmedState(false);
@@ -194,7 +201,7 @@ export class UAAcknowledgeableConditionImpl extends UAConditionImpl implements U
         this.raiseNewBranchState(branch);
 
         this._raiseAuditConditionAcknowledgeEvent(branch);
-
+        
         /**
          * @event acknowledged
          * @param  eventId   {Buffer|null}
@@ -202,7 +209,7 @@ export class UAAcknowledgeableConditionImpl extends UAConditionImpl implements U
          * @param  branch    {ConditionSnapshot}
          * raised when the alarm branch has been acknowledged
          */
-        this.emit("acknowledged", conditionEventId, comment, branch);
+        (this as UAAcknowledgeableConditionImplBase).emit("acknowledged", conditionEventId, coerceLocalizedText(comment), branch);
 
         return StatusCodes.Good;
     }
@@ -233,21 +240,22 @@ export class UAAcknowledgeableConditionImpl extends UAConditionImpl implements U
 
         this.raiseNewBranchState(branch);
 
-        /**
+       /**
          * @event confirmed
          * @param  eventId
          * @param  comment
          * @param  eventId
          * raised when the alarm branch has been confirmed
          */
-        this.emit("confirmed", conditionEventId, comment, branch);
+        (this as UAAcknowledgeableConditionImplBase).emit("confirmed", conditionEventId, coerceLocalizedText(comment), branch);
     }
 
     /**
+     * 
      */
     public autoConfirmBranch(branch: ConditionSnapshot, comment: LocalizedTextLike): void {
         assert(branch instanceof ConditionSnapshotImpl);
-        if (!this.confirmedState) {
+        if (!$(this).confirmedState) {
             // no confirmedState => ignoring
             return;
         }
@@ -260,10 +268,10 @@ export class UAAcknowledgeableConditionImpl extends UAConditionImpl implements U
     }
 
     /**
-     * 
+     *
      */
     public acknowledgeAndAutoConfirmBranch(branch: ConditionSnapshot, comment: string | LocalizedTextLike | LocalizedText): void {
-        comment = LocalizedText.coerce(comment)!;
+        comment = LocalizedText.coerce(comment) as LocalizedText;
         const conditionEventId = branch.getEventId();
         branch.setRetain(false);
         this._acknowledge_branch(conditionEventId, comment, branch, "Server/Acknowledge");
@@ -271,17 +279,21 @@ export class UAAcknowledgeableConditionImpl extends UAConditionImpl implements U
     }
 }
 
+export type UAAcknowledgeableConditionImpl = UAAcknowledgeableConditionImplBase & UAAcknowledgeableConditionEx;
+export const UAAcknowledgeableConditionImpl =
+    UAAcknowledgeableConditionImplBase as unknown as new () => UAAcknowledgeableConditionImpl;
+
 function _acknowledge_method(
     inputArguments: VariantLike[],
     context: ISessionContext,
     callback: CallbackT<CallMethodResultOptions>
 ) {
-    UAConditionImpl.with_condition_method(
+    UAConditionImplBase.with_condition_method(
         inputArguments,
         context,
         callback,
         (conditionEventId: Buffer, comment: LocalizedText, branch: ConditionSnapshot, conditionNode: UAConditionImpl) => {
-            const ackConditionNode = conditionNode as UAAcknowledgeableConditionImpl;
+            const ackConditionNode = conditionNode as unknown as UAAcknowledgeableConditionImplBase;
             // precondition checking
             assert(!conditionEventId || conditionEventId instanceof Buffer, "must have a valid eventId or  null");
             assert(comment instanceof LocalizedText, "expecting a comment as LocalizedText");
@@ -301,7 +313,7 @@ function _acknowledge_method(
  * @private
  */
 function _confirm_method(inputArguments: VariantLike[], context: ISessionContext, callback: CallbackT<CallMethodResultOptions>) {
-    UAConditionImpl.with_condition_method(
+    UAConditionImplBase.with_condition_method(
         inputArguments,
         context,
         callback,
@@ -310,7 +322,7 @@ function _confirm_method(inputArguments: VariantLike[], context: ISessionContext
             assert(branch.getEventId() instanceof Buffer);
             assert(branch.getEventId().toString("hex") === eventId.toString("hex"));
 
-            const ackConditionNode = conditionNode as UAAcknowledgeableConditionImpl;
+            const ackConditionNode = conditionNode as unknown as UAAcknowledgeableConditionImplBase;
             if (branch.getConfirmedState()) {
                 return StatusCodes.BadConditionBranchAlreadyConfirmed;
             }

package/src/alarms_and_conditions/ua_alarm_condition_impl.ts

@@ -14,11 +14,10 @@ import type { ConditionInfo } from "../../source/interfaces/alarms_and_condition
 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 { _clear_timer_if_any, type UAShelvedStateMachineExImpl, UAShelvedStateMachineExImplBase } from "../state_machine/ua_shelving_state_machine_ex";
 import { _install_TwoStateVariable_machinery } from "../state_machine/ua_two_state_variable";
-
 import { ConditionInfoImpl } from "./condition_info_impl";
-import { UAAcknowledgeableConditionImpl } from "./ua_acknowledgeable_condition_impl";
+import { UAAcknowledgeableConditionImpl, UAAcknowledgeableConditionImplBase } from "./ua_acknowledgeable_condition_impl";
 
 const debugLog = make_debugLog(__filename);
 
@@ -28,11 +27,9 @@ function _update_suppressedOrShelved(alarmNode: UAAlarmConditionImpl) {
         value: alarmNode.isSuppressedOrShelved()
     });
 }
-export declare interface UAAlarmConditionImpl extends UAAlarmConditionEx, UAAcknowledgeableConditionImpl {
-    on(eventName: string, eventHandler: any): this;
-}
 
-export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl implements UAAlarmConditionEx {
+const  $ = (a: UAAlarmConditionImplBase): UAAlarmConditionEx =>  a as unknown as UAAlarmConditionEx;
+export class UAAlarmConditionImplBase extends UAAcknowledgeableConditionImplBase {
     public static MaxDuration = 2 ** 31;
 
     public static instantiate(
@@ -60,17 +57,17 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
         options.optionals = options.optionals || [];
         if (Object.hasOwn(options, "maxTimeShelved")) {
             options.optionals.push("MaxTimeShelved");
-            assert(Number.isFinite(options.maxTimeShelved!));
+            assert(Number.isFinite(options.maxTimeShelved));
         }
 
         assert(alarmConditionTypeBase === alarmConditionType || alarmConditionType.isSubtypeOf(alarmConditionTypeBase));
 
-        const alarmNode = UAAcknowledgeableConditionImpl.instantiate(
+        const alarmNode = UAAcknowledgeableConditionImplBase.instantiate(
             namespace,
             alarmConditionTypeId,
             options,
             data
-        ) as UAAlarmConditionImpl;
+        ) as unknown as UAAlarmConditionImpl;
         Object.setPrototypeOf(alarmNode, UAAlarmConditionImpl.prototype);
 
         // ----------------------- Install Alarm specifics
@@ -123,7 +120,7 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
          * @type ShelvingStateMachine
          */
         if (alarmNode.shelvingState) {
-            UAShelvedStateMachineExImpl.promote(alarmNode.shelvingState);
+            UAShelvedStateMachineExImplBase.promote(alarmNode.shelvingState);
         }
 
         // SuppressedOrShelved : Mandatory
@@ -181,9 +178,10 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
         return alarmNode;
     }
 
+
     public dispose(): void {
-        if (this.shelvingState) {
-            _clear_timer_if_any(this.shelvingState as any as UAShelvedStateMachineExImpl);
+        if ($(this).shelvingState) {
+            _clear_timer_if_any($(this).shelvingState as unknown as UAShelvedStateMachineExImpl);
         }
         super.dispose();
     }
@@ -217,12 +215,12 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
 
     public isSuppressedOrShelved(): boolean {
         let suppressed = false;
-        if (this.suppressedState) {
-            suppressed = this.suppressedState.id?.readValue().value.value;
+        if ($(this).suppressedState) {
+            suppressed = $(this).suppressedState?.id?.readValue().value.value || false;
         }
         let shelved = false;
-        if (this.shelvingState) {
-            const shelvedValue = this.shelvingState.currentState.readValue().value.value;
+        if ($(this).shelvingState) {
+            const shelvedValue = $(this).shelvingState?.currentState.readValue().value.value;
             if (shelvedValue && shelvedValue.text !== "Unshelved") {
                 shelved = true;
             }
@@ -231,7 +229,7 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
     }
 
     public getSuppressedOrShelved(): boolean {
-        return this.suppressedOrShelved.readValue().value.value;
+        return $(this).suppressedOrShelved.readValue().value.value;
     }
 
     /**
@@ -242,7 +240,7 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
         if (duration < 10 || duration >= 2 ** 31) {
             throw new Error(` Invalid maxTimeShelved duration: ${duration}  must be [10,2**31] `);
         }
-        this.maxTimeShelved?.setValueFromSource({
+       $(this).maxTimeShelved?.setValueFromSource({
             dataType: "Duration", // <= Duration is basic Type Double! ( milliseconds)
             value: duration
         });
@@ -252,14 +250,14 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
      * note: return a  Duration
      */
     public getMaxTimeShelved(): number {
-        if (!this.maxTimeShelved) {
+        if (!$(this).maxTimeShelved) {
             // if maxTimeShelved is not provided we assume MaxDuration
-            assert(UAAlarmConditionImpl.MaxDuration <= 2147483648, "MaxDuration cannot be greater than 2**31");
-            return UAAlarmConditionImpl.MaxDuration;
+            assert(UAAlarmConditionImplBase.MaxDuration <= 2147483648, "MaxDuration cannot be greater than 2**31");
+            return UAAlarmConditionImplBase.MaxDuration;
         }
-        const dataValue = this.maxTimeShelved.readValue();
-        assert(dataValue.value.dataType === DataType.Double); // Double <= Duration
-        return dataValue.value.value;
+        const dataValue = $(this).maxTimeShelved?.readValue();
+        assert(dataValue?.value.dataType === DataType.Double); // Double <= Duration
+        return dataValue?.value.value || 0;
     }
 
     /**
@@ -273,20 +271,20 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
      *       whose node id is stored in alarm.inputNode
      */
     public getInputNodeNode(): UAVariable | null {
-        const nodeId = this.inputNode.readValue().value.value;
+        const nodeId =$(this).inputNode.readValue().value.value;
         assert(nodeId instanceof NodeId || nodeId === null);
         return this.addressSpace.findNode(nodeId) as UAVariable | null;
     }
     /**
      *
      */
-    public getInputNodeValue(): any | null {
+    public getInputNodeValue(): number | null {
         const node = this.getInputNodeNode();
         if (!node) {
             return null;
         }
         assert(node.nodeClass === NodeClass.Variable);
-        return node.readValue().value.value;
+        return node.readValue().value.value || 0;
     }
 
     public updateState(): void {
@@ -317,18 +315,18 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
          * @property inputNode
          * @type     UAVariable
          */
-        assert(this.inputNode.nodeClass === NodeClass.Variable);
+        assert($(this).inputNode.nodeClass === NodeClass.Variable);
 
         const addressSpace = this.addressSpace as AddressSpacePrivate;
         assert(inputNode, " must provide options.inputNode (NodeId or BaseNode object)");
 
         if (inputNode instanceof NodeId) {
-            this.inputNode.setValueFromSource({
+           $(this).inputNode.setValueFromSource({
                 dataType: DataType.NodeId,
                 value: inputNode as NodeId
             });
         } else {
-            this.inputNode.setValueFromSource({
+           $(this).inputNode.setValueFromSource({
                 dataType: "NodeId",
                 value: (inputNode as BaseNode).nodeId
             });
@@ -338,7 +336,7 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
                 debugLog(" cannot find nodeId ", inputNode);
             } else {
                 assert(_node, "Expecting a valid input node");
-                this.inputNode.setValueFromSource({
+               $(this).inputNode.setValueFromSource({
                     dataType: DataType.NodeId,
                     value: _node.nodeId
                 });
@@ -420,7 +418,7 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
         this.currentBranch().setActiveState(false);
         this.currentBranch().setAckedState(true);
     }
-    public _signalNewCondition(stateName: string | null, isActive?: boolean, value?: string): void {
+    public _signalNewCondition(stateName: string | null, isActive: boolean, value: string): void {
         // xx if(stateName === null) {
         // xx     alarm.currentBranch().setActiveState(false);
         // xx     alarm.currentBranch().setAckedState(true);
@@ -431,7 +429,7 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
         // xx assert(isActive !== alarm.activeState.getValue());
 
         const oldConditionInfo = this.getCurrentConditionInfo();
-        const newConditionInfo = this._calculateConditionInfo(stateName, !!isActive, value!, oldConditionInfo);
+        const newConditionInfo = this._calculateConditionInfo(stateName, isActive, value, oldConditionInfo);
 
         // detect potential internal bugs due to misused of _signalNewCondition
         if (isEqual(oldConditionInfo, newConditionInfo)) {
@@ -469,3 +467,6 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
         }
     }
 }
+
+export type UAAlarmConditionImpl = UAAlarmConditionImplBase & UAAlarmConditionEx;
+export const UAAlarmConditionImpl = UAAlarmConditionImplBase as unknown as new () => UAAlarmConditionImpl;

package/src/alarms_and_conditions/ua_base_event_impl.ts

@@ -1,46 +1,42 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
+
+import type { BaseNode, ListenerSignature } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
-import { NodeId } from "node-opcua-nodeid";
+import type { NodeId } from "node-opcua-nodeid";
 import { DataType, Variant } from "node-opcua-variant";
-import { BaseNode } from "node-opcua-address-space-base";
-import { UABaseEvent_Base, UABaseEvent } from "node-opcua-nodeset-ua";
-
+import type { UABaseEventEvents, UABaseEventEx } from "../../source/interfaces/alarms_and_conditions/ua_base_event_ex";
+import { BaseNodeImpl } from "../base_node_impl";
 import { UAObjectImpl } from "../ua_object_impl";
-import { UABaseEventHelper } from "../../source/interfaces/alarms_and_conditions/ua_condition_ex";
 
-export interface UABaseEventEx extends UABaseEvent_Base, UABaseEventHelper {
-    /** empty interface */
-}
-export declare interface UABaseEventImpl extends UABaseEventEx {
-    /** empty interface */
-}
+export type { UABaseEventEvents, UABaseEventEx } from "../../source/interfaces/alarms_and_conditions/ua_base_event_ex";
 
-/**
- * @internal
- */
-export class UABaseEventImpl extends UAObjectImpl implements UABaseEventEx {
+const $ = (a: UABaseEventImplBase): UABaseEventEx => a as unknown as UABaseEventEx;
+
+export class UABaseEventImplBase<T extends UABaseEventEvents & ListenerSignature<T> = UABaseEventEvents> extends UAObjectImpl<T> {
     /**
      */
     public setSourceName(name: string): void {
         assert(typeof name === "string");
-        this.sourceName.setValueFromSource(
+        $(this).sourceName.setValueFromSource(
             new Variant({
                 dataType: DataType.String,
                 value: name
             })
         );
     }
-
     /**
      */
     public setSourceNode(node: NodeId | BaseNode): void {
-        this.sourceNode.setValueFromSource(
+        $(this).sourceNode.setValueFromSource(
             new Variant({
                 dataType: DataType.NodeId,
-                value: (node as any).nodeId ? (node as any).nodeId : node
+                value: node instanceof BaseNodeImpl ? node.nodeId : node
             })
         );
     }
 }
+
+export type UABaseEventImpl = UABaseEventImplBase & UABaseEventEx;
+export const UABaseEventImpl = UABaseEventImplBase as unknown as new () => UABaseEventImpl;

package/src/alarms_and_conditions/ua_certificate_expiration_alarm_impl.ts

@@ -29,7 +29,7 @@ export function instantiateCertificateExpirationAlarm(
     alarmType: "CertificateExpirationAlarmType",
     options: InstantiateOffNormalAlarmOptions
 ): UACertificateExpirationAlarmEx {
-    return UACertificateExpirationAlarmImpl.instantiate(namespace, alarmType, options);
+    return UACertificateExpirationAlarmImplBase.instantiate(namespace, alarmType, options);
 }
 
 // This Simple DataType is a Double that defines an interval of time in milliseconds (fractions can be used to define sub-millisecond values).
@@ -42,7 +42,7 @@ export const TwoWeeksDuration = OneDayDuration * 2 * 7;
  * Certificate is within the ExpirationLimit
  * of expiration. This alarm automatically returns to normal when the certificate is updated.
  */
-class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implements UACertificateExpirationAlarmEx {
+class UACertificateExpirationAlarmImplBase extends UASystemOffNormalAlarmImpl {
     declare expirationDate: UAProperty<Date, DataType.DateTime>;
     declare expirationLimit: UAProperty<number, DataType.Double> | undefined;
     declare certificateType: UAProperty<NodeId, DataType.NodeId>;
@@ -238,3 +238,7 @@ export function promoteToCertificateExpirationAlarm(node: UAObject): UACertifica
     return _node;
 }
 registerNodePromoter(ObjectTypeIds.CertificateExpirationAlarmType, promoteToCertificateExpirationAlarm, true);
+
+export type UACertificateExpirationAlarmImpl = UACertificateExpirationAlarmImplBase & UACertificateExpirationAlarmEx;
+export const UACertificateExpirationAlarmImpl: new () => UACertificateExpirationAlarmImpl =
+    UACertificateExpirationAlarmImplBase as any;