node-opcua-address-space 2.83.0 → 2.85.0

package/source/pseudo_session.ts

@@ -32,6 +32,96 @@ import { callMethodHelper } from "./helpers/call_helpers";
 import { SessionContext } from "./session_context";
 
 const errorLog = make_errorLog("PseudoSession");
+
+function coerceBrowseDescription(browseDescription: BrowseDescriptionLike): BrowseDescription {
+    if (typeof browseDescription === "string") {
+        return coerceBrowseDescription({
+            nodeId: resolveNodeId(browseDescription)
+        });
+    } else if (browseDescription instanceof BrowseDescription) {
+        return browseDescription;
+    } else {
+        return new BrowseDescription(browseDescription);
+    }
+}
+export interface InnerBrowseEngine {
+    requestedMaxReferencesPerNode: number;
+    maxBrowseContinuationPoints: number;
+    continuationPointManager: ContinuationPointManager;
+    context: ISessionContext;
+    browseAll: (nodesToBrowse: BrowseDescriptionOptions[], callack: ResponseCallback<BrowseResult[]>) => void;
+}
+
+export function innerBrowse(
+    engine: InnerBrowseEngine,
+    nodesToBrowse: BrowseDescriptionOptions[],
+    callback?: ResponseCallback<BrowseResult[]>
+): void {
+    engine.browseAll(nodesToBrowse, (err, results) => {
+        if (err || !results) {
+            return callback!(err);
+        }
+        // handle continuation points
+        results = results.map((result: BrowseResult, index) => {
+            assert(!result.continuationPoint);
+            // istanbul ignore next
+            if (!engine.continuationPointManager) {
+                return new BrowseResult({ statusCode: StatusCodes.BadNoContinuationPoints });
+            }
+            if (index === 0) {
+                // clear previous continuation points
+                engine.continuationPointManager.clearContinuationPoints();
+            }
+            if (engine.continuationPointManager.hasReachedMaximum(engine.maxBrowseContinuationPoints)) {
+                return new BrowseResult({ statusCode: StatusCodes.BadNoContinuationPoints });
+            }
+
+            const truncatedResult = engine.continuationPointManager.registerReferences(
+                engine.requestedMaxReferencesPerNode,
+                result.references || [],
+                { continuationPoint: null, index }
+            );
+            let { statusCode } = truncatedResult;
+            const { continuationPoint, values } = truncatedResult;
+            assert(statusCode === StatusCodes.Good || statusCode === StatusCodes.GoodNoData);
+            statusCode = result.statusCode;
+            return new BrowseResult({
+                statusCode,
+                continuationPoint,
+                references: values
+            });
+        });
+        callback!(null, results);
+    });
+}
+
+export interface InnerBrowseNextEngine {
+    continuationPointManager: ContinuationPointManager;
+}
+export function innerBrowseNext(
+    engine: InnerBrowseNextEngine,
+    continuationPoints: Buffer[],
+    releaseContinuationPoints: boolean,
+    callback?: ResponseCallback<BrowseResult[]>
+): void {
+    const results = continuationPoints
+        .map((continuationPoint: ContinuationPoint, index: number) => {
+            return engine.continuationPointManager.getNextReferences(0, {
+                continuationPoint,
+                index,
+                releaseContinuationPoints
+            });
+        })
+        .map(
+            (r) =>
+                new BrowseResult({
+                    statusCode: r.statusCode,
+                    continuationPoint: r.continuationPoint,
+                    references: r.values
+                })
+        );
+    callback!(null, results);
+}
 /**
  * Pseudo session is an helper object that exposes the same async methods
  * than the ClientSession. It can be used on a server address space.
@@ -44,6 +134,7 @@ const errorLog = make_errorLog("PseudoSession");
  */
 export class PseudoSession implements IBasicSession {
     public requestedMaxReferencesPerNode = 0;
+    public maxBrowseContinuationPoints = 0; // 0=no limits
     private _sessionId: NodeId = new NodeId(NodeIdType.GUID, randomGuid());
     private readonly addressSpace: IAddressSpace;
     private readonly continuationPointManager: ContinuationPointManager;
@@ -63,40 +154,36 @@ export class PseudoSession implements IBasicSession {
     public browse(nodeToBrowse: BrowseDescriptionLike): Promise<BrowseResult>;
     public browse(nodesToBrowse: BrowseDescriptionLike[]): Promise<BrowseResult[]>;
     public browse(nodesToBrowse: BrowseDescriptionLike | BrowseDescriptionLike[], callback?: ResponseCallback<any>): any {
-        setImmediate(() => {
-            const isArray = Array.isArray(nodesToBrowse);
-            if (!isArray) {
-                nodesToBrowse = [nodesToBrowse as BrowseDescriptionLike];
-            }
-            let results: BrowseResult[] = [];
+        const isArray = Array.isArray(nodesToBrowse);
+        if (!isArray) {
+            return this.browse([nodesToBrowse as BrowseDescriptionLike], (err, results) => {
+                return callback!(err, results ? results[0] : undefined);
+            });
+        }
+        const browseAll = (nodesToBrowse: BrowseDescriptionOptions[], callack: ResponseCallback<BrowseResult[]>) => {
+            const results: BrowseResult[] = [];
             for (const browseDescription of nodesToBrowse as BrowseDescriptionOptions[]) {
                 browseDescription.referenceTypeId = resolveNodeId(browseDescription.referenceTypeId!);
-                const _browseDescription =
-                    browseDescription instanceof BrowseDescription ? browseDescription : new BrowseDescription(browseDescription);
+                const _browseDescription = coerceBrowseDescription(browseDescription);
                 const nodeId = resolveNodeId(_browseDescription.nodeId);
                 const r = this.addressSpace.browseSingleNode(nodeId, _browseDescription, this.context);
                 results.push(r);
             }
+            callack(null, results);
+        };
 
-            // handle continuation points
-            results = results.map((result: BrowseResult, index) => {
-                assert(!result.continuationPoint);
-                const r = this.continuationPointManager.registerReferences(
-                    this.requestedMaxReferencesPerNode,
-                    result.references || [],
-                    { continuationPoint: null, index }
-                );
-                let { statusCode } = r;
-                const { continuationPoint, values } = r;
-                assert(statusCode === StatusCodes.Good || statusCode === StatusCodes.GoodNoData);
-                statusCode = result.statusCode;
-                return new BrowseResult({
-                    statusCode,
-                    continuationPoint,
-                    references: values
-                });
-            });
-            callback!(null, isArray ? results : results[0]);
+        setImmediate(() => {
+            innerBrowse(
+                {
+                    browseAll,
+                    context: this.context,
+                    continuationPointManager: this.continuationPointManager,
+                    requestedMaxReferencesPerNode: this.requestedMaxReferencesPerNode,
+                    maxBrowseContinuationPoints: this.maxBrowseContinuationPoints
+                },
+                nodesToBrowse as BrowseDescriptionOptions[],
+                callback
+            );
         });
     }
 
@@ -175,25 +262,12 @@ export class PseudoSession implements IBasicSession {
                     callback!(null, _results![0]);
                 });
             }
-
-            const results = continuationPoints
-                .map((continuationPoint: ContinuationPoint, index: number) => {
-                    return this.continuationPointManager.getNextReferences(0, {
-                        continuationPoint,
-                        index,
-                        releaseContinuationPoints
-                    });
-                })
-                .map(
-                    (r) =>
-                        new BrowseResult({
-                            statusCode: r.statusCode,
-                            continuationPoint: r.continuationPoint,
-                            references: r.values
-                        })
-                );
-
-            callback!(null, results);
+            innerBrowseNext(
+                { continuationPointManager: this.continuationPointManager },
+                continuationPoints,
+                releaseContinuationPoints,
+                callback
+            );
         });
     }
 

