node-opcua-address-space 2.76.1 → 2.76.2

package/dist/src/extension_object_array_node.js

@@ -1,277 +1,277 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.removeElement = exports.addElement = exports.bindExtObjArrayNode = exports.createExtObjArrayNode = void 0;
-/**
- * @module node-opcua-address-space.Private
- */
-const node_opcua_assert_1 = require("node-opcua-assert");
-const node_opcua_data_model_1 = require("node-opcua-data-model");
-const node_opcua_debug_1 = require("node-opcua-debug");
-const node_opcua_variant_1 = require("node-opcua-variant");
-const node_opcua_variant_2 = require("node-opcua-variant");
-const node_opcua_variant_3 = require("node-opcua-variant");
-const ua_variable_impl_1 = require("./ua_variable_impl");
-const doDebug = (0, node_opcua_debug_1.checkDebugFlag)(__filename);
-const debugLog = (0, node_opcua_debug_1.make_debugLog)(__filename);
-const errorLog = (0, node_opcua_debug_1.make_errorLog)(__filename);
-/*
- * define a complex Variable containing a array of extension objects
- * each element of the array is also accessible as a component variable.
- *
- */
-function getExtObjArrayNodeValue() {
-    return new node_opcua_variant_1.Variant({
-        arrayType: node_opcua_variant_3.VariantArrayType.Array,
-        dataType: node_opcua_variant_2.DataType.ExtensionObject,
-        value: this.$$extensionObjectArray
-    });
-}
-function removeElementByIndex(uaArrayVariableNode, elementIndex) {
-    const _array = uaArrayVariableNode.$$extensionObjectArray;
-    (0, node_opcua_assert_1.assert)(typeof elementIndex === "number");
-    const addressSpace = uaArrayVariableNode.addressSpace;
-    const extObj = _array[elementIndex];
-    const browseName = uaArrayVariableNode.$$getElementBrowseName(extObj);
-    // remove element from global array (inefficient)
-    uaArrayVariableNode.$$extensionObjectArray.splice(elementIndex, 1);
-    // remove matching component
-    const node = uaArrayVariableNode.getComponentByName(browseName);
-    if (!node) {
-        throw new Error(" cannot find component ");
-    }
-    const hasComponent = uaArrayVariableNode.addressSpace.findReferenceType("HasComponent");
-    // remove the hasComponent reference toward node
-    uaArrayVariableNode.removeReference({
-        isForward: true,
-        nodeId: node.nodeId,
-        referenceType: hasComponent.nodeId
-    });
-    // now check if node has still some parent
-    const parents = node.findReferencesEx("HasChild", node_opcua_data_model_1.BrowseDirection.Inverse);
-    if (parents.length === 0) {
-        addressSpace.deleteNode(node.nodeId);
-    }
-}
-/**
- *
- * create a node Variable that contains a array of ExtensionObject of a given type
- * @method createExtObjArrayNode
- * @param parentFolder
- * @param options
- * @param options.browseName
- * @param options.complexVariableType
- * @param options.variableType        the type of Extension objects stored in the array.
- * @param options.indexPropertyName
- * @return {Object|UAVariable}
- */
-function createExtObjArrayNode(parentFolder, options) {
-    (0, node_opcua_assert_1.assert)(typeof options.variableType === "string");
-    (0, node_opcua_assert_1.assert)(typeof options.indexPropertyName === "string");
-    const addressSpace = parentFolder.addressSpace;
-    const namespace = parentFolder.namespace;
-    const complexVariableType = addressSpace.findVariableType(options.complexVariableType);
-    // istanbul ignore next
-    if (!complexVariableType) {
-        throw new Error("cannot find complex variable type");
-    }
-    (0, node_opcua_assert_1.assert)(!complexVariableType.nodeId.isEmpty());
-    const variableType = addressSpace.findVariableType(options.variableType);
-    if (!variableType) {
-        throw new Error("cannot find variable Type");
-    }
-    (0, node_opcua_assert_1.assert)(!variableType.nodeId.isEmpty());
-    const structure = addressSpace.findDataType("Structure");
-    (0, node_opcua_assert_1.assert)(structure, "Structure Type not found: please check your nodeset file");
-    const dataType = addressSpace.findDataType(variableType.dataType);
-    // istanbul ignore next
-    if (!dataType) {
-        errorLog(variableType.toString());
-        throw new Error("cannot find Data Type");
-    }
-    (0, node_opcua_assert_1.assert)(dataType.isSupertypeOf(structure), "expecting a structure (= ExtensionObject) here ");
-    const inner_options = {
-        componentOf: parentFolder,
-        browseName: options.browseName,
-        dataType: dataType.nodeId,
-        typeDefinition: complexVariableType.nodeId,
-        value: { dataType: node_opcua_variant_2.DataType.ExtensionObject, value: [], arrayType: node_opcua_variant_3.VariantArrayType.Array },
-        valueRank: 1
-    };
-    const uaArrayVariableNode = namespace.addVariable(inner_options);
-    bindExtObjArrayNode(uaArrayVariableNode, options.variableType, options.indexPropertyName);
-    return uaArrayVariableNode;
-}
-exports.createExtObjArrayNode = createExtObjArrayNode;
-function _getElementBrowseName(extObj) {
-    const indexPropertyName1 = this.$$indexPropertyName;
-    if (!Object.prototype.hasOwnProperty.call(extObj, indexPropertyName1)) {
-        console.log(" extension object do not have ", indexPropertyName1, extObj);
-    }
-    // assert(extObj.constructor === addressSpace.constructExtensionObject(dataType));
-    (0, node_opcua_assert_1.assert)(Object.prototype.hasOwnProperty.call(extObj, indexPropertyName1));
-    const browseName = extObj[indexPropertyName1].toString();
-    return browseName;
-}
-;
-/**
- * @method bindExtObjArrayNode
- * @param uaArrayVariableNode
- * @param variableTypeNodeId
- * @param indexPropertyName
- * @return
- */
-function bindExtObjArrayNode(uaArrayVariableNode, variableTypeNodeId, indexPropertyName) {
-    (0, node_opcua_assert_1.assert)(uaArrayVariableNode.valueRank === 1, "expecting a one dimension array");
-    const addressSpace = uaArrayVariableNode.addressSpace;
-    const variableType = addressSpace.findVariableType(variableTypeNodeId);
-    // istanbul ignore next
-    if (!variableType || variableType.nodeId.isEmpty()) {
-        throw new Error("Cannot find VariableType " + variableTypeNodeId.toString());
-    }
-    const structure = addressSpace.findDataType("Structure");
-    // istanbul ignore next
-    if (!structure) {
-        throw new Error("Structure Type not found: please check your nodeset file");
-    }
-    let dataType = addressSpace.findDataType(variableType.dataType);
-    // istanbul ignore next
-    if (!dataType) {
-        throw new Error("Cannot find DataType " + variableType.dataType.toString());
-    }
-    (0, node_opcua_assert_1.assert)(dataType.isSupertypeOf(structure), "expecting a structure (= ExtensionObject) here ");
-    (0, node_opcua_assert_1.assert)(!uaArrayVariableNode.$$variableType, "uaArrayVariableNode has already been bound !");
-    uaArrayVariableNode.$$variableType = variableType;
-    // verify that an object with same doesn't already exist
-    dataType = addressSpace.findDataType(variableType.dataType);
-    (0, node_opcua_assert_1.assert)(dataType.isSupertypeOf(structure), "expecting a structure (= ExtensionObject) here ");
-    uaArrayVariableNode.$$dataType = dataType;
-    uaArrayVariableNode.$$extensionObjectArray = [];
-    uaArrayVariableNode.$$indexPropertyName = indexPropertyName;
-    uaArrayVariableNode.$$getElementBrowseName = _getElementBrowseName;
-    const bindOptions = {
-        get: getExtObjArrayNodeValue,
-        set: undefined // readonly
-    };
-    // bind the readonly
-    uaArrayVariableNode.bindVariable(bindOptions, true);
-    return uaArrayVariableNode;
-}
-exports.bindExtObjArrayNode = bindExtObjArrayNode;
-/**
- * @method addElement
- * add a new element in a ExtensionObject Array variable
- * @param options {Object}   data used to construct the underlying ExtensionObject
- * @param uaArrayVariableNode {UAVariable}
- * @return {UAVariable}
- *
- * @method addElement
- * add a new element in a ExtensionObject Array variable
- * @param nodeVariable a variable already exposing an extension objects
- * @param uaArrayVariableNode {UAVariable}
- * @return {UAVariable}
- *
- * @method addElement
- * add a new element in a ExtensionObject Array variable
- * @param constructor  constructor of the extension object to create
- * @param uaArrayVariableNode {UAVariable}
- * @return {UAVariable}
- */
-function addElement(options /* ExtensionObjectConstructor | ExtensionObject | UAVariable*/, uaArrayVariableNode) {
-    (0, node_opcua_assert_1.assert)(uaArrayVariableNode, " must provide an UAVariable containing the array");
-    // verify that arr has been created correctly
-    (0, node_opcua_assert_1.assert)(!!uaArrayVariableNode.$$variableType && !!uaArrayVariableNode.$$dataType, "did you create the array Node with createExtObjArrayNode ?");
-    (0, node_opcua_assert_1.assert)(uaArrayVariableNode.$$dataType.nodeClass === node_opcua_data_model_1.NodeClass.DataType);
-    const addressSpace = uaArrayVariableNode.addressSpace;
-    const Constructor = addressSpace.getExtensionObjectConstructor(uaArrayVariableNode.$$dataType);
-    (0, node_opcua_assert_1.assert)(Constructor instanceof Function);
-    let extensionObject;
-    let elVar = null;
-    let browseName;
-    if (options instanceof ua_variable_impl_1.UAVariableImpl) {
-        elVar = options;
-        extensionObject = elVar.$extensionObject; // get shared extension object
-        (0, node_opcua_assert_1.assert)(extensionObject instanceof Constructor, "the provided variable must expose a Extension Object of the expected type ");
-        // add a reference
-        uaArrayVariableNode.addReference({
-            isForward: true,
-            nodeId: elVar.nodeId,
-            referenceType: "HasComponent"
-        });
-        // xx elVar.bindExtensionObject();
-    }
-    else {
-        if (options instanceof Constructor) {
-            // extension object has already been created
-            extensionObject = options;
-        }
-        else {
-            extensionObject = addressSpace.constructExtensionObject(uaArrayVariableNode.$$dataType, options);
-        }
-        browseName = uaArrayVariableNode.$$getElementBrowseName(extensionObject);
-        elVar = uaArrayVariableNode.$$variableType.instantiate({
-            browseName,
-            componentOf: uaArrayVariableNode.nodeId,
-            value: { dataType: node_opcua_variant_2.DataType.ExtensionObject, value: extensionObject }
-        });
-        elVar.bindExtensionObject(extensionObject, { force: true });
-        elVar.$extensionObject = extensionObject;
-    }
-    // also add the value inside
-    uaArrayVariableNode.$$extensionObjectArray.push(elVar.$extensionObject);
-    return elVar;
-}
-exports.addElement = addElement;
-/**
- *
- * @method removeElement
- * @param uaArrayVariableNode {UAVariable}
- * @param element {number}   index of element to remove in array
- *
- *
- * @method removeElement
- * @param uaArrayVariableNode {UAVariable}
- * @param element {UAVariable}   node of element to remove in array
- *
- * @method removeElement
- * @param uaArrayVariableNode {UAVariable}
- * @param element {ExtensionObject}   extension object of the node of element to remove in array
- *
- */
-function removeElement(uaArrayVariableNode, element /* number | UAVariable | (a any) => boolean | ExtensionObject */) {
-    (0, node_opcua_assert_1.assert)(element, "removeElement: element must exist");
-    const _array = uaArrayVariableNode.$$extensionObjectArray;
-    // istanbul ignore next
-    if (_array.length === 0) {
-        throw new Error(" cannot remove an element from an empty array ");
-    }
-    let elementIndex = -1;
-    if (typeof element === "number") {
-        // find element by index
-        elementIndex = element;
-        (0, node_opcua_assert_1.assert)(elementIndex >= 0 && elementIndex < _array.length);
-    }
-    else if (element && element.nodeClass) {
-        // find element by name
-        const browseNameToFind = element.browseName.name.toString();
-        elementIndex = _array.findIndex((obj, i) => {
-            const browseName = uaArrayVariableNode.$$getElementBrowseName(obj).toString();
-            return browseName === browseNameToFind;
-        });
-    }
-    else if (typeof element === "function") {
-        // find element by functor
-        elementIndex = _array.findIndex(element);
-    }
-    else {
-        // find element by inner extension object
-        (0, node_opcua_assert_1.assert)(_array[0].constructor.name === element.constructor.name, "element must match");
-        elementIndex = _array.findIndex((x) => x === element);
-    }
-    // istanbul ignore next
-    if (elementIndex < 0) {
-        throw new Error("removeElement: cannot find element matching " + element.toString());
-    }
-    return removeElementByIndex(uaArrayVariableNode, elementIndex);
-}
-exports.removeElement = removeElement;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeElement = exports.addElement = exports.bindExtObjArrayNode = exports.createExtObjArrayNode = void 0;
+/**
+ * @module node-opcua-address-space.Private
+ */
+const node_opcua_assert_1 = require("node-opcua-assert");
+const node_opcua_data_model_1 = require("node-opcua-data-model");
+const node_opcua_debug_1 = require("node-opcua-debug");
+const node_opcua_variant_1 = require("node-opcua-variant");
+const node_opcua_variant_2 = require("node-opcua-variant");
+const node_opcua_variant_3 = require("node-opcua-variant");
+const ua_variable_impl_1 = require("./ua_variable_impl");
+const doDebug = (0, node_opcua_debug_1.checkDebugFlag)(__filename);
+const debugLog = (0, node_opcua_debug_1.make_debugLog)(__filename);
+const errorLog = (0, node_opcua_debug_1.make_errorLog)(__filename);
+/*
+ * define a complex Variable containing a array of extension objects
+ * each element of the array is also accessible as a component variable.
+ *
+ */
+function getExtObjArrayNodeValue() {
+    return new node_opcua_variant_1.Variant({
+        arrayType: node_opcua_variant_3.VariantArrayType.Array,
+        dataType: node_opcua_variant_2.DataType.ExtensionObject,
+        value: this.$$extensionObjectArray
+    });
+}
+function removeElementByIndex(uaArrayVariableNode, elementIndex) {
+    const _array = uaArrayVariableNode.$$extensionObjectArray;
+    (0, node_opcua_assert_1.assert)(typeof elementIndex === "number");
+    const addressSpace = uaArrayVariableNode.addressSpace;
+    const extObj = _array[elementIndex];
+    const browseName = uaArrayVariableNode.$$getElementBrowseName(extObj);
+    // remove element from global array (inefficient)
+    uaArrayVariableNode.$$extensionObjectArray.splice(elementIndex, 1);
+    // remove matching component
+    const node = uaArrayVariableNode.getComponentByName(browseName);
+    if (!node) {
+        throw new Error(" cannot find component ");
+    }
+    const hasComponent = uaArrayVariableNode.addressSpace.findReferenceType("HasComponent");
+    // remove the hasComponent reference toward node
+    uaArrayVariableNode.removeReference({
+        isForward: true,
+        nodeId: node.nodeId,
+        referenceType: hasComponent.nodeId
+    });
+    // now check if node has still some parent
+    const parents = node.findReferencesEx("HasChild", node_opcua_data_model_1.BrowseDirection.Inverse);
+    if (parents.length === 0) {
+        addressSpace.deleteNode(node.nodeId);
+    }
+}
+/**
+ *
+ * create a node Variable that contains a array of ExtensionObject of a given type
+ * @method createExtObjArrayNode
+ * @param parentFolder
+ * @param options
+ * @param options.browseName
+ * @param options.complexVariableType
+ * @param options.variableType        the type of Extension objects stored in the array.
+ * @param options.indexPropertyName
+ * @return {Object|UAVariable}
+ */
+function createExtObjArrayNode(parentFolder, options) {
+    (0, node_opcua_assert_1.assert)(typeof options.variableType === "string");
+    (0, node_opcua_assert_1.assert)(typeof options.indexPropertyName === "string");
+    const addressSpace = parentFolder.addressSpace;
+    const namespace = parentFolder.namespace;
+    const complexVariableType = addressSpace.findVariableType(options.complexVariableType);
+    // istanbul ignore next
+    if (!complexVariableType) {
+        throw new Error("cannot find complex variable type");
+    }
+    (0, node_opcua_assert_1.assert)(!complexVariableType.nodeId.isEmpty());
+    const variableType = addressSpace.findVariableType(options.variableType);
+    if (!variableType) {
+        throw new Error("cannot find variable Type");
+    }
+    (0, node_opcua_assert_1.assert)(!variableType.nodeId.isEmpty());
+    const structure = addressSpace.findDataType("Structure");
+    (0, node_opcua_assert_1.assert)(structure, "Structure Type not found: please check your nodeset file");
+    const dataType = addressSpace.findDataType(variableType.dataType);
+    // istanbul ignore next
+    if (!dataType) {
+        errorLog(variableType.toString());
+        throw new Error("cannot find Data Type");
+    }
+    (0, node_opcua_assert_1.assert)(dataType.isSupertypeOf(structure), "expecting a structure (= ExtensionObject) here ");
+    const inner_options = {
+        componentOf: parentFolder,
+        browseName: options.browseName,
+        dataType: dataType.nodeId,
+        typeDefinition: complexVariableType.nodeId,
+        value: { dataType: node_opcua_variant_2.DataType.ExtensionObject, value: [], arrayType: node_opcua_variant_3.VariantArrayType.Array },
+        valueRank: 1
+    };
+    const uaArrayVariableNode = namespace.addVariable(inner_options);
+    bindExtObjArrayNode(uaArrayVariableNode, options.variableType, options.indexPropertyName);
+    return uaArrayVariableNode;
+}
+exports.createExtObjArrayNode = createExtObjArrayNode;
+function _getElementBrowseName(extObj) {
+    const indexPropertyName1 = this.$$indexPropertyName;
+    if (!Object.prototype.hasOwnProperty.call(extObj, indexPropertyName1)) {
+        console.log(" extension object do not have ", indexPropertyName1, extObj);
+    }
+    // assert(extObj.constructor === addressSpace.constructExtensionObject(dataType));
+    (0, node_opcua_assert_1.assert)(Object.prototype.hasOwnProperty.call(extObj, indexPropertyName1));
+    const browseName = extObj[indexPropertyName1].toString();
+    return browseName;
+}
+;
+/**
+ * @method bindExtObjArrayNode
+ * @param uaArrayVariableNode
+ * @param variableTypeNodeId
+ * @param indexPropertyName
+ * @return
+ */
+function bindExtObjArrayNode(uaArrayVariableNode, variableTypeNodeId, indexPropertyName) {
+    (0, node_opcua_assert_1.assert)(uaArrayVariableNode.valueRank === 1, "expecting a one dimension array");
+    const addressSpace = uaArrayVariableNode.addressSpace;
+    const variableType = addressSpace.findVariableType(variableTypeNodeId);
+    // istanbul ignore next
+    if (!variableType || variableType.nodeId.isEmpty()) {
+        throw new Error("Cannot find VariableType " + variableTypeNodeId.toString());
+    }
+    const structure = addressSpace.findDataType("Structure");
+    // istanbul ignore next
+    if (!structure) {
+        throw new Error("Structure Type not found: please check your nodeset file");
+    }
+    let dataType = addressSpace.findDataType(variableType.dataType);
+    // istanbul ignore next
+    if (!dataType) {
+        throw new Error("Cannot find DataType " + variableType.dataType.toString());
+    }
+    (0, node_opcua_assert_1.assert)(dataType.isSupertypeOf(structure), "expecting a structure (= ExtensionObject) here ");
+    (0, node_opcua_assert_1.assert)(!uaArrayVariableNode.$$variableType, "uaArrayVariableNode has already been bound !");
+    uaArrayVariableNode.$$variableType = variableType;
+    // verify that an object with same doesn't already exist
+    dataType = addressSpace.findDataType(variableType.dataType);
+    (0, node_opcua_assert_1.assert)(dataType.isSupertypeOf(structure), "expecting a structure (= ExtensionObject) here ");
+    uaArrayVariableNode.$$dataType = dataType;
+    uaArrayVariableNode.$$extensionObjectArray = [];
+    uaArrayVariableNode.$$indexPropertyName = indexPropertyName;
+    uaArrayVariableNode.$$getElementBrowseName = _getElementBrowseName;
+    const bindOptions = {
+        get: getExtObjArrayNodeValue,
+        set: undefined // readonly
+    };
+    // bind the readonly
+    uaArrayVariableNode.bindVariable(bindOptions, true);
+    return uaArrayVariableNode;
+}
+exports.bindExtObjArrayNode = bindExtObjArrayNode;
+/**
+ * @method addElement
+ * add a new element in a ExtensionObject Array variable
+ * @param options {Object}   data used to construct the underlying ExtensionObject
+ * @param uaArrayVariableNode {UAVariable}
+ * @return {UAVariable}
+ *
+ * @method addElement
+ * add a new element in a ExtensionObject Array variable
+ * @param nodeVariable a variable already exposing an extension objects
+ * @param uaArrayVariableNode {UAVariable}
+ * @return {UAVariable}
+ *
+ * @method addElement
+ * add a new element in a ExtensionObject Array variable
+ * @param constructor  constructor of the extension object to create
+ * @param uaArrayVariableNode {UAVariable}
+ * @return {UAVariable}
+ */
+function addElement(options /* ExtensionObjectConstructor | ExtensionObject | UAVariable*/, uaArrayVariableNode) {
+    (0, node_opcua_assert_1.assert)(uaArrayVariableNode, " must provide an UAVariable containing the array");
+    // verify that arr has been created correctly
+    (0, node_opcua_assert_1.assert)(!!uaArrayVariableNode.$$variableType && !!uaArrayVariableNode.$$dataType, "did you create the array Node with createExtObjArrayNode ?");
+    (0, node_opcua_assert_1.assert)(uaArrayVariableNode.$$dataType.nodeClass === node_opcua_data_model_1.NodeClass.DataType);
+    const addressSpace = uaArrayVariableNode.addressSpace;
+    const Constructor = addressSpace.getExtensionObjectConstructor(uaArrayVariableNode.$$dataType);
+    (0, node_opcua_assert_1.assert)(Constructor instanceof Function);
+    let extensionObject;
+    let elVar = null;
+    let browseName;
+    if (options instanceof ua_variable_impl_1.UAVariableImpl) {
+        elVar = options;
+        extensionObject = elVar.$extensionObject; // get shared extension object
+        (0, node_opcua_assert_1.assert)(extensionObject instanceof Constructor, "the provided variable must expose a Extension Object of the expected type ");
+        // add a reference
+        uaArrayVariableNode.addReference({
+            isForward: true,
+            nodeId: elVar.nodeId,
+            referenceType: "HasComponent"
+        });
+        // xx elVar.bindExtensionObject();
+    }
+    else {
+        if (options instanceof Constructor) {
+            // extension object has already been created
+            extensionObject = options;
+        }
+        else {
+            extensionObject = addressSpace.constructExtensionObject(uaArrayVariableNode.$$dataType, options);
+        }
+        browseName = uaArrayVariableNode.$$getElementBrowseName(extensionObject);
+        elVar = uaArrayVariableNode.$$variableType.instantiate({
+            browseName,
+            componentOf: uaArrayVariableNode.nodeId,
+            value: { dataType: node_opcua_variant_2.DataType.ExtensionObject, value: extensionObject }
+        });
+        elVar.bindExtensionObject(extensionObject, { force: true });
+        elVar.$extensionObject = extensionObject;
+    }
+    // also add the value inside
+    uaArrayVariableNode.$$extensionObjectArray.push(elVar.$extensionObject);
+    return elVar;
+}
+exports.addElement = addElement;
+/**
+ *
+ * @method removeElement
+ * @param uaArrayVariableNode {UAVariable}
+ * @param element {number}   index of element to remove in array
+ *
+ *
+ * @method removeElement
+ * @param uaArrayVariableNode {UAVariable}
+ * @param element {UAVariable}   node of element to remove in array
+ *
+ * @method removeElement
+ * @param uaArrayVariableNode {UAVariable}
+ * @param element {ExtensionObject}   extension object of the node of element to remove in array
+ *
+ */
+function removeElement(uaArrayVariableNode, element /* number | UAVariable | (a any) => boolean | ExtensionObject */) {
+    (0, node_opcua_assert_1.assert)(element, "removeElement: element must exist");
+    const _array = uaArrayVariableNode.$$extensionObjectArray;
+    // istanbul ignore next
+    if (_array.length === 0) {
+        throw new Error(" cannot remove an element from an empty array ");
+    }
+    let elementIndex = -1;
+    if (typeof element === "number") {
+        // find element by index
+        elementIndex = element;
+        (0, node_opcua_assert_1.assert)(elementIndex >= 0 && elementIndex < _array.length);
+    }
+    else if (element && element.nodeClass) {
+        // find element by name
+        const browseNameToFind = element.browseName.name.toString();
+        elementIndex = _array.findIndex((obj, i) => {
+            const browseName = uaArrayVariableNode.$$getElementBrowseName(obj).toString();
+            return browseName === browseNameToFind;
+        });
+    }
+    else if (typeof element === "function") {
+        // find element by functor
+        elementIndex = _array.findIndex(element);
+    }
+    else {
+        // find element by inner extension object
+        (0, node_opcua_assert_1.assert)(_array[0].constructor.name === element.constructor.name, "element must match");
+        elementIndex = _array.findIndex((x) => x === element);
+    }
+    // istanbul ignore next
+    if (elementIndex < 0) {
+        throw new Error("removeElement: cannot find element matching " + element.toString());
+    }
+    return removeElementByIndex(uaArrayVariableNode, elementIndex);
+}
+exports.removeElement = removeElement;
 //# sourceMappingURL=extension_object_array_node.js.map

