node-opcua-address-space 2.116.0 → 2.117.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-address-space",
-    "version": "2.116.0",
+    "version": "2.117.0",
     "description": "pure nodejs OPCUA SDK - module address-space",
     "main": "./dist/src/index_current.js",
     "types": "./dist/source/index.d.ts",
@@ -16,42 +16,42 @@
         "c": "mocha --version"
     },
     "dependencies": {
-        "@types/lodash": "4.14.199",
-        "@types/semver": "^7.5.3",
-        "async": "^3.2.4",
+        "@types/lodash": "4.14.201",
+        "@types/semver": "^7.5.5",
+        "async": "^3.2.5",
         "chalk": "4.1.2",
         "dequeue": "^1.0.5",
         "lodash": "4.17.21",
-        "node-opcua-address-space-base": "2.114.0",
+        "node-opcua-address-space-base": "2.117.0",
         "node-opcua-assert": "2.105.0",
-        "node-opcua-basic-types": "2.114.0",
-        "node-opcua-binary-stream": "2.114.0",
-        "node-opcua-client-dynamic-extension-object": "2.116.0",
+        "node-opcua-basic-types": "2.117.0",
+        "node-opcua-binary-stream": "2.117.0",
+        "node-opcua-client-dynamic-extension-object": "2.117.0",
         "node-opcua-constants": "2.114.0",
         "node-opcua-crypto": "4.5.0",
-        "node-opcua-data-access": "2.114.0",
-        "node-opcua-data-model": "2.114.0",
-        "node-opcua-data-value": "2.114.0",
-        "node-opcua-date-time": "2.114.0",
-        "node-opcua-debug": "2.114.0",
-        "node-opcua-enum": "2.114.0",
-        "node-opcua-extension-object": "2.114.0",
-        "node-opcua-factory": "2.114.0",
-        "node-opcua-nodeid": "2.114.0",
-        "node-opcua-nodeset-ua": "2.114.0",
-        "node-opcua-numeric-range": "2.114.0",
-        "node-opcua-object-registry": "2.114.0",
-        "node-opcua-pseudo-session": "2.116.0",
-        "node-opcua-service-browse": "2.114.0",
-        "node-opcua-service-call": "2.114.0",
-        "node-opcua-service-history": "2.114.0",
-        "node-opcua-service-translate-browse-path": "2.114.0",
-        "node-opcua-service-write": "2.114.0",
-        "node-opcua-status-code": "2.114.0",
-        "node-opcua-types": "2.114.0",
-        "node-opcua-utils": "2.114.0",
-        "node-opcua-variant": "2.114.0",
-        "node-opcua-xml2json": "2.114.0",
+        "node-opcua-data-access": "2.117.0",
+        "node-opcua-data-model": "2.117.0",
+        "node-opcua-data-value": "2.117.0",
+        "node-opcua-date-time": "2.117.0",
+        "node-opcua-debug": "2.117.0",
+        "node-opcua-enum": "2.117.0",
+        "node-opcua-extension-object": "2.117.0",
+        "node-opcua-factory": "2.117.0",
+        "node-opcua-nodeid": "2.117.0",
+        "node-opcua-nodeset-ua": "2.117.0",
+        "node-opcua-numeric-range": "2.117.0",
+        "node-opcua-object-registry": "2.117.0",
+        "node-opcua-pseudo-session": "2.117.0",
+        "node-opcua-service-browse": "2.117.0",
+        "node-opcua-service-call": "2.117.0",
+        "node-opcua-service-history": "2.117.0",
+        "node-opcua-service-translate-browse-path": "2.117.0",
+        "node-opcua-service-write": "2.117.0",
+        "node-opcua-status-code": "2.117.0",
+        "node-opcua-types": "2.117.0",
+        "node-opcua-utils": "2.117.0",
+        "node-opcua-variant": "2.117.0",
+        "node-opcua-xml2json": "2.117.0",
         "semver": "^7.5.4",
         "set-prototype-of": "^1.0.0",
         "thenify": "^3.3.1",
@@ -59,14 +59,14 @@
     },
     "devDependencies": {
         "mocha": "^10.2.0",
-        "node-opcua-benchmarker": "2.114.0",
-        "node-opcua-leak-detector": "2.114.0",
+        "node-opcua-benchmarker": "2.117.0",
+        "node-opcua-leak-detector": "2.117.0",
         "node-opcua-nodesets": "2.110.0",
-        "node-opcua-packet-analyzer": "2.114.0",
-        "node-opcua-service-filter": "2.114.0",
-        "node-opcua-test-fixtures": "2.114.0",
+        "node-opcua-packet-analyzer": "2.117.0",
+        "node-opcua-service-filter": "2.117.0",
+        "node-opcua-test-fixtures": "2.117.0",
         "should": "^13.2.3",
-        "sinon": "^16.0.0",
+        "sinon": "^17.0.1",
         "source-map-support": "^0.5.21"
     },
     "author": "Etienne Rossignon",
