node-opcua-address-space 2.82.0 → 2.84.0

package/src/base_node_private.ts

@@ -49,17 +49,35 @@ const g_weakMap = new WeakMap();
 
 const warningLog = make_warningLog(__filename);
 
+interface BaseNodeCacheInner {
+    typeDefinition?: NodeId;
+    _childByNameMap?: Record<string, BaseNode>;
+    typeDefinitionObj?: UAVariableType | UAObjectType | null;
+    _aggregates?: BaseNode[];
+    _components?: BaseNode[];
+    _properties?: BaseNode[];
+    _notifiers?: BaseNode[];
+    _eventSources?: BaseNode[];
+    _methods?: UAMethod[];
+    _ref?: Record<string, UAReference[]>;
+    _encoding?: Record<string, UAObject | null>;
+    _subtype_id?: Record<string, UAReferenceType[]> | null;
+    _subtype_idx?: Record<string, UAReferenceType> | null;
+    _subtype_idxVersion?: number;
+    _allSubTypes?: UAReferenceType[] | null;
+    _allSubTypesVersion?: number;
+    _subtypeOfObj?: BaseNode | null;
+}
+
 interface BaseNodeCache {
     __address_space: IAddressSpace | null;
     _browseFilter?: (this: BaseNode, context?: ISessionContext) => boolean;
-    _cache: any;
+    _cache: BaseNodeCacheInner;
     _description?: LocalizedText;
     _displayName: LocalizedText[];
     _parent?: BaseNode | null;
-
     _back_referenceIdx: { [key: string]: UAReference };
     _referenceIdx: { [key: string]: UAReference };
-
     _subtype_idxVersion: number;
     _subtype_idx: any;
 }
@@ -100,7 +118,7 @@ export function BaseNode_getPrivate(self: BaseNode): BaseNodeCache {
     return g_weakMap.get(self);
 }
 
