node-opcua-address-space 2.136.0 → 2.138.0

package/src/alarms_and_conditions/ua_acknowledgeable_condition_impl.ts

@@ -16,8 +16,6 @@ import { _install_TwoStateVariable_machinery } from "../state_machine/ua_two_sta
 import { UAAcknowledgeableConditionEx } from "../../source/interfaces/alarms_and_conditions/ua_acknowledgeable_condition_ex";
 import { ConditionSnapshot } from "../../source/interfaces/alarms_and_conditions/condition_snapshot";
 import { InstantiateAlarmConditionOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_alarm_condition_options";
-
-import { _setAckedState } from "./condition";
 import { ConditionSnapshotImpl } from "./condition_snapshot_impl";
 import {  UAConditionImpl } from "./ua_condition_impl";
 
@@ -175,7 +173,7 @@ export class UAAcknowledgeableConditionImpl extends UAConditionImpl implements U
     ): StatusCode {
         assert(typeof message === "string");
 
-        const statusCode = _setAckedState(branch as ConditionSnapshotImpl, true, conditionEventId, comment);
+        const statusCode = (branch as ConditionSnapshotImpl)._setAckedState(true, conditionEventId, comment);
         if (statusCode.isNotGood()) {
             return statusCode;
         }

package/src/alarms_and_conditions/ua_base_event_impl.ts

@@ -10,8 +10,12 @@ import { UABaseEvent_Base, UABaseEvent } from "node-opcua-nodeset-ua";
 import { UAObjectImpl } from "../ua_object_impl";
 import { UABaseEventHelper } from "../../source/interfaces/alarms_and_conditions/ua_condition_ex";
 
-export interface UABaseEventEx extends UABaseEvent_Base, UABaseEventHelper {}
-export declare interface UABaseEventImpl extends UABaseEventEx {}
+export interface UABaseEventEx extends UABaseEvent_Base, UABaseEventHelper {
+    /** empty interface */
+}
+export declare interface UABaseEventImpl extends UABaseEventEx {
+    /** empty interface */
+}
 
 /**
  * @internal

package/src/alarms_and_conditions/ua_condition_impl.ts

@@ -192,13 +192,13 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
     }
     private _branch0: ConditionSnapshot = null as any;
     private _previousRetainFlag = false;
-    private _branches: { [key: string]: ConditionSnapshot } = {};
+    private _branches: Map<string,ConditionSnapshot> = new Map()
 
     /**
      * @private
      */
     public initialize(): void {
-        this._branches = {};
+        this._branches = new Map();
     }
 
     /**
@@ -220,13 +220,11 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
     }
 
     public getBranchCount(): number {
-        return Object.keys(this._branches).length;
+        return this._branches.size;
     }
 
     public getBranches(): ConditionSnapshot[] {
-        return Object.keys(this._branches).map((x) => {
-            return this._branches[x];
-        });
+        return [... this._branches.values()];
     }
 
     public getBranchIds(): NodeId[] {
@@ -238,7 +236,7 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
     public createBranch(): ConditionSnapshot {
         const branchId = _create_new_branch_id();
         const snapshot = new ConditionSnapshotImpl(this, branchId);
-        this._branches[branchId.toString()] = snapshot;
+        this._branches.set(branchId.toString(),snapshot);
         return snapshot;
     }
 
@@ -247,8 +245,8 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
     public deleteBranch(branch: ConditionSnapshot): void {
         const key = branch.getBranchId().toString();
         assert(!sameNodeId(branch.getBranchId(), NodeId.nullNodeId), "cannot delete branch zero");
-        assert(Object.prototype.hasOwnProperty.call(this._branches, key));
-        delete this._branches[key];
+        assert(this._branches.has(key));
+        this._branches.delete(key);
         this.emit("branch_deleted", key);
     }
 
@@ -453,7 +451,7 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
             throw new Error("UACondition#raiseNewCondition Condition is not enabled");
         }
 
-        conditionInfo = conditionInfo || {};
+        conditionInfo = conditionInfo || { severity: UAConditionImpl.defaultSeverity };
 
         conditionInfo.severity = Object.prototype.hasOwnProperty.call(conditionInfo, "severity")
             ? conditionInfo.severity
@@ -612,7 +610,7 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
         if (sameBuffer(this.eventId!.readValue().value.value, eventId)) {
             return this.currentBranch();
         }
-        const e = Object.values(this._branches).filter((branch: ConditionSnapshot) => sameBuffer(branch.getEventId(), eventId));
+        const e = [...this._branches.values()].filter((branch: ConditionSnapshot) => sameBuffer(branch.getEventId(), eventId));
         if (e.length === 1) {
             return e[0];
         }
@@ -730,7 +728,7 @@ function UACondition_instantiate(
         value: conditionType.nodeId
     });
 
-    data = data || {};
+    data = data || Object.create(null);
     // install initial branch ID (null NodeId);
     conditionNode.branchId.setValueFromSource({
         dataType: DataType.NodeId,
@@ -771,7 +769,7 @@ function UACondition_instantiate(
     conditionNode.enabledState.setValue(true);
 
     // set properties to in initial values
-    Object.entries(data).forEach(([key, value]) => {
+    Object.entries(data!).forEach(([key, value]) => {
         const varNode = _getCompositeKey(conditionNode, key);
         assert(varNode.nodeClass === NodeClass.Variable);
 

package/src/alarms_and_conditions/ua_exclusive_limit_alarm_impl.ts

@@ -14,7 +14,9 @@ import {  UALimitAlarmImpl } from "./ua_limit_alarm_impl";
 
 const validState = ["HighHigh", "High", "Low", "LowLow", null];
 
-export declare interface UAExclusiveLimitAlarmImpl extends UAExclusiveLimitAlarmEx {}
+export declare interface UAExclusiveLimitAlarmImpl extends UAExclusiveLimitAlarmEx {
+    /** empty interface */
+}
 
 export class UAExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UAExclusiveLimitAlarmEx {
     /***

package/src/alarms_and_conditions/ua_exclusive_rate_of_change_alarm_impl.ts

@@ -22,4 +22,6 @@ export interface UAExclusiveRateOfChangeAlarmEx
         UAExclusiveLimitAlarmEx {
     on(eventName: string, eventHandler: any): this;
 }
-export class UAExclusiveRateOfChangeAlarmImpl extends UAExclusiveLimitAlarmImpl implements UAExclusiveRateOfChangeAlarmEx {}
+export class UAExclusiveRateOfChangeAlarmImpl extends UAExclusiveLimitAlarmImpl implements UAExclusiveRateOfChangeAlarmEx {
+    /** empty interface */
+}

