node-opcua-modeler 2.51.0

package/distNodeJS/symbol_cvs.js

@@ -0,0 +1,64 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPresetSymbolsFromCSV = exports.saveSymbolsToCSV = void 0;
+const fs = require("fs");
+const parse = require("csv-parse");
+const __1 = require("..");
+// node 14 onward : import { readFile, writeFile } from "fs/promises";
+const { readFile, writeFile } = fs.promises;
+function saveSymbolsToCSV(csvFilename, symbols) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield writeFile(csvFilename, (0, __1.toCSV)(symbols), "utf-8");
+    });
+}
+exports.saveSymbolsToCSV = saveSymbolsToCSV;
+function getPresetSymbolsFromCSV(csvFilename) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!fs.existsSync(csvFilename)) {
+            return [];
+        }
+        try {
+            const data = yield readFile(csvFilename, "utf-8");
+            const records = yield new Promise((resolve) => {
+                const output = [];
+                parse(data, {
+                    cast: (value, context) => {
+                        if (context.index === 1) {
+                            return parseInt(value, 10);
+                        }
+                        return value;
+                    }
+                })
+                    .on("readable", function () {
+                    let record = this.read();
+                    while (record) {
+                        output.push(record);
+                        record = this.read();
+                    }
+                })
+                    .on("end", () => {
+                    resolve(output);
+                });
+            });
+            return records;
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                // tslint:disable-next-line: no-console
+                console.log("getPresetSymbols err = ", err.message);
+            }
+            return [];
+        }
+    });
+}
+exports.getPresetSymbolsFromCSV = getPresetSymbolsFromCSV;
+//# sourceMappingURL=symbol_cvs.js.map

package/distNodeJS/symbol_cvs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol_cvs.js","sourceRoot":"","sources":["../source_nodejs/symbol_cvs.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,yBAAyB;AAEzB,mCAAmC;AAInC,0BAA2B;AAE3B,sEAAsE;AACtE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC;AAE5C,SAAsB,gBAAgB,CAAC,WAAmB,EAAE,OAAgB;;QACxE,MAAM,SAAS,CAAC,WAAW,EAAE,IAAA,SAAK,EAAC,OAAO,CAAC,EAAE,OAAO,CAAC,CAAC;IAC1D,CAAC;CAAA;AAFD,4CAEC;AAED,SAAsB,uBAAuB,CAAC,WAAmB;;QAC7D,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE;YAC7B,OAAO,EAAE,CAAC;SACb;QACD,IAAI;YACA,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;YAElD,MAAM,OAAO,GAAG,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;gBAC1C,MAAM,MAAM,GAAU,EAAE,CAAC;gBACzB,KAAK,CAAC,IAAI,EAAE;oBACR,IAAI,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;wBACrB,IAAI,OAAO,CAAC,KAAK,KAAK,CAAC,EAAE;4BACrB,OAAO,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;yBAC9B;wBACD,OAAO,KAAK,CAAC;oBACjB,CAAC;iBACJ,CAAC;qBACG,EAAE,CAAC,UAAU,EAAE;oBACZ,IAAI,MAAM,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;oBACzB,OAAO,MAAM,EAAE;wBACX,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;wBACpB,MAAM,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;qBACxB;gBACL,CAAC,CAAC;qBACD,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE;oBACZ,OAAO,CAAC,MAAM,CAAC,CAAC;gBACpB,CAAC,CAAC,CAAC;YACX,CAAC,CAAC,CAAC;YACH,OAAO,OAAkB,CAAC;SAC7B;QAAC,OAAO,GAAG,EAAE;YACV,IAAI,GAAG,YAAY,KAAK,EAAE;gBACtB,uCAAuC;gBACvC,OAAO,CAAC,GAAG,CAAC,yBAAyB,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;aACvD;YACD,OAAO,EAAE,CAAC;SACb;IACL,CAAC;CAAA;AApCD,0DAoCC"}

package/examples/make_model.ts

