node-opcua-address-space 2.170.1 → 2.172.0

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

@@ -3,12 +3,11 @@ import { NodeClass } from "node-opcua-types";
 import { initialize_properties_and_components } from "../src/_instantiate_helpers";
 
 export function implementInterface(
-    uaNode: UAObject | UAObjectType | UAVariable | UAVariableType, 
+    uaNode: UAObject | UAObjectType | UAVariable | UAVariableType,
     interfaceType: UAObjectType,
     optionals?: string[],
     isModellingType?: boolean
 ) {
-
     optionals = optionals || [];
 
     const addressSpace = uaNode.addressSpace;
@@ -17,15 +16,19 @@ export function implementInterface(
         throw new Error("cannot find BaseInterfaceType");
     }
 
-    isModellingType = isModellingType === undefined ? uaNode.nodeClass === NodeClass.ObjectType || uaNode.nodeClass === NodeClass.VariableType : isModellingType;
+    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, 
+        uaNode as UAObject | UAVariable,
+        topMost,
+        interfaceType,
+        copyAlsoModellingRules,
+        copyAlsoAllOptionals,
         optionals
     );
     uaNode.addReference({

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 || {});
 }

package/src/_instantiate_helpers.ts

@@ -12,14 +12,14 @@ import {
     type UAObject,
     type UAObjectType,
     type UAVariable,
-    type UAVariableType,
+    type UAVariableType
 } from "node-opcua-address-space-base";
-import { checkDebugFlag, make_errorLog, make_warningLog} from "node-opcua-debug";
+import { BrowseDirection } from "node-opcua-data-model";
+import { checkDebugFlag, make_errorLog, make_warningLog } from "node-opcua-debug";
 import { resolveNodeId, sameNodeId } from "node-opcua-nodeid";
 import { makeOptionalsMap, type OptionalMap } from "../source/helpers/make_optionals_map";
 import { MandatoryChildOrRequestedOptionalFilter } from "./_mandatory_child_or_requested_optional_filter";
 import { _clone_hierarchical_references } from "./base_node_private";
-import { BrowseDirection } from "node-opcua-data-model";
 
 // const debugLog = make_debugLog("INSTANTIATE");
 // const doDebug = checkDebugFlag("INSTANTIATE");
@@ -86,7 +86,7 @@ function _initialize_properties_and_components<B extends UAObject | UAVariable |
             ),
             baseTypeDefinition ? baseTypeDefinition.browseName.toString() : "undefined"
         );
