node-opcua-address-space 2.178.0 → 2.179.0

package/src/nodeset_tools/nodeset_to_xml.ts

@@ -1,4 +1,3 @@
-/* eslint-disable complexity */
 /**
  * @module node-opcua-address-space
  */
@@ -56,7 +55,6 @@ import {
     constructNamespacePriorityTable
 } from "./construct_namespace_dependency";
 
-// tslint:disable:no-var-requires
 const XMLWriter = require("xml-writer");
 
 const debugLog = make_debugLog(__filename);
@@ -70,7 +68,9 @@ function _hash(node: BaseNode | UAReference): string {
 
 function _dumpDisplayName(xw: XmlWriter, node: BaseNode): void {
     if (node.displayName?.[0]) {
-        xw.startElement("DisplayName").text(node.displayName[0].text!).endElement();
+        xw.startElement("DisplayName")
+            .text(node.displayName[0].text || "")
+            .endElement();
     }
 }
 function _dumpDescription(xw: XmlWriter, node: { description?: LocalizedText }): void {
@@ -116,22 +116,36 @@ function _hasHigherPriorityThan(xw: XmlWriter, namespaceIndex1: number, namespac
     return hasHigherPriorityThan(namespaceIndex1, namespaceIndex2, xw.priorityTable);
 }
 
+function _mustFindReferenceType(addressSpace: IAddressSpace, name: string): UAReferenceType {
+    const referenceType = addressSpace.findReferenceType(name);
+    // c8 ignore next
+    if (!referenceType) {
+        throw new Error(`Cannot find standard reference type ${name}: please check your nodeset file`);
+    }
+    return referenceType;
+}
+
 function _dumpReferences(xw: XmlWriter, node: BaseNode) {
     xw.startElement("References");
 
     const addressSpace = node.addressSpace;
 
-    const aggregateReferenceType = addressSpace.findReferenceType("Aggregates")!;
-    // const hasChildReferenceType = addressSpace.findReferenceType("HasChild")!;
-    const hasSubtypeReferenceType = addressSpace.findReferenceType("HasSubtype")!;
-    const hasTypeDefinitionReferenceType = addressSpace.findReferenceType("HasTypeDefinition")!;
-    const nonHierarchicalReferencesType = addressSpace.findReferenceType("NonHierarchicalReferences")!;
-    const organizesReferencesType = addressSpace.findReferenceType("Organizes")!;
-    const connectsToReferenceType = addressSpace.findReferenceType("ConnectsTo")!;
-    const hasEventSourceReferenceType = addressSpace.findReferenceType("HasEventSource")!;
+    const aggregateReferenceType = _mustFindReferenceType(addressSpace, "Aggregates");
+    // const hasChildReferenceType = _mustFindReferenceType(addressSpace, "HasChild");
+    const hasSubtypeReferenceType = _mustFindReferenceType(addressSpace, "HasSubtype");
+    const hasTypeDefinitionReferenceType = _mustFindReferenceType(addressSpace, "HasTypeDefinition");
+    const nonHierarchicalReferencesType = _mustFindReferenceType(addressSpace, "NonHierarchicalReferences");
+    const organizesReferencesType = _mustFindReferenceType(addressSpace, "Organizes");
+    // ConnectsTo is genuinely optional: not every nodeset registers it, and the check
+    // below already tolerates it being absent.
+    const connectsToReferenceType = addressSpace.findReferenceType("ConnectsTo");
+    const hasEventSourceReferenceType = _mustFindReferenceType(addressSpace, "HasEventSource");
 
     function referenceToKeep(reference: UAReference): boolean {
-        const referenceType = (reference as ReferenceImpl)._referenceType!;
+        const referenceType = (reference as ReferenceImpl)._referenceType;
+        if (!referenceType) {
+            return false;
+        }
         const targetedNamespaceIndex = reference.nodeId.namespace;
 
         // get the direct backward reference to a external namespace
@@ -275,7 +289,10 @@ function getPrefix(xw: XmlWriter, namespace: XmlNamespaceUri): XmlNs {
 function restoreDefaultNamespace(xw: XmlWriter) {
     const xwe = xw as XmlWriterEx;
     if (!xwe.map) return;
-    xwe.map = xwe.stackMap.pop()!;
+    const previousMap = xwe.stackMap.pop();
+    if (previousMap) {
+        xwe.map = previousMap;
+    }
 }
 
 function setDefaultNamespace(xw: XmlWriter, namespace: XmlNamespaceUri): void {
@@ -304,7 +321,7 @@ function _dumpNodeId(xw: XmlWriter, v: NodeId) {
     xw.endElement();
 }
 
-function _dumpVariantValue(xw: XmlWriter, dataTypeNodeId: NodeId, dataType: DataType, addressSpace: IAddressSpace, value: any) {
+function _dumpVariantValue(xw: XmlWriter, dataTypeNodeId: NodeId, dataType: DataType, addressSpace: IAddressSpace, value: unknown) {
     if (value === undefined || value === null) {
         return;
     }
@@ -334,7 +351,7 @@ function _dumpVariantInnerExtensionObject(
     for (const field of definition.fields || []) {
         const dataTypeNodeId = field.dataType;
 
-        const fieldName = field.name!;
+        const fieldName = field.name || "";
         const lowerFieldName = lowerFirstLetter(fieldName);
         const v = (value as unknown as Record<string, unknown>)[lowerFieldName];
         if (v !== null && v !== undefined) {
@@ -352,17 +369,20 @@ function _dumpVariantInnerExtensionObject(
             startElementEx(xw, ns, fieldName, namespaceUri);
             //  xw.startElement(fieldName);
 
-            let fun: (value: any) => void = (_value: any) => {
+            let fun: (value: unknown) => void = (_value: unknown) => {
                 /** */
             };
             if (definition instanceof StructureDefinition) {
-                fun = _dumpVariantInnerExtensionObject.bind(null, xw, definitionMap, definition, addressSpace);
+                fun = _dumpVariantInnerExtensionObject.bind(null, xw, definitionMap, definition, addressSpace) as (
+                    value: unknown
+                ) => void;
             } else if (definition instanceof EnumDefinition) {
                 fun = _dumpVariantInnerValueEnum.bind(null, xw, definition);
             } else if (definition?.dataType === DataType.Variant) {
-                fun = (value: Variant) => {
+                fun = (value: unknown) => {
+                    const variantValue = value as Variant;
                     xw.startElement("Value");
-                    _dumpVariantValue(xw, field.dataType, value.dataType, addressSpace, value.value);
+                    _dumpVariantValue(xw, field.dataType, variantValue.dataType, addressSpace, variantValue.value);
                     xw.endElement();
                 };
             } else {
@@ -374,19 +394,21 @@ function _dumpVariantInnerExtensionObject(
                     fun(v);
                 } else {
                     // array
-                    for (const arrayItem of v as any[]) {
+                    for (const arrayItem of v as unknown[]) {
                         xw.startElement(name);
                         fun(arrayItem);
                         xw.endElement();
                     }
                 }
             } catch (err) {
-                // eslint-disable-next-line max-depth
                 if (types.isNativeError(err)) {
                     errorLog("Error in _dumpVariantExtensionObjectValue_Body !!!", err.message);
                 }
-                debugLog(name);
-                debugLog(field);
+                // c8 ignore next
+                if (doDebug) {
+                    debugLog(name);
+                    debugLog(field);
+                }
                 // throw err;
             }
             restoreDefaultNamespace(xw);
@@ -402,7 +424,7 @@ function _dumpVariantInnerExtensionObject(
     }
 }
 
-function _dumpVariantInnerValueEnum(xw: XmlWriter, definition: EnumDefinition, value: any): void {
+function _dumpVariantInnerValueEnum(xw: XmlWriter, definition: EnumDefinition, value: unknown): void {
     if (!definition.fields) {
         return;
     }
@@ -410,14 +432,13 @@ function _dumpVariantInnerValueEnum(xw: XmlWriter, definition: EnumDefinition, v
     xw.text(`${field?.name}_${field?.value[1]}`);
 }
 
-// eslint-disable-next-line complexity
 function _dumpVariantInnerValue(
     xw: XmlWriter,
     dataType: DataType,
     dataTypeNodeId: NodeId,
     definitionMap: DefinitionMap2,
     addressSpace: IAddressSpace,
-    value: any
+    value: unknown
 ): void {
     const uax = getPrefix(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
     switch (dataType) {
@@ -434,11 +455,11 @@ function _dumpVariantInnerValue(
             _dumpNodeId(xw, value as NodeId);
             break;
         case DataType.DateTime:
-            xw.text(value.toISOString());
+            xw.text((value as Date).toISOString());
             break;
         case DataType.Int64:
         case DataType.UInt64:
-            xw.text(value[1].toString());
+            xw.text((value as [number, number])[1].toString());
             break;
         case DataType.Boolean:
         case DataType.SByte:
@@ -450,12 +471,13 @@ function _dumpVariantInnerValue(
         case DataType.UInt16:
         case DataType.UInt32:
         case DataType.String:
-            xw.text(value.toString());
+            xw.text((value as { toString(): string }).toString());
             break;
         case DataType.ByteString:
             {
-                const base64 = value.toString("base64");
-                xw.text(base64.length > 80 ? base64.match(/.{0,80}/g).join("\n") : base64);
+                const base64 = (value as Buffer).toString("base64");
+                const chunks = base64.match(/.{0,80}/g);
+                xw.text(base64.length > 80 && chunks ? chunks.join("\n") : base64);
             }
             break;
         case DataType.Guid:
@@ -467,7 +489,7 @@ function _dumpVariantInnerValue(
             if (value !== undefined && value !== null) {
                 // xw.writeAttribute("xmlns", "http://opcfoundation.org/UA/2008/02/Types.xsd");
                 xw.startElement(`${uax}String`);
-                xw.text(value.toString());
+                xw.text((value as { toString(): string }).toString());
                 xw.endElement();
             }
             break;
@@ -481,9 +503,11 @@ function _dumpVariantInnerValue(
         case DataType.StatusCode:
             xw.text((value as StatusCode).value.toString());
             break;
-        case DataType.Variant:
-            _dumpVariantInnerValue(xw, value.dataType, dataTypeNodeId, definitionMap, addressSpace, value.value);
+        case DataType.Variant: {
+            const variantValue = value as Variant;
+            _dumpVariantInnerValue(xw, variantValue.dataType, dataTypeNodeId, definitionMap, addressSpace, variantValue.value);
             break;
+        }
         default:
             errorLog(`_dumpVariantInnerValue incomplete ${value} DataType=${dataType}=${DataType[dataType]}`);
         //  throw new Error("_dumpVariantInnerValue incomplete " + value + " " + "DataType=" + dataType + "=" + DataType[dataType]);
@@ -503,7 +527,7 @@ function _dumpVariantExtensionObjectValue_Body(
     name: string,
     definition: StructureDefinition,
     addressSpace: IAddressSpace,
-    value: any
+    value: ExtensionObject
 ) {
     if (value) {
         const namespaceUri = findXsdNamespaceUri(xw, definition.defaultEncodingId);
@@ -557,7 +581,7 @@ function _dumpVariantExtensionObjectValue(
 function _dumpVariantExtensionObjectValue2(xw: XmlWriter, addressSpace: IAddressSpace, value: ExtensionObject) {
     const dataTypeNodeId = value.schema.dataTypeNodeId;
     const definitionMap = makeDefinitionMap(addressSpace);
-    const dataTypeNode = addressSpace.findDataType(dataTypeNodeId)!;
+    const dataTypeNode = addressSpace.findDataType(dataTypeNodeId);
     if (!dataTypeNode) {
         warningLog("_dumpVariantExtensionObjectValue2: Cannot find dataType for  ", dataTypeNodeId.toString());
         return;
@@ -565,7 +589,6 @@ function _dumpVariantExtensionObjectValue2(xw: XmlWriter, addressSpace: IAddress
     _dumpVariantExtensionObjectValue(xw, dataTypeNode.nodeId, definitionMap, addressSpace, value);
 }
 
-// eslint-disable-next-line complexity
 function _isDefaultValue(value: Variant): boolean {
     // detect default value
     if (value.arrayType === VariantArrayType.Scalar) {
@@ -631,7 +654,6 @@ function _isDefaultValue(value: Variant): boolean {
     }
 }
 
-// eslint-disable-next-line max-statements
 function _dumpValue(xw: XmlWriter, node: UAVariable | UAVariableType, variant: Variant) {
     const addressSpace = node.addressSpace;
 
@@ -645,7 +667,8 @@ function _dumpValue(xw: XmlWriter, node: UAVariable | UAVariableType, variant: V
 
     // c8 ignore next
     if (!dataTypeNode) {
-        debugLog("Cannot find dataType:", node.dataType.toString());
+        // c8 ignore next
+        doDebug && debugLog("Cannot find dataType:", node.dataType.toString());
         return;
     }
 
@@ -732,7 +755,7 @@ function _visitUANode(node: BaseNode, data: DumpData, forward: boolean) {
         if (!data.index_el[k]) {
             data.index_el[k] = 1;
 
-            const o = addressSpace.findNode(k)! as BaseNode;
+            const o = addressSpace.findNode(k) as BaseNode | null;
             if (o) {
                 _visitUANode(o, data, forward);
             }
@@ -754,7 +777,7 @@ function dumpReferencedNodes(xw: XmlWriter, node: BaseNode, forward: boolean) {
             const r = node.findReferencesEx("HasTypeDefinition");
             if (r?.length) {
                 assert(r.length === 1);
-                const typeDefinitionObj = ReferenceImpl.resolveReferenceNode(addressSpace, r[0])! as BaseNode;
+                const typeDefinitionObj = ReferenceImpl.resolveReferenceNode(addressSpace, r[0]) as BaseNode | null;
                 if (!typeDefinitionObj) {
                     warningLog(node.toString());
                     warningLog(
@@ -777,9 +800,9 @@ function dumpReferencedNodes(xw: XmlWriter, node: BaseNode, forward: boolean) {
         {
             const r = node.findReferencesEx("HasSubtype", BrowseDirection.Inverse);
             if (r?.length) {
-                const subTypeOf = ReferenceImpl.resolveReferenceNode(addressSpace, r[0])! as BaseNode;
+                const subTypeOf = ReferenceImpl.resolveReferenceNode(addressSpace, r[0]) as BaseNode | null;
                 assert(r.length === 1);
-                if (subTypeOf.nodeId.namespace === node.nodeId.namespace) {
+                if (subTypeOf && subTypeOf.nodeId.namespace === node.nodeId.namespace) {
                     // only output node if it is on the same namespace
                     if (!xw.visitedNode.has(_hash(subTypeOf))) {
                         dumpNodeInXml(xw, subTypeOf);
@@ -794,12 +817,14 @@ function dumpReferencedNodes(xw: XmlWriter, node: BaseNode, forward: boolean) {
             assert(nodeChild instanceof BaseNodeImpl);
             if (nodeChild.nodeId.namespace === node.nodeId.namespace) {
                 if (!xw.visitedNode.has(_hash(nodeChild))) {
-                    debugLog(
-                        node.nodeId.toString(),
-                        " dumping child ",
-                        nodeChild.browseName.toString(),
-                        nodeChild.nodeId.toString()
-                    );
+                    // c8 ignore next
+                    doDebug &&
+                        debugLog(
+                            node.nodeId.toString(),
+                            " dumping child ",
+                            nodeChild.browseName.toString(),
+                            nodeChild.nodeId.toString()
+                        );
                     dumpNodeInXml(xw, nodeChild);
                 }
             }
@@ -826,11 +851,12 @@ function dumpCommonAttributes(xw: XmlWriter, node: BaseNode) {
         }
     }
     if (Object.hasOwn(node, "symbolicName")) {
-        xw.writeAttribute("SymbolicName", (node as any).symbolicName);
+        xw.writeAttribute("SymbolicName", (node as unknown as { symbolicName: string }).symbolicName);
     }
     if (Object.hasOwn(node, "isAbstract")) {
-        if ((node as any).isAbstract) {
-            xw.writeAttribute("IsAbstract", (node as any).isAbstract ? "true" : "false");
+        const isAbstract = (node as unknown as { isAbstract: boolean }).isAbstract;
+        if (isAbstract) {
+            xw.writeAttribute("IsAbstract", isAbstract ? "true" : "false");
         }
     }
     // AccessLevel and UserAccessLevel exist in the XSD on UAVariable only. Gate on the node
@@ -913,7 +939,7 @@ function coerceInt64ToInt32(int64: Int64): number {
 function _dumpEnumDefinition(xw: XmlWriter, enumDefinition: EnumDefinition) {
     enumDefinition.fields = enumDefinition.fields || [];
 
-    for (const defItem of enumDefinition.fields!) {
+    for (const defItem of enumDefinition.fields) {
         xw.startElement("Field");
         xw.writeAttribute("Name", defItem.name as string);
         if (!isNullOrUndefined(defItem.value)) {
@@ -1127,14 +1153,16 @@ function dumpUAVariableType(xw: XmlWriter, node: UAVariableType) {
         const dataTypeNode = addressSpace.findNode(node.dataType);
         if (!dataTypeNode) {
             // throw new Error(" cannot find datatype " + node.dataType);
-            debugLog(
-                " cannot find datatype " +
-                    node.dataType +
-                    " for node " +
-                    node.browseName.toString() +
-                    " id =" +
-                    node.nodeId.toString()
-            );
+            // c8 ignore next
+            doDebug &&
+                debugLog(
+                    " cannot find datatype " +
+                        node.dataType +
+                        " for node " +
+                        node.browseName.toString() +
+                        " id =" +
+                        node.nodeId.toString()
+                );
         } else {
             const dataTypeName = b(xw, resolveDataTypeName(addressSpace, dataTypeNode.nodeId));
             xw.writeAttribute("DataType", dataTypeName);
@@ -1393,7 +1421,7 @@ interface DumpData extends BuildAliasesData {
     index_el: Record<string, number>;
 }
 
-export type DumpXMLOptions = {};
+export type DumpXMLOptions = Record<string, never>;
 
 UAMethodImpl.prototype.dumpXML = function (xw) {
     dumpUAMethod(xw, this);
@@ -1426,7 +1454,6 @@ function makeTypeXsd(namespaceUri: string): string {
     return `${namespaceUri.replace(/\/$/, "")}/Type.xsd`;
 }
 
-// eslint-disable-next-line max-statements
 NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
     const namespaceArrayNode = this.addressSpace.findNode(VariableIds.Server_NamespaceArray);
     const namespaceArray: string[] = namespaceArrayNode
@@ -1474,7 +1501,7 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
 
     // let's sort the dependencies in the same order as the translation table
     const sortedDependencies = dependency.sort((a, b) =>
-        translationTable.get(a.index)! > translationTable.get(b.index)! ? 1 : -1
+        (translationTable.get(a.index) ?? 0) > (translationTable.get(b.index) ?? 0) ? 1 : -1
     );
 
     doDebug && debugLog(sortedDependencies.map((a) => `${a.index} + ${a.namespaceUri}`).join("\n"));
@@ -1562,12 +1589,14 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
             const result = getDataTypeDescription(opcBinaryTypeSystem);
             if (result.length === 1) {
                 xw.writeComment("DataSystem - Binary");
-                const dataSystemType = addressSpace.findNode(result[0].nodeId)! as UAVariable;
-                const types = dataSystemType.getComponents();
-                for (const f of types) {
-                    dumpNodeInXml(xw, f);
+                const dataSystemType = addressSpace.findNode(result[0].nodeId) as UAVariable | null;
+                if (dataSystemType) {
+                    const types = dataSystemType.getComponents();
+                    for (const f of types) {
+                        dumpNodeInXml(xw, f);
+                    }
+                    dumpNodeInXml(xw, dataSystemType);
                 }
-                dumpNodeInXml(xw, dataSystemType);
             }
         }
 
@@ -1575,14 +1604,15 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
             const result = getDataTypeDescription(opcXmlSchemaTypeSystem);
             if (result.length === 1) {
                 xw.writeComment("DataSystem - Xml");
-                const dataSystemType = addressSpace.findNode(result[0].nodeId)! as UAVariable;
+                const dataSystemType = addressSpace.findNode(result[0].nodeId) as UAVariable | null;
+                if (dataSystemType) {
+                    const types = dataSystemType.getComponents();
+                    for (const f of types) {
+                        dumpNodeInXml(xw, f);
+                    }
 
-                const types = dataSystemType.getComponents();
-                for (const f of types) {
-                    dumpNodeInXml(xw, f);
+                    dumpNodeInXml(xw, dataSystemType);
                 }
-
-                dumpNodeInXml(xw, dataSystemType);
             }
         }
     }

package/src/private_namespace.ts

@@ -1,13 +1,18 @@
 import type { Namespace } from "../source/namespace";
 import type { NodeEntry1, NodeIdManager } from "./nodeid_manager";
 
+interface NamespaceWithNodeIdManager extends Namespace {
+    _nodeIdManager: NodeIdManager;
+    registerSymbolicNames: boolean;
+}
+
 export function getNodeIdManager(ns: Namespace): NodeIdManager {
-    const nodeIdManager = (ns as any)._nodeIdManager as NodeIdManager;
+    const nodeIdManager = (ns as NamespaceWithNodeIdManager)._nodeIdManager;
     return nodeIdManager;
 }
 export function setSymbols(ns: Namespace, symbols: NodeEntry1[]) {
     const nodeIdManager = getNodeIdManager(ns);
-    (ns as any).registerSymbolicNames = true;
+    (ns as NamespaceWithNodeIdManager).registerSymbolicNames = true;
     nodeIdManager.setSymbols(symbols);
 }
 export function getSymbols(ns: Namespace): NodeEntry1[] {

package/src/reference_impl.ts

@@ -1,9 +1,8 @@
 /**
  * @module node-opcua-address-space
  */
-// tslint:disable:no-console
 import chalk from "chalk";
-import type { AddReferenceOpts, BaseNode, UAReference, UAReferenceType } from "node-opcua-address-space-base";
+import type { AddReferenceOpts, BaseNode, IAddressSpace, UAReference, UAReferenceType } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import { coerceNodeId, NodeId, type NodeIdLike, sameNodeId } from "node-opcua-nodeid";
 import { isNullOrUndefined } from "node-opcua-utils";
@@ -52,7 +51,7 @@ function _w(str: string, width: number): string {
 }
 
 function _localCoerceToNodeID(nodeIdLike: string | NodeIdLike | { nodeId: NodeId }): NodeId {
-    if (typeof nodeIdLike === "object" &&  Object.hasOwn(nodeIdLike, "nodeId")) {
+    if (typeof nodeIdLike === "object" && Object.hasOwn(nodeIdLike, "nodeId")) {
         return (nodeIdLike as { nodeId: NodeId }).nodeId;
     }
     return coerceNodeId(nodeIdLike);
@@ -67,7 +66,7 @@ export interface MinimalistAddressSpace {
 export function resolveReferenceNode(addressSpace: MinimalistAddressSpace, reference: UAReference): BaseNode {
     const _reference = reference as ReferenceImpl;
     if (!_reference.node) {
-        _reference.node = addressSpace.findNode(reference.nodeId)!;
+        _reference.node = addressSpace.findNode(reference.nodeId) as BaseNode;
     }
     return _reference.node;
 }
@@ -78,7 +77,7 @@ export function resolveReferenceType(addressSpace: MinimalistAddressSpace, refer
         if (!_reference.referenceType) {
             errorLog(chalk.red("ERROR MISSING reference"), reference);
         }
-        _reference._referenceType = addressSpace.findReferenceType(reference.referenceType)!;
+        _reference._referenceType = addressSpace.findReferenceType(reference.referenceType) as UAReferenceType;
     }
     return _reference._referenceType;
 }
@@ -117,7 +116,7 @@ export class ReferenceImpl implements UAReference {
         this.isForward = options.isForward === undefined ? true : !!options.isForward;
         this.nodeId = _localCoerceToNodeID(options.nodeId);
         // optional to speed up when AddReferenceOpts is in fact a Reference !
-        this._referenceType = (options as any)._referenceType;
+        this._referenceType = (options as Partial<ReferenceImpl>)._referenceType;
         this.node = options.node;
         assert(is_valid_reference(this));
     }
@@ -127,17 +126,19 @@ export class ReferenceImpl implements UAReference {
 
      * @return {String}
      */
-    public toString(options?: { addressSpace?: any }): string {
+    public toString(options?: { addressSpace?: IAddressSpace }): string {
         let infoNode = _w(this.nodeId.toString(), 24);
         let refType = this.referenceType.toString();
 
         if (options?.addressSpace) {
             const node = options.addressSpace.findNode(this.nodeId);
-            infoNode = `[${infoNode}]${_w(node?.browseName.toString(), 40)}`;
+            infoNode = `[${infoNode}]${_w(node?.browseName.toString() || "", 40)}`;
 
             const ref = options.addressSpace.findReferenceType(this.referenceType);
-            const refNode = options.addressSpace.findNode(ref.nodeId);
-            refType = `${refNode.browseName.toString()} (${ref.nodeId.toString()})`;
+            if (ref) {
+                const refNode = options.addressSpace.findNode(ref.nodeId);
+                refType = `${refNode?.browseName.toString() || "<unknown>"} (${ref.nodeId.toString()})`;
+            }
         }
         return _arrow(refType, 40, this.isForward) + infoNode;
     }

package/src/state_machine/finite_state_machine.ts

@@ -32,14 +32,13 @@ import { UAObjectTypeImpl } from "../ua_object_type_impl";
 const warningLog = make_warningLog(__filename);
 
 const doDebug = false;
-const debugLog = make_debugLog(__filename); 
+const debugLog = make_debugLog(__filename);
 
 export class UATransitionImplBase extends BaseNodeImpl {
     /* intentionnaly empty */
 }
 export type UATransitionImpl = UATransitionImplBase & UATransitionEx;
-export const  UATransitionImpl = UATransitionImplBase as unknown as new () => UATransitionImpl;
-
+export const UATransitionImpl = UATransitionImplBase as unknown as new () => UATransitionImpl;
 
 function getComponentOfType(typeDef: UAObjectType, typedefinition: UAObjectType): UAObject[] {
     const get = (typeDef: UAObjectType) =>
@@ -62,8 +61,6 @@ function getComponentOfType(typeDef: UAObjectType, typedefinition: UAObjectType)
     return components_parts as UAObject[];
 }
 
-
-
 const defaultPredicate = (transitions: UATransition[], fromState: UAState, toState: UAState) => {
     if (transitions.length === 0) {
         return null;
@@ -122,10 +119,10 @@ export function getFiniteStateMachineTypeStateByName(uaFiniteStateMachineType: U
         return s.browseName.name === stateName;
     });
     assert(states.length <= 1);
-    return states.length === 1 ? (states[0]) : null;
+    return states.length === 1 ? states[0] : null;
 }
 
-const $ = (uaObject: UAStateMachineImplBase) =>  uaObject as  unknown as UAStateMachineEx;
+const $ = (uaObject: UAStateMachineImplBase) => uaObject as unknown as UAStateMachineEx;
 /*
  *
  * @class StateMachine
@@ -302,7 +299,10 @@ export class UAStateMachineImplBase extends UAObjectImpl {
     public setState(toStateNode: string | UAState | null, predicate?: TransitionSelector): void {
         if (!toStateNode) {
             this.currentStateNode = null;
-            $(this).currentState.setValueFromSource({ dataType: DataType.LocalizedText, value: null }, StatusCodes.BadStateNotActive);
+            $(this).currentState.setValueFromSource(
+                { dataType: DataType.LocalizedText, value: null },
+                StatusCodes.BadStateNotActive
+            );
             return;
         }
 
@@ -322,7 +322,7 @@ export class UAStateMachineImplBase extends UAObjectImpl {
         $(this).currentState.setValueFromSource(
             {
                 dataType: DataType.LocalizedText,
-                value: coerceLocalizedText(toStateNode.displayName[0] || toStateNode.browseName.name  || "")
+                value: coerceLocalizedText(toStateNode.displayName[0] || toStateNode.browseName.name || "")
             },
             StatusCodes.Good
         );
@@ -563,7 +563,9 @@ export class UAStateMachineImplBase extends UAObjectImpl {
 
         // also update executable flags on methods
         for (const method of this.getMethods()) {
-            (method as any)._notifyAttributeChange(AttributeIds.Executable);
+            (method as unknown as { _notifyAttributeChange(attributeId: AttributeIds): void })._notifyAttributeChange(
+                AttributeIds.Executable
+            );
         }
     }
 

package/src/state_machine/ua_shelving_state_machine_ex.ts

@@ -82,7 +82,7 @@ export class UAShelvedStateMachineExImplBase extends UAStateMachineImpl {
     }
 }
 export type UAShelvedStateMachineExImpl = UAShelvedStateMachineExImplBase & UAShelvedStateMachineEx;
-export const  UAShelvedStateMachineExImpl = UAShelvedStateMachineExImplBase as unknown as new () => UAShelvedStateMachineExImpl;
+export const UAShelvedStateMachineExImpl = UAShelvedStateMachineExImplBase as unknown as new () => UAShelvedStateMachineExImpl;
 
 // The Unshelve Method sets the AlarmCondition to the Unshelved state. Normally, the MethodId found
 // the Shelving child of the Condition instance and the NodeId of the Shelving object as the ObjectId
@@ -112,7 +112,7 @@ function _unshelve_method(inputArguments: VariantLike[], context: ISessionContex
     }
     shelvingState.setState("Unshelved");
 
-    (shelvingState as any)._unshelvedTime = new Date(); // now
+    shelvingState._unshelvedTime = new Date(); // now
 
     _clear_timer_if_any(shelvingState);
     assert(!shelvingState._timer);
@@ -196,7 +196,7 @@ function _timedShelve_method(
     if (!context.object) {
         return;
     }
-    const shelvingState = context.object! as UAShelvedStateMachineExImpl;
+    const shelvingState = context.object as UAShelvedStateMachineExImpl;
 
     if (shelvingState.getCurrentState() !== "Unshelved") {
         return callback(null, {
@@ -254,7 +254,7 @@ function _oneShotShelve_method(
     callback: CallbackT<CallMethodResultOptions>
 ) {
     assert(inputArguments.length === 0);
-    const shelvingState = context.object! as UAShelvedStateMachineExImpl;
+    const shelvingState = context.object as UAShelvedStateMachineExImpl;
     if (shelvingState.getCurrentState() === "OneShotShelved") {
         return callback(null, {
             statusCode: StatusCodes.BadConditionAlreadyShelved