node-opcua-address-space 2.90.1 → 2.91.0

package/src/{tool_isSupertypeOf.ts → tool_isSubtypeOf.ts}

@@ -5,12 +5,12 @@
 import { assert } from "node-opcua-assert";
 import { NodeId, NodeIdLike, resolveNodeId } from "node-opcua-nodeid";
 import { sameNodeId } from "node-opcua-nodeid";
+import { NodeClass } from "node-opcua-data-model";
 import { BaseNode, UADataType, UAObjectType, UAReference, UAReferenceType, UAVariableType } from "node-opcua-address-space-base";
 
 import { BaseNode_getCache } from "./base_node_private";
 import { ReferenceImpl } from "./reference_impl";
 import { BaseNodeImpl } from "./base_node_impl";
-import { NodeClass } from "node-opcua-data-model";
 
 const HasSubTypeNodeId = resolveNodeId("HasSubtype");
 
@@ -20,13 +20,13 @@ function _filterSubType(reference: UAReference) {
 
 export type BaseNodeConstructor<T extends BaseNode> = new () => T;
 
-function _slow_isSupertypeOf<T extends UAType>(this: T, Class: typeof BaseNodeImpl, baseType: T | NodeIdLike): boolean {
+function _slow_isSubtypeOf<T extends UAType>(this: T, Class: typeof BaseNodeImpl, baseType: T | NodeIdLike): boolean {
     if (!(baseType instanceof Class)) {
         const node = this.addressSpace.findNode(baseType as NodeIdLike);
         if (!node || !(node instanceof Class)) {
             throw new Error("Invalid argument");
         }
-        return _slow_isSupertypeOf.call(this, Class, node as unknown as T);
+        return _slow_isSubtypeOf.call(this, Class, node as unknown as T);
     }
     assert(this instanceof Class);
     assert(baseType instanceof Class, " Object must have same type");
@@ -50,7 +50,7 @@ function _slow_isSupertypeOf<T extends UAType>(this: T, Class: typeof BaseNodeIm
         if (sameNodeId(subTypeNode.nodeId, baseType.nodeId)) {
             return true;
         } else {
-            if (_slow_isSupertypeOf.call(subTypeNode, Class, baseType)) {
+            if (_slow_isSubtypeOf.call(subTypeNode, Class, baseType)) {
                 return true;
             }
         }
@@ -96,11 +96,11 @@ function hashBaseNode(e: BaseNode): string {
     return e.nodeId.value.toString();
 }
 
-export type IsSupertypeOfFunc<T extends UAType> = (this: T, baseType: T) => boolean;
+export type IsSubtypeOfFunc<T extends UAType> = (this: T, baseType: T) => boolean;
 
 export type UAType = UAReferenceType | UADataType | UAObjectType | UAVariableType;
 
-export function construct_isSupertypeOf<T extends UAType>(Class: typeof BaseNodeImpl): IsSupertypeOfFunc<T> {
+export function construct_isSubtypeOf<T extends UAType>(Class: typeof BaseNodeImpl): IsSubtypeOfFunc<T> {
     return wrap_memoize(function (this: T, baseType: T | NodeIdLike): boolean {
         if (!(baseType instanceof Class)) {
             throw new Error(
@@ -115,13 +115,13 @@ export function construct_isSupertypeOf<T extends UAType>(Class: typeof BaseNode
         if (!(this instanceof Class)) {
             throw new Error("expecting this to be " + Class.name + " but got " + baseType.constructor.name);
         }
-        return _slow_isSupertypeOf.call(this, Class, baseType as T);
+        return _slow_isSubtypeOf.call(this, Class, baseType as T);
     }, hashBaseNode);
 }
 
-export function construct_slow_isSupertypeOf<T extends UAType>(Class: typeof BaseNodeImpl) {
+export function construct_slow_isSubtypeOf<T extends UAType>(Class: typeof BaseNodeImpl) {
     return function (this: T, baseType: T | NodeIdLike): boolean {
-        return _slow_isSupertypeOf.call(this, Class, baseType);
+        return _slow_isSubtypeOf.call(this, Class, baseType);
     };
 }
 

package/src/ua_data_type_impl.ts

@@ -26,9 +26,9 @@ 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_isSupertypeOf";
-import { get_subtypeOf } from "./tool_isSupertypeOf";
-import { get_subtypeOfObj } from "./tool_isSupertypeOf";
+import * as tools from "./tool_isSubtypeOf";
+import { get_subtypeOf } from "./tool_isSubtypeOf";
+import { get_subtypeOfObj } from "./tool_isSubtypeOf";
 import { BaseNode_getCache } from "./base_node_private";
 
 export interface UADataTypeImpl {
@@ -62,8 +62,8 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
      *
      *    var dataTypeDouble = addressSpace.findDataType("Double");
      *    var dataTypeNumber = addressSpace.findDataType("Number");
-     *    assert(dataTypeDouble.isSupertypeOf(dataTypeNumber));
-     *    assert(!dataTypeNumber.isSupertypeOf(dataTypeDouble));
+     *    assert(dataTypeDouble.isSubtypeOf(dataTypeNumber));
+     *    assert(!dataTypeNumber.isSubtypeOf(dataTypeDouble));
      *
      */
     public get subtypeOf(): NodeId | null {
@@ -74,7 +74,9 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
         return get_subtypeOfObj.call(this) as any as UADataType;
     }
 
-    public isSupertypeOf = tools.construct_isSupertypeOf<UADataType>(UADataTypeImpl);
+    /** @deprecated */
+    public isSupertypeOf = tools.construct_isSubtypeOf<UADataType>(UADataTypeImpl);
+    public isSubtypeOf = tools.construct_isSubtypeOf<UADataType>(UADataTypeImpl);
 
     public readonly isAbstract: boolean;
 
@@ -277,9 +279,9 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
 
         // we have a data type from a companion specification
         // let's see if this data type need to be registered
-        const isEnumeration = enumeration && this.isSupertypeOf(enumeration);
-        const isStructure = structure && this.isSupertypeOf(structure);
-        const isUnion = !!(structure && union && this.isSupertypeOf(union));
+        const isEnumeration = enumeration && this.isSubtypeOf(enumeration);
+        const isStructure = structure && this.isSubtypeOf(structure);
+        const isUnion = !!(structure && union && this.isSubtypeOf(union));
 
         const isRootDataType = (n: UADataType) => n.nodeId.namespace === 0 && n.nodeId.value === DataTypeIds.BaseDataType;
         // https://reference.opcfoundation.org/v104/Core/docs/Part3/8.49/#Table34
@@ -367,24 +369,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
@@ -418,8 +420,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

@@ -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_isSupertypeOf";
-import * as tools from "./tool_isSupertypeOf";
+import { get_subtypeOf, get_subtypeOfObj } from "./tool_isSubtypeOf";
+import * as tools from "./tool_isSubtypeOf";
 import {
     assertUnusedChildBrowseName,
     initialize_properties_and_components,
@@ -42,10 +42,16 @@ export class UAObjectTypeImpl extends BaseNodeImpl implements UAObjectType {
     public get subtypeOf(): NodeId | null {
         return get_subtypeOf.call(this);
     }
+
+
     public get subtypeOfObj(): UAObjectType | null {
         return get_subtypeOfObj.call(this) as any as UAObjectType;
     }
-    public isSupertypeOf = tools.construct_isSupertypeOf<UAObjectType>(UAObjectTypeImpl);
+
+
+    public isSubtypeOf = tools.construct_isSubtypeOf<UAObjectType>(UAObjectTypeImpl);
+    /** @deprecated - use  isSubtypeOf instead */
+    public isSupertypeOf = tools.construct_isSubtypeOf<UAObjectType>(UAObjectTypeImpl);
 
     constructor(options: any) {
         super(options);

package/src/ua_reference_type_impl.ts

@@ -14,8 +14,8 @@ import { DataType } from "node-opcua-variant";
 
 import { SessionContext, UAReferenceType as UAReferenceTypePublic } from "../source";
 import { BaseNodeImpl, InternalBaseNodeOptions } from "./base_node_impl";
-import * as tools from "./tool_isSupertypeOf";
-import { get_subtypeOf, get_subtypeOfObj } from "./tool_isSupertypeOf";
+import * as tools from "./tool_isSubtypeOf";
+import { get_subtypeOf, get_subtypeOfObj } from "./tool_isSubtypeOf";
 import { ReferenceImpl } from "./reference_impl";
 import { BaseNode_getCache } from "./base_node_private";
 
@@ -98,12 +98,15 @@ export class UAReferenceTypeImpl extends BaseNodeImpl implements UAReferenceType
     /**
      * returns true if self is  a super type of baseType
      */
-    public isSupertypeOf = tools.construct_isSupertypeOf<UAReferenceType>(UAReferenceTypeImpl);
+    public isSubtypeOf = tools.construct_isSubtypeOf<UAReferenceType>(UAReferenceTypeImpl);
+  
+    /** @deprecated - use `isSubtypeOf` instead*/
+    public isSupertypeOf = tools.construct_isSubtypeOf<UAReferenceType>(UAReferenceTypeImpl);
 
     /**
      * @private
      */
-    public _slow_isSupertypeOf = tools.construct_slow_isSupertypeOf<UAReferenceType>(UAReferenceTypeImpl);
+    public _slow_isSubtypeOf = tools.construct_slow_isSubtypeOf<UAReferenceType>(UAReferenceTypeImpl);
 
     constructor(options: UAReferenceTypeOptions) {
         super(options);