node-opcua-address-space 2.170.1 → 2.172.0

package/src/address_space.ts

@@ -51,24 +51,17 @@ import type {
     ModelChangeStructureDataType,
     RelativePathElement
 } from "node-opcua-types";
-import {
-    BrowsePath,
-    BrowsePathResult,
-} from "node-opcua-types";
+import { BrowsePath, BrowsePathResult } from "node-opcua-types";
 import { isNullOrUndefined, lowerFirstLetter } from "node-opcua-utils";
 import { DataType, Variant, VariantArrayType, type VariantOptions, type VariantT } from "node-opcua-variant";
 import { adjustBrowseDirection } from "../source/helpers/adjust_browse_direction";
-import type {
-    ExtensionObjectConstructorFuncWithSchema
-} from "../source/interfaces/extension_object_constructor";
+import type { ExtensionObjectConstructorFuncWithSchema } from "../source/interfaces/extension_object_constructor";
 import type { UARootFolder } from "../source/ua_root_folder";
 import type { AddressSpacePrivate } from "./address_space_private";
-import { UAAcknowledgeableConditionImpl, UAConditionImpl } from "./alarms_and_conditions";
+import { UAAcknowledgeableConditionImplBase, UAConditionImplBase } from "./alarms_and_conditions";
 import { BaseNodeImpl } from "./base_node_impl";
 import { EventData } from "./event_data";
-import {
-    AddressSpace_installHistoricalDataNode
-} from "./historical_access/address_space_historical_data_node";
+import { AddressSpace_installHistoricalDataNode } from "./historical_access/address_space_historical_data_node";
 import { isNonEmptyQualifiedName, NamespaceImpl } from "./namespace_impl";
 import type { NamespacePrivate } from "./namespace_private";
 import { ReferenceImpl } from "./reference_impl";
@@ -139,7 +132,7 @@ function _extract_namespace_and_browse_name_as_string(
     }
 
     /* c8 ignore next */
