node-opcua-address-space 2.180.0 → 2.181.0

package/src/alarms_and_conditions/ua_discrete_alarm_impl.ts

@@ -1,57 +0,0 @@
-/**
- * @module node-opcua-address-space.AlarmsAndConditions
- */
-
-import type { INamespace, UAEventType } from "node-opcua-address-space-base";
-import { assert } from "node-opcua-assert";
-import type { NodeId } from "node-opcua-nodeid";
-import type { UADiscreteAlarm } from "node-opcua-nodeset-ua";
-import type { VariantOptions } from "node-opcua-variant";
-import type { InstantiateAlarmConditionOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_alarm_condition_options.js";
-import type { UADiscreteAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_discrete_alarm_ex.js";
-import { UAAlarmConditionImplBase } from "./ua_alarm_condition_impl.js";
-/**
- * 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 class UADiscreteAlarmImplBase extends UAAlarmConditionImplBase {
-    public static instantiate(
-        namespace: INamespace,
-        discreteAlarmTypeId: UAEventType | NodeId | string,
-        options: InstantiateAlarmConditionOptions,
-        data?: Record<string, VariantOptions>
-    ): UADiscreteAlarmImpl {
-        const addressSpace = namespace.addressSpace;
-
-        const discreteAlarmType = addressSpace.findEventType(discreteAlarmTypeId);
-        /* c8 ignore next */
-        if (!discreteAlarmType) {
-            throw new Error(` cannot find Condition Type for ${discreteAlarmType}`);
-        }
-
-        const discreteAlarmTypeBase = addressSpace.findObjectType("DiscreteAlarmType");
-        assert(discreteAlarmTypeBase, "expecting DiscreteAlarmType - please check you nodeset xml file!");
-        if (!discreteAlarmTypeBase) {
-            throw new Error("expecting DiscreteAlarmType - please check you nodeset xml file!");
-        }
-
-        /* eventTypeNode should be subtypeOf("DiscreteAlarmType"); */
-        /* c8 ignore next */
-        if (!discreteAlarmType.isSubtypeOf(discreteAlarmTypeBase)) {
-            throw new Error("UADiscreteAlarm.instantiate : event found is not subType of DiscreteAlarmType");
-        }
-
-        const alarmNode = UAAlarmConditionImplBase.instantiate(
-            namespace,
-            discreteAlarmType.nodeId,
-            options,
-            data
-        ) as unknown as UADiscreteAlarm;
-        Object.setPrototypeOf(alarmNode, UADiscreteAlarmImplBase.prototype);
-
-        return alarmNode as unknown as UADiscreteAlarmImpl;
-    }
-}
-export type UADiscreteAlarmImpl = UADiscreteAlarmImplBase & UADiscreteAlarmEx;
-export const UADiscreteAlarmImpl = UADiscreteAlarmImplBase as unknown as UADiscreteAlarmImpl;

package/src/alarms_and_conditions/ua_exclusive_deviation_alarm_impl.ts

