node-opcua-modeler 2.63.1 → 2.64.1

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";
@@ -37,142 +38,194 @@ const hasSubtypeNodeId = resolveNodeId("HasSubtype");
 export interface DisplayNodeOptions {
     format: "cli" | "markdown";
 }
+function encodeXML(s: string) {
+    return s.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;");
+}
+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 (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 refType = resolveReferenceType(data.node.addressSpace, ref);
+    if (filter) {
+        if (refType.browseName.name !== filter) {
+            return;
+        }
+    }
+    const key = ref.nodeId.toString() + ref.referenceType.toString();
+    if (data.alreadyDumped[key]) {
+        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";
+        }
+        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);
+    }
 
+    const row = [
+        refType.browseName.toString() + dir + symbol(refNode.nodeClass),
+        refNode.nodeId.toString(),
+        encodeXML(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.text || "" : "",
+        name: refNode.browseName.name!,
+        type: dataType
+    });
+    data.alreadyDumped[key] = 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");
+    }
+    for (const ref of _references) {
+        console.log(data.node!.addressSpace!.findReferenceType(ref.referenceType)!.toString());
+        dumpReference(data, ref, undefined);
+    }
+}
+
+function shortDescription(d: string) {
+    return d.split(/\.|\n/)[0];
+}
 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() }]);
+    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 superType = (node as UAObjectType).subtypeOfObj;
+        if (superType) {
+            table.push(["Base", superType.browseName.toString(), { colSpan: 6, content: node.browseName.toString() }]);
+        }
 
-    if (node.description) {
-        table.push(["Description", node.description.toString(), { colSpan: 6, content: node.browseName.toString() }]);
+        if (node.description) {
+            table.push(["Description", { colspan: 6, content: shortDescription(node.description.text! || "") }]);
+        }
+        return table;
     }
 
-    const alreadyDumped: any = {};
+    const table = createTable();
 
-    const descriptions: any = [];
+    const alreadyDumped: Record<string, any> = {};
 
-    function dumpReference(ref: UAReference, filter?: string) {
-        resolveReferenceNode(node.addressSpace, ref);
-        if (!ref.isForward) {
-            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 (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";
-            }
-            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);
-        }
+    const descriptions: Description[] = [];
 
-        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;
-    }
     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);
