node-opcua-address-space 2.169.0 → 2.170.1

package/src/event_data.ts

@@ -1,80 +1,83 @@
 /**
  * @module node-opcua-address-space.Private
  */
+
+import type { BaseNode, IEventData } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import { coerceExpandedNodeId, NodeId, sameNodeId } from "node-opcua-nodeid";
 import { StatusCodes } from "node-opcua-status-code";
-import { BrowsePath, BrowsePathResult } from "node-opcua-types";
-import { Variant, VariantLike } from "node-opcua-variant";
-
-import { BaseNode, IEventData } from "node-opcua-address-space-base";
+import { type BrowsePath, BrowsePathResult } from "node-opcua-types";
 import { lowerFirstLetter } from "node-opcua-utils";
+import { Variant, type VariantLike } from "node-opcua-variant";
 
 type NodeIdString = string;
 type FullBrowsePath = string;
 
-
 /**
  */
 export class EventData implements IEventData {
-    public eventId: NodeId;
-    public $eventDataSource: BaseNode;
+  public eventId: NodeId;
+  #eventDataSource: BaseNode;
+  #cache: {
+    __values: { [key: NodeIdString]: Variant };
+    __nodeIdToNode: { [key: NodeIdString]: BaseNode };
+    __pathToNodeId: { [key: FullBrowsePath]: NodeId };
+    __nodeIdToFullPath: { [key: NodeIdString]: FullBrowsePath };
+  };
 