package/src/address_space.ts

@@ -123,7 +123,6 @@ function isNodeIdString(str: unknown): boolean {
     return str.substring(0, 2) === "i=" || str.substring(0, 3) === "ns=";
 }
 
-
 /**
  * `AddressSpace` is a collection of UA nodes.
  *
@@ -423,7 +422,9 @@ export class AddressSpace implements AddressSpacePrivate {
         // +-> Structure
         //       +-> Node
         //            +-> ObjectNode
-        if (dataType instanceof NodeId) {
+        if (dataType instanceof UADataTypeImpl) {
+            return this.findDataType(dataType.nodeId);
+        } else if (dataType instanceof NodeId) {
             return _find_by_node_id<UADataType>(this, dataType!, namespaceIndex);
         }
         if (typeof dataType === "number") {
@@ -1346,29 +1347,16 @@ export class AddressSpace implements AddressSpacePrivate {
                 _nodeId = (_nodeId as any).nodeId as NodeId;
             }
             _nodeId = resolveNodeId(_nodeId);
-            /* istanbul ignore next */
-            if (!(_nodeId instanceof NodeId) || _nodeId.isEmpty()) {
-                // tslint:disable:no-console
-                console.log("xx =>", JSON.stringify(params, null, " "));
-                throw new Error(" Invalid reference nodeId " + _nodeId.toString());
-            }
             params.nodeId = _nodeId;
         }
         return new ReferenceImpl(params);
     }
 
