node-opcua-address-space 2.55.0 → 2.58.0

package/distHelpers/mock_session.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockSession = exports.MockContinuationPointManager = void 0;
+const node_opcua_nodeid_1 = require("node-opcua-nodeid");
+class MockContinuationPointManager {
+    registerHistoryReadRaw(maxElements, dataValues, cnt) {
+        throw new Error("Method not implemented.");
+    }
+    getNextHistoryReadRaw(numValues, cnt) {
+        throw new Error("Method not implemented.");
+    }
+    registerReferences(maxElements, values, cnt) {
+        throw new Error("Method not implemented.");
+    }
+    getNextReferences(numValue, cnt) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.MockContinuationPointManager = MockContinuationPointManager;
+exports.mockSession = {
+    getSessionId() {
+        return node_opcua_nodeid_1.NodeId.nullNodeId;
+    },
+    continuationPointManager: new MockContinuationPointManager()
+};
+//# sourceMappingURL=mock_session.js.map

package/distHelpers/mock_session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock_session.js","sourceRoot":"","sources":["../test_helpers/mock_session.ts"],"names":[],"mappings":";;;AAEA,yDAA2C;AAG3C,MAAa,4BAA4B;IAC9B,sBAAsB,CACzB,WAAmB,EACnB,UAAuB,EACvB,GAAqB;QAErB,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC/C,CAAC;IACM,qBAAqB,CAAC,SAAiB,EAAE,GAAqB;QACjE,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC/C,CAAC;IACM,kBAAkB,CACrB,WAAmB,EACnB,MAA8B,EAC9B,GAAqB;QAErB,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC/C,CAAC;IACM,iBAAiB,CAAC,QAAgB,EAAE,GAAqB;QAC5D,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC/C,CAAC;CACJ;AArBD,oEAqBC;AAEY,QAAA,WAAW,GAAG;IACvB,YAAY;QACR,OAAO,0BAAM,CAAC,UAAU,CAAC;IAC7B,CAAC;IACD,wBAAwB,EAAE,IAAI,4BAA4B,EAAE;CAC/D,CAAC"}

package/generate.js

@@ -1 +1 @@
-const generator = require("node-opcua-generator");
+const generator = require("node-opcua-generator");

package/nodeJS.d.ts

@@ -1 +1 @@
-export * from "./distNodeJS";
+export * from "./distNodeJS";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-address-space",
-    "version": "2.55.0",
+    "version": "2.58.0",
     "description": "pure nodejs OPCUA SDK - module -address-space",
     "main": "./dist/src/index_current.js",
     "types": "./dist/source/index.d.ts",
@@ -10,7 +10,8 @@
     "scripts": {
         "build": "tsc -b",
         "test": "mocha",
-        "lint": "eslint source/**/*.ts",
+        "lint": "eslint source test src source_nodejs test_helpers",
+        "format": "prettier --write source test src source_nodejs test_helpers",
         "clean": "node -e \"require('rimraf').sync('dist');\"",
         "c": "mocha --version"
     },
@@ -20,49 +21,48 @@
         "chalk": "4.1.2",
         "dequeue": "^1.0.5",
         "lodash": "4.17.21",
-        "node-opcua-address-space-base": "2.55.0",
+        "node-opcua-address-space-base": "2.58.0",
         "node-opcua-assert": "2.55.0",
-        "node-opcua-basic-types": "2.55.0",
-        "node-opcua-client-dynamic-extension-object": "2.55.0",
+        "node-opcua-basic-types": "2.57.0",
+        "node-opcua-client-dynamic-extension-object": "2.57.0",
         "node-opcua-constants": "2.52.0",
-        "node-opcua-data-access": "2.55.0",
-        "node-opcua-data-model": "2.55.0",
-        "node-opcua-data-value": "2.55.0",
+        "node-opcua-data-access": "2.57.0",
+        "node-opcua-data-model": "2.57.0",
+        "node-opcua-data-value": "2.57.0",
         "node-opcua-date-time": "2.55.0",
         "node-opcua-debug": "2.55.0",
         "node-opcua-enum": "2.55.0",
-        "node-opcua-factory": "2.55.0",
+        "node-opcua-factory": "2.57.0",
         "node-opcua-nodeid": "2.55.0",
-        "node-opcua-nodeset-ua": "2.55.0",
-        "node-opcua-numeric-range": "2.55.0",
-        "node-opcua-object-registry": "2.55.0",
-        "node-opcua-pseudo-session": "2.55.0",
-        "node-opcua-schemas": "2.55.0",
-        "node-opcua-service-browse": "2.55.0",
-        "node-opcua-service-call": "2.55.0",
-        "node-opcua-service-filter": "2.55.0",
-        "node-opcua-service-history": "2.55.0",
-        "node-opcua-service-translate-browse-path": "2.55.0",
-        "node-opcua-service-write": "2.55.0",
-        "node-opcua-status-code": "2.55.0",
-        "node-opcua-types": "2.55.0",
-        "node-opcua-utils": "2.55.0",
-        "node-opcua-variant": "2.55.0",
-        "node-opcua-xml2json": "2.55.0",
+        "node-opcua-nodeset-ua": "2.58.0",
+        "node-opcua-numeric-range": "2.57.0",
+        "node-opcua-object-registry": "2.56.0",
+        "node-opcua-pseudo-session": "2.57.0",
+        "node-opcua-schemas": "2.57.0",
+        "node-opcua-service-browse": "2.57.0",
+        "node-opcua-service-call": "2.57.0",
+        "node-opcua-service-filter": "2.57.0",
+        "node-opcua-service-history": "2.57.0",
+        "node-opcua-service-translate-browse-path": "2.57.0",
+        "node-opcua-service-write": "2.57.0",
+        "node-opcua-status-code": "2.56.0",
+        "node-opcua-types": "2.57.0",
+        "node-opcua-utils": "2.57.0",
+        "node-opcua-variant": "2.57.0",
+        "node-opcua-xml2json": "2.57.0",
         "set-prototype-of": "^1.0.0",
         "thenify": "^3.3.1",
         "xml-writer": "^1.7.0"
     },
     "devDependencies": {
-        "date-utils": "^1.2.21",
         "humanize": "0.0.9",
         "node-opcua-benchmarker": "2.55.0",
         "node-opcua-binary-stream": "2.55.0",
-        "node-opcua-extension-object": "2.55.0",
-        "node-opcua-leak-detector": "2.55.0",
-        "node-opcua-nodesets": "2.51.0",
-        "node-opcua-packet-analyzer": "2.55.0",
-        "node-opcua-test-fixtures": "2.55.0",
+        "node-opcua-extension-object": "2.57.0",
+        "node-opcua-leak-detector": "2.56.0",
+        "node-opcua-nodesets": "2.57.0",
+        "node-opcua-packet-analyzer": "2.57.0",
+        "node-opcua-test-fixtures": "2.57.0",
         "should": "^13.2.3",
         "sinon": "^11.1.2",
         "source-map-support": "^0.5.20"
@@ -82,5 +82,5 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "28fdbfe1c5306fd0e69758ccacfa2c6d1722115c"
+    "gitHead": "a5d0c4ddd44eda6a4710afd6d98f9b16033a95b0"
 }

