node-opcua-address-space 2.106.0 → 2.107.0

package/src/state_machine/finite_state_machine.ts

@@ -5,28 +5,41 @@ import chalk from "chalk";
 import { UAState, UAStateVariable, UATransition, UATransition_Base, UATransitionVariable } from "node-opcua-nodeset-ua";
 import { assert } from "node-opcua-assert";
 import { ObjectTypeIds } from "node-opcua-constants";
-import { coerceLocalizedText, LocalizedText, NodeClass } from "node-opcua-data-model";
+import {
+    BrowseDirection,
+    coerceLocalizedText,
+    coerceQualifiedName,
+    LocalizedText,
+    NodeClass,
+    QualifiedName
+} from "node-opcua-data-model";
 import { AttributeIds } from "node-opcua-data-model";
-import { NodeId } from "node-opcua-nodeid";
+import { make_warningLog } from "node-opcua-debug";
+import { NodeId, sameNodeId } from "node-opcua-nodeid";
 import { StatusCodes } from "node-opcua-status-code";
-import { DataType } from "node-opcua-variant";
+import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
 import { UAString } from "node-opcua-basic-types";
 import { BaseNode, UAMethod, UAObject, UAObjectType, UAVariable, UAVariableT } from "node-opcua-address-space-base";
 import { registerNodePromoter } from "../../source/loader/register_node_promoter";
 
-import { UAStateMachineEx, TransitionSelector, UAStateMachineTypeHelper } from "../../source/interfaces/state_machine/ua_state_machine_type";
+import {
+    UAStateMachineEx,
+    TransitionSelector,
+    UAStateMachineTypeHelper
+} from "../../source/interfaces/state_machine/ua_state_machine_type";
 import { UAObjectImpl } from "../ua_object_impl";
 import { UATransitionEx } from "../../source/interfaces/state_machine/ua_transition_ex";
 import { BaseNodeImpl } from "../base_node_impl";
 import { UAObjectTypeImpl } from "../ua_object_type_impl";
 
+const warningLog = make_warningLog(__filename);
+
 const doDebug = false;
 