-    public $cache: {
-        __values: { [key: NodeIdString]: Variant };
-        __nodeIdToNode: { [key: NodeIdString]: BaseNode };
-        __pathToNodeId: { [key: FullBrowsePath]: NodeId };
-        __nodeIdToFullPath: { [key: NodeIdString]: FullBrowsePath };
+  constructor(eventTypeNode: BaseNode) {
+    this.#cache = {
+      __values: {},
+      __nodeIdToNode: {},
+      __pathToNodeId: {},
+      __nodeIdToFullPath: {}
     };
 
-    constructor(eventTypeNode: BaseNode) {
-        this.$cache = {
-            __values: {},
-            __nodeIdToNode: {},
-            __pathToNodeId: {},
-            __nodeIdToFullPath: {}
-        };
+    this.eventId = new NodeId();
+    this.#eventDataSource = eventTypeNode;
+  }
 
-        this.eventId = new NodeId();
-        this.$eventDataSource = eventTypeNode;
-    }
+  public getEventDataSource(): BaseNode {
+    return this.#eventDataSource;
+  }
+  public _createValue(fullBrowsePath: string, node: BaseNode, variant: VariantLike): void {
+    const eventData = this as Record<string, unknown>;
+    assert(!eventData[fullBrowsePath], `already exists ${fullBrowsePath}`);
 
-    public _createValue(fullBrowsePath: string, node: BaseNode, variant: VariantLike): void {
-        const eventData = this as any;
-        assert(!eventData[fullBrowsePath], "already exists " + fullBrowsePath);
+    const lowerName = fullBrowsePath.split(".").map(lowerFirstLetter).join(".");
 
-        const lowerName = fullBrowsePath.split(".").map(lowerFirstLetter).join(".");
+    eventData[lowerName] = Variant.coerce(variant);
 
-        eventData[lowerName] = Variant.coerce(variant);
+    this.#cache.__pathToNodeId[fullBrowsePath] = node.nodeId;
+    this.#cache.__nodeIdToNode[node.nodeId.toString()] = node;
+    this.#cache.__nodeIdToFullPath[node.nodeId.toString()] = fullBrowsePath;
+    this.#cache.__values[node.nodeId.toString()] = eventData[lowerName] as Variant;
+  }
 
-        this.$cache.__pathToNodeId[fullBrowsePath] = node.nodeId;
-        this.$cache.__nodeIdToNode[node.nodeId.toString()] = node;
-        this.$cache.__nodeIdToFullPath[node.nodeId.toString()] = fullBrowsePath;
-        this.$cache.__values[node.nodeId.toString()] = eventData[lowerName];
+  public _browse(browsePath: BrowsePath): BrowsePathResult | null {
+    if (!sameNodeId(browsePath.startingNode, this.#eventDataSource.nodeId)) {
+      return null;
     }
-
-    public _browse(browsePath: BrowsePath): BrowsePathResult | null {
-        if (!sameNodeId(browsePath.startingNode, this.$eventDataSource.nodeId)) {
-            return null;
+    const fullBrowsePath = (browsePath.relativePath.elements || []).map((b) => b.targetName.toString()).join(".");
+    const nodeId = this.#cache.__pathToNodeId[fullBrowsePath];
+    if (!nodeId) return null;
+    return new BrowsePathResult({
+      statusCode: StatusCodes.Good,
+      targets: [
+        {
+          remainingPathIndex: 0,
+          targetId: coerceExpandedNodeId(nodeId)
         }
-        const fullBrowsePath = (browsePath.relativePath.elements || []).map((b=>b.targetName.toString())).join(".");
-        const nodeId = this.$cache.__pathToNodeId[fullBrowsePath];
-        if (!nodeId) return null;
-        return new BrowsePathResult({
-            statusCode: StatusCodes.Good,
-            targets: [{
-                remainingPathIndex: 0,
-                targetId: coerceExpandedNodeId(nodeId),
-            }]
-        })
-    }
+      ]
+    });
+  }
 
-    public _readValue(nodeId: NodeId): Variant | null {
-        const key = nodeId.toString();
-        const cached_value = this.$cache.__values[key];
-        if (cached_value) {
-            return cached_value;
-        }
-        return null;
+  public _readValue(nodeId: NodeId): Variant | null {
+    const key = nodeId.toString();
+    const cached_value = this.#cache.__values[key];
+    if (cached_value) {
+      return cached_value;
     }
-}
+    return null;
+  }
+}

package/src/ua_object_impl.ts

@@ -5,36 +5,36 @@ import chalk from "chalk";
 
 import { assert } from "node-opcua-assert";
 import { isValidByte } from "node-opcua-basic-types";
-import { NodeClass, QualifiedNameLike, QualifiedNameOptions } from "node-opcua-data-model";
+import { NodeClass, type QualifiedNameLike, type QualifiedNameOptions } from "node-opcua-data-model";
 import { AttributeIds } from "node-opcua-data-model";
-import { DataValue, DataValueLike } from "node-opcua-data-value";
+import { DataValue, type DataValueLike } from "node-opcua-data-value";
 import { getCurrentClock } from "node-opcua-date-time";
 import { NodeId } from "node-opcua-nodeid";
-import { NumericRange } from "node-opcua-numeric-range";
+import type { NumericRange } from "node-opcua-numeric-range";
 import { StatusCodes } from "node-opcua-status-code";
 import { DataType } from "node-opcua-variant";
 import {
-    EventTypeLike,
-    RaiseEventData,
-    ISessionContext,
-    UAMethod,
-    UAObject,
-    UAObjectType,
-    CloneOptions,
-    CloneFilter,
-    CloneExtraInfo,
-    BaseNode,
-    UAEventType,
-    IEventData,
+    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 { BaseNodeImpl, InternalBaseNodeOptions } from "./base_node_impl";
+import { BaseNodeImpl, type InternalBaseNodeOptions } from "./base_node_impl";
 import { _clone, ToStringBuilder, UAObject_toString } from "./base_node_private";
-import { apply_condition_refresh, ConditionRefreshCache } from "./apply_condition_refresh";
+import { apply_condition_refresh, type ConditionRefreshCache } from "./apply_condition_refresh";
 
 const errorLog = make_errorLog(__filename);
 
@@ -159,11 +159,11 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
         } else if (eventType instanceof NodeId) {
             const eventTypeFound = addressSpace.findNode(eventType) as BaseNode;
             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) {
-                throw new Error("eventType must exist and be an UAObjectType" + eventType.toString());
+                throw new Error(`eventType must exist and be an UAObjectType: ${eventType.toString()}`);
             }
         }
 
@@ -172,14 +172,14 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
         let eventTypeNode: UAEventType = eventType as UAEventType;
         // c8 ignore next
         if (!eventTypeNode) {
-            throw new Error("UAObject#raiseEventType : Cannot find event type :" + eventType.toString());
+            throw new Error(`UAObject#raiseEventType : Cannot find event type : ${eventType.toString()}`);
         }
 
         // coerce EventType
         eventTypeNode = addressSpace.findEventType(eventType as UAEventType) as UAEventType;
-        const baseEventType = addressSpace.findEventType("BaseEventType")!;
+        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);
@@ -241,4 +241,33 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
         UAObject_toString.call(this, options);
         return options.toString();
     }
