node-opcua-client 2.97.0 → 2.98.1

package/dist/alarms_and_conditions/client_alarm.d.ts

@@ -1,49 +1,49 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { EventEmitter } from "events";
-import { NodeId } from "node-opcua-nodeid";
-import { StatusCode } from "node-opcua-status-code";
-import { Variant } from "node-opcua-variant";
-import { ClientSession } from "../client_session";
-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 declare class ClientAlarm extends EventEmitter {
-    conditionId: NodeId;
-    eventType: NodeId;
-    eventId: Buffer;
-    fields: EventStuff;
-    constructor(eventFields: EventStuff);
-    confirm(session: ClientSession, comment: string): Promise<StatusCode>;
-    update(eventFields: EventStuff): void;
-    getRetain(): boolean;
-    toString(): string;
-}
-/**
- * @private
- */
-export declare function fieldsToJson(fields: string[], eventFields: Variant[], flat?: boolean): EventStuff;
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from "events";
+import { NodeId } from "node-opcua-nodeid";
+import { StatusCode } from "node-opcua-status-code";
+import { Variant } from "node-opcua-variant";
+import { ClientSession } from "../client_session";
+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 declare class ClientAlarm extends EventEmitter {
+    conditionId: NodeId;
+    eventType: NodeId;
+    eventId: Buffer;
+    fields: EventStuff;
+    constructor(eventFields: EventStuff);
+    confirm(session: ClientSession, comment: string): Promise<StatusCode>;
+    update(eventFields: EventStuff): void;
+    getRetain(): boolean;
+    toString(): string;
+}
+/**
+ * @private
+ */
+export declare function fieldsToJson(fields: string[], eventFields: Variant[], flat?: boolean): EventStuff;

package/dist/alarms_and_conditions/client_alarm.js

