node-opcua-address-space 2.178.0 → 2.179.0

package/source/loader/parsers/extension_object_parser.ts

@@ -2,24 +2,27 @@ import assert from "node:assert";
 import type { IAddressSpace } from "node-opcua-address-space-base";
 import { coerceInt64 } from "node-opcua-basic-types";
 import { Range } from "node-opcua-data-access";
-import { coerceLocalizedText, LocalizedText, type LocalizedTextOptions } from "node-opcua-data-model";
+import { coerceLocalizedText, coerceLocalizedTextStrict, LocalizedText, type LocalizedTextOptions } from "node-opcua-data-model";
 import { make_debugLog } from "node-opcua-debug";
 import { ExtensionObject } from "node-opcua-extension-object";
 import { NodeId, resolveNodeId } from "node-opcua-nodeid";
 import { Argument, EnumValueType, EUInformation, type EUInformationOptions } from "node-opcua-types";
-import { InternalFragmentClonerReaderState, type ParserLike, type ReaderStateParserLike } from "node-opcua-xml2json";
+import {
+    InternalFragmentClonerReaderState,
+    type IReaderState,
+    type ParserLike,
+    type ReaderStateParserLike,
+    type Xml2Json,
+    type XmlAttributes
+} from "node-opcua-xml2json";
 import { decodeXmlExtensionObject } from "../decode_xml_extension_object";
 import { localizedText_parser } from "./localized_text_parser";
 
 const debugLog = make_debugLog("ExtensionObjectParser");
 const errorLog = make_debugLog("ExtensionObjectParser");
-const _doDebug = false;
+const doDebug = false;
 export type Task = (addressSpace: IAddressSpace) => Promise<void>;
 
-interface PostExtensionObjectData {
-    postponedExtensionObject: ExtensionObject | null;
-}
-
 // #region Argument parser
 type ArgumentParser = ParserLike & { argument: Argument };
 type ArgumentParserL2 = { parent: ArgumentParser } & { text: string };