+
+    public toJSON(): Record<string, unknown> {
+        return {
+            ...super.toJSON(),
+            typeDefinition: this.typeDefinitionObj ? this.typeDefinitionObj.browseName.toString() : undefined,
+            eventNotifier: this._eventNotifier
+        };
+    }
+
+    public [Symbol.for("nodejs.util.inspect.custom")](depth: number | null, inspectOptions: { colors?: boolean }): string {
+        const c = inspectOptions?.colors === false ? plainChalk : chalk;
+        const typeName = this.typeDefinitionObj?.browseName.toString() ?? "?";
+        const displayName = this.displayName.length ? this.displayName.map((d) => d.text).join(" | ") : "";
+        if (depth !== null && depth <= 0) {
+            return `${c.cyan("UAObject<")}${c.green(this.browseName.toString())}${c.grey(` ${this.nodeId.toString()}`)}${c.cyan(">")}`;
+        }
+        const lines = [
+            `${c.cyan("UAObject ")}${c.green(this.browseName.toString())}${c.grey(` ${this.nodeId.toString()}`)}`,
+            c.yellow("  typeDefinition : ") + typeName,
+            c.yellow("  displayName    : ") + displayName,
+            c.yellow("  eventNotifier  : ") + this._eventNotifier
+        ];
+        if (this.description?.text) {
+            lines.push(c.yellow("  description    : ") + this.description.text);
+        }
+        return lines.join("\n");
+    }
 }
+
+const plainChalk = new Proxy(chalk, { get: () => (s: string) => s }) as typeof chalk;

package/src/ua_object_type_impl.ts

@@ -112,12 +112,12 @@ export class UAObjectTypeImpl extends BaseNodeImpl implements UAObjectType {
             "expecting a browse name"
         );
 
-        assert(!Object.prototype.hasOwnProperty.call(options, "propertyOf"), "an Object shall not be a PropertyOf an other object");
-        assert(!Object.prototype.hasOwnProperty.call(options, "optional"), "do you mean optionals ?");
+        assert(!Object.hasOwn(options, "propertyOf"), "an Object shall not be a PropertyOf an other object");
+        assert(!Object.hasOwn(options, "optional"), "do you mean optionals ?");
 
         assertUnusedChildBrowseName(addressSpace, options);
 
-        const baseObjectType = addressSpace.findObjectType("BaseObjectType")!;
+        const baseObjectType = addressSpace.findObjectType("BaseObjectType") as UAObjectType;
         assert(baseObjectType, "BaseObjectType must be defined in the address space");
 
         const references: UAReference[] = [];

package/src/ua_variable_impl.ts

@@ -76,7 +76,7 @@ import { UAHistoricalDataConfiguration } from "node-opcua-nodeset-ua";
 import { SessionContext } from "../source/session_context";
 import { convertToCallbackFunction1 } from "../source/helpers/multiform_func";
 import { BaseNodeImpl, InternalBaseNodeOptions } from "./base_node_impl";
-import { _clone, ToStringBuilder, UAVariable_toString } from "./base_node_private";
+import { _clone, ToStringBuilder, UAVariable_toString, valueRankToString } from "./base_node_private";
 import { EnumerationInfo, IEnumItem, UADataTypeImpl } from "./ua_data_type_impl";
 import { apply_condition_refresh, ConditionRefreshCache } from "./apply_condition_refresh";
 import {
@@ -101,6 +101,8 @@ const warningLog = make_warningLog(__filename);
 const doDebug = checkDebugFlag(__filename);
 const errorLog = make_errorLog(__filename);
 
+const plainChalk = new Proxy(chalk, { get: () => (s: string) => s }) as typeof chalk;
+
 export function adjust_accessLevel(accessLevel: string | number | null): AccessLevelFlag {
     accessLevel = isNullOrUndefined(accessLevel) ? "CurrentRead | CurrentWrite" : accessLevel;
     accessLevel = makeAccessLevelFlag(accessLevel);
@@ -239,7 +241,9 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             // this could happen in faulty external nodeset and has been seen once
             // in an nano server
             warningLog(super.typeDefinitionObj.toString());
-            return this.addressSpace.findVariableType("BaseVariableType")!;
+            const baseVariableType= this.addressSpace.findVariableType("BaseVariableType");
+            if (!baseVariableType) throw new Error("Cannot find BaseVariableType in address space");
+            return baseVariableType;
         }
         return super.typeDefinitionObj as UAVariableType;
     }
