node-opcua-address-space 2.186.1 → 2.186.2

package/impl/_instantiate_helpers.ts

@@ -61,7 +61,13 @@ function _initialize_properties_and_components<B extends UAObject | UAVariable |
         return; // nothing to do
     }
 
-    const filter = new MandatoryChildOrRequestedOptionalFilter(instance, copyAlsoAllOptionals, optionalsMap);
+    // an instance declaration of a type (copyAlsoModellingRules) takes its type's placeholders too
+    const filter = new MandatoryChildOrRequestedOptionalFilter(
+        instance,
+        copyAlsoAllOptionals,
+        optionalsMap,
+        copyAlsoModellingRules
+    );
 
     doTrace &&
         traceLog(
@@ -115,6 +121,8 @@ export function initialize_properties_and_components<
     optionals?: string[]
 ): void {
     const extraInfo = new CloneHelper();
+    // flushed below, once the whole tree is cloned
+    extraInfo.canDefer = true;
 
     extraInfo.pushContext({
         clonedParent: instance,
@@ -151,6 +159,9 @@ export function initialize_properties_and_components<
         browseNameMap
     );
 
+    // the members a node only organizes, now that their owners were cloned
+    extraInfo.flushDeferred();
+
     reconstructFunctionalGroupType(extraInfo);
 
     reconstructNonHierarchicalReferences(extraInfo);

package/impl/_mandatory_child_or_requested_optional_filter.ts

@@ -25,9 +25,16 @@ export class MandatoryChildOrRequestedOptionalFilter implements CloneFilter {
     private readonly optionalsMap: OptionalMap;
     private readonly references: UAReference[];
     private readonly copyAlsoAllOptionals: boolean = false;
+    /**
+     * the clone is an instance declaration of a type (instantiate() inside a type): the
+     * placeholders its type declares are part of it, as the ModelCompiler emits them
+     * (OPC 10000-100 DI DeviceType/DeviceTypeImage/<ImageIdentifier>). An instance never takes one.
+     */
+    private readonly keepPlaceholders: boolean = false;
 
-    constructor(instance: BaseNode, copyAlsoAllOptionals: boolean, optionalsMap: OptionalMap) {
+    constructor(instance: BaseNode, copyAlsoAllOptionals: boolean, optionalsMap: OptionalMap, keepPlaceholders = false) {
         this.copyAlsoAllOptionals = copyAlsoAllOptionals;
+        this.keepPlaceholders = keepPlaceholders;
         // should we clone the node to be a component or propertyOf of a instance
         assert(null !== instance);
         this.optionalsMap = optionalsMap;
@@ -78,7 +85,8 @@ export class MandatoryChildOrRequestedOptionalFilter implements CloneFilter {
                 // only if in requested optionals
                 return this.copyAlsoAllOptionals || (node.browseName?.name || "") in this.optionalsMap;
             case "OptionalPlaceholder":
-                return false; // ignored
+            case "MandatoryPlaceholder":
+                return this.keepPlaceholders;
             default:
                 return false; // ignored
         }
@@ -94,7 +102,16 @@ export class MandatoryChildOrRequestedOptionalFilter implements CloneFilter {
         }
         /* c8 ignore next */
         doTrace && traceLog("filterFor ", browseName, map);
-        const newFilter = new MandatoryChildOrRequestedOptionalFilter(childInstance, false, map);
+        // a placeholder's copy takes its own members, not the placeholders of its type: the walk
+        // would never end on a type whose placeholder is typed by a type holding one in turn
+        const isPlaceholder =
+            childInstance.modellingRule === "OptionalPlaceholder" || childInstance.modellingRule === "MandatoryPlaceholder";
+        const newFilter = new MandatoryChildOrRequestedOptionalFilter(
+            childInstance,
+            false,
+            map,
+            this.keepPlaceholders && !isPlaceholder
+        );
         return newFilter;
     }
 }

package/impl/base_node_impl.ts

@@ -184,6 +184,8 @@ export interface InternalBaseNodeOptions {
     nodesetDocumentation?: string;
     /** the `<Category>` elements as the nodeset declared them; see BaseNode.nodesetCategory */
     nodesetCategory?: string[];
+    /** `DesignToolOnly="true"` as the nodeset declared it; see BaseNode.designToolOnly */
+    designToolOnly?: boolean;
     /** the AccessRestrictions as declared, whatever this loader applies; see BaseNode */
     declaredAccessRestrictions?: string;
 }
@@ -233,6 +235,8 @@ export abstract class BaseNodeImpl<T extends BaseNodeEvents & ListenerSignature<
     public nodesetDocumentation?: string;
     /** see BaseNode.nodesetCategory; only set when the nodeset declared at least one */
     public nodesetCategory?: string[];
+    /** see BaseNode.designToolOnly; only set when the nodeset declared it */
+    public designToolOnly?: boolean;
     /** see BaseNode.declaredAccessRestrictions */
     public declaredAccessRestrictions?: string;
     private _accessRestrictions?: AccessRestrictionsFlag;
@@ -459,6 +463,9 @@ export abstract class BaseNodeImpl<T extends BaseNodeEvents & ListenerSignature<
         if (options.nodesetCategory && options.nodesetCategory.length > 0) {
             this.nodesetCategory = [...options.nodesetCategory];
         }
+        if (options.designToolOnly) {
+            this.designToolOnly = true;
+        }
         if (options.parentNodeId) {
             _private._declaredParentNodeId =
                 options.parentNodeId instanceof NodeId

package/impl/base_node_private.ts

@@ -595,6 +595,39 @@ function _merge_base_declaration(
     );
 }
 
+/**
+ * whether `declaringNode` is the declared parent (ParentNodeId) of `node` while `reference` links the
+ * two without aggregating it: the parent then names the node, the reference does not
+ */
+function _isDeclaredNonAggregatedMemberOf(node: BaseNode, declaringNode: BaseNode, reference: UAReference): boolean {
+    const declaredParent = node.parentNodeId;
+    if (!declaredParent || !sameNodeId(declaredParent, declaringNode.nodeId)) {
+        return false;
+    }
+    const addressSpace = node.addressSpace;
+    const referenceType = addressSpace.findReferenceType(reference.referenceType);
+    const aggregates = addressSpace.findReferenceType("Aggregates");
+    return !!referenceType && !!aggregates && !referenceType.isSubtypeOf(aggregates);
+}
+
+/**
+ * whether `organizer` reaches `node` through a reference that does not aggregate it, while the
+ * node's declared parent (ParentNodeId) is another node that aggregates it: its owner
+ */
+function _isOrganizedWhileOwnedByAnother(node: BaseNode, organizer: BaseNode, reference: UAReference): boolean {
+    const owner = node.parentNodeId;
+    if (!owner || sameNodeId(owner, organizer.nodeId)) {
+        return false;
+    }
+    const addressSpace = node.addressSpace;
+    const referenceType = addressSpace.findReferenceType(reference.referenceType);
+    const aggregates = addressSpace.findReferenceType("Aggregates");
+    if (!referenceType || !aggregates || referenceType.isSubtypeOf(aggregates)) {
+        return false;
+    }
+    return node.findReferencesEx("Aggregates", BrowseDirection.Inverse).some((r) => sameNodeId(r.nodeId, owner));
+}
+
 /*
  * clone properties and methods
  * @private
@@ -662,6 +695,23 @@ function _clone_collection_new(
         }
         browseNameMap?.add(key);
 
+        // a node this one only organizes, while another node of the template owns it (aggregates
+        // it, as its ParentNodeId), is left to its owner: cloned through this reference first, it
+        // was parentless and named after its browse name alone (OPC 30100 IO-Link:
+        // IOLinkDeviceType/General organizes MethodSet/ApplicationReset). Once the whole tree is
+        // cloned, the owner's clone gets this reference too; a node no owner cloned is cloned here.
+        if (
+            extraInfo instanceof CloneHelper &&
+            extraInfo.canDefer &&
+            _isOrganizedWhileOwnedByAnother(node, nodeToClone, reference)
+        ) {
+            extraInfo.deferInCurrentContext(() => attach(reference, node));
+            continue;
+        }
+        attach(reference, node);
+    }
+
+    function attach(reference: UAReference, node: UAVariable | UAObject | UAMethod): void {
         // assert(reference.isForward);
         // assert(reference.referenceType instanceof NodeId, "" + reference.referenceType.toString());
         const options: CloneOptions = {
@@ -670,6 +720,13 @@ function _clone_collection_new(
             copyAlsoModellingRules,
             baseDeclarations: _base_declarations_of(nodeToClone, node.browseName)
         };
+        // a member that the template declares under the node being cloned (its ParentNodeId), but links
+        // through a reference that does not aggregate it (Organizes), is named after that parent on the
+        // type (`DirectoryType_CertificateGroups`): the clone declares its own parent likewise, or it is
+        // named after its browse name alone and misses its id (`Directory_CertificateGroups`)
+        if (_isDeclaredNonAggregatedMemberOf(node, nodeToClone, reference)) {
+            options.parentNodeId = newParent.nodeId;
+        }
 
         const alreadyCloned = extraInfo.getCloned({ originalParent: nodeToClone, clonedParent: newParent, originalNode: node });
         if (alreadyCloned) {

package/impl/nodeid_manager.ts

@@ -1,6 +1,6 @@
 import type { BaseNode, UAReference, UAReferenceType } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
-import { NodeClass, type QualifiedName, type QualifiedNameOptions } from "node-opcua-data-model";
+import { BrowseDirection, NodeClass, type QualifiedName, type QualifiedNameOptions } from "node-opcua-data-model";
 import { make_debugLog, make_warningLog } from "node-opcua-debug";
 import { makeNodeId, NodeId, type NodeIdLike, NodeIdType, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
 import { setOwnProperty } from "node-opcua-utils";
@@ -86,6 +86,16 @@ function _findParentNodeId(addressSpace: AddressSpacePartial, options: Construct
     return references.length ? _filterAggregates(addressSpace, references) : null;
 }
 
+/** whether the node being built hangs, through an inverse reference, from a node `occupant` hangs from */
+function _shareAnOrganizer(occupant: BaseNode, options: ConstructNodeIdOptions): boolean {
+    const references = (options.references ?? []).filter((r) => !r.isForward);
+    if (references.length === 0) {
+        return false;
+    }
+    const parents = occupant.findReferencesEx("HierarchicalReferences", BrowseDirection.Inverse).map((r) => r.nodeId);
+    return references.some((r) => parents.some((p) => sameNodeId(p, r.nodeId)));
+}
+
 function prepareName(browseName?: QualifiedName | QualifiedNameOptions): string {
     const m = browseName?.name?.toString().replace(/[ ]/g, "").replace(/(<|>)/g, "");
     return m || "";
@@ -110,9 +120,14 @@ export interface ConstructNodeIdOptions {
 export type NodeEntry = [string, number, NodeClass];
 export type NodeEntry1 = [string, number, string /*"Object" | "Variable" etc...*/];
 
+/** the separator of a disambiguated symbolic name (`X__2`): prepareName never produces it from a browse name */
+export const SYMBOLIC_NAME_OCCURRENCE_SEPARATOR = "__";
+
 export class NodeIdManager {
     private _cacheSymbolicName: { [key: string]: [number, NodeClass] } = {};
     private _cacheSymbolicNameRev: Set<number> = new Set<number>();
+    /** the symbolic name each id was registered under, so that a node's members are named after it */
+    private _nameOfId: Map<number, string> = new Map<number, string>();
 
     private _internal_id_counter: number;
     private namespaceIndex: number;
@@ -149,9 +164,51 @@ export class NodeIdManager {
         for (const [name, value, nodeClass] of symbols2) {
             setOwnProperty(this._cacheSymbolicName, name, [value, nodeClass]);
             this._cacheSymbolicNameRev.add(value);
+            if (!this._nameOfId.has(value)) {
+                this._nameOfId.set(value, name);
+            }
+        }
+    }
+
+    private _registerName(name: string, value: number, nodeClass: NodeClass | undefined): void {
+        setOwnProperty(this._cacheSymbolicName, name, [value, nodeClass || NodeClass.Unspecified]);
+        this._cacheSymbolicNameRev.add(value);
+        this._nameOfId.set(value, name);
+    }
+
+    /**
+     * The first `name__n` (n >= 2) a node may take: one the table does not list, or, for a node
+     * whose id is not fixed yet, one listed with an id that no node holds (a preset). A node whose
+     * id is fixed (`nodeId`) takes the name listed with that id, or a new one.
+     */
+    private _nextFreeName(fullName: string, nodeId?: number): { name: string; value?: number } {
+        for (let n = 2; ; n++) {
+            const name = `${fullName}${SYMBOLIC_NAME_OCCURRENCE_SEPARATOR}${n}`;
+            const cached = this._cacheSymbolicName[name];
+            if (!cached) {
+                return { name };
+            }
+            if (
+                nodeId === undefined
+                    ? !this.addressSpace.findNode(makeNodeId(cached[0], this.namespaceIndex))
+                    : cached[0] === nodeId
+            ) {
+                return { name, value: cached[0] };
+            }
         }
     }
 
+    /**
+     * Whether a node whose symbolic name another node holds takes the next free `name__n`: a
+     * parentless node (its name is its browse name alone, which distinct nodes share), and a
+     * child whose browse name differs from its sibling's by the namespace only (`1:Speed` next to
+     * `0:Speed`), which the name does not spell. A child of a string NodeId is not named at all:
+     * its id is built from its parent's.
+     */
+    private _mayTakeAnotherName(parentInfo: [NodeId, Suffix] | null): boolean {
+        return parentInfo === null || parentInfo[0].identifierType === NodeIdType.NUMERIC;
+    }
+
     public getSymbols(): NodeEntry1[] {
         const line: NodeEntry1[] = [];
         for (const [key, [value, nodeClass1]] of Object.entries(this._cacheSymbolicName)) {
@@ -185,6 +242,13 @@ export class NodeIdManager {
         };
 
         const buildUpName2 = (nodeId: NodeId, suffix: string) => {
+            // a parent registered under a name of its own (`X__2`) passes that name on to its members
+            if (nodeId.namespace === this.namespaceIndex && nodeId.identifierType === NodeIdType.NUMERIC) {
+                const registered = this._nameOfId.get(nodeId.value as number);
+                if (registered !== undefined) {
+                    return registered + suffix;
+                }
+            }
             const namespaceIndex = nodeId.namespace;
             let name = "";
             let n: BaseNode | null = this.addressSpace.findNode(nodeId);
@@ -204,17 +268,27 @@ export class NodeIdManager {
                 fullParentName = buildUpName2(parentNodeId, suffix);
             }
             const fullName = compose(fullParentName, prepareName(options.browseName));
+            let name = fullName;
             const cached = this._cacheSymbolicName[fullName];
-            if (cached && this._isCacheHitReusable(cached[0], options, parentInfo)) {
-                return makeNodeId(cached[0], this.namespaceIndex);
+            if (cached) {
+                if (this._isCacheHitReusable(cached[0], options, parentInfo)) {
+                    return makeNodeId(cached[0], this.namespaceIndex);
+                }
+                if (!this._mayTakeAnotherName(parentInfo)) {
+                    // a fresh id, with no name
+                    return this._constructNodeId(options);
+                }
+                // another node holds the name: this one takes the next free `name__n`
+                const free = this._nextFreeName(fullName);
+                if (free.value !== undefined) {
+                    this._nameOfId.set(free.value, free.name);
+                    return makeNodeId(free.value, this.namespaceIndex);
+                }
+                name = free.name;
             }
             const nodeId = this._constructNodeId(options);
-            if (nodeId.identifierType === NodeIdType.NUMERIC && !cached) {
-                setOwnProperty(this._cacheSymbolicName, fullName, [
-                    nodeId.value as number,
-                    options.nodeClass || NodeClass.Unspecified
-                ]);
-                this._cacheSymbolicNameRev.add(nodeId.value as number);
+            if (nodeId.identifierType === NodeIdType.NUMERIC) {
+                this._registerName(name, nodeId.value as number, options.nodeClass);
             }
             return nodeId;
         }
@@ -231,12 +305,17 @@ export class NodeIdManager {
                 fullParentName = buildUpName2(parentNodeId, suffix);
             }
             const fullName = compose(fullParentName, prepareName(options.browseName));
-            if (!this._cacheSymbolicName[fullName]) {
-                setOwnProperty(this._cacheSymbolicName, fullName, [
-                    nodeId.value as number,
-                    options.nodeClass || NodeClass.Unspecified
-                ]);
-                this._cacheSymbolicNameRev.add(nodeId.value as number);
+            const value = nodeId.value as number;
+            const cached = this._cacheSymbolicName[fullName];
+            if (!cached) {
+                this._registerName(fullName, value, options.nodeClass);
+            } else if (cached[0] === value) {
+                this._nameOfId.set(value, fullName);
+            } else if (this._mayTakeAnotherName(parentInfo)) {
+                // another node holds the name (OPC 40502 CNC's three parentless X axes): this
+                // one is listed under the next free `name__n`, as it would be named when built
+                const free = this._nextFreeName(fullName, value);
+                this._registerName(free.name, value, options.nodeClass);
             }
         }
         return nodeId;
@@ -275,9 +354,11 @@ export class NodeIdManager {
             (occupant.browseName.namespaceIndex ?? 0) === (options.browseName?.namespaceIndex ?? 0);
 
         const expectedParentNodeId = parentInfo ? parentInfo[0] : null;
+        // two parentless nodes are the same node only when one node organizes both (the same
+        // node declared twice in a folder); otherwise they merely share a browse name
         const sameParent = expectedParentNodeId
             ? !!occupant.parentNodeId && sameNodeId(occupant.parentNodeId, expectedParentNodeId)
-            : !occupant.parentNodeId;
+            : !occupant.parentNodeId && _shareAnOrganizer(occupant, options);
 
         return sameBrowseName && sameParent;
     }

package/impl/nodeset_tools/dump_to_bsd.ts

@@ -132,7 +132,23 @@ function dumpDataTypeStructure(
     xw.endElement();
 }
 
+/**
+ * whether the 1.03 dictionary describes `dataType`: it lists Structures and Enumerations only. A
+ * basic type's subtype (OPC 30010 AutoID's CodeTypeDataType, a String) has no definition at all,
+ * and a bit-mask OptionSet's lists bits, not values: asking for them threw.
+ */
+function isDescribedInBSD(dataType: UADataType): boolean {
+    if (dataType.isStructure()) {
+        return true;
+    }
+    const isOptionSet = !!(dataType as UADataType & { isOptionSetDataType?: boolean }).isOptionSetDataType;
+    return !isOptionSet && dataType.isEnumeration();
+}
+
 function dumpDataTypeToBSD(xw: XmlWriter, dataType: UADataType, map: Map<number, string>) {
+    if (!isDescribedInBSD(dataType)) {
+        return;
+    }
     const addressSpace = dataType.addressSpace;
 
     const name: string = dataType.browseName.name || "";

package/impl/nodeset_tools/nodeset_to_records.ts

@@ -366,6 +366,9 @@ class RecordExporter {
         if (node.releaseStatus) {
             record.releaseStatus = node.releaseStatus;
         }
+        if (node.designToolOnly) {
+            record.designToolOnly = true;
+        }
         if (node.nodesetCategory && node.nodesetCategory.length > 0) {
             record.category = [...node.nodesetCategory];
         }

package/impl/nodeset_tools/nodeset_to_xml.ts

@@ -685,6 +685,9 @@ function dumpCommonAttributes(xw: XmlWriter, node: BaseNode) {
     if (node.releaseStatus) {
         xw.writeAttribute("ReleaseStatus", node.releaseStatus);
     }
+    if (node.designToolOnly) {
+        xw.writeAttribute("DesignToolOnly", "true");
+    }
     if (Object.hasOwn(node, "isAbstract")) {
         const isAbstract = (node as unknown as { isAbstract: boolean }).isAbstract;
         if (isAbstract) {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "node-opcua-address-space",
     "type": "module",
-    "version": "2.186.1",
+    "version": "2.186.2",
     "description": "pure nodejs OPCUA SDK - module address-space",
     "main": "./dist/api/index.js",
     "types": "./dist/api/index.d.ts",
@@ -23,7 +23,7 @@
         "@types/semver": "7.8.0",
         "chalk": "4.1.2",
         "dequeue": "^1.0.5",
-        "node-opcua-address-space-base": "2.186.1",
+        "node-opcua-address-space-base": "2.186.2",
         "node-opcua-assert": "2.184.0",
         "node-opcua-basic-types": "2.186.1",
         "node-opcua-binary-stream": "2.186.1",
@@ -39,7 +39,7 @@
         "node-opcua-extension-object": "2.186.1",
         "node-opcua-factory": "2.186.1",
         "node-opcua-nodeid": "2.186.1",
-        "node-opcua-nodeset-ua": "2.186.1",
+        "node-opcua-nodeset-ua": "2.186.2",
         "node-opcua-numeric-range": "2.186.1",
         "node-opcua-object-registry": "2.184.0",
         "node-opcua-pseudo-session": "2.186.1",
@@ -64,7 +64,7 @@
         "node-opcua-nodesets": "2.185.0",
         "node-opcua-packet-analyzer": "2.186.1",
         "node-opcua-schemas": "2.186.1",
-        "node-opcua-service-filter": "2.186.1",
+        "node-opcua-service-filter": "2.186.2",
         "node-opcua-test-fixtures": "2.184.0",
         "node-opcua-test-helpers": "2.184.0"
     },
@@ -83,7 +83,7 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "c4b15b4ca645101b2d656a75b2ea9a8a843d25b5",
+    "gitHead": "86af5eac683e2b11900c1e93c232d4adc06b5b77",
     "files": [
         "dist",
         "distHelpers",