-    /**
-     *
-     * @param references
-     */
     public normalizeReferenceTypes(references: AddReferenceOpts[] | ReferenceImpl[] | null): UAReference[] {
         if (!references || references.length === 0) {
             return [];
         }
-        references = references as UAReference[] | AddReferenceOpts[];
-        assert(Array.isArray(references));
-
-        return (references as any).map((el: UAReference | AddReferenceOpts) => this.normalizeReferenceType(el));
+        return references.map((el) => this.normalizeReferenceType(el));
     }
 
     // -- Historical Node  -----------------------------------------------------------------------------------------

package/src/base_node_impl.ts

@@ -237,7 +237,13 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
             _cache.typeDefinitionObj = nodeId ? (this.addressSpace.findNode(nodeId) as UAObjectType | UAVariableType) : null;
         }
         if (!_cache.typeDefinitionObj) {
-            warningLog("cannot find typeDefinitionObj ", this.browseName.toString(), this.nodeId.toString());
+            warningLog(
+                this.nodeClass,
+                "cannot find typeDefinitionObj ",
+                this.browseName.toString(),
+                this.nodeId.toString(),
+                NodeClass[this.nodeClass]
+            );
         }
         return _cache.typeDefinitionObj as UAObjectType | UAVariableType;
     }
@@ -390,7 +396,6 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
         return results;
     }
 
