node-opcua-address-space 2.170.1 → 2.172.0

package/source/loader/parsers/qualified_name_parser.ts

@@ -1,10 +1,9 @@
-import { QualifiedNameOptions, QualifiedName, coerceQualifiedName } from "node-opcua-data-model";
-import { resolveNodeId, NodeId, NodeIdLike } from "node-opcua-nodeid";
-import { ReaderStateParserLike } from "node-opcua-xml2json";
-
+import { coerceQualifiedName, type QualifiedName, type QualifiedNameOptions } from "node-opcua-data-model";
+import { type NodeId, resolveNodeId } from "node-opcua-nodeid";
+import type { ReaderStateParserLike } from "node-opcua-xml2json";
 
 interface QualifiedNameParserL1 extends ReaderStateParserLike {
-    value: QualifiedName| null;
+    value: QualifiedName | null;
     qualifiedName: QualifiedNameOptions;
 }
 
@@ -13,7 +12,7 @@ export interface QualifiedNameParserL2 {
     text: string;
 }
 
-export const makeQualifiedNameParser = (_translateNodeId: (nodeId: string)=> NodeId) => ({
+export const makeQualifiedNameParser = (_translateNodeId: (nodeId: string) => NodeId) => ({
     QualifiedName: {
         init(this: QualifiedNameParserL1) {
             this.qualifiedName = {
@@ -37,7 +36,7 @@ export const makeQualifiedNameParser = (_translateNodeId: (nodeId: string)=> Nod
             }
         },
         finish(this: QualifiedNameParserL1) {
-            this.value = coerceQualifiedName(this.qualifiedName)
+            this.value = coerceQualifiedName(this.qualifiedName);
         }
     }
 });

package/source/loader/parsers/variant_parser.ts

@@ -1,21 +1,26 @@
-import { coerceBoolean, coerceInt64, coerceUInt64, DataType, Int64, isValidGuid, UInt64 } from "node-opcua-basic-types";
-import { IAddressSpace, UAVariable, UAVariableType } from "node-opcua-address-space-base";
-import { coerceLocalizedText, coerceQualifiedName, LocalizedTextOptions, NodeClass, QualifiedNameOptions } from "node-opcua-data-model";
-import { ExtensionObject } from "node-opcua-extension-object";
-import { resolveNodeId, NodeIdLike, NodeId } from "node-opcua-nodeid";
-import { VariantArrayType, VariantOptions } from "node-opcua-variant";
+import type { IAddressSpace, UAVariable, UAVariableType } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
-import { ParserLike, ReaderStateParserLike, XmlAttributes } from "node-opcua-xml2json";
+import { coerceBoolean, coerceInt64, coerceUInt64, DataType, type Int64, isValidGuid, type UInt64 } from "node-opcua-basic-types";
+import {
+    coerceLocalizedText,
+    coerceQualifiedName,
+    type LocalizedTextOptions,
+    NodeClass,
+    type QualifiedNameOptions
+} from "node-opcua-data-model";
 import { make_debugLog } from "node-opcua-debug";
-
-import { localizedText_parser } from "./localized_text_parser";
-import { makeQualifiedNameParser } from "./qualified_name_parser";
+import type { ExtensionObject } from "node-opcua-extension-object";
+import { type NodeId, type NodeIdLike, resolveNodeId } from "node-opcua-nodeid";
+import { VariantArrayType, type VariantOptions } from "node-opcua-variant";
+import type { ParserLike, ReaderStateParserLike, XmlAttributes } from "node-opcua-xml2json";
 import {
     createXMLExtensionObjectDecodingTask,
     makeExtensionObjectInnerParser,
-    makeExtensionObjectParser,
+    makeExtensionObjectParser
 } from "./extension_object_parser";
+import { localizedText_parser } from "./localized_text_parser";
 import { makeNodeIdParser } from "./nodeid_parser";
+import { makeQualifiedNameParser } from "./qualified_name_parser";
 
 const debugLog = make_debugLog(__dirname);
 
@@ -28,20 +33,17 @@ type IBasicReaderStateParserLike<T> = ReaderStateParserLike & {
 function BasicType_parser<T>(dataType: string, parseFunc: (this: { value: T | undefined }, text: string) => any): ParserLike {
     const _parser: Record<string, ReaderStateParserLike> = {};
     const a = {
-        init(this: IBasicReaderStateParserLike<T>, name: string, attrs: XmlAttributes, parent: any, endElement: any) {
+        init(this: IBasicReaderStateParserLike<T>, _name: string, _attrs: XmlAttributes, _parent: any, _endElement: any) {
             this.value = undefined;
         },
         finish(this: IBasicReaderStateParserLike<T>) {
             this.value = parseFunc.call(this, this.text);
         }
-    }
+    };
     _parser[dataType] = a as ReaderStateParserLike;
     return _parser as ParserLike;
 }
 
-
-
-
 function ListOf<T>(_setValue: (data: VariantOptions) => void, dataType: string, parseFunc: any) {
     return {
         init(this: ListOfTParser<T>) {
@@ -57,32 +59,27 @@ function ListOf<T>(_setValue: (data: VariantOptions) => void, dataType: string,
                 value: this.listData
             });
         },
-        endElement(this: ListOfTParser<T>, element: string) {
+        endElement(this: ListOfTParser<T>, _element: string) {
             this.listData.push(this.parser[dataType].value);
         }
     };
 }
 
-
 interface Parser {
     parent: Parser | any;
 }
 
-
-
-function installExtensionObjectListInitializationPostTask(
+function _installExtensionObjectListInitializationPostTask(
     postTasks2_AssignedExtensionObjectToDataValue: Task[],
-    element: ListOfExtensionObjectParser) {
-
-
-
+    element: ListOfExtensionObjectParser
+) {
     let listExtensionObject = element.listExtensionObject;
     let nodeId = element.parent.parent.obj.nodeId;
     assert(nodeId, "expecting a nodeid");
     const task = async (addressSpace2: IAddressSpace) => {
         const node = addressSpace2.findNode(nodeId)!;
         if (!node) {
-            debugLog("Cannot find node with nodeId " + nodeId + ". may be the node was marked as deprecated");
+            debugLog(`Cannot find node with nodeId ${nodeId}. may be the node was marked as deprecated`);
         } else if (node.nodeClass === NodeClass.Variable) {
             const v = node as UAVariable;
             assert(v.getBasicDataType() === DataType.ExtensionObject, "expecting an extension object");
@@ -99,9 +96,6 @@ function installExtensionObjectListInitializationPostTask(
     postTasks2_AssignedExtensionObjectToDataValue.push(task);
 }
 
-
-
-
 export interface ListOfTParser<T> extends Parser {
     listData: T[];
     parent: Parser;
@@ -123,9 +117,6 @@ function parser2<T>(_setValue: (data: VariantOptions) => void, type: string, p:
 const parseUInt64 = (str: string): UInt64 => coerceUInt64(str);
 const parseInt64 = (str: string): Int64 => coerceInt64(str);
 
-
-
-
 export interface ListOfExtensionObjectParser extends ListOfTParser<ExtensionObject> {
     isDeferred: boolean;
     listExtensionObject: (ExtensionObject | null)[];
@@ -135,19 +126,16 @@ export interface ListOfExtensionObjectParser extends ListOfTParser<ExtensionObje
     };
 }
 
-
-
 export function makeVariantReader<T extends ReaderStateParserLike>(
     setValue: (self: T, data: VariantOptions) => void,
     setDeferredValue: (self: T, data: VariantOptions, deferedTask: () => ExtensionObject | ExtensionObject[] | null) => void,
     postExtensionObjectDecoding: (task: (addressSpace: IAddressSpace) => Promise<void>) => void,
-    translateNodeId: (nodeId: string) => NodeId,
+    translateNodeId: (nodeId: string) => NodeId
 ): ReaderStateParserLike {
-
     let self: T;
     const setValue2 = (data: VariantOptions) => {
         setValue(self, data);
-    }
+    };
     const reader = {
         init(this: ReaderStateParserLike) {
             /* empty */
@@ -159,7 +147,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
                 finish(this: any) {
                     setValue2({
                         dataType: DataType.QualifiedName,
-                        value: coerceQualifiedName({...this.qualifiedName})
+                        value: coerceQualifiedName({ ...this.qualifiedName })
                     });
                 }
             },
@@ -168,7 +156,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
                 finish(this: any) {
                     setValue2({
                         dataType: DataType.LocalizedText,
-                        value: coerceLocalizedText({...this.localizedText})
+                        value: coerceLocalizedText({ ...this.localizedText })
                     });
                 }
             },
@@ -272,8 +260,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
                         value: extensionObject
                     });
                 },
-                (xmlEncodingNodeId: NodeId, bodyXML: string, data) => {
-
+                (xmlEncodingNodeId: NodeId, bodyXML: string, _data) => {
                     let _capturedExtensionObject: ExtensionObject | ExtensionObject[] | null = null;
                     // extension object creation will be postponed
                     const task0 = createXMLExtensionObjectDecodingTask(
@@ -282,13 +269,18 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
                         bodyXML,
                         (extensionObject: ExtensionObject) => {
                             _capturedExtensionObject = extensionObject;
-                        });
+                        }
+                    );
                     postExtensionObjectDecoding(task0);
-                    setDeferredValue(self, {
-                        dataType: DataType.ExtensionObject,
-                        arrayType: VariantArrayType.Scalar,
-                        value: null
-                    }, () => _capturedExtensionObject);
+                    setDeferredValue(
+                        self,
+                        {
+                            dataType: DataType.ExtensionObject,
+                            arrayType: VariantArrayType.Scalar,
+                            value: null
+                        },
+                        () => _capturedExtensionObject
+                    );
                 }
             ),
 
@@ -312,14 +304,15 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
                         self.listExtensionObject.push(null);
                         const index = self.listExtensionObject.length - 1;
                         assert(index >= 0);
-                        let listExtensionObject = self.listExtensionObject;
+                        const listExtensionObject = self.listExtensionObject;
                         const task0 = createXMLExtensionObjectDecodingTask(
                             translateNodeId,
                             xmlEncodingNodeId,
                             bodyXML,
                             (extensionObject: ExtensionObject) => {
                                 listExtensionObject[index] = extensionObject;
-                            });
+                            }
+                        );
                         postExtensionObjectDecoding(task0);
                     }
                 ),
