node-opcua-address-space 2.86.0 → 2.87.0

package/src/nodeset_tools/construct_namespace_dependency.ts

@@ -19,7 +19,7 @@ function _constructNamespaceDependency(
     // navigate all namespace recursively to
 
     function consider(namespaceIndex: number) {
-        if (hasHigherPriorityThan(namespaceIndex,namespace.index, priorityTable)) {
+        if (hasHigherPriorityThan(namespaceIndex, namespace.index, priorityTable)) {
             return;
         }
         if (!depMap.has(namespaceIndex)) {
@@ -48,7 +48,7 @@ function _constructNamespaceDependency(
         }
         // istanbul ignore next
         if (dataTypeNode.nodeClass !== NodeClass.DataType) {
-            warningLog("exploreDataTypes! ignoring ",dataTypeNode.toString());
+            warningLog("exploreDataTypes! ignoring ", dataTypeNode.toString());
             return;
         }
 
@@ -94,19 +94,33 @@ export function hasHigherPriorityThan(namespaceIndex1: number, namespaceIndex2:
     return order1 > order2;
 }
 
+/**
+ * 
+ * @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 
     // 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;
     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;
     for (let i = 0; i < namespaceWithReq.length; i++) {
@@ -117,10 +131,10 @@ export function constructNamespacePriorityTable(namespace: INamespace): number[]
     }
     return priorityList;
 }
-
+const doDebug = false;
 export function constructNamespaceDependency(namespace: INamespace, priorityTable?: number[]): INamespace[] {
     const addressSpace = namespace.addressSpace;
-   
+
     priorityTable = priorityTable || constructNamespacePriorityTable(namespace);
 
     const dependency: INamespace[] = [];
@@ -137,5 +151,12 @@ export function constructNamespaceDependency(namespace: INamespace, priorityTabl
 
     _constructNamespaceDependency(namespace, dependency, depMap, _visitedDataType, priorityTable);
 
-    return dependency;
+    doDebug && console.log("namespace : ", namespace.index, namespace.namespaceUri);
+    doDebug && console.log("   ", 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   "));
+
+    return sorted;
 }

package/src/nodeset_tools/nodeset_to_xml.ts

@@ -61,6 +61,7 @@ const XMLWriter = require("xml-writer");
 const debugLog = make_debugLog(__filename);
 const warningLog = make_warningLog(__filename);
 const errorLog = make_errorLog(__filename);
+const doDebug = false;
 
 function _hash(node: BaseNode | UAReference): string {
     return node.nodeId.toString();
@@ -1036,11 +1037,11 @@ function dumpUAVariableType(xw: XmlWriter, node: UAVariableType) {
             // throw new Error(" cannot find datatype " + node.dataType);
             console.log(
                 " 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));
@@ -1247,10 +1248,21 @@ function writeAliases(xw: XmlWriter, aliases: Record<string, NodeIdString>) {
     xw.endElement();
 }
 
-export function constructNamespaceTranslationTable(dependency: INamespace[]): ITranslationTable {
+function constructNamespaceTranslationTable(dependency: INamespace[], exportedNamespace: INamespace): ITranslationTable {
+
     const translationTable: ITranslationTable = {};
-    for (let i = 0; i < dependency.length; i++) {
-        translationTable[dependency[i].index] = i;
+    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;
 }
@@ -1342,7 +1354,7 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
 
     xw.priorityTable = constructNamespacePriorityTable(this);
     const dependency = constructNamespaceDependency(this, xw.priorityTable);
-    const translationTable = constructNamespaceTranslationTable(dependency);
+    const translationTable = constructNamespaceTranslationTable(dependency, this);
     xw.translationTable = translationTable;
 
     xw.startDocument({ encoding: "utf-8", version: "1.0" });
@@ -1372,12 +1384,17 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
     // xx xw.writeAttribute("LastModified", (new Date()).toISOString());
 
     // ------------- INamespace Uris
+    initXmlWriterEx(xw, namespacesMap, namespaceArray);
+
     xw.startElement("NamespaceUris");
 
-    initXmlWriterEx(xw, namespacesMap, namespaceArray);
+    // 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);
+    
+    doDebug && console.log(sortedDependencies.map((a)=>a.index + " + "+ a.namespaceUri).join("\n"));
+    doDebug && console.log("translation table ", translationTable);
 
-    // xx const namespaceArray = namespace.addressSpace.getNamespaceArray();
-    for (const depend of dependency) {
+    for (const depend of sortedDependencies) {
         if (depend.index === 0) {
             continue; // ignore namespace 0
         }
@@ -1385,7 +1402,6 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
         xw.text(depend.namespaceUri);
         xw.endElement();
     }
-
     xw.endElement();
 
     // ------------- INamespace Uris
@@ -1395,7 +1411,7 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
         xw.writeAttribute("ModelUri", this.namespaceUri);
         xw.writeAttribute("Version", this.version);
         xw.writeAttribute("PublicationDate", this.publicationDate.toISOString());
-        for (const depend of dependency) {
+        for (const depend of sortedDependencies) {
             if (depend.index === this.index) {
                 continue; // ignore our namespace 0
             }

package/src/private_namespace.ts

@@ -0,0 +1,18 @@
+
+
+import { Namespace } from "../source/namespace";
+import { NodeEntry1, NodeIdManager } from "./nodeid_manager";
+
+export function getNodeIdManager(ns: Namespace): NodeIdManager {
+    const nodeIdManager = (ns as any)._nodeIdManager as NodeIdManager;
+    return nodeIdManager;
+}
+export function setSymbols(ns: Namespace, symbols: NodeEntry1[]) {
+    const nodeIdManager = getNodeIdManager(ns);
+    (ns.addressSpace.getOwnNamespace() as any).registerSymbolicNames = true;
+    nodeIdManager.setSymbols(symbols);
+}
+export function getSymbols(ns: Namespace): NodeEntry1[] {
+    const nodeIdManager = getNodeIdManager(ns);
+    return nodeIdManager?.getSymbols() || [];
+}