node-opcua-address-space 2.112.0 → 2.114.0

package/src/alarms_and_conditions/ua_condition_impl.ts

@@ -143,7 +143,6 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
     ): void {
         const conditionNode = context.object;
 
-        // xx console.log(inputArguments.map(function(a){return a.toString()}));
         if (!(conditionNode instanceof UAConditionImpl)) {
             callback(null, {
                 statusCode: StatusCodes.BadNodeIdInvalid
@@ -426,7 +425,6 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
             branch.renewEventId();
         }
 
-        // xx console.log("MMMMMMMM%%%%%%%%%%%%%%%%%%%%% branch  " +
         // branch.getBranchId().toString() + " eventId = " + branch.getEventId().toString("hex"));
 
         assert(branch instanceof ConditionSnapshotImpl);
@@ -462,7 +460,6 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
                 "therefore event cannot bubble-up to the server object"
             );
         }
-        // xx console.log("MMMMMMMM%%%%%%%%%%%%%%%%%%%%% branch  " +
         // branch.getBranchId().toString() + " eventId = " + branch.getEventId().toString("hex"));
     }
 
@@ -536,7 +533,6 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
         this.raiseConditionEvent(branch, true);
 
         if (!sameNodeId(branch.getBranchId(), NodeId.nullNodeId) && !branch.getRetain()) {
-            // xx console.log(" Deleting not longer needed branch ", branch.getBranchId().toString());
             // branch can be deleted
             this.deleteBranch(branch);
         }
