node-opcua-address-space 2.169.0 → 2.172.0

package/src/event_data.ts

@@ -1,26 +1,24 @@
 /**
  * @module node-opcua-address-space.Private
  */
+
+import type { BaseNode, IEventData } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import { coerceExpandedNodeId, NodeId, sameNodeId } from "node-opcua-nodeid";
 import { StatusCodes } from "node-opcua-status-code";
-import { BrowsePath, BrowsePathResult } from "node-opcua-types";
-import { Variant, VariantLike } from "node-opcua-variant";
-
-import { BaseNode, IEventData } from "node-opcua-address-space-base";
+import { type BrowsePath, BrowsePathResult } from "node-opcua-types";
 import { lowerFirstLetter } from "node-opcua-utils";
+import { Variant, type VariantLike } from "node-opcua-variant";
 
 type NodeIdString = string;
 type FullBrowsePath = string;
 
-
 /**
  */
 export class EventData implements IEventData {
     public eventId: NodeId;
-    public $eventDataSource: BaseNode;
-
-    public $cache: {
+    #eventDataSource: BaseNode;
+    #cache: {
         __values: { [key: NodeIdString]: Variant };
         __nodeIdToNode: { [key: NodeIdString]: BaseNode };
         __pathToNodeId: { [key: FullBrowsePath]: NodeId };
@@ -28,7 +26,7 @@ export class EventData implements IEventData {
     };
 
     constructor(eventTypeNode: BaseNode) {
-        this.$cache = {
+        this.#cache = {
             __values: {},
             __nodeIdToNode: {},
             __pathToNodeId: {},
@@ -36,45 +34,50 @@ export class EventData implements IEventData {
         };
 
         this.eventId = new NodeId();
-        this.$eventDataSource = eventTypeNode;
+        this.#eventDataSource = eventTypeNode;
     }
 
+    public getEventDataSource(): BaseNode {
+        return this.#eventDataSource;
+    }
     public _createValue(fullBrowsePath: string, node: BaseNode, variant: VariantLike): void {
-        const eventData = this as any;
-        assert(!eventData[fullBrowsePath], "already exists " + fullBrowsePath);
+        const eventData = this as Record<string, unknown>;
+        assert(!eventData[fullBrowsePath], `already exists ${fullBrowsePath}`);
 
         const lowerName = fullBrowsePath.split(".").map(lowerFirstLetter).join(".");
 
         eventData[lowerName] = Variant.coerce(variant);
 
-        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];
+        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;
     }
 
     public _browse(browsePath: BrowsePath): BrowsePathResult | null {
-        if (!sameNodeId(browsePath.startingNode, this.$eventDataSource.nodeId)) {
+        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];
+        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),
-            }]
-        })
+            targets: [
+                {
+                    remainingPathIndex: 0,
+                    targetId: coerceExpandedNodeId(nodeId)
+                }
+            ]
+        });
     }
 
     public _readValue(nodeId: NodeId): Variant | null {
         const key = nodeId.toString();
-        const cached_value = this.$cache.__values[key];
+        const cached_value = this.#cache.__values[key];
         if (cached_value) {
             return cached_value;
         }
         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);
 }

package/src/get_basic_datatype.ts

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

package/src/historical_access/address_space_historical_data_node.ts

@@ -4,13 +4,21 @@
 // tslint:disable:no-console
 
 import chalk from "chalk";
-
+import type {
+    ContinuationData,
+    IAddressSpace,
+    ISessionContext,
+    IVariableHistorian,
+    IVariableHistorianOptions,
+    UAVariable
+} from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
-import { AccessLevelFlag, NodeClass, QualifiedNameLike } from "node-opcua-data-model";
-import { DataValue } from "node-opcua-data-value";
+import { AccessLevelFlag, NodeClass, type QualifiedNameLike } from "node-opcua-data-model";
+import type { DataValue } from "node-opcua-data-value";
 import { isMinDate, minDate } from "node-opcua-date-time";
