node-opcua-address-space 2.87.0 → 2.89.0

package/dist/src/ua_variable_impl_ext_obj.js

@@ -1,18 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractPartialData = exports._bindExtensionObject = exports._installExtensionObjectBindingOnProperties = exports.setExtensionObjectValue = exports._setExtensionObject = exports.propagateTouchValueUpward = exports._touchValue = void 0;
-const chalk = require("chalk");
+exports.extractPartialData = exports.incrementElement = exports.setElement = exports.getElement = exports._bindExtensionObjectArrayOrMatrix = exports._bindExtensionObject = exports._installExtensionObjectBindingOnProperties = exports.setExtensionObjectPartialValue = exports.propagateTouchValueUpward = exports._touchValue = exports.getProxyTarget = void 0;
 const node_opcua_assert_1 = require("node-opcua-assert");
 const node_opcua_data_model_1 = require("node-opcua-data-model");
 const node_opcua_date_time_1 = require("node-opcua-date-time");
-const node_opcua_data_value_1 = require("node-opcua-data-value");
 const node_opcua_debug_1 = require("node-opcua-debug");
+const node_opcua_extension_object_1 = require("node-opcua-extension-object");
 const node_opcua_nodeid_1 = require("node-opcua-nodeid");
 const node_opcua_status_code_1 = require("node-opcua-status-code");
 const node_opcua_utils_1 = require("node-opcua-utils");
 const node_opcua_variant_1 = require("node-opcua-variant");
-const base_node_private_1 = require("./base_node_private");
 const ua_variable_impl_1 = require("./ua_variable_impl");
+const idx_iterator_1 = require("./idx_iterator");
 const doDebug = (0, node_opcua_debug_1.checkDebugFlag)(__filename);
 const debugLog = (0, node_opcua_debug_1.make_debugLog)(__filename);
 // const doDebug = true; // checkDebugFlag(__filename);