@@ -1,110 +1,110 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fieldsToJson = exports.ClientAlarm = void 0;
-const events_1 = require("events");
-const node_opcua_assert_1 = require("node-opcua-assert");
-const node_opcua_debug_1 = require("node-opcua-debug");
-const node_opcua_nodeid_1 = require("node-opcua-nodeid");
-const node_opcua_utils_1 = require("node-opcua-utils");
-const node_opcua_variant_1 = require("node-opcua-variant");
-const warningLog = (0, node_opcua_debug_1.make_warningLog)(__filename);
-/**
- * describes a OPCUA Alarm as seen in the client side
- */
-class ClientAlarm extends events_1.EventEmitter {
-    constructor(eventFields) {
-        super();
-        this.conditionId = (0, node_opcua_nodeid_1.resolveNodeId)(eventFields.conditionId.value);
-        this.eventType = (0, node_opcua_nodeid_1.resolveNodeId)(eventFields.eventType.value);
-        this.eventId = eventFields.eventId.value;
-        this.fields = eventFields;
-        this.update(eventFields);
-    }
-    acknowledge(session, comment) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield session.acknowledgeCondition(this.conditionId, this.eventId, comment);
-        });
-    }
-    confirm(session, comment) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield session.confirmCondition(this.conditionId, this.eventId, comment);
-        });
-    }
-    update(eventFields) {
-        (0, node_opcua_assert_1.assert)(this.conditionId.toString() === (0, node_opcua_nodeid_1.resolveNodeId)(eventFields.conditionId.value).toString());
-        (0, node_opcua_assert_1.assert)(this.eventType.toString() === (0, node_opcua_nodeid_1.resolveNodeId)(eventFields.eventType.value).toString());
-        this.eventId = eventFields.eventId.value;
-        this.fields = eventFields;
-    }
-    getRetain() {
-        return this.fields.retain.value;
-    }
-    toString() {
-        return (this.constructor.name +
-            ": " +
-            this.conditionId.toString() +
-            " " +
-            this.eventType.toString() +
-            " " +
-            Object.entries(this.fields)
-                .filter(([key, value]) => value.dataType !== node_opcua_variant_1.DataType.Null)
-                .map(([key, value]) => key.padEnd(30) + "=" + value.toString())
-                .join("\n") +
-            "\n\n");
-    }
-    getField(fieldName) {
-        return this.fields[fieldName] || null;
-    }
-}
-exports.ClientAlarm = ClientAlarm;
-/**
- * @private
- */
-function fieldsToJson(fields, eventFields, flat) {
-    function setProperty(_data, fieldName, value) {
-        let name;
-        if (!fieldName || value === null) {
-            return;
-        }
-        if (!flat) {
-            const f = fieldName.split(".");
-            if (f.length === 1) {
-                fieldName = (0, node_opcua_utils_1.lowerFirstLetter)(fieldName);
-                _data[fieldName] = value;
-            }
-            else {
-                for (let i = 0; i < f.length - 1; i++) {
-                    name = (0, node_opcua_utils_1.lowerFirstLetter)(f[i]);
-                    _data[name] = _data[name] || {};
-                    _data = _data[name];
-                }
-                name = (0, node_opcua_utils_1.lowerFirstLetter)(f[f.length - 1]);
-                _data[name] = value;
-            }
-        }
-        else {
-            const name = fieldName.split(".").map(node_opcua_utils_1.lowerFirstLetter).join(".");
-            _data[name] = value;
-        }
-    }
-    if (fields.length > eventFields.length) {
-        warningLog("warning fields.length !==  eventFields.length", fields.length, eventFields.length);
-    }
-    const data = {};
-    for (let index = 0; index < fields.length; index++) {
-        const variant = eventFields[index];
-        setProperty(data, fields[index], variant);
-    }
-    return data;
-}
-exports.fieldsToJson = fieldsToJson;
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldsToJson = exports.ClientAlarm = void 0;
+const events_1 = require("events");
+const node_opcua_assert_1 = require("node-opcua-assert");
+const node_opcua_debug_1 = require("node-opcua-debug");
+const node_opcua_nodeid_1 = require("node-opcua-nodeid");
+const node_opcua_utils_1 = require("node-opcua-utils");
+const node_opcua_variant_1 = require("node-opcua-variant");
+const warningLog = (0, node_opcua_debug_1.make_warningLog)(__filename);
+/**
+ * describes a OPCUA Alarm as seen in the client side
+ */
+class ClientAlarm extends events_1.EventEmitter {
+    constructor(eventFields) {
+        super();
+        this.conditionId = (0, node_opcua_nodeid_1.resolveNodeId)(eventFields.conditionId.value);
+        this.eventType = (0, node_opcua_nodeid_1.resolveNodeId)(eventFields.eventType.value);
+        this.eventId = eventFields.eventId.value;
+        this.fields = eventFields;
+        this.update(eventFields);
+    }
+    acknowledge(session, comment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield session.acknowledgeCondition(this.conditionId, this.eventId, comment);
+        });
+    }
+    confirm(session, comment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield session.confirmCondition(this.conditionId, this.eventId, comment);
+        });
+    }
+    update(eventFields) {
+        (0, node_opcua_assert_1.assert)(this.conditionId.toString() === (0, node_opcua_nodeid_1.resolveNodeId)(eventFields.conditionId.value).toString());
+        (0, node_opcua_assert_1.assert)(this.eventType.toString() === (0, node_opcua_nodeid_1.resolveNodeId)(eventFields.eventType.value).toString());
+        this.eventId = eventFields.eventId.value;
+        this.fields = eventFields;
+    }
+    getRetain() {
+        return this.fields.retain.value;
+    }
+    toString() {
+        return (this.constructor.name +
+            ": " +
+            this.conditionId.toString() +
+            " " +
+            this.eventType.toString() +
+            " " +
+            Object.entries(this.fields)
+                .filter(([key, value]) => value.dataType !== node_opcua_variant_1.DataType.Null)
+                .map(([key, value]) => key.padEnd(30) + "=" + value.toString())
+                .join("\n") +
+            "\n\n");
+    }
+    getField(fieldName) {
+        return this.fields[fieldName] || null;
+    }
+}
+exports.ClientAlarm = ClientAlarm;
+/**
+ * @private
+ */
+function fieldsToJson(fields, eventFields, flat) {
+    function setProperty(_data, fieldName, value) {
+        let name;
+        if (!fieldName || value === null) {
+            return;
+        }
+        if (!flat) {
+            const f = fieldName.split(".");
+            if (f.length === 1) {
+                fieldName = (0, node_opcua_utils_1.lowerFirstLetter)(fieldName);
+                _data[fieldName] = value;
+            }
+            else {
+                for (let i = 0; i < f.length - 1; i++) {
+                    name = (0, node_opcua_utils_1.lowerFirstLetter)(f[i]);
+                    _data[name] = _data[name] || {};
+                    _data = _data[name];
+                }
+                name = (0, node_opcua_utils_1.lowerFirstLetter)(f[f.length - 1]);
+                _data[name] = value;
+            }
+        }
+        else {
+            const name = fieldName.split(".").map(node_opcua_utils_1.lowerFirstLetter).join(".");
+            _data[name] = value;
+        }
+    }
+    if (fields.length > eventFields.length) {
+        warningLog("warning fields.length !==  eventFields.length", fields.length, eventFields.length);
+    }
+    const data = {};
+    for (let index = 0; index < fields.length; index++) {
+        const variant = eventFields[index];
+        setProperty(data, fields[index], variant);
+    }
+    return data;
+}
+exports.fieldsToJson = fieldsToJson;
 //# sourceMappingURL=client_alarm.js.map