package/src/apply_condition_refresh.ts

@@ -3,10 +3,10 @@ import { UAConditionImpl } from "./alarms_and_conditions/ua_condition_impl";
 import { BaseNodeImpl } from "./base_node_impl";
 import { UAObjectImpl } from "./ua_object_impl";
 
-export type ConditionRefreshCache = { [key in string]: UAObject };
+export type ConditionRefreshCache = Map<string,UAObject>;
 export function apply_condition_refresh(this: BaseNodeImpl, cache?: ConditionRefreshCache): void {
     // visit all notifiers recursively
-    cache = cache || {};
+    cache = cache || new Map();
     const notifiers = this.getNotifiers();
     const eventSources = this.getEventSources();
 
@@ -20,8 +20,8 @@ export function apply_condition_refresh(this: BaseNodeImpl, cache?: ConditionRef
 
     for (const notifier of arr) {
         const key = notifier.nodeId.toString();
-        if (!cache[key]) {
-            cache[key] = notifier;
+        if (!cache.has(key)) {
+            cache.set(key,notifier);
             if (notifier._conditionRefresh) {
                 notifier._conditionRefresh(cache);
             }

package/src/base_node_impl.ts

@@ -38,7 +38,7 @@ import {
     AccessRestrictionsFlag
 } from "node-opcua-data-model";
 import { DataValue } from "node-opcua-data-value";
-import { dumpIf, make_debugLog,  make_warningLog, make_errorLog } from "node-opcua-debug";
+import { dumpIf, make_debugLog, make_warningLog, make_errorLog } from "node-opcua-debug";
 import { coerceNodeId, makeNodeId, NodeId, NodeIdLike, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
 import { NumericRange } from "node-opcua-numeric-range";
 import { ReferenceDescription } from "node-opcua-service-browse";
@@ -88,7 +88,7 @@ const errorLog = make_errorLog(__filename);
 const debugLog = make_debugLog(__filename);
 
 const HasEventSourceReferenceType = resolveNodeId("HasEventSource");
-const HasNotifierReferenceType = resolveNodeId("HasNotifier");  
+const HasNotifierReferenceType = resolveNodeId("HasNotifier");
 
 function defaultBrowseFilterFunc(context?: ISessionContext): boolean {
     return true;
@@ -432,17 +432,17 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
             // throw new Error("expecting valid reference name " + strReference);
             return [];
         }
-        _cache._ref = _cache._ref || {};
+        _cache._ref = _cache._ref || new Map();
         const hash = "_ref_" + referenceTypeNode.nodeId.toString() + isForward.toString();
-        if (_cache._ref[hash]) {
-            return _cache._ref[hash];
+        if (_cache._ref.has(hash)) {
+            return _cache._ref.get(hash)!;
         }
         // istanbul ignore next
         if (doDebug && !this.addressSpace.findReferenceType(referenceTypeNode.nodeId)) {
             throw new Error("expecting valid reference name " + referenceType);
         }
         const result = this.findReferences_no_cache(referenceTypeNode, isForward);
-        _cache._ref[hash] = result;
+        _cache._ref.set(hash, result);
         return result;
     }
 
@@ -1103,15 +1103,15 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
         const addressSpace = this.addressSpace;
 
         if (!_cache._childByNameMap) {
-            _cache._childByNameMap = {};
+            _cache._childByNameMap = new Map();
 
             const childReferenceTypes = this.findReferencesEx("HasChild");
             for (const r of childReferenceTypes) {
                 const child = resolveReferenceNode(addressSpace, r);
-                _cache._childByNameMap[child.browseName.name!.toString()] = child;
+                _cache._childByNameMap.set(child.browseName.name!.toString(),child);
             }
         }
-        const ret = _cache._childByNameMap[browseName.toString()] || null;
+        const ret = _cache._childByNameMap.get(browseName.toString()) || null;
         return ret;
     }
 
@@ -1509,11 +1509,11 @@ function _asObject<T extends BaseNode>(references: UAReference[], addressSpace:
     function toObject(reference: UAReference): T {
         const obj = resolveReferenceNode(addressSpace, reference);
         // istanbul ignore next
-        if (doDebug&& !obj) {
+        if (doDebug && !obj) {
             debugLog(
                 chalk.red(" Warning :  object with nodeId ") +
-                chalk.cyan(reference.nodeId.toString()) +
-                chalk.red(" cannot be found in the address space !")
+                    chalk.cyan(reference.nodeId.toString()) +
+                    chalk.red(" cannot be found in the address space !")
             );
         }
         return obj as any as T;
@@ -1790,7 +1790,7 @@ function install_components_as_object_properties(parentObj: BaseNode) {
         doDebug && debugLog("Installing property " + name, " on ", parentObj.browseName.toString());
 
         const hasProperty = Object.prototype.hasOwnProperty.call(parentObj, name);
-        if (hasProperty && ((parentObj as any)[name] !== null && (parentObj as any)[name] !== undefined)) {
+        if (hasProperty && (parentObj as any)[name] !== null && (parentObj as any)[name] !== undefined) {
             continue;
         }
 

package/src/base_node_private.ts

@@ -57,7 +57,7 @@ const warningLog = make_warningLog(__filename);
 
 interface BaseNodeCacheInner {
     typeDefinition?: NodeId;
-    _childByNameMap?: Record<string, BaseNode>;
+    _childByNameMap?: Map<string, BaseNode>;
     typeDefinitionObj?: UAVariableType | UAObjectType | null;
     _aggregates?: BaseNode[];
     _components?: BaseNode[];
@@ -65,10 +65,9 @@ interface BaseNodeCacheInner {
     _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;
+    _ref?: Map<string, UAReference[]>;
+    _encoding?: Map<string, UAObject | null>;
+    _subtype_idx?: Map<string, UAReferenceType> | null;
     _subtype_idxVersion?: number;
     _allSubTypes?: UAReferenceType[] | null;
     _allSubTypesVersion?: number;
@@ -84,8 +83,6 @@ interface BaseNodeCache {
     _parent?: BaseNode | null;
     _back_referenceIdx: { [key: string]: UAReference };
     _referenceIdx: { [key: string]: UAReference };
-    _subtype_idxVersion: number;
-    _subtype_idx: any;
 }
 
 export function BaseNode_initPrivate(self: BaseNode): BaseNodeCache {
@@ -100,8 +97,6 @@ export function BaseNode_initPrivate(self: BaseNode): BaseNodeCache {
         _description: undefined,
         _displayName: [],
         _parent: undefined,
-        _subtype_idx: {},
-        _subtype_idxVersion: 0
     };
     g_weakMap.set(self, _private);
     return _private;
@@ -1087,7 +1082,7 @@ export function _handle_HierarchicalReference(node: BaseNode, reference: UARefer
             if (referenceType.isSubtypeOf(HierarchicalReferencesType!)) {
                 assert(reference.isForward);
                 const targetNode = ReferenceImpl.resolveReferenceNode(addressSpace, reference);
-                _cache._childByNameMap[targetNode.browseName!.name!.toString()] = targetNode;
+                _cache._childByNameMap.set(targetNode.browseName!.name!.toString(), targetNode);
             }
         }
     }
@@ -1104,7 +1099,7 @@ function _remove_HierarchicalReference(node: BaseNode, reference: UAReference) {
             if (referenceType.isSubtypeOf(HierarchicalReferencesType!)) {
                 assert(reference.isForward);
                 const targetNode = ReferenceImpl.resolveReferenceNode(addressSpace, reference);
-                delete _cache._childByNameMap[targetNode.browseName!.name!.toString()];
+                _cache._childByNameMap.delete(targetNode.browseName!.name!.toString());
             }
         }
     }

package/src/data_access/ua_multistate_value_discrete_impl.ts

@@ -148,7 +148,7 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType>
     public _enumValueIndex(): Record<Int32, DTEnumValue> {
         // construct an index to quickly find a EnumValue from a value
         const enumValues: DTEnumValue[] = this.enumValues.readValue().value.value;
-        const enumValueIndex: Record<Int32, DTEnumValue> = {};
+        const enumValueIndex: Record<Int32, DTEnumValue> = Object.create(null);
         if (!enumValues || !enumValues.forEach) {
             return enumValueIndex;
         }

package/src/historical_access/address_space_historical_data_node.ts

@@ -696,7 +696,7 @@ export function AddressSpace_installHistoricalDataNode(
     };
 
     assert(node.nodeClass === NodeClass.Variable);
-    options = options || {};
+    options = options || Object.create(null);
 
     const addressSpace = node.addressSpace;
 
@@ -820,6 +820,6 @@ export function AddressSpace_installHistoricalDataNode(
     node.on("value_changed", on_value_change);
 
     // update the index of historizing nodes in the addressSpace
-    node.addressSpace.historizingNodes = node.addressSpace.historizingNodes || {};
-    node.addressSpace.historizingNodes[node.nodeId.toString()] = node;
+    node.addressSpace.historizingNodes = node.addressSpace.historizingNodes || new Set();
+    node.addressSpace.historizingNodes.add(node);
 }

package/src/index_current.ts

@@ -13,7 +13,6 @@ export * from "../source/helpers/ensure_secure_access";
 export * from "../source/helpers/resolve_opaque_on_address_space";
 export * from "../source/interfaces/alarms_and_conditions/condition_info_i";
 export * from "../src/nodeset_tools/construct_namespace_dependency";
-export * from "../src/validate_data_type_correctness";
 
 
 export * from "../source/set_namespace_meta_data";
@@ -57,3 +56,7 @@ export * from "./alarms_and_conditions";
 export * from "./event_data";
 
 export * from "node-opcua-nodeset-ua";
+
+export * from "../src/validate_data_type_correctness";
+export * from "../source/ua_addin";
+export * from "../source/ua_interface";

package/src/namespace_impl.ts

@@ -799,16 +799,8 @@ export class NamespaceImpl implements NamespacePrivate {
     }
 
     // ---------------------------------------------------------------------------------------------------
-    /**
-
-     * @param options
-     * @param options.browseName {String}
-     * @param options.definition {String}
-     * @param [options.valuePrecision {Double |null} =null]
-     * @param options.dataType {NodeId} // todo :check
-     * @param options.value
-     * @param options.componentOf
-     * @return {UAVariable}
+    /** 
+     * 
      */
     public addDataItem<T, DT extends DataType>(options: AddDataItemOptions): UADataItem<T, DT> {
         const addressSpace = this.addressSpace;
@@ -2134,12 +2126,28 @@ function _handle_event_hierarchy_parent(
 }
 
 export function _handle_hierarchy_parent(addressSpace: AddressSpacePrivate, references: AddReferenceOpts[], options: any): void {
+    options.addInOf = _coerce_parent(addressSpace, options.addInOf, addressSpace._coerceNode);
     options.componentOf = _coerce_parent(addressSpace, options.componentOf, addressSpace._coerceNode);
     options.propertyOf = _coerce_parent(addressSpace, options.propertyOf, addressSpace._coerceNode);
     options.organizedBy = _coerce_parent(addressSpace, options.organizedBy, addressSpace._coerceFolder);
     options.encodingOf = _coerce_parent(addressSpace, options.encodingOf, addressSpace._coerceNode);
 
+    if (options.addInOf) {
+        assert(!options.componentOf);
+        assert(!options.propertyOf);
+        assert(!options.organizedBy);
+        assert(options.addInOf.nodeClass === NodeClass.Object || options.addInOf.nodeClass === NodeClass.ObjectType,
+            "addInOf must be of nodeClass Object or ObjectType"
+        );   
+        references.push({
+            isForward: false,
+            nodeId: options.addInOf.nodeId,
+            referenceType: "HasAddIn"
+        });
+    }
+
     if (options.componentOf) {
+        assert(!options.addInOf);
         assert(!options.propertyOf);
         assert(!options.organizedBy);
         assert(addressSpace.rootFolder.objects, "addressSpace must have a rootFolder.objects folder");
@@ -2155,6 +2163,7 @@ export function _handle_hierarchy_parent(addressSpace: AddressSpacePrivate, refe
     }
 
     if (options.propertyOf) {
+        assert(!options.addInOf);
         assert(!options.componentOf);
         assert(!options.organizedBy);
         assert(
@@ -2169,6 +2178,7 @@ export function _handle_hierarchy_parent(addressSpace: AddressSpacePrivate, refe
     }
 
     if (options.organizedBy) {
+        assert(!options.addInOf);
         assert(!options.propertyOf);
         assert(!options.componentOf);
         references.push({
@@ -2177,6 +2187,7 @@ export function _handle_hierarchy_parent(addressSpace: AddressSpacePrivate, refe
             referenceType: "Organizes"
         });
     }
+    
     if (options.encodingOf) {
         // parent must be a DataType
         assert(options.encodingOf.nodeClass === NodeClass.DataType, "encodingOf must be toward a DataType");

package/src/nodeid_manager.ts

@@ -6,6 +6,7 @@ import { makeNodeId, NodeId, NodeIdLike, NodeIdType, resolveNodeId, sameNodeId }
 import { make_debugLog, make_warningLog } from "node-opcua-debug";
 import { BaseNode, UAReference, UAReferenceType } from "node-opcua-address-space-base";
 import { getReferenceType } from "./base_node_impl";
+import { resolveReferenceNode, resolveReferenceType } from "./reference_impl";
 
 const debugLog = make_debugLog(__filename);
 const warningLog = make_warningLog(__filename);
@@ -22,21 +23,49 @@ const regExp2 = /^ns=[0-9]+;(s|i|b|g)=/;
 const hasPropertyRefId = resolveNodeId("HasProperty");
 const hasComponentRefId = resolveNodeId("HasComponent");
 const hasOrderedComponentRefId = resolveNodeId("HasOrderedComponent");
+const hasAddIn = resolveNodeId("HasAddIn");
 const hasEncoding = resolveNodeId("HasEncoding");
 
 type Suffix = string;
 
-function _identifyParentInReference(references: UAReference[]): [NodeId, Suffix] | null {
-    const candidates = references.filter((r: UAReference) => {
-        return (
-            !r.isForward &&
-            (sameNodeId(r.referenceType, hasComponentRefId) ||
-                sameNodeId(r.referenceType, hasOrderedComponentRefId) ||
-                sameNodeId(r.referenceType, hasPropertyRefId) ||
-                sameNodeId(r.referenceType, hasEncoding))
-        );
-    });
-    assert(candidates.length <= 1);
+// function _identifyParentInReference(references: UAReference[]): [NodeId, Suffix] | null {
+//     const candidates = references.filter((r: UAReference) => {
+//         return (
+//             !r.isForward &&
+//             (sameNodeId(r.referenceType, hasComponentRefId) ||
+//                 sameNodeId(r.referenceType, hasOrderedComponentRefId) ||
+//                 sameNodeId(r.referenceType, hasPropertyRefId) ||
+//                 sameNodeId(r.referenceType, hasEncoding) ||
+//                 sameNodeId(r.referenceType, hasAddIn))
+//         );
+//     });
+//     assert(candidates.length <= 1);
+//     if (candidates.length === 0) {
+//         return null;
+//     }
+//     const ref = candidates[0];
+//     if (sameNodeId(ref.referenceType, hasEncoding)) {
+//         return [ref.nodeId, "_Encoding"];
+//     }
+//     return [ref.nodeId, ""];
+// }
+
+function checkAggregate(addressSpace: AddressSpacePartial, reference: UAReference, refType: UAReferenceType): boolean {
+    const r = resolveReferenceType(addressSpace, reference);
+    if (!r) {
+        return false;
+    }
+    return r.isSubtypeOf(refType)
+}
+function _filterAggregates(addressSpace: AddressSpacePartial, references: UAReference[]): [NodeId, Suffix] | null {
+
+    const aggregates = addressSpace.findNode(resolveNodeId("Aggregates")) as UAReferenceType;
+    
+    const candidates = references.filter((r: UAReference) =>
+        !r.isForward && checkAggregate(addressSpace, r, aggregates)
+    );
+
+    assert(candidates.length <= 1, "a node shall not have more than one parent (link to a parent with a reference derived from 'Aggregates')");
     if (candidates.length === 0) {
         return null;
     }
@@ -60,7 +89,7 @@ function _findParentNodeId(addressSpace: AddressSpacePartial, options: Construct
         (ref as any).referenceType = (ref as any)._referenceType.nodeId;
     }
     // find HasComponent, or has Property reverse
-    return _identifyParentInReference(options.references);
+    return _filterAggregates(addressSpace, options.references);
 }
 
 function prepareName(browseName: QualifiedName): string {
@@ -83,7 +112,7 @@ export type NodeEntry = [string, number, NodeClass];
 export type NodeEntry1 = [string, number, string /*"Object" | "Variable" etc...*/];
 
 export class NodeIdManager {
-    private _cacheSymbolicName: { [key: string]: [number,NodeClass] } = {};
+    private _cacheSymbolicName: { [key: string]: [number, NodeClass] } = {};
     private _cacheSymbolicNameRev: Set<number> = new Set<number>();
 
     private _internal_id_counter: number;
@@ -174,11 +203,11 @@ export class NodeIdManager {
         }
         return this._constructNodeId(options);
     }
- 
+
     private _constructNodeId(options: ConstructNodeIdOptions): NodeId {
 
         let nodeId = options.nodeId;
-  
+
         if (!nodeId) {
             const parentInfo = this.findParentNodeId(options);
             if (parentInfo) {
@@ -190,7 +219,7 @@ export class NodeIdManager {
                     const childName = parentNodeId.value + NamespaceOptions.nodeIdNameSeparator + name;
                     nodeId = new NodeId(NodeId.NodeIdType.STRING, childName, parentNodeId.namespace);
                     return nodeId;
-                } 
+                }
             }
         } else if (typeof nodeId === "string") {
             if (this.namespaceIndex !== 0) {
@@ -218,7 +247,7 @@ export class NodeIdManager {
     }
 
     private _isInCache(nodeId: NodeId): boolean {
-        if( nodeId.namespace !== this.namespaceIndex || nodeId.identifierType !== NodeIdType.NUMERIC) return false;
+        if (nodeId.namespace !== this.namespaceIndex || nodeId.identifierType !== NodeIdType.NUMERIC) return false;
         return this._cacheSymbolicNameRev.has(nodeId.value as number) ? true : false;
     }
 }

package/src/nodeset_tools/construct_namespace_dependency.ts

@@ -9,7 +9,7 @@ import { make_debugLog, make_warningLog } from "node-opcua-debug";
 import { NamespacePrivate } from "../namespace_private";
 import { BaseNodeImpl, getReferenceType } from "../base_node_impl";
 import { UAVariableImpl } from "../ua_variable_impl";
-import { ITranslationTable } from "../../source/xml_writer";
+import { TranslationTable } from "../../source/xml_writer";
 
 const warningLog = make_warningLog(__filename);
 const debugLog = make_debugLog(__filename);
@@ -201,7 +201,7 @@ export function _getCompleteRequiredModelsFromValuesAndReferences(
     const thisPriority = priorityList[namespace.index];
 
     const requiredNamespaceIndexes = _recomputeRequiredModelsFromTypes2(namespace, cache).requiredNamespaceIndexes;
-    const requiredModelsSet: Set<number> = new Set<number>([... requiredNamespaceIndexes]);
+    const requiredModelsSet: Set<number> = new Set<number>([...requiredNamespaceIndexes]);
 
     const consider = (requiredModel: number) => {
         if (requiredModel !== namespace.index && !requiredModelsSet.has(requiredModel)) {
@@ -323,26 +323,27 @@ export function constructNamespaceDependency(namespace: INamespace, priorityTabl
 /**
  * @private
  */
-export function _constructNamespaceTranslationTable(dependency: INamespace[], exportedNamespace: INamespace): ITranslationTable {
+export function _constructNamespaceTranslationTable(dependency: INamespace[], exportedNamespace: INamespace): TranslationTable {
+    const translationTable: TranslationTable = new Map();
     if (!dependency || dependency.length === 0) {
-        return { 0: 0 };
+        translationTable.set(0, 0);
+        return translationTable;
         // throw new Error("Cannot constructNamespaceTranslationTable on empty dependency");
     }
-    const translationTable: ITranslationTable = {};
     assert(dependency[0].namespaceUri === "http://opcfoundation.org/UA/");
 
     let counter = 0;
-    translationTable[dependency[0].index] = counter++;
+    translationTable.set(dependency[0].index, counter++);
     //
     if (exportedNamespace) {
-        translationTable[exportedNamespace.index] = counter++;
+        translationTable.set(exportedNamespace.index, counter++);
     }
     for (let i = 1; i < dependency.length; i++) {
         const dep = dependency[i];
         if (exportedNamespace && exportedNamespace === dep) {
             continue;
         }
-        translationTable[dep.index] = counter++;
+        translationTable.set(dep.index, counter++);
     }
     return translationTable;
 }

package/src/nodeset_tools/dump_to_bsd.ts

@@ -23,7 +23,7 @@ function dumpEnumeratedType(xw: XmlWriter, e: EnumDefinition, name: string): voi
     }
     xw.endElement();
 }
-function buildXmlName(addressSpace: AddressSpacePrivate, map: { [key: number]: string }, nodeId: NodeId): string {
+function buildXmlName(addressSpace: AddressSpacePrivate, map: Map<number,string>, nodeId: NodeId): string {
     if (NodeId.sameNodeId(nodeId, NodeId.nullNodeId)) {
         return "ua:ExtensionObject";
     }
@@ -35,7 +35,7 @@ function buildXmlName(addressSpace: AddressSpacePrivate, map: { [key: number]: s
     const typeName = node.browseName.name!;
 
     const n = node.nodeId as INodeId;
-    const prefix = (n.identifierType === NodeIdType.NUMERIC && n.namespace === 0) ? (n.value <= 15 ? "opc" : "ua") : map[node.nodeId.namespace];
+    const prefix = (n.identifierType === NodeIdType.NUMERIC && n.namespace === 0) ? (n.value <= 15 ? "opc" : "ua") : map.get(node.nodeId.namespace);
     return prefix + ":" + (typeName === "Structure" && prefix === "ua" ? "ExtensionObject" : typeName);
 }
 
@@ -43,7 +43,7 @@ function buildXmlName(addressSpace: AddressSpacePrivate, map: { [key: number]: s
 function dumpDataTypeStructure(
     xw: XmlWriter,
     addressSpace: IAddressSpace,
-    map: { [key: number]: string },
+    map: Map<number,string>,
     structureDefinition: StructureDefinition,
     structureDefinitionBase: StructureDefinition | undefined | null,
     name: string,
@@ -129,7 +129,7 @@ function dumpDataTypeStructure(
     xw.endElement();
 }
 
-function dumpDataTypeToBSD(xw: XmlWriter, dataType: UADataType, map: { [key: number]: string }) {
+function dumpDataTypeToBSD(xw: XmlWriter, dataType: UADataType, map: Map<number,string>) {
     const addressSpace = dataType.addressSpace;
 
     const name: string = dataType.browseName.name!;
@@ -163,9 +163,9 @@ export function dumpToBSD(namespace: NamespacePrivate): string {
     xw.writeAttribute("xmlns:ua", "http://opcfoundation.org/UA/");
     xw.writeAttribute("xmlns:tns", namespace.namespaceUri);
 
-    const map: { [key: number]: string } = {};
+    const map: Map<number,string> = new Map();
 
-    map[namespace.index] = "tns";
+    map.set(namespace.index,"tns");
 
     for (const dependantNamespace of dependency) {
         const namespaceIndex = dependantNamespace.index;
@@ -173,7 +173,7 @@ export function dumpToBSD(namespace: NamespacePrivate): string {
             continue;
         }
         const ns = shortcut(dependantNamespace);
-        map[namespaceIndex] = ns;
+        map.set(namespaceIndex,ns);
         xw.writeAttribute(`xmlns:${ns}`, dependantNamespace.namespaceUri);
     }