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

package/source/extra_data_type_manager.ts

@@ -1,14 +1,14 @@
 /**
  * @module node-opcua-client-dynamic-extension-object
  */
-import { format } from "util";
+import { format } from "node:util";
 
 import { assert } from "node-opcua-assert";
 import { BrowseDirection, NodeClassMask, ResultMask } from "node-opcua-data-model";
-import { ConstructorFunc, DataTypeFactory, getStandardDataTypeFactory, StructureInfo } from "node-opcua-factory";
-import { NodeId } from "node-opcua-nodeid";
-import { IBasicSessionAsync2 } from "node-opcua-pseudo-session";
-import { AnyConstructorFunc } from "node-opcua-schemas";
+import { type ConstructorFunc, type DataTypeFactory, getStandardDataTypeFactory, type StructureInfo } from "node-opcua-factory";
+import type { NodeId } from "node-opcua-nodeid";
+import type { IBasicSessionAsync2 } from "node-opcua-pseudo-session";
+import type { AnyConstructorFunc } from "node-opcua-schemas";
 
 export class ExtraDataTypeManager {
     public namespaceArray: string[] = [];
@@ -16,10 +16,6 @@ export class ExtraDataTypeManager {
     private _session: IBasicSessionAsync2 | null = null;
     private _pendingExtractions: Map<string, Promise<StructureInfo>> = new Map();
 
-    constructor() {
-        /* */
-    }
-
     public setSession(session: IBasicSessionAsync2): void {
         this._session = session;
     }
@@ -32,7 +28,7 @@ export class ExtraDataTypeManager {
         if (namespaceIndex === 0) {
             return true;
         }
-        return !!Object.prototype.hasOwnProperty.call(this.dataTypeFactoryMapByNamespace, namespaceIndex);
+        return !!Object.hasOwn(this.dataTypeFactoryMapByNamespace, namespaceIndex);
     }
 
     public registerDataTypeFactory(namespaceIndex: number, dataTypeFactory: DataTypeFactory): void {
@@ -64,13 +60,15 @@ export class ExtraDataTypeManager {
         if (standardDataTypeFactory.hasBuiltInType(fieldTypeName)) {
             return standardDataTypeFactory.getBuiltInType(fieldTypeName);
         }
-        throw new Error("Cannot find built-in type " + fieldTypeName);
+        throw new Error(`Cannot find built-in type ${fieldTypeName}`);
     }
 
     public getStructureInfoForDataType(dataTypeNodeId: NodeId): StructureInfo | null {
         const dataTypeFactory = this.getDataTypeFactory(dataTypeNodeId.namespace);
         if (!dataTypeFactory) {
-            throw new Error("cannot find dataFactory for namespace=" + dataTypeNodeId.namespace + " when requested for " + dataTypeNodeId.toString());
+            throw new Error(
+                `cannot find dataFactory for namespace=${dataTypeNodeId.namespace} when requested for ${dataTypeNodeId.toString()}`
+            );
         }
         return dataTypeFactory.getStructureInfoForDataType(dataTypeNodeId);
     }
@@ -85,21 +83,23 @@ export class ExtraDataTypeManager {
         }
 
         const key = dataTypeNodeId.toString();
-        if (this._pendingExtractions.has(key)) {
-            return await this._pendingExtractions.get(key)!;
+        const pending = this._pendingExtractions.get(key);
+        if (pending) {
+            return await pending;
         }
 
+        const session = this._session;
         const promise = (async () => {
             // We'll need to make sure it's accessible and correctly used.
             // For now, let's assume we can import it or move it.
             // Actually, populate_data_type_manager_104.ts exports readDataTypeDefinitionAndBuildType
             const { readDataTypeDefinitionAndBuildType } = require("./private/populate_data_type_manager_104");
             const cache = {}; // local cache for this extraction
-            await readDataTypeDefinitionAndBuildType(this._session!, dataTypeNodeId, undefined, this, cache);
+            await readDataTypeDefinitionAndBuildType(session, dataTypeNodeId, undefined, this, cache);
 
             const info = this.getStructureInfoForDataType(dataTypeNodeId);
             if (!info) {
-                throw new Error("Failed to extract data type structure for " + dataTypeNodeId.toString());
+                throw new Error(`Failed to extract data type structure for ${dataTypeNodeId.toString()}`);
             }
             return info;
         })();
@@ -115,7 +115,9 @@ export class ExtraDataTypeManager {
     public getExtensionObjectConstructorFromDataType(dataTypeNodeId: NodeId): AnyConstructorFunc {
         const dataTypeFactory = this.getDataTypeFactory(dataTypeNodeId.namespace);
         if (!dataTypeFactory) {
-            throw new Error("cannot find dataFactory for namespace=" + dataTypeNodeId.namespace + " when requested for " + dataTypeNodeId.toString());
+            throw new Error(
+                `cannot find dataFactory for namespace=${dataTypeNodeId.namespace} when requested for ${dataTypeNodeId.toString()}`
+            );
         }
         // find schema corresponding to dataTypeNodeId in typeDictionary
         const structureInfo = dataTypeFactory.findStructureInfoForDataType(dataTypeNodeId);
@@ -130,7 +132,7 @@ export class ExtraDataTypeManager {
         const structureInfo = await this.getStructureInfoForDataTypeAsync(dataTypeNodeId);
         const Constructor = structureInfo.constructor;
         if (!Constructor) {
-            throw new Error("Cannot find Extension Object Constructor for Abstract dataType " + dataTypeNodeId.toString());
+            throw new Error(`Cannot find Extension Object Constructor for Abstract dataType ${dataTypeNodeId.toString()}`);
         }
         return Constructor;
     }
@@ -141,7 +143,7 @@ export class ExtraDataTypeManager {
         if (!Constructor) {
             throw new Error(
                 "getExtensionObjectConstructorFromBinaryEncoding cannot find constructor for binaryEncoding " +
-                binaryEncodingNodeId.toString()
+                    binaryEncodingNodeId.toString()
             );
         }
         return Constructor;
@@ -169,7 +171,7 @@ export class ExtraDataTypeManager {
         });
 
         if (browseResult.statusCode.isNotGood() || !browseResult.references || browseResult.references.length !== 1) {
-            throw new Error("Cannot find DataType for binary encoding " + binaryEncodingNodeId.toString());
+            throw new Error(`Cannot find DataType for binary encoding ${binaryEncodingNodeId.toString()}`);
         }
 
         const dataTypeNodeId = browseResult.references[0].nodeId;
@@ -177,14 +179,14 @@ export class ExtraDataTypeManager {
 
         Constructor = dataTypeFactory.getConstructor(binaryEncodingNodeId);
         if (!Constructor) {
-            throw new Error("Cannot find constructor for binary encoding " + binaryEncodingNodeId.toString() + " after extraction");
+            throw new Error(`Cannot find constructor for binary encoding ${binaryEncodingNodeId.toString()} after extraction`);
         }
         return Constructor;
     }
 
     public toString(): string {
         const l: string[] = [];
-        function write(...args: [any, ...any[]]) {
+        function write(...args: [unknown, ...unknown[]]) {
             l.push(format.apply(format, args));
         }
         write("ExtraDataTypeManager");

package/source/get_extension_object_constructor.ts

@@ -1,7 +1,7 @@
-import { QualifiedName, AttributeIds } from "node-opcua-data-model";
-import { NodeId } from "node-opcua-nodeid";
-import { IBasicSessionAsync2 } from "node-opcua-pseudo-session";
-import { AnyConstructorFunc } from "node-opcua-schemas";
+import { AttributeIds, type QualifiedName } from "node-opcua-data-model";
+import type { NodeId } from "node-opcua-nodeid";
+import type { IBasicSessionAsync2 } from "node-opcua-pseudo-session";
+import type { AnyConstructorFunc } from "node-opcua-schemas";
 //
 import { getExtraDataTypeManager } from "./get_extra_data_type_manager";
 import { readDataTypeDefinitionAndBuildType } from "./private/populate_data_type_manager_104";
@@ -9,8 +9,10 @@ import { readDataTypeDefinitionAndBuildType } from "./private/populate_data_type
 /**
  *
  */
-export async function getExtensionObjectConstructor(session: IBasicSessionAsync2, dataTypeNodeId: NodeId): Promise<AnyConstructorFunc> {
-   
+export async function getExtensionObjectConstructor(
+    session: IBasicSessionAsync2,
+    dataTypeNodeId: NodeId
+): Promise<AnyConstructorFunc> {
     const dataTypeManager = await getExtraDataTypeManager(session);
 
     const dataTypeFactory = dataTypeManager.getDataTypeFactory(dataTypeNodeId.namespace);
@@ -23,7 +25,10 @@ export async function getExtensionObjectConstructor(session: IBasicSessionAsync2
         attributeId: AttributeIds.BrowseName
     });
     const browseName = dataValue.value.value as QualifiedName;
-    await readDataTypeDefinitionAndBuildType(session, dataTypeNodeId, browseName.name!, dataTypeManager, {});
+    if (!browseName.name) {
+        throw new Error(`Unexpected: BrowseName has no name for nodeId ${dataTypeNodeId.toString()}`);
+    }
+    await readDataTypeDefinitionAndBuildType(session, dataTypeNodeId, browseName.name, dataTypeManager, {});
 
     return await dataTypeManager.getExtensionObjectConstructorFromDataType(dataTypeNodeId);
 }

package/source/get_extra_data_type_manager.ts

@@ -1,16 +1,11 @@
 import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
 import { DataTypeFactory, getStandardDataTypeFactory } from "node-opcua-factory";
-import {
-    IBasicSessionAsync2,
-    clearSessionCache,
-    readNamespaceArray
-} from "node-opcua-pseudo-session";
-import { NodeId } from "node-opcua-nodeid";
+import type { NodeId } from "node-opcua-nodeid";
+import { clearSessionCache, type IBasicSessionAsync2, readNamespaceArray } from "node-opcua-pseudo-session";
 //
 import { ExtraDataTypeManager } from "./extra_data_type_manager";
 import { DataTypeExtractStrategy, populateDataTypeManager } from "./populate_data_type_manager";
 
-
 const doDebug = checkDebugFlag(__filename);
 const debugLog = make_debugLog(__filename);
 const errorLog = make_errorLog(__filename);
@@ -26,7 +21,6 @@ export interface IBasicSessionAsync2Private extends IBasicSessionAsync2 {
     on?: (this: IBasicSessionAsync2Private, event: "session_restored", func: () => void) => void;
 
     sessionId?: NodeId;
-
 }
 export async function invalidateExtraDataTypeManager(session: IBasicSessionAsync2): Promise<void> {
     const sessionPriv = session as IBasicSessionAsync2Private;
@@ -38,7 +32,10 @@ export async function invalidateExtraDataTypeManager(session: IBasicSessionAsync
     }
 }
 
-async function extractDataTypeManagerPrivate(session: IBasicSessionAsync2, strategy: DataTypeExtractStrategy): Promise<ExtraDataTypeManager> {
+async function extractDataTypeManagerPrivate(
+    session: IBasicSessionAsync2,
+    strategy: DataTypeExtractStrategy
+): Promise<ExtraDataTypeManager> {
     const namespaceArray = await readNamespaceArray(session);
     // c8 ignore next
     if (namespaceArray.length === 0) {
@@ -64,7 +61,6 @@ async function extractDataTypeManagerPrivate(session: IBasicSessionAsync2, strat
     return dataTypeManager;
 }
 
-
 function getStrategy(session: IBasicSessionAsync2, strategy?: DataTypeExtractStrategy): DataTypeExtractStrategy {
     if (strategy !== undefined) {
         return strategy;
@@ -76,10 +72,9 @@ function getStrategy(session: IBasicSessionAsync2, strategy?: DataTypeExtractStr
     return DataTypeExtractStrategy.Auto;
 }
 
-
 export function hasBoostedSession(session: IBasicSessionAsync2): boolean {
-    const _session: IBasicSessionAsync2Private = session as IBasicSessionAsync2Private;
-    return !!_session.$$getSessionForDataTypeExtraction || !!(_session as any).session;
+    const _session: IBasicSessionAsync2Private & ICascadingSession = session as IBasicSessionAsync2Private & ICascadingSession;
+    return !!_session.$$getSessionForDataTypeExtraction || !!_session.session;
 }
 export function getSessionForDataTypeManagerExtraction(session: IBasicSessionAsync2): IBasicSessionAsync2 {
     const _session: IBasicSessionAsync2Private = session as IBasicSessionAsync2Private;
@@ -89,7 +84,7 @@ export function getSessionForDataTypeManagerExtraction(session: IBasicSessionAsy
     return session;
 }
 
-type ICascadingSession = { session?: IBasicSessionAsync2; }
+type ICascadingSession = { session?: IBasicSessionAsync2 };
 function followSession(session: IBasicSessionAsync2Private & ICascadingSession): IBasicSessionAsync2Private {
     if (session.session) {
         return followSession(session.session);
@@ -97,24 +92,28 @@ function followSession(session: IBasicSessionAsync2Private & ICascadingSession):
     return session;
 }
 
-export async function getExtraDataTypeManager(session: IBasicSessionAsync2, strategy?: DataTypeExtractStrategy): Promise<ExtraDataTypeManager> {
-
+export async function getExtraDataTypeManager(
+    session: IBasicSessionAsync2,
+    strategy?: DataTypeExtractStrategy
+): Promise<ExtraDataTypeManager> {
     const sessionPriv: IBasicSessionAsync2Private = followSession(session) as IBasicSessionAsync2Private;
 
     if (sessionPriv.$$extraDataTypeManager) {
         return sessionPriv.$$extraDataTypeManager;
     }
 
-    if (sessionPriv.$$extraDataTypeManagerToResolve) {
+    const pendingList = sessionPriv.$$extraDataTypeManagerToResolve;
+    if (pendingList) {
         doDebug && debugLog("getExtraDataTypeManager is re-entering !");
         return await new Promise<ExtraDataTypeManager>((resolve, reject) => {
-            sessionPriv.$$extraDataTypeManagerToResolve?.push([resolve, reject]);
+            pendingList.push([resolve, reject]);
         });
     }
-    sessionPriv.$$extraDataTypeManagerToResolve = [];
+    const newPendingList: [(a: ExtraDataTypeManager) => void, (err: Error) => void][] = [];
+    sessionPriv.$$extraDataTypeManagerToResolve = newPendingList;
 
     return await new Promise<ExtraDataTypeManager>((_resolve, _reject) => {
-        sessionPriv.$$extraDataTypeManagerToResolve!.push([_resolve, _reject]);
+        newPendingList.push([_resolve, _reject]);
         (async () => {
             try {
                 strategy = getStrategy(session, strategy);
@@ -124,16 +123,14 @@ export async function getExtraDataTypeManager(session: IBasicSessionAsync2, stra
                 const dataTypeManager = await extractDataTypeManagerPrivate(sessionToUse, strategy);
                 // note: reconnection will call invalidateExtraDataTypeManager
                 // if the session is recreated
-                const tmp = sessionPriv.$$extraDataTypeManagerToResolve!;
                 sessionPriv.$$extraDataTypeManagerToResolve = undefined;
-                for (const [resolve] of tmp) {
+                for (const [resolve] of newPendingList) {
                     resolve(dataTypeManager);
                 }
                 sessionPriv.$$extraDataTypeManager = dataTypeManager;
             } catch (err) {
-                const tmp = sessionPriv.$$extraDataTypeManagerToResolve!;
                 sessionPriv.$$extraDataTypeManagerToResolve = undefined;
-                for (const [_resolve, reject] of tmp) {
+                for (const [_resolve, reject] of newPendingList) {
                     reject(err as Error);
                 }
             }

package/source/index.ts

@@ -9,10 +9,10 @@
  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  * the Software, and to permit persons to whom the Software is furnished to do so,
  * subject to the following conditions:
- * 
+ *
  *   The above copyright notice and this permission notice shall be included in all
  *   copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
@@ -23,13 +23,13 @@
 /**
  * @module node-opcua-client-dynamic-extension-object
  */
-export * from "./populate_data_type_manager";
+
+export * from "./convert_data_type_definition_to_structuretype_schema";
+export * from "./convert_structuretype_schema_to_structure_definition";
 export * from "./extra_data_type_manager";
-export * from "./resolve_dynamic_extension_object";
-export * from "./promote_opaque_structure";
 export * from "./get_extension_object_constructor";
 export * from "./get_extra_data_type_manager";
-export * from "./resolve_dynamic_extension_object";
-export * from "./convert_data_type_definition_to_structuretype_schema";
-export * from "./convert_structuretype_schema_to_structure_definition";
+export * from "./populate_data_type_manager";
+export * from "./promote_opaque_structure";
 export * from "./promote_opaque_structure_in_notification_data";
+export * from "./resolve_dynamic_extension_object";

package/source/populate_data_type_manager.ts

@@ -1,36 +1,26 @@
+import { DataTypeIds, ObjectIds, VariableIds, VariableTypeIds } from "node-opcua-constants";
 import { AttributeIds, BrowseDirection, NodeClassMask, ResultMask } from "node-opcua-data-model";
+import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
+import { DataTypeFactory } from "node-opcua-factory";
 import { resolveNodeId } from "node-opcua-nodeid";
-import {
-    IBasicSessionAsync2,
-    browseAll,
-    readNamespaceArray
-} from "node-opcua-pseudo-session";
-import { DataTypeIds, ObjectIds, VariableIds, VariableTypeIds } from "node-opcua-constants";
-import { DataType } from "node-opcua-variant";
-import { ReferenceDescription } from "node-opcua-types";
+import { type IBasicSessionAsync2, readNamespaceArray } from "node-opcua-pseudo-session";
 import { makeBrowsePath } from "node-opcua-service-translate-browse-path";
 //
-import { ExtraDataTypeManager } from "./extra_data_type_manager";
+import type { ExtraDataTypeManager } from "./extra_data_type_manager";
 import { populateDataTypeManager103 } from "./private/populate_data_type_manager_103";
 import { populateDataTypeManager104 } from "./private/populate_data_type_manager_104";
-import { DataTypeFactory } from "node-opcua-factory";
-import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
-
 
 const doDebug = checkDebugFlag("populateDataTypeManager");
 const debugLog = make_debugLog("populateDataTypeManager");
 
 const ComplexTypes2017 = "http://opcfoundation.org/UA-Profile/Server/ComplexTypes2017";
 
-export async function serverImplementsDataTypeDefinition(
-    session: IBasicSessionAsync2
-): Promise<boolean> {
-
+export async function serverImplementsDataTypeDefinition(session: IBasicSessionAsync2): Promise<boolean> {
     const dataValueServerCapabilities = await session.read({
         nodeId: resolveNodeId(VariableIds.Server_ServerCapabilities_ServerProfileArray),
         attributeId: AttributeIds.Value
     });
-    const serverCapabilities = dataValueServerCapabilities.value?.value as string[] ?? [];
+    const serverCapabilities = (dataValueServerCapabilities.value?.value as string[]) ?? [];
 
     if (serverCapabilities.indexOf(ComplexTypes2017) >= 0) {
         doDebug && debugLog("server implements ComplexTypes2017");
@@ -76,7 +66,7 @@ export async function serverImplementsDataTypeDefinition(
     });
 
     const references = browseResult2.references || [];
-    const customDataType = references.find(r => r.nodeId.namespace !== 0);
+    const customDataType = references.find((r) => r.nodeId.namespace !== 0);
     if (customDataType) {
         const dv = await session.read({ nodeId: customDataType.nodeId, attributeId: AttributeIds.DataTypeDefinition });
         if (dv.statusCode.isGood()) {
@@ -84,7 +74,7 @@ export async function serverImplementsDataTypeDefinition(
             return true;
         }
     } else {
-        const standardDataType = references.find(r => r.nodeId.namespace == 0);
+        const standardDataType = references.find((r) => r.nodeId.namespace === 0);
         if (standardDataType) {
             const dv = await session.read({ nodeId: standardDataType.nodeId, attributeId: AttributeIds.DataTypeDefinition });
             if (dv.statusCode.isGood()) {
@@ -103,7 +93,7 @@ export async function serverImplementsDataTypeDefinition(
         referenceTypeId: resolveNodeId("HasSubtype"),
         resultMask: 63
     });
-    const customDataType2 = (browseResult3.references || []).find(r => r.nodeId.namespace !== 0);
+    const customDataType2 = (browseResult3.references || []).find((r) => r.nodeId.namespace !== 0);
     if (customDataType2) {
         const dv = await session.read({ nodeId: customDataType2.nodeId, attributeId: AttributeIds.DataTypeDefinition });
         if (dv.statusCode.isGood()) {
@@ -122,7 +112,7 @@ export enum DataTypeExtractStrategy {
     Force104 = 2,
     Both = 3,
     Lazy = 4
-};
+}
 
 export async function populateDataTypeManager(
     session: IBasicSessionAsync2,
@@ -131,7 +121,6 @@ export async function populateDataTypeManager(
 ): Promise<void> {
     dataTypeManager.setSession(session);
 
-
     if (strategy === DataTypeExtractStrategy.Lazy) {
         doDebug && debugLog("populateDataTypeManager: Lazy mode");
         const force104 = await serverImplementsDataTypeDefinition(session);
@@ -165,17 +154,20 @@ export async function populateDataTypeManager(
             await populateDataTypeManager104(session, dataTypeManager);
             return;
         }
-        doDebug && debugLog("populateDataTypeManager: Auto mode - server does not implement 1.04 dictionary - we will be 103 eager and 104 eager");
+        doDebug &&
+            debugLog(
+                "populateDataTypeManager: Auto mode - server does not implement 1.04 dictionary - we will be 103 eager and 104 eager"
+            );
         // old way for 1.03 and early 1.04 prototype
         await populateDataTypeManager103(session, dataTypeManager);
         await populateDataTypeManager104(session, dataTypeManager);
         return;
     }
-    if (strategy == DataTypeExtractStrategy.Force103 || strategy == DataTypeExtractStrategy.Both) {
+    if (strategy === DataTypeExtractStrategy.Force103 || strategy === DataTypeExtractStrategy.Both) {
         doDebug && debugLog("populateDataTypeManager: Force103 mode - we will be 103 eager");
         await populateDataTypeManager103(session, dataTypeManager);
     }
-    if (strategy == DataTypeExtractStrategy.Force104 || strategy == DataTypeExtractStrategy.Both) {
+    if (strategy === DataTypeExtractStrategy.Force104 || strategy === DataTypeExtractStrategy.Both) {
         doDebug && debugLog("populateDataTypeManager: Force104 mode - we will be 104 eager");
         await populateDataTypeManager104(session, dataTypeManager);
     }

package/source/private/find_encodings.ts

@@ -1,7 +1,7 @@
 import { BrowseDirection, makeNodeClassMask, makeResultMask } from "node-opcua-data-model";
 import { NodeId, resolveNodeId } from "node-opcua-nodeid";
-import { BrowseDescriptionLike, browseAll, ISessionForBrowseAll } from "node-opcua-pseudo-session";
-import { DataTypeAndEncodingId } from "node-opcua-schemas";
+import { type BrowseDescriptionLike, browseAll, type ISessionForBrowseAll } from "node-opcua-pseudo-session";
+import type { DataTypeAndEncodingId } from "node-opcua-schemas";
 
 export async function _findEncodings(session: ISessionForBrowseAll, dataTypeNodeId: NodeId): Promise<DataTypeAndEncodingId> {
     const nodeToBrowse: BrowseDescriptionLike = {