node-opcua-address-space 2.169.0 → 2.172.0

package/source/loader/ensure_datatype_extracted.ts

@@ -1,4 +1,4 @@
-import { IAddressSpace, INamespace, UADataType } from "node-opcua-address-space-base";
+import type { IAddressSpace, INamespace, UADataType } from "node-opcua-address-space-base";
 import {
     convertStructureTypeSchemaToStructureDefinition,
     DataTypeExtractStrategy,
@@ -7,11 +7,14 @@ import {
 } from "node-opcua-client-dynamic-extension-object";
 import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
 import { DataTypeFactory, getStandardDataTypeFactory } from "node-opcua-factory";
-import { CallbackT } from "node-opcua-status-code";
-import { StructureField } from "node-opcua-types";
-import { AddressSpacePrivate } from "../../src/address_space_private";
+import type { CallbackT } from "node-opcua-status-code";
+import type { StructureField } from "node-opcua-types";
+import type { AddressSpacePrivate } from "../../src/address_space_private";
+import {
+    constructNamespaceDependency,
+    constructNamespacePriorityTable
+} from "../../src/nodeset_tools/construct_namespace_dependency";
 import { PseudoSession } from "../pseudo_session";
-import { constructNamespaceDependency, constructNamespacePriorityTable } from "../../src/nodeset_tools/construct_namespace_dependency";
 
 const debugLog = make_debugLog(__filename);
 const doDebug = checkDebugFlag(__filename);
@@ -20,11 +23,7 @@ interface UADataTypePriv extends UADataType {
     $partialDefinition?: StructureField[];
 }
 
-function fixDefinition103(
-    addressSpace: IAddressSpace,
-    namespaceArray: string[],
-    dataTypeManager: ExtraDataTypeManager
-): void {
+function fixDefinition103(addressSpace: IAddressSpace, namespaceArray: string[], dataTypeManager: ExtraDataTypeManager): void {
     // fix datatype _getDefinition();
     for (let namespaceIndex = 1; namespaceIndex < namespaceArray.length; namespaceIndex++) {
         const df = dataTypeManager.getDataTypeFactory(namespaceIndex);
@@ -36,11 +35,11 @@ function fixDefinition103(
             if (!dataType) {
                 continue;
             }
-            if (dataType.$partialDefinition && dataType.$partialDefinition.length) {
+            if (dataType.$partialDefinition?.length) {
                 continue;
             }
             // debugLog(" Exploration", dataType.browseName.toString());
-            if (!dataType.$partialDefinition || (dataType.$partialDefinition.length === 0 && s.schema.fields!.length > 0)) {
+            if (!dataType.$partialDefinition || (dataType.$partialDefinition.length === 0 && s.schema.fields?.length > 0)) {
                 const sd = convertStructureTypeSchemaToStructureDefinition(s.schema);
                 dataType.$partialDefinition = sd.fields || undefined;
             }
@@ -48,10 +47,7 @@ function fixDefinition103(
     }
 }
 
-export async function ensureDatatypeExtracted(
-    addressSpace: IAddressSpace
-): Promise<ExtraDataTypeManager> {
-
+export async function ensureDatatypeExtracted(addressSpace: IAddressSpace): Promise<ExtraDataTypeManager> {
     const addressSpacePriv: any = addressSpace as AddressSpacePrivate;
 
     if (!addressSpacePriv.$$extraDataTypeManager) {
@@ -70,7 +66,6 @@ export async function ensureDatatypeExtracted(
         const priorityTable = constructNamespacePriorityTable(addressSpace).priorityTable;
 
         for (let namespaceIndex = 1; namespaceIndex < namespaceArray.length; namespaceIndex++) {
-
             const namespace = addressSpace.getNamespace(namespaceIndex);
 
             if (doDebug) {
@@ -88,13 +83,13 @@ export async function ensureDatatypeExtracted(
                         debugLog("namespace = ", namespace.namespaceUri);
                         debugLog("priorityTable", priorityTable);
                         debugLog(dependency.map((ns) => `${ns.index} ${ns.namespaceUri}`).join("\n"));
-                        throw new Error("Cannot find factory for namespace " + ns.namespaceUri);
+                        throw new Error(`Cannot find factory for namespace ${ns.namespaceUri}`);
                     }
                     return df;
                 });
                 //            getStandardDataTypeFactory()
 
-                const dataTypeFactory1 = new DataTypeFactory(dependFactories);
+                const _dataTypeFactory1 = new DataTypeFactory(dependFactories);
             }
             const dataTypeFactory1 = new DataTypeFactory([...factories]);
             dataTypeFactory1.targetNamespace = namespace.namespaceUri;

package/source/loader/generateAddressSpaceRaw.ts

@@ -1,11 +1,11 @@
-import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
-import { CallbackT } from "node-opcua-status-code";
-import { IAddressSpace, RequiredModel } from "node-opcua-address-space-base";
-import { ReaderStateParser, ReaderStateParserLike, Xml2Json } from "node-opcua-xml2json";
+import type { IAddressSpace, RequiredModel } from "node-opcua-address-space-base";
 import { getMinOPCUADate } from "node-opcua-date-time";
+import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
+import type { CallbackT } from "node-opcua-status-code";
+import { type ReaderStateParser, type ReaderStateParserLike, Xml2Json } from "node-opcua-xml2json";
+import type { NamespacePrivate } from "../../src/namespace_private";
 import { adjustNamespaceArray } from "../../src/nodeset_tools/adjust_namespace_array";
-import { NodeSetLoaderOptions } from "../interfaces/nodeset_loader_options";
-import { NamespacePrivate } from "../../src/namespace_private";
+import type { NodeSetLoaderOptions } from "../interfaces/nodeset_loader_options";
 import { NodeSetLoader } from "./load_nodeset2";
 
 const doDebug = checkDebugFlag(__filename);
@@ -24,7 +24,7 @@ async function parseDependencies(xmlData: string): Promise<NodesetInfo> {
     const namespaceUris: string[] = [];
 
     const models: Model[] = [];
-    let currentModel: Model | undefined = undefined;
+    let currentModel: Model | undefined;
     const state0: ReaderStateParser = {
         parser: {
             UANodeSet: {
@@ -32,7 +32,7 @@ async function parseDependencies(xmlData: string): Promise<NodesetInfo> {
                     NamespaceUris: {
                         parser: {
                             Uri: <ReaderStateParserLike & { text: string }>{
-                                finish(this: ReaderStateParserLike & {text: string}) {
+                                finish(this: ReaderStateParserLike & { text: string }) {
                                     namespaceUris.push(this.text);
                                 }
                             }
@@ -41,7 +41,7 @@ async function parseDependencies(xmlData: string): Promise<NodesetInfo> {
                     Models: {
                         parser: {
                             Model: {
-                                init(elementName: string, attrs: any) {
+                                init(_elementName: string, attrs: any) {
                                     const modelUri = attrs.ModelUri;
                                     const version = attrs.Version;
                                     const publicationDate = new Date(Date.parse(attrs.PublicationDate));
@@ -56,7 +56,7 @@ async function parseDependencies(xmlData: string): Promise<NodesetInfo> {
                                 },
                                 parser: {
                                     RequiredModel: {
-                                        init(elementName: string, attrs: any) {
+                                        init(_elementName: string, attrs: any) {
                                             const modelUri = attrs.ModelUri;
                                             const version = attrs.Version;
                                             const publicationDate = new Date(Date.parse(attrs.PublicationDate));
@@ -146,7 +146,7 @@ export function findOrder(nodesetDescs: NodesetDesc[]): number[] {
         for (const requiredModel of model.requiredModel) {
             const requiredModelIndex = findNodesetIndex(requiredModel.modelUri);
             if (requiredModelIndex === -1) {
-                throw new Error("Cannot find namespace for " + requiredModel.modelUri);
+                throw new Error(`Cannot find namespace for ${requiredModel.modelUri}`);
             }
             const nd = nodesetDescs[requiredModelIndex];
             for (const n of nd.namespaceModel.models) {
@@ -154,7 +154,7 @@ export function findOrder(nodesetDescs: NodesetDesc[]): number[] {
             }
         }
         const nodesetIndex = findNodesetIndex(model.modelUri);
-        const alreadyIn = order.findIndex((x) => x === nodesetIndex) !== -1;
+        const alreadyIn = order.indexOf(nodesetIndex) !== -1;
         if (!alreadyIn) order.push(nodesetIndex);
     };
     const visit2 = (nodesetDesc: NodesetDesc) => {
@@ -197,7 +197,6 @@ export async function generateAddressSpaceRaw(
         }
     }
 
-
     for (let index = 0; index < order.length; index++) {
         const nodesetIndex = order[index];
         const nodeset = nodesetDesc[nodesetIndex];

package/source/loader/load_nodeset2.ts

@@ -221,8 +221,8 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
         if (!namespace) {
             throw new Error(
                 "cannot find namespace for " +
-                namespaceUri +
-                "\nplease make sure to initialize your address space with the corresponding nodeset files"
+                    namespaceUri +
+                    "\nplease make sure to initialize your address space with the corresponding nodeset files"
             );
         }
         foundNamespaceMap.set(namespaceUri, namespace);
@@ -1038,7 +1038,7 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
         doDebug &&
             debugLog(
                 chalk.bgGreenBright("Performing post loading tasks -------------------------------------------") +
-                chalk.green("DONE")
+                    chalk.green("DONE")
             );
 
         async function performPostLoadingTasks(tasks: Task[]): Promise<void> {

package/source/loader/make_xml_extension_object_parser.ts

@@ -1,11 +1,29 @@
-import { IAddressSpace } from "node-opcua-address-space-base";
-import { Byte, coerceInt64, coerceUInt64, Int16, Int32, Int64, SByte, UAString, UInt16, UInt32, UInt64 } from "node-opcua-basic-types";
+import type { IAddressSpace } from "node-opcua-address-space-base";
+import {
+    type Byte,
+    coerceInt64,
+    coerceUInt64,
+    type Int16,
+    type Int32,
+    type Int64,
+    type SByte,
+    type UInt16,
+    type UInt32,
+    type UInt64
+} from "node-opcua-basic-types";
 import { make_debugLog, make_warningLog } from "node-opcua-debug";
-import { coerceNodeId, INodeId, NodeId, NodeIdType } from "node-opcua-nodeid";
+import { coerceNodeId, type INodeId, type NodeId, NodeIdType } from "node-opcua-nodeid";
 import { EnumDefinition, StructureDefinition } from "node-opcua-types";
 import { lowerFirstLetter } from "node-opcua-utils";
-import { DataType, VariantOptions, Variant } from "node-opcua-variant";
-import { ReaderState, ReaderStateParserLike, ParserLike, XmlAttributes, IReaderState, Xml2Json, ReaderStateParser } from "node-opcua-xml2json";
+import { DataType, Variant, type VariantOptions } from "node-opcua-variant";
+import {
+    type IReaderState,
+    ReaderState,
+    type ReaderStateParser,
+    type ReaderStateParserLike,
+    type Xml2Json,
+    type XmlAttributes
+} from "node-opcua-xml2json";
 import { localizedText_parser } from "./parsers/localized_text_parser";
 import { makeQualifiedNameParser } from "./parsers/qualified_name_parser";
 import { makeVariantReader } from "./parsers/variant_parser";
@@ -50,12 +68,12 @@ const partials = {
 
     Boolean: <Parser<boolean>>{
         finish(this: Parser<boolean>) {
-            this.value = this.text.toLowerCase() === "true" ? true : false;
+            this.value = this.text.toLowerCase() === "true";
         }
     },
 
     ByteString: <Parser<Buffer>>{
-        init(this: Parser<Buffer>, name: string, attrs: XmlAttributes, parent: IReaderState, engine: Xml2Json) {
+        init(this: Parser<Buffer>, _name: string, _attrs: XmlAttributes, _parent: IReaderState, _engine: Xml2Json) {
             this.value = null;
         },
         finish(this: Parser<Buffer>) {
@@ -65,56 +83,56 @@ const partials = {
         }
     },
 
-    Float: <Parser<number>> {
+    Float: <Parser<number>>{
         finish(this: Parser<number>) {
             this.value = parseFloat(this.text);
         }
     },
 
-    Double: <Parser<number>> {
+    Double: <Parser<number>>{
         finish(this: Parser<number>) {
             this.value = parseFloat(this.text);
         }
     },
-    Byte: <Parser<Byte>>  {
+    Byte: <Parser<Byte>>{
         finish(this: Parser<Byte>) {
             this.value = clamp(parseInt(this.text, 10), 0, 255);
         }
     },
-    SByte: <Parser<SByte>> {
+    SByte: <Parser<SByte>>{
         finish(this: Parser<SByte>) {
             this.value = clamp(parseInt(this.text, 10), -128, 127);
         }
     },
-    Int8: <Parser<SByte>>  {
+    Int8: <Parser<SByte>>{
         finish(this: Parser<SByte>) {
             this.value = clamp(parseInt(this.text, 10), -128, 127);
         }
     },
 
-    Int16: <Parser<Int16>> {
+    Int16: <Parser<Int16>>{
         finish(this: Parser<Int16>) {
             this.value = clamp(parseInt(this.text, 10), -32768, 32767);
         }
     },
-    Int32: <Parser<Int32>>  {
+    Int32: <Parser<Int32>>{
         finish(this: Parser<Int32>) {
             this.value = clamp(parseInt(this.text, 10), -2147483648, 2147483647);
         }
     },
-    Int64: <Parser<Int64>>  {
+    Int64: <Parser<Int64>>{
         finish(this: Parser<Int64>) {
             this.value = coerceInt64(parseInt(this.text, 10));
         }
     },
 
-    UInt8: <Parser<Byte>>  {
+    UInt8: <Parser<Byte>>{
         finish(this: Parser<Byte>) {
             this.value = clamp(parseInt(this.text, 10), 0, 255);
         }
     },
 
-    UInt16: <Parser<UInt16>>   {
+    UInt16: <Parser<UInt16>>{
         finish(this: Parser<UInt16>) {
             this.value = clamp(parseInt(this.text, 10), 0, 65535);
         }
@@ -146,7 +164,7 @@ const partials = {
         }
     },
 
-    NodeId: <Parser<NodeId>> {
+    NodeId: <Parser<NodeId>>{
         finish(this: Parser<NodeId>) {
             // to do check Local or GMT
             this.value = coerceNodeId(this.text);
@@ -176,13 +194,13 @@ function _clone(a: any): any {
     if (typeof a === "string" || typeof a === "number" || typeof a === "boolean") {
         return a;
     }
-    if (a instanceof Buffer) {
+    if (Buffer.isBuffer(a)) {
         return Buffer.from(a);
     }
     if (a instanceof Date) {
         return new Date(a);
     }
-    if (a instanceof Array) {
+    if (Array.isArray(a)) {
         return a.map((x) => _clone(x));
     }
     return { ...a };
@@ -197,14 +215,10 @@ function _makeTypeReader(
     const n = dataTypeNodeId1 as INodeId;
     if (n.identifierType === NodeIdType.NUMERIC && n.namespace === 0 && n.value === 0) {
         // a generic Extension Object
-        return { name: "Variant", reader: partials["Variant"] };
+        return { name: "Variant", reader: partials.Variant };
     }
 
-    if (
-        n.namespace === 0 &&
-        n.identifierType === NodeIdType.NUMERIC &&
-        n.value < DataType.ExtensionObject
-    ) {
+    if (n.namespace === 0 && n.identifierType === NodeIdType.NUMERIC && n.value < DataType.ExtensionObject) {
         const name = DataType[n.value as number] as string;
         const reader = partials[name as keyof typeof partials] as ReaderStateParser;
         return { name, reader };
@@ -236,14 +250,14 @@ function _makeTypeReader(
             const fieldTypename = typeReader.name;
             // c8 ignore next
             if (!fieldParser) {
-                throw new Error(" Cannot find reader for dataType " + field.dataType + " fieldTypename=" + fieldTypename);
+                throw new Error(` Cannot find reader for dataType ${field.dataType} fieldTypename=${fieldTypename}`);
             }
 
             if (field.valueRank === undefined || field.valueRank === -1) {
                 // scalar
                 const parser = fieldParser;
                 if (!parser) {
-                    throw new Error("??? " + field.dataType + "  " + field.name);
+                    throw new Error(`??? ${field.dataType}  ${field.name}`);
                 }
 
                 reader.parser![field.name!] = {
@@ -254,7 +268,7 @@ function _makeTypeReader(
                         if (fieldParser.finish) {
                             fieldParser.finish.call(this);
                         } else {
-                            debugLog("xxx check " + fieldTypename);
+                            debugLog(`xxx check ${fieldTypename}`);
                         }
                         this.parent.value = this.parent.value || Object.create(null);
                         this.parent.value[elName] = _clone(this.value);
@@ -265,14 +279,16 @@ function _makeTypeReader(
                     init(this: any) {
                         this.value = [];
                     },
-                    parser: { /** empty */},
+                    parser: {
+                        /** empty */
+                    },
                     finish(this: any) {
                         const elName = lowerFirstLetter(this.name);
                         this.parent.value = this.parent.value || Object.create(null);
                         this.parent.value[elName] = this.value;
                         this.value = undefined;
                     },
-                    startElement(name: string, attrs: XmlAttributes) {
+                    startElement(_name: string, _attrs: XmlAttributes) {
                         // empty
                     },
                     endElement(element: string) {
@@ -285,7 +301,7 @@ function _makeTypeReader(
                 throw new Error("Unsupported ValueRank !");
             }
         }
-        readerMap.set(dataTypeName,reader);
+        readerMap.set(dataTypeName, reader);
         return { name, reader };
     } else if (definition instanceof EnumDefinition) {
         const turnToInt = (value: any) => {
@@ -300,26 +316,26 @@ function _makeTypeReader(
                 }
             }
         };
-    } else if (definition?.dataType == DataType.Variant) {
+    } else if (definition?.dataType === DataType.Variant) {
         // <Value><String>Foo</String></Value>
         type Task = (addressSpace: any) => Promise<void>;
 
         let variantOptions: VariantOptions = Object.create(null);
 
         const variantReader = makeVariantReader(
-            (self, data: VariantOptions) => variantOptions = data,
-            /*setDeferredValue: */(self,data, deferedTask) => {
+            (_self, data: VariantOptions) => (variantOptions = data),
+            /*setDeferredValue: */ (_self, _data, _deferedTask) => {
                 // to do
             },
-            /* postExtensionObjectDecoding:*/(task: (addressSpace: IAddressSpace) => Promise<void>) => {
+            /* postExtensionObjectDecoding:*/ (_task: (addressSpace: IAddressSpace) => Promise<void>) => {
                 // to do
             },
-            translateNodeId,
+            translateNodeId
         );
         return {
             name,
             reader: {
-                init(this: any , name: string, attrs: XmlAttributes, parent: IReaderState, engine: Xml2Json) {
+                init(this: any, _name: string, _attrs: XmlAttributes, _parent: IReaderState, _engine: Xml2Json) {
                     this.obj = {};
                 },
                 ...variantReader,
@@ -334,7 +350,7 @@ function _makeTypeReader(
         const reader = partials[typeName as keyof typeof partials] as ReaderStateParser;
         // c8 ignore next
         if (!reader) {
-            throw new Error("missing parse for " + typeName);
+            throw new Error(`missing parse for ${typeName}`);
         }
         return { name, reader };
     }

package/source/loader/namespace_post_step.ts

@@ -1,8 +1,7 @@
+import type { IAddressSpace, INamespace, UAObject, UAVariable } from "node-opcua-address-space-base";
 import { NodeClass } from "node-opcua-data-model";
-import { make_debugLog, checkDebugFlag } from "node-opcua-debug";
-
-import { UAObject, UAVariable, IAddressSpace, INamespace, UAVariableType } from "node-opcua-address-space-base";
-import { NamespacePrivate } from "../../src/namespace_private";
+import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
+import type { NamespacePrivate } from "../../src/namespace_private";
 
 const debugLog = make_debugLog(__filename);
 const doDebug = checkDebugFlag(__filename);