node-opcua-modeler 2.64.1 → 2.66.0

package/source/dump_state_machine_to_graphviz.ts

@@ -1,164 +0,0 @@
-/**
- * @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");
-
-}

package/source/to_graphivz.ts

@@ -1,351 +0,0 @@
-import {
-    BaseNode,
-    UAReference,
-    UAObject,
-    UAVariable,
-    UAReferenceType,
-    UADataType,
-    UAObjectType,
-    UAVariableType,
-    UAMethod,
-    UAStateMachineEx,
-    promoteToStateMachine
-} from "node-opcua-address-space";
-import { UAStateMachineImpl } from "node-opcua-address-space/src/state_machine/finite_state_machine";
-import { ReferenceTypeIds } from "node-opcua-constants";
-import { BrowseDirection, NodeClass } from "node-opcua-data-model";
-import { resolveNodeId } from "node-opcua-nodeid";
-
-function e(str: string): string {
-    return str.replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function innerText(node: UAObject | UAVariable) {
-    const browseName = node.browseName.name;
-    const typeDefinition = node.typeDefinitionObj?.browseName?.name;
-
-    if (typeDefinition) {
-        return `[ label =< <FONT point-size="8" ><I>${typeDefinition}</I></FONT><BR/>${e(browseName!)} >]`;
-    } else {
-        return `[label =< ${e(browseName!)} >]`;
-    }
-}
-function arrowHeadAttribute(reference: UAReference): string {
-    switch (reference.referenceType.value) {
-        case ReferenceTypeIds.HasTypeDefinition:
-            return "normalnormal";
-        case ReferenceTypeIds.HasComponent:
-            return "noneteetee";
-        case ReferenceTypeIds.HasProperty:
-            return "nonetee";
-        case ReferenceTypeIds.HasSubtype:
-            return "onormalonormal";
-        case ReferenceTypeIds.HasModellingRule:
-            return "none";
-        default:
-            return "normal";
-    }
-}
-function arrowHead(reference: UAReference): string {
-    return `[arrowhead = ${arrowHeadAttribute(reference)}]`;
-}
-
-const regularShapes: Record<string, string> = {
-    ObjectType: '[shape=rectangle, style="filled" fillcolor="#e8edf7;0.75:#d2def0" gradientangle=275]',
-    VariableType: '[shape=rectangle, style="rounded,filled" fillcolor="#e8edf7;0.75:#d2def0" gradientangle=275]',
-    Object: ' [shape=rectangle, style="filled" fillcolor="#e8edf7"]',
-    Variable: '[shape=rectangle, style="filled,rounded" fillcolor="#e8edf7"]',
-    Method: '[shape=oval, style="filled" fillcolor="#e8edf7"]'
-};
-const regularShapesOptionals: Record<string, string> = {
-    ObjectType: '[shape=rectangle, style="filled,dashed" fillcolor="#e8edf7;0.75:#d2def0" gradientangle=275]',
-    VariableType: '[shape=rectangle, style="rounded,filled,dashed" fillcolor="#e8edf7;0.75:#d2def0" gradientangle=275]',
-    Object: ' [shape=rectangle, style="filled,dashed" fillcolor="#e8edf7"]',
-    Variable: '[shape=rectangle, style="filled,rounded,dashed" fillcolor="#e8edf7"]',
-    Method: '[shape=oval, style="filled,dashed" fillcolor="#e8edf7"]'
-};
-
-interface Options {
-    naked: boolean;
-}
-
-class NodeRegistry {
-    m: Record<string, { name: string; node: BaseNode }[]> = {};
-    invisibleNodes: string[] = [];
-    duplicated: { [key: string]: string } = {};
-    add(name: string, node: BaseNode) {
-        if (this.duplicated[name]) {
-            return; //throw new Error("Already included");
-        }
-        this.duplicated[name] = name;
-        const nodeClass = NodeClass[node.nodeClass];
-        this.m[nodeClass] = this.m[nodeClass] || [];
-        this.m[nodeClass].push({ name, node });
-    }
-    addInvisibleNode(name: string) {
-        this.invisibleNodes.push(name);
-    }
-}
-function dumpNodeByNodeClass(str: string[], nodeRegistry: NodeRegistry) {
-    for (const [className, listNode] of Object.entries(nodeRegistry.m)) {
-        if (listNode.length === 0) {
-            continue;
-        }
-        str.push(`  ## -> ${className}`);
-
-        const mandatoryNodes = listNode.filter(({ name, node }) => !node.modellingRule || node.modellingRule.match(/Mandatory/));
-        const optionalNodes = listNode.filter(({ name, node }) => node.modellingRule && node.modellingRule.match(/Optional/));
-        if (mandatoryNodes.length > 0) {
-            str.push(`  node [];`);
-            const decoration = regularShapes[className] as string;
-            str.push(`  node ${decoration};`);
-            for (const { name, node } of mandatoryNodes) {
-                str.push(`  ${name} ${innerText(node as UAVariable | UAObject)}`);
-            }
-        }
-        if (optionalNodes.length > 0) {
-            const decoration2 = regularShapesOptionals[className] as string;
-            str.push(`  node [];`);
-            str.push(`  node ${decoration2};`);
-            for (const { name, node } of listNode) {
-                str.push(`  ${name} ${innerText(node as UAVariable | UAObject)}`);
-            }
-        }
-    }
-    if (nodeRegistry.invisibleNodes.length) {
-        str.push("  #  invisible nodes");
-        str.push("  node []");
-        str.push("  node [width=0,height=0,shape=point,style=invis];");
-        str.push(`  ${nodeRegistry.invisibleNodes.join("\n  ")};`);
-    }
-}
-
-import { dumpStateMachineToPlantUML } from "./dump_state_machine_to_graphviz";
-
-export function opcuaToDot(node: UAObjectType | UAVariableType, options?: Options): string {
-    if (node.nodeClass === NodeClass.ObjectType) {
-        const finitieStateMachineType = node.addressSpace.findObjectType("FiniteStateMachineType");
-        if (finitieStateMachineType) {
-            if ((node as UAObjectType).isSupertypeOf(finitieStateMachineType)) {
-                const stateMachine = node.instantiate({ browseName: "StateMachine" }) as UAObject;
-                promoteToStateMachine(stateMachine);
-                return dumpStateMachineToPlantUML(stateMachine as UAStateMachineEx);
-            }
-        }
-    }
-    options = options || { naked: false };
-    const nodeRegistry = new NodeRegistry();
-
-    const str: string[] = [];
-    const str2: string[] = [];
-    str.push("digraph G {");
-    if (!options.naked) {
-        str.push("  rankdir=TB;");
-        str.push("  nodesep=0.5;");
-        str.push("  node [];");
-    }
-
-    function makeId(p: string, c: string) {
-        return `${p}_${c}`.replace(" ", "_").replace(/<|>/g, "_");
-    }
-    // eslint-disable-next-line max-params
-    // eslint-disable-next-line max-statements
-    function typeMemberAndSubTypeMember(
-        str: string[],
-        parentNode: string,
-        node: UAObjectType | UAVariableType | UAMethod | UAVariable | UAObject,
-        parent: UAObjectType | UAVariableType | UAMethod | UAVariable | UAObject | null,
-        offset: number,
-        prefix: string,
-        joinWithCaller: boolean,
-        visitorMap: Record<string, any>
-    ): [number, string[]] {
-        let innerDepth = 0;
-        const browseName = (parent || node).browseName.name!.toString();
-        const r: string[] = [];
-        const r2: string[] = [];
-
-        const references = (parent || node).findReferencesEx("Aggregates", BrowseDirection.Forward);
-        const folderElements = (parent || node).findReferencesEx("Organizes", BrowseDirection.Forward);
-        const childReferences = [...references, ...folderElements];
-        const id = makeId(parentNode, browseName);
-        nodeRegistry.add(id, node);
-
-        function addInvisibleNode(prefix: string, index: number) {
-            const breakNode = `${prefix}${index}`;
-            r2.push(breakNode);
-            nodeRegistry.addInvisibleNode(breakNode);
-            return breakNode;
-        }
-        for (let i = 0; i < childReferences.length; i++) {
-            const isLast = i === childReferences.length - 1;
-            const reference = childReferences[i];
-
-            const childNode = reference.node! as UAVariable | UAObject | UAMethod;
-            const childName = childNode.browseName.name!.toString();
-
-            const fullChildName = makeId(id, childName);
-            // avoid member duplication
-            if (visitorMap[fullChildName]) {
-                continue;
-            } else {
-                visitorMap[fullChildName] = 1;
-            }
-
-            innerDepth++;
-
-            nodeRegistry.add(fullChildName, childNode);
-            const edgeAttributes = arrowHead(reference);
-
-            const breakNode = addInvisibleNode(prefix, i + offset);
-            const horizontalPart = `{ rank=same ${breakNode} -> ${fullChildName} ${edgeAttributes} }`;
-            r.push(horizontalPart);
-
-            // push children  on same level
-            const [depth] = typeMemberAndSubTypeMember(str, id, childNode, null, 0, `${prefix}${i + offset}_`, false, visitorMap);
-
-            // add invisible nodes
-            {
-                for (let d = 0; d < depth; d++) {
-                    offset++;
-                    if (!isLast) {
-                        addInvisibleNode(prefix, i + offset);
-                    }
-                }
-                innerDepth += depth;
-            }
-        }
-
-        if (node.nodeClass == NodeClass.ObjectType || node.nodeClass === NodeClass.VariableType) {
-            if (node.subtypeOfObj && node.subtypeOfObj.nodeId.namespace === node.nodeId.namespace) {
-                const [depth, rr2] = typeMemberAndSubTypeMember(
-                    str,
-                    parentNode,
-                    node.subtypeOfObj,
-                    node,
-                    r.length + offset + 1,
-                    prefix,
-                    true,
-                    visitorMap
-                );
-                innerDepth += depth + 1;
-                r2.push(...rr2);
-            }
-        }
-        if (r.length) {
-            str.push(...r.map((x) => "  " + x));
-        }
-
-        if (!joinWithCaller) {
-            if (r2.length) {
-                str.push(`  ${id} -> ${r2.join(" -> ")} [arrowhead=none];`);
-            }
-        }
-
-        return [innerDepth, r2];
-    }
-
-    const visitorMap = {};
-    typeMemberAndSubTypeMember(str2, "", node, null, 0, "r", false, visitorMap);
-
-    if (!options.naked) {
-        dumpNodeByNodeClass(str, nodeRegistry);
-    }
-    str.push(...str2);
-    str.push("}");
-
-    //
-    const dot = str.join("\n");
-    return dot;
-}
-
-export function dumpClassHierachry(
-    typeNode: UAObjectType | UAVariableType | UADataType | UAReferenceType,
-    options?: { naked?: boolean; depth?: number; showBaseType?: boolean; showSubType?: boolean }
-) {
-    options = options || { naked: false, showBaseType: true, showSubType: true };
-    const level = options.depth || 50;
-
-    const str: string[] = [];
-    const nodeRegistry = new NodeRegistry();
-    nodeRegistry.add(typeNode.browseName.name!, typeNode);
-    str.push("digraph G {");
-    if (!options.naked) {
-        // str.push("  splines=ortho;");
-        str.push("  rankdir=BT;");
-        str.push("  nodesep=0.5;");
-        str.push("  node [];");
-    }
-    function dumpSubtypes(str: string[], typeNode: BaseNode, level: number) {
-        const parentName = typeNode.browseName.name!.toString();
-        const references = typeNode.findReferencesEx("HasSubtype", BrowseDirection.Forward);
-        for (let i = 0; i < references.length; i++) {
-            const reference = references[i];
-            const childNode = reference.node! as UAVariableType | UAObjectType;
-            const nodeClass = NodeClass[childNode.nodeClass];
-            const childName = childNode.browseName.name!.toString();
-            nodeRegistry.add(childName, childNode);
-            const edgeAttributes = arrowHead(reference);
-            str.push(`  ${childName}  -> ${parentName} ${edgeAttributes};`);
-
-            if (level > 0) {
-                dumpSubtypes(str, childNode, level - 1);
-            }
-        }
-    }
-    function dumpBaseTypes(str: string[], typeNode: BaseNode, level: number) {
-        const parentName = typeNode.browseName.name!.toString();
-        const references = typeNode.findReferencesEx("HasSubtype", BrowseDirection.Inverse);
-        for (let i = 0; i < references.length; i++) {
-            const reference = references[i];
-            const childNode = reference.node! as UAVariableType | UAObjectType;
-            const nodeClass = NodeClass[childNode.nodeClass];
-            const childName = childNode.browseName.name!.toString();
-            nodeRegistry.add(childName, childNode);
-            const edgeAttributes = arrowHead(reference);
-            str.push(`  ${parentName}  -> ${childName} ${edgeAttributes};`);
-            if (level > 0) {
-                dumpBaseTypes(str, childNode, level - 1);
-            }
-        }
-    }
-    const str2: string[] = [];
-    if (options.showBaseType) {
-        dumpBaseTypes(str2, typeNode, level);
-    }
-    /** */
-    if (options.showSubType) {
-        dumpSubtypes(str2, typeNode, level);
-    }
-    if (!options.naked) {
-        dumpNodeByNodeClass(str, nodeRegistry);
-    }
-    str.push(...str2);
-    str.push("}");
-    return str.join("\n");
-}
-
-export function graphVizToPlantUml(str: string): string {
-    const ttt = "```";
-    return `${ttt}plantuml\n@startuml\n${str}\n@enduml\n${ttt}`;
-}
-export function dumpTypeDiagram(namespace: any) {
-    const objectTypes = [...namespace._objectTypeIterator()];
-    const variableTypes = [...namespace._variableTypeIterator()];
-    const dataTypes = [...namespace._dataTypeIterator()];
-    const referenceTypes = [...namespace._referenceTypeIterator()];
-    const addressSpace = namespace.addressSpace;
-
-    const str: string[] = [];
-    for (const type of [...objectTypes, ...variableTypes]) {
-        const d = opcuaToDot(type);
-        str.push(graphVizToPlantUml(d));
-
-        const d2 = dumpClassHierachry(type);
-        str.push(graphVizToPlantUml(d2));
-    }
-    for (const dataType of dataTypes) {
-        const d = opcuaToDot(dataType);
-        str.push(graphVizToPlantUml(d));
-    }
-    return str.join("\n");
-}