-import { UAHistoricalDataConfiguration } from "node-opcua-nodeset-ua";
-import { NumericRange } from "node-opcua-numeric-range";
+import { make_warningLog } from "node-opcua-debug";
+import type { UAHistoricalDataConfiguration } from "node-opcua-nodeset-ua";
+import type { NumericRange } from "node-opcua-numeric-range";
 import {
     HistoryData,
     HistoryReadResult,
@@ -19,72 +27,73 @@ import {
     ReadProcessedDetails,
     ReadRawModifiedDetails
 } from "node-opcua-service-history";
-import { StatusCodes } from "node-opcua-status-code";
-import { CallbackT } from "node-opcua-status-code";
+import { type CallbackT, StatusCodes } from "node-opcua-status-code";
 import { DataType } from "node-opcua-variant";
-import {
-    IAddressSpace,
-    IVariableHistorian,
-    IVariableHistorianOptions,
-    UAVariable,
-    ContinuationData
-} from "node-opcua-address-space-base";
-import { make_warningLog } from "node-opcua-debug";
-import { ISessionContext } from "node-opcua-address-space-base";
-
-import { UAVariableImpl } from "../ua_variable_impl";
 import { AddressSpace } from "../../source/address_space_ts";
-import { AddressSpacePrivate } from "../address_space_private";
+import type { AddressSpacePrivate } from "../address_space_private";
+import { UAVariableImpl } from "../ua_variable_impl";
 
 const warningLog = make_warningLog(__filename);
 
 // tslint:disable:no-var-requires
+interface DequeueItem<T> {
+    data: T | null;
+    next: DequeueItem<T>;
+    prev: DequeueItem<T>;
+}
+interface Dequeue<T> {
+    push(value: T): void;
+    shift(): T | undefined;
+    first(): T | undefined;
+    length: number;
+    head: DequeueItem<T>;
+}
 const Dequeue = require("dequeue");
 
 /* interface Historian  */
 // {
 //
 // }
-function inInTimeRange(historyReadDetails: any, dataValue: DataValue): boolean {
+function inInTimeRange(historyReadDetails: ReadRawModifiedDetails, dataValue: DataValue): boolean {
     if (
         historyReadDetails.startTime &&
         !isMinDate(historyReadDetails.startTime) &&
-        dataValue.sourceTimestamp! < historyReadDetails.startTime
+        (dataValue.sourceTimestamp || 0) < historyReadDetails.startTime
     ) {
         return false;
     }
     if (
         historyReadDetails.endTime &&
         !isMinDate(historyReadDetails.endTime) &&
-        dataValue.sourceTimestamp! > historyReadDetails.endTime
+        (dataValue.sourceTimestamp || 0) > historyReadDetails.endTime
     ) {
         return false;
     }
     return true;
 }
 
-function inInTimeRange2(historyReadDetails: any, dataValue: DataValue): boolean {
+function inInTimeRange2(historyReadDetails: ReadRawModifiedDetails, dataValue: DataValue): boolean {
     if (
         historyReadDetails.endTime &&
         !isMinDate(historyReadDetails.endTime) &&
-        dataValue.sourceTimestamp! > historyReadDetails.endTime
+        (dataValue.sourceTimestamp || 0) > historyReadDetails.endTime
     ) {
         return false;
     }
     return !(
         historyReadDetails.startTime &&
         !isMinDate(historyReadDetails.startTime) &&
-        dataValue.sourceTimestamp! < historyReadDetails.startTime
+        (dataValue.sourceTimestamp || 0) < historyReadDetails.startTime
     );
 }
 
 function filter_dequeue(
-    q: any,
+    q: Dequeue<DataValue>,
     historyReadRawModifiedDetails: ReadRawModifiedDetails,
     onlyThisNumber: number,
     isReversed: boolean
-) {
-    const r: any[] = [];
+): DataValue[] {
+    const r: DataValue[] = [];
     const predicate = isReversed
         ? inInTimeRange2.bind(null, historyReadRawModifiedDetails)
         : inInTimeRange.bind(null, historyReadRawModifiedDetails);
@@ -117,7 +126,7 @@ function filter_dequeue(
 
 export class VariableHistorian implements IVariableHistorian {
     public readonly node: UAVariable;
-    private readonly _timeline: any /* Dequeue */;
+    private readonly _timeline: Dequeue<DataValue>;
     private readonly _maxOnlineValues: number;
     private lastDate: Date;
     private lastDatePicoSeconds: number;
@@ -149,8 +158,8 @@ export class VariableHistorian implements IVariableHistorian {
                     this.lastDate,
                     "\n last known picoSeconds = ",
                     this.lastDatePicoSeconds,
-                    "\n lastValue = ",
-                    this._timeline[this._timeline.length - 1]?.toString()
+                    "\n lastValue = "
+                    /// this._timeline[this._timeline.length - 1]?.toString()
                 );
                 // artificially increment date by one 100 picoseconds
                 newDataValue.sourcePicoseconds++;
@@ -170,7 +179,7 @@ export class VariableHistorian implements IVariableHistorian {
 
         if (this._timeline.length >= this._maxOnlineValues || this._timeline.length === 1) {
             const first = this._timeline.first();
-            (this.node as UAVariableImpl)._update_startOfOnlineArchive(first.sourceTimestamp);
+            (this.node as UAVariableImpl)._update_startOfOnlineArchive(first?.sourceTimestamp || minDate);
             // we update the node startOnlineDate
         }
     }
@@ -204,7 +213,7 @@ function _get_startOfArchive(node: UAVariableImpl) {
     if (!node.$historicalDataConfiguration) {
         throw new Error("this variable has no HistoricalDataConfiguration");
     }
-    return node.$historicalDataConfiguration!.startOfArchive?.readValue();
+    return node.$historicalDataConfiguration?.startOfArchive?.readValue();
 }
 
 function _update_startOfArchive(this: UAVariableImpl, newDate: Date): void {
@@ -255,7 +264,7 @@ function _historyPush(this: UAVariableImpl, newDataValue: DataValue) {
     if (!this.varHistorian) {
         throw new Error("this variable has no HistoricalDataConfiguration");
     }
-    assert(Object.prototype.hasOwnProperty.call(this, "historizing"), "expecting a historizing attribute on node");
+    assert(Object.hasOwn(this, "historizing"), "expecting a historizing attribute on node");
     if (!this.historizing) {
         return; //
     }
@@ -265,11 +274,11 @@ function _historyPush(this: UAVariableImpl, newDataValue: DataValue) {
 
 function _historyReadModify(
     this: UAVariable,
-    context: ISessionContext,
-    historyReadRawModifiedDetails: ReadRawModifiedDetails,
-    indexRange: NumericRange | null,
-    dataEncoding: QualifiedNameLike | null,
-    continuationData: ContinuationData,
+    _context: ISessionContext,
+    _historyReadRawModifiedDetails: ReadRawModifiedDetails,
+    _indexRange: NumericRange | null,
+    _dataEncoding: QualifiedNameLike | null,
+    _continuationData: ContinuationData,
     callback: CallbackT<HistoryReadResult>
 ) {
     //
@@ -338,15 +347,18 @@ function _historyReadRawAsync(
     callback: CallbackT<DataValue[]>
 ) {
     assert(typeof callback === "function");
-    this.varHistorian!.extractDataValues(historyReadRawModifiedDetails, maxNumberToExtract, isReversed, reverseDataValue, callback);
+    if (!this.varHistorian) {
+        return callback(new Error("this variable has no HistoricalDataConfiguration"));
+    }
+    this.varHistorian.extractDataValues(historyReadRawModifiedDetails, maxNumberToExtract, isReversed, reverseDataValue, callback);
 }
 
 function _historyReadRaw(
     this: UAVariable,
     context: ISessionContext,
     historyReadRawModifiedDetails: ReadRawModifiedDetails,
-    indexRange: NumericRange | null,
-    dataEncoding: QualifiedNameLike | null,
+    _indexRange: NumericRange | null,
+    _dataEncoding: QualifiedNameLike | null,
     continuationData: ContinuationData,
     callback: CallbackT<HistoryReadResult>
 ): void {
@@ -455,7 +467,8 @@ function _historyReadRaw(
             historyData: new HistoryData({ dataValues: values }),
             statusCode
         });
-        return callback(null, result2);
+        callback(null, result2);
+        return;
     }
 
     // todo add special treatment for when startTime > endTime
@@ -464,17 +477,18 @@ function _historyReadRaw(
     let maxNumberToExtract = 0;
     let isReversed = false;
     let reverseDataValue = false;
-    if (isMinDate(historyReadRawModifiedDetails.endTime!)) {
+    if (isMinDate(historyReadRawModifiedDetails.endTime)) {
         // end time is not specified
         maxNumberToExtract = historyReadRawModifiedDetails.numValuesPerNode;
-        if (isMinDate(historyReadRawModifiedDetails.startTime!)) {
+        if (isMinDate(historyReadRawModifiedDetails.startTime)) {
             // end start and start time are not specified, this is invalid
             const result = new HistoryReadResult({
                 statusCode: StatusCodes.BadHistoryOperationUnsupported // should be an error
             });
-            return callback(null, result);
+            callback(null, result);
+            return;
         }
-    } else if (isMinDate(historyReadRawModifiedDetails.startTime!)) {
+    } else if (isMinDate(historyReadRawModifiedDetails.startTime)) {
         // start time is not specified
         // end time is specified
         maxNumberToExtract = historyReadRawModifiedDetails.numValuesPerNode;
@@ -488,12 +502,13 @@ function _historyReadRaw(
             const result = new HistoryReadResult({
                 statusCode: StatusCodes.BadHistoryOperationUnsupported // should be an error
             });
-            return callback(null, result);
+            callback(null, result);
+            return;
         }
     } else {
         // start time is specified
         // end time is specified
-        if (historyReadRawModifiedDetails.endTime!.getTime() < historyReadRawModifiedDetails.startTime!.getTime()) {
+        if ((historyReadRawModifiedDetails.endTime?.getTime() || 0) < (historyReadRawModifiedDetails.startTime?.getTime() || 0)) {
             reverseDataValue = true;
             const tmp = historyReadRawModifiedDetails.endTime;
             historyReadRawModifiedDetails.endTime = historyReadRawModifiedDetails.startTime;
@@ -714,7 +729,7 @@ export function AddressSpace_installHistoricalDataNode(
     node._historyReadRaw = _historyReadRaw;
     node._historyReadRawAsync = _historyReadRawAsync;
 
-    node.varHistorian = (options as any).historian || AddressSpace.historizerFactory.create(node, options);
+    node.varHistorian = (options as { historian?: boolean }).historian || AddressSpace.historizerFactory.create(node, options);
 
     const historicalDataConfigurationType = addressSpace.findObjectType("HistoricalDataConfigurationType");
     if (!historicalDataConfigurationType) {

package/src/idx_iterator.ts

@@ -1,9 +1,4 @@
-
-
-
-
 export class IndexIterator {
-
     public current: number[] | null = null;
     constructor(private limits: number[]) {
         this.reset();
@@ -17,14 +12,13 @@ export class IndexIterator {
     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) {
+                if (n === 0) {
                     this.current = null;
                     return false;
                 }
@@ -33,7 +27,7 @@ export class IndexIterator {
             }
             this.current[n] = this.current[n] + 1;
             return true;
-        }
+        };
         const n = this.limits.length - 1;
         if (!increase(n)) {
             this.current = null;
@@ -43,10 +37,8 @@ export class IndexIterator {
         if (!this.current) {
             throw new Error("Outof bond");
         }
-        const r = [... this.current];
+        const r = [...this.current];
         this.increment();
         return r;
     }
-
-
-}
+}