package/dist/src/historical_access/address_space_historical_data_node.d.ts

@@ -1,26 +1,26 @@
-/**
- * @module node-opcua-address-space
- * @class IAddressSpace
- */
-import { DataValue } from "node-opcua-data-value";
-import { ReadRawModifiedDetails } from "node-opcua-service-history";
-import { CallbackT } from "node-opcua-status-code";
-import { IAddressSpace, IVariableHistorian, IVariableHistorianOptions, UAVariable } from "node-opcua-address-space-base";
-import { UAVariableImpl } from "../ua_variable_impl";
-export declare class VariableHistorian implements IVariableHistorian {
-    readonly node: UAVariable;
-    private readonly _timeline;
-    private readonly _maxOnlineValues;
-    private lastDate;
-    private lastDatePicoSeconds;
-    constructor(node: UAVariable, options: IVariableHistorianOptions);
-    push(newDataValue: DataValue): any;
-    extractDataValues(historyReadRawModifiedDetails: ReadRawModifiedDetails, maxNumberToExtract: number, isReversed: boolean, reverseDataValue: boolean, callback: CallbackT<DataValue[]>): void;
-}
-/**
- * @method installHistoricalDataNode
- * @param node      UAVariable
- * @param [options] {Object}
- * @param [options.maxOnlineValues = 1000]
- */
-export declare function AddressSpace_installHistoricalDataNode(this: IAddressSpace, node: UAVariableImpl, options?: IVariableHistorianOptions): void;
+/**
+ * @module node-opcua-address-space
+ * @class IAddressSpace
+ */
+import { DataValue } from "node-opcua-data-value";
+import { ReadRawModifiedDetails } from "node-opcua-service-history";
+import { CallbackT } from "node-opcua-status-code";
+import { IAddressSpace, IVariableHistorian, IVariableHistorianOptions, UAVariable } from "node-opcua-address-space-base";
+import { UAVariableImpl } from "../ua_variable_impl";
+export declare class VariableHistorian implements IVariableHistorian {
+    readonly node: UAVariable;
+    private readonly _timeline;
+    private readonly _maxOnlineValues;
+    private lastDate;
+    private lastDatePicoSeconds;
+    constructor(node: UAVariable, options: IVariableHistorianOptions);
+    push(newDataValue: DataValue): any;
+    extractDataValues(historyReadRawModifiedDetails: ReadRawModifiedDetails, maxNumberToExtract: number, isReversed: boolean, reverseDataValue: boolean, callback: CallbackT<DataValue[]>): void;
+}
+/**
+ * @method installHistoricalDataNode
+ * @param node      UAVariable
+ * @param [options] {Object}
+ * @param [options.maxOnlineValues = 1000]
+ */
+export declare function AddressSpace_installHistoricalDataNode(this: IAddressSpace, node: UAVariableImpl, options?: IVariableHistorianOptions): void;