- 
+
     // c8 ignore next
     if (!baseTypeDefinition) {
         throw new Error(chalk.red("Cannot find object with nodeId ") + baseTypeDefinitionNodeId);
@@ -108,10 +108,14 @@ function _initialize_properties_and_components<B extends UAObject | UAVariable |
 export function initialize_properties_and_components<
     B extends UAObject | UAVariable | UAMethod,
     T extends UAVariableType | UAObjectType
->(instance: B, topMostType: T, nodeType: T,
+>(
+    instance: B,
+    topMostType: T,
+    nodeType: T,
     copyAlsoModellingRules: boolean,
     copyAlsoAllOptionals: boolean,
-    optionals?: string[]): void {
+    optionals?: string[]
+): void {
     const extraInfo = new CloneHelper();
 
     extraInfo.pushContext({
@@ -139,7 +143,15 @@ export function initialize_properties_and_components<
     );
 
     // instantiate optionals from interfaces
-    instantiate_interface_children<B>(nodeType, extraInfo, instance, copyAlsoModellingRules, copyAlsoAllOptionals, optionalsMap, browseNameMap);
+    instantiate_interface_children<B>(
+        nodeType,
+        extraInfo,
+        instance,
+        copyAlsoModellingRules,
+        copyAlsoAllOptionals,
+        optionalsMap,
+        browseNameMap
+    );
 
     reconstructFunctionalGroupType(extraInfo);
 
@@ -147,12 +159,12 @@ export function initialize_properties_and_components<
 }
 
 function instantiate_interface_children<B extends UAObject | UAVariable | UAMethod>(
-    nodeType: UAObjectType | UAVariableType, 
-    extraInfo: CloneHelper, 
-    instance: B, 
-    copyAlsoModellingRules: boolean, 
-    copyAlsoAllOptionals: boolean, 
-    optionalsMap: OptionalMap, 
+    nodeType: UAObjectType | UAVariableType,
+    extraInfo: CloneHelper,
+    instance: B,
+    copyAlsoModellingRules: boolean,
+    copyAlsoAllOptionals: boolean,
+    optionalsMap: OptionalMap,
     browseNameMap: Set<string>
 ) {
     const interfaces = nodeType.findReferencesEx(resolveNodeId("HasInterface"), BrowseDirection.Forward);
@@ -160,8 +172,7 @@ function instantiate_interface_children<B extends UAObject | UAVariable | UAMeth
         return;
     }
     for (const reference of interfaces) {
-        const interfaceType =
-            (reference.node as UAObjectType) || nodeType.addressSpace.findObjectType(reference.nodeId);
+        const interfaceType = (reference.node as UAObjectType) || nodeType.addressSpace.findObjectType(reference.nodeId);
         if (!interfaceType) {
             warningLog(" cannot find node ", reference.nodeId.toString());
             continue;
@@ -187,4 +198,3 @@ function instantiate_interface_children<B extends UAObject | UAVariable | UAMeth
         );
     }
 }
-

package/src/_mandatory_child_or_requested_optional_filter.ts

@@ -1,12 +1,18 @@
+import {
+    type BaseNode,
+    type CloneFilter,
+    fullPath2,
+    type UAMethod,
+    type UAObject,
+    type UAReference,
+    type UAVariable
+} from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
-import { BaseNode, UAMethod, UAObject, UAReference, UAVariable, CloneFilter, fullPath2 } from "node-opcua-address-space-base";
-import { checkDebugFlag, make_debugLog, make_warningLog, make_errorLog } from "node-opcua-debug";
 import { BrowseDirection } from "node-opcua-data-model";
-
-import { _clone_hierarchical_references } from "./base_node_private";
+import { checkDebugFlag, make_errorLog, make_warningLog } from "node-opcua-debug";
 
 // const debugLog = make_debugLog(__filename);
-const doDebug = checkDebugFlag(__filename);
+const _doDebug = checkDebugFlag(__filename);
 const warningLog = make_warningLog(__filename);
 const errorLog = make_errorLog(__filename);
 const doTrace = checkDebugFlag("INSTANTIATE");
@@ -14,17 +20,18 @@ const traceLog = errorLog;
 
 export type OptionalMap = Record<string, string | Record<string, any>>;
 export class MandatoryChildOrRequestedOptionalFilter implements CloneFilter {
-    private readonly instance: BaseNode;
     private readonly optionalsMap: OptionalMap;
     private readonly references: UAReference[];
     private readonly copyAlsoAllOptionals: boolean = false;
 
+    private readonly _instance: BaseNode;
+
     constructor(instance: BaseNode, copyAlsoAllOptionals: boolean, optionalsMap: OptionalMap) {
         this.copyAlsoAllOptionals = copyAlsoAllOptionals;
         // should we clone the node to be a component or propertyOf of a instance
         assert(null !== instance);
         this.optionalsMap = optionalsMap;
-        this.instance = instance;
+        this._instance = instance;
         this.references = instance.findReferencesEx("Aggregates", BrowseDirection.Forward);
     }
 
@@ -54,13 +61,7 @@ export class MandatoryChildOrRequestedOptionalFilter implements CloneFilter {
             case null:
             case undefined:
                 // c8 ignore next
-                doTrace &&
-                    traceLog(
-                        "node ",
-                        fullPath2(node),
-                        " has no modellingRule ",
-                        node ? fullPath2(node) : ""
-                    );
+                doTrace && traceLog("node ", fullPath2(node), " has no modellingRule ", node ? fullPath2(node) : "");
                 /**
                  * in some badly generated NodeSet2.xml file, the modellingRule is not specified
                  *
@@ -76,7 +77,7 @@ export class MandatoryChildOrRequestedOptionalFilter implements CloneFilter {
                 return true; // keep;
             case "Optional":
                 // only if in requested optionals
-                return this.copyAlsoAllOptionals || ((node.browseName?.name || "") in this.optionalsMap);
+                return this.copyAlsoAllOptionals || (node.browseName?.name || "") in this.optionalsMap;
             case "OptionalPlaceholder":
                 return false; // ignored
             default: