node-opcua-address-space 2.180.0 → 2.181.1

package/impl/data_access/ua_multistate_value_discrete_impl.ts

@@ -0,0 +1,384 @@
+import type {
+    BindVariableOptions,
+    CloneExtraInfo,
+    CloneFilter,
+    CloneOptions,
+    INamespace,
+    UAProperty,
+    UAVariable
+} from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import {
+    coerceInt32,
+    coerceInt64toInt32,
+    coerceUInt64,
+    coerceUInt64toInt32,
+    type Int32,
+    type Int64,
+    isValidInt64,
+    isValidUInt64,
+    type UInt64
+} from "node-opcua-basic-types";
+import { VariableTypeIds } from "node-opcua-constants";
+import { coerceLocalizedText, type LocalizedText } from "node-opcua-data-model";
+import type { DataValue } from "node-opcua-data-value";
+import type { DTEnumValue } from "node-opcua-nodeset-ua";
+import { type StatusCode, StatusCodes } from "node-opcua-status-code";
+import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
+import type { AddMultiStateValueDiscreteOptions } from "../../api/address_space_ts.js";
+import { coerceEnumValues } from "../../api/helpers/coerce_enum_value.js";
+import type { UAMultiStateValueDiscreteEx } from "../../api/interfaces/data_access/ua_multistate_value_discrete_ex.js";
+import type { ISetStateOptions } from "../../api/interfaces/i_set_state_options.js";
+import { registerNodePromoter } from "../../api/loader/register_node_promoter.js";
+import { _getBasicDataTypeFromDataTypeNodeId } from "../get_basic_datatype.js";
+import { UAVariableImpl } from "../ua_variable_impl.js";
+import { add_dataItem_stuff } from "./add_dataItem_stuff.js";
+
+function convertToArray<T>(array: ArrayLike<T> | T[]): T[] {
+    if (Array.isArray(array)) return array;
+    const result: T[] = [];
+    for (let i = 0; i < array.length; i++) {
+        result[i] = array[i];
+    }
+    return result;
+}
+const getCoerceToInt32 = (dataType: DataType) => {
+    switch (dataType) {
+        case DataType.UInt64:
+            return coerceUInt64toInt32;
+        case DataType.Int64:
+            return coerceInt64toInt32;
+        default:
+            return coerceInt32;
+    }
+};
+
+type Number = number | Int64 | UInt64;
+
+function install_synchronization<T extends Number, DT extends DataType>(
+    _variable: UAVariableImpl & UAMultiStateValueDiscreteEx<T, DT>
+) {
+    _variable.on("value_changed", (dataValue: DataValue) => {
+        const valueAsTextNode = _variable.valueAsText || (_variable.getComponentByName("ValueAsText") as UAVariable);
+        if (!valueAsTextNode) {
+            return;
+        }
+        if (dataValue.value.arrayType === VariantArrayType.Array || dataValue.value.arrayType === VariantArrayType.Matrix) {
+            //
+            const _coerce = getCoerceToInt32(_variable.getBasicDataType());
+
+            const values: number[] = convertToArray<Int32>(dataValue.value.value).map((a) => coerceInt32(a));
+            const variantArray: Variant[] = values.map((a) => _variable.findValueAsText(a));
+            const localizedText = variantArray.map((a) => a.value);
+
+            const valueAsText1 = new Variant({
+                arrayType: dataValue.value.arrayType,
+                dataType: DataType.LocalizedText,
+                value: localizedText,
+                dimensions: dataValue.value.dimensions
+            });
+            valueAsTextNode.setValueFromSource(valueAsText1);
+        } else {
+            const valueAsText1 = _variable.findValueAsText(dataValue.value.value);
+            valueAsTextNode.setValueFromSource(valueAsText1);
+        }
+    });
+    const dataValue = _variable.readValue();
+    // detect value changes to update valueAsText  (initial state)
+    _variable.emit("value_changed", dataValue);
+}
+
+/** @internal */
+export class UAMultiStateValueDiscreteImplBase<T extends Number, DT extends DataType> extends UAVariableImpl {
+    /**
+     * Properties installed as child nodes by the address space rather than assigned by this
+     * constructor - hence `declare`, which emits nothing.
+     */
+    declare public readonly enumValues: UAProperty<DTEnumValue[], DataType.ExtensionObject>;
+    declare public readonly valueAsText: UAProperty<LocalizedText, DataType.LocalizedText>;
+    public setValue(value: string | number | Int64, options?: ISetStateOptions): void {
+        if (typeof value === "string") {
+            const enumValues = this.enumValues.readValue().value.value;
+            const selected = enumValues.filter((a) => a.displayName.text === value)[0];
+            if (selected) {
+                this._setValue(selected.value);
+            } else {
+                throw new Error(`cannot find enum string ${value} in ${enumValues.toString()}`);
+            }
+        } else {
+            this._setValue(coerceUInt64(value), options);
+        }
+    }
+
+    public getValueAsString(): string | string[] {
+        const v = this.valueAsText.readValue().value.value;
+        if (Array.isArray(v)) {
+            return v.map((a) => a.text);
+        }
+        return v.text || "";
+    }
+
+    public getValueAsNumber(): number {
+        return this.readValue().value.value;
+    }
+
+    public checkVariantCompatibility(value: Variant): StatusCode {
+        if (this.enumValues) {
+            if (!this._isValueInRange(coerceInt32(value.value))) {
+                return StatusCodes.BadOutOfRange;
+            }
+        }
+        return StatusCodes.Good;
+    }
+
+    public clone(
+        options1: CloneOptions,
+        optionalFilter?: CloneFilter,
+        extraInfo?: CloneExtraInfo
+    ): UAMultiStateValueDiscreteImpl<T, DT> {
+        const variable1 = UAVariableImpl.prototype.clone.call(this, options1, optionalFilter, extraInfo);
+        return promoteToMultiStateValueDiscrete(variable1);
+    }
+
+    /**
+     * @private
+     */
+    public _isValueInRange(value: number): boolean {
+        // MultiStateValueDiscreteType
+        const enumValues = this.enumValues.readValue().value.value as DTEnumValue[];
+        const e = enumValues.findIndex((x: DTEnumValue) => coerceInt64toInt32(x.value) === value);
+        return !(e === -1);
+    }
+    /**
+     *
+     * @private
+     */
+    public _enumValueIndex(): Record<Int32, DTEnumValue> {
+        // construct an index to quickly find a EnumValue from a value
+        const enumValues: DTEnumValue[] = this.enumValues.readValue().value.value;
+        const enumValueIndex: Record<Int32, DTEnumValue> = Object.create(null);
+        if (!enumValues?.forEach) {
+            return enumValueIndex;
+        }
+        enumValues.forEach((e: DTEnumValue) => {
+            const index = coerceInt64toInt32(e.value);
+            enumValueIndex[index] = e;
+        });
+        return enumValueIndex;
+    }
+
+    /**
+     *
+     * @private
+     */
+    public _setValue(value: Int64, _options?: ISetStateOptions): void {
+        const int32Value = coerceInt64toInt32(value);
+        // check that value is in bound
+        if (!this._isValueInRange(int32Value)) {
+            throw new Error(`UAMultiStateValueDiscrete#_setValue out of range ${value}`);
+        }
+
+        const dataType = this._getDataType();
+        if (dataType === DataType.Int64 || dataType === DataType.UInt64) {
+            this.setValueFromSource({ dataType, arrayType: VariantArrayType.Scalar, value });
+        } else {
+            this.setValueFromSource({ dataType, arrayType: VariantArrayType.Scalar, value: int32Value });
+        }
+    }
+
+    /**
+     *
+     * @private
+     */
+    public findValueAsText(value?: number | Int64): Variant {
+        const enumValueIndex = this._enumValueIndex();
+        if (value === undefined) {
+            throw new Error("Unexpected undefined value");
+        }
+        const valueAsInt32 = coerceInt64toInt32(value);
+
+        let valueAsText1 = "Invalid";
+        if (enumValueIndex[valueAsInt32] !== undefined) {
+            valueAsText1 = enumValueIndex[valueAsInt32].displayName.text || `Invalid:${value}`;
+        }
+        const result = new Variant({
+            dataType: DataType.LocalizedText,
+            value: coerceLocalizedText(valueAsText1)
+        });
+        return result;
+    }
+
+    public _getDataType(): DataType {
+        if (this.dataType.value === 26 /* Number */) {
+            return DataType.UInt32;
+        }
+        const dataTypeStr = DataType[this.dataType.value as number] as string;
+        return DataType[dataTypeStr as keyof typeof DataType];
+    }
+
+    /**
+     *
+     * @private
+     */
+    public _post_initialize(): void {
+        // MultiStateValueDiscrete Variables can have any numeric Data Type;
+        // this includes signed and unsigned integers from 8 to 64 Bit length.
+
+        // c8 ignore next
+        validateIsNumericDataType(this.dataType.value);
+
+        // find the enum value type
+        install_synchronization(this as unknown as UAVariableImpl & UAMultiStateValueDiscreteEx<T, DT>);
+    }
+}
+// This intersection stays, unlike the one MultiStateDiscrete used to have. One class serves
+// two published interfaces: UAMultiStateValueDiscreteEx for a scalar node and
+// UAMultiStateValueDiscreteArrayEx for an array one, and they disagree on purpose -
+// getValueAsString returns a string for one and a string[] for the other, which is why the
+// class returns the union and neither interface alone describes it. Declaring `implements`
+// on either would be a false claim about the other half.
+/** @internal */
+export type UAMultiStateValueDiscreteImpl<T extends Number, DT extends DataType> = UAMultiStateValueDiscreteImplBase<T, DT> &
+    UAMultiStateValueDiscreteEx<T, DT>;
+/** @internal */
+// check-construction-cast: ok - serves both the scalar and the array interface, see above
+export const UAMultiStateValueDiscreteImpl = UAMultiStateValueDiscreteImplBase as unknown as new <
+    T extends Number,
+    DT extends DataType
+>() => UAMultiStateValueDiscreteImpl<T, DT>;
+
+export function promoteToMultiStateValueDiscrete<T extends Number, DT extends DataType>(
+    node: UAVariable
+): UAMultiStateValueDiscreteImpl<T, DT> {
+    if (node instanceof UAMultiStateValueDiscreteImpl) {
+        return node; // already promoted
+    }
+    Object.setPrototypeOf(node, UAMultiStateValueDiscreteImpl.prototype);
+    assert(node instanceof UAMultiStateValueDiscreteImpl, "should now  be a State Machine");
+    (node as UAMultiStateValueDiscreteImpl<T, DT>)._post_initialize();
+    return node as UAMultiStateValueDiscreteImpl<T, DT>;
+}
+
+registerNodePromoter(VariableTypeIds.MultiStateValueDiscreteType, promoteToMultiStateValueDiscrete);
+
+/** @internal */
+export function _addMultiStateValueDiscrete<T, DT extends DataType>(
+    namespace: INamespace,
+    options: AddMultiStateValueDiscreteOptions
+): UAMultiStateValueDiscreteEx<T, DT> {
+    assert(Object.hasOwn(options, "enumValues"));
+    assert(!Object.hasOwn(options, "ValuePrecision"));
+
+    const addressSpace = namespace.addressSpace;
+
+    const multiStateValueDiscreteType = addressSpace.findVariableType("MultiStateValueDiscreteType");
+    if (!multiStateValueDiscreteType) {
+        throw new Error("expecting MultiStateValueDiscreteType to be defined , check nodeset xml file");
+    }
+
+    // todo : if options.typeDefinition is specified, check that type is SubTypeOf MultiStateDiscreteType
+
+    // EnumValueType
+    //   value: Int64, displayName: LocalizedText, Description: LocalizedText
+    const enumValues = coerceEnumValues(options.enumValues);
+
+    if (options.value === undefined && enumValues[0]) {
+        options.value = enumValues[0].value; // Int64
+    }
+    // Only DataTypes that can be represented with EnumValues are allowed for Variables of MultiStateValueDiscreteType.
+    // These are Integers up to 64 Bits (signed and unsigned).:
+
+    const dataType: DataType = _getBasicDataTypeFromDataTypeNodeId(addressSpace, options.dataType || DataType.UInt32);
+
+    let value: undefined | BindVariableOptions;
+    if (
+        typeof options.value === "number" ||
+        isValidUInt64(options.value as number | number[]) ||
+        isValidInt64(options.value as number | number[])
+    ) {
+        value = new Variant({
+            dataType,
+            value: options.value
+        });
+    } else {
+        value = options.value as BindVariableOptions;
+    }
+
+    const cloned_options = {
+        ...options,
+        dataType,
+        typeDefinition: multiStateValueDiscreteType.nodeId,
+        // valueRank:
+        // note : OPCUA Spec 1.03 specifies -1:Scalar (part 8 page 8) but nodeset file specifies -2:Any
+        value,
+        // limitation:  although the Specs specify -2:any, we only support -1(Scalar)
+        valueRank: -1 // -1 : Scalar
+    };
+
+    const variable = namespace.addVariable(cloned_options) as UAMultiStateValueDiscreteEx<T, DT>;
+
+    add_dataItem_stuff(variable, options);
+
+    namespace.addVariable({
+        accessLevel: "CurrentRead",
+        browseName: { name: "EnumValues", namespaceIndex: 0 },
+        dataType: "EnumValueType",
+        valueRank: 1,
+        minimumSamplingInterval: 0,
+        modellingRule: options.modellingRule ? "Mandatory" : undefined,
+        propertyOf: variable,
+        typeDefinition: "PropertyType",
+        userAccessLevel: "CurrentRead",
+        value: new Variant({
+            arrayType: VariantArrayType.Array,
+            dataType: DataType.ExtensionObject,
+            value: enumValues
+        })
+    });
+
+    namespace.addVariable({
+        accessLevel: "CurrentRead",
+        browseName: { name: "ValueAsText", namespaceIndex: 0 },
+        dataType: DataType.LocalizedText,
+        minimumSamplingInterval: 0,
+        modellingRule: options.modellingRule ? "Mandatory" : undefined,
+        propertyOf: variable,
+        arrayDimensions: options.arrayDimensions,
+        valueRank: options.valueRank,
+        typeDefinition: "PropertyType",
+        userAccessLevel: "CurrentRead"
+        // value: valueAsText
+    });
+
+    // install additional helpers methods
+    variable.install_extra_properties();
+
+    promoteToMultiStateValueDiscrete(variable);
+
+    assert(variable.enumValues.browseName.toString() === "EnumValues");
+    assert(variable.valueAsText.browseName.toString() === "ValueAsText");
+    return variable;
+}
+
+const validBasicNumericDataTypes = [
+    DataType.UInt64,
+    DataType.Int64,
+    DataType.UInt32,
+    DataType.Int32,
+    DataType.UInt16,
+    DataType.Int16,
+    DataType.Byte,
+    DataType.Byte,
+    DataType.SByte,
+    26 /* Number  (abstract)*/,
+    27 /* Integer  (abstract)*/,
+    28 /* UInteger (abstract)*/
+];
+export function validateIsNumericDataType(dataTypeValue: unknown): void {
+    if (typeof dataTypeValue !== "number" || validBasicNumericDataTypes.indexOf(dataTypeValue) < 0) {
+        throw new Error(`Invalid DataType in UAMultiStateValueDiscrete => ${dataTypeValue}`);
+    }
+}
+
+/** @deprecated: use validateIsNumericDataType instead */
+export const validateDataType = validateIsNumericDataType;

