node-opcua-modeler 2.62.6 → 2.63.2

package/source/displayNodeElement.ts

@@ -4,7 +4,8 @@ import {
     UAObjectType,
     UAVariable,
     resolveReferenceNode,
-    resolveReferenceType
+    resolveReferenceType,
+    UAVariableType
 } from "node-opcua-address-space";
 import { NodeClass } from "node-opcua-data-model";
 import { NodeId, resolveNodeId } from "node-opcua-nodeid";
@@ -38,141 +39,177 @@ export interface DisplayNodeOptions {
     format: "cli" | "markdown";
 }
 
-export function displayNodeElement(node: BaseNode, options?: DisplayNodeOptions): string {
-    const head: string[] = ["ReferenceType", "NodeId", "BrowseName", "ModellingRule", "TypeDefinition", "DataType", "Value"];
-    const table = new TableHelper(head);
-
-    table.push(["BrowseName: ", { colSpan: 6, content: node.browseName.toString() }]);
-
-    const superType = (node as UAObjectType).subtypeOfObj;
-    if (superType) {
-        table.push(["Base", superType.browseName.toString(), { colSpan: 6, content: node.browseName.toString() }]);
+interface Data {
+    table: TableHelper;
+    node: BaseNode;
+    alreadyDumped: Record<string, any>;
+    descriptions: Description[];
+}
+interface Description {
+    description: string;
+    name: string;
+    type: string;
+}
+function dumpReference(data: Data, ref: UAReference, filter?: string) {
+    resolveReferenceNode(data.node.addressSpace, ref);
+    if (!ref.isForward) {
+        return;
     }
-
-    if (node.description) {
-        table.push(["Description", node.description.toString(), { colSpan: 6, content: node.browseName.toString() }]);
+    if (NodeId.sameNodeId(ref.referenceType, hasSubtypeNodeId)) {
+        return; // ignore forward HasSubtype
     }
+    // ignore subtype references
+    /* istanbul ignore next */
+    if (!ref.node) {
+        // tslint:disable-next-line: no-console
+        console.log(" Halt ", ref.toString({ addressSpace: data.node.addressSpace }));
+        return;
+    }
+    const dir = ref.isForward ? " " : " ";
+    const refNode = ref.node!;
 
-    const alreadyDumped: any = {};
-
-    const descriptions: any = [];
-
-    function dumpReference(ref: UAReference, filter?: string) {
-        resolveReferenceNode(node.addressSpace, ref);
-        if (!ref.isForward) {
+    const refType = resolveReferenceType(data.node.addressSpace, ref);
+    if (filter) {
+        if (refType.browseName.toString() !== filter) {
             return;
         }
-        if (NodeId.sameNodeId(ref.referenceType, hasSubtypeNodeId)) {
-            return; // ignore forward HasSubtype
-        }
-        // ignore subtype references
-        /* istanbul ignore next */
-        if (!ref.node) {
-            // tslint:disable-next-line: no-console
-            console.log(" Halt ", ref.toString({ addressSpace: node.addressSpace }));
-            return;
-        }
-        const dir = ref.isForward ? " " : " ";
-        const refNode = ref.node!;
-
-        const refType = resolveReferenceType(node.addressSpace, ref);
-        if (filter) {
-            if (refType.browseName.toString() !== filter) {
-                return;
-            }
+    }
+    if (data.alreadyDumped[refNode.nodeId.toString()]) {
+        return;
+    }
+    // xx const r = refNode.findReferencesAsObject("HasModellingRule", true);
+    const modelingRule = refNode.modellingRule || ""; //  r[0] ? r[0].browseName.toString() : "/";
+
+    let value = "";
+    let dataType = "";
+    if (refNode.nodeClass === NodeClass.Variable) {
+        const v = refNode as UAVariable;
+
+        const val = v.readValue().value.value;
+        if (v.isExtensionObject()) {
+            // don't do anything
+        } else if (v.isEnumeration() && val !== null) {
+            const enumValue = v.readEnumValue();
+            value = enumValue.value + " (" + enumValue.name + ")";
+        } else if (val instanceof Date) {
+            value = val ? val.toUTCString() : "";
+        } else {
+            value = val ? val.toString() : "null";
         }
-        if (alreadyDumped[refNode.nodeId.toString()]) {
-            return;
+        const actualDataType = DataType[v.readValue().value.dataType];
+        const basicDataType = DataType[v.dataTypeObj.basicDataType];
+        dataType = v.dataTypeObj.browseName.toString();
+        if (basicDataType !== dataType) {
+            dataType = dataType + "(" + basicDataType + ")";
         }
-        // xx const r = refNode.findReferencesAsObject("HasModellingRule", true);
-        const modelingRule = refNode.modellingRule || ""; //  r[0] ? r[0].browseName.toString() : "/";
-
-        let value = "";
-        let dataType = "";
-        if (refNode.nodeClass === NodeClass.Variable) {
-            const v = refNode as UAVariable;
-
-            const val = v.readValue().value.value;
-            if (v.isExtensionObject()) {
-                // don't do anything
-            } else if (v.isEnumeration() && val !== null) {
-                const enumValue = v.readEnumValue();
-                value = enumValue.value + " (" + enumValue.name + ")";
-            } else if (val instanceof Date) {
-                value = val ? val.toUTCString() : "";
-            } else {
-                value = val ? val.toString() : "null";
-            }
-            const actualDataType = DataType[v.readValue().value.dataType];
-            const basicDataType = DataType[v.dataTypeObj.basicDataType];
-            dataType = v.dataTypeObj.browseName.toString();
-            if (basicDataType !== dataType) {
-                dataType = dataType + "(" + basicDataType + ")";
-            }
-            // findBasicDataType(v.dataTypeObj);
+        // findBasicDataType(v.dataTypeObj);
+    }
+
+    const row = [
+        refType.browseName.toString() + dir + symbol(refNode.nodeClass),
+        refNode.nodeId.toString(),
+        refNode.browseName.toString(),
+        modelingRule,
+        (refNode as any).typeDefinitionObj ? (refNode as any).typeDefinitionObj.browseName.toString() : "",
+        dataType,
+        value
+    ];
+
+    data.table.push(row);
+
+    data.descriptions.push({
+        description: refNode.description ? refNode.description.toString() : "",
+        name: refNode.browseName.name!,
+        type: dataType
+    });
+    data.alreadyDumped[refNode.nodeId.toString()] = 1;
+}
+function dumpReferences(data: Data, _references: UAReference[]) {
+    // xx for (const ref of references) {
+    // xx  dumpReference(ref, "HasSubtype");
+    // xx }
+    for (const ref of _references) {
+        dumpReference(data, ref, "HasTypeDefinition");
+    }
+    for (const ref of _references) {
+        dumpReference(data, ref, "HasEncoding");
+    }
+    for (const ref of _references) {
+        dumpReference(data, ref, "HasComponent");
+    }
+    for (const ref of _references) {
+        dumpReference(data, ref, "HasProperty");
+    }
+    for (const ref of _references) {
+        dumpReference(data, ref, "Organizes");
+    }
+}
+export function displayNodeElement(node: BaseNode, options?: DisplayNodeOptions): string {
+    const head: string[] = ["ReferenceType", "NodeId", "BrowseName", "ModellingRule", "TypeDefinition", "DataType", "Value"];
+
+    function createTable() {
+        const table = new TableHelper(head);
+        table.push(["BrowseName: ", { colSpan: 6, content: node.browseName.toString() }]);
+
+        const superType = (node as UAObjectType).subtypeOfObj;
+        if (superType) {
+            table.push(["Base", superType.browseName.toString(), { colSpan: 6, content: node.browseName.toString() }]);
         }
 
-        const row = [
-            refType.browseName.toString() + dir + symbol(refNode.nodeClass),
-            refNode.nodeId.toString(),
-            refNode.browseName.toString(),
-            modelingRule,
-            (refNode as any).typeDefinitionObj ? (refNode as any).typeDefinitionObj.browseName.toString() : "",
-            dataType,
-            value
-        ];
-
-        table.push(row);
-
-        descriptions.push({
-            description: refNode.description ? refNode.description.toString() : "",
-            name: refNode.browseName.name!,
-            type: dataType
-        });
-        alreadyDumped[refNode.nodeId.toString()] = 1;
+        if (node.description) {
+            table.push(["Description", node.description.toString(), { colSpan: 6, content: node.browseName.toString() }]);
+        }
+        return table;
     }
+
+    const table = createTable();
+
+    const alreadyDumped: Record<string, any> = {};
+
+    const descriptions: Description[] = [];
+
     const references = node.allReferences();
 
     const m = {};
 
-    function dumpReferences(_references: UAReference[]) {
-        // xx for (const ref of references) {
-        // xx  dumpReference(ref, "HasSubtype");
-        // xx }
-        for (const ref of _references) {
-            dumpReference(ref, "HasTypeDefinition");
-        }
-        for (const ref of _references) {
-            dumpReference(ref, "HasEncoding");
-        }
-        for (const ref of _references) {
-            dumpReference(ref, "HasComponent");
-        }
-        for (const ref of _references) {
-            dumpReference(ref, "HasProperty");
-        }
-        for (const ref of _references) {
-            dumpReference(ref, "Organizes");
+    const data = { table, node, alreadyDumped, descriptions };
+    dumpReferences(data, references);
+
+    function toText(table: TableHelper) {
+        if (options && options.format === "markdown") {
+            return table.toMarkdownTable();
+        } else {
+            return table.toString();
         }
     }
-    dumpReferences(references);
+
+    const str: string[] = [];
+    const tables: TableHelper[] = [];
+    tables.push(table);
+    str.push(toText(table));
+
+    const str2: string[] = [];
 
     // add property from base object/variable type
     if (node.nodeClass === NodeClass.ObjectType || node.nodeClass === NodeClass.VariableType) {
         const curNode = node;
 
-        let subtypeOf = (curNode as UAObjectType).subtypeOfObj;
+        let subtypeOf = (curNode as UAObjectType | UAVariableType).subtypeOfObj;
         while (subtypeOf) {
+            data.table = createTable();
             table.push([subtypeOf.browseName.toString() + ":", "--", "--", "--"]);
             const references2 = subtypeOf.allReferences();
-            dumpReferences(references2);
+            dumpReferences(data, references2);
+
+            str.push("<details>");
+            str.push("<summary>Base type: " + subtypeOf.browseName.toString() + "</summary>");
+            str.push("");
+            str.push(toText(table));
+            str.push("");
+            str2.push("</details>");
+
             subtypeOf = (subtypeOf as UAObjectType).subtypeOfObj;
         }
     }
-
-    if (options && options.format === "markdown") {
-        return table.toMarkdownTable();
-    } else {
-        return table.toString();
-    }
+    return str.join("\n") + str2.join("\n");
 }

package/source/generate_markdown_doc.ts

@@ -3,8 +3,10 @@ import { BaseNode, Namespace, UADataType, UAObjectType, UAReferenceType, UAVaria
 import { coerceUInt32 } from "node-opcua-basic-types";
 import { DataTypeDefinition, EnumDefinition, StructureDefinition, StructureField } from "node-opcua-types";
 import { DataType } from "node-opcua-variant";
+import { object } from "underscore";
 import { displayNodeElement } from "./displayNodeElement";
 import { TableHelper } from "./tableHelper";
+import { dumpClassHierachry, graphVizToPlantUml, opcuaToDot } from "./to_graphivz";
 
 interface NamespacePriv2 {
     nodeIterator(): IterableIterator<BaseNode>;
@@ -74,7 +76,7 @@ function dataTypeToMarkdown(dataType: UADataType): string {
                 f.valueRank ? f.valueRank : "",
                 f.maxStringLength ? f.maxStringLength : "",
                 f.arrayDimensions ? f.arrayDimensions : "",
-                f.description.text || ""
+                (f.description.text || "").replace(/\n/g, "<br>"),
             ]);
         }
         writer.writeLine(table.toMarkdownTable());
@@ -123,6 +125,11 @@ export async function buildDocumentation(namespace: Namespace, writer: IWriter):
     for (const objectType of namespacePriv._objectTypeIterator()) {
         writer.writeLine("\n\n### " + objectType.browseName.name!.toString());
         writer.writeLine(d(objectType));
+
+        writer.writeLine(graphVizToPlantUml(dumpClassHierachry(objectType, {showBaseType: true, depth: 2})));
+
+        writer.writeLine(graphVizToPlantUml(opcuaToDot(objectType)));
+
         // enumerate components
         writer.writeLine(displayNodeElement(objectType, { format: "markdown" }));
 
@@ -145,6 +152,12 @@ export async function buildDocumentation(namespace: Namespace, writer: IWriter):
         writer.writeLine("\n\n### " + variableType.browseName.name!.toString());
         writer.writeLine(d(variableType));
         writer.writeLine("");
+
+        writer.writeLine(graphVizToPlantUml(dumpClassHierachry(variableType, {showBaseType: true, depth: 2})));
+
+        writer.writeLine(graphVizToPlantUml(opcuaToDot(variableType)));
+
+
         // enumerate components
         writer.writeLine(displayNodeElement(variableType, { format: "markdown" }));
         for (const reference of variableType.allReferences()) {
@@ -155,3 +168,5 @@ export async function buildDocumentation(namespace: Namespace, writer: IWriter):
         }
     }
 }
+
+

package/source/index.ts

@@ -6,6 +6,7 @@ export * from "./build_model_inner";
 export * from "./addExtensionObjectDataType";
 export * from "./symbol";
 export * from "./to_cvs";
+export * from "./to_graphivz";
 export * from "./generate_markdown_doc";
 //
 export * from "node-opcua-address-space";
@@ -20,6 +21,7 @@ export * from "node-opcua-basic-types";
 export * from "node-opcua-constants";
 export * from "node-opcua-assert";
 export * from "node-opcua-service-translate-browse-path";
+
 export { MethodIds, DataTypeIds, ReferenceTypeIds, VariableIds, VariableTypeIds, ObjectTypeIds, ObjectIds } from "node-opcua-constants";
 
 export {