+
+    if (node.description) {
+        str.push(node.description.text! || "");
+        str.push("");
+    }
+    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) {
-            table.push([subtypeOf.browseName.toString() + ":", "--", "--", "--"]);
+            data.table = createTable();
+            data.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(data.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/dump_state_machine_to_graphviz.ts

@@ -0,0 +1,164 @@
+/**
+ * @module node-opcua-address-space
+ */
+// tslint:disable:no-console
+/*
+ * class Node {
+ *     { browseName: "string", nodeId: NodeId}
+ * }
+ * Transition {
+ *     browseName: "String"
+ *     fromState: Node
+ *     toState: Node
+ * }
+ * class SateMachineType {
+ *    initialState: Node
+ *    states: [ Node,Node, ...]
+ *    transitions: [Transition]
+ * }
+ * @param stateMachineType
+ */
+import { BaseNode, UAState, UAStateMachineEx, UATransition, UAObject, UATransitionEx } from "node-opcua-address-space";
+
+
+export function dumpStateMachineToPlantUML(stateMachineType: UAStateMachineEx): string {
+
+    const lines: string[] = [];
+    function w(str: string) {
+        lines.push(str);
+    }
+
+    function s(state: BaseNode) {
+        return state? state.nodeId.value.toString() : "";
+    }
+
+    function n(state: BaseNode) {
+        return state ? state.browseName.name!.toString() : "";
+    }
+
+//w("@startuml "); // + stateMachineType.browseName.toString() + ".png");
+    // initial state if any
+
+    if (stateMachineType.initialState) {
+        w(" [*] --> " + s(stateMachineType.initialState));
+        w(" " + s(stateMachineType.initialState) + ":" + n(stateMachineType.initialState));
+    } else {
+        w("[*] --> [*]");
+    }
+
+    function t(transition: BaseNode) {
+        let name = n(transition);
+        name = name.replace(":", "");
+        name = name.replace("To", "\\nTo\\n");
+        name = name.replace("Transition", "\\nTransition");
+        return name;
+    }
+
+    stateMachineType.states && stateMachineType.states.forEach((state: UAObject) => w(" " + s(state) + ": " + n(state)));
+
+    stateMachineType.transitions && stateMachineType.transitions.forEach((transition: UATransitionEx) =>
+        w("  " + s(transition.fromStateNode!) + " --> " + s(transition.toStateNode!) + " : " + t(transition))
+    );
+
+ //   w("@enduml");
+    return lines.join("\n");
+
+}
+
+/*
+ @startuml
+
+ 2930: Unshelved
+
+ 2932: TimedShelved
+
+ 2933: OneShotShelved
+
+ 2930 --> 2932 :   "2935\nUnshelvedToTimedShelved"
+
+ 2930 --> 2933 :   "2936\nUnshelvedToOneShotShelved"
+
+ 2932 --> 2930 :   "2940\nTimedShelvedToUnshelved"
+
+ 2932 --> 2933 :   "2942\nTimedShelvedToOneShotShelved"
+
+ 2933 --> 2930 :   "2943\nOneShotShelvedToUnshelved"
+
+ 2933 --> 2932 :   "2945\nOneShotShelvedToTimedShelved"
+
+ @enduml
+
+ */
+
+/*
+ digraph finite_state_machine {
+ rankdir=LR;
+ size="8,5"
+ node [shape = doublecircle]; LR_0 LR_3 LR_4 LR_8;
+ node [shape = circle];
+ LR_0 -> LR_2 [ label = "SS(B)" ];
+ LR_0 -> LR_1 [ label = "SS(S)" ];
+ LR_1 -> LR_3 [ label = "S($end)" ];
+ LR_2 -> LR_6 [ label = "SS(b)" ];
+ LR_2 -> LR_5 [ label = "SS(a)" ];
+ LR_2 -> LR_4 [ label = "S(A)" ];
+ LR_5 -> LR_7 [ label = "S(b)" ];
+ LR_5 -> LR_5 [ label = "S(a)" ];
+ LR_6 -> LR_6 [ label = "S(b)" ];
+ LR_6 -> LR_5 [ label = "S(a)" ];
+ LR_7 -> LR_8 [ label = "S(b)" ];
+ LR_7 -> LR_5 [ label = "S(a)" ];
+ LR_8 -> LR_6 [ label = "S(b)" ];
+ LR_8 -> LR_5 [ label = "S(a)" ];
+ }
+ */
+export function dumpStateMachineToGraphViz(
+    /*StateMachineProxy*/
+    stateMachineType: UAStateMachineEx
+): string {
+    const lines: string[] = [];
+    function w(str: string) {
+        lines.push(str)
+    }
+
+    function s(state: BaseNode) {
+        return state.nodeId.value.toString();
+    }
+
+    function n(state: BaseNode) {
+        return state.browseName.name!.toString();
+    }
+
+    function s_full(state: BaseNode) {
+        return s(state) + ' [ label = "' + n(state) + '" ]';
+    }
+
+    w("digraph finite_state_machine {");
+    // initial state if any
+
+    if (stateMachineType.initialState) {
+        w("node [ shape = doublecircle];");
+        w("  _" + s_full(stateMachineType.initialState!) + " ;");
+    }
+    w("node [ shape = circle];");
+    stateMachineType.states.forEach((state: UAState) => w("   _" + s_full(state)));
+
+    stateMachineType.transitions.forEach((transition) =>
+        w(
+            "  _" +
+                s(transition.fromStateNode!) +
+                " -> _" +
+                s(transition.toStateNode!) +
+                " [ " +
+                //   " labeltooltip = \"" + i(transition) + "\" " +
+                ', label = "' +
+                n(transition) +
+                '" ];'
+        )
+    );
+
+    w("}");
+
+    return lines.join("\n");
+
+}