node-opcua-convert-nodeset-to-javascript 2.178.0 → 2.179.0

package/source/convert_to_typescript.ts

@@ -1,44 +1,34 @@
-/* eslint-disable max-depth */
 import chalk from "chalk";
-import { LocalizedText, NodeClass, QualifiedName } from "node-opcua-data-model";
-import { NodeId, resolveNodeId } from "node-opcua-nodeid";
-import { IBasicSessionBrowseAsyncSimple, IBasicSessionReadAsyncSimple } from "node-opcua-pseudo-session";
-import {
-    ReferenceDescription,
-    StructureDefinition,
-    _enumerationDataChangeTrigger
-} from "node-opcua-types";
+import type { ModellingRuleType } from "node-opcua-address-space-base";
+import assert from "node-opcua-assert";
+import { type LocalizedText, NodeClass, type QualifiedName } from "node-opcua-data-model";
+import { make_debugLog, make_warningLog } from "node-opcua-debug";
+import type { NodeId } from "node-opcua-nodeid";
+import type { IBasicSessionBrowseAsyncSimple, IBasicSessionReadAsyncSimple } from "node-opcua-pseudo-session";
+import { type ReferenceDescription, StructureDefinition } from "node-opcua-types";
 import { LineFile } from "node-opcua-utils";
 import { DataType } from "node-opcua-variant";
-import assert from "node-opcua-assert";
-import { ModellingRuleType } from "node-opcua-address-space-base";
-import { make_warningLog, make_debugLog } from "node-opcua-debug";
+import { _exportDataTypeToTypescript } from "./_dataType";
+import type { Options } from "./options";
+import { type Cache, constructCache, type Import, makeTypeNameNew, type RequestedSubSymbol } from "./private/cache";
+import { getCorrespondingJavascriptType2 } from "./private/get_corresponding_data_type";
+import { toFilename } from "./private/to_filename";
 import {
+    extractBasicDataType,
     getBrowseName,
-    getIsAbstract,
+    getChildrenOrFolderElements,
+    getDataTypeNodeId,
     getDefinition,
     getDescription,
+    getIsAbstract,
     getModellingRule,
     getNodeClass,
     getSubtypeNodeIdIfAny,
     getTypeDefOrBaseType,
-    getChildrenOrFolderElements,
-    getDataTypeNodeId,
-    extractBasicDataType,
-    getValueRank} from "./private/utils";
-
-import {
-    Cache,
-    constructCache,
-    Import,
-    makeTypeNameNew,
-    RequestedSubSymbol
-} from "./private/cache";
-import { Options } from "./options";
-import { toFilename } from "./private/to_filename";
+    getValueRank
+} from "./private/utils";
 import { f1, f2, quotifyIfNecessary, toComment, toJavascritPropertyName } from "./utils2";
-import { _exportDataTypeToTypescript } from "./_dataType";
-import { getCorrespondingJavascriptType2 } from "./private/get_corresponding_data_type";
+
 const warningLog = make_warningLog("typescript");
 const debugLog = make_debugLog("typescript");
 const doDebug = false;
@@ -46,7 +36,7 @@ const baseExtension = "_Base";
 
 const m0 = !doDebug ? "" : `/* 0 */`;
 const m1 = !doDebug ? "" : `/* 1 */`;
-const m2 = !doDebug ? "" : `/* 2 */`;
+const _m2 = !doDebug ? "" : `/* 2 */`;
 const m3 = !doDebug ? "" : `/* 3 */`;
 const m4 = !doDebug ? "" : `/* 4 */`;
 const m5 = !doDebug ? "" : `/* 5 */`;
@@ -61,16 +51,15 @@ const mD = !doDebug ? "" : `/* d */`;
 const mE = !doDebug ? "" : `/* e */`;
 const mF = !doDebug ? "" : `/* f */`;
 
-
 export async function convertDataTypeToTypescript(session: IBasicSessionReadAsyncSimple, dataTypeId: NodeId): Promise<void> {
     const definition = await getDefinition(session, dataTypeId);
     const browseName = await getBrowseName(session, dataTypeId);
 
-    const dataTypeTypescriptName = `UA${browseName.name!.toString()}`;
+    const dataTypeTypescriptName = `UA${browseName.name?.toString()}`;
     const f = new LineFile();
     if (definition && definition instanceof StructureDefinition) {
         f.write(`interface ${dataTypeTypescriptName} {`);
-        for (const field of definition.fields || []) {
+        for (const _field of definition.fields || []) {
             /** */
         }
         f.write(`}`);
@@ -114,8 +103,12 @@ export async function extractClassDefinition(
     cache: Cache
 ): Promise<ClassDefinition> {
     const extraImports: Import[] = [];
-    const _c = (cache as any).classDefCache || {};
-    (cache as any).classDefCache = _c;
+    interface CacheWithClassDefCache {
+        classDefCache?: Record<string, ClassDefinition>;
+    }
+    const cacheWithClassDefCache = cache as unknown as CacheWithClassDefCache;
+    const _c = cacheWithClassDefCache.classDefCache || {};
+    cacheWithClassDefCache.classDefCache = _c;
 
     let classDef: ClassDefinition | null = _c[nodeId.toString()];
     if (classDef) {
@@ -123,7 +116,7 @@ export async function extractClassDefinition(
     }
     const nodeClass = await getNodeClass(session, nodeId);
     if (nodeClass !== NodeClass.VariableType && nodeClass !== NodeClass.ObjectType) {
-        throw new Error("Invalid nodeClass " + NodeClass[nodeClass] + " nodeId " + nodeId.toString());
+        throw new Error(`Invalid nodeClass ${NodeClass[nodeClass]} nodeId ${nodeId.toString()}`);
     }
 
     const browseName = await getBrowseName(session, nodeId);
@@ -133,20 +126,23 @@ export async function extractClassDefinition(
     const dataTypeNodeId = await getDataTypeNodeId(session, nodeId);
     let dataTypeName = "";
     let dataType: DataType = DataType.Null;
-    let dataTypeImport: Import[] | undefined = undefined;
-    let valueRank: number| undefined;
-    let dataTypeCombination: string| undefined;;
+    let dataTypeImport: Import[] | undefined;
+    let valueRank: number | undefined;
+    let dataTypeCombination: string | undefined;
     if (nodeClass === NodeClass.VariableType) {
-        dataType = await extractBasicDataType(session, dataTypeNodeId!);
+        if (!dataTypeNodeId) {
+            throw new Error(`VariableType ${nodeId.toString()} is expected to have a DataType attribute`);
+        }
+        dataType = await extractBasicDataType(session, dataTypeNodeId);
         const importCollector = (i: Import) => {
             extraImports.push(i);
             cache.ensureImported(i);
         };
-        const info = await getCorrespondingJavascriptType2(session, nodeId, dataTypeNodeId!, cache, importCollector);
+        const info = await getCorrespondingJavascriptType2(session, nodeId, dataTypeNodeId, cache, importCollector);
         const jtype = info.jtype;
         dataTypeCombination = info.dataTypeCombination;
         dataTypeName = jtype; // with decoration
-        if (!dataTypeNodeId?.isEmpty()) {
+        if (!dataTypeNodeId.isEmpty()) {
             // "DT" + (await getBrowseName(session, dataTypeNodeId!))?.name! || "";
             // const bn = await getBrowseName(session, dataTypeNodeId!);
             dataTypeImport = extraImports; // makeTypeName2(NodeClass.DataType, bn);
@@ -191,7 +187,6 @@ export async function extractClassDefinition(
         baseInterfaceName,
         valueRank,
         dataTypeCombination
-
     };
     _c[nodeId.toString()] = classDef;
 
@@ -210,7 +205,7 @@ interface ClassMemberBasic {
     description: LocalizedText;
     suffix?: string;
     suffixInstantiate?: string;
-    chevrons: any;
+    chevrons: ChevronsInfo | null | undefined;
     typeToReference: Import[];
 }
 
@@ -303,7 +298,7 @@ async function classify(
 async function extractAllMembers(
     session: IBasicSessionReadAsyncSimple & IBasicSessionBrowseAsyncSimple,
     classDef: ClassDefinition,
-    cache: Cache
+    _cache: Cache
 ): Promise<ClassifiedReferenceDescriptions> {
     const m = [...classDef.children];
     let s = classDef;
@@ -331,11 +326,11 @@ export async function findClassMember(
     const childBrowseName = browseName.toString();
     const r = baseParentDef.children.find((a) => a.browseName.toString() === childBrowseName);
     if (r) {
-        const d = await extractClassMemberDef(session, r!.nodeId, baseParentDef, cache);
+        const d = await extractClassMemberDef(session, r?.nodeId, baseParentDef, cache);
         return d;
     }
     const baseBaseParentDef =
-        baseParentDef.superType && (await extractClassDefinition(session, baseParentDef.superType!.nodeId, cache));
+        baseParentDef.superType && (await extractClassDefinition(session, baseParentDef.superType?.nodeId, cache));
     if (!baseBaseParentDef) {
         return null;
     }
@@ -346,7 +341,7 @@ function hasNewMaterial(referenceMembers: ReferenceDescription[], instanceMember
     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) {
+        if (ref.indexOf(n) < 0) {
             return true;
         }
     }
@@ -364,7 +359,7 @@ export function checkIfShouldExposeInnerDefinition(
     return hasNewStuff;
 }
 
-function dump1(a: ClassifiedReferenceDescriptions): void {
+function _dump1(a: ClassifiedReferenceDescriptions): void {
     console.log(
         "Mandatory = ",
         a.Mandatory.map((x) => x.browseName.toString())
@@ -378,10 +373,10 @@ function dump1(a: ClassifiedReferenceDescriptions): void {
             .join(" ")
     );
 }
-dump1;
+_dump1;
 
 function getSameInBaseClass(parent: ClassDefinitionB | null, browseName: QualifiedName): ClassMember | null {
-    if (!parent || !parent.baseClassDef) return null;
+    if (!parent?.baseClassDef) return null;
     const originalClassMember = parent.baseClassDef.members.find((m) => m.browseName.toString() === browseName.toString());
     return originalClassMember || null;
 }
@@ -397,12 +392,14 @@ async function _extractLocalMembers(
     classMember: ClassMember,
     cache: Cache
 ): Promise<ClassMemberBasic[]> {
-
     const children2: ClassMemberBasic[] = [];
     for (const child of classMember.children) {
         const nodeId = child.nodeId;
         const browseName = await getBrowseName(session, nodeId);
-        const name = toJavascritPropertyName(browseName.name!, { ignoreConflictingName: true });
+        if (!browseName.name) {
+            throw new Error(`Expecting a browseName.name for node ${nodeId.toString()}`);
+        }
+        const name = toJavascritPropertyName(browseName.name, { ignoreConflictingName: true });
 
         const description = await getDescription(session, nodeId);
         const modellingRule = await getModellingRule(session, nodeId);
@@ -463,11 +460,20 @@ async function extractVariableExtra(
     const nodeClass = await getNodeClass(session, nodeId);
     if (nodeClass === NodeClass.Variable) {
         const dataTypeNodeId = await getDataTypeNodeId(session, nodeId);
-        const valueRank = await getValueRank(session, nodeId);
-        valueRank;
-        const { dataType, jtype, dataTypeCombination } = await getCorrespondingJavascriptType2(session, nodeId, dataTypeNodeId!, cache, importCollector);
+        if (!dataTypeNodeId) {
+            throw new Error(`Variable ${nodeId.toString()} is expected to have a DataType attribute`);
+        }
+        const _valueRank = await getValueRank(session, nodeId);
+        _valueRank;
+        const { dataType, jtype, dataTypeCombination } = await getCorrespondingJavascriptType2(
+            session,
+            nodeId,
+            dataTypeNodeId,
+            cache,
+            importCollector
+        );
 
-        cache && cache.referenceBasicType("DataType");
+        cache?.referenceBasicType("DataType");
         importCollector({ name: "DataType", namespace: -1, module: "BasicType" });
 
         const t = isUnspecifiedDataType(classMember.classDef?.dataType);
@@ -475,13 +481,13 @@ async function extractVariableExtra(
         const suffix =
             jtype === "undefined" || isUnspecifiedDataType(dataType)
                 ? `<any, any>`
-                : `<${jtype}${t ? `, ${m0}DataType.${DataType[dataType]}` :""}>`;
+                : `<${jtype}${t ? `, ${m0}DataType.${DataType[dataType]}` : ""}>`;
 
         // const suffix2 = `<T${t ? `, /DT extends DataType` : ""}>`;
         const suffix3 = `<T${t ? `, ${m1}DT` : ""}>`;
 
         const typeDef = await getTypeDefOrBaseType(session, nodeId);
-        const typeDefCD = await extractClassDefinition(session, typeDef.nodeId!, cache);
+        const typeDefCD = await extractClassDefinition(session, typeDef.nodeId, cache);
         const chevrons = calculateChevrons(typeDefCD, { dataType });
         const suffix2 = chevrons.chevronsDef;
 
@@ -497,22 +503,31 @@ async function extractVariableExtra(
             }
         } else {
             if (!isUnspecifiedDataType(typeDefCD.dataType)) {
-
-                if (jtype === "number" && (dataTypeNodeId!.value as number> 25)) {
-                    console.log("dataTypeNodeId", dataTypeNodeId?.toString()), dataTypeCombination;   
+                if (jtype === "number" && (dataTypeNodeId?.value as number) > 25) {
+                    console.log("dataTypeNodeId", dataTypeNodeId?.toString(), dataTypeCombination);
                 }
                 if (dataTypeCombination) {
                     suffixInstantiate = `<${jtype}${mD},${dataTypeCombination}>`;
                 } else {
                     suffixInstantiate = `<${jtype}${mE}>`;
-
                 }
             } else {
                 suffixInstantiate = `<${jtype}, DataType.${DataType[dataType]}${mF}>`;
             }
         }
 
-        return { suffixInstantiate, suffix, suffix2, suffix3, dataTypeNodeId, dataType, jtype, typeToReference, chevrons , dataTypeCombination};
+        return {
+            suffixInstantiate,
+            suffix,
+            suffix2,
+            suffix3,
+            dataTypeNodeId,
+            dataType,
+            jtype,
+            typeToReference,
+            chevrons,
+            dataTypeCombination
+        };
     }
     return { suffix: "", typeToReference };
 }
@@ -524,7 +539,6 @@ interface ClassDefinitionB {
     interfaceName: Import;
     baseClassDef?: ClassDefinition | null;
 }
-// eslint-disable-next-line max-statements
 export async function extractClassMemberDef(
     session: IBasicSessionReadAsyncSimple & IBasicSessionBrowseAsyncSimple,
     nodeId: NodeId,
@@ -534,10 +548,13 @@ export async function extractClassMemberDef(
     const nodeClass = await getNodeClass(session, nodeId);
     const browseName = await getBrowseName(session, nodeId);
 
-    const name = toJavascritPropertyName(browseName.name!, { ignoreConflictingName: true });
+    if (!browseName.name) {
+        throw new Error(`Expecting a browseName.name for node ${nodeId.toString()}`);
+    }
+    const name = toJavascritPropertyName(browseName.name, { ignoreConflictingName: true });
 
     if (nodeClass !== NodeClass.Method && nodeClass !== NodeClass.Object && nodeClass !== NodeClass.Variable) {
-        throw new Error("Invalid property " + NodeClass[nodeClass] + " " + browseName?.toString() + " " + nodeId.toString());
+        throw new Error(`Invalid property ${NodeClass[nodeClass]} ${browseName?.toString()} ${nodeId.toString()}`);
     }
 
     const description = await getDescription(session, nodeId);
@@ -548,7 +565,7 @@ export async function extractClassMemberDef(
 
     const typeDefinition = await getTypeDefOrBaseType(session, nodeId);
 
-    if (nodeClass !== NodeClass.Method && (!typeDefinition.browseName || !typeDefinition.browseName.name)) {
+    if (nodeClass !== NodeClass.Method && !typeDefinition.browseName?.name) {
         warningLog(typeDefinition.toString());
         warningLog("cannot find typeDefinition for ", browseName.toString(), "( is the namespace loaded ?)");
     }
@@ -561,9 +578,9 @@ export async function extractClassMemberDef(
 
     let shouldExposeInnerDefinition = false;
     // find member exposed by type definition
-    const baseParentDef = parentDef.superType && (await extractClassDefinition(session, parentDef.superType!.nodeId, cache));
+    const baseParentDef = parentDef.superType && (await extractClassDefinition(session, parentDef.superType?.nodeId, cache));
     if (classDef && baseParentDef) {
-        const chevrons1 = calculateChevrons(classDef, baseParentDef);
+        const _chevrons1 = calculateChevrons(classDef, baseParentDef);
         assert(!innerClass);
 
         // let's extract the member that are theorically defined in the member
@@ -585,7 +602,7 @@ export async function extractClassMemberDef(
             if (sameMemberInBaseClass) {
                 innerClass = {
                     module: parentDef.interfaceName.module,
-                    name: parentDef.interfaceName.name + "_" + name,
+                    name: `${parentDef.interfaceName.name}_${name}`,
                     namespace: nodeId.namespace
                 };
                 childBase = sameMemberInBaseClass.childType;
@@ -593,7 +610,7 @@ export async function extractClassMemberDef(
             } else {
                 innerClass = {
                     module: parentDef.interfaceName.module,
-                    name: parentDef.interfaceName.name + "_" + name,
+                    name: `${parentDef.interfaceName.name}_${name}`,
                     namespace: nodeId.namespace
                 };
                 childBase = childType;
@@ -647,22 +664,27 @@ export async function extractClassMemberDef(
             ...classMember,
             ...extra
         };
-        
+
         const baseParentDef2 = parentDef.superType && parentDef.baseClassDef;
         if (baseParentDef2) {
-            const sameMemberInBase = baseParentDef2.members.find(
-                (m) => m.browseName.toString() === browseName.toString()
-            );
-            if (sameMemberInBase && sameMemberInBase.childType.name === classMember.childType.name 
-                && sameMemberInBase.childType.name !== typeDefinition.browseName.name?.toString()) {
+            const sameMemberInBase = baseParentDef2.members.find((m) => m.browseName.toString() === browseName.toString());
+            if (
+                sameMemberInBase &&
+                sameMemberInBase.childType.name === classMember.childType.name &&
+                sameMemberInBase.childType.name !== typeDefinition.browseName.name?.toString()
+            ) {
                 // childType was inherited from base (e.g., UADiscreteItem instead of UATwoStateDiscrete)
                 // Recalculate suffix based on base class's classDef
                 if (sameMemberInBase.classDef && classMember.dataType !== undefined) {
-                    const baseTypeHasUnspecifiedDataType = 
-                        sameMemberInBase.classDef.dataType === DataType.Null || 
+                    const baseTypeHasUnspecifiedDataType =
+                        sameMemberInBase.classDef.dataType === DataType.Null ||
                         sameMemberInBase.classDef.dataType === DataType.Variant;
-                    
-                    if (baseTypeHasUnspecifiedDataType && classMember.dataType !== DataType.Null && classMember.dataType !== DataType.Variant) {
+
+                    if (
+                        baseTypeHasUnspecifiedDataType &&
+                        classMember.dataType !== DataType.Null &&
+                        classMember.dataType !== DataType.Variant
+                    ) {
                         // Base type is generic (2 params), current has specific dataType
                         // Generate: <specificType, DataType.SpecificType>
                         classMember.suffixInstantiate = `<${classMember.jtype}, DataType.${DataType[classMember.dataType]}>`;
@@ -691,7 +713,7 @@ async function preDumpChildren(padding: string, classDef: ClassDefinition, f: Li
 
         //f.write(`export interface ${innerClass.name}${suffix2} extends ${childBase.name}${suffix3} { // ${NodeClass[nodeClass]}`);
         f.write(`export interface ${innerClass.name}${suffix2} extends ${baseStuff} { // ${NodeClass[nodeClass]}`);
-        await dumpChildren(padding + "  ", memberDef.children2, f, cache);
+        await dumpChildren(`${padding}  `, memberDef.children2, f, cache);
         f.write("}");
     }
 }
@@ -709,7 +731,9 @@ function dumpChildren(padding: string, children: ClassMemberBasic[], f: LineFile
 
     for (const def of children) {
         const { suffixInstantiate, name, childType, isOptional, description } = def;
-        def.typeToReference.forEach((t) => cache.ensureImported(t));
+        def.typeToReference.forEach((t) => {
+            cache.ensureImported(t);
+        });
 
         if (isPlaceHolder(def)) {
             f.write("   // PlaceHolder for ", name);
@@ -740,10 +764,8 @@ export function findUsedImport(namespaceIndex: number, cache: Cache): string[] {
     const usedImport: string[] = [];
     // 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) {
+        const symbolToImport = Object.keys(cache.imports[imp]).filter((f) => Object.hasOwn(cache.requestedBasicTypes, f));
+        if (symbolToImport.length === 0) {
             continue;
         }
         usedImport.push(imp);
@@ -768,9 +790,9 @@ function dumpUsedExport(currentType: string, namespaceIndex: number, cache: Cach
 
     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)
+            (f) => f !== currentType && Object.hasOwn(cache.requestedBasicTypes, f)
         );
-        if (symbolToImport.length == 0) {
+        if (symbolToImport.length === 0) {
             continue;
         }
         f.write(`import { ${symbolToImport.join(", ")} } from "${imp}"`);
@@ -802,6 +824,8 @@ function dumpUsedExport(currentType: string, namespaceIndex: number, cache: Cach
 
 export type Type = "enum" | "basic" | "structure" | "ua";
 
+type ChevronsInfo = ReturnType<typeof calculateChevrons>;
+
 function calculateChevrons(classDef: ClassDefinition, classDefDerived?: { dataType: DataType }) {
     const { nodeClass, dataType, dataTypeName } = classDef;
     let chevronsDef = "";
@@ -853,13 +877,16 @@ function extractMembersRecursively(classDef?: ClassDefinition | null): string[]
 function getBaseClassWithOmit(classDef: ClassDefinition) {
     const { baseInterfaceName, members } = classDef;
 
+    if (!classDef.baseClassDef) {
+        throw new Error(`Expecting a baseClassDef for ${classDef.browseName.toString()}`);
+    }
     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);
+    const chBase = calculateChevrons(classDef.baseClassDef, classDef);
 
     let baseStuff = `${baseInterfaceName?.name}${chBase.chevronsUse}`;
     if (conflictingMembers.length) {
@@ -886,7 +913,6 @@ function getBaseClassWithOmit2(classMember: ClassMember) {
 /**
  *  nodeId : a DataType, ReferenceType,AObjectType, VariableType node
  */
-// eslint-disable-next-line max-statements
 export async function _convertTypeToTypescript(
     session: IBasicSessionReadAsyncSimple & IBasicSessionBrowseAsyncSimple,
     nodeId: NodeId,
@@ -929,13 +955,12 @@ export async function _convertTypeToTypescript(
     f.write(` * |----------------|${f2("-")}|`);
     f.write(` * |namespace       |${f1(cache.namespace[nodeId.namespace].namespaceUri)}|`);
     f.write(` * |nodeClass       |${f1(NodeClass[nodeClass])}|`);
-    f.write(` * |typedDefinition |${f1(browseName.name!.toString() + " " + n(nodeId))}|`);
+    f.write(` * |typedDefinition |${f1(`${browseName.name?.toString()} ${n(nodeId)}`)}|`);
     if (nodeClass === NodeClass.VariableType) {
         const { valueRank } = classDef;
         f.write(` * |dataType        |${f1(DataType[dataType])}|`);
-        f.write(` * |dataType Name   |${f1(dataTypeName + " " + n(dataTypeNodeId))}|`);
+        f.write(` * |dataType Name   |${f1(`${dataTypeName} ${n(dataTypeNodeId)}`)}|`);
         valueRank && f.write(` * |value rank      |${f1(valueRank.toString())}|`);
-
     }
     f.write(` * |isAbstract      |${f1(isAbstract.toString())}|`);
     f.write(` */`);
@@ -943,57 +968,60 @@ export async function _convertTypeToTypescript(
     // if (interfaceName.name === "UAOperationLimits") {
     //     debugger;
     // }
-    cache.ensureImported(baseInterfaceName!);
-    cache.ensureImported({ ...baseInterfaceName!, name: baseInterfaceName!.name + `${baseExtension}` });
+    if (!baseInterfaceName) {
+        throw new Error(`Expecting a baseInterfaceName for ${interfaceName.name}`);
+    }
+    cache.ensureImported(baseInterfaceName);
+    cache.ensureImported({ ...baseInterfaceName, name: `${baseInterfaceName.name}${baseExtension}` });
 
     const ch = calculateChevrons(classDef);
-
-    {
-        if (nodeClass === NodeClass.VariableType) {
-            if (classDef.dataTypeImport) {
-                // c8 ignore next
-                if (doDebug) {
-                    debugLog(chalk.red(" ----------------> ", classDef.browseName));
-                    classDef.dataTypeImport.forEach((a) => {
-                        debugLog(chalk.red(" ------------------------> ", a.module, a.name, a.namespace));
-                    });
-                }
-                classDef.dataTypeImport.forEach(cache.ensureImported.bind(cache));
+    if (nodeClass === NodeClass.VariableType) {
+        if (classDef.dataTypeImport) {
+            // c8 ignore next
+            if (doDebug) {
+                debugLog(chalk.red(" ----------------> ", classDef.browseName));
+                classDef.dataTypeImport.forEach((a) => {
+                    debugLog(chalk.red(" ------------------------> ", a.module, a.name, a.namespace));
+                });
             }
-            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 (countExposedChildren(members) === 0 && baseInterfaceName?.name !== "UAVariableT") {
-                //
-                const baseName = `${baseInterfaceName?.name}${baseExtension}${chevronsBase.chevronsExtend}`;
-                f.write(`export type ${classBaseName} = ${baseName};`);
+            classDef.dataTypeImport.forEach(cache.ensureImported.bind(cache));
+        }
+        cache.referenceBasicType("DataType");
+        const chevrons = calculateChevrons(classDef);
+        if (!classDef.baseClassDef) {
+            throw new Error(`Expecting a baseClassDef for ${classDef.browseName.toString()}`);
+        }
+        const chevronsBase = calculateChevrons(classDef.baseClassDef, classDef);
+        //  Shall we  cache.ensureImported({ ...baseInterfaceName, module: dataTypeName, name: dataTypeName });
+        const classBaseName = `${interfaceName.name}${baseExtension}${chevrons.chevronsDef}`;
+        if (countExposedChildren(members) === 0 && baseInterfaceName?.name !== "UAVariableT") {
+            //
+            const baseName = `${baseInterfaceName?.name}${baseExtension}${chevronsBase.chevronsExtend}`;
+            f.write(`export type ${classBaseName} = ${baseName};`);
+        } else {
+            if (baseInterfaceName?.name === "UAVariableT") {
+                f.write(`export interface ${classBaseName}  {`);
             } else {
-                if (baseInterfaceName?.name === "UAVariableT") {
-                    f.write(`export interface ${classBaseName}  {`);
-                } else {
-                    const baseName = `${baseInterfaceName?.name}${baseExtension}${chevronsBase.chevronsExtend}`;
-                    f.write(`export interface ${classBaseName}  extends ${baseName} {`);
-                }
-                await dumpChildren("    ", members, f, cache);
-                f.write(`}`);
+                const baseName = `${baseInterfaceName?.name}${baseExtension}${chevronsBase.chevronsExtend}`;
+                f.write(`export interface ${classBaseName}  extends ${baseName} {`);
             }
+            await dumpChildren("    ", members, f, cache);
+            f.write(`}`);
+        }
+    } else {
+        const classBaseName = `${interfaceName.name}${baseExtension}`;
+        if (countExposedChildren(members) === 0 && baseInterfaceName?.name !== "UAObject") {
+            const baseName = `${baseInterfaceName?.name}${baseExtension}`;
+            f.write(`export type ${classBaseName} = ${baseName};`);
         } else {
-            const classBaseName = `${interfaceName.name}${baseExtension}`;
-            if (countExposedChildren(members) === 0 && baseInterfaceName?.name !== "UAObject") {
-                const baseName = `${baseInterfaceName?.name}${baseExtension}`;
-                f.write(`export type ${classBaseName} = ${baseName};`);
+            if (baseInterfaceName?.name === "UAObject") {
+                f.write(`export interface ${classBaseName} {`);
             } else {
-                if (baseInterfaceName?.name === "UAObject") {
-                    f.write(`export interface ${classBaseName} {`);
-                } else {
-                    const baseName = `${baseInterfaceName?.name}${baseExtension}`;
-                    f.write(`export interface ${classBaseName} extends ${baseName} {`);
-                }
-                await dumpChildren("    ", members, f, cache);
-                f.write(`}`);
+                const baseName = `${baseInterfaceName?.name}${baseExtension}`;
+                f.write(`export interface ${classBaseName} extends ${baseName} {`);
             }
+            await dumpChildren("    ", members, f, cache);
+            f.write(`}`);
         }
     }
     const baseStuff = getBaseClassWithOmit(classDef);

package/source/index.ts

@@ -1,3 +1,3 @@
-export * from "./convert_to_typescript";
 export * from "./convert_namespace_to_typescript";
-export * from "./walk_through";
+export * from "./convert_to_typescript";
+export * from "./walk_through";

package/source/main.ts

@@ -31,7 +31,7 @@ async function main() {
     const session = new PseudoSession(addressSpace);
     const options = {
         baseFolder: path.join(__dirname, "../../"),
-        prefix: "node-opcua-nodeset-",
+        prefix: "node-opcua-nodeset-"
     };
     // const nodesetCatalog2 = nodesetCatalog.filter((meta) => meta.name == "scales");
 
@@ -48,7 +48,7 @@ async function main() {
         }
         await convertNamespaceTypeToTypescript(session, index, {
             ...options,
-            nsName: meta.name,
+            nsName: meta.name
         });
     }
 
@@ -56,7 +56,8 @@ async function main() {
     // source/ folder on disk. This covers cases where a catalog entry name
     // doesn't line up with its package folder (e.g. catalog "standard" writes
     // into node-opcua-nodeset-ua).
-    const folders = fs.readdirSync(options.baseFolder)
+    const folders = fs
+        .readdirSync(options.baseFolder)
         .filter((name) => name.startsWith(options.prefix))
         .map((name) => path.join(options.baseFolder, name))
         .filter((p) => fs.existsSync(path.join(p, "source")));