@@ -333,17 +326,18 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
                     } else {
                         // postpone the creation of the extension object
                         const listExtensionObject: ExtensionObject[] = this.listExtensionObject as any;
-                        setDeferredValue(self,
+                        setDeferredValue(
+                            self,
                             {
                                 arrayType: VariantArrayType.Array,
                                 dataType: DataType.ExtensionObject,
                                 value: null
                             },
-                            () => listExtensionObject,
+                            () => listExtensionObject
                         );
                         this.listExtensionObject = [];
                     }
-                },
+                }
             },
 
             ListOfLocalizedText: {
@@ -385,7 +379,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
                     this.listData = [];
                 },
                 parser: makeNodeIdParser(translateNodeId),
-                endElement(this: ListOfTParser<NodeIdLike>, elementName: string) {
+                endElement(this: ListOfTParser<NodeIdLike>, _elementName: string) {
                     this.listData.push(this.parser.NodeId.nodeId);
                 },
                 finish(this: ListOfTParser<NodeIdLike>) {
@@ -419,8 +413,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
 
             ListOfString: ListOf<string>(setValue2, "String", (value: string) => value),
 
-            ListOfXmlElement: ListOf<string>(setValue2, "XmlElement", (value: string) => value),
-
+            ListOfXmlElement: ListOf<string>(setValue2, "XmlElement", (value: string) => value)
         }
     };
     return reader as any as ReaderStateParserLike;

