node-opcua-address-space 2.180.0 → 2.181.0

package/src/data_access/ua_two_state_discrete_impl.ts

@@ -1,184 +0,0 @@
-import type {
-    BindVariableOptions,
-    CloneExtraInfo,
-    CloneFilter,
-    CloneOptions,
-    INamespace,
-    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 "../../source/address_space_ts";
-import type { UATwoStateDiscreteEx } from "../../source/interfaces/data_access/ua_two_state_discrete_ex";
-import type { ISetStateOptions } from "../../source/interfaces/i_set_state_options";
-import { registerNodePromoter } from "../../source/loader/register_node_promoter";
-import { UAVariableImpl } from "../ua_variable_impl";
-import { add_dataItem_stuff } from "./add_dataItem_stuff";
-
-export class UATwoStateDiscreteImplBase extends UAVariableImpl {
-    private get $5(): UATwoStateDiscreteEx {
-        return this as unknown as UATwoStateDiscreteEx;
-    }
-    /*
-     * @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.$5.trueState.readValue().value.value as LocalizedText).text || "";
-    }
-    getFalseStateAsString(): string {
-        return (this.$5.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;
-    }
-}
-export type UATwoStateDiscreteImpl = UATwoStateDiscreteImplBase & UATwoStateDiscreteEx;
-export const UATwoStateDiscreteImpl = UATwoStateDiscreteImplBase as unknown as new () => UATwoStateDiscreteImpl;
-
-export function promoteToTwoStateDiscrete(node: UAVariable): UATwoStateDiscreteEx {
-    if (node instanceof UATwoStateDiscreteImpl) {
-        return node as unknown as UATwoStateDiscreteEx; // 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 as unknown as UATwoStateDiscreteEx;
-}
-registerNodePromoter(VariableTypeIds.TwoStateDiscreteType, promoteToTwoStateDiscrete);
-
-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,
-        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/src/event_data.ts

@@ -1,83 +0,0 @@
-/**
- * @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";
-
-type NodeIdString = string;
-type FullBrowsePath = string;
-
-/**
- */
-export class EventData implements IEventData {
-    public eventId: NodeId;
-    #eventDataSource: BaseNode;
-    #cache: {
-        __values: { [key: NodeIdString]: Variant };
-        __nodeIdToNode: { [key: NodeIdString]: BaseNode };
-        __pathToNodeId: { [key: FullBrowsePath]: NodeId };
-        __nodeIdToFullPath: { [key: NodeIdString]: FullBrowsePath };
-    };
-
-    constructor(eventTypeNode: BaseNode) {
-        this.#cache = {
-            __values: {},
-            __nodeIdToNode: {},
-            __pathToNodeId: {},
-            __nodeIdToFullPath: {}
-        };
-
-        this.eventId = new NodeId();
-        this.#eventDataSource = eventTypeNode;
-    }
-
-    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(".");
-
-        eventData[lowerName] = Variant.coerce(variant);
-
-        this.#cache.__pathToNodeId[fullBrowsePath] = node.nodeId;
-        this.#cache.__nodeIdToNode[node.nodeId.toString()] = node;
-        this.#cache.__nodeIdToFullPath[node.nodeId.toString()] = fullBrowsePath;
-        this.#cache.__values[node.nodeId.toString()] = eventData[lowerName] as Variant;
-    }
-
-    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.#cache.__pathToNodeId[fullBrowsePath];
-        if (!nodeId) return null;
-        return new BrowsePathResult({
-            statusCode: StatusCodes.Good,
-            targets: [
-                {
-                    remainingPathIndex: 0,
-                    targetId: coerceExpandedNodeId(nodeId)
-                }
-            ]
-        });
-    }
-
-    public _readValue(nodeId: NodeId): Variant | null {
-        const key = nodeId.toString();
-        const cached_value = this.#cache.__values[key];
-        if (cached_value) {
-            return cached_value;
-        }
-        return null;
-    }
-}

package/src/extension_object_array_node.ts

