node-opcua-address-space 2.178.0 → 2.179.0

package/src/historical_access/address_space_historical_data_node.ts

@@ -1,7 +1,6 @@
 /**
  * @module node-opcua-address-space
  */
-// tslint:disable:no-console
 
 import chalk from "chalk";
 import type {
@@ -35,7 +34,6 @@ import { UAVariableImpl } from "../ua_variable_impl";
 
 const warningLog = make_warningLog(__filename);
 
-// tslint:disable:no-var-requires
 interface DequeueItem<T> {
     data: T | null;
     next: DequeueItem<T>;
@@ -716,7 +714,7 @@ export function AddressSpace_installHistoricalDataNode(
     };
 
     assert(node.nodeClass === NodeClass.Variable);
-    options = options || Object.create(null);
+    const historianOptions: IVariableHistorianOptions = options || Object.create(null);
 
     const addressSpace = node.addressSpace;
 
@@ -729,7 +727,7 @@ export function AddressSpace_installHistoricalDataNode(
     node._historyReadRaw = _historyReadRaw;
     node._historyReadRawAsync = _historyReadRawAsync;
 
-    node.varHistorian = (options as { historian?: boolean }).historian || AddressSpace.historizerFactory.create(node, options);
+    node.varHistorian = historianOptions.historian || AddressSpace.historizerFactory.create(node, historianOptions);
 
     const historicalDataConfigurationType = addressSpace.findObjectType("HistoricalDataConfigurationType");
     if (!historicalDataConfigurationType) {
@@ -737,7 +735,6 @@ export function AddressSpace_installHistoricalDataNode(
     }
     node.historizing = true;
 
-    // tslint:disable:no-bitwise
     node.accessLevel = node.accessLevel | AccessLevelFlag.CurrentRead | AccessLevelFlag.HistoryRead;
     if (node.userAccessLevel !== undefined) {
         node.userAccessLevel = node.userAccessLevel | AccessLevelFlag.CurrentRead | AccessLevelFlag.HistoryRead;

package/src/namespace_impl.ts

@@ -1,7 +1,6 @@
 /**
  * @module node-opcua-address-space
  */
-// tslint:disable:no-console
 import chalk from "chalk";
 import type {
     AddBaseNodeOptions,
@@ -16,7 +15,7 @@ import type {
     AddViewOptions,
     AddYArrayItemOptions,
     BaseNode,
-
+    BaseNodeEvents,
     CreateDataTypeOptions,
     CreateNodeOptions,
     EnumerationItem,
@@ -102,7 +101,6 @@ import {
     UAConditionImplBase,
     UADiscreteAlarmImplBase
 } from "./alarms_and_conditions";
-import { UADiscreteAlarmImpl } from "./alarms_and_conditions/ua_discrete_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";
@@ -1019,7 +1017,7 @@ export class NamespaceImpl implements NamespacePrivate {
 
             instrumentRange.on("value_changed", handler);
         }
-        (variable as any).acceptValueOutOfRange = options.acceptValueOutOfRange;
+        (variable as unknown as { acceptValueOutOfRange?: boolean }).acceptValueOutOfRange = options.acceptValueOutOfRange;
 
         if (Object.hasOwn(options, "engineeringUnits")) {
             const engineeringUnits = new EUInformation(options.engineeringUnits);
@@ -1209,7 +1207,7 @@ export class NamespaceImpl implements NamespacePrivate {
             })
         );
 
-        return variable as any;
+        return variable as unknown as UAYArrayItemEx<DT>;
     }
 
     // - Methods ----------------------------------------------------------------------------------------------------
@@ -1424,7 +1422,7 @@ export class NamespaceImpl implements NamespacePrivate {
             //   or OptionSet DataType. It is derived from the DataType EnumValueType. If used for an
             //   OptionSet, the corresponding Value in the base type contains the number of the bit associated
             //   with the field. The EnumField is formally defined in Table 37.
-            (enumType as any).$fullDefinition = new EnumDefinition({
+            (enumType as unknown as { $fullDefinition?: EnumDefinition }).$fullDefinition = new EnumDefinition({
                 fields: enumeration.map(
                     (x: string, index: number) =>
                         new EnumField({
@@ -1463,7 +1461,7 @@ export class NamespaceImpl implements NamespacePrivate {
             });
             assert(enumValues.browseName.toString() === "EnumValues");
 
-            (enumType as any).$fullDefinition = new EnumDefinition({
+            (enumType as unknown as { $fullDefinition?: EnumDefinition }).$fullDefinition = new EnumDefinition({
                 fields: enumeration.map(
                     (x: EnumerationItem, _index: number) =>
                         new EnumField({
@@ -1804,7 +1802,6 @@ export class NamespaceImpl implements NamespacePrivate {
             case NodeClass.View:
                 break;
             default:
-                // tslint:disable-next-line:no-console
                 errorLog("Invalid class Name", node.nodeClass);
                 throw new Error("Invalid class name specified");
         }
@@ -1885,8 +1882,7 @@ export class NamespaceImpl implements NamespacePrivate {
 
         options.addressSpace = this.addressSpace as AddressSpacePrivate;
 
-        // biome-ignore lint/suspicious/noExplicitAny: to fix later
-        const node = new Constructor(options as any);
+        const node = new Constructor(options);
         this._register(node);
 
         // object shall now be registered
@@ -1918,7 +1914,6 @@ export class NamespaceImpl implements NamespacePrivate {
             case NodeClass.View:
                 break;
             default:
-                // tslint:disable:no-console
                 warningLog("Invalid class Name", node.nodeClass);
                 throw new Error("Invalid class name specified");
         }
@@ -1948,15 +1943,23 @@ export class NamespaceImpl implements NamespacePrivate {
         }
         const references: UAReference[] = [];
 
-        function process_subtypeOf_options(this: NamespaceImpl, options2: any, references1: AddReferenceOpts[]) {
+        function process_subtypeOf_options(this: NamespaceImpl, options2: CreateNodeOptions, references1: AddReferenceOpts[]) {
             // check common misspelling mistake
-            assert(!options2.subTypeOf, "misspell error : it should be 'subtypeOf' instead");
+            assert(
+                !(options2 as unknown as Record<string, unknown>).subTypeOf,
+                "misspell error : it should be 'subtypeOf' instead"
+            );
             if (Object.hasOwn(options2, "hasTypeDefinition")) {
                 throw new Error("hasTypeDefinition option is invalid. Do you mean typeDefinition instead ?");
             }
             assert(!options2.typeDefinition, " do you mean subtypeOf ?");
 
-            const subtypeOfNodeId = addressSpace._coerceType(options2.subtypeOf, topMostBaseType, nodeClass);
+            // subtypeOf is optional: _coerceType defaults to topMostBaseType when it's falsy.
+            const subtypeOfNodeId = addressSpace._coerceType(
+                options2.subtypeOf as unknown as string | NodeId | BaseNode,
+                topMostBaseType,
+                nodeClass
+            );
 
             assert(subtypeOfNodeId);
             references1.push({
@@ -2142,7 +2145,7 @@ export class NamespaceImpl implements NamespacePrivate {
     /**
      * @private
      */
-    private _addMethod(options: any): UAMethod {
+    private _addMethod(options: AddMethodOptions & { eventNotifier?: number }): UAMethod {
         const addressSpace = this.addressSpace;
 
         assert(isNonEmptyQualifiedName(options.browseName));
@@ -2158,7 +2161,7 @@ export class NamespaceImpl implements NamespacePrivate {
             browseName: options.browseName,
             description: options.description || "",
             displayName: options.displayName,
-            eventNotifier: +options.eventNotifier,
+            eventNotifier: +(options.eventNotifier || 0),
             isAbstract: false,
             nodeClass: NodeClass.Method,
             nodeId: options.nodeId,
@@ -2173,7 +2176,11 @@ export class NamespaceImpl implements NamespacePrivate {
     }
 }
 
-const _constructors_map: Record<keyof Omit<typeof NodeClass, "Unspecified">, new (options: any) => BaseNodeImpl<any>> = {
+// each concrete constructor below takes a different, incompatible options type (UADataTypeOptions,
+// UAVariableOptions, ...) — the map is only ever indexed by nodeClass and invoked with the matching
+// options shape by the caller, so a wider `new (options: any) => ...` signature is required here.
+// biome-ignore lint/suspicious/noExplicitAny: see comment above
+const _constructors_map: Record<keyof Omit<typeof NodeClass, "Unspecified">, new (options: any) => BaseNodeImpl<BaseNodeEvents>> = {
     DataType: UADataTypeImpl,
     Method: UAMethodImpl,
     Object: UAObjectImpl,

package/src/nodeid_manager.ts

@@ -1,13 +1,10 @@
-/* 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, type QualifiedName, type QualifiedNameOptions } from "node-opcua-data-model";
 import { make_debugLog, make_warningLog } from "node-opcua-debug";
 import { makeNodeId, NodeId, type NodeIdLike, NodeIdType, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
-import { BaseNodeImpl, getReferenceType } from "./base_node_impl";
-import { resolveReferenceType } from "./reference_impl";
+import { BaseNodeImpl } from "./base_node_impl";
+import { type ReferenceImpl, resolveReferenceType } from "./reference_impl";
 
 const _debugLog = make_debugLog(__filename);
 const _warningLog = make_warningLog(__filename);
@@ -16,7 +13,7 @@ export const NamespaceOptions = {
     nodeIdNameSeparator: "-"
 };
 function _isValidNodeClass(nodeClass: NodeClass) {
-    return typeof (NodeClass as any)[nodeClass] === "string";
+    return typeof NodeClass[nodeClass] === "string";
 }
 
 const regExp1 = /^(s|i|b|g)=/;
@@ -59,12 +56,13 @@ function _findParentNodeId(addressSpace: AddressSpacePartial, options: Construct
         return null;
     }
     for (const ref of options.references) {
-        (ref as any)._referenceType = addressSpace.findReferenceType(ref.referenceType);
+        const _ref = ref as ReferenceImpl;
+        _ref._referenceType = addressSpace.findReferenceType(ref.referenceType) ?? undefined;
         /* c8 ignore next */
-        if (!getReferenceType(ref)) {
+        if (!_ref._referenceType) {
             throw new Error(`Cannot find referenceType ${JSON.stringify(ref)}`);
         }
-        (ref as any).referenceType = (ref as any)._referenceType.nodeId;
+        _ref.referenceType = _ref._referenceType.nodeId;
     }
     // find HasComponent, or has Property reverse
     return _filterAggregates(addressSpace, options.references);
@@ -105,7 +103,7 @@ export class NodeIdManager {
 
     public setSymbols(symbols: NodeEntry1[]): void {
         function convertNodeClass(nodeClass: string): NodeClass {
-            return (NodeClass as any)[nodeClass as any] as NodeClass;
+            return (NodeClass as unknown as Record<string, NodeClass>)[nodeClass];
         }
         const symbols2 = symbols.map((e: [string, number, string]) => [e[0] as string, e[1] as number, convertNodeClass(e[2])]) as [
             string,
@@ -243,7 +241,6 @@ export class NodeIdManager {
     }
 
     private _constructNodeId(options: ConstructNodeIdOptions): NodeId {
-
         const resolveNodeIdEx = (nodeId: BaseNode | NodeIdLike) =>
             nodeId && typeof nodeId === "object" && nodeId instanceof BaseNodeImpl
                 ? nodeId.nodeId

package/src/nodeset_tools/construct_namespace_dependency.ts

@@ -18,7 +18,6 @@ interface RequiredModel {
     requiredNamespaceIndexes: number[];
     nbTypes: number;
 }
-// eslint-disable-next-line max-statements, complexity
 export function _recomputeRequiredModelsFromTypes(namespace: INamespace, cache?: Map<number, RequiredModel>): RequiredModel {
     if (namespace.index === 0) {
         return { requiredNamespaceIndexes: [], nbTypes: 1 };
@@ -103,12 +102,12 @@ export function _recomputeRequiredModelsFromTypes(namespace: INamespace, cache?:
         if (!uaVariable.$dataValue) return;
         const variant = uaVariable.$dataValue.value;
         if (!variant) return;
-        const value: any | any[] = variant.value;
+        const value: unknown = variant.value;
         if (!value) return;
         if (Array.isArray(value)) {
-            value.forEach(exploreExtensionObject);
+            (value as ExtensionObject[]).forEach(exploreExtensionObject);
         } else {
-            exploreExtensionObject(value);
+            exploreExtensionObject(value as ExtensionObject);
         }
     }
     for (const node of namespace_.nodeIterator()) {
@@ -132,7 +131,7 @@ export function _recomputeRequiredModelsFromTypes(namespace: INamespace, cache?:
         } else if (isInstance !== -1) {
             if (node.nodeClass === NodeClass.Variable || node.nodeClass === NodeClass.VariableType) {
                 const dataTypeNodeId = (node as UAVariable | UAVariableType).dataType;
-                const dataTypeNode = addressSpace.findDataType(dataTypeNodeId)!;
+                const dataTypeNode = addressSpace.findDataType(dataTypeNodeId);
                 if (dataTypeNode) {
                     consider(dataTypeNode.nodeId.namespace);
                 } else {
@@ -236,9 +235,11 @@ export function _getCompleteRequiredModelsFromValuesAndReferences(
                         // 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)) {
+                        if (
+                            reference.isForward &&
+                            nonHierarchicalReferencesType &&
+                            referenceType.isSubtypeOf(nonHierarchicalReferencesType)
+                        ) {
                             consider(namespaceIndexOfTargetNode);
                         }
                         // For inverse HierarchicalReferences (e.g. Organizes),
@@ -246,9 +247,11 @@ export function _getCompleteRequiredModelsFromValuesAndReferences(
                         // 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)) {
+                        if (
+                            !reference.isForward &&
+                            hierarchicalReferencesType &&
+                            referenceType.isSubtypeOf(hierarchicalReferencesType)
+                        ) {
                             consider(namespaceIndexOfTargetNode);
                         }
                     }
@@ -313,14 +316,14 @@ export function constructNamespacePriorityTable(addressSpace: IAddressSpace): {
     };
 
     for (let i = 0; i < namespaces.length; i++) {
-        const { nbTypes } = map.get(i)!;
-        if (nbTypes) {
+        const entry = map.get(i);
+        if (entry?.nbTypes) {
             h(namespaces[i]);
         }
     }
     for (let i = 0; i < namespaces.length; i++) {
-        const { nbTypes } = map.get(i)!;
-        if (!nbTypes) {
+        const entry = map.get(i);
+        if (!entry?.nbTypes) {
             h(namespaces[i]);
         }
     }

package/src/nodeset_tools/dump_to_bsd.ts

@@ -7,7 +7,6 @@ import type { AddressSpacePrivate } from "../address_space_private";
 import type { NamespacePrivate } from "../namespace_private";
 import { constructNamespaceDependency } from "./construct_namespace_dependency";
 
-// tslint:disable-next-line: no-var-requires
 const XMLWriter = require("xml-writer");
 
 function dumpEnumeratedType(xw: XmlWriter, e: EnumDefinition, name: string): void {
@@ -16,7 +15,7 @@ function dumpEnumeratedType(xw: XmlWriter, e: EnumDefinition, name: string): voi
     xw.writeAttribute("LengthInBits", "32");
     for (const f of e.fields || []) {
         xw.startElement("opc:EnumeratedValue");
-        xw.writeAttribute("Name", f.name|| "");
+        xw.writeAttribute("Name", f.name || "");
         assert(f.value[0] === 0, "unsupported 64 bit value !");
         xw.writeAttribute("Value", f.value[1].toString());
         xw.endElement();
@@ -32,7 +31,7 @@ function buildXmlName(addressSpace: AddressSpacePrivate, map: Map<number, string
     if (!node) {
         throw new Error(`Cannot find Node for${nodeId?.toString()}`);
     }
-    const typeName = node.browseName.name!;
+    const typeName = node.browseName.name || "";
 
     const n = node.nodeId as INodeId;
     const prefix =
@@ -44,7 +43,6 @@ function buildXmlName(addressSpace: AddressSpacePrivate, map: Map<number, string
     return `${prefix}:${typeName === "Structure" && prefix === "ua" ? "ExtensionObject" : typeName}`;
 }
 
-// eslint-disable-next-line max-statements
 function dumpDataTypeStructure(
     xw: XmlWriter,
     addressSpace: IAddressSpace,
@@ -110,7 +108,7 @@ function dumpDataTypeStructure(
 
         if (isArray) {
             xw.startElement("opc:Field");
-            xw.writeAttribute("Name", `NoOf${f.name!}`);
+            xw.writeAttribute("Name", `NoOf${f.name || ""}`);
             xw.writeAttribute("TypeName", "opc:Int32");
             if (f.isOptional) {
                 xw.writeAttribute("SwitchField", `${f.name}Specified`);
@@ -119,15 +117,15 @@ function dumpDataTypeStructure(
         }
 
         xw.startElement("opc:Field");
-        xw.writeAttribute("Name", f.name|| "");
+        xw.writeAttribute("Name", f.name || "");
 
         const typeName = buildXmlName(addressSpace as AddressSpacePrivate, map, f.dataType);
         xw.writeAttribute("TypeName", typeName);
         if (isArray) {
-            xw.writeAttribute("LengthField", `NoOf${f.name|| ""}`);
+            xw.writeAttribute("LengthField", `NoOf${f.name || ""}`);
         }
         if (f.isOptional) {
-            xw.writeAttribute("SwitchField", `${f.name|| ""}Specified`);
+            xw.writeAttribute("SwitchField", `${f.name || ""}Specified`);
         }
         xw.endElement();
     }