@@ -84,7 +84,7 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "713ad387571a323c8d886ad1c907f50ad96a5e76",
+    "gitHead": "99ed7589a203923985c25be8907b36485c798bbe",
     "files": [
         "dist",
         "distHelpers",

package/source/loader/generateAddressSpaceRaw.ts

@@ -187,15 +187,21 @@ export async function generateAddressSpaceRaw(
 
     const nodesetDesc = await preLoad(xmlFiles, xmlLoader);
     const order = findOrder(nodesetDesc);
+
+    // register namespace in the same order as specified in the xmlFiles array
     for (let index = 0; index < order.length; index++) {
-        const nodesetIndex = order[index];
-        const nodeset = nodesetDesc[nodesetIndex];
-        debugLog(" loading ", nodesetIndex, nodeset.xmlData.length);
-        for (const model of nodeset.namespaceModel.models) {
+        const n = nodesetDesc[index];
+        for (const model of n.namespaceModel.models) {
             const ns = addressSpace.registerNamespace(model.modelUri) as NamespacePrivate;
             ns.setRequiredModels(model.requiredModel);
         }
+    }
 
+
+    for (let index = 0; index < order.length; index++) {
+        const nodesetIndex = order[index];
+        const nodeset = nodesetDesc[nodesetIndex];
+        debugLog(" loading ", nodesetIndex, nodeset.xmlData.length);
         try {
             await nodesetLoader.addNodeSetAsync(nodeset.xmlData);
         } catch (err) {

package/source/loader/load_nodeset2.ts

@@ -194,8 +194,8 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
 
         // istanbul ignore next
         if (namespaceIndex === undefined) {
-            debugLog("Warning: namespace_uri_translation = ", namespace_uri_translation);
-            errorLog("namespace_uri_translation", namespace_uri_translation);
+            errorLog("Warning: namespace_uri_translation = ", namespace_uri_translation);
+            errorLog("Error; namespace_uri_translation", namespace_uri_translation);
             throw new Error("_translateNamespaceIndex() ! Cannot find namespace definition for index " + innerIndex);
         }
         return namespaceIndex;

package/src/nodeset_tools/construct_namespace_dependency.ts

@@ -1,4 +1,4 @@
-import { INamespace, UADataType, UAVariable, UAVariableType } from "node-opcua-address-space-base";
+import { IAddressSpace, INamespace, UADataType, UAVariable, UAVariableType } from "node-opcua-address-space-base";
 import { NodeClass } from "node-opcua-data-model";
 import { StructureField } from "node-opcua-types";
 import { DataType } from "node-opcua-basic-types";
@@ -9,42 +9,46 @@ 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";
+import { ITranslationTable } from "../../source/xml_writer";
 
 const warningLog = make_warningLog(__filename);
 const debugLog = make_debugLog(__filename);
 
-function _constructNamespaceDependency(
+// eslint-disable-next-line max-statements, complexity
+export function _recomputeRequiredModelsFromTypes(
     namespace: INamespace,
-    dependency: INamespace[],
-    depMap: Set<number>,
-    _visitedDataType: Set<string>,
-    priorityTable: number[]
-): void {
-    const addressSpace = namespace.addressSpace;
-    const namespace_ = namespace as NamespacePrivate;
-    // navigate all namespace recursively to
-
-    function consider(namespaceIndex: number) {
-        if (hasHigherPriorityThan(namespaceIndex, namespace.index, priorityTable)) {
-            return;
-        }
-        considerStrongly(namespaceIndex);
+    cache?: Map<number, { requiredNamespaceIndexes: number[]; nbTypes: number }>
+): { requiredNamespaceIndexes: number[]; nbTypes: number } {
+    if (namespace.index === 0) {
+        return { requiredNamespaceIndexes: [], nbTypes: 1 };
     }
-    function considerStrongly(namespaceIndex: number) {
-        if (!depMap.has(namespaceIndex)) {
-            depMap.add(namespaceIndex);
-            const namespace = addressSpace.getNamespace(namespaceIndex);
-            dependency.push(namespace);
-            if (namespaceIndex > 0) {
-                _constructNamespaceDependency(namespace, dependency, depMap, _visitedDataType, priorityTable);
-            }
+    if (cache) {
+        if (cache.has(namespace.index)) {
+            return cache.get(namespace.index)!;
         }
     }
+    const requiredNamespaceIndexes = [0];
+    const requiredModelsSet = new Set<number>();
+    requiredModelsSet.add(0);
+    const namespace_ = namespace as NamespacePrivate;
+    let nbTypes = 0;
+    const addressSpace = namespace.addressSpace;
+    const types = [NodeClass.VariableType, NodeClass.ObjectType, NodeClass.ReferenceType, NodeClass.DataType];
+    const instances = [NodeClass.Variable, NodeClass.Object, NodeClass.Method];
+
+    const consider = (requiredModel: number) => {
+        if (requiredModel !== namespace.index && !requiredModelsSet.has(requiredModel)) {
+            requiredModelsSet.add(requiredModel);
+            requiredNamespaceIndexes.push(requiredModel);
+        }
+    };
+
+    const _visitedDataType: Set<string> = new Set<string>();
 
     function exploreDataTypeField(field: StructureField) {
         const dataType = field.dataType;
         const namespaceIndex = dataType.namespace;
-        considerStrongly(namespaceIndex);
+        consider(namespaceIndex);
         const dataTypeNode = addressSpace.findDataType(field.dataType);
         if (dataTypeNode) {
             exploreDataTypes(dataTypeNode);
@@ -65,7 +69,7 @@ function _constructNamespaceDependency(
         }
 
         const namespaceIndex = dataType.namespace;
-        considerStrongly(namespaceIndex);
+        consider(namespaceIndex);
         if (dataTypeNode.isStructure()) {
             const definition = dataTypeNode.getStructureDefinition();
             for (const field of definition.fields || []) {
@@ -78,7 +82,7 @@ function _constructNamespaceDependency(
     function exploreExtensionObject(e: ExtensionObject) {
         assert(!(e instanceof Variant));
         const nodeId = e.schema.encodingDefaultXml || e.schema.dataTypeNodeId || e.schema.dataTypeNodeId;
-        considerStrongly(nodeId.namespace);
+        consider(nodeId.namespace);
         // istanbul ignore next
         if (e.schema.dataTypeNodeId.isEmpty()) {
             warningLog("Cannot find dataTypeNodeId for ", e.schema.name);
@@ -88,6 +92,7 @@ function _constructNamespaceDependency(
         if (!d) return;
         exploreDataTypes(d);
     }
+
     function exploreDataValue(uaVariable: UAVariableImpl) {
         if (uaVariable.getBasicDataType() !== DataType.ExtensionObject) {
             return;
@@ -104,36 +109,131 @@ function _constructNamespaceDependency(
         }
     }
     for (const node of namespace_.nodeIterator()) {
-        if (node.nodeClass === NodeClass.Variable || node.nodeClass === NodeClass.VariableType) {
-            const dataTypeNodeId = (node as UAVariable | UAVariableType).dataType;
-            const dataTypeNode = addressSpace.findDataType(dataTypeNodeId)!;
-            if (dataTypeNode) {
-                exploreDataTypes(dataTypeNode);
-            } else {
-                // istanbul ignore next
-                if (dataTypeNodeId.value != 0) {
-                    warningLog("Warning: Cannot find dataType", dataTypeNodeId.toString());
+        const isType = types.indexOf(node.nodeClass);
+        const isInstance = instances.indexOf(node.nodeClass);
+        if (isType !== -1) {
+            nbTypes++;
+            const superTypes = node.findReferencesAsObject("HasSubtype", false);
+            if (superTypes.length === 0) {
+                continue;
+            }
+            if (superTypes.length !== 1) {
+                continue;
+            }
+            const superType = superTypes[0];
+            if (superType.nodeId.namespace === 0) {
+                continue;
+            }
+            const requiredModel = superType.nodeId.namespace;
+            consider(requiredModel);
+        } else if (isInstance !== -1) {
+            if (node.nodeClass === NodeClass.Variable || node.nodeClass === NodeClass.VariableType) {
+                const dataTypeNodeId = (node as UAVariable | UAVariableType).dataType;
+                const dataTypeNode = addressSpace.findDataType(dataTypeNodeId)!;
+                if (dataTypeNode) {
+                    consider(dataTypeNode.nodeId.namespace);
+                } else {
+                    // istanbul ignore next
+                    if (dataTypeNodeId.value != 0) {
+                        warningLog("Warning: Cannot find dataType", dataTypeNodeId.toString());
+                    }
                 }
+                const nodeV = node as UAVariableImpl;
+                exploreDataValue(nodeV);
             }
-            const nodeV = node as UAVariableImpl;
-            exploreDataValue(nodeV);
+
+            const typeDefinitions = node.findReferencesAsObject("HasTypeDefinition", true);
+            if (typeDefinitions.length === 0) {
+                continue;
+            }
+            if (typeDefinitions.length !== 1) {
+                continue;
+            }
+            const typeDefinition = typeDefinitions[0];
+            const requiredModel = typeDefinition.nodeId.namespace;
+            consider(requiredModel);
         }
-        // visit all references
-        const references = (<BaseNodeImpl>node).ownReferences();
-        for (const reference of references) {
-            // check referenceId
-            const namespaceIndex = getReferenceType(reference)!.nodeId.namespace;
-            consider(namespaceIndex);
-            const namespaceIndex2 = reference.nodeId.namespace;
-            consider(namespaceIndex2);
+    }
+
+    const result = { requiredNamespaceIndexes: requiredNamespaceIndexes, nbTypes: nbTypes };
+    if (cache) {
+        cache.set(namespace.index, result);
+    }
+    return result;
+}
+
+export function _recomputeRequiredModelsFromTypes2(
+    namespace: INamespace,
+    cache?: Map<number, { requiredNamespaceIndexes: number[]; nbTypes: number }>
+): { requiredNamespaceIndexes: number[] } {
+    const addressSpace = namespace.addressSpace;
+
+    const { requiredNamespaceIndexes } = _recomputeRequiredModelsFromTypes(namespace, cache);
+
+    const set = new Set<number>(requiredNamespaceIndexes);
+    const pass2: number[] = [];
+    for (const r of requiredNamespaceIndexes) {
+        if (r === 0) {
+            pass2.push(0);
+            continue;
+        }
+        const namespaces = _recomputeRequiredModelsFromTypes(addressSpace.getNamespace(r), cache);
+        for (const nIndex of namespaces.requiredNamespaceIndexes) {
+            if (!set.has(nIndex)) {
+                set.add(nIndex);
+                pass2.push(nIndex);
+            }
         }
+        pass2.push(r);
     }
+
+    return { requiredNamespaceIndexes: pass2 };
 }
 
-export function hasHigherPriorityThan(namespaceIndex1: number, namespaceIndex2: number, priorityTable: number[]) {
-    const order1 = priorityTable[namespaceIndex1];
-    const order2 = priorityTable[namespaceIndex2];
-    return order1 > order2;
+export function _getCompleteRequiredModelsFromValuesAndReferences(
+    namespace: INamespace,
+    priorityList: number[],
+    cache?: Map<number, { requiredNamespaceIndexes: number[]; nbTypes: number }>
+): number[] {
+
+    const namespace_ = namespace as NamespacePrivate;
+
+    const thisPriority = priorityList[namespace.index];
+
+    const requiredNamespaceIndexes = _recomputeRequiredModelsFromTypes2(namespace, cache).requiredNamespaceIndexes;
+    const requiredModelsSet: Set<number> = new Set<number>([... requiredNamespaceIndexes]);
+
+    const consider = (requiredModel: number) => {
+        if (requiredModel !== namespace.index && !requiredModelsSet.has(requiredModel)) {
+            requiredModelsSet.add(requiredModel);
+            requiredNamespaceIndexes.push(requiredModel);
+        }
+    }
+
+    //const maxIndex = Math.max(...requiredNamespaceIndexes);
+    for (const node of namespace_.nodeIterator()) {
+        const references = (<BaseNodeImpl>node).allReferences();
+        for (const reference of references) {
+            // if (reference.isForward) continue;
+            // only look at backward reference
+            // check referenceId
+            const namespaceIndexOfReferenceType = getReferenceType(reference)!.nodeId.namespace;
+            if (namespaceIndexOfReferenceType !== 0 && namespaceIndexOfReferenceType !== namespace.index) {
+                const refPriority = priorityList[namespaceIndexOfReferenceType];
+                if (refPriority <= thisPriority) {
+                    consider(namespaceIndexOfReferenceType);
+                }
+            }
+            const namespaceIndexOfTargetNode = reference.nodeId.namespace;
+            if (namespaceIndexOfTargetNode !== 0 && namespaceIndexOfTargetNode !== namespace.index) {
+                const refPriority = priorityList[namespaceIndexOfTargetNode];
+                if (refPriority <= thisPriority) {
+                    consider(namespaceIndexOfTargetNode);
+                }
+            }
+        }
+    }
+    return requiredNamespaceIndexes;
 }
 
 /**
@@ -150,58 +250,99 @@ export function hasHigherPriorityThan(namespaceIndex1: number, namespaceIndex2:
  *                           ---
  *  ua, own , di , kitchen , own2,  adi  => 0 , 2,  3,  5, 1
  */
-export function constructNamespacePriorityTable(namespace: INamespace): number[] {
-    // 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
-
-    const addressSpace = namespace.addressSpace;
+export function constructNamespacePriorityTable(addressSpace: IAddressSpace): { loadingOrder: number[]; priorityTable: number[] } {
+    // - Namespace 0 will always be 0
+    // - Namespace with requiredModels are considered to be companion specification,
+    //   so RequireModel will be used to determine the order
+    // - Namespaces with no requiredModel are more complicated:
+    //
+    //   we study ObjectType,ReferenceType, DataType and VariableType
+    //   to find strong dependencies between namespace.
+    //
+    //   if the namespace doesn't define ObjectType,ReferenceType, DataType and VariableType
+    //   it will be considered as instance namespaces and will added at the end
+    //   in the same order as they appear,
     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 loadingOrder: number[] = [0];
 
-    const priorityList: number[] = [0];
-    let counter = 1;
-    for (let i = 0; i < namespaceWithReq.length; i++) {
-        priorityList[namespaceWithReq[i].index] = counter++;
-    }
-    for (let i = 0; i < namespaceWithoutReq.length; i++) {
-        priorityList[namespaceWithoutReq[i].index] = counter++;
+    const map = new Map<number, { nbTypes: number; requiredNamespaceIndexes: number[]; namespace: INamespace }>();
+    for (let i = 0; i < namespaces.length; i++) {
+        const { nbTypes, requiredNamespaceIndexes } = _recomputeRequiredModelsFromTypes(namespaces[i], map);
+        map.set(namespaces[i].index, { nbTypes, requiredNamespaceIndexes, namespace: namespaces[i] });
     }
-    return priorityList;
-}
-const doDebug = false;
-export function constructNamespaceDependency(namespace: INamespace, priorityTable?: number[]): INamespace[] {
-    const addressSpace = namespace.addressSpace;
 
-    priorityTable = priorityTable || constructNamespacePriorityTable(namespace);
+    const visited = new Set<number>();
+    visited.add(0);
 
-    const dependency: INamespace[] = [];
-    const depMap = new Set<number>();
+    const h = (n: INamespace) => {
+        if (visited.has(n.index)) {
+            return;
+        }
+        visited.add(n.index);
+        const data = map.get(n.index);
+        if (!data) return;
+        const { requiredNamespaceIndexes } = data;
+        for (const r of requiredNamespaceIndexes || []) {
+            h(namespaces[r]);
+        }
+        loadingOrder.push(n.index);
+    };
 
-    dependency.push(addressSpace.getDefaultNamespace());
-    depMap.add(0);
+    for (let i = 0; i < namespaces.length; i++) {
+        const { nbTypes } = map.get(i)!;
+        if (nbTypes) {
+            h(namespaces[i]);
+        }
+    }
+    for (let i = 0; i < namespaces.length; i++) {
+        const { nbTypes } = map.get(i)!;
+        if (!nbTypes) {
+            h(namespaces[i]);
+        }
+    }
 
-    if (namespace !== addressSpace.getDefaultNamespace()) {
-        dependency.push(namespace);
-        depMap.add(namespace.index);
+    const priorityTable: number[] = [];
+    for (let i = 0; i < loadingOrder.length; i++) {
+        const namespaceIndex = loadingOrder[i];
+        assert(namespaceIndex !== -1);
+        priorityTable[namespaceIndex] = i;
     }
-    const _visitedDataType = new Set<string>();
 
-    _constructNamespaceDependency(namespace, dependency, depMap, _visitedDataType, priorityTable);
+    return { loadingOrder, priorityTable };
+}
 
-    // 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 doDebug = true;
+export function constructNamespaceDependency(namespace: INamespace, priorityTable?: number[]): INamespace[] {
+    const addressSpace = namespace.addressSpace;
+    priorityTable = priorityTable || constructNamespacePriorityTable(addressSpace).priorityTable;
+    const requiredNamespaceIndexes = _getCompleteRequiredModelsFromValuesAndReferences(namespace, priorityTable);
+    return [...requiredNamespaceIndexes.map((r) => addressSpace.getNamespace(r)), namespace];
+}
 
-    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   "));
+/**
+ * @private
+ */
+export function _constructNamespaceTranslationTable(dependency: INamespace[], exportedNamespace: INamespace): ITranslationTable {
+    if (!dependency || dependency.length === 0) {
+        return { 0: 0 };
+        // throw new Error("Cannot constructNamespaceTranslationTable on empty dependency");
+    }
+    const translationTable: ITranslationTable = {};
+    assert(dependency[0].namespaceUri === "http://opcfoundation.org/UA/");
 
-    return sorted;
+    let counter = 0;
+    translationTable[dependency[0].index] = counter++;
+    //
+    if (exportedNamespace) {
+        translationTable[exportedNamespace.index] = counter++;
+    }
+    for (let i = 1; i < dependency.length; i++) {
+        const dep = dependency[i];
+        if (exportedNamespace && exportedNamespace === dep) {
+            continue;
+        }
+        translationTable[dep.index] = counter++;
+    }
+    return translationTable;
 }

package/src/nodeset_tools/nodeset_to_xml.ts

@@ -53,9 +53,9 @@ 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";
 import {
+    _constructNamespaceTranslationTable,
     constructNamespaceDependency,
-    constructNamespacePriorityTable,
-    hasHigherPriorityThan
+    constructNamespacePriorityTable
 } from "./construct_namespace_dependency";
 
 // tslint:disable:no-var-requires
@@ -105,6 +105,13 @@ function b(xw: XmlWriter, browseName: QualifiedName): string {
     return translateBrowseName(xw, browseName).toString().replace("ns=0;", "");
 }
 
+
+function hasHigherPriorityThan(namespaceIndex1: number, namespaceIndex2: number, priorityTable: number[]) {
+    const order1 = priorityTable[namespaceIndex1];
+    const order2 = priorityTable[namespaceIndex2];
+    return order1 > order2;
+}
+
 function _hasHigherPriorityThan(xw: XmlWriter, namespaceIndex1: number, namespaceIndex2: number) {
     assert(xw.priorityTable, "expecting a priorityTable");
     assert(namespaceIndex1 < xw.priorityTable.length);
@@ -128,7 +135,6 @@ function _dumpReferences(xw: XmlWriter, node: BaseNode) {
 
     function referenceToKeep(reference: UAReference): boolean {
         const referenceType = (reference as ReferenceImpl)._referenceType!;
-
         const targetedNamespaceIndex = reference.nodeId.namespace;
         if (_hasHigherPriorityThan(xw, targetedNamespaceIndex, node.nodeId.namespace)) {
             // this reference has nothing to do here ! drop it
@@ -165,8 +171,8 @@ function _dumpReferences(xw: XmlWriter, node: BaseNode) {
         }
         return false;
     }
-
-    const references = node.allReferences().filter(referenceToKeep);
+    const allReferences = node.allReferences();
+    const references = allReferences.filter(referenceToKeep);
 
     for (const reference of references.sort(sortByNodeId)) {
         if (getReferenceType(reference).browseName.toString() === "HasSubtype" && reference.isForward) {
@@ -535,6 +541,10 @@ function _dumpVariantExtensionObjectValue2(xw: XmlWriter, addressSpace: IAddress
     const dataTypeNodeId = value.schema.dataTypeNodeId;
     const definitionMap = makeDefinitionMap(addressSpace);
     const dataTypeNode = addressSpace.findDataType(dataTypeNodeId)!;
+    if (!dataTypeNode) {
+        warningLog("_dumpVariantExtensionObjectValue2: Cannot find dataType for  ", dataTypeNodeId.toString());
+        return;
+    }
     _dumpVariantExtensionObjectValue(xw, dataTypeNode.nodeId, definitionMap, value);
 }
 
@@ -1155,7 +1165,7 @@ function dumpUAObjectType(xw: XmlWriter, node: UAObjectTypeImpl) {
     xw.writeComment("ObjectType - " + b(xw, node.browseName) + " {{{{ ");
     _markAsVisited(xw, node);
 
-    // dump SubtypeOf and HasTypeDefinition
+    // dump SubtypeOf and HasTypeDefinition node if part of the same namespace
     dumpReferencedNodes(xw, node, false);
 
     xw.startElement("UAObjectType");
@@ -1268,25 +1278,6 @@ function writeAliases(xw: XmlWriter, aliases: Record<string, NodeIdString>) {
     xw.endElement();
 }
 
-function constructNamespaceTranslationTable(dependency: INamespace[], exportedNamespace: INamespace): ITranslationTable {
-    const translationTable: ITranslationTable = {};
-    assert(dependency[0].namespaceUri === "http://opcfoundation.org/UA/");
-
-    let counter = 0;
-    translationTable[dependency[0].index] = counter++;
-    //
-    if (exportedNamespace) {
-        translationTable[exportedNamespace.index] = counter++;
-    }
-    for (let i = 1; i < dependency.length; i++) {
-        const dep = dependency[i];
-        if (exportedNamespace && exportedNamespace === dep) {
-            continue;
-        }
-        translationTable[dep.index] = counter++;
-    }
-    return translationTable;
-}
 function dumpReferenceType(xw: XmlWriter, referenceType: UAReferenceType) {
     _markAsVisited(xw, referenceType);
 
@@ -1382,9 +1373,10 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
 
     const xw: XmlWriter = new XMLWriter(true);
 
-    xw.priorityTable = constructNamespacePriorityTable(this);
+    xw.priorityTable = constructNamespacePriorityTable(this.addressSpace).priorityTable;
+
     const dependency = constructNamespaceDependency(this, xw.priorityTable);
-    const translationTable = constructNamespaceTranslationTable(dependency, this);
+    const translationTable = _constructNamespaceTranslationTable(dependency, this);
     xw.translationTable = translationTable;
 
     xw.startDocument({ encoding: "utf-8", version: "1.0" });