node-opcua-address-space 2.136.0 → 2.138.0

package/src/nodeset_tools/nodeset_to_xml.ts

@@ -46,7 +46,7 @@ import { NamespaceImpl } from "../namespace_impl";
 import { UAMethodImpl } from "../ua_method_impl";
 import { UADataTypeImpl } from "../ua_data_type_impl";
 import { UAVariableTypeImpl } from "../ua_variable_type_impl";
-import { SessionContext } from "../index_current";
+import { AddressSpace, SessionContext } from "../index_current";
 import { UAViewImpl } from "../ua_view_impl";
 
 import { DefinitionMap2 } from "../../source/loader/make_xml_extension_object_parser";
@@ -56,6 +56,7 @@ import {
     constructNamespaceDependency,
     constructNamespacePriorityTable
 } from "./construct_namespace_dependency";
+import { start } from "repl";
 
 // tslint:disable:no-var-requires
 const XMLWriter = require("xml-writer");
@@ -84,7 +85,7 @@ function _dumpDescription(xw: XmlWriter, node: { description?: LocalizedText }):
 
 function translateNodeId(xw: XmlWriter, nodeId: NodeId): NodeId {
     assert(nodeId instanceof NodeId);
-    const nn = xw.translationTable[nodeId.namespace];
+    const nn = xw.translationTable.get(nodeId.namespace);
     const translatedNode = new NodeId(nodeId.identifierType, nodeId.value, nn);
     return translatedNode;
 }