@@ -61,11 +64,11 @@ const makeArgumentParser = (_translateNodeId: (nodeId: string) => NodeId) => ({
             Description: {
                 ...localizedText_parser.LocalizedText,
                 finish(this: ArgumentParserL2L) {
-                    this.parent.argument.description = coerceLocalizedText({ ...this.localizedText })!;
+                    this.parent.argument.description = coerceLocalizedTextStrict({ ...this.localizedText });
                 }
             }
         },
-        finish(this: any) {
+        finish(this: ArgumentParser) {
             // xx this.argument = new Argument(this.argument);
         }
     }
@@ -102,14 +105,14 @@ const Range_parser = {
 
 type EUInformationParser = ReaderStateParserLike & {
     euInformation: EUInformationOptions;
-    parser: any;
+    parser: ParserLike;
 };
 type EUInformationParserLevel2 = { parent: EUInformationParser } & { text: string };
 type EUInformationParserLevel2L = { parent: EUInformationParser } & { localizedText: LocalizedTextOptions };
 
 const EUInformation_parser: ParserLike = {
-    EUInformation: <EUInformationParser>{
-        init(this: EUInformationParser, _name, _attrs, _parent, _engine) {
+    EUInformation: <EUInformationParser>(<unknown>{
+        init(this: EUInformationParser, _name: string, _attrs: XmlAttributes, _parent: IReaderState, _engine: Xml2Json) {
             this.euInformation = new EUInformation({});
         },
         parser: {
@@ -141,7 +144,7 @@ const EUInformation_parser: ParserLike = {
         finish(this: EUInformationParser) {
             this.euInformation = new EUInformation(this.euInformation);
         }
-    }
+    })
 };
 // #endregion
 
@@ -208,11 +211,11 @@ export interface ExtensionObjectTypeIdIdentifierParser {
 export interface ExtensionObjectParserInner {
     typeDefinitionId: NodeId;
 }
-type ExtensionObjectParser = ExtensionObjectParserInner & any;
+type ExtensionObjectParser = ExtensionObjectParserInner & ReaderStateParserLike & { parent?: unknown };
 export interface ExtensionObjectBodyParser {
     parent: ExtensionObjectParser;
     _cloneFragment: InternalFragmentClonerReaderState;
-    engine: any;
+    engine: Xml2Json;
     parser: {
         Argument: ArgumentParser;
         EUInformation: EUInformationParser;
@@ -236,7 +239,7 @@ export function makeExtensionObjectParser<T>(
     setExtensionObjectPojo: (typeDefinition: NodeId, xmlData: string, data: T) => void
 ): ParserLike {
     return {
-        ExtensionObject: <ExtensionObjectParser>{
+        ExtensionObject: <ExtensionObjectParser>(<unknown>{
             init(this: ExtensionObjectParser) {
                 this.typeDefinitionId = NodeId.nullNodeId;
             },
@@ -261,7 +264,7 @@ export function makeExtensionObjectParser<T>(
                         EnumValueType: enumValueType_parser.EnumValueType,
                         Range: Range_parser.Range
                     },
-                    startElement(this: ExtensionObjectBodyParser, elementName: string, attrs: any) {
+                    startElement(this: ExtensionObjectBodyParser, elementName: string, attrs: XmlAttributes) {
                         if (!Object.hasOwn(this.parser, elementName)) {
                             // treat it as a opaque XML bloc for the time being
                             // until we find the definition of this object, so we know how to interpret the fields
@@ -315,22 +318,25 @@ export function makeExtensionObjectParser<T>(
                                     // the XML file is probably not exposing standard UA extension object correctly.
                                     // this has been seen in some generated xml files using the dataType nodeId instead of the default encoding
                                     // nodeid
-                                    errorLog(
-                                        "[NODE-OPCUA-E12] standard OPCUA Extension object from (namespace=0) has a invalid TypeId",
-                                        typeDefinitionId.toString()
-                                    );
+                                    // c8 ignore next
+                                    doDebug &&
+                                        errorLog(
+                                            "[NODE-OPCUA-E12] standard OPCUA Extension object from (namespace=0) has a invalid TypeId",
+                                            typeDefinitionId.toString()
+                                        );
                                     break;
                                 }
-                                const bodyXML = this._cloneFragment?.value;
-                                this._cloneFragment!.value = null;
+                                const bodyXML = this._cloneFragment.value;
+                                this._cloneFragment.value = null;
 
                                 // the "Default Xml" encoding  nodeId
                                 const xmlEncodingNodeId = typeDefinitionId;
                                 if (typeDefinitionId.isEmpty()) {
-                                    debugLog(`xmlEncodingNodeId is empty for ${typeDefinitionId.toString()}`);
+                                    // c8 ignore next
+                                    doDebug && debugLog(`xmlEncodingNodeId is empty for ${typeDefinitionId.toString()}`);
                                     break;
                                 }
-                                setExtensionObjectPojo(xmlEncodingNodeId, bodyXML, data);
+                                setExtensionObjectPojo(xmlEncodingNodeId, bodyXML ?? "", data);
                                 break;
                             }
                         }
@@ -340,7 +346,7 @@ export function makeExtensionObjectParser<T>(
             finish(this: ExtensionObjectParser) {
                 /* empty */
             }
-        }
+        })
     };
 }
 
@@ -359,7 +365,10 @@ export function createXMLExtensionObjectDecodingTask(
             capturedXmlBody,
             translateNodeId
         );
-        withDecoded(extensionObject!);
+        if (!extensionObject) {
+            throw new Error("decodeXmlExtensionObject returned null");
+        }
+        withDecoded(extensionObject);
     };
     return task;
 }

package/source/loader/parsers/localized_text_parser.ts

@@ -1,7 +1,7 @@
 import { coerceLocalizedText, type LocalizedText, type LocalizedTextOptions } from "node-opcua-data-model";
 import type { ReaderStateParserLike } from "node-opcua-xml2json";
 
-type LocalizedTextParserLikeL1 = ReaderStateParserLike & {
+export type LocalizedTextParserLikeL1 = ReaderStateParserLike & {
     localizedText: LocalizedTextOptions;
     value: LocalizedText | null;
 };

package/source/loader/parsers/nodeid_parser.ts

@@ -1,13 +1,21 @@
 import { type NodeId, resolveNodeId } from "node-opcua-nodeid";
 
+interface NodeIdParserState {
+    nodeId: string | NodeId;
+}
+interface IdentifierParserState {
+    text: string;
+    parent: NodeIdParserState;
+}
+
 export const makeNodeIdParser = (_translateNodeId: (nodeId: string) => NodeId) => ({
     NodeId: {
-        init(this: any) {
+        init(this: NodeIdParserState) {
             this.nodeId = "";
         },
         parser: {
             Identifier: {
-                finish(this: any) {
+                finish(this: IdentifierParserState) {
                     this.parent.nodeId = _translateNodeId(resolveNodeId(this.text.trim()).toString());
                 }
             }

package/source/loader/parsers/qualified_name_parser.ts

@@ -2,7 +2,7 @@ import { coerceQualifiedName, type QualifiedName, type QualifiedNameOptions } fr
 import { type NodeId, resolveNodeId } from "node-opcua-nodeid";
 import type { ReaderStateParserLike } from "node-opcua-xml2json";
 
-interface QualifiedNameParserL1 extends ReaderStateParserLike {
+export interface QualifiedNameParserL1 extends ReaderStateParserLike {
     value: QualifiedName | null;
     qualifiedName: QualifiedNameOptions;
 }

package/source/loader/parsers/variant_parser.ts

@@ -1,4 +1,4 @@
-import type { IAddressSpace, UAVariable, UAVariableType } from "node-opcua-address-space-base";
+import type { IAddressSpace, UAVariable } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import { coerceBoolean, coerceInt64, coerceUInt64, DataType, type Int64, isValidGuid, type UInt64 } from "node-opcua-basic-types";
 import {
@@ -8,21 +8,22 @@ import {
     NodeClass,
     type QualifiedNameOptions
 } from "node-opcua-data-model";
-import { make_debugLog } from "node-opcua-debug";
+import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
 import type { ExtensionObject } from "node-opcua-extension-object";
 import { type NodeId, type NodeIdLike, resolveNodeId } from "node-opcua-nodeid";
 import { VariantArrayType, type VariantOptions } from "node-opcua-variant";
-import type { ParserLike, ReaderStateParserLike, XmlAttributes } from "node-opcua-xml2json";
+import type { IReaderState, ParserLike, ReaderStateParserLike, Xml2Json, XmlAttributes } from "node-opcua-xml2json";
 import {
     createXMLExtensionObjectDecodingTask,
     makeExtensionObjectInnerParser,
     makeExtensionObjectParser
 } from "./extension_object_parser";
-import { localizedText_parser } from "./localized_text_parser";
+import { type LocalizedTextParserLikeL1, localizedText_parser } from "./localized_text_parser";
 import { makeNodeIdParser } from "./nodeid_parser";
-import { makeQualifiedNameParser } from "./qualified_name_parser";
+import { makeQualifiedNameParser, type QualifiedNameParserL1 } from "./qualified_name_parser";
 
 const debugLog = make_debugLog(__dirname);
+const doDebug = checkDebugFlag(__dirname);
 
 export type Task = (addressSpace2: IAddressSpace) => Promise<void>;
 
@@ -30,10 +31,11 @@ type IBasicReaderStateParserLike<T> = ReaderStateParserLike & {
     value: T | undefined;
     text: string;
 };
-function BasicType_parser<T>(dataType: string, parseFunc: (this: { value: T | undefined }, text: string) => any): ParserLike {
+
+function BasicType_parser<T>(dataType: string, parseFunc: (this: { value: T | undefined }, text: string) => T): ParserLike {
     const _parser: Record<string, ReaderStateParserLike> = {};
     const a = {
-        init(this: IBasicReaderStateParserLike<T>, _name: string, _attrs: XmlAttributes, _parent: any, _endElement: any) {
+        init(this: IBasicReaderStateParserLike<T>, _name: string, _attrs: XmlAttributes, _parent: IReaderState, _engine: Xml2Json) {
             this.value = undefined;
         },
         finish(this: IBasicReaderStateParserLike<T>) {
@@ -44,7 +46,11 @@ function BasicType_parser<T>(dataType: string, parseFunc: (this: { value: T | un
     return _parser as ParserLike;
 }
 
-function ListOf<T>(_setValue: (data: VariantOptions) => void, dataType: string, parseFunc: any) {
+function ListOf<T>(
+    _setValue: (data: VariantOptions) => void,
+    dataType: string,
+    parseFunc: (this: { value: T | undefined }, text: string) => T
+) {
     return {
         init(this: ListOfTParser<T>) {
             this.listData = [];
@@ -55,43 +61,50 @@ function ListOf<T>(_setValue: (data: VariantOptions) => void, dataType: string,
         finish(this: ListOfTParser<T>) {
             _setValue({
                 arrayType: VariantArrayType.Array,
-                dataType: (DataType as any)[dataType],
+                dataType: (DataType as unknown as Record<string, number>)[dataType] as DataType,
                 value: this.listData
             });
         },
         endElement(this: ListOfTParser<T>, _element: string) {
-            this.listData.push(this.parser[dataType].value);
+            this.listData.push(this.parser[dataType].value as T);
         }
     };
 }
 
 interface Parser {
-    parent: Parser | any;
+    parent?: Parser;
+    obj?: { nodeId: NodeId };
+}
+
+interface UAVariableTypeWithVariantValue {
+    value: { value: unknown };
 }
 
 function _installExtensionObjectListInitializationPostTask(
     postTasks2_AssignedExtensionObjectToDataValue: Task[],
     element: ListOfExtensionObjectParser
 ) {
-    let listExtensionObject = element.listExtensionObject;
-    let nodeId = element.parent.parent.obj.nodeId;
-    assert(nodeId, "expecting a nodeid");
+    let listExtensionObject: (ExtensionObject | null)[] | undefined = element.listExtensionObject;
+    let nodeId: NodeId | undefined = element.parent.parent?.obj?.nodeId;
+    if (!nodeId) {
+        throw new Error("expecting a nodeid");
+    }
     const task = async (addressSpace2: IAddressSpace) => {
-        const node = addressSpace2.findNode(nodeId)!;
+        const node = nodeId ? addressSpace2.findNode(nodeId) : null;
         if (!node) {
-            debugLog(`Cannot find node with nodeId ${nodeId}. may be the node was marked as deprecated`);
+            // c8 ignore next
+            doDebug && debugLog(`Cannot find node with nodeId ${nodeId}. may be the node was marked as deprecated`);
         } else if (node.nodeClass === NodeClass.Variable) {
             const v = node as UAVariable;
             assert(v.getBasicDataType() === DataType.ExtensionObject, "expecting an extension object");
             v.bindExtensionObject(listExtensionObject as ExtensionObject[], { createMissingProp: false });
         } else if (node.nodeClass === NodeClass.VariableType) {
             // no need to bind a variable type
-            const v = node as UAVariableType;
-            (v as any) /*fix me*/.value.value = listExtensionObject;
+            (node as unknown as UAVariableTypeWithVariantValue) /*fix me*/.value.value = listExtensionObject;
         }
-        listExtensionObject.slice(0);
-        (listExtensionObject as any) = undefined;
-        (nodeId as any) = undefined;
+        listExtensionObject?.slice(0);
+        listExtensionObject = undefined;
+        nodeId = undefined;
     };
     postTasks2_AssignedExtensionObjectToDataValue.push(task);
 }
@@ -100,15 +113,15 @@ export interface ListOfTParser<T> extends Parser {
     listData: T[];
     parent: Parser;
     parser: {
-        [key: string]: Parser | any;
+        [key: string]: ReaderStateParserLike & { value?: T; nodeId?: NodeId | string };
     };
 }
-function parser2<T>(_setValue: (data: VariantOptions) => void, type: string, p: (a: any) => any): any {
+function parser2(_setValue: (data: VariantOptions) => void, type: string, p: (text: string) => unknown): ReaderStateParserLike {
     return {
-        finish(this: T & { text: string }) {
+        finish(this: { text: string }) {
             _setValue({
                 arrayType: VariantArrayType.Scalar,
-                dataType: (DataType as any)[type],
+                dataType: (DataType as unknown as Record<string, number>)[type] as DataType,
                 value: p(this.text)
             });
         }
@@ -144,7 +157,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
         parser: {
             QualifiedName: {
                 ...makeQualifiedNameParser(translateNodeId).QualifiedName,
-                finish(this: any) {
+                finish(this: QualifiedNameParserL1) {
                     setValue2({
                         dataType: DataType.QualifiedName,
                         value: coerceQualifiedName({ ...this.qualifiedName })
@@ -153,7 +166,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
             },
             LocalizedText: {
                 ...localizedText_parser.LocalizedText,
-                finish(this: any) {
+                finish(this: LocalizedTextParserLikeL1) {
                     setValue2({
                         dataType: DataType.LocalizedText,
                         value: coerceLocalizedText({ ...this.localizedText })
@@ -161,7 +174,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
                 }
             },
             XmlElement: {
-                finish(this: any) {
+                finish(this: { text: string }) {
                     setValue2({
                         dataType: DataType.XmlElement,
                         value: this.text
@@ -169,7 +182,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
                 }
             },
             String: {
-                finish(this: any) {
+                finish(this: { text: string }) {
                     setValue2({
                         dataType: DataType.String,
                         value: this.text
@@ -179,7 +192,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
             Guid: {
                 parser: {
                     String: {
-                        finish(this: any) {
+                        finish(this: { text: string }) {
                             const guid = this.text;
                             if (!isValidGuid(guid)) {
                                 /* ?*/
@@ -196,7 +209,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
             NodeId: {
                 parser: {
                     Identifier: {
-                        finish(this: any) {
+                        finish(this: { text: string }) {
                             const nodeId = this.text;
                             setValue2({
                                 dataType: DataType.NodeId,
@@ -221,10 +234,10 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
             Int64: parser2(setValue2, "Int64", parseInt64),
 
             ByteString: {
-                init(this: any) {
+                init(this: { value: Buffer | null; text: string }) {
                     this.value = null;
                 },
-                finish(this: any) {
+                finish(this: { value: Buffer | null; text: string }) {
                     const base64text = this.text;
                     const byteString = Buffer.from(base64text, "base64");
                     setValue2({
@@ -235,7 +248,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
                 }
             },
             Float: {
-                finish(this: any) {
+                finish(this: { text: string }) {
                     setValue2({
                         dataType: DataType.Float,
                         value: parseFloat(this.text)
@@ -244,7 +257,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
             },
 
             Double: {
-                finish(this: any) {
+                finish(this: { text: string }) {
                     setValue2({
                         dataType: DataType.Double,
                         value: parseFloat(this.text)
@@ -325,7 +338,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
                         });
                     } else {
                         // postpone the creation of the extension object
-                        const listExtensionObject: ExtensionObject[] = this.listExtensionObject as any;
+                        const listExtensionObject: ExtensionObject[] = this.listExtensionObject as ExtensionObject[];
                         setDeferredValue(
                             self,
                             {
@@ -348,7 +361,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
                     ...localizedText_parser
                 },
                 endElement(this: ListOfTParser<QualifiedNameOptions> /*element*/) {
-                    this.listData.push(this.parser.LocalizedText.value);
+                    this.listData.push(this.parser.LocalizedText.value as QualifiedNameOptions);
                 },
                 finish(this: ListOfTParser<QualifiedNameOptions>) {
                     setValue2({
@@ -364,7 +377,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
                 },
                 parser: makeQualifiedNameParser(translateNodeId),
                 endElement(this: ListOfTParser<QualifiedNameOptions> /*element*/) {
-                    this.listData.push(this.parser.QualifiedName.value);
+                    this.listData.push(this.parser.QualifiedName.value as QualifiedNameOptions);
                 },
                 finish(this: ListOfTParser<QualifiedNameOptions>) {
                     setValue2({
@@ -380,7 +393,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
                 },
                 parser: makeNodeIdParser(translateNodeId),
                 endElement(this: ListOfTParser<NodeIdLike>, _elementName: string) {
-                    this.listData.push(this.parser.NodeId.nodeId);
+                    this.listData.push(this.parser.NodeId.nodeId as NodeIdLike);
                 },
                 finish(this: ListOfTParser<NodeIdLike>) {
                     setValue2({
@@ -416,5 +429,5 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
             ListOfXmlElement: ListOf<string>(setValue2, "XmlElement", (value: string) => value)
         }
     };
-    return reader as any as ReaderStateParserLike;
+    return reader as unknown as ReaderStateParserLike;
 }