package/source/address_space_ts.ts

@@ -37,7 +37,6 @@ import { MinimalistAddressSpace } from "../src/reference_impl";
 import { Namespace } from "./namespace";
 import { UARootFolder } from "./ua_root_folder";
 
-
 export declare function resolveReferenceType(addressSpace: MinimalistAddressSpace, reference: UAReference): UAReferenceType;
 
 export declare function resolveReferenceNode(addressSpace: MinimalistAddressSpace, reference: UAReference): BaseNode;
@@ -125,7 +124,6 @@ export interface XAxisDefinitionVariable extends UAVariable {
     euRange: RangeVariable;
 }
 
-
 export declare const NamespaceOptions: { nodeIdNameSeparator: string };
 
 export interface UATypesFolder extends UAFolder {
@@ -187,7 +185,6 @@ export declare class VariableHistorian implements IVariableHistorian {
 
 export type UAClonable = UAObject | UAVariable | UAMethod;
 
-
 export interface Enumeration extends UAVariable {}
 export declare function createExtObjArrayNode<T extends ExtensionObject>(
     parentFolder: UAObject,

package/source/continuation_points/continuation_point_manager.ts

@@ -1,11 +1,73 @@
 /**
  * @module node-opcua-server
  */
-import { assert } from "node-opcua-assert";
 import { StatusCode, StatusCodes } from "node-opcua-status-code";
 import { BrowseResultOptions, ReferenceDescription } from "node-opcua-types";
-import { ContinuationPoint } from "node-opcua-address-space-base";
+import {
+    ContinuationPoint,
+    IContinuationPointManager,
+    IContinuationPointInfo,
+    ContinuationData
+} from "node-opcua-address-space-base";
+import { DataValue } from "node-opcua-data-value";
+import { runInThisContext } from "vm";
 
+/**
+ * from https://reference.opcfoundation.org/v104/Core/docs/Part4/7.6/
+ *
+ * A ContinuationPoint is used to pause a Browse, QueryFirst or HistoryRead operation and allow it to be restarted later by calling BrowseNext,
+ * QueryNext or HistoryRead.
+ * - Operations are paused when the number of results found exceeds the limits set by either the Client or the Server.
+ * - The Client specifies the maximum number of results per operation in the request message.
+ * - A Server shall not return more than this number of results but it may return fewer results.
+ * - The Server allocates a  ContinuationPoint if there are more results to return.
+ * - Servers shall support at least one ContinuationPoint per Session.
+ * - Servers specify a maximum number of ContinuationPoints per Session in the ServerCapabilities Object defined in OPC 10000-5.
+ * - ContinuationPoints remain active until
+ *     a/ the Client retrieves the remaining results,
+ *     b/ or, the Client releases the ContinuationPoint
+ *     c/ or the Session is closed.
+ * - A Server shall automatically free ContinuationPoints from prior requests from a Session if they are needed to process a new request
+ *   from this Session.
+ * - The Server returns a Bad_ContinuationPointInvalid error if a Client tries to use a ContinuationPoint that has been released.
+ * - A Client can avoid this situation by completing paused operations before starting new operations.
+ * - Requests will often specify multiple operations that may or may not require a ContinuationPoint.
+ * - A Server shall process the operations until it uses the maximum number of continuation points in this response.
+ *   Once that happens the Server shall return a Bad_NoContinuationPoints error for any remaining operations. A Client can avoid
+ *   this situation by sending requests with a number of operations that do not exceed the maximum number  of ContinuationPoints
+ *   per Session defined for the Service in the ServerCapabilities Object defined in OPC 10000-5.
+ *   A Client restarts an operation by passing the ContinuationPoint back to the Server. Server should always be able to reuse the ContinuationPoint
+ *   provided so Servers shall never return Bad_NoContinuationPoints error when continuing a previously halted operation.
+ *   A ContinuationPoint is a subtype of the ByteString data type.
+ *
+ *
+ * for historical access: https://reference.opcfoundation.org/v104/Core/docs/Part11/6.3/
+ *
+ * The continuationPoint parameter in the HistoryRead Service is used to mark a point from which to continue
+ * the read if not all values could be returned in one response. The value is opaque for the Client and is
+ * only used to maintain the state information for the Server to continue from. *
+ *
+ * For HistoricalDataNode requests, a Server may use the timestamp of the last returned data item if the timestamp
+ * is unique. This can reduce the need in the Server to store state information for the continuation point.
+ * The Client specifies the maximum number of results per operation in the request Message. A Server shall
+ * not return more than this number of results but it may return fewer results. The Server allocates a
+ * ContinuationPoint if there are more results to return. The Server may return fewer results due to buffer issues
+ * or other internal constraints. It may also be required to return a continuationPoint due to HistoryRead
+ * parameter constraints. If a request is taking a long time to calculate and is approaching the timeout time, the
+ * Server may return partial results with a continuation point. This may be done if the calculation is going to
+ * take more time than the Client timeout. In some cases it may take longer than the Client timeout to calculate
+ * even one result. Then the Server may return zero results with a continuation point that allows the Server to
+ * resume the calculation on the next Client read call. For additional discussions regarding ContinuationPoints
+ * and HistoryRead please see the individual extensible HistoryReadDetails parameter in 6.4.
+ * If the Client specifies a ContinuationPoint, then the HistoryReadDetails parameter and the TimestampsToReturn
+ * parameter are ignored, because it does not make sense to request different parameters when continuing from a
+ * previous call. It is permissible to change the dataEncoding parameter with each request.
+ * If the Client specifies a ContinuationPoint that is no longer valid, then the Server shall return a
+ * Bad_ContinuationPointInvalid error.
+ * If the releaseContinuationPoints parameter is set in the request the Server shall not return any data and shall
+ * release all ContinuationPoints passed in the request. If the ContinuationPoint for an operation is missing or
+ * invalid then the StatusCode for the operation shall be Bad_ContinuationPointInvalid.
+ */
 let counter = 0;
 
 function make_key() {
@@ -14,107 +76,159 @@ function make_key() {
     return Buffer.from(counter.toString(), "ascii");
 }
 
-export interface ContinuationPointInfo extends BrowseResultOptions {
-    continuationPoint?: ContinuationPoint;
-    references?: ReferenceDescription[];
-    statusCode: StatusCode;
+interface Data {
+    maxElements: number;
+    values: ReferenceDescription[] | DataValue[];
 }
-
-export class ContinuationPointManager {
-    private readonly _map: any;
+export class ContinuationPointManager implements IContinuationPointManager {
+    private _map: Map<string, Data>;
 
     constructor() {
-        this._map = {};
+        this._map = new Map();
     }
 
     /**
-     * returns true if the current number of active continuation point has reach the limit
-     * specified in maxBrowseContinuationPoint
+     * returns true if the current number of active continuation point has reached the limit
+     * specified in maxContinuationPoint
      * @param maxBrowseContinuationPoint
      */
-    public hasReachMaximum(maxBrowseContinuationPoint: number): boolean {
-        if (maxBrowseContinuationPoint === 0) {
+    public hasReachedMaximum(maxContinuationPoint: number): boolean {
+        if (maxContinuationPoint === 0) {
             return false;
         }
-        const nbContinuationPoints = Object.keys(this._map).length;
-        return nbContinuationPoints >= maxBrowseContinuationPoint;
+        const nbContinuationPoints = this._map.size;
+        return nbContinuationPoints >= maxContinuationPoint;
+    }
+
+    public clearContinuationPoints() {
+        // call when a new request to the server is received
+        this._map.clear();
+    }
+
+    public registerHistoryReadRaw(
+        numValuesPerNode: number,
+        dataValues: DataValue[],
+        continuationData: ContinuationData
+    ): IContinuationPointInfo<DataValue> {
+        return this._register(numValuesPerNode, dataValues, continuationData);
+    }
+    public getNextHistoryReadRaw(numValues: number, continuationData: ContinuationData): IContinuationPointInfo<DataValue> {
+        return this._getNext(numValues, continuationData);
+    }
+
+    registerReferences(
+        maxElements: number,
+        values: ReferenceDescription[],
+        continuationData: ContinuationData
+    ): IContinuationPointInfo<ReferenceDescription> {
+        return this._register(maxElements, values, continuationData);
+    }
+    /**
+     * - releaseContinuationPoints = TRUE
+     *
+     *  passed continuationPoints shall be reset to free resources in
+     *  the Server. The continuation points are released and the results
+     *  and diagnosticInfos arrays are empty.
+     *
+     * - releaseContinuationPoints = FALSE
+     *
+     *   passed continuationPoints shall be used to get the next set of
+     *   browse information
+     */
+    getNextReferences(numValues: number, continuationData: ContinuationData): IContinuationPointInfo<ReferenceDescription> {
+        return this._getNext(numValues, continuationData);
     }
 
-    public register(maxElements: number, values: ReferenceDescription[]): ContinuationPointInfo {
-        maxElements = maxElements || values.length;
-        if (maxElements >= values.length) {
+    private _register<T extends DataValue | ReferenceDescription>(
+        maxValues: number,
+        values: T[],
+        continuationData: ContinuationData
+    ): IContinuationPointInfo<T> {
+        if (continuationData.releaseContinuationPoints) {
+            this.clearContinuationPoints();
             return {
                 continuationPoint: undefined,
-                references: values,
+                values: [],
                 statusCode: StatusCodes.Good
             };
         }
+        if (!continuationData.continuationPoint && !continuationData.index) {
+            this.clearContinuationPoints();
+        }
 
-        const key = make_key();
-        const keyHash = key.toString("ascii");
+        if (maxValues >= 1) {
+            // now make sure that only the requested number of value is returned
+            if (values.length === 0) {
+                return {
+                    continuationPoint: undefined,
+                    values: null,
+                    statusCode: StatusCodes.GoodNoData
+                };
+            }
+        }
 
+        maxValues = maxValues || values.length;
+        if (maxValues >= values.length) {
+            return {
+                continuationPoint: undefined,
+                values,
+                statusCode: StatusCodes.Good
+            };
+        }
         // split the array in two ( values)
-        const current_block = values.splice(0, maxElements);
+        const current_block = values.splice(0, maxValues);
+
+        const key = make_key();
+        const keyHash = key.toString("ascii");
 
         const result = {
             continuationPoint: key,
-            references: current_block,
+            values: current_block,
             statusCode: StatusCodes.Good
         };
 
         // create
-        const data = {
-            maxElements,
-            remainingElements: values
+        const data: Data = {
+            maxElements: maxValues,
+            values: values as DataValue[] | ReferenceDescription[]
         };
-        this._map[keyHash] = data;
-
-        return result;
-    }
-
-    public getNext(continuationPoint: ContinuationPoint): ContinuationPointInfo {
-        if (!continuationPoint) {
-            return { statusCode: StatusCodes.BadContinuationPointInvalid };
-        }
-        const keyHash = continuationPoint.toString("ascii");
+        this._map.set(keyHash, data);
 
-        const data = this._map[keyHash];
-        if (!data) {
-            return { statusCode: StatusCodes.BadContinuationPointInvalid };
-        }
-        assert(data.maxElements > 0);
-        // split the array in two ( values)
-        const current_block = data.remainingElements.splice(0, data.maxElements);
-
-        const result = {
-            continuationPoint: data.remainingElements.length ? continuationPoint : undefined,
-            references: current_block,
-            statusCode: StatusCodes.Good
-        };
-        if (data.remainingElements.length === 0) {
-            // we are done
-            delete this._map[keyHash];
-        }
         return result;
     }
 
-    public cancel(continuationPoint: ContinuationPoint): ContinuationPointInfo {
-        if (!continuationPoint) {
-            return { statusCode: StatusCodes.BadContinuationPointInvalid };
+    private _getNext<T extends DataValue | ReferenceDescription>(
+        numValues: number,
+        continuationData: ContinuationData
+    ): IContinuationPointInfo<T> {
+        if (!continuationData.continuationPoint) {
+            return {
+                continuationPoint: undefined,
+                values: null,
+                statusCode: StatusCodes.BadContinuationPointInvalid
+            };
         }
-
-        const keyHash = continuationPoint.toString("ascii");
-
-        const data = this._map[keyHash];
+        const keyHash = continuationData.continuationPoint.toString("ascii");
+        const data = this._map.get(keyHash);
         if (!data) {
             return {
-                continuationPoint: undefined, // nullBuffer,
-                references: [],
+                continuationPoint: undefined,
+                values: null,
                 statusCode: StatusCodes.BadContinuationPointInvalid
             };
         }
-        delete this._map[keyHash];
+
+        const values = data.values.splice(0, numValues || data.maxElements) as T[];
+
+        let continuationPoint: ContinuationPoint | undefined = continuationData.continuationPoint;
+        if (data.values.length === 0 || continuationData.releaseContinuationPoints) {
+            // no more data available for next call
+            this._map.delete(keyHash);
+            continuationPoint = undefined;
+        }
         return {
+            continuationPoint,
+            values,
             statusCode: StatusCodes.Good
         };
     }

package/source/helpers/adjust_browse_direction.ts

@@ -4,9 +4,9 @@
 import { BrowseDirection } from "node-opcua-data-model";
 
 export function adjustBrowseDirection(
-  browseDirection: BrowseDirection | null | undefined,
-  defaultValue: BrowseDirection
-):BrowseDirection  {
+    browseDirection: BrowseDirection | null | undefined,
+    defaultValue: BrowseDirection
+): BrowseDirection {
     // istanbul ignore next
     if (browseDirection === null || browseDirection === undefined) {
         return defaultValue;

package/source/helpers/argument_list.ts

@@ -24,7 +24,7 @@ function myfindBuiltInType(dataType: DataType): any {
     return factories.findBuiltInType(DataType[dataType]);
 }
 export interface ArgumentDef {
-    dataType: DataType
+    dataType: DataType;
     valueRank?: undefined | number;
 }
 export function encode_ArgumentList(definition: ArgumentDef[], args: any[], stream: OutputBinaryStream): void {

package/source/helpers/call_helpers.ts

@@ -30,7 +30,6 @@ import { resolveOpaqueOnAddressSpace } from "./resolve_opaque_on_address_space";
 // BadNoCommunication
 type ResponseCallback<T> = (err: Error | null, result?: T) => void;
 
-
 export function callMethodHelper(
     context: ISessionContext,
     addressSpace: IAddressSpace,

package/source/helpers/check_event_clause.ts

@@ -14,10 +14,7 @@ import { BaseNode, UAObjectType } from "node-opcua-address-space-base";
  * @param selectClause
  * @return {Array<StatusCode>}
  */
-export function checkSelectClause(
-  parentNode: BaseNode,
-  selectClause: SimpleAttributeOperand
-): StatusCode {
+export function checkSelectClause(parentNode: BaseNode, selectClause: SimpleAttributeOperand): StatusCode {
     //
     const addressSpace = parentNode.addressSpace;
 
@@ -45,7 +42,6 @@ export function checkSelectClause(
     const browsePath = constructBrowsePathFromQualifiedName(eventTypeNode, selectClause.browsePath);
     const browsePathResult = addressSpace.browsePath(browsePath);
     return browsePathResult.statusCode;
-
 }
 
 /**
@@ -54,9 +50,6 @@ export function checkSelectClause(
  * @param selectClauses
  * @return an array of StatusCode
  */
-export function checkSelectClauses(
-  eventTypeNode: UAObjectType,
-  selectClauses: SimpleAttributeOperand[]
-): StatusCode[] {
+export function checkSelectClauses(eventTypeNode: UAObjectType, selectClauses: SimpleAttributeOperand[]): StatusCode[] {
     return selectClauses.map(checkSelectClause.bind(null, eventTypeNode));
 }

package/source/helpers/coerce_enum_value.ts

@@ -7,12 +7,12 @@ import { coerceLocalizedText } from "node-opcua-data-model";
 import { EnumValueType } from "node-opcua-types";
 import { EnumValueTypeOptionsLike } from "../address_space_ts";
 
-export function coerceEnumValues(enumValues: EnumValueTypeOptionsLike[] | { [key: string]: number| Int64 }): EnumValueType[] {
+export function coerceEnumValues(enumValues: EnumValueTypeOptionsLike[] | { [key: string]: number | Int64 }): EnumValueType[] {
     if (Array.isArray(enumValues)) {
         //
         return enumValues.map((en: any) => {
-            assert(Object.prototype.hasOwnProperty.call(en,"value"));
-            assert(Object.prototype.hasOwnProperty.call(en,"displayName"));
+            assert(Object.prototype.hasOwnProperty.call(en, "value"));
+            assert(Object.prototype.hasOwnProperty.call(en, "displayName"));
             return new EnumValueType({
                 displayName: coerceLocalizedText(en.displayName),
                 value: en.value

package/source/helpers/ensure_secure_access.ts

@@ -27,19 +27,7 @@ function newIsUserReadable(this: BaseNode, context: ISessionContext): boolean {
     }
     return false;
 }
-function replaceMethod(obj: any, method: string, func: any) {
-    const oldMethod = obj[method];
-    if (!oldMethod) {
-        throw new Error("I cannot find method " + method + " on object " + obj.browseName.toString());
-    }
-    obj[method] = function (this: any, ...args: any[]) {
-        const ret = func.apply(this, args);
-        if (!ret) {
-            return false;
-        }
-        return oldMethod.apply(this, args);
-    };
-}
+
 /**
  * make sure that the given ia node can only be read
  * by Administrator user on a encrypted channel

package/source/helpers/resolve_opaque_on_address_space.ts

@@ -4,7 +4,10 @@ import { IAddressSpace } from "node-opcua-address-space-base";
 import { PseudoSession } from "../pseudo_session";
 import { ensureDatatypeExtracted } from "../loader/load_nodeset2";
 
-export async function resolveOpaqueOnAddressSpace(addressSpace: IAddressSpace, variants: (Variant | null) | (Variant | null)[]): Promise<void> {
+export async function resolveOpaqueOnAddressSpace(
+    addressSpace: IAddressSpace,
+    variants: (Variant | null) | (Variant | null)[]
+): Promise<void> {
     if (!variants) {
         return;
     }

package/source/interfaces/alarms_and_conditions/condition_info_i.ts

@@ -1,13 +1,13 @@
-/**
- * @module node-opcua-address-space
- */
-import { UInt16 } from "node-opcua-basic-types";
-import { LocalizedTextLike } from "node-opcua-data-model";
-import { StatusCode } from "node-opcua-status-code";
-
-export interface ConditionInfoOptions {
-    message?: string | LocalizedTextLike |null ;
-    quality?: StatusCode |null;
-    severity?: UInt16 | null;
-    retain?: boolean | null;
-}
+/**
+ * @module node-opcua-address-space
+ */
+import { UInt16 } from "node-opcua-basic-types";
+import { LocalizedTextLike } from "node-opcua-data-model";
+import { StatusCode } from "node-opcua-status-code";
+
+export interface ConditionInfoOptions {
+    message?: string | LocalizedTextLike | null;
+    quality?: StatusCode | null;
+    severity?: UInt16 | null;
+    retain?: boolean | null;
+}

package/source/interfaces/data_access/ua_multistate_value_discrete_ex.ts

@@ -30,5 +30,4 @@ export interface UAMultiStateValueDiscreteEx<T, DT extends DataType>
     setValue(value: string | number | Int64): void;
 
     findValueAsText(value: number | UInt64): Variant;
-
 }

package/source/interfaces/data_access/ua_y_array_item_ex.ts

@@ -3,8 +3,10 @@
  */
 import { UAVariableT } from "node-opcua-address-space-base";
 import { DataType } from "node-opcua-variant";
-import  { DT3DOrientation, UAYArrayItem_Base } from "node-opcua-nodeset-ua";
+import { DT3DOrientation, UAYArrayItem_Base } from "node-opcua-nodeset-ua";
 
-export interface UAYArrayItemEx<DT extends DataType.Double|DataType.Float> extends UAVariableT<number[], DT>, UAYArrayItem_Base<number[], DT> {
+export interface UAYArrayItemEx<DT extends DataType.Double | DataType.Float>
+    extends UAVariableT<number[], DT>,
+        UAYArrayItem_Base<number[], DT> {
     // --- helpers ---
 }

package/source/interfaces/state_machine/ua_exclusive_limit_state_machine_type_ex.ts

@@ -6,7 +6,11 @@ import { UAExclusiveLimitStateMachine, UAExclusiveLimitStateMachine_Base } from
 
 import { UAStateMachineEx, UAStateMachineHelper, UAStateMachineType } from "./ua_state_machine_type";
 
-export interface UAExclusiveLimitStateMachineEx extends  UAObject, UAExclusiveLimitStateMachine_Base , UAStateMachineHelper, UAStateMachineEx {}
+export interface UAExclusiveLimitStateMachineEx
+    extends UAObject,
+        UAExclusiveLimitStateMachine_Base,
+        UAStateMachineHelper,
+        UAStateMachineEx {}
 
 export interface UAExclusiveLimitStateMachineType extends UAStateMachineType {
     isAbstract: false;