@@ -95,7 +96,7 @@ function n(xw: XmlWriter, nodeId: NodeId): string {
 
 function translateBrowseName(xw: XmlWriter, browseName: QualifiedName): QualifiedName {
     assert(browseName instanceof QualifiedName);
-    const nn = xw.translationTable[browseName.namespaceIndex];
+    const nn = xw.translationTable.get(browseName.namespaceIndex);
     const translatedBrowseName = new QualifiedName({ namespaceIndex: nn, name: browseName.name });
     return translatedBrowseName;
 }
@@ -305,10 +306,13 @@ function _dumpNodeId(xw: XmlWriter, v: NodeId) {
     xw.endElement();
 }
 
-// eslint-disable-next-line complexity
-function _dumpVariantValue(xw: XmlWriter, dataType: DataType, node: UAVariable | UAVariableType, value: any) {
-    const dataTypeNode = node.addressSpace.findDataType(node.dataType)!;
-
+function _dumpVariantValue(
+    xw: XmlWriter,
+    dataTypeNodeId: NodeId,
+    dataType: DataType,
+    addressSpace: IAddressSpace,
+    value: any
+) {
     if (value === undefined || value === null) {
         return;
     }
@@ -317,8 +321,8 @@ function _dumpVariantValue(xw: XmlWriter, dataType: DataType, node: UAVariable |
     }
     const uax = getPrefix(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
     xw.startElement(`${uax}${DataType[dataType]}`);
-    const definitionMap = makeDefinitionMap(node.addressSpace);
-    _dumpVariantInnerValue(xw, dataType, dataTypeNode.nodeId, definitionMap, value);
+    const definitionMap = makeDefinitionMap(addressSpace);
+    _dumpVariantInnerValue(xw, dataType, dataTypeNodeId, definitionMap, addressSpace, value);
     xw.endElement();
 }
 
@@ -326,12 +330,13 @@ function _dumpVariantInnerExtensionObject(
     xw: XmlWriter,
     definitionMap: DefinitionMap2,
     definition: StructureDefinition,
+    addressSpace: IAddressSpace,
     value: ExtensionObject
 ) {
     const namespaceUri = findXsdNamespaceUri(xw, definition.defaultEncodingId);
     const ns = getPrefix(xw, namespaceUri);
 
-    const isUnion = definition.structureType === StructureType.Union || definition.structureType ===  StructureType.UnionWithSubtypedValues;
+    const isUnion = definition.structureType === StructureType.Union || definition.structureType === StructureType.UnionWithSubtypedValues;
 
     for (const field of definition.fields || []) {
         const dataTypeNodeId = field.dataType;
@@ -358,12 +363,19 @@ function _dumpVariantInnerExtensionObject(
                 /** */
             };
             if (definition instanceof StructureDefinition) {
-                fun = _dumpVariantInnerExtensionObject.bind(null, xw, definitionMap, definition);
+                fun = _dumpVariantInnerExtensionObject.bind(null, xw, definitionMap, definition, addressSpace);
             } else if (definition instanceof EnumDefinition) {
                 fun = _dumpVariantInnerValueEnum.bind(null, xw, definition);
+            } else if (definition?.dataType == DataType.Variant) {
+                fun = (value: Variant)=> {
+                    
+                    xw.startElement("Value");
+                    _dumpVariantValue(xw, field.dataType, value.dataType, addressSpace, value.value);
+                    xw.endElement();
+                }
             } else {
                 const baseType = definition.dataType;
-                fun = _dumpVariantInnerValue.bind(null, xw, baseType, dataTypeNodeId, definitionMap);
+                fun = _dumpVariantInnerValue.bind(null, xw, baseType, dataTypeNodeId, definitionMap, addressSpace);
             }
             try {
                 if (field.valueRank === -1) {
@@ -412,6 +424,7 @@ function _dumpVariantInnerValue(
     dataType: DataType,
     dataTypeNodeId: NodeId,
     definitionMap: DefinitionMap2,
+    addressSpace: IAddressSpace,
     value: any
 ): void {
     const uax = getPrefix(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
@@ -468,7 +481,7 @@ function _dumpVariantInnerValue(
             break;
 
         case DataType.ExtensionObject:
-            _dumpVariantExtensionObjectValue(xw, dataTypeNodeId, definitionMap, value as ExtensionObject);
+            _dumpVariantExtensionObjectValue(xw, dataTypeNodeId, definitionMap, addressSpace, value as ExtensionObject);
             break;
         case DataType.XmlElement:
             _dumpXmlElement(xw, value as string);
@@ -476,6 +489,9 @@ function _dumpVariantInnerValue(
         case DataType.StatusCode:
             xw.text((value as StatusCode).value.toString());
             break;
+        case DataType.Variant:
+            _dumpVariantInnerValue(xw, value.dataType, dataTypeNodeId, definitionMap, addressSpace, value.value);
+            break;
         default:
             errorLog("_dumpVariantInnerValue incomplete " + value + " " + "DataType=" + dataType + "=" + DataType[dataType]);
         //  throw new Error("_dumpVariantInnerValue incomplete " + value + " " + "DataType=" + dataType + "=" + DataType[dataType]);
@@ -494,6 +510,7 @@ function _dumpVariantExtensionObjectValue_Body(
     definitionMap: DefinitionMap2,
     name: string,
     definition: StructureDefinition,
+    addressSpace: IAddressSpace,
     value: any
 ) {
     if (value) {
@@ -501,7 +518,7 @@ function _dumpVariantExtensionObjectValue_Body(
         const ns = getPrefix(xw, namespaceUri);
         startElementEx(xw, ns, `${name}`, namespaceUri);
         if (value) {
-            _dumpVariantInnerExtensionObject(xw, definitionMap, definition, value);
+            _dumpVariantInnerExtensionObject(xw, definitionMap, definition, addressSpace, value);
         }
         restoreDefaultNamespace(xw);
         xw.endElement();
@@ -512,6 +529,7 @@ function _dumpVariantExtensionObjectValue(
     xw: XmlWriter,
     dataTypeNodeId: NodeId,
     definitionMap: DefinitionMap2,
+    addressSpace: IAddressSpace,
     value: ExtensionObject
 ) {
     const { name, definition } = definitionMap.findDefinition(dataTypeNodeId);
@@ -537,7 +555,13 @@ function _dumpVariantExtensionObjectValue(
         xw.endElement();
         startElementEx(xw, uax, "Body", "http://opcfoundation.org/UA/2008/02/Types.xsd");
 
-        _dumpVariantExtensionObjectValue_Body(xw, definitionMap, name, definition as StructureDefinition, value);
+        _dumpVariantExtensionObjectValue_Body(
+            xw,
+            definitionMap,
+            name,
+            definition as StructureDefinition,
+            addressSpace,
+            value);
 
         restoreDefaultNamespace(xw);
         xw.endElement();
@@ -554,7 +578,7 @@ function _dumpVariantExtensionObjectValue2(xw: XmlWriter, addressSpace: IAddress
         warningLog("_dumpVariantExtensionObjectValue2: Cannot find dataType for  ", dataTypeNodeId.toString());
         return;
     }
-    _dumpVariantExtensionObjectValue(xw, dataTypeNode.nodeId, definitionMap, value);
+    _dumpVariantExtensionObjectValue(xw, dataTypeNode.nodeId, definitionMap,addressSpace, value);
 }
 
 // eslint-disable-next-line complexity
@@ -677,7 +701,7 @@ function _dumpValue(xw: XmlWriter, node: UAVariable | UAVariableType, variant: V
                 errorLog("_dumpValue : unsupported arrayType: ", variant.arrayType);
         }
     } else {
-        const encodeXml = _dumpVariantValue.bind(null, xw, variant.dataType, node);
+        const encodeXml = _dumpVariantValue.bind(null, xw, node.dataType, variant.dataType, node.addressSpace);
         switch (variant.arrayType) {
             case VariantArrayType.Matrix:
             case VariantArrayType.Array:
@@ -757,7 +781,7 @@ function dumpReferencedNodes(xw: XmlWriter, node: BaseNode, forward: boolean) {
                     assert(typeDefinitionObj instanceof BaseNodeImpl);
                     if (typeDefinitionObj.nodeId.namespace === node.nodeId.namespace) {
                         // only output node if it is on the same namespace
-                        if (!xw.visitedNode[_hash(typeDefinitionObj)]) {
+                        if (!xw.visitedNode.has(_hash(typeDefinitionObj))) {
                             dumpNodeInXml(xw, typeDefinitionObj);
                         }
                     }
@@ -773,7 +797,7 @@ function dumpReferencedNodes(xw: XmlWriter, node: BaseNode, forward: boolean) {
                 assert(r.length === 1);
                 if (subTypeOf.nodeId.namespace === node.nodeId.namespace) {
                     // only output node if it is on the same namespace
-                    if (!xw.visitedNode[_hash(subTypeOf)]) {
+                    if (!xw.visitedNode.has(_hash(subTypeOf))) {
                         dumpNodeInXml(xw, subTypeOf);
                     }
                 }
@@ -785,7 +809,7 @@ function dumpReferencedNodes(xw: XmlWriter, node: BaseNode, forward: boolean) {
             const nodeChild = ReferenceImpl.resolveReferenceNode(addressSpace, reference) as BaseNode;
             assert(nodeChild instanceof BaseNodeImpl);
             if (nodeChild.nodeId.namespace === node.nodeId.namespace) {
-                if (!xw.visitedNode[_hash(nodeChild)]) {
+                if (!xw.visitedNode.has(_hash(nodeChild))) {
                     debugLog(
                         node.nodeId.toString(),
                         " dumping child ",
@@ -1002,14 +1026,14 @@ function dumpUADataType(xw: XmlWriter, node: UADataType) {
 }
 
 function _markAsVisited(xw: XmlWriter, node: BaseNode) {
-    xw.visitedNode = xw.visitedNode || {};
-    assert(!xw.visitedNode[_hash(node)]);
-    xw.visitedNode[_hash(node)] = 1;
+    xw.visitedNode = xw.visitedNode || new Set();
+    assert(!xw.visitedNode.has(_hash(node)));
+    xw.visitedNode.add(_hash(node));
 }
 
 function dumpUAVariable(xw: XmlWriter, node: UAVariable) {
     assert(node.nodeClass === NodeClass.Variable);
-    if (xw.visitedNode[_hash(node)]) {
+    if (xw.visitedNode.has(_hash(node))) {
         return;
     }
     _markAsVisited(xw, node);
@@ -1054,9 +1078,9 @@ function dumpUAVariable(xw: XmlWriter, node: UAVariable) {
 
 function dumpUAVariableType(xw: XmlWriter, node: UAVariableType) {
     assert(node.nodeClass === NodeClass.VariableType);
-    xw.visitedNode = xw.visitedNode || {};
-    assert(!xw.visitedNode[_hash(node)]);
-    xw.visitedNode[_hash(node)] = 1;
+    xw.visitedNode = xw.visitedNode || new Set();
+    assert(!xw.visitedNode.has(_hash(node)));
+    xw.visitedNode.add(_hash(node));
 
     dumpReferencedNodes(xw, node, false);
 
@@ -1112,9 +1136,9 @@ function dumpUAObject(xw: XmlWriter, node: UAObject) {
 
 function _dumpUAObject(xw: XmlWriter, node: UAObject) {
     assert(node.nodeClass === NodeClass.Object);
-    xw.visitedNode = xw.visitedNode || {};
-    assert(!xw.visitedNode[_hash(node)]);
-    xw.visitedNode[_hash(node)] = 1;
+    xw.visitedNode = xw.visitedNode || new Set();
+    assert(!xw.visitedNode.has(_hash(node)));
+    xw.visitedNode.add(_hash(node));
 
     // dump SubTypeOf and HasTypeDefinition
     dumpReferencedNodes(xw, node, false);
@@ -1140,7 +1164,7 @@ function dumpElementInFolder(xw: XmlWriter, node: BaseNodeImpl) {
             return;
         }
 
-        if (!xw.visitedNode[_hash(aggregate)]) {
+        if (!xw.visitedNode.has(_hash(aggregate))) {
             aggregate.dumpXML(xw);
         }
     }
@@ -1161,7 +1185,7 @@ function dumpAggregates(xw: XmlWriter, node: BaseNode) {
         if (_hasHigherPriorityThan(xw, aggregate.nodeId.namespace, node.nodeId.namespace)) {
             continue;
         }
-        if (!xw.visitedNode[_hash(aggregate)]) {
+        if (!xw.visitedNode.has(_hash(aggregate))) {
             (<BaseNodeImpl>aggregate).dumpXML(xw);
         }
     }
@@ -1223,14 +1247,14 @@ function resolveDataTypeName(addressSpace: IAddressSpace, dataType: string | Nod
 function buildUpAliases(node: BaseNode, xw: XmlWriter, data: BuildAliasesData) {
     const addressSpace = node.addressSpace;
 
-    if (!data.aliases_visited) data.aliases_visited = {};
+    if (!data.aliases_visited) data.aliases_visited = new Set();
 
     const k = _hash(node);
     // istanbul ignore next
-    if (data.aliases_visited[k]) {
+    if (data.aliases_visited.has(k)) {
         return;
     }
-    data.aliases_visited[k] = 1;
+    data.aliases_visited.add(k);
 
     // put datatype into aliases list
     if (node.nodeClass === NodeClass.Variable || node.nodeClass === NodeClass.VariableType) {
@@ -1331,7 +1355,7 @@ type NodeIdString = string;
 
 export interface BuildAliasesData {
     aliases: Record<string, NodeIdString>;
-    aliases_visited?: Record<string, unknown>;
+    aliases_visited?: Set<string>;
 }
 interface DumpData extends BuildAliasesData {
     elements: Dumpable[];
@@ -1405,7 +1429,7 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
         if (namespace.index === 0) {
             continue;
         }
-        const translatedIndex = translationTable[namespace.index];
+        const translatedIndex = translationTable.get(namespace.index);
 
         const smallName = `ns${translatedIndex}`;
         xw.writeAttribute(`xmlns:${smallName}`, makeTypeXsd(namespace.namespaceUri));
@@ -1420,10 +1444,12 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
     xw.startElement("NamespaceUris");
 
     // let's sort the dependencies in the same order as the translation table
-    const sortedDependencies = dependency.sort((a, b) => (translationTable[a.index] > translationTable[b.index] ? 1 : -1));
+    const sortedDependencies = dependency.sort(
+        (a, b) => 
+            (translationTable.get(a.index)! > translationTable.get(b.index)! ? 1 : -1));
 
     doDebug && debugLog(sortedDependencies.map((a) => a.index + " + " + a.namespaceUri).join("\n"));
-    doDebug && debugLog("translation table ", translationTable);
+    doDebug && debugLog("translation table ", translationTable.entries());
 
     for (const depend of sortedDependencies) {
         if (depend.index === 0) {
@@ -1462,7 +1488,7 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
     }
     writeAliases(xw, data.aliases);
 
-    xw.visitedNode = {};
+    xw.visitedNode = new Set();
 
     // -------------- writeReferences
     xw.writeComment("ReferenceTypes");
@@ -1494,7 +1520,7 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
         xw.writeComment("DataTypes");
         // xx xw.writeComment(" "+ objectTypes.map(x=>x.browseName.name.toString()).join(" "));
         for (const dataType of dataTypes.sort(sortByNodeId)) {
-            if (!xw.visitedNode[_hash(dataType)]) {
+            if (!xw.visitedNode.has(_hash(dataType))) {
                 dumpNodeInXml(xw, dataType);
             }
         }
@@ -1539,7 +1565,7 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
     const objectTypes = [...this._objectTypeIterator()].sort(sortByBrowseName);
     // xx xw.writeComment(" "+ objectTypes.map(x=>x.browseName.name.toString()).join(" "));
     for (const objectType of objectTypes.sort(sortByNodeId)) {
-        if (!xw.visitedNode[_hash(objectType)]) {
+        if (!xw.visitedNode.has(_hash(objectType))) {
             dumpNodeInXml(xw, objectType);
         }
     }
@@ -1549,7 +1575,7 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
     const variableTypes = [...this._variableTypeIterator()].sort(sortByBrowseName);
     // xx xw.writeComment("ObjectTypes "+ variableTypes.map(x=>x.browseName.name.toString()).join(" "));
     for (const variableType of variableTypes.sort(sortByNodeId)) {
-        if (!xw.visitedNode[_hash(variableType)]) {
+        if (!xw.visitedNode.has(_hash(variableType))) {
             dumpNodeInXml(xw, variableType);
         }
     }
@@ -1558,7 +1584,7 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
     xw.writeComment("Other Nodes");
     const nodes = [...this.nodeIterator()].sort(sortByBrowseName);
     for (const node of nodes.sort(sortByNodeId)) {
-        if (!xw.visitedNode[_hash(node)]) {
+        if (!xw.visitedNode.has(_hash(node))) {
             dumpNodeInXml(xw, node);
         }
     }

package/src/private_namespace.ts

@@ -1,6 +1,7 @@
 
 
 import { Namespace } from "../source/namespace";
+import { NamespacePrivate } from "./namespace_private";
 import { NodeEntry1, NodeIdManager } from "./nodeid_manager";
 
 export function getNodeIdManager(ns: Namespace): NodeIdManager {
@@ -9,7 +10,7 @@ export function getNodeIdManager(ns: Namespace): NodeIdManager {
 }
 export function setSymbols(ns: Namespace, symbols: NodeEntry1[]) {
     const nodeIdManager = getNodeIdManager(ns);
-    (ns.addressSpace.getOwnNamespace() as any).registerSymbolicNames = true;
+    (ns as any).registerSymbolicNames = true;
     nodeIdManager.setSymbols(symbols);
 }
 export function getSymbols(ns: Namespace): NodeEntry1[] {

package/src/tool_isSubtypeOf.ts

@@ -60,11 +60,15 @@ function _slow_isSubtypeOf<T extends UAType>(this: T, Class: typeof BaseNodeImpl
 
 export type MemberFuncValue<T, P, R> = (this: T, param: P) => R;
 
-export function wipeMemorizedStuff(node: any) {
-    if (!node.__cache) {
-        node.__cache = undefined;
+
+const g_WeakMap = new WeakMap<Object, Map<string, unknown>>();
+
+export function wipeMemorizedStuff(node: Object) {
+    if (g_WeakMap.has(node)) {
+        g_WeakMap.delete(node);
     }
 }
+
 //  http://jsperf.com/underscore-js-memoize-refactor-test
 //  http://addyosmani.com/blog/faster-javascript-memoization/
 function wrap_memoize<T, P, R>(
@@ -74,26 +78,25 @@ function wrap_memoize<T, P, R>(
     if (undefined === hashFunc) {
         hashFunc = (_p: T) => (_p as any).toString();
     }
-
     return function memoize(this: any, param: any) {
-        if (!this.__cache) {
-            this.__cache = {};
+        const self = this;
+        if (!g_WeakMap.has(self)) {
+            g_WeakMap.set(self,new Map());
         }
+        const memoMap = g_WeakMap.get(self)!;
 
         const hash = hashFunc!.call(this, param);
-
-        let cache_value = this.__cache[hash];
-
-        if (cache_value === undefined) {
-            cache_value = func.call(this, param);
-            this.__cache[hash] = cache_value;
+        if (memoMap.has(hash)) {
+            return memoMap.get(hash) as R;
         }
-        return cache_value;
+        const cache_value = func.call(this, param);
+        memoMap.set(hash,cache_value);
+        return cache_value as R;
     };
 }
 
 function hashBaseNode(e: BaseNode): string {
-    return e.nodeId.value.toString();
+    return e.nodeId.toString();
 }
 
 export type IsSubtypeOfFunc<T extends UAType> = (this: T, baseType: T) => boolean;
@@ -101,6 +104,7 @@ export type IsSubtypeOfFunc<T extends UAType> = (this: T, baseType: T) => boolea
 export type UAType = UAReferenceType | UADataType | UAObjectType | UAVariableType;
 
 export function construct_isSubtypeOf<T extends UAType>(Class: typeof BaseNodeImpl): IsSubtypeOfFunc<T> {
+
     return wrap_memoize(function (this: T, baseType: T | NodeIdLike): boolean {
         if (!(baseType instanceof Class)) {
             throw new Error(
@@ -136,9 +140,9 @@ export function get_subtypeOf<T extends BaseNode>(this: T): NodeId | null {
 export function get_subtypeOfObj(this: BaseNode): BaseNode | null {
     const _cache = BaseNode_getCache(this);
 
-    if (!_cache._subtypeOfObj) {
+    if (_cache._subtypeOfObj == undefined) {
         const is_subtype_of_ref = this.findReference("HasSubtype", false);
-        if (is_subtype_of_ref) {
+        if (is_subtype_of_ref ) {
             _cache._subtypeOfObj = ReferenceImpl.resolveReferenceNode(this.addressSpace, is_subtype_of_ref);
         } else {
             _cache._subtypeOfObj = null;

package/src/ua_data_type_impl.ts

@@ -151,9 +151,9 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
 
     public getEncodingNode(encoding_name: string): UAObject | null {
         const _cache = BaseNode_getCache(this);
-        _cache._encoding = _cache._encoding || {};
+        _cache._encoding = _cache._encoding || new Map();
         const key = encoding_name + "Node";
-        if (_cache._encoding[key] === undefined) {
+        if (!_cache._encoding.has(key)) {
             assert(encoding_name === "Default Binary" || encoding_name === "Default XML" || encoding_name === "Default JSON");
             // could be binary or xml
             const refs = this.findReferences("HasEncoding", true);
@@ -163,9 +163,10 @@ 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._encoding[key] = node;
+            _cache._encoding.set(key,node);
+            return node
         }
-        return _cache._encoding[key];
+        return _cache._encoding.get(key) || null;
     }
 
     public getEncodingNodeId(encoding_name: string): ExpandedNodeId | null {

package/src/ua_object_type_impl.ts

@@ -82,8 +82,9 @@ export class UAObjectTypeImpl extends BaseNodeImpl implements UAObjectType {
      * @param options
      * @param options.browseName
      * @param [options.description]
-     * @param [options.organizedBy] the parent Folder holding this object
+     * @param [options.organizedBy] the parent Folder holding this object 
      * @param [options.componentOf] the parent Object holding this object
+     * @param [options.addInOf]
      * @param [options.notifierOf]
      * @param [options.eventSourceOf]
      * @param [options.optionals = [] name of the optional child to create
@@ -132,6 +133,7 @@ export class UAObjectTypeImpl extends BaseNodeImpl implements UAObjectType {
             eventSourceOf: options.eventSourceOf,
             notifierOf: options.notifierOf,
             organizedBy: options.organizedBy,
+            addInOf: options.addInOf,
             references,
 
             typeDefinition: this.nodeId,
@@ -147,7 +149,10 @@ export class UAObjectTypeImpl extends BaseNodeImpl implements UAObjectType {
 
         const instance = namespace.addObject(opts);
 
-        initialize_properties_and_components(instance, baseObjectType, this, copyAlsoModellingRules, options.optionals);
+        const copyAlsoAllOptionals = options.copyAlsoAllOptionals || false;
+        initialize_properties_and_components(
+            instance, baseObjectType, this, 
+            copyAlsoModellingRules, copyAlsoAllOptionals, options.optionals);
 
         assert(instance.typeDefinition.toString() === this.nodeId.toString());
 

package/src/ua_reference_type_impl.ts

@@ -53,17 +53,17 @@ function _getAllSubtypes(ref: UAReferenceType) {
     return _cache._allSubTypes;
 }
 
-function _internal_getSubtypeIndex(referenceType: UAReferenceType): { [key: string]: UAReferenceTypePublic } {
+function _internal_getSubtypeIndex(referenceType: UAReferenceType): Map<string,UAReferenceTypePublic> {
     const possibleReferenceTypes = _getAllSubtypes(referenceType);
     // create a index of reference type with browseName as key for faster search
-    const keys: Record<string, UAReferenceType> = {};
+    const keys: Map<string, UAReferenceType> = new Map();
     for (const refType of possibleReferenceTypes) {
-        keys[refType.nodeId.toString()] = refType;
+        keys.set(refType.nodeId.toString(),refType);
     }
     return keys;
 }
 
-function _getSubtypeIndex(referenceType: UAReferenceType): { [key: string]: UAReferenceTypePublic } {
+function _getSubtypeIndex(referenceType: UAReferenceType): Map<string, UAReferenceTypePublic> {
     const _cache = BaseNode_getCache(referenceType);
     if (!_cache._subtype_idx || (_cache._subtype_idxVersion && _cache._subtype_idxVersion < ReferenceTypeCounter.count)) {
         // the cache need to be invalidated
@@ -99,7 +99,7 @@ export class UAReferenceTypeImpl extends BaseNodeImpl implements UAReferenceType
      * returns true if self is  a super type of baseType
      */
     public isSubtypeOf = construct_isSubtypeOf<UAReferenceType>(UAReferenceTypeImpl);
-  
+
     /** @deprecated - use `isSubtypeOf` instead*/
     public isSupertypeOf = construct_isSubtypeOf<UAReferenceType>(UAReferenceTypeImpl);
 
@@ -166,6 +166,6 @@ export class UAReferenceTypeImpl extends BaseNodeImpl implements UAReferenceType
         const _index = _getSubtypeIndex(this);
         const referenceTypeNodeId = ref instanceof ReferenceImpl ? ref.nodeId : (ref as NodeId);
         const _key = referenceTypeNodeId.toString();
-        return !!_index[_key];
+        return _index.has(_key);
     }
 }

package/src/ua_variable_impl.ts

@@ -94,6 +94,7 @@ import {
 import { adjustDataValueStatusCode } from "./data_access/adjust_datavalue_status_code";
 import { _getBasicDataType } from "./get_basic_datatype";
 import { validateDataTypeCorrectness } from "./validate_data_type_correctness";
+import { DataTypeIds } from "node-opcua-constants";
 
 const debugLog = make_debugLog(__filename);
 const warningLog = make_warningLog(__filename);
@@ -1310,6 +1311,9 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
 
     public getDataTypeNode(): UADataType {
         const addressSpace = this.addressSpace;
+        if (this.dataType.isEmpty()) {
+            this.dataType = this.resolveNodeId(DataType.Variant);
+        }
         const dt = addressSpace.findNode(this.dataType);
         // istanbul ignore next
         if (!dt) {

package/src/ua_variable_impl_ext_obj.ts

@@ -204,7 +204,8 @@ function getOrCreateProperty(
 
     // istanbul ignore next
     if (field.dataType.value === DataType.Variant) {
-        warningLog("Warning : variant is not supported in ExtensionObject");
+       // this means that any type of extensions being used here
+       debugLog("Warning : variant is not supported in ExtensionObject");
     }
 
     if (selectedComponents.length === 1) {

package/src/ua_variable_type_impl.ts

@@ -50,8 +50,13 @@ interface InstantiateS {
     propertyOf?: any;
     componentOf?: any;
     modellingRule?: ModellingRuleType;
+    copyAlsoModellingRules?: boolean;
+    copyAlsoAllOptionals?: boolean;
 }
 export function topMostParentIsObjectTypeOrVariableType(addressSpace: AddressSpacePrivate, options: InstantiateS): boolean {
+    if (options.copyAlsoModellingRules) {
+        return true;
+    }
     if (options.modellingRule) {
         return true;
     }
@@ -288,8 +293,13 @@ export class UAVariableTypeImpl extends BaseNodeImpl implements UAVariableType {
         const instance = namespace.addVariable(opts);
 
         // xx assert(instance.minimumSamplingInterval === options.minimumSamplingInterval);
+        const copyAlsoAllOptionals = options.copyAlsoAllOptionals || false;
 
-        initialize_properties_and_components(instance, baseVariableType, this, copyAlsoModellingRules, options.optionals);
+        initialize_properties_and_components(
+            instance, baseVariableType, this, 
+            copyAlsoModellingRules,
+            copyAlsoAllOptionals,
+            options.optionals);
 
         // if VariableType is a type of Structure DataType
         // we need to instantiate a dataValue