package/dist/alarms_and_conditions/client_alarm_list.d.ts

@@ -1,25 +1,25 @@
-/// <reference types="node" />
-import { EventEmitter } from "events";
-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;
-}
-export declare class ClientAlarmList extends EventEmitter implements Iterable<ClientAlarm> {
-    private _map;
-    constructor();
-    [Symbol.iterator](): Iterator<ClientAlarm>;
-    alarms(): ClientAlarm[];
-    update(eventField: EventStuff): void;
-    removeAlarm(eventField: EventStuff): void;
-    get length(): number;
-    purgeUnusedAlarms(): void;
-    private _removeAlarm;
-    private makeKey;
-    private findAlarm;
-    private deleteAlarm;
-}
+/// <reference types="node" />
+import { EventEmitter } from "events";
+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;
+}
+export declare class ClientAlarmList extends EventEmitter implements Iterable<ClientAlarm> {
+    private _map;
+    constructor();
+    [Symbol.iterator](): Iterator<ClientAlarm>;
+    alarms(): ClientAlarm[];
+    update(eventField: EventStuff): void;
+    removeAlarm(eventField: EventStuff): void;
+    get length(): number;
+    purgeUnusedAlarms(): void;
+    private _removeAlarm;
+    private makeKey;
+    private findAlarm;
+    private deleteAlarm;
+}

package/dist/alarms_and_conditions/client_alarm_list.js

