node-opcua-client-dynamic-extension-object 2.178.0 → 2.180.0

package/source/private/populate_data_type_manager_103.ts

@@ -1,32 +1,39 @@
-/* eslint-disable max-statements */
-// tslint:disable: no-console
 /**
  * @module node-opcua-client-dynamic-extension-object
  */
 import chalk from "chalk";
 
 import { assert } from "node-opcua-assert";
-import { AttributeIds, makeNodeClassMask, makeResultMask, NodeClassMask, QualifiedName } from "node-opcua-data-model";
+import { AttributeIds, makeNodeClassMask, makeResultMask, NodeClassMask, type QualifiedName } from "node-opcua-data-model";
+import type { DataValue } from "node-opcua-data-value";
 import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
-import { ConstructorFuncWithSchema, DataTypeFactory, getStandardDataTypeFactory } from "node-opcua-factory";
+import { type ConstructorFuncWithSchema, DataTypeFactory, getStandardDataTypeFactory } from "node-opcua-factory";
 import { ExpandedNodeId, NodeId, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
-import { browseAll, BrowseDescriptionLike, IBasicSessionAsync, IBasicSessionAsync2 } from "node-opcua-pseudo-session";
+import {
+    type BrowseDescriptionLike,
+    browseAll,
+    type IBasicSessionAsync,
+    type IBasicSessionAsync2
+} from "node-opcua-pseudo-session";
 import {
     createDynamicObjectConstructor,
-    DataTypeAndEncodingId,
-    MapDataTypeAndEncodingIdProvider,
+    type DataTypeAndEncodingId,
+    type MapDataTypeAndEncodingIdProvider,
     parseBinaryXSD
 } from "node-opcua-schemas";
-import { BrowseDescriptionOptions, BrowseDirection, BrowseResult, ReferenceDescription } from "node-opcua-service-browse";
+import {
+    type BrowseDescriptionOptions,
+    BrowseDirection,
+    type BrowseResult,
+    type ReferenceDescription
+} from "node-opcua-service-browse";
 import { makeBrowsePath } from "node-opcua-service-translate-browse-path";
-import { ReadValueIdOptions, StructureDefinition } from "node-opcua-types";
-
-import { ExtraDataTypeManager } from "../extra_data_type_manager";
+import { type ReadValueIdOptions, StructureDefinition } from "node-opcua-types";
 import {
-    CacheForFieldResolution,
+    type CacheForFieldResolution,
     convertDataTypeDefinitionToStructureTypeSchema
 } from "../convert_data_type_definition_to_structuretype_schema";
-import { DataValue } from "node-opcua-data-value";
+import type { ExtraDataTypeManager } from "../extra_data_type_manager";
 
 const doDebug = checkDebugFlag(__filename);
 const debugLog = make_debugLog(__filename);
@@ -58,7 +65,8 @@ async function _readDeprecatedFlag(session: IBasicSessionAsync, dataTypeDictiona
     /* c8 ignore next */
     if (!a.targets || a.targets.length === 0) {
         // the server is probably version < 1.04.
-        debugLog("Cannot find Deprecated property for dataTypeDictionary " + dataTypeDictionary.toString());
+        // c8 ignore next
+        doDebug && debugLog(`Cannot find Deprecated property for dataTypeDictionary ${dataTypeDictionary.toString()}`);
         return false;
     }
     const deprecatedFlagNodeId = a.targets[0].targetId;
@@ -103,21 +111,34 @@ async function _getDataTypeDescriptions(
     return result2.references.map((r) => ({ nodeId: r.nodeId, browseName: r.browseName }));
 }
 
+/**
+ * A DataType together with the DataTypeDescription it was reached through.
+ *
+ * These used to be two arrays paired by index, which only holds while nothing is
+ * skipped - and descriptions are skipped, since an abstract type has no DescriptionOf
+ * reference. After the first skip every index named a different type in each array, so
+ * encodings were written onto the wrong description and the caller's lookup missed. That
+ * surfaced as "cannot find dataTypeDescription for ns=..;i=..", caught and logged, with
+ * the class silently left unregistered. Keeping the two together makes it unrepresentable.
+ */
+interface IDataTypeAndDescription {
+    dataTypeNodeId: NodeId;
+    dataTypeDescription: IDataTypeDescription;
+}
+
 async function _enrichWithDescriptionOf(
     session: IBasicSessionAsync2,
     dataTypeDescriptions: IDataTypeDescription[]
-): Promise<NodeId[]> {
-    const nodesToBrowse3: BrowseDescriptionOptions[] =
-        dataTypeDescriptions.map((dataTypeDescription) => ({
-            browseDirection: BrowseDirection.Inverse,
-            includeSubtypes: false,
-            nodeClassMask: makeNodeClassMask("Object"),
-            nodeId: dataTypeDescription.nodeId.toString(),
-            referenceTypeId: resolveNodeId("HasDescription"),
-            //            resultMask: makeResultMask("NodeId | ReferenceType | BrowseName | NodeClass | TypeDefinition")
-            resultMask: makeResultMask("NodeId")
-        }))
-        ;
+): Promise<IDataTypeAndDescription[]> {
+    const nodesToBrowse3: BrowseDescriptionOptions[] = dataTypeDescriptions.map((dataTypeDescription) => ({
+        browseDirection: BrowseDirection.Inverse,
+        includeSubtypes: false,
+        nodeClassMask: makeNodeClassMask("Object"),
+        nodeId: dataTypeDescription.nodeId.toString(),
+        referenceTypeId: resolveNodeId("HasDescription"),
+        //            resultMask: makeResultMask("NodeId | ReferenceType | BrowseName | NodeClass | TypeDefinition")
+        resultMask: makeResultMask("NodeId")
+    }));
 
     /* c8 ignore next */
     if (nodesToBrowse3.length === 0) {
@@ -127,6 +148,8 @@ async function _enrichWithDescriptionOf(
 
     const binaryEncodings = [];
     const nodesToBrowseDataType: BrowseDescriptionOptions[] = [];
+    // parallel to nodesToBrowseDataType, so the pairing survives the skips below
+    const browsedDescriptions: IDataTypeDescription[] = [];
 
     for (let i = 0; i < results3.length; i++) {
         const result3 = results3[i];
@@ -153,6 +176,7 @@ async function _enrichWithDescriptionOf(
             };
             dataTypeDescription.encodings.binaryEncodingNodeId = binaryEncodingNodeId;
             binaryEncodings.push(binaryEncodingNodeId);
+            browsedDescriptions.push(dataTypeDescription);
             nodesToBrowseDataType.push({
                 browseDirection: BrowseDirection.Inverse,
                 includeSubtypes: false,
@@ -165,7 +189,7 @@ async function _enrichWithDescriptionOf(
         }
     }
 
-    const dataTypeNodeIds: NodeId[] = [];
+    const pairs: IDataTypeAndDescription[] = [];
 
     if (nodesToBrowseDataType.length > 0) {
         const results4 = await browseAll(session, nodesToBrowseDataType);
@@ -177,16 +201,21 @@ async function _enrichWithDescriptionOf(
             if (result4.references.length !== 1) {
                 errorLog("What's going on ?", result4.toString(), "result4.references.length = ", result4.references.length);
             }
+            // Nothing to pair with, and reading references[0] would throw.
+            if (result4.references.length === 0) {
+                continue;
+            }
 
-            const ref = result4.references![0];
+            const ref = result4.references[0];
             const dataTypeNodeId = ref.nodeId;
-            dataTypeNodeIds[i] = dataTypeNodeId;
-            const dataTypeDescription = dataTypeDescriptions[i];
+            const dataTypeDescription = browsedDescriptions[i];
+            // biome-ignore lint/style/noNonNullAssertion: encodings is always populated for entries that reached nodesToBrowseDataType (see loop above)
             dataTypeDescription.encodings!.dataTypeNodeId = dataTypeNodeId;
+            pairs.push({ dataTypeNodeId, dataTypeDescription });
         }
     }
 
-    const otherEncodingBrowse = dataTypeNodeIds.map((dataTypeNodeId) => ({
+    const otherEncodingBrowse = pairs.map(({ dataTypeNodeId }) => ({
         browseDirection: BrowseDirection.Forward,
         includeSubtypes: false,
         nodeClassMask: NodeClassMask.Object,
@@ -199,20 +228,22 @@ async function _enrichWithDescriptionOf(
     const results5 = await browseAll(session, otherEncodingBrowse);
     for (let i = 0; i < results5.length; i++) {
         const result5 = results5[i];
-        const dataTypeDescription = dataTypeDescriptions[i];
+        const { dataTypeDescription } = pairs[i];
         let encodingCounter = 0;
+        // biome-ignore lint/style/noNonNullAssertion: encodings is always populated by the earlier enrichment pass for these dataTypeDescriptions
+        const encodings = dataTypeDescription.encodings!;
         for (const ref of result5.references || []) {
             switch (ref.browseName.name) {
                 case "Default XML":
-                    dataTypeDescription.encodings!.xmlEncodingNodeId = ref.nodeId;
+                    encodings.xmlEncodingNodeId = ref.nodeId;
                     encodingCounter++;
                     break;
                 case "Default Binary":
-                    dataTypeDescription.encodings!.binaryEncodingNodeId = ref.nodeId;
+                    encodings.binaryEncodingNodeId = ref.nodeId;
                     encodingCounter++;
                     break;
                 case "Default JSON":
-                    dataTypeDescription.encodings!.jsonEncodingNodeId = ref.nodeId;
+                    encodings.jsonEncodingNodeId = ref.nodeId;
                     encodingCounter++;
                     break;
                 default:
@@ -223,7 +254,7 @@ async function _enrichWithDescriptionOf(
             dataTypeDescription.isAbstract = true;
         }
     }
-    return dataTypeNodeIds;
+    return pairs;
 }
 
 interface IDataTypeDefInfo {
@@ -231,6 +262,8 @@ interface IDataTypeDefInfo {
     dataTypeNodeId: NodeId;
     dataTypeDefinition: StructureDefinition;
     isAbstract: boolean;
+    /** the description this type was reached through; carried so nothing has to find it again */
+    dataTypeDescription: IDataTypeDescription;
 }
 type DataTypeDefinitions = IDataTypeDefInfo[];
 
@@ -283,19 +316,22 @@ async function _extractDataTypeDictionaryFromDefinition(
     assert(dataTypeManager, "expecting a dataTypeManager");
 
     const dataTypeDescriptions = await _getDataTypeDescriptions(session, dataTypeDictionaryNodeId);
-    const dataTypeNodeIds = await _enrichWithDescriptionOf(session, dataTypeDescriptions);
+    const dataTypeAndDescriptions = await _enrichWithDescriptionOf(session, dataTypeDescriptions);
 
-    // now read DataTypeDefinition attributes of all the dataTypeNodeIds, this will only contains concrete structure
-    const nodesToRead: ReadValueIdOptions[] = dataTypeNodeIds.map((nodeId: NodeId) => ({
+    // now read DataTypeDefinition attributes of all the dataTypes, this will only contains concrete structure
+    const nodesToRead: ReadValueIdOptions[] = dataTypeAndDescriptions.map(({ dataTypeNodeId }) => ({
         attributeId: AttributeIds.DataTypeDefinition,
-        nodeId
+        nodeId: dataTypeNodeId
     }));
 
     const cache: { [key: string]: CacheForFieldResolution } = {};
     const dataValuesWithDataTypeDefinition = nodesToRead.length > 0 ? await session.read(nodesToRead) : [];
 
-    // in some circumstances like Euromap, this assert fails:
-    // assert(dataValuesWithDataTypeDefinition.length === dataTypeDescriptions.length);
+    // The commented-out assert here compared against dataTypeDescriptions.length and
+    // was reported to fail on nodesets such as Euromap. It was right to fail: the two
+    // lists are not the same length, because abstract types are skipped. The read is
+    // driven by dataTypeAndDescriptions, so this is the invariant that does hold.
+    assert(dataValuesWithDataTypeDefinition.length === dataTypeAndDescriptions.length);
 
     const dataTypeDefinitions: DataTypeDefinitions = [];
 
@@ -303,31 +339,39 @@ async function _extractDataTypeDictionaryFromDefinition(
 
     const promise: Promise<void>[] = [];
     for (const dataValue of dataValuesWithDataTypeDefinition) {
-        const dataTypeNodeId = dataTypeNodeIds[index];
-        const dataTypeDescription = dataTypeDescriptions[index];
-
+        const { dataTypeNodeId, dataTypeDescription } = dataTypeAndDescriptions[index];
 
         if (dataValue.statusCode.isGood()) {
             const dataTypeDefinition = dataValue.value.value;
 
             if (dataTypeDefinition && dataTypeDefinition instanceof StructureDefinition) {
-                const className = dataTypeDescription.browseName.name!;
+                if (!dataTypeDescription.browseName.name) {
+                    throw new Error(`Unexpected: BrowseName has no name for nodeId ${dataTypeNodeId.toString()}`);
+                }
+                const className = dataTypeDescription.browseName.name;
                 promise.push(
                     (async () => {
                         const isAbstract = await readIsAbstract(session, dataTypeNodeId);
-                        dataTypeDefinitions.push({ className, dataTypeNodeId, dataTypeDefinition, isAbstract });
+                        dataTypeDefinitions.push({
+                            className,
+                            dataTypeNodeId,
+                            dataTypeDefinition,
+                            isAbstract,
+                            dataTypeDescription
+                        });
                     })()
                 );
             }
-        }
-        /* c8 ignore next */
-        else {
-            debugLog(
-                "dataTypeNodeId ",
-                dataTypeNodeId.toString(),
-                " has no DataTypeDescription attribute",
-                dataValue.statusCode.toString()
-            );
+        } else {
+            /* c8 ignore next */
+            // c8 ignore next
+            doDebug &&
+                debugLog(
+                    "dataTypeNodeId ",
+                    dataTypeNodeId.toString(),
+                    " has no DataTypeDescription attribute",
+                    dataValue.statusCode.toString()
+                );
         }
         index++;
     }
@@ -337,15 +381,14 @@ async function _extractDataTypeDictionaryFromDefinition(
     const dataTypeDefinitionsSorted = sortStructure(dataTypeDefinitions);
     // c8 ignore next
     if (doDebug) {
-        debugLog("order ", dataTypeDefinitionsSorted.map((a) => a.className + " " + a.dataTypeNodeId).join(" ->  "));
+        debugLog("order ", dataTypeDefinitionsSorted.map((a) => `${a.className} ${a.dataTypeNodeId}`).join(" ->  "));
     }
 
     const promises2: Promise<void>[] = [];
 
-    for (const { className, dataTypeNodeId, dataTypeDefinition, isAbstract } of dataTypeDefinitionsSorted) {
+    for (const { className, dataTypeNodeId, dataTypeDefinition, isAbstract, dataTypeDescription } of dataTypeDefinitionsSorted) {
         promises2.push(
             (async () => {
-
                 const dataTypeFactory = dataTypeManager.getDataTypeFactoryForNamespace(dataTypeNodeId.namespace);
                 // c8 ignore next
                 if (doDebug) {
@@ -356,16 +399,22 @@ async function _extractDataTypeDictionaryFromDefinition(
                 }
                 // now fill typeDictionary
                 try {
-                    const dataTypeDescription = dataTypeDescriptions.find((a) => a.nodeId.toString() === dataTypeNodeId.toString());
+                    // Previously this searched dataTypeDescriptions for one whose nodeId
+                    // equalled dataTypeNodeId - comparing a description node against a
+                    // DataType node, which only ever matched by accident. The description
+                    // now travels with the type it belongs to.
                     if (!dataTypeDefinition) {
-                        throw new Error("cannot find dataTypeDefinition for " + dataTypeNodeId.toString());
+                        throw new Error(`cannot find dataTypeDefinition for ${dataTypeNodeId.toString()}`);
+                    }
+                    if (!dataTypeDescription) {
+                        throw new Error(`cannot find dataTypeDescription for ${dataTypeNodeId.toString()}`);
                     }
                     const schema = await convertDataTypeDefinitionToStructureTypeSchema(
                         session,
                         dataTypeNodeId,
                         className,
                         dataTypeDefinition,
-                        dataTypeDescription!, // for encodings
+                        dataTypeDescription, // for encodings
                         dataTypeManager,
                         isAbstract,
                         cache
@@ -393,7 +442,7 @@ async function _extractDataTypeDictionaryFromDefinition(
                     }
                 } catch (err) {
                     errorLog("Constructor verification err: ", (<Error>err).message);
-                    errorLog("For this reason class " + className + " has not been registered");
+                    errorLog(`For this reason class ${className} has not been registered`);
                     errorLog(err);
                 }
             })()
@@ -414,7 +463,10 @@ async function _extractNodeIds(
     await _enrichWithDescriptionOf(session, dataTypeDescriptions);
 
     for (const dataTypeDescription of dataTypeDescriptions) {
-        map[dataTypeDescription.browseName.name!.toString()] = dataTypeDescription.encodings!;
+        if (!dataTypeDescription.browseName.name || !dataTypeDescription.encodings) {
+            continue;
+        }
+        map[dataTypeDescription.browseName.name.toString()] = dataTypeDescription.encodings;
     }
 
     return {
@@ -465,7 +517,7 @@ async function _extractDataTypeDictionary(
         // dataType definition in store directly in UADataType under the definition attribute
         const dataTypeFactory2 = dataTypeManager.getDataTypeFactory(dataTypeDictionaryNodeId.namespace);
         if (!dataTypeFactory2) {
-            throw new Error("cannot find dataTypeFactory for namespace " + dataTypeDictionaryNodeId.namespace);
+            throw new Error(`cannot find dataTypeFactory for namespace ${dataTypeDictionaryNodeId.namespace}`);
         }
         await _extractDataTypeDictionaryFromDefinition(session, dataTypeDictionaryNodeId, dataTypeManager);
     } else {
@@ -525,7 +577,7 @@ async function _exploreDataTypeDefinition(
     const results2 = await browseAll(session, nodesToBrowse2);
 
     const binaryEncodingNodeIds = results2.map((br: BrowseResult) => {
-        const defaultBin = br.references!.filter((r: ReferenceDescription) => r.browseName.toString() === "Default Binary");
+        const defaultBin = (br.references || []).filter((r: ReferenceDescription) => r.browseName.toString() === "Default Binary");
 
         /* c8 ignore next */
         if (defaultBin.length < 1) {
@@ -542,7 +594,10 @@ async function _exploreDataTypeDefinition(
         for (let i = 0; i < references.length; i++) {
             const ref = references[i];
             const binaryEncoding = binaryEncodingNodeIds[i];
-            const name = ref.browseName!.name!.toString();
+            const name = ref.browseName?.name?.toString();
+            if (!name) {
+                continue;
+            }
             debugLog("      type ", name.padEnd(30, " "), binaryEncoding.toString());
             // let's verify that constructor is operational
             try {
@@ -558,8 +613,8 @@ async function _exploreDataTypeDefinition(
                 const testObject = new Constructor();
                 debugLog(testObject.toString());
             } catch (err) {
-                debugLog("         Error cannot construct Extension Object " + name);
-                debugLog("         " + (<Error>err).message);
+                debugLog(`         Error cannot construct Extension Object ${name}`);
+                debugLog(`         ${(<Error>err).message}`);
             }
         }
     }
@@ -594,7 +649,8 @@ export async function populateDataTypeManager103(
     session: IBasicSessionAsync2,
     dataTypeManager: ExtraDataTypeManager
 ): Promise<void> {
-    debugLog("in ... populateDataTypeManager");
+    // c8 ignore next
+    doDebug && debugLog("in ... populateDataTypeManager");
 
     // read namespace array
     const dataValueNamespaceArray = await session.read({
@@ -606,14 +662,15 @@ export async function populateDataTypeManager103(
 
     // c8 ignore next
     if (!namespaceArray) {
-        debugLog("session: cannot read Server_NamespaceArray");
+        // c8 ignore next
+        doDebug && debugLog("session: cannot read Server_NamespaceArray");
         // throw new Error("Cannot get Server_NamespaceArray as a array of string");
         return;
     }
 
     // c8 ignore next
     if (doDebug) {
-        debugLog("namespaceArray ", namespaceArray.map((a, index) => " " + index.toString().padEnd(3) + ":" + a).join(" "));
+        debugLog("namespaceArray ", namespaceArray.map((a, index) => ` ${index.toString().padEnd(3)}:${a}`).join(" "));
     }
 
     if (dataValueNamespaceArray.statusCode.isGood() && namespaceArray && namespaceArray.length > 0) {
@@ -653,17 +710,18 @@ export async function populateDataTypeManager103(
     // c8 ignore next
     if (doDebug) {
         debugLog(result.statusCode.toString());
-        debugLog(result.references?.map((r: any) => r.browseName?.toString()).join(" "));
+        debugLog(result.references?.map((r) => r.browseName?.toString()).join(" "));
     }
 
     // filter nodes that have the expected namespace Index
     // ( more specifically we want to filter out DataStructure from namespace 0)
     // we also want to keep only object of type DataTypeDictionaryType
-    const references = result.references!.filter(
+    const references = (result.references || []).filter(
         (e: ReferenceDescription) => e.nodeId.namespace !== 0 && sameNodeId(e.typeDefinition, dataTypeDictionaryType)
     );
 
-    debugLog(`found ${references.length} dictionaries`);
+    // c8 ignore next
+    doDebug && debugLog(`found ${references.length} dictionaries`);
 
     async function putInCorrectOrder(): Promise<TypeDictionaryInfo[]> {
         const infos: TypeDictionaryInfo[] = [];
@@ -673,11 +731,11 @@ export async function populateDataTypeManager103(
             const dataTypeDictionaryNodeId = reference.nodeId;
 
             const promises: [Promise<boolean>, Promise<DataValue>] = [
-                    /* isDictionaryDeprecated: bool = await */ _readDeprecatedFlag(session, dataTypeDictionaryNodeId),
-                    /* rawSchemaDataValue!: DataValue = await */ session.read({
-                attributeId: AttributeIds.Value,
-                nodeId: dataTypeDictionaryNodeId
-            })
+                /* isDictionaryDeprecated: bool = await */ _readDeprecatedFlag(session, dataTypeDictionaryNodeId),
+                /* rawSchemaDataValue!: DataValue = await */ session.read({
+                    attributeId: AttributeIds.Value,
+                    nodeId: dataTypeDictionaryNodeId
+                })
             ];
 
             const [isDictionaryDeprecated, rawSchemaDataValue] = await Promise.all(promises);
@@ -721,17 +779,20 @@ export async function populateDataTypeManager103(
                         if (r) {
                             const { xmlns, namespace } = r;
                             nsKeyNamespace[xmlns] = namespace;
-                            debugLog("xxxx ns= ", xmlns, "=>", namespace);
+                            // c8 ignore next
+                            doDebug && debugLog("xxxx ns= ", xmlns, "=>", namespace);
                         }
                     }
                     info.dependencies = nsKeyNamespace;
-                    debugLog("xxx targetNamespace = ", info.targetNamespace);
+                    // c8 ignore next
+                    doDebug && debugLog("xxx targetNamespace = ", info.targetNamespace);
                     innerMap[info.targetNamespace] = info;
                 }
             } else {
                 // may be 1.04 => the rawSchema is no more needed in new version
                 info.targetNamespace = namespaceArray[dataTypeDictionaryNodeId.namespace];
-                debugLog("xxx targetNamespace = ", info.targetNamespace);
+                // c8 ignore next
+                doDebug && debugLog("xxx targetNamespace = ", info.targetNamespace);
                 innerMap[info.targetNamespace] = info;
             }
             // assert(info.targetNamespace.length !== 0);
@@ -741,13 +802,13 @@ export async function populateDataTypeManager103(
 
         // ----------------------------------
         const orderedList: TypeDictionaryInfo[] = [];
-        const visited: any = {};
+        const visited: Record<string, number> = {};
         function explore(d: TypeDictionaryInfo): void {
             if (visited[d.targetNamespace]) {
                 return;
             }
             visited[d.targetNamespace] = 1;
-            for (const [xmlns, namespace] of Object.entries(d.dependencies)) {
+            for (const [_xmlns, namespace] of Object.entries(d.dependencies)) {
                 if (!innerMap[namespace] || namespace === d.targetNamespace) {
                     continue;
                 }
@@ -759,7 +820,8 @@ export async function populateDataTypeManager103(
             explore(d);
         }
 
-        debugLog(" Ordered List = ", orderedList.map((a) => a.targetNamespace).join("  "));
+        // c8 ignore next
+        doDebug && debugLog(" Ordered List = ", orderedList.map((a) => a.targetNamespace).join("  "));
 
         return orderedList;
     }
@@ -811,8 +873,8 @@ export async function populateDataTypeManager103(
         const set = new Set<DataTypeFactory>();
         set.add(getStandardDataTypeFactory());
 
-        var visited: Set<string> = new Set();
-        function explore(d: TypeDictionaryInfo): void {
+        const visited: Set<string> = new Set();
+        const explore = (d: TypeDictionaryInfo): void => {
             if (visited.has(d.targetNamespace)) {
                 return;
             }
@@ -825,10 +887,10 @@ export async function populateDataTypeManager103(
                 if (namespaceUri === d.targetNamespace) {
                     continue;
                 }
-                var index = namespaceArray.indexOf(namespaceUri);
-                if (index == -1) continue;
+                const index = namespaceArray.indexOf(namespaceUri);
+                if (index === -1) continue;
 
-                var dd = dataTypeManager.getDataTypeFactory(index);
+                const dd = dataTypeManager.getDataTypeFactory(index);
                 set.add(dd);
 
                 const base = map[namespaceUri];
@@ -836,7 +898,7 @@ export async function populateDataTypeManager103(
                     explore(base);
                 }
             }
-        }
+        };
         explore(d);
         const baseDataFactories = Array.from(set);
         const dataTypeFactory = dataTypeManager.getDataTypeFactory(d.dataTypeDictionaryNodeId.namespace);
@@ -848,7 +910,8 @@ export async function populateDataTypeManager103(
 
     // now investigate DataTypeDescriptionType
     async function processReferenceOnDataTypeDictionaryType(d: TypeDictionaryInfo): Promise<void> {
-        debugLog(chalk.cyan("processReferenceOnDataTypeDictionaryType on  "), d.targetNamespace);
+        // c8 ignore next
+        doDebug && debugLog(chalk.cyan("processReferenceOnDataTypeDictionaryType on  "), d.targetNamespace);
         const ref = d.reference;
         const dataTypeDictionaryNodeId = d.reference.nodeId;
 
@@ -872,8 +935,8 @@ export async function populateDataTypeManager103(
         }
     }
 
-
     // https://medium.com/swlh/dealing-with-multiple-promises-in-javascript-41d6c21f20ff
+    // biome-ignore lint/correctness/noConstantCondition: deliberate debug on/off toggle, not dead code
     if (false) {
         // we need to read sequentially the dataTypeDictionaryInfo
         // to esnsure that dependencies are resolved in the correct order
@@ -897,11 +960,10 @@ export async function populateDataTypeManager103(
                 s = s.substring(0, s.length - 1);
             }
             return s;
-        }
+        };
         // check if all dependencies have been processed for this dataTypeDictionary
         const allDependenciesAlreadyProcessed = (typeDictionaryInfo: TypeDictionaryInfo) => {
-
-            for (const [key, namespace1] of Object.entries(typeDictionaryInfo.dependencies)) {
+            for (const [_key, namespace1] of Object.entries(typeDictionaryInfo.dependencies)) {
                 // codesys may add quotes around the namespace
                 const namespace = unquote(namespace1);
                 if (typeDictionaryInfo.targetNamespace === namespace) {
@@ -913,11 +975,11 @@ export async function populateDataTypeManager103(
                 }
             }
             return true;
-        }
+        };
 
         const queue: TypeDictionaryInfo[] = [...dataTypeDictionaryInfo];
 
-        // we load typeDictionary in parallel by processing all 
+        // we load typeDictionary in parallel by processing all
         // typeDictionary that have all their dependencies resolved
         const extractIndependantTypeInfo = (queue: TypeDictionaryInfo[]): TypeDictionaryInfo[] => {
             const toProcess = queue.splice(0);
@@ -932,7 +994,7 @@ export async function populateDataTypeManager103(
                 }
             }
             return result;
-        }
+        };
         const processFunc = async (typeDictionaryInfo: TypeDictionaryInfo) => {
             try {
                 doDebug && debugLog("processing ", typeDictionaryInfo.targetNamespace);
@@ -941,9 +1003,8 @@ export async function populateDataTypeManager103(
                 errorLog("Error in processReferenceOnDataTypeDictionaryType", err);
             }
             alreadyProcessed.add(unquote(typeDictionaryInfo.targetNamespace));
-        }
+        };
         while (queue.length > 0) {
-
             // c8 ignore next
             if (doDebug) {
                 for (const d of queue) {
@@ -959,10 +1020,10 @@ export async function populateDataTypeManager103(
                 errorLog("Cannot process any more dataTypeDictionary");
                 break;
             }
-            const promises: Promise<void>[] =
-                readyToProcess.map((typeDictionaryInfo) => processFunc(typeDictionaryInfo));
+            const promises: Promise<void>[] = readyToProcess.map((typeDictionaryInfo) => processFunc(typeDictionaryInfo));
             await Promise.all(promises);
         }
     }
-    debugLog("out ... populateDataTypeManager103");
+    // c8 ignore next
+    doDebug && debugLog("out ... populateDataTypeManager103");
 }