@@ -0,0 +1,152 @@
+// tslint:disable:no-console
+import * as fs from "fs";
+import { promisify } from "util";
+import {
+    AddressSpace,
+    DataType,
+    displayNodeElement,
+    nodesets,
+    promoteToMandatory,
+    setNamespaceMetaData,
+    Symbols,
+    UAObject,
+    UAVariable,
+    UAVariableT
+} from "..";
+
+import { getPresetSymbolsFromCSV, saveSymbolsToCSV, buildModel } from "../nodeJS";
+import { generateAddressSpace } from "node-opcua-address-space/nodeJS";
+
+import { createBoilerType } from "node-opcua-address-space/testHelpers";
+
+// node 14 onward : import { writeFile } from "fs/promises";
+const { writeFile } = fs.promises;
+
+interface UABoilerTest extends UAObject {
+    deviceHealth: UAVariable;
+    manufacturer: UAVariableT<string, DataType.String>;
+}
+
+const xmlFiles = [nodesets.standard, nodesets.di];
+
+const namespaceUri = "http://acme.com/Boiler/V0";
+const version = "1.0.0";
+
+const nodesetFilename = "./MyModel.NodeSet2.xml";
+const symbolFilename = "./MyModelIds.csv";
+
+async function createModel(addressSpace: AddressSpace): Promise<void> {
+    const ns = addressSpace.getOwnNamespace();
+
+    const nsDI = addressSpace.getNamespaceIndex("http://opcfoundation.org/UA/DI/");
+    if (nsDI < 0) {
+        throw new Error("Cannot find DI namespace!");
+    }
+
+    const deviceSet = addressSpace.rootFolder.objects.getFolderElementByName(`DeviceSet`);
+    if (!deviceSet) {
+        throw new Error("Cannot find DeviceSet object!");
+    }
+
+    const deviceType = addressSpace.findObjectType("DeviceType", nsDI);
+    if (!deviceType) {
+        throw new Error("Cannot find DeviceType");
+    }
+
+    // construct namespace meta data
+    const metaData = setNamespaceMetaData(addressSpace.getOwnNamespace());
+
+    const boilerDeviceType = ns.addObjectType({
+        browseName: "BoilerDeviceType",
+        subtypeOf: deviceType
+    });
+
+    promoteToMandatory(boilerDeviceType, "Manufacturer", nsDI);
+    promoteToMandatory(boilerDeviceType, "DeviceHealth", nsDI);
+    const parameterSet = promoteToMandatory(boilerDeviceType, "ParameterSet", nsDI);
+
+    ns.addVariable({
+        browseName: "HumiditySetpoint",
+        componentOf: parameterSet,
+        dataType: "Double"
+    });
+
+    ns.addVariable({
+        browseName: "TemperatureSetpoint",
+        componentOf: parameterSet,
+        dataType: "Double"
+    });
+
+    createBoilerType(ns);
+
+    console.log(displayNodeElement(boilerDeviceType));
+}
+
+async function buildModelFile() {
+    try {
+        const presetSymbols = await getPresetSymbolsFromCSV(symbolFilename);
+
+        const { xmlModel, symbols } = await buildModel({
+            createModel,
+            namespaceUri,
+            version,
+            xmlFiles,
+            // tslint:disable-next-line: object-literal-sort-keys
+            presetSymbols
+        });
+        // save model to a file
+        await writeFile(nodesetFilename, xmlModel, "utf-8");
+
+        await saveSymbolsToCSV(symbolFilename, symbols);
+    } catch (err) {
+        console.log("Error", err);
+    }
+}
+
+async function testNamespace() {
+    const addressSpace = AddressSpace.create();
+    const xmlFiles1 = [nodesets.standard, nodesets.di, nodesetFilename];
+    await generateAddressSpace(addressSpace, xmlFiles1);
+
+    const nsDI = addressSpace.getNamespaceIndex("http://opcfoundation.org/UA/DI/");
+    if (nsDI < 0) {
+        throw new Error("Cannot find DI namespace!");
+    }
+
+    const deviceSet = addressSpace.rootFolder.objects.getFolderElementByName(`DeviceSet`);
+    if (!deviceSet) {
+        throw new Error("Cannot find DeviceSet object!");
+    }
+
+    const nsLRA = addressSpace.getNamespaceIndex("http://acme.com/Boiler/V0");
+    const boilerDeviceType = addressSpace.findObjectType("BoilerDeviceType", nsLRA);
+    if (!boilerDeviceType) {
+        throw new Error("cannot find boiler type");
+    }
+
+    const boiler = boilerDeviceType.instantiate({
+        browseName: "Boiler1",
+        organizedBy: deviceSet
+    }) as UABoilerTest;
+
+    boiler.deviceHealth.writeEnumValue("MAINTENANCE_REQUIRED");
+    boiler.manufacturer.setValueFromSource({ dataType: DataType.LocalizedText, value: { text: "STERFIVE" } });
+
+    console.log(displayNodeElement(boiler));
+
+    addressSpace.dispose();
+}
+
+(async () => {
+    try {
+        await buildModelFile();
+        // now test the nodeset
+        await testNamespace();
+    } catch (err) {
+        if (err instanceof Error) {
+            console.log("err", err.message);
+        }
+        console.log(err);
+    }
+    console.log("done");
+})();

