node-opcua-address-space 2.116.0 → 2.118.0

package/src/nodeset_tools/construct_namespace_dependency.ts

@@ -1,4 +1,4 @@
-import { INamespace, UADataType, UAVariable, UAVariableType } from "node-opcua-address-space-base";
+import { IAddressSpace, INamespace, UADataType, UAVariable, UAVariableType } from "node-opcua-address-space-base";
 import { NodeClass } from "node-opcua-data-model";
 import { StructureField } from "node-opcua-types";
 import { DataType } from "node-opcua-basic-types";
@@ -9,42 +9,46 @@ import { make_debugLog, make_warningLog } from "node-opcua-debug";
 import { NamespacePrivate } from "../namespace_private";
 import { BaseNodeImpl, getReferenceType } from "../base_node_impl";
 import { UAVariableImpl } from "../ua_variable_impl";
+import { ITranslationTable } from "../../source/xml_writer";
 
 const warningLog = make_warningLog(__filename);
 const debugLog = make_debugLog(__filename);
 
-function _constructNamespaceDependency(
+// eslint-disable-next-line max-statements, complexity
+export function _recomputeRequiredModelsFromTypes(
     namespace: INamespace,
-    dependency: INamespace[],
-    depMap: Set<number>,
-    _visitedDataType: Set<string>,
-    priorityTable: number[]
-): void {
-    const addressSpace = namespace.addressSpace;
-    const namespace_ = namespace as NamespacePrivate;
-    // navigate all namespace recursively to
-
-    function consider(namespaceIndex: number) {
-        if (hasHigherPriorityThan(namespaceIndex, namespace.index, priorityTable)) {
-            return;
-        }
-        considerStrongly(namespaceIndex);
+    cache?: Map<number, { requiredNamespaceIndexes: number[]; nbTypes: number }>
+): { requiredNamespaceIndexes: number[]; nbTypes: number } {
+    if (namespace.index === 0) {
+        return { requiredNamespaceIndexes: [], nbTypes: 1 };
     }
-    function considerStrongly(namespaceIndex: number) {
-        if (!depMap.has(namespaceIndex)) {
-            depMap.add(namespaceIndex);
-            const namespace = addressSpace.getNamespace(namespaceIndex);
-            dependency.push(namespace);
-            if (namespaceIndex > 0) {
-                _constructNamespaceDependency(namespace, dependency, depMap, _visitedDataType, priorityTable);
-            }
+    if (cache) {
+        if (cache.has(namespace.index)) {
+            return cache.get(namespace.index)!;
         }
     }
+    const requiredNamespaceIndexes = [0];
+    const requiredModelsSet = new Set<number>();
+    requiredModelsSet.add(0);
+    const namespace_ = namespace as NamespacePrivate;
+    let nbTypes = 0;
+    const addressSpace = namespace.addressSpace;
+    const types = [NodeClass.VariableType, NodeClass.ObjectType, NodeClass.ReferenceType, NodeClass.DataType];
+    const instances = [NodeClass.Variable, NodeClass.Object, NodeClass.Method];
+
+    const consider = (requiredModel: number) => {
+        if (requiredModel !== namespace.index && !requiredModelsSet.has(requiredModel)) {
+            requiredModelsSet.add(requiredModel);
+            requiredNamespaceIndexes.push(requiredModel);
+        }
+    };
+
+    const _visitedDataType: Set<string> = new Set<string>();
 
     function exploreDataTypeField(field: StructureField) {
         const dataType = field.dataType;
         const namespaceIndex = dataType.namespace;
-        considerStrongly(namespaceIndex);
+        consider(namespaceIndex);
         const dataTypeNode = addressSpace.findDataType(field.dataType);
         if (dataTypeNode) {
             exploreDataTypes(dataTypeNode);
@@ -65,7 +69,7 @@ function _constructNamespaceDependency(
         }
 
         const namespaceIndex = dataType.namespace;
-        considerStrongly(namespaceIndex);
+        consider(namespaceIndex);
         if (dataTypeNode.isStructure()) {
             const definition = dataTypeNode.getStructureDefinition();
             for (const field of definition.fields || []) {
@@ -78,7 +82,7 @@ function _constructNamespaceDependency(
     function exploreExtensionObject(e: ExtensionObject) {
         assert(!(e instanceof Variant));
         const nodeId = e.schema.encodingDefaultXml || e.schema.dataTypeNodeId || e.schema.dataTypeNodeId;
-        considerStrongly(nodeId.namespace);
+        consider(nodeId.namespace);
         // istanbul ignore next
         if (e.schema.dataTypeNodeId.isEmpty()) {
             warningLog("Cannot find dataTypeNodeId for ", e.schema.name);
@@ -88,6 +92,7 @@ function _constructNamespaceDependency(
         if (!d) return;
         exploreDataTypes(d);
     }
+
     function exploreDataValue(uaVariable: UAVariableImpl) {
         if (uaVariable.getBasicDataType() !== DataType.ExtensionObject) {
             return;
@@ -104,36 +109,131 @@ function _constructNamespaceDependency(
         }
     }
     for (const node of namespace_.nodeIterator()) {
-        if (node.nodeClass === NodeClass.Variable || node.nodeClass === NodeClass.VariableType) {
-            const dataTypeNodeId = (node as UAVariable | UAVariableType).dataType;
-            const dataTypeNode = addressSpace.findDataType(dataTypeNodeId)!;
-            if (dataTypeNode) {
-                exploreDataTypes(dataTypeNode);
-            } else {
-                // istanbul ignore next
-                if (dataTypeNodeId.value != 0) {
-                    warningLog("Warning: Cannot find dataType", dataTypeNodeId.toString());
+        const isType = types.indexOf(node.nodeClass);
+        const isInstance = instances.indexOf(node.nodeClass);
+        if (isType !== -1) {
+            nbTypes++;
+            const superTypes = node.findReferencesAsObject("HasSubtype", false);
+            if (superTypes.length === 0) {
+                continue;
+            }
+            if (superTypes.length !== 1) {
+                continue;
+            }
+            const superType = superTypes[0];
+            if (superType.nodeId.namespace === 0) {
+                continue;
+            }
+            const requiredModel = superType.nodeId.namespace;
+            consider(requiredModel);
+        } 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)!;
+                if (dataTypeNode) {
+                    consider(dataTypeNode.nodeId.namespace);
+                } else {
+                    // istanbul ignore next
+                    if (dataTypeNodeId.value != 0) {
+                        warningLog("Warning: Cannot find dataType", dataTypeNodeId.toString());
+                    }
                 }
+                const nodeV = node as UAVariableImpl;
+                exploreDataValue(nodeV);
             }
-            const nodeV = node as UAVariableImpl;
-            exploreDataValue(nodeV);
+
+            const typeDefinitions = node.findReferencesAsObject("HasTypeDefinition", true);
+            if (typeDefinitions.length === 0) {
+                continue;
+            }
+            if (typeDefinitions.length !== 1) {
+                continue;
+            }
+            const typeDefinition = typeDefinitions[0];
+            const requiredModel = typeDefinition.nodeId.namespace;
+            consider(requiredModel);
         }
-        // visit all references
-        const references = (<BaseNodeImpl>node).ownReferences();
-        for (const reference of references) {
-            // check referenceId
-            const namespaceIndex = getReferenceType(reference)!.nodeId.namespace;
-            consider(namespaceIndex);
-            const namespaceIndex2 = reference.nodeId.namespace;
-            consider(namespaceIndex2);
+    }
+
+    const result = { requiredNamespaceIndexes: requiredNamespaceIndexes, nbTypes: nbTypes };
+    if (cache) {
+        cache.set(namespace.index, result);
+    }
+    return result;
+}
+
+export function _recomputeRequiredModelsFromTypes2(
+    namespace: INamespace,
+    cache?: Map<number, { requiredNamespaceIndexes: number[]; nbTypes: number }>
+): { requiredNamespaceIndexes: number[] } {
+    const addressSpace = namespace.addressSpace;
+
+    const { requiredNamespaceIndexes } = _recomputeRequiredModelsFromTypes(namespace, cache);
+
+    const set = new Set<number>(requiredNamespaceIndexes);
+    const pass2: number[] = [];
+    for (const r of requiredNamespaceIndexes) {
+        if (r === 0) {
+            pass2.push(0);
+            continue;
+        }
+        const namespaces = _recomputeRequiredModelsFromTypes(addressSpace.getNamespace(r), cache);
+        for (const nIndex of namespaces.requiredNamespaceIndexes) {
+            if (!set.has(nIndex)) {
+                set.add(nIndex);
+                pass2.push(nIndex);
+            }
         }
+        pass2.push(r);
     }
+
+    return { requiredNamespaceIndexes: pass2 };
 }
 
-export function hasHigherPriorityThan(namespaceIndex1: number, namespaceIndex2: number, priorityTable: number[]) {
-    const order1 = priorityTable[namespaceIndex1];
-    const order2 = priorityTable[namespaceIndex2];
-    return order1 > order2;
+export function _getCompleteRequiredModelsFromValuesAndReferences(
+    namespace: INamespace,
+    priorityList: number[],
+    cache?: Map<number, { requiredNamespaceIndexes: number[]; nbTypes: number }>
+): number[] {
+
+    const namespace_ = namespace as NamespacePrivate;
+
+    const thisPriority = priorityList[namespace.index];
+
+    const requiredNamespaceIndexes = _recomputeRequiredModelsFromTypes2(namespace, cache).requiredNamespaceIndexes;
+    const requiredModelsSet: Set<number> = new Set<number>([... requiredNamespaceIndexes]);
+
+    const consider = (requiredModel: number) => {
+        if (requiredModel !== namespace.index && !requiredModelsSet.has(requiredModel)) {
+            requiredModelsSet.add(requiredModel);
+            requiredNamespaceIndexes.push(requiredModel);
+        }
+    }
+
+    //const maxIndex = Math.max(...requiredNamespaceIndexes);
+    for (const node of namespace_.nodeIterator()) {
+        const references = (<BaseNodeImpl>node).allReferences();
+        for (const reference of references) {
+            // if (reference.isForward) continue;
+            // only look at backward reference
+            // check referenceId
+            const namespaceIndexOfReferenceType = getReferenceType(reference)!.nodeId.namespace;
+            if (namespaceIndexOfReferenceType !== 0 && namespaceIndexOfReferenceType !== namespace.index) {
+                const refPriority = priorityList[namespaceIndexOfReferenceType];
+                if (refPriority <= thisPriority) {
+                    consider(namespaceIndexOfReferenceType);
+                }
+            }
+            const namespaceIndexOfTargetNode = reference.nodeId.namespace;
+            if (namespaceIndexOfTargetNode !== 0 && namespaceIndexOfTargetNode !== namespace.index) {
+                const refPriority = priorityList[namespaceIndexOfTargetNode];
+                if (refPriority <= thisPriority) {
+                    consider(namespaceIndexOfTargetNode);
+                }
+            }
+        }
+    }
+    return requiredNamespaceIndexes;
 }
 
 /**
@@ -150,58 +250,99 @@ export function hasHigherPriorityThan(namespaceIndex1: number, namespaceIndex2:
  *                           ---
  *  ua, own , di , kitchen , own2,  adi  => 0 , 2,  3,  5, 1
  */
-export function constructNamespacePriorityTable(namespace: INamespace): number[] {
-    // Namespace 0 will always be 0
-    // Namespaces with no requiredModel will be considered as instance namespaces and will added at the end
-    // in the same order as they appear,
-    // Namespace with requiredModels are considered to be companion specification, so already loaded in the correct order
-
-    const addressSpace = namespace.addressSpace;
+export function constructNamespacePriorityTable(addressSpace: IAddressSpace): { loadingOrder: number[]; priorityTable: number[] } {
+    // - Namespace 0 will always be 0
+    // - Namespace with requiredModels are considered to be companion specification,
+    //   so RequireModel will be used to determine the order
+    // - Namespaces with no requiredModel are more complicated:
+    //
+    //   we study ObjectType,ReferenceType, DataType and VariableType
+    //   to find strong dependencies between namespace.
+    //
+    //   if the namespace doesn't define ObjectType,ReferenceType, DataType and VariableType
+    //   it will be considered as instance namespaces and will added at the end
+    //   in the same order as they appear,
     const namespaces = addressSpace.getNamespaceArray();
 
-    const namespaceWithReq = namespaces.filter((n) => n.getRequiredModels() !== undefined && n.index !== 0);
-    const namespaceWithoutReq = namespaces.filter((n) => n.getRequiredModels() === undefined && n.index !== 0);
+    const loadingOrder: number[] = [0];
 
-    const priorityList: number[] = [0];
-    let counter = 1;
-    for (let i = 0; i < namespaceWithReq.length; i++) {
-        priorityList[namespaceWithReq[i].index] = counter++;
-    }
-    for (let i = 0; i < namespaceWithoutReq.length; i++) {
-        priorityList[namespaceWithoutReq[i].index] = counter++;
+    const map = new Map<number, { nbTypes: number; requiredNamespaceIndexes: number[]; namespace: INamespace }>();
+    for (let i = 0; i < namespaces.length; i++) {
+        const { nbTypes, requiredNamespaceIndexes } = _recomputeRequiredModelsFromTypes(namespaces[i], map);
+        map.set(namespaces[i].index, { nbTypes, requiredNamespaceIndexes, namespace: namespaces[i] });
     }
-    return priorityList;
-}
-const doDebug = false;
-export function constructNamespaceDependency(namespace: INamespace, priorityTable?: number[]): INamespace[] {
-    const addressSpace = namespace.addressSpace;
 
-    priorityTable = priorityTable || constructNamespacePriorityTable(namespace);
+    const visited = new Set<number>();
+    visited.add(0);
 
-    const dependency: INamespace[] = [];
-    const depMap = new Set<number>();
+    const h = (n: INamespace) => {
+        if (visited.has(n.index)) {
+            return;
+        }
+        visited.add(n.index);
+        const data = map.get(n.index);
+        if (!data) return;
+        const { requiredNamespaceIndexes } = data;
+        for (const r of requiredNamespaceIndexes || []) {
+            h(namespaces[r]);
+        }
+        loadingOrder.push(n.index);
+    };
 
-    dependency.push(addressSpace.getDefaultNamespace());
-    depMap.add(0);
+    for (let i = 0; i < namespaces.length; i++) {
+        const { nbTypes } = map.get(i)!;
+        if (nbTypes) {
+            h(namespaces[i]);
+        }
+    }
+    for (let i = 0; i < namespaces.length; i++) {
+        const { nbTypes } = map.get(i)!;
+        if (!nbTypes) {
+            h(namespaces[i]);
+        }
+    }
 
-    if (namespace !== addressSpace.getDefaultNamespace()) {
-        dependency.push(namespace);
-        depMap.add(namespace.index);
+    const priorityTable: number[] = [];
+    for (let i = 0; i < loadingOrder.length; i++) {
+        const namespaceIndex = loadingOrder[i];
+        assert(namespaceIndex !== -1);
+        priorityTable[namespaceIndex] = i;
     }
-    const _visitedDataType = new Set<string>();
 
-    _constructNamespaceDependency(namespace, dependency, depMap, _visitedDataType, priorityTable);
+    return { loadingOrder, priorityTable };
+}
 
-    // istanbul ignore next
-    doDebug && debugLog("namespace : ", namespace.index, namespace.namespaceUri);
-    // istanbul ignore next
-    doDebug && debugLog("   ", dependency.map((d) => d.index + " " + d.namespaceUri).join("\n   "));
+const doDebug = true;
+export function constructNamespaceDependency(namespace: INamespace, priorityTable?: number[]): INamespace[] {
+    const addressSpace = namespace.addressSpace;
+    priorityTable = priorityTable || constructNamespacePriorityTable(addressSpace).priorityTable;
+    const requiredNamespaceIndexes = _getCompleteRequiredModelsFromValuesAndReferences(namespace, priorityTable);
+    return [...requiredNamespaceIndexes.map((r) => addressSpace.getNamespace(r)), namespace];
+}
 
-    const sorted = dependency.sort((a, b) => (priorityTable![a.index] < priorityTable![b.index] ? -1 : 1));
-    // istanbul ignore next
-    doDebug && debugLog("sorted:");
-    // istanbul ignore next
-    doDebug && debugLog("   ", sorted.map((d) => d.index + " " + d.namespaceUri).join("\n   "));
+/**
+ * @private
+ */
+export function _constructNamespaceTranslationTable(dependency: INamespace[], exportedNamespace: INamespace): ITranslationTable {
+    if (!dependency || dependency.length === 0) {
+        return { 0: 0 };
+        // throw new Error("Cannot constructNamespaceTranslationTable on empty dependency");
+    }
+    const translationTable: ITranslationTable = {};
+    assert(dependency[0].namespaceUri === "http://opcfoundation.org/UA/");
 
-    return sorted;
+    let counter = 0;
+    translationTable[dependency[0].index] = counter++;
+    //
+    if (exportedNamespace) {
+        translationTable[exportedNamespace.index] = counter++;
+    }
+    for (let i = 1; i < dependency.length; i++) {
+        const dep = dependency[i];
+        if (exportedNamespace && exportedNamespace === dep) {
+            continue;
+        }
+        translationTable[dep.index] = counter++;
+    }
+    return translationTable;
 }

package/src/nodeset_tools/nodeset_to_xml.ts

@@ -18,7 +18,7 @@ import {
     QualifiedName
 } from "node-opcua-data-model";
 import { ExpandedNodeId, NodeId, NodeIdType, resolveNodeId } from "node-opcua-nodeid";
-import * as utils from "node-opcua-utils";
+import { lowerFirstLetter, isNullOrUndefined } from "node-opcua-utils";
 import { Variant, VariantArrayType, DataType } from "node-opcua-variant";
 import {
     IAddressSpace,
@@ -53,9 +53,9 @@ import { UAViewImpl } from "../ua_view_impl";
 import { DefinitionMap2, TypeInfo } from "../../source/loader/make_xml_extension_object_parser";
 import { makeDefinitionMap } from "../../source/loader/decode_xml_extension_object";
 import {
+    _constructNamespaceTranslationTable,
     constructNamespaceDependency,
-    constructNamespacePriorityTable,
-    hasHigherPriorityThan
+    constructNamespacePriorityTable
 } from "./construct_namespace_dependency";
 
 // tslint:disable:no-var-requires
@@ -105,6 +105,12 @@ function b(xw: XmlWriter, browseName: QualifiedName): string {
     return translateBrowseName(xw, browseName).toString().replace("ns=0;", "");
 }
 
+function hasHigherPriorityThan(namespaceIndex1: number, namespaceIndex2: number, priorityTable: number[]) {
+    const order1 = priorityTable[namespaceIndex1];
+    const order2 = priorityTable[namespaceIndex2];
+    return order1 > order2;
+}
+
 function _hasHigherPriorityThan(xw: XmlWriter, namespaceIndex1: number, namespaceIndex2: number) {
     assert(xw.priorityTable, "expecting a priorityTable");
     assert(namespaceIndex1 < xw.priorityTable.length);
@@ -128,7 +134,6 @@ function _dumpReferences(xw: XmlWriter, node: BaseNode) {
 
     function referenceToKeep(reference: UAReference): boolean {
         const referenceType = (reference as ReferenceImpl)._referenceType!;
-
         const targetedNamespaceIndex = reference.nodeId.namespace;
         if (_hasHigherPriorityThan(xw, targetedNamespaceIndex, node.nodeId.namespace)) {
             // this reference has nothing to do here ! drop it
@@ -165,8 +170,8 @@ function _dumpReferences(xw: XmlWriter, node: BaseNode) {
         }
         return false;
     }
-
-    const references = node.allReferences().filter(referenceToKeep);
+    const allReferences = node.allReferences();
+    const references = allReferences.filter(referenceToKeep);
 
     for (const reference of references.sort(sortByNodeId)) {
         if (getReferenceType(reference).browseName.toString() === "HasSubtype" && reference.isForward) {
@@ -329,7 +334,7 @@ function _dumpVariantInnerExtensionObject(
         const dataTypeNodeId = field.dataType;
 
         const fieldName = field.name!;
-        const lowerFieldName = utils.lowerFirstLetter(fieldName);
+        const lowerFieldName = lowerFirstLetter(fieldName);
         const v = (value as unknown as Record<string, unknown>)[lowerFieldName];
         if (v !== null && v !== undefined) {
             if (
@@ -535,6 +540,10 @@ function _dumpVariantExtensionObjectValue2(xw: XmlWriter, addressSpace: IAddress
     const dataTypeNodeId = value.schema.dataTypeNodeId;
     const definitionMap = makeDefinitionMap(addressSpace);
     const dataTypeNode = addressSpace.findDataType(dataTypeNodeId)!;
+    if (!dataTypeNode) {
+        warningLog("_dumpVariantExtensionObjectValue2: Cannot find dataType for  ", dataTypeNodeId.toString());
+        return;
+    }
     _dumpVariantExtensionObjectValue(xw, dataTypeNode.nodeId, definitionMap, value);
 }
 
@@ -845,7 +854,7 @@ function _dumpEnumDefinition(xw: XmlWriter, enumDefinition: EnumDefinition) {
     for (const defItem of enumDefinition.fields!) {
         xw.startElement("Field");
         xw.writeAttribute("Name", defItem.name as string);
-        if (!utils.isNullOrUndefined(defItem.value)) {
+        if (!isNullOrUndefined(defItem.value)) {
             xw.writeAttribute("Value", coerceInt64ToInt32(defItem.value));
         }
         _dumpDescription(xw, defItem);
@@ -1155,7 +1164,7 @@ function dumpUAObjectType(xw: XmlWriter, node: UAObjectTypeImpl) {
     xw.writeComment("ObjectType - " + b(xw, node.browseName) + " {{{{ ");
     _markAsVisited(xw, node);
 
-    // dump SubtypeOf and HasTypeDefinition
+    // dump SubtypeOf and HasTypeDefinition node if part of the same namespace
     dumpReferencedNodes(xw, node, false);
 
     xw.startElement("UAObjectType");
@@ -1268,25 +1277,6 @@ function writeAliases(xw: XmlWriter, aliases: Record<string, NodeIdString>) {
     xw.endElement();
 }
 
-function constructNamespaceTranslationTable(dependency: INamespace[], exportedNamespace: INamespace): ITranslationTable {
-    const translationTable: ITranslationTable = {};
-    assert(dependency[0].namespaceUri === "http://opcfoundation.org/UA/");
-
-    let counter = 0;
-    translationTable[dependency[0].index] = counter++;
-    //
-    if (exportedNamespace) {
-        translationTable[exportedNamespace.index] = counter++;
-    }
-    for (let i = 1; i < dependency.length; i++) {
-        const dep = dependency[i];
-        if (exportedNamespace && exportedNamespace === dep) {
-            continue;
-        }
-        translationTable[dep.index] = counter++;
-    }
-    return translationTable;
-}
 function dumpReferenceType(xw: XmlWriter, referenceType: UAReferenceType) {
     _markAsVisited(xw, referenceType);
 
@@ -1382,9 +1372,10 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
 
     const xw: XmlWriter = new XMLWriter(true);
 
-    xw.priorityTable = constructNamespacePriorityTable(this);
+    xw.priorityTable = constructNamespacePriorityTable(this.addressSpace).priorityTable;
+
     const dependency = constructNamespaceDependency(this, xw.priorityTable);
-    const translationTable = constructNamespaceTranslationTable(dependency, this);
+    const translationTable = _constructNamespaceTranslationTable(dependency, this);
     xw.translationTable = translationTable;
 
     xw.startDocument({ encoding: "utf-8", version: "1.0" });

package/src/reference_impl.ts

@@ -6,7 +6,7 @@ import chalk from "chalk";
 import { AddReferenceOpts, UAReference, BaseNode, UAReferenceType } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import { coerceNodeId, NodeId, NodeIdLike, sameNodeId } from "node-opcua-nodeid";
-import * as utils from "node-opcua-utils";
+import { isNullOrUndefined } from "node-opcua-utils";
 
 export function isNodeIdString(str: string): boolean {
     assert(typeof str === "string");
@@ -17,7 +17,7 @@ function is_valid_reference(ref: UAReference): boolean {
     const hasRequestedProperties =
         Object.prototype.hasOwnProperty.call(ref, "referenceType") &&
         Object.prototype.hasOwnProperty.call(ref, "nodeId") &&
-        !utils.isNullOrUndefined(ref.isForward);
+        !isNullOrUndefined(ref.isForward);
 
     if (!hasRequestedProperties) {
         return false;

package/src/ua_data_type_impl.ts

@@ -21,16 +21,16 @@ import {
 import { DataType } from "node-opcua-variant";
 import { UAObject, ISessionContext, UADataType, UAVariable, BaseNode } from "node-opcua-address-space-base";
 import { DataTypeIds } from "node-opcua-constants";
+import { Int64, coerceInt32, coerceInt64, coerceInt64toInt32 } from "node-opcua-basic-types";
 
 import { SessionContext } from "../source/session_context";
 import { ExtensionObjectConstructorFuncWithSchema } from "../source/interfaces/extension_object_constructor";
 import { BaseNodeImpl, InternalBaseNodeOptions } from "./base_node_impl";
 import { BaseNode_References_toString, BaseNode_toString, ToStringBuilder, ToStringOption } from "./base_node_private";
-import * as tools from "./tool_isSubtypeOf";
+import { construct_isSubtypeOf } from "./tool_isSubtypeOf";
 import { get_subtypeOf } from "./tool_isSubtypeOf";
 import { get_subtypeOfObj } from "./tool_isSubtypeOf";
 import { BaseNode_getCache } from "./base_node_private";
-import { Int64, coerceInt32, coerceInt64, coerceInt64toInt32 } from "node-opcua-basic-types";
 
 export interface UADataTypeImpl {
     _extensionObjectConstructor: ExtensionObjectConstructorFuncWithSchema;
@@ -76,8 +76,8 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
     }
 
     /** @deprecated */
-    public isSupertypeOf = tools.construct_isSubtypeOf<UADataType>(UADataTypeImpl);
-    public isSubtypeOf = tools.construct_isSubtypeOf<UADataType>(UADataTypeImpl);
+    public isSupertypeOf = construct_isSubtypeOf<UADataType>(UADataTypeImpl);
+    public isSubtypeOf = construct_isSubtypeOf<UADataType>(UADataTypeImpl);
 
     public readonly isAbstract: boolean;
 
@@ -370,24 +370,24 @@ export function DataType_toString(this: UADataTypeImpl, options: ToStringOption)
 
     options.add(
         options.padding +
-        chalk.yellow("          binaryEncodingNodeId: ") +
-        (this.binaryEncodingNodeId ? this.binaryEncodingNodeId.toString() : "<none>")
+            chalk.yellow("          binaryEncodingNodeId: ") +
+            (this.binaryEncodingNodeId ? this.binaryEncodingNodeId.toString() : "<none>")
     );
     options.add(
         options.padding +
-        chalk.yellow("          xmlEncodingNodeId   : ") +
-        (this.xmlEncodingNodeId ? this.xmlEncodingNodeId.toString() : "<none>")
+            chalk.yellow("          xmlEncodingNodeId   : ") +
+            (this.xmlEncodingNodeId ? this.xmlEncodingNodeId.toString() : "<none>")
     );
     options.add(
         options.padding +
-        chalk.yellow("          jsonEncodingNodeId  : ") +
-        (this.jsonEncodingNodeId ? this.jsonEncodingNodeId.toString() : "<none>")
+            chalk.yellow("          jsonEncodingNodeId  : ") +
+            (this.jsonEncodingNodeId ? this.jsonEncodingNodeId.toString() : "<none>")
     );
     if (this.subtypeOfObj) {
         options.add(
             options.padding +
-            chalk.yellow("          subtypeOfObj        : ") +
-            (this.subtypeOfObj ? this.subtypeOfObj.browseName.toString() : "")
+                chalk.yellow("          subtypeOfObj        : ") +
+                (this.subtypeOfObj ? this.subtypeOfObj.browseName.toString() : "")
         );
     }
     // references
@@ -396,7 +396,6 @@ export function DataType_toString(this: UADataTypeImpl, options: ToStringOption)
     dataTypeDefinition_toString.call(this, options);
 }
 
-
 const defaultEnumValue: Int64 = coerceInt64(-1);
 
 function makeEnumDefinition(definitionFields: EnumFieldOptions[]) {
@@ -424,8 +423,8 @@ function makeStructureDefinition(
     const structureType = isUnion
         ? StructureType.Union
         : hasOptionalFields
-            ? StructureType.StructureWithOptionalFields
-            : StructureType.Structure;
+        ? StructureType.StructureWithOptionalFields
+        : StructureType.Structure;
 
     const sd = new StructureDefinition({
         baseDataType,

package/src/ua_object_type_impl.ts

@@ -7,7 +7,7 @@ import { AttributeIds } from "node-opcua-data-model";
 import { DataValue, DataValueLike } from "node-opcua-data-value";
 import { NodeId } from "node-opcua-nodeid";
 import { StatusCodes } from "node-opcua-status-code";
-import * as utils from "node-opcua-utils";
+import { isNullOrUndefined } from "node-opcua-utils";
 import { DataType } from "node-opcua-variant";
 import {
     AddObjectOptions,
@@ -21,8 +21,8 @@ import {
 import { SessionContext } from "../source/session_context";
 import { BaseNodeImpl } from "./base_node_impl";
 import { ToStringBuilder, UAObjectType_toString } from "./base_node_private";
-import { get_subtypeOf, get_subtypeOfObj } from "./tool_isSubtypeOf";
-import * as tools from "./tool_isSubtypeOf";
+import { construct_isSubtypeOf, get_subtypeOf, get_subtypeOfObj } from "./tool_isSubtypeOf";
+import { } from "./tool_isSubtypeOf";
 import {
     assertUnusedChildBrowseName,
     topMostParentIsObjectTypeOrVariableType
@@ -49,13 +49,13 @@ export class UAObjectTypeImpl extends BaseNodeImpl implements UAObjectType {
     }
 
 
-    public isSubtypeOf = tools.construct_isSubtypeOf<UAObjectType>(UAObjectTypeImpl);
+    public isSubtypeOf = construct_isSubtypeOf<UAObjectType>(UAObjectTypeImpl);
     /** @deprecated - use  isSubtypeOf instead */
-    public isSupertypeOf = tools.construct_isSubtypeOf<UAObjectType>(UAObjectTypeImpl);
+    public isSupertypeOf = construct_isSubtypeOf<UAObjectType>(UAObjectTypeImpl);
 
     constructor(options: any) {
         super(options);
-        this.isAbstract = utils.isNullOrUndefined(options.isAbstract) ? false : options.isAbstract;
+        this.isAbstract = isNullOrUndefined(options.isAbstract) ? false : options.isAbstract;
     }
 
     public readAttribute(context: ISessionContext, attributeId: AttributeIds): DataValue {