@@ -1522,6 +1526,79 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         return options.toString();
     }
 
+    public toJSON(): Record<string, unknown> {
+        let value: unknown;
+        let statusCode: string | undefined;
+        try {
+            const dv = this.$dataValue;
+            if (dv) {
+                statusCode = dv.statusCode?.toString();
+                if (dv.value && !(dv.value.value instanceof OpaqueStructure)) {
+                    value = dv.value.value;
+                }
+            }
+        } catch {
+            // ignore — value access may fail for bound variables
+        }
+        return {
+            ...super.toJSON(),
+            typeDefinition: this.typeDefinitionObj?.browseName.toString(),
+            dataType: this.dataType?.toString(),
+            valueRank: this.valueRank,
+            arrayDimensions: this.arrayDimensions,
+            accessLevel: AccessLevelFlag[this.accessLevel],
+            statusCode,
+            value
+        };
+    }
+
+    public [Symbol.for("nodejs.util.inspect.custom")](depth: number | null, inspectOptions: { colors?: boolean }): string {
+        const c = inspectOptions?.colors === false ? plainChalk : chalk;
+        const typeName = this.typeDefinitionObj?.browseName.toString() ?? "?";
+        const displayName = this.displayName.length ? this.displayName.map((d) => d.text).join(" | ") : "";
+        if (depth !== null && depth <= 0) {
+            return `${c.cyan("UAVariable<")}${c.green(this.browseName.toString())}${c.grey(` ${this.nodeId.toString()}`)}${c.cyan(">")}`;
+        }
+        const dt = this.dataType?.toString() ?? "?";
+        let valueStr = "";
+        let statusStr = "";
+        try {
+            const dv = this.$dataValue;
+            if (dv) {
+                if (dv.statusCode) statusStr = dv.statusCode.toString();
+                if (dv.value && dv.value.value !== undefined && dv.value.value !== null && !(dv.value.value instanceof OpaqueStructure)) {
+                    const v = dv.value.value;
+                    valueStr = typeof v === "object" ? Object.prototype.toString.call(v) : String(v);
+                    if (valueStr.length > 80) valueStr = `${valueStr.slice(0, 77)}...`;
+                }
+            }
+        } catch {
+            // ignore
+        }
+        const lines = [
+            `${c.cyan("UAVariable ")}${c.green(this.browseName.toString())}${c.grey(` ${this.nodeId.toString()}`)}`,
+            c.yellow("  typeDefinition : ") + typeName,
+            c.yellow("  displayName    : ") + displayName,
+            c.yellow("  dataType       : ") + dt,
+            c.yellow("  valueRank      : ") + valueRankToString(this.valueRank),
+            c.yellow("  accessLevel    : ") + AccessLevelFlag[this.accessLevel]
+        ];
+        if (this.arrayDimensions?.length) {
+            lines.push(c.yellow("  arrayDimensions: ") + JSON.stringify(this.arrayDimensions));
+        }
+        if (valueStr) {
+            lines.push(c.yellow("  value          : ") + valueStr);
+        }
+        if (statusStr && statusStr !== "Good (0x00000000)") {
+            lines.push(c.yellow("  statusCode     : ") + statusStr);
+        }
+        if (this.description?.text) {
+            lines.push(c.yellow("  description    : ") + this.description.text);
+        }
+        return lines.join("\n");
+    }
+
+
     // ---------------------------------------------------------------------------------------------------
     // History
     // ---------------------------------------------------------------------------------------------------