node-opcua-modeler 2.51.0

package/source/displayNodeElement.ts

@@ -0,0 +1,178 @@
+import {
+    BaseNode,
+    UAReference,
+    UAObjectType,
+    UAVariable,
+    resolveReferenceNode,
+    resolveReferenceType
+} from "node-opcua-address-space";
+import { NodeClass } from "node-opcua-data-model";
+import { NodeId, resolveNodeId } from "node-opcua-nodeid";
+import { DataType } from "node-opcua-variant";
+import { TableHelper } from "./tableHelper";
+
+const a = "ⓂⓄⓋⓥⓇ❗⟵	⟶⟷";
+function symbol(nodeClass: NodeClass) {
+    switch (nodeClass) {
+        case NodeClass.DataType:
+            return "Ⓓ";
+        case NodeClass.ObjectType:
+            return "ⓄT";
+        case NodeClass.VariableType:
+            return "ⓋT";
+        case NodeClass.Method:
+            return "Ⓜ";
+        case NodeClass.Object:
+            return "Ⓞ";
+        case NodeClass.Variable:
+            return "Ⓥ";
+        case NodeClass.View:
+            return "⦖";
+        default:
+            return "?";
+    }
+}
+const hasSubtypeNodeId = resolveNodeId("HasSubtype");
+
+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() }]);
+    }
+
+    if (node.description) {
+        table.push(["Description", node.description.toString(), { colSpan: 6, content: node.browseName.toString() }]);
+    }
+
+    const alreadyDumped: any = {};
+
+    const descriptions: 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 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");
+        }
+    }
+    dumpReferences(references);
+
+    // 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;
+        while (subtypeOf) {
+            table.push([subtypeOf.browseName.toString() + ":", "--", "--", "--"]);
+            const references2 = subtypeOf.allReferences();
+            dumpReferences(references2);
+            subtypeOf = (subtypeOf as UAObjectType).subtypeOfObj;
+        }
+    }
+
+    if (options && options.format === "markdown") {
+        return table.toMarkdownTable();
+    } else {
+        return table.toString();
+    }
+}

package/source/generate_markdown_doc.ts

