node-opcua-factory 2.51.0 → 2.55.0

package/source/factories_schema_helpers.ts

@@ -1,125 +1,125 @@
-/**
- * @module node-opcua-factory
- */
-import { assert } from "node-opcua-assert";
-import { make_debugLog } from "node-opcua-debug";
-import { CommonInterface, FieldCategory, FieldType, StructuredTypeField } from "./types";
-
-const debugLog = make_debugLog(__filename);
-
-export const parameters = {
-    debugSchemaHelper: !!process.env.DEBUG_CLASS
-};
-
-/**
- * ensure correctness of a schema object.
- *
- * @method check_schema_correctness
- * @param schema
- *
- */
-export function check_schema_correctness(schema: any) {
-    assert(typeof schema.name === "string", " expecting schema to have a name");
-    assert(schema.fields instanceof Array, " expecting schema to provide a set of fields " + schema.name);
-    assert(schema.baseType === undefined || typeof schema.baseType === "string");
-}
-
-/**
- * @method initialize_value
- * @param value
- * @param defaultValue
- * @return {*}
- */
-export function initialize_field(field: StructuredTypeField, value: any): any {
-    const _t = field.schema;
-    if (!(_t !== null && typeof _t === "object")) {
-        throw new Error(
-            "initialize_field: expecting field.schema to be set field.name = '" + field.name + "' type = " + field.fieldType
-        );
-    }
-    if (field.category === FieldCategory.complex) {
-        if (field.fieldTypeConstructor) {
-            return new field.fieldTypeConstructor(value);
-        } else {
-            debugLog("xxxx => missing constructor for field type", field.fieldType);
-        }
-    }
-
-    if (value === undefined || value === null) {
-        const defaultValue = _t.computer_default_value ? _t.computer_default_value(field.defaultValue) : field.defaultValue;
-        if (value === undefined) {
-            if (_t.coerce) {
-                return _t.coerce(defaultValue);
-            }
-            return defaultValue;
-        }
-        if (defaultValue === null) {
-            if (value === null) {
-                return null;
-            }
-        }
-    }
-    if (_t.coerce) {
-        value = _t.coerce(value);
-    }
-    if (field.validate) {
-        if (!field.validate(value)) {
-            throw Error(" invalid value " + value + " for field " + field.name + " of type " + field.fieldType);
-        }
-    }
-    return value;
-}
-
-function initialize_value(value: any, defaultValue: any, _t: CommonInterface) {
-    if (value === undefined) {
-        return defaultValue;
-    }
-    if (defaultValue === null) {
-        if (value === null) {
-            return null;
-        }
-    }
-    if (_t.coerce) {
-        value = _t.coerce(value);
-        return value;
-    }
-    return value;
-}
-/**
- * @method initialize_field_array
- * @param field
- * @param valueArray
- * @return
- */
-export function initialize_field_array(field: FieldType, valueArray: any) {
-    const _t = field.schema;
-
-    let value;
-    let i;
-    assert(field !== null && typeof field === "object");
-    assert(field.isArray);
-
-    if (!valueArray && field.defaultValue === null) {
-        return null;
-    }
-
-    valueArray = valueArray || [];
-
-    let defaultValue: any;
-    if (_t.computer_default_value) {
-        defaultValue = _t.computer_default_value(field.defaultValue);
-    }
-    const arr = [];
-    for (i = 0; i < valueArray.length; i++) {
-        value = initialize_value(valueArray[i], defaultValue, _t);
-        arr.push(value);
-    }
-    if (field.validate) {
-        for (i = 0; i < arr.length; i++) {
-            if (!field.validate(arr[i])) {
-                throw Error(" invalid value " + arr[i] + " for field " + field.name + " of type " + field.fieldType);
-            }
-        }
-    }
-    return arr;
-}
+/**
+ * @module node-opcua-factory
+ */
+import { assert } from "node-opcua-assert";
+import { make_debugLog } from "node-opcua-debug";
+import { CommonInterface, FieldCategory, FieldType, StructuredTypeField } from "./types";
+
+const debugLog = make_debugLog(__filename);
+
+export const parameters = {
+    debugSchemaHelper: !!process.env.DEBUG_CLASS
+};
+
+/**
+ * ensure correctness of a schema object.
+ *
+ * @method check_schema_correctness
+ * @param schema
+ *
+ */
+export function check_schema_correctness(schema: any) {
+    assert(typeof schema.name === "string", " expecting schema to have a name");
+    assert(schema.fields instanceof Array, " expecting schema to provide a set of fields " + schema.name);
+    assert(schema.baseType === undefined || typeof schema.baseType === "string");
+}
+
+/**
+ * @method initialize_value
+ * @param value
+ * @param defaultValue
+ * @return {*}
+ */
+export function initialize_field(field: StructuredTypeField, value: any): any {
+    const _t = field.schema;
+    if (!(_t !== null && typeof _t === "object")) {
+        throw new Error(
+            "initialize_field: expecting field.schema to be set field.name = '" + field.name + "' type = " + field.fieldType
+        );
+    }
+    if (field.category === FieldCategory.complex) {
+        if (field.fieldTypeConstructor) {
+            return new field.fieldTypeConstructor(value);
+        } else {
+            debugLog("xxxx => missing constructor for field type", field.fieldType);
+        }
+    }
+
+    if (value === undefined || value === null) {
+        const defaultValue = _t.computer_default_value ? _t.computer_default_value(field.defaultValue) : field.defaultValue;
+        if (value === undefined) {
+            if (_t.coerce) {
+                return _t.coerce(defaultValue);
+            }
+            return defaultValue;
+        }
+        if (defaultValue === null) {
+            if (value === null) {
+                return null;
+            }
+        }
+    }
+    if (_t.coerce) {
+        value = _t.coerce(value);
+    }
+    if (field.validate) {
+        if (!field.validate(value)) {
+            throw Error(" invalid value " + value + " for field " + field.name + " of type " + field.fieldType);
+        }
+    }
+    return value;
+}
+
+function initialize_value(value: any, defaultValue: any, _t: CommonInterface) {
+    if (value === undefined) {
+        return defaultValue;
+    }
+    if (defaultValue === null) {
+        if (value === null) {
+            return null;
+        }
+    }
+    if (_t.coerce) {
+        value = _t.coerce(value);
+        return value;
+    }
+    return value;
+}
+/**
+ * @method initialize_field_array
+ * @param field
+ * @param valueArray
+ * @return
+ */
+export function initialize_field_array(field: FieldType, valueArray: any) {
+    const _t = field.schema;
+
+    let value;
+    let i;
+    assert(field !== null && typeof field === "object");
+    assert(field.isArray);
+
+    if (!valueArray && field.defaultValue === null) {
+        return null;
+    }
+
+    valueArray = valueArray || [];
+
+    let defaultValue: any;
+    if (_t.computer_default_value) {
+        defaultValue = _t.computer_default_value(field.defaultValue);
+    }
+    const arr = [];
+    for (i = 0; i < valueArray.length; i++) {
+        value = initialize_value(valueArray[i], defaultValue, _t);
+        arr.push(value);
+    }
+    if (field.validate) {
+        for (i = 0; i < arr.length; i++) {
+            if (!field.validate(arr[i])) {
+                throw Error(" invalid value " + arr[i] + " for field " + field.name + " of type " + field.fieldType);
+            }
+        }
+    }
+    return arr;
+}

