node-opcua-address-space-base 2.169.0 → 2.172.0

package/source/base_node.ts

@@ -1,8 +1,7 @@
-import { EventEmitter } from "events";
-
-export type Duration = number;
-
-import {
+import  { EventEmitter } from "node:events";
+import type { UAString, UInt32 } from "node-opcua-basic-types";
+import type { ReferenceTypeIds } from "node-opcua-constants";
+import type {
     AccessRestrictionsFlag,
     AttributeIds,
     BrowseDirection,
@@ -13,14 +12,11 @@ import {
     QualifiedNameLike,
     QualifiedNameOptions
 } from "node-opcua-data-model";
-import { DataType } from "node-opcua-variant";
-import { DataValue, DataValueOptions } from "node-opcua-data-value";
-import { NodeId, NodeIdLike } from "node-opcua-nodeid";
-import { NumericRange } from "node-opcua-numeric-range";
-import { StatusCode } from "node-opcua-status-code";
-
-import {
-    BrowseDescription,
+import type { DataValue } from "node-opcua-data-value";
+import type { NodeId, NodeIdLike } from "node-opcua-nodeid";
+import type { NumericRange } from "node-opcua-numeric-range";
+import type { StatusCode } from "node-opcua-status-code";
+import type {
     BrowseDescriptionOptions,
     ReferenceDescription,
     RelativePathElement,
@@ -28,20 +24,19 @@ import {
     RolePermissionTypeOptions,
     WriteValueOptions
 } from "node-opcua-types";
+import type { DataType } from "node-opcua-variant";
+import type { IAddressSpace } from "./address_space";
+import type { IEventData } from "./i_event_data";
+import type { ModellingRuleType } from "./modelling_rule_type";
+import type { INamespace } from "./namespace";
+import type { ISessionContext } from "./session_context";
+import type { UAObject } from "./ua_object";
+import type { UAProperty } from "./ua_property";
+import type { UAReference } from "./ua_reference";
+import type { UAReferenceType } from "./ua_reference_type";
+import type { UAVariable } from "./ua_variable";
 
-import { UAString, UInt32 } from "node-opcua-basic-types";
-import { ReferenceTypeIds } from "node-opcua-constants";
-
-import { INamespace } from "./namespace";
-import { IAddressSpace } from "./address_space";
-import { ModellingRuleType } from "./modelling_rule_type";
-import { ISessionContext } from "./session_context";
-import { UAObject } from "./ua_object";
-import { UAReferenceType } from "./ua_reference_type";
-import { UAVariable } from "./ua_variable";
-import { UAVariableT } from "./ua_variable_t";
-import { UAReference } from "./ua_reference";
-import { UAProperty } from "./ua_property";
+export type Duration = number;
 
 export declare interface AddReferenceOpts {
     referenceType: keyof ReferenceTypeIds | NodeIdLike | UAReferenceType;
@@ -85,45 +80,104 @@ export interface BrowseDescriptionOptions2 extends BrowseDescriptionOptions {
     resultMask: UInt32;
 }
 
-export declare class BaseNode extends EventEmitter {
-    public get addressSpace(): IAddressSpace;
-    public readonly browseName: QualifiedName;
-    public get displayName(): LocalizedText[];
-    public get description(): LocalizedText;
-    public readonly nodeClass: NodeClass;
-    public readonly nodeId: NodeId;
-    public get modellingRule(): ModellingRuleType | undefined;
-    public get parentNodeId(): NodeId | undefined;
-    public get accessRestrictions(): AccessRestrictionsFlag | undefined;
-    public get rolePermissions(): RolePermissionType[] | undefined;
+export type AttributeEventName =
+    | "Value_changed"
+    | "DisplayName_changed"
+    | "Description_changed"
+    | "BrowseName_changed"
+    | "RolePermissions_changed"
+    | "AccessRestrictions_changed";
+
+export interface BaseNodeEvents_ {
+    dispose: [];
+    event: [attribute: IEventData];
+    Value_changed: [attribute: DataValue];
+    DisplayName_changed: [attribute: DataValue];
+    Description_changed: [attribute: DataValue];
+    BrowseName_changed: [attribute: DataValue];
+    RolePermissions_changed: [attribute: DataValue];
+    AccessRestrictions_changed: [attribute: DataValue];
+}
+
+export interface BaseNodeEvents {
+    dispose: () => void;
+    event: (attribute: IEventData) => void;
+    Value_changed: (attribute: DataValue) => void;
+    DisplayName_changed: (attribute: DataValue) => void;
+    Description_changed: (attribute: DataValue) => void;
+    BrowseName_changed: (attribute: DataValue) => void;
+    RolePermissions_changed: (attribute: DataValue) => void;
+    AccessRestrictions_changed: (attribute: DataValue) => void;
+}
+
+// Self-referential constraint: every property of L must be a function.
+// Lets us drop the broken `T[K] extends (...) => ...` conditionals while
+// preserving exact callback signatures (named params, optional args) for IntelliSense.
+export type ListenerSignature<L> = {
+    // biome-ignore lint/suspicious/noExplicitAny: any is required to bypass function-parameter contravariance; using unknown breaks T[K] assignability
+    [E in keyof L]: (...args: any[]) => any;
+};
+
+export interface ITypedEventEmitter<T extends ListenerSignature<T>> {
+    on<K extends keyof T>(event: K, listener: T[K]): this;
+    once<K extends keyof T>(event: K, listener: T[K]): this;
+    emit<K extends keyof T>(event: K, ...args: Parameters<T[K]>): boolean;
+    off<K extends keyof T>(event: K, listener: T[K]): this;
+
+    listenerCount<K extends keyof T>(event: K): number;
+
+    setMaxListeners(n: number): void;
+    removeAllListeners(): void;
+    removeListener<K extends keyof T>(event: K, listener: T[K]): void;
+}
+
+// Aliases Node's EventEmitter directly so listeners receive `this === <emitter>`, matching
+// the standard EventEmitter contract. The previous composition-based implementation invoked
+// listeners with `this` bound to a private inner emitter, breaking that contract.
+export type TypedEventEmitter<T extends ListenerSignature<T>> = ITypedEventEmitter<T>;
+export const TypedEventEmitter = EventEmitter as unknown as {
+    new <T extends ListenerSignature<T>>(): ITypedEventEmitter<T>;
+};
+export interface BaseNode<T extends BaseNodeEvents & ListenerSignature<T> = BaseNodeEvents> extends ITypedEventEmitter<T> {
+ 
+    readonly nodeClass: NodeClass;
+    get addressSpace(): IAddressSpace;
+    readonly browseName: QualifiedName;
+    get displayName(): LocalizedText[];
+    get description(): LocalizedText;
+    readonly nodeId: NodeId;
+    get modellingRule(): ModellingRuleType | undefined;
+    get parentNodeId(): NodeId | undefined;
+    get accessRestrictions(): AccessRestrictionsFlag | undefined;
+    get rolePermissions(): RolePermissionType[] | undefined;
 
     // access to parent namespace
-    public get namespaceIndex(): number;
-    public get namespaceUri(): string;
-    public get namespace(): INamespace;
+    get namespaceIndex(): number;
+    get namespaceUri(): string;
+    get namespace(): INamespace;
 
-    public isDisposed(): boolean;
+    isDisposed(): boolean;
 
-    public onFirstBrowseAction?: (this: BaseNode) => Promise<void>;
+    onFirstBrowseAction?: (this: BaseNode) => Promise<void>;
 
     /**
      * return a complete name of this object by pre-pending
      * name of its parent(s) to its own name
      */
-    public fullName(): string;
+    fullName(): string;
 
-    public addReference(options: AddReferenceOpts): void;
+    addReference(options: AddReferenceOpts): void;
 
-    public removeReference(referenceOpts: AddReferenceOpts): void;
+    removeReference(referenceOpts: AddReferenceOpts): void;
 
-    public readAttribute(
+    readAttribute(
         context: ISessionContext | null,
         attributeId: AttributeIds,
         indexRange?: NumericRange,
         dataEncoding?: QualifiedNameLike | null
     ): DataValue;
 
-    public writeAttribute(
+    writeAttribute(
         context: ISessionContext | null,
         writeValue: WriteValueOptions,
         callback: (err: Error | null, statusCode?: StatusCode) => void
@@ -133,26 +187,26 @@ export declare class BaseNode extends EventEmitter {
      * return a array with the event source of this object.
      * self = HasEventSource => nodes
      */
-    public getEventSources(): BaseNode[];
+    getEventSources(): BaseNode[];
 
     /**
      * return a array of the objects for which this node is an EventSource
      * nodes = HasEventSource => self
      */
-    public getEventSourceOfs(): BaseNode[];
+    getEventSourceOfs(): BaseNode[];
 
     /**
      *
      * @param locale the locale of the text to return (e.g. en-EN)
      */
-    public getDisplayName(locale?: string): string;
+    getDisplayName(locale?: string): string;
 
     /**
      * private
      */
-    public install_extra_properties(): void;
+    install_extra_properties(): void;
 
-    public browseNodeByTargetName(relativePathElement: RelativePathElement, isLast: boolean): NodeId[];
+    browseNodeByTargetName(relativePathElement: RelativePathElement, isLast: boolean): NodeId[];
 
     /**
      * find all the references that are of type **`reference`** or a sub type of **`reference`**, in the
@@ -160,7 +214,7 @@ export declare class BaseNode extends EventEmitter {
      *
      *  * BrowseDirection.Forward direction is implied if browseDirection flags is omitted.
      */
-    public findReferencesEx(referenceType: string | NodeId | UAReferenceType, browseDirection?: BrowseDirection): UAReference[];
+    findReferencesEx(referenceType: string | NodeId | UAReferenceType, browseDirection?: BrowseDirection): UAReference[];
 
     /**
      * find all the references that are strictly of type **`reference`**.
@@ -168,7 +222,7 @@ export declare class BaseNode extends EventEmitter {
      *
      * Forward direction is implied if omitted.
      */
-    public findReferences(referenceType: string | NodeId | UAReferenceType, isForward?: boolean): UAReference[];
+    findReferences(referenceType: string | NodeId | UAReferenceType, isForward?: boolean): UAReference[];
 
     /**
      * find the the references that are strictly of type **`reference`**.
@@ -180,18 +234,15 @@ export declare class BaseNode extends EventEmitter {
      * * will throw an exception  if more than one reference exists with the referenceType.
      * * will return null if no reference exists.
      */
-    public findReference(referenceType: string | NodeId | UAReferenceType, isForward?: boolean): UAReference | null;
+    findReference(referenceType: string | NodeId | UAReferenceType, isForward?: boolean): UAReference | null;
 
     /**
-     * find all the nodes that are referenced by references of type **`reference`** or a 
+     * find all the nodes that are referenced by references of type **`reference`** or a
      * sub type of **`reference`**, in the direction specified by **`browseDirection`**
      *
      *  * BrowseDirection.Forward direction is implied if browseDirection flags is omitted.
      */
-    public findReferencesExAsObject(
-        referenceType: string | NodeId | UAReferenceType,
-        browseDirection?: BrowseDirection
-    ): BaseNode[];
+    findReferencesExAsObject(referenceType: string | NodeId | UAReferenceType, browseDirection?: BrowseDirection): BaseNode[];
 
     /**
      *  find all the nodes that are referenced by references strictly of type **`reference`**.
@@ -203,19 +254,18 @@ export declare class BaseNode extends EventEmitter {
      * * will throw an exception  if more than one reference exists with the referenceType.
      * * will return null if no reference exists.
      */
-    public findReferencesAsObject(referenceType: string | NodeId | UAReferenceType, isForward?: boolean): BaseNode[];
+    findReferencesAsObject(referenceType: string | NodeId | UAReferenceType, isForward?: boolean): BaseNode[];
 
-    public allReferences(): UAReference[];
+    allReferences(): UAReference[];
 
     /**
      * Get the Child by name, if browseName is string and namespaceIndex undefined
      * then the search doesn't care about namespace matching
-     * 
-     * @param browseName 
+     *
+     * @param browseName
      */
-    public getChildByName(browseName: QualifiedNameOptions): BaseNode | null;
-    public getChildByName(browseName: string, namespaceIndex?: number): BaseNode | null;
-
+    getChildByName(browseName: QualifiedNameOptions): BaseNode | null;
+    getChildByName(browseName: string, namespaceIndex?: number): BaseNode | null;
 
     /**
      * this methods propagates the forward references to the pointed node
@@ -223,12 +273,12 @@ export declare class BaseNode extends EventEmitter {
      *
      * @private
      */
-    public propagate_back_references(): void;
+    propagate_back_references(): void;
 
     /**
      * browse the node to extract information requested in browseDescription
      */
-    public browseNode(browseDescription: BrowseDescriptionOptions2, session?: ISessionContext): ReferenceDescription[];
+    browseNode(browseDescription: BrowseDescriptionOptions2, session?: ISessionContext): ReferenceDescription[];
 
     /**
      *
@@ -253,28 +303,26 @@ export declare class BaseNode extends EventEmitter {
     getAccessRestrictions(inherited: boolean): AccessRestrictionsFlag;
     /**
      * NodeVersion (Optional) String The NodeVersion Property is used to indicate the version of a Node.
-     * 
-     * The NodeVersion Property is updated each time a Reference is added or deleted 
-     * to the Node the Property belongs to. 
-     * 
+     *
+     * The NodeVersion Property is updated each time a Reference is added or deleted
+     * to the Node the Property belongs to.
+     *
      * Attribute value changes do not cause the NodeVersion to change.
-     * 
-     * Clients may read the NodeVersion Property or subscribe to it to determine when the 
+     *
+     * Clients may read the NodeVersion Property or subscribe to it to determine when the
      * structure of a Node has changed.
      */
     // nodeVersion?: UAProperty<UAString, DataType.String>;
-     /**
+    /**
      * return the versioning node
      */
     getNodeVersion(): UAProperty<UAString, DataType.String> | null;
 
-
-
     /**
      *
      */
     getAggregates(): BaseNode[];
 
-    public setDisplayName(value: LocalizedTextLike[] | LocalizedTextLike): void;
-    public setDescription(value: LocalizedTextLike | null): void;
+    setDisplayName(value: LocalizedTextLike[] | LocalizedTextLike): void;
+    setDescription(value: LocalizedTextLike | null): void;
 }

package/source/bind_variable.ts

@@ -1,18 +1,17 @@
-import { Variant, VariantLike } from "node-opcua-variant";
-import { CallbackT, StatusCode, StatusCodeCallback } from "node-opcua-status-code";
-import {
+import type { QualifiedNameLike } from "node-opcua-data-model";
+import type { DataValue } from "node-opcua-data-value";
+import type { NumericRange } from "node-opcua-numeric-range";
+import type { CallbackT, StatusCode } from "node-opcua-status-code";
+import type {
     HistoryReadResult,
     ReadAtTimeDetails,
     ReadEventDetails,
     ReadProcessedDetails,
     ReadRawModifiedDetails
 } from "node-opcua-types";
-import { NumericRange } from "node-opcua-numeric-range";
-import { QualifiedNameLike } from "node-opcua-data-model";
-import { DataValue } from "node-opcua-data-value";
-
-import { UAVariable } from "./ua_variable";
-import { ContinuationData, ISessionContext } from "./session_context";
+import type { Variant, VariantLike } from "node-opcua-variant";
+import type { ContinuationData, ISessionContext } from "./session_context";
+import type { UAVariable } from "./ua_variable";
 
 export type VariableSetterVariation1 = (this: UAVariable, value: Variant) => StatusCode;
 

package/source/clone_helper.ts

@@ -1,55 +1,55 @@
 import { assert } from "node-opcua-assert";
-import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
-import { BrowseDirection, NodeClass, QualifiedName } from "node-opcua-data-model";
-import { makeNodeId, sameNodeId } from "node-opcua-nodeid";
 import { ReferenceTypeIds } from "node-opcua-constants";
-import { UAObject } from "./ua_object";
-import { UAVariable } from "./ua_variable";
-import { UAMethod } from "./ua_method";
-import { UAObjectType } from "./ua_object_type";
-import { UAVariableType } from "./ua_variable_type";
-import { BaseNode } from "./base_node";
-import { UAReference } from "./ua_reference";
-import { IAddressSpace } from "./address_space";
-
-const warningLog = make_warningLog("CLONE");
-
-const errorLog = make_errorLog(__filename);
+import { BrowseDirection, NodeClass, type QualifiedName } from "node-opcua-data-model";
+import { checkDebugFlag, make_errorLog, make_warningLog } from "node-opcua-debug";
+import { makeNodeId, type NodeIdLike, sameNodeId } from "node-opcua-nodeid";
+import type { IAddressSpace } from "./address_space";
+import type { BaseNode } from "./base_node";
+import type { UAMethod } from "./ua_method";
+import type { UAObject } from "./ua_object";
+import type { UAObjectType } from "./ua_object_type";
+import type { UAReference } from "./ua_reference";
+import type { UAVariable } from "./ua_variable";
+import type { UAVariableType } from "./ua_variable_type";
+
+const warningLog = make_warningLog("INSTANTIATE");
+const errorLog = make_errorLog("INSTANTIATE");
 const doTrace = checkDebugFlag("INSTANTIATE");
 const traceLog = errorLog;
 
 type UAConcrete = UAVariable | UAObject | UAMethod;
 
 /* c8 ignore start */
-/** 
- * @private 
+/**
+ * @private
  */
 export function fullPath(node: BaseNode): string {
     const browseName = node.browseName.toString();
 
     const parent = node.findReferencesExAsObject("Aggregates", BrowseDirection.Inverse)[0];
     if (parent) {
-        return fullPath(parent) + "/" + browseName;
+        return `${fullPath(parent)}/${browseName}`;
     }
     const containingFolder = node.findReferencesExAsObject("Organizes", BrowseDirection.Inverse)[0];
     if (containingFolder) {
-        return fullPath(containingFolder) + "@" + browseName;
+        return `${fullPath(containingFolder)}@${browseName}`;
     }
     return browseName;
 }
 /** @private */
-export function fullPath2(node: BaseNode): string {
-    return fullPath(node) + " (" + node.nodeId.toString() + ")";
+export function fullPath2(node: BaseNode | null | undefined): string {
+    if (!node) return "(unknown)";
+    return `${fullPath(node)} (${node.nodeId.toString()})`;
 }
 /** @private */
 export function exploreNode(node: BaseNode) {
     const f = (n: BaseNode) => {
-        return `${n.browseName.toString()} (${n.nodeId.toString()})${n.modellingRule ? " - " + n.modellingRule : ""}`;
+        return `${n.browseName.toString()} (${n.nodeId.toString()})${n.modellingRule ? ` - ${n.modellingRule}` : ""}`;
     };
-    const r = (r: any) => {
+    const r = (r: NodeIdLike) => {
         const ref = node.addressSpace.findNode(r);
-        if (!ref) return `${r.nodeId.toString()} (unknown)`;
-        return ref?.browseName.toString() + " " + ref!.nodeId.toString();
+        if (!ref) return `(unknown)`;
+        return `${ref?.browseName.toString()} ${ref?.nodeId.toString()}`;
     };
     const map = new Set();
     const _explore = (node: BaseNode, pad: string) => {
@@ -57,20 +57,21 @@ export function exploreNode(node: BaseNode) {
         const b = node.findReferencesEx("Organizes", BrowseDirection.Forward);
 
         for (const ref of [...a, ...b]) {
+            if (!ref.node) continue;
             const alreadyVisited = map.has(ref.nodeId.toString());
             traceLog(
                 pad,
                 "  +-- ",
                 r(ref.referenceType).padEnd(20),
                 "-->",
-                f(ref.node!).padEnd(10),
+                f(ref.node).padEnd(10),
                 alreadyVisited ? " (already visited)" : ""
             );
             if (alreadyVisited) {
                 continue;
             }
             map.add(ref.nodeId.toString());
-            _explore(ref.node!, pad + "   ");
+            _explore(ref.node, `${pad}   `);
         }
     };
     traceLog("exploring ", f(node));
@@ -90,9 +91,8 @@ export function exploreNode(node: BaseNode) {
 //              |
 //              +-------------------------------|- EnabledState    <
 //
-// find also child object with the same browse name that are
-// overridden in the SuperType
-
+// find also child object with the same browse name that is overridden in the SuperType
+//
 // case 2:
 //
 //   /-----------------------------\
@@ -115,7 +115,7 @@ export function exploreNode(node: BaseNode) {
 //              |                     |
 //              |                     +--------------|- (EnabledState)
 //
-// find also child object with the same browse name that are
+// find also child object with the same browse name that is overridden in the same child of the SuperType
 
 function _get_parent_type_and_path(originalObject: BaseNode): {
     parentType: null | UAVariableType | UAObjectType;
@@ -124,17 +124,40 @@ function _get_parent_type_and_path(originalObject: BaseNode): {
     if (originalObject.nodeClass === NodeClass.Method) {
         return { parentType: null, path: [] };
     }
-
     const addressSpace = originalObject.addressSpace;
-
     const parents = originalObject.findReferencesEx("HasChild", BrowseDirection.Inverse);
     // c8 ignore next
     if (parents.length > 1) {
-        warningLog(" object ", originalObject.browseName.toString(), " has more than one parent !");
+        // it could be a tricky buggy situation  like that we have seen with SIOME
+        //
+        //  AnalogUnitTyoe
+        //    |-- HasProperty --> EngineeringUnits (i=17052)
+        //  MyObjectType
+        //    |-- HasComponent --> ActualSpeed
+        //                              |-- HasComponent --> EngineeringUnits (i=17052) <== BUGGY !!!
+
+        const parentTypes = parents.filter((p) => {
+            const n = addressSpace.findNode(p.nodeId);
+            return n && (n.nodeClass === NodeClass.ObjectType || n.nodeClass === NodeClass.VariableType);
+        });
+
+        if (parentTypes.length === 1) {
+            return {
+                parentType: addressSpace.findNode(parentTypes[0].nodeId) as UAObjectType | UAVariableType,
+                path: [originalObject.browseName]
+            };
+        }
+
+        warningLog(
+            " object ",
+            originalObject.browseName.toString(),
+            originalObject.nodeId.toString(),
+            " has more than one parent !"
+        );
         warningLog(originalObject.toString());
         warningLog(" parents : ");
         for (const parent of parents) {
-            warningLog("     ", parent.toString(), addressSpace.findNode(parent.nodeId)!.browseName.toString());
+            warningLog("     ", parent.toString(), addressSpace.findNode(parent.nodeId)?.browseName.toString());
         }
         return { parentType: null, path: [] };
     }
@@ -143,12 +166,12 @@ function _get_parent_type_and_path(originalObject: BaseNode): {
     if (parents.length === 0) {
         return { parentType: null, path: [] };
     }
-    const theParent = addressSpace.findNode(parents[0]!.nodeId)!;
+    const theParent = addressSpace.findNode(parents[0]?.nodeId) as BaseNode;
     if (theParent && (theParent.nodeClass === NodeClass.VariableType || theParent.nodeClass === NodeClass.ObjectType)) {
         return { parentType: theParent as UAVariableType | UAObjectType, path: [originalObject.browseName] };
     }
     // walk up
-    const { parentType, path } = _get_parent_type_and_path(theParent!);
+    const { parentType, path } = _get_parent_type_and_path(theParent);
     return { parentType, path: [...path, originalObject.browseName] };
 }
 /* c8 ignore stop */
@@ -220,7 +243,7 @@ export class CloneHelper {
     }
     public popContext() {
         assert(this._contextStack.length > 0);
-        this._context = this._contextStack.pop()!;
+        this._context = this._contextStack.pop() || null;
     }
     public registerClonedObject<
         TO extends UAObject | UAVariable | UAMethod | UAObjectType | UAVariableType,
@@ -294,7 +317,7 @@ export class CloneHelper {
                 fullPath2(clonedParent)
             );
 
-        const info = this._context!.get(originalNode.nodeId.toString());
+        const info = this._context?.get(originalNode.nodeId.toString());
         if (info) {
             return info.cloned;
         }
@@ -324,7 +347,7 @@ function _remove_unwanted_ref(references: UAReference[]): UAReference[] {
  */
 function findNonHierarchicalReferences(originalObject: BaseNode): UAReference[] {
     // todo: MEMOIZE this method
-    const addressSpace: IAddressSpace = originalObject.addressSpace;
+    const _addressSpace: IAddressSpace = originalObject.addressSpace;
 
     // we need to explore the non hierarchical references backwards
     let references = originalObject.findReferencesEx("NonHierarchicalReferences", BrowseDirection.Inverse);
@@ -336,7 +359,7 @@ function findNonHierarchicalReferences(originalObject: BaseNode): UAReference[]
 
     const { parentType, path } = _get_parent_type_and_path(originalObject);
 
-    if (parentType && parentType.subtypeOfObj) {
+    if (parentType?.subtypeOfObj) {
         // parent is a ObjectType or VariableType and is not a root type
         assert(parentType.nodeClass === NodeClass.VariableType || parentType.nodeClass === NodeClass.ObjectType);
 
@@ -392,14 +415,14 @@ export function reconstructNonHierarchicalReferences(extraInfo: CloneHelper): vo
 
             // if the object pointed by this reference is also cloned ...
 
-            const originalDest = info.original;
+            const _originalDest = info.original;
             const cloneDest = info.cloned;
 
             // c8 ignore next
             doTrace &&
                 traceLog(
                     "   adding reference ",
-                    fullPath2(addressSpace.findNode(ref.referenceType)!),
+                    fullPath2(addressSpace.findNode(ref.referenceType)),
                     " from cloned ",
                     fullPath2(cloned),
                     " to cloned ",
@@ -450,7 +473,7 @@ export function reconstructFunctionalGroupType(extraInfo: CloneHelper) {
 
             if (!folder.typeDefinitionObj) continue;
 
-            if (folder.typeDefinitionObj.browseName.name!.toString() !== "FunctionalGroupType") {
+            if (folder.typeDefinitionObj.browseName.name?.toString() !== "FunctionalGroupType") {
                 continue;
             }
 

package/source/clone_options.ts

@@ -1,15 +1,14 @@
-import { NodeId, NodeIdLike } from "node-opcua-nodeid";
-import { LocalizedText, NodeClass, QualifiedName } from "node-opcua-data-model";
-
-import { BaseNode } from "./base_node";
-import { ModellingRuleType } from "./modelling_rule_type";
-import { INamespace } from "./namespace";
-import { UAMethod } from "./ua_method";
-import { UAObject } from "./ua_object";
-import { UAObjectType } from "./ua_object_type";
-import { UAReference } from "./ua_reference";
-import { UAVariable } from "./ua_variable";
+import type { LocalizedText, NodeClass, QualifiedName } from "node-opcua-data-model";
+import type { NodeId, NodeIdLike } from "node-opcua-nodeid";
+import type { BaseNode } from "./base_node";
 import { CloneHelper } from "./clone_helper";
+import type { ModellingRuleType } from "./modelling_rule_type";
+import type { INamespace } from "./namespace";
+import type { UAMethod } from "./ua_method";
+import type { UAObject } from "./ua_object";
+import type { UAObjectType } from "./ua_object_type";
+import type { UAReference } from "./ua_reference";
+import type { UAVariable } from "./ua_variable";
 
 export interface CloneFilter {
     shouldKeep(node: BaseNode): boolean;
@@ -22,8 +21,8 @@ export const defaultCloneFilter: CloneFilter = {
         }
         return true;
     },
-    filterFor(node: BaseNode) {
-        return this;
+    filterFor(_childInstance: UAVariable | UAObject | UAMethod): CloneFilter {
+        return defaultCloneFilter;
     }
 };
 
@@ -46,7 +45,7 @@ export interface CloneExtraInfo {
 export const makeDefaultCloneExtraInfo = (node: UAVariable | UAMethod | UAObject): CloneExtraInfo => {
     const extraInfo = new CloneHelper();
     extraInfo.pushContext({ originalParent: node, clonedParent: node });
-    return extraInfo;
+    return extraInfo as CloneExtraInfo;
 };
 
 export interface CloneOptions /* extends ConstructNodeIdOptions */ {

package/source/continuation_point.ts

@@ -1,3 +1,2 @@
-import { ByteString } from "node-opcua-basic-types";
-
+import type { ByteString } from "node-opcua-basic-types";
 export type ContinuationPoint = ByteString;