@@ -1,331 +0,0 @@
-/**
- * @module node-opcua-address-space.Private
- */
-
-import type { BindVariableOptionsVariation1, UADynamicVariableArray, UAObject, UAVariable } from "node-opcua-address-space-base";
-import { assert } from "node-opcua-assert";
-import { BrowseDirection, NodeClass, type QualifiedName, type QualifiedNameLike } from "node-opcua-data-model";
-import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
-import { ExtensionObject } from "node-opcua-extension-object";
-import type { NodeId } from "node-opcua-nodeid";
-import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
-import { UAVariableImpl } from "./ua_variable_impl";
-
-const _doDebug = checkDebugFlag(__filename);
-const _debugLog = make_debugLog(__filename);
-const errorLog = make_errorLog(__filename);
-const warningLog = make_warningLog(__filename);
-
-/*
- * define a complex Variable containing a array of extension objects
- * each element of the array is also accessible as a component variable.
- *
- */
-
-function getExtObjArrayNodeValue<T extends ExtensionObject>(this: UADynamicVariableArray<T>) {
-    return new Variant({
-        arrayType: VariantArrayType.Array,
-        dataType: DataType.ExtensionObject,
-        value: this.$$extensionObjectArray
-    });
-}
-
-function removeElementByIndex<T extends ExtensionObject>(uaArrayVariableNode: UADynamicVariableArray<T>, elementIndex: number) {
-    const _array = uaArrayVariableNode.$$extensionObjectArray;
-
-    assert(typeof elementIndex === "number");
-
-    const addressSpace = uaArrayVariableNode.addressSpace;
-    const extObj = _array[elementIndex];
-    const browseName = uaArrayVariableNode.$$getElementBrowseName(extObj, elementIndex);
-
-    // remove element from global array (inefficient)
-    uaArrayVariableNode.$$extensionObjectArray.splice(elementIndex, 1);
-    if (uaArrayVariableNode.$$extensionObjectArray !== uaArrayVariableNode.$dataValue.value.value) {
-        //    throw new Error("internal error");
-    }
-    uaArrayVariableNode.touchValue();
-
-    // remove matching component
-    const node = uaArrayVariableNode.getComponentByName(browseName);
-    if (!node) {
-        throw new Error(" cannot find component ");
-    }
-
-    const hasComponent = uaArrayVariableNode.addressSpace.findReferenceType("HasComponent");
-    // c8 ignore next
-    if (!hasComponent) {
-        throw new Error("cannot find HasComponent reference type: please check your nodeset file");
-    }
-
-    // remove the hasComponent reference toward node
-    uaArrayVariableNode.removeReference({
-        isForward: true,
-        nodeId: node.nodeId,
-        referenceType: hasComponent.nodeId
-    });
-
-    // now check if node has still some parent
-    const parents = node.findReferencesEx("HasChild", BrowseDirection.Inverse);
-    if (parents.length === 0) {
-        addressSpace.deleteNode(node.nodeId);
-    }
-}
-
-export interface CreateExtObjArrayNodeOptions {
-    browseName: QualifiedNameLike;
-    complexVariableType: string | NodeId;
-    variableType: string | NodeId;
-    indexPropertyName: string;
-    minimumSamplingInterval?: number;
-}
-
-/**
- *
- * create a node Variable that contains a array of ExtensionObject of a given type
- */
-export function createExtObjArrayNode<T extends ExtensionObject>(
-    parentFolder: UAObject,
-    options: CreateExtObjArrayNodeOptions
-): UADynamicVariableArray<T> {
-    assert(typeof options.variableType === "string");
-    assert(typeof options.indexPropertyName === "string");
-
-    const addressSpace = parentFolder.addressSpace;
-    const namespace = parentFolder.namespace;
-
-    const complexVariableType = addressSpace.findVariableType(options.complexVariableType);
-    // c8 ignore next
-    if (!complexVariableType) {
-        throw new Error("cannot find complex variable type");
-    }
-    assert(!complexVariableType.nodeId.isEmpty());
-
-    const variableType = addressSpace.findVariableType(options.variableType);
-    if (!variableType) {
-        throw new Error("cannot find variable Type");
-    }
-    assert(!variableType.nodeId.isEmpty());
-
-    const structure = addressSpace.findDataType("Structure");
-    // c8 ignore next
-    if (!structure) {
-        throw new Error("Structure Type not found: please check your nodeset file");
-    }
-
-    const dataType = addressSpace.findDataType(variableType.dataType);
-
-    // c8 ignore next
-    if (!dataType) {
-        errorLog(variableType.toString());
-        throw new Error("cannot find Data Type");
-    }
-
-    assert(dataType.isSubtypeOf(structure), "expecting a structure (= ExtensionObject) here ");
-
-    const inner_options = {
-        componentOf: parentFolder,
-
-        browseName: options.browseName,
-        dataType: dataType.nodeId,
-        typeDefinition: complexVariableType.nodeId,
-        value: { dataType: DataType.ExtensionObject, value: [], arrayType: VariantArrayType.Array },
-        valueRank: 1
-    };
-
-    const uaArrayVariableNode = namespace.addVariable(inner_options) as UADynamicVariableArray<T>;
-
-    if (options.minimumSamplingInterval !== undefined) {
-        uaArrayVariableNode.minimumSamplingInterval = options.minimumSamplingInterval;
-    }
-
-    bindExtObjArrayNode(uaArrayVariableNode, options.variableType, options.indexPropertyName);
-
-    return uaArrayVariableNode;
-}
-
-function _getElementBrowseName<T extends ExtensionObject>(
-    this: UADynamicVariableArray<T>,
-    extObj: ExtensionObject,
-    _index: number | number[]
-) {
-    const indexPropertyName1 = this.$$indexPropertyName;
-
-    if (!Object.hasOwn(extObj, indexPropertyName1)) {
-        warningLog(" extension object does not have ", indexPropertyName1, extObj);
-    }
-    // assert(extObj.constructor === addressSpace.constructExtensionObject(dataType));
-    assert(Object.hasOwn(extObj, indexPropertyName1));
-    const browseName = (extObj as unknown as Record<string, { toString(): string }>)[indexPropertyName1].toString();
-    return browseName;
-}
-
-export function bindExtObjArrayNode<T extends ExtensionObject>(
-    uaArrayVariableNode: UADynamicVariableArray<T>,
-    variableTypeNodeId: string | NodeId,
-    indexPropertyName: string
-): UAVariable {
-    assert(uaArrayVariableNode.valueRank === 1, "expecting a one dimension array");
-
-    const addressSpace = uaArrayVariableNode.addressSpace;
-
-    const variableType = addressSpace.findVariableType(variableTypeNodeId);
-    // c8 ignore next
-    if (!variableType || variableType.nodeId.isEmpty()) {
-        throw new Error(`Cannot find VariableType ${variableTypeNodeId.toString()}`);
-    }
-
-    const structure = addressSpace.findDataType("Structure");
-    // c8 ignore next
-    if (!structure) {
-        throw new Error("Structure Type not found: please check your nodeset file");
-    }
-
-    let dataType = addressSpace.findDataType(variableType.dataType);
-    // c8 ignore next
-    if (!dataType) {
-        throw new Error(`Cannot find DataType ${variableType.dataType.toString()}`);
-    }
-
-    assert(dataType.isSubtypeOf(structure), "expecting a structure (= ExtensionObject) here ");
-
-    assert(!uaArrayVariableNode.$$variableType, "uaArrayVariableNode has already been bound !");
-
-    uaArrayVariableNode.$$variableType = variableType;
-
-    // verify that an object with same doesn't already exist
-    dataType = addressSpace.findDataType(variableType.dataType);
-    // c8 ignore next
-    if (!dataType) {
-        throw new Error(`Cannot find DataType ${variableType.dataType.toString()}`);
-    }
-    assert(dataType.isSubtypeOf(structure), "expecting a structure (= ExtensionObject) here ");
-    assert(!uaArrayVariableNode.$$extensionObjectArray, "UAVariable ExtensionObject array already bounded");
-    uaArrayVariableNode.$$dataType = dataType;
-    uaArrayVariableNode.$$extensionObjectArray = [];
-    uaArrayVariableNode.$$indexPropertyName = indexPropertyName;
-    // _getElementBrowseName actually returns a plain string (used opaquely via .toString() by every
-    // caller), while the base interface declares QualifiedName — cast to preserve exact prior runtime behavior.
-    uaArrayVariableNode.$$getElementBrowseName = _getElementBrowseName as unknown as (obj: T, index: number) => QualifiedName;
-    uaArrayVariableNode.$dataValue.value.value = uaArrayVariableNode.$$extensionObjectArray;
-    uaArrayVariableNode.$dataValue.value.arrayType = VariantArrayType.Array;
-
-    const bindOptions: BindVariableOptionsVariation1 = {
-        // getExtObjArrayNodeValue is generic over `this: UADynamicVariableArray<T>`, narrower than GetFunc's `this: UAVariable`
-        get: getExtObjArrayNodeValue as unknown as BindVariableOptionsVariation1["get"],
-        set: undefined // readonly
-    };
-    // bind the readonly
-    uaArrayVariableNode.bindVariable(bindOptions, true);
-    return uaArrayVariableNode;
-}
-
-/**
-
- * add a new element in a ExtensionObject Array variable
- * @param options {Object}   data used to construct the underlying ExtensionObject
- * @param uaArrayVariableNode {UAVariable}
- * @return {UAVariable}
- *
- */
-export function addElement<T extends ExtensionObject>(
-    options: UAVariableImpl | ExtensionObject | Record<string, unknown>,
-    uaArrayVariableNode: UADynamicVariableArray<T>
-): UAVariable {
-    assert(uaArrayVariableNode, " must provide an UAVariable containing the array");
-    // verify that arr has been created correctly
-    assert(
-        !!uaArrayVariableNode.$$variableType && !!uaArrayVariableNode.$$dataType,
-        "did you create the array Node with createExtObjArrayNode ?"
-    );
-    assert(uaArrayVariableNode.$$dataType.nodeClass === NodeClass.DataType);
-
-    const addressSpace = uaArrayVariableNode.addressSpace;
-    const Constructor = addressSpace.getExtensionObjectConstructor(uaArrayVariableNode.$$dataType);
-    assert(Constructor instanceof Function);
-
-    let extensionObject: T;
-    let elVar = null;
-    let browseName: QualifiedName;
-
-    if (options instanceof UAVariableImpl) {
-        elVar = options;
-        extensionObject = elVar.$extensionObject; // get shared extension object
-
-        assert(
-            extensionObject instanceof Constructor,
-            "the provided variable must expose a Extension Object of the expected type "
-        );
-        // add a reference
-        uaArrayVariableNode.addReference({
-            isForward: true,
-            nodeId: elVar.nodeId,
-            referenceType: "HasComponent"
-        });
-        // xx elVar.bindExtensionObject();
-    } else {
-        if (options instanceof ExtensionObject) {
-            // extension object has already been created
-            extensionObject = options as T;
-        } else {
-            extensionObject = addressSpace.constructExtensionObject(uaArrayVariableNode.$$dataType, options) as T;
-        }
-        const index = uaArrayVariableNode.$$extensionObjectArray?.length || 0;
-        browseName = uaArrayVariableNode.$$getElementBrowseName(extensionObject, index);
-        elVar = uaArrayVariableNode.$$variableType.instantiate({
-            browseName,
-            componentOf: uaArrayVariableNode.nodeId,
-            value: { dataType: DataType.ExtensionObject, value: extensionObject }
-        }) as UAVariableImpl;
-        elVar.bindExtensionObject(extensionObject, { force: true });
-    }
-
-    if (uaArrayVariableNode.$$extensionObjectArray !== uaArrayVariableNode.$dataValue.value.value) {
-        //    throw new Error("internal error");
-    }
-    // also add the value inside
-    uaArrayVariableNode.$$extensionObjectArray.push(elVar.$extensionObject);
-    uaArrayVariableNode.touchValue();
-
-    return elVar;
-}
-
-/**
- *
- */
-export function removeElement<T extends ExtensionObject>(
-    uaArrayVariableNode: UADynamicVariableArray<T>,
-    element: number | UAVariable | ((a: T) => boolean)
-): void {
-    assert(element, "removeElement: element must exist");
-    const _array = uaArrayVariableNode.$$extensionObjectArray;
-
-    // c8 ignore next
-    if (_array.length === 0) {
-        throw new Error(" cannot remove an element from an empty array ");
-    }
-    let elementIndex = -1;
-    if (typeof element === "number") {
-        // find element by index
-        elementIndex = element;
-        assert(elementIndex >= 0 && elementIndex < _array.length);
-    } else if (typeof element === "function") {
-        // find element by functor
-        elementIndex = _array.findIndex(element);
-    } else if (element?.nodeClass) {
-        // find element by name
-        const browseNameToFind = element.browseName.name?.toString();
-        elementIndex = _array.findIndex((obj: T, _i: number) => {
-            const browseName = uaArrayVariableNode.$$getElementBrowseName(obj, elementIndex).toString();
-            return browseName === browseNameToFind;
-        });
-    } else {
-        throw new Error("Unsupported anymore!!! please use a functor instead");
-    }
-
-    // c8 ignore next
-    if (elementIndex < 0) {
-        throw new Error(`removeElement: cannot find element matching ${element.toString()}`);
-    }
-    removeElementByIndex(uaArrayVariableNode, elementIndex);
-}