@@ -0,0 +1,156 @@
+import { BaseNode, Namespace, UADataType, UAObjectType, UAReferenceType, UAVariableType } from "node-opcua-address-space";
+import { coerceUInt32 } from "node-opcua-basic-types";
+import { DataTypeDefinition, EnumDefinition, StructureDefinition, StructureField } from "node-opcua-types";
+import { DataType } from "node-opcua-variant";
+import { displayNodeElement } from "./displayNodeElement";
+import { TableHelper } from "./tableHelper";
+
+interface NamespacePriv2 {
+    nodeIterator(): IterableIterator<BaseNode>;
+    _objectTypeIterator(): IterableIterator<UAObjectType>;
+    _objectTypeCount(): number;
+    _variableTypeIterator(): IterableIterator<UAVariableType>;
+    _variableTypeCount(): number;
+    _dataTypeIterator(): IterableIterator<UADataType>;
+    _dataTypeCount(): number;
+    _referenceTypeIterator(): IterableIterator<UAReferenceType>;
+    _referenceTypeCount(): number;
+    _aliasCount(): number;
+}
+export interface IWriter {
+    writeLine(...args: any[]): void;
+}
+class Writer implements IWriter {
+    private readonly stream: string[] = [];
+    constructor() {
+        /* empty */
+    }
+    public writeLine(str: string) {
+        this.stream.push(str);
+    }
+    public toString(): string {
+        return this.stream.join("\n");
+    }
+}
+
+export async function buildDocumentationToString(namespace: Namespace): Promise<string> {
+    const writer = new Writer();
+    await buildDocumentation(namespace, writer);
+    return writer.toString();
+}
+
+function dataTypeToMarkdown(dataType: UADataType): string {
+    const addressSpace = dataType.addressSpace;
+
+    const writer = new Writer();
+    const definition: DataTypeDefinition = (dataType as any).$definition;
+
+    writer.writeLine("\nisAbstract: " + (dataType.isAbstract ? "Yes" : "No"));
+    if (dataType.subtypeOfObj) {
+        writer.writeLine("\nSubtype of " + dataType.subtypeOfObj?.browseName.toString());
+    }
+    writer.writeLine("");
+
+    if (definition instanceof EnumDefinition) {
+        writer.writeLine("\nBasic Type: " + (DataType as any)[DataType.UInt32]);
+        writer.writeLine("");
+
+        const table = new TableHelper(["Name", "Value", "Description"]);
+        for (const f of definition.fields || []) {
+            table.push([f.name, coerceUInt32(f.value[1]), f.description.text || ""]);
+        }
+        writer.writeLine(table.toMarkdownTable());
+    } else if (definition instanceof StructureDefinition) {
+        writer.writeLine("\nBasic Type: " + (DataType as any)[dataType.basicDataType]);
+
+        const table = new TableHelper(["Name", "data type", "value rank", "maxStringLength", "Dimensions", "Description"]);
+
+        for (const f of definition.fields || []) {
+            const dataTypeString = addressSpace.findDataType(f.dataType)!.browseName.toString();
+            table.push([
+                f.name,
+                dataTypeString,
+                f.valueRank ? f.valueRank : "",
+                f.maxStringLength ? f.maxStringLength : "",
+                f.arrayDimensions ? f.arrayDimensions : "",
+                f.description.text || ""
+            ]);
+        }
+        writer.writeLine(table.toMarkdownTable());
+    } else {
+        writer.writeLine("\nBasic Type: " + (DataType as any)[dataType.basicDataType]);
+        writer.writeLine("");
+    }
+    return writer.toString();
+}
+export async function buildDocumentation(namespace: Namespace, writer: IWriter) {
+    const addressSpace = namespace.addressSpace;
+
+    const namespaceUri = namespace.namespaceUri;
+    // -------- Documentation
+
+    const nsIndex = addressSpace.getNamespaceIndex(namespaceUri);
+
+    writer.writeLine("");
+    writer.writeLine("# Namespace " + namespaceUri);
+    writer.writeLine("");
+    // -------------- writeReferences
+    const namespacePriv = (namespace as unknown) as NamespacePriv2;
+    writer.writeLine("");
+    writer.writeLine("##  References ");
+    writer.writeLine("");
+    for (const referenceType of namespacePriv._referenceTypeIterator()) {
+        writer.writeLine("\n\n###  reference " + referenceType.browseName.name!);
+    }
+
+    function d(node: BaseNode): string {
+        return node.description ? node.description!.text!.toString() : "";
+    }
+    // -------------- writeDataType
+    writer.writeLine("");
+    writer.writeLine("## DataTypes");
+    writer.writeLine("");
+    for (const dataType of namespacePriv._dataTypeIterator()) {
+        writer.writeLine("\n\n### " + dataType.browseName.name!.toString());
+        writer.writeLine("");
+        writer.writeLine(dataTypeToMarkdown(dataType));
+    }
+    // -------------- writeObjectType
+    writer.writeLine("");
+    writer.writeLine("## ObjectTypes");
+    writer.writeLine("");
+    for (const objectType of namespacePriv._objectTypeIterator()) {
+        writer.writeLine("\n\n### " + objectType.browseName.name!.toString());
+        writer.writeLine(d(objectType));
+        // enumerate components
+        writer.writeLine(displayNodeElement(objectType, { format: "markdown" }));
+
+        for (const comp of objectType.getComponents()) {
+            writer.writeLine("\n\n#### " + comp.browseName.name!.toString());
+            writer.writeLine("");
+            writer.writeLine(d(comp));
+        }
+        for (const comp of objectType.getProperties()) {
+            writer.writeLine("\n\n#### " + comp.browseName.name!.toString());
+            writer.writeLine("");
+            writer.writeLine(d(comp));
+        }
+    }
+    // -------------- writeVariableType
+    writer.writeLine("");
+    writer.writeLine("## VariableTypes");
+    writer.writeLine("");
+    for (const variableType of namespacePriv._variableTypeIterator()) {
+        writer.writeLine("\n\n### " + variableType.browseName.name!.toString());
+        writer.writeLine(d(variableType));
+        writer.writeLine("");
+        // enumerate components
+        writer.writeLine(displayNodeElement(variableType, { format: "markdown" }));
+        for (const reference of variableType.allReferences()) {
+            const n = reference.node!;
+            writer.writeLine("\n\n#### " + n.browseName.name!.toString());
+            writer.writeLine("");
+            writer.writeLine(d(n));
+        }
+    }
+}

