node-opcua-client 2.117.0 → 2.119.0

package/source/index.ts

@@ -10,17 +10,14 @@ export * from "./client_monitored_item_base";
 export * from "./client_monitored_item";
 export * from "./client_monitored_item_group";
 export * from "./alarms_and_conditions/client_tools";
-export * from "./alarms_and_conditions/client_alarm";
-export * from "./alarms_and_conditions/client_alarm_list";
-export * from "./alarms_and_conditions/client_alarm_tools";
-export * from "./alarms_and_conditions/client_alarm_tools_extractConditionFields";
-export * from "./alarms_and_conditions/client_alarm_tools_dump_event";
-export * from "./alarms_and_conditions/client_alarm_tools_acknowledge_all_conditions";
 export * from "./tools/findservers";
 export * from "./tools/read_history_server_capabilities";
 export * from "./client_utils";
 export * from "./verify";
 export * from "./user_identity_info";
+export * from "./alarms_and_conditions/client_alarm_tools";
+export * from "./alarms_and_conditions/client_tools";
+export * from "node-opcua-alarm-condition";
 
 export { assert } from "node-opcua-assert";
 export * from "node-opcua-utils";

package/source/private/client_base_impl.ts

@@ -2,9 +2,9 @@
  * @module node-opcua-client-private
  */
 // tslint:disable:no-unused-expression
-import * as fs from "fs";
-import * as path from "path";
-import * as async from "async";
+import fs from "fs";
+import path from "path";
+import async from "async";
 import chalk from "chalk";
 import { withLock } from "@ster5/global-mutex";
 import { assert } from "node-opcua-assert";

package/source/private/client_publish_engine.ts

@@ -2,7 +2,7 @@
  * @module node-opcua-client-private
  */
 import { types } from "util";
-import * as async from "async";
+import async from "async";
 import chalk from "chalk";
 import { assert } from "node-opcua-assert";
 import { checkDebugFlag, make_debugLog, make_warningLog } from "node-opcua-debug";

package/source/private/client_session_impl.ts

@@ -16,7 +16,7 @@ import {
     PseudoDataValue
 } from "node-opcua-client-dynamic-extension-object";
 import { Certificate, Nonce } from "node-opcua-crypto";
-import { attributeNameById, BrowseDirection, LocalizedTextLike } from "node-opcua-data-model";
+import { BrowseDirection, LocalizedTextLike } from "node-opcua-data-model";
 import { DataValue } from "node-opcua-data-value";
 import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
 import { ExtensionObject } from "node-opcua-extension-object";
@@ -24,12 +24,12 @@ import { coerceNodeId, NodeId, NodeIdLike, resolveNodeId } from "node-opcua-node
 import {
     getBuiltInDataType,
     getArgumentDefinitionHelper,
-    IBasicSession,
     IBasicTransportSettings,
     readAllAttributes,
     NodeAttributes,
     ResponseCallback,
-    BrowseDescriptionLike
+    BrowseDescriptionLike,
+    IBasicSessionAsync2
 } from "node-opcua-pseudo-session";
 import { AnyConstructorFunc } from "node-opcua-schemas";
 import { ClientSecureChannelLayer, requestHandleNotSetValue, SignatureData } from "node-opcua-secure-channel";
@@ -102,7 +102,7 @@ import {
     UserTokenType,
     WriteValueOptions
 } from "node-opcua-types";
-import { buffer_ellipsis, getFunctionParameterNames, isNullOrUndefined, lowerFirstLetter } from "node-opcua-utils";
+import { buffer_ellipsis, getFunctionParameterNames, isNullOrUndefined } from "node-opcua-utils";
 import { DataType, Variant, VariantLike } from "node-opcua-variant";
 
 import {
@@ -1836,7 +1836,13 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
         const methodId = args[0] as MethodId;
         const callback = args[1] as ResponseCallback<ArgumentDefinition>;
         assert(typeof callback === "function");
-        return getArgumentDefinitionHelper(this, methodId, callback);
+        return getArgumentDefinitionHelper(this, methodId)
+            .then((result) => {
+                callback!(null, result);
+            })
+            .catch((err) => {
+                callback(err);
+            });
     }
 
     public async registerNodes(nodesToRegister: NodeIdLike[]): Promise<NodeId[]>;
@@ -2088,6 +2094,10 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
         /** empty */
     }
 
+    /**
+     * @deprecated
+     * @private
+     */
     public findMethodId(_nodeId: NodeIdLike, _methodName: string, _callback?: ResponseCallback<NodeId>): any {
         /** empty */
     }
