node-opcua-address-space 2.87.0 → 2.88.0

package/src/extension_object_array_node.ts

@@ -23,7 +23,7 @@ const errorLog = make_errorLog(__filename);
  *
  */
 
-function getExtObjArrayNodeValue<T  extends ExtensionObject>(this: UADynamicVariableArray<T>) {
+function getExtObjArrayNodeValue<T extends ExtensionObject>(this: UADynamicVariableArray<T>) {
     return new Variant({
         arrayType: VariantArrayType.Array,
         dataType: DataType.ExtensionObject,
@@ -38,7 +38,7 @@ function removeElementByIndex<T extends ExtensionObject>(uaArrayVariableNode: UA
 
     const addressSpace = uaArrayVariableNode.addressSpace;
     const extObj = _array[elementIndex];
-    const browseName = uaArrayVariableNode.$$getElementBrowseName(extObj);
+    const browseName = uaArrayVariableNode.$$getElementBrowseName(extObj, elementIndex);
 
     // remove element from global array (inefficient)
     uaArrayVariableNode.$$extensionObjectArray.splice(elementIndex, 1);
@@ -68,14 +68,6 @@ function removeElementByIndex<T extends ExtensionObject>(uaArrayVariableNode: UA
 /**
  *
  * 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}
  */
 export function createExtObjArrayNode<T extends ExtensionObject>(parentFolder: UAObject, options: any): UADynamicVariableArray<T> {
     assert(typeof options.variableType === "string");
@@ -126,7 +118,9 @@ export function createExtObjArrayNode<T extends ExtensionObject>(parentFolder: U
 
     return uaArrayVariableNode;
 }
-function _getElementBrowseName<T extends ExtensionObject>(this: UADynamicVariableArray<T>, extObj: ExtensionObject) {
+
+function _getElementBrowseName<T extends ExtensionObject>
+    (this: UADynamicVariableArray<T>, extObj: ExtensionObject, index: number | number[]) {
     const indexPropertyName1 = this.$$indexPropertyName;
 
     if (!Object.prototype.hasOwnProperty.call(extObj, indexPropertyName1)) {
@@ -137,13 +131,7 @@ function _getElementBrowseName<T extends ExtensionObject>(this: UADynamicVariabl
     const browseName = (extObj as any)[indexPropertyName1].toString();
     return browseName;
 };
-/**
- * @method bindExtObjArrayNode
- * @param uaArrayVariableNode
- * @param variableTypeNodeId
- * @param indexPropertyName
- * @return
- */
+
 export function bindExtObjArrayNode<T extends ExtensionObject>(
     uaArrayVariableNode: UADynamicVariableArray<T>,
     variableTypeNodeId: string | NodeId,
@@ -155,26 +143,23 @@ export function bindExtObjArrayNode<T extends ExtensionObject>(
     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());
     }
-    
+
     assert(dataType.isSupertypeOf(structure), "expecting a structure (= ExtensionObject) here ");
 
     assert(!uaArrayVariableNode.$$variableType, "uaArrayVariableNode has already been bound !");
@@ -197,7 +182,6 @@ export function bindExtObjArrayNode<T extends ExtensionObject>(
     };
     // bind the readonly
     uaArrayVariableNode.bindVariable(bindOptions, true);
-
     return uaArrayVariableNode;
 }
 
@@ -208,20 +192,9 @@ export function bindExtObjArrayNode<T extends 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}
  */
 export function addElement<T extends ExtensionObject>(
-    options: any /* ExtensionObjectConstructor | ExtensionObject | UAVariable*/,
+    options: UAVariableImpl | ExtensionObject | Record<string, unknown>,
     uaArrayVariableNode: UADynamicVariableArray<T>
 ): UAVariable {
     assert(uaArrayVariableNode, " must provide an UAVariable containing the array");
@@ -256,19 +229,20 @@ export function addElement<T extends ExtensionObject>(
         });
         // xx elVar.bindExtensionObject();
     } else {
-        if (options instanceof Constructor) {
+        if (options instanceof ExtensionObject) {
             // extension object has already been created
             extensionObject = options as T;
         } else {
             extensionObject = addressSpace.constructExtensionObject(uaArrayVariableNode.$$dataType, options) as T;
         }
-        browseName = uaArrayVariableNode.$$getElementBrowseName(extensionObject);
+        const index = uaArrayVariableNode.$$extensionObjectArray?.length || 0;
+        browseName = uaArrayVariableNode.$$getElementBrowseName(extensionObject, index);
         elVar = uaArrayVariableNode.$$variableType.instantiate({
             browseName,
             componentOf: uaArrayVariableNode.nodeId,
             value: { dataType: DataType.ExtensionObject, value: extensionObject }
         }) as UAVariableImpl;
-        elVar.bindExtensionObject(extensionObject,  { force: true });
+        elVar.bindExtensionObject(extensionObject, { force: true });
         elVar.$extensionObject = extensionObject;
     }
 
@@ -279,19 +253,6 @@ export function addElement<T extends ExtensionObject>(
 }
 
 /**
- *
- * @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
  *
  */
 export function removeElement<T extends ExtensionObject>(
@@ -305,7 +266,7 @@ export function removeElement<T extends ExtensionObject>(
     if (_array.length === 0) {
         throw new Error(" cannot remove an element from an empty array ");
     }
-    
+
     let elementIndex = -1;
 
     if (typeof element === "number") {
@@ -316,7 +277,7 @@ export function removeElement<T extends ExtensionObject>(
         // find element by name
         const browseNameToFind = element.browseName.name!.toString();
         elementIndex = _array.findIndex((obj: any, i: number) => {
-            const browseName = uaArrayVariableNode.$$getElementBrowseName(obj).toString();
+            const browseName = uaArrayVariableNode.$$getElementBrowseName(obj, elementIndex).toString();
             return browseName === browseNameToFind;
         });
     } else if (typeof element === "function") {
@@ -327,7 +288,7 @@ export function removeElement<T extends ExtensionObject>(
         assert(_array[0].constructor.name === (element as any).constructor.name, "element must match");
         elementIndex = _array.findIndex((x: any) => x === element);
     }
-    
+
     // istanbul ignore next
     if (elementIndex < 0) {
         throw new Error("removeElement: cannot find element matching " + element.toString());

package/src/idx_iterator.ts

@@ -0,0 +1,52 @@
+
+
+
+
+export class IndexIterator {
+
+    public current: number[] | null = null;
+    constructor(private limits: number[]) {
+        this.reset();
+    }
+    public reset() {
+        this.current = [];
+        for (let i = 0; i < this.limits.length; i++) {
+            this.current[i] = 0;
+        }
+    }
+    public increment() {
+        if (!this.current) return;
+
+
+        const increase = (n: number): boolean => {
+            if (n < 0) {
+                return false;
+            }
+            if (!this.current) return false;
+            if (this.current[n] + 1 >= this.limits[n]) {
+                if (n==0) {
+                    this.current = null;
+                    return false;
+                }
+                this.current[n] = 0;
+                return increase(n - 1);
+            }
+            this.current[n] = this.current[n] + 1;
+            return true;
+        }
+        const n = this.limits.length - 1;
+        if (!increase(n)) {
+            this.current = null;
+        }
+    }
+    public next(): number[] {
+        if (!this.current) {
+            throw new Error("Outof bond");
+        }
+        const r = [... this.current];
+        this.increment();
+        return r;
+    }
+
+
+}

package/src/ua_variable_impl.ts

@@ -28,7 +28,8 @@ import {
     AccessLevelFlag,
     makeAccessLevelFlag,
     AttributeIds,
-    isDataEncoding
+    isDataEncoding,
+    QualifiedName
 } from "node-opcua-data-model";
 import { extractRange, sameDataValue, DataValue, DataValueLike, DataValueT } from "node-opcua-data-value";
 import { coerceClock, getCurrentClock, PreciseClock } from "node-opcua-date-time";
@@ -87,6 +88,8 @@ import {
     propagateTouchValueUpward,
     setExtensionObjectValue,
     _bindExtensionObject,
+    _bindExtensionObjectArray,
+    _bindExtensionObjectMatrix,
     _installExtensionObjectBindingOnProperties,
     _setExtensionObject,
     _touchValue
@@ -1471,24 +1474,41 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
      * @return {ExtensionObject}
      */
     public bindExtensionObjectScalar(
-        optionalExtensionObject: ExtensionObject,
+        optionalExtensionObject?: ExtensionObject,
         options?: BindExtensionObjectOptions
     ): ExtensionObject | null {
-        return this.bindExtensionObject(optionalExtensionObject, options) as ExtensionObject | null;
+        return _bindExtensionObject(this, optionalExtensionObject, options) as ExtensionObject;
     }
 
     public bindExtensionObjectArray(
-        optionalExtensionObject: ExtensionObject[],
+        optionalExtensionObject?: ExtensionObject[],
         options?: BindExtensionObjectOptions
     ): ExtensionObject[] | null {
-        return this.bindExtensionObject(optionalExtensionObject, options) as ExtensionObject[] | null;
+        assert(this.valueRank === 1, "expecting a Array variable here");
+        return _bindExtensionObjectArray(this, optionalExtensionObject, options) as ExtensionObject[];
     }
 
     public bindExtensionObject(
         optionalExtensionObject?: ExtensionObject | ExtensionObject[],
         options?: BindExtensionObjectOptions
     ): ExtensionObject | ExtensionObject[] | null {
-        return _bindExtensionObject(this, optionalExtensionObject, options);
+        if (optionalExtensionObject) {
+            if (optionalExtensionObject instanceof Array) {
+                return this.bindExtensionObjectArray(optionalExtensionObject, options);
+            } else {
+                return this.bindExtensionObjectScalar(optionalExtensionObject, options);
+            }
+        }
+        assert(optionalExtensionObject === undefined);
+        if (this.valueRank === -1) {
+            return this.bindExtensionObjectScalar(undefined, options);
+        } else if (this.valueRank === 1) {
+            return this.bindExtensionObjectArray(undefined, options);
+        } else if (this.valueRank > 1) {
+            return _bindExtensionObjectMatrix(this, undefined, options);
+        }
+        //  unsupported case ... 
+        return null;
     }
 
     public updateExtensionObjectPartial(partialExtensionObject?: { [key: string]: any }): ExtensionObject {
@@ -1830,14 +1850,15 @@ UAVariableImpl.prototype.writeAttribute = thenify.withCallback(UAVariableImpl.pr
 UAVariableImpl.prototype.historyRead = thenify.withCallback(UAVariableImpl.prototype.historyRead);
 UAVariableImpl.prototype.readValueAsync = thenify.withCallback(UAVariableImpl.prototype.readValueAsync);
 
-export interface UAVariableImpl {
-    $$variableType?: any;
-    $$dataType?: any;
-    $$getElementBrowseName: any;
-    $$extensionObjectArray: any;
-    $$indexPropertyName: any;
+export interface UAVariableImplExtArray {
+    $$variableType?: UAVariableType;
+    $$dataType: UADataType;
+    $$getElementBrowseName: (extObject: ExtensionObject, index: number | number[]) => QualifiedName;
+    $$extensionObjectArray: ExtensionObject[];
+    $$indexPropertyName: string;
+}
+export interface UAVariableImpl extends UAVariableImplExtArray {
 }
-
 function check_valid_array(dataType: DataType, array: any): boolean {
     if (Array.isArray(array)) {
         return true;

package/src/ua_variable_impl_ext_obj.ts

@@ -1,12 +1,12 @@
 import * as chalk from "chalk";
 import assert from "node-opcua-assert";
-import { BindExtensionObjectOptions, UADataType, UAVariable, UAVariableType } from "node-opcua-address-space-base";
-import { NodeClass } from "node-opcua-data-model";
-import { getCurrentClock, PreciseClock } from "node-opcua-date-time";
+import { BindExtensionObjectOptions, UADataType, UADynamicVariableArray, UAVariable, UAVariableType } from "node-opcua-address-space-base";
+import { coerceQualifiedName, NodeClass } from "node-opcua-data-model";
+import { getCurrentClock, PreciseClock, DateWithPicoseconds, coerceClock } from "node-opcua-date-time";
 import { DataValue } from "node-opcua-data-value";
 import { make_debugLog, make_warningLog, checkDebugFlag, make_errorLog } from "node-opcua-debug";
 import { ExtensionObject } from "node-opcua-extension-object";
-import { NodeId } from "node-opcua-nodeid";
+import { coerceNodeId, NodeId, NodeIdType } from "node-opcua-nodeid";
 import { StatusCodes, CallbackT, StatusCode } from "node-opcua-status-code";
 import { StructureField } from "node-opcua-types";
 import { lowerFirstLetter } from "node-opcua-utils";
@@ -15,6 +15,9 @@ import { DataType, Variant, VariantLike, VariantArrayType } from "node-opcua-var
 import { valueRankToString } from "./base_node_private";
 import { UAVariableImpl } from "./ua_variable_impl";
 import { UADataTypeImpl } from "./ua_data_type_impl";
+import { bindExtObjArrayNode } from "./extension_object_array_node";
+import { IndexIterator } from "./idx_iterator";
+import { DateTime } from "node-opcua-basic-types";
 
 const doDebug = checkDebugFlag(__filename);
 const debugLog = make_debugLog(__filename);
@@ -114,7 +117,7 @@ function propagateTouchValueDownward(self: UAVariableImpl, now: PreciseClock): v
     }
 }
 
-export function _setExtensionObject(self: UAVariableImpl, ext: ExtensionObject | ExtensionObject[]): void {
+export function _setExtensionObject(self: UAVariableImpl, ext: ExtensionObject | ExtensionObject[], sourceTimestamp?: PreciseClock): void {
     // assert(!(ext as any).$isProxy, "internal error ! ExtensionObject has already been proxied !");
     if (Array.isArray(ext)) {
         assert(self.valueRank === 1, "Only Array is supported for the time being");
@@ -133,7 +136,7 @@ export function _setExtensionObject(self: UAVariableImpl, ext: ExtensionObject |
         self.$dataValue.statusCode = StatusCodes.Good;
     }
 
-    const now = getCurrentClock();
+    const now = sourceTimestamp || getCurrentClock();
     propagateTouchValueUpward(self, now);
     propagateTouchValueDownward(self, now);
 }
@@ -193,7 +196,10 @@ function getOrCreateProperty(
             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
         }) as UAVariableImpl;
         assert(property.minimumSamplingInterval === variableNode.minimumSamplingInterval);
     }
@@ -226,17 +232,46 @@ function bindProperty(variableNode: UAVariableImpl, propertyNode: UAVariableImpl
                 return new DataValue(propertyNode.$dataValue);
             },
             timestamped_set: (_dataValue: DataValue, callback: CallbackT<StatusCode>) => {
-                callback(null, StatusCodes.BadNotWritable);
+
+                propertyNode.setValueFromSource(_dataValue.value, _dataValue.statusCode, _dataValue.sourceTimestamp || new Date());
+                // callback(null, StatusCodes.BadNotWritable);
+                callback(null, StatusCodes.Good);
             }
         },
         true
     );
 }
 
+
+function _initial_setup(variableNode: UAVariableImpl) {
+    const dataValue = variableNode.readValue();
+    const extObj = dataValue.value.value;
+    if (extObj instanceof ExtensionObject) {
+        variableNode.bindExtensionObject(extObj, { createMissingProp: true, force: true });
+    } else if (extObj instanceof Array) {
+        if (dataValue.value.arrayType === VariantArrayType.Array) {
+            variableNode.bindExtensionObjectArray(extObj, { createMissingProp: true, force: true });
+        } else if (dataValue.value.arrayType === VariantArrayType.Matrix) {
+            _bindExtensionObjectMatrix(variableNode, extObj, { createMissingProp: true, force: true });
+        } else {
+            throw new Error("Internal Error, unexpected case");
+        }
+    } else {
+        const msg = `variableNode ${variableNode.browseName.toString()} doesn't have $extensionObject property`;
+        errorLog(msg);
+        errorLog(dataValue.toString());
+        throw new Error(msg);
+    }
+}
 export function _installExtensionObjectBindingOnProperties(
     variableNode: UAVariableImpl,
     options: BindExtensionObjectOptions
 ): void {
+
+    if (!variableNode.$extensionObject) {
+        _initial_setup(variableNode);
+        return;
+    }
     const addressSpace = variableNode.addressSpace;
     const dt = variableNode.getDataTypeNode();
     const definition = dt.getStructureDefinition();
@@ -256,7 +291,12 @@ export function _installExtensionObjectBindingOnProperties(
             continue;
         }
         propertyNode.$dataValue.statusCode = StatusCodes.Good;
-        propertyNode.touchValue();
+        propertyNode.$dataValue.sourceTimestamp = variableNode.$dataValue.sourceTimestamp;
+        propertyNode.$dataValue.sourcePicoseconds = variableNode.$dataValue.sourcePicoseconds;
+        propertyNode.$dataValue.serverTimestamp = variableNode.$dataValue.serverTimestamp;
+        propertyNode.$dataValue.serverPicoseconds = variableNode.$dataValue.serverPicoseconds;
+
+        //xx propertyNode.touchValue();
 
         const basicDataType = addressSpace.findCorrespondingBasicDataType(field.dataType);
 
@@ -322,36 +362,43 @@ export function _installExtensionObjectBindingOnProperties(
     }
 }
 
-// eslint-disable-next-line complexity
-export function _bindExtensionObject(
-    self: UAVariableImpl,
-    optionalExtensionObject?: ExtensionObject | ExtensionObject[],
-    options?: BindExtensionObjectOptions
-): ExtensionObject | ExtensionObject[] | null {
-    options = options || { createMissingProp: false };
-
-
-    const addressSpace = self.addressSpace;
+function isVariableContainingExtensionObject(uaVariable: UAVariableImpl): boolean {
+    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;
     }
 
     assert(structure.browseName.toString() === "Structure", "expecting DataType Structure to be in IAddressSpace");
 
-    const dt = self.getDataTypeNode() as UADataTypeImpl;
+    const dt = uaVariable.getDataTypeNode() as UADataTypeImpl;
     if (!dt.isSupertypeOf(structure)) {
+        return false;
+    }
+    return true;
+
+}
+// eslint-disable-next-line complexity
+export function _bindExtensionObject(
+    self: UAVariableImpl,
+    optionalExtensionObject?: ExtensionObject | ExtensionObject[],
+    options?: BindExtensionObjectOptions
+): ExtensionObject | ExtensionObject[] | null {
+    options = options || { createMissingProp: false };
+
+    if (!isVariableContainingExtensionObject(self)) {
         return null;
     }
+    const addressSpace = self.addressSpace;
+    let extensionObject_;
 
-    if (self.valueRank !== -1 && self.valueRank !==1) {
+    if (self.valueRank !== -1 && self.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());
@@ -365,6 +412,7 @@ export function _bindExtensionObject(
     ) {
         const parentDataType = (self.parent as UAVariable | UAVariableType).dataType;
         const dataTypeNode = addressSpace.findNode(parentDataType) as UADataType;
+        const structure = addressSpace.findDataType("Structure")!;
         // istanbul ignore next
         if (dataTypeNode && dataTypeNode.isSupertypeOf(structure)) {
             // warningLog(
@@ -392,9 +440,9 @@ export function _bindExtensionObject(
             warningLog(self.$extensionObject?.toString());
             throw new Error(
                 "bindExtensionObject: $extensionObject is incorrect: we are expecting a " +
-                    self.dataType.toString({ addressSpace: self.addressSpace }) +
-                    " but we got a " +
-                    self.$extensionObject?.constructor.name
+                self.dataType.toString({ addressSpace: self.addressSpace }) +
+                " but we got a " +
+                self.$extensionObject?.constructor.name
             );
         }
         return self.$extensionObject;
@@ -422,6 +470,10 @@ export function _bindExtensionObject(
     return self.$extensionObject;
 
     function innerBindExtensionObject() {
+        const makePreciseClock = (sourceTimestamp: DateTime, picoseconds?: number): PreciseClock =>
+            ({ timestamp: sourceTimestamp as DateWithPicoseconds, picoseconds: picoseconds || 0 });
+
+
         if (s.value && (s.value.dataType === DataType.Null || (s.value.dataType === DataType.ExtensionObject && !s.value.value))) {
             if (self.valueRank === -1 /** Scalar */) {
                 // create a structure and bind it
@@ -439,13 +491,16 @@ export function _bindExtensionObject(
                             if (!self.checkExtensionObjectIsCorrect(ext)) {
                                 return callback(null, StatusCodes.BadInvalidArgument);
                             }
-                            _setExtensionObject(self, ext);
+                            const sourceTime = coerceClock(dataValue.sourceTimestamp, dataValue.sourcePicoseconds);
+                            _setExtensionObject(self, ext, sourceTime);
                             callback(null, StatusCodes.Good);
                         }
                     },
                     true
                 );
-                _setExtensionObject(self, extensionObject_);
+                const sourceTime = coerceClock(self.$dataValue.sourceTimestamp, self.$dataValue.sourcePicoseconds);
+                _setExtensionObject(self, extensionObject_, sourceTime);
+
             } else if (self.valueRank === 1 /** Array */) {
                 // create a structure and bind it
 
@@ -462,17 +517,19 @@ export function _bindExtensionObject(
                             return d;
                         },
                         timestamped_set(dataValue: DataValue, callback: CallbackT<StatusCode>) {
-                            const ext = dataValue.value.value;
-                            if (!self.checkExtensionObjectIsCorrect(ext)) {
+                            const extensionObjectArray = dataValue.value.value;
+                            if (!self.checkExtensionObjectIsCorrect(extensionObjectArray)) {
                                 return callback(null, StatusCodes.BadInvalidArgument);
                             }
-                            _setExtensionObject(self, ext);
+                            const sourceTime = coerceClock(dataValue.sourceTimestamp, dataValue.sourcePicoseconds);
+                            _setExtensionObject(self, extensionObjectArray, sourceTime);
                             callback(null, StatusCodes.Good);
                         }
                     },
                     true
                 );
-                _setExtensionObject(self, extensionObject_);
+                const sourceTime = coerceClock(self.$dataValue.sourceTimestamp, self.$dataValue.sourcePicoseconds);
+                _setExtensionObject(self, extensionObject_, sourceTime);
             } else {
                 errorLog(self.toString());
                 errorLog("Unsupported case ! valueRank= ", self.valueRank);
@@ -488,6 +545,102 @@ export function _bindExtensionObject(
     }
 }
 
+const getIndexAsText = (index: number | number[]): string => {
+    if (typeof index === "number")
+        return `${index}`;
+    return `${index.map((a) => a.toString()).join(",")}`;
+}
+const composeBrowseNameAndNodeId = (uaVariable: UAVariable, indexes: number[]) => {
+    const iAsText = getIndexAsText(indexes);
+    const browseName = coerceQualifiedName(iAsText);
+    let nodeId: NodeId | undefined;
+    if (uaVariable.nodeId.identifierType === NodeIdType.STRING) {
+        nodeId = new NodeId(NodeIdType.STRING, uaVariable.nodeId.value as string + `[${iAsText}]`, uaVariable.nodeId.namespace);
+    }
+    return { browseName, nodeId };
+}
+
+export function _bindExtensionObjectArray(
+    uaVariable: UAVariableImpl,
+    optionalExtensionObjectArray?: ExtensionObject[],
+    options?: BindExtensionObjectOptions
+): ExtensionObject[] {
+    return _bindExtensionObjectMatrix(uaVariable, optionalExtensionObjectArray, options);
+}
+export function _bindExtensionObjectMatrix(
+    uaVariable: UAVariableImpl,
+    optionalExtensionObjectArray?: ExtensionObject[],
+    options?: BindExtensionObjectOptions
+): ExtensionObject[] {
+
+    if (uaVariable.valueRank < 1) {
+        throw new Error("Variable must be a MultiDimensional array");
+    }
+    const arrayDimensions = uaVariable.arrayDimensions || [];
+
+    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.$$getElementBrowseName = getElementBrowseNameByIndex;
+
+    uaVariable.bindVariable({
+        get: () => new Variant({
+            arrayType: VariantArrayType.Array,
+            dataType: DataType.ExtensionObject,
+            value: uaVariable.$$extensionObjectArray
+        })
+    }, true);
+    const namespace = uaVariable.namespace;
+    const indexIterator = new IndexIterator(arrayDimensions);
+    for (let i = 0; i < totalLength; i++) {
+
+        const index = indexIterator.next();
+
+        const { browseName, nodeId } = composeBrowseNameAndNodeId(uaVariable, index);
+
+        const uaElement = namespace.addVariable({
+            browseName,
+            nodeId,
+            componentOf: uaVariable,
+            dataType: uaVariable.dataType,
+            valueRank: -1,
+            accessLevel: uaVariable.userAccessLevel
+        });
+        {
+            const capturedIndex = i;
+            uaElement.bindVariable({
+                get: () => new Variant({
+                    dataType: DataType.ExtensionObject,
+                    arrayType: VariantArrayType.Scalar,
+                    value: uaVariable.$$extensionObjectArray[capturedIndex]
+                })
+            })
+        }
+    }
+    return uaVariable.$$extensionObjectArray;
+}
+
 export function extractPartialData(path: string | string[], extensionObject: ExtensionObject) {
     let name;
     if (typeof path === "string") {