@opcua/for-node-red 3.34.2 → 3.36.0

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

@@ -1,32 +1,31 @@
+import type { BindExtensionObjectOptions, UADataType, UAVariable, UAVariableType } from "node-opcua-address-space-base";
 import assert from "node-opcua-assert";
-import { BindExtensionObjectOptions, UADataType, UAVariable, UAVariableType } from "node-opcua-address-space-base";
 import { coerceQualifiedName, NodeClass } from "node-opcua-data-model";
-import { getCurrentClock, PreciseClock, coerceClock } from "node-opcua-date-time";
-import { DataValue } from "node-opcua-data-value";
-import { make_debugLog, make_warningLog, checkDebugFlag, make_errorLog } from "node-opcua-debug";
+import type { DataValue } from "node-opcua-data-value";
+import { coerceClock, getCurrentClock, type PreciseClock } from "node-opcua-date-time";
+import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
 import { ExtensionObject } from "node-opcua-extension-object";
 import { NodeId, NodeIdType } from "node-opcua-nodeid";
+import type { NumericRange } from "node-opcua-numeric-range";
 import { StatusCodes } from "node-opcua-status-code";
-import { StructureField } from "node-opcua-types";
+import type { StructureField } from "node-opcua-types";
 import { lowerFirstLetter } from "node-opcua-utils";
-import { DataType, VariantLike, VariantArrayType } from "node-opcua-variant";
-import { NumericRange } from "node-opcua-numeric-range";
-
-import { UAVariableImpl } from "./ua_variable_impl";
-import { UADataTypeImpl } from "./ua_data_type_impl";
+import { DataType, VariantArrayType, type VariantLike } from "node-opcua-variant";
 import { IndexIterator } from "./idx_iterator";
+import type { UADataTypeImpl } from "./ua_data_type_impl";
+import { UAVariableImpl } from "./ua_variable_impl";
 
 const doDebug = checkDebugFlag(__filename);
 const debugLog = make_debugLog(__filename);
 const warningLog = make_warningLog(__filename);
 const errorLog = make_errorLog(__filename);
 
