node-opcua-address-space 2.117.0 → 2.119.0

package/src/data_access/ua_multistate_value_discrete_impl.ts

@@ -3,7 +3,7 @@
  */
 import { assert } from "node-opcua-assert";
 import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
-import { coerceInt32, coerceInt64toInt32, coerceUInt64, Int32, Int64, isValidUInt64 } from "node-opcua-basic-types";
+import { coerceInt32, coerceInt64toInt32, coerceUInt64, coerceUInt64toInt32, Int32, Int64, isValidInt64, isValidUInt64 } from "node-opcua-basic-types";
 import { coerceLocalizedText, LocalizedText, QualifiedNameLike } from "node-opcua-data-model";
 import { DataValue, DataValueT } from "node-opcua-data-value";
 import { StatusCodes } from "node-opcua-status-code";
@@ -12,26 +12,68 @@ import { NumericRange } from "node-opcua-numeric-range";
 import { DTEnumValue } from "node-opcua-nodeset-ua";
 import { BindVariableOptions, INamespace, UAVariable, UAProperty, ISessionContext } from "node-opcua-address-space-base";
 import { VariableTypeIds } from "node-opcua-constants";
+import { _getBasicDataType, _getBasicDataTypeFromDataTypeNodeId } from "../get_basic_datatype";
 
 import { registerNodePromoter } from "../../source/loader/register_node_promoter";
 import { coerceEnumValues } from "../../source/helpers/coerce_enum_value";
 import { UAMultiStateValueDiscreteEx } from "../../source/interfaces/data_access/ua_multistate_value_discrete_ex";
 import { AddMultiStateValueDiscreteOptions } from "../../source/address_space_ts";
+import { ISetStateOptions } from "../../source/interfaces/i_set_state_options";
 import { UAVariableImpl } from "../ua_variable_impl";
 
 import { add_dataItem_stuff } from "./add_dataItem_stuff";
 
