node-opcua-address-space 2.106.0 → 2.107.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-address-space",
-    "version": "2.106.0",
+    "version": "2.107.0",
     "description": "pure nodejs OPCUA SDK - module address-space",
     "main": "./dist/src/index_current.js",
     "types": "./dist/source/index.d.ts",
@@ -22,14 +22,14 @@
         "chalk": "4.1.2",
         "dequeue": "^1.0.5",
         "lodash": "4.17.21",
-        "node-opcua-address-space-base": "2.106.0",
+        "node-opcua-address-space-base": "2.107.0",
         "node-opcua-assert": "2.105.0",
         "node-opcua-basic-types": "2.105.0",
         "node-opcua-binary-stream": "2.105.0",
-        "node-opcua-client-dynamic-extension-object": "2.106.0",
+        "node-opcua-client-dynamic-extension-object": "2.107.0",
         "node-opcua-constants": "2.98.1",
         "node-opcua-crypto": "3.0.6",
-        "node-opcua-data-access": "2.105.0",
+        "node-opcua-data-access": "2.107.0",
         "node-opcua-data-model": "2.105.0",
         "node-opcua-data-value": "2.105.0",
         "node-opcua-date-time": "2.105.0",
@@ -38,20 +38,20 @@
         "node-opcua-extension-object": "2.105.0",
         "node-opcua-factory": "2.105.0",
         "node-opcua-nodeid": "2.105.0",
-        "node-opcua-nodeset-ua": "2.106.0",
+        "node-opcua-nodeset-ua": "2.107.0",
         "node-opcua-numeric-range": "2.105.0",
         "node-opcua-object-registry": "2.105.0",
-        "node-opcua-pseudo-session": "2.106.0",
-        "node-opcua-service-browse": "2.105.0",
-        "node-opcua-service-call": "2.105.0",
-        "node-opcua-service-history": "2.105.0",
-        "node-opcua-service-translate-browse-path": "2.105.0",
-        "node-opcua-service-write": "2.105.0",
+        "node-opcua-pseudo-session": "2.107.0",
+        "node-opcua-service-browse": "2.107.0",
+        "node-opcua-service-call": "2.107.0",
+        "node-opcua-service-history": "2.107.0",
+        "node-opcua-service-translate-browse-path": "2.107.0",
+        "node-opcua-service-write": "2.107.0",
         "node-opcua-status-code": "2.105.0",
-        "node-opcua-types": "2.105.0",
+        "node-opcua-types": "2.107.0",
         "node-opcua-utils": "2.105.0",
         "node-opcua-variant": "2.105.0",
-        "node-opcua-xml2json": "2.105.0",
+        "node-opcua-xml2json": "2.107.0",
         "semver": "^7.5.1",
         "set-prototype-of": "^1.0.0",
         "thenify": "^3.3.1",
@@ -61,10 +61,10 @@
         "mocha": "^10.2.0",
         "node-opcua-benchmarker": "2.105.0",
         "node-opcua-leak-detector": "2.105.0",
-        "node-opcua-nodesets": "2.103.0",
+        "node-opcua-nodesets": "2.107.0",
         "node-opcua-packet-analyzer": "2.105.0",
-        "node-opcua-service-filter": "2.106.0",
-        "node-opcua-test-fixtures": "2.105.0",
+        "node-opcua-service-filter": "2.107.0",
+        "node-opcua-test-fixtures": "2.107.0",
         "should": "^13.2.3",
         "sinon": "^15.1.0",
         "source-map-support": "^0.5.21"