package/source/loader/register_node_promoter.ts

@@ -1,6 +1,6 @@
 import { resolveNodeId } from "node-opcua-nodeid";
-import { g_promotableObject, Promoter } from "./namespace_post_step";
+import { g_promotableObject, type Promoter } from "./namespace_post_step";
 
 export function registerNodePromoter(standardNodeId: number, promoter: Promoter, onInstanceOnly = false): void {
-    g_promotableObject.set(resolveNodeId(standardNodeId).toString(),{ promoter, onInstanceOnly });
+    g_promotableObject.set(resolveNodeId(standardNodeId).toString(), { promoter, onInstanceOnly });
 }

package/source/namespace.ts

@@ -1,7 +1,7 @@
-import { INamespace } from "node-opcua-address-space-base";
+import type { INamespace } from "node-opcua-address-space-base";
 
-import { INamespaceAlarmAndCondition } from "./namespace_alarm_and_condition";
-import { INamespaceDataAccess } from "./namespace_data_access";
-import { INamespaceMachineState } from "./namespace_machine_state";
+import type { INamespaceAlarmAndCondition } from "./namespace_alarm_and_condition";
+import type { INamespaceDataAccess } from "./namespace_data_access";
+import type { INamespaceMachineState } from "./namespace_machine_state";
 
 export interface Namespace extends INamespace, INamespaceAlarmAndCondition, INamespaceDataAccess, INamespaceMachineState {}

