@opcua/for-node-red 3.34.2 → 3.36.0

package/node_modules/@sterfive/opcua-pinned/node_modules/node-opcua-address-space/src/namespace_impl.ts

@@ -16,6 +16,7 @@ import type {
     AddViewOptions,
     AddYArrayItemOptions,
     BaseNode,
+
     CreateDataTypeOptions,
     CreateNodeOptions,
     EnumerationItem,
@@ -74,6 +75,7 @@ import type {
     AddTwoStateDiscreteOptions,
     AddTwoStateVariableOptions
 } from "../source/address_space_ts";
+import type { InstantiateConditionOptions } from "../source/interfaces/alarms_and_conditions/instantiate_condition_options";
 import type { InstantiateExclusiveDeviationAlarmOptions } from "../source/interfaces/alarms_and_conditions/instantiate_exclusive_deviation_alarm_options";
 import type { InstantiateNonExclusiveDeviationAlarmOptions } from "../source/interfaces/alarms_and_conditions/instantiate_non_exclusive_deviation_alarm_options";
 import type { InstantiateNonExclusiveLimitAlarmOptions } from "../source/interfaces/alarms_and_conditions/instantiate_non_exclusive_limit_alarm_options";
@@ -93,15 +95,20 @@ import type { UATwoStateVariableEx } from "../source/ua_two_state_variable_ex";
 
 import { _handle_delete_node_model_change_event, _handle_model_change_event } from "./address_space_change_event_tools";
 import type { AddressSpacePrivate } from "./address_space_private";
-import { UAAcknowledgeableConditionImpl, UAAlarmConditionImpl } from "./alarms_and_conditions";
-import { UAConditionImpl } from "./alarms_and_conditions/ua_condition_impl";
+import {
+    type UAAcknowledgeableConditionImpl,
+    UAAcknowledgeableConditionImplBase,
+    UAAlarmConditionImplBase,
+    UAConditionImplBase,
+    UADiscreteAlarmImplBase
+} from "./alarms_and_conditions";
 import { UADiscreteAlarmImpl } from "./alarms_and_conditions/ua_discrete_alarm_impl";
-import { UAExclusiveDeviationAlarmImpl } from "./alarms_and_conditions/ua_exclusive_deviation_alarm_impl";
-import { UAExclusiveLimitAlarmImpl } from "./alarms_and_conditions/ua_exclusive_limit_alarm_impl";
-import { UALimitAlarmImpl } from "./alarms_and_conditions/ua_limit_alarm_impl";
-import { UANonExclusiveDeviationAlarmImpl } from "./alarms_and_conditions/ua_non_exclusive_deviation_alarm_impl";
-import { UANonExclusiveLimitAlarmImpl } from "./alarms_and_conditions/ua_non_exclusive_limit_alarm_impl";
-import { type UAOffNormalAlarmEx, UAOffNormalAlarmImpl } from "./alarms_and_conditions/ua_off_normal_alarm_impl";
+import { UAExclusiveDeviationAlarmImplBase } from "./alarms_and_conditions/ua_exclusive_deviation_alarm_impl";
+import { UAExclusiveLimitAlarmImplBase } from "./alarms_and_conditions/ua_exclusive_limit_alarm_impl";
+import { UALimitAlarmImplBase } from "./alarms_and_conditions/ua_limit_alarm_impl";
+import { UANonExclusiveDeviationAlarmImplBase } from "./alarms_and_conditions/ua_non_exclusive_deviation_alarm_impl";
+import { UANonExclusiveLimitAlarmImplBase } from "./alarms_and_conditions/ua_non_exclusive_limit_alarm_impl";
+import { type UAOffNormalAlarmEx, UAOffNormalAlarmImplBase } from "./alarms_and_conditions/ua_off_normal_alarm_impl";
 import { BaseNodeImpl } from "./base_node_impl";
 import { add_dataItem_stuff } from "./data_access/add_dataItem_stuff";
 import { _addMultiStateDiscrete, type UAMultiStateDiscreteImpl } from "./data_access/ua_multistate_discrete_impl";
@@ -500,7 +507,6 @@ export class NamespaceImpl implements NamespacePrivate {
      * add a variable as a component of the parent node
      */
     public addVariable(options: AddVariableOptions): UAVariable {
-        assert(arguments.length === 1, "Invalid arguments IAddressSpace#addVariable now takes only one argument.");
         if (Object.hasOwn(options, "propertyOf") && options.propertyOf) {
             assert(!options.typeDefinition || options.typeDefinition === "PropertyType");
             options.typeDefinition = options.typeDefinition || "PropertyType";
@@ -572,11 +578,11 @@ export class NamespaceImpl implements NamespacePrivate {
 
         const addressSpace = this.addressSpace;
 
-        assert(!(options as any).typeDefinition, "addFolder does not expect typeDefinition to be defined ");
+        assert(!(options as CreateNodeOptions).typeDefinition, "addFolder does not expect typeDefinition to be defined ");
         const typeDefinition = addressSpace._coerceTypeDefinition("FolderType");
         parentFolder = addressSpace._coerceFolder(parentFolder) as UAObject;
-        (options as any).nodeClass = NodeClass.Object;
-        (options as any).references = [
+        (options as CreateNodeOptions).nodeClass = NodeClass.Object;
+        (options as CreateNodeOptions).references = [
             { referenceType: "HasTypeDefinition", isForward: true, nodeId: typeDefinition },
             { referenceType: "Organizes", isForward: false, nodeId: parentFolder.nodeId }
         ];
@@ -669,7 +675,7 @@ export class NamespaceImpl implements NamespacePrivate {
      * @internal
      */
     public createNode(options: CreateNodeOptions): BaseNode {
-        let node: BaseNode = null as any as BaseNode;
+        let node: BaseNode = null as unknown as BaseNode;
 
         const addressSpace = this.addressSpace;
         addressSpace.modelChangeTransaction(() => {
@@ -712,11 +718,11 @@ export class NamespaceImpl implements NamespacePrivate {
      *
      */
     public deleteNode(nodeOrNodeId: NodeId | BaseNode): void {
-        let node: BaseNode | null = null;
+        let node: BaseNodeImpl | null = null;
         let nodeId: NodeId = new NodeId();
         if (nodeOrNodeId instanceof NodeId) {
             nodeId = nodeOrNodeId;
-            node = this.findNode(nodeId);
+            node = this.findNode(nodeId) as BaseNodeImpl;
             // c8 ignore next
             if (!node) {
                 throw new Error(` deleteNode : cannot find node with nodeId${nodeId.toString()}`);
@@ -819,7 +825,7 @@ export class NamespaceImpl implements NamespacePrivate {
      *      });
      *
      */
-    public addEventType(options: any): UAObjectType {
+    public addEventType(options: AddObjectTypeOptions): UAObjectType {
         options.subtypeOf = options.subtypeOf || "BaseEventType";
         // are eventType always abstract ?? No => Condition can be instantiated!
         // but, by default is abstract is true
@@ -899,7 +905,7 @@ export class NamespaceImpl implements NamespacePrivate {
 
         const clone_options = { ...options, dataType, typeDefinition: analogItemType.nodeId } as AddVariableOptions;
 
-        const variable = this.addVariable(clone_options) as UAVariableImpl;
+        const variable = this.addVariable(clone_options) as unknown as UAVariableImpl;
 
         add_dataItem_stuff(variable, options);
 
@@ -925,7 +931,7 @@ export class NamespaceImpl implements NamespacePrivate {
                 dataType: DataType.ExtensionObject,
                 value: new Range(options.engineeringUnitsRange)
             })
-        }) as UAVariableImpl;
+        }) as unknown as UAVariableImpl;
 
         assert(euRange.readValue().value.value instanceof Range);
 
@@ -1084,8 +1090,8 @@ export class NamespaceImpl implements NamespacePrivate {
             optionals
         }) as UAYArrayItemEx<DataType.Float | DataType.Double>;
 
-        function coerceAxisScale(value: any) {
-            const ret = AxisScaleEnumeration[value];
+        function coerceAxisScale(value: unknown) {
+            const ret = AxisScaleEnumeration[value as keyof typeof AxisScaleEnumeration];
             assert(!isNullOrUndefined(ret));
             return ret;
         }
@@ -1448,8 +1454,15 @@ export class NamespaceImpl implements NamespacePrivate {
 
         assert(_component.nodeClass === NodeClass.Object || _component.nodeClass === NodeClass.ObjectType);
 
-        const initialStateType = addressSpace.findObjectType("InitialStateType")!;
-        const stateType = addressSpace.findObjectType("StateType")!;
+        const initialStateType = addressSpace.findObjectType("InitialStateType");
+        const stateType = addressSpace.findObjectType("StateType");
+
+        if (!initialStateType) {
+            throw new Error("Cannot find InitialStateType");
+        }
+        if (!stateType) {
+            throw new Error("Cannot find StateType");
+        }
 
         let state: UAState | UAInitialState;
         if (isInitialState) {
@@ -1558,10 +1571,10 @@ export class NamespaceImpl implements NamespacePrivate {
     // --- Alarms & Conditions -------------------------------------------------
     public instantiateCondition(
         conditionTypeId: UAEventType | NodeId | string,
-        options: any,
+        options: InstantiateConditionOptions,
         data: Record<string, VariantOptions>
     ): UAConditionEx {
-        return UAConditionImpl.instantiate(this, conditionTypeId, options, data);
+        return UAConditionImplBase.instantiate(this, conditionTypeId, options, data);
     }
 
     public instantiateAcknowledgeableCondition(
@@ -1569,7 +1582,7 @@ export class NamespaceImpl implements NamespacePrivate {
         options: InstantiateAlarmConditionOptions,
         data?: Record<string, VariantOptions>
     ): UAAcknowledgeableConditionImpl {
-        return UAAcknowledgeableConditionImpl.instantiate(this, conditionTypeId, options, data);
+        return UAAcknowledgeableConditionImplBase.instantiate(this, conditionTypeId, options, data);
     }
 
     public instantiateAlarmCondition(
@@ -1577,7 +1590,7 @@ export class NamespaceImpl implements NamespacePrivate {
         options: InstantiateAlarmConditionOptions,
         data?: Record<string, VariantOptions>
     ): UAAlarmConditionEx {
-        return UAAlarmConditionImpl.instantiate(this, alarmConditionTypeId, options, data);
+        return UAAlarmConditionImplBase.instantiate(this, alarmConditionTypeId, options, data);
     }
 
     public instantiateLimitAlarm(
@@ -1585,7 +1598,7 @@ export class NamespaceImpl implements NamespacePrivate {
         options: InstantiateLimitAlarmOptions,
         data?: Record<string, VariantOptions>
     ): UALimitAlarmEx {
-        return UALimitAlarmImpl.instantiate(this, limitAlarmTypeId, options, data);
+        return UALimitAlarmImplBase.instantiate(this, limitAlarmTypeId, options, data);
     }
 
     public instantiateExclusiveLimitAlarm(
@@ -1593,14 +1606,14 @@ export class NamespaceImpl implements NamespacePrivate {
         options: InstantiateLimitAlarmOptions,
         data?: Record<string, VariantOptions>
     ): UAExclusiveLimitAlarmEx {
-        return UAExclusiveLimitAlarmImpl.instantiate(this, exclusiveLimitAlarmTypeId, options, data);
+        return UAExclusiveLimitAlarmImplBase.instantiate(this, exclusiveLimitAlarmTypeId, options, data);
     }
 
     public instantiateExclusiveDeviationAlarm(
         options: InstantiateExclusiveDeviationAlarmOptions,
         data?: Record<string, VariantOptions>
     ): UAExclusiveDeviationAlarmEx {
-        return UAExclusiveDeviationAlarmImpl.instantiate(this, "ExclusiveDeviationAlarmType", options, data);
+        return UAExclusiveDeviationAlarmImplBase.instantiate(this, "ExclusiveDeviationAlarmType", options, data);
     }
 
     public instantiateNonExclusiveLimitAlarm(
@@ -1608,14 +1621,14 @@ export class NamespaceImpl implements NamespacePrivate {
         options: InstantiateNonExclusiveLimitAlarmOptions,
         data?: Record<string, VariantOptions>
     ): UANonExclusiveLimitAlarmEx {
-        return UANonExclusiveLimitAlarmImpl.instantiate(this, nonExclusiveLimitAlarmTypeId, options, data);
+        return UANonExclusiveLimitAlarmImplBase.instantiate(this, nonExclusiveLimitAlarmTypeId, options, data);
     }
 
     public instantiateNonExclusiveDeviationAlarm(
         options: InstantiateNonExclusiveDeviationAlarmOptions,
         data?: Record<string, VariantOptions>
     ): UANonExclusiveDeviationAlarmEx {
-        return UANonExclusiveDeviationAlarmImpl.instantiate(this, "NonExclusiveDeviationAlarmType", options, data);
+        return UANonExclusiveDeviationAlarmImplBase.instantiate(this, "NonExclusiveDeviationAlarmType", options, data);
     }
 
     public instantiateDiscreteAlarm(
@@ -1623,13 +1636,13 @@ export class NamespaceImpl implements NamespacePrivate {
         options: InstantiateAlarmConditionOptions,
         data?: Record<string, VariantOptions>
     ): UADiscreteAlarmEx {
-        return UADiscreteAlarmImpl.instantiate(this, discreteAlarmType, options, data);
+        return UADiscreteAlarmImplBase.instantiate(this, discreteAlarmType, options, data);
     }
     public instantiateOffNormalAlarm(
         options: InstantiateOffNormalAlarmOptions,
         data?: Record<string, VariantOptions>
     ): UAOffNormalAlarmEx {
-        return UAOffNormalAlarmImpl.instantiate(this, "OffNormalAlarmType", options, data);
+        return UAOffNormalAlarmImplBase.instantiate(this, "OffNormalAlarmType", options, data);
     }
 
     // default roles and permissions
@@ -1661,12 +1674,12 @@ export class NamespaceImpl implements NamespacePrivate {
         if (node.nodeId.namespace !== this.index) {
             throw new Error(
                 "node must belong to this namespace : " +
-                node.nodeId.toString() +
-                "  " +
-                " node.browseName = " +
-                node.browseName.toString() +
-                " this.index = " +
-                this.index
+                    node.nodeId.toString() +
+                    "  " +
+                    " node.browseName = " +
+                    node.browseName.toString() +
+                    " this.index = " +
+                    this.index
             );
         }
         assert(node.nodeId.namespace === this.index, "node must belongs to this namespace");
@@ -1676,24 +1689,24 @@ export class NamespaceImpl implements NamespacePrivate {
 
         // c8 ignore next
         if (this._nodeid_index.has(hashKey)) {
-            const existingNode = this.findNode(node.nodeId)!;
+            const existingNode = this.findNode(node.nodeId);
             throw new Error(
                 "node " +
-                node.browseName.toString() +
-                " nodeId = " +
-                node.nodeId.displayText() +
-                " already registered " +
-                node.nodeId.toString() +
-                "\n" +
-                " in namespace " +
-                this.namespaceUri +
-                " index = " +
-                this.index +
-                "\n" +
-                "existing node = " +
-                existingNode.toString() +
-                "this parent : " +
-                node.parentNodeId?.toString()
+                    node.browseName.toString() +
+                    " nodeId = " +
+                    node.nodeId.displayText() +
+                    " already registered " +
+                    node.nodeId.toString() +
+                    "\n" +
+                    " in namespace " +
+                    this.namespaceUri +
+                    " index = " +
+                    this.index +
+                    "\n" +
+                    "existing node = " +
+                    existingNode?.toString() +
+                    "this parent : " +
+                    node.parentNodeId?.toString()
             );
         }
 
@@ -1756,15 +1769,15 @@ export class NamespaceImpl implements NamespacePrivate {
                     errorLog(
                         chalk.red.bold(
                             "Error: namespace index used at the front of the browseName " +
-                            indexVerify +
-                            " do not match the index of the current namespace (" +
-                            this.index +
-                            ")"
+                                indexVerify +
+                                " do not match the index of the current namespace (" +
+                                this.index +
+                                ")"
                         )
                     );
                     errorLog(
                         " Please fix your code so that the created node is inserted in the correct namespace," +
-                        " please refer to the NodeOPCUA documentation"
+                            " please refer to the NodeOPCUA documentation"
                     );
                 }
             }
@@ -2019,7 +2032,7 @@ export class NamespaceImpl implements NamespacePrivate {
             warningLog(
                 "[NODE-OPCUA-W30",
                 "namespace#addVariable a getter has been specified and minimumSamplingInterval is missing.\nMinimumSamplingInterval has been adjusted to 1000 ms\nvariable = " +
-                options?.browseName?.toString()
+                    options?.browseName?.toString()
             );
             options.minimumSamplingInterval = 1000;
         }
@@ -2087,7 +2100,7 @@ export class NamespaceImpl implements NamespacePrivate {
     }
 }
 
-const _constructors_map: Record<keyof Omit<typeof NodeClass, "Unspecified">, typeof BaseNodeImpl> = {
+const _constructors_map: Record<keyof Omit<typeof NodeClass, "Unspecified">, new (options: any) => BaseNodeImpl<any>> = {
     DataType: UADataTypeImpl,
     Method: UAMethodImpl,
     Object: UAObjectImpl,

package/node_modules/@sterfive/opcua-pinned/node_modules/node-opcua-address-space/src/namespace_private.ts

@@ -9,14 +9,13 @@ import type {
     INamespace,
     ModellingRuleType,
     RequiredModel,
-    UADataType,
+    UADataType
 } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import type { NodeId } from "node-opcua-nodeid";
 
 import type { AddressSpacePrivate } from "./address_space_private";
 
-
 export interface NamespacePrivate extends INamespace {
     addressSpace: AddressSpacePrivate;
 
@@ -45,8 +44,6 @@ export interface NamespacePrivate extends INamespace {
     _variableTypeCount(): number;
     _dataTypeCount(): number;
     _referenceTypeCount(): number;
-
-
 }
 
 export declare const NamespacePrivate: new (options: unknown) => NamespacePrivate;
@@ -67,10 +64,7 @@ function isValidModellingRule(ruleName: string) {
  * @param modellingRule
  * @private
  */
-export function UANamespace_process_modelling_rule(
-    references: AddReferenceOpts[],
-    modellingRule?: ModellingRuleType
-): void {
+export function UANamespace_process_modelling_rule(references: AddReferenceOpts[], modellingRule?: ModellingRuleType): void {
     if (modellingRule) {
         assert(isValidModellingRule(modellingRule), "expecting a valid modelling rule");
         const modellingRuleName = `ModellingRule_${modellingRule}`;

package/node_modules/@sterfive/opcua-pinned/node_modules/node-opcua-address-space/src/nodeid_manager.ts

@@ -1,20 +1,21 @@
 /* eslint-disable max-depth */
 /* eslint-disable max-statements */
+
+import type { BaseNode, UAReference, UAReferenceType } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
-import { NodeClass, QualifiedName, QualifiedNameLike, QualifiedNameOptions } from "node-opcua-data-model";
-import { makeNodeId, NodeId, NodeIdLike, NodeIdType, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
+import { NodeClass, type QualifiedName, type QualifiedNameOptions } from "node-opcua-data-model";
 import { make_debugLog, make_warningLog } from "node-opcua-debug";
-import { AddReferenceOpts, BaseNode, UAReference, UAReferenceType } from "node-opcua-address-space-base";
-import { getReferenceType } from "./base_node_impl";
-import { resolveReferenceNode, resolveReferenceType } from "./reference_impl";
+import { makeNodeId, NodeId, type NodeIdLike, NodeIdType, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
+import { BaseNodeImpl, getReferenceType } from "./base_node_impl";
+import { resolveReferenceType } from "./reference_impl";
 
-const debugLog = make_debugLog(__filename);
-const warningLog = make_warningLog(__filename);
+const _debugLog = make_debugLog(__filename);
+const _warningLog = make_warningLog(__filename);
 
 export const NamespaceOptions = {
     nodeIdNameSeparator: "-"
 };
-function isValidNodeClass(nodeClass: NodeClass) {
+function _isValidNodeClass(nodeClass: NodeClass) {
     return typeof (NodeClass as any)[nodeClass] === "string";
 }
 
@@ -25,24 +26,24 @@ const hasEncoding = resolveNodeId("HasEncoding");
 type Suffix = string;
 
 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 => {
+    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)
-    }
+        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')");
+    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;
     }
@@ -61,7 +62,7 @@ function _findParentNodeId(addressSpace: AddressSpacePartial, options: Construct
         (ref as any)._referenceType = addressSpace.findReferenceType(ref.referenceType);
         /* c8 ignore next */
         if (!getReferenceType(ref)) {
-            throw new Error("Cannot find referenceType " + JSON.stringify(ref));
+            throw new Error(`Cannot find referenceType ${JSON.stringify(ref)}`);
         }
         (ref as any).referenceType = (ref as any)._referenceType.nodeId;
     }
@@ -70,8 +71,8 @@ function _findParentNodeId(addressSpace: AddressSpacePartial, options: Construct
 }
 
 function prepareName(browseName?: QualifiedName | QualifiedNameOptions): string {
-    const m = browseName!.name!.toString().replace(/[ ]/g, "").replace(/(<|>)/g, "");
-    return m;
+    const m = browseName?.name?.toString().replace(/[ ]/g, "").replace(/(<|>)/g, "");
+    return m ||"";
 }
 
 export interface AddressSpacePartial {
@@ -120,7 +121,7 @@ export class NodeIdManager {
     public getSymbols(): NodeEntry1[] {
         const line: NodeEntry1[] = [];
         for (const [key, [value, nodeClass1]] of Object.entries(this._cacheSymbolicName)) {
-            const node = this.addressSpace.findNode(makeNodeId(value, this.namespaceIndex));
+            const _node = this.addressSpace.findNode(makeNodeId(value, this.namespaceIndex));
             const nodeClass = NodeClass[nodeClass1 || NodeClass.Unspecified];
             line.push([key, value, nodeClass]);
         }
@@ -145,10 +146,10 @@ export class NodeIdManager {
     }
 
     public constructNodeId(options: ConstructNodeIdOptions): NodeId {
+        const compose = (left: string, right: string) => {
+            return right ? (left ? `${left}_${right}` : right) : left;
+        };
 
-        const compose = (left: string, right: string) => { return right ? (left ? left + '_' + right : right) : left };
-
-        
         const buildUpName2 = (nodeId: NodeId, suffix: string) => {
             const namespaceIndex = nodeId.namespace;
             let name = "";
@@ -159,7 +160,7 @@ export class NodeIdManager {
                 n = n.parentNodeId ? this.addressSpace.findNode(n.parentNodeId) : null;
             }
             return name;
-        }
+        };
 
         if (!options.nodeId && options.registerSymbolicNames) {
             const parentInfo = this.findParentNodeId(options);
@@ -185,14 +186,16 @@ export class NodeIdManager {
     private _constructNodeId(options: ConstructNodeIdOptions): NodeId {
 
         const resolveNodeIdEx = (nodeId: BaseNode | NodeIdLike) =>
-            (nodeId && typeof nodeId == "object" && nodeId instanceof BaseNode) ? nodeId.nodeId : resolveNodeId(nodeId);
+            nodeId && typeof nodeId === "object" && nodeId instanceof BaseNodeImpl
+                ? nodeId.nodeId
+                : resolveNodeId(nodeId as NodeIdLike);
 
         let nodeId = options.nodeId;
 
         if (!nodeId) {
             const parentInfo = this.findParentNodeId(options);
             if (parentInfo) {
-                const [parentNodeId, linkName] = parentInfo;
+                const [parentNodeId, _linkName] = parentInfo;
                 const name = prepareName(options.browseName);
                 nodeId = null;
                 if (parentNodeId.identifierType === NodeId.NodeIdType.STRING) {
@@ -207,7 +210,7 @@ export class NodeIdManager {
                 if (nodeId.match(regExp2)) {
                     // nothing
                 } else if (nodeId.match(regExp1)) {
-                    nodeId = "ns=" + this.namespaceIndex + ";" + nodeId;
+                    nodeId = `ns=${this.namespaceIndex};${nodeId}`;
                     // } else {
                     //     nodeId = this._getOrCreateFromName(nodeId, nodeClass);
                 }
@@ -229,6 +232,6 @@ export class NodeIdManager {
 
     private _isInCache(nodeId: NodeId): boolean {
         if (nodeId.namespace !== this.namespaceIndex || nodeId.identifierType !== NodeIdType.NUMERIC) return false;
-        return this._cacheSymbolicNameRev.has(nodeId.value as number) ? true : false;
+        return !!this._cacheSymbolicNameRev.has(nodeId.value as number);
     }
 }

package/node_modules/@sterfive/opcua-pinned/node_modules/node-opcua-address-space/src/nodeset_tools/adjust_namespace_array.ts

@@ -1,4 +1,4 @@
-import { IAddressSpace, UAVariable } from "node-opcua-address-space-base";
+import type { IAddressSpace, UAVariable } from "node-opcua-address-space-base";
 
 export function adjustNamespaceArray(addressSpace: IAddressSpace): void {
     const namepsaceArrayVar = addressSpace.findNode("Server_NamespaceArray") as UAVariable;

package/node_modules/@sterfive/opcua-pinned/node_modules/node-opcua-address-space/src/nodeset_tools/construct_namespace_dependency.ts

@@ -1,18 +1,18 @@
-import { IAddressSpace, INamespace, UADataType, UAVariable, UAVariableType } from "node-opcua-address-space-base";
-import { NodeClass } from "node-opcua-data-model";
-import { StructureField } from "node-opcua-types";
-import { DataType } from "node-opcua-basic-types";
-import { ExtensionObject } from "node-opcua-extension-object";
-import { Variant } from "node-opcua-variant";
+import type { IAddressSpace, INamespace, UADataType, UAVariable, UAVariableType } from "node-opcua-address-space-base";
 import assert from "node-opcua-assert";
+import { DataType } from "node-opcua-basic-types";
+import { NodeClass } from "node-opcua-data-model";
 import { make_debugLog, make_warningLog } from "node-opcua-debug";
-import { NamespacePrivate } from "../namespace_private";
-import { BaseNodeImpl, getReferenceType } from "../base_node_impl";
-import { UAVariableImpl } from "../ua_variable_impl";
-import { TranslationTable } from "../../source/xml_writer";
+import type { ExtensionObject } from "node-opcua-extension-object";
+import type { StructureField } from "node-opcua-types";
+import { Variant } from "node-opcua-variant";
+import type { TranslationTable } from "../../source/xml_writer";
+import { type BaseNodeImpl, getReferenceType } from "../base_node_impl";
+import type { NamespacePrivate } from "../namespace_private";
+import type { UAVariableImpl } from "../ua_variable_impl";
 
 const warningLog = make_warningLog(__filename);
-const debugLog = make_debugLog(__filename);
+const _debugLog = make_debugLog(__filename);
 
 // eslint-disable-next-line max-statements, complexity
 export function _recomputeRequiredModelsFromTypes(
@@ -134,7 +134,7 @@ export function _recomputeRequiredModelsFromTypes(
                     consider(dataTypeNode.nodeId.namespace);
                 } else {
                     // c8 ignore next
-                    if (dataTypeNodeId.value != 0) {
+                    if (dataTypeNodeId.value !== 0) {
                         warningLog("Warning: Cannot find dataType", dataTypeNodeId.toString());
                     }
                 }
@@ -195,7 +195,6 @@ export function _getCompleteRequiredModelsFromValuesAndReferences(
     priorityList: number[],
     cache?: Map<number, { requiredNamespaceIndexes: number[]; nbTypes: number }>
 ): number[] {
-
     const namespace_ = namespace as NamespacePrivate;
 
     const thisPriority = priorityList[namespace.index];
@@ -208,16 +207,17 @@ export function _getCompleteRequiredModelsFromValuesAndReferences(
             requiredModelsSet.add(requiredModel);
             requiredNamespaceIndexes.push(requiredModel);
         }
-    }
+    };
+
+    const addressSpace = namespace.addressSpace;
+    const nonHierarchicalReferencesType = addressSpace.findReferenceType("NonHierarchicalReferences");
 
     //const maxIndex = Math.max(...requiredNamespaceIndexes);
     for (const node of namespace_.nodeIterator()) {
         const references = (<BaseNodeImpl>node).allReferences();
         for (const reference of references) {
-            // if (reference.isForward) continue;
-            // only look at backward reference
             // check referenceId
-            const namespaceIndexOfReferenceType = getReferenceType(reference)!.nodeId.namespace;
+            const namespaceIndexOfReferenceType = getReferenceType(reference)?.nodeId.namespace;
             if (namespaceIndexOfReferenceType !== 0 && namespaceIndexOfReferenceType !== namespace.index) {
                 const refPriority = priorityList[namespaceIndexOfReferenceType];
                 if (refPriority <= thisPriority) {
@@ -229,6 +229,29 @@ export function _getCompleteRequiredModelsFromValuesAndReferences(
                 const refPriority = priorityList[namespaceIndexOfTargetNode];
                 if (refPriority <= thisPriority) {
                     consider(namespaceIndexOfTargetNode);
+                } else {
+                    const referenceType = getReferenceType(reference);
+                    if (referenceType) {
+                        // For forward NonHierarchicalReferences (e.g. HasInterface),
+                        // always include the target namespace as a dependency
+                        // regardless of priority, since the current node owns
+                        // this relationship.
+                        if (reference.isForward
+                            && nonHierarchicalReferencesType
+                            && referenceType.isSubtypeOf(nonHierarchicalReferencesType)) {
+                            consider(namespaceIndexOfTargetNode);
+                        }
+                        // For inverse HierarchicalReferences (e.g. Organizes),
+                        // always include the target namespace as a dependency
+                        // regardless of priority, since the reference is
+                        // stored on this node (organizedBy pattern).
+                        const hierarchicalReferencesType = addressSpace.findReferenceType("HierarchicalReferences");
+                        if (!reference.isForward
+                            && hierarchicalReferencesType
+                            && referenceType.isSubtypeOf(hierarchicalReferencesType)) {
+                            consider(namespaceIndexOfTargetNode);
+                        }
+                    }
                 }
             }
         }
@@ -312,7 +335,7 @@ export function constructNamespacePriorityTable(addressSpace: IAddressSpace): {
     return { loadingOrder, priorityTable };
 }
 
-const doDebug = false;
+const _doDebug = false;
 export function constructNamespaceDependency(namespace: INamespace, priorityTable?: number[]): INamespace[] {
     const addressSpace = namespace.addressSpace;
     priorityTable = priorityTable || constructNamespacePriorityTable(addressSpace).priorityTable;