node-opcua-address-space 2.137.0 → 2.138.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-address-space",
-    "version": "2.137.0",
+    "version": "2.138.1",
     "description": "pure nodejs OPCUA SDK - module address-space",
     "main": "./dist/src/index_current.js",
     "types": "./dist/source/index.d.ts",
@@ -22,11 +22,11 @@
         "chalk": "4.1.2",
         "dequeue": "^1.0.5",
         "lodash": "4.17.21",
-        "node-opcua-address-space-base": "2.137.0",
+        "node-opcua-address-space-base": "2.138.0",
         "node-opcua-assert": "2.120.0",
         "node-opcua-basic-types": "2.134.0",
         "node-opcua-binary-stream": "2.133.0",
-        "node-opcua-client-dynamic-extension-object": "2.137.0",
+        "node-opcua-client-dynamic-extension-object": "2.138.0",
         "node-opcua-constants": "2.125.0",
         "node-opcua-crypto": "4.12.0",
         "node-opcua-data-access": "2.137.0",
@@ -38,10 +38,10 @@
         "node-opcua-extension-object": "2.137.0",
         "node-opcua-factory": "2.137.0",
         "node-opcua-nodeid": "2.133.0",
-        "node-opcua-nodeset-ua": "2.137.0",
+        "node-opcua-nodeset-ua": "2.138.0",
         "node-opcua-numeric-range": "2.137.0",
         "node-opcua-object-registry": "2.133.0",
-        "node-opcua-pseudo-session": "2.137.0",
+        "node-opcua-pseudo-session": "2.138.0",
         "node-opcua-service-browse": "2.137.0",
         "node-opcua-service-call": "2.137.0",
         "node-opcua-service-history": "2.137.0",
@@ -62,7 +62,7 @@
         "node-opcua-leak-detector": "2.133.0",
         "node-opcua-nodesets": "2.137.0",
         "node-opcua-packet-analyzer": "2.137.0",
-        "node-opcua-service-filter": "2.137.0",
+        "node-opcua-service-filter": "2.138.0",
         "node-opcua-test-fixtures": "2.137.0",
         "source-map-support": "^0.5.21"
     },
@@ -81,7 +81,7 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "e88e4f20d5436dd68084d2a6d447f170330b373d",
+    "gitHead": "9a9b6ac2281306c90fc0ef55e93c8b773f9edcd2",
     "files": [
         "dist",
         "distHelpers",

package/source/ua_addin.ts

@@ -24,18 +24,19 @@ export function instantiateAddIn(objectType: UAObjectType, options: InstantiateA
         browseName: browseName,
         modellingRule: options.modellingRule,
         copyAlsoModellingRules: options.copyAlsoModellingRules,
+        addInOf: options.addInOf
     });
-    options.addInOf.addReference({
-        referenceType: "HasAddIn",
-        nodeId: addIn.nodeId
-    })
     return addIn;
 }
 