package/source/index.ts

@@ -0,0 +1,31 @@
+export * from "./types";
+export * from "./displayNodeElement";
+export * from "./promoteToMandatory";
+export * from "./setNamespaceMetaData";
+export * from "./build_model_inner";
+export * from "./addExtensionObjectDataType";
+export * from "./symbol";
+export * from "./to_cvs";
+export * from "./generate_markdown_doc";
+//
+export * from "node-opcua-address-space";
+export * from "node-opcua-nodesets";
+export * from "node-opcua-variant";
+export * from "node-opcua-assert";
+export * from "node-opcua-data-model";
+export * from "node-opcua-nodeid";
+export * from "node-opcua-numeric-range";
+export * from "node-opcua-status-code";
+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 {
+    DataTypeDefinition,
+    EnumDefinition,
+    EnumDefinitionOptions,
+    StructureDefinition,
+    StructureDefinitionOptions
+} from "node-opcua-types";

package/source/promoteToMandatory.ts

@@ -0,0 +1,137 @@
+import {
+    BaseNode,
+    UADataType,
+    UAMethod,
+    UAObject,
+    UAObjectType,
+    UAReference,
+    UAReferenceType,
+    UAVariable,
+    UAVariableType,
+    ModellingRuleType,
+} from "node-opcua-address-space";
+import { NodeClass } from "node-opcua-data-model";
+import { makeBrowsePath } from "node-opcua-service-translate-browse-path";
+
+import { displayNodeElement } from "./displayNodeElement";
+
+type UAType = UAObjectType | UAVariableType | UAReferenceType | UADataType;
+
+export type UAConcrete = UAVariable | UAObject | UAMethod;
+
+// find the reference that links node1 to node2
+function findReferenceToNode(node1: BaseNode, node2: BaseNode): UAReference {
+    const references = node1.allReferences();
+    const r = references.filter((reference: UAReference) => {
+        return reference.nodeId.toString() === node2.nodeId.toString();
+    });
+    const ref = r ? r[0] : null;
+    /* istanbul ignore next */
+    if (!ref) {
+        // may be from subtype
+        if (
+            node1.nodeClass === NodeClass.ObjectType ||
+            node1.nodeClass === NodeClass.ReferenceType ||
+            node1.nodeClass === NodeClass.VariableType
+        ) {
+            const uaType = node1 as UAType;
+            if (uaType.subtypeOfObj) {
+                return findReferenceToNode(uaType.subtypeOfObj, node2);
+            }
+        }
+
+        throw new Error("Internal Error cannot find ref from node " + node1.nodeId.toString() + " " + node2.nodeId.toString());
+    }
+    return ref;
+}
+
+export function getChildInTypeOrBaseType(
+    node: UAObjectType | UAVariableType,
+    propertyName: string,
+    namespaceIndex: number
+): { propInSuperType: UAConcrete; reference: UAReference } {
+    const addressSpace = node.addressSpace;
+
+    const subtypeOf = node.subtypeOfObj!;
+    /* istanbul ignore next */
+    if (!subtypeOf) {
+        throw new Error("Expecting a super type");
+    }
+
+    const browseResult = addressSpace.browsePath(makeBrowsePath(subtypeOf.nodeId, `.${namespaceIndex}:${propertyName}`));
+    const propNodeId = !browseResult.targets || !browseResult.targets[0] ? null : browseResult.targets[0].targetId!;
+
+    /* istanbul ignore next */
+    if (!propNodeId) {
+        displayNodeElement(subtypeOf);
+        throw new Error("property " + propertyName + " do not exists on " + subtypeOf.browseName.toString() + " or any superType");
+    }
+
+    const propInSuperType = addressSpace.findNode(propNodeId)! as UAVariable | UAMethod | UAObject;
+
+    /* istanbul ignore next */
+    if (!propInSuperType) {
+        throw new Error("cannot find " + propNodeId.toString());
+    }
+    // replicate property
+    const reference = findReferenceToNode(subtypeOf, propInSuperType);
+
+    /* istanbul ignore next */
+    if (!reference) {
+        throw new Error("cannot find reference");
+    }
+    return { propInSuperType, reference };
+}
+
+export function promoteToMandatory(node: UAObjectType | UAVariableType, propertyName: string, namespaceIndex: number): UAConcrete {
+    // get base node
+
+    const { propInSuperType, reference } = getChildInTypeOrBaseType(node, propertyName, namespaceIndex);
+
+    // check mandatory
+    /* istanbul ignore next */
+    if (propInSuperType.modellingRule === "Mandatory") {
+        // tslint:disable-next-line: no-console
+        console.log("Warning property " + propertyName + " is already Mandatory in super type");
+        return propInSuperType;
+    }
+
+    const newRef = {
+        isForward: false,
+        nodeId: node.nodeId,
+        referenceType: reference.referenceType
+    };
+
+    const newProp = (propInSuperType as UAConcrete).clone({
+        namespace: node.namespace,
+        modellingRule: "Mandatory",
+        references: [newRef]
+    });
+    return newProp;
+}
+
+export function promoteChild(
+    node: UAObjectType | UAVariableType,
+    propertyName: string,
+    namespaceIndex: number,
+    modellingRule: ModellingRuleType
+): UAConcrete {
+    const { propInSuperType, reference } = getChildInTypeOrBaseType(node, propertyName, namespaceIndex);
+
+    if (!modellingRule) {
+        modellingRule = propInSuperType.modellingRule || null;
+    }
+
+    const newRef: UAReference = {
+        isForward: false,
+        nodeId: node.nodeId,
+        referenceType: reference.referenceType
+    };
+
+    const newProp = (propInSuperType as UAConcrete).clone({
+        namespace: node.namespace,
+        modellingRule,
+        references: [{...newRef}]
+    });
+    return newProp;
+}

