node-opcua-address-space 2.175.0 → 2.175.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-address-space",
-    "version": "2.175.0",
+    "version": "2.175.2",
     "description": "pure nodejs OPCUA SDK - module address-space",
     "main": "./dist/src/index_current.js",
     "types": "./dist/source/index.d.ts",
@@ -21,49 +21,49 @@
         "@types/semver": "7.7.1",
         "chalk": "4.1.2",
         "dequeue": "^1.0.5",
-        "node-opcua-address-space-base": "2.174.0",
-        "node-opcua-assert": "2.164.0",
-        "node-opcua-basic-types": "2.174.0",
-        "node-opcua-binary-stream": "2.173.0",
-        "node-opcua-client-dynamic-extension-object": "2.174.0",
-        "node-opcua-constants": "2.174.0",
+        "node-opcua-address-space-base": "2.175.2",
+        "node-opcua-assert": "2.175.1",
+        "node-opcua-basic-types": "2.175.1",
+        "node-opcua-binary-stream": "2.175.1",
+        "node-opcua-client-dynamic-extension-object": "2.175.2",
+        "node-opcua-constants": "2.175.1",
         "node-opcua-crypto": "5.3.6",
-        "node-opcua-data-access": "2.174.0",
-        "node-opcua-data-model": "2.174.0",
-        "node-opcua-data-value": "2.174.0",
-        "node-opcua-date-time": "2.174.0",
-        "node-opcua-debug": "2.172.0",
-        "node-opcua-enum": "2.173.0",
-        "node-opcua-extension-object": "2.174.0",
-        "node-opcua-factory": "2.174.0",
-        "node-opcua-nodeid": "2.174.0",
-        "node-opcua-nodeset-ua": "2.174.0",
-        "node-opcua-numeric-range": "2.174.0",
-        "node-opcua-object-registry": "2.172.0",
-        "node-opcua-pseudo-session": "2.174.0",
-        "node-opcua-service-browse": "2.174.0",
-        "node-opcua-service-call": "2.174.0",
-        "node-opcua-service-history": "2.174.0",
-        "node-opcua-service-translate-browse-path": "2.174.0",
-        "node-opcua-service-write": "2.174.0",
-        "node-opcua-status-code": "2.173.0",
-        "node-opcua-types": "2.174.0",
-        "node-opcua-utils": "2.173.0",
-        "node-opcua-variant": "2.174.0",
-        "node-opcua-xml2json": "2.173.0",
+        "node-opcua-data-access": "2.175.2",
+        "node-opcua-data-model": "2.175.1",
+        "node-opcua-data-value": "2.175.1",
+        "node-opcua-date-time": "2.175.1",
+        "node-opcua-debug": "2.175.1",
+        "node-opcua-enum": "2.175.1",
+        "node-opcua-extension-object": "2.175.1",
+        "node-opcua-factory": "2.175.1",
+        "node-opcua-nodeid": "2.175.1",
+        "node-opcua-nodeset-ua": "2.175.2",
+        "node-opcua-numeric-range": "2.175.1",
+        "node-opcua-object-registry": "2.175.1",
+        "node-opcua-pseudo-session": "2.175.2",
+        "node-opcua-service-browse": "2.175.2",
+        "node-opcua-service-call": "2.175.2",
+        "node-opcua-service-history": "2.175.2",
+        "node-opcua-service-translate-browse-path": "2.175.2",
+        "node-opcua-service-write": "2.175.2",
+        "node-opcua-status-code": "2.175.1",
+        "node-opcua-types": "2.175.2",
+        "node-opcua-utils": "2.175.1",
+        "node-opcua-variant": "2.175.1",
+        "node-opcua-xml2json": "2.175.2",
         "semver": "^7.8.5",
         "thenify-ex": "4.4.0",
         "xml-writer": "^1.7.0"
     },
     "devDependencies": {
         "humanize": "0.0.9",
-        "node-opcua-benchmarker": "2.173.0",
-        "node-opcua-leak-detector": "2.172.0",
-        "node-opcua-nodesets": "2.174.0",
-        "node-opcua-packet-analyzer": "2.174.0",
-        "node-opcua-schemas": "2.174.0",
-        "node-opcua-service-filter": "2.174.0",
-        "node-opcua-test-fixtures": "2.157.0"
+        "node-opcua-benchmarker": "2.175.1",
+        "node-opcua-leak-detector": "2.175.1",
+        "node-opcua-nodesets": "2.175.1",
+        "node-opcua-packet-analyzer": "2.175.1",
+        "node-opcua-schemas": "2.175.2",
+        "node-opcua-service-filter": "2.175.2",
+        "node-opcua-test-fixtures": "2.175.1"
     },
     "author": "Etienne Rossignon",
     "license": "MIT",
