node-opcua-factory 2.51.0 → 2.55.0

package/source/constructor_type.ts

@@ -1,18 +1,18 @@
-/**
- * @module node-opcua-factory
- */
-import { ExpandedNodeId } from "node-opcua-nodeid";
-
-import { BaseUAObject } from "./factories_baseobject";
-import { StructuredTypeSchema } from "./factories_structuredTypeSchema";
-
-type BaseUAObjectConstructable = new (options?: any) => BaseUAObject;
-export type ConstructorFunc = BaseUAObjectConstructable;
-// new (...args: any[]) => BaseUAObjectConstructable;
-
-export interface ConstructorFuncWithSchema extends ConstructorFunc {
-    schema: StructuredTypeSchema;
-    possibleFields: string[];
-    encodingDefaultBinary: ExpandedNodeId;
-    encodingDefaultXml: ExpandedNodeId;
-}
+/**
+ * @module node-opcua-factory
+ */
+import { ExpandedNodeId } from "node-opcua-nodeid";
+
+import { BaseUAObject } from "./factories_baseobject";
+import { StructuredTypeSchema } from "./factories_structuredTypeSchema";
+
+type BaseUAObjectConstructable = new (options?: any) => BaseUAObject;
+export type ConstructorFunc = BaseUAObjectConstructable;
+// new (...args: any[]) => BaseUAObjectConstructable;
+
+export interface ConstructorFuncWithSchema extends ConstructorFunc {
+    schema: StructuredTypeSchema;
+    possibleFields: string[];
+    encodingDefaultBinary: ExpandedNodeId;
+    encodingDefaultXml: ExpandedNodeId;
+}

package/source/datatype_factory.ts

@@ -1,9 +1,8 @@
 /**
  * @module node-opcua-factory
  */
-// tslint:disable:no-console
-import * as chalk from "chalk";
 import * as util from "util";
+import * as chalk from "chalk";
 
 import { assert } from "node-opcua-assert";
 import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
@@ -42,7 +41,7 @@ export class DataTypeFactory {
         this.baseDataFactories = baseDataFactories;
     }
     // -----------------------------