-function install_synchronization<T, DT extends DataType>(variable: UAMultiStateValueDiscreteEx<T, DT>) {
+function convertToArray<T>(array: any): T[] {
+    if (Array.isArray(array)) return array;
+    const result: T[] = [];
+    for (let i = 0; i < array.length; i++) {
+        result[i] = array[i];
+    }
+    return result;
+}
+const getCoerceToInt32 = (dataType: DataType) => {
+    switch (dataType) {
+        case DataType.UInt64:
+            return coerceUInt64toInt32;
+        case DataType.Int64:
+            return coerceInt64toInt32;
+        default:
+            return coerceInt32;
+    }
+};
+
+function install_synchronization<T extends number | Int64 | Int64, DT extends DataType>(
+    variable: UAMultiStateValueDiscreteEx<T, DT>
+) {
     const _variable = variable as UAMultiStateValueDiscreteEx<T, DT>;
-    _variable.on("value_changed", (value: DataValue) => {
+    _variable.on("value_changed", (dataValue: DataValue) => {
         const valueAsTextNode = variable.valueAsText || (_variable.getComponentByName("ValueAsText") as UAVariable);
         if (!valueAsTextNode) {
             return;
         }
-        const valueAsText1 = _variable.findValueAsText(value.value.value);
-        valueAsTextNode.setValueFromSource(valueAsText1);
+        if (dataValue.value.arrayType === VariantArrayType.Array || dataValue.value.arrayType === VariantArrayType.Matrix) {
+            //
+            const coerce = getCoerceToInt32(_variable.getBasicDataType());
+
+            const values: number[] = convertToArray<Int32>(dataValue.value.value).map((a) => coerceInt32(a));
+            const variantArray: Variant[] = values.map((a) => _variable.findValueAsText(a));
+            const localizedText = variantArray.map((a) => a.value);
+
+            const valueAsText1 = new Variant({
+                arrayType: dataValue.value.arrayType,
+                dataType: DataType.LocalizedText,
+                value: localizedText,
+                dimensions: dataValue.value.dimensions
+            });
+            valueAsTextNode.setValueFromSource(valueAsText1);
+        } else {
+            const valueAsText1 = _variable.findValueAsText(dataValue.value.value);
+            valueAsTextNode.setValueFromSource(valueAsText1);
+        }
     });
-    _variable.emit("value_changed", _variable.readValue());
+    const dataValue = _variable.readValue();
+    // detect value changes to update valueAsText  (initial state)
+    _variable.emit("value_changed", dataValue);
 }
 
 export interface UAMultiStateValueDiscreteImpl<T, DT extends DataType> {
@@ -46,8 +88,11 @@ export interface UAMultiStateValueDiscreteImpl<T, DT extends DataType> {
 
     readValueAsync(context: ISessionContext | null, callback?: any): any;
 }
-export class UAMultiStateValueDiscreteImpl<T, DT extends DataType> extends UAVariableImpl implements UAMultiStateValueDiscreteEx<T, DT> {
-    public setValue(value: string | number | Int64): void {
+export class UAMultiStateValueDiscreteImpl<T, DT extends DataType>
+    extends UAVariableImpl
+    implements UAMultiStateValueDiscreteEx<T, DT>
+{
+    public setValue(value: string | number | Int64, options?: ISetStateOptions): void {
         if (typeof value === "string") {
             const enumValues = this.enumValues.readValue().value.value;
             const selected = enumValues.filter((a: any) => a.displayName.text === value)[0];
@@ -57,16 +102,20 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType> extends UAVar
                 throw new Error("cannot find enum string " + value + " in " + enumValues.toString());
             }
         } else {
-            this._setValue(coerceUInt64(value));
+            this._setValue(coerceUInt64(value), options);
         }
     }
 
-    public getValueAsString(): string {
-        return this.valueAsText.readValue().value.value.text || "";
+    public getValueAsString(): any {
+        const v = this.valueAsText.readValue().value.value;
+        if (Array.isArray(v)) {
+            return v.map((a) => a.text);
+        }
+        return v.text || "";
     }
 
-    public getValueAsNumber(): number {
-        return this.readValue().value.value as unknown as number;
+    public getValueAsNumber(): any {
+        return this.readValue().value.value;
     }
 
     public checkVariantCompatibility(value: Variant): StatusCode {
@@ -89,7 +138,7 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType> extends UAVar
     public _isValueInRange(value: number): boolean {
         // MultiStateValueDiscreteType
         const enumValues = this.enumValues.readValue().value.value as DTEnumValue[];
-        const e = enumValues.findIndex((x: DTEnumValue) => coerceInt32(x.value) === value);
+        const e = enumValues.findIndex((x: DTEnumValue) => coerceInt64toInt32(x.value) === value);
         return !(e === -1);
     }
     /**
@@ -114,18 +163,18 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType> extends UAVar
      *
      * @private
      */
-    public _setValue(value: Int64): void {
+    public _setValue(value: Int64, options?: ISetStateOptions): void {
+        const int32Value = coerceInt64toInt32(value);
         // check that value is in bound
-        if (!this._isValueInRange(coerceInt32(value))) {
+        if (!this._isValueInRange(int32Value)) {
             throw new Error("UAMultiStateValueDiscrete#_setValue out of range " + value);
         }
 
         const dataType = this._getDataType();
         if (dataType === DataType.Int64 || dataType === DataType.UInt64) {
-            this.setValueFromSource({ dataType, value });
+            this.setValueFromSource({ dataType, arrayType: VariantArrayType.Scalar, value });
         } else {
-            const valueN = value[1];
-            this.setValueFromSource({ dataType, value: valueN });
+            this.setValueFromSource({ dataType, arrayType: VariantArrayType.Scalar, value: int32Value });
         }
     }
 
@@ -135,17 +184,14 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType> extends UAVar
      */
     public findValueAsText(value?: number | Int64): Variant {
         const enumValueIndex = this._enumValueIndex();
-
         if (value === undefined) {
             throw new Error("Unexpected undefined value");
         }
-        if (value instanceof Array) {
-            value = value[1];
-        }
-        assert(!((value as any) instanceof Variant));
+        const valueAsInt32 = coerceInt64toInt32(value);
+
         let valueAsText1 = "Invalid";
-        if (enumValueIndex[value]) {
-            valueAsText1 = enumValueIndex[value].displayName.text || `Invalid:${value}`;
+        if (enumValueIndex[valueAsInt32] !== undefined) {
+            valueAsText1 = enumValueIndex[valueAsInt32].displayName.text || `Invalid:${value}`;
         }
         const result = new Variant({
             dataType: DataType.LocalizedText,
@@ -153,6 +199,7 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType> extends UAVar
         });
         return result;
     }
+
     public _getDataType(): DataType {
         if (this.dataType.value === 26 /* Number */) {
             return DataType.UInt32;
@@ -170,7 +217,7 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType> extends UAVar
         // this includes signed and unsigned integers from 8 to 64 Bit length.
 
         // istanbul ignore next
-        validateDataType(this.dataType.value);
+        validateIsNumericDataType(this.dataType.value);
 
         // find the enum value type
         install_synchronization(this);
@@ -212,30 +259,33 @@ export function _addMultiStateValueDiscrete<T, DT extends DataType>(
     if (options.value === undefined && enumValues[0]) {
         options.value = enumValues[0].value; // Int64
     }
+    // Only DataTypes that can be represented with EnumValues are allowed for Variables of MultiStateValueDiscreteType.
+    // These are Integers up to 64 Bits (signed and unsigned).:
+
+    const dataType: DataType = _getBasicDataTypeFromDataTypeNodeId(addressSpace, options.dataType || DataType.UInt32);
+
     let value: undefined | BindVariableOptions;
-    if (typeof options.value === "number" || isValidUInt64(options.value as number | number[])) {
-        if (isValidUInt64(options.value as number | number[])) {
-            value = new Variant({
-                dataType: DataType.UInt32,
-                value: (options.value as Int64)[1] // Low word
-            });
-        } else {
-            value = new Variant({
-                dataType: DataType.UInt32,
-                value: options.value
-            });
-        }
+    if (
+        typeof options.value === "number" ||
+        isValidUInt64(options.value as number | number[]) ||
+        isValidInt64(options.value as number | number[])
+    ) {
+        value = new Variant({
+            dataType,
+            value: options.value
+        });
     } else {
         value = options.value as any;
     }
 
     const cloned_options = {
         ...options,
-        dataType: DataType.UInt32,
+        dataType,
         typeDefinition: multiStateValueDiscreteType.nodeId,
         // valueRank:
         // note : OPCUA Spec 1.03 specifies -1:Scalar (part 8 page 8) but nodeset file specifies -2:Any
         value,
+        // limitation:  although the Specs specify -2:any, we only support -1(Scalar)
         valueRank: -1 // -1 : Scalar
     };
 
@@ -267,6 +317,8 @@ export function _addMultiStateValueDiscrete<T, DT extends DataType>(
         minimumSamplingInterval: 0,
         modellingRule: options.modellingRule ? "Mandatory" : undefined,
         propertyOf: variable,
+        arrayDimensions: options.arrayDimensions,
+        valueRank: options.valueRank,
         typeDefinition: "PropertyType",
         userAccessLevel: "CurrentRead"
         // value: valueAsText
@@ -282,21 +334,23 @@ export function _addMultiStateValueDiscrete<T, DT extends DataType>(
     return variable;
 }
 
-export function validateDataType(dataTypeValue: any): void {
-    const validTypes = [
-        DataType.UInt64,
-        DataType.Int64,
-        DataType.UInt32,
-        DataType.Int32,
-        DataType.UInt16,
-        DataType.Int16,
-        DataType.Byte,
-        DataType.Byte,
-        DataType.SByte,
-        26 /*Number*/
-    ];
-
-    if (typeof dataTypeValue !== "number" || validTypes.indexOf(dataTypeValue) < 0) {
+const validBasicNumericDataTypes = [
+    DataType.UInt64,
+    DataType.Int64,
+    DataType.UInt32,
+    DataType.Int32,
+    DataType.UInt16,
+    DataType.Int16,
+    DataType.Byte,
+    DataType.Byte,
+    DataType.SByte,
+    26 /*Number*/
+];
+export function validateIsNumericDataType(dataTypeValue: any): void {
+    if (typeof dataTypeValue !== "number" || validBasicNumericDataTypes.indexOf(dataTypeValue) < 0) {
         throw new Error(`Invalid DataType in UAMultiStateValueDiscrete => ${dataTypeValue.toString()}`);
     }
 }
+
+/** @deprecated: use validateIsNumericDataType instead */
+export const validateDataType = validateIsNumericDataType;

package/src/data_access/ua_two_state_discrete_impl.ts

@@ -10,9 +10,11 @@ import { UAVariableImpl } from "../ua_variable_impl";
 import { registerNodePromoter } from "../../source/loader/register_node_promoter";
 import { AddTwoStateDiscreteOptions } from "../../source/address_space_ts";
 import { UATwoStateDiscreteEx } from "../../source/interfaces/data_access/ua_two_state_discrete_ex";
+import { ISetStateOptions } from "../../source/interfaces/i_set_state_options";
 
 import { add_dataItem_stuff } from "./add_dataItem_stuff";
 
+
 export interface UATwoStateDiscreteImpl {
     falseState: UAProperty<LocalizedText, /*c*/ DataType.LocalizedText>;
     trueState: UAProperty<LocalizedText, /*c*/ DataType.LocalizedText>;
@@ -58,15 +60,15 @@ export class UATwoStateDiscreteImpl extends UAVariableImpl implements UATwoState
             );
         }
     }
-    setValue(value: boolean | LocalizedTextLike): void {
+    setValue(value: boolean | LocalizedTextLike, options?: ISetStateOptions): void {
         if (typeof value === "boolean") {
             this.setValueFromSource({ dataType: DataType.Boolean, value });
         } else {
             const text: string = (typeof value === "string" ? value : value.text) || "";
             if (text === this.getTrueStateAsString()) {
-                this.setValue(true);
+                this.setValue(true, options);
             } else if (text === this.getFalseStateAsString()) {
-                this.setValue(false);
+                this.setValue(false, options);
             } else {
                 throw new Error("setValue invalid value " + value);
             }

package/src/get_basic_datatype.ts

@@ -1,7 +1,7 @@
 import { IAddressSpace } from "node-opcua-address-space-base";
 import { DataType } from "node-opcua-basic-types";
 import { NodeClass } from "node-opcua-data-model";
-import { NodeId } from "node-opcua-nodeid";
+import { NodeId, NodeIdLike } from "node-opcua-nodeid";
 
 export interface IBaseNodeVariableOrVariableType {
     addressSpace: IAddressSpace;
@@ -10,6 +10,19 @@ export interface IBaseNodeVariableOrVariableType {
 interface IBaseNodeVariableOrVariableTypeEx extends IBaseNodeVariableOrVariableType {
     _basicDataType: DataType;
 }
+
+export function _getBasicDataTypeFromDataTypeNodeId(
+    addressSpace: IAddressSpace,
+    dataTypeNodeId: { nodeId: NodeIdLike } | NodeIdLike
+): DataType {
+    const dataTypeNodeId_  =  (dataTypeNodeId as any).nodeId ? (dataTypeNodeId as any).nodeId : dataTypeNodeId;
+    const dataTypeNode = addressSpace.findDataType(dataTypeNodeId_);
+    if (!dataTypeNode) {
+        return DataType.Null;
+    }
+    return dataTypeNode.getBasicDataType();
+}
+
 export function _getBasicDataType(uaNode: IBaseNodeVariableOrVariableType): DataType {
     const _uaNode = uaNode as IBaseNodeVariableOrVariableTypeEx;
     if (_uaNode._basicDataType) {
@@ -23,10 +36,6 @@ export function _getBasicDataType(uaNode: IBaseNodeVariableOrVariableType): Data
         // may be node has been deleted already
         return DataType.Null;
     }
-    const dataTypeNode = addressSpace.findDataType(_uaNode.dataType)!;
-    const basicDataType =
-        dataTypeNode && dataTypeNode.nodeClass === NodeClass.DataType ? dataTypeNode.getBasicDataType() : DataType.Null;
-    // const basicDataType = addressSpace.findCorrespondingBasicDataType(uaNode.dataType);
-    _uaNode._basicDataType = basicDataType;
-    return basicDataType;
+    _uaNode._basicDataType =  _getBasicDataTypeFromDataTypeNodeId(addressSpace, _uaNode.dataType);
+    return _uaNode._basicDataType;
 }

package/src/namespace_impl.ts

@@ -27,7 +27,7 @@ import {
     RolePermissionType,
     RolePermissionTypeOptions
 } from "node-opcua-types";
-import * as utils from "node-opcua-utils";
+import { isNullOrUndefined } from "node-opcua-utils";
 import { DataType, Variant, VariantArrayType, VariantOptions, verifyRankAndDimensions } from "node-opcua-variant";
 import {
     AddBaseNodeOptions,
@@ -45,7 +45,6 @@ import {
     CreateDataTypeOptions,
     CreateNodeOptions,
     EnumerationItem,
-    INamespace,
     RequiredModel,
     UADataType,
     UAEventType,
@@ -58,7 +57,7 @@ import {
     UAVariableType,
     UAView
 } from "node-opcua-address-space-base";
-import { UAAnalogItem, UADataItem, UAInitialState, UAState, UAYArrayItem } from "node-opcua-nodeset-ua";
+import { UAAnalogItem, UADataItem, UAInitialState, UAState } from "node-opcua-nodeset-ua";
 
 import {
     AddMultiStateDiscreteOptions,
@@ -70,13 +69,12 @@ import { UAStateMachineEx } from "../source/interfaces/state_machine/ua_state_ma
 import { UATransitionEx } from "../source/interfaces/state_machine/ua_transition_ex";
 import {
     InstantiateAlarmConditionOptions,
-    InstantiateExclusiveLimitAlarmOptions,
     InstantiateLimitAlarmOptions,
     InstantiateOffNormalAlarmOptions,
     UATwoStateDiscreteEx,
     UAYArrayItemEx
 } from "../source";
-import { AddAnalogDataItemOptions, AddDataItemOptions, UAAnalogItemEx } from "../source/namespace_data_access";
+import { AddAnalogDataItemOptions, AddDataItemOptions } from "../source/namespace_data_access";
 import { UATwoStateVariableEx } from "../source/ua_two_state_variable_ex";
 import { UAMultiStateValueDiscreteEx } from "../source/interfaces/data_access/ua_multistate_value_discrete_ex";
 import { UAAlarmConditionEx } from "../source/interfaces/alarms_and_conditions/ua_alarm_condition_ex";
@@ -1076,7 +1074,7 @@ export class NamespaceImpl implements NamespacePrivate {
 
         function coerceAxisScale(value: any) {
             const ret = AxisScaleEnumeration[value];
-            assert(!utils.isNullOrUndefined(ret));
+            assert(!isNullOrUndefined(ret));
             return ret;
         }
 
@@ -1982,7 +1980,7 @@ export class NamespaceImpl implements NamespacePrivate {
         // ------------------------------------------ DataType
         options.dataType = addressSpace._coerce_DataType(options.dataType!);
 
-        options.valueRank = utils.isNullOrUndefined(options.valueRank)
+        options.valueRank = isNullOrUndefined(options.valueRank)
             ? options.arrayDimensions
                 ? options.arrayDimensions.length
                 : -1

package/src/nodeset_tools/nodeset_to_xml.ts

@@ -18,7 +18,7 @@ import {
     QualifiedName
 } from "node-opcua-data-model";
 import { ExpandedNodeId, NodeId, NodeIdType, resolveNodeId } from "node-opcua-nodeid";
-import * as utils from "node-opcua-utils";
+import { lowerFirstLetter, isNullOrUndefined } from "node-opcua-utils";
 import { Variant, VariantArrayType, DataType } from "node-opcua-variant";
 import {
     IAddressSpace,
@@ -105,7 +105,6 @@ function b(xw: XmlWriter, browseName: QualifiedName): string {
     return translateBrowseName(xw, browseName).toString().replace("ns=0;", "");
 }
 
-
 function hasHigherPriorityThan(namespaceIndex1: number, namespaceIndex2: number, priorityTable: number[]) {
     const order1 = priorityTable[namespaceIndex1];
     const order2 = priorityTable[namespaceIndex2];
@@ -335,7 +334,7 @@ function _dumpVariantInnerExtensionObject(
         const dataTypeNodeId = field.dataType;
 
         const fieldName = field.name!;
-        const lowerFieldName = utils.lowerFirstLetter(fieldName);
+        const lowerFieldName = lowerFirstLetter(fieldName);
         const v = (value as unknown as Record<string, unknown>)[lowerFieldName];
         if (v !== null && v !== undefined) {
             if (
@@ -855,7 +854,7 @@ function _dumpEnumDefinition(xw: XmlWriter, enumDefinition: EnumDefinition) {
     for (const defItem of enumDefinition.fields!) {
         xw.startElement("Field");
         xw.writeAttribute("Name", defItem.name as string);
-        if (!utils.isNullOrUndefined(defItem.value)) {
+        if (!isNullOrUndefined(defItem.value)) {
             xw.writeAttribute("Value", coerceInt64ToInt32(defItem.value));
         }
         _dumpDescription(xw, defItem);

package/src/reference_impl.ts

@@ -6,7 +6,7 @@ import chalk from "chalk";
 import { AddReferenceOpts, UAReference, BaseNode, UAReferenceType } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import { coerceNodeId, NodeId, NodeIdLike, sameNodeId } from "node-opcua-nodeid";
-import * as utils from "node-opcua-utils";
+import { isNullOrUndefined } from "node-opcua-utils";
 
 export function isNodeIdString(str: string): boolean {
     assert(typeof str === "string");
@@ -17,7 +17,7 @@ function is_valid_reference(ref: UAReference): boolean {
     const hasRequestedProperties =
         Object.prototype.hasOwnProperty.call(ref, "referenceType") &&
         Object.prototype.hasOwnProperty.call(ref, "nodeId") &&
-        !utils.isNullOrUndefined(ref.isForward);
+        !isNullOrUndefined(ref.isForward);
 
     if (!hasRequestedProperties) {
         return false;

package/src/state_machine/ua_two_state_variable.ts

@@ -21,6 +21,8 @@ import { AddTwoStateVariableOptions } from "../../source/address_space_ts";
 import { UATwoStateVariableEx } from "../../source/ua_two_state_variable_ex";
 // private types
 import { UAVariableImpl, UAVariableImplT } from "../ua_variable_impl";
+import { ISetStateOptions } from "../../source/interfaces/i_set_state_options";
+
 
 const hasTrueSubState_ReferenceTypeNodeId = resolveNodeId("HasTrueSubState");
 const hasFalseSubState_ReferenceTypeNodeId = resolveNodeId("HasFalseSubState");
@@ -54,19 +56,23 @@ const hasFalseSubState_ReferenceTypeNodeId = resolveNodeId("HasFalseSubState");
 //                  TwoStateVariableType
 //                                                  <StateIdentifier> Defined in Clause 5.4.3 Optional
 
-function _updateTransitionTime(node: UATwoStateVariableEx, _subState?: UAVariable) {
+function _updateTransitionTime(node: UATwoStateVariableEx, _subState?: UAVariable, options?: ISetStateOptions) {
     // TransitionTime specifies the time when the current state was entered.
     if (node.transitionTime) {
-        node.transitionTime.setValueFromSource({ dataType: DataType.DateTime, value: new Date() });
+        const transitionTime = options?.transitionTime || new Date();
+        node.transitionTime.setValueFromSource({ dataType: DataType.DateTime, value: transitionTime });
     }
 }
 
-function _updateEffectiveTransitionTime(node: UATwoStateVariableImpl) {
+function _updateEffectiveTransitionTime(node: UATwoStateVariableImpl,options?: ISetStateOptions) {
     if (node.effectiveTransitionTime) {
+        
+        const effectiveTransitionTime = options?.effectiveTransitionTime || new Date();
+
         // because subStateNode ",subStateNode.browseName.toString());
         node.effectiveTransitionTime.setValueFromSource({
             dataType: DataType.DateTime,
-            value: new Date()
+            value: effectiveTransitionTime
         });
     }
 }
@@ -308,7 +314,7 @@ export class UATwoStateVariableImpl extends UAVariableImplT<LocalizedText, DataT
      * @method setValue
      * @param boolValue {Boolean}
      */
-    public setValue(boolValue: boolean): void {
+    public setValue(boolValue: boolean, options?: ISetStateOptions): void {
         assert(typeof boolValue === "boolean");
         const dataValue = this.id!.readValue();
         const oldValue = dataValue.value.value;
@@ -317,8 +323,8 @@ export class UATwoStateVariableImpl extends UAVariableImplT<LocalizedText, DataT
         }
         //
         this.id.setValueFromSource(new Variant({ dataType: DataType.Boolean, value: boolValue }));
-        _updateTransitionTime(this);
-        _updateEffectiveTransitionTime(this);
+        _updateTransitionTime(this, undefined, options);
+        _updateEffectiveTransitionTime(this, options);
     }
 
     /**
@@ -369,7 +375,7 @@ export class UATwoStateVariableImpl extends UAVariableImplT<LocalizedText, DataT
             const addressSpace = this.addressSpace;
             // add event handle
             const subState = addressSpace.findNode(reference.nodeId) as UAVariable;
-            subState.on("value_changed", _updateEffectiveTransitionTime.bind(null, this));
+            subState.on("value_changed", _updateEffectiveTransitionTime.bind(null, this, undefined));
         }
     }
 }

package/src/ua_data_type_impl.ts

@@ -21,16 +21,16 @@ import {
 import { DataType } from "node-opcua-variant";
 import { UAObject, ISessionContext, UADataType, UAVariable, BaseNode } from "node-opcua-address-space-base";
 import { DataTypeIds } from "node-opcua-constants";
+import { Int64, coerceInt32, coerceInt64, coerceInt64toInt32 } from "node-opcua-basic-types";
 
 import { SessionContext } from "../source/session_context";
 import { ExtensionObjectConstructorFuncWithSchema } from "../source/interfaces/extension_object_constructor";
 import { BaseNodeImpl, InternalBaseNodeOptions } from "./base_node_impl";
 import { BaseNode_References_toString, BaseNode_toString, ToStringBuilder, ToStringOption } from "./base_node_private";
-import * as tools from "./tool_isSubtypeOf";
+import { construct_isSubtypeOf } 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;
@@ -76,8 +76,8 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
     }
 
     /** @deprecated */
-    public isSupertypeOf = tools.construct_isSubtypeOf<UADataType>(UADataTypeImpl);
-    public isSubtypeOf = tools.construct_isSubtypeOf<UADataType>(UADataTypeImpl);
+    public isSupertypeOf = construct_isSubtypeOf<UADataType>(UADataTypeImpl);
+    public isSubtypeOf = construct_isSubtypeOf<UADataType>(UADataTypeImpl);
 
     public readonly isAbstract: boolean;
 
@@ -370,24 +370,24 @@ export function DataType_toString(this: UADataTypeImpl, options: ToStringOption)
 
     options.add(
         options.padding +
-        chalk.yellow("          binaryEncodingNodeId: ") +
-        (this.binaryEncodingNodeId ? this.binaryEncodingNodeId.toString() : "<none>")
+            chalk.yellow("          binaryEncodingNodeId: ") +
+            (this.binaryEncodingNodeId ? this.binaryEncodingNodeId.toString() : "<none>")
     );
     options.add(
         options.padding +
-        chalk.yellow("          xmlEncodingNodeId   : ") +
-        (this.xmlEncodingNodeId ? this.xmlEncodingNodeId.toString() : "<none>")
+            chalk.yellow("          xmlEncodingNodeId   : ") +
+            (this.xmlEncodingNodeId ? this.xmlEncodingNodeId.toString() : "<none>")
     );
     options.add(
         options.padding +
-        chalk.yellow("          jsonEncodingNodeId  : ") +
-        (this.jsonEncodingNodeId ? this.jsonEncodingNodeId.toString() : "<none>")
+            chalk.yellow("          jsonEncodingNodeId  : ") +
+            (this.jsonEncodingNodeId ? this.jsonEncodingNodeId.toString() : "<none>")
     );
     if (this.subtypeOfObj) {
         options.add(
             options.padding +
-            chalk.yellow("          subtypeOfObj        : ") +
-            (this.subtypeOfObj ? this.subtypeOfObj.browseName.toString() : "")
+                chalk.yellow("          subtypeOfObj        : ") +
+                (this.subtypeOfObj ? this.subtypeOfObj.browseName.toString() : "")
         );
     }
     // references
@@ -396,7 +396,6 @@ export function DataType_toString(this: UADataTypeImpl, options: ToStringOption)
     dataTypeDefinition_toString.call(this, options);
 }
 
-
 const defaultEnumValue: Int64 = coerceInt64(-1);
 
 function makeEnumDefinition(definitionFields: EnumFieldOptions[]) {
@@ -424,8 +423,8 @@ function makeStructureDefinition(
     const structureType = isUnion
         ? StructureType.Union
         : hasOptionalFields
-            ? StructureType.StructureWithOptionalFields
-            : StructureType.Structure;
+        ? StructureType.StructureWithOptionalFields
+        : StructureType.Structure;
 
     const sd = new StructureDefinition({
         baseDataType,

package/src/ua_object_type_impl.ts

@@ -7,7 +7,7 @@ import { AttributeIds } from "node-opcua-data-model";
 import { DataValue, DataValueLike } from "node-opcua-data-value";
 import { NodeId } from "node-opcua-nodeid";
 import { StatusCodes } from "node-opcua-status-code";
-import * as utils from "node-opcua-utils";
+import { isNullOrUndefined } from "node-opcua-utils";
 import { DataType } from "node-opcua-variant";
 import {
     AddObjectOptions,
@@ -21,8 +21,8 @@ import {
 import { SessionContext } from "../source/session_context";
 import { BaseNodeImpl } from "./base_node_impl";
 import { ToStringBuilder, UAObjectType_toString } from "./base_node_private";
-import { get_subtypeOf, get_subtypeOfObj } from "./tool_isSubtypeOf";
-import * as tools from "./tool_isSubtypeOf";
+import { construct_isSubtypeOf, get_subtypeOf, get_subtypeOfObj } from "./tool_isSubtypeOf";
+import { } from "./tool_isSubtypeOf";
 import {
     assertUnusedChildBrowseName,
     topMostParentIsObjectTypeOrVariableType
@@ -49,13 +49,13 @@ export class UAObjectTypeImpl extends BaseNodeImpl implements UAObjectType {
     }
 
 
-    public isSubtypeOf = tools.construct_isSubtypeOf<UAObjectType>(UAObjectTypeImpl);
+    public isSubtypeOf = construct_isSubtypeOf<UAObjectType>(UAObjectTypeImpl);
     /** @deprecated - use  isSubtypeOf instead */
-    public isSupertypeOf = tools.construct_isSubtypeOf<UAObjectType>(UAObjectTypeImpl);
+    public isSupertypeOf = construct_isSubtypeOf<UAObjectType>(UAObjectTypeImpl);
 
     constructor(options: any) {
         super(options);
-        this.isAbstract = utils.isNullOrUndefined(options.isAbstract) ? false : options.isAbstract;
+        this.isAbstract = isNullOrUndefined(options.isAbstract) ? false : options.isAbstract;
     }
 
     public readAttribute(context: ISessionContext, attributeId: AttributeIds): DataValue {