package/nodeJS.d.ts

@@ -0,0 +1 @@
+export * from "./distNodeJS";

package/nodeJS.js

@@ -0,0 +1 @@
+module.exports = require("./distNodeJS");

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "node-opcua-modeler",
+  "version": "2.51.0",
+  "description": "pure nodejs OPCUA SDK - module - model",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "node -e \"require('rimraf').sync('dist');\"",
+    "test": "mocha"
+  },
+  "author": "Etienne Rossignon",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "4.1.2",
+    "cli-table3": "^0.6.0",
+    "csv-parse": "4.16.3",
+    "node-opcua-address-space": "2.51.0",
+    "node-opcua-assert": "2.51.0",
+    "node-opcua-basic-types": "2.51.0",
+    "node-opcua-client-dynamic-extension-object": "2.51.0",
+    "node-opcua-constants": "2.51.0",
+    "node-opcua-data-model": "2.51.0",
+    "node-opcua-factory": "2.51.0",
+    "node-opcua-nodeid": "2.51.0",
+    "node-opcua-nodesets": "2.51.0",
+    "node-opcua-numeric-range": "2.51.0",
+    "node-opcua-schemas": "2.51.0",
+    "node-opcua-service-translate-browse-path": "2.51.0",
+    "node-opcua-status-code": "2.51.0",
+    "node-opcua-types": "2.51.0",
+    "node-opcua-variant": "2.51.0",
+    "node-opcua-xml2json": "2.51.0"
+  },
+  "devDependencies": {
+    "node-opcua-leak-detector": "2.51.0",
+    "should": "^13.2.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/node-opcua/node-opcua.git"
+  },
+  "keywords": [
+    "OPCUA",
+    "opcua",
+    "m2m",
+    "iot",
+    "opc ua",
+    "internet of things"
+  ],
+  "homepage": "http://node-opcua.github.io/",
+  "gitHead": "75feb111daf7ec65fa0111e4fa5beb8987fd4945"
+}

package/readme.md

@@ -0,0 +1,43 @@
+## Node-OPCUA Modeler
+
+Node-opcua-modeler provides a programatic way to conveniently create OPCUA model and nodeset files.
+
+```typescript
+import {
+    AddressSpace,
+    buildModel,
+    nodesets
+} from "node-opcua-modeler";
+import * as fs from "fs";
+
+// the namespaceUri
+const namespaceUri = "http://acme.com/Boiler/V0";
+const version= "1.0.0";
+
+// the nodeset file required by your model
+const xmlFiles: string[] = [
+    nodesets.standard,
+    nodesets.di
+];
+    
+async function createModel(addressSpace: AddressSpace): Promise<void> {
+    // create your model here !
+}
+
+(async () => {
+    try {
+        const { markdown, xmlModel, symbols } = await buildModel({
+            namespaceUri,
+            version,
+            xmlFiles,
+            createModel
+        });
+        // save model to a file
+        const nodesetFiename = "./MyModel.NodeSet2.xml";
+        await fs.promises.writeFile(nodesetFiename, xmlModel, "utf-8");
+
+    } catch (err) {
+        console.log("Error", err);
+    }
+})();
+```