-export function BaseNode_getCache(node: BaseNode): any {
+export function BaseNode_getCache(node: BaseNode): BaseNodeCacheInner {
     return BaseNode_getPrivate(node)._cache;
 }
 export function BaseNode_clearCache(node: BaseNode): void {
@@ -484,7 +502,8 @@ function _clone_collection_new(
         }
 
         if (optionalFilter && node && !optionalFilter.shouldKeep(node)) {
-            doTrace && traceLog(extraInfo.pad(), "skipping optional ", node.browseName.toString(), "that doesn't appear in the filter");
+            doTrace &&
+                traceLog(extraInfo.pad(), "skipping optional ", node.browseName.toString(), "that doesn't appear in the filter");
             continue; // skip this node
         }
         const key = node.browseName.toString();
@@ -541,7 +560,7 @@ function _extractInterfaces2(typeDefinitionNode: UAObjectType | UAVariableType,
 
     const hasInterfaceReference = addressSpace.findReferenceType("HasInterface");
     if (!hasInterfaceReference) {
-        // this version of the standard UA namespace doesn't support Interface yet 
+        // this version of the standard UA namespace doesn't support Interface yet
         return [];
     }
     // example:
@@ -669,10 +688,7 @@ function _cloneInterface(
     const interfaces = _extractInterfaces2(typeDefinitionNode, extraInfo);
     if (interfaces.length === 0) {
         if (doTrace) {
-            traceLog(
-                extraInfo.pad(),
-                chalk.yellow("No interface for ", node.browseName.toString(), node.nodeId.toString())
-            );
+            traceLog(extraInfo.pad(), chalk.yellow("No interface for ", node.browseName.toString(), node.nodeId.toString()));
         }
         return;
     }
@@ -797,25 +813,25 @@ export function _clone<T extends UAObject | UAVariable | UAMethod>(
         const browseNameMap = new Set<string>();
         _clone_children_references(this, cloneObj, options.copyAlsoModellingRules, newFilter!, extraInfo, browseNameMap);
 
-        //
-        let typeDefinitionNode: UAVariableType | UAObjectType | null = this.typeDefinitionObj;
-        while (typeDefinitionNode) {
-            doTrace &&
-                traceLog(
-                    extraInfo?.pad(),
-                    chalk.blueBright("---------------------- Exploring ", typeDefinitionNode.browseName.toString())
+        if (this.nodeClass === NodeClass.Object || this.nodeClass === NodeClass.Variable) {
+            let typeDefinitionNode: UAVariableType | UAObjectType | null = this.typeDefinitionObj;
+            while (typeDefinitionNode) {
+                doTrace &&
+                    traceLog(
+                        extraInfo?.pad(),
+                        chalk.blueBright("---------------------- Exploring ", typeDefinitionNode.browseName.toString())
+                    );
+                _clone_children_references(
+                    typeDefinitionNode,
+                    cloneObj,
+                    options.copyAlsoModellingRules,
+                    newFilter,
+                    extraInfo,
+                    browseNameMap
                 );
-            _clone_children_references(
-                typeDefinitionNode,
-                cloneObj,
-                options.copyAlsoModellingRules,
-                newFilter,
-                extraInfo,
-                browseNameMap
-            );
-            typeDefinitionNode = typeDefinitionNode.subtypeOfObj;
+                typeDefinitionNode = typeDefinitionNode.subtypeOfObj;
+            }
         }
-
         _clone_non_hierarchical_references(this, cloneObj, options.copyAlsoModellingRules, newFilter, extraInfo, browseNameMap);
     }
     cloneObj.propagate_back_references();

package/src/nodeset_tools/nodeset_to_xml.ts

@@ -50,7 +50,11 @@ import { SessionContext } from "../index_current";
 
 import { DefinitionMap2, TypeInfo } from "../../source/loader/make_xml_extension_object_parser";
 import { makeDefinitionMap } from "../../source/loader/decode_xml_extension_object";
-import { constructNamespaceDependency, constructNamespacePriorityTable, hasHigherPriorityThan } from "./construct_namespace_dependency";
+import {
+    constructNamespaceDependency,
+    constructNamespacePriorityTable,
+    hasHigherPriorityThan
+} from "./construct_namespace_dependency";
 
 // tslint:disable:no-var-requires
 const XMLWriter = require("xml-writer");
@@ -628,37 +632,37 @@ function _dumpValue(xw: XmlWriter, node: UAVariable | UAVariableType, value: Var
     if (isExtensionObject) {
         const encodeXml = _dumpVariantExtensionObjectValue2.bind(null, xw, dataTypeNode);
 
-        if (value.arrayType === VariantArrayType.Array) {
-            startElementEx(xw, uax, `ListOf${baseDataTypeName}`, "http://opcfoundation.org/UA/2008/02/Types.xsd");
-            value.value.forEach(encodeXml);
-            restoreDefaultNamespace(xw);
-            xw.endElement();
-        } else if (value.arrayType === VariantArrayType.Scalar) {
-            encodeXml(value.value);
-        } else {
-            errorLog(node.toString());
-            errorLog("_dumpValue : unsupported case , Matrix of ExtensionObjects");
-            // throw new Error("Unsupported case");
+        switch (value.arrayType) {
+            case VariantArrayType.Matrix:
+            case VariantArrayType.Array:
+                startElementEx(xw, uax, `ListOf${baseDataTypeName}`, "http://opcfoundation.org/UA/2008/02/Types.xsd");
+                value.value.forEach(encodeXml);
+                restoreDefaultNamespace(xw);
+                xw.endElement();
+                break;
+            case VariantArrayType.Scalar:
+                encodeXml(value.value);
+                break;
+            default:
+                errorLog(node.toString());
+                errorLog("_dumpValue : unsupported arrayType: ", value.arrayType);
         }
     } else {
         const encodeXml = _dumpVariantValue.bind(null, xw, value.dataType, node);
-        if (value.arrayType === VariantArrayType.Matrix) {
-            // console.log("Warning _dumpValue : Matrix not supported yet");
-            startElementEx(xw, uax, `ListOf${dataTypeName}`, "http://opcfoundation.org/UA/2008/02/Types.xsd");
-            value.value.forEach(encodeXml);
-            restoreDefaultNamespace(xw);
-            xw.endElement();
-        } else if (value.arrayType === VariantArrayType.Array) {
-            startElementEx(xw, uax, `ListOf${dataTypeName}`, "http://opcfoundation.org/UA/2008/02/Types.xsd");
-            value.value.forEach(encodeXml);
-            restoreDefaultNamespace(xw);
-            xw.endElement();
-        } else if (value.arrayType === VariantArrayType.Scalar) {
-            encodeXml(value.value);
-        } else {
-            errorLog(node.toString());
-            errorLog("_dumpValue : unsupported case , Matrix");
-            // xx throw new Error("Unsupported case");
+        switch (value.arrayType) {
+            case VariantArrayType.Matrix:
+            case VariantArrayType.Array:
+                startElementEx(xw, uax, `ListOf${dataTypeName}`, "http://opcfoundation.org/UA/2008/02/Types.xsd");
+                value.value.forEach(encodeXml);
+                restoreDefaultNamespace(xw);
+                xw.endElement();
+                break;
+            case VariantArrayType.Scalar:
+                encodeXml(value.value);
+                break;
+            default:
+                errorLog(node.toString());
+                errorLog("_dumpValue : unsupported arrayType: ", value.arrayType);
         }
     }
 
@@ -675,7 +679,6 @@ function _dumpArrayDimensionsAttribute(xw: XmlWriter, node: UAVariableType | UAV
 }
 
 function visitUANode(node: BaseNode, data: DumpData, forward: boolean) {
-
     const addressSpace = node.addressSpace;
 
     // visit references
@@ -800,7 +803,7 @@ function dumpCommonAttributes(xw: XmlWriter, node: BaseNode) {
         }
     }
     if (Object.prototype.hasOwnProperty.call(node, "minimumSamplingInterval")) {
-        const minimumSamplingInterval =(node as UAVariable).minimumSamplingInterval;
+        const minimumSamplingInterval = (node as UAVariable).minimumSamplingInterval;
         if (minimumSamplingInterval > 0) {
             xw.writeAttribute("MinimumSamplingInterval", minimumSamplingInterval);
         }
@@ -1030,11 +1033,11 @@ function dumpUAVariableType(xw: XmlWriter, node: UAVariableType) {
             // throw new Error(" cannot find datatype " + node.dataType);
             console.log(
                 " cannot find datatype " +
-                node.dataType +
-                " for node " +
-                node.browseName.toString() +
-                " id =" +
-                node.nodeId.toString()
+                    node.dataType +
+                    " for node " +
+                    node.browseName.toString() +
+                    " id =" +
+                    node.nodeId.toString()
             );
         } else {
             const dataTypeName = b(xw, resolveDataTypeName(addressSpace, dataTypeNode.nodeId));
@@ -1063,6 +1066,7 @@ function dumpUAObject(xw: XmlWriter, node: UAObject) {
     _dumpUAObject(xw, node);
     xw.writeComment("Object - " + b(xw, node.browseName) + " }}}} ");
 }
+
 function _dumpUAObject(xw: XmlWriter, node: UAObject) {
     assert(node.nodeClass === NodeClass.Object);
     xw.visitedNode = xw.visitedNode || {};
@@ -1101,9 +1105,7 @@ function dumpElementInFolder(xw: XmlWriter, node: BaseNodeImpl) {
 
 function dumpAggregates(xw: XmlWriter, node: BaseNode) {
     // Xx xw.writeComment("Aggregates {{ ");
-    const aggregates = node
-        .getAggregates()
-        .sort(sortByBrowseName);
+    const aggregates = node.getAggregates().sort(sortByBrowseName);
     // const aggregates = node.findReferencesExAsObject("Aggregates", BrowseDirection.Forward);
 
     for (const aggregate of aggregates.sort(sortByNodeId)) {
@@ -1242,7 +1244,6 @@ function writeAliases(xw: XmlWriter, aliases: Record<string, NodeIdString>) {
     xw.endElement();
 }
 
-
 export function constructNamespaceTranslationTable(dependency: INamespace[]): ITranslationTable {
     const translationTable: ITranslationTable = {};
     for (let i = 0; i < dependency.length; i++) {
@@ -1329,8 +1330,6 @@ function makeTypeXsd(namespaceUri: string): string {
 
 // eslint-disable-next-line max-statements
 NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
-
-
     const namespaceArrayNode = this.addressSpace.findNode(VariableIds.Server_NamespaceArray);
     const namespaceArray: string[] = namespaceArrayNode
         ? namespaceArrayNode.readAttribute(null, AttributeIds.Value).value.value
@@ -1343,7 +1342,6 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
     const translationTable = constructNamespaceTranslationTable(dependency);
     xw.translationTable = translationTable;
 
-
     xw.startDocument({ encoding: "utf-8", version: "1.0" });
     xw.startElement("UANodeSet");
 

package/src/ua_data_type_impl.ts

@@ -31,7 +31,6 @@ import { get_subtypeOf } from "./tool_isSupertypeOf";
 import { get_subtypeOfObj } from "./tool_isSupertypeOf";
 import { BaseNode_getCache } from "./base_node_private";
 
-
 export interface UADataTypeImpl {
     _extensionObjectConstructor: ExtensionObjectConstructorFuncWithSchema;
 }
@@ -149,8 +148,9 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
 
     public getEncodingNode(encoding_name: string): UAObject | null {
         const _cache = BaseNode_getCache(this);
+        _cache._encoding = _cache._encoding || {};
         const key = encoding_name + "Node";
-        if (_cache[key] === undefined) {
+        if (_cache._encoding[key] === undefined) {
             assert(encoding_name === "Default Binary" || encoding_name === "Default XML" || encoding_name === "Default JSON");
             // could be binary or xml
             const refs = this.findReferences("HasEncoding", true);
@@ -160,24 +160,18 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
                 .filter((obj: any) => obj !== null)
                 .filter((obj: any) => obj.browseName.toString() === encoding_name);
             const node = encoding.length === 0 ? null : (encoding[0] as UAObject);
-            _cache[key] = node;
+            _cache._encoding[key] = node;
         }
-        return _cache[key];
+        return _cache._encoding[key];
     }
 
     public getEncodingNodeId(encoding_name: string): ExpandedNodeId | null {
-        const _cache = BaseNode_getCache(this);
-        const key = encoding_name + "NodeId";
-        if (_cache[key] === undefined) {
-            const encoding = this.getEncodingNode(encoding_name);
-            if (encoding) {
-                const namespaceUri = this.addressSpace.getNamespaceUri(encoding.nodeId.namespace);
-                _cache[key] = ExpandedNodeId.fromNodeId(encoding.nodeId, namespaceUri);
-            } else {
-                _cache[key] = null;
-            }
+        const encoding = this.getEncodingNode(encoding_name);
+        if (!encoding) {
+            return null;
         }
-        return _cache[key];
+        const namespaceUri = this.addressSpace.getNamespaceUri(encoding.nodeId.namespace);
+        return ExpandedNodeId.fromNodeId(encoding.nodeId, namespaceUri);
     }
     /**
      * returns the encoding of this node's

package/src/ua_reference_type_impl.ts

@@ -56,7 +56,7 @@ function _getAllSubtypes(ref: UAReferenceType) {
 function _internal_getSubtypeIndex(referenceType: UAReferenceType): { [key: string]: UAReferenceTypePublic } {
     const possibleReferenceTypes = _getAllSubtypes(referenceType);
     // create a index of reference type with browseName as key for faster search
-    const keys: any = {};
+    const keys: Record<string, UAReferenceType> = {};
     for (const refType of possibleReferenceTypes) {
         keys[refType.nodeId.toString()] = refType;
     }
@@ -65,7 +65,7 @@ function _internal_getSubtypeIndex(referenceType: UAReferenceType): { [key: stri
 
 function _getSubtypeIndex(referenceType: UAReferenceType): { [key: string]: UAReferenceTypePublic } {
     const _cache = BaseNode_getCache(referenceType);
-    if (!_cache._subtype_idx || _cache._subtype_idxVersion < ReferenceTypeCounter.count) {
+    if (!_cache._subtype_idx || (_cache._subtype_idxVersion && _cache._subtype_idxVersion < ReferenceTypeCounter.count)) {
         // the cache need to be invalidated
         _cache._subtype_idx = null;
     }

package/src/ua_variable_impl.ts

@@ -1388,7 +1388,7 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
                 return false;
             }
             return checkExtensionObjectIsCorrectScalar.call(this, extObj);
-        } else if (this.valueRank === 1) {
+        } else if (this.valueRank >= 1) {
             /** array */
             if (!(extObj instanceof Array)) {
                 // let's coerce this scalar into an 1-element array if it is a valid extension object