package/source/setNamespaceMetaData.ts

@@ -0,0 +1 @@
+export { setNamespaceMetaData } from "node-opcua-address-space";

package/source/symbol.ts

@@ -0,0 +1 @@
+export type Symbols = [string, number, string][];

package/source/tableHelper.ts

@@ -0,0 +1,64 @@
+// tslint:disable-next-line: no-var-requires
+const Table = require("cli-table3");
+
+const chars1 = {
+    // tslint:disable-next-line: object-literal-sort-keys
+    "top": "-", "top-mid": "+", "top-left": "+", "top-right": "+"
+    , "bottom": "-", "bottom-mid": "+", "bottom-left": "+", "bottom-right": "+"
+    , "left": "|", "left-mid": "+", "mid": "-", "mid-mid": "+"
+    , "right": "|", "right-mid": "+", "middle": "|"
+};
+const chars2 = {
+    // tslint:disable-next-line: object-literal-sort-keys
+    "top": " ", "top-mid": "   ", "top-left": "  ", "top-right": "  "
+    , "bottom": " ", "bottom-mid": "   ", "bottom-left": "  ", "bottom-right": " "
+    , "left": "| ", "left-mid": "| ", "mid": "-", "mid-mid": " | "
+    , "right": " |", "right-mid": "| ", "middle": " | "
+};
+const chars3 = {
+    // tslint:disable-next-line: object-literal-sort-keys
+    "top": "", "top-mid": "", "top-left": "", "top-right": ""
+    , "bottom": "", "bottom-mid": "", "bottom-left": "", "bottom-right": ""
+    , "left": "| ", "left-mid": "", "mid": "-", "mid-mid": " | "
+    , "right": " |", "right-mid": "", "middle": " | "
+};
+
+function toMarkdownTable(table: { head: string[], rows: string[][] }): string {
+
+    const t = [];
+
+    t.push("| " + table.head.join(" | ") + " |");
+    t.push("| " + table.head.map(() => "---").join(" | ") + " |");
+    for (const r of table.rows) {
+        t.push("| " + r.join(" | ") + " |");
+    }
+    return t.join("\n");
+}
+
+export class TableHelper {
+
+    private readonly rows: string[][] = [];
+    private readonly table: typeof Table;
+    private readonly head: string[];
+    constructor(head: string[]) {
+        this.rows = [];
+        // instantiate
+        this.table = new Table({
+            // chars,
+            head,
+            // colWidths: [100, 200, 50, 50,]
+        });
+        this.head = head;
+    }
+    public push(row: any) {
+        this.table.push(row);
+        const row2 = row.map((c: any) => (c.content) ? c.content : c);
+        this.rows.push(row2);
+    }
+    public toString() {
+        return this.table.toString();
+    }
+    public toMarkdownTable() {
+        return toMarkdownTable({ head: this.head, rows: this.rows });
+    }
+}