-    public registerSimpleType(name: string, dataTypeNodeId: NodeId, def: BasicTypeDefinition) {
+    public registerSimpleType(name: string, dataTypeNodeId: NodeId, def: BasicTypeDefinition): void {
         // istanbul ignore next
         if (this._simpleTypes.has(name)) {
             throw new Error("registerSimpleType " + name + " already register");
@@ -257,10 +256,10 @@ export class DataTypeFactory {
             return new BaseUAObject();
             // throw new Error("Cannot find constructor for " + expandedNodeId.toString());
         }
-        return callConstructor(constructor);
+        return new constructor();
     }
 
-    public associateWithBinaryEncoding(className: string, expandedNodeId: ExpandedNodeId) {
+    public associateWithBinaryEncoding(className: string, expandedNodeId: ExpandedNodeId): void {
         const classConstructor = this.getStructureTypeConstructor(className);
         if (doDebug) {
             debugLog(" associateWithBinaryEncoding ", className, expandedNodeId.toString());
@@ -359,10 +358,4 @@ function verifyExpandedNodeId(expandedNodeId: NodeId): boolean {
 
 function makeExpandedNodeIdKey(expandedNodeId: NodeId): string {
     return expandedNodeId.toString();
-}
-
-export function callConstructor(constructor: ConstructorFunc): BaseUAObject {
-    assert(typeof constructor === "function");
-    const constructorFunc: any = constructor.bind.apply(constructor, arguments as any);
-    return new constructorFunc();
-}
+}

package/source/factories_baseobject.ts

@@ -1,9 +1,12 @@
+/* eslint-disable prefer-rest-params */
+/* eslint-disable complexity */
 /**
  * @module node-opcua-factory
  */
 // tslint:disable:no-shadowed-variable
 import * as chalk from "chalk";
 import { assert } from "node-opcua-assert";
+import { AttributeIds } from "node-opcua-basic-types";
 import { BinaryStream, BinaryStreamSizeCalculator, OutputBinaryStream } from "node-opcua-binary-stream";
 import { hexDump } from "node-opcua-debug";
 import { NodeId } from "node-opcua-nodeid";
@@ -11,11 +14,10 @@ import * as utils from "node-opcua-utils";
 
 import { getBuildInType } from "./factories_builtin_types";
 import { getEnumeration, hasEnumeration } from "./factories_enumerations";
-import { callConstructor, DataTypeFactory } from "./datatype_factory";
+import { DataTypeFactory } from "./datatype_factory";
 import { getStructureTypeConstructor } from "./factories_factories";
 import { get_base_schema, StructuredTypeSchema } from "./factories_structuredTypeSchema";
 import { EnumerationDefinition, FieldCategory, StructuredTypeField, BuiltInTypeDefinition, FieldType } from "./types";
-import { AttributeIds } from "node-opcua-basic-types";
 
 function r(str: string, length = 30) {
     return (str + "                                ").substr(0, length);
@@ -50,7 +52,7 @@ function _decode_member_(value: any, field: StructuredTypeField, stream: BinaryS
             }
             // assert(typeof field.fieldTypeConstructor === "function");
             const constructor = field.fieldTypeConstructor;
-            value = callConstructor(constructor);
+            value = new constructor();
             value.decodeDebug(stream, options);
         }
     }
@@ -122,7 +124,9 @@ interface ExploreParams {
     padding: string;
     lines: string[];
 }
-function _exploreObject(self: BaseUAObject, field: StructuredTypeField, data: ExploreParams, args: any) {
+// eslint-disable-next-line complexity
+// eslint-disable-next-line max-statements
+function _exploreObject(self: BaseUAObject, field: StructuredTypeField, data: ExploreParams, args: any): void {
     if (!self) {
         return;
     }
@@ -217,6 +221,7 @@ function _exploreObject(self: BaseUAObject, field: StructuredTypeField, data: Ex
                 } else if (fieldType === "DateTime" || fieldType === "UtcTime") {
                     value = value && value.toISOString ? value.toISOString() : value;
                 } else if (typeof value === "object" && value !== null && value !== undefined) {
+                    // eslint-disable-next-line prefer-spread
                     value = value.toString.apply(value, args);
                 }
                 str =
@@ -298,23 +303,25 @@ function _exploreObject(self: BaseUAObject, field: StructuredTypeField, data: Ex
 
     switch (category) {
         case FieldCategory.enumeration:
-            const s = field.schema as EnumerationDefinition;
+            {
+                const s = field.schema as EnumerationDefinition;
 
-            // istanbul ignore next
-            if (!s.typedEnum) {
-                // tslint:disable:no-console
-                console.log("xxxx cannot find typeEnum", s);
-            }
-            // istanbul ignore next
-            if (!s.typedEnum.get(value)) {
-                // tslint:disable:no-console
-                (s.typedEnum as any)._isFlaggable = true;
-                console.log("xxxx cannot find typeEnum value ", value);
-                str = fieldNameF + " " + fieldTypeF + ": " + s.name + "." + s.typedEnum.get(value) + " ( " + value + ")";
-                data.lines.push(str);
-            } else {
-                str = fieldNameF + " " + fieldTypeF + ": " + s.name + "." + s.typedEnum.get(value)!.key + " ( " + value + ")";
-                data.lines.push(str);
+                // istanbul ignore next
+                if (!s.typedEnum) {
+                    // tslint:disable:no-console
+                    console.log("xxxx cannot find typeEnum", s);
+                }
+                // istanbul ignore next
+                if (!s.typedEnum.get(value)) {
+                    // tslint:disable:no-console
+                    (s.typedEnum as any)._isFlaggable = true;
+                    console.log("xxxx cannot find typeEnum value ", value);
+                    str = fieldNameF + " " + fieldTypeF + ": " + s.name + "." + s.typedEnum.get(value) + " ( " + value + ")";
+                    data.lines.push(str);
+                } else {
+                    str = fieldNameF + " " + fieldTypeF + ": " + s.name + "." + s.typedEnum.get(value)!.key + " ( " + value + ")";
+                    data.lines.push(str);
+                }
             }
             break;
         case FieldCategory.basic:
@@ -390,7 +397,9 @@ export interface BaseUAObject {
  * @constructor
  */
 export class BaseUAObject {
-    constructor() {}
+    constructor() {
+        /**  */
+    }
 
     /**
      * Encode the object to the binary stream.
@@ -398,7 +407,9 @@ export class BaseUAObject {
      * @method encode
      * @param stream {BinaryStream}
      */
-    public encode(stream: OutputBinaryStream): void {}
+    public encode(stream: OutputBinaryStream): void {
+        /** */
+    }
 
     /**
      * Decode the object from the binary stream.
@@ -406,7 +417,9 @@ export class BaseUAObject {
      * @method decode
      * @param stream {BinaryStream}
      */
-    public decode(stream: BinaryStream): void {}
+    public decode(stream: BinaryStream): void {
+        /** */
+    }
 
     /**
      * Calculate the required size to store this object in a binary stream.
@@ -424,14 +437,14 @@ export class BaseUAObject {
      * @return {String}
      */
     public toString(...args: any[]): string {
-        if (this.schema && this.schema.hasOwnProperty("toString")) {
+        if (this.schema && Object.prototype.hasOwnProperty.call(this.schema, "toString")) {
             return this.schema.toString.apply(this, arguments as any);
         } else {
             if (!this.explore) {
                 // xx console.log(util.inspect(this));
                 return Object.prototype.toString.apply(this, arguments as any);
             }
-            return this.explore.apply(this, arguments as any);
+            return this.explore();
         }
     }
 
@@ -464,8 +477,8 @@ export class BaseUAObject {
         for (const field of schema.fields) {
             const value = self[field.name];
 
-            if (typeof field.switchValue === "number" ) {
-                // skip 
+            if (typeof field.switchValue === "number") {
+                // skip
                 if (self["switchField"] !== field.switchValue) {
                     continue;
                 }

package/source/factories_basic_type.ts

@@ -46,7 +46,7 @@ export interface BasicTypeOptions {
  *
  * @param [schema.toJSON]optional, a method to convert a value into the request type.
  */
-export function registerBasicType(schema: BasicTypeOptions) {
+export function registerBasicType(schema: BasicTypeOptions): void {
     const exists: boolean = hasBuiltInType(schema.name);
 
     /* istanbul ignore next */

package/source/factories_builtin_types.ts

@@ -65,8 +65,7 @@ import { makeExpandedNodeId, makeNodeId } from "node-opcua-nodeid";
 import { coerceStatusCode, decodeStatusCode, encodeStatusCode, StatusCodes } from "node-opcua-status-code";
 import { BasicTypeDefinition, BasicTypeDefinitionOptions, FieldCategory, TypeSchemaBase } from "./types";
 
-// tslint:disable:no-empty
-// tslint:enable:no-unused-variable
+// eslint-disable-next-line @typescript-eslint/no-empty-function
 function defaultEncode(value: any, stream: OutputBinaryStream): void {}
 
 function defaultDecode(stream: BinaryStream): any {
@@ -109,6 +108,7 @@ function decodeAny(stream: BinaryStream) {
     assert(false, "type 'Any' cannot be decoded");
 }
 
+// eslint-disable-next-line @typescript-eslint/no-empty-function
 function encodeNull(value: any, stream: OutputBinaryStream): void {}
 
 function decodeNull(stream: BinaryStream): any {
@@ -376,6 +376,6 @@ export function findBuiltInType(dataTypeName: string): BasicTypeDefinition {
     return t;
 }
 
-export function getTypeMap() {
+export function getTypeMap(): Map<string, BasicTypeSchema> {
     return _defaultTypeMap;
 }

package/source/factories_builtin_types_special.ts

@@ -35,7 +35,7 @@ function _self_coerce(constructor: any) {
     };
 }
 
-export function registerSpecialVariantEncoder(constructor: ConstructorFunc) {
+export function registerSpecialVariantEncoder(constructor: ConstructorFunc): void {
     assert(typeof constructor === "function");
 
     const name = constructor.prototype.schema.name;

package/source/factories_enumerations.ts

@@ -15,7 +15,7 @@ function _encode_enumeration(typedEnum: Enum, value: number, stream: OutputBinar
 
 function _decode_enumeration(typedEnum: Enum, stream: BinaryStream): number {
     const value = stream.readInteger();
-    const e = (typedEnum.get(value) as any) as string;
+    const e = typedEnum.get(value) as any as string;
     // istanbul ignore next
     if (!e) {
         throw new Error("cannot  coerce value=" + value + " to " + typedEnum.constructor.name);
@@ -72,11 +72,11 @@ const _enumerations: Map<string, EnumerationDefinitionSchema> = new Map<string,
  * @return {Enum}
  */
 export function registerEnumeration(options: EnumerationDefinitionOptions): Enum {
-    assert(Object.prototype.hasOwnProperty.call(options,"name"));
-    assert(Object.prototype.hasOwnProperty.call(options,"enumValues"));
+    assert(Object.prototype.hasOwnProperty.call(options, "name"));
+    assert(Object.prototype.hasOwnProperty.call(options, "enumValues"));
     const name = options.name;
 
-    if (_enumerations.hasOwnProperty(name)) {
+    if (Object.prototype.hasOwnProperty.call(_enumerations, name)) {
         throw new Error("factories.registerEnumeration : Enumeration " + options.name + " has been already inserted");
     }
     const enumerationDefinition = new EnumerationDefinitionSchema(options);

package/source/factories_factories.ts

@@ -1,58 +1,58 @@
-/**
- * @module node-opcua-factory
- */
-// tslint:disable:no-console
-
-import * as chalk from "chalk";
-
-import { assert } from "node-opcua-assert";
-import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
-import { ExpandedNodeId, NodeId } from "node-opcua-nodeid";
-
-import { DataTypeFactory } from "./datatype_factory";
-import { ConstructorFuncWithSchema, ConstructorFunc } from "./constructor_type";
-
-import { BaseUAObject } from "./factories_baseobject";
-import { StructuredTypeSchema } from "./factories_structuredTypeSchema";
-
-const debugLog = make_debugLog(__filename);
-const doDebug = checkDebugFlag(__filename);
-
-let globalFactory: DataTypeFactory;
-export function getStandardDataTypeFactory(): DataTypeFactory {
-    if (!globalFactory) {
-        globalFactory = new DataTypeFactory([]);
-        globalFactory.targetNamespace = "http://opcfoundation.org/UA/";
-    }
-    return globalFactory;
-}
-export function getStructureTypeConstructor(typeName: string): ConstructorFuncWithSchema {
-    return getStandardDataTypeFactory().getStructureTypeConstructor(typeName);
-}
-export function hasStructuredType(typeName: string): boolean {
-    return getStandardDataTypeFactory().hasStructuredType(typeName);
-}
-export function getStructuredTypeSchema(typeName: string): StructuredTypeSchema {
-    return getStandardDataTypeFactory().getStructuredTypeSchema(typeName);
-}
-
-export function getConstructor(binaryEncodingNodeId: ExpandedNodeId): ConstructorFunc | null {
-    return getStandardDataTypeFactory().getConstructor(binaryEncodingNodeId);
-}
-export function hasConstructor(binaryEncodingNodeId: ExpandedNodeId): boolean {
-    return getStandardDataTypeFactory().hasConstructor(binaryEncodingNodeId);
-}
-export function constructObject(binaryEncodingNodeId: ExpandedNodeId): BaseUAObject {
-    return getStandardDataTypeFactory().constructObject(binaryEncodingNodeId);
-}
-export function registerClassDefinition(
-    dataTypeNodeId: NodeId,
-    className: string,
-    classConstructor: ConstructorFuncWithSchema
-): void {
-    return getStandardDataTypeFactory().registerClassDefinition(dataTypeNodeId, className, classConstructor);
-}
-/* istanbul ignore next */
-export function dump(): void {
-    getStandardDataTypeFactory().dump();
-}
+/**
+ * @module node-opcua-factory
+ */
+// tslint:disable:no-console
+
+import * as chalk from "chalk";
+
+import { assert } from "node-opcua-assert";
+import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
+import { ExpandedNodeId, NodeId } from "node-opcua-nodeid";
+
+import { DataTypeFactory } from "./datatype_factory";
+import { ConstructorFuncWithSchema, ConstructorFunc } from "./constructor_type";
+
+import { BaseUAObject } from "./factories_baseobject";
+import { StructuredTypeSchema } from "./factories_structuredTypeSchema";
+
+const debugLog = make_debugLog(__filename);
+const doDebug = checkDebugFlag(__filename);
+
+let globalFactory: DataTypeFactory;
+export function getStandardDataTypeFactory(): DataTypeFactory {
+    if (!globalFactory) {
+        globalFactory = new DataTypeFactory([]);
+        globalFactory.targetNamespace = "http://opcfoundation.org/UA/";
+    }
+    return globalFactory;
+}
+export function getStructureTypeConstructor(typeName: string): ConstructorFuncWithSchema {
+    return getStandardDataTypeFactory().getStructureTypeConstructor(typeName);
+}
+export function hasStructuredType(typeName: string): boolean {
+    return getStandardDataTypeFactory().hasStructuredType(typeName);
+}
+export function getStructuredTypeSchema(typeName: string): StructuredTypeSchema {
+    return getStandardDataTypeFactory().getStructuredTypeSchema(typeName);
+}
+
+export function getConstructor(binaryEncodingNodeId: ExpandedNodeId): ConstructorFunc | null {
+    return getStandardDataTypeFactory().getConstructor(binaryEncodingNodeId);
+}
+export function hasConstructor(binaryEncodingNodeId: ExpandedNodeId): boolean {
+    return getStandardDataTypeFactory().hasConstructor(binaryEncodingNodeId);
+}
+export function constructObject(binaryEncodingNodeId: ExpandedNodeId): BaseUAObject {
+    return getStandardDataTypeFactory().constructObject(binaryEncodingNodeId);
+}
+export function registerClassDefinition(
+    dataTypeNodeId: NodeId,
+    className: string,
+    classConstructor: ConstructorFuncWithSchema
+): void {
+    return getStandardDataTypeFactory().registerClassDefinition(dataTypeNodeId, className, classConstructor);
+}
+/* istanbul ignore next */
+export function dump(): void {
+    getStandardDataTypeFactory().dump();
+}

package/source/factories_id_generator.ts

@@ -1,18 +1,18 @@
-/**
- * @module node-opcua-factory
- */
-const _FIRST_INTERNAL_ID = 0xFFFE0000;
-
-let _nextAvailableId = _FIRST_INTERNAL_ID;
-
-export function generate_new_id(): number {
-    _nextAvailableId += 1;
-    return _nextAvailableId;
-}
-
-export function next_available_id(): number  {
-    return -1;
-}
-export function is_internal_id(value: number): boolean  {
-    return value >= _FIRST_INTERNAL_ID;
-}
+/**
+ * @module node-opcua-factory
+ */
+const _FIRST_INTERNAL_ID = 0xFFFE0000;
+
+let _nextAvailableId = _FIRST_INTERNAL_ID;
+
+export function generate_new_id(): number {
+    _nextAvailableId += 1;
+    return _nextAvailableId;
+}
+
+export function next_available_id(): number  {
+    return -1;
+}
+export function is_internal_id(value: number): boolean  {
+    return value >= _FIRST_INTERNAL_ID;
+}