node-opcua-address-space 2.170.1 → 2.172.0

package/src/data_access/ua_multistate_value_discrete_impl.ts

@@ -1,29 +1,39 @@
-/**
- * @module node-opcua-address-space.DataAccess
- */
+import type {
+    BindVariableOptions,
+    CloneExtraInfo,
+    CloneFilter,
+    CloneOptions,
+    INamespace,
+    UAVariable
+} from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
-import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
-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";
-import { StatusCode } from "node-opcua-status-code";
-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 {
+    coerceInt32,
+    coerceInt64toInt32,
+    coerceUInt64,
+    coerceUInt64toInt32,
+    type Int32,
+    type Int64,
+    isValidInt64,
+    isValidUInt64,
+    type UInt64
+} from "node-opcua-basic-types";
 import { VariableTypeIds } from "node-opcua-constants";
-import { _getBasicDataType, _getBasicDataTypeFromDataTypeNodeId } from "../get_basic_datatype";
-
-import { registerNodePromoter } from "../../source/loader/register_node_promoter";
+import { coerceLocalizedText } from "node-opcua-data-model";
+import type { DataValue } from "node-opcua-data-value";
+import type { DTEnumValue } from "node-opcua-nodeset-ua";
+import { type StatusCode, StatusCodes } from "node-opcua-status-code";
+import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
+import type { AddMultiStateValueDiscreteOptions } from "../../source/address_space_ts";
 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 type { UAMultiStateValueDiscreteEx } from "../../source/interfaces/data_access/ua_multistate_value_discrete_ex";
+import type { ISetStateOptions } from "../../source/interfaces/i_set_state_options";
+import { registerNodePromoter } from "../../source/loader/register_node_promoter";
+import { _getBasicDataTypeFromDataTypeNodeId } from "../get_basic_datatype";
 import { UAVariableImpl } from "../ua_variable_impl";
-
 import { add_dataItem_stuff } from "./add_dataItem_stuff";
 