-export function addDefaultInstanceBrowseName(objectType: UAObjectType, defaultBrowseName: string)
+export function addDefaultInstanceBrowseName(objectType: UAObjectType, defaultBrowseName: QualifiedName | string)
     : UAVariableT<QualifiedName, DataType.QualifiedName> {
 
     const namespace1 = objectType.namespace;
+    if (typeof defaultBrowseName === "string") {
+        defaultBrowseName = coerceQualifiedName({ name: defaultBrowseName, namespaceIndex: namespace1.index });
+    }
+
     const uaVaraible = namespace1.addVariable({
         browseName: coerceQualifiedName({ name: "DefaultInstanceBrowseName", namespaceIndex: 0 }),
         propertyOf: objectType,
@@ -43,9 +44,9 @@ export function addDefaultInstanceBrowseName(objectType: UAObjectType, defaultBr
         dataType: DataType.QualifiedName,
         value: {
             dataType: DataType.QualifiedName,
-            value: { namespaceIndex: namespace1.index, name: defaultBrowseName }
+            value: defaultBrowseName
         },
-        modellingRule: null
+        modellingRule: null // DefaultInstanceBrowseName must have no ModellingRule
     });
     return uaVaraible as UAVariableT<QualifiedName, DataType.QualifiedName>;
 

package/source/ua_interface.ts

@@ -2,12 +2,13 @@
 
 import { UAObject, UAObjectType, UAVariable, UAVariableType } from "node-opcua-address-space-base";
 import { BrowseDirection } from "node-opcua-data-model";
+import { initialize_properties_and_components } from "../src/_instantiate_helpers";
 
-export function implementInterface(uaNode: UAObject | UAObjectType | UAVariable | UAVariableType, interfaceType: UAObjectType) {
+export function implementInterfaceBad(uaNode: UAObject | UAObjectType | UAVariable | UAVariableType, interfaceType: UAObjectType) {
 
     const addressSpace = uaNode.addressSpace;
     const tmp = interfaceType.instantiate({
-        browseName: "_tmp_",
+        browseName: uaNode.browseName,
         copyAlsoModellingRules: true,
         copyAlsoAllOptionals: true,
         modellingRule: "Mandatory"
@@ -33,6 +34,16 @@ export function implementInterface(uaNode: UAObject | UAObjectType | UAVariable
         });
     }
     addressSpace.deleteNode(tmp);
-    console.log(uaNode.toString());
+}
+
+export function implementInterface(uaNode: UAObject | UAObjectType | UAVariable | UAVariableType, interfaceType: UAObjectType) {
+
+    const addressSpace = uaNode.addressSpace;
+    const topMost = addressSpace.findObjectType("BaseInterfaceType")!;
+    initialize_properties_and_components(uaNode as any, topMost, interfaceType, true, true, []);
+    uaNode.addReference({
+        nodeId: interfaceType,
+        referenceType: "HasInterface"
+    });
 
 }

package/src/_instantiate_helpers.ts

@@ -71,7 +71,7 @@ function _initialize_properties_and_components<B extends UAObject | UAVariable |
     doTrace &&
         traceLog(
             chalk.cyan(extraInfo.pad(), "cloning relevant member of typeDefinition class"),
-            typeDefinitionNode.browseName.toString()
+            typeDefinitionNode.browseName.toString()+ "\n optionals" + (JSON.stringify(optionalsMap))
         );
 
     _clone_hierarchical_references(typeDefinitionNode, instance, copyAlsoModellingRules, filter, extraInfo, browseNameMap);

package/src/namespace_impl.ts

@@ -799,16 +799,8 @@ export class NamespaceImpl implements NamespacePrivate {
     }
 
     // ---------------------------------------------------------------------------------------------------
-    /**
-
-     * @param options
-     * @param options.browseName {String}
-     * @param options.definition {String}
-     * @param [options.valuePrecision {Double |null} =null]
-     * @param options.dataType {NodeId} // todo :check
-     * @param options.value
-     * @param options.componentOf
-     * @return {UAVariable}
+    /** 
+     * 
      */
     public addDataItem<T, DT extends DataType>(options: AddDataItemOptions): UADataItem<T, DT> {
         const addressSpace = this.addressSpace;
@@ -2134,12 +2126,28 @@ function _handle_event_hierarchy_parent(
 }
 
 export function _handle_hierarchy_parent(addressSpace: AddressSpacePrivate, references: AddReferenceOpts[], options: any): void {
+    options.addInOf = _coerce_parent(addressSpace, options.addInOf, addressSpace._coerceNode);
     options.componentOf = _coerce_parent(addressSpace, options.componentOf, addressSpace._coerceNode);
     options.propertyOf = _coerce_parent(addressSpace, options.propertyOf, addressSpace._coerceNode);
     options.organizedBy = _coerce_parent(addressSpace, options.organizedBy, addressSpace._coerceFolder);
     options.encodingOf = _coerce_parent(addressSpace, options.encodingOf, addressSpace._coerceNode);
 
+    if (options.addInOf) {
+        assert(!options.componentOf);
+        assert(!options.propertyOf);
+        assert(!options.organizedBy);
+        assert(options.addInOf.nodeClass === NodeClass.Object || options.addInOf.nodeClass === NodeClass.ObjectType,
+            "addInOf must be of nodeClass Object or ObjectType"
+        );   
+        references.push({
+            isForward: false,
+            nodeId: options.addInOf.nodeId,
+            referenceType: "HasAddIn"
+        });
+    }
+
     if (options.componentOf) {
+        assert(!options.addInOf);
         assert(!options.propertyOf);
         assert(!options.organizedBy);
         assert(addressSpace.rootFolder.objects, "addressSpace must have a rootFolder.objects folder");
@@ -2155,6 +2163,7 @@ export function _handle_hierarchy_parent(addressSpace: AddressSpacePrivate, refe
     }
 
     if (options.propertyOf) {
+        assert(!options.addInOf);
         assert(!options.componentOf);
         assert(!options.organizedBy);
         assert(
@@ -2169,6 +2178,7 @@ export function _handle_hierarchy_parent(addressSpace: AddressSpacePrivate, refe
     }
 
     if (options.organizedBy) {
+        assert(!options.addInOf);
         assert(!options.propertyOf);
         assert(!options.componentOf);
         references.push({
@@ -2177,6 +2187,7 @@ export function _handle_hierarchy_parent(addressSpace: AddressSpacePrivate, refe
             referenceType: "Organizes"
         });
     }
+    
     if (options.encodingOf) {
         // parent must be a DataType
         assert(options.encodingOf.nodeClass === NodeClass.DataType, "encodingOf must be toward a DataType");

package/src/nodeid_manager.ts

@@ -6,6 +6,7 @@ import { makeNodeId, NodeId, NodeIdLike, NodeIdType, resolveNodeId, sameNodeId }
 import { make_debugLog, make_warningLog } from "node-opcua-debug";
 import { BaseNode, UAReference, UAReferenceType } from "node-opcua-address-space-base";
 import { getReferenceType } from "./base_node_impl";
+import { resolveReferenceNode, resolveReferenceType } from "./reference_impl";
 
 const debugLog = make_debugLog(__filename);
 const warningLog = make_warningLog(__filename);
@@ -19,24 +20,29 @@ function isValidNodeClass(nodeClass: NodeClass) {
 
 const regExp1 = /^(s|i|b|g)=/;
 const regExp2 = /^ns=[0-9]+;(s|i|b|g)=/;
-const hasPropertyRefId = resolveNodeId("HasProperty");
-const hasComponentRefId = resolveNodeId("HasComponent");
-const hasOrderedComponentRefId = resolveNodeId("HasOrderedComponent");
 const hasEncoding = resolveNodeId("HasEncoding");
 
 type Suffix = string;
 
-function _identifyParentInReference(references: UAReference[]): [NodeId, Suffix] | null {
-    const candidates = references.filter((r: UAReference) => {
-        return (
-            !r.isForward &&
-            (sameNodeId(r.referenceType, hasComponentRefId) ||
-                sameNodeId(r.referenceType, hasOrderedComponentRefId) ||
-                sameNodeId(r.referenceType, hasPropertyRefId) ||
-                sameNodeId(r.referenceType, hasEncoding))
-        );
-    });
-    assert(candidates.length <= 1);
+function _filterAggregates(addressSpace: AddressSpacePartial, references: UAReference[]): [NodeId, Suffix] | null {
+
+    const aggregatesRefType = addressSpace.findNode(resolveNodeId("Aggregates")) as UAReferenceType;
+    const hasEncodinRefType = addressSpace.findNode(resolveNodeId("HasEncoding")) as UAReferenceType;
+
+    const checkAggregate = (
+        reference: UAReference,
+    ): boolean => {
+        if (reference.isForward) return false;
+        const r = resolveReferenceType(addressSpace, reference);
+        if (!r) {
+            return false;
+        }
+        return r.isSubtypeOf(aggregatesRefType) || r.isSubtypeOf(hasEncodinRefType)
+    }
+
+    const candidates = references.filter(checkAggregate);
+
+    assert(candidates.length <= 1, "a node shall not have more than one parent (link to a parent with a reference derived from 'Aggregates')");
     if (candidates.length === 0) {
         return null;
     }
@@ -60,7 +66,7 @@ function _findParentNodeId(addressSpace: AddressSpacePartial, options: Construct
         (ref as any).referenceType = (ref as any)._referenceType.nodeId;
     }
     // find HasComponent, or has Property reverse
-    return _identifyParentInReference(options.references);
+    return _filterAggregates(addressSpace, options.references);
 }
 
 function prepareName(browseName: QualifiedName): string {
@@ -83,7 +89,7 @@ export type NodeEntry = [string, number, NodeClass];
 export type NodeEntry1 = [string, number, string /*"Object" | "Variable" etc...*/];
 
 export class NodeIdManager {
-    private _cacheSymbolicName: { [key: string]: [number,NodeClass] } = {};
+    private _cacheSymbolicName: { [key: string]: [number, NodeClass] } = {};
     private _cacheSymbolicNameRev: Set<number> = new Set<number>();
 
     private _internal_id_counter: number;
@@ -174,11 +180,11 @@ export class NodeIdManager {
         }
         return this._constructNodeId(options);
     }
- 
+
     private _constructNodeId(options: ConstructNodeIdOptions): NodeId {
 
         let nodeId = options.nodeId;
-  
+
         if (!nodeId) {
             const parentInfo = this.findParentNodeId(options);
             if (parentInfo) {
@@ -190,7 +196,7 @@ export class NodeIdManager {
                     const childName = parentNodeId.value + NamespaceOptions.nodeIdNameSeparator + name;
                     nodeId = new NodeId(NodeId.NodeIdType.STRING, childName, parentNodeId.namespace);
                     return nodeId;
-                } 
+                }
             }
         } else if (typeof nodeId === "string") {
             if (this.namespaceIndex !== 0) {
@@ -218,7 +224,7 @@ export class NodeIdManager {
     }
 
     private _isInCache(nodeId: NodeId): boolean {
-        if( nodeId.namespace !== this.namespaceIndex || nodeId.identifierType !== NodeIdType.NUMERIC) return false;
+        if (nodeId.namespace !== this.namespaceIndex || nodeId.identifierType !== NodeIdType.NUMERIC) return false;
         return this._cacheSymbolicNameRev.has(nodeId.value as number) ? true : false;
     }
 }

package/src/private_namespace.ts

@@ -1,6 +1,7 @@
 
 
 import { Namespace } from "../source/namespace";
+import { NamespacePrivate } from "./namespace_private";
 import { NodeEntry1, NodeIdManager } from "./nodeid_manager";
 
 export function getNodeIdManager(ns: Namespace): NodeIdManager {
@@ -9,7 +10,7 @@ export function getNodeIdManager(ns: Namespace): NodeIdManager {
 }
 export function setSymbols(ns: Namespace, symbols: NodeEntry1[]) {
     const nodeIdManager = getNodeIdManager(ns);
-    (ns.addressSpace.getOwnNamespace() as any).registerSymbolicNames = true;
+    (ns as any).registerSymbolicNames = true;
     nodeIdManager.setSymbols(symbols);
 }
 export function getSymbols(ns: Namespace): NodeEntry1[] {

package/src/ua_object_type_impl.ts

@@ -82,8 +82,9 @@ export class UAObjectTypeImpl extends BaseNodeImpl implements UAObjectType {
      * @param options
      * @param options.browseName
      * @param [options.description]
-     * @param [options.organizedBy] the parent Folder holding this object
+     * @param [options.organizedBy] the parent Folder holding this object 
      * @param [options.componentOf] the parent Object holding this object
+     * @param [options.addInOf]
      * @param [options.notifierOf]
      * @param [options.eventSourceOf]
      * @param [options.optionals = [] name of the optional child to create
@@ -132,6 +133,7 @@ export class UAObjectTypeImpl extends BaseNodeImpl implements UAObjectType {
             eventSourceOf: options.eventSourceOf,
             notifierOf: options.notifierOf,
             organizedBy: options.organizedBy,
+            addInOf: options.addInOf,
             references,
 
             typeDefinition: this.nodeId,