-    if (!result || !result[0]) {
+    if (!result?.[0]) {
         throw new Error(` Cannot find namespace associated with ${browseNameOrNodeId} ${namespaceIndex}`);
     }
     return result as [NamespacePrivate, string];
@@ -510,9 +503,9 @@ export class AddressSpace implements AddressSpacePrivate {
         if (!(dataTypeNode instanceof UADataTypeImpl)) {
             throw new Error(
                 "we are expecting an UADataType here :  " +
-                _orig_dataTypeNode.toString() +
-                " should not refer to a  " +
-                (dataTypeNode as BaseNode).browseName.name
+                    _orig_dataTypeNode.toString() +
+                    " should not refer to a  " +
+                    (dataTypeNode as BaseNode).browseName.name
             );
         }
 
@@ -711,7 +704,6 @@ export class AddressSpace implements AddressSpacePrivate {
         /* c8 ignore next */
         if (!eventTypeNode) throw new Error(` cannot find EventType for ${eventTypeId}`);
 
-
         assert(eventTypeNode instanceof UAObjectTypeImpl, "eventTypeId must represent a UAObjectType");
 
         // eventId
@@ -793,18 +785,18 @@ export class AddressSpace implements AddressSpacePrivate {
                         // tslint:disable:no-console
                         errorLog(
                             chalk.red("ERROR : AddressSpace#constructEventData(eventType,options) " + "cannot find property ") +
-                            self.browseName.toString() +
-                            " => " +
-                            chalk.cyan(lowerName)
+                                self.browseName.toString() +
+                                " => " +
+                                chalk.cyan(lowerName)
                         );
                     } else {
                         errorLog(
                             chalk.yellow(
                                 "Warning : AddressSpace#constructEventData(eventType,options)" + " cannot find property "
                             ) +
-                            self.browseName.toString() +
-                            " => " +
-                            chalk.cyan(lowerName)
+                                self.browseName.toString() +
+                                " => " +
+                                chalk.cyan(lowerName)
                         );
                     }
                 }
@@ -821,11 +813,11 @@ export class AddressSpace implements AddressSpacePrivate {
                 if (!alreadyVisited(k)) {
                     warningLog(
                         "constructEventData:  cannot find property '" +
-                        k +
-                        "' in [ " +
-                        Object.keys(visitedProperties).join(", ") +
-                        "] when filling " +
-                        eventTypeNode?.browseName.toString()
+                            k +
+                            "' in [ " +
+                            Object.keys(visitedProperties).join(", ") +
+                            "] when filling " +
+                            eventTypeNode?.browseName.toString()
                     );
                 }
             });
@@ -963,7 +955,7 @@ export class AddressSpace implements AddressSpacePrivate {
         // TranslateBrowsePathToNodeIds further restrict RelativePath targetName rules:
         // The last element in the relativePath shall always have a targetName specified.
         const last_el = browsePath.relativePath.elements[elements_length - 1];
-        if (!last_el.targetName || !last_el.targetName.name || last_el.targetName.name.length === 0) {
+        if (!last_el.targetName?.name || last_el.targetName.name.length === 0) {
             return new BrowsePathResult({ statusCode: StatusCodes.BadBrowseNameInvalid });
         }
 
@@ -1359,7 +1351,7 @@ export class AddressSpace implements AddressSpacePrivate {
             params.node = params.nodeId as BaseNode;
             params.nodeId = params.node.nodeId;
         } else {
-            let _nodeId = params.nodeId! as NodeId;
+            let _nodeId = params.nodeId as NodeId;
             assert(!!_nodeId, "missing 'nodeId' in reference");
             if (_nodeId && (_nodeId as any).nodeId) {
                 _nodeId = (_nodeId as any).nodeId as NodeId;
@@ -1392,8 +1384,8 @@ export class AddressSpace implements AddressSpacePrivate {
      *
      */
     public installAlarmsAndConditionsService(): void {
-        UAConditionImpl.install_condition_refresh_handle(this);
-        UAAcknowledgeableConditionImpl.install_method_handle_on_type(this);
+        UAConditionImplBase.install_condition_refresh_handle(this);
+        UAAcknowledgeableConditionImplBase.install_method_handle_on_type(this);
     }
 
     // -- internal stuff -----------------------------------------------------------------------------------------------

package/src/address_space_change_event_tools.ts

@@ -2,16 +2,13 @@
  * @module node-opcua-address-space
  */
 import chalk from "chalk";
-
-import { UAReference, BaseNode, UAObject, UAVariable, UAObjectType, UAVariableType } from "node-opcua-address-space-base";
-import { assert } from "node-opcua-assert";
+import type { BaseNode, UAObject, UAReference, UAVariable } from "node-opcua-address-space-base";
 import { BrowseDirection, NodeClass } from "node-opcua-data-model";
-import { Enum, EnumItem } from "node-opcua-enum";
-import { NodeId } from "node-opcua-nodeid";
+import { Enum } from "node-opcua-enum";
+import type { NodeId } from "node-opcua-nodeid";
 import { ModelChangeStructureDataType } from "node-opcua-types";
-
-import { AddressSpacePrivate } from "./address_space_private";
-import { BaseNodeImpl } from "./base_node_impl";
+import type { AddressSpacePrivate } from "./address_space_private";
+import type { BaseNodeImpl } from "./base_node_impl";
 
 const verbFlags = new Enum({
     //                         NodeAdded        0         Indicates the affected Node has been added.
@@ -35,29 +32,27 @@ const verbFlags = new Enum({
     DataTypeChanged: 0x10
 });
 
-function makeVerb(verbs: any): number {
-    const e: EnumItem = verbFlags.get(verbs)!;
-    assert(e !== null);
-    return e.value;
+type VerbFlagNames = "NodeAdded" | "NodeDeleted" | "ReferenceAdded" | "ReferenceDeleted" | "DataTypeChanged";
+
+function makeVerb(verbs: VerbFlagNames): number {
+    const e = verbFlags.get(verbs);
+    return e?.value || 0;
 }
 
 function _getTypeDef(node: BaseNode) {
     if (node.nodeClass === NodeClass.Object || node.nodeClass === NodeClass.Variable) {
-        return (<UAVariable | UAObject>node).typeDefinitionObj.nodeId;
+        return (node as unknown as UAObject | UAVariable).typeDefinitionObj.nodeId;
     }
     return null;
 }
 export function _handle_add_reference_change_event(node1: BaseNode, node2id: NodeId): void {
-    
     const addressSpace = node1.addressSpace as AddressSpacePrivate;
     const node2 = addressSpace.findNode(node2id);
     if (!node2) return;
 
-    if (node1.getNodeVersion() ||node2.getNodeVersion()) {
-
+    if (node1.getNodeVersion() || node2.getNodeVersion()) {
         // a event has to be send
         addressSpace.modelChangeTransaction(() => {
-
             let modelChangeTgt = new ModelChangeStructureDataType({
                 affected: node1.nodeId,
                 affectedType: _getTypeDef(node1),
@@ -78,7 +73,7 @@ export function _handle_add_reference_change_event(node1: BaseNode, node2id: Nod
 }
 
 try {
-    (ModelChangeStructureDataType as any).prototype.toString = function (options: any): string {
+    ModelChangeStructureDataType.prototype.toString = function (options?: { addressSpace: AddressSpacePrivate }): string {
         if (!options) {
             return "";
         }
@@ -88,16 +83,16 @@ try {
             if (!nodeId || nodeId.isEmpty()) {
                 return "";
             }
-            const node = addressSpace.findNode(nodeId)!;
-            return '"' + nodeId.toString() + '"' + chalk.yellow(" /* " + (node ? node.browseName.toString() : "???") + " */");
+            const node = addressSpace.findNode(nodeId);
+            return `"${nodeId.toString()}"${chalk.yellow(` /* ${node ? node.browseName.toString() : "???"} */`)}`;
         }
 
-        let str = "{ verb:" + verbFlags.get(this.verb)!.key + ",";
-        str += " affected: " + n(this.affected) + ",";
-        str += " type: " + n(this.affectedType) + " }";
+        let str = `{ verb:${verbFlags.get(this.verb)?.key},`;
+        str += ` affected: ${n(this.affected)},`;
+        str += ` type: ${n(this.affectedType)} }`;
         return str;
     };
-} catch (err) {
+} catch (_err) {
     //
 }
 
@@ -113,7 +108,7 @@ export function _handle_model_change_event(node: BaseNodeImpl): void {
         typeDefinitionNodeId = node.typeDefinitionObj.nodeId;
     }
     for (const parent of [...parents, ...containingFolders]) {
-        if (parent && parent.getNodeVersion()) {
+        if (parent?.getNodeVersion()) {
             addressSpace.modelChangeTransaction(() => {
                 const modelChange1 = new ModelChangeStructureDataType({
                     affected: node.nodeId,
@@ -147,22 +142,22 @@ export function _handle_delete_node_model_change_event(node: BaseNode): void {
     const addressSpace = node.addressSpace as AddressSpacePrivate;
 
     // get backward references
-    const references = node.findReferencesEx("HierarchicalReferences", BrowseDirection.Inverse)!;
+    const references = node.findReferencesEx("HierarchicalReferences", BrowseDirection.Inverse);
 
     const parentNodes = references.map((r: UAReference) => {
-        return addressSpace.findNode(r.nodeId)! as BaseNode;
+        return addressSpace.findNode(r.nodeId) as BaseNode;
     });
 
-    const versionableNodes = parentNodes.filter((n) => null!=n.getNodeVersion());
+    const versionableNodes = parentNodes.filter((n) => null != n.getNodeVersion());
 
     if (versionableNodes.length >= 1 || node.getNodeVersion()) {
         addressSpace.modelChangeTransaction(() => {
             // ...
             for (const r of references) {
-                const target = addressSpace.findNode(r.nodeId)!;
+                const target = addressSpace.findNode(r.nodeId);
 
                 const modelChangeSrc_l = new ModelChangeStructureDataType({
-                    affected: target.nodeId,
+                    affected: target?.nodeId,
                     affectedType: null,
                     verb: makeVerb("ReferenceDeleted")
                 });

package/src/address_space_private.ts

@@ -1,33 +1,32 @@
 /**
  * @module node-opcua-address-space.Private
  */
-import { ExtraDataTypeManager } from "node-opcua-client-dynamic-extension-object";
-import { NodeClass, QualifiedNameLike } from "node-opcua-data-model";
-import { ExtensionObject } from "node-opcua-extension-object";
-import { NodeId, NodeIdLike } from "node-opcua-nodeid";
-import { ModelChangeStructureDataType, ReadProcessedDetails, HistoryReadResult } from "node-opcua-types";
-import { NumericRange } from "node-opcua-numeric-range";
-import { CallbackT } from "node-opcua-status-code";
-
-import {
-    IAddressSpace,
+
+import type {
+    AddReferenceOpts,
     BaseNode,
-    UADataType,
-    UAView,
+    ContinuationData,
+    IAddressSpace,
     ISessionContext,
-    AddReferenceOpts,
-    UAVariableType,
+    MethodCallInterceptor,
+    UADataType,
     UAObjectType,
     UAReference,
     UAVariable,
-    ContinuationData,
-    MethodCallInterceptor
+    UAVariableType,
+    UAView
 } from "node-opcua-address-space-base";
-import { UARootFolder } from "../source/ua_root_folder";
-import { ExtensionObjectConstructorFuncWithSchema } from "../source/interfaces/extension_object_constructor";
-
-import { NamespacePrivate } from "./namespace_private";
-
+import type { ExtraDataTypeManager } from "node-opcua-client-dynamic-extension-object";
+import type { NodeClass, QualifiedNameLike } from "node-opcua-data-model";
+import type { ExtensionObject } from "node-opcua-extension-object";
+import type { NodeId, NodeIdLike } from "node-opcua-nodeid";
+import type { NumericRange } from "node-opcua-numeric-range";
+import type { CallbackT } from "node-opcua-status-code";
+import type { HistoryReadResult, ModelChangeStructureDataType, ReadProcessedDetails } from "node-opcua-types";
+import type { ExtensionObjectConstructorFuncWithSchema } from "../source/interfaces/extension_object_constructor";
+import type { UARootFolder } from "../source/ua_root_folder";
+
+import type { NamespacePrivate } from "./namespace_private";
 
 export interface AddressSpacePrivate extends IAddressSpace {
     rootFolder: UARootFolder;

package/src/alarms_and_conditions/condition.ts

@@ -2,8 +2,6 @@
  * @module node-opcua-address-space.AlarmsAndConditions
  */
 
-
-
 /*
  As per spec OPCUA 1.03 part 9:
 

package/src/alarms_and_conditions/condition_info_impl.ts

@@ -1,12 +1,10 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
-import { assert } from "node-opcua-assert";
-import { UInt16 } from "node-opcua-basic-types";
-import { LocalizedText, LocalizedTextLike } from "node-opcua-data-model";
-import { StatusCode } from "node-opcua-status-code";
-import { ConditionInfo, ConditionInfoOptions } from "../../source/interfaces/alarms_and_conditions/condition_info_i";
-
+import type { UInt16 } from "node-opcua-basic-types";
+import { LocalizedText } from "node-opcua-data-model";
+import type { StatusCode } from "node-opcua-status-code";
+import type { ConditionInfo, ConditionInfoOptions } from "../../source/interfaces/alarms_and_conditions/condition_info_i";
 
 /**
  * @private
@@ -23,25 +21,19 @@ export class ConditionInfoImpl implements ConditionInfo {
         this.message = null;
         this.retain = null;
 
-        if (Object.prototype.hasOwnProperty.call(options, "message") && options.message) {
+        if (Object.hasOwn(options, "message") && options.message) {
             this.message = LocalizedText.coerce(options.message);
         }
-        if (Object.prototype.hasOwnProperty.call(options, "quality") && options.quality !== null) {
-            this.quality = options.quality!;
+        if (Object.hasOwn(options, "quality") && options.quality) {
+            this.quality = options.quality;
         }
-        if (Object.prototype.hasOwnProperty.call(options, "severity") && options.severity !== null) {
-            assert(typeof options.severity === "number");
-            this.severity = options.severity!;
+        if (Object.hasOwn(options, "severity") && options.severity !== null) {
+            this.severity = options.severity || 0;
         }
-        if (Object.prototype.hasOwnProperty.call(options, "retain") && options.retain !== null) {
-            assert(typeof options.retain === "boolean");
-            this.retain = options.retain!;
+        if (Object.hasOwn(options, "retain") && options.retain !== null) {
+            this.retain = options.retain || false;
         }
     }
-
-    /**
-     * 
-     */
     public isDifferentFrom(otherConditionInfo: ConditionInfo): boolean {
         return (
             this.severity !== otherConditionInfo.severity ||