package/source/addExtensionObjectDataType.ts

@@ -0,0 +1,241 @@
+import {
+    Namespace,
+    PseudoSession,
+    UADataType,
+    UAObject,
+    UAVariable,
+    UAVariableT,
+    UAVariableType,
+    dumpToBSD,
+    UADataTypeDictionary,
+    DTDataTypeDefinition,
+    UAProperty
+} from "node-opcua-address-space";
+import assert from "node-opcua-assert";
+import { convertDataTypeDefinitionToStructureTypeSchema, ExtraDataTypeManager } from "node-opcua-client-dynamic-extension-object";
+import { coerceQualifiedName, LocalizedTextLike, NodeClass, QualifiedNameLike } from "node-opcua-data-model";
+import { ConstructorFuncWithSchema } from "node-opcua-factory";
+import { NodeId, resolveNodeId } from "node-opcua-nodeid";
+import { createDynamicObjectConstructor } from "node-opcua-schemas";
+import { StructureDefinition, StructureDefinitionOptions } from "node-opcua-types";
+import { DataType, Variant } from "node-opcua-variant";
+
+/**
+ * create the deprecated DataTypeDictionary node that was
+ * used up to version 1.03
+ */
+export function getOrCreateDataTypeSystem(namespace: Namespace): UAObject {
+    const addressSpace = namespace.addressSpace;
+
+    const opcBinaryTypeSystem = addressSpace.findNode("OPCBinarySchema_TypeSystem") as UAObject;
+    /* istanbul ignore next */
+    if (!opcBinaryTypeSystem) {
+        throw new Error("Cannot find OPCBinarySchema_TypeSystem");
+    }
+    assert(opcBinaryTypeSystem.nodeId.toString() === "ns=0;i=93");
+    assert(opcBinaryTypeSystem.browseName.toString() === "OPC Binary");
+
+    return opcBinaryTypeSystem;
+}
+
+export function getDataTypeDictionary(namespace: Namespace): UADataTypeDictionary<Buffer> {
+    const addressSpace = namespace.addressSpace;
+
+    const opcBinaryTypeSystem = getOrCreateDataTypeSystem(namespace);
+    assert(opcBinaryTypeSystem.nodeId.toString() === "ns=0;i=93");
+
+    const name = namespace.namespaceUri.replace(/.*:/, "");
+
+    const node: UAVariable = opcBinaryTypeSystem.getComponentByName(name) as UAVariable;
+    if (node) {
+        assert(node.nodeClass === NodeClass.Variable);
+        // already exits ....
+        return node as UADataTypeDictionary<Buffer>;
+    }
+
+    const dataTypeDictionaryType = addressSpace.findVariableType("DataTypeDictionaryType");
+    /* istanbul ignore next */
+    if (!dataTypeDictionaryType) {
+        throw new Error("Cannot find DataTypeDictionaryType");
+    }
+    const dataTypeDictionary = dataTypeDictionaryType.instantiate({
+        browseName: name!,
+        description: `Collects the data type descriptions of ${namespace.namespaceUri}`,
+
+        componentOf: opcBinaryTypeSystem,
+
+        optionals: ["Deprecated", "DataTypeVersion", "NamespaceUri"]
+    }) as UADataTypeDictionary<Buffer>;
+
+    dataTypeDictionary.bindVariable({
+        get: () => {
+            const bsd = dumpToBSD(namespace);
+            return new Variant({
+                dataType: DataType.ByteString,
+                value: Buffer.from(bsd, "utf-8")
+            });
+        }
+    });
+
+    const namespaceUriProp = dataTypeDictionary.getPropertyByName("NamespaceUri");
+    if (namespaceUriProp) {
+        namespaceUriProp.setValueFromSource({ dataType: DataType.String, value: namespace.namespaceUri });
+    }
+    const deprecatedProp = dataTypeDictionary.getPropertyByName("Deprecated");
+    if (deprecatedProp) {
+        deprecatedProp.setValueFromSource({ dataType: DataType.Boolean, value: true });
+    }
+    return dataTypeDictionary;
+}
+
+export function addDataTypeDescription(namespace: Namespace, dataType: UADataType) {
+    const addressSpace = namespace.addressSpace;
+
+    const dataTypeDictionary = getDataTypeDictionary(namespace);
+
+    const dataTypeDescriptionType = addressSpace.findVariableType("DataTypeDescriptionType");
+    if (!dataTypeDescriptionType) {
+        throw new Error("Cannot find DataTypeDescriptionType");
+    }
+
+    const dataTypeDescription = dataTypeDescriptionType.instantiate({
+        browseName: dataType.browseName.name!,
+        componentOf: dataTypeDictionary
+    });
+    dataTypeDescription.setValueFromSource({
+        dataType: DataType.String,
+        value: dataType.browseName.name!
+    });
+
+    return dataTypeDescription;
+}
+export interface ExtensionObjectDefinition {
+    browseName: QualifiedNameLike;
+    description: LocalizedTextLike;
+    isAbstract: boolean;
+
+    structureDefinition: StructureDefinitionOptions;
+    binaryEncoding?: NodeId;
+    xmlEncoding?: NodeId;
+    jsonEncoding?: NodeId;
+
+    subtypeOf?: UADataType;
+}
+
+export async function addExtensionObjectDataType(namespace: Namespace, options: ExtensionObjectDefinition): Promise<UADataType> {
+    const addressSpace = namespace.addressSpace;
+
+    // encodings
+    const dataTypeEncodingType = addressSpace.findObjectType("DataTypeEncodingType");
+    /* istanbul ignore next */
+    if (!dataTypeEncodingType) {
+        throw new Error("Cannot find DataTypeEncodingType");
+    }
+
+    /* istanbul ignore next */
+    if (!options.browseName.toString().match(/DataType$/)) {
+        throw new Error("DataType name must end up with DataType ! " + options.browseName.toString());
+    }
+
+    const baseSuperType = "Structure";
+    const subtypeOf = addressSpace.findDataType(options.subtypeOf ? options.subtypeOf : baseSuperType)!;
+
+    const structureDefinition = options.structureDefinition;
+    structureDefinition.baseDataType = structureDefinition.baseDataType
+        ? resolveNodeId(structureDefinition.baseDataType)
+        : resolveNodeId("Structure");
+
+    const dataType = namespace.createDataType({
+        browseName: options.browseName,
+        description: options.description,
+        isAbstract: options.isAbstract,
+        subtypeOf
+    });
+
+    const defaultBinary = dataTypeEncodingType.instantiate({
+        browseName: coerceQualifiedName("0:Default Binary"),
+        encodingOf: dataType
+        // nodeId: defaultBinaryEncodingNode,
+    })!;
+    assert(defaultBinary.browseName.toString() === "Default Binary");
+
+    (dataType as any).$definition = new StructureDefinition(structureDefinition);
+    assert(!NodeId.sameNodeId((dataType as any).$definition.baseDataType, NodeId.nullNodeId));
+
+    const dataTypeDescription = addDataTypeDescription(namespace, dataType);
+    defaultBinary.addReference({
+        isForward: true,
+        nodeId: dataTypeDescription,
+        referenceType: "HasDescription"
+    });
+    const v = dataType.getEncodingNode("Default Binary")!;
+    assert(v?.browseName.toString() === "Default Binary");
+
+    /// --------------- Create constructor
+    const dataTypeManager = (addressSpace as any).$$extraDataTypeManager as ExtraDataTypeManager;
+    const dataTypeFactory = dataTypeManager.getDataTypeFactory(namespace.index);
+    const session = new PseudoSession(addressSpace);
+
+    const className = dataType.browseName.name!;
+    const cache: any = {};
+    const schema = await convertDataTypeDefinitionToStructureTypeSchema(
+        session,
+        dataType.nodeId,
+        className,
+        (dataType as any).$definition,
+        dataTypeFactory,
+        cache
+    );
+    const Constructor = createDynamicObjectConstructor(schema, dataTypeFactory) as ConstructorFuncWithSchema;
+
+    return dataType;
+}
+
+export function addVariableTypeForDataType(namespace: Namespace, dataType: UADataType): UAVariableType {
+    const addressSpace = namespace.addressSpace;
+
+    // get Definition
+    const definition = (dataType as any).$definition as StructureDefinition;
+    if (!definition || !(definition instanceof StructureDefinition)) {
+        throw new Error("dataType is not a structure");
+    }
+
+    const variableTypeName = dataType.browseName.name?.replace("DataType", "Type")!;
+    const variableType = namespace.addVariableType({
+        browseName: variableTypeName,
+        dataType: dataType.nodeId
+    });
+
+    const structure = addressSpace.findDataType("Structure")!;
+    for (const field of definition.fields || []) {
+        let typeDefinition: UAVariableType | string = "BaseVariableType";
+        const fType = addressSpace.findDataType(field.dataType);
+        /* istanbul ignore next */
+        if (!fType) {
+            throw new Error("Cannot find dataType" + field.dataType.toString());
+        }
+        if (fType.isSupertypeOf(structure)) {
+            const name = fType.browseName.name!.replace("DataType", "Type");
+            typeDefinition = addressSpace.findVariableType(name, field.dataType.namespace)!;
+            const comp = typeDefinition.instantiate({
+                browseName: field.name!,
+                componentOf: variableType,
+                dataType: field.dataType,
+                description: field.description,
+                modellingRule: "Mandatory",
+                valueRank: field.valueRank === undefined ? -1 : field.valueRank
+            });
+        } else {
+            const comp = namespace.addVariable({
+                browseName: field.name!,
+                componentOf: variableType,
+                dataType: field.dataType,
+                description: field.description,
+                modellingRule: "Mandatory",
+                typeDefinition,
+                valueRank: field.valueRank === undefined ? -1 : field.valueRank
+            });
+        }
+    }
+    return variableType;
+}