@@ -2215,12 +2225,15 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
 }
 
 type promoteOpaqueStructure3WithCallbackFunc = (
-    session: IBasicSession,
+    session: IBasicSessionAsync2,
     callMethodResults: CallMethodResult[],
     callback: ErrorCallback
 ) => void;
 
-async function promoteOpaqueStructure2(session: IBasicSession, callMethodResult: CallMethodResult): Promise<void> {
+async function promoteOpaqueStructure2(
+    session: IBasicSessionAsync2,
+    callMethodResult: CallMethodResult
+): Promise<void> {
     if (!callMethodResult || !callMethodResult.outputArguments || callMethodResult.outputArguments.length === 0) {
         return;
     }
@@ -2242,7 +2255,7 @@ function countOpaqueStructures(callMethodResults: CallMethodResult[]): number {
     }, 0);
     return opaqueStructureCount;
 }
-async function promoteOpaqueStructure3(session: IBasicSession, callMethodResults: CallMethodResult[]): Promise<void> {
+async function promoteOpaqueStructure3(session: IBasicSessionAsync2, callMethodResults: CallMethodResult[]): Promise<void> {
     const opaqueStructureCount = countOpaqueStructures(callMethodResults);
     if (0 === opaqueStructureCount) return;
 

package/source/private/client_subscription_impl.ts

@@ -3,7 +3,7 @@
  */
 // tslint:disable:unified-signatures
 import { EventEmitter } from "events";
-import * as async from "async";
+import async from "async";
 import chalk from "chalk";
 
 import { assert } from "node-opcua-assert";
@@ -35,9 +35,9 @@ import {
 
 import { StatusCode, StatusCodes } from "node-opcua-status-code";
 import { Callback, ErrorCallback } from "node-opcua-status-code";
-import * as utils from "node-opcua-utils";
+import { isNullOrUndefined } from "node-opcua-utils";
 import { promoteOpaqueStructureInNotificationData } from "node-opcua-client-dynamic-extension-object";
-import { createMonitoredItemsLimit, IBasicSession, readOperationLimits } from "node-opcua-pseudo-session";
+import { createMonitoredItemsLimit, IBasicSessionReadAsync, readOperationLimits } from "node-opcua-pseudo-session";
 
 import { IBasicSessionWithSubscription } from "node-opcua-pseudo-session";
 import { ClientMonitoredItemBase } from "../client_monitored_item_base";
@@ -123,7 +123,7 @@ function displayKeepAliveWarning(sessionTimeout: number, maxKeepAliveCount: numb
 }
 
 function createMonitoredItemsAndRespectOperationalLimits(
-    session: IBasicSession & IBasicSessionWithSubscription,
+    session: IBasicSessionReadAsync & IBasicSessionWithSubscription,
     createMonitorItemsRequest: CreateMonitoredItemsRequest,
     callback: (err: Error | null, response?: CreateMonitoredItemsResponse) => void
 ) {
@@ -208,7 +208,7 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
             );
         }
 
-        options.maxNotificationsPerPublish = utils.isNullOrUndefined(options.maxNotificationsPerPublish)
+        options.maxNotificationsPerPublish = isNullOrUndefined(options.maxNotificationsPerPublish)
             ? 0
             : options.maxNotificationsPerPublish;
 

package/source/private/opcua_client_impl.ts

@@ -3,7 +3,7 @@
  */
 import { callbackify } from "util";
 import { randomBytes, createPublicKey } from "crypto";
-import * as async from "async";
+import async from "async";
 import chalk from "chalk";
 
 import { assert } from "node-opcua-assert";

package/source/tools/findservers.ts

@@ -1,7 +1,7 @@
 /**
  * @module node-opcua-client
  */
-import * as async from "async";
+import async from "async";
 
 import { ErrorCallback } from "node-opcua-status-code";
 import { ServerOnNetwork } from "node-opcua-service-discovery";

package/source/alarms_and_conditions/client_alarm.ts

@@ -1,130 +0,0 @@
-import { EventEmitter } from "events";
-import { assert } from "node-opcua-assert";
-import { make_warningLog } from "node-opcua-debug";
-import { NodeId, resolveNodeId } from "node-opcua-nodeid";
-import { StatusCode } from "node-opcua-status-code";
-import { lowerFirstLetter } from "node-opcua-utils";
-import { DataType, Variant } from "node-opcua-variant";
-import { ClientSession } from "../client_session";
-
-const warningLog = make_warningLog(__filename);
-
-export interface TVariant<T> extends Variant {
-    value: T;
-}
-export interface TTwoStateStatus extends TVariant<string> {
-    id: TVariant<boolean>;
-}
-export interface EventStuff {
-    conditionId: TVariant<NodeId>;
-    eventType: TVariant<NodeId>;
-    eventId: TVariant<Buffer>;
-    retain: TVariant<boolean>;
-    activeState: TTwoStateStatus;
-    ackedState: TTwoStateStatus;
-    confirmedState: TTwoStateStatus;
-    conditionName?: TVariant<string>;
-}
-
-export interface ClientAlarm {
-    conditionId: NodeId;
-    eventType: NodeId;
-    fields: EventStuff;
-    on(eventName: "changed", eventHandler: () => void): this;
-    acknowledge(session: ClientSession, comment: string): Promise<StatusCode>;
-    getField(fieldName: string): Variant | null;
-}
-
-/**
- * describes a OPCUA Alarm as seen in the client side
- */
-export class ClientAlarm extends EventEmitter {
-    public conditionId: NodeId;
-    public eventType: NodeId;
-    public eventId: Buffer;
-    public fields: EventStuff;
-
-    public constructor(eventFields: EventStuff) {
-        super();
-        this.conditionId = resolveNodeId(eventFields.conditionId.value);
-        this.eventType = resolveNodeId(eventFields.eventType.value);
-        this.eventId = eventFields.eventId.value;
-        this.fields = eventFields;
-        this.update(eventFields);
-    }
-    public async acknowledge(session: ClientSession, comment: string): Promise<StatusCode> {
-        return await session.acknowledgeCondition(this.conditionId, this.eventId, comment);
-    }
-    public async confirm(session: ClientSession, comment: string): Promise<StatusCode> {
-        return await session.confirmCondition(this.conditionId, this.eventId, comment);
-    }
-    public update(eventFields: EventStuff): void {
-        assert(this.conditionId.toString() === resolveNodeId(eventFields.conditionId.value).toString());
-        assert(this.eventType.toString() === resolveNodeId(eventFields.eventType.value).toString());
-        this.eventId = eventFields.eventId.value;
-        this.fields = eventFields;
-    }
-    public getRetain(): boolean {
-        return this.fields.retain.value;
-    }
-    public toString(): string {
-        return (
-            this.constructor.name +
-            ": " +
-            this.conditionId.toString() +
-            " " +
-            this.eventType.toString() +
-            " " +
-            Object.entries(this.fields)
-                .filter(([key, value]) => value.dataType !== DataType.Null)
-                .map(([key, value]) => key.padEnd(30) + "=" + value.toString())
-                .join("\n") +
-            "\n\n"
-        );
-    }
-
-    public getField(fieldName: string): Variant | null {
-        return (this.fields as any)[fieldName] || null;
-    }
-}
-
-/**
- * @private
- */
-export function fieldsToJson(fields: string[], eventFields: Variant[], flat?: boolean): EventStuff {
-
-    function setProperty(_data: Record<string, unknown>, fieldName: string, value: Variant) {
-        let name: string;
-        if (!fieldName || value === null) {
-            return;
-        }
-        if (!flat) {
-            const f = fieldName.split(".");
-            if (f.length === 1) {
-                fieldName = lowerFirstLetter(fieldName);
-                _data[fieldName] = value;
-            } else {
-                for (let i = 0; i < f.length - 1; i++) {
-                    name = lowerFirstLetter(f[i]);
-                    _data[name] = _data[name] || {};
-                    _data = _data[name] as Record<string, unknown>;
-                }
-                name = lowerFirstLetter(f[f.length - 1]);
-                _data[name] = value;
-            }
-        } else {
-            const name = fieldName.split(".").map(lowerFirstLetter).join(".");
-            _data[name] = value;
-        }
-    }
-    if (fields.length > eventFields.length) {
-        warningLog("warning fields.length !==  eventFields.length", fields.length, eventFields.length);
-    }
-    const data: any = {};
-    for (let index = 0; index < fields.length; index++) {
-        const variant = eventFields[index];
-        setProperty(data, fields[index], variant);
-    }
-
-    return data;
-}

package/source/alarms_and_conditions/client_alarm_list.ts

@@ -1,112 +0,0 @@
-import { EventEmitter } from "events";
-import { assert } from "node-opcua-assert";
-import { DataType } from "node-opcua-basic-types";
-import { NodeId } from "node-opcua-nodeid";
-import { ClientAlarm, EventStuff } from "./client_alarm";
-
-export interface ClientAlarmList {
-    on(eventName: "alarmChanged", handler: (alarm: ClientAlarm) => void): this;
-    on(eventName: "alarmDeleted", handler: (alarm: ClientAlarm) => void): this;
-    on(eventName: "newAlarm", handler: (alarm: ClientAlarm) => void): this;
-
-    emit(eventName: "alarmChanged", alarm: ClientAlarm): boolean;
-    emit(eventName: "newAlarm", alarm: ClientAlarm): boolean;
-    emit(eventName: "alarmDeleted", alarm: ClientAlarm): boolean;
-}
-// maintain a set of alarm list for a client
-export class ClientAlarmList extends EventEmitter implements Iterable<ClientAlarm> {
-    private _map: { [key: string]: ClientAlarm } = {};
-
-    public constructor() {
-        super();
-    }
-
-    public [Symbol.iterator](): Iterator<ClientAlarm> {
-        let pointer = 0;
-        const components = Object.values(this._map);
-        return {
-            next(): IteratorResult<ClientAlarm> {
-                if (pointer >= components.length) {
-                    return {
-                        done: true,
-                        value: components[pointer++]
-                    };
-                } else {
-                    return {
-                        done: false,
-                        value: components[pointer++]
-                    };
-                }
-            }
-        };
-    }
-
-    public alarms(): ClientAlarm[] {
-        return Object.values(this._map);
-    }
-
-    public update(eventField: EventStuff): void {
-        // Spec says:
-        // Clients shall check for multiple Event Notifications for a ConditionBranch to avoid
-        // overwriting a new state delivered together with an older state from the Refresh
-        // process.
-
-        const { conditionId, eventType } = eventField;
-        assert(conditionId, "must have a valid conditionId ( verify that event is a acknodweldgeable type");
-        const alarm = this.findAlarm(conditionId.value, eventType.value);
-
-        if (!alarm) {
-            const key = this.makeKey(conditionId.value, eventType.value);
-            const newAlarm = new ClientAlarm(eventField);
-            this._map[key] = newAlarm;
-            this.emit("newAlarm", newAlarm);
-            this.emit("alarmChanged", newAlarm);
-        } else {
-            alarm.update(eventField);
-            this.emit("alarmChanged", alarm);
-        }
-    }
-    public removeAlarm(eventField: EventStuff): void {
-        const { conditionId, eventType } = eventField;
-        const alarm = this.findAlarm(conditionId.value, eventType.value);
-        if (alarm) {
-            alarm.update(eventField);
-            this._removeAlarm(alarm);
-        }
-    }
-
-    public get length(): number {
-        return Object.keys(this._map).length;
-    }
-    public purgeUnusedAlarms(): void {
-        const alarms = this.alarms();
-        for (const alarm of alarms) {
-            if (!alarm.getRetain()) {
-                this._removeAlarm(alarm);
-            }
-        }
-    }
-
-    private _removeAlarm(alarm: ClientAlarm) {
-        this.emit("alarmDeleted", alarm);
-        this.deleteAlarm(alarm.conditionId, alarm.eventType);
-    }
-
-    private makeKey(conditionId: NodeId, eventType: NodeId) {
-        return conditionId.toString() + "|" + eventType.toString();
-    }
-    private findAlarm(conditionId: NodeId, eventType: NodeId): ClientAlarm | null {
-        const key = this.makeKey(conditionId, eventType);
-        const _c = this._map[key];
-        return _c || null;
-    }
-    private deleteAlarm(conditionId: NodeId, eventType: NodeId): boolean {
-        const key = this.makeKey(conditionId, eventType);
-        const _c = this._map[key];
-        if (_c) {
-            delete this._map[key];
-            return true;
-        }
-        return false;
-    }
-}

package/source/alarms_and_conditions/client_alarm_tools_acknowledge_all_conditions.ts

@@ -1,187 +0,0 @@
-import { resolveNodeId } from "node-opcua-nodeid";
-import { constructEventFilter } from "node-opcua-service-filter";
-import { AttributeIds, ReadValueIdOptions, TimestampsToReturn } from "node-opcua-service-read";
-import { CreateSubscriptionRequestOptions, MonitoringParametersOptions } from "node-opcua-service-subscription";
-import { StatusCode, StatusCodes } from "node-opcua-status-code";
-import { DataType, Variant } from "node-opcua-variant";
-import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
-import { ClientSession } from "../client_session";
-import { EventStuff, fieldsToJson } from "./client_alarm";
-import { extractConditionFields } from "./client_alarm_tools_extractConditionFields";
-import { callConditionRefresh } from "./client_tools";
-
-const doDebug = checkDebugFlag(__filename);
-const debugLog = make_debugLog(__filename);
-const errorLog = make_errorLog(__filename);
-
-/**
- *
- * @param session
- * @param eventStuff
- * @param comment
- */
-export async function acknowledgeCondition(session: ClientSession, eventStuff: EventStuff, comment: string): Promise<StatusCode> {
-    try {
-        const conditionId = eventStuff.conditionId.value;
-        const eventId = eventStuff.eventId.value;
-        return await session.acknowledgeCondition(conditionId, eventId, comment);
-    } catch (err) {
-        errorLog("Acknowledging alarm has failed !", err);
-        return StatusCodes.BadInternalError;
-    }
-}
-export async function confirmCondition(session: ClientSession, eventStuff: EventStuff, comment: string): Promise<StatusCode> {
-    try {
-        const conditionId = eventStuff.conditionId.value;
-        const eventId = eventStuff.eventId.value;
-        return await session.confirmCondition(conditionId, eventId, comment);
-    } catch (err) {
-        errorLog("Acknowledging alarm has failed !", err);
-        return StatusCodes.BadInternalError;
-    }
-}
-
-/**
- * Enumerate all events
- * @param session
- */
-export async function findActiveConditions(session: ClientSession): Promise<EventStuff[]> {
-    const request: CreateSubscriptionRequestOptions = {
-        maxNotificationsPerPublish: 10000,
-        priority: 6,
-        publishingEnabled: true,
-        requestedLifetimeCount: 1000,
-        requestedMaxKeepAliveCount: 100,
-        requestedPublishingInterval: 100
-    };
-
-    const subscription = await session.createSubscription2(request);
-
-    const itemToMonitor: ReadValueIdOptions = {
-        attributeId: AttributeIds.EventNotifier,
-        nodeId: resolveNodeId("Server") // i=2253
-    };
-
-    const fields = await extractConditionFields(session, "AcknowledgeableConditionType");
-
-    // note: we may want to have this select clause
-    //  Or(OfType("AcknowledgeableConditionType"), OfType("RefreshStartEventType"), OfType("RefreshEndEventType"))
-    const eventFilter = constructEventFilter(fields);
-
-    const monitoringParameters: MonitoringParametersOptions = {
-        discardOldest: false,
-        filter: eventFilter,
-        queueSize: 100,
-        samplingInterval: 0
-    };
-
-    const event_monitoringItem = await subscription.monitor(itemToMonitor, monitoringParameters, TimestampsToReturn.Both);
-
-    const acknowledgeableConditions: EventStuff[] = [];
-
-    let refreshStartEventHasBeenReceived = false;
-    let RefreshEndEventHasBeenReceived = false;
-
-    const RefreshStartEventType = resolveNodeId("RefreshStartEventType").toString();
-    const RefreshEndEventType = resolveNodeId("RefreshEndEventType").toString();
-
-    const promise: Promise<void> = new Promise((resolve, reject) => {
-        // now create a event monitored Item
-        event_monitoringItem.on("changed", (_eventFields: any) => {
-            const eventFields = _eventFields as Variant[];
-
-            try {
-                if (RefreshEndEventHasBeenReceived) {
-                    return;
-                }
-
-                // dumpEvent(session, fields, eventFields);
-                const pojo = fieldsToJson(fields, eventFields) as any;
-
-                // make sure we only start recording event after the RefreshStartEvent has been received
-                if (!refreshStartEventHasBeenReceived) {
-                    if (pojo.eventType.value.toString() === RefreshStartEventType) {
-                        refreshStartEventHasBeenReceived = true;
-                    }
-                    return;
-                }
-                if (pojo.eventType.value.toString() === RefreshEndEventType) {
-                    RefreshEndEventHasBeenReceived = true;
-                    resolve();
-                    return;
-                }
-                if (!pojo.conditionId.value) {
-                    // not a Acknowledgeable condition
-                    return;
-                }
-
-                if (pojo.ackedState.id.dataType === DataType.Boolean) {
-                    acknowledgeableConditions.push(pojo as EventStuff);
-                }
-            } catch (err) {
-                errorLog("Error !!", err);
-            }
-        });
-        // async call without waiting !
-        try {
-            callConditionRefresh(subscription);
-        } catch (err) {
-            // it is possible that server do not implement conditionRefresh ...
-            debugLog("Server may not implement conditionRefresh", err);
-        }
-    });
-
-    await promise;
-
-    // now shut down subscription
-    await subscription.terminate();
-
-    return acknowledgeableConditions;
-}
-
-export async function acknowledgeAllConditions(session: ClientSession, message: string): Promise<void> {
-    try {
-        let conditions = await findActiveConditions(session);
-        if (conditions.length === 0) {
-            debugLog("Warning: cannot find conditions ");
-        }
-
-        // filter acknowledgeable conditions (no acked yet)
-        conditions = conditions.filter((pojo) => pojo.ackedState.id.value === false);
-
-        const promises: Array<Promise<StatusCode>> = [];
-        for (const eventStuff of conditions) {
-            promises.push(acknowledgeCondition(session, eventStuff, message));
-        }
-        const result = await Promise.all(promises);
-        // istanbul ignore next
-        if (doDebug) {
-            debugLog("Acked all results: ", result.map((e) => e.toString()).join(" "));
-        }
-    } catch (err) {
-        errorLog("Error", err);
-    }
-}
-export async function confirmAllConditions(session: ClientSession, message: string): Promise<void> {
-    try {
-        let conditions = await findActiveConditions(session);
-        if (conditions.length === 0) {
-            debugLog("Warning: cannot find conditions ");
-        }
-
-        // filter acknowledgeable conditions (no acked yet)
-        conditions = conditions.filter((pojo) => pojo.confirmedState.id.value === false);
-
-        const promises: Array<Promise<any>> = [];
-        for (const eventStuff of conditions) {
-            promises.push(confirmCondition(session, eventStuff, message));
-        }
-        const result = await Promise.all(promises);
-        // istanbul ignore next
-        if (doDebug) {
-            debugLog("Confirm all results: ", result.map((e) => e.toString()).join(" "));
-        }
-    } catch (err) {
-        errorLog("Error", err);
-    }
-}

package/source/alarms_and_conditions/client_alarm_tools_dump_event.ts

@@ -1,67 +0,0 @@
-import chalk from "chalk";
-import { AttributeIds } from "node-opcua-data-model";
-import { NodeId } from "node-opcua-nodeid";
-import { IBasicSession } from "node-opcua-pseudo-session";
-import { DataType, Variant, VariantLike } from "node-opcua-variant";
-
-import { make_warningLog } from "node-opcua-debug";
-
-const warningLog = make_warningLog("ClientAlarmTool");
-
-/**
- *
- * @param session
- * @param fields
- * @param eventFields
- */
-export async function dumpEvent(session: IBasicSession, fields: string[], eventFields: Variant[]): Promise<void> {
-    async function getBrowseName(_session: IBasicSession, nodeId: NodeId): Promise<string> {
-        const dataValue = await _session.read({
-            attributeId: AttributeIds.BrowseName,
-            nodeId
-        });
-        if (dataValue.statusCode.isGood()) {
-            const browseName = dataValue.value.value.name!;
-            return browseName;
-        } else {
-            return "???";
-        }
-    }
-    function w(str: string, l: number): string {
-        return (str || "").toString().padEnd(l, " ").substring(0, l);
-    }
-    async function __dumpEvent1(_session: IBasicSession, _fields: any, variant: VariantLike, index: number) {
-        if (variant.dataType === DataType.Null) {
-            return;
-        }
-        if (variant.dataType === DataType.NodeId) {
-            const name = await getBrowseName(_session, variant.value);
-            warningLog(
-                chalk.yellow(w(name, 30), w(_fields[index], 25)),
-                chalk.cyan(w(DataType[variant.dataType], 10).toString()),
-                chalk.cyan.bold(name),
-                "(",
-                w(variant.value, 20),
-                ")"
-            );
-        } else {
-            // tslint:disable-next-line: no-console
-            warningLog(
-                chalk.yellow(w("", 30), w(_fields[index], 25)),
-                chalk.cyan(w(DataType[variant.dataType as number], 10).toString()),
-                variant.value
-            );
-        }
-    }
-
-    async function __dumpEvent(_session: IBasicSession, _fields: string[], _eventFields: Variant[]) {
-        let index = 0;
-        const promises = [];
-        for (const variant of _eventFields) {
-            promises.push(__dumpEvent1(_session, _fields, variant, index));
-            index++;
-        }
-        await Promise.all(promises);
-    }
-    await __dumpEvent(session, fields, eventFields);
-}