@@ -854,8 +850,7 @@ function UACondition_instantiate(
     if (options.conditionSource) {
         options.conditionSource = addressSpace._coerceNode(options.conditionSource)!;
         if (options.conditionSource.nodeClass !== NodeClass.Object && options.conditionSource.nodeClass !== NodeClass.Variable) {
-            // tslint:disable:no-console
-            console.log(options.conditionSource);
+            debugLog(options.conditionSource);
             throw new Error("Expecting condition source to be NodeClass.Object or Variable");
         }
 
@@ -1013,7 +1008,7 @@ function _disable_method(inputArguments: VariantLike[], context: ISessionContext
 
     // istanbul ignore next
     if (!(conditionNode instanceof UAConditionImpl)) {
-        console.log("conditionNode is not a UACondition ", conditionNode?.toString());
+        debugLog("conditionNode is not a UACondition ", conditionNode?.toString());
         return callback(null, {
             statusCode: StatusCodes.BadNodeIdInvalid
         });
@@ -1048,6 +1043,7 @@ function _condition_refresh_method(
     // arguments : IntegerId SubscriptionId
     assert(inputArguments.length === 1);
     const addressSpace = context.object!.addressSpace as AddressSpacePrivate;
+    // istanbul ignore next
     if (doDebug) {
         debugLog(chalk.red(" ConditionType.ConditionRefresh ! subscriptionId ="), inputArguments[0].toString());
     }

package/src/base_node_impl.ts

@@ -38,7 +38,7 @@ import {
     AccessRestrictionsFlag
 } from "node-opcua-data-model";
 import { DataValue } from "node-opcua-data-value";
-import { dumpIf, make_warningLog, make_errorLog } from "node-opcua-debug";
+import { dumpIf, make_debugLog,  make_warningLog, make_errorLog } from "node-opcua-debug";
 import { coerceNodeId, makeNodeId, NodeId, NodeIdLike, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
 import { NumericRange } from "node-opcua-numeric-range";
 import { ReferenceDescription } from "node-opcua-service-browse";
@@ -85,6 +85,8 @@ import { coerceRolePermissions } from "./role_permissions";
 const doDebug = false;
 const warningLog = make_warningLog(__filename);
 const errorLog = make_errorLog(__filename);
+const debugLog = make_debugLog(__filename);
+
 
 function defaultBrowseFilterFunc(context?: ISessionContext): boolean {
     return true;
@@ -867,7 +869,7 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
 
         /* istanbul ignore next */
         if (do_debug) {
-            console.log("all references :", this.nodeId.toString(), this.browseName.toString());
+            debugLog("all references :", this.nodeId.toString(), this.browseName.toString());
             dumpReferences(addressSpace, (Object as any).values(_private._referenceIdx));
         }
 
@@ -940,7 +942,7 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
 
         // istanbul ignore next
         if (!addressSpace) {
-            console.log(" Where is addressSpace ?");
+            debugLog("Where is addressSpace ?");
         }
         const reference = addressSpace.normalizeReferenceTypes([referenceOpts!])![0];
         const h = (<ReferenceImpl>reference).hash;
@@ -1021,7 +1023,7 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
             // istanbul ignore next
             if (doDebug) {
                 // tslint:disable-next-line:no-console
-                console.log(chalk.bgWhite.red("Ignoring reserved keyword                                     " + name));
+                debugLog(chalk.bgWhite.red("Ignoring reserved keyword                                     " + name));
             }
             return;
         }
@@ -1508,9 +1510,8 @@ function _asObject<T extends BaseNode>(references: UAReference[], addressSpace:
     function toObject(reference: UAReference): T {
         const obj = resolveReferenceNode(addressSpace, reference);
         // istanbul ignore next
-        if (false && !obj) {
-            // tslint:disable-next-line:no-console
-            console.log(
+        if (doDebug&& !obj) {
+            debugLog(
                 chalk.red(" Warning :  object with nodeId ") +
                 chalk.cyan(reference.nodeId.toString()) +
                 chalk.red(" cannot be found in the address space !")
@@ -1584,16 +1585,7 @@ function _propagate_ref(this: BaseNode, addressSpace: MinimalistAddressSpace, re
                 displayWarningReferencePointingToItSelf = false;
             }
         }
-        // xx ignore this assert(reference.nodeId.toString() !== this.nodeId.toString());
-        // function w(s,l) { return (s+"                                                          ").substring(0,l);}
-        // if (reference.isForward) {
-        //    console.log("  CHILD => ",w(related_node.browseName   + " " + related_node.nodeId.toString(),30),
-        //    "  PARENT   ",w(this.browseName + " " + this.nodeId.toString(),30) , reference.toString());
-        // } else {
-        //    console.log("  CHILD => ",w(this.browseName   + " " + this.nodeId.toString(),30),
-        //   "  PARENT   ",w(related_node.browseName + " " + related_node.nodeId.toString(),30) , reference.toString());
-        //
-        // }
+
         (related_node as BaseNodeImpl)._add_backward_reference(
             new ReferenceImpl({
                 _referenceType: getReferenceType(reference),
@@ -1630,7 +1622,7 @@ function normalize_referenceTypeId(addressSpace: IAddressSpace, referenceTypeId?
     try {
         nodeId = addressSpace.resolveNodeId(referenceTypeId);
     } catch (err) {
-        console.log("cannot normalize_referenceTypeId", referenceTypeId);
+        errorLog("cannot normalize_referenceTypeId", referenceTypeId);
         throw err;
     }
     assert(nodeId);
@@ -1790,14 +1782,14 @@ function install_components_as_object_properties(parentObj: BaseNode) {
         if (Object.prototype.hasOwnProperty.call(reservedNames, name)) {
             // ignore reserved names
             if (doDebug) {
-                console.log(chalk.bgWhite.red("Ignoring reserved keyword                                               " + name));
+                debugLog(chalk.bgWhite.red("Ignoring reserved keyword                                               " + name));
             }
             continue;
         }
 
         // ignore reserved names
         if (doDebug) {
-            console.log("Installing property " + name, " on ", parentObj.browseName.toString());
+            debugLog("Installing property " + name, " on ", parentObj.browseName.toString());
         }
 
         /* istanbul ignore next */

package/src/data_access/ua_multistate_value_discrete_impl.ts

@@ -3,7 +3,7 @@
  */
 import { assert } from "node-opcua-assert";
 import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
-import { coerceInt32, coerceUInt64, Int64, isValidUInt64 } from "node-opcua-basic-types";
+import { coerceInt32, coerceInt64toInt32, coerceUInt64, Int32, Int64, isValidUInt64 } from "node-opcua-basic-types";
 import { coerceLocalizedText, LocalizedText, QualifiedNameLike } from "node-opcua-data-model";
 import { DataValue, DataValueT } from "node-opcua-data-value";
 import { StatusCodes } from "node-opcua-status-code";
@@ -46,10 +46,7 @@ export interface UAMultiStateValueDiscreteImpl<T, DT extends DataType> {
 
     readValueAsync(context: ISessionContext | null, callback?: any): any;
 }
-export class UAMultiStateValueDiscreteImpl<T, DT extends DataType>
-    extends UAVariableImpl
-    implements UAMultiStateValueDiscreteEx<T, DT>
-{
+export class UAMultiStateValueDiscreteImpl<T, DT extends DataType> extends UAVariableImpl implements UAMultiStateValueDiscreteEx<T, DT> {
     public setValue(value: string | number | Int64): void {
         if (typeof value === "string") {
             const enumValues = this.enumValues.readValue().value.value;
@@ -99,15 +96,16 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType>
      *
      * @private
      */
-    public _enumValueIndex(): any {
+    public _enumValueIndex(): Record<Int32, DTEnumValue> {
         // construct an index to quickly find a EnumValue from a value
-        const enumValues = this.enumValues.readValue().value.value;
-        const enumValueIndex: any = {};
+        const enumValues: DTEnumValue[] = this.enumValues.readValue().value.value;
+        const enumValueIndex: Record<Int32, DTEnumValue> = {};
         if (!enumValues || !enumValues.forEach) {
             return enumValueIndex;
         }
-        enumValues.forEach((e: any) => {
-            enumValueIndex[e.value[1]] = e;
+        enumValues.forEach((e: DTEnumValue) => {
+            const index = coerceInt64toInt32(e.value);
+            enumValueIndex[index] = e;
         });
         return enumValueIndex;
     }
@@ -147,7 +145,7 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType>
         assert(!((value as any) instanceof Variant));
         let valueAsText1 = "Invalid";
         if (enumValueIndex[value]) {
-            valueAsText1 = enumValueIndex[value].displayName;
+            valueAsText1 = enumValueIndex[value].displayName.text || `Invalid:${value}`;
         }
         const result = new Variant({
             dataType: DataType.LocalizedText,

package/src/get_basic_datatype.ts

@@ -0,0 +1,32 @@
+import { IAddressSpace } from "node-opcua-address-space-base";
+import { DataType } from "node-opcua-basic-types";
+import { NodeClass } from "node-opcua-data-model";
+import { NodeId } from "node-opcua-nodeid";
+
+export interface IBaseNodeVariableOrVariableType {
+    addressSpace: IAddressSpace;
+    dataType: NodeId;
+}
+interface IBaseNodeVariableOrVariableTypeEx extends IBaseNodeVariableOrVariableType {
+    _basicDataType: DataType;
+}
+export function _getBasicDataType(uaNode: IBaseNodeVariableOrVariableType): DataType {
+    const _uaNode = uaNode as IBaseNodeVariableOrVariableTypeEx;
+    if (_uaNode._basicDataType) {
+        return _uaNode._basicDataType;
+    }
+    if (_uaNode.dataType.namespace === 0 && _uaNode.dataType.value === 0) {
+        return DataType.Null;
+    }
+    const addressSpace = _uaNode.addressSpace;
+    if (!addressSpace) {
+        // may be node has been deleted already
+        return DataType.Null;
+    }
+    const dataTypeNode = addressSpace.findDataType(_uaNode.dataType)!;
+    const basicDataType =
+        dataTypeNode && dataTypeNode.nodeClass === NodeClass.DataType ? dataTypeNode.getBasicDataType() : DataType.Null;
+    // const basicDataType = addressSpace.findCorrespondingBasicDataType(uaNode.dataType);
+    _uaNode._basicDataType = basicDataType;
+    return basicDataType;
+}

package/src/namespace_impl.ts

@@ -1709,7 +1709,7 @@ export class NamespaceImpl implements NamespacePrivate {
                 break;
             default:
                 // tslint:disable-next-line:no-console
-                console.log("Invalid class Name", node.nodeClass);
+                errorLog("Invalid class Name", node.nodeClass);
                 throw new Error("Invalid class name specified");
         }
     }
@@ -1733,13 +1733,13 @@ export class NamespaceImpl implements NamespacePrivate {
             if (match) {
                 const correctedName = match[1];
                 // the application is using an old scheme
-                console.log(
+                warningLog(
                     chalk.green(
                         "Warning : since node-opcua 0.4.2 " + "namespace index should not be prepended to the browse name anymore"
                     )
                 );
-                console.log("   ", options.browseName, " will be replaced with ", correctedName);
-                console.log(" Please update your code");
+                warningLog("   ", options.browseName, " will be replaced with ", correctedName);
+                warningLog(" Please update your code");
 
                 const indexVerify = parseInt(match[0], 10);
                 if (indexVerify !== this.index) {
@@ -1819,7 +1819,7 @@ export class NamespaceImpl implements NamespacePrivate {
                 break;
             default:
                 // tslint:disable:no-console
-                console.log("Invalid class Name", node.nodeClass);
+                warningLog("Invalid class Name", node.nodeClass);
                 throw new Error("Invalid class name specified");
         }
         const deleted = this._nodeid_index.delete(hashKey);
@@ -2234,7 +2234,6 @@ function _create_node_version_if_needed(node: BaseNode, options: { nodeVersion:
             propertyOf: node
         });
         const initialValue = typeof options.nodeVersion === "string" ? options.nodeVersion : "0";
-        // xx console.log(" init value =",initialValue);
         nodeVersion.setValueFromSource({ dataType: "String", value: initialValue });
     }
 }

package/src/nodeset_tools/construct_namespace_dependency.ts

@@ -1,11 +1,17 @@
 import { INamespace, UADataType, UAVariable, UAVariableType } from "node-opcua-address-space-base";
 import { NodeClass } from "node-opcua-data-model";
 import { StructureField } from "node-opcua-types";
-import { make_warningLog } from "node-opcua-debug";
+import { DataType } from "node-opcua-basic-types";
+import { ExtensionObject } from "node-opcua-extension-object";
+import { Variant } from "node-opcua-variant";
+import assert from "node-opcua-assert";
+import { make_debugLog, make_warningLog } from "node-opcua-debug";
 import { NamespacePrivate } from "../namespace_private";
 import { BaseNodeImpl, getReferenceType } from "../base_node_impl";
+import { UAVariableImpl } from "../ua_variable_impl";
 
 const warningLog = make_warningLog(__filename);
+const debugLog = make_debugLog(__filename);
 
 function _constructNamespaceDependency(
     namespace: INamespace,
@@ -42,6 +48,9 @@ function _constructNamespaceDependency(
         }
     }
     function exploreDataTypes(dataTypeNode: UADataType): void {
+        if (!dataTypeNode) {
+            return;
+        }
         const dataType = dataTypeNode.nodeId;
         if (_visitedDataType.has(dataType.toString())) {
             return;
@@ -62,6 +71,35 @@ function _constructNamespaceDependency(
         }
         _visitedDataType.add(dataType.toString());
     }
+
+    function exploreExtensionObject(e: ExtensionObject) {
+        assert(!(e instanceof Variant));
+        const nodeId = e.schema.encodingDefaultXml || e.schema.dataTypeNodeId || e.schema.dataTypeNodeId;
+        consider(nodeId.namespace);
+        // istanbul ignore next
+        if (e.schema.dataTypeNodeId.isEmpty()) {
+            warningLog("Cannot find dataTypeNodeId for ", e.schema.name);
+        }
+        const d = addressSpace.findNode(e.schema.dataTypeNodeId) as UADataType | null;
+        // istanbul ignore next
+        if (!d) return;
+        exploreDataTypes(d);
+    }
+    function exploreDataValue(uaVariable: UAVariableImpl) {
+        if (uaVariable.getBasicDataType() !== DataType.ExtensionObject) {
+            return;
+        }
+        if (!uaVariable.$dataValue) return;
+        const variant = uaVariable.$dataValue.value;
+        if (!variant) return;
+        const value: any | any[] = variant.value;
+        if (!value) return;
+        if (Array.isArray(value)) {
+            value.forEach(exploreExtensionObject);
+        } else {
+            exploreExtensionObject(value);
+        }
+    }
     for (const node of namespace_.nodeIterator()) {
         if (node.nodeClass === NodeClass.Variable || node.nodeClass === NodeClass.VariableType) {
             const dataTypeNodeId = (node as UAVariable | UAVariableType).dataType;
@@ -71,9 +109,11 @@ function _constructNamespaceDependency(
             } else {
                 // istanbul ignore next
                 if (dataTypeNodeId.value != 0) {
-                    console.log("Internal error: Cannot find dataType", dataTypeNodeId.toString());
+                    warningLog("Warning: Cannot find dataType", dataTypeNodeId.toString());
                 }
             }
+            const nodeV = node as UAVariableImpl;
+            exploreDataValue(nodeV);
         }
         // visit all references
         const references = (<BaseNodeImpl>node).ownReferences();
@@ -87,7 +127,6 @@ function _constructNamespaceDependency(
     }
 }
 
-
 export function hasHigherPriorityThan(namespaceIndex1: number, namespaceIndex2: number, priorityTable: number[]) {
     const order1 = priorityTable[namespaceIndex1];
     const order2 = priorityTable[namespaceIndex2];
@@ -95,22 +134,21 @@ export function hasHigherPriorityThan(namespaceIndex1: number, namespaceIndex2:
 }
 
 /**
- * 
- * @param namespace 
- * @returns the order 
- * 
+ *
+ * @param namespace
+ * @returns the order
+ *
  *      ---
  *  ua, own , di  => 0 , 2,  1
- * 
+ *
  *      ---
  *  ua, own , di , kitchen , own2,  adi  => 0 , 2,  3, 1
- * 
+ *
  *                           ---
  *  ua, own , di , kitchen , own2,  adi  => 0 , 2,  3,  5, 1
  */
 export function constructNamespacePriorityTable(namespace: INamespace): number[] {
-
-    // Namespace 0 will always be 0 
+    // Namespace 0 will always be 0
     // Namespaces with no requiredModel will be considered as instance namespaces and will added at the end
     // in the same order as they appear,
     // Namespace with requiredModels are considered to be companion specification, so already loaded in the correct order
@@ -118,8 +156,8 @@ export function constructNamespacePriorityTable(namespace: INamespace): number[]
     const addressSpace = namespace.addressSpace;
     const namespaces = addressSpace.getNamespaceArray();
 
-    const namespaceWithReq = namespaces.filter((n) => (n.getRequiredModels() !== undefined) && n.index !== 0);
-    const namespaceWithoutReq = namespaces.filter((n) => (n.getRequiredModels() === undefined) && n.index !== 0);
+    const namespaceWithReq = namespaces.filter((n) => n.getRequiredModels() !== undefined && n.index !== 0);
+    const namespaceWithoutReq = namespaces.filter((n) => n.getRequiredModels() === undefined && n.index !== 0);
 
     const priorityList: number[] = [0];
     let counter = 1;
@@ -151,12 +189,16 @@ export function constructNamespaceDependency(namespace: INamespace, priorityTabl
 
     _constructNamespaceDependency(namespace, dependency, depMap, _visitedDataType, priorityTable);
 
-    doDebug && console.log("namespace : ", namespace.index, namespace.namespaceUri);
-    doDebug && console.log("   ", dependency.map((d)=>d.index + " " + d.namespaceUri).join("\n   "));
+    // istanbul ignore next
+    doDebug && debugLog("namespace : ", namespace.index, namespace.namespaceUri);
+    // istanbul ignore next
+    doDebug && debugLog("   ", dependency.map((d) => d.index + " " + d.namespaceUri).join("\n   "));
 
-    const sorted = dependency.sort((a, b) => priorityTable![a.index] < priorityTable![b.index] ? -1 : 1);
-    doDebug && console.log("sorted:")
-    doDebug && console.log("   ", sorted.map((d)=>d.index + " " + d.namespaceUri).join("\n   "));
+    const sorted = dependency.sort((a, b) => (priorityTable![a.index] < priorityTable![b.index] ? -1 : 1));
+    // istanbul ignore next
+    doDebug && debugLog("sorted:");
+    // istanbul ignore next
+    doDebug && debugLog("   ", sorted.map((d) => d.index + " " + d.namespaceUri).join("\n   "));
 
     return sorted;
 }

package/src/nodeset_tools/nodeset_to_xml.ts

@@ -48,6 +48,7 @@ import { UAMethodImpl } from "../ua_method_impl";
 import { UADataTypeImpl } from "../ua_data_type_impl";
 import { UAVariableTypeImpl } from "../ua_variable_type_impl";
 import { SessionContext } from "../index_current";
+import { UAViewImpl } from "../ua_view_impl";
 
 import { DefinitionMap2, TypeInfo } from "../../source/loader/make_xml_extension_object_parser";
 import { makeDefinitionMap } from "../../source/loader/decode_xml_extension_object";
@@ -56,7 +57,6 @@ import {
     constructNamespacePriorityTable,
     hasHigherPriorityThan
 } from "./construct_namespace_dependency";
-import { UAViewImpl } from "../ua_view_impl";
 
 // tslint:disable:no-var-requires
 const XMLWriter = require("xml-writer");
@@ -141,7 +141,6 @@ function _dumpReferences(xw: XmlWriter, node: BaseNode) {
             if (reference.nodeId.namespace !== node.nodeId.namespace) {
                 // todo: may be check that reference.nodeId.namespace is one of the namespace
                 // on which our namespace is build and not a derived one !
-                // xx console.log("xxxxxxxxxxxxxx Keeping => ", referenceType.toString(), reference.node?.nodeId.toString());
                 return true;
             }
         }
@@ -374,8 +373,8 @@ function _dumpVariantInnerExtensionObject(
                 if (types.isNativeError(err)) {
                     errorLog("Error in _dumpVariantExtensionObjectValue_Body !!!", err.message);
                 }
-                console.log(name);
-                console.log(field);
+                debugLog(name);
+                debugLog(field);
                 // throw err;
             }
             restoreDefaultNamespace(xw);
@@ -503,7 +502,7 @@ function _dumpVariantExtensionObjectValue(
     const { name, definition } = definitionMap.findDefinition(dataTypeNodeId);
     // const encodingDefaultXml = (getStructureTypeConstructor(schema.name) as any).encodingDefaultXml;
     const encodingDefaultXml = value.schema.encodingDefaultXml;
-    if (!encodingDefaultXml) {
+    if (!encodingDefaultXml || encodingDefaultXml.isEmpty()) {
         warningLog("dataType Name ", name, "with ", dataTypeNodeId.toString(), " does not have xml encoding");
         // throw new Error("Extension Object doesn't provide a XML ");
         return;
@@ -532,9 +531,10 @@ function _dumpVariantExtensionObjectValue(
     xw.endElement();
 }
 
-function _dumpVariantExtensionObjectValue2(xw: XmlWriter, dataTypeNode: UADataType, value: ExtensionObject) {
-    const addressSpace = dataTypeNode.addressSpace;
+function _dumpVariantExtensionObjectValue2(xw: XmlWriter, addressSpace: IAddressSpace, value: ExtensionObject) {
+    const dataTypeNodeId = value.schema.dataTypeNodeId;
     const definitionMap = makeDefinitionMap(addressSpace);
+    const dataTypeNode = addressSpace.findDataType(dataTypeNodeId)!;
     _dumpVariantExtensionObjectValue(xw, dataTypeNode.nodeId, definitionMap, value);
 }
 
@@ -605,22 +605,25 @@ function _isDefaultValue(value: Variant): boolean {
 }
 
 // eslint-disable-next-line max-statements
-function _dumpValue(xw: XmlWriter, node: UAVariable | UAVariableType, value: Variant) {
+function _dumpValue(xw: XmlWriter, node: UAVariable | UAVariableType, variant: Variant) {
     const addressSpace = node.addressSpace;
 
     // istanbul ignore next
-    if (value === null || value === undefined) {
+    if (variant === null || variant === undefined) {
         return;
     }
-    assert(value instanceof Variant);
+    assert(variant instanceof Variant);
 
     const dataTypeNode = addressSpace.findDataType(node.dataType);
+
+    // istanbul ignore next
     if (!dataTypeNode) {
-        console.log("Cannot find dataType:", node.dataType);
+        debugLog("Cannot find dataType:", node.dataType.toString());
         return;
     }
+
     const dataTypeName = dataTypeNode.browseName.name!.toString();
-    const baseDataTypeName = DataType[value.dataType];
+    const baseDataTypeName = DataType[variant.dataType];
 
     if (baseDataTypeName === "Null") {
         return;
@@ -628,48 +631,48 @@ function _dumpValue(xw: XmlWriter, node: UAVariable | UAVariableType, value: Var
     assert(typeof baseDataTypeName === "string");
 
     // determine if dataTypeName is a ExtensionObject
-    const isExtensionObject = value.dataType === DataType.ExtensionObject;
+    const isExtensionObject = variant.dataType === DataType.ExtensionObject;
 
-    if (_isDefaultValue(value)) {
+    if (_isDefaultValue(variant)) {
         return;
     }
     xw.startElement("Value");
 
     const uax = getPrefix(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
     if (isExtensionObject) {
-        const encodeXml = _dumpVariantExtensionObjectValue2.bind(null, xw, dataTypeNode);
+        const encodeXml = _dumpVariantExtensionObjectValue2.bind(null, xw, node.addressSpace);
 
-        switch (value.arrayType) {
+        switch (variant.arrayType) {
             case VariantArrayType.Matrix:
             case VariantArrayType.Array:
                 startElementEx(xw, uax, `ListOf${baseDataTypeName}`, "http://opcfoundation.org/UA/2008/02/Types.xsd");
-                value.value.forEach(encodeXml);
+                variant.value.forEach(encodeXml);
                 restoreDefaultNamespace(xw);
                 xw.endElement();
                 break;
             case VariantArrayType.Scalar:
-                encodeXml(value.value);
+                encodeXml(variant.value);
                 break;
             default:
                 errorLog(node.toString());
-                errorLog("_dumpValue : unsupported arrayType: ", value.arrayType);
+                errorLog("_dumpValue : unsupported arrayType: ", variant.arrayType);
         }
     } else {
-        const encodeXml = _dumpVariantValue.bind(null, xw, value.dataType, node);
-        switch (value.arrayType) {
+        const encodeXml = _dumpVariantValue.bind(null, xw, variant.dataType, node);
+        switch (variant.arrayType) {
             case VariantArrayType.Matrix:
             case VariantArrayType.Array:
                 startElementEx(xw, uax, `ListOf${dataTypeName}`, "http://opcfoundation.org/UA/2008/02/Types.xsd");
-                value.value.forEach(encodeXml);
+                variant.value.forEach(encodeXml);
                 restoreDefaultNamespace(xw);
                 xw.endElement();
                 break;
             case VariantArrayType.Scalar:
-                encodeXml(value.value);
+                encodeXml(variant.value);
                 break;
             default:
                 errorLog(node.toString());
-                errorLog("_dumpValue : unsupported arrayType: ", value.arrayType);
+                errorLog("_dumpValue : unsupported arrayType: ", variant.arrayType);
         }
     }
 
@@ -764,7 +767,7 @@ function dumpReferencedNodes(xw: XmlWriter, node: BaseNode, forward: boolean) {
             assert(nodeChild instanceof BaseNodeImpl);
             if (nodeChild.nodeId.namespace === node.nodeId.namespace) {
                 if (!xw.visitedNode[_hash(nodeChild)]) {
-                    console.log(
+                    debugLog(
                         node.nodeId.toString(),
                         " dumping child ",
                         nodeChild.browseName.toString(),
@@ -953,7 +956,6 @@ function dumpUAView(xw: XmlWriter, node: UAView) {
     xw.endElement();
 
     dumpAggregates(xw, node);
-
 }
 
 function dumpUADataType(xw: XmlWriter, node: UADataType) {
@@ -1053,13 +1055,13 @@ function dumpUAVariableType(xw: XmlWriter, node: UAVariableType) {
         const dataTypeNode = addressSpace.findNode(node.dataType);
         if (!dataTypeNode) {
             // throw new Error(" cannot find datatype " + node.dataType);
-            console.log(
+            debugLog(
                 " cannot find datatype " +
-                node.dataType +
-                " for node " +
-                node.browseName.toString() +
-                " id =" +
-                node.nodeId.toString()
+                    node.dataType +
+                    " for node " +
+                    node.browseName.toString() +
+                    " id =" +
+                    node.nodeId.toString()
             );
         } else {
             const dataTypeName = b(xw, resolveDataTypeName(addressSpace, dataTypeNode.nodeId));
@@ -1267,7 +1269,6 @@ function writeAliases(xw: XmlWriter, aliases: Record<string, NodeIdString>) {
 }
 
 function constructNamespaceTranslationTable(dependency: INamespace[], exportedNamespace: INamespace): ITranslationTable {
-
     const translationTable: ITranslationTable = {};
     assert(dependency[0].namespaceUri === "http://opcfoundation.org/UA/");
 
@@ -1279,7 +1280,9 @@ function constructNamespaceTranslationTable(dependency: INamespace[], exportedNa
     }
     for (let i = 1; i < dependency.length; i++) {
         const dep = dependency[i];
-        if (exportedNamespace && exportedNamespace === dep) { continue; }
+        if (exportedNamespace && exportedNamespace === dep) {
+            continue;
+        }
         translationTable[dep.index] = counter++;
     }
     return translationTable;
@@ -1291,7 +1294,7 @@ function dumpReferenceType(xw: XmlWriter, referenceType: UAReferenceType) {
 
     dumpCommonAttributes(xw, referenceType);
 
-    const isSymmetric = (!referenceType.inverseName || referenceType.inverseName?.text === referenceType.browseName?.name);
+    const isSymmetric = !referenceType.inverseName || referenceType.inverseName?.text === referenceType.browseName?.name;
     if (isSymmetric) {
         xw.writeAttribute("Symmetric", "true");
     }
@@ -1364,7 +1367,7 @@ UADataTypeImpl.prototype.dumpXML = function (xw: XmlWriter) {
 
 UAViewImpl.prototype.dumpXML = function (xw: XmlWriter) {
     dumpUAView(xw, this);
-}
+};
 
 function makeTypeXsd(namespaceUri: string): string {
     return namespaceUri.replace(/\/$/, "") + "/Type.xsd";
@@ -1416,10 +1419,10 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
     xw.startElement("NamespaceUris");
 
     // let's sort the dependencies in the same order as the translation table
-    const sortedDependencies = dependency.sort((a, b) => translationTable[a.index] > translationTable[b.index] ? 1 : -1);
+    const sortedDependencies = dependency.sort((a, b) => (translationTable[a.index] > translationTable[b.index] ? 1 : -1));
 
-    doDebug && console.log(sortedDependencies.map((a) => a.index + " + " + a.namespaceUri).join("\n"));
-    doDebug && console.log("translation table ", translationTable);
+    doDebug && debugLog(sortedDependencies.map((a) => a.index + " + " + a.namespaceUri).join("\n"));
+    doDebug && debugLog("translation table ", translationTable);
 
     for (const depend of sortedDependencies) {
         if (depend.index === 0) {