node-opcua-factory 2.71.0 → 2.72.1

package/dist/factories_schema_helpers.js

@@ -1,122 +1,122 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initialize_field_array = exports.initialize_field = exports.check_schema_correctness = exports.parameters = void 0;
-/**
- * @module node-opcua-factory
- */
-const node_opcua_assert_1 = require("node-opcua-assert");
-const node_opcua_debug_1 = require("node-opcua-debug");
-const types_1 = require("./types");
-const debugLog = (0, node_opcua_debug_1.make_debugLog)(__filename);
-exports.parameters = {
-    debugSchemaHelper: (typeof process === "object" && !!process.env.DEBUG_CLASS)
-};
-/**
- * ensure correctness of a schema object.
- *
- * @method check_schema_correctness
- * @param schema
- *
- */
-function check_schema_correctness(schema) {
-    (0, node_opcua_assert_1.assert)(typeof schema.name === "string", " expecting schema to have a name");
-    (0, node_opcua_assert_1.assert)(schema.fields instanceof Array, " expecting schema to provide a set of fields " + schema.name);
-    (0, node_opcua_assert_1.assert)(schema.baseType === undefined || typeof schema.baseType === "string");
-}
-exports.check_schema_correctness = check_schema_correctness;
-/**
- * @method initialize_value
- * @param value
- * @param defaultValue
- * @return {*}
- */
-function initialize_field(field, value) {
-    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 === types_1.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;
-}
-exports.initialize_field = initialize_field;
-function initialize_value(value, defaultValue, _t) {
-    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
- */
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-function initialize_field_array(field, valueArray) {
-    const _t = field.schema;
-    let value;
-    let i;
-    (0, node_opcua_assert_1.assert)(field !== null && typeof field === "object");
-    (0, node_opcua_assert_1.assert)(field.isArray);
-    if (!valueArray && field.defaultValue === null) {
-        return null;
-    }
-    valueArray = valueArray || [];
-    let defaultValue;
-    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;
-}
-exports.initialize_field_array = initialize_field_array;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialize_field_array = exports.initialize_field = exports.check_schema_correctness = exports.parameters = void 0;
+/**
+ * @module node-opcua-factory
+ */
+const node_opcua_assert_1 = require("node-opcua-assert");
+const node_opcua_debug_1 = require("node-opcua-debug");
+const types_1 = require("./types");
+const debugLog = (0, node_opcua_debug_1.make_debugLog)(__filename);
+exports.parameters = {
+    debugSchemaHelper: (typeof process === "object" && !!process.env.DEBUG_CLASS)
+};
+/**
+ * ensure correctness of a schema object.
+ *
+ * @method check_schema_correctness
+ * @param schema
+ *
+ */
+function check_schema_correctness(schema) {
+    (0, node_opcua_assert_1.assert)(typeof schema.name === "string", " expecting schema to have a name");
+    (0, node_opcua_assert_1.assert)(schema.fields instanceof Array, " expecting schema to provide a set of fields " + schema.name);
+    (0, node_opcua_assert_1.assert)(schema.baseType === undefined || typeof schema.baseType === "string");
+}
+exports.check_schema_correctness = check_schema_correctness;
+/**
+ * @method initialize_value
+ * @param value
+ * @param defaultValue
+ * @return {*}
+ */
+function initialize_field(field, value) {
+    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 === types_1.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;
+}
+exports.initialize_field = initialize_field;
+function initialize_value(value, defaultValue, _t) {
+    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
+ */
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+function initialize_field_array(field, valueArray) {
+    const _t = field.schema;
+    let value;
+    let i;
+    (0, node_opcua_assert_1.assert)(field !== null && typeof field === "object");
+    (0, node_opcua_assert_1.assert)(field.isArray);
+    if (!valueArray && field.defaultValue === null) {
+        return null;
+    }
+    valueArray = valueArray || [];
+    let defaultValue;
+    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;
+}
+exports.initialize_field_array = initialize_field_array;
 //# sourceMappingURL=factories_schema_helpers.js.map

package/dist/factories_structuredTypeSchema.d.ts

@@ -1,45 +1,45 @@
-import { BinaryStream } from "node-opcua-binary-stream";
-import { ExpandedNodeId, NodeId } from "node-opcua-nodeid";
-import { DataTypeFactory } from "./datatype_factory";
-import { FieldType, StructuredTypeOptions, TypeSchemaBase } from "./types";
-export declare class StructuredTypeSchema extends TypeSchemaBase {
-    fields: FieldType[];
-    id: NodeId;
-    dataTypeNodeId: NodeId;
-    baseType: string;
-    _possibleFields: string[];
-    _baseSchema: StructuredTypeSchema | null;
-    documentation?: string;
-    isValid?: (options: any) => boolean;
-    decodeDebug?: (stream: BinaryStream, options: any) => any;
-    constructHook?: (options: any) => any;
-    encodingDefaultBinary?: ExpandedNodeId;
-    encodingDefaultXml?: ExpandedNodeId;
-    encodingDefaultJson?: ExpandedNodeId;
-    bitFields?: any[];
-    constructor(options: StructuredTypeOptions);
-    toString(): string;
-}
-/**
- *
- * @method get_base_schema
- * @param schema
- * @return {*}
- *
- */
-export declare function get_base_schema(schema: StructuredTypeSchema): StructuredTypeSchema | null;
-/**
- * extract a list of all possible fields for a schema
- * (by walking up the inheritance chain)
- *
- */
-export declare function extract_all_fields(schema: StructuredTypeSchema): string[];
-/**
- * check correctness of option fields against scheme
- *
- * @method  check_options_correctness_against_schema
- *
- */
-export declare function check_options_correctness_against_schema(obj: any, schema: StructuredTypeSchema, options: any): boolean;
-export declare function buildStructuredType2(dataTypeFactory: DataTypeFactory, schemaLight: StructuredTypeOptions): StructuredTypeSchema;
-export declare function buildStructuredType(schemaLight: StructuredTypeOptions): StructuredTypeSchema;
+import { BinaryStream } from "node-opcua-binary-stream";
+import { ExpandedNodeId, NodeId } from "node-opcua-nodeid";
+import { DataTypeFactory } from "./datatype_factory";
+import { FieldType, StructuredTypeOptions, TypeSchemaBase } from "./types";
+export declare class StructuredTypeSchema extends TypeSchemaBase {
+    fields: FieldType[];
+    id: NodeId;
+    dataTypeNodeId: NodeId;
+    baseType: string;
+    _possibleFields: string[];
+    _baseSchema: StructuredTypeSchema | null;
+    documentation?: string;
+    isValid?: (options: any) => boolean;
+    decodeDebug?: (stream: BinaryStream, options: any) => any;
+    constructHook?: (options: any) => any;
+    encodingDefaultBinary?: ExpandedNodeId;
+    encodingDefaultXml?: ExpandedNodeId;
+    encodingDefaultJson?: ExpandedNodeId;
+    bitFields?: any[];
+    constructor(options: StructuredTypeOptions);
+    toString(): string;
+}
+/**
+ *
+ * @method get_base_schema
+ * @param schema
+ * @return {*}
+ *
+ */
+export declare function get_base_schema(schema: StructuredTypeSchema): StructuredTypeSchema | null;
+/**
+ * extract a list of all possible fields for a schema
+ * (by walking up the inheritance chain)
+ *
+ */
+export declare function extract_all_fields(schema: StructuredTypeSchema): string[];
+/**
+ * check correctness of option fields against scheme
+ *
+ * @method  check_options_correctness_against_schema
+ *
+ */
+export declare function check_options_correctness_against_schema(obj: any, schema: StructuredTypeSchema, options: any): boolean;
+export declare function buildStructuredType2(dataTypeFactory: DataTypeFactory, schemaLight: StructuredTypeOptions): StructuredTypeSchema;
+export declare function buildStructuredType(schemaLight: StructuredTypeOptions): StructuredTypeSchema;