node-opcua-address-space 2.181.1 → 2.182.0

package/api/loader/nodeset_xml_producer.ts

@@ -11,8 +11,16 @@ import { coerceBoolean, coerceByte, coerceInt32 } from "node-opcua-basic-types";
 import { DataTypeIds } from "node-opcua-constants";
 import { NodeClass, type QualifiedName, stringToQualifiedName } from "node-opcua-data-model";
 import { NodeId, resolveNodeId } from "node-opcua-nodeid";
-import { _definitionParser, ReaderState, type ReaderStateParserLike, Xml2Json, type XmlAttributes } from "node-opcua-xml2json";
 import {
+    _definitionParser,
+    InternalFragmentClonerReaderState,
+    ReaderState,
+    type ReaderStateParserLike,
+    Xml2Json,
+    type XmlAttributes
+} from "node-opcua-xml2json";
+import {
+    type NodesetDataTypeDefinitionRecord,
     type NodesetDefinitionField,
     type NodesetHeaderRecord,
     type NodesetModelRecord,
@@ -46,6 +54,7 @@ interface NodeState {
 export function makeXmlNodesetRecordReader(): XmlNodesetRecordReader {
     let pending: NodesetRecord[] = [];
     let namespaceUris: string[] = [];
+    let extensions: string[] = [];
     const models: NodesetModelRecord[] = [];
     const aliases: Record<string, NodeId> = Object.create(null);
     let headerEmitted = false;
@@ -75,6 +84,7 @@ export function makeXmlNodesetRecordReader(): XmlNodesetRecordReader {
         }
         headerEmitted = true;
         const header: NodesetHeaderRecord = { kind: "header", namespaceUris, models: models.slice(), aliases: { ...aliases } };
+        if (extensions.length > 0) header.extensions = extensions.slice();
         pending.push(header);
     }
 
@@ -147,9 +157,28 @@ export function makeXmlNodesetRecordReader(): XmlNodesetRecordReader {
             (this.parent as NodeState).obj.description = this.text;
         }
     };
+    // a node may declare several <Category> elements and at most one <Documentation>. Neither is
+    // part of the information model and neither reaches the address space, but both are content a
+    // working group wrote into the document, and a form that drops them is not the same document
+    const category_parser = {
+        finish(this: State) {
+            const obj = (this.parent as NodeState).obj;
+            if (!obj.category) {
+                obj.category = [];
+            }
+            obj.category.push(this.text);
+        }
+    };
+    const documentation_parser = {
+        finish(this: State) {
+            (this.parent as NodeState).obj.documentation = this.text;
+        }
+    };
     const common_parser = {
         DisplayName: displayName_parser,
         Description: description_parser,
+        Category: category_parser,
+        Documentation: documentation_parser,
         References: references_parser,
         RolePermissions: role_permissions_parser
     };
@@ -203,6 +232,8 @@ export function makeXmlNodesetRecordReader(): XmlNodesetRecordReader {
             if (attrs.SymbolicName !== undefined) this.obj.symbolicName = attrs.SymbolicName;
             this.definitionFields = [];
             this.definitionName = undefined;
+            this.definitionIsUnion = undefined;
+            this.definitionIsOptionSet = undefined;
         },
         finish(this: State) {
             const fields = this.definitionFields as Array<Record<string, unknown>>;
@@ -216,7 +247,11 @@ export function makeXmlNodesetRecordReader(): XmlNodesetRecordReader {
                     if (field.allowSubTypes) field.allowSubTypes = coerceBoolean(field.allowSubTypes as string | boolean);
                     return field as unknown as NodesetDefinitionField;
                 });
-                (this.obj as NodesetNodeRecord).definition = { name: this.definitionName, fields: converted };
+                const definition: NodesetDataTypeDefinitionRecord = { name: this.definitionName, fields: converted };
+                // the <Definition> flags, which the definition parser leaves on this state
+                if (this.definitionIsUnion) definition.isUnion = true;
+                if (this.definitionIsOptionSet) definition.isOptionSet = true;
+                (this.obj as NodesetNodeRecord).definition = definition;
             }
             pending.push(this.obj);
         },
@@ -269,6 +304,8 @@ export function makeXmlNodesetRecordReader(): XmlNodesetRecordReader {
         ...emit,
         parser: {
             DisplayName: displayName_parser,
+            Category: category_parser,
+            Documentation: documentation_parser,
             References: references_parser,
             RolePermissions: role_permissions_parser
         }
@@ -312,9 +349,31 @@ export function makeXmlNodesetRecordReader(): XmlNodesetRecordReader {
         }
     });
 
+    const state_Extensions = {
+        init() {
+            extensions = [];
+        },
+        parser: {
+            Extension: {
+                startElement(this: State, elementName: string, attrs: XmlAttributes, qualifiedName?: string) {
+                    // whatever a tool put in here is foreign XML: clone the element verbatim, under
+                    // the name the document gave it, prefix included
+                    this._cloneFragment = new InternalFragmentClonerReaderState();
+                    this.engine?._promote(this._cloneFragment, this.engine?.currentLevel, qualifiedName ?? elementName, attrs);
+                },
+                finish(this: State) {
+                    const xml = this._cloneFragment?.value;
+                    if (xml) extensions.push(xml);
+                    if (this._cloneFragment) this._cloneFragment.value = null;
+                }
+            }
+        }
+    };
+
     const state_0: ReaderStateParserLike = {
         parser: {
             Aliases: { parser: { Alias: state_Alias } },
+            Extensions: state_Extensions,
             NamespaceUris: {
                 init() {
                     namespaceUris = [];

package/api/loader/parsers/variant_parser.ts

@@ -83,6 +83,8 @@ function parser2(_setValue: (data: VariantOptions) => void, type: string, p: (te
     };
 }
 const parseUInt64 = (str: string): UInt64 => coerceUInt64(str);
+/** an invalid date is left as one rather than as null: the document said something, and said it badly */
+const parseDateTime = (str: string): Date => new Date(str);
 const parseInt64 = (str: string): Int64 => coerceInt64(str);
 
 /** an element of an ExtensionObject array as the reader leaves it: decoded, or waiting as its XML */
@@ -211,6 +213,11 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
             UInt64: parser2(setValue2, "UInt64", parseUInt64),
             Int64: parser2(setValue2, "Int64", parseInt64),
 
+            // a NodeSet2 <Value> may hold a DateTime, and until this was here the reader silently
+            // gave back no value at all for one -- the variable then looked to every consumer like
+            // a variable the document had never valued
+            DateTime: parser2(setValue2, "DateTime", parseDateTime),
+
             ByteString: {
                 init(this: { value: Buffer | null; text: string }) {
                     this.value = null;
@@ -354,6 +361,8 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
 
             ListOfUInt8: ListOf<number>(setValue2, "UInt8", parseInt),
 
+            ListOfDateTime: ListOf<Date>(setValue2, "DateTime", parseDateTime),
+
             ListOfString: ListOf<string>(setValue2, "String", (value: string) => value),
 
             ListOfXmlElement: ListOf<string>(setValue2, "XmlElement", (value: string) => value)