@@ -80,7 +80,7 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "b15c534b0f03502d30c49934c36291368bdacb80",
+    "gitHead": "4e2a73e5b96bdf3bd3a88709c813289038caf19b",
     "files": [
         "dist",
         "distHelpers",

package/source/loader/make_xml_extension_object_parser.ts

@@ -12,7 +12,7 @@ import {
     type UInt64
 } from "node-opcua-basic-types";
 import { make_debugLog, make_warningLog } from "node-opcua-debug";
-import { coerceNodeId, type INodeId, type NodeId, NodeIdType } from "node-opcua-nodeid";
+import { coerceNodeId, ExpandedNodeId, type INodeId, type NodeId, NodeIdType } from "node-opcua-nodeid";
 import { EnumDefinition, StructureDefinition } from "node-opcua-types";
 import { lowerFirstLetter } from "node-opcua-utils";
 import { DataType, Variant, type VariantOptions } from "node-opcua-variant";
@@ -31,6 +31,30 @@ import { makeVariantReader } from "./parsers/variant_parser";
 const warningLog = make_warningLog(__filename);
 const debugLog = make_debugLog(__filename);
 
+// textual form of an ExpandedNodeId, as found in <ExpandedNodeId><Identifier>...</Identifier></ExpandedNodeId>:
+// an optional server index, an optional namespace uri, then a plain nodeId. see OPC UA part 6.
+const regexServerIndex = /^svr=([0-9]+);(.*)$/;
+const regexNamespaceUri = /^nsu=(.*?);(.*)$/;
+
+function parseExpandedNodeId(text: string): ExpandedNodeId {
+    let remaining = text.trim();
+    let serverIndex = 0;
+    let namespaceUri: string | null = null;
+
+    const serverIndexMatch = remaining.match(regexServerIndex);
+    if (serverIndexMatch) {
+        serverIndex = parseInt(serverIndexMatch[1], 10);
+        remaining = serverIndexMatch[2];
+    }
+    const namespaceUriMatch = remaining.match(regexNamespaceUri);
+    if (namespaceUriMatch) {
+        namespaceUri = namespaceUriMatch[1];
+        remaining = namespaceUriMatch[2];
+    }
+    const nodeId = coerceNodeId(remaining);
+    return new ExpandedNodeId(nodeId.identifierType, nodeId.value, nodeId.namespace, namespaceUri, serverIndex);
+}
+
 function clamp(value: number, minValue: number, maxValue: number) {
     if (value < minValue) {
         warningLog(`invalid value range : ${value} < ${minValue} but should be [${minValue} , ${maxValue}]`);
@@ -169,6 +193,13 @@ const partials = {
             // to do check Local or GMT
             this.value = coerceNodeId(this.text);
         }
+    },
+
+    // <ExpandedNodeId><Identifier>svr=1;nsu=http://acme.com/UA/;i=42</Identifier></ExpandedNodeId>
+    ExpandedNodeId: <Parser<ExpandedNodeId>>{
+        finish(this: Parser<ExpandedNodeId>) {
+            this.value = parseExpandedNodeId(this.text);
+        }
     }
 };
 
@@ -231,10 +262,16 @@ function _makeTypeReader(
     let reader: ReaderStateParserLike = readerMap.get(dataTypeName)!;
 
     if (reader) {
-        return { name, reader: reader.parser! };
+        return { name, reader };
     }
 
     reader = {
+        init(this: any) {
+            // the same reader instance is used for every element of that data type: the value must be
+            // reset here, or the element being read would inherit the fields of the previously read one
+            // ( or of the enclosing one, when the structure refers to itself ).
+            this.value = undefined;
+        },
         finish(this: any) {
             /** empty  */
         },
@@ -244,6 +281,12 @@ function _makeTypeReader(
     };
 
     if (definition instanceof StructureDefinition) {
+        // the reader must be registered *before* its fields are explored: a structure may refer to
+        // itself, directly or through one of its fields, and the recursion below would never end.
+        // `reader` and `reader.parser` keep their identity while being filled, so a nested reference
+        // that picks the reader up from the map ends up pointing at the completed reader.
+        readerMap.set(dataTypeName, reader);
+
         for (const field of definition.fields || []) {
             const typeReader = _makeTypeReader(field.dataType, definitionMap, readerMap, translateNodeId);
             const fieldParser = typeReader.reader;
@@ -260,11 +303,11 @@ function _makeTypeReader(
                     throw new Error(`??? ${field.dataType}  ${field.name}`);
                 }
 
-                reader.parser![field.name!] = {
+                reader.parser![field.name || ""] = {
                     parser: fieldParser.parser,
                     // endElement: fieldReader.endElement,
                     finish(this: any) {
-                        const elName = lowerFirstLetter(field.name!);
+                        const elName = lowerFirstLetter(field.name || "");
                         if (fieldParser.finish) {
                             fieldParser.finish.call(this);
                         } else {
@@ -301,7 +344,6 @@ function _makeTypeReader(
                 throw new Error("Unsupported ValueRank !");
             }
         }
-        readerMap.set(dataTypeName, reader);
         return { name, reader };
     } else if (definition instanceof EnumDefinition) {
         const turnToInt = (value: any) => {

package/source/namespace_data_access.ts

@@ -2,7 +2,8 @@ import type {
     AddVariableOptionsWithoutValue,
     AddYArrayItemOptions,
     BindVariableOptions,
-    UADataType
+    UADataType,
+    UAVariableType
 } from "node-opcua-address-space-base";
 import type { NodeIdLike } from "node-opcua-nodeid";
 import type { UAAnalogItem, UADataItem } from "node-opcua-nodeset-ua";
@@ -45,6 +46,13 @@ export interface AddAnalogDataItemOptions extends AddDataItemOptions {
     minimumSamplingInterval?: number;
     dataType?: string | NodeIdLike | UADataType;
 
+    /**
+     * an optional VariableType, which must be a subtype of AnalogItemType, to use instead of the
+     * plain AnalogItemType. Its own mandatory members (if any) will be instantiated as well.
+     * @default AnalogItemType
+     */
+    typeDefinition?: string | NodeIdLike | UAVariableType;
+
     /**
      * the acceptValueOutOfRange property indicates whether the write operation will accept or reject a value which
      * is out of range of the instrumentRange.

package/src/namespace_impl.ts

@@ -45,7 +45,7 @@ import {
     type QualifiedNameLike
 } from "node-opcua-data-model";
 import { dumpIf, make_errorLog, make_warningLog } from "node-opcua-debug";
-import { coerceNodeId, NodeId, type NodeIdLike, NodeIdType, resolveNodeId } from "node-opcua-nodeid";
+import { coerceNodeId, NodeId, type NodeIdLike, NodeIdType, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
 import type { UAAnalogItem, UADataItem, UAInitialState, UAState } from "node-opcua-nodeset-ua";
 import { StatusCodes } from "node-opcua-status-code";
 import {
@@ -903,9 +903,52 @@ export class NamespaceImpl implements NamespacePrivate {
             throw new Error("expecting AnalogItemType to be defined , check nodeset xml file");
         }
 
-        const clone_options = { ...options, dataType, typeDefinition: analogItemType.nodeId } as AddVariableOptions;
-
-        const variable = this.addVariable(clone_options) as unknown as UAVariableImpl;
+        // options.typeDefinition may designate a subtype of AnalogItemType (e.g. a companion
+        // specification's own AnalogItemType-derived VariableType). In that case we must honor it
+        // so that the subtype's identity - and its own mandatory members - are preserved, instead of
+        // silently downgrading the variable to a plain AnalogItemType.
+        let requestedTypeDefinition = analogItemType;
+        if (options.typeDefinition) {
+            const t =
+                options.typeDefinition instanceof BaseNodeImpl
+                    ? (options.typeDefinition as unknown as UAVariableType)
+                    : addressSpace.findVariableType(options.typeDefinition as NodeIdLike);
+            if (!t) {
+                throw new Error(`cannot find requested typeDefinition ${options.typeDefinition.toString()}`);
+            }
+            if (!t.isSubtypeOf(analogItemType)) {
+                throw new Error(`typeDefinition ${t.browseName.toString()} shall be a subtype of AnalogItemType`);
+            }
+            requestedTypeDefinition = t;
+        }
+        const isStrictSubtype = !sameNodeId(requestedTypeDefinition.nodeId, analogItemType.nodeId);
+
+        let variable: UAVariableImpl;
+        if (isStrictSubtype) {
+            // instantiate the requested subtype so that its own mandatory members
+            // (in addition to the AnalogItemType ones) get materialized.
+            const optionals: string[] = [];
+            if (Object.hasOwn(options, "instrumentRange")) {
+                optionals.push("InstrumentRange");
+            }
+            if (Object.hasOwn(options, "engineeringUnits")) {
+                optionals.push("EngineeringUnits");
+            }
+            variable = requestedTypeDefinition.instantiate({
+                browseName: options.browseName,
+                componentOf: options.componentOf,
+                dataType: addressSpace._coerce_DataType(dataType as NodeIdLike),
+                modellingRule: options.modellingRule,
+                nodeId: options.nodeId,
+                notifierOf: options.notifierOf,
+                eventSourceOf: options.eventSourceOf,
+                organizedBy: options.organizedBy,
+                optionals
+            }) as unknown as UAVariableImpl;
+        } else {
+            const clone_options = { ...options, dataType, typeDefinition: analogItemType.nodeId } as AddVariableOptions;
+            variable = this.addVariable(clone_options) as unknown as UAVariableImpl;
+        }
 
         add_dataItem_stuff(variable, options);
 
@@ -920,38 +963,59 @@ export class NamespaceImpl implements NamespacePrivate {
         // prepared to handle this.
         //     Example:    EURange ::= {-200.0,1400.0}
 
-        const euRange = this.addVariable({
-            browseName: { name: "EURange", namespaceIndex: 0 },
-            dataType: "Range",
-            minimumSamplingInterval: 0,
-            modellingRule: options.modellingRule,
-            propertyOf: variable,
-            typeDefinition: "PropertyType",
-            value: new Variant({
-                dataType: DataType.ExtensionObject,
-                value: new Range(options.engineeringUnitsRange)
-            })
-        }) as unknown as UAVariableImpl;
-
-        assert(euRange.readValue().value.value instanceof Range);
-
-        const handler = variable.handle_semantic_changed.bind(variable);
-        euRange.on("value_changed", handler);
-
-        if (Object.hasOwn(options, "instrumentRange")) {
-            const instrumentRange = this.addVariable({
-                accessLevel: "CurrentRead | CurrentWrite",
-                browseName: { name: "InstrumentRange", namespaceIndex: 0 },
+        // when `variable` was instantiated from a strict AnalogItemType subtype (isStrictSubtype),
+        // EURange/InstrumentRange/EngineeringUnits may already exist as cloned mandatory/optional
+        // members of that subtype - reuse them instead of creating duplicate property nodes.
+        const euRangeExisting = variable.getPropertyByName("EURange") as UAVariableImpl | null;
+        const euRange =
+            euRangeExisting ||
+            (this.addVariable({
+                browseName: { name: "EURange", namespaceIndex: 0 },
                 dataType: "Range",
                 minimumSamplingInterval: 0,
-                modellingRule: options.modellingRule ? "Mandatory" : undefined,
+                modellingRule: options.modellingRule,
                 propertyOf: variable,
                 typeDefinition: "PropertyType",
                 value: new Variant({
                     dataType: DataType.ExtensionObject,
-                    value: new Range(options.instrumentRange)
+                    value: new Range(options.engineeringUnitsRange)
                 })
-            });
+            }) as unknown as UAVariableImpl);
+        if (euRangeExisting) {
+            euRange.setValueFromSource(
+                new Variant({ dataType: DataType.ExtensionObject, value: new Range(options.engineeringUnitsRange) }),
+                StatusCodes.Good
+            );
+        }
+
+        assert(euRange.readValue().value.value instanceof Range);
+
+        const handler = variable.handle_semantic_changed.bind(variable);
+        euRange.on("value_changed", handler);
+
+        if (Object.hasOwn(options, "instrumentRange")) {
+            const instrumentRangeExisting = variable.getPropertyByName("InstrumentRange") as UAVariableImpl | null;
+            const instrumentRange =
+                instrumentRangeExisting ||
+                this.addVariable({
+                    accessLevel: "CurrentRead | CurrentWrite",
+                    browseName: { name: "InstrumentRange", namespaceIndex: 0 },
+                    dataType: "Range",
+                    minimumSamplingInterval: 0,
+                    modellingRule: options.modellingRule ? "Mandatory" : undefined,
+                    propertyOf: variable,
+                    typeDefinition: "PropertyType",
+                    value: new Variant({
+                        dataType: DataType.ExtensionObject,
+                        value: new Range(options.instrumentRange)
+                    })
+                });
+            if (instrumentRangeExisting) {
+                instrumentRange.setValueFromSource(
+                    new Variant({ dataType: DataType.ExtensionObject, value: new Range(options.instrumentRange) }),
+                    StatusCodes.Good
+                );
+            }
 
             instrumentRange.on("value_changed", handler);
         }
@@ -964,19 +1028,28 @@ export class NamespaceImpl implements NamespacePrivate {
             // EngineeringUnits  specifies the units for the   DataItem‟s value (e.g., degree, hertz, seconds).   The
             // EUInformation   type is specified in   5.6.3.
 
-            const eu = this.addVariable({
-                accessLevel: "CurrentRead",
-                browseName: { name: "EngineeringUnits", namespaceIndex: 0 },
-                dataType: "EUInformation",
-                minimumSamplingInterval: 0,
-                modellingRule: options.modellingRule ? "Mandatory" : undefined,
-                propertyOf: variable,
-                typeDefinition: "PropertyType",
-                value: new Variant({
-                    dataType: DataType.ExtensionObject,
-                    value: engineeringUnits
-                })
-            });
+            const euExisting = variable.getPropertyByName("EngineeringUnits") as UAVariableImpl | null;
+            const eu =
+                euExisting ||
+                this.addVariable({
+                    accessLevel: "CurrentRead",
+                    browseName: { name: "EngineeringUnits", namespaceIndex: 0 },
+                    dataType: "EUInformation",
+                    minimumSamplingInterval: 0,
+                    modellingRule: options.modellingRule ? "Mandatory" : undefined,
+                    propertyOf: variable,
+                    typeDefinition: "PropertyType",
+                    value: new Variant({
+                        dataType: DataType.ExtensionObject,
+                        value: engineeringUnits
+                    })
+                });
+            if (euExisting) {
+                eu.setValueFromSource(
+                    new Variant({ dataType: DataType.ExtensionObject, value: engineeringUnits }),
+                    StatusCodes.Good
+                );
+            }
 
             eu.on("value_changed", handler);
         }

package/src/nodeid_manager.ts

@@ -72,7 +72,7 @@ function _findParentNodeId(addressSpace: AddressSpacePartial, options: Construct
 
 function prepareName(browseName?: QualifiedName | QualifiedNameOptions): string {
     const m = browseName?.name?.toString().replace(/[ ]/g, "").replace(/(<|>)/g, "");
-    return m ||"";
+    return m || "";
 }
 
 export interface AddressSpacePartial {
@@ -169,13 +169,14 @@ export class NodeIdManager {
                 const [parentNodeId, suffix] = parentInfo;
                 fullParentName = buildUpName2(parentNodeId, suffix);
             }
-            const fullName = compose(fullParentName, prepareName(options.browseName!));
-            if (this._cacheSymbolicName[fullName]) {
-                return makeNodeId(this._cacheSymbolicName[fullName][0], this.namespaceIndex);
+            const fullName = compose(fullParentName, prepareName(options.browseName));
+            const cached = this._cacheSymbolicName[fullName];
+            if (cached && this._isCacheHitReusable(cached[0], options, parentInfo)) {
+                return makeNodeId(cached[0], this.namespaceIndex);
             }
             const nodeId = this._constructNodeId(options);
-            if (nodeId.identifierType === NodeIdType.NUMERIC) {
-                this._cacheSymbolicName[fullName] = [nodeId.value as number, options.nodeClass!];
+            if (nodeId.identifierType === NodeIdType.NUMERIC && !cached) {
+                this._cacheSymbolicName[fullName] = [nodeId.value as number, options.nodeClass || NodeClass.Unspecified];
                 this._cacheSymbolicNameRev.add(nodeId.value as number);
             }
             return nodeId;
@@ -192,15 +193,55 @@ export class NodeIdManager {
                 const [parentNodeId, suffix] = parentInfo;
                 fullParentName = buildUpName2(parentNodeId, suffix);
             }
-            const fullName = compose(fullParentName, prepareName(options.browseName!));
+            const fullName = compose(fullParentName, prepareName(options.browseName));
             if (!this._cacheSymbolicName[fullName]) {
-                this._cacheSymbolicName[fullName] = [nodeId.value as number, options.nodeClass!];
+                this._cacheSymbolicName[fullName] = [nodeId.value as number, options.nodeClass || NodeClass.Unspecified];
                 this._cacheSymbolicNameRev.add(nodeId.value as number);
             }
         }
         return nodeId;
     }
 
+    /**
+     * A symbol-cache hit is only safe to reuse when it actually refers to
+     * the node we are about to construct. Because the cache key is built
+     * from a (possibly truncated, e.g. during a clone where parentNodeId
+     * isn't linked yet) parent-name chain, two unrelated nodes can end up
+     * sharing the same key. When that happens, reusing the cached nodeId
+     * would hand a brand-new node the identity of a completely different,
+     * already-registered one.
+     *
+     * We only trust the cache hit when either:
+     *  - nothing occupies that nodeId yet (first-time reservation), or
+     *  - the occupant is genuinely the same node (same browseName AND same
+     *    parent) - in which case we deliberately return the same id so
+     *    that the caller's duplicate-registration error still fires.
+     */
+    private _isCacheHitReusable(value: number, options: ConstructNodeIdOptions, parentInfo: [NodeId, Suffix] | null): boolean {
+        const candidate = makeNodeId(value, this.namespaceIndex);
+        const occupant = this.addressSpace.findNode(candidate);
+        if (!occupant) {
+            return true;
+        }
+        // options.browseName is expected to already carry its real, resolved namespaceIndex by the
+        // time it reaches here: internalCreateNode() normalizes plain-string browseNames to
+        // `namespaceIndex: this.index` before construction, so `0` here means "explicitly namespace 0"
+        // (e.g. the standard "0:EURange" / "0:EngineeringUnits" properties), not "unspecified".
+        // Comparing literally keeps genuinely different namespaces (own-namespace vs explicit ns 0)
+        // from being treated as the same node.
+        const sameBrowseName =
+            !!occupant.browseName &&
+            occupant.browseName.name === (options.browseName?.name ?? null) &&
+            (occupant.browseName.namespaceIndex ?? 0) === (options.browseName?.namespaceIndex ?? 0);
+
+        const expectedParentNodeId = parentInfo ? parentInfo[0] : null;
+        const sameParent = expectedParentNodeId
+            ? !!occupant.parentNodeId && sameNodeId(occupant.parentNodeId, expectedParentNodeId)
+            : !occupant.parentNodeId;
+
+        return sameBrowseName && sameParent;
+    }
+
     private _constructNodeId(options: ConstructNodeIdOptions): NodeId {
 
         const resolveNodeIdEx = (nodeId: BaseNode | NodeIdLike) =>

package/src/nodeset_tools/dump_to_bsd.ts

@@ -16,7 +16,7 @@ function dumpEnumeratedType(xw: XmlWriter, e: EnumDefinition, name: string): voi
     xw.writeAttribute("LengthInBits", "32");
     for (const f of e.fields || []) {
         xw.startElement("opc:EnumeratedValue");
-        xw.writeAttribute("Name", f.name!);
+        xw.writeAttribute("Name", f.name|| "");
         assert(f.value[0] === 0, "unsupported 64 bit value !");
         xw.writeAttribute("Value", f.value[1].toString());
         xw.endElement();
@@ -119,15 +119,15 @@ function dumpDataTypeStructure(
         }
 
         xw.startElement("opc:Field");
-        xw.writeAttribute("Name", f.name!);
+        xw.writeAttribute("Name", f.name|| "");
 
         const typeName = buildXmlName(addressSpace as AddressSpacePrivate, map, f.dataType);
         xw.writeAttribute("TypeName", typeName);
         if (isArray) {
-            xw.writeAttribute("LengthField", `NoOf${f.name!}`);
+            xw.writeAttribute("LengthField", `NoOf${f.name|| ""}`);
         }
         if (f.isOptional) {
-            xw.writeAttribute("SwitchField", `${f.name}Specified`);
+            xw.writeAttribute("SwitchField", `${f.name|| ""}Specified`);
         }
         xw.endElement();
     }
@@ -137,7 +137,7 @@ function dumpDataTypeStructure(
 function dumpDataTypeToBSD(xw: XmlWriter, dataType: UADataType, map: Map<number, string>) {
     const addressSpace = dataType.addressSpace;
 
-    const name: string = dataType.browseName.name!;
+    const name: string = dataType.browseName.name || "";
 
     const definition = dataType.getDefinition();
     if (definition instanceof StructureDefinition) {

package/src/nodeset_tools/nodeset_to_xml.ts

@@ -898,7 +898,7 @@ function _dumpStructureDefinition(
     for (let index = nbFieldsInBase; index < fields.length; index++) {
         const defItem = fields[index];
         xw.startElement("Field");
-        xw.writeAttribute("Name", defItem.name!);
+        xw.writeAttribute("Name", defItem.name as string);
 
         if (defItem.arrayDimensions) {
             xw.writeAttribute("ArrayDimensions", defItem.arrayDimensions.map((x) => x.toString()).join(","));