node-opcua-address-space 2.82.0 → 2.83.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;
     }

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;
     }