node-opcua-address-space 2.170.1 → 2.172.0

package/src/state_machine/ua_two_state_variable.ts

@@ -1,28 +1,36 @@
-    /**
+/**
  * @module node-opcua-address-space
  */
-import { assert } from "node-opcua-assert";
 
+import type {
+    BaseNode,
+    BindVariableOptions,
+    INamespace,
+    ISessionContext,
+    UAReference,
+    UAVariable
+} from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
 import { VariableTypeIds } from "node-opcua-constants";
-import { BrowseDirection, coerceLocalizedText, LocalizedText, LocalizedTextLike } from "node-opcua-data-model";
-import { DataValueT } from "node-opcua-data-value";
-import { NodeId, resolveNodeId } from "node-opcua-nodeid";
-import { sameNodeId } from "node-opcua-nodeid";
-import { StatusCodes, StatusCode, StatusCodeCallback } from "node-opcua-status-code";
-import { Variant, VariantLike, VariantT } from "node-opcua-variant";
-import { DataType } from "node-opcua-variant";
-import { BaseNode, BindVariableOptions, INamespace, UAReference, UAVariable, ISessionContext } from "node-opcua-address-space-base";
-import { NumericRange } from "node-opcua-numeric-range";
-import { QualifiedNameLike } from "node-opcua-data-model";
-
+import {
+    BrowseDirection,
+    coerceLocalizedText,
+    type LocalizedText,
+    type LocalizedTextLike,
+    type QualifiedNameLike
+} from "node-opcua-data-model";
+import type { DataValueT } from "node-opcua-data-value";
+import { type NodeId, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
+import type { NumericRange } from "node-opcua-numeric-range";
+import { type StatusCode, type StatusCodeCallback, StatusCodes } from "node-opcua-status-code";
+import { DataType, Variant, type VariantLike, type VariantT } from "node-opcua-variant";
+import type { AddTwoStateVariableOptions } from "../../source/address_space_ts";
+import type { ISetStateOptions } from "../../source/interfaces/i_set_state_options";
 // public interfaces
 import { registerNodePromoter } from "../../source/loader/register_node_promoter";
-import { AddTwoStateVariableOptions } from "../../source/address_space_ts";
-import { UATwoStateVariableEx } from "../../source/ua_two_state_variable_ex";
+import type { UATwoStateVariableEx } from "../../source/ua_two_state_variable_ex";
 // private types
 import { UAVariableImpl, UAVariableImplT } from "../ua_variable_impl";
-import { ISetStateOptions } from "../../source/interfaces/i_set_state_options";
-
 
 const hasTrueSubState_ReferenceTypeNodeId = resolveNodeId("HasTrueSubState");
 const hasFalseSubState_ReferenceTypeNodeId = resolveNodeId("HasFalseSubState");
@@ -64,9 +72,8 @@ function _updateTransitionTime(node: UATwoStateVariableEx, _subState?: UAVariabl
     }
 }
 