package/source/to_cvs.ts

@@ -0,0 +1,9 @@
+import { Symbols } from "./symbol";
+
+export function toCSV(arr: Symbols) {
+    const line: string[] = [];
+    for (const [name, value, nodeClass] of arr) {
+        line.push([name, value, nodeClass].join(","));
+    }
+    return line.join("\n");
+}

package/source/types.ts

@@ -0,0 +1 @@
+export { UANamespaceMetadata } from "node-opcua-address-space";

package/source_nodejs/build_documentation_to_file.ts

@@ -0,0 +1,13 @@
+import * as fs from "fs";
+import { Namespace } from "node-opcua-address-space";
+import { buildDocumentationToString } from "..";
+
+export async function buildDocumentationToFile(namespace: Namespace, filename: string) {
+    const str = await buildDocumentationToString(namespace);
+    const stream = fs.createWriteStream("documentation.md");
+    stream.write(str);
+    await new Promise((resolve) => {
+        stream.on("finish", resolve);
+        stream.end();
+    });
+}

package/source_nodejs/build_model.ts

@@ -0,0 +1,12 @@
+import { readNodeSet2XmlFile } from "node-opcua-address-space/nodeJS";
+
+import { buildModelInner, BuildModelOptionsBase } from "..";
+import { Symbols } from "..";
+
+export async function buildModel(data: BuildModelOptionsBase): Promise<{ markdown: string; xmlModel: string; symbols: Symbols }> {
+    const option1 = {
+        ...data,
+        xmlLoader: readNodeSet2XmlFile
+    };
+    return buildModelInner(option1);
+}

package/source_nodejs/index.ts

@@ -0,0 +1,5 @@
+export * from "./symbol_cvs";
+export * from "./build_model";
+export * from "./build_documentation_to_file";
+export * from "../dist";
+export { generateAddressSpace } from "node-opcua-address-space/nodeJS"

package/source_nodejs/symbol_cvs.ts

@@ -0,0 +1,52 @@
+import * as fs from "fs";
+import { promisify } from "util";
+import * as parse from "csv-parse";
+import { Parser } from "csv-parse";
+
+import { Symbols } from "..";
+import { toCSV } from "..";
+
+// node 14 onward : import { readFile, writeFile } from "fs/promises";
+const { readFile, writeFile } = fs.promises;
+
+export async function saveSymbolsToCSV(csvFilename: string, symbols: Symbols): Promise<void> {
+    await writeFile(csvFilename, toCSV(symbols), "utf-8");
+}
+
+export async function getPresetSymbolsFromCSV(csvFilename: string): Promise<Symbols> {
+    if (!fs.existsSync(csvFilename)) {
+        return [];
+    }
+    try {
+        const data = await readFile(csvFilename, "utf-8");
+
+        const records = await new Promise((resolve) => {
+            const output: any[] = [];
+            parse(data, {
+                cast: (value, context) => {
+                    if (context.index === 1) {
+                        return parseInt(value, 10);
+                    }
+                    return value;
+                }
+            })
+                .on("readable", function (this: Parser) {
+                    let record = this.read();
+                    while (record) {
+                        output.push(record);
+                        record = this.read();
+                    }
+                })
+                .on("end", () => {
+                    resolve(output);
+                });
+        });
+        return records as Symbols;
+    } catch (err) {
+        if (err instanceof Error) {
+            // tslint:disable-next-line: no-console
+            console.log("getPresetSymbols err = ", err.message);
+        }
+        return [];
+    }
+}