node-opcua-address-space 2.112.0 → 2.114.0

package/src/reference_impl.ts

@@ -78,7 +78,7 @@ export function resolveReferenceType(addressSpace: MinimalistAddressSpace, refer
     const _reference = reference as ReferenceImpl;
     if (!_reference._referenceType) {
         if (!_reference.referenceType) {
-            console.log(chalk.red("ERROR MISSING reference"), reference);
+            errorLog(chalk.red("ERROR MISSING reference"), reference);
         }
         _reference._referenceType = addressSpace.findReferenceType(reference.referenceType)!;
     }
@@ -169,3 +169,7 @@ export class ReferenceImpl implements UAReference {
         */
     }
 }
+function errorLog(arg0: string, reference: UAReference) {
+    throw new Error("Function not implemented.");
+}
+

package/src/state_machine/finite_state_machine.ts

@@ -14,7 +14,7 @@ import {
     QualifiedName
 } from "node-opcua-data-model";
 import { AttributeIds } from "node-opcua-data-model";
-import { make_warningLog } from "node-opcua-debug";
+import { make_debugLog, make_warningLog } from "node-opcua-debug";
 import { NodeId, sameNodeId } from "node-opcua-nodeid";
 import { StatusCodes } from "node-opcua-status-code";
 import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
@@ -35,6 +35,7 @@ import { UAObjectTypeImpl } from "../ua_object_type_impl";
 const warningLog = make_warningLog(__filename);
 
 const doDebug = false;
+const debugLog = make_debugLog(__filename);
 
 export declare interface UATransitionImpl extends UATransition, UATransitionEx {}
 export class UATransitionImpl implements UATransition, UATransitionEx {}
@@ -217,8 +218,7 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
         if (!transition) {
             // istanbul ignore next
             if (doDebug) {
-                // tslint:disable-next-line: no-console
-                console.log(" No transition from ", this.currentStateNode.browseName.toString(), " to ", toStateNode.toString());
+                debugLog(" No transition from ", this.currentStateNode.browseName.toString(), " to ", toStateNode.toString());
             }
             return false;
         }
@@ -522,7 +522,6 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
                 }
             };
             applyLastTransitionOptionalProps();
-            // xx console.log("transitionNode ",transitionNode.toString());
             // The inherited Property SourceNode shall be filled with the NodeId of the StateMachine instance where the
             // Transition occurs. If the Transition occurs in a SubStateMachine, then the NodeId of the SubStateMachine
             // has to be used. If the Transition occurs between a StateMachine and a SubStateMachine, then the NodeId of

package/src/state_machine/ua_shelving_state_machine_ex.ts