-export declare interface UATransitionImpl extends UATransition, UATransitionEx { }
-export class UATransitionImpl implements UATransition, UATransitionEx { }
+export declare interface UATransitionImpl extends UATransition, UATransitionEx {}
+export class UATransitionImpl implements UATransition, UATransitionEx {}
 
 function getComponentOfType(typeDef: UAObjectType, typedefinition: UAObjectType): UAObject[] {
-
     const get = (typeDef: UAObjectType) =>
         typeDef.getComponents().filter((cc) => {
             const c = cc as UAObject | UAVariable | UAMethod;
@@ -45,7 +58,6 @@ function getComponentOfType(typeDef: UAObjectType, typedefinition: UAObjectType)
         components_parts = get(typeDef);
     }
     return components_parts as UAObject[];
-
 }
 
 export interface UAStateMachineImpl {
@@ -63,25 +75,18 @@ const defaultPredicate = (transitions: UATransition[], fromState: UAState, toSta
     if (transitions.length === 1) {
         return transitions[0];
     }
-    // tslint:disable-next-line: no-console
-    console.log(" FromState = ", fromState.browseName.toString());
-    // tslint:disable-next-line: no-console
-    console.log(" ToState   = ", toState.browseName.toString());
+    warningLog(" FromState = ", fromState.browseName.toString());
+    warningLog(" ToState   = ", toState.browseName.toString());
     for (const transition of transitions) {
-        // tslint:disable-next-line: no-console
-        console.log("  possible transition : ", transition.browseName.toString(), " ", transition.nodeId.toString());
+        warningLog("  possible transition : ", transition.browseName.toString(), " ", transition.nodeId.toString());
     }
-    // tslint:disable-next-line: no-console
-    console.log(
+    warningLog(
         "warning: a duplicated FromState Reference to the same target has been found.\nPlease check your model or provide a predicate method to select which one to use"
     );
-    // tslint:disable-next-line: no-console
-    console.log("fromStateNode: ", fromState.toString());
+    warningLog("fromStateNode: ", fromState.toString());
     return transitions[0];
 };
 
-
-
 export function getFiniteStateMachineTypeStates(uaFiniteStateMachineType: UAObjectType): UAState[] {
     const addressSpace = uaFiniteStateMachineType.addressSpace;
 
@@ -113,7 +118,6 @@ export function getFiniteStateMachineTypeTransitions(uaFiniteStateMachineType: U
     }
     const comp = getComponentOfType(uaFiniteStateMachineType, transitionType);
     return comp as UATransitionEx[];
-
 }
 
 export function getFiniteStateMachineTypeStateByName(uaFiniteStateMachineType: UAObjectType, stateName: string): UAState | null {
@@ -185,13 +189,10 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
      * @private
      */
     public _coerceNode(node: UAState | BaseNode | null | string | NodeId): BaseNode | null {
-        if (node === null) {
-            return null;
-        }
-        const addressSpace = this.addressSpace;
         if (node instanceof BaseNodeImpl) {
             return node;
         } else if (node instanceof NodeId) {
+            const addressSpace = this.addressSpace;
             return addressSpace.findNode(node) as BaseNode;
         } else if (typeof node === "string") {
             return this.getStateByName(node) as any as BaseNode;
@@ -243,14 +244,18 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
             return null;
         }
 
+        // istanbul ignore next
         if (_fromStateNode.nodeClass !== NodeClass.Object) {
             throw new Error("Internal Error");
         }
+        // istanbul ignore next
         if (_toStateNode && _toStateNode.nodeClass !== NodeClass.Object) {
             throw new Error("Internal Error");
         }
 
         const stateType = addressSpace.findObjectType("StateType");
+        
+        // istanbul ignore next
         if (!stateType) {
             throw new Error("Cannot find StateType");
         }
@@ -318,7 +323,6 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
             if (!state) {
                 throw new Error("Cannot find state with name " + toStateNode);
             }
-            assert(state.browseName.name!.toString() === toStateNode);
             toStateNode = state;
         }
         const fromStateNode = this.currentStateNode;
@@ -329,16 +333,195 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
         this.currentState.setValueFromSource(
             {
                 dataType: DataType.LocalizedText,
-                value: coerceLocalizedText(toStateNode.browseName.toString())
+                value: coerceLocalizedText(toStateNode.displayName[0] || toStateNode.browseName.name!)
             },
             StatusCodes.Good
         );
 
         this.currentStateNode = toStateNode;
 
-        const transitionNode = this.findTransitionNode(fromStateNode, toStateNode, predicate) as UATransitionImpl;
+        const applyCurrentStateOptionalProps = () => {
+            const uaId = this.currentState.getPropertyByName("Id")! as UAVariable;
+            if (uaId) {
+                uaId.setValueFromSource({
+                    dataType: DataType.NodeId,
+                    value: this.currentStateNode ? this.currentStateNode.nodeId : NodeId.nullNodeId
+                });
+            }
+
+            const uaName = this.currentState.getPropertyByName("Name")! as UAVariable;
+            if (uaName) {
+                uaName.setValueFromSource({
+                    dataType: DataType.QualifiedName,
+                    value: this.currentStateNode ? this.currentStateNode.browseName : coerceQualifiedName("")
+                });
+            }
 
+            const uaNumber = this.currentState.getPropertyByName("Number")! as UAVariable;
+            if (uaNumber) {
+                if (!this.currentStateNode) {
+                    const n = uaNumber.setValueFromSource({
+                        dataType: DataType.UInt32,
+                        value: 0 // may be wrong !
+                    });
+                } else {
+                    const n = uaNumber.setValueFromSource({
+                        dataType: DataType.UInt32,
+                        value: this.currentStateNode.stateNumber.readValue().value.value
+                    });
+                }
+            }
+
+            const uaEffectiveDisplayName = this.currentState.getPropertyByName("EffectiveDisplayName")! as UAVariable;
+            if (uaEffectiveDisplayName) {
+                uaEffectiveDisplayName.setValueFromSource({
+                    dataType: DataType.LocalizedText,
+                    value: coerceLocalizedText(
+                        this.currentStateNode ? this.currentStateNode.displayName[0] || this.currentStateNode.browseName.name : ""
+                    )
+                });
+            }
+        };
+        applyCurrentStateOptionalProps();
+
+        const transitionTime = new Date();
+        const applyTransitionOptionalPropsPhase1 = () => {
+            //                                                  +-----------------------------+
+            //             +--------------------------------|>|>| MainStateMachineType        |
+            //             |                                    +-----------------------------+
+            //             |                                                 |
+            //             |                                                 |    +--------+
+            // +------------------+                                          +--->| State1 |
+            // | MainStateMachine |                                          |    +--------+
+            // +------------------+                                          |
+            //       |                                                       |    +--------+
+            //       |       +----------------+                              +--->| State2 |   --- HasSubStateMachine --+
+            //       +---||->| SubStateMachine|                              |    +--------+                            |
+            //               +----------------+                              |                                          |
+            //                      |                                        |    +-----------------+                   |
+            //                                                               +--->| SubStateMachine |<------------------+
+            //                                                                    +-----------------+
+            //
+            // * `this` is potentially a subState machine
+            // *  get mainState = parent of `this`
+            // *  is mainState.typeDefinition is not StateMachineType -> exit
+            // *  find subMachine in mainState.typeDefinition (or any subtype of it) that has the same browse name as this.browseName
+            const ms = this.findReferencesExAsObject("Aggregates", BrowseDirection.Inverse)[0] as
+                | UAStateMachineEx
+                | undefined
+                | null;
+            if (!ms) return;
+            if (ms.nodeClass !== NodeClass.Object) return;
+            const stateMachineType = this.addressSpace.findObjectType("StateMachineType")!;
+            if (!ms.typeDefinitionObj.isSubtypeOf(stateMachineType)) return;
+
+            const find = (node: UAObjectType, browseName: QualifiedName): UAObject | UAVariable | null => {
+                const r = node
+                    .getAggregates()
+                    .filter((x) => x.browseName.name! === browseName.name && x.namespaceIndex === browseName.namespaceIndex);
+                if (r.length === 0) {
+                    // look in subType
+                    const subType = node.subtypeOfObj;
+                    if (subType) {
+                        return find(subType, browseName);
+                    }
+                    return null;
+                } else {
+                    const retVal = r[0];
+
+                    // istanbul ignore next
+                    if (retVal.nodeClass !== NodeClass.Variable && retVal.nodeClass !== NodeClass.Object) {
+                        throw new Error("find: expecting only object and variable here");
+                    }
+                    return retVal as UAObject | UAVariable;
+                }
+            };
+            const stateMachineInType = find(ms.typeDefinitionObj, this.browseName);
+            if (!stateMachineInType) return;
+            const mainState = stateMachineInType.findReferencesAsObject("HasSubStateMachine", false)[0] as UAVariable;
+
+            if (mainState) {
+                if (!ms.currentStateNode || !sameNodeId(mainState.nodeId, ms.currentStateNode.nodeId)) {
+                    return;
+                }
+
+                // also update uaLastTransition.EffectiveTransitionTime
+                const uaLastTransitionMain = ms.getComponentByName("LastTransition") as UAVariable;
+                if (uaLastTransitionMain) {
+                    const uaEffectiveTransitionTimeMain = uaLastTransitionMain.getPropertyByName(
+                        "EffectiveTransitionTime"
+                    )! as UAVariable;
+                    if (uaEffectiveTransitionTimeMain) {
+                        uaEffectiveTransitionTimeMain.setValueFromSource({
+                            dataType: DataType.DateTime,
+                            value: transitionTime
+                        });
+                    }
+                }
+            }
+        };
+        applyTransitionOptionalPropsPhase1();
+
+        const transitionNode = this.findTransitionNode(fromStateNode, toStateNode, predicate) as UATransitionImpl;
         if (transitionNode) {
+            const applyLastTransitionOptionalProps = () => {
+                const uaLastTransition = this.getComponentByName("LastTransition") as UAVariable;
+                if (uaLastTransition) {
+                    uaLastTransition.setValueFromSource(
+                        {
+                            dataType: DataType.LocalizedText,
+                            value: transitionNode.displayName[0] || transitionNode.browseName.name!
+                        },
+                        StatusCodes.Good,
+                        transitionTime
+                    );
+
+                    const uaId = uaLastTransition.getPropertyByName("Id")! as UAVariable;
+                    if (uaId) {
+                        uaId.setValueFromSource({
+                            dataType: DataType.NodeId,
+                            value: transitionNode.nodeId
+                        });
+                    }
+
+                    const uaLastTransitionTime = uaLastTransition.getPropertyByName("TransitionTime")! as UAVariable;
+                    if (uaLastTransitionTime) {
+                        uaLastTransitionTime.setValueFromSource({
+                            dataType: DataType.DateTime,
+                            value: transitionTime
+                        });
+                    }
+                    /**
+                     * EffectiveTransitionTime specifies the time when the current state or one of its sub-states was entered.
+                     * If, for example, a StateA is active and – while active – switches several times between its sub-states
+                     * SubA and SubB, then the TransitionTime stays at the point in time where StateA became active whereas the *
+                     * EffectiveTransitionTime changes with each change of a sub-state.
+                     */
+                    const uaEffectiveTransitionTime = uaLastTransition.getPropertyByName("EffectiveTransitionTime")! as UAVariable;
+                    if (uaEffectiveTransitionTime) {
+                        uaEffectiveTransitionTime.setValueFromSource({
+                            dataType: DataType.DateTime,
+                            value: transitionTime
+                        });
+                    }
+                    //
+                    const uaName = uaLastTransition.getPropertyByName("Name")! as UAVariable;
+                    if (uaName) {
+                        uaName.setValueFromSource({
+                            dataType: DataType.QualifiedName,
+                            value: transitionNode.browseName
+                        });
+                    }
+                    const uaNumber = uaLastTransition.getPropertyByName("Number")! as UAVariable;
+                    if (uaNumber) {
+                        uaNumber.setValueFromSource({
+                            dataType: DataType.UInt32,
+                            value: transitionNode.transitionNumber.readValue().value.value
+                        });
+                    }
+                }
+            };
+            applyLastTransitionOptionalProps();
             // xx console.log("transitionNode ",transitionNode.toString());
             // The inherited Property SourceNode shall be filled with the NodeId of the StateMachine instance where the
             // Transition occurs. If the Transition occurs in a SubStateMachine, then the NodeId of the SubStateMachine
@@ -367,8 +550,8 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
                 "fromState.id": fromStateNode
                     ? fromStateNode.stateNumber.readValue().value
                     : {
-                        dataType: "Null"
-                    },
+                          dataType: "Null"
+                      },
 
                 toState: {
                     dataType: "LocalizedText",
@@ -383,8 +566,7 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
                 if (doDebug) {
                     const f = fromStateNode.browseName.toString();
                     const t = toStateNode.browseName.toString();
-                    // tslint:disable-next-line:no-console
-                    console.log(chalk.red("Warning"), " cannot raise event :  transition " + f + " to " + t + " is missing");
+                    warningLog(chalk.red("Warning"), " cannot raise event :  transition " + f + " to " + t + " is missing");
                 }
             }
         }
@@ -397,11 +579,13 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
 
     /**
      * @internal
-     * @private
+     * @private|
      */
     public _post_initialize(): void {
         const addressSpace = this.addressSpace;
         const finiteStateMachineType = addressSpace.findObjectType("FiniteStateMachineType");
+       
+        // istanbul ignore next
         if (!finiteStateMachineType) {
             throw new Error("cannot find FiniteStateMachineType");
         }
@@ -419,6 +603,38 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
                 d.value && d.value.value ? (d.value.value.text ? d.value.value.text.toString() : d.value.value.toString()) : "";
             this.currentStateNode = this.getStateByName(txt);
         }
+
+        // Install AvailableStatesVariable if available
+        const uaAvailableStates = this.getComponentByName("AvailableStates", 0) as UAVariable;
+        if (uaAvailableStates) {
+            uaAvailableStates.bindVariable(
+                {
+                    get: () => {
+                        return new Variant({
+                            arrayType: VariantArrayType.Array,
+                            dataType: DataType.NodeId,
+                            value: this.getStates().map((state) => state.nodeId)
+                        });
+                    }
+                },
+                true
+            );
+        }
+        const uaAvailableTransitions = this.getComponentByName("AvailableTransitions", 0) as UAVariable;
+        if (uaAvailableTransitions) {
+            uaAvailableTransitions.bindVariable(
+                {
+                    get: () => {
+                        return new Variant({
+                            arrayType: VariantArrayType.Array,
+                            dataType: DataType.NodeId,
+                            value: this.getTransitions().map((state) => state.nodeId)
+                        });
+                    }
+                },
+                true
+            );
+        }
     }
 }
 
@@ -434,14 +650,12 @@ export function promoteToStateMachine(node: UAObject): UAStateMachineEx {
 }
 registerNodePromoter(ObjectTypeIds.FiniteStateMachineType, promoteToStateMachine);
 
-
 export class UAStateMachineTypeImpl extends UAObjectTypeImpl implements UAStateMachineTypeHelper {
     getStateByName(name: string): UAState | null {
         return getFiniteStateMachineTypeStateByName(this, name);
     }
     getStates(): UAState[] {
         return getFiniteStateMachineTypeStates(this);
-
     }
     getTransitions(): UATransitionEx[] {
         return getFiniteStateMachineTypeTransitions(this);
@@ -450,7 +664,6 @@ export class UAStateMachineTypeImpl extends UAObjectTypeImpl implements UAStateM
     _post_initialize(): void {
         /** */
     }
-
 }
 export function promoteToStateMachineType(node: UAObject): UAStateMachineTypeHelper {
     if (node instanceof UAStateMachineTypeImpl) {
@@ -461,4 +674,4 @@ export function promoteToStateMachineType(node: UAObject): UAStateMachineTypeHel
     const _node = node as unknown as UAStateMachineTypeImpl;
     _node._post_initialize();
     return _node;
-}
+}

package/src/ua_method_impl.ts

@@ -264,12 +264,15 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
 
         _handle_hierarchy_parent(addressSpace, options.references, options);
 
+        if (!extraInfo) {
+            extraInfo = makeDefaultCloneExtraInfo(this);
+        }
         const clonedMethod = _clone(
             this,
             UAMethodImpl,
             options,
             optionalFilter || defaultCloneFilter,
-            extraInfo || makeDefaultCloneExtraInfo()
+            extraInfo 
         ) as UAMethodImpl;
 
         clonedMethod._asyncExecutionFunction = this._asyncExecutionFunction;

package/src/ua_object_impl.ts

@@ -101,7 +101,7 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
             UAObjectImpl,
             options,
             optionalFilter || defaultCloneFilter,
-            extraInfo || makeDefaultCloneExtraInfo()
+            extraInfo || makeDefaultCloneExtraInfo(this)
         ) as UAObject;
         // xx  newObject.propagate_back_references();
         // xx newObject.install_extra_properties();
@@ -191,8 +191,7 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
             server.emit("event", eventData);
             m[server.nodeId.toString()] = server;
         } else {
-            // tslint:disable:no-console
-            console.warn(
+            errorLog(
                 chalk.yellow("Warning. ") +
                     chalk.cyan("UAObject#raiseEvent") +
                     chalk.red(" cannot find Server object on addressSpace")

package/src/ua_object_type_impl.ts

@@ -25,10 +25,10 @@ import { get_subtypeOf, get_subtypeOfObj } from "./tool_isSubtypeOf";
 import * as tools from "./tool_isSubtypeOf";
 import {
     assertUnusedChildBrowseName,
-    initialize_properties_and_components,
     topMostParentIsObjectTypeOrVariableType
 } from "./ua_variable_type_impl";
 import { AddressSpacePrivate } from "./address_space_private";
+import { initialize_properties_and_components } from "./_instantiate_helpers";
 
 export class UAObjectTypeImpl extends BaseNodeImpl implements UAObjectType {
     public readonly nodeClass = NodeClass.ObjectType;

package/src/ua_variable_impl.ts

@@ -249,7 +249,7 @@ interface UAVariableOptions extends InternalBaseNodeOptions {
     value?: any;
     dataType: NodeId | string;
     /**
-     * This attribute indicates whether the Value attribute of the Variableis an array and how many dimensions the array has.
+     * This attribute indicates whether the Value attribute of the Variable is an array and how many dimensions the array has.
      * It may have the following values:
      *   * n > 1: the Value is an array with the specified number of dimensions.
      *   * OneDimension (1): The value is an array with one dimension.
@@ -327,10 +327,10 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
     get typeDefinitionObj(): UAVariableType {
         // istanbul ignore next
         if (super.typeDefinitionObj && super.typeDefinitionObj.nodeClass !== NodeClass.VariableType) {
-            console.log(super.typeDefinitionObj.toString());
-            throw new Error(
-                "Invalid type definition node class , expecting a VariableType got " + NodeClass[super.typeDefinitionObj.nodeClass]
-            );
+            // this could happen in faulty external nodeset and has been seen once 
+            // in an nano server
+            warningLog(super.typeDefinitionObj.toString());
+            return this.addressSpace.findVariableType("BaseVariableType")!;
         }
         return super.typeDefinitionObj as UAVariableType;
     }
@@ -1371,7 +1371,7 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             UAVariableImpl,
             options,
             optionalFilter || defaultCloneFilter,
-            extraInfo || makeDefaultCloneExtraInfo()
+            extraInfo || makeDefaultCloneExtraInfo(this)
         ) as UAVariableImpl;
 
         newVariable.bindVariable();
@@ -1387,7 +1387,7 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             try {
                 newVariable.bindExtensionObject(newVariable.$dataValue.value.value);
             } catch (err) {
-                errorLog("Errro binding extension objects");
+                errorLog("Error binding extension objects");
                 errorLog((err as Error).message);
                 errorLog(this.toString());
                 errorLog("---------------------------------------");