@@ -84,7 +84,7 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "6fe67f5a64192bff5c7f590c4de4e827ae0c551a",
+    "gitHead": "df5c9168eea0d1a521603d181fa66ace7649e79e",
     "files": [
         "dist",
         "distHelpers",

package/source/loader/register_node_promoter.ts

@@ -3,10 +3,7 @@ import { UAObject, UAVariable } from "node-opcua-address-space-base";
 
 import { g_promotableObject, Promoter } from "./namespace_post_step";
 
-export function registerNodePromoter(
-    standardNodeId: number,
-    promoter: Promoter,
-    applyOnTypes = false
-): void {
-    g_promotableObject[resolveNodeId(standardNodeId).toString()] = { promoter, onInstanceOnly: applyOnTypes };
+export function registerNodePromoter(standardNodeId: number, promoter: Promoter, onInstanceOnly = false): void {
+    
+    g_promotableObject[resolveNodeId(standardNodeId).toString()] = { promoter, onInstanceOnly };
 }

package/src/_instantiate_helpers.ts

@@ -0,0 +1,141 @@
+/**
+ * @module node-opcua-address-space
+ */
+// tslint:disable:max-classes-per-file
+// tslint:disable:no-console
+import chalk from "chalk";
+
+import {
+    UAMethod,
+    UAObject,
+    UAObjectType,
+    UAVariable,
+    UAVariableType,
+    reconstructFunctionalGroupType,
+    reconstructNonHierarchicalReferences,
+    CloneHelper
+} from "node-opcua-address-space-base";
+
+import { checkDebugFlag, make_debugLog, make_warningLog, make_errorLog } from "node-opcua-debug";
+import { sameNodeId } from "node-opcua-nodeid";
+
+import { makeOptionalsMap, OptionalMap } from "../source/helpers/make_optionals_map";
+
+import { _clone_hierarchical_references } from "./base_node_private";
+import { MandatoryChildOrRequestedOptionalFilter } from "./_mandatory_child_or_requested_optional_filter";
+
+const debugLog = make_debugLog(__filename);
+const doDebug = checkDebugFlag(__filename);
+const warningLog = make_warningLog(__filename);
+const errorLog = make_errorLog(__filename);
+
+// eslint-disable-next-line prefer-const
+let doTrace = checkDebugFlag("INSTANTIATE");
+const traceLog = errorLog;
+
+// install properties and components on a instantiated Object
+//
+// based on their ModelingRule
+//  => Mandatory                 => Installed
+//  => Optional                  => Not Installed , unless it appear in optionals array
+//  => OptionalPlaceHolder       => Not Installed
+//  => null (no modelling rule ) => Not Installed
+//
+
+function _initialize_properties_and_components<B extends UAObject | UAVariable | UAMethod, T extends UAObjectType | UAVariableType>(
+    instance: B,
+    topMostType: T,
+    typeDefinitionNode: T,
+    copyAlsoModellingRules: boolean,
+    optionalsMap: OptionalMap,
+    extraInfo: CloneHelper,
+    browseNameMap: Set<string>
+) {
+    if (doTrace) {
+        warningLog("instance browseName =", instance.browseName.toString());
+        warningLog("typeNode            =", typeDefinitionNode.browseName.toString());
+        warningLog("optionalsMap        =", Object.keys(optionalsMap).join(" "));
+
+        const c = typeDefinitionNode.findReferencesEx("Aggregates");
+        warningLog("typeDefinition aggregates      =", c.map((x) => x.node!.browseName.toString()).join(" "));
+    }
+    optionalsMap = optionalsMap || {};
+
+    if (sameNodeId(topMostType.nodeId, typeDefinitionNode.nodeId)) {
+        return; // nothing to do
+    }
+
+    const filter = new MandatoryChildOrRequestedOptionalFilter(instance, optionalsMap);
+
+    doTrace &&
+        traceLog(
+            chalk.cyan(extraInfo.pad(), "cloning relevant member of typeDefinition class"),
+            typeDefinitionNode.browseName.toString()
+        );
+
+    _clone_hierarchical_references(typeDefinitionNode, instance, copyAlsoModellingRules, filter, extraInfo, browseNameMap);
+
+    // now apply recursion on baseTypeDefinition  to get properties and components from base class
+
+    const baseTypeDefinitionNodeId = typeDefinitionNode.subtypeOf;
+    const baseTypeDefinition = typeDefinitionNode.subtypeOfObj!;
+
+    doTrace &&
+        traceLog(
+            chalk.cyan(
+                extraInfo.pad(),
+                "now apply recursion on baseTypeDefinition  to get properties and components from base class"
+            ),
+            baseTypeDefinition.browseName.toString()
+        );
+
+    // istanbul ignore next
+    if (!baseTypeDefinition) {
+        throw new Error(chalk.red("Cannot find object with nodeId ") + baseTypeDefinitionNodeId);
+    }
+    extraInfo.level++;
+    _initialize_properties_and_components(
+        instance,
+        topMostType,
+        baseTypeDefinition,
+        copyAlsoModellingRules,
+        optionalsMap,
+        extraInfo,
+        browseNameMap
+    );
+    extraInfo.level--;
+}
+
+export function initialize_properties_and_components<
+    B extends UAObject | UAVariable | UAMethod,
+    T extends UAVariableType | UAObjectType
+>(instance: B, topMostType: T, nodeType: T, copyAlsoModellingRules: boolean, optionals?: string[]): void {
+    const extraInfo = new CloneHelper();
+
+    extraInfo.pushContext({
+        clonedParent: instance,
+        originalParent: nodeType
+    });
+    extraInfo.registerClonedObject({
+        clonedNode: instance,
+        originalNode: nodeType
+    });
+
+    const optionalsMap = makeOptionalsMap(optionals);
+
+    const browseNameMap = new Set<string>();
+
+    _initialize_properties_and_components(
+        instance,
+        topMostType,
+        nodeType,
+        copyAlsoModellingRules,
+        optionalsMap,
+        extraInfo,
+        browseNameMap
+    );
+
+    reconstructFunctionalGroupType(extraInfo);
+
+    reconstructNonHierarchicalReferences(extraInfo);
+}

package/src/_mandatory_child_or_requested_optional_filter.ts

@@ -0,0 +1,98 @@
+import { assert } from "node-opcua-assert";
+import { BaseNode, UAMethod, UAObject, UAReference, UAVariable, CloneFilter, fullPath2 } from "node-opcua-address-space-base";
+
+import { checkDebugFlag, make_debugLog, make_warningLog, make_errorLog } from "node-opcua-debug";
+
+import { _clone_hierarchical_references } from "./base_node_private";
+
+// const debugLog = make_debugLog(__filename);
+const doDebug = checkDebugFlag(__filename);
+const warningLog = make_warningLog(__filename);
+const errorLog = make_errorLog(__filename);
+const doTrace = checkDebugFlag("INSTANTIATE");
+const traceLog = errorLog;
+
+export class MandatoryChildOrRequestedOptionalFilter implements CloneFilter {
+    private readonly instance: BaseNode;
+    private readonly optionalsMap: any;
+    private readonly references: UAReference[];
+
+    constructor(instance: BaseNode, optionalsMap: any) {
+        // should we clone the node to be a component or propertyOf of a instance
+        assert(optionalsMap !== null && typeof optionalsMap === "object");
+        assert(null !== instance);
+        this.optionalsMap = optionalsMap;
+        this.instance = instance;
+        this.references = instance.allReferences();
+    }
+
+    public shouldKeep(node: BaseNode): boolean {
+        const addressSpace = node.addressSpace;
+
+        const alreadyIn = this.references.filter((r: UAReference) => {
+            const n = addressSpace.findNode(r.nodeId)!;
+            // istanbul ignore next
+            if (!n) {
+                warningLog(" cannot find node ", r.nodeId.toString());
+                return false;
+            }
+            return n.browseName!.name!.toString() === node.browseName!.name!.toString();
+        });
+
+        if (alreadyIn.length > 0) {
+            assert(alreadyIn.length === 1, "Duplication found ?");
+            // a child with the same browse name has already been install
+            // probably from a SuperClass, we should ignore this.
+            return false; // ignore
+        }
+
+        const modellingRule = node.modellingRule;
+
+        switch (modellingRule) {
+            case null:
+            case undefined:
+                // istanbul ignore next
+                doTrace &&
+                    traceLog(
+                        "node ",
+                        fullPath2(node),
+                        " has no modellingRule ",
+                        node ? fullPath2(node) : ""
+                    );
+                /**
+                 * in some badly generated NodeSet2.xml file, the modellingRule is not specified
+                 *
+                 * but in some other NodeSet2.xml, this means that the data are only attached to the Type node and shall not be
+                 * instantiate in the corresponding instance (example is the state variable of a finite state machine that are only
+                 * defined in the Type node)
+                 *
+                 * we should not consider it as an error, and treat it as not present
+                 */
+                return false;
+
+            case "Mandatory":
+                return true; // keep;
+            case "Optional":
+                // only if in requested optionals
+                return node.browseName!.name! in this.optionalsMap;
+            case "OptionalPlaceholder":
+                return false; // ignored
+            default:
+                return false; // ignored
+        }
+    }
+
+    public filterFor(childInstance: UAVariable | UAObject | UAMethod): CloneFilter {
+        const browseName: string = childInstance.browseName.name!;
+
+        let map = {};
+
+        if (browseName in this.optionalsMap) {
+            map = this.optionalsMap[browseName];
+        }
+        // istanbul ignore next
+        doTrace && traceLog("filterFor ", browseName, map);
+        const newFilter = new MandatoryChildOrRequestedOptionalFilter(childInstance, map);
+        return newFilter;
+    }
+}

package/src/alarms_and_conditions/ua_alarm_condition_impl.ts

@@ -201,6 +201,9 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
 
     public deactivateAlarm(retain?: boolean): void {
         const branch = this.currentBranch();
+        if (!branch) {
+            return;
+        }
         branch.setRetain(retain === undefined ? true : retain);
         branch.setActiveState(false);
     }

package/src/alarms_and_conditions/ua_certificate_expiration_alarm_impl.ts

@@ -193,7 +193,7 @@ class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implem
             this.expirationLimit.accessLevel = makeAccessLevelExFlag("CurrentRead | CurrentWrite");
             this.expirationLimit.userAccessLevel = makeAccessLevelExFlag("CurrentRead | CurrentWrite");
             this.expirationLimit.on("value_changed", (dataValue) => {
-                // make sure we re-evaluate the certificfate
+                // make sure we re-evaluate the certificate
                 const certificate = this.getCertificate();
                 this.setCertificate(certificate);
             });

package/src/alarms_and_conditions/ua_condition_impl.ts

@@ -32,7 +32,8 @@ import {
     BaseNode,
     UAObject,
     InstantiateObjectOptions,
-    UAProperty
+    UAProperty,
+    fullPath2
 } from "node-opcua-address-space-base";
 import { UAConditionVariable } from "node-opcua-nodeset-ua";
 
@@ -89,7 +90,7 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
         namespace: INamespace,
         conditionTypeId: NodeId | string | UAEventType,
         options: any,
-        data: any
+        data?: Record<string, VariantOptions>
     ): UAConditionImpl {
         return UACondition_instantiate(namespace, conditionTypeId, options, data) as UAConditionImpl;
     }
@@ -455,9 +456,10 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
             }
         } else {
             warningLog(
-                "Condition ",
-                this.nodeId.toString(),
-                "is not linked to a Object with a IsConditionOf(reversed(HasCondition))"
+                "raiseConditionEvent: the condition ",
+                fullPath2(this),
+                "is not linked to a Object with a IsConditionOf(reversed(HasCondition)) reference",
+                "therefore event cannot bubble-up to the server object"
             );
         }
         // xx console.log("MMMMMMMM%%%%%%%%%%%%%%%%%%%%% branch  " +