-function _updateEffectiveTransitionTime(node: UATwoStateVariableImpl,options?: ISetStateOptions) {
+function _updateEffectiveTransitionTime(node: UATwoStateVariableImpl, options?: ISetStateOptions) {
     if (node.effectiveTransitionTime) {
-        
         const effectiveTransitionTime = options?.effectiveTransitionTime || new Date();
 
         // because subStateNode ",subStateNode.browseName.toString());
@@ -77,7 +84,7 @@ function _updateEffectiveTransitionTime(node: UATwoStateVariableImpl,options?: I
     }
 }
 
-function _getEffectiveDisplayName<T, DT extends DataType>(
+function _getEffectiveDisplayName<_T, _DT extends DataType>(
     node: UATwoStateVariableImpl
 ): DataValueT<LocalizedText, DataType.LocalizedText> {
     const humanReadableString = _getHumanReadableString(node);
@@ -92,7 +99,7 @@ function _getEffectiveDisplayName<T, DT extends DataType>(
     } else {
         subStateNodes = node.findReferencesExAsObject("HasFalseSubState", BrowseDirection.Forward);
     }
-    const states = subStateNodes.forEach((n: any) => {
+    const _states = subStateNodes.forEach((_n: any) => {
         // todo happen
     });
 
@@ -133,7 +140,7 @@ export function _install_TwoStateVariable_machinery(
     assert(node.minimumSamplingInterval === 0);
     assert(node.typeDefinitionObj.browseName.toString() === "TwoStateVariableType");
     assert(node.dataTypeObj.browseName.toString() === "LocalizedText");
-    assert(Object.prototype.hasOwnProperty.call(node, "valueRank") && (node.valueRank === -1 || node.valueRank === 0));
+    assert(Object.hasOwn(node, "valueRank") && (node.valueRank === -1 || node.valueRank === 0));
 
     // promote node into a UATwoStateVariable
     const _node = promoteToTwoStateVariable(node);
@@ -196,10 +203,6 @@ export class UATwoStateVariableImpl extends UAVariableImplT<LocalizedText, DataT
     private _trueState?: string;
     private _falseState?: string;
 
-    public constructor(opts: any) {
-        super(opts);
-    }
-
     get isFalseSubStateOf(): UATwoStateVariableEx {
         return super.isFalseSubStateOf as UATwoStateVariableEx;
     }
@@ -219,7 +222,7 @@ export class UATwoStateVariableImpl extends UAVariableImplT<LocalizedText, DataT
                     value: coerceLocalizedText(options.falseState)
                 });
             } else {
-                this._trueState = coerceLocalizedText(options.trueState)!.text!;
+                this._trueState = coerceLocalizedText(options.trueState)?.text!;
             }
             if (this.trueState) {
                 this.trueState.setValueFromSource({
@@ -227,7 +230,7 @@ export class UATwoStateVariableImpl extends UAVariableImplT<LocalizedText, DataT
                     value: coerceLocalizedText(options.trueState)
                 });
             } else {
-                this._falseState = coerceLocalizedText(options.falseState)!.text!;
+                this._falseState = coerceLocalizedText(options.falseState)?.text!;
             }
         }
 
@@ -264,7 +267,7 @@ export class UATwoStateVariableImpl extends UAVariableImplT<LocalizedText, DataT
                 },
                 StatusCodes.Good
             );
-        } else if (Object.prototype.hasOwnProperty.call(options.value, "dataType")) {
+        } else if (Object.hasOwn(options.value, "dataType")) {
             assert((options.value as VariantLike).dataType === DataType.Boolean);
             this.id.setValueFromSource(options.value as VariantLike, StatusCodes.Good);
         } else {
@@ -312,7 +315,7 @@ export class UATwoStateVariableImpl extends UAVariableImplT<LocalizedText, DataT
      */
     public setValue(boolValue: boolean, options?: ISetStateOptions): void {
         assert(typeof boolValue === "boolean");
-        const dataValue = this.id!.readValue();
+        const dataValue = this.id?.readValue();
         const oldValue = dataValue.value.value;
         if (dataValue.statusCode.isGood() && boolValue === oldValue) {
             return; // nothing to do
@@ -326,7 +329,7 @@ export class UATwoStateVariableImpl extends UAVariableImplT<LocalizedText, DataT
     /**
      */
     public getValue(): boolean {
-        const dataValue = this.id!.readValue();
+        const dataValue = this.id?.readValue();
         assert(dataValue.statusCode.isGood());
         assert(dataValue.value.dataType === DataType.Boolean);
         return dataValue.value.value;

package/src/tool_isSubtypeOf.ts

@@ -2,15 +2,21 @@
  * @module node-opcua-address-space
  */
 
+import type {
+    BaseNode,
+    BaseNodeEvents,
+    UADataType,
+    UAObjectType,
+    UAReference,
+    UAReferenceType,
+    UAVariableType
+} from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
-import { NodeId, NodeIdLike, resolveNodeId } from "node-opcua-nodeid";
-import { sameNodeId } from "node-opcua-nodeid";
 import { NodeClass } from "node-opcua-data-model";
-import { BaseNode, UADataType, UAObjectType, UAReference, UAReferenceType, UAVariableType } from "node-opcua-address-space-base";
-
+import { type NodeId, type NodeIdLike, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
+import type { BaseNodeImpl } from "./base_node_impl";
 import { BaseNode_getCache } from "./base_node_private";
 import { ReferenceImpl } from "./reference_impl";
-import { BaseNodeImpl } from "./base_node_impl";
 
 const HasSubTypeNodeId = resolveNodeId("HasSubtype");
 
@@ -20,7 +26,11 @@ function _filterSubType(reference: UAReference) {
 
 export type BaseNodeConstructor<T extends BaseNode> = new () => T;
 
-function _slow_isSubtypeOf<T extends UAType>(this: T, Class: typeof BaseNodeImpl, baseType: T | NodeIdLike): boolean {
+function _slow_isSubtypeOf<T extends UAType>(
+    this: T,
+    Class: typeof BaseNodeImpl,
+    baseType: T | NodeIdLike
+): boolean {
     if (!(baseType instanceof Class)) {
         const node = this.addressSpace.findNode(baseType as NodeIdLike);
         if (!node || !(node instanceof Class)) {
@@ -42,10 +52,10 @@ function _slow_isSubtypeOf<T extends UAType>(this: T, Class: typeof BaseNodeImpl
 
     for (const subType1 of subTypes) {
         const subTypeId = subType1.nodeId;
-        const subTypeNode = this.addressSpace.findNode(subTypeId) as any as T;
+        const subTypeNode = this.addressSpace.findNode(subTypeId) as unknown as T;
         // c8 ignore next
         if (!subTypeNode) {
-            throw new Error("Cannot find object with nodeId " + subTypeId.toString());
+            throw new Error(`Cannot find object with nodeId ${subTypeId.toString()}`);
         }
         if (sameNodeId(subTypeNode.nodeId, baseType.nodeId)) {
             return true;
@@ -60,10 +70,9 @@ function _slow_isSubtypeOf<T extends UAType>(this: T, Class: typeof BaseNodeImpl
 
 export type MemberFuncValue<T, P, R> = (this: T, param: P) => R;
 
+const g_WeakMap = new WeakMap<object, Map<string, unknown>>();
 
-const g_WeakMap = new WeakMap<Object, Map<string, unknown>>();
-
-export function wipeMemorizedStuff(node: Object) {
+export function wipeMemorizedStuff(node: object) {
     if (g_WeakMap.has(node)) {
         g_WeakMap.delete(node);
     }
@@ -71,40 +80,46 @@ export function wipeMemorizedStuff(node: Object) {
 
 //  http://jsperf.com/underscore-js-memoize-refactor-test
 //  http://addyosmani.com/blog/faster-javascript-memoization/
-function wrap_memoize<T, P, R>(
+function wrap_memoize<T extends object, P, R>(
     func: MemberFuncValue<T, P, R>,
-    hashFunc?: (this: T, param: any) => string
+    hashFunc?: (this: T, param: P) => string
 ): MemberFuncValue<T, P, R> {
-    if (undefined === hashFunc) {
-        hashFunc = (_p: T) => (_p as any).toString();
-    }
-    return function memoize(this: any, param: any) {
-        const self = this;
-        if (!g_WeakMap.has(self)) {
-            g_WeakMap.set(self,new Map());
+    const effectiveHashFunc: (this: T, param: P) => string =
+        hashFunc ??
+        function (this: T, param: P) {
+            return (param as unknown as object).toString();
+        };
+    return function memoize(this: T, param: P): R {
+        let memoMap = g_WeakMap.get(this) as Map<string, R> | undefined;
+        if (!memoMap) {
+            memoMap = new Map<string, R>();
+            g_WeakMap.set(this, memoMap as Map<string, unknown>);
         }
-        const memoMap = g_WeakMap.get(self)!;
 
-        const hash = hashFunc!.call(this, param);
+        const hash = effectiveHashFunc.call(this, param);
         if (memoMap.has(hash)) {
             return memoMap.get(hash) as R;
         }
         const cache_value = func.call(this, param);
-        memoMap.set(hash,cache_value);
-        return cache_value as R;
+        memoMap.set(hash, cache_value);
+        return cache_value;
     };
 }
 
-function hashBaseNode(e: BaseNode): string {
-    return e.nodeId.toString();
+function hashBaseNode(e: BaseNode | NodeIdLike): string {
+    if (e && typeof e === "object" && "nodeId" in e) {
+        return (e as BaseNode).nodeId.toString();
+    }
+    return resolveNodeId(e as NodeIdLike).toString();
 }
 
 export type IsSubtypeOfFunc<T extends UAType> = (this: T, baseType: T) => boolean;
 
 export type UAType = UAReferenceType | UADataType | UAObjectType | UAVariableType;
 
-export function construct_isSubtypeOf<T extends UAType>(Class: typeof BaseNodeImpl): IsSubtypeOfFunc<T> {
-
+export function construct_isSubtypeOf<T extends UAType>(
+    Class: typeof BaseNodeImpl
+): IsSubtypeOfFunc<T> {
     return wrap_memoize(function (this: T, baseType: T | NodeIdLike): boolean {
         if (!(baseType instanceof Class)) {
             throw new Error(
@@ -117,7 +132,7 @@ export function construct_isSubtypeOf<T extends UAType>(Class: typeof BaseNodeIm
             );
         }
         if (!(this instanceof Class)) {
-            throw new Error("expecting this to be " + Class.name + " but got " + baseType.toString());
+            throw new Error(`expecting this to be ${Class.name} but got ${baseType.toString()}`);
         }
         return _slow_isSubtypeOf.call(this, Class, baseType as T);
     }, hashBaseNode);
@@ -137,16 +152,16 @@ export function get_subtypeOf<T extends BaseNode>(this: T): NodeId | null {
     return s ? s.nodeId : null;
 }
 
-export function get_subtypeOfObj(this: BaseNode): BaseNode | null {
+export function get_subtypeOfObj<T extends BaseNode>(this: T): T | null {
     const _cache = BaseNode_getCache(this);
 
-    if (_cache._subtypeOfObj == undefined) {
+    if (_cache._subtypeOfObj === undefined) {
         const is_subtype_of_ref = this.findReference("HasSubtype", false);
-        if (is_subtype_of_ref ) {
+        if (is_subtype_of_ref) {
             _cache._subtypeOfObj = ReferenceImpl.resolveReferenceNode(this.addressSpace, is_subtype_of_ref);
         } else {
             _cache._subtypeOfObj = null;
         }
     }
-    return _cache._subtypeOfObj;
+    return (_cache._subtypeOfObj as T) || null;
 }

package/src/ua_condition_type.ts

@@ -1,4 +1,4 @@
-import { UAMethod, UAObjectType } from "node-opcua-address-space-base";
+import type { UAMethod, UAObjectType } from "node-opcua-address-space-base";
 
 export interface UAConditionType extends UAObjectType {
     disable: UAMethod;

package/src/ua_data_type_impl.ts

@@ -37,7 +37,6 @@ import { construct_isSubtypeOf, get_subtypeOf, get_subtypeOfObj } from "./tool_i
 const debugLog = make_debugLog("DATA_TYPE");
 const doDebug = checkDebugFlag("DATA_TYPE");
 
-
 export interface StructureFieldOptionsEx extends StructureFieldOptions {
     allowSubTypes: boolean;
 }
@@ -374,24 +373,24 @@ export function DataType_toString(this: UADataTypeImpl, options: ToStringOption)
 
     options.add(
         options.padding +
-        chalk.yellow("          binaryEncodingNodeId: ") +
-        (this.binaryEncodingNodeId ? this.binaryEncodingNodeId.toString() : "<none>")
+            chalk.yellow("          binaryEncodingNodeId: ") +
+            (this.binaryEncodingNodeId ? this.binaryEncodingNodeId.toString() : "<none>")
     );
     options.add(
         options.padding +
-        chalk.yellow("          xmlEncodingNodeId   : ") +
-        (this.xmlEncodingNodeId ? this.xmlEncodingNodeId.toString() : "<none>")
+            chalk.yellow("          xmlEncodingNodeId   : ") +
+            (this.xmlEncodingNodeId ? this.xmlEncodingNodeId.toString() : "<none>")
     );
     options.add(
         options.padding +
-        chalk.yellow("          jsonEncodingNodeId  : ") +
-        (this.jsonEncodingNodeId ? this.jsonEncodingNodeId.toString() : "<none>")
+            chalk.yellow("          jsonEncodingNodeId  : ") +
+            (this.jsonEncodingNodeId ? this.jsonEncodingNodeId.toString() : "<none>")
     );
     if (this.subtypeOfObj) {
         options.add(
             options.padding +
-            chalk.yellow("          subtypeOfObj        : ") +
-            (this.subtypeOfObj ? this.subtypeOfObj.browseName.toString() : "")
+                chalk.yellow("          subtypeOfObj        : ") +
+                (this.subtypeOfObj ? this.subtypeOfObj.browseName.toString() : "")
         );
     }
     // references
@@ -435,10 +434,10 @@ function makeStructureDefinition(
             ? StructureType.UnionWithSubtypedValues
             : StructureType.Union
         : hasOptionalFields
-            ? StructureType.StructureWithOptionalFields
-            : hasSubtypedFields
-                ? StructureType.StructureWithSubtypedValues
-                : StructureType.Structure;
+          ? StructureType.StructureWithOptionalFields
+          : hasSubtypedFields
+            ? StructureType.StructureWithSubtypedValues
+            : StructureType.Structure;
 
     // note:  https://reference.opcfoundation.org/Core/Part3/v105/docs/8.51
     // field.isOptional has a special behavior depending on the structure type

package/src/ua_method_impl.ts

@@ -15,6 +15,7 @@ import {
     type MethodFunctorC,
     makeDefaultCloneExtraInfo,
     type UAMethod,
+    type UAMethodEvents, 
     type UAObject,
     type UAObjectType,
     type UAVariable
@@ -31,7 +32,7 @@ import { type CallMethodResultOptions, PermissionType } from "node-opcua-types";
 import { DataType, Variant, type VariantLike } from "node-opcua-variant";
 import type { SessionContext } from "../source/session_context";
 import type { AddressSpacePrivate } from "./address_space_private";
-import { BaseNodeImpl } from "./base_node_impl";
+import { BaseNodeImpl, type InternalBaseNodeOptions } from "./base_node_impl";
 import { _clone } from "./base_node_private";
 import { _handle_hierarchy_parent } from "./namespace_impl";
 
@@ -40,10 +41,14 @@ const debugLog = make_debugLog(__filename);
 const errorLog = make_errorLog(__filename);
 
 function default_check_valid_argument(arg: unknown): boolean {
-    return (arg as any) instanceof Argument;
+    return (arg as object) instanceof Argument;
 }
 
-export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
+export interface IMethodOptons extends InternalBaseNodeOptions {
+    value: unknown;
+    methodDeclarationId: NodeId;
+}
+export class UAMethodImpl extends BaseNodeImpl<UAMethodEvents> implements UAMethod {
     public static checkValidArgument(args: unknown): boolean {
         return default_check_valid_argument(args);
     }
@@ -58,13 +63,13 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
         return super.parent as UAObject;
     }
 
-    public value?: any;
+    public value?: unknown;
     public methodDeclarationId: NodeId;
     public _getExecutableFlag?: (this: UAMethod, context: ISessionContext | null) => boolean;
 
     public _asyncExecutionFunction?: MethodFunctor;
 
-    constructor(options: any) {
+    constructor(options: IMethodOptons) {
         super(options);
         this.value = options.value;
         this.methodDeclarationId = options.methodDeclarationId;
@@ -175,11 +180,11 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
         if (object.nodeClass !== NodeClass.Object && object.nodeClass !== NodeClass.ObjectType) {
             warningLog(
                 "Method " +
-                this.nodeId.toString() +
-                " " +
-                this.browseName.toString() +
-                " called for a node that is not a Object/ObjectType but " +
-                NodeClass[context.object?.nodeClass as number]
+                    this.nodeId.toString() +
+                    " " +
+                    this.browseName.toString() +
+                    " called for a node that is not a Object/ObjectType but " +
+                    NodeClass[context.object?.nodeClass as number]
             );
             return callback(null, { statusCode: StatusCodes.BadNodeIdInvalid });
         }
@@ -264,7 +269,7 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
 
                         // ── afterCall event ──
                         try {
-                            this.emit("afterCall", context, coercedInputArguments, callMethodResult);
+                            (this as UAMethod).emit("afterCall", context, coercedInputArguments, callMethodResult);
                         } catch (afterCallErr) {
                             if (afterCallErr instanceof Error) {
                                 warningLog(chalk.red("ERR in afterCall listener"), afterCallErr.message);
@@ -314,7 +319,7 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
         clonedMethod._getExecutableFlag = this._getExecutableFlag;
 
         if (options.componentOf) {
-            const m = options.componentOf.getMethodByName(clonedMethod.browseName.name!);
+            const m = options.componentOf.getMethodByName(clonedMethod.browseName.name || "");
             assert(m);
         }
         return clonedMethod as UAMethod;

package/src/ua_object_impl.ts

@@ -1,48 +1,50 @@
 /**
  * @module node-opcua-address-space
  */
-import chalk from "chalk";
 
+import chalk from "chalk";
+import {
+    type BaseNode,
+    type CloneExtraInfo,
+    type CloneFilter,
+    type CloneOptions,
+    defaultCloneFilter,
+    EventNotifierFlags,
+    type EventTypeLike,
+    type IEventData,
+    type ISessionContext,
+    type ListenerSignature,
+    makeDefaultCloneExtraInfo,
+    type RaiseEventData,
+    type UAEventType,
+    type UAMethod,
+    type UAObject,
+    type UAObjectEvents,
+    type UAObjectType
+} from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import { isValidByte } from "node-opcua-basic-types";
-import { NodeClass, type QualifiedNameLike, type QualifiedNameOptions } from "node-opcua-data-model";
-import { AttributeIds } from "node-opcua-data-model";
+import { AttributeIds, NodeClass, type QualifiedNameLike, type QualifiedNameOptions } from "node-opcua-data-model";
 import { DataValue, type DataValueLike } from "node-opcua-data-value";
 import { getCurrentClock } from "node-opcua-date-time";
+import { make_errorLog } from "node-opcua-debug";
 import { NodeId } from "node-opcua-nodeid";
 import type { NumericRange } from "node-opcua-numeric-range";
 import { StatusCodes } from "node-opcua-status-code";
 import { DataType } from "node-opcua-variant";
-import {
-    type EventTypeLike,
-    type RaiseEventData,
-    type ISessionContext,
-    type UAMethod,
-    type UAObject,
-    type UAObjectType,
-    type CloneOptions,
-    type CloneFilter,
-    type CloneExtraInfo,
-    type BaseNode,
-    type UAEventType,
-    type IEventData,
-    defaultCloneFilter,
-    makeDefaultCloneExtraInfo,
-    EventNotifierFlags
-} from "node-opcua-address-space-base";
-import { make_errorLog } from "node-opcua-debug";
-
+import { apply_condition_refresh, type ConditionRefreshCache } from "./apply_condition_refresh";
 import { BaseNodeImpl, type InternalBaseNodeOptions } from "./base_node_impl";
 import { _clone, ToStringBuilder, UAObject_toString } from "./base_node_private";
-import { apply_condition_refresh, type ConditionRefreshCache } from "./apply_condition_refresh";
 
 const errorLog = make_errorLog(__filename);
 
-export class UAObjectImpl extends BaseNodeImpl implements UAObject {
+export class UAObjectImpl<T extends UAObjectEvents & ListenerSignature<T> = UAObjectEvents>
+    extends BaseNodeImpl<T>
+    implements UAObject<T>
+{
     private _eventNotifier: EventNotifierFlags;
     public readonly nodeClass = NodeClass.Object;
     public get eventNotifier(): EventNotifierFlags {
-
         // ensure eventNotifier is set if the node has some event
 
         if (!this._eventNotifier) {
@@ -105,12 +107,12 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
         options = {
             eventNotifier: this.eventNotifier,
             symbolicName: this.symbolicName || undefined,
-            ...options,
+            ...options
         };
 
         const cloneObject = _clone(
             this,
-            UAObjectImpl,
+            UAObjectImpl<T>,
             options,
             optionalFilter || defaultCloneFilter,
             extraInfo || makeDefaultCloneExtraInfo(this)
@@ -130,7 +132,7 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
     public getMethodByName(methodName: QualifiedNameOptions): UAMethod | null;
     public getMethodByName(methodName: string, namespaceIndex?: number): UAMethod | null;
     public getMethodByName(methodName: QualifiedNameLike, namespaceIndex?: number): UAMethod | null {
-        return super.getMethodByName(methodName as any, namespaceIndex);
+        return super.getMethodByName(methodName as string, namespaceIndex);
     }
 
     public getMethods(): UAMethod[] {
@@ -150,7 +152,7 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
         if (typeof eventType === "string") {
             const eventTypeFound = addressSpace.findEventType(eventType);
             if (!eventTypeFound) {
-                throw new Error("raiseEvent: eventType cannot find event Type " + eventType.toString());
+                throw new Error(`raiseEvent: eventType cannot find event Type ${eventType.toString()}`);
             }
             eventType = eventTypeFound;
             if (!eventType || eventType.nodeClass !== NodeClass.ObjectType) {
@@ -161,7 +163,7 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
             if (!eventTypeFound) {
                 throw new Error(`raiseEvent: eventType cannot find event Type ${eventType.toString()}`);
             }
-            eventType = eventTypeFound!;
+            eventType = eventTypeFound;
             if (!eventType || eventType.nodeClass !== NodeClass.ObjectType) {
                 throw new Error(`eventType must exist and be an UAObjectType: ${eventType.toString()}`);
             }
@@ -179,7 +181,7 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
         eventTypeNode = addressSpace.findEventType(eventType as UAEventType) as UAEventType;
         const _baseEventType = addressSpace.findEventType("BaseEventType");
 
-        data.$eventDataSource =eventTypeNode;
+        data.$eventDataSource = eventTypeNode;
         data.sourceNode = data.sourceNode || { dataType: DataType.NodeId, value: this.nodeId };
 
         const eventData1 = addressSpace.constructEventData(eventTypeNode, data);
@@ -190,9 +192,9 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
     public _bubble_up_event(eventData: IEventData): void {
         const addressSpace = this.addressSpace;
 
-        const queue: any[] = [];
+        const queue: BaseNode[] = [];
         // walk up the hasNotify / hasEventSource chain
-        const m: any = {};
+        const m: Record<string, BaseNode> = {};
 
         // all events are notified to the server object
         // emit on server object
@@ -222,6 +224,9 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
 
         while (queue.length) {
             const obj = queue.pop();
+            if (!obj) {
+                continue;
+            }
             // emit on object
             obj.emit("event", eventData);