package/source/namespace_alarm_and_condition.ts

@@ -1,30 +1,30 @@
-import { NodeId } from "node-opcua-nodeid";
-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";
-import { UAExclusiveLimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex";
-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";
+import type { UAEventType } from "node-opcua-address-space-base";
+import type { NodeId } from "node-opcua-nodeid";
+import type { VariantOptions } from "node-opcua-variant";
+import type { UAOffNormalAlarmEx } from "../src/alarms_and_conditions/ua_off_normal_alarm_impl";
+import type { InstantiateAlarmConditionOptions } from "./interfaces/alarms_and_conditions/instantiate_alarm_condition_options";
+import type { InstantiateConditionOptions } from "./interfaces/alarms_and_conditions/instantiate_condition_options";
+import type { InstantiateExclusiveDeviationAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_exclusive_deviation_alarm_options";
+import type { InstantiateExclusiveLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_exclusive_limit_alarm_options";
+import type { InstantiateLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
+import type { InstantiateNonExclusiveDeviationAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_non_exclusive_deviation_alarm_options";
+import type { InstantiateNonExclusiveLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_non_exclusive_limit_alarm_options";
+import type { InstantiateOffNormalAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_off_normal_alarm_options";
+import type { UAAcknowledgeableConditionEx } from "./interfaces/alarms_and_conditions/ua_acknowledgeable_condition_ex";
+import type { UAAlarmConditionEx } from "./interfaces/alarms_and_conditions/ua_alarm_condition_ex";
+import type { UAConditionEx } from "./interfaces/alarms_and_conditions/ua_condition_ex";
+import type { UADiscreteAlarmEx } from "./interfaces/alarms_and_conditions/ua_discrete_alarm_ex";
+import type { UAExclusiveDeviationAlarmEx } from "./interfaces/alarms_and_conditions/ua_exclusive_deviation_alarm_ex";
+import type { UAExclusiveLimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex";
+import type { UALimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_limit_alarm_ex";
+import type { UANonExclusiveDeviationAlarmEx } from "./interfaces/alarms_and_conditions/ua_non_exclusive_deviation_alarm_ex";
+import type { UANonExclusiveLimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_non_exclusive_limit_alarm_ex";
 
 export interface INamespaceAlarmAndCondition {
     // --- Alarms & Conditions -------------------------------------------------
     instantiateCondition(
         conditionTypeId: UAEventType | NodeId | string,
-        options: any,
+        options: InstantiateConditionOptions,
         data?: Record<string, VariantOptions>
     ): UAConditionEx;
 

package/source/namespace_data_access.ts

@@ -1,25 +1,24 @@
-import {
+import type {
     AddVariableOptionsWithoutValue,
     AddYArrayItemOptions,
     BindVariableOptions,
     UADataType
 } from "node-opcua-address-space-base";
-import { NodeIdLike } from "node-opcua-nodeid";
-import { UAAnalogItem, UADataItem } from "node-opcua-nodeset-ua";
-import { EUInformation, EUInformationOptions } from "node-opcua-types";
-import { DataType, VariantArrayType } from "node-opcua-variant";
-
-import { UAMultiStateDiscreteEx } from "./interfaces/data_access/ua_multistate_discrete_ex";
-import { UAMultiStateValueDiscreteEx } from "./interfaces/data_access/ua_multistate_value_discrete_ex";
-import { UATwoStateDiscreteEx } from "./interfaces/data_access/ua_two_state_discrete_ex";
-import {
+import type { NodeIdLike } from "node-opcua-nodeid";
+import type { UAAnalogItem, UADataItem } from "node-opcua-nodeset-ua";
+import type { EUInformation, EUInformationOptions } from "node-opcua-types";
+import type { DataType, VariantArrayType } from "node-opcua-variant";
+import type {
     AddMultiStateDiscreteOptions,
     AddMultiStateValueDiscreteOptions,
     AddTwoStateDiscreteOptions,
     AddTwoStateVariableOptions
 } from "./address_space_ts";
-import { UATwoStateVariableEx } from "./ua_two_state_variable_ex";
-import { UAYArrayItemEx } from "./interfaces/data_access/ua_y_array_item_ex";
+import type { UAMultiStateDiscreteEx } from "./interfaces/data_access/ua_multistate_discrete_ex";
+import type { UAMultiStateValueDiscreteEx } from "./interfaces/data_access/ua_multistate_value_discrete_ex";
+import type { UATwoStateDiscreteEx } from "./interfaces/data_access/ua_two_state_discrete_ex";
+import type { UAYArrayItemEx } from "./interfaces/data_access/ua_y_array_item_ex";
+import type { UATwoStateVariableEx } from "./ua_two_state_variable_ex";
 
 export interface AddDataItemOptions extends AddVariableOptionsWithoutValue {
     arrayType?: VariantArrayType;
@@ -49,7 +48,7 @@ export interface AddAnalogDataItemOptions extends AddDataItemOptions {
     /**
      * the acceptValueOutOfRange property indicates whether the write operation will accept or reject a value which
      * is out of range of the instrumentRange.
-     * 
+     *
      * **if true**: during a writeOperation by a client if the dataValue that is outside of the instrumentRange
      * it will be recorded database and the statusCode will be set to BadOutOfRange, and
      * the write operation will return Good. If the variable supports historizing, the value will be recorded in the history database.

package/source/namespace_machine_state.ts

@@ -1,10 +1,15 @@
-import { UAObject, UAObjectType } from "node-opcua-address-space-base";
-import { UAState } from "node-opcua-nodeset-ua";
-import { QualifiedNameLike } from "node-opcua-data-model";
+import type { UAObject, UAObjectType } from "node-opcua-address-space-base";
+import type { QualifiedNameLike } from "node-opcua-data-model";
+import type { UAState } from "node-opcua-nodeset-ua";
 
-import { UATransitionEx } from "./interfaces/state_machine/ua_transition_ex";
+import type { UATransitionEx } from "./interfaces/state_machine/ua_transition_ex";
 export interface INamespaceMachineState {
-    addState(component: UAObject | UAObjectType, stateName: QualifiedNameLike, stateNumber: number, isInitialState?: boolean): UAState;
+    addState(
+        component: UAObject | UAObjectType,
+        stateName: QualifiedNameLike,
+        stateNumber: number,
+        isInitialState?: boolean
+    ): UAState;
     addTransition(
         component: UAObject | UAObjectType /* StateMachine | StateMachineType,*/,
         fromState: string,