@@ -25,37 +24,61 @@ function w(str, n) {
 function isProxy(ext) {
     return ext.$isProxy ? true : false;
 }
+function getProxyVariable(ext) {
+    (0, node_opcua_assert_1.default)(isProxy(ext));
+    return ext.$variable;
+}
+function getProxyVariableForProp(ext, prop) {
+    const uaVariable = getProxyVariable(ext);
+    if (!uaVariable)
+        return undefined;
+    return uaVariable[prop];
+}
 function getProxyTarget(ext) {
     (0, node_opcua_assert_1.default)(isProxy(ext));
-    return ext.$proxyTarget;
+    const target = ext.$proxyTarget;
+    if (target && isProxy(target)) {
+        return getProxyTarget(target);
+    }
+    return target;
 }
+exports.getProxyTarget = getProxyTarget;
 function unProxy(ext) {
     return isProxy(ext) ? getProxyTarget(ext) : ext;
 }
-function _extensionObjectFieldGetter(target, key /*, receiver*/) {
+function _extensionObjectFieldGetter(getVariable, target, key /*, receiver*/) {
     if (key === "$isProxy") {
         return true;
     }
     if (key === "$proxyTarget") {
         return target;
     }
+    if (key === "$variable") {
+        return getVariable();
+    }
     if (target[key] === undefined) {
         return undefined;
     }
     return target[key];
 }
-function _extensionObjectFieldSetter(variable, target, key, value /*, receiver*/) {
+function _extensionObjectFieldSetter(getVariable, target, key, value /*, receiver*/) {
     target[key] = value;
-    const child = variable[key];
+    if (isProxy(target)) {
+        return true;
+    }
+    const uaVariable = getVariable();
+    if (!uaVariable)
+        return true;
+    const child = uaVariable[key];
     if (child && child.touchValue) {
         child.touchValue();
     }
     return true; // true means the set operation has succeeded
 }
-function makeHandler(variable) {
+function makeHandler(getVariable) {
     const handler = {
-        get: _extensionObjectFieldGetter,
-        set: _extensionObjectFieldSetter.bind(null, variable)
+        get: _extensionObjectFieldGetter.bind(null, getVariable),
+        set: _extensionObjectFieldSetter.bind(null, getVariable)
     };
     return handler;
 }
@@ -79,17 +102,22 @@ function _touchValue(property, now) {
     }
 }
 exports._touchValue = _touchValue;
-function propagateTouchValueUpward(self, now) {
+function propagateTouchValueUpward(self, now, cache) {
     _touchValue(self, now);
     if (self.parent && self.parent.nodeClass === node_opcua_data_model_1.NodeClass.Variable) {
         const parentVar = self.parent;
         if (!parentVar.isExtensionObject())
             return;
-        propagateTouchValueUpward(parentVar, now);
+        if (cache) {
+            if (cache.has(parentVar))
+                return;
+            cache.add(parentVar);
+        }
+        propagateTouchValueUpward(parentVar, now, cache);
     }
 }
 exports.propagateTouchValueUpward = propagateTouchValueUpward;
-function propagateTouchValueDownward(self, now) {
+function propagateTouchValueDownward(self, now, cache) {
     if (!self.isExtensionObject())
         return;
     // also propagate changes to embeded variables
@@ -98,36 +126,19 @@ function propagateTouchValueDownward(self, now) {
     for (const field of definition.fields || []) {
         const property = self.getChildByName(field.name);
         if (property) {
+            if (cache) {
+                if (cache.has(property)) {
+                    continue;
+                }
+                cache.add(property);
+            }
             _touchValue(property, now);
             // to do cascade recursivelly ?
         }
     }
 }
-function _setExtensionObject(self, ext) {
-    // assert(!(ext as any).$isProxy, "internal error ! ExtensionObject has already been proxied !");
-    if (Array.isArray(ext)) {
-        (0, node_opcua_assert_1.default)(self.valueRank === 1, "Only Array is supported for the time being");
-        ext = ext.map((e) => unProxy(e));
-        self.$dataValue.value.arrayType = node_opcua_variant_1.VariantArrayType.Array;
-        self.$extensionObject = ext.map((e) => new Proxy(e, makeHandler(self)));
-        self.$dataValue.value.dataType = node_opcua_variant_1.DataType.ExtensionObject;
-        self.$dataValue.value.value = self.$extensionObject;
-        self.$dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
-        return;
-    }
-    else {
-        ext = unProxy(ext);
-        self.$extensionObject = new Proxy(ext, makeHandler(self));
-        self.$dataValue.value.dataType = node_opcua_variant_1.DataType.ExtensionObject;
-        self.$dataValue.value.value = self.$extensionObject;
-        self.$dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
-    }
-    const now = (0, node_opcua_date_time_1.getCurrentClock)();
-    propagateTouchValueUpward(self, now);
-    propagateTouchValueDownward(self, now);
-}
-exports._setExtensionObject = _setExtensionObject;
-function setExtensionObjectValue(node, partialObject) {
+function setExtensionObjectPartialValue(node, partialObject, sourceTimestamp) {
+    const variablesToUpdate = new Set();
     const extensionObject = node.$extensionObject;
     if (!extensionObject) {
         throw new Error("setExtensionObjectValue node has no extension object " + node.browseName.toString());
@@ -139,13 +150,32 @@ function setExtensionObjectValue(node, partialObject) {
                 _update_extension_object(extObject[prop], partialObject1[prop]);
             }
             else {
-                extObject[prop] = partialObject1[prop];
+                if (isProxy(extObject)) {
+                    // collect element we have to update
+                    const target = getProxyTarget(extObject);
+                    (0, node_opcua_assert_1.default)(!isProxy(target), "something wierd!");
+                    target[prop] = partialObject1[prop];
+                    const variable = getProxyVariableForProp(extObject, prop);
+                    variable && variablesToUpdate.add(variable);
+                }
+                else {
+                    extObject[prop] = partialObject1[prop];
+                }
             }
         }
     }
     _update_extension_object(extensionObject, partialObject);
+    const now = sourceTimestamp || (0, node_opcua_date_time_1.getCurrentClock)();
+    const cache = new Set();
+    for (const c of variablesToUpdate) {
+        if (cache.has(c))
+            continue;
+        propagateTouchValueUpward(c, now, cache);
+        propagateTouchValueDownward(c, now, cache);
+        cache.add(c);
+    }
 }
-exports.setExtensionObjectValue = setExtensionObjectValue;
+exports.setExtensionObjectPartialValue = setExtensionObjectPartialValue;
 function getOrCreateProperty(variableNode, field, options) {
     const dt = variableNode.getDataTypeNode();
     // the namespace for the structure browse name elements
@@ -173,7 +203,10 @@ function getOrCreateProperty(variableNode, field, options) {
             browseName: { namespaceIndex: structureNamespace, name: field.name.toString() },
             componentOf: variableNode,
             dataType: field.dataType,
-            minimumSamplingInterval: variableNode.minimumSamplingInterval
+            minimumSamplingInterval: variableNode.minimumSamplingInterval,
+            accessLevel: variableNode.accessLevel,
+            accessRestrictions: variableNode.accessRestrictions,
+            rolePermissions: variableNode.rolePermissions
         });
         (0, node_opcua_assert_1.default)(property.minimumSamplingInterval === variableNode.minimumSamplingInterval);
     }
@@ -185,121 +218,184 @@ function prepareVariantValue(dataType, value) {
     }
     return value;
 }
-function bindProperty(variableNode, propertyNode, name, dataType) {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    propertyNode.bindVariable({
-        timestamped_get: () => {
-            const propertyValue = variableNode.$extensionObject[name];
-            if (propertyValue === undefined) {
-                propertyNode.$dataValue.value.dataType = node_opcua_variant_1.DataType.Null;
-                propertyNode.$dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
-                propertyNode.$dataValue.value.value = null;
-                return new node_opcua_data_value_1.DataValue(propertyNode.$dataValue);
+function installExt(uaVariable, ext) {
+    ext = unProxy(ext);
+    uaVariable.$extensionObject = new Proxy(ext, makeHandler(() => uaVariable));
+    const addressSpace = uaVariable.addressSpace;
+    const definition = uaVariable.dataTypeObj.getStructureDefinition();
+    const structure = addressSpace.findDataType("Structure");
+    for (const field of definition.fields || []) {
+        if (field.dataType) {
+            const dataTypeNode = addressSpace.findDataType(field.dataType);
+            // istanbul ignore next
+            if (dataTypeNode && dataTypeNode.isSupertypeOf(structure)) {
+                // sub structure .. let make an handler too
+                const camelCaseName = (0, node_opcua_utils_1.lowerFirstLetter)(field.name);
+                const subExtObj = uaVariable.$extensionObject[camelCaseName];
+                if (subExtObj) {
+                    uaVariable.$extensionObject[camelCaseName] = new Proxy(subExtObj, makeHandler(() => {
+                        return uaVariable.getComponentByName(field.name);
+                    }));
+                }
+                else {
+                    warningLog("extension object is null");
+                }
             }
-            const value = prepareVariantValue(dataType, propertyValue);
-            propertyNode.$dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
-            propertyNode.$dataValue.value.dataType = dataType;
-            propertyNode.$dataValue.value.value = value;
-            return new node_opcua_data_value_1.DataValue(propertyNode.$dataValue);
-        },
-        timestamped_set: (_dataValue, callback) => {
-            callback(null, node_opcua_status_code_1.StatusCodes.BadNotWritable);
         }
-    }, true);
+    }
 }
-function _installExtensionObjectBindingOnProperties(variableNode, options) {
-    const addressSpace = variableNode.addressSpace;
-    const dt = variableNode.getDataTypeNode();
+function _installExtensionObjectBindingOnProperties(uaVariable, options) {
+    // may be extension object mechanism has alreday been install
+    // in this case we just need to rebind the properties...
+    if (uaVariable.$extensionObject) {
+        const extObj = uaVariable.$extensionObject;
+        uaVariable.bindExtensionObject(extObj, { createMissingProp: true, force: true });
+        return;
+    }
+    if (uaVariable.$$extensionObjectArray) {
+        const extObj = uaVariable.$$extensionObjectArray;
+        _bindExtensionObjectArrayOrMatrix(uaVariable, extObj, { createMissingProp: true, force: true });
+        return;
+    }
+    const dataValue = uaVariable.readValue();
+    const extObj = dataValue.value.value;
+    if (extObj instanceof node_opcua_extension_object_1.ExtensionObject) {
+        uaVariable.bindExtensionObject(extObj, { createMissingProp: true, force: true });
+    }
+    else if (extObj instanceof Array) {
+        // istanbul ignore else
+        if (dataValue.value.arrayType === node_opcua_variant_1.VariantArrayType.Array || dataValue.value.arrayType === node_opcua_variant_1.VariantArrayType.Matrix) {
+            _bindExtensionObjectArrayOrMatrix(uaVariable, extObj, { createMissingProp: true, force: true });
+        }
+        else {
+            throw new Error("Internal Error, unexpected case");
+        }
+    }
+}
+exports._installExtensionObjectBindingOnProperties = _installExtensionObjectBindingOnProperties;
+function _installFields2(uaVariable, { get, set }, options) {
+    options = options || { createMissingProp: false };
+    const dt = uaVariable.getDataTypeNode();
     const definition = dt.getStructureDefinition();
     for (const field of definition.fields || []) {
-        // istanbul ignore next
         if (node_opcua_nodeid_1.NodeId.sameNodeId(node_opcua_nodeid_1.NodeId.nullNodeId, field.dataType)) {
             warningLog("field.dataType is null ! ", field.name, node_opcua_nodeid_1.NodeId.nullNodeId.toString());
             warningLog(field.toString());
             warningLog(" dataType replaced with BaseDataType ");
             warningLog(definition.toString());
-            field.dataType = variableNode.resolveNodeId("BaseDataType");
+            field.dataType = uaVariable.resolveNodeId("BaseDataType");
         }
-        const propertyNode = getOrCreateProperty(variableNode, field, options);
+        const propertyNode = getOrCreateProperty(uaVariable, field, options);
         if (!propertyNode) {
             continue;
         }
         propertyNode.$dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
-        propertyNode.touchValue();
-        const basicDataType = addressSpace.findCorrespondingBasicDataType(field.dataType);
-        // istanbul ignore next
-        if (doDebug) {
-            const x = addressSpace.findNode(field.dataType).browseName.toString();
-            debugLog(chalk.cyan("xxx"), " dataType", w(field.dataType.toString(), 8), w(field.name, 25), "valueRank", chalk.cyan(w((0, base_node_private_1.valueRankToString)(field.valueRank), 10)), chalk.green(w(x, 15)), "basicType = ", chalk.yellow(w(basicDataType.toString(), 20)), propertyNode.nodeId.toString(), propertyNode.readValue().statusCode.toString());
+        propertyNode.$dataValue.sourceTimestamp = uaVariable.$dataValue.sourceTimestamp;
+        propertyNode.$dataValue.sourcePicoseconds = uaVariable.$dataValue.sourcePicoseconds;
+        propertyNode.$dataValue.serverTimestamp = uaVariable.$dataValue.serverTimestamp;
+        propertyNode.$dataValue.serverPicoseconds = uaVariable.$dataValue.serverPicoseconds;
+        propertyNode.$dataValue.value.dataType = propertyNode.dataTypeObj.basicDataType;
+        propertyNode.$dataValue.value.arrayType = propertyNode.valueRank === -1 ? node_opcua_variant_1.VariantArrayType.Scalar : (propertyNode.valueRank === 1 ? node_opcua_variant_1.VariantArrayType.Array : node_opcua_variant_1.VariantArrayType.Matrix);
+        propertyNode.$dataValue.value.dimensions = propertyNode.valueRank > 1 ? propertyNode.arrayDimensions : null;
+        const fieldName = field.name;
+        installDataValueGetter(propertyNode, () => get(fieldName));
+        (0, node_opcua_assert_1.default)(propertyNode._inner_replace_dataValue);
+        propertyNode._inner_replace_dataValue = (dataValue, indexRange) => {
+            /** */
+            const sourceTime = (0, node_opcua_date_time_1.coerceClock)(dataValue.sourceTimestamp, dataValue.sourcePicoseconds);
+            const value = dataValue.value.value;
+            set(field.name, value, sourceTime);
+        };
+        if (propertyNode.dataTypeObj.basicDataType === node_opcua_variant_1.DataType.ExtensionObject) {
+            _installFields2(propertyNode, {
+                get: (fieldName) => {
+                    const mainFieldName = field.name;
+                    return get(mainFieldName)[(0, node_opcua_utils_1.lowerFirstLetter)(fieldName)];
+                },
+                set: (fieldName, value, sourceTime) => {
+                    const mainFieldName = field.name;
+                    get(mainFieldName)[(0, node_opcua_utils_1.lowerFirstLetter)(fieldName)] = value;
+                }
+            }, options);
         }
-        const camelCaseName = (0, node_opcua_utils_1.lowerFirstLetter)(field.name);
-        // assert(Object.prototype.hasOwnProperty.call(variableNode.$extensionObject, camelCaseName));
-        if (variableNode.$extensionObject[camelCaseName] !== undefined && basicDataType === node_opcua_variant_1.DataType.ExtensionObject) {
-            propertyNode.bindExtensionObject(variableNode.$extensionObject[camelCaseName], Object.assign(Object.assign({}, options), { force: true }));
-            // replace upwards
-            variableNode.$extensionObject[camelCaseName] = propertyNode.$extensionObject;
-        }
-        else {
-            const prop = variableNode.$extensionObject[camelCaseName];
-            if (prop === undefined) {
-                propertyNode._internal_set_value(new node_opcua_variant_1.Variant({
-                    dataType: node_opcua_variant_1.DataType.Null
-                }));
-            }
-            else {
-                const preparedValue = prepareVariantValue(basicDataType, prop);
-                propertyNode._internal_set_value(new node_opcua_variant_1.Variant({
-                    dataType: basicDataType,
-                    value: preparedValue
-                }));
-            }
-            // eslint-disable-next-line @typescript-eslint/no-this-alias
-            //  property.camelCaseName = camelCaseName;
-            propertyNode.setValueFromSource = function (variant) {
-                // eslint-disable-next-line @typescript-eslint/no-this-alias
-                const inner_this = this;
-                const variant1 = node_opcua_variant_1.Variant.coerce(variant);
-                inner_this.verifyVariantCompatibility(variant1);
-                // because self.$extensionObject is a Proxy with handlers that
-                // cascade the chagne we do not need to call touchValue() here
-                variableNode.$extensionObject[camelCaseName] = variant1.value;
-            };
-        }
-        (0, node_opcua_assert_1.default)(propertyNode.readValue().statusCode.equals(node_opcua_status_code_1.StatusCodes.Good));
-        bindProperty(variableNode, propertyNode, camelCaseName, basicDataType);
     }
 }
-exports._installExtensionObjectBindingOnProperties = _installExtensionObjectBindingOnProperties;
-// eslint-disable-next-line complexity
-function _bindExtensionObject(self, optionalExtensionObject, options) {
-    var _a, _b;
-    options = options || { createMissingProp: false };
-    const addressSpace = self.addressSpace;
+function installDataValueGetter(propertyNode, get) {
+    Object.defineProperty(propertyNode.$dataValue.value, "value", { get });
+    const $ = propertyNode.$dataValue;
+    Object.defineProperty(propertyNode, "$dataValue", {
+        get() {
+            return $;
+        },
+        set: (value) => {
+            throw new Error("$dataValue is now frozen and should not be modified this way !\n contact sterfive.com");
+        }
+    });
+}
+function isVariableContainingExtensionObject(uaVariable) {
+    const addressSpace = uaVariable.addressSpace;
     const structure = addressSpace.findDataType("Structure");
-    let extensionObject_;
     if (!structure) {
         // the addressSpace is limited and doesn't provide extension object
         // bindExtensionObject cannot be performed and shall finish here.
-        return null;
+        return false;
     }
     (0, node_opcua_assert_1.default)(structure.browseName.toString() === "Structure", "expecting DataType Structure to be in IAddressSpace");
-    const dt = self.getDataTypeNode();
+    const dt = uaVariable.getDataTypeNode();
     if (!dt.isSupertypeOf(structure)) {
+        return false;
+    }
+    return true;
+}
+function _innerBindExtensionObjectScalar(uaVariable, { get, set }, options) {
+    uaVariable.$dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
+    uaVariable.$dataValue.value.dataType = node_opcua_variant_1.DataType.ExtensionObject;
+    uaVariable.$dataValue.value.arrayType = node_opcua_variant_1.VariantArrayType.Scalar;
+    uaVariable.setValueFromSource = function (variant) {
+        setExtensionObjectPartialValue(this, variant.value);
+    };
+    installDataValueGetter(uaVariable, get);
+    (0, node_opcua_assert_1.default)(uaVariable._inner_replace_dataValue);
+    uaVariable._inner_replace_dataValue = (dataValue, indexRange) => {
+        /** */
+        const ext = dataValue.value.value;
+        const sourceTime = (0, node_opcua_date_time_1.coerceClock)(dataValue.sourceTimestamp, dataValue.sourcePicoseconds);
+        set(ext, sourceTime);
+    };
+    _installFields2(uaVariable, {
+        get: (fieldName) => {
+            const extObj = get();
+            return extObj[(0, node_opcua_utils_1.lowerFirstLetter)(fieldName)];
+        },
+        set: (fieldName, value, sourceTime) => {
+            const extObj = get();
+            extObj[(0, node_opcua_utils_1.lowerFirstLetter)(fieldName)] = value;
+            //1 propagateTouchValueDownward(uaVariable, sourceTime);
+            //1 propagateTouchValueUpward(uaVariable, sourceTime);
+        }
+    }, options);
+}
+function _bindExtensionObject(uaVariable, optionalExtensionObject, options) {
+    var _a, _b;
+    options = options || { createMissingProp: false };
+    if (!isVariableContainingExtensionObject(uaVariable)) {
         return null;
     }
-    if (self.valueRank !== -1 && self.valueRank !== 1) {
+    const addressSpace = uaVariable.addressSpace;
+    let extensionObject_;
+    // istanbul ignore next
+    if (uaVariable.valueRank !== -1 && uaVariable.valueRank !== 1) {
         throw new Error("Cannot bind an extension object here, valueRank must be scalar (-1) or one-dimensional (1)");
     }
     // istanbul ignore next
-    if (doDebug) {
-        debugLog(" ------------------------------ binding ", self.browseName.toString(), self.nodeId.toString());
-    }
+    doDebug && debugLog(" ------------------------------ binding ", uaVariable.browseName.toString(), uaVariable.nodeId.toString());
     // ignore bindExtensionObject on sub extension object, bindExtensionObject has to be called from the top most object
     if (!options.force &&
-        self.parent &&
-        (self.parent.nodeClass === node_opcua_data_model_1.NodeClass.Variable || self.parent.nodeClass === node_opcua_data_model_1.NodeClass.VariableType)) {
-        const parentDataType = self.parent.dataType;
+        uaVariable.parent &&
+        (uaVariable.parent.nodeClass === node_opcua_data_model_1.NodeClass.Variable || uaVariable.parent.nodeClass === node_opcua_data_model_1.NodeClass.VariableType)) {
+        const parentDataType = uaVariable.parent.dataType;
         const dataTypeNode = addressSpace.findNode(parentDataType);
+        const structure = addressSpace.findDataType("Structure");
         // istanbul ignore next
         if (dataTypeNode && dataTypeNode.isSupertypeOf(structure)) {
             // warningLog(
@@ -313,98 +409,182 @@ function _bindExtensionObject(self, optionalExtensionObject, options) {
         }
     }
     // -------------------- make sure we do not bind a variable twice ....
-    if (self.$extensionObject && !optionalExtensionObject) {
+    if (uaVariable.$extensionObject && !optionalExtensionObject) {
         // istanbul ignore next
-        if (!self.checkExtensionObjectIsCorrect(self.$extensionObject)) {
-            warningLog("on node : ", self.browseName.toString(), self.nodeId.toString(), "dataType=", self.dataType.toString({ addressSpace: self.addressSpace }));
-            warningLog((_a = self.$extensionObject) === null || _a === void 0 ? void 0 : _a.toString());
+        if (!uaVariable.checkExtensionObjectIsCorrect(uaVariable.$extensionObject)) {
+            warningLog("on node : ", uaVariable.browseName.toString(), uaVariable.nodeId.toString(), "dataType=", uaVariable.dataType.toString({ addressSpace: uaVariable.addressSpace }));
+            warningLog((_a = uaVariable.$extensionObject) === null || _a === void 0 ? void 0 : _a.toString());
             throw new Error("bindExtensionObject: $extensionObject is incorrect: we are expecting a " +
-                self.dataType.toString({ addressSpace: self.addressSpace }) +
+                uaVariable.dataType.toString({ addressSpace: uaVariable.addressSpace }) +
                 " but we got a " +
-                ((_b = self.$extensionObject) === null || _b === void 0 ? void 0 : _b.constructor.name));
+                ((_b = uaVariable.$extensionObject) === null || _b === void 0 ? void 0 : _b.constructor.name));
         }
-        return self.$extensionObject;
-        // throw new Error("Variable already bound");
+        return uaVariable.$extensionObject;
     }
-    // ------------------------------------------------------
-    // make sure we have a structure
-    // ------------------------------------------------------
-    const s = self.readValue();
     // istanbul ignore next
-    if (self.dataTypeObj.isAbstract) {
-        warningLog("Warning the DataType associated with this Variable is abstract ", self.dataTypeObj.browseName.toString());
+    if (uaVariable.dataTypeObj.isAbstract) {
+        warningLog("Warning the DataType associated with this Variable is abstract ", uaVariable.dataTypeObj.browseName.toString());
         warningLog("You need to provide a extension object yourself ");
         throw new Error("bindExtensionObject requires a extensionObject as associated dataType is only abstract");
     }
+    const s = uaVariable.readValue();
     if (s.value && s.value.dataType === node_opcua_variant_1.DataType.ExtensionObject && s.value.value && optionalExtensionObject) {
         // we want to replace the extension object
         s.value.value = null;
     }
     innerBindExtensionObject();
-    (0, node_opcua_assert_1.default)(self.$extensionObject instanceof Object);
-    return self.$extensionObject;
+    (0, node_opcua_assert_1.default)(uaVariable.$extensionObject instanceof Object);
+    return uaVariable.$extensionObject;
     function innerBindExtensionObject() {
         if (s.value && (s.value.dataType === node_opcua_variant_1.DataType.Null || (s.value.dataType === node_opcua_variant_1.DataType.ExtensionObject && !s.value.value))) {
-            if (self.valueRank === -1 /** Scalar */) {
-                // create a structure and bind it
-                extensionObject_ = optionalExtensionObject || addressSpace.constructExtensionObject(self.dataType, {});
-                // eslint-disable-next-line @typescript-eslint/no-this-alias
-                self.bindVariable({
-                    timestamped_get() {
-                        const d = new node_opcua_data_value_1.DataValue(self.$dataValue);
-                        d.value.value = self.$extensionObject ? self.$extensionObject.clone() : null;
-                        return d;
-                    },
-                    timestamped_set(dataValue, callback) {
-                        const ext = dataValue.value.value;
-                        if (!self.checkExtensionObjectIsCorrect(ext)) {
-                            return callback(null, node_opcua_status_code_1.StatusCodes.BadInvalidArgument);
-                        }
-                        _setExtensionObject(self, ext);
-                        callback(null, node_opcua_status_code_1.StatusCodes.Good);
-                    }
-                }, true);
-                _setExtensionObject(self, extensionObject_);
+            if (uaVariable.valueRank === -1 /** Scalar */) {
+                extensionObject_ = optionalExtensionObject || addressSpace.constructExtensionObject(uaVariable.dataType, {});
+                installExt(uaVariable, extensionObject_);
+                _innerBindExtensionObjectScalar(uaVariable, {
+                    get: () => uaVariable.$extensionObject,
+                    set: (value) => installExt(uaVariable, value)
+                }, options);
+                return;
             }
-            else if (self.valueRank === 1 /** Array */) {
-                // create a structure and bind it
-                extensionObject_ = optionalExtensionObject || [];
-                // eslint-disable-next-line @typescript-eslint/no-this-alias
-                self.bindVariable({
-                    timestamped_get() {
-                        const d = new node_opcua_data_value_1.DataValue(self.$dataValue);
-                        d.value.value = self.$extensionObject
-                            ? self.$extensionObject.map((e) => e.clone())
-                            : null;
-                        return d;
-                    },
-                    timestamped_set(dataValue, callback) {
-                        const ext = dataValue.value.value;
-                        if (!self.checkExtensionObjectIsCorrect(ext)) {
-                            return callback(null, node_opcua_status_code_1.StatusCodes.BadInvalidArgument);
-                        }
-                        _setExtensionObject(self, ext);
-                        callback(null, node_opcua_status_code_1.StatusCodes.Good);
-                    }
-                }, true);
-                _setExtensionObject(self, extensionObject_);
+            else if (uaVariable.valueRank === 1 /** Array */) {
+                throw new Error("Should not get there ! Please fix me");
             }
             else {
-                errorLog(self.toString());
-                errorLog("Unsupported case ! valueRank= ", self.valueRank);
+                errorLog(uaVariable.toString());
+                errorLog("Unsupported case ! valueRank= ", uaVariable.valueRank);
             }
         }
         else {
             // verify that variant has the correct type
             (0, node_opcua_assert_1.default)(s.value.dataType === node_opcua_variant_1.DataType.ExtensionObject);
-            self.$extensionObject = s.value.value;
-            (0, node_opcua_assert_1.default)(self.checkExtensionObjectIsCorrect(self.$extensionObject));
-            (0, node_opcua_assert_1.default)(s.statusCode.equals(node_opcua_status_code_1.StatusCodes.Good));
+            installExt(uaVariable, s.value.value);
+            _innerBindExtensionObjectScalar(uaVariable, {
+                get: () => uaVariable.$extensionObject,
+                set: (value) => installExt(uaVariable, value)
+            }, options);
         }
-        _installExtensionObjectBindingOnProperties(self, options);
     }
 }
 exports._bindExtensionObject = _bindExtensionObject;
+const getIndexAsText = (index) => {
+    if (typeof index === "number")
+        return `${index}`;
+    return `${index.map((a) => a.toString()).join(",")}`;
+};
+const composeBrowseNameAndNodeId = (uaVariable, indexes) => {
+    const iAsText = getIndexAsText(indexes);
+    const browseName = (0, node_opcua_data_model_1.coerceQualifiedName)(iAsText);
+    let nodeId;
+    if (uaVariable.nodeId.identifierType === node_opcua_nodeid_1.NodeIdType.STRING) {
+        nodeId = new node_opcua_nodeid_1.NodeId(node_opcua_nodeid_1.NodeIdType.STRING, uaVariable.nodeId.value + `[${iAsText}]`, uaVariable.nodeId.namespace);
+    }
+    return { browseName, nodeId };
+};
+// eslint-disable-next-line max-statements
+function _bindExtensionObjectArrayOrMatrix(uaVariable, optionalExtensionObjectArray, options) {
+    // istanbul ignore next
+    if (uaVariable.valueRank < 1) {
+        throw new Error("Variable must be a MultiDimensional array");
+    }
+    const arrayDimensions = uaVariable.arrayDimensions || [];
+    // istanbul ignore next
+    if (!isVariableContainingExtensionObject(uaVariable)) {
+        return [];
+    }
+    if ((arrayDimensions.length === 0 || arrayDimensions.length === 1 && arrayDimensions[0] === 0) && optionalExtensionObjectArray) {
+        arrayDimensions[0] = optionalExtensionObjectArray.length;
+    }
+    const totalLength = arrayDimensions.reduce((p, c) => p * c, 1);
+    /** */
+    const addressSpace = uaVariable.addressSpace;
+    if (optionalExtensionObjectArray) {
+        if (optionalExtensionObjectArray.length !== totalLength) {
+            throw new Error(`optionalExtensionObjectArray must have the expected number of element matching ${arrayDimensions}`);
+        }
+    }
+    if (!optionalExtensionObjectArray) {
+        optionalExtensionObjectArray = [];
+        for (let i = 0; i < totalLength; i++) {
+            optionalExtensionObjectArray[i] = addressSpace.constructExtensionObject(uaVariable.dataType, {});
+            ;
+        }
+    }
+    uaVariable.$$extensionObjectArray = optionalExtensionObjectArray;
+    uaVariable.$dataValue.value.arrayType = uaVariable.valueRank === 1 ? node_opcua_variant_1.VariantArrayType.Array : node_opcua_variant_1.VariantArrayType.Matrix;
+    uaVariable.$dataValue.value.dimensions = uaVariable.valueRank === 1 ? null : (uaVariable.arrayDimensions || []);
+    uaVariable.$dataValue.value.dataType = node_opcua_variant_1.DataType.ExtensionObject;
+    uaVariable.$dataValue.value.value = uaVariable.$$extensionObjectArray;
+    uaVariable.bindVariable({
+        get: () => uaVariable.$dataValue.value
+    }, true);
+    const namespace = uaVariable.namespace;
+    const indexIterator = new idx_iterator_1.IndexIterator(arrayDimensions);
+    for (let i = 0; i < totalLength; i++) {
+        const index = indexIterator.next();
+        const { browseName, nodeId } = composeBrowseNameAndNodeId(uaVariable, index);
+        let uaElement = uaVariable.getComponentByName(browseName);
+        if (!uaElement) {
+            uaElement = namespace.addVariable({
+                browseName,
+                nodeId,
+                componentOf: uaVariable,
+                dataType: uaVariable.dataType,
+                valueRank: -1,
+                accessLevel: uaVariable.accessLevel
+            });
+        }
+        uaElement.$dataValue.value.dataType = node_opcua_variant_1.DataType.ExtensionObject;
+        uaElement.$dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
+        uaElement.$dataValue.sourceTimestamp = uaVariable.$dataValue.sourceTimestamp;
+        uaElement.$dataValue.sourcePicoseconds = uaVariable.$dataValue.sourcePicoseconds;
+        uaElement.$dataValue.serverTimestamp = uaVariable.$dataValue.serverTimestamp;
+        uaElement.$dataValue.serverPicoseconds = uaVariable.$dataValue.serverPicoseconds;
+        uaElement.$dataValue.value.dataType = node_opcua_variant_1.DataType.ExtensionObject;
+        uaElement.$dataValue.value.arrayType = node_opcua_variant_1.VariantArrayType.Scalar;
+        {
+            const capturedIndex = i;
+            _innerBindExtensionObjectScalar(uaElement, {
+                get: () => uaVariable.$$extensionObjectArray[capturedIndex],
+                set: (newValue, sourceTimestamp) => {
+                    uaVariable.$$extensionObjectArray[capturedIndex] = newValue;
+                    uaVariable.touchValue();
+                    propagateTouchValueDownward(uaVariable, sourceTimestamp);
+                    propagateTouchValueUpward(uaVariable, sourceTimestamp);
+                },
+            }, Object.assign(Object.assign({}, options), { force: true }));
+        }
+    }
+    return uaVariable.$$extensionObjectArray;
+}
+exports._bindExtensionObjectArrayOrMatrix = _bindExtensionObjectArrayOrMatrix;
+function getElement(path, data) {
+    if (typeof path === "string") {
+        path = path.split(".");
+    }
+    let a = data;
+    for (const e of path) {
+        a = a[e];
+    }
+    return a;
+}
+exports.getElement = getElement;
+function setElement(path, data, value) {
+    if (typeof path === "string") {
+        path = path.split(".");
+    }
+    const last = path.pop();
+    let a = data;
+    for (const e of path) {
+        a = a[e];
+    }
+    a[last] = value;
+}
+exports.setElement = setElement;
+function incrementElement(path, data) {
+    const value = getElement(path, data);
+    setElement(path, data, value + 1);
+}
+exports.incrementElement = incrementElement;
 function extractPartialData(path, extensionObject) {
     let name;
     if (typeof path === "string") {
@@ -431,7 +611,6 @@ function extractPartialData(path, extensionObject) {
     }
     name = path[path.length - 1];
     c1[name] = c2[name];
-    c1[name] += 1;
     return partialData;
 }
 exports.extractPartialData = extractPartialData;