-
     public findReferences_no_cache(referenceTypeNode: UAReferenceType, isForward = true): UAReference[] {
         const _private = BaseNode_getPrivate(this);
         const result: UAReference[] = [];
@@ -500,7 +505,7 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
         //     _cache._notifiers = this.findReferencesAsObject("HasNotifier", true);
         // }
         // return _cache._notifiers;
-        return  this.findReferencesAsObject("HasNotifier", true);
+        return this.findReferencesAsObject("HasNotifier", true);
     }
 
     /**

package/src/base_node_private.ts

@@ -40,6 +40,7 @@ import { UANamespace_process_modelling_rule } from "./namespace_private";
 import { ReferenceImpl } from "./reference_impl";
 import { BaseNodeImpl, getReferenceType } from "./base_node_impl";
 import { AddressSpacePrivate } from "./address_space_private";
+import { wipeMemorizedStuff } from "./tool_isSupertypeOf";
 
 // eslint-disable-next-line prefer-const
 let doTrace = checkDebugFlag("INSTANTIATE");
@@ -126,6 +127,7 @@ export function BaseNode_clearCache(node: BaseNode): void {
     if (_private && _private._cache) {
         _private._cache = {};
     }
+    wipeMemorizedStuff(node);
 }
 const hasTypeDefinition_ReferenceTypeNodeId = resolveNodeId("HasTypeDefinition");
 
@@ -681,6 +683,10 @@ function _cloneInterface(
 
     extraInfo = extraInfo || defaultExtraInfo;
     const addressSpace = node.addressSpace;
+
+    if (node.nodeClass !== NodeClass.Object && node.nodeClass !== NodeClass.Variable) {
+        return;
+    }
     const typeDefinitionNode = node.typeDefinitionObj;
     if (!typeDefinitionNode) {
         return;
@@ -813,25 +819,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/namespace_impl.ts

@@ -10,7 +10,7 @@ import { AxisScaleEnumeration } from "node-opcua-data-access";
 import { AccessRestrictionsFlag, coerceLocalizedText, QualifiedNameLike } from "node-opcua-data-model";
 import { QualifiedName } from "node-opcua-data-model";
 import { BrowseDirection } from "node-opcua-data-model";
-import { LocalizedText, NodeClass } from "node-opcua-data-model";
+import { NodeClass } from "node-opcua-data-model";
 import { dumpIf, make_errorLog } from "node-opcua-debug";
 import { NodeIdLike, NodeIdType, resolveNodeId } from "node-opcua-nodeid";
 import { NodeId } from "node-opcua-nodeid";
@@ -124,7 +124,7 @@ import { UAReferenceTypeImpl } from "./ua_reference_type_impl";
 import { UAViewImpl } from "./ua_view_impl";
 import { UAStateMachineImpl, UATransitionImpl } from "./state_machine/finite_state_machine";
 import { _addMultiStateValueDiscrete } from "./data_access/ua_multistate_value_discrete_impl";
-import { notDeepEqual } from "assert";
+
 
 function _makeHashKey(nodeId: NodeId): string | number {
     switch (nodeId.identifierType) {
@@ -615,7 +615,7 @@ export class NamespaceImpl implements NamespacePrivate {
         assert(!Object.prototype.hasOwnProperty.call(options, "nodeClass"));
         assert(Object.prototype.hasOwnProperty.call(options, "browseName"), "must provide a browseName");
 
-        const options1 = options as any;
+        const options1 = options as unknown as { nodeClass: NodeClass; references: AddReferenceOpts[]; subtypeOf: UADataType };
         options1.nodeClass = NodeClass.DataType;
         options1.references = options.references || [];
 
@@ -638,6 +638,9 @@ export class NamespaceImpl implements NamespacePrivate {
             });
         }
         const node = this.internalCreateNode(options) as UADataType;
+
+        node.propagate_back_references();
+        
         return node;
     }
 

package/src/nodeset_tools/construct_namespace_dependency.ts

@@ -1,9 +1,12 @@
 import { INamespace, UADataType, UAVariable, UAVariableType } from "node-opcua-address-space-base";
 import { NodeClass } from "node-opcua-data-model";
 import { StructureField } from "node-opcua-types";
+import { make_warningLog } from "node-opcua-debug";
 import { NamespacePrivate } from "../namespace_private";
 import { BaseNodeImpl, getReferenceType } from "../base_node_impl";
 
+const warningLog = make_warningLog(__filename);
+
 function _constructNamespaceDependency(
     namespace: INamespace,
     dependency: INamespace[],
@@ -43,6 +46,12 @@ function _constructNamespaceDependency(
         if (_visitedDataType.has(dataType.toString())) {
             return;
         }
+        // istanbul ignore next
+        if (dataTypeNode.nodeClass !== NodeClass.DataType) {
+            warningLog("exploreDataTypes! ignoring ",dataTypeNode.toString());
+            return;
+        }
+
         const namespaceIndex = dataType.namespace;
         consider(namespaceIndex);
         if (dataTypeNode.isStructure()) {

package/src/nodeset_tools/nodeset_to_xml.ts

@@ -35,7 +35,6 @@ import { AttributeIds, Int64, minOPCUADate, StatusCode, StatusCodes } from "node
 import { BrowseDescription, EnumDefinition, StructureDefinition, StructureType } from "node-opcua-types";
 
 import { ITranslationTable, XmlWriter } from "../../source/xml_writer";
-import { NamespacePrivate } from "../namespace_private";
 import { ReferenceImpl } from "../reference_impl";
 import { BaseNodeImpl, getReferenceType } from "../base_node_impl";
 import { UAReferenceTypeImpl } from "../ua_reference_type_impl";
@@ -50,7 +49,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");
@@ -247,6 +250,10 @@ function findXsdNamespaceUri(xw: XmlWriter, nodeId: NodeId): string {
     if (namespace === "http://opcfoundation.org/UA/") {
         return "http://opcfoundation.org/UA/2008/02/Types.xsd";
     }
+    // istanbul ignore next
+    if (!namespace) {
+        return "";
+    }
     return namespace.replace(/\/$/, "") + "/Types.xsd";
 }
 
@@ -628,37 +635,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 +682,6 @@ function _dumpArrayDimensionsAttribute(xw: XmlWriter, node: UAVariableType | UAV
 }
 
 function visitUANode(node: BaseNode, data: DumpData, forward: boolean) {
-
     const addressSpace = node.addressSpace;
 
     // visit references
@@ -800,7 +806,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 +1036,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 +1069,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 +1108,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 +1247,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 +1333,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 +1345,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/tool_isSupertypeOf.ts

@@ -60,6 +60,11 @@ function _slow_isSupertypeOf<T extends UAType>(this: T, Class: typeof BaseNodeIm
 
 export type MemberFuncValue<T, P, R> = (this: T, param: P) => R;
 
+export function wipeMemorizedStuff(node: any) {
+    if (!node.__cache) {
+        node.__cache = undefined;
+    }
+}
 //  http://jsperf.com/underscore-js-memoize-refactor-test
 //  http://addyosmani.com/blog/faster-javascript-memoization/
 function wrap_memoize<T, P, R>(

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