node-opcua-address-space 2.169.0 → 2.172.0

package/source/namespace_data_access.ts

@@ -1,25 +1,24 @@
-import {
+import type {
     AddVariableOptionsWithoutValue,
     AddYArrayItemOptions,
     BindVariableOptions,
     UADataType
 } from "node-opcua-address-space-base";
-import { NodeIdLike } from "node-opcua-nodeid";
-import { UAAnalogItem, UADataItem } from "node-opcua-nodeset-ua";
-import { EUInformation, EUInformationOptions } from "node-opcua-types";
-import { DataType, VariantArrayType } from "node-opcua-variant";
-
-import { UAMultiStateDiscreteEx } from "./interfaces/data_access/ua_multistate_discrete_ex";
-import { UAMultiStateValueDiscreteEx } from "./interfaces/data_access/ua_multistate_value_discrete_ex";
-import { UATwoStateDiscreteEx } from "./interfaces/data_access/ua_two_state_discrete_ex";
-import {
+import type { NodeIdLike } from "node-opcua-nodeid";
+import type { UAAnalogItem, UADataItem } from "node-opcua-nodeset-ua";
+import type { EUInformation, EUInformationOptions } from "node-opcua-types";
+import type { DataType, VariantArrayType } from "node-opcua-variant";
+import type {
     AddMultiStateDiscreteOptions,
     AddMultiStateValueDiscreteOptions,
     AddTwoStateDiscreteOptions,
     AddTwoStateVariableOptions
 } from "./address_space_ts";
-import { UATwoStateVariableEx } from "./ua_two_state_variable_ex";
-import { UAYArrayItemEx } from "./interfaces/data_access/ua_y_array_item_ex";
+import type { UAMultiStateDiscreteEx } from "./interfaces/data_access/ua_multistate_discrete_ex";
+import type { UAMultiStateValueDiscreteEx } from "./interfaces/data_access/ua_multistate_value_discrete_ex";
+import type { UATwoStateDiscreteEx } from "./interfaces/data_access/ua_two_state_discrete_ex";
+import type { UAYArrayItemEx } from "./interfaces/data_access/ua_y_array_item_ex";
+import type { UATwoStateVariableEx } from "./ua_two_state_variable_ex";
 
 export interface AddDataItemOptions extends AddVariableOptionsWithoutValue {
     arrayType?: VariantArrayType;
@@ -49,7 +48,7 @@ export interface AddAnalogDataItemOptions extends AddDataItemOptions {
     /**
      * the acceptValueOutOfRange property indicates whether the write operation will accept or reject a value which
      * is out of range of the instrumentRange.
-     * 
+     *
      * **if true**: during a writeOperation by a client if the dataValue that is outside of the instrumentRange
      * it will be recorded database and the statusCode will be set to BadOutOfRange, and
      * the write operation will return Good. If the variable supports historizing, the value will be recorded in the history database.

package/source/namespace_machine_state.ts

@@ -1,10 +1,15 @@
-import { UAObject, UAObjectType } from "node-opcua-address-space-base";
-import { UAState } from "node-opcua-nodeset-ua";
-import { QualifiedNameLike } from "node-opcua-data-model";
+import type { UAObject, UAObjectType } from "node-opcua-address-space-base";
+import type { QualifiedNameLike } from "node-opcua-data-model";
+import type { UAState } from "node-opcua-nodeset-ua";
 
-import { UATransitionEx } from "./interfaces/state_machine/ua_transition_ex";
+import type { UATransitionEx } from "./interfaces/state_machine/ua_transition_ex";
 export interface INamespaceMachineState {
-    addState(component: UAObject | UAObjectType, stateName: QualifiedNameLike, stateNumber: number, isInitialState?: boolean): UAState;
+    addState(
+        component: UAObject | UAObjectType,
+        stateName: QualifiedNameLike,
+        stateNumber: number,
+        isInitialState?: boolean
+    ): UAState;
     addTransition(
         component: UAObject | UAObjectType /* StateMachine | StateMachineType,*/,
         fromState: string,

package/source/pseudo_session.ts

@@ -1,29 +1,29 @@
 /**
  * @module node-opcua-address-space
  */
-import { promisify } from "util";
+
+import { promisify } from "node:util";
+import type { ContinuationPoint, IAddressSpace, ISessionContext, UAVariable } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
+import { randomGuid } from "node-opcua-basic-types";
+import { AttributeIds, NodeClass } from "node-opcua-data-model";
 import { DataValue } from "node-opcua-data-value";
 import { make_errorLog } from "node-opcua-debug";
-import { NodeId, resolveNodeId, NodeIdType } from "node-opcua-nodeid";
+import { NodeId, NodeIdType, resolveNodeId } from "node-opcua-nodeid";
 import {
-    ArgumentDefinition,
-    BrowseDescriptionLike,
-    CallMethodRequestLike,
+    type ArgumentDefinition,
+    type BrowseDescriptionLike,
+    type CallMethodRequestLike,
     getArgumentDefinitionHelper,
-    IBasicSession,
-    MethodId,
-    ResponseCallback
+    type IBasicSession,
+    type MethodId,
+    type ResponseCallback
 } from "node-opcua-pseudo-session";
 import { BrowseDescription, BrowseResult } from "node-opcua-service-browse";
-import { CallMethodRequest, CallMethodResult, CallMethodResultOptions } from "node-opcua-service-call";
-import { BrowsePath, BrowsePathResult } from "node-opcua-service-translate-browse-path";
-import { StatusCodes, StatusCode } from "node-opcua-status-code";
-import { NodeClass, AttributeIds } from "node-opcua-data-model";
-import { WriteValueOptions, ReadValueIdOptions, BrowseDescriptionOptions } from "node-opcua-types";
-import { randomGuid } from "node-opcua-basic-types";
-
-import { IAddressSpace, UAVariable, ISessionContext, ContinuationPoint } from "node-opcua-address-space-base";
+import { CallMethodRequest, CallMethodResult } from "node-opcua-service-call";
+import type { BrowsePath, BrowsePathResult } from "node-opcua-service-translate-browse-path";
+import { type StatusCode, StatusCodes } from "node-opcua-status-code";
+import type { BrowseDescriptionOptions, ReadValueIdOptions, WriteValueOptions } from "node-opcua-types";
 
 import { ContinuationPointManager } from "./continuation_points/continuation_point_manager";
 import { callMethodHelper } from "./helpers/call_helpers";
@@ -57,10 +57,10 @@ export function innerBrowse(
 ): void {
     engine.browseAll(nodesToBrowse, (err, results) => {
         if (err || !results) {
-            return callback!(err);
+            return callback?.(err);
         }
         // handle continuation points
-        results = results.map((result: BrowseResult, index) => {
+        results = results.map((result: BrowseResult, _index) => {
             assert(!result.continuationPoint);
             // c8 ignore next
             if (!engine.continuationPointManager) {
@@ -86,7 +86,7 @@ export function innerBrowse(
                 references: values
             });
         });
-        callback!(null, results);
+        callback?.(null, results);
     });
 }
 
@@ -100,7 +100,7 @@ export function innerBrowseNext(
     callback?: ResponseCallback<BrowseResult[]>
 ): void {
     const results = continuationPoints
-        .map((continuationPoint: ContinuationPoint, index: number) => {
+        .map((continuationPoint: ContinuationPoint, _index: number) => {
             return engine.continuationPointManager.getNextReferences(0, {
                 continuationPoint,
                 releaseContinuationPoints
@@ -114,7 +114,7 @@ export function innerBrowseNext(
                     references: r.values
                 })
         );
-    callback!(null, results);
+    callback?.(null, results);
 }
 
 const $addressSpace = Symbol("addressSpace");
@@ -154,7 +154,7 @@ export class PseudoSession implements IBasicSession {
         const isArray = Array.isArray(nodesToBrowse);
         if (!isArray) {
             return this.browse([nodesToBrowse as BrowseDescriptionLike], (err, results) => {
-                return callback!(err, results ? results[0] : undefined);
+                return callback?.(err, results ? results[0] : undefined);
             });
         }
         const browseAll = (nodesToBrowse: BrowseDescriptionOptions[], callack: ResponseCallback<BrowseResult[]>) => {
@@ -166,7 +166,7 @@ export class PseudoSession implements IBasicSession {
                 const r = this[$addressSpace].browseSingleNode(nodeId, _browseDescription, this[$context]);
                 results.push(r);
             }
-            callack!(null, results);
+            callack?.(null, results);
         };
 
         setImmediate(() => {
@@ -202,8 +202,8 @@ export class PseudoSession implements IBasicSession {
                 return new DataValue({ statusCode: StatusCodes.BadNodeIdUnknown });
             }
             // refresh the variable value if the attribute to read is the Value attribute
-            if (obj.nodeClass === NodeClass.Variable && nodeToRead.attributeId == AttributeIds.Value) {
-               return await (obj as UAVariable).readValueAsync(context);
+            if (obj.nodeClass === NodeClass.Variable && nodeToRead.attributeId === AttributeIds.Value) {
+                return await (obj as UAVariable).readValueAsync(context);
             }
             assert(!!nodeToRead.nodeId, "expecting a nodeId");
             assert(!!nodeToRead.attributeId, "expecting a attributeId");
@@ -214,8 +214,8 @@ export class PseudoSession implements IBasicSession {
             return dataValue;
         };
         Promise.all(_nodesToRead.map(async (nodeToRead: ReadValueIdOptions) => await readV(nodeToRead)))
-            .then((dataValues) => callback!(null, isArray ? dataValues : dataValues[0]))
-            .catch((err) => callback!(err));
+            .then((dataValues) => callback?.(null, isArray ? dataValues : dataValues[0]))
+            .catch((err) => callback?.(err));
     }
 
     public browseNext(
@@ -242,9 +242,9 @@ export class PseudoSession implements IBasicSession {
             if (continuationPoints instanceof Buffer) {
                 return this.browseNext([continuationPoints], releaseContinuationPoints, (err, _results) => {
                     if (err) {
-                        return callback!(err);
+                        return callback?.(err);
                     }
-                    callback!(null, _results![0]);
+                    callback?.(null, _results?.[0]);
                 });
             }
             innerBrowseNext(
@@ -266,23 +266,25 @@ export class PseudoSession implements IBasicSession {
         if (!isArray) {
             methodsToCall = [methodsToCall as CallMethodRequestLike];
         }
-        Promise.all((methodsToCall as CallMethodRequestLike[]).map(async (methodToCall) => {
-            const callMethodRequest = new CallMethodRequest(methodToCall);
-            try {
-                const result = await callMethodHelper(this[$context], this[$addressSpace], callMethodRequest);
-                return new CallMethodResult(result);
-            } catch (err) {
-                errorLog("Internal Error = ", err);
-                return new CallMethodResult({
-                    statusCode: StatusCodes.BadInternalError
-                });
-            }
-        }))
+        Promise.all(
+            (methodsToCall as CallMethodRequestLike[]).map(async (methodToCall) => {
+                const callMethodRequest = new CallMethodRequest(methodToCall);
+                try {
+                    const result = await callMethodHelper(this[$context], this[$addressSpace], callMethodRequest);
+                    return new CallMethodResult(result);
+                } catch (err) {
+                    errorLog("Internal Error = ", err);
+                    return new CallMethodResult({
+                        statusCode: StatusCodes.BadInternalError
+                    });
+                }
+            })
+        )
             .then((callMethodResults) => {
-                callback!(null, isArray ? callMethodResults : callMethodResults[0]);
+                callback?.(null, isArray ? callMethodResults : callMethodResults[0]);
             })
             .catch((err) => {
-                callback!(err);
+                callback?.(err);
             });
     }
 
@@ -291,10 +293,10 @@ export class PseudoSession implements IBasicSession {
     public getArgumentDefinition(methodId: MethodId, callback?: ResponseCallback<ArgumentDefinition>): any {
         getArgumentDefinitionHelper(this, methodId)
             .then((result) => {
-                callback!(null, result);
+                callback?.(null, result);
             })
             .catch((err: Error) => {
-                callback!(err);
+                callback?.(err);
             });
     }
 
@@ -310,14 +312,14 @@ export class PseudoSession implements IBasicSession {
         const browsePathResults = (browsePaths as BrowsePath[]).map((browsePath: BrowsePath) => {
             return this[$addressSpace].browsePath(browsePath);
         });
-        callback!(null, isArray ? browsePathResults : browsePathResults[0]);
+        callback?.(null, isArray ? browsePathResults : browsePathResults[0]);
     }
     public write(nodeToWrite: WriteValueOptions, callback: ResponseCallback<StatusCode>): void;
     public write(nodesToWrite: WriteValueOptions[], callback: ResponseCallback<StatusCode[]>): void;
     public write(nodeToWrite: WriteValueOptions): Promise<StatusCode>;
     public write(nodesToWrite: WriteValueOptions[]): Promise<StatusCode[]>;
     public write(nodesToWrite: WriteValueOptions[] | WriteValueOptions, callback?: ResponseCallback<any>): any {
-        const isArray = nodesToWrite instanceof Array;
+        const isArray = Array.isArray(nodesToWrite);
         const _nodesToWrite: WriteValueOptions[] = !isArray ? [nodesToWrite] : nodesToWrite;
         const context = this[$context];
         setImmediate(() => {
@@ -332,16 +334,16 @@ export class PseudoSession implements IBasicSession {
                 }
                 try {
                     return promisify(obj.writeAttribute).call(obj, context, nodeToWrite);
-                } catch (err) {
+                } catch (_err) {
                     return StatusCodes.BadInternalError;
                 }
             });
             Promise.all(statusCodesPromises)
                 .then((statusCodes) => {
-                    callback!(null, isArray ? statusCodes : statusCodes[0]);
+                    callback?.(null, isArray ? statusCodes : statusCodes[0]);
                 })
                 .catch((err) => {
-                    callback!(err);
+                    callback?.(err);
                 });
         });
     }
@@ -350,6 +352,7 @@ export class PseudoSession implements IBasicSession {
 // tslint:disable:no-var-requires
 // tslint:disable:max-line-length
 import { withCallback } from "thenify-ex";
+
 PseudoSession.prototype.read = withCallback(PseudoSession.prototype.read);
 PseudoSession.prototype.write = withCallback(PseudoSession.prototype.write);
 PseudoSession.prototype.browse = withCallback(PseudoSession.prototype.browse);

package/source/session_context.ts

@@ -315,7 +315,7 @@ export class SessionContext implements ISessionContext {
         if (username === "anonymous") {
             return anonymous;
         }
-        if (!this.server || !this.server.userManager) {
+        if (!this.server?.userManager) {
             return anonymous;
         }
 

package/source/set_namespace_meta_data.ts

@@ -1,5 +1,5 @@
-import { INamespace, UAObject, UAVariable } from "node-opcua-address-space-base";
-import { UANamespaceMetadata } from "node-opcua-nodeset-ua";
+import type { INamespace, UAObject, UAVariable } from "node-opcua-address-space-base";
+import type { UANamespaceMetadata } from "node-opcua-nodeset-ua";
 import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
 
 function specialEncode(namespaceUri: string): string {
@@ -27,7 +27,7 @@ export function setNamespaceMetaData(namespace: INamespace): void {
 
     /* c8 ignore next */
     if (existingMetaData) {
-        throw new Error("INamespace meta data already exists for " + deriveName);
+        throw new Error(`INamespace meta data already exists for ${deriveName}`);
     }
     const metaData = namespaceMetadataType.instantiate({
         browseName: deriveName,

package/source/ua_addin.ts

@@ -1,7 +1,7 @@
-import { INamespace, ModellingRuleType, UAObject, UAObjectType, UAVariableT } from "node-opcua-address-space-base";
+import type { INamespace, ModellingRuleType, UAObject, UAObjectType, UAVariableT } from "node-opcua-address-space-base";
 import { DataType } from "node-opcua-basic-types";
-import { coerceQualifiedName, QualifiedName, QualifiedNameLike } from "node-opcua-data-model";
-import { NodeIdLike } from "node-opcua-nodeid";
+import { coerceQualifiedName, type QualifiedName, type QualifiedNameLike } from "node-opcua-data-model";
+import type { NodeIdLike } from "node-opcua-nodeid";
 
 export interface InstantiateAddInOptions {
     defaultName?: QualifiedNameLike;
@@ -14,15 +14,14 @@ export interface InstantiateAddInOptions {
 }
 
 export function instantiateAddIn(objectType: UAObjectType, options: InstantiateAddInOptions): UAObject {
-
-    let defaultName = options.defaultName;
+    const defaultName = options.defaultName;
     // check that objectType has he shape of an addInd
     const defaultInstanceBrowseName = objectType.getPropertyByName("DefaultInstanceBrowseName");
     if (!defaultInstanceBrowseName) {
         throw new Error("objectType must have a DefaultInstanceBrowseName property");
     }
 
-    const browseName = coerceQualifiedName(defaultName || defaultInstanceBrowseName.readValue().value.value as QualifiedName);
+    const browseName = coerceQualifiedName(defaultName || (defaultInstanceBrowseName.readValue().value.value as QualifiedName));
     const addIn = objectType.instantiate({
         namespace: options.namespace || objectType.namespace,
         browseName: browseName,
@@ -34,9 +33,10 @@ export function instantiateAddIn(objectType: UAObjectType, options: InstantiateA
     return addIn;
 }
 
-export function addDefaultInstanceBrowseName(objectType: UAObjectType, defaultBrowseName: QualifiedName | string)
-    : UAVariableT<QualifiedName, DataType.QualifiedName> {
-
+export function addDefaultInstanceBrowseName(
+    objectType: UAObjectType,
+    defaultBrowseName: QualifiedName | string
+): UAVariableT<QualifiedName, DataType.QualifiedName> {
     const namespace1 = objectType.namespace;
     if (typeof defaultBrowseName === "string") {
         defaultBrowseName = coerceQualifiedName({ name: defaultBrowseName, namespaceIndex: namespace1.index });
@@ -54,5 +54,4 @@ export function addDefaultInstanceBrowseName(objectType: UAObjectType, defaultBr
         modellingRule: null // DefaultInstanceBrowseName must have no ModellingRule
     });
     return uaVaraible as UAVariableT<QualifiedName, DataType.QualifiedName>;
-
-}
+}

package/source/ua_interface.ts

@@ -1,49 +1,38 @@
-
-
-import { UAObject, UAObjectType, UAVariable, UAVariableType } from "node-opcua-address-space-base";
-import { BrowseDirection } from "node-opcua-data-model";
+import type { UAObject, UAObjectType, UAVariable, UAVariableType } from "node-opcua-address-space-base";
+import { NodeClass } from "node-opcua-types";
 import { initialize_properties_and_components } from "../src/_instantiate_helpers";
 
-export function implementInterfaceBad(uaNode: UAObject | UAObjectType | UAVariable | UAVariableType, interfaceType: UAObjectType) {
+export function implementInterface(
+    uaNode: UAObject | UAObjectType | UAVariable | UAVariableType,
+    interfaceType: UAObjectType,
+    optionals?: string[],
+    isModellingType?: boolean
+) {
+    optionals = optionals || [];
 
     const addressSpace = uaNode.addressSpace;
-    const tmp = interfaceType.instantiate({
-        browseName: uaNode.browseName,
-        copyAlsoModellingRules: true,
-        copyAlsoAllOptionals: true,
-        modellingRule: "Mandatory"
-    });
-    // 
-    uaNode.addReference({
-        nodeId: interfaceType,
-        referenceType: "HasInterface"
-    });
-    const childrenRef = tmp.findReferencesEx("HasChild", BrowseDirection.Forward);
-    // transfer children to uaNode
-    for (const childRef of childrenRef) {
-
-        tmp.removeReference({
-            nodeId: childRef.nodeId,
-            referenceType: childRef.referenceType,
-            isForward: childRef.isForward
-        });
-        uaNode.addReference({
-            nodeId: childRef.nodeId,
-            referenceType: childRef.referenceType,
-            isForward: childRef.isForward
-        });
+    const topMost = addressSpace.findObjectType("BaseInterfaceType");
+    if (!topMost) {
+        throw new Error("cannot find BaseInterfaceType");
     }
-    addressSpace.deleteNode(tmp);
-}
 
-export function implementInterface(uaNode: UAObject | UAObjectType | UAVariable | UAVariableType, interfaceType: UAObjectType) {
-
-    const addressSpace = uaNode.addressSpace;
-    const topMost = addressSpace.findObjectType("BaseInterfaceType")!;
-    initialize_properties_and_components(uaNode as any, topMost, interfaceType, true, true, []);
+    isModellingType =
+        isModellingType === undefined
+            ? uaNode.nodeClass === NodeClass.ObjectType || uaNode.nodeClass === NodeClass.VariableType
+            : isModellingType;
+
+    const copyAlsoModellingRules = isModellingType;
+    const copyAlsoAllOptionals = isModellingType;
+    initialize_properties_and_components(
+        uaNode as UAObject | UAVariable,
+        topMost,
+        interfaceType,
+        copyAlsoModellingRules,
+        copyAlsoAllOptionals,
+        optionals
+    );
     uaNode.addReference({
         nodeId: interfaceType,
         referenceType: "HasInterface"
     });
-
 }

package/source/ua_root_folder.ts

@@ -1,4 +1,4 @@
-import { UAFolder, UAServer } from "node-opcua-nodeset-ua";
+import type { UAFolder, UAServer } from "node-opcua-nodeset-ua";
 export interface UAObjectsFolder extends UAFolder {
     server: UAServer;
 }

package/source/ua_two_state_variable_ex.ts

@@ -1,11 +1,11 @@
 /**
  * @module node-opcua-address-space
  */
-import { UAVariableT } from "node-opcua-address-space-base";
-import { LocalizedText } from "node-opcua-data-model";
-import { UAStateVariable, UATwoStateVariable_Base } from "node-opcua-nodeset-ua";
-import { DataType } from "node-opcua-variant";
-import { ISetStateOptions } from "./interfaces/i_set_state_options";
+import type { UAVariableT } from "node-opcua-address-space-base";
+import type { LocalizedText } from "node-opcua-data-model";
+import type { UAStateVariable, UATwoStateVariable_Base } from "node-opcua-nodeset-ua";
+import type { DataType } from "node-opcua-variant";
+import type { ISetStateOptions } from "./interfaces/i_set_state_options";
 
 /**
  * @see https://reference.opcfoundation.org/v104/Core/docs/Part9/5.2/

package/source_nodejs/generate_address_space.ts

@@ -1,19 +1,16 @@
 import fs from "node:fs";
-
+import type { IAddressSpace } from "node-opcua-address-space-base";
 import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
-import { IAddressSpace } from "node-opcua-address-space-base";
-
-import { generateAddressSpaceRaw } from "..";
-import { NodeSetLoaderOptions } from "..";
+import { generateAddressSpaceRaw, type NodeSetLoaderOptions } from "..";
 
-const doDebug = checkDebugFlag(__filename);
+const _doDebug = checkDebugFlag(__filename);
 const debugLog = make_debugLog(__filename);
 const errorLog = make_errorLog(__filename);
 
 export async function readNodeSet2XmlFile(xmlFile: string): Promise<string> {
     // c8 ignore next
     if (!fs.existsSync(xmlFile)) {
-        const msg = "[NODE-OPCUA-E02] generateAddressSpace : cannot find nodeset2 xml file at " + xmlFile;
+        const msg = `[NODE-OPCUA-E02] generateAddressSpace : cannot find nodeset2 xml file at ${xmlFile}`;
         errorLog(msg);
         throw new Error(msg);
     }
@@ -26,7 +23,6 @@ export async function generateAddressSpace(
     addressSpace: IAddressSpace,
     xmlFiles: string | string[],
     options?: NodeSetLoaderOptions
-): Promise<void>
-{
+): Promise<void> {
     await generateAddressSpaceRaw(addressSpace, xmlFiles, readNodeSet2XmlFile, options || {});
 }