package/source/build_model_inner.ts

@@ -0,0 +1,45 @@
+import { 
+    AddressSpace, 
+    Namespace, NodeIdManager, XmlLoaderFunc, generateAddressSpaceRaw } from "node-opcua-address-space";
+import { buildDocumentationToString } from "./generate_markdown_doc";
+import { Symbols } from "./symbol";
+
+export interface BuildModelOptionsBase {
+    version: string;
+    namespaceUri: string;
+    xmlFiles: string[];
+    createModel: /*async*/ (addressSpace: AddressSpace) => Promise<void>;
+    presetSymbols?: Symbols;
+}
+export interface BuildModelOptions extends BuildModelOptionsBase {
+    xmlLoader: XmlLoaderFunc;
+}
+
+export async function buildModelInner(data: BuildModelOptions): Promise<{ markdown: string; xmlModel: string; symbols: Symbols }> {
+    try {
+        const addressSpace = AddressSpace.create();
+
+        // create own namespace (before loading other xml files)
+        const ns = addressSpace.registerNamespace(data.namespaceUri);
+
+        const nodeIdManager = (ns as any)._nodeIdManager as NodeIdManager;
+        if (data.presetSymbols) {
+            nodeIdManager.setSymbols(data.presetSymbols);
+        }
+
+        await generateAddressSpaceRaw(addressSpace, data.xmlFiles, data.xmlLoader);
+
+        await data.createModel(addressSpace);
+
+        const xmlModel = ns.toNodeset2XML();
+        const symbols = nodeIdManager.getSymbols();
+        const doc = await buildDocumentationToString(ns);
+        addressSpace.dispose();
+
+        return { xmlModel, symbols, markdown: doc };
+    } catch (err) {
+        // tslint:disable-next-line: no-console
+        console.log("Error", err);
+        throw err;
+    }
+}