@@ -1,94 +0,0 @@
-/**
- * @module node-opcua-address-space.AlarmsAndConditions
- */
-
-import type { UAVariableT } from "node-opcua-address-space-base";
-import { assert } from "node-opcua-assert";
-import type { DataValue } from "node-opcua-data-value";
-import type { NodeId } from "node-opcua-nodeid";
-import type { DataType, VariantOptions } from "node-opcua-variant";
-import type { DeviationStuff } from "../../source/interfaces/alarms_and_conditions/deviation_stuff";
-import type {
-    InstallSetPointOptions,
-    SetPointSupport
-} from "../../source/interfaces/alarms_and_conditions/install_setpoint_options";
-import type { InstantiateExclusiveLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_exclusive_limit_alarm_options";
-import type { UAExclusiveDeviationAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_exclusive_deviation_alarm_ex";
-
-import type { NamespacePrivate } from "../namespace_private";
-import {
-    DeviationAlarmHelper_getSetpointNodeNode,
-    DeviationAlarmHelper_getSetpointValue,
-    DeviationAlarmHelper_install_setpoint,
-    DeviationAlarmHelper_onSetpointDataValueChange
-} from "./deviation_alarm_helper";
-
-import { UAExclusiveLimitAlarmImpl, UAExclusiveLimitAlarmImplBase } from "./ua_exclusive_limit_alarm_impl";
-import { UALimitAlarmImpl } from "./ua_limit_alarm_impl";
-
-export class UAExclusiveDeviationAlarmImplBase extends UAExclusiveLimitAlarmImplBase {
-    public static instantiate(
-        namespace: NamespacePrivate,
-        type: string | NodeId,
-        options: InstantiateExclusiveLimitAlarmOptions & InstallSetPointOptions,
-        data?: Record<string, VariantOptions>
-    ): UAExclusiveDeviationAlarmImpl {
-        const addressSpace = namespace.addressSpace;
-
-        const exclusiveDeviationAlarmType = addressSpace.findEventType("ExclusiveDeviationAlarmType");
-        /* c8 ignore next */
-        if (!exclusiveDeviationAlarmType) {
-            throw new Error("cannot find ExclusiveDeviationAlarmType");
-        }
-
-        assert(type === exclusiveDeviationAlarmType.browseName.toString());
-
-        const alarm = UAExclusiveLimitAlarmImplBase.instantiate(
-            namespace,
-            type,
-            options,
-            data
-        ) as unknown as UAExclusiveDeviationAlarmImplBase;
-        Object.setPrototypeOf(alarm, UAExclusiveDeviationAlarmImpl.prototype);
-        assert(alarm instanceof UAExclusiveDeviationAlarmImpl);
-        assert(alarm instanceof UAExclusiveLimitAlarmImpl);
-        assert(alarm instanceof UALimitAlarmImpl);
-
-        alarm._install_setpoint(options);
-
-        return alarm as UAExclusiveDeviationAlarmImpl;
-    }
-
-    private get $16() {
-        return this as unknown as UAExclusiveDeviationAlarmEx & DeviationStuff;
-    }
-    public getSetpointNodeNode(): UAVariableT<number, DataType.Double> | UAVariableT<number, DataType.Float> | undefined {
-        return DeviationAlarmHelper_getSetpointNodeNode.call(this.$16);
-    }
-
-    public getSetpointValue(): number | null {
-        return DeviationAlarmHelper_getSetpointValue.call(this.$16);
-    }
-
-    public _onSetpointDataValueChange(dataValue: DataValue): void {
-        DeviationAlarmHelper_onSetpointDataValueChange.call(this.$16, dataValue);
-    }
-
-    public _install_setpoint(options: InstallSetPointOptions): void {
-        DeviationAlarmHelper_install_setpoint.call(this.$16, options);
-    }
-
-    public _setStateBasedOnInputValue(value: number): void {
-        const setpointValue = this.getSetpointValue();
-        if (setpointValue === null) {
-            return;
-        }
-        assert(Number.isFinite(setpointValue));
-        // call base class implementation
-        UAExclusiveLimitAlarmImpl.prototype._setStateBasedOnInputValue.call(this, value - setpointValue);
-    }
-}
-export type UAExclusiveDeviationAlarmImpl = UAExclusiveDeviationAlarmImplBase & UAExclusiveDeviationAlarmEx;
-export const UAExclusiveDeviationAlarmImpl =
-    UAExclusiveDeviationAlarmImplBase as unknown as new () => UAExclusiveDeviationAlarmImpl;
-export interface UAExclusiveDeviationAlarmHelper extends SetPointSupport {}

package/src/alarms_and_conditions/ua_exclusive_level_alarm_impl.ts

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

package/src/alarms_and_conditions/ua_exclusive_limit_alarm_impl.ts

@@ -1,109 +0,0 @@
-import type { UAEventType, UAObject } from "node-opcua-address-space-base";
-import { assert } from "node-opcua-assert";
-import type { NodeId } from "node-opcua-nodeid";
-import type { VariantOptions } from "node-opcua-variant";
-import type { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
-import type { UAExclusiveLimitAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex";
-import type { NamespacePrivate } from "../namespace_private";
-import { promoteToStateMachine } from "../state_machine/finite_state_machine";
-import { UALimitAlarmImpl, UALimitAlarmImplBase } from "./ua_limit_alarm_impl";
-
-const validState = ["HighHigh", "High", "Low", "LowLow", null];
-
-export class UAExclusiveLimitAlarmImplBase extends UALimitAlarmImpl {
-    /***
-     *
-     * @param namespace {INamespace}
-     * @param type
-     * @param options
-     * @param data
-     * @return {UAExclusiveLimitAlarm}
-     */
-    public static instantiate(
-        namespace: NamespacePrivate,
-        type: UAEventType | string | NodeId,
-        options: InstantiateLimitAlarmOptions,
-        data?: Record<string, VariantOptions>
-    ): UAExclusiveLimitAlarmImpl {
-        const addressSpace = namespace.addressSpace;
-
-        const exclusiveAlarmType = addressSpace.findEventType(type);
-
-        /* c8 ignore next */
-        if (!exclusiveAlarmType) {
-            throw new Error(` cannot find Alarm Condition Type for ${type}`);
-        }
-
-        const exclusiveLimitAlarmType = addressSpace.findEventType("ExclusiveLimitAlarmType");
-        /* c8 ignore next */
-        if (!exclusiveLimitAlarmType) {
-            throw new Error("cannot find ExclusiveLimitAlarmType");
-        }
-
-        const node = UALimitAlarmImplBase.instantiate(namespace, type, options, data);
-        Object.setPrototypeOf(node, UAExclusiveLimitAlarmImplBase.prototype);
-        const alarm = node as unknown as UAExclusiveLimitAlarmImplBase;
-        assert(alarm instanceof UAExclusiveLimitAlarmImpl);
-        assert(alarm instanceof UALimitAlarmImpl);
-
-        // ---------------- install LimitState StateMachine
-        assert(alarm.$10.limitState, "limitState is mandatory");
-        promoteToStateMachine(alarm.$10.limitState as unknown as UAObject);
-
-        // start with a inactive state
-        alarm.activeState.setValue(false);
-
-        alarm.updateState();
-
-        return alarm as UAExclusiveLimitAlarmImpl;
-    }
-
-    private get $10() {
-        return this as unknown as UAExclusiveLimitAlarmEx;
-    }
-    public _signalNewCondition(stateName: string | null, isActive: boolean, value: string): void {
-        assert(stateName === null || typeof isActive === "boolean");
-        assert(validState.indexOf(stateName) >= 0, `must have a valid state : ${stateName}`);
-
-        const _oldState = this.$10.limitState.getCurrentState();
-        const _oldActive = this.activeState.getValue();
-
-        if (stateName) {
-            this.$10.limitState.setState(stateName);
-        } else {
-            assert(stateName === null);
-            this.$10.limitState.setState(stateName);
-        }
-        super._signalNewCondition(stateName, isActive, value);
-    }
-
-    public _setStateBasedOnInputValue(value: number): void {
-        assert(Number.isFinite(value));
-        let isActive = false;
-
-        let state = null;
-
-        const oldState = this.$10.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));
-        }
-    }
-}
-
-export type UAExclusiveLimitAlarmImpl = UAExclusiveLimitAlarmImplBase & UAExclusiveLimitAlarmEx;
-export const UAExclusiveLimitAlarmImpl = UAExclusiveLimitAlarmImplBase as unknown as new () => UAExclusiveLimitAlarmImpl;

package/src/alarms_and_conditions/ua_exclusive_rate_of_change_alarm_impl.ts

@@ -1,25 +0,0 @@
-/**
- * @module node-opcua-address-space.AlarmsAndConditions
- */
-import type { UAExclusiveRateOfChangeAlarm_Base } from "node-opcua-nodeset-ua";
-import type { 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 {}
-export class UAExclusiveRateOfChangeAlarmImpl extends UAExclusiveLimitAlarmImpl implements UAExclusiveRateOfChangeAlarmEx {
-    /** empty interface */
-}

package/src/alarms_and_conditions/ua_limit_alarm_impl.ts

@@ -1,244 +0,0 @@
-import type { UAEventType, UAVariable } from "node-opcua-address-space-base";
-import { assert } from "node-opcua-assert";
-import { NodeClass } from "node-opcua-data-model";
-import { DataValue } from "node-opcua-data-value";
-import { make_warningLog } from "node-opcua-debug";
-import type { NodeId } from "node-opcua-nodeid";
-import { StatusCodes } from "node-opcua-status-code";
-import { DataType, type VariantOptions } from "node-opcua-variant";
-import type { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
-import type { UALimitAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_limit_alarm_ex";
-import type { NamespacePrivate } from "../namespace_private";
-import { UAAlarmConditionImplBase } from "./ua_alarm_condition_impl";
-
-const warningLog = make_warningLog("AlarmsAndConditions");
-
-const uaLimitAlarmInputSupportedDataType: DataType[] = [
-    DataType.Double,
-    DataType.Float,
-    DataType.Byte,
-    DataType.SByte,
-    DataType.Int16,
-    DataType.Int32,
-    DataType.UInt16,
-    DataType.UInt32
-];
-
-export class UALimitAlarmImplBase extends UAAlarmConditionImplBase {
-    public static instantiate(
-        namespace: NamespacePrivate,
-        limitAlarmTypeId: UAEventType | NodeId | string,
-        options: InstantiateLimitAlarmOptions,
-        data?: Record<string, VariantOptions>
-    ): UALimitAlarmImpl {
-        const addressSpace = namespace.addressSpace;
-
-        // must provide a inputNode
-        // xx assert(Object.prototype.hasOwnProperty.call(options,"conditionOf")); // must provide a conditionOf
-        assert(Object.hasOwn(options, "inputNode"), "UALimitAlarm.instantiate: options must provide the inputNode");
-
-        options.optionals = options.optionals || [];
-        let count = 0;
-        if (Object.hasOwn(options, "highHighLimit")) {
-            options.optionals.push("HighHighLimit");
-            options.optionals.push("HighHighState");
-            count++;
-        }
-        if (Object.hasOwn(options, "highLimit")) {
-            options.optionals.push("HighLimit");
-            options.optionals.push("HighState");
-            count++;
-        }
-        if (Object.hasOwn(options, "lowLimit")) {
-            options.optionals.push("LowLimit");
-            options.optionals.push("LowState");
-            count++;
-        }
-        if (Object.hasOwn(options, "lowLowLimit")) {
-            options.optionals.push("LowLowLimit");
-            options.optionals.push("LowLowState");
-            count++;
-        }
-
-        // xx assert(options.optionals,"must provide an optionals");
-        const alarmNode = UAAlarmConditionImplBase.instantiate(namespace, limitAlarmTypeId, options, data) as UALimitAlarmImpl;
-        Object.setPrototypeOf(alarmNode, UALimitAlarmImpl.prototype);
-
-        assert(alarmNode.conditionOfNode() !== null);
-
-        const inputNode = addressSpace._coerceNode(options.inputNode) as UAVariable;
-        if (!inputNode) {
-            throw new Error("Expecting a valid input node");
-        }
-        assert(inputNode.nodeClass === NodeClass.Variable);
-
-        // ----------------------- Install Limit Alarm specifics
-        // from spec 1.03:
-        // Four optional limits are defined that configure the states of the derived limit Alarm Types.
-        // These Properties shall be set for any Alarm limits that are exposed by the derived limit Alarm
-        // Types. These Properties are listed as optional but at least one is required. For cases where
-        // an underlying system cannot provide the actual value of a limit, the limit Property shall still be
-        // provided, but will have its AccessLevel set to not readable. It is assumed that the limits are
-        // described using the same Engineering Unit that is assigned to the variable that is the source
-        // of the alarm. For Rate of change limit alarms, it is assumed this rate is units per second
-        // unless otherwise specified.
-        if (count === 0) {
-            throw new Error("at least one limit is required");
-        }
-
-        const dataType = addressSpace.findCorrespondingBasicDataType(inputNode.dataType);
-
-        if (-1 === uaLimitAlarmInputSupportedDataType.indexOf(dataType)) {
-            const message = `UALimitAlarm.instantiate: inputNode must be of type ${uaLimitAlarmInputSupportedDataType
-                .map((a) => DataType[a])
-                .join("|")}, got ${DataType[dataType]}`;
-            warningLog(message);
-            throw new Error(message);
-        }
-
-        if (Object.hasOwn(options, "highHighLimit") && options.highHighLimit !== undefined) {
-            alarmNode.setHighHighLimit(options.highHighLimit);
-        }
-        if (Object.hasOwn(options, "highLimit")) {
-            alarmNode.setHighLimit(options.highLimit);
-        }
-        if (Object.hasOwn(options, "lowLimit")) {
-            alarmNode.setLowLimit(options.lowLimit);
-        }
-        if (Object.hasOwn(options, "lowLowLimit") && options.lowLowLimit !== undefined) {
-            alarmNode.setLowLowLimit(options.lowLowLimit);
-        }
-
-        /*
-         * The InputNode Property provides the NodeId of the Variable the Value of which is used as
-         * primary input in the calculation of the Alarm state. If this Variable is not in the AddressSpace,
-         * a Null NodeId shall be provided. In some systems, an Alarm may be calculated based on
-         * multiple Variables Values; it is up to the system to determine which Variable’s NodeId is used.
-         */
-        assert(alarmNode.inputNode.nodeClass === NodeClass.Variable);
-        alarmNode.inputNode.setValueFromSource({ dataType: "NodeId", value: inputNode.nodeId });
-
-        // install inputNode monitoring for change
-        alarmNode.installInputNodeMonitoring(options.inputNode);
-        alarmNode._watchLimits();
-
-        return alarmNode;
-    }
-
-    private get $8() {
-        return this as unknown as UALimitAlarmEx;
-    }
-
-    public getHighHighLimit(): number {
-        if (!this.$8.highHighLimit) {
-            throw new Error("Alarm do not expose highHighLimit");
-        }
-        return this.$8.highHighLimit.readValue().value.value;
-    }
-
-    public getHighLimit(): number {
-        if (!this.$8.highLimit) {
-            throw new Error("Alarm do not expose highLimit");
-        }
-        return this.$8.highLimit.readValue().value.value;
-    }
-
-    public getLowLimit(): number {
-        if (!this.$8.lowLimit) {
-            throw new Error("Alarm do not expose lowLimit");
-        }
-        return this.$8.lowLimit.readValue().value.value;
-    }
-
-    public getLowLowLimit(): number {
-        if (!this.$8.lowLowLimit) {
-            throw new Error("Alarm do not expose lowLowLimit");
-        }
-        return this.$8.lowLowLimit.readValue().value.value;
-    }
-
-    public setHighHighLimit(value: number): void {
-        if (!this.$8.highHighLimit) {
-            throw new Error("LimitAlarm instance must expose the optional HighHighLimit property");
-        }
-        this.$8.highHighLimit.setValueFromSource({ dataType: DataType.Double, value });
-    }
-
-    public setHighLimit(value: number): void {
-        if (!this.$8.highLimit) {
-            throw new Error("LimitAlarm instance must expose the optional HighLimit property");
-        }
-        this.$8.highLimit.setValueFromSource({ dataType: DataType.Double, value });
-    }
-
-    public setLowLimit(value: number): void {
-        if (!this.$8.lowLimit) {
-            throw new Error("LimitAlarm instance must expose the optional LowLimit property");
-        }
-        this.$8.lowLimit.setValueFromSource({ dataType: DataType.Double, value });
-    }
-    public setLowLowLimit(value: number): void {
-        if (!this.$8.lowLowLimit) {
-            throw new Error("LimitAlarm instance must expose the optional LowLowLimit property");
-        }
-        this.$8.lowLowLimit.setValueFromSource({ dataType: DataType.Double, value });
-    }
-
-    protected _onInputDataValueChange(dataValue: DataValue): void {
-        assert(dataValue instanceof DataValue);
-
-        if (dataValue.statusCode.equals(StatusCodes.BadWaitingForInitialData)) {
-            // we are not ready yet to use the input node value
-            return;
-        }
-        if (dataValue.statusCode.isNotGood() && !dataValue.statusCode.equals(StatusCodes.UncertainInitialValue)) {
-            // genuinely bad status (not the initial uncertain state) → no specific limit state, alarm inactive
-            this._signalNewCondition(null, false, "Input node value is not good");
-            return;
-        }
-        if (dataValue.value.dataType === DataType.Null) {
-            // input not yet set → no specific limit state, alarm inactive
-            this._signalNewCondition(null, false, "Input node value is null");
-            return;
-        }
-        const value = dataValue.value.value;
-        this._setStateBasedOnInputValue(value);
-    }
-
-    protected _setStateBasedOnInputValue(_value: number): void {
-        throw new Error("_setStateBasedOnInputValue must be overriden");
-    }
-
-    protected _watchLimits(): void {
-        /// ----------------------------------------------------------------------
-        /// Installing Limits monitored
-        const _updateState = () => this.updateState();
-
-        if (this.$8.highHighLimit) {
-            this.$8.highHighLimit.on("value_changed", _updateState);
-        }
-        if (this.$8.highLimit) {
-            this.$8.highLimit.on("value_changed", _updateState);
-        }
-        if (this.$8.lowLimit) {
-            this.$8.lowLimit.on("value_changed", _updateState);
-        }
-        if (this.$8.lowLowLimit) {
-            this.$8.lowLowLimit.on("value_changed", _updateState);
-        }
-    }
-
-    protected evaluateConditionsAfterEnabled(): void {
-        assert(this.getEnabledState() === true);
-        // simulate input value event
-        const input = this.getInputNodeNode();
-        if (!input) {
-            return;
-        }
-        const dataValue = input.readValue();
-        this._onInputDataValueChange(dataValue);
-    }
-}
-
-export const UALimitAlarmImpl = UALimitAlarmImplBase as unknown as new () => UALimitAlarmImpl;
-export type UALimitAlarmImpl = UALimitAlarmImplBase & UALimitAlarmEx;

package/src/alarms_and_conditions/ua_non_exclusive_deviation_alarm_impl.ts

@@ -1,88 +0,0 @@
-/**
- * @module node-opcua-address-space.AlarmsAndConditions
- */
-
-import type { UAVariableT } from "node-opcua-address-space-base";
-import { assert } from "node-opcua-assert";
-import type { DataValue } from "node-opcua-data-value";
-import type { NodeId } from "node-opcua-nodeid";
-import type { DataType, VariantOptions } from "node-opcua-variant";
-import type { InstallSetPointOptions } from "../../source/interfaces/alarms_and_conditions/install_setpoint_options";
-import type { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
-import type { UANonExclusiveDeviationAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_non_exclusive_deviation_alarm_ex";
-import type { NamespacePrivate } from "../namespace_private";
-import {
-    DeviationAlarmHelper_getSetpointNodeNode,
-    DeviationAlarmHelper_getSetpointValue,
-    DeviationAlarmHelper_install_setpoint,
-    DeviationAlarmHelper_onSetpointDataValueChange
-} from "./deviation_alarm_helper";
-import { UALimitAlarmImpl } from "./ua_limit_alarm_impl";
-import { UANonExclusiveLimitAlarmImpl, UANonExclusiveLimitAlarmImplBase } from "./ua_non_exclusive_limit_alarm_impl";
-
-export class UANonExclusiveDeviationAlarmImplBase extends UANonExclusiveLimitAlarmImplBase {
-    public static instantiate(
-        namespace: NamespacePrivate,
-        type: string | NodeId,
-        options: InstantiateLimitAlarmOptions & InstallSetPointOptions,
-        data?: Record<string, VariantOptions>
-    ): UANonExclusiveDeviationAlarmImpl {
-        const addressSpace = namespace.addressSpace;
-
-        const nonExclusiveDeviationAlarmType = addressSpace.findEventType("NonExclusiveDeviationAlarmType");
-        /* c8 ignore next */
-        if (!nonExclusiveDeviationAlarmType) {
-            throw new Error("cannot find ExclusiveDeviationAlarmType");
-        }
-        assert(type === nonExclusiveDeviationAlarmType.browseName.toString());
-
-        const alarm = UANonExclusiveLimitAlarmImplBase.instantiate(
-            namespace,
-            type,
-            options,
-            data
-        ) as UANonExclusiveDeviationAlarmImpl;
-        Object.setPrototypeOf(alarm, UANonExclusiveDeviationAlarmImpl.prototype);
-
-        assert(alarm instanceof UANonExclusiveDeviationAlarmImpl);
-        assert(alarm instanceof UANonExclusiveLimitAlarmImpl);
-        assert(alarm instanceof UALimitAlarmImpl);
-
-        alarm._install_setpoint(options);
-
-        return alarm;
-    }
-
-    private get $13() {
-        return this as unknown as UANonExclusiveDeviationAlarmEx;
-    }
-    public _setStateBasedOnInputValue(value: number): void {
-        const setpointValue = this.getSetpointValue();
-        if (setpointValue === null) {
-            throw new Error("Cannot access setpoint Value");
-        }
-        assert(Number.isFinite(setpointValue), "expecting a valid setpoint value");
-        // call base class implementation
-        super._setStateBasedOnInputValue(value - setpointValue);
-    }
-
-    public getSetpointNodeNode(): UAVariableT<number, DataType.Double> | UAVariableT<number, DataType.Float> | undefined {
-        return DeviationAlarmHelper_getSetpointNodeNode.call(this.$13);
-    }
-
-    public getSetpointValue(): number | null {
-        return DeviationAlarmHelper_getSetpointValue.call(this.$13);
-    }
-
-    public _onSetpointDataValueChange(dataValue: DataValue): void {
-        DeviationAlarmHelper_onSetpointDataValueChange.call(this.$13, dataValue);
-    }
-
-    public _install_setpoint(options: InstallSetPointOptions): void {
-        DeviationAlarmHelper_install_setpoint.call(this.$13, options);
-    }
-}
-
-export type UANonExclusiveDeviationAlarmImpl = UANonExclusiveDeviationAlarmImplBase & UANonExclusiveDeviationAlarmEx;
-export const UANonExclusiveDeviationAlarmImpl =
-    UANonExclusiveDeviationAlarmImplBase as unknown as new () => UANonExclusiveDeviationAlarmImpl;