@@ -125,7 +125,6 @@ function _unshelve_method(inputArguments: VariantLike[], context: ISessionContex
 export function _clear_timer_if_any(shelvingState: UAShelvedStateMachineExImpl): void {
     if (shelvingState._timer) {
         clearTimeout(shelvingState._timer);
-        // xx console.log("_clear_timer_if_any shelvingState = ",shelvingState._timer,shelvingState.constructor.name);
         shelvingState._timer = null;
     }
 }
@@ -134,6 +133,7 @@ function _automatically_unshelve(shelvingState: UAShelvedStateMachineExImpl) {
     assert(shelvingState._timer, "expecting timerId to be set");
     shelvingState._timer = null;
 
+    // istanbul ignore next
     if (doDebug) {
         debugLog("Automatically unshelving variable ", shelvingState.browseName.toString());
     }
@@ -157,6 +157,7 @@ function _start_timer_for_automatic_unshelve(shelvingState: UAShelvedStateMachin
     shelvingState._sheveldTime = new Date(); // now
     shelvingState._duration = duration;
 
+    // istanbul ignore next
     if (doDebug) {
         debugLog("shelvingState._duration", shelvingState._duration);
     }
@@ -217,8 +218,6 @@ function _timedShelve_method(
     assert(inputArguments[0].dataType === DataType.Double); // Duration
     assert(inputArguments[0] instanceof Variant);
 
-    // xx console.log("inputArguments",inputArguments[0].toString());
-
     const proposedDuration = inputArguments[0].value; // as double (milliseconds)
     if (proposedDuration > maxTimeShelved) {
         return callback(null, {

package/src/state_machine/ua_two_state_variable.ts

@@ -63,7 +63,6 @@ function _updateTransitionTime(node: UATwoStateVariableEx, _subState?: UAVariabl
 
 function _updateEffectiveTransitionTime(node: UATwoStateVariableImpl) {
     if (node.effectiveTransitionTime) {
-        // xx console.log("xxxx _updateEffectiveTransitionTime
         // because subStateNode ",subStateNode.browseName.toString());
         node.effectiveTransitionTime.setValueFromSource({
             dataType: DataType.DateTime,

package/src/ua_data_type_impl.ts

@@ -30,6 +30,7 @@ import * as tools from "./tool_isSubtypeOf";
 import { get_subtypeOf } from "./tool_isSubtypeOf";
 import { get_subtypeOfObj } from "./tool_isSubtypeOf";
 import { BaseNode_getCache } from "./base_node_private";
+import { Int64, coerceInt32, coerceInt64, coerceInt64toInt32 } from "node-opcua-basic-types";
 
 export interface UADataTypeImpl {
     _extensionObjectConstructor: ExtensionObjectConstructorFuncWithSchema;
@@ -230,7 +231,7 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
             definition = enumValues.map((e: any) => {
                 return {
                     name: e.displayName.text,
-                    value: e.value[1]
+                    value: coerceInt64toInt32(e.value)
                 };
             });
         }
@@ -395,12 +396,15 @@ export function DataType_toString(this: UADataTypeImpl, options: ToStringOption)
     dataTypeDefinition_toString.call(this, options);
 }
 
+
+const defaultEnumValue: Int64 = coerceInt64(-1);
+
 function makeEnumDefinition(definitionFields: EnumFieldOptions[]) {
     return new EnumDefinition({
         fields: definitionFields.map((x) => ({
             description: x.description,
             name: x.name,
-            value: x.value
+            value: x.value === undefined ? defaultEnumValue : coerceInt64(x.value)
         }))
     });
 }
@@ -431,27 +435,3 @@ function makeStructureDefinition(
     });
     return sd;
 }
-
-/*
-function lockReadOnlyWithWriteDetection<T>(obj: T): T {
-    if (obj instanceof Array) {
-        return obj.map(lockReadOnlyWithWriteDetection) as unknown as T;
-    }
-    if (obj instanceof Object) {
-        const _org = obj;
-        for (const [key, value] of Object.entries(obj)) {
-            lockReadOnlyWithWriteDetection(value);
-        }
-        obj = new Proxy(obj, {
-            get: (target: any, prop: string) => {
-                return target[prop];
-            },
-            set: (target: any, prop: string | symbol, value: any, receiver: any) => {
-                console.log("QQQQQ Cannot modify stuff ");
-                throw new Error("Invalid");
-            }
-        });
-    }
-    return obj;
-}
-*/

package/src/ua_variable_impl.ts

@@ -1,11 +1,7 @@
 /* eslint-disable max-statements */
-/* eslint-disable complexity */
 /**
  * @module node-opcua-address-space
  */
-// tslint:disable:no-bitwise
-// tslint:disable:no-console
-// tslint:disable:max-line-length
 import { types } from "util";
 import chalk from "chalk";
 
@@ -97,6 +93,7 @@ import {
     _touchValue
 } from "./ua_variable_impl_ext_obj";
 import { adjustDataValueStatusCode } from "./data_access/adjust_datavalue_status_code";
+import { _getBasicDataType } from "./get_basic_datatype";
 
 const debugLog = make_debugLog(__filename);
 const warningLog = make_warningLog(__filename);
@@ -714,23 +711,7 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
     }
 
     public getBasicDataType(): DataType {
-        if (this._basicDataType) {
-            return this._basicDataType;
-        }
-        if (this.dataType.namespace === 0 && this.dataType.value === 0) {
-            return DataType.Null;
-        }
-        const addressSpace = this.addressSpace;
-        if (!addressSpace) {
-            // may be node has been deleted already
-            return DataType.Null;
-        }
-        const dataTypeNode = addressSpace.findDataType(this.dataType)!;
-        const basicDataType =
-            dataTypeNode && dataTypeNode.nodeClass === NodeClass.DataType ? dataTypeNode.getBasicDataType() : DataType.Null;
-        // const basicDataType = addressSpace.findCorrespondingBasicDataType(this.dataType);
-        this._basicDataType = basicDataType;
-        return basicDataType;
+        return _getBasicDataType(this);
     }
     public adjustVariant(variant: Variant): Variant {
         return adjustVariant(variant, this.valueRank, this.getBasicDataType());
@@ -1425,7 +1406,9 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             // has not yet been loaded !
             return true;
         }
-
+        if (dataType.nodeId.namespace === 0 && dataType.nodeId.value === DataType.ExtensionObject) {
+            return true;
+        }
         const Constructor = addressSpace.getExtensionObjectConstructor(this.dataType);
 
         if (this.valueRank === -1) {

package/src/ua_variable_impl_ext_obj.ts

@@ -70,7 +70,12 @@ function _extensionObjectFieldGetter(getVariable: () => UAVariable | null, targe
     }
     return target[key];
 }
-function _extensionObjectFieldSetter(getVariable: () => UAVariable | null, target: any, key: string, value: any /*, receiver*/): boolean {
+function _extensionObjectFieldSetter(
+    getVariable: () => UAVariable | null,
+    target: any,
+    key: string,
+    value: any /*, receiver*/
+): boolean {
     target[key] = value;
     if (isProxy(target)) {
         return true;
@@ -132,7 +137,6 @@ export function propagateTouchValueDownward(self: UAVariableImpl, now: PreciseCl
         const property = self.getChildByName(field.name!) as UAVariableImpl;
 
         if (property) {
-
             if (cache) {
                 if (cache.has(property)) {
                     continue;
@@ -146,9 +150,7 @@ export function propagateTouchValueDownward(self: UAVariableImpl, now: PreciseCl
     }
 }
 
-
 export function setExtensionObjectPartialValue(node: UAVariableImpl, partialObject: any, sourceTimestamp?: PreciseClock) {
-
     const variablesToUpdate: Set<UAVariableImpl> = new Set();
 
     const extensionObject = node.$extensionObject;
@@ -162,7 +164,6 @@ export function setExtensionObjectPartialValue(node: UAVariableImpl, partialObje
             if (extObject[prop] instanceof Object) {
                 _update_extension_object(extObject[prop], partialObject1[prop]);
             } else {
-
                 if (isProxy(extObject)) {
                     // collect element we have to update
                     const target = getProxyTarget(extObject);
@@ -242,8 +243,10 @@ function prepareVariantValue(dataType: DataType, value: VariantLike): VariantLik
 
 function installExt(uaVariable: UAVariableImpl, ext: ExtensionObject) {
     ext = unProxy(ext);
-    uaVariable.$extensionObject = new Proxy(ext, makeHandler(() => uaVariable));
-
+    uaVariable.$extensionObject = new Proxy(
+        ext,
+        makeHandler(() => uaVariable)
+    );
 
     const addressSpace = uaVariable.addressSpace;
     const definition = uaVariable.dataTypeObj.getStructureDefinition();
@@ -258,9 +261,12 @@ function installExt(uaVariable: UAVariableImpl, ext: ExtensionObject) {
 
                 const subExtObj = uaVariable.$extensionObject[camelCaseName];
                 if (subExtObj) {
-                    uaVariable.$extensionObject[camelCaseName] = new Proxy(subExtObj, makeHandler(() => {
-                        return uaVariable.getComponentByName(field.name!) as UAVariable | null;
-                    }));
+                    uaVariable.$extensionObject[camelCaseName] = new Proxy(
+                        subExtObj,
+                        makeHandler(() => {
+                            return uaVariable.getComponentByName(field.name!) as UAVariable | null;
+                        })
+                    );
                 } else {
                     doDebug && warningLog("extension object is null");
                 }
@@ -269,11 +275,7 @@ function installExt(uaVariable: UAVariableImpl, ext: ExtensionObject) {
     }
 }
 
-export function _installExtensionObjectBindingOnProperties(
-    uaVariable: UAVariableImpl,
-    options?: BindExtensionObjectOptions
-): void {
-
+export function _installExtensionObjectBindingOnProperties(uaVariable: UAVariableImpl, options?: BindExtensionObjectOptions): void {
     // may be extension object mechanism has alreday been install
     // in this case we just need to rebind the properties...
     if (uaVariable.$extensionObject) {
@@ -292,7 +294,6 @@ export function _installExtensionObjectBindingOnProperties(
     if (extObj instanceof ExtensionObject) {
         uaVariable.bindExtensionObject(extObj, { createMissingProp: true, force: true });
     } else if (extObj instanceof Array) {
-
         // istanbul ignore else
         if (dataValue.value.arrayType === VariantArrayType.Array || dataValue.value.arrayType === VariantArrayType.Matrix) {
             _bindExtensionObjectArrayOrMatrix(uaVariable, extObj, { createMissingProp: true, force: true });
@@ -302,17 +303,22 @@ export function _installExtensionObjectBindingOnProperties(
     }
 }
 
-function _installFields2(uaVariable: UAVariableImpl, { get, set }: {
-    get: (fieldName: string) => any,
-    set: (fieldName: string, value: any, sourceTime: PreciseClock) => void;
-}, options?: BindExtensionObjectOptions) {
-
+function _installFields2(
+    uaVariable: UAVariableImpl,
+    {
+        get,
+        set
+    }: {
+        get: (fieldName: string) => any;
+        set: (fieldName: string, value: any, sourceTime: PreciseClock) => void;
+    },
+    options?: BindExtensionObjectOptions
+) {
     options = options || { createMissingProp: false };
     const dt = uaVariable.getDataTypeNode();
     const definition = dt.getStructureDefinition();
 
     for (const field of definition.fields || []) {
-
         if (NodeId.sameNodeId(NodeId.nullNodeId, field.dataType)) {
             warningLog("field.dataType is null ! ", field.name, NodeId.nullNodeId.toString());
             warningLog(field.toString());
@@ -332,7 +338,12 @@ function _installFields2(uaVariable: UAVariableImpl, { get, set }: {
         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 ? VariantArrayType.Scalar : (propertyNode.valueRank === 1 ? VariantArrayType.Array : VariantArrayType.Matrix)
+        propertyNode.$dataValue.value.arrayType =
+            propertyNode.valueRank === -1
+                ? VariantArrayType.Scalar
+                : propertyNode.valueRank === 1
+                ? VariantArrayType.Array
+                : VariantArrayType.Matrix;
         propertyNode.$dataValue.value.dimensions = propertyNode.valueRank > 1 ? propertyNode.arrayDimensions : null;
 
         const fieldName = field.name!;
@@ -344,19 +355,23 @@ function _installFields2(uaVariable: UAVariableImpl, { get, set }: {
             const value = dataValue.value.value;
             set(field.name!, value, sourceTime);
             propertyNode.touchValue(sourceTime);
-        }
+        };
 
         if (propertyNode.dataTypeObj.basicDataType === DataType.ExtensionObject) {
-            _installFields2(propertyNode, {
-                get: (fieldName: string) => {
-                    const mainFieldName = field.name!;
-                    return get(mainFieldName)[lowerFirstLetter(fieldName)];
+            _installFields2(
+                propertyNode,
+                {
+                    get: (fieldName: string) => {
+                        const mainFieldName = field.name!;
+                        return get(mainFieldName)[lowerFirstLetter(fieldName)];
+                    },
+                    set: (fieldName: string, value: any, sourceTime: PreciseClock) => {
+                        const mainFieldName = field.name!;
+                        get(mainFieldName)[lowerFirstLetter(fieldName)] = value;
+                    }
                 },
-                set: (fieldName: string, value: any, sourceTime: PreciseClock) => {
-                    const mainFieldName = field.name!;
-                    get(mainFieldName)[lowerFirstLetter(fieldName)] = value;
-                }
-            }, options);
+                options
+            );
         }
     }
 }
@@ -393,15 +408,19 @@ function isVariableContainingExtensionObject(uaVariable: UAVariableImpl): boolea
     return true;
 }
 
-function _innerBindExtensionObjectScalar(uaVariable: UAVariableImpl,
-    { get, set, setField }: {
+function _innerBindExtensionObjectScalar(
+    uaVariable: UAVariableImpl,
+    {
+        get,
+        set,
+        setField
+    }: {
         get: () => ExtensionObject;
         set: (value: ExtensionObject, sourceTimestamp: PreciseClock, cache: Set<UAVariableImpl>) => void;
         setField: (fieldName: string, value: any, sourceTimestamp: PreciseClock, cache?: Set<UAVariableImpl>) => void;
     },
     options?: BindExtensionObjectOptions
 ) {
-
     uaVariable.$dataValue.statusCode = StatusCodes.Good;
     uaVariable.$dataValue.value.dataType = DataType.ExtensionObject;
     uaVariable.$dataValue.value.arrayType = VariantArrayType.Scalar;
@@ -413,19 +432,21 @@ function _innerBindExtensionObjectScalar(uaVariable: UAVariableImpl,
     installDataValueGetter(uaVariable, get);
     uaVariable.$set_ExtensionObject = set;
 
-    _installFields2(uaVariable, {
-        get: (fieldName: string) => {
-            const extObj = get() as any;
-            return extObj[lowerFirstLetter(fieldName)];
+    _installFields2(
+        uaVariable,
+        {
+            get: (fieldName: string) => {
+                const extObj = get() as any;
+                return extObj[lowerFirstLetter(fieldName)];
+            },
+            set: (fieldName: string, value: any, sourceTime: PreciseClock) => {
+                setField(fieldName, value, sourceTime);
+            }
         },
-        set: (fieldName: string, value: any, sourceTime: PreciseClock) => {
-            setField(fieldName, value, sourceTime);
-        }
-    }, options);
-
+        options
+    );
 }
 
-
 // eslint-disable-next-line complexity
 export function _bindExtensionObject(
     uaVariable: UAVariableImpl,
@@ -441,7 +462,10 @@ export function _bindExtensionObject(
 
     // istanbul ignore next
     if (optionalExtensionObject && uaVariable.valueRank === 0) {
-        warningLog(uaVariable.browseName.toString() + ": valueRank was zero but needed to be adjusted to -1 (Scalar) in bindExtensionObject");
+        warningLog(
+            uaVariable.browseName.toString() +
+                ": valueRank was zero but needed to be adjusted to -1 (Scalar) in bindExtensionObject"
+        );
         uaVariable.valueRank = -1;
     }
     const addressSpace = uaVariable.addressSpace;
@@ -491,19 +515,24 @@ export function _bindExtensionObject(
             warningLog(uaVariable.$extensionObject?.toString());
             throw new Error(
                 "bindExtensionObject: $extensionObject is incorrect: we are expecting a " +
-                uaVariable.dataType.toString({ addressSpace: uaVariable.addressSpace }) +
-                " but we got a " +
-                uaVariable.$extensionObject?.schema.name
+                    uaVariable.dataType.toString({ addressSpace: uaVariable.addressSpace }) +
+                    " but we got a " +
+                    uaVariable.$extensionObject?.schema.name
             );
         }
         return uaVariable.$extensionObject;
     }
 
-    // istanbul ignore next
     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");
+        // istanbul ignore next
+        if (!optionalExtensionObject) {
+            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();
@@ -516,14 +545,14 @@ export function _bindExtensionObject(
     return uaVariable.$extensionObject;
 
     function innerBindExtensionObject() {
-
         if (s.value && (s.value.dataType === DataType.Null || (s.value.dataType === DataType.ExtensionObject && !s.value.value))) {
             if (uaVariable.valueRank === -1 /** Scalar */) {
                 extensionObject_ = optionalExtensionObject || addressSpace.constructExtensionObject(uaVariable.dataType, {});
 
                 installExt(uaVariable, extensionObject_);
 
-                _innerBindExtensionObjectScalar(uaVariable,
+                _innerBindExtensionObjectScalar(
+                    uaVariable,
                     {
                         get: () => uaVariable.$extensionObject,
                         set: (value: ExtensionObject) => installExt(uaVariable, value),
@@ -531,8 +560,9 @@ export function _bindExtensionObject(
                             const extObj = uaVariable.$extensionObject;
                             getProxyTarget(extObj)[lowerFirstLetter(fieldName)] = value;
                         }
-
-                    }, options);
+                    },
+                    options
+                );
                 return;
             } else if (uaVariable.valueRank === 1 /** Array */) {
                 throw new Error("Should not get there ! Please fix me");
@@ -544,7 +574,8 @@ export function _bindExtensionObject(
             // verify that variant has the correct type
             assert(s.value.dataType === DataType.ExtensionObject);
             installExt(uaVariable, s.value.value);
-            _innerBindExtensionObjectScalar(uaVariable,
+            _innerBindExtensionObjectScalar(
+                uaVariable,
                 {
                     get: () => uaVariable.$extensionObject,
                     set: (value: ExtensionObject) => installExt(uaVariable, value),
@@ -552,26 +583,26 @@ export function _bindExtensionObject(
                         const extObj = uaVariable.$extensionObject;
                         getProxyTarget(extObj)[lowerFirstLetter(fieldName)] = value;
                     }
-                }, options);
+                },
+                options
+            );
         }
     }
 }
 
 const getIndexAsText = (index: number | number[]): string => {
-    if (typeof index === "number")
-        return `${index}`;
+    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);
+        nodeId = new NodeId(NodeIdType.STRING, (uaVariable.nodeId.value as string) + `[${iAsText}]`, uaVariable.nodeId.namespace);
     }
     return { browseName, nodeId };
-}
-
+};
 
 // eslint-disable-next-line max-statements, complexity
 export function _bindExtensionObjectArrayOrMatrix(
@@ -579,7 +610,6 @@ export function _bindExtensionObjectArrayOrMatrix(
     optionalExtensionObjectArray?: ExtensionObject[],
     options?: BindExtensionObjectOptions
 ): ExtensionObject[] {
-
     options = options || { createMissingProp: false };
     options.createMissingProp = options.createMissingProp || false;
 
@@ -598,7 +628,10 @@ export function _bindExtensionObjectArrayOrMatrix(
         optionalExtensionObjectArray = uaVariable.$dataValue.value.value;
     }
 
-    if ((arrayDimensions.length === 0 || arrayDimensions.length === 1 && arrayDimensions[0] === 0) && optionalExtensionObjectArray) {
+    if (
+        (arrayDimensions.length === 0 || (arrayDimensions.length === 1 && arrayDimensions[0] === 0)) &&
+        optionalExtensionObjectArray
+    ) {
         arrayDimensions[0] = optionalExtensionObjectArray.length;
     }
 
@@ -616,16 +649,15 @@ export function _bindExtensionObjectArrayOrMatrix(
     if (!optionalExtensionObjectArray) {
         optionalExtensionObjectArray = [];
         for (let i = 0; i < totalLength; i++) {
-            optionalExtensionObjectArray[i] = addressSpace.constructExtensionObject(uaVariable.dataType, {});;
+            optionalExtensionObjectArray[i] = addressSpace.constructExtensionObject(uaVariable.dataType, {});
         }
     }
     uaVariable.$$extensionObjectArray = optionalExtensionObjectArray;
     uaVariable.$dataValue.value.arrayType = uaVariable.valueRank === 1 ? VariantArrayType.Array : VariantArrayType.Matrix;
-    uaVariable.$dataValue.value.dimensions = uaVariable.valueRank === 1 ? null : (uaVariable.arrayDimensions || []);
+    uaVariable.$dataValue.value.dimensions = uaVariable.valueRank === 1 ? null : uaVariable.arrayDimensions || [];
     uaVariable.$dataValue.value.dataType = DataType.ExtensionObject;
     uaVariable.$dataValue.value.value = uaVariable.$$extensionObjectArray;
 
-
     // make sure uaVariable.$dataValue cannot be inadvertantly changed from this point onward
     const $dataValue = uaVariable.$dataValue;
     Object.defineProperty(uaVariable, "$dataValue", {
@@ -637,25 +669,25 @@ export function _bindExtensionObjectArrayOrMatrix(
         },
         //    writable: true,
         enumerable: true,
-        configurable: true,
+        configurable: true
     });
 
-    uaVariable.bindVariable({
-        get: () => uaVariable.$dataValue.value
-    }, true);
-
+    uaVariable.bindVariable(
+        {
+            get: () => uaVariable.$dataValue.value
+        },
+        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);
 
         let uaElement = uaVariable.getComponentByName(browseName) as UAVariableImpl | null;
         if (!uaElement) {
-
             if (!options.createMissingProp) {
                 continue;
             }
@@ -681,15 +713,17 @@ export function _bindExtensionObjectArrayOrMatrix(
         {
             const capturedIndex = i;
             const capturedUaElement = uaElement as UAVariableImpl;
-            _innerBindExtensionObjectScalar(uaElement,
+            _innerBindExtensionObjectScalar(
+                uaElement,
                 {
                     get: () => uaVariable.$$extensionObjectArray[capturedIndex],
                     set: (newValue: ExtensionObject, sourceTimestamp: PreciseClock, cache: Set<UAVariableImpl>) => {
                         assert(!isProxy(uaVariable.$$extensionObjectArray[capturedIndex]));
                         uaVariable.$$extensionObjectArray[capturedIndex] = newValue;
+                        // istanbul ignore next
                         if (uaVariable.$$extensionObjectArray !== uaVariable.$dataValue.value.value) {
-                            console.log("uaVariable", uaVariable.nodeId.toString());
-                            console.log("Houston! We have a problem ");
+                            warningLog("uaVariable", uaVariable.nodeId.toString());
+                            warningLog("Houston! We have a problem ");
                         }
                         propagateTouchValueDownward(capturedUaElement, sourceTimestamp, cache);
                         propagateTouchValueUpward(capturedUaElement, sourceTimestamp, cache);
@@ -700,8 +734,9 @@ export function _bindExtensionObjectArrayOrMatrix(
                         (isProxy(extObj) ? getProxyTarget(extObj) : extObj)[lowerFirstLetter(fieldName)] = newValue;
                         propagateTouchValueUpward(capturedUaElement, sourceTimestamp, cache);
                     }
-                }, { ...options, force: true });
-
+                },
+                { ...options, force: true }
+            );
         }
     }
     return uaVariable.$$extensionObjectArray;
@@ -764,14 +799,12 @@ export function extractPartialData(path: string | string[], extensionObject: Ext
 }
 
 export function propagateTouchValueDownwardArray(uaVariable: UAVariableImpl, now: PreciseClock, cache: Set<UAVariable>) {
-
     if (!uaVariable.$$extensionObjectArray) return;
     const arrayDimensions = uaVariable.arrayDimensions || [];
     const totalLength = uaVariable.$$extensionObjectArray.length;
 
     const indexIterator = new IndexIterator(arrayDimensions);
     for (let i = 0; i < totalLength; i++) {
-
         const index = indexIterator.next();
 
         const { browseName, nodeId } = composeBrowseNameAndNodeId(uaVariable, index);
@@ -781,4 +814,4 @@ export function propagateTouchValueDownwardArray(uaVariable: UAVariableImpl, now
             propagateTouchValueDownward(uaElement, now, cache);
         }
     }
-}
+}