@@ -1,98 +1,98 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClientAlarmList = void 0;
-const events_1 = require("events");
-const node_opcua_assert_1 = require("node-opcua-assert");
-const client_alarm_1 = require("./client_alarm");
-// maintain a set of alarm list for a client
-class ClientAlarmList extends events_1.EventEmitter {
-    constructor() {
-        super();
-        this._map = {};
-    }
-    [Symbol.iterator]() {
-        let pointer = 0;
-        const components = Object.values(this._map);
-        return {
-            next() {
-                if (pointer >= components.length) {
-                    return {
-                        done: true,
-                        value: components[pointer++]
-                    };
-                }
-                else {
-                    return {
-                        done: false,
-                        value: components[pointer++]
-                    };
-                }
-            }
-        };
-    }
-    alarms() {
-        return Object.values(this._map);
-    }
-    update(eventField) {
-        // 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;
-        (0, node_opcua_assert_1.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 client_alarm_1.ClientAlarm(eventField);
-            this._map[key] = newAlarm;
-            this.emit("newAlarm", newAlarm);
-            this.emit("alarmChanged", newAlarm);
-        }
-        else {
-            alarm.update(eventField);
-            this.emit("alarmChanged", alarm);
-        }
-    }
-    removeAlarm(eventField) {
-        const { conditionId, eventType } = eventField;
-        const alarm = this.findAlarm(conditionId.value, eventType.value);
-        if (alarm) {
-            alarm.update(eventField);
-            this._removeAlarm(alarm);
-        }
-    }
-    get length() {
-        return Object.keys(this._map).length;
-    }
-    purgeUnusedAlarms() {
-        const alarms = this.alarms();
-        for (const alarm of alarms) {
-            if (!alarm.getRetain()) {
-                this._removeAlarm(alarm);
-            }
-        }
-    }
-    _removeAlarm(alarm) {
-        this.emit("alarmDeleted", alarm);
-        this.deleteAlarm(alarm.conditionId, alarm.eventType);
-    }
-    makeKey(conditionId, eventType) {
-        return conditionId.toString() + "|" + eventType.toString();
-    }
-    findAlarm(conditionId, eventType) {
-        const key = this.makeKey(conditionId, eventType);
-        const _c = this._map[key];
-        return _c || null;
-    }
-    deleteAlarm(conditionId, eventType) {
-        const key = this.makeKey(conditionId, eventType);
-        const _c = this._map[key];
-        if (_c) {
-            delete this._map[key];
-            return true;
-        }
-        return false;
-    }
-}
-exports.ClientAlarmList = ClientAlarmList;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientAlarmList = void 0;
+const events_1 = require("events");
+const node_opcua_assert_1 = require("node-opcua-assert");
+const client_alarm_1 = require("./client_alarm");
+// maintain a set of alarm list for a client
+class ClientAlarmList extends events_1.EventEmitter {
+    constructor() {
+        super();
+        this._map = {};
+    }
+    [Symbol.iterator]() {
+        let pointer = 0;
+        const components = Object.values(this._map);
+        return {
+            next() {
+                if (pointer >= components.length) {
+                    return {
+                        done: true,
+                        value: components[pointer++]
+                    };
+                }
+                else {
+                    return {
+                        done: false,
+                        value: components[pointer++]
+                    };
+                }
+            }
+        };
+    }
+    alarms() {
+        return Object.values(this._map);
+    }
+    update(eventField) {
+        // 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;
+        (0, node_opcua_assert_1.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 client_alarm_1.ClientAlarm(eventField);
+            this._map[key] = newAlarm;
+            this.emit("newAlarm", newAlarm);
+            this.emit("alarmChanged", newAlarm);
+        }
+        else {
+            alarm.update(eventField);
+            this.emit("alarmChanged", alarm);
+        }
+    }
+    removeAlarm(eventField) {
+        const { conditionId, eventType } = eventField;
+        const alarm = this.findAlarm(conditionId.value, eventType.value);
+        if (alarm) {
+            alarm.update(eventField);
+            this._removeAlarm(alarm);
+        }
+    }
+    get length() {
+        return Object.keys(this._map).length;
+    }
+    purgeUnusedAlarms() {
+        const alarms = this.alarms();
+        for (const alarm of alarms) {
+            if (!alarm.getRetain()) {
+                this._removeAlarm(alarm);
+            }
+        }
+    }
+    _removeAlarm(alarm) {
+        this.emit("alarmDeleted", alarm);
+        this.deleteAlarm(alarm.conditionId, alarm.eventType);
+    }
+    makeKey(conditionId, eventType) {
+        return conditionId.toString() + "|" + eventType.toString();
+    }
+    findAlarm(conditionId, eventType) {
+        const key = this.makeKey(conditionId, eventType);
+        const _c = this._map[key];
+        return _c || null;
+    }
+    deleteAlarm(conditionId, eventType) {
+        const key = this.makeKey(conditionId, eventType);
+        const _c = this._map[key];
+        if (_c) {
+            delete this._map[key];
+            return true;
+        }
+        return false;
+    }
+}
+exports.ClientAlarmList = ClientAlarmList;
 //# sourceMappingURL=client_alarm_list.js.map

package/dist/alarms_and_conditions/client_alarm_tools.d.ts

@@ -1,4 +1,4 @@
-import { ClientSession } from "../client_session";
-import { ClientAlarmList } from "./client_alarm_list";
-export declare function uninstallAlarmMonitoring(session: ClientSession): Promise<void>;
-export declare function installAlarmMonitoring(session: ClientSession): Promise<ClientAlarmList>;
+import { ClientSession } from "../client_session";
+import { ClientAlarmList } from "./client_alarm_list";
+export declare function uninstallAlarmMonitoring(session: ClientSession): Promise<void>;
+export declare function installAlarmMonitoring(session: ClientSession): Promise<ClientAlarmList>;