-function convertToArray<T>(array: any): T[] {
+function convertToArray<T>(array: ArrayLike<T> | T[]): T[] {
     if (Array.isArray(array)) return array;
     const result: T[] = [];
     for (let i = 0; i < array.length; i++) {
@@ -42,18 +52,19 @@ const getCoerceToInt32 = (dataType: DataType) => {
     }
 };
 
-function install_synchronization<T extends number | Int64 | Int64, DT extends DataType>(
-    variable: UAMultiStateValueDiscreteEx<T, DT>
+type Number = number | Int64 | UInt64;
+
+function install_synchronization<T extends Number, DT extends DataType>(
+    _variable: UAVariableImpl & UAMultiStateValueDiscreteEx<T, DT>
 ) {
-    const _variable = variable as UAMultiStateValueDiscreteEx<T, DT>;
     _variable.on("value_changed", (dataValue: DataValue) => {
-        const valueAsTextNode = variable.valueAsText || (_variable.getComponentByName("ValueAsText") as UAVariable);
+        const valueAsTextNode = _variable.valueAsText || (_variable.getComponentByName("ValueAsText") as UAVariable);
         if (!valueAsTextNode) {
             return;
         }
         if (dataValue.value.arrayType === VariantArrayType.Array || dataValue.value.arrayType === VariantArrayType.Matrix) {
             //
-            const coerce = getCoerceToInt32(_variable.getBasicDataType());
+            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));
@@ -76,50 +87,38 @@ function install_synchronization<T extends number | Int64 | Int64, DT extends Da
     _variable.emit("value_changed", dataValue);
 }
 
-export interface UAMultiStateValueDiscreteImpl<T, DT extends DataType> {
-    enumValues: UAProperty<DTEnumValue[], DataType.ExtensionObject>;
-    valueAsText: UAProperty<LocalizedText, DataType.LocalizedText>;
-
-    readValue(
-        context?: ISessionContext | null,
-        indexRange?: NumericRange,
-        dataEncoding?: QualifiedNameLike | null
-    ): DataValueT<T, DT>;
-
-    readValueAsync(context: ISessionContext | null, callback?: any): any;
-}
-export class UAMultiStateValueDiscreteImpl<T, DT extends DataType>
-    extends UAVariableImpl
-    implements UAMultiStateValueDiscreteEx<T, DT>
-{
+export class UAMultiStateValueDiscreteImplBase<T extends Number, DT extends DataType> extends UAVariableImpl {
+    private get $6(): UAMultiStateValueDiscreteEx<T, DT> {
+        return this as unknown as 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];
+            const enumValues = this.$6.enumValues.readValue().value.value;
+            const selected = enumValues.filter((a) => a.displayName.text === value)[0];
             if (selected) {
                 this._setValue(selected.value);
             } else {
-                throw new Error("cannot find enum string " + value + " in " + enumValues.toString());
+                throw new Error(`cannot find enum string ${value} in ${enumValues.toString()}`);
             }
         } else {
             this._setValue(coerceUInt64(value), options);
         }
     }
 
-    public getValueAsString(): any {
-        const v = this.valueAsText.readValue().value.value;
+    public getValueAsString(): string | string[] {
+        const v = this.$6.valueAsText.readValue().value.value;
         if (Array.isArray(v)) {
             return v.map((a) => a.text);
         }
         return v.text || "";
     }
 
-    public getValueAsNumber(): any {
+    public getValueAsNumber(): number {
         return this.readValue().value.value;
     }
 
     public checkVariantCompatibility(value: Variant): StatusCode {
-        if (this.enumValues) {
+        if (this.$6.enumValues) {
             if (!this._isValueInRange(coerceInt32(value.value))) {
                 return StatusCodes.BadOutOfRange;
             }
@@ -127,7 +126,11 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType>
         return StatusCodes.Good;
     }
 
-    public clone<T, DT extends DataType>(options1: any, optionalFilter: any, extraInfo: any): UAMultiStateValueDiscreteImpl<T, DT> {
+    public clone(
+        options1: CloneOptions,
+        optionalFilter?: CloneFilter,
+        extraInfo?: CloneExtraInfo
+    ): UAMultiStateValueDiscreteImpl<T, DT> {
         const variable1 = UAVariableImpl.prototype.clone.call(this, options1, optionalFilter, extraInfo);
         return promoteToMultiStateValueDiscrete(variable1);
     }
@@ -137,7 +140,7 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType>
      */
     public _isValueInRange(value: number): boolean {
         // MultiStateValueDiscreteType
-        const enumValues = this.enumValues.readValue().value.value as DTEnumValue[];
+        const enumValues = this.$6.enumValues.readValue().value.value as DTEnumValue[];
         const e = enumValues.findIndex((x: DTEnumValue) => coerceInt64toInt32(x.value) === value);
         return !(e === -1);
     }
@@ -147,9 +150,9 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType>
      */
     public _enumValueIndex(): Record<Int32, DTEnumValue> {
         // construct an index to quickly find a EnumValue from a value
-        const enumValues: DTEnumValue[] = this.enumValues.readValue().value.value;
+        const enumValues: DTEnumValue[] = this.$6.enumValues.readValue().value.value;
         const enumValueIndex: Record<Int32, DTEnumValue> = Object.create(null);
-        if (!enumValues || !enumValues.forEach) {
+        if (!enumValues?.forEach) {
             return enumValueIndex;
         }
         enumValues.forEach((e: DTEnumValue) => {
@@ -163,11 +166,11 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType>
      *
      * @private
      */
-    public _setValue(value: Int64, options?: ISetStateOptions): void {
+    public _setValue(value: Int64, _options?: ISetStateOptions): void {
         const int32Value = coerceInt64toInt32(value);
         // check that value is in bound
         if (!this._isValueInRange(int32Value)) {
-            throw new Error("UAMultiStateValueDiscrete#_setValue out of range " + value);
+            throw new Error(`UAMultiStateValueDiscrete#_setValue out of range ${value}`);
         }
 
         const dataType = this._getDataType();
@@ -205,7 +208,7 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType>
             return DataType.UInt32;
         }
         const dataTypeStr = DataType[this.dataType.value as number] as string;
-        return (DataType as any)[dataTypeStr] as DataType;
+        return DataType[dataTypeStr as keyof typeof DataType];
     }
 
     /**
@@ -220,11 +223,19 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType>
         validateIsNumericDataType(this.dataType.value);
 
         // find the enum value type
-        install_synchronization(this);
+        install_synchronization(this as unknown as UAVariableImpl & UAMultiStateValueDiscreteEx<T, DT>);
     }
 }
-
-export function promoteToMultiStateValueDiscrete<T, DT extends DataType>(node: UAVariable): UAMultiStateValueDiscreteImpl<T, DT> {
+export type UAMultiStateValueDiscreteImpl<T extends Number, DT extends DataType> = UAMultiStateValueDiscreteImplBase<T, DT> &
+    UAMultiStateValueDiscreteEx<T, DT>;
+export const UAMultiStateValueDiscreteImpl = UAMultiStateValueDiscreteImplBase as unknown as new <
+    T extends Number,
+    DT extends DataType
+>() => UAMultiStateValueDiscreteImpl<T, DT>;
+
+export function promoteToMultiStateValueDiscrete<T extends Number, DT extends DataType>(
+    node: UAVariable
+): UAMultiStateValueDiscreteImpl<T, DT> {
     if (node instanceof UAMultiStateValueDiscreteImpl) {
         return node; // already promoted
     }
@@ -240,8 +251,8 @@ export function _addMultiStateValueDiscrete<T, DT extends DataType>(
     namespace: INamespace,
     options: AddMultiStateValueDiscreteOptions
 ): UAMultiStateValueDiscreteEx<T, DT> {
-    assert(Object.prototype.hasOwnProperty.call(options, "enumValues"));
-    assert(!Object.prototype.hasOwnProperty.call(options, "ValuePrecision"));
+    assert(Object.hasOwn(options, "enumValues"));
+    assert(!Object.hasOwn(options, "ValuePrecision"));
 
     const addressSpace = namespace.addressSpace;
 
@@ -275,7 +286,7 @@ export function _addMultiStateValueDiscrete<T, DT extends DataType>(
             value: options.value
         });
     } else {
-        value = options.value as any;
+        value = options.value as BindVariableOptions;
     }
 
     const cloned_options = {
@@ -344,13 +355,13 @@ const validBasicNumericDataTypes = [
     DataType.Byte,
     DataType.Byte,
     DataType.SByte,
-    26, /* Number  (abstract)*/
-    27, /* Integer  (abstract)*/
-    28  /* UInteger (abstract)*/
+    26 /* Number  (abstract)*/,
+    27 /* Integer  (abstract)*/,
+    28 /* UInteger (abstract)*/
 ];
-export function validateIsNumericDataType(dataTypeValue: any): void {
+export function validateIsNumericDataType(dataTypeValue: unknown): void {
     if (typeof dataTypeValue !== "number" || validBasicNumericDataTypes.indexOf(dataTypeValue) < 0) {
-        throw new Error(`Invalid DataType in UAMultiStateValueDiscrete => ${dataTypeValue.toString()}`);
+        throw new Error(`Invalid DataType in UAMultiStateValueDiscrete => ${dataTypeValue}`);
     }
 }
 

package/src/data_access/ua_two_state_discrete_impl.ts

@@ -1,33 +1,26 @@
+import type {
+    BindVariableOptions,
+    CloneExtraInfo,
+    CloneFilter,
+    CloneOptions,
+    INamespace,
+    UAVariable
+} from "node-opcua-address-space-base";
 import assert from "node-opcua-assert";
-import { coerceLocalizedText, LocalizedText, LocalizedTextLike, QualifiedNameLike } from "node-opcua-data-model";
-import { DataType, Variant, VariantLike } from "node-opcua-variant";
 import { VariableTypeIds } from "node-opcua-constants";
-import { INamespace, UAVariable, BindVariableOptions, UAProperty, ISessionContext } from "node-opcua-address-space-base";
-import { DataValueT } from "node-opcua-data-value";
-import { NumericRange } from "node-opcua-numeric-range";
-
-import { UAVariableImpl } from "../ua_variable_impl";
+import { coerceLocalizedText, type LocalizedText, type LocalizedTextLike } from "node-opcua-data-model";
+import { DataType, Variant } from "node-opcua-variant";
+import type { AddTwoStateDiscreteOptions } from "../../source/address_space_ts";
+import type { UATwoStateDiscreteEx } from "../../source/interfaces/data_access/ua_two_state_discrete_ex";
+import type { ISetStateOptions } from "../../source/interfaces/i_set_state_options";
 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 { UAVariableImpl } from "../ua_variable_impl";
 import { add_dataItem_stuff } from "./add_dataItem_stuff";
 
-
-export interface UATwoStateDiscreteImpl {
-    falseState: UAProperty<LocalizedText, /*c*/ DataType.LocalizedText>;
-    trueState: UAProperty<LocalizedText, /*c*/ DataType.LocalizedText>;
-
-    readValue(
-        context?: ISessionContext | null,
-        indexRange?: NumericRange,
-        dataEncoding?: QualifiedNameLike | null
-    ): DataValueT<boolean, DataType.Boolean>;
-
-    readValueAsync(context: ISessionContext | null, callback?: any): any;
-}
-export class UATwoStateDiscreteImpl extends UAVariableImpl implements UATwoStateDiscreteEx {
+export class UATwoStateDiscreteImplBase extends UAVariableImpl {
+    private get $5(): UATwoStateDiscreteEx {
+        return this as unknown as UATwoStateDiscreteEx;
+    }
     /*
      * @private
      */
@@ -40,9 +33,8 @@ export class UATwoStateDiscreteImpl extends UAVariableImpl implements UATwoState
         const falseState = this.getPropertyByName("FalseState");
         if (falseState) {
             falseState.on("value_changed", handler);
-        }
-        /* c8 ignore next */
-        else {
+        } else {
+            /* c8 ignore next */
             console.warn(
                 "warning: UATwoStateDiscrete -> a FalseState property is mandatory ",
                 this.browseName.toString(),
@@ -52,9 +44,8 @@ export class UATwoStateDiscreteImpl extends UAVariableImpl implements UATwoState
         const trueState = this.getPropertyByName("TrueState");
         if (trueState) {
             trueState.on("value_changed", handler);
-        }
-        /* c8 ignore next */
-        else {
+        } else {
+            /* c8 ignore next */
             console.warn(
                 "waring: UATwoStateDiscrete -> a TrueState property is mandatory",
                 this.browseName.toString(),
@@ -72,7 +63,7 @@ export class UATwoStateDiscreteImpl extends UAVariableImpl implements UATwoState
             } else if (text === this.getFalseStateAsString()) {
                 this.setValue(false, options);
             } else {
-                throw new Error("setValue invalid value " + value);
+                throw new Error(`setValue invalid value ${value}`);
             }
         }
     }
@@ -87,18 +78,20 @@ export class UATwoStateDiscreteImpl extends UAVariableImpl implements UATwoState
         }
     }
     getTrueStateAsString(): string {
-        return (this.trueState.readValue().value.value as LocalizedText).text || "";
+        return (this.$5.trueState.readValue().value.value as LocalizedText).text || "";
     }
     getFalseStateAsString(): string {
-        return (this.falseState.readValue().value.value as LocalizedText).text || "";
+        return (this.$5.falseState.readValue().value.value as LocalizedText).text || "";
     }
 
-    public clone(options1: any, optionalFilter: any, extraInfo: any): UAVariable {
+    public clone(options1: CloneOptions, optionalFilter?: CloneFilter, extraInfo?: CloneExtraInfo): UAVariable {
         const variable1 = UAVariableImpl.prototype.clone.call(this, options1, optionalFilter, extraInfo);
         promoteToTwoStateDiscrete(variable1);
         return variable1;
     }
 }
+export type UATwoStateDiscreteImpl = UATwoStateDiscreteImplBase & UATwoStateDiscreteEx;
+export const UATwoStateDiscreteImpl = UATwoStateDiscreteImplBase as unknown as new () => UATwoStateDiscreteImpl;
 
 export function promoteToTwoStateDiscrete(node: UAVariable): UATwoStateDiscreteEx {
     if (node instanceof UATwoStateDiscreteImpl) {
@@ -115,7 +108,7 @@ registerNodePromoter(VariableTypeIds.TwoStateDiscreteType, promoteToTwoStateDisc
 export function _addTwoStateDiscrete(namespace: INamespace, options: AddTwoStateDiscreteOptions): UATwoStateDiscreteEx {
     const addressSpace = namespace.addressSpace;
 
-    assert(!Object.prototype.hasOwnProperty.call(options, "ValuePrecision"));
+    assert(!Object.hasOwn(options, "ValuePrecision"));
 
     const twoStateDiscreteType = addressSpace.findVariableType("TwoStateDiscreteType");
     if (!twoStateDiscreteType) {

package/src/event_data.ts

@@ -16,68 +16,68 @@ type FullBrowsePath = string;
 /**
  */
 export class EventData implements IEventData {
-  public eventId: NodeId;
-  #eventDataSource: BaseNode;
-  #cache: {
-    __values: { [key: NodeIdString]: Variant };
-    __nodeIdToNode: { [key: NodeIdString]: BaseNode };
-    __pathToNodeId: { [key: FullBrowsePath]: NodeId };
-    __nodeIdToFullPath: { [key: NodeIdString]: FullBrowsePath };
-  };
-
-  constructor(eventTypeNode: BaseNode) {
-    this.#cache = {
-      __values: {},
-      __nodeIdToNode: {},
-      __pathToNodeId: {},
-      __nodeIdToFullPath: {}
+    public eventId: NodeId;
+    #eventDataSource: BaseNode;
+    #cache: {
+        __values: { [key: NodeIdString]: Variant };
+        __nodeIdToNode: { [key: NodeIdString]: BaseNode };
+        __pathToNodeId: { [key: FullBrowsePath]: NodeId };
+        __nodeIdToFullPath: { [key: NodeIdString]: FullBrowsePath };
     };
 
-    this.eventId = new NodeId();
-    this.#eventDataSource = eventTypeNode;
-  }
+    constructor(eventTypeNode: BaseNode) {
+        this.#cache = {
+            __values: {},
+            __nodeIdToNode: {},
+            __pathToNodeId: {},
+            __nodeIdToFullPath: {}
+        };
 
-  public getEventDataSource(): BaseNode {
-    return this.#eventDataSource;
-  }
-  public _createValue(fullBrowsePath: string, node: BaseNode, variant: VariantLike): void {
-    const eventData = this as Record<string, unknown>;
-    assert(!eventData[fullBrowsePath], `already exists ${fullBrowsePath}`);
+        this.eventId = new NodeId();
+        this.#eventDataSource = eventTypeNode;
+    }
 
-    const lowerName = fullBrowsePath.split(".").map(lowerFirstLetter).join(".");
+    public getEventDataSource(): BaseNode {
+        return this.#eventDataSource;
+    }
+    public _createValue(fullBrowsePath: string, node: BaseNode, variant: VariantLike): void {
+        const eventData = this as Record<string, unknown>;
+        assert(!eventData[fullBrowsePath], `already exists ${fullBrowsePath}`);
 
-    eventData[lowerName] = Variant.coerce(variant);
+        const lowerName = fullBrowsePath.split(".").map(lowerFirstLetter).join(".");
 
-    this.#cache.__pathToNodeId[fullBrowsePath] = node.nodeId;
-    this.#cache.__nodeIdToNode[node.nodeId.toString()] = node;
-    this.#cache.__nodeIdToFullPath[node.nodeId.toString()] = fullBrowsePath;
-    this.#cache.__values[node.nodeId.toString()] = eventData[lowerName] as Variant;
-  }
+        eventData[lowerName] = Variant.coerce(variant);
 
-  public _browse(browsePath: BrowsePath): BrowsePathResult | null {
-    if (!sameNodeId(browsePath.startingNode, this.#eventDataSource.nodeId)) {
-      return null;
+        this.#cache.__pathToNodeId[fullBrowsePath] = node.nodeId;
+        this.#cache.__nodeIdToNode[node.nodeId.toString()] = node;
+        this.#cache.__nodeIdToFullPath[node.nodeId.toString()] = fullBrowsePath;
+        this.#cache.__values[node.nodeId.toString()] = eventData[lowerName] as Variant;
     }
-    const fullBrowsePath = (browsePath.relativePath.elements || []).map((b) => b.targetName.toString()).join(".");
-    const nodeId = this.#cache.__pathToNodeId[fullBrowsePath];
-    if (!nodeId) return null;
-    return new BrowsePathResult({
-      statusCode: StatusCodes.Good,
-      targets: [
-        {
-          remainingPathIndex: 0,
-          targetId: coerceExpandedNodeId(nodeId)
+
+    public _browse(browsePath: BrowsePath): BrowsePathResult | null {
+        if (!sameNodeId(browsePath.startingNode, this.#eventDataSource.nodeId)) {
+            return null;
         }
-      ]
-    });
-  }
+        const fullBrowsePath = (browsePath.relativePath.elements || []).map((b) => b.targetName.toString()).join(".");
+        const nodeId = this.#cache.__pathToNodeId[fullBrowsePath];
+        if (!nodeId) return null;
+        return new BrowsePathResult({
+            statusCode: StatusCodes.Good,
+            targets: [
+                {
+                    remainingPathIndex: 0,
+                    targetId: coerceExpandedNodeId(nodeId)
+                }
+            ]
+        });
+    }
 
-  public _readValue(nodeId: NodeId): Variant | null {
-    const key = nodeId.toString();
-    const cached_value = this.#cache.__values[key];
-    if (cached_value) {
-      return cached_value;
+    public _readValue(nodeId: NodeId): Variant | null {
+        const key = nodeId.toString();
+        const cached_value = this.#cache.__values[key];
+        if (cached_value) {
+            return cached_value;
+        }
+        return null;
     }
-    return null;
-  }
 }

package/src/extension_object_array_node.ts

@@ -1,23 +1,20 @@
 /**
  * @module node-opcua-address-space.Private
  */
-import { assert } from "node-opcua-assert";
 
+import type { UADataType, UADynamicVariableArray, UAObject, UAReferenceType, UAVariable } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
 import { BrowseDirection, NodeClass } from "node-opcua-data-model";
 import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
-import { NodeId } from "node-opcua-nodeid";
-import { Variant } from "node-opcua-variant";
-import { DataType } from "node-opcua-variant";
-import { VariantArrayType } from "node-opcua-variant";
-
 import { ExtensionObject } from "node-opcua-extension-object";
-import { UADataType, UADynamicVariableArray, UAObject, UAReferenceType, UAVariable } from "node-opcua-address-space-base";
+import type { NodeId } from "node-opcua-nodeid";
+import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
 import { UAVariableImpl } from "./ua_variable_impl";
 
-const doDebug = checkDebugFlag(__filename);
-const debugLog = make_debugLog(__filename);
+const _doDebug = checkDebugFlag(__filename);
+const _debugLog = make_debugLog(__filename);
 const errorLog = make_errorLog(__filename);
-const warningLog= make_warningLog(__filename);
+const warningLog = make_warningLog(__filename);
 
 /*
  * define a complex Variable containing a array of extension objects
@@ -44,8 +41,8 @@ function removeElementByIndex<T extends ExtensionObject>(uaArrayVariableNode: UA
 
     // remove element from global array (inefficient)
     uaArrayVariableNode.$$extensionObjectArray.splice(elementIndex, 1);
-    if(uaArrayVariableNode.$$extensionObjectArray !== uaArrayVariableNode.$dataValue.value.value) {
-    //    throw new Error("internal error");
+    if (uaArrayVariableNode.$$extensionObjectArray !== uaArrayVariableNode.$dataValue.value.value) {
+        //    throw new Error("internal error");
     }
     uaArrayVariableNode.touchValue();
 
@@ -125,25 +122,27 @@ export function createExtObjArrayNode<T extends ExtensionObject>(parentFolder: U
     return uaArrayVariableNode;
 }
 
-function _getElementBrowseName<T extends ExtensionObject>
-    (this: UADynamicVariableArray<T>, extObj: ExtensionObject, index: number | number[]) {
+function _getElementBrowseName<T extends ExtensionObject>(
+    this: UADynamicVariableArray<T>,
+    extObj: ExtensionObject,
+    _index: number | number[]
+) {
     const indexPropertyName1 = this.$$indexPropertyName;
 
-    if (!Object.prototype.hasOwnProperty.call(extObj, indexPropertyName1)) {
+    if (!Object.hasOwn(extObj, indexPropertyName1)) {
         warningLog(" extension object does not have ", indexPropertyName1, extObj);
     }
     // assert(extObj.constructor === addressSpace.constructExtensionObject(dataType));
-    assert(Object.prototype.hasOwnProperty.call(extObj, indexPropertyName1));
+    assert(Object.hasOwn(extObj, indexPropertyName1));
     const browseName = (extObj as any)[indexPropertyName1].toString();
     return browseName;
-};
+}
 
 export function bindExtObjArrayNode<T extends ExtensionObject>(
     uaArrayVariableNode: UADynamicVariableArray<T>,
     variableTypeNodeId: string | NodeId,
     indexPropertyName: string
 ): UAVariable {
-
     assert(uaArrayVariableNode.valueRank === 1, "expecting a one dimension array");
 
     const addressSpace = uaArrayVariableNode.addressSpace;
@@ -151,7 +150,7 @@ export function bindExtObjArrayNode<T extends ExtensionObject>(
     const variableType = addressSpace.findVariableType(variableTypeNodeId);
     // c8 ignore next
     if (!variableType || variableType.nodeId.isEmpty()) {
-        throw new Error("Cannot find VariableType " + variableTypeNodeId.toString());
+        throw new Error(`Cannot find VariableType ${variableTypeNodeId.toString()}`);
     }
 
     const structure = addressSpace.findDataType("Structure");
@@ -163,7 +162,7 @@ export function bindExtObjArrayNode<T extends ExtensionObject>(
     let dataType = addressSpace.findDataType(variableType.dataType);
     // c8 ignore next
     if (!dataType) {
-        throw new Error("Cannot find DataType " + variableType.dataType.toString());
+        throw new Error(`Cannot find DataType ${variableType.dataType.toString()}`);
     }
 
     assert(dataType.isSubtypeOf(structure), "expecting a structure (= ExtensionObject) here ");
@@ -174,13 +173,13 @@ export function bindExtObjArrayNode<T extends ExtensionObject>(
 
     // verify that an object with same doesn't already exist
     dataType = addressSpace.findDataType(variableType.dataType)! as UADataType;
-    assert(dataType!.isSubtypeOf(structure), "expecting a structure (= ExtensionObject) here ");
+    assert(dataType?.isSubtypeOf(structure), "expecting a structure (= ExtensionObject) here ");
     assert(!uaArrayVariableNode.$$extensionObjectArray, "UAVariable ExtensionObject array already bounded");
     uaArrayVariableNode.$$dataType = dataType;
     uaArrayVariableNode.$$extensionObjectArray = [];
     uaArrayVariableNode.$$indexPropertyName = indexPropertyName;
     uaArrayVariableNode.$$getElementBrowseName = _getElementBrowseName;
-    uaArrayVariableNode.$dataValue.value.value =  uaArrayVariableNode.$$extensionObjectArray;
+    uaArrayVariableNode.$dataValue.value.value = uaArrayVariableNode.$$extensionObjectArray;
     uaArrayVariableNode.$dataValue.value.arrayType = VariantArrayType.Array;
 
     const bindOptions: any = {
@@ -252,8 +251,8 @@ export function addElement<T extends ExtensionObject>(
         elVar.bindExtensionObject(extensionObject, { force: true });
     }
 
-    if(uaArrayVariableNode.$$extensionObjectArray !== uaArrayVariableNode.$dataValue.value.value) {
-    //    throw new Error("internal error");
+    if (uaArrayVariableNode.$$extensionObjectArray !== uaArrayVariableNode.$dataValue.value.value) {
+        //    throw new Error("internal error");
     }
     // also add the value inside
     uaArrayVariableNode.$$extensionObjectArray.push(elVar.$extensionObject);
@@ -284,10 +283,10 @@ export function removeElement<T extends ExtensionObject>(
     } else if (typeof element === "function") {
         // find element by functor
         elementIndex = _array.findIndex(element);
-    } else if (element && element.nodeClass) {
+    } else if (element?.nodeClass) {
         // find element by name
-        const browseNameToFind = element.browseName.name!.toString();
-        elementIndex = _array.findIndex((obj: any, i: number) => {
+        const browseNameToFind = element.browseName.name?.toString();
+        elementIndex = _array.findIndex((obj: any, _i: number) => {
             const browseName = uaArrayVariableNode.$$getElementBrowseName(obj, elementIndex).toString();
             return browseName === browseNameToFind;
         });
@@ -297,7 +296,7 @@ export function removeElement<T extends ExtensionObject>(
 
     // c8 ignore next
     if (elementIndex < 0) {
-        throw new Error("removeElement: cannot find element matching " + element.toString());
+        throw new Error(`removeElement: cannot find element matching ${element.toString()}`);
     }
     return removeElementByIndex(uaArrayVariableNode, elementIndex);
 }