-function w(str: string, n: number): string {
+function _w(str: string, n: number): string {
     return str.padEnd(n).substring(n);
 }
 
 function isProxy(ext: any) {
-    return ext.$isProxy ? true : false;
+    return !!ext.$isProxy;
 }
 function getProxyVariable(ext: any): UAVariable | null {
     assert(isProxy(ext));
@@ -52,6 +51,16 @@ function unProxy(ext: ExtensionObject) {
     return isProxy(ext) ? getProxyTarget(ext) : ext;
 }
 
+function getExtensionObjectArray(uaVariable: UAVariableImpl): ExtensionObject[] {
+    const arr = uaVariable.$$extensionObjectArray;
+    if (!arr) {
+        throw new Error(
+            `Internal Error: $$extensionObjectArray is not bound on UAVariable ${uaVariable.nodeId.toString()} (${uaVariable.browseName.toString()})`
+        );
+    }
+    return arr;
+}
+
 function _extensionObjectFieldGetter(getVariable: () => UAVariable | null, target: any, key: string /*, receiver*/) {
     if (key === "$isProxy") {
         return true;
@@ -81,7 +90,7 @@ function _extensionObjectFieldSetter(
     const uaVariable = getVariable();
     if (!uaVariable) return true;
     const child = (uaVariable as any)[key] as UAVariable | null;
-    if (child && child.touchValue) {
+    if (child?.touchValue) {
         child.touchValue();
     }
     return true; // true means the set operation has succeeded
@@ -132,7 +141,7 @@ export function propagateTouchValueDownward(self: UAVariableImpl, now: PreciseCl
     const dataTypeNode = self.getDataTypeNode();
     const definition = dataTypeNode.getStructureDefinition();
     for (const field of definition.fields || []) {
-        const property = self.getChildByName(field.name!) as UAVariableImpl;
+        const property = self.getChildByName(field.name || "") as UAVariableImpl;
 
         if (property) {
             if (cache) {
@@ -192,9 +201,12 @@ export function setExtensionObjectPartialValue(node: UAVariableImpl, partialObje
         // checking the *existing* side with isProxy, not here.
         // Instead, only recurse if it's a schema'd type AND has
         // Extension-Object-like characteristics (constructor with schema.name)
-        if (value.schema !== undefined && value.constructor?.name !== "QualifiedName"
-            && value.constructor?.name !== "LocalizedText"
-            && value.constructor?.name !== "DiagnosticInfo") {
+        if (
+            value.schema !== undefined &&
+            value.constructor?.name !== "QualifiedName" &&
+            value.constructor?.name !== "LocalizedText" &&
+            value.constructor?.name !== "DiagnosticInfo"
+        ) {
             return true;
         }
         return false;
@@ -243,7 +255,7 @@ function getOrCreateProperty(
     const components = variableNode.getComponents();
     let property: UAVariableImpl;
     const selectedComponents = components.filter(
-        (f) => f instanceof UAVariableImpl && f.browseName.name!.toString() === field.name
+        (f) => f instanceof UAVariableImpl && f.browseName.name?.toString() === field.name
     );
 
     // c8 ignore next
@@ -256,7 +268,7 @@ function getOrCreateProperty(
         property = selectedComponents[0] as UAVariableImpl;
         /* c8 ignore next */
     } else {
-        if (!options!.createMissingProp) {
+        if (!options?.createMissingProp) {
             return null;
         }
         debugLog("adding missing array variable", field.name, variableNode.browseName.toString(), variableNode.nodeId.toString());
@@ -264,7 +276,7 @@ function getOrCreateProperty(
         assert(selectedComponents.length === 0);
         // create a variable (Note we may use ns=1;s=parentName/0:PropertyName)
         property = variableNode.namespace.addVariable({
-            browseName: { namespaceIndex: structureNamespace, name: field.name!.toString() },
+            browseName: { namespaceIndex: structureNamespace, name: field.name?.toString() },
             componentOf: variableNode,
             dataType: field.dataType,
             minimumSamplingInterval: variableNode.minimumSamplingInterval,
@@ -277,7 +289,6 @@ function getOrCreateProperty(
     return property;
 }
 
-
 function installExt(uaVariable: UAVariableImpl, ext: ExtensionObject) {
     ext = unProxy(ext);
     uaVariable.$extensionObject = new Proxy(
@@ -292,7 +303,7 @@ function installExt(uaVariable: UAVariableImpl, ext: ExtensionObject) {
         if (field.dataType) {
             const dataTypeNode = addressSpace.findDataType(field.dataType);
             // c8 ignore next
-            if (dataTypeNode && dataTypeNode.isSubtypeOf(structure)) {
+            if (dataTypeNode?.isSubtypeOf(structure)) {
                 // sub structure .. let make an handler too
                 const camelCaseName = lowerFirstLetter(field.name!);
 
@@ -312,7 +323,10 @@ function installExt(uaVariable: UAVariableImpl, ext: ExtensionObject) {
     }
 }
 
-export function _installExtensionObjectBindingOnProperties(uaVariable: UAVariableImpl, options?: BindExtensionObjectOptions): void {
+export function _installExtensionObjectBindingOnProperties(
+    uaVariable: UAVariableImpl,
+    _options?: BindExtensionObjectOptions
+): void {
     // may be extension object mechanism has alreday been install
     // in this case we just need to rebind the properties...
     if (uaVariable.$extensionObject) {
@@ -330,12 +344,11 @@ export function _installExtensionObjectBindingOnProperties(uaVariable: UAVariabl
     const extObj = dataValue.value.value;
     if (extObj instanceof ExtensionObject) {
         uaVariable.bindExtensionObject(extObj, { createMissingProp: true, force: true });
-    } else if (extObj instanceof Array) {
+    } else if (Array.isArray(extObj)) {
         if (dataValue.value.arrayType === VariantArrayType.Array || dataValue.value.arrayType === VariantArrayType.Matrix) {
             _bindExtensionObjectArrayOrMatrix(uaVariable, extObj, { createMissingProp: true, force: true });
-        }
-        /* c8 ignore next */
-        else {
+        } else {
+            /* c8 ignore next */
             throw new Error("Internal Error, unexpected case");
         }
     }
@@ -382,14 +395,14 @@ function _installFields2(
             propertyNode.valueRank === -1
                 ? VariantArrayType.Scalar
                 : propertyNode.valueRank === 1
-                    ? VariantArrayType.Array
-                    : VariantArrayType.Matrix;
+                  ? VariantArrayType.Array
+                  : VariantArrayType.Matrix;
         propertyNode.$dataValue.value.dimensions = propertyNode.valueRank > 1 ? propertyNode.arrayDimensions : null;
 
         const fieldName = field.name!;
         installDataValueGetter(propertyNode, () => get(fieldName));
         assert(propertyNode._inner_replace_dataValue);
-        propertyNode._inner_replace_dataValue = (dataValue: DataValue, indexRange?: NumericRange | null) => {
+        propertyNode._inner_replace_dataValue = (dataValue: DataValue, _indexRange?: NumericRange | null) => {
             /** */
             const sourceTime = coerceClock(dataValue.sourceTimestamp, dataValue.sourcePicoseconds);
             const value = dataValue.value.value;
@@ -405,7 +418,7 @@ function _installFields2(
                         const mainFieldName = field.name!;
                         return get(mainFieldName)[lowerFirstLetter(fieldName)];
                     },
-                    set: (fieldName: string, value: any, sourceTime: PreciseClock) => {
+                    set: (fieldName: string, value: any, _sourceTime: PreciseClock) => {
                         const mainFieldName = field.name!;
                         get(mainFieldName)[lowerFirstLetter(fieldName)] = value;
                     }
@@ -423,7 +436,7 @@ function installDataValueGetter(propertyNode: UAVariableImpl, get: () => any) {
         get() {
             return $;
         },
-        set: (value) => {
+        set: (_value) => {
             throw new Error("$dataValue is now frozen and should not be modified this way !\n contact sterfive.com");
         }
     });
@@ -504,12 +517,12 @@ export function _bindExtensionObject(
     if (optionalExtensionObject && uaVariable.valueRank === 0) {
         warningLog(
             uaVariable.browseName.toString() +
-            ": valueRank was zero but needed to be adjusted to -1 (Scalar) in bindExtensionObject"
+                ": valueRank was zero but needed to be adjusted to -1 (Scalar) in bindExtensionObject"
         );
         uaVariable.valueRank = -1;
     }
     const addressSpace = uaVariable.addressSpace;
-    let extensionObject_;
+    let extensionObject_: ExtensionObject | undefined;
 
     // c8 ignore next
     if (uaVariable.valueRank !== -1 && uaVariable.valueRank !== 1) {
@@ -529,7 +542,7 @@ export function _bindExtensionObject(
         const dataTypeNode = addressSpace.findNode(parentDataType) as UADataType;
         const structure = addressSpace.findDataType("Structure")!;
         // c8 ignore next
-        if (dataTypeNode && dataTypeNode.isSubtypeOf(structure)) {
+        if (dataTypeNode?.isSubtypeOf(structure)) {
             // warningLog(
             //     "Ignoring bindExtensionObject on sub extension object",
             //     "child=",
@@ -555,9 +568,9 @@ export function _bindExtensionObject(
             warningLog(uaVariable.$extensionObject?.toString());
             throw new Error(
                 "bindExtensionObject: $extensionObject is incorrect: we are expecting a " +
-                uaVariable.dataType.toString({ addressSpace: uaVariable.addressSpace }) +
-                " but we got a " +
-                uaVariable.$extensionObject?.schema.name
+                    uaVariable.dataType.toString({ addressSpace: uaVariable.addressSpace }) +
+                    " but we got a " +
+                    uaVariable.$extensionObject?.schema.name
             );
         }
         return uaVariable.$extensionObject;
@@ -639,7 +652,7 @@ const composeBrowseNameAndNodeId = (uaVariable: UAVariable, indexes: number[]) =
     const browseName = coerceQualifiedName(iAsText);
     let nodeId: NodeId | undefined;
     if (uaVariable.nodeId.identifierType === NodeIdType.STRING) {
-        nodeId = new NodeId(NodeIdType.STRING, (uaVariable.nodeId.value as string) + `[${iAsText}]`, uaVariable.nodeId.namespace);
+        nodeId = new NodeId(NodeIdType.STRING, `${uaVariable.nodeId.value as string}[${iAsText}]`, uaVariable.nodeId.namespace);
     }
     return { browseName, nodeId };
 };
@@ -679,14 +692,14 @@ export function _bindExtensionObjectArrayOrMatrix(
 
     /** */
     const addressSpace = uaVariable.addressSpace;
-    if (optionalExtensionObjectArray && optionalExtensionObjectArray.length != 0) {
+    if (optionalExtensionObjectArray && optionalExtensionObjectArray.length !== 0) {
         if (optionalExtensionObjectArray.length !== totalLength) {
             throw new Error(
                 `optionalExtensionObjectArray must have the expected number of element matching ${arrayDimensions} but was ${optionalExtensionObjectArray.length}`
             );
         }
     }
-    if (!optionalExtensionObjectArray || optionalExtensionObjectArray.length == 0) {
+    if (!optionalExtensionObjectArray || optionalExtensionObjectArray.length === 0) {
         optionalExtensionObjectArray = [];
         for (let i = 0; i < totalLength; i++) {
             optionalExtensionObjectArray[i] = addressSpace.constructExtensionObject(uaVariable.dataType, {});
@@ -756,12 +769,13 @@ export function _bindExtensionObjectArrayOrMatrix(
             _innerBindExtensionObjectScalar(
                 uaElement,
                 {
-                    get: () => uaVariable.$$extensionObjectArray[capturedIndex],
+                    get: () => getExtensionObjectArray(uaVariable)[capturedIndex],
                     set: (newValue: ExtensionObject, sourceTimestamp: PreciseClock, cache: Set<UAVariableImpl>) => {
-                        assert(!isProxy(uaVariable.$$extensionObjectArray[capturedIndex]));
-                        uaVariable.$$extensionObjectArray[capturedIndex] = newValue;
+                        const extArray = getExtensionObjectArray(uaVariable);
+                        assert(!isProxy(extArray[capturedIndex]));
+                        extArray[capturedIndex] = newValue;
                         // c8 ignore next
-                        if (uaVariable.$$extensionObjectArray !== uaVariable.$dataValue.value.value) {
+                        if (extArray !== uaVariable.$dataValue.value.value) {
                             warningLog("uaVariable", uaVariable.nodeId.toString());
                             warningLog("Houston! We have a problem ");
                         }
@@ -770,8 +784,8 @@ export function _bindExtensionObjectArrayOrMatrix(
                     },
                     setField: (fieldName: string, newValue: any, sourceTimestamp: PreciseClock, cache?: Set<UAVariableImpl>) => {
                         // c8 ignore next doDebug && debugLog("setField", fieldName, newValue, sourceTimestamp, cache);
-                        const extObj = uaVariable.$$extensionObjectArray[capturedIndex];
-                        (isProxy(extObj) ? getProxyTarget(extObj) : extObj)[lowerFirstLetter(fieldName)] = newValue;
+                        const extObj = getExtensionObjectArray(uaVariable)[capturedIndex];
+                        unProxy(extObj)[lowerFirstLetter(fieldName)] = newValue;
                         propagateTouchValueUpward(capturedUaElement, sourceTimestamp, cache);
                     }
                 },
@@ -808,12 +822,11 @@ export function incrementElement(path: string | string[], data: any) {
     setElement(path, data, value + 1);
 }
 export function extractPartialData(path: string | string[], extensionObject: ExtensionObject) {
-    let name;
+    let name : string;
     if (typeof path === "string") {
         path = path.split(".");
     }
-    assert(path instanceof Array);
-    let i;
+    let i : number;
     // read partial value
     const partialData: any = {};
     let p: any = partialData;

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

@@ -1,54 +1,45 @@
 /**
  * @module node-opcua-address-space
  */
-// tslint:disable:max-classes-per-file
-// tslint:disable:no-console
-
-import { assert } from "node-opcua-assert";
-import {
-    IAddressSpace,
+import type {
     AddVariableOptions,
     BaseNode,
+    BaseNodeEvents,
+    IAddressSpace,
+    INamespace,
     InstantiateVariableOptions,
     ModellingRuleType,
-    INamespace,
+    UAMethod,
+    UAObject,
+    UAObjectType,
     UAVariable,
     UAVariableType
 } from "node-opcua-address-space-base";
-
-import { coerceQualifiedName, NodeClass, QualifiedName, BrowseDirection, AttributeIds } from "node-opcua-data-model";
-import { DataValue, DataValueLike } from "node-opcua-data-value";
-import { checkDebugFlag, make_debugLog, make_warningLog, make_errorLog } from "node-opcua-debug";
-import { coerceNodeId, NodeId, NodeIdLike } from "node-opcua-nodeid";
+import { assert } from "node-opcua-assert";
+import type { UInt32 } from "node-opcua-basic-types";
+import { AttributeIds, BrowseDirection, coerceQualifiedName, NodeClass, type QualifiedName } from "node-opcua-data-model";
+import { DataValue, type DataValueLike } from "node-opcua-data-value";
+import { make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
+import { coerceNodeId, NodeId, type NodeIdLike } from "node-opcua-nodeid";
 import { StatusCodes } from "node-opcua-status-code";
-import { UInt32 } from "node-opcua-basic-types";
 import { isNullOrUndefined } from "node-opcua-utils";
 import { DataType, Variant, VariantArrayType, verifyRankAndDimensions } from "node-opcua-variant";
-
 import { SessionContext } from "../source/session_context";
-
 import { initialize_properties_and_components } from "./_instantiate_helpers";
-import { AddressSpacePrivate } from "./address_space_private";
-import { BaseNodeImpl, InternalBaseNodeOptions } from "./base_node_impl";
-import { _clone_hierarchical_references, ToStringBuilder, UAVariableType_toString } from "./base_node_private";
-import { construct_isSubtypeOf } from "./tool_isSubtypeOf";
-import { get_subtypeOfObj } from "./tool_isSubtypeOf";
-import { get_subtypeOf } from "./tool_isSubtypeOf";
+import type { AddressSpacePrivate } from "./address_space_private";
+import { BaseNodeImpl, type InternalBaseNodeOptions } from "./base_node_impl";
+import { ToStringBuilder, UAVariableType_toString } from "./base_node_private";
 import { checkValueRankCompatibility } from "./check_value_rank_compatibility";
 import { _getBasicDataType } from "./get_basic_datatype";
+import { construct_isSubtypeOf, get_subtypeOf, get_subtypeOfObj } from "./tool_isSubtypeOf";
 
 const debugLog = make_debugLog(__filename);
-const doDebug = checkDebugFlag(__filename);
 const warningLog = make_warningLog(__filename);
 const errorLog = make_errorLog(__filename);
 
-// eslint-disable-next-line prefer-const
-let doTrace = checkDebugFlag("INSTANTIATE");
-const traceLog = errorLog;
-
 interface InstantiateS {
-    propertyOf?: any;
-    componentOf?: any;
+    propertyOf?: NodeIdLike | UAObject | UAObjectType | UAVariable | UAVariableType | UAMethod;
+    componentOf?: NodeIdLike | BaseNode;
     modellingRule?: ModellingRuleType;
     copyAlsoModellingRules?: boolean;
     copyAlsoAllOptionals?: boolean;
@@ -65,7 +56,7 @@ export function topMostParentIsObjectTypeOrVariableType(addressSpace: AddressSpa
     if (!parent) {
         return false;
     }
-    const parentNode = addressSpace._coerceNode(parent);
+    const parentNode = addressSpace._coerceNode(parent as BaseNode | NodeIdLike);
     if (!parentNode) {
         return false;
     }
@@ -99,14 +90,14 @@ export interface UAVariableTypeOptions extends InternalBaseNodeOptions {
     arrayDimensions?: number[] | null;
     historizing?: boolean;
     isAbstract?: boolean;
-    value?: any;
+    value?: unknown;
     dataType: NodeIdLike;
 }
 
 function deprecate<T>(func: T): T {
     return func;
 }
-export class UAVariableTypeImpl extends BaseNodeImpl implements UAVariableType {
+export class UAVariableTypeImpl extends BaseNodeImpl<BaseNodeEvents> implements UAVariableType {
     public readonly nodeClass = NodeClass.VariableType;
 
     public get subtypeOf(): NodeId | null {
@@ -127,7 +118,7 @@ export class UAVariableTypeImpl extends BaseNodeImpl implements UAVariableType {
     public valueRank: number;
     public arrayDimensions: UInt32[] | null;
     public readonly minimumSamplingInterval: number;
-    public readonly value: any;
+    public readonly value: unknown;
     public historizing: boolean;
 
     constructor(options: UAVariableTypeOptions) {
@@ -157,13 +148,13 @@ export class UAVariableTypeImpl extends BaseNodeImpl implements UAVariableType {
         const options: DataValueLike = {};
         switch (attributeId) {
             case AttributeIds.IsAbstract:
-                options.value = { dataType: DataType.Boolean, value: this.isAbstract ? true : false };
+                options.value = { dataType: DataType.Boolean, value: !!this.isAbstract };
                 options.statusCode = StatusCodes.Good;
                 break;
             case AttributeIds.Value:
-                if (Object.prototype.hasOwnProperty.call(this, "value") && this.value !== undefined) {
-                    assert(this.value.schema.name === "Variant");
-                    options.value = this.value;
+                if (Object.hasOwn(this, "value") && this.value !== undefined) {
+                    assert((this.value as Variant).schema.name === "Variant");
+                    options.value = this.value as Variant;
                     options.statusCode = StatusCodes.Good;
                 } else {
                     debugLog(" warning Value not implemented");
@@ -228,15 +219,15 @@ export class UAVariableTypeImpl extends BaseNodeImpl implements UAVariableType {
             typeof options.browseName === "string" || (options.browseName !== null && typeof options.browseName === "object"),
             "expecting a browse name"
         );
-        assert(
-            !Object.prototype.hasOwnProperty.call(options, "propertyOf"),
-            "Use addressSpace#addVariable({ propertyOf: xxx}); to add a property"
-        );
+        assert(!Object.hasOwn(options, "propertyOf"), "Use addressSpace#addVariable({ propertyOf: xxx}); to add a property");
 
         assertUnusedChildBrowseName(addressSpace, options);
 
-        const baseVariableType = addressSpace.findVariableType("BaseVariableType")!;
-        assert(baseVariableType, "BaseVariableType must be defined in the address space");
+        const baseVariableType = addressSpace.findVariableType("BaseVariableType");
+        // c8 ignore next
+        if (!baseVariableType) {
+            throw new Error("BaseVariableType must be defined in the address space");
+        }
 
         let dataType = options.dataType !== undefined ? options.dataType : this.dataType;
         // may be required (i.e YArrayItemType )
@@ -267,7 +258,7 @@ export class UAVariableTypeImpl extends BaseNodeImpl implements UAVariableType {
         // BadAttributeIdInvalid
         const defaultDataValue = this.readAttribute(null, AttributeIds.Value);
         const defaultValue =
-            (defaultDataType.namespace === 0 && defaultDataType.value == 0) || defaultDataValue.statusCode.isNotGood()
+            (defaultDataType.namespace === 0 && defaultDataType.value === 0) || defaultDataValue.statusCode.isNotGood()
                 ? undefined
                 : defaultDataValue.value;
 
@@ -296,10 +287,13 @@ export class UAVariableTypeImpl extends BaseNodeImpl implements UAVariableType {
         const copyAlsoAllOptionals = options.copyAlsoAllOptionals || false;
 
         initialize_properties_and_components(
-            instance, baseVariableType, this, 
+            instance,
+            baseVariableType,
+            this,
             copyAlsoModellingRules,
             copyAlsoAllOptionals,
-            options.optionals);
+            options.optionals
+        );
 
         // if VariableType is a type of Structure DataType
         // we need to instantiate a dataValue
@@ -311,7 +305,7 @@ export class UAVariableTypeImpl extends BaseNodeImpl implements UAVariableType {
         instance.install_extra_properties();
 
         if (this._postInstantiateFunc) {
-            this._postInstantiateFunc(instance, this);
+            this._postInstantiateFunc(instance as BaseNode, this);
         }
 
         return instance;
@@ -364,14 +358,14 @@ export function assertUnusedChildBrowseName(addressSpace: AddressSpacePrivate, o
     }
     assert(parent !== null && typeof parent === "object");
     if (!(parent instanceof BaseNodeImpl)) {
-        throw new Error("Invalid parent  parent is " + parent.constructor.name);
+        throw new Error(`Invalid parent  parent is ${parent.constructor.name}`);
     }
     // c8 ignore next
     // verify that no components already exists in parent
-    if (parent && hasChildWithBrowseName(parent, coerceQualifiedName(options.browseName))) {
+    if (parent && hasChildWithBrowseName(parent as BaseNode, coerceQualifiedName(options.browseName))) {
         throw new Error(
             "object " +
-                parent.browseName.name!.toString() +
+                parent.browseName.name?.toString() +
                 " have already a child with browseName " +
                 options.browseName.toString()
         );

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

@@ -1,15 +1,15 @@
 /**
  * @module node-opcua-address-space
  */
-import { NodeClass } from "node-opcua-data-model";
-import { AttributeIds } from "node-opcua-data-model";
-import { DataValue, DataValueLike } from "node-opcua-data-value";
+
+import { EventNotifierFlags, type ISessionContext, type UAView } from "node-opcua-address-space-base";
+import { AttributeIds, NodeClass } from "node-opcua-data-model";
+import { DataValue, type DataValueLike } from "node-opcua-data-value";
 import { StatusCodes } from "node-opcua-status-code";
 import { DataType } from "node-opcua-variant";
-import { EventNotifierFlags, ISessionContext, UAView } from "node-opcua-address-space-base";
 
 import { SessionContext } from "../source/session_context";
-import { BaseNodeImpl, InternalBaseNodeOptions } from "./base_node_impl";
+import { BaseNodeImpl, type InternalBaseNodeOptions } from "./base_node_impl";
 
 export interface InternalViewOptions extends InternalBaseNodeOptions {
     containsNoLoops?: boolean;

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

@@ -1,9 +1,9 @@
 import chalk from "chalk";
+import type { IAddressSpace, UADataType } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
-import { IAddressSpace, UADataType } from "node-opcua-address-space-base";
 import { DataType } from "node-opcua-basic-types";
-import { make_debugLog, make_warningLog, checkDebugFlag, make_errorLog } from "node-opcua-debug";
-import { NodeId } from "node-opcua-nodeid";
+import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
+import type { NodeId } from "node-opcua-nodeid";
 
 const debugLog = make_debugLog(__filename);
 const doDebug = checkDebugFlag(__filename);
@@ -15,7 +15,7 @@ function _dataType_toUADataType(addressSpace: IAddressSpace, dataType: DataType)
     const dataTypeNode = addressSpace.findDataType(DataType[dataType]);
     /* c8 ignore next */
     if (!dataTypeNode) {
-        throw new Error(" Cannot find DataType " + DataType[dataType] + " in address Space");
+        throw new Error(` Cannot find DataType ${DataType[dataType]} in address Space`);
     }
     return dataTypeNode as UADataType;
 }
@@ -47,15 +47,19 @@ export function validateDataTypeCorrectness(
     let builtInType: DataType;
     let builtInUADataType: UADataType;
 
-    const destUADataType = addressSpace.findDataType(dataTypeNodeId)!;
+    const destUADataType = addressSpace.findDataType(dataTypeNodeId);
 
     // c8 ignore next
     if (!destUADataType) {
-        throw new Error("Cannot find UADataType " + dataTypeNodeId.toString() + " in address Space");
+        throw new Error(`Cannot find UADataType ${dataTypeNodeId.toString()} in address Space`);
     }
 
     if (variantDataType === DataType.ExtensionObject) {
-        const structure = addressSpace.findDataType("Structure")!;
+        const structure = addressSpace.findDataType("Structure");
+        // c8 ignore next
+        if (!structure) {
+            throw new Error("Cannot find Structure DataType node in standard address space");
+        }
         if (destUADataType.isSubtypeOf(structure)) {
             return true;
         }
@@ -70,7 +74,12 @@ export function validateDataTypeCorrectness(
             // it should have been trapped earlier
             return false;
         }
-        builtInUADataType = addressSpace.findDataType(builtInType)!;
+        const foundDataType = addressSpace.findDataType(builtInType);
+        /* c8 ignore next */
+        if (!foundDataType) {
+            throw new Error(`Cannot find DataType ${DataType[builtInType]} in address Space`);
+        }
+        builtInUADataType = foundDataType;
     }
 
     const enumerationUADataType = addressSpace.findDataType("Enumeration");

package/node_modules/@sterfive/opcua-pinned/node_modules/node-opcua-address-space-base/dist/address_space.d.ts

@@ -1,23 +1,23 @@
-import { ExtensionObject } from "node-opcua-extension-object";
-import { NodeId, NodeIdLike } from "node-opcua-nodeid";
-import { AnyConstructorFunc } from "node-opcua-schemas";
-import { StatusCode } from "node-opcua-status-code";
-import { BrowseDescription, BrowsePath, BrowsePathResult, BrowseResult } from "node-opcua-types";
-import { DataType, Variant, VariantByteString } from "node-opcua-variant";
-import { AddReferenceOpts, BaseNode } from "./base_node";
-import { INamespace } from "./namespace";
-import { ISessionContext } from "./session_context";
-import { UADataType } from "./ua_data_type";
-import { IEventData } from "./i_event_data";
-import { UAMethod } from "./ua_method";
-import { UAObject } from "./ua_object";
-import { UAEventType } from "./ua_event_type";
-import { UAObjectType } from "./ua_object_type";
-import { UAReference } from "./ua_reference";
-import { UAReferenceType } from "./ua_reference_type";
-import { IHistoricalDataNodeOptions, UAVariable } from "./ua_variable";
-import { UAVariableType } from "./ua_variable_type";
-import { UAView } from "./ua_view";
+import type { ExtensionObject } from "node-opcua-extension-object";
+import type { NodeId, NodeIdLike } from "node-opcua-nodeid";
+import type { AnyConstructorFunc } from "node-opcua-schemas";
+import type { StatusCode } from "node-opcua-status-code";
+import type { BrowseDescription, BrowsePath, BrowsePathResult, BrowseResult } from "node-opcua-types";
+import type { DataType, Variant, VariantByteString } from "node-opcua-variant";
+import type { AddReferenceOpts, BaseNode } from "./base_node";
+import type { IEventData } from "./i_event_data";
+import type { INamespace } from "./namespace";
+import type { ISessionContext } from "./session_context";
+import type { UADataType } from "./ua_data_type";
+import type { UAEventType } from "./ua_event_type";
+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 { UAReferenceType } from "./ua_reference_type";
+import type { IHistoricalDataNodeOptions, UAVariable } from "./ua_variable";
+import type { UAVariableType } from "./ua_variable_type";
+import type { UAView } from "./ua_view";
 export type ShutdownTask = ((this: IAddressSpace) => void) | ((this: IAddressSpace) => Promise<void>);
 /**
  * A method call interceptor is invoked before every UAMethod.execute() call.