node-opcua-address-space 2.76.1 → 2.76.2

package/dist/src/alarms_and_conditions/ua_discrete_alarm_impl.d.ts

@@ -1,14 +1,14 @@
-import { NodeId } from "node-opcua-nodeid";
-import { VariantOptions } from "node-opcua-variant";
-import { INamespace, UAEventType } from "node-opcua-address-space-base";
-import { UADiscreteAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_discrete_alarm_ex";
-import { InstantiateAlarmConditionOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_alarm_condition_options";
-import { UAAlarmConditionImpl } from "./ua_alarm_condition_impl";
-/**
- * The DiscreteAlarmType is used to classify Types into Alarm Conditions where the input for the
- * Alarm may take on only a certain number of possible values (e.g. true/false,
- * running/stopped/terminating).
- */
-export declare class UADiscreteAlarmImpl extends UAAlarmConditionImpl implements UADiscreteAlarmEx {
-    static instantiate(namespace: INamespace, discreteAlarmTypeId: UAEventType | NodeId | string, options: InstantiateAlarmConditionOptions, data?: Record<string, VariantOptions>): UADiscreteAlarmImpl;
-}
+import { NodeId } from "node-opcua-nodeid";
+import { VariantOptions } from "node-opcua-variant";
+import { INamespace, UAEventType } from "node-opcua-address-space-base";
+import { UADiscreteAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_discrete_alarm_ex";
+import { InstantiateAlarmConditionOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_alarm_condition_options";
+import { UAAlarmConditionImpl } from "./ua_alarm_condition_impl";
+/**
+ * The DiscreteAlarmType is used to classify Types into Alarm Conditions where the input for the
+ * Alarm may take on only a certain number of possible values (e.g. true/false,
+ * running/stopped/terminating).
+ */
+export declare class UADiscreteAlarmImpl extends UAAlarmConditionImpl implements UADiscreteAlarmEx {
+    static instantiate(namespace: INamespace, discreteAlarmTypeId: UAEventType | NodeId | string, options: InstantiateAlarmConditionOptions, data?: Record<string, VariantOptions>): UADiscreteAlarmImpl;
+}

package/dist/src/alarms_and_conditions/ua_discrete_alarm_impl.js

@@ -1,35 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UADiscreteAlarmImpl = void 0;
-/**
- * @module node-opcua-address-space.AlarmsAndConditions
- */
-const node_opcua_assert_1 = require("node-opcua-assert");
-const ua_alarm_condition_impl_1 = require("./ua_alarm_condition_impl");
-/**
- * The DiscreteAlarmType is used to classify Types into Alarm Conditions where the input for the
- * Alarm may take on only a certain number of possible values (e.g. true/false,
- * running/stopped/terminating).
- */
-class UADiscreteAlarmImpl extends ua_alarm_condition_impl_1.UAAlarmConditionImpl {
-    static instantiate(namespace, discreteAlarmTypeId, options, data) {
-        const addressSpace = namespace.addressSpace;
-        const discreteAlarmType = addressSpace.findEventType(discreteAlarmTypeId);
-        /* istanbul ignore next */
-        if (!discreteAlarmType) {
-            throw new Error(" cannot find Condition Type for " + discreteAlarmType);
-        }
-        const discreteAlarmTypeBase = addressSpace.findObjectType("DiscreteAlarmType");
-        (0, node_opcua_assert_1.assert)(discreteAlarmTypeBase, "expecting DiscreteAlarmType - please check you nodeset xml file!");
-        /* eventTypeNode should be subtypeOf("DiscreteAlarmType"); */
-        /* istanbul ignore next */
-        if (!discreteAlarmType.isSupertypeOf(discreteAlarmTypeBase)) {
-            throw new Error("UADiscreteAlarm.instantiate : event found is not subType of DiscreteAlarmType");
-        }
-        const alarmNode = ua_alarm_condition_impl_1.UAAlarmConditionImpl.instantiate(namespace, discreteAlarmType.nodeId, options, data);
-        Object.setPrototypeOf(alarmNode, UADiscreteAlarmImpl.prototype);
-        return alarmNode;
-    }
-}
-exports.UADiscreteAlarmImpl = UADiscreteAlarmImpl;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UADiscreteAlarmImpl = void 0;
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+const node_opcua_assert_1 = require("node-opcua-assert");
+const ua_alarm_condition_impl_1 = require("./ua_alarm_condition_impl");
+/**
+ * The DiscreteAlarmType is used to classify Types into Alarm Conditions where the input for the
+ * Alarm may take on only a certain number of possible values (e.g. true/false,
+ * running/stopped/terminating).
+ */
+class UADiscreteAlarmImpl extends ua_alarm_condition_impl_1.UAAlarmConditionImpl {
+    static instantiate(namespace, discreteAlarmTypeId, options, data) {
+        const addressSpace = namespace.addressSpace;
+        const discreteAlarmType = addressSpace.findEventType(discreteAlarmTypeId);
+        /* istanbul ignore next */
+        if (!discreteAlarmType) {
+            throw new Error(" cannot find Condition Type for " + discreteAlarmType);
+        }
+        const discreteAlarmTypeBase = addressSpace.findObjectType("DiscreteAlarmType");
+        (0, node_opcua_assert_1.assert)(discreteAlarmTypeBase, "expecting DiscreteAlarmType - please check you nodeset xml file!");
+        /* eventTypeNode should be subtypeOf("DiscreteAlarmType"); */
+        /* istanbul ignore next */
+        if (!discreteAlarmType.isSupertypeOf(discreteAlarmTypeBase)) {
+            throw new Error("UADiscreteAlarm.instantiate : event found is not subType of DiscreteAlarmType");
+        }
+        const alarmNode = ua_alarm_condition_impl_1.UAAlarmConditionImpl.instantiate(namespace, discreteAlarmType.nodeId, options, data);
+        Object.setPrototypeOf(alarmNode, UADiscreteAlarmImpl.prototype);
+        return alarmNode;
+    }
+}
+exports.UADiscreteAlarmImpl = UADiscreteAlarmImpl;
 //# sourceMappingURL=ua_discrete_alarm_impl.js.map

package/dist/src/alarms_and_conditions/ua_exclusive_deviation_alarm_impl.d.ts

@@ -1,24 +1,24 @@
-import { DataValue } from "node-opcua-data-value";
-import { NodeId } from "node-opcua-nodeid";
-import { DataType, VariantOptions } from "node-opcua-variant";
-import { UAVariableT } from "node-opcua-address-space-base";
-import { AddressSpace } from "../address_space";
-import { NamespacePrivate } from "../namespace_private";
-import { UAExclusiveDeviationAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_exclusive_deviation_alarm_ex";
-import { InstantiateExclusiveLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_exclusive_limit_alarm_options";
-import { InstallSetPointOptions, SetPointSupport } from "../../source/interfaces/alarms_and_conditions/install_setpoint_options";
-import { UAExclusiveLimitAlarmImpl } from "./ua_exclusive_limit_alarm_impl";
-export declare interface UAExclusiveDeviationAlarmImpl extends UAExclusiveDeviationAlarmEx, UAExclusiveLimitAlarmImpl {
-    on(eventName: string, eventHandler: any): this;
-    get addressSpace(): AddressSpace;
-}
-export declare class UAExclusiveDeviationAlarmImpl extends UAExclusiveLimitAlarmImpl implements UAExclusiveDeviationAlarmEx {
-    static instantiate(namespace: NamespacePrivate, type: string | NodeId, options: InstantiateExclusiveLimitAlarmOptions, data?: Record<string, VariantOptions>): UAExclusiveDeviationAlarmImpl;
-    getSetpointNodeNode(): UAVariableT<number, DataType.Double> | UAVariableT<number, DataType.Float> | undefined;
-    getSetpointValue(): number | null;
-    _onSetpointDataValueChange(dataValue: DataValue): void;
-    _install_setpoint(options: InstallSetPointOptions): any;
-    _setStateBasedOnInputValue(value: number): void;
-}
-export interface UAExclusiveDeviationAlarmHelper extends SetPointSupport {
-}
+import { DataValue } from "node-opcua-data-value";
+import { NodeId } from "node-opcua-nodeid";
+import { DataType, VariantOptions } from "node-opcua-variant";
+import { UAVariableT } from "node-opcua-address-space-base";
+import { AddressSpace } from "../address_space";
+import { NamespacePrivate } from "../namespace_private";
+import { UAExclusiveDeviationAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_exclusive_deviation_alarm_ex";
+import { InstantiateExclusiveLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_exclusive_limit_alarm_options";
+import { InstallSetPointOptions, SetPointSupport } from "../../source/interfaces/alarms_and_conditions/install_setpoint_options";
+import { UAExclusiveLimitAlarmImpl } from "./ua_exclusive_limit_alarm_impl";
+export declare interface UAExclusiveDeviationAlarmImpl extends UAExclusiveDeviationAlarmEx, UAExclusiveLimitAlarmImpl {
+    on(eventName: string, eventHandler: any): this;
+    get addressSpace(): AddressSpace;
+}
+export declare class UAExclusiveDeviationAlarmImpl extends UAExclusiveLimitAlarmImpl implements UAExclusiveDeviationAlarmEx {
+    static instantiate(namespace: NamespacePrivate, type: string | NodeId, options: InstantiateExclusiveLimitAlarmOptions, data?: Record<string, VariantOptions>): UAExclusiveDeviationAlarmImpl;
+    getSetpointNodeNode(): UAVariableT<number, DataType.Double> | UAVariableT<number, DataType.Float> | undefined;
+    getSetpointValue(): number | null;
+    _onSetpointDataValueChange(dataValue: DataValue): void;
+    _install_setpoint(options: InstallSetPointOptions): any;
+    _setStateBasedOnInputValue(value: number): void;
+}
+export interface UAExclusiveDeviationAlarmHelper extends SetPointSupport {
+}

package/dist/src/alarms_and_conditions/ua_exclusive_deviation_alarm_impl.js

@@ -1,57 +1,57 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UAExclusiveDeviationAlarmImpl = void 0;
-/**
- * @module node-opcua-address-space.AlarmsAndConditions
- */
-const node_opcua_assert_1 = require("node-opcua-assert");
-const deviation_alarm_helper_1 = require("./deviation_alarm_helper");
-const ua_exclusive_limit_alarm_impl_1 = require("./ua_exclusive_limit_alarm_impl");
-const ua_limit_alarm_impl_1 = require("./ua_limit_alarm_impl");
-class UAExclusiveDeviationAlarmImpl extends ua_exclusive_limit_alarm_impl_1.UAExclusiveLimitAlarmImpl {
-    static instantiate(namespace, type, options, data) {
-        const addressSpace = namespace.addressSpace;
-        const exclusiveDeviationAlarmType = addressSpace.findEventType("ExclusiveDeviationAlarmType");
-        /* istanbul ignore next */
-        if (!exclusiveDeviationAlarmType) {
-            throw new Error("cannot find ExclusiveDeviationAlarmType");
-        }
-        (0, node_opcua_assert_1.assert)(type === exclusiveDeviationAlarmType.browseName.toString());
-        const alarm = ua_exclusive_limit_alarm_impl_1.UAExclusiveLimitAlarmImpl.instantiate(namespace, type, options, data);
-        Object.setPrototypeOf(alarm, UAExclusiveDeviationAlarmImpl.prototype);
-        (0, node_opcua_assert_1.assert)(alarm instanceof UAExclusiveDeviationAlarmImpl);
-        (0, node_opcua_assert_1.assert)(alarm instanceof ua_exclusive_limit_alarm_impl_1.UAExclusiveLimitAlarmImpl);
-        (0, node_opcua_assert_1.assert)(alarm instanceof ua_limit_alarm_impl_1.UALimitAlarmImpl);
-        alarm._install_setpoint(options);
-        return alarm;
-    }
-    getSetpointNodeNode() {
-        return deviation_alarm_helper_1.DeviationAlarmHelper_getSetpointNodeNode.call(this);
-    }
-    getSetpointValue() {
-        return deviation_alarm_helper_1.DeviationAlarmHelper_getSetpointValue.call(this);
-    }
-    _onSetpointDataValueChange(dataValue) {
-        deviation_alarm_helper_1.DeviationAlarmHelper_onSetpointDataValueChange.call(this, dataValue);
-    }
-    _install_setpoint(options) {
-        return deviation_alarm_helper_1.DeviationAlarmHelper_install_setpoint.call(this, options);
-    }
-    _setStateBasedOnInputValue(value) {
-        const setpointValue = this.getSetpointValue();
-        if (setpointValue === null) {
-            return;
-        }
-        (0, node_opcua_assert_1.assert)(isFinite(setpointValue));
-        // call base class implementation
-        ua_exclusive_limit_alarm_impl_1.UAExclusiveLimitAlarmImpl.prototype._setStateBasedOnInputValue.call(this, value - setpointValue);
-    }
-}
-exports.UAExclusiveDeviationAlarmImpl = UAExclusiveDeviationAlarmImpl;
-/*
-UAExclusiveDeviationAlarm.prototype.getSetpointNodeNode = DeviationAlarmHelper.getSetpointNodeNode;
-UAExclusiveDeviationAlarm.prototype.getSetpointValue = DeviationAlarmHelper.getSetpointValue;
-UAExclusiveDeviationAlarm.prototype._onSetpointDataValueChange = DeviationAlarmHelper._onSetpointDataValueChange;
-UAExclusiveDeviationAlarm.prototype._install_setpoint = DeviationAlarmHelper._install_setpoint;
- */
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UAExclusiveDeviationAlarmImpl = void 0;
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+const node_opcua_assert_1 = require("node-opcua-assert");
+const deviation_alarm_helper_1 = require("./deviation_alarm_helper");
+const ua_exclusive_limit_alarm_impl_1 = require("./ua_exclusive_limit_alarm_impl");
+const ua_limit_alarm_impl_1 = require("./ua_limit_alarm_impl");
+class UAExclusiveDeviationAlarmImpl extends ua_exclusive_limit_alarm_impl_1.UAExclusiveLimitAlarmImpl {
+    static instantiate(namespace, type, options, data) {
+        const addressSpace = namespace.addressSpace;
+        const exclusiveDeviationAlarmType = addressSpace.findEventType("ExclusiveDeviationAlarmType");
+        /* istanbul ignore next */
+        if (!exclusiveDeviationAlarmType) {
+            throw new Error("cannot find ExclusiveDeviationAlarmType");
+        }
+        (0, node_opcua_assert_1.assert)(type === exclusiveDeviationAlarmType.browseName.toString());
+        const alarm = ua_exclusive_limit_alarm_impl_1.UAExclusiveLimitAlarmImpl.instantiate(namespace, type, options, data);
+        Object.setPrototypeOf(alarm, UAExclusiveDeviationAlarmImpl.prototype);
+        (0, node_opcua_assert_1.assert)(alarm instanceof UAExclusiveDeviationAlarmImpl);
+        (0, node_opcua_assert_1.assert)(alarm instanceof ua_exclusive_limit_alarm_impl_1.UAExclusiveLimitAlarmImpl);
+        (0, node_opcua_assert_1.assert)(alarm instanceof ua_limit_alarm_impl_1.UALimitAlarmImpl);
+        alarm._install_setpoint(options);
+        return alarm;
+    }
+    getSetpointNodeNode() {
+        return deviation_alarm_helper_1.DeviationAlarmHelper_getSetpointNodeNode.call(this);
+    }
+    getSetpointValue() {
+        return deviation_alarm_helper_1.DeviationAlarmHelper_getSetpointValue.call(this);
+    }
+    _onSetpointDataValueChange(dataValue) {
+        deviation_alarm_helper_1.DeviationAlarmHelper_onSetpointDataValueChange.call(this, dataValue);
+    }
+    _install_setpoint(options) {
+        return deviation_alarm_helper_1.DeviationAlarmHelper_install_setpoint.call(this, options);
+    }
+    _setStateBasedOnInputValue(value) {
+        const setpointValue = this.getSetpointValue();
+        if (setpointValue === null) {
+            return;
+        }
+        (0, node_opcua_assert_1.assert)(isFinite(setpointValue));
+        // call base class implementation
+        ua_exclusive_limit_alarm_impl_1.UAExclusiveLimitAlarmImpl.prototype._setStateBasedOnInputValue.call(this, value - setpointValue);
+    }
+}
+exports.UAExclusiveDeviationAlarmImpl = UAExclusiveDeviationAlarmImpl;
+/*
+UAExclusiveDeviationAlarm.prototype.getSetpointNodeNode = DeviationAlarmHelper.getSetpointNodeNode;
+UAExclusiveDeviationAlarm.prototype.getSetpointValue = DeviationAlarmHelper.getSetpointValue;
+UAExclusiveDeviationAlarm.prototype._onSetpointDataValueChange = DeviationAlarmHelper._onSetpointDataValueChange;
+UAExclusiveDeviationAlarm.prototype._install_setpoint = DeviationAlarmHelper._install_setpoint;
+ */
 //# sourceMappingURL=ua_exclusive_deviation_alarm_impl.js.map

package/dist/src/alarms_and_conditions/ua_exclusive_level_alarm_impl.d.ts

@@ -1,11 +1,11 @@
-/**
- * @module node-opcua-address-space.AlarmsAndConditions
- */
-import { NodeId } from "node-opcua-nodeid";
-import { VariantOptions } from "node-opcua-variant";
-import { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
-import { NamespacePrivate } from "../namespace_private";
-import { UAExclusiveLimitAlarmImpl } from "./ua_exclusive_limit_alarm_impl";
-export declare class UAExclusiveLevelAlarmImpl extends UAExclusiveLimitAlarmImpl {
-    static instantiate(namespace: NamespacePrivate, type: NodeId | string, options: InstantiateLimitAlarmOptions, data?: Record<string, VariantOptions>): UAExclusiveLevelAlarmImpl;
-}
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+import { NodeId } from "node-opcua-nodeid";
+import { VariantOptions } from "node-opcua-variant";
+import { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
+import { NamespacePrivate } from "../namespace_private";
+import { UAExclusiveLimitAlarmImpl } from "./ua_exclusive_limit_alarm_impl";
+export declare class UAExclusiveLevelAlarmImpl extends UAExclusiveLimitAlarmImpl {
+    static instantiate(namespace: NamespacePrivate, type: NodeId | string, options: InstantiateLimitAlarmOptions, data?: Record<string, VariantOptions>): UAExclusiveLevelAlarmImpl;
+}

package/dist/src/alarms_and_conditions/ua_exclusive_level_alarm_impl.js

@@ -1,12 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UAExclusiveLevelAlarmImpl = void 0;
-const ua_exclusive_limit_alarm_impl_1 = require("./ua_exclusive_limit_alarm_impl");
-class UAExclusiveLevelAlarmImpl extends ua_exclusive_limit_alarm_impl_1.UAExclusiveLimitAlarmImpl {
-    static instantiate(namespace, type, options, data) {
-        const addressSpace = namespace.addressSpace;
-        return ua_exclusive_limit_alarm_impl_1.UAExclusiveLimitAlarmImpl.instantiate(namespace, type, options, data);
-    }
-}
-exports.UAExclusiveLevelAlarmImpl = UAExclusiveLevelAlarmImpl;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UAExclusiveLevelAlarmImpl = void 0;
+const ua_exclusive_limit_alarm_impl_1 = require("./ua_exclusive_limit_alarm_impl");
+class UAExclusiveLevelAlarmImpl extends ua_exclusive_limit_alarm_impl_1.UAExclusiveLimitAlarmImpl {
+    static instantiate(namespace, type, options, data) {
+        const addressSpace = namespace.addressSpace;
+        return ua_exclusive_limit_alarm_impl_1.UAExclusiveLimitAlarmImpl.instantiate(namespace, type, options, data);
+    }
+}
+exports.UAExclusiveLevelAlarmImpl = UAExclusiveLevelAlarmImpl;
 //# sourceMappingURL=ua_exclusive_level_alarm_impl.js.map

package/dist/src/alarms_and_conditions/ua_exclusive_limit_alarm_impl.d.ts

@@ -1,23 +1,23 @@
-import { NodeId } from "node-opcua-nodeid";
-import { VariantOptions } from "node-opcua-variant";
-import { UAEventType } from "node-opcua-address-space-base";
-import { NamespacePrivate } from "../namespace_private";
-import { UAExclusiveLimitAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex";
-import { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
-import { UALimitAlarmImpl } from "./ua_limit_alarm_impl";
-export declare interface UAExclusiveLimitAlarmImpl extends UAExclusiveLimitAlarmEx {
-}
-export declare class UAExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UAExclusiveLimitAlarmEx {
-    /***
-     *
-     * @method (static)instantiate
-     * @param namespace {INamespace}
-     * @param type
-     * @param options
-     * @param data
-     * @return {UAExclusiveLimitAlarm}
-     */
-    static instantiate(namespace: NamespacePrivate, type: UAEventType | string | NodeId, options: InstantiateLimitAlarmOptions, data?: Record<string, VariantOptions>): UAExclusiveLimitAlarmImpl;
-    _signalNewCondition(stateName: string | null, isActive: boolean, value: string): void;
-    _setStateBasedOnInputValue(value: number): void;
-}
+import { NodeId } from "node-opcua-nodeid";
+import { VariantOptions } from "node-opcua-variant";
+import { UAEventType } from "node-opcua-address-space-base";
+import { NamespacePrivate } from "../namespace_private";
+import { UAExclusiveLimitAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex";
+import { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
+import { UALimitAlarmImpl } from "./ua_limit_alarm_impl";
+export declare interface UAExclusiveLimitAlarmImpl extends UAExclusiveLimitAlarmEx {
+}
+export declare class UAExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UAExclusiveLimitAlarmEx {
+    /***
+     *
+     * @method (static)instantiate
+     * @param namespace {INamespace}
+     * @param type
+     * @param options
+     * @param data
+     * @return {UAExclusiveLimitAlarm}
+     */
+    static instantiate(namespace: NamespacePrivate, type: UAEventType | string | NodeId, options: InstantiateLimitAlarmOptions, data?: Record<string, VariantOptions>): UAExclusiveLimitAlarmImpl;
+    _signalNewCondition(stateName: string | null, isActive: boolean, value: string): void;
+    _setStateBasedOnInputValue(value: number): void;
+}

package/dist/src/alarms_and_conditions/ua_exclusive_limit_alarm_impl.js

@@ -1,87 +1,87 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UAExclusiveLimitAlarmImpl = void 0;
-/**
- * @module node-opcua-address-space.AlarmsAndConditions
- */
-const node_opcua_assert_1 = require("node-opcua-assert");
-const finite_state_machine_1 = require("../state_machine/finite_state_machine");
-const ua_limit_alarm_impl_1 = require("./ua_limit_alarm_impl");
-const validState = ["HighHigh", "High", "Low", "LowLow", null];
-class UAExclusiveLimitAlarmImpl extends ua_limit_alarm_impl_1.UALimitAlarmImpl {
-    /***
-     *
-     * @method (static)instantiate
-     * @param namespace {INamespace}
-     * @param type
-     * @param options
-     * @param data
-     * @return {UAExclusiveLimitAlarm}
-     */
-    static instantiate(namespace, type, options, data) {
-        const addressSpace = namespace.addressSpace;
-        const exclusiveAlarmType = addressSpace.findEventType(type);
-        /* istanbul ignore next */
-        if (!exclusiveAlarmType) {
-            throw new Error(" cannot find Alarm Condition Type for " + type);
-        }
-        const exclusiveLimitAlarmType = addressSpace.findEventType("ExclusiveLimitAlarmType");
-        /* istanbul ignore next */
-        if (!exclusiveLimitAlarmType) {
-            throw new Error("cannot find ExclusiveLimitAlarmType");
-        }
-        const node = ua_limit_alarm_impl_1.UALimitAlarmImpl.instantiate(namespace, type, options, data);
-        Object.setPrototypeOf(node, UAExclusiveLimitAlarmImpl.prototype);
-        const alarm = node;
-        (0, node_opcua_assert_1.assert)(alarm instanceof UAExclusiveLimitAlarmImpl);
-        (0, node_opcua_assert_1.assert)(alarm instanceof ua_limit_alarm_impl_1.UALimitAlarmImpl);
-        // ---------------- install LimitState StateMachine
-        (0, node_opcua_assert_1.assert)(alarm.limitState, "limitState is mandatory");
-        (0, finite_state_machine_1.promoteToStateMachine)(alarm.limitState);
-        // start with a inactive state
-        alarm.activeState.setValue(false);
-        alarm.updateState();
-        return alarm;
-    }
-    _signalNewCondition(stateName, isActive, value) {
-        (0, node_opcua_assert_1.assert)(stateName === null || typeof isActive === "boolean");
-        (0, node_opcua_assert_1.assert)(validState.indexOf(stateName) >= 0, "must have a valid state : " + stateName);
-        const oldState = this.limitState.getCurrentState();
-        const oldActive = this.activeState.getValue();
-        if (stateName) {
-            this.limitState.setState(stateName);
-        }
-        else {
-            (0, node_opcua_assert_1.assert)(stateName === null);
-            this.limitState.setState(stateName);
-        }
-        super._signalNewCondition(stateName, isActive, value);
-    }
-    _setStateBasedOnInputValue(value) {
-        (0, node_opcua_assert_1.assert)(isFinite(value));
-        let isActive = false;
-        let state = null;
-        const oldState = this.limitState.getCurrentState();
-        if (this.highHighLimit && this.getHighHighLimit() < value) {
-            state = "HighHigh";
-            isActive = true;
-        }
-        else if (this.highLimit && this.getHighLimit() < value) {
-            state = "High";
-            isActive = true;
-        }
-        else if (this.lowLowLimit && this.getLowLowLimit() > value) {
-            state = "LowLow";
-            isActive = true;
-        }
-        else if (this.lowLimit && this.getLowLimit() > value) {
-            state = "Low";
-            isActive = true;
-        }
-        if (state !== oldState) {
-            this._signalNewCondition(state, isActive, value.toFixed(3));
-        }
-    }
-}
-exports.UAExclusiveLimitAlarmImpl = UAExclusiveLimitAlarmImpl;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UAExclusiveLimitAlarmImpl = void 0;
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+const node_opcua_assert_1 = require("node-opcua-assert");
+const finite_state_machine_1 = require("../state_machine/finite_state_machine");
+const ua_limit_alarm_impl_1 = require("./ua_limit_alarm_impl");
+const validState = ["HighHigh", "High", "Low", "LowLow", null];
+class UAExclusiveLimitAlarmImpl extends ua_limit_alarm_impl_1.UALimitAlarmImpl {
+    /***
+     *
+     * @method (static)instantiate
+     * @param namespace {INamespace}
+     * @param type
+     * @param options
+     * @param data
+     * @return {UAExclusiveLimitAlarm}
+     */
+    static instantiate(namespace, type, options, data) {
+        const addressSpace = namespace.addressSpace;
+        const exclusiveAlarmType = addressSpace.findEventType(type);
+        /* istanbul ignore next */
+        if (!exclusiveAlarmType) {
+            throw new Error(" cannot find Alarm Condition Type for " + type);
+        }
+        const exclusiveLimitAlarmType = addressSpace.findEventType("ExclusiveLimitAlarmType");
+        /* istanbul ignore next */
+        if (!exclusiveLimitAlarmType) {
+            throw new Error("cannot find ExclusiveLimitAlarmType");
+        }
+        const node = ua_limit_alarm_impl_1.UALimitAlarmImpl.instantiate(namespace, type, options, data);
+        Object.setPrototypeOf(node, UAExclusiveLimitAlarmImpl.prototype);
+        const alarm = node;
+        (0, node_opcua_assert_1.assert)(alarm instanceof UAExclusiveLimitAlarmImpl);
+        (0, node_opcua_assert_1.assert)(alarm instanceof ua_limit_alarm_impl_1.UALimitAlarmImpl);
+        // ---------------- install LimitState StateMachine
+        (0, node_opcua_assert_1.assert)(alarm.limitState, "limitState is mandatory");
+        (0, finite_state_machine_1.promoteToStateMachine)(alarm.limitState);
+        // start with a inactive state
+        alarm.activeState.setValue(false);
+        alarm.updateState();
+        return alarm;
+    }
+    _signalNewCondition(stateName, isActive, value) {
+        (0, node_opcua_assert_1.assert)(stateName === null || typeof isActive === "boolean");
+        (0, node_opcua_assert_1.assert)(validState.indexOf(stateName) >= 0, "must have a valid state : " + stateName);
+        const oldState = this.limitState.getCurrentState();
+        const oldActive = this.activeState.getValue();
+        if (stateName) {
+            this.limitState.setState(stateName);
+        }
+        else {
+            (0, node_opcua_assert_1.assert)(stateName === null);
+            this.limitState.setState(stateName);
+        }
+        super._signalNewCondition(stateName, isActive, value);
+    }
+    _setStateBasedOnInputValue(value) {
+        (0, node_opcua_assert_1.assert)(isFinite(value));
+        let isActive = false;
+        let state = null;
+        const oldState = this.limitState.getCurrentState();
+        if (this.highHighLimit && this.getHighHighLimit() < value) {
+            state = "HighHigh";
+            isActive = true;
+        }
+        else if (this.highLimit && this.getHighLimit() < value) {
+            state = "High";
+            isActive = true;
+        }
+        else if (this.lowLowLimit && this.getLowLowLimit() > value) {
+            state = "LowLow";
+            isActive = true;
+        }
+        else if (this.lowLimit && this.getLowLimit() > value) {
+            state = "Low";
+            isActive = true;
+        }
+        if (state !== oldState) {
+            this._signalNewCondition(state, isActive, value.toFixed(3));
+        }
+    }
+}
+exports.UAExclusiveLimitAlarmImpl = UAExclusiveLimitAlarmImpl;
 //# sourceMappingURL=ua_exclusive_limit_alarm_impl.js.map

package/dist/src/alarms_and_conditions/ua_exclusive_rate_of_change_alarm_impl.d.ts

@@ -1,11 +1,11 @@
-/**
- * @module node-opcua-address-space.AlarmsAndConditions
- */
-import { UAExclusiveRateOfChangeAlarm_Base } from "node-opcua-nodeset-ua";
-import { UAExclusiveLimitAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex";
-import { UAExclusiveLimitAlarmImpl } from "./ua_exclusive_limit_alarm_impl";
-export interface UAExclusiveRateOfChangeAlarmEx extends Omit<UAExclusiveRateOfChangeAlarm_Base, "ackedState" | "activeState" | "confirmedState" | "enabledState" | "latchedState" | "limitState" | "outOfServiceState" | "shelvingState" | "silenceState" | "suppressedState">, UAExclusiveLimitAlarmEx {
-    on(eventName: string, eventHandler: any): this;
-}
-export declare class UAExclusiveRateOfChangeAlarmImpl extends UAExclusiveLimitAlarmImpl implements UAExclusiveRateOfChangeAlarmEx {
-}
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+import { UAExclusiveRateOfChangeAlarm_Base } from "node-opcua-nodeset-ua";
+import { UAExclusiveLimitAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex";
+import { UAExclusiveLimitAlarmImpl } from "./ua_exclusive_limit_alarm_impl";
+export interface UAExclusiveRateOfChangeAlarmEx extends Omit<UAExclusiveRateOfChangeAlarm_Base, "ackedState" | "activeState" | "confirmedState" | "enabledState" | "latchedState" | "limitState" | "outOfServiceState" | "shelvingState" | "silenceState" | "suppressedState">, UAExclusiveLimitAlarmEx {
+    on(eventName: string, eventHandler: any): this;
+}
+export declare class UAExclusiveRateOfChangeAlarmImpl extends UAExclusiveLimitAlarmImpl implements UAExclusiveRateOfChangeAlarmEx {
+}

package/dist/src/alarms_and_conditions/ua_exclusive_rate_of_change_alarm_impl.js

@@ -1,8 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UAExclusiveRateOfChangeAlarmImpl = void 0;
-const ua_exclusive_limit_alarm_impl_1 = require("./ua_exclusive_limit_alarm_impl");
-class UAExclusiveRateOfChangeAlarmImpl extends ua_exclusive_limit_alarm_impl_1.UAExclusiveLimitAlarmImpl {
-}
-exports.UAExclusiveRateOfChangeAlarmImpl = UAExclusiveRateOfChangeAlarmImpl;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UAExclusiveRateOfChangeAlarmImpl = void 0;
+const ua_exclusive_limit_alarm_impl_1 = require("./ua_exclusive_limit_alarm_impl");
+class UAExclusiveRateOfChangeAlarmImpl extends ua_exclusive_limit_alarm_impl_1.UAExclusiveLimitAlarmImpl {
+}
+exports.UAExclusiveRateOfChangeAlarmImpl = UAExclusiveRateOfChangeAlarmImpl;
 //# sourceMappingURL=ua_exclusive_rate_of_change_alarm_impl.js.map