node-opcua-factory 2.78.0 → 2.81.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-factory",
-    "version": "2.78.0",
+    "version": "2.81.0",
     "description": "pure nodejs OPCUA SDK - module -factory",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
@@ -17,13 +17,13 @@
     "dependencies": {
         "chalk": "4.1.2",
         "node-opcua-assert": "2.77.0",
-        "node-opcua-basic-types": "2.77.0",
+        "node-opcua-basic-types": "2.81.0",
         "node-opcua-binary-stream": "2.77.0",
         "node-opcua-constants": "2.77.0",
         "node-opcua-debug": "2.77.0",
         "node-opcua-enum": "2.77.0",
-        "node-opcua-guid": "2.77.0",
-        "node-opcua-nodeid": "2.77.0",
+        "node-opcua-guid": "2.81.0",
+        "node-opcua-nodeid": "2.81.0",
         "node-opcua-status-code": "2.77.0",
         "node-opcua-utils": "2.77.0"
     },
@@ -42,5 +42,5 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "31c6eee3c51f52427584364fff2fdb07bbac65be"
+    "gitHead": "fd89928bc4a4b9f31a6b6e5921f743e8284eba2b"
 }

package/dist/constructor_type.d.ts

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

package/dist/constructor_type.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=constructor_type.js.map

package/dist/constructor_type.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constructor_type.js","sourceRoot":"","sources":["../source/constructor_type.ts"],"names":[],"mappings":""}

package/dist/factories_baseobject.d.ts

@@ -1,56 +0,0 @@
-import { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";
-import { StructuredTypeSchema } from "./factories_structuredTypeSchema";
-export interface DecodeDebugOptions {
-    tracer: any;
-    name: string;
-}
-export interface BaseUAObject {
-    schema: StructuredTypeSchema;
-}
-/**
- * @class BaseUAObject
- * @constructor
- */
-export declare class BaseUAObject {
-    constructor();
-    /**
-     * Encode the object to the binary stream.
-     * @class BaseUAObject
-     * @method encode
-     * @param stream {BinaryStream}
-     */
-    encode(stream: OutputBinaryStream): void;
-    /**
-     * Decode the object from the binary stream.
-     * @class BaseUAObject
-     * @method decode
-     * @param stream {BinaryStream}
-     */
-    decode(stream: BinaryStream): void;
-    /**
-     * Calculate the required size to store this object in a binary stream.
-     * @method binaryStoreSize
-     * @return number
-     */
-    binaryStoreSize(): number;
-    /**
-     * @method toString
-     * @return {String}
-     */
-    toString(...args: any[]): string;
-    /**
-     *
-     * verify that all object attributes values are valid according to schema
-     * @method isValid
-     * @return boolean
-     */
-    isValid(): boolean;
-    /**
-     * @method decodeDebug
-     *
-     */
-    decodeDebug(stream: BinaryStream, options: DecodeDebugOptions): void;
-    explore(): string;
-    toJSON(): any;
-    clone(): any;
-}

package/dist/factories_baseobject.js

@@ -1,535 +0,0 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseUAObject = void 0;
-/* eslint-disable prefer-rest-params */
-/* eslint-disable complexity */
-/**
- * @module node-opcua-factory
- */
-// tslint:disable:no-shadowed-variable
-const chalk = require("chalk");
-const node_opcua_assert_1 = require("node-opcua-assert");
-const node_opcua_basic_types_1 = require("node-opcua-basic-types");
-const node_opcua_binary_stream_1 = require("node-opcua-binary-stream");
-const node_opcua_debug_1 = require("node-opcua-debug");
-const node_opcua_nodeid_1 = require("node-opcua-nodeid");
-const utils = require("node-opcua-utils");
-const factories_builtin_types_1 = require("./factories_builtin_types");
-const factories_enumerations_1 = require("./factories_enumerations");
-const factories_factories_1 = require("./factories_factories");
-const factories_structuredTypeSchema_1 = require("./factories_structuredTypeSchema");
-const types_1 = require("./types");
-function r(str, length = 30) {
-    return (str + "                                ").substring(0, length);
-}
-function _decode_member_(value, field, stream, options) {
-    const tracer = options.tracer;
-    const cursorBefore = stream.length;
-    const fieldType = field.fieldType;
-    switch (field.category) {
-        case types_1.FieldCategory.basic:
-            if (field.schema.decode) {
-                value = field.schema.decode(stream);
-            }
-            tracer.trace("member", options.name, value, cursorBefore, stream.length, fieldType);
-            break;
-        case types_1.FieldCategory.enumeration:
-            if (field.schema.decode) {
-                value = field.schema.decode(stream);
-            }
-            tracer.trace("member", options.name, value, cursorBefore, stream.length, fieldType);
-            break;
-        case types_1.FieldCategory.complex: {
-            (0, node_opcua_assert_1.assert)(field.category === types_1.FieldCategory.complex);
-            if (!field.fieldTypeConstructor) {
-                field.fieldTypeConstructor = (0, factories_factories_1.getStructureTypeConstructor)(field.fieldType);
-            }
-            if (typeof field.fieldTypeConstructor !== "function") {
-                throw new Error("Cannot find constructor for  " + field.name + "of type " + field.fieldType);
-            }
-            // assert(typeof field.fieldTypeConstructor === "function");
-            const constructor = field.fieldTypeConstructor;
-            value = new constructor();
-            value.decodeDebug(stream, options);
-        }
-    }
-    return value;
-}
-function applyOnAllSchemaFields(self, schema, data, functor, args) {
-    const baseSchema = (0, factories_structuredTypeSchema_1.get_base_schema)(schema);
-    if (baseSchema) {
-        applyOnAllSchemaFields(self, baseSchema, data, functor, args);
-    }
-    for (const field of schema.fields) {
-        functor(self, field, data, args);
-    }
-}
-const _nbElements = typeof process === "object" ? (process.env.ARRAYLENGTH ? parseInt(process.env.ARRAYLENGTH, 10) : 10) : 10;
-const fullBuffer = typeof process === "object" ? !!((_a = process.env) === null || _a === void 0 ? void 0 : _a.FULLBUFFER) : false;
-function _arrayEllipsis(value, data) {
-    if (!value) {
-        return "null []";
-    }
-    else {
-        if (value.length === 0) {
-            return "[ /* empty*/ ]";
-        }
-        (0, node_opcua_assert_1.assert)(Array.isArray(value));
-        const v = [];
-        const m = Math.min(_nbElements, value.length);
-        const ellipsis = value.length > _nbElements ? " ... " : "";
-        const pad = data.padding + "  ";
-        let isMultiLine = true;
-        for (let i = 0; i < m; i++) {
-            let element = value[i];
-            if (element instanceof Buffer) {
-                element = (0, node_opcua_debug_1.hexDump)(element, 32, 16);
-            }
-            else if (utils.isNullOrUndefined(element)) {
-                element = "null";
-            }
-            else {
-                element = element.toString();
-                const s = element.split("\n");
-                if (s.length > 1) {
-                    element = "\n" + pad + s.join("\n" + pad);
-                    isMultiLine = true;
-                }
-            }
-            if (element.length > 80) {
-                isMultiLine = true;
-            }
-            v.push(element);
-        }
-        const length = "/* length =" + value.length + "*/";
-        if (isMultiLine) {
-            return "[ " + length + "\n" + pad + v.join(",\n" + pad + "    ") + ellipsis + "\n" + data.padding + "]";
-        }
-        else {
-            return "[ " + length + v.join(",") + ellipsis + "]";
-        }
-    }
-}
-// eslint-disable-next-line complexity
-// eslint-disable-next-line max-statements
-function _exploreObject(self, field, data, args) {
-    if (!self) {
-        return;
-    }
-    (0, node_opcua_assert_1.assert)(self);
-    const fieldType = field.fieldType;
-    const fieldName = field.name;
-    const category = field.category;
-    const padding = data.padding;
-    let value = self[fieldName];
-    let str;
-    // decorate the field name with ?# if the field is optional
-    let opt = "    ";
-    if (field.switchBit !== undefined) {
-        opt = " ?" + field.switchBit + " ";
-    }
-    if (field.switchValue !== undefined) {
-        opt = " !" + field.switchValue + " ";
-    }
-    const fieldNameF = chalk.yellow(r(padding + fieldName, 30));
-    const fieldTypeF = chalk.cyan("/* " + r(fieldType + opt, 17) + (field.isArray ? "[]" : "  ") + " */");
-    // detected when optional field is not specified in value
-    if (field.switchBit !== undefined && value === undefined) {
-        str = fieldNameF + " " + fieldTypeF + ": " + chalk.italic.grey("undefined") + " /* optional field not specified */";
-        data.lines.push(str);
-        return;
-    }
-    // detected when union field is not specified in value
-    if (field.switchValue !== undefined && value === undefined) {
-        str = fieldNameF + " " + fieldTypeF + ": " + chalk.italic.grey("undefined") + " /* union field not specified */";
-        data.lines.push(str);
-        return;
-    }
-    // compact version of very usual objects
-    if (fieldType === "QualifiedName" && !field.isArray && value) {
-        value = value.toString() || "<null>";
-        str = fieldNameF + " " + fieldTypeF + ": " + chalk.green(value.toString());
-        data.lines.push(str);
-        return;
-    }
-    if (fieldType === "LocalizedText" && !field.isArray && value) {
-        value = value.toString() || "<null>";
-        str = fieldNameF + " " + fieldTypeF + ": " + chalk.green(value.toString());
-        data.lines.push(str);
-        return;
-    }
-    if (fieldType === "DataValue" && !field.isArray && value) {
-        value = value.toString(data);
-        str = fieldNameF + " " + fieldTypeF + ": " + chalk.green(value.toString(data));
-        data.lines.push(str);
-        return;
-    }
-    function _dump_enumeration_value(self, field, data, value, fieldType) {
-        const s = field.schema;
-        // istanbul ignore next
-        if (!s.typedEnum) {
-            // tslint:disable:no-console
-            console.log("xxxx cannot find typeEnum", s);
-        }
-        const convert = (value) => {
-            // istanbul ignore next
-            if (!s.typedEnum.get(value)) {
-                return [value, s.typedEnum.get(value)];
-            }
-            else {
-                return [value, s.typedEnum.get(value).key];
-            }
-        };
-        const toS = ([n, s]) => `${n} /*(${s})*/`;
-        if (field.isArray) {
-            str =
-                fieldNameF +
-                    " " +
-                    fieldTypeF +
-                    ": [" +
-                    value
-                        .map((c) => convert(c))
-                        .map(toS)
-                        .join(", ") +
-                    "]";
-            data.lines.push(str);
-        }
-        else {
-            const c = convert(value);
-            str = `${fieldNameF} ${fieldTypeF}: ${toS(c)}`;
-            data.lines.push(str);
-        }
-    }
-    function _dump_simple_value(self, field, data, value, fieldType) {
-        let str = "";
-        if (value instanceof Buffer) {
-            data.lines.push(fieldNameF + " " + fieldTypeF);
-            if (fullBuffer || value.length <= 32) {
-                const _hexDump = value.length <= 32 ? "Ox" + value.toString("hex") : "\n" + (0, node_opcua_debug_1.hexDump)(value);
-                data.lines.push("Buffer: " + _hexDump);
-            }
-            else {
-                const _hexDump1 = value.slice(0, 16).toString("hex");
-                const _hexDump2 = value.slice(-16).toString("hex");
-                data.lines.push("Buffer: ", _hexDump1 + "..." + _hexDump2);
-            }
-        }
-        else {
-            if (field.isArray) {
-                str = fieldNameF + " " + fieldTypeF + ": " + _arrayEllipsis(value, data);
-            }
-            else {
-                if (field.fieldType === "NodeId" && value instanceof node_opcua_nodeid_1.NodeId) {
-                    value = value.displayText();
-                }
-                else if (fieldType === "IntegerId" || fieldType === "UInt32") {
-                    if (field.name === "attributeId") {
-                        value = "AttributeIds." + node_opcua_basic_types_1.AttributeIds[value] + "/* " + value + " */";
-                    }
-                    else {
-                        const extra = value !== undefined ? "0x" + value.toString(16) : "undefined";
-                        value = "" + value + "               " + extra;
-                    }
-                }
-                else if (fieldType === "DateTime" || fieldType === "UtcTime") {
-                    try {
-                        value = value && value.toISOString ? value.toISOString() : value;
-                    }
-                    catch (_a) {
-                        value = chalk.red((value === null || value === void 0 ? void 0 : value.toString()) + " *** ERROR ***");
-                    }
-                }
-                else if (typeof value === "object" && value !== null && value !== undefined) {
-                    // eslint-disable-next-line prefer-spread
-                    value = value.toString.apply(value, args);
-                }
-                str =
-                    fieldNameF +
-                        " " +
-                        fieldTypeF +
-                        ": " +
-                        (value === null || value === undefined ? chalk.blue("null") : value.toString());
-            }
-            data.lines.push(str);
-        }
-    }
-    function _dump_complex_value(self, field, data, value, fieldType) {
-        if (field.subType) {
-            // this is a synonymous
-            fieldType = field.subType;
-            _dump_simple_value(self, field, data, value, fieldType);
-        }
-        else {
-            const typeDictionary = self.schema.$$factory;
-            // istanbul ignore next
-            if (!typeDictionary) {
-                // tslint:disable-next-line: no-console
-                console.log(" No typeDictionary for ", self.schema);
-                return;
-            }
-            field.fieldTypeConstructor = field.fieldTypeConstructor || typeDictionary.getStructureTypeConstructor(fieldType);
-            const fieldTypeConstructor = field.fieldTypeConstructor;
-            const _newFieldSchema = field.schema ||
-                fieldTypeConstructor.prototype.schema ||
-                fieldTypeConstructor.schema;
-            if (field.isArray) {
-                if (value === null) {
-                    data.lines.push(fieldNameF + " " + fieldTypeF + ": null []");
-                }
-                else if (value.length === 0) {
-                    data.lines.push(fieldNameF + " " + fieldTypeF + ": [ /* empty */ ]");
-                }
-                else {
-                    data.lines.push(fieldNameF + " " + fieldTypeF + ": [");
-                    const m = Math.min(_nbElements, value.length);
-                    for (let i = 0; i < m; i++) {
-                        const element = value[i];
-                        data.lines.push(padding + chalk.cyan("  { " + ("/*" + i + "*/")));
-                        const data1 = {
-                            lines: [],
-                            padding: padding + "    "
-                        };
-                        applyOnAllSchemaFields(element, _newFieldSchema, data1, _exploreObject, args);
-                        data.lines = data.lines.concat(data1.lines);
-                        data.lines.push(padding + "  }" + (i === value.length - 1 ? "" : ","));
-                    }
-                    if (m < value.length) {
-                        data.lines.push(padding + " ..... ( " + value.length + " elements )");
-                    }
-                    data.lines.push(padding + "]");
-                }
-            }
-            else {
-                data.lines.push(fieldNameF + " " + fieldTypeF + ": {");
-                const data1 = { padding: padding + "  ", lines: [] };
-                applyOnAllSchemaFields(value, _newFieldSchema, data1, _exploreObject, args);
-                data.lines = data.lines.concat(data1.lines);
-                data.lines.push(padding + "}");
-            }
-        }
-    }
-    switch (category) {
-        case types_1.FieldCategory.enumeration:
-            _dump_enumeration_value(self, field, data, value, fieldType);
-            break;
-        case types_1.FieldCategory.basic:
-            _dump_simple_value(self, field, data, value, fieldType);
-            break;
-        case types_1.FieldCategory.complex:
-            _dump_complex_value(self, field, data, value, fieldType);
-            break;
-        default:
-            throw new Error("internal error: unknown kind_of_field " + category);
-    }
-}
-function json_ify(t, value, fieldType) {
-    if (value instanceof Array) {
-        return value.map((e) => (e && e.toJSON ? e.toJSON() : e));
-    }
-    /*
-    if (typeof fieldType.toJSON === "function") {
-        return fieldType.toJSON(value);
-    } else
-    */
-    if (t && t.toJSON) {
-        return t.toJSON(value);
-    }
-    else if (value.toJSON) {
-        return value.toJSON();
-    }
-    else {
-        return value;
-    }
-}
-function _JSONify(self, schema, pojo) {
-    /* jshint validthis: true */
-    for (const field of schema.fields) {
-        const fieldValue = self[field.name];
-        if (fieldValue === null || fieldValue === undefined) {
-            continue;
-        }
-        if ((0, factories_enumerations_1.hasEnumeration)(field.fieldType)) {
-            const enumeration = (0, factories_enumerations_1.getEnumeration)(field.fieldType);
-            (0, node_opcua_assert_1.assert)(enumeration !== null);
-            if (field.isArray) {
-                pojo[field.name] = fieldValue.map((value) => enumeration.enumValues[value.toString()]);
-            }
-            else {
-                pojo[field.name] = enumeration.enumValues[fieldValue.toString()];
-            }
-            continue;
-        }
-        const t = (0, factories_builtin_types_1.getBuildInType)(field.fieldType);
-        if (field.isArray) {
-            pojo[field.name] = fieldValue.map((value) => json_ify(t, value, field));
-        }
-        else {
-            pojo[field.name] = json_ify(t, fieldValue, field);
-        }
-    }
-}
-/**
- * @class BaseUAObject
- * @constructor
- */
-class BaseUAObject {
-    constructor() {
-        /**  */
-    }
-    /**
-     * Encode the object to the binary stream.
-     * @class BaseUAObject
-     * @method encode
-     * @param stream {BinaryStream}
-     */
-    encode(stream) {
-        /** */
-    }
-    /**
-     * Decode the object from the binary stream.
-     * @class BaseUAObject
-     * @method decode
-     * @param stream {BinaryStream}
-     */
-    decode(stream) {
-        /** */
-    }
-    /**
-     * Calculate the required size to store this object in a binary stream.
-     * @method binaryStoreSize
-     * @return number
-     */
-    binaryStoreSize() {
-        const stream = new node_opcua_binary_stream_1.BinaryStreamSizeCalculator();
-        this.encode(stream);
-        return stream.length;
-    }
-    /**
-     * @method toString
-     * @return {String}
-     */
-    toString(...args) {
-        if (this.schema && Object.prototype.hasOwnProperty.call(this.schema, "toString")) {
-            return this.schema.toString.apply(this, arguments);
-        }
-        else {
-            if (!this.explore) {
-                // xx console.log(util.inspect(this));
-                return Object.prototype.toString.apply(this, arguments);
-            }
-            return this.explore();
-        }
-    }
-    /**
-     *
-     * verify that all object attributes values are valid according to schema
-     * @method isValid
-     * @return boolean
-     */
-    isValid() {
-        (0, node_opcua_assert_1.assert)(this.schema);
-        if (this.schema.isValid) {
-            return this.schema.isValid(this);
-        }
-        else {
-            return true;
-        }
-    }
-    /**
-     * @method decodeDebug
-     *
-     */
-    decodeDebug(stream, options) {
-        const tracer = options.tracer;
-        const schema = this.schema;
-        tracer.trace("start", options.name + "(" + schema.name + ")", stream.length, stream.length);
-        const self = this;
-        for (const field of schema.fields) {
-            const value = self[field.name];
-            if (typeof field.switchValue === "number") {
-                // skip
-                if (self["switchField"] !== field.switchValue) {
-                    continue;
-                }
-            }
-            if (field.isArray) {
-                const cursorBefore = stream.length;
-                let nb = stream.readUInt32();
-                if (nb === 0xffffffff) {
-                    nb = 0;
-                }
-                options.name = field.name + [];
-                tracer.trace("start_array", field.name, nb, cursorBefore, stream.length);
-                for (let i = 0; i < nb; i++) {
-                    tracer.trace("start_element", field.name, i);
-                    options.name = "element #" + i;
-                    _decode_member_(value, field, stream, options);
-                    tracer.trace("end_element", field.name, i);
-                }
-                tracer.trace("end_array", field.name, stream.length - 4);
-            }
-            else {
-                options.name = field.name;
-                _decode_member_(value, field, stream, options);
-            }
-        }
-        tracer.trace("end", schema.name, stream.length, stream.length);
-    }
-    explore() {
-        const data = {
-            lines: [],
-            padding: " "
-        };
-        data.lines.push("{" + chalk.cyan(" /*" + (this.schema ? this.schema.name : "") + "*/"));
-        if (this.schema) {
-            applyOnAllSchemaFields(this, this.schema, data, _exploreObject, arguments);
-        }
-        data.lines.push("};");
-        return data.lines.join("\n");
-    }
-    toJSON() {
-        (0, node_opcua_assert_1.assert)(this.schema);
-        if (this.schema.toJSON) {
-            return this.schema.toJSON.apply(this, arguments);
-        }
-        else {
-            (0, node_opcua_assert_1.assert)(this.schema);
-            const schema = this.schema;
-            const pojo = {};
-            _visitSchemaChain(this, schema, pojo, _JSONify, null);
-            return pojo;
-        }
-    }
-    clone( /*options,optionalFilter,extraInfo*/) {
-        const self = this;
-        const params = {};
-        function construct_param(schema, options) {
-            for (const field of schema.fields) {
-                const f = self[field.name];
-                if (f === null || f === undefined) {
-                    continue;
-                }
-                if (field.isArray) {
-                    options[field.name] = self[field.name];
-                }
-                else {
-                    options[field.name] = self[field.name];
-                }
-            }
-        }
-        construct_param.call(this, self.schema, params);
-        return new self.constructor(params);
-    }
-}
-exports.BaseUAObject = BaseUAObject;
-function _visitSchemaChain(self, schema, pojo, func, extraData) {
-    (0, node_opcua_assert_1.assert)(typeof func === "function");
-    // apply also construct to baseType schema first
-    const baseSchema = (0, factories_structuredTypeSchema_1.get_base_schema)(schema);
-    if (baseSchema) {
-        _visitSchemaChain(self, baseSchema, pojo, func, extraData);
-    }
-    func.call(null, self, schema, pojo);
-}
-//# sourceMappingURL=factories_baseobject.js.map