package/source/factories_structuredTypeSchema.ts

@@ -2,7 +2,6 @@
  * @module node-opcua-factory
  */
 import * as chalk from "chalk";
-import { CommonInterface, FieldCategory, FieldInterfaceOptions, FieldType, StructuredTypeOptions, TypeSchemaBase } from "./types";
 
 import { assert } from "node-opcua-assert";
 import { BinaryStream } from "node-opcua-binary-stream";
@@ -14,6 +13,7 @@ import { getEnumeration, hasEnumeration } from "./factories_enumerations";
 import { getStructuredTypeSchema, getStructureTypeConstructor, hasStructuredType } from "./factories_factories";
 import { parameters } from "./factories_schema_helpers";
 import { DataTypeFactory } from "./datatype_factory";
+import { CommonInterface, FieldCategory, FieldInterfaceOptions, FieldType, StructuredTypeOptions, TypeSchemaBase } from "./types";
 
 function figureOutFieldCategory(field: FieldInterfaceOptions): FieldCategory {
     const fieldType = field.fieldType;
@@ -165,7 +165,7 @@ export class StructuredTypeSchema extends TypeSchemaBase {
         this._possibleFields = this.fields.map((field) => field.name);
         this._baseSchema = null;
     }
-    public toString() {
+    public toString(): string {
         const str: string[] = [];
         str.push("name           = " + this.name);
         str.push("baseType       = " + this.baseType);
@@ -199,7 +199,7 @@ export class StructuredTypeSchema extends TypeSchemaBase {
  * @return {*}
  *
  */
-export function get_base_schema(schema: StructuredTypeSchema) {
+export function get_base_schema(schema: StructuredTypeSchema): StructuredTypeSchema | null {
     let baseSchema = schema._baseSchema;
     if (baseSchema) {
         return baseSchema;
@@ -234,10 +234,9 @@ export function get_base_schema(schema: StructuredTypeSchema) {
 /**
  * extract a list of all possible fields for a schema
  * (by walking up the inheritance chain)
- * @method extract_all_fields
  *
  */
-export function extract_all_fields(schema: StructuredTypeSchema) {
+export function extract_all_fields(schema: StructuredTypeSchema): string[] {
     // returns cached result if any
     // istanbul ignore next
     if (schema._possibleFields) {

package/source/index.ts

@@ -1,15 +1,15 @@
-/**
- * @module node-opcua-factory
- */
-export * from "./constructor_type";
-export * from "./datatype_factory";
-export * from "./factories_id_generator";
-export * from "./factories_enumerations";
-export * from "./factories_basic_type";
-export * from "./factories_builtin_types";
-export * from "./factories_builtin_types_special";
-export * from "./factories_baseobject";
-export * from "./types";
-export * from "./factories_schema_helpers";
-export * from "./factories_factories";
-export * from "./factories_structuredTypeSchema";
+/**
+ * @module node-opcua-factory
+ */
+export * from "./constructor_type";
+export * from "./datatype_factory";
+export * from "./factories_id_generator";
+export * from "./factories_enumerations";
+export * from "./factories_basic_type";
+export * from "./factories_builtin_types";
+export * from "./factories_builtin_types_special";
+export * from "./factories_baseobject";
+export * from "./types";
+export * from "./factories_schema_helpers";
+export * from "./factories_factories";
+export * from "./factories_structuredTypeSchema";

package/source/types.ts

@@ -125,12 +125,6 @@ export interface EnumerationDefinition extends CommonInterface {
 
 export type TypeDefinition = BuiltInTypeDefinition | EnumerationDefinition | BasicTypeDefinition | TypeSchemaBase;
 
-// tslint:disable-next-line:no-empty
-function defaultEncode(value: any, stream: BinaryStream): void {}
-
-// tslint:disable-next-line:no-empty
-function defaultDecode(stream: BinaryStream): void {}
-
 /**
  * @class TypeSchemaBase
  * @param options {Object}
@@ -166,7 +160,7 @@ export class TypeSchemaBase implements CommonInterface {
      * @param defaultValue {*} the default value
      * @return {*}
      */
-    public computer_default_value(defaultValue: any): any {
+    public computer_default_value(defaultValue: unknown): any {
         if (defaultValue === undefined) {
             defaultValue = this.defaultValue;
         }