package/impl/data_access/ua_two_state_discrete_impl.ts

@@ -0,0 +1,195 @@
+import type {
+    BindVariableOptions,
+    CloneExtraInfo,
+    CloneFilter,
+    CloneOptions,
+    INamespace,
+    UAProperty,
+    UAVariable
+} from "node-opcua-address-space-base";
+import assert from "node-opcua-assert";
+import { VariableTypeIds } from "node-opcua-constants";
+import { coerceLocalizedText, type LocalizedText, type LocalizedTextLike } from "node-opcua-data-model";
+import { DataType, Variant } from "node-opcua-variant";
+import type { AddTwoStateDiscreteOptions } from "../../api/address_space_ts.js";
+import type { UATwoStateDiscreteEx } from "../../api/interfaces/data_access/ua_two_state_discrete_ex.js";
+import type { ISetStateOptions } from "../../api/interfaces/i_set_state_options.js";
+import { registerNodePromoter } from "../../api/loader/register_node_promoter.js";
+import { UAVariableImpl, UAVariableImplT } from "../ua_variable_impl.js";
+import { add_dataItem_stuff } from "./add_dataItem_stuff.js";
+
+/** @internal */
+export class UATwoStateDiscreteImplBase extends UAVariableImplT<boolean, DataType.Boolean> implements UATwoStateDiscreteEx {
+    /**
+     * Properties installed as child nodes by the address space rather than assigned by this
+     * constructor - hence `declare`, which emits nothing.
+     */
+    declare public readonly falseState: UAProperty<LocalizedText, DataType.LocalizedText>;
+    declare public readonly trueState: UAProperty<LocalizedText, DataType.LocalizedText>;
+    /*
+     * @private
+     */
+    _post_initialize(): void {
+        // The StatusCode SemanticsChanged bit shall be set if any of the FalseState or TrueState
+        // (changes can cause misinterpretation by users or (scripting) programs) Properties are changed
+        // (see section 5.2 for additional information).
+        const handler = this.handle_semantic_changed.bind(this);
+
+        const falseState = this.getPropertyByName("FalseState");
+        if (falseState) {
+            falseState.on("value_changed", handler);
+        } else {
+            /* c8 ignore next */
+            console.warn(
+                "warning: UATwoStateDiscrete -> a FalseState property is mandatory ",
+                this.browseName.toString(),
+                this.nodeId.toString()
+            );
+        }
+        const trueState = this.getPropertyByName("TrueState");
+        if (trueState) {
+            trueState.on("value_changed", handler);
+        } else {
+            /* c8 ignore next */
+            console.warn(
+                "waring: UATwoStateDiscrete -> a TrueState property is mandatory",
+                this.browseName.toString(),
+                this.nodeId.toString()
+            );
+        }
+    }
+    setValue(value: boolean | LocalizedTextLike, options?: ISetStateOptions): void {
+        if (typeof value === "boolean") {
+            this.setValueFromSource({ dataType: DataType.Boolean, value });
+        } else {
+            const text: string = (typeof value === "string" ? value : value.text) || "";
+            if (text === this.getTrueStateAsString()) {
+                this.setValue(true, options);
+            } else if (text === this.getFalseStateAsString()) {
+                this.setValue(false, options);
+            } else {
+                throw new Error(`setValue invalid value ${value}`);
+            }
+        }
+    }
+    getValue(): boolean {
+        return this.readValue().value.value as boolean;
+    }
+    getValueAsString(): string {
+        if (this.getValue()) {
+            return this.getTrueStateAsString();
+        } else {
+            return this.getFalseStateAsString();
+        }
+    }
+    getTrueStateAsString(): string {
+        return (this.trueState.readValue().value.value as LocalizedText).text || "";
+    }
+    getFalseStateAsString(): string {
+        return (this.falseState.readValue().value.value as LocalizedText).text || "";
+    }
+
+    public clone(options1: CloneOptions, optionalFilter?: CloneFilter, extraInfo?: CloneExtraInfo): UAVariable {
+        const variable1 = UAVariableImpl.prototype.clone.call(this, options1, optionalFilter, extraInfo);
+        promoteToTwoStateDiscrete(variable1);
+        return variable1;
+    }
+}
+// The class states that it implements the published interface, so the name is just the
+// class, and promoteToTwoStateDiscrete can return it without converting.
+/** @internal */
+export type UATwoStateDiscreteImpl = UATwoStateDiscreteImplBase;
+/** @internal */
+export const UATwoStateDiscreteImpl = UATwoStateDiscreteImplBase;
+
+export function promoteToTwoStateDiscrete(node: UAVariable): UATwoStateDiscreteEx {
+    if (node instanceof UATwoStateDiscreteImpl) {
+        return node; // already promoted
+    }
+    Object.setPrototypeOf(node, UATwoStateDiscreteImpl.prototype);
+    assert(node instanceof UATwoStateDiscreteImpl, "should now  be a UATwoStateDiscrete");
+    const _node = node as UATwoStateDiscreteImpl;
+    _node._post_initialize();
+    return _node;
+}
+registerNodePromoter(VariableTypeIds.TwoStateDiscreteType, promoteToTwoStateDiscrete);
+
+/** @internal */
+export function _addTwoStateDiscrete(namespace: INamespace, options: AddTwoStateDiscreteOptions): UATwoStateDiscreteEx {
+    const addressSpace = namespace.addressSpace;
+
+    assert(!Object.hasOwn(options, "ValuePrecision"));
+
+    const twoStateDiscreteType = addressSpace.findVariableType("TwoStateDiscreteType");
+    if (!twoStateDiscreteType) {
+        throw new Error("expecting TwoStateDiscreteType to be defined , check nodeset xml file");
+    }
+
+    let value: undefined | BindVariableOptions;
+    if (typeof options.value === "boolean") {
+        value = new Variant({ dataType: DataType.Boolean, value: !!options.value });
+    } else {
+        value = options.value;
+    }
+    // todo : if options.typeDefinition is specified,
+    // todo : refactor to use twoStateDiscreteType.instantiate
+
+    const variable = namespace.addVariable({
+        accessLevel: options.accessLevel,
+        browseName: options.browseName,
+        displayName: options.displayName,
+        componentOf: options.componentOf,
+        propertyOf: options.propertyOf,
+        organizedBy: options.organizedBy,
+        dataType: DataType.Boolean,
+        nodeId: options.nodeId,
+        typeDefinition: twoStateDiscreteType.nodeId,
+        userAccessLevel: options.userAccessLevel,
+        modellingRule: options.modellingRule,
+        minimumSamplingInterval: options.minimumSamplingInterval,
+        value
+    }) as UAVariable;
+
+    /*
+    const dataValueVerif = variable.readValue();
+    assert(dataValueVerif.value.dataType === DataType.Boolean);
+    */
+    const handler = (variable as UAVariableImpl).handle_semantic_changed.bind(variable);
+
+    add_dataItem_stuff(variable, options);
+
+    const trueStateNode = namespace.addVariable({
+        browseName: { name: "TrueState", namespaceIndex: 0 },
+        dataType: "LocalizedText",
+        minimumSamplingInterval: 0,
+        propertyOf: variable,
+        typeDefinition: "PropertyType",
+        modellingRule: options.modellingRule ? "Mandatory" : undefined,
+        value: new Variant({
+            dataType: DataType.LocalizedText,
+            value: coerceLocalizedText(options.trueState || "ON")
+        })
+    });
+
+    trueStateNode.on("value_changed", handler);
+
+    const falseStateNode = namespace.addVariable({
+        browseName: { name: "FalseState", namespaceIndex: 0 },
+        dataType: "LocalizedText",
+        minimumSamplingInterval: 0,
+        propertyOf: variable,
+        typeDefinition: "PropertyType",
+        modellingRule: options.modellingRule ? "Mandatory" : undefined,
+
+        value: new Variant({
+            dataType: DataType.LocalizedText,
+            value: coerceLocalizedText(options.falseState || "OFF")
+        })
+    });
+
+    falseStateNode.on("value_changed", handler);
+
+    variable.install_extra_properties();
+
+    return promoteToTwoStateDiscrete(variable);
+}

package/impl/event_data.ts

@@ -0,0 +1,80 @@
+/**
+ * @module node-opcua-address-space.Private
+ */
+
+import type { BaseNode, IEventData } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import { coerceExpandedNodeId, NodeId, sameNodeId } from "node-opcua-nodeid";
+import { StatusCodes } from "node-opcua-status-code";
+import { type BrowsePath, BrowsePathResult } from "node-opcua-types";
+import { lowerFirstLetter } from "node-opcua-utils";
+import { Variant, type VariantLike } from "node-opcua-variant";
+import type { EventField } from "./event_layout.js";
+
+type NodeIdString = string;
+type FullBrowsePath = string;
+
+/**
+ */
+export class EventData implements IEventData {
+    public eventId: NodeId;
+    #eventDataSource: BaseNode;
+    #values = new Map<NodeIdString, Variant>();
+    #pathToNodeId: Map<FullBrowsePath, NodeId>;
+    /** the path map belongs to the event layout and is already complete */
+    #sharedPaths: boolean;
+
+    /**
+     * @param pathToNodeId the browse-path index of the event layout, shared by every event of the type;
+     *   an event built field by field (a condition snapshot) keeps an index of its own
+     */
+    constructor(eventTypeNode: BaseNode, pathToNodeId?: Map<FullBrowsePath, NodeId>) {
+        this.eventId = new NodeId();
+        this.#eventDataSource = eventTypeNode;
+        this.#sharedPaths = pathToNodeId !== undefined;
+        this.#pathToNodeId = pathToNodeId ?? new Map<FullBrowsePath, NodeId>();
+    }
+
+    public getEventDataSource(): BaseNode {
+        return this.#eventDataSource;
+    }
+
+    public _createValue(fullBrowsePath: string, node: BaseNode, variant: VariantLike): void {
+        const eventData = this as Record<string, unknown>;
+        assert(!eventData[fullBrowsePath], `already exists ${fullBrowsePath}`);
+        const lowerName = fullBrowsePath.split(".").map(lowerFirstLetter).join(".");
+        this._setField({ lowerName, fullBrowsePath, node, nodeIdKey: node.nodeId.toString(), mandatory: false }, variant);
+    }
+
+    /** the value of one field of the layout */
+    public _setField(field: EventField, variant: VariantLike): void {
+        const value = Variant.coerce(variant);
+        (this as Record<string, unknown>)[field.lowerName] = value;
+        if (!this.#sharedPaths) {
+            this.#pathToNodeId.set(field.fullBrowsePath, field.node.nodeId);
+        }
+        this.#values.set(field.nodeIdKey, value);
+    }
+
+    public _browse(browsePath: BrowsePath): BrowsePathResult | null {
+        if (!sameNodeId(browsePath.startingNode, this.#eventDataSource.nodeId)) {
+            return null;
+        }
+        const fullBrowsePath = (browsePath.relativePath.elements || []).map((b) => b.targetName.toString()).join(".");
+        const nodeId = this.#pathToNodeId.get(fullBrowsePath);
+        if (!nodeId) return null;
+        return new BrowsePathResult({
+            statusCode: StatusCodes.Good,
+            targets: [
+                {
+                    remainingPathIndex: 0,
+                    targetId: coerceExpandedNodeId(nodeId)
+                }
+            ]
+        });
+    }
+
+    public _readValue(nodeId: NodeId): Variant | null {
+        return this.#values.get(nodeId.toString()) ?? null;
+    }
+}