node-opcua-address-space 2.57.0 → 2.61.0

package/src/base_node_private.ts

@@ -34,12 +34,16 @@ import {
     CloneOptions
 } from "node-opcua-address-space-base";
 import { DataValue } from "node-opcua-data-value";
+import { ObjectTypeIds, VariableTypeIds } from "node-opcua-constants";
 
 import { UANamespace_process_modelling_rule } from "./namespace_private";
 import { ReferenceImpl } from "./reference_impl";
 import { BaseNodeImpl, getReferenceType } from "./base_node_impl";
 import { AddressSpacePrivate } from "./address_space_private";
-import { UAObjectImpl } from "./ua_object_impl";
+
+// eslint-disable-next-line prefer-const
+let dotrace = false;
+const traceLog = console.log.bind(console);
 
 const g_weakMap = new WeakMap();
 
@@ -184,7 +188,10 @@ export function BaseNode_References_toString(this: BaseNode, options: ToStringOp
     const addressSpace = this.addressSpace;
 
     options.add(
-        options.padding + chalk.yellow("          references    : ") + "  length =" + Object.keys(_private._referenceIdx).length
+        options.padding +
+            chalk.yellow("    references                : ") +
+            "  length =" +
+            Object.keys(_private._referenceIdx).length
     );
 
     function dump_reference(follow: boolean, reference: UAReference | null) {
@@ -193,8 +200,37 @@ export function BaseNode_References_toString(this: BaseNode, options: ToStringOp
         }
         const o = ReferenceImpl.resolveReferenceNode(addressSpace, reference);
         const name = o ? o.browseName.toString() : "<???>";
+        const extra =
+            (o.modellingRule || " ")[0] +
+            (() => {
+                switch (o.nodeClass) {
+                    case NodeClass.Object:
+                        return "[O] ";
+                    case NodeClass.Variable:
+                        return "[V] " + (o as UAVariable).dataType.toString(displayOptions).padEnd(10);
+                    case NodeClass.Method:
+                        return "[M] ";
+                    case NodeClass.DataType:
+                        return "[DT]";
+                    case NodeClass.ReferenceType:
+                        return "[RT]";
+                    case NodeClass.ObjectType:
+                        return "[OT]";
+                    case NodeClass.VariableType:
+                        return "[VT]";
+                    case NodeClass.View:
+                        return "[V] ";
+                }
+                return "";
+            })();
         options.add(
-            options.padding + chalk.yellow("               +-> ") + reference.toString(displayOptions) + " " + chalk.cyan(name)
+            options.padding +
+                chalk.yellow("      +-> ") +
+                reference.toString(displayOptions) +
+                " " +
+                chalk.cyan(name.padEnd(25, " ")) +
+                " " +
+                chalk.magentaBright(extra)
         );
 
         // ignore HasTypeDefinition as it has been already handled
@@ -223,7 +259,7 @@ export function BaseNode_References_toString(this: BaseNode, options: ToStringOp
 
     options.add(
         options.padding +
-            chalk.yellow("          back_references     : ") +
+            chalk.yellow("    back_references                 : ") +
             chalk.cyan("  length =") +
             br.length +
             chalk.grey(" ( references held by other nodes involving this node)")
@@ -343,6 +379,10 @@ function AccessLevelFlags_toString(this: UAVariable, options: ToStringOption) {
         );
     }
 }
+
+interface WithDataValue {
+    $dataValue?: DataValue;
+}
 export function VariableOrVariableType_toString(this: UAVariableType | UAVariable, options: ToStringOption): void {
     assert(options);
     if (this.dataType) {
@@ -352,7 +392,7 @@ export function VariableOrVariableType_toString(this: UAVariableType | UAVariabl
         options.add(options.padding + chalk.yellow("          dataType            : ") + this.dataType + "  " + n);
     }
     if (this.nodeClass === NodeClass.Variable) {
-        const _dataValue = (<any>this)._dataValue as DataValue | undefined;
+        const _dataValue = (<WithDataValue>this).$dataValue as DataValue | undefined;
         if (_dataValue) {
             options.add(
                 options.padding +
@@ -392,6 +432,16 @@ export function VariableOrVariableType_toString(this: UAVariableType | UAVariabl
     }
 }
 
+const defaultExtraInfo = {
+    level: 0,
+    pad(): string {
+        return "";
+    },
+    registerClonedObject(node: BaseNode, node1: BaseNode): void {
+        /** */
+    }
+};
+
 /**
  * clone properties and methods
  * @private
@@ -400,17 +450,17 @@ function _clone_collection_new(
     newParent: BaseNode,
     collectionRef: UAReference[],
     copyAlsoModellingRules: boolean,
-    optionalFilter?: CloneFilter,
-    extraInfo?: CloneExtraInfo
+    optionalFilter: CloneFilter,
+    extraInfo: CloneExtraInfo,
+    browseNameMap: Set<string>
 ): void {
     const namespace = newParent.namespace;
-
+    extraInfo = extraInfo || defaultExtraInfo;
     const addressSpace = newParent.addressSpace;
     assert(!optionalFilter || (typeof optionalFilter.shouldKeep === "function" && typeof optionalFilter.filterFor === "function"));
 
     for (const reference of collectionRef) {
-        const node: BaseNode = ReferenceImpl.resolveReferenceNode(addressSpace, reference);
-
+        const node = ReferenceImpl.resolveReferenceNode(addressSpace, reference) as UAVariable | UAObject | UAMethod;
         // ensure node is of the correct type,
         // it may happen that the xml nodeset2 file was malformed
 
@@ -429,18 +479,41 @@ function _clone_collection_new(
         }
 
         if (optionalFilter && node && !optionalFilter.shouldKeep(node)) {
+            dotrace && traceLog(extraInfo.pad(), "skipping ", node.browseName.toString());
             continue; // skip this node
         }
+        const key = node.browseName.toString();
+        if (browseNameMap?.has(key)) {
+            continue; // skipping node with same browseName
+        }
+        browseNameMap?.add(key);
 
-        assert(reference.isForward);
-        assert(reference.referenceType instanceof NodeId, "" + reference.referenceType.toString());
+        // assert(reference.isForward);
+        // assert(reference.referenceType instanceof NodeId, "" + reference.referenceType.toString());
         const options = {
             namespace,
             references: [new ReferenceImpl({ referenceType: reference.referenceType, isForward: false, nodeId: newParent.nodeId })],
             copyAlsoModellingRules
         };
 
+        dotrace &&
+            traceLog(
+                extraInfo.pad(),
+                "cloning => ",
+                reference.referenceType.toString({ addressSpace }),
+                "=>",
+                node.browseName.toString(),
+                chalk.magentaBright(node.typeDefinitionObj?.browseName.toString())
+            );
+
+        extraInfo.level += 4;
         const clone = (node as UAVariable | UAMethod | UAObject).clone(options, optionalFilter, extraInfo);
+        extraInfo.level -= 4;
+
+        // also clone or instantiate interface members that may be required in the optionals
+        extraInfo.level++;
+        _cloneInterface(newParent, node, optionalFilter, extraInfo, browseNameMap);
+        extraInfo.level--;
 
         if (extraInfo) {
             extraInfo.registerClonedObject(node, clone);
@@ -448,24 +521,179 @@ function _clone_collection_new(
     }
 }
 
-export function _clone_children_references(
-    node: BaseNode,
+type UAInterface = UAObjectType;
+function _extractInterfaces2(typeDefinitionNode: UAObjectType | UAVariableType, extraInfo: CloneExtraInfo): UAInterface[] {
+    if (
+        !typeDefinitionNode ||
+        (typeDefinitionNode.nodeId.namespace === 0 &&
+            (typeDefinitionNode.nodeId.value === ObjectTypeIds.BaseObjectType ||
+                typeDefinitionNode.nodeId.value === VariableTypeIds.BaseVariableType))
+    ) {
+        return [];
+    }
+
+    const addressSpace = typeDefinitionNode.addressSpace;
+    // example:
+    // FolderType
+    //   FunctionalGroupType
+    //     MachineryItemIdentificationType     : IMachineryItemVendorNameplateType
+    //       MachineIdentificationType         : IMachineTagNameplateType, IMachineVendorNamePlateType
+    //         MachineToolIdentificationType
+    //
+    //
+    // IMachineTagNameplateType            -subTypeOf-> ITagNameplateType
+    // IMachineVendorNamePlateType         -subTypeOf-> IMachineryItemVendorNamePlateType
+    // IMachineryItemVendorNamePlateType   -subTypeOf-> IVendorNameplateType
+    const interfacesRef = typeDefinitionNode.findReferencesEx("HasInterface", BrowseDirection.Forward);
+    const interfaces = interfacesRef.map((r) => addressSpace.findNode(r.nodeId) as UAInterface);
+
+    const baseInterfaces: UAInterface[] = [];
+    for (const iface of interfaces) {
+        dotrace &&
+            traceLog(
+                extraInfo.pad(),
+                typeDefinitionNode.browseName.toString(),
+                " - has interface -> ",
+                iface.browseName.toString()
+            );
+        baseInterfaces.push(iface);
+        if (iface.subtypeOfObj) {
+            extraInfo.level++;
+            baseInterfaces.push(..._extractInterfaces2(iface.subtypeOfObj, extraInfo));
+            extraInfo.level--;
+        }
+    }
+    interfaces.push(...baseInterfaces);
+    if (typeDefinitionNode.subtypeOfObj) {
+        dotrace &&
+            traceLog(
+                extraInfo.pad(),
+                typeDefinitionNode.browseName.toString(),
+                " - subtypef  -> ",
+                typeDefinitionNode.subtypeOfObj.browseName.toString()
+            );
+        extraInfo.level++;
+        interfaces.push(..._extractInterfaces2(typeDefinitionNode.subtypeOfObj, extraInfo));
+        extraInfo.level--;
+    }
+    const dedupedInterfaces = [...new Set(interfaces)];
+
+    dotrace &&
+        traceLog(
+            extraInfo.pad(),
+            chalk.yellow("Interface for ", typeDefinitionNode.browseName.toString()),
+            "=",
+            dedupedInterfaces.map((x) => x.browseName.toString()).join(" ")
+        );
+    return dedupedInterfaces;
+}
+
+/*
+
+    // also find all related interfaces
+    if (false && typeDefinitionNode) {
+        dotrace && tracelog("typeDefinitionNode = ", typeDefinitionNode.browseName.toString());
+        const interfaces = _extractInterfaces(typeDefinitionNode);
+        for (const interfaceNode of interfaces) {
+            dotrace && tracelog("   adding member of interface ", interfaceNode.browseName.toString());
+            const fromInterface = interfaceNode.findReferencesEx("Aggregates", BrowseDirection.Forward);
+            dotrace && tracelog(
+                "             B   ",
+                fromInterface.map((r) => r.toString({ addressSpace }) + " " + r.node!.browseName.toString()).join("\n")
+            );
+            add(fromInterface);
+        }
+    }
+    */
+
+function _crap_extractInterfaces(typeDefinitionNode: UAObjectType | UAVariableType, extraInfo: CloneExtraInfo): UAInterface[] {
+    if (
+        typeDefinitionNode.nodeId.namespace === 0 &&
+        (typeDefinitionNode.nodeId.value === ObjectTypeIds.BaseObjectType ||
+            typeDefinitionNode.nodeId.value === VariableTypeIds.BaseVariableType)
+    ) {
+        return [];
+    }
+
+    const addressSpace = typeDefinitionNode.addressSpace;
+    // example:
+    // FolderType
+    //   FunctionalGroupType
+    //     MachineryItemIdentificationType     : IMachineryItemVendorNameplateType
+    //       MachineIdentificationType         : IMachineTagNameplateType, IMachineVendorNamePlateType
+    //         MachineToolIdentificationType
+    //
+    //
+    // IMachineTagNameplateType            -subTypeOf-> ITagNameplateType
+    // IMachineVendorNamePlateType         -subTypeOf-> IMachineryItemVendorNamePlateType
+    // IMachineryItemVendorNamePlateType   -subTypeOf-> IVendorNameplateType
+    const interfacesRef = typeDefinitionNode.findReferencesEx("HasInterface", BrowseDirection.Forward);
+    const interfaces = interfacesRef.map((r) => r.node! as UAInterface);
+    for (const iface of interfaces) {
+        dotrace && traceLog(extraInfo.pad(), "   interface ", iface.browseName.toString());
+    }
+
+    return interfaces;
+}
+
+function _cloneInterface(
     newParent: BaseNode,
+    node: UAObject | UAVariable | UAMethod,
+    optionalFilter: CloneFilter,
+    extraInfo: CloneExtraInfo,
+    browseNameMap: Set<string>
+): void {
+    dotrace &&
+        traceLog(
+            extraInfo?.pad(),
+            chalk.green("-------------------- now cloning interfaces of ", node.browseName.toString(), node.nodeId.toString())
+        );
+
+    extraInfo = extraInfo || defaultExtraInfo;
+    const addressSpace = node.addressSpace;
+    const typeDefinitionNode = node.typeDefinitionObj;
+    if (!typeDefinitionNode) {
+        return;
+    }
+    dotrace && traceLog(extraInfo.pad(), "  --- {");
+    const interfaces = _extractInterfaces2(typeDefinitionNode, extraInfo);
+    dotrace && traceLog(extraInfo.pad(), "  --- }");
+    dotrace && traceLog(extraInfo?.pad(), chalk.green("-------------------- interfaces are  ", interfaces.length));
+
+    const localFilter = optionalFilter.filterFor(node);
+
+    for (const iface of interfaces) {
+        const aggregates = iface.findReferencesEx("Aggregates", BrowseDirection.Forward);
+        dotrace &&
+            traceLog(
+                extraInfo.pad(),
+                chalk.magentaBright("   interface ", iface.browseName.toString()),
+                "\n" + extraInfo?.pad(),
+                aggregates.map((r) => r.toString({ addressSpace })).join("\n" + extraInfo?.pad())
+            );
+        _clone_collection_new(newParent, aggregates, false, localFilter, extraInfo, browseNameMap);
+    }
+}
+export function _clone_children_references(
+    node: UAObject | UAVariable | UAMethod | UAObjectType | UAVariableType,
+    newParent: UAObject | UAVariable | UAMethod,
     copyAlsoModellingRules: boolean,
-    optionalFilter?: CloneFilter,
-    extraInfo?: CloneExtraInfo
+    optionalFilter: CloneFilter,
+    extraInfo: CloneExtraInfo,
+    browseNameMap: Set<string>
 ): void {
     // find all reference that derives from the Aggregates
     const aggregatesRef = node.findReferencesEx("Aggregates", BrowseDirection.Forward);
-    _clone_collection_new(newParent, aggregatesRef, copyAlsoModellingRules, optionalFilter, extraInfo);
+    _clone_collection_new(newParent, aggregatesRef, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap);
 }
 
 export function _clone_non_hierarchical_references(
     node: BaseNode,
     newParent: BaseNode,
     copyAlsoModellingRules: boolean,
-    optionalFilter?: CloneFilter,
-    extraInfo?: CloneExtraInfo
+    optionalFilter: CloneFilter,
+    extraInfo: CloneExtraInfo,
+    browseNameMap: Set<string>
 ): void {
     // clone only some non hierarchical_references that we do want to clone
     // such as:
@@ -474,7 +702,7 @@ export function _clone_non_hierarchical_references(
     assert(newParent instanceof BaseNodeImpl);
     // find all reference that derives from the HasSubStateMachine
     const references = node.findReferencesEx("HasSubStateMachine", BrowseDirection.Forward);
-    _clone_collection_new(newParent, references, copyAlsoModellingRules, optionalFilter, extraInfo);
+    _clone_collection_new(newParent, references, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap);
 }
 
 /**
@@ -485,8 +713,8 @@ export function _clone<T extends UAObject | UAVariable | UAMethod>(
     this: T,
     Constructor: new (options: any) => T,
     options: CloneOptions,
-    optionalFilter?: CloneFilter,
-    extraInfo?: CloneExtraInfo
+    optionalFilter: CloneFilter,
+    extraInfo: CloneExtraInfo
 ): T {
     assert(typeof Constructor === "function");
     assert(options !== null && typeof options === "object");
@@ -544,9 +772,31 @@ export function _clone<T extends UAObject | UAVariable | UAMethod>(
 
     options.copyAlsoModellingRules = options.copyAlsoModellingRules || false;
 
-    const newFilter = optionalFilter ? optionalFilter.filterFor(cloneObj) : undefined;
-    _clone_children_references(this, cloneObj, options.copyAlsoModellingRules, newFilter, extraInfo);
-    _clone_non_hierarchical_references(this, cloneObj, options.copyAlsoModellingRules, newFilter, extraInfo);
+    const newFilter = optionalFilter.filterFor(cloneObj);
+
+    const browseNameMap = new Set<string>();
+    _clone_children_references(this, cloneObj, options.copyAlsoModellingRules, newFilter!, extraInfo, browseNameMap);
+
+    //
+    let typeDefinitionNode: UAVariableType | UAObjectType | null = this.typeDefinitionObj;
+    while (typeDefinitionNode) {
+        dotrace &&
+            traceLog(
+                extraInfo?.pad(),
+                chalk.blueBright("---------------------- Exploring ", typeDefinitionNode.browseName.toString())
+            );
+        _clone_children_references(
+            typeDefinitionNode,
+            cloneObj,
+            options.copyAlsoModellingRules,
+            newFilter,
+            extraInfo,
+            browseNameMap
+        );
+        typeDefinitionNode = typeDefinitionNode.subtypeOfObj;
+    }
+
+    _clone_non_hierarchical_references(this, cloneObj, options.copyAlsoModellingRules, newFilter, extraInfo, browseNameMap);
 
     cloneObj.propagate_back_references();
 
@@ -584,7 +834,7 @@ function _remove_HierarchicalReference(node: BaseNode, reference: UAReference) {
             if (referenceType.isSupertypeOf(HierarchicalReferencesType!)) {
                 assert(reference.isForward);
                 const targetNode = ReferenceImpl.resolveReferenceNode(addressSpace, reference);
-                // Xx console.log(" adding object to map");
+                // Xx dotrace && tracelog(" adding object to map");
                 delete _cache._childByNameMap[targetNode.browseName!.name!.toString()];
             }
         }
@@ -622,7 +872,7 @@ function _makeReferenceDescription(addressSpace: IAddressSpace, reference: UARef
         };
     }
     if (data.typeDefinition === null) {
-        data.typeDefinition = NodeId.nullNodeId;
+        data.typeDefinition = new NodeId();
     }
     const referenceDescription = new ReferenceDescription(data);
     return referenceDescription;
@@ -665,18 +915,14 @@ export function BaseNode_add_backward_reference(this: BaseNode, reference: UARef
     // istanbul ignore next
     if (_private._back_referenceIdx[h]) {
         const opts = { addressSpace: this.addressSpace };
-        // tslint:disable-next-line:no-console
-        console.warn(" Warning !", this.browseName.toString());
-        // tslint:disable-next-line:no-console
-        console.warn("    ", reference.toString(opts));
-        // tslint:disable-next-line:no-console
-        console.warn(" already found in ===>");
-        // tslint:disable-next-line:no-console
-        console.warn(
+        warningLog(" Warning !", this.browseName.toString());
+        warningLog("    ", reference.toString(opts));
+        warningLog(" already found in ===>");
+        warningLog(
             (Object.values(_private._back_referenceIdx) as UAReference[]).map((c: UAReference) => c.toString(opts)).join("\n")
         );
         // tslint:disable-next-line:no-console
-        console.warn("===>");
+        warningLog("===>");
         throw new Error("reference exists already in _back_references");
     }
 

package/src/event_data.ts

@@ -25,7 +25,7 @@ export class EventData implements IEventData {
 
     constructor(eventTypeNode: BaseNode) {
         this.__nodes = {};
-        this.eventId = NodeId.nullNodeId;
+        this.eventId = new NodeId();
         this.$eventDataSource = eventTypeNode;
     }
 

package/src/namespace_impl.ts

@@ -28,7 +28,7 @@ import {
     RolePermissionTypeOptions
 } from "node-opcua-types";
 import * as utils from "node-opcua-utils";
-import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
+import { DataType, Variant, VariantArrayType, verifyRankAndDimensions } from "node-opcua-variant";
 import {
     AddBaseNodeOptions,
     AddEnumerationTypeOptions,
@@ -100,7 +100,7 @@ import { _install_TwoStateVariable_machinery, _addTwoStateVariable } from "./sta
 //
 import { NamespacePrivate, UANamespace_process_modelling_rule } from "./namespace_private";
 import { BaseNodeImpl } from "./base_node_impl";
-import { UAVariableImpl, verifyRankAndDimensions } from "./ua_variable_impl";
+import { UAVariableImpl } from "./ua_variable_impl";
 
 import { ConstructNodeIdOptions, NodeIdManager } from "./nodeid_manager";
 import { _addTwoStateDiscrete } from "./data_access/ua_two_state_discrete";
@@ -238,7 +238,7 @@ export class NamespaceImpl implements NamespacePrivate {
     }
 
     public getDefaultNamespace(): NamespacePrivate {
-        return this.index === 0 ? this : (this.addressSpace.getDefaultNamespace());
+        return this.index === 0 ? this : this.addressSpace.getDefaultNamespace();
     }
 
     public dispose(): void {
@@ -656,7 +656,7 @@ export class NamespaceImpl implements NamespacePrivate {
      */
     public deleteNode(nodeOrNodeId: NodeId | BaseNode): void {
         let node: BaseNode | null = null;
-        let nodeId: NodeId = NodeId.nullNodeId;
+        let nodeId: NodeId = new NodeId();
         if (nodeOrNodeId instanceof NodeId) {
             nodeId = nodeOrNodeId;
             node = this.findNode(nodeId);
@@ -1337,7 +1337,7 @@ export class NamespaceImpl implements NamespacePrivate {
             //   or OptionSet DataType. It is derived from the DataType EnumValueType. If used for an
             //   OptionSet, the corresponding Value in the base type contains the number of the bit associated
             //   with the field. The EnumField is formally defined in Table 37.
-            (enumType as any).$definition = new EnumDefinition({
+            (enumType as any).$fullDefinition = new EnumDefinition({
                 fields: enumeration.map(
                     (x: string, index: number) =>
                         new EnumField({
@@ -1376,7 +1376,7 @@ export class NamespaceImpl implements NamespacePrivate {
             });
             assert(enumValues.browseName.toString() === "EnumValues");
 
-            (enumType as any).$definition = new EnumDefinition({
+            (enumType as any).$fullDefinition = new EnumDefinition({
                 fields: enumeration.map(
                     (x: EnumerationItem, index: number) =>
                         new EnumField({

package/src/nodeset_tools/nodeset_to_xml.ts

@@ -592,7 +592,7 @@ function _dumpValue(xw: XmlWriter, node: UAVariable | UAVariableType, value: Var
 
 function _dumpArrayDimensionsAttribute(xw: XmlWriter, node: UAVariableType | UAVariable) {
     if (node.arrayDimensions) {
-        if (node.arrayDimensions.length === 1 && node.arrayDimensions[0] === 0) {
+        if (node.valueRank === -1 || (node.arrayDimensions.length === 1 && node.arrayDimensions[0] === 0)) {
             return;
         }
         xw.writeAttribute("ArrayDimensions", node.arrayDimensions.join(","));
@@ -749,7 +749,11 @@ function _dumpEnumDefinition(xw: XmlWriter, enumDefinition: EnumDefinition) {
         xw.endElement();
     }
 }
-function _dumpStructureDefinition(xw: XmlWriter, structureDefinition: StructureDefinition) {
+function _dumpStructureDefinition(
+    xw: XmlWriter,
+    structureDefinition: StructureDefinition,
+    baseStructureDefinition: StructureDefinition | null | undefined
+) {
     /*
      * note: baseDataType and defaultEncodingId are implicit and not stored in the XML file ??
      *
@@ -757,8 +761,12 @@ function _dumpStructureDefinition(xw: XmlWriter, structureDefinition: StructureD
     const baseDataType = structureDefinition.baseDataType;
     const defaultEncodingId = structureDefinition.defaultEncodingId;
 
-    structureDefinition.fields = structureDefinition.fields || [];
-    for (const defItem /*: StructureField*/ of structureDefinition.fields) {
+    // do not repeat elements that are already defined in base structure in the xml ouput!
+    const fields = structureDefinition.fields || [];
+    const nbFieldsInBase: number = baseStructureDefinition ? baseStructureDefinition.fields?.length || 0  : 0;
+
+    for(let index = nbFieldsInBase; index <fields.length; index++ ) {
+       const  defItem = fields[index];
         xw.startElement("Field");
         xw.writeAttribute("Name", defItem.name!);
 
@@ -788,27 +796,29 @@ function _dumpStructureDefinition(xw: XmlWriter, structureDefinition: StructureD
         xw.endElement();
     }
 }
-function _dumpUADataTypeDefinition(xw: XmlWriter, node: UADataType) {
+function _dumpUADataTypeDefinition(xw: XmlWriter, uaDataType: UADataType) {
     // to do remove DataType from base class
-
-    const definition = node.getDefinition();
+    const uaDataTypeBase = uaDataType.subtypeOfObj;
+    const definition = uaDataType.getDefinition();
     if (!definition) {
         return;
     }
     if (definition instanceof EnumDefinition) {
         xw.startElement("Definition");
-        xw.writeAttribute("Name", node.browseName.name!);
+        xw.writeAttribute("Name", uaDataType.browseName.name!);
         _dumpEnumDefinition(xw, definition);
         xw.endElement();
         return;
     }
     if (definition instanceof StructureDefinition) {
+        const baseDefinition = uaDataTypeBase ? (uaDataTypeBase.getDefinition() as StructureDefinition | null) : null;
+
         xw.startElement("Definition");
-        xw.writeAttribute("Name", node.browseName.name!);
+        xw.writeAttribute("Name", uaDataType.browseName.name!);
         if (definition.structureType === StructureType.Union) {
             xw.writeAttribute("IsUnion", "true");
         }
-        _dumpStructureDefinition(xw, definition);
+        _dumpStructureDefinition(xw, definition, baseDefinition);
         xw.endElement();
         return;
     }

package/src/nodeset_tools/typedictionary_to_xml.ts

@@ -44,6 +44,7 @@ function dumpDataTypeStructure(
     addressSpace: IAddressSpace,
     map: { [key: number]: string },
     structureDefinition: StructureDefinition,
+    structureDefinitionBase: StructureDefinition | undefined| null,
     name: string,
     doc?: string
 ): void {
@@ -56,8 +57,14 @@ function dumpDataTypeStructure(
         xw.text(doc);
         xw.endElement();
     }
+
+    const fields = structureDefinition.fields || [];
+    // get base class
+    const nbFieldsInBase = structureDefinitionBase? structureDefinitionBase.fields?.length || 0 : 0;
+
     let optionalsCount = 0;
-    for (const f of structureDefinition.fields || []) {
+    for (let index = nbFieldsInBase; index < fields.length; index ++) {
+        const f=  fields [index];
         if (f.isOptional) {
             xw.startElement("opc:Field");
             xw.writeAttribute("Name", f.name + "Specified");
@@ -90,7 +97,9 @@ function dumpDataTypeStructure(
             xw.endElement();
         }
     }
-    for (const f of structureDefinition.fields || []) {
+    for (let index = nbFieldsInBase; index < fields.length; index ++) {
+        const f=  fields [index];
+   
         const isArray = f.valueRank > 0 && f.arrayDimensions?.length;
 
         if (isArray) {
@@ -124,12 +133,13 @@ function dumpDataTypeToBSD(xw: XmlWriter, dataType: UADataType, map: { [key: num
 
     const name: string = dataType.browseName.name!;
 
-    const def = (<UADataTypeImpl>dataType)._getDefinition(false);
-    if (def instanceof StructureDefinition) {
-        dumpDataTypeStructure(xw, addressSpace, map, def, name);
+    const definition = dataType.getDefinition();
+    if (definition instanceof StructureDefinition) {
+        const structureDefinitionBase = dataType.subtypeOfObj?.getStructureDefinition();
+        dumpDataTypeStructure(xw, addressSpace, map, definition, structureDefinitionBase, name);
     }
-    if (def instanceof EnumDefinition) {
-        dumpEnumeratedType(xw, def, name);
+    if (definition instanceof EnumDefinition) {
+        dumpEnumeratedType(xw, definition, name);
     }
 }
 

package/src/reference_impl.ts

@@ -53,9 +53,9 @@ function _w(str: string, width: number): string {
     return (str + "                                         ").substr(0, width);
 }
 
-function _localCoerceToNodeID(nodeIdLike: string | NodeId | BaseNode) {
-    if ((nodeIdLike as any).nodeId) {
-        return (nodeIdLike as BaseNode).nodeId;
+function _localCoerceToNodeID(nodeIdLike: string | NodeIdLike | { nodeId: NodeId }): NodeId {
+    if (Object.prototype.hasOwnProperty.call(nodeIdLike, "nodeId")) {
+        return (nodeIdLike as { nodeId: NodeId }).nodeId;
     }
     return coerceNodeId(nodeIdLike);
 }