node-opcua-convert-nodeset-to-javascript 2.51.0

package/dist/convert_to_typescript.js

@@ -0,0 +1,879 @@
+"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.convertTypeToTypescript = exports._convertTypeToTypescript = exports._exportDataTypeToTypescript = exports.findUsedImport = exports.extractClassMemberDef = exports.checkIfShouldExposeInnerDefinition = exports.findClassMember = exports.extractClassDefinition = exports.makeTypeName2 = exports.convertDataTypeToTypescript = void 0;
+const wrap = require("wordwrap");
+const node_opcua_data_model_1 = require("node-opcua-data-model");
+const node_opcua_types_1 = require("node-opcua-types");
+const node_opcua_utils_1 = require("node-opcua-utils");
+const node_opcua_variant_1 = require("node-opcua-variant");
+const node_opcua_assert_1 = require("node-opcua-assert");
+const chalk = require("chalk");
+const utils_1 = require("./private/utils");
+const cache_1 = require("./private/cache");
+const to_filename_1 = require("./private/to_filename");
+const wrapText = wrap(0, 50);
+const f2 = (str) => str.padEnd(50, "-");
+const f1 = (str) => str.padEnd(50, " ");
+const baseExtension = "_Base";
+function convertDataTypeToTypescript(session, dataTypeId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const definition = yield (0, utils_1.getDefinition)(session, dataTypeId);
+        const browseName = yield (0, utils_1.getBrowseName)(session, dataTypeId);
+        const dataTypeTypescriptName = `UA${browseName.name.toString()}`;
+        const f = new node_opcua_utils_1.LineFile();
+        if (definition && definition instanceof node_opcua_types_1.StructureDefinition) {
+            f.write(`interface ${dataTypeTypescriptName} {`);
+            for (const field of definition.fields || []) {
+                /** */
+            }
+            f.write(`}`);
+        }
+    });
+}
+exports.convertDataTypeToTypescript = convertDataTypeToTypescript;
+// to avoid clashes
+function toJavascritPropertyName(childName) {
+    childName = (0, node_opcua_utils_1.lowerFirstLetter)(childName);
+    if (childName === "namespaceUri") {
+        childName = "$namespaceUri";
+    }
+    if (childName === "rolePermissions") {
+        childName = "$rolePermissions";
+    }
+    if (childName === "displayName") {
+        childName = "$displayName";
+    }
+    if (childName === "eventNotifier") {
+        childName = "$eventNotifier";
+    }
+    return childName.replace(/</g, "$").replace(/>/g, "$").replace(/ |\./g, "_").replace(/#/g, "_");
+}
+function quotifyIfNecessary(s) {
+    if (s.match(/(^[^a-zA-Z])|([^a-zA-Z_0-9])/)) {
+        return `"${s}"`;
+    }
+    if (s === "nodeClass") {
+        return `["$nodeClass"]`;
+    }
+    return s;
+}
+function getCorrepondingJavascriptType2(session, nodeId, dataTypeNodeId, cache, importCollect) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const q = yield getCorrepondingJavascriptType(session, dataTypeNodeId, cache, importCollect);
+        const valueRank = yield (0, utils_1.getValueRank)(session, nodeId);
+        return { dataType: q.dataType, jtype: q.jtype + (valueRank >= 1 ? "[]" : "") };
+    });
+}
+// eslint-disable-next-line complexity
+function getCorrepondingJavascriptType(session, dataTypeNodeId, cache, importCollect) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const dataType = yield (0, utils_1.convertNodeIdToDataTypeAsync)(session, dataTypeNodeId);
+        const referenceBasicType = (name) => {
+            const t = { name, namespace: -1, module: "BasicType" };
+            importCollect && importCollect(t);
+            cache.ensureImported(t);
+            return t.name;
+        };
+        if (dataType === node_opcua_variant_1.DataType.ExtensionObject) {
+            const jtypeImport = yield (0, cache_1.referenceExtensionObject)(session, dataTypeNodeId);
+            const jtype = jtypeImport.name;
+            importCollect && importCollect(jtypeImport);
+            return { dataType, jtype: jtype };
+        }
+        switch (dataType) {
+            case node_opcua_variant_1.DataType.Null:
+                return { dataType, jtype: "undefined" };
+            case node_opcua_variant_1.DataType.Boolean:
+                return { dataType, jtype: "boolean" };
+            case node_opcua_variant_1.DataType.Byte:
+                return { dataType, jtype: referenceBasicType("Byte") };
+            case node_opcua_variant_1.DataType.ByteString:
+                return { dataType, jtype: "Buffer" };
+            case node_opcua_variant_1.DataType.DataValue:
+                return { dataType, jtype: referenceBasicType("DataValue") };
+            case node_opcua_variant_1.DataType.DateTime:
+                return { dataType, jtype: "Date" };
+            case node_opcua_variant_1.DataType.DiagnosticInfo:
+                return { dataType, jtype: referenceBasicType("DiagnosticInfo") };
+            case node_opcua_variant_1.DataType.Double:
+                return { dataType, jtype: "number" };
+            case node_opcua_variant_1.DataType.Float:
+                return { dataType, jtype: "number" };
+            case node_opcua_variant_1.DataType.Guid:
+                return { dataType, jtype: referenceBasicType("Guid") };
+            case node_opcua_variant_1.DataType.Int16:
+                return { dataType, jtype: referenceBasicType("Int16") };
+            case node_opcua_variant_1.DataType.Int32:
+                return { dataType, jtype: referenceBasicType("Int32") };
+            case node_opcua_variant_1.DataType.UInt16:
+                return { dataType, jtype: referenceBasicType("UInt16") };
+            case node_opcua_variant_1.DataType.UInt32:
+                return { dataType, jtype: referenceBasicType("UInt32") };
+            case node_opcua_variant_1.DataType.UInt64:
+                return { dataType, jtype: referenceBasicType("UInt64") };
+            case node_opcua_variant_1.DataType.Int64:
+                return { dataType, jtype: referenceBasicType("Int64") };
+            case node_opcua_variant_1.DataType.LocalizedText:
+                return { dataType, jtype: referenceBasicType("LocalizedText") };
+            case node_opcua_variant_1.DataType.NodeId:
+                return { dataType, jtype: referenceBasicType("NodeId") };
+            case node_opcua_variant_1.DataType.ExpandedNodeId:
+                return { dataType, jtype: referenceBasicType("ExpandedNodeId") };
+            case node_opcua_variant_1.DataType.QualifiedName:
+                return { dataType, jtype: referenceBasicType("QualifiedName") };
+            case node_opcua_variant_1.DataType.SByte:
+                return { dataType, jtype: referenceBasicType("SByte") };
+            case node_opcua_variant_1.DataType.StatusCode:
+                return { dataType, jtype: referenceBasicType("StatusCode") };
+            case node_opcua_variant_1.DataType.String:
+                return { dataType, jtype: referenceBasicType("UAString") };
+            case node_opcua_variant_1.DataType.Variant:
+                return { dataType, jtype: referenceBasicType("Variant") };
+            case node_opcua_variant_1.DataType.XmlElement:
+                return { dataType, jtype: referenceBasicType("UAString") };
+            default:
+                throw new Error("Unsupported " + dataType + " " + node_opcua_variant_1.DataType[dataType]);
+        }
+    });
+}
+function makeTypeName2(nodeClass, browseName, suffix) {
+    (0, node_opcua_assert_1.default)(browseName);
+    if (nodeClass === node_opcua_data_model_1.NodeClass.Method) {
+        return { name: "UAMethod", namespace: 0, module: "UAMethod" };
+    }
+    return (0, cache_1.makeTypeNameNew)(nodeClass, null, browseName, suffix);
+}
+exports.makeTypeName2 = makeTypeName2;
+function extractClassDefinition(session, nodeId, cache) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const extraImports = [];
+        const _c = cache.classDefCache || {};
+        cache.classDefCache = _c;
+        let classDef = _c[nodeId.toString()];
+        if (classDef) {
+            return classDef;
+        }
+        const nodeClass = yield (0, utils_1.getNodeClass)(session, nodeId);
+        if (nodeClass !== node_opcua_data_model_1.NodeClass.VariableType && nodeClass !== node_opcua_data_model_1.NodeClass.ObjectType) {
+            throw new Error("Invalid nodeClass " + node_opcua_data_model_1.NodeClass[nodeClass] + " nodeId " + nodeId.toString());
+        }
+        const browseName = yield (0, utils_1.getBrowseName)(session, nodeId);
+        const isAbstract = yield (0, utils_1.getIsAbstract)(session, nodeId);
+        const superType = (yield (0, utils_1.getSubtypeNodeIdIfAny)(session, nodeId)) || undefined;
+        const dataTypeNodeId = yield (0, utils_1.getDataTypeNodeId)(session, nodeId);
+        let dataTypeName = "";
+        let dataType = node_opcua_variant_1.DataType.Null;
+        let dataTypeImport = undefined;
+        if (nodeClass === node_opcua_data_model_1.NodeClass.VariableType) {
+            dataType = yield (0, utils_1.extractBasicDataType)(session, dataTypeNodeId);
+            const importCollector = (i) => {
+                extraImports.push(i);
+                cache.ensureImported(i);
+            };
+            const { jtype } = yield getCorrepondingJavascriptType2(session, nodeId, dataTypeNodeId, cache, importCollector);
+            dataTypeName = jtype; // with decoration
+            if (!(dataTypeNodeId === null || dataTypeNodeId === void 0 ? void 0 : dataTypeNodeId.isEmpty())) {
+                // "DT" + (await getBrowseName(session, dataTypeNodeId!))?.name! || "";
+                // const bn = await getBrowseName(session, dataTypeNodeId!);
+                dataTypeImport = extraImports; // makeTypeName2(NodeClass.DataType, bn);
+            }
+        }
+        const baseClassDef = !superType ? null : yield extractClassDefinition(session, superType.nodeId, cache);
+        const description = yield (0, utils_1.getDescription)(session, nodeId);
+        // const definition = await getDefinition(session, nodeId);
+        const interfaceName = makeTypeName2(nodeClass, browseName);
+        const baseInterfaceName = !superType ? null : makeTypeName2(nodeClass, superType.browseName);
+        // extract member
+        const children = yield (0, utils_1.getChildrenOrFolderElements)(session, nodeId);
+        const members = [];
+        classDef = {
+            nodeClass,
+            browseName,
+            isAbstract,
+            dataType,
+            dataTypeNodeId,
+            dataTypeName,
+            dataTypeImport,
+            superType,
+            baseClassDef,
+            description,
+            // definition,
+            children,
+            members,
+            interfaceName,
+            baseInterfaceName
+        };
+        _c[nodeId.toString()] = classDef;
+        for (const child of children) {
+            const c = yield extractClassMemberDef(session, child.nodeId, classDef, cache);
+            classDef.members.push(c);
+        }
+        return classDef;
+    });
+}
+exports.extractClassDefinition = extractClassDefinition;
+function classify(session, refs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const r = {
+            Mandatory: [],
+            Optional: [],
+            MandatoryPlaceholder: [],
+            OptionalPlaceholder: [],
+            ExposesItsArray: []
+        };
+        for (const mm of refs) {
+            const modellingRule = yield (0, utils_1.getModellingRule)(session, mm.nodeId);
+            if (modellingRule) {
+                r[modellingRule] = r[modellingRule] || [];
+                r[modellingRule].push(mm);
+            }
+        }
+        return r;
+    });
+}
+function extractAllMembers(session, classDef, cache) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const m = [...classDef.children];
+        let s = classDef;
+        while (s.baseClassDef) {
+            s = s.baseClassDef;
+            // start from top most class
+            // do not overwrite most top member definition, so we get mandatory stuff
+            for (const mm of s.children) {
+                const found = m.findIndex((r) => r.browseName.toString() === mm.browseName.toString());
+                if (found < 0) {
+                    m.push(mm);
+                }
+            }
+        }
+        // now separate mandatory and optionals
+        const members = yield classify(session, m);
+        return members;
+    });
+}
+function findClassMember(session, browseName, baseParentDef, cache) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const str = browseName.toString();
+        const r = baseParentDef.children.find((a) => a.browseName.toString() === str);
+        if (r) {
+            const d = yield extractClassMemberDef(session, r.nodeId, baseParentDef, cache);
+            return d;
+        }
+        const baseBaseParentDef = baseParentDef.superType && (yield extractClassDefinition(session, baseParentDef.superType.nodeId, cache));
+        if (!baseBaseParentDef) {
+            return null;
+        }
+        return yield findClassMember(session, browseName, baseBaseParentDef, cache);
+    });
+}
+exports.findClassMember = findClassMember;
+function hasNewMaterial(referenceMembers, instanceMembers) {
+    const ref = referenceMembers.map((x) => x.browseName.toString()).sort();
+    const instance = instanceMembers.map((x) => x.browseName.toString()).sort();
+    for (const n of instance) {
+        if (ref.findIndex((x) => x === n) < 0) {
+            return true;
+        }
+    }
+    return false;
+}
+// we should expose an inner definition if
+//  - at least one mandatory in instnace doesn't exist in main.Mandatory
+//  - at least one optional in instnace doesn't exist in main.Mandatory
+function checkIfShouldExposeInnerDefinition(main, instance) {
+    const hasNewStuff = hasNewMaterial(main.Mandatory, instance.Mandatory) || hasNewMaterial(main.Optional, instance.Optional);
+    return hasNewStuff;
+}
+exports.checkIfShouldExposeInnerDefinition = checkIfShouldExposeInnerDefinition;
+function dump1(a) {
+    console.log("Mandatory = ", a.Mandatory.map((x) => x.browseName.toString())
+        .sort()
+        .join(" "));
+    console.log("Optional  = ", a.Optional.map((x) => x.browseName.toString())
+        .sort()
+        .join(" "));
+}
+function _extractLocalMembers(session, classMember, cache) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const children2 = [];
+        for (const child of classMember.children) {
+            const nodeId = child.nodeId;
+            const browseName = yield (0, utils_1.getBrowseName)(session, nodeId);
+            const name = toJavascritPropertyName(browseName.name);
+            if (name === "cartesianCoordinates") {
+                //    debugger;
+            }
+            const description = yield (0, utils_1.getDescription)(session, nodeId);
+            const modellingRule = yield (0, utils_1.getModellingRule)(session, nodeId);
+            const isOptional = modellingRule === "Optional";
+            const typeDefinition = yield (0, utils_1.getTypeDefOrBaseType)(session, nodeId);
+            const childInBase = (_a = classMember.classDef) === null || _a === void 0 ? void 0 : _a.members.find((a) => a.browseName.toString() === browseName.toString());
+            let childType;
+            if (childInBase) {
+                childType = childInBase.childType;
+            }
+            else {
+                const d = typeDefinition.nodeId.isEmpty() ? null : yield extractClassDefinition(session, typeDefinition.nodeId, cache);
+                childType = (d === null || d === void 0 ? void 0 : d.interfaceName) || { name: "UAMethod", module: "BasicType", namespace: -1 };
+            }
+            // may be childType is already
+            const { suffix, suffixInstantiate, typeToReference, chevrons } = yield extractVariableExtra(session, child.nodeId, cache, classMember);
+            const c = {
+                childType,
+                description,
+                isOptional,
+                modellingRule,
+                name,
+                suffix,
+                suffixInstantiate,
+                typeToReference,
+                chevrons
+            };
+            children2.push(c);
+        }
+        return children2;
+    });
+}
+function isUnspecifiedDataType(dataType) {
+    return dataType === node_opcua_variant_1.DataType.Null || dataType === node_opcua_variant_1.DataType.Variant;
+}
+function extractVariableExtra(session, nodeId, cache, classMember) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const typeToReference = [];
+        const importCollector = (i) => {
+            typeToReference.push(i);
+            cache.ensureImported(i);
+        };
+        const nodeClass = yield (0, utils_1.getNodeClass)(session, nodeId);
+        if (nodeClass === node_opcua_data_model_1.NodeClass.Variable) {
+            const dataTypeNodeId = yield (0, utils_1.getDataTypeNodeId)(session, nodeId);
+            const { dataType, jtype } = yield getCorrepondingJavascriptType2(session, nodeId, dataTypeNodeId, cache, importCollector);
+            cache && cache.referenceBasicType("DataType");
+            importCollector({ name: "DataType", namespace: -1, module: "BasicType" });
+            const t = isUnspecifiedDataType((_a = classMember.classDef) === null || _a === void 0 ? void 0 : _a.dataType);
+            const suffix = jtype === "undefined" || isUnspecifiedDataType(dataType)
+                ? `<any, any>`
+                : `<${jtype}${t ? `, /*c*/DataType.${node_opcua_variant_1.DataType[dataType]}` : ""}>`;
+            // const suffix2 = `<T${t ? `, /*a*/DT extends DataType` : ""}>`;
+            const suffix3 = `<T${t ? `, /*b*/DT` : ""}>`;
+            const typeDef = yield (0, utils_1.getTypeDefOrBaseType)(session, nodeId);
+            const typeDefCD = yield extractClassDefinition(session, typeDef.nodeId, cache);
+            const chevrons = calculateChevrons(typeDefCD, { dataType });
+            const suffix2 = chevrons.chevronsDef;
+            /** Suffix for instantiation
+             *  if typeDef.dataType is not null, then we need to add a type argument
+             */
+            let suffixInstantiate = "";
+            if (isUnspecifiedDataType(dataType)) {
+                if (!isUnspecifiedDataType(typeDefCD.dataType)) {
+                    suffixInstantiate = "<any>";
+                }
+                else {
+                    suffixInstantiate = "<any, any>";
+                }
+            }
+            else {
+                if (!isUnspecifiedDataType(typeDefCD.dataType)) {
+                    suffixInstantiate = `<${jtype}>`;
+                }
+                else {
+                    suffixInstantiate = `<${jtype}, /*z*/DataType.${node_opcua_variant_1.DataType[dataType]}>`;
+                }
+            }
+            return { suffixInstantiate, suffix, suffix2, suffix3, dataTypeNodeId, dataType, jtype, typeToReference, chevrons };
+        }
+        return { suffix: "", typeToReference };
+    });
+}
+// eslint-disable-next-line max-statements
+function extractClassMemberDef(session, nodeId, parentDef, cache) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const nodeClass = yield (0, utils_1.getNodeClass)(session, nodeId);
+        const browseName = yield (0, utils_1.getBrowseName)(session, nodeId);
+        const name = toJavascritPropertyName(browseName.name);
+        if (nodeClass !== node_opcua_data_model_1.NodeClass.Method && nodeClass !== node_opcua_data_model_1.NodeClass.Object && nodeClass !== node_opcua_data_model_1.NodeClass.Variable) {
+            throw new Error("Invalid property " + node_opcua_data_model_1.NodeClass[nodeClass] + " " + (browseName === null || browseName === void 0 ? void 0 : browseName.toString()) + " " + nodeId.toString());
+        }
+        const description = yield (0, utils_1.getDescription)(session, nodeId);
+        const children = yield (0, utils_1.getChildrenOrFolderElements)(session, nodeId);
+        const modellingRule = yield (0, utils_1.getModellingRule)(session, nodeId);
+        const isOptional = modellingRule === "Optional";
+        const typeDefinition = yield (0, utils_1.getTypeDefOrBaseType)(session, nodeId);
+        if (!typeDefinition.browseName) {
+            console.log("cannot find typeDefinition for ", browseName.toString(), "( is the namespace loaded ?)");
+        }
+        let childType = makeTypeName2(nodeClass, typeDefinition.browseName);
+        const classDef = typeDefinition.nodeId.isEmpty() ? null : yield extractClassDefinition(session, typeDefinition.nodeId, cache);
+        let innerClass = null;
+        let childBase = null;
+        let shouldExposeInnerDefinition = false;
+        // find member exposed by type definition
+        const baseParentDef = parentDef.superType && (yield extractClassDefinition(session, parentDef.superType.nodeId, cache));
+        if (classDef && baseParentDef) {
+            const chevrons1 = calculateChevrons(classDef, baseParentDef);
+            (0, node_opcua_assert_1.default)(!innerClass);
+            // let's extract the member that are theorically defined in the member
+            const membersReference = yield extractAllMembers(session, classDef, cache);
+            // find member exposed by this member
+            const membersInstance = yield classify(session, children);
+            // if (name==="powerup") {
+            //     dump1(membersReference);
+            //     dump1(membersInstance);
+            //     await extractAllMembers(session, classDef, cache);
+            // }
+            shouldExposeInnerDefinition = checkIfShouldExposeInnerDefinition(membersReference, membersInstance);
+            const sameMemberInBaseClass = baseParentDef && (yield findClassMember(session, browseName, baseParentDef, cache));
+            if (shouldExposeInnerDefinition) {
+                if (sameMemberInBaseClass) {
+                    innerClass = {
+                        module: parentDef.interfaceName.module,
+                        name: parentDef.interfaceName.name + "_" + name,
+                        namespace: nodeId.namespace
+                    };
+                    childBase = sameMemberInBaseClass.childType;
+                    childType = innerClass;
+                }
+                else {
+                    innerClass = {
+                        module: parentDef.interfaceName.module,
+                        name: parentDef.interfaceName.name + "_" + name,
+                        namespace: nodeId.namespace
+                    };
+                    childBase = childType;
+                    childType = innerClass;
+                }
+                (0, node_opcua_assert_1.default)(innerClass);
+                (0, node_opcua_assert_1.default)(childBase);
+            }
+            else {
+                // may not expose definition  but we may want to used the augment typescript class defined in the definition
+                // we don't need to create an inner class ...
+                childType = sameMemberInBaseClass ? sameMemberInBaseClass === null || sameMemberInBaseClass === void 0 ? void 0 : sameMemberInBaseClass.childType : childType;
+                (0, node_opcua_assert_1.default)(!innerClass);
+                (0, node_opcua_assert_1.default)(!childBase);
+            }
+        }
+        else {
+            // the lass member has no HasTypeDefinition reference
+            // may be is a method
+            (0, node_opcua_assert_1.default)(!innerClass);
+            (0, node_opcua_assert_1.default)(!childBase);
+        }
+        let classMember = {
+            name,
+            nodeClass,
+            browseName,
+            modellingRule,
+            isOptional,
+            classDef,
+            description,
+            typeDefinition,
+            childType,
+            suffix2: "",
+            suffix: "",
+            suffix3: "",
+            suffixInstantiate: "",
+            children,
+            children2: [],
+            typeToReference: [],
+            //
+            innerClass,
+            childBase,
+            chevrons: null
+        };
+        classMember.children2 = yield _extractLocalMembers(session, classMember, cache);
+        if (nodeClass === node_opcua_data_model_1.NodeClass.Variable) {
+            const extra = yield extractVariableExtra(session, nodeId, cache, classMember);
+            classMember = Object.assign(Object.assign({}, classMember), extra);
+        }
+        return classMember;
+    });
+}
+exports.extractClassMemberDef = extractClassMemberDef;
+function preDumpChildren(session, padding, classDef, f, cache) {
+    return __awaiter(this, void 0, void 0, function* () {
+        f = f || new node_opcua_utils_1.LineFile();
+        for (const memberDef of classDef.members) {
+            const { innerClass, suffix2, suffix3, nodeClass, childBase, chevrons } = memberDef;
+            if (!innerClass || !childBase) {
+                continue; // no need to expose inner class
+            }
+            cache.ensureImported(childBase);
+            if (innerClass.name === "UAPubSubDiagnostics_counters" || innerClass.name === "UAProgramStateMachine_currentState") {
+                //      debugger;
+            }
+            const baseStuff = getBaseClassWithOmit2(memberDef);
+            //f.write(`export interface ${innerClass.name}${suffix2} extends ${childBase.name}${suffix3} { // ${NodeClass[nodeClass]}`);
+            f.write(`export interface ${innerClass.name}${suffix2} extends ${baseStuff} { // ${node_opcua_data_model_1.NodeClass[nodeClass]}`);
+            yield dumpChildren(session, padding + "  ", memberDef.children2, f, cache);
+            f.write("}");
+        }
+    });
+}
+function dumpChildren(session, padding, children, f, cache) {
+    f = f || new node_opcua_utils_1.LineFile();
+    for (const def of children) {
+        const { suffixInstantiate, name, childType, modellingRule, isOptional, description } = def;
+        def.typeToReference.forEach((t) => cache.ensureImported(t));
+        if (modellingRule === "MandatoryPlaceholder" || modellingRule === "OptionalPlaceholder")
+            continue;
+        cache.ensureImported(childType);
+        const adjustedName = toJavascritPropertyName(name);
+        if (description.text) {
+            f.write(`${padding}/**`);
+            f.write(`${padding} * ${name || ""}`);
+            f.write(toComment(`${padding} * `, description.text || ""));
+            f.write(`${padding} */`);
+        }
+        f.write(`${padding}${quotifyIfNecessary(adjustedName)}${isOptional ? "?" : ""}: ${childType.name}${suffixInstantiate || ""};`);
+    }
+}
+// now from other namespace
+const getSubSymbolList = (s) => {
+    const subSymbolList = [];
+    for (const [subSymbol, count] of Object.entries(s.subSymbols)) {
+        subSymbolList.push(subSymbol);
+    }
+    return subSymbolList;
+};
+function findUsedImport(namespaceIndex, cache) {
+    const usedImport = [];
+    // from standard types
+    for (const imp of Object.keys(cache.imports)) {
+        const symbolToImport = Object.keys(cache.imports[imp]).filter((f) => Object.prototype.hasOwnProperty.call(cache.requestedBasicTypes, f));
+        if (symbolToImport.length == 0) {
+            continue;
+        }
+        usedImport.push(imp);
+    }
+    // from namespace
+    for (let ns = 0; ns < cache.requestedSymbols.namespace.length; ns++) {
+        if (ns === namespaceIndex) {
+            continue; // avoid self reference
+        }
+        const module = cache.namespace[ns].module;
+        if (cache.requestedSymbols.namespace[ns] && Object.values(cache.requestedSymbols.namespace[ns]).length > 0) {
+            usedImport.push(module);
+        }
+    }
+    return usedImport;
+}
+exports.findUsedImport = findUsedImport;
+function dumpUsedExport(currentType, namespaceIndex, cache, f) {
+    f = f || new node_opcua_utils_1.LineFile();
+    for (const imp of Object.keys(cache.imports)) {
+        const symbolToImport = Object.keys(cache.imports[imp]).filter((f) => f !== currentType && Object.prototype.hasOwnProperty.call(cache.requestedBasicTypes, f));
+        if (symbolToImport.length == 0) {
+            continue;
+        }
+        f.write(`import { ${symbolToImport.join(", ")} } from "${imp}"`);
+    }
+    for (let ns = 0; ns < cache.requestedSymbols.namespace.length; ns++) {
+        const n = cache.namespace[ns];
+        const sourceFolder = n.sourceFolder;
+        const module = n.module;
+        if (ns === namespaceIndex) {
+            // include individuals stuff
+            for (const [symbol, s] of Object.entries(cache.requestedSymbols.namespace[ns].symbols).filter((a) => a[0] !== currentType)) {
+                const filename = (0, to_filename_1.toFilename)(symbol);
+                const subSymbolList = getSubSymbolList(s);
+                f.write(`import { ${subSymbolList.join(", ")} } from "./${filename}"`);
+            }
+        }
+        else {
+            if (cache.requestedSymbols.namespace[ns]) {
+                for (const [symbol, s] of Object.entries(cache.requestedSymbols.namespace[ns].symbols)) {
+                    const subSymbolList = getSubSymbolList(s);
+                    const filename = (0, to_filename_1.toFilename)(symbol);
+                    f.write(`import { ${subSymbolList.join(", ")} } from "${module}/source/${filename}"`);
+                }
+            }
+        }
+    }
+    return f.toString();
+}
+function toComment(prefix, description) {
+    const d = wrapText(description);
+    return d
+        .split("\n")
+        .map((x) => prefix + x)
+        .join("\n");
+}
+// eslint-disable-next-line max-statements
+function _exportDataTypeToTypescript(session, nodeId, cache, f) {
+    return __awaiter(this, void 0, void 0, function* () {
+        f = f || new node_opcua_utils_1.LineFile();
+        const importCollector = (i) => {
+            cache.ensureImported(i);
+        };
+        const nodeClass = node_opcua_data_model_1.NodeClass.DataType;
+        const description = yield (0, utils_1.getDescription)(session, nodeId);
+        const definition = yield (0, utils_1.getDefinition)(session, nodeId);
+        const browseName = yield (0, utils_1.getBrowseName)(session, nodeId);
+        const isAbstract = yield (0, utils_1.getIsAbstract)(session, nodeId);
+        const interfaceImport = (0, cache_1.makeTypeNameNew)(nodeClass, definition, browseName);
+        const interfaceName = interfaceImport.name;
+        const superType = yield (0, utils_1.getSubtypeNodeId)(session, nodeId);
+        const baseInterfaceImport = (0, cache_1.makeTypeNameNew)(nodeClass, definition, superType.browseName);
+        cache.ensureImported(baseInterfaceImport);
+        const baseInterfaceName = baseInterfaceImport.name;
+        //  f.write(superType.toString());
+        f.write(`/**`);
+        if (description.text) {
+            f.write(toComment(" * ", description.text || ""));
+            f.write(` *`);
+        }
+        f.write(` * |           |${f1(" ")}|`);
+        f.write(` * |-----------|${f2("-")}|`);
+        f.write(` * | namespace |${f1(cache.namespace[nodeId.namespace].namespaceUri)}|`);
+        f.write(` * | nodeClass |${f1(node_opcua_data_model_1.NodeClass[nodeClass])}|`);
+        f.write(` * | name      |${f1(browseName.toString())}|`);
+        f.write(` * | isAbstract|${f1(isAbstract.toString())}|`);
+        f.write(` */`);
+        let type = "basic";
+        if (definition instanceof node_opcua_types_1.EnumDefinition) {
+            type = "enum";
+            f.write(`export enum ${interfaceName}  {`);
+            for (const field of definition.fields) {
+                if (field.description.text) {
+                    f.write(`  /**`);
+                    f.write(toComment("   * ", field.description.text || ""));
+                    f.write(`   */`);
+                }
+                f.write(`  ${quotifyIfNecessary(field.name)} = ${field.value[1]},`);
+            }
+            f.write(`}`);
+        }
+        else if (definition instanceof node_opcua_types_1.StructureDefinition) {
+            type = "structure";
+            if (interfaceName === "DTStructure") {
+                f.write(`export interface ${interfaceName} {`);
+            }
+            else {
+                f.write(`export interface ${interfaceName} extends ${baseInterfaceName}  {`);
+            }
+            for (const field of definition.fields) {
+                const fieldName = toJavascritPropertyName(field.name);
+                // special case ! fieldName=
+                if (field.description.text) {
+                    f.write(`/** ${field.description.text}*/`);
+                }
+                let ar = "";
+                if (field.valueRank >= 1) {
+                    ar = "[]";
+                }
+                const { dataType, jtype } = yield getCorrepondingJavascriptType(session, field.dataType, cache, importCollector);
+                f.write(`  ${quotifyIfNecessary(fieldName)}: ${jtype}${ar}; // ${node_opcua_variant_1.DataType[dataType]} ${field.dataType.toString()}`);
+            }
+            f.write(`}`);
+        }
+        else {
+            type = "basic";
+            f.write(`// NO DEFINITION`);
+            f.write(`export interface ${interfaceName} extends ${baseInterfaceName}  {`);
+            f.write(`}`);
+            // throw new Error("Invalid " + definition?.constructor.name);
+        }
+        return { type, content: f.toString(), typeName: interfaceName };
+    });
+}
+exports._exportDataTypeToTypescript = _exportDataTypeToTypescript;
+function calculateChevrons(classDef, classDefDerived) {
+    const { nodeClass, dataType, dataTypeName } = classDef;
+    let chevronsDef = "";
+    let chevronsUse = "";
+    let chevronsExtend = "";
+    if (nodeClass !== node_opcua_data_model_1.NodeClass.VariableType) {
+        return { chevronsDef, chevronsUse, chevronsExtend };
+    }
+    if (!isUnspecifiedDataType(dataType)) {
+        chevronsDef = `<T extends ${dataTypeName}/*j*/>`;
+        chevronsUse = "<T/*k*/>";
+        if (classDefDerived) {
+            if (isUnspecifiedDataType(classDefDerived.dataType)) {
+                chevronsExtend = `<T, /*i*/DataType.${node_opcua_variant_1.DataType[dataType]}>`;
+            }
+            else {
+                chevronsExtend = `<T/*h*/>`;
+            }
+        }
+    }
+    else {
+        // classDef.dataType === DataType.Null
+        chevronsDef = `<T, DT extends DataType>`;
+        if (classDefDerived) {
+            if (isUnspecifiedDataType(classDefDerived.dataType)) {
+                chevronsUse = "<T, /*m*/DT>";
+                chevronsExtend = `<T/*g*/, DT>`;
+            }
+            else {
+                chevronsUse = `<T, /*n*/DataType.${node_opcua_variant_1.DataType[classDefDerived.dataType]}>`;
+                chevronsExtend = `<T, /*e*/DataType.${node_opcua_variant_1.DataType[classDefDerived.dataType]}>`;
+            }
+        }
+    }
+    return { chevronsDef, chevronsUse, chevronsExtend };
+}
+// find the structure member that are already in base structure definition and that are replicated here
+// we will have to use the Omit<Base,"member1" |"member2"> typescript pattern to avoid issues
+function extractMembersRecursively(classDef) {
+    if (!classDef) {
+        return [];
+    }
+    const m = classDef.members.map((m) => m.name);
+    if (classDef.baseClassDef) {
+        const m2 = extractMembersRecursively(classDef.baseClassDef);
+        return m.concat(m2);
+    }
+    return m;
+}
+function getBaseClassWithOmit(classDef) {
+    const { baseInterfaceName, members } = classDef;
+    const allMembers = extractMembersRecursively(classDef.baseClassDef);
+    const conflictingMembers = members.filter((m) => allMembers.indexOf(m.name) !== -1);
+    //console.log(allMembers.join(" "));
+    if (conflictingMembers.length) {
+        //  console.log("conflictingMembers = ", conflictingMembers.map((a) => a.name).join(" "));
+    }
+    const chBase = calculateChevrons(classDef.baseClassDef, classDef);
+    let baseStuff = `${baseInterfaceName === null || baseInterfaceName === void 0 ? void 0 : baseInterfaceName.name}${chBase.chevronsUse}`;
+    if (conflictingMembers.length) {
+        baseStuff = `Omit<${baseStuff}, ${conflictingMembers.map((a) => `"${a.name}"`).join("|")}>`;
+    }
+    return baseStuff;
+}
+function getBaseClassWithOmit2(classMember) {
+    const members = classMember.children2;
+    const allMembers = extractMembersRecursively(classMember.classDef);
+    const conflictingMembers = members.filter((m) => allMembers.indexOf(m.name) !== -1);
+    //console.log(allMembers.join(" "));
+    if (conflictingMembers.length) {
+        console.log("conflictingMembers = ", conflictingMembers.map((a) => a.name).join(" "));
+    }
+    const childBase = classMember.childBase;
+    let baseStuff = `${childBase === null || childBase === void 0 ? void 0 : childBase.name}${classMember.suffix3}`;
+    if (conflictingMembers.length) {
+        baseStuff = `Omit<${baseStuff}, ${conflictingMembers.map((a) => `"${a.name}"`).join("|")}>`;
+    }
+    return baseStuff;
+}
+/**
+ *  nodeId : a DataType, ReferenceType,AObjectType, VariableType node
+ */
+// eslint-disable-next-line max-statements
+function _convertTypeToTypescript(session, nodeId, cache, f) {
+    return __awaiter(this, void 0, void 0, function* () {
+        f = f || new node_opcua_utils_1.LineFile();
+        const nodeClass = yield (0, utils_1.getNodeClass)(session, nodeId);
+        if (nodeClass === node_opcua_data_model_1.NodeClass.DataType) {
+            return yield _exportDataTypeToTypescript(session, nodeId, cache, f);
+        }
+        const classDef = yield extractClassDefinition(session, nodeId, cache);
+        // if (classDef.browseName.toString().match(/PubSubDiagnosticsWriterGroupType/)) {
+        //     debugger;
+        // }
+        const { dataTypeName, dataType, dataTypeNodeId, interfaceName, baseInterfaceName, browseName, description, isAbstract, members } = classDef;
+        yield preDumpChildren(session, "    ", classDef, f, cache);
+        //  f.write(superType.toString());
+        f.write(`/**`);
+        if (description.text) {
+            f.write(toComment(" * ", description.text || ""));
+            f.write(` *`);
+        }
+        f.write(` * |                |${f1(" ")}|`);
+        f.write(` * |----------------|${f2("-")}|`);
+        f.write(` * |namespace       |${f1(cache.namespace[nodeId.namespace].namespaceUri)}|`);
+        f.write(` * |nodeClass       |${f1(node_opcua_data_model_1.NodeClass[nodeClass])}|`);
+        f.write(` * |typedDefinition |${f1(browseName.toString() + " " + nodeId.toString())}|`);
+        if (nodeClass === node_opcua_data_model_1.NodeClass.VariableType) {
+            f.write(` * |dataType        |${f1(node_opcua_variant_1.DataType[dataType])}|`);
+            f.write(` * |dataType Name   |${f1(dataTypeName + " " + (dataTypeNodeId === null || dataTypeNodeId === void 0 ? void 0 : dataTypeNodeId.toString()))}|`);
+        }
+        f.write(` * |isAbstract      |${f1(isAbstract.toString())}|`);
+        f.write(` */`);
+        // if (interfaceName.name === "UAOperationLimits") {
+        //     debugger;
+        // }
+        cache.ensureImported(baseInterfaceName);
+        cache.ensureImported(Object.assign(Object.assign({}, baseInterfaceName), { name: baseInterfaceName.name + `${baseExtension}` }));
+        const ch = calculateChevrons(classDef);
+        if (nodeClass === node_opcua_data_model_1.NodeClass.VariableType) {
+            if (classDef.dataTypeImport) {
+                console.log(chalk.red(" ----------------> ", classDef.browseName));
+                classDef.dataTypeImport.forEach((a) => {
+                    console.log(chalk.red(" ------------------------> ", a.module, a.name, a.namespace));
+                });
+                classDef.dataTypeImport.forEach(cache.ensureImported.bind(cache));
+            }
+            cache.referenceBasicType("DataType");
+            const chevrons = calculateChevrons(classDef);
+            const chevronsBase = calculateChevrons(classDef.baseClassDef, classDef);
+            //  Shall we  cache.ensureImported({ ...baseInterfaceName!, module: dataTypeName, name: dataTypeName });
+            const classBaseName = `${interfaceName.name}${baseExtension}${chevrons.chevronsDef}`;
+            if ((baseInterfaceName === null || baseInterfaceName === void 0 ? void 0 : baseInterfaceName.name) === "UAVariableT") {
+                f.write(`export interface ${classBaseName}  {`);
+            }
+            else {
+                const baseName = `${baseInterfaceName === null || baseInterfaceName === void 0 ? void 0 : baseInterfaceName.name}${baseExtension}${chevronsBase.chevronsExtend}`;
+                f.write(`export interface ${classBaseName}  extends ${baseName} {`);
+            }
+        }
+        else {
+            const classBaseName = `${interfaceName.name}${baseExtension}`;
+            if ((baseInterfaceName === null || baseInterfaceName === void 0 ? void 0 : baseInterfaceName.name) === "UAObject") {
+                f.write(`export interface ${classBaseName} {`);
+            }
+            else {
+                const baseName = `${baseInterfaceName === null || baseInterfaceName === void 0 ? void 0 : baseInterfaceName.name}${baseExtension}`;
+                f.write(`export interface ${classBaseName} extends ${baseName} {`);
+            }
+        }
+        yield dumpChildren(session, "    ", members, f, cache);
+        f.write(`}`);
+        const baseStuff = getBaseClassWithOmit(classDef);
+        if (nodeClass === node_opcua_data_model_1.NodeClass.VariableType) {
+            cache.referenceBasicType("DataType");
+            // if dataType is a extension object we can simpligy by forcing DT
+            const className = `${interfaceName.name}${ch.chevronsDef}`;
+            const c = isUnspecifiedDataType(dataType) ? "<T, DT /*A*/>" : "<T /*B*/>";
+            const classBaseName = `${interfaceName.name}${baseExtension}${c}`;
+            f.write(`export interface ${className} extends ${baseStuff}, ${classBaseName} {`);
+        }
+        else {
+            const className = `${interfaceName.name}`;
+            const classBaseName = `${interfaceName.name}${baseExtension}`;
+            f.write(`export interface ${className} extends ${baseStuff}, ${classBaseName} {`);
+        }
+        f.write(`}`);
+        return { type: "ua", content: f.toString(), typeName: interfaceName.name };
+    });
+}
+exports._convertTypeToTypescript = _convertTypeToTypescript;
+function convertTypeToTypescript(session, nodeId, options, cache, f) {
+    return __awaiter(this, void 0, void 0, function* () {
+        f = new node_opcua_utils_1.LineFile();
+        cache = cache || (yield (0, cache_1.constructCache)(session, options));
+        const { type, content, typeName } = yield _convertTypeToTypescript(session, nodeId, cache);
+        f.write(`// ----- this file has been automatically generated - do not edit`);
+        f.write(dumpUsedExport(typeName, nodeId.namespace, cache));
+        f.write(content);
+        const folder = cache.namespace[nodeId.namespace].sourceFolder;
+        const module = cache.namespace[nodeId.namespace].module;
+        const filename = (0, to_filename_1.toFilename)(typeName);
+        const dependencies = findUsedImport(nodeId.namespace, cache);
+        return { type, content: f.toString(), folder, module, filename, dependencies };
+    });
+}
+exports.convertTypeToTypescript = convertTypeToTypescript;
+//# sourceMappingURL=convert_to_typescript.js.map