node-opcua-factory 2.64.1 → 2.68.0

package/dist/types.d.ts

@@ -1,111 +1,110 @@
-import { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";
-import { Enum } from "node-opcua-enum";
-import { NodeId } from "node-opcua-nodeid";
-import { ConstructorFunc } from "./constructor_type";
-export interface CommonInterface {
-    name: string;
-    encode?: (value: any, stream: OutputBinaryStream) => void;
-    decode?: (stream: BinaryStream) => any;
-    coerce?: (value: any) => any;
-    toJSON?: (value: any) => any;
-    random?: () => any;
-    validate?: (value: any) => void;
-    defaultValue?: any;
-    computer_default_value(defaultValue: any): any;
-}
-export declare enum FieldCategory {
-    enumeration = "enumeration",
-    complex = "complex",
-    basic = "basic"
-}
-export interface StructuredTypeField {
-    name: string;
-    fieldType: string;
-    isArray?: boolean;
-    documentation?: string;
-    category: FieldCategory;
-    schema: CommonInterface;
-    fieldTypeConstructor?: ConstructorFunc;
-    subType?: string;
-    defaultValue?: any;
-    validate?: (value: any) => boolean;
-    decode?: (stream: BinaryStream) => any;
-    switchBit?: number;
-    switchValue?: number;
-}
-export interface FieldEnumeration extends StructuredTypeField {
-}
-export interface FieldComplex extends StructuredTypeField {
-}
-export interface FieldBasic extends StructuredTypeField {
-}
-export declare type FieldType = FieldEnumeration | FieldComplex | FieldBasic;
-export declare type DefaultValueFunc = () => any;
-export interface FieldInterfaceOptions {
-    name: string;
-    fieldType: string;
-    isArray?: boolean;
-    documentation?: string;
-    category?: FieldCategory;
-    defaultValue?: any | DefaultValueFunc;
-    schema?: any;
-    switchBit?: number;
-    switchValue?: number;
-}
-export interface StructuredTypeOptions {
-    name: string;
-    id?: number | NodeId;
-    fields: FieldInterfaceOptions[];
-    documentation?: string;
-    baseType: string;
-    _resolved?: boolean;
-    bitFields?: any[];
-    base?: StructuredTypeOptions;
-}
-export interface TypeSchemaConstructorOptions {
-    name: string;
-    category?: FieldCategory;
-    defaultValue?: any;
-    encode?: (value: any, stream: OutputBinaryStream) => void;
-    decode?: (stream: BinaryStream) => any;
-    coerce?: (value: any) => any;
-}
-export interface BasicTypeDefinitionOptions extends TypeSchemaConstructorOptions {
-    subType: string;
-    toJSON?: (value: any) => any;
-    random?: () => any;
-    validate?: (value: any) => void;
-}
-export interface BasicTypeDefinition extends CommonInterface {
-    subType: string;
-}
-export interface BuiltInTypeDefinition extends BasicTypeDefinition {
-}
-export interface EnumerationDefinition extends CommonInterface {
-    enumValues: any;
-    typedEnum: Enum;
-    documentation?: string;
-}
-export declare type TypeDefinition = BuiltInTypeDefinition | EnumerationDefinition | BasicTypeDefinition | TypeSchemaBase;
-/**
- * @class TypeSchemaBase
- * @param options {Object}
- * @constructor
- * create a new type Schema
- */
-export declare class TypeSchemaBase implements CommonInterface {
-    name: string;
-    defaultValue: any;
-    encode?: (value: any, stream: OutputBinaryStream) => void;
-    decode?: (stream: BinaryStream) => any;
-    coerce?: (value: any) => any;
-    toJSON?: () => string;
-    category: FieldCategory;
-    constructor(options: TypeSchemaConstructorOptions);
-    /**
-     * @method  computer_default_value
-     * @param defaultValue {*} the default value
-     * @return {*}
-     */
-    computer_default_value(defaultValue: unknown): any;
-}
+import { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";
+import { Enum } from "node-opcua-enum";
+import { NodeId } from "node-opcua-nodeid";
+import { ConstructorFunc } from "./constructor_type";
+export interface CommonInterface {
+    name: string;
+    encode?: (value: any, stream: OutputBinaryStream) => void;
+    decode?: (stream: BinaryStream) => any;
+    coerce?: (value: any) => any;
+    toJSON?: (value: any) => any;
+    random?: () => any;
+    validate?: (value: any) => void;
+    defaultValue?: any;
+    computer_default_value(defaultValue: any): any;
+}
+export declare enum FieldCategory {
+    enumeration = "enumeration",
+    complex = "complex",
+    basic = "basic"
+}
+export interface StructuredTypeField {
+    name: string;
+    fieldType: string;
+    isArray?: boolean;
+    documentation?: string;
+    category: FieldCategory;
+    schema: CommonInterface;
+    fieldTypeConstructor?: ConstructorFunc;
+    subType?: string;
+    defaultValue?: any;
+    validate?: (value: any) => boolean;
+    decode?: (stream: BinaryStream) => any;
+    switchBit?: number;
+    switchValue?: number;
+}
+export interface FieldEnumeration extends StructuredTypeField {
+}
+export interface FieldComplex extends StructuredTypeField {
+}
+export interface FieldBasic extends StructuredTypeField {
+}
+export declare type FieldType = FieldEnumeration | FieldComplex | FieldBasic;
+export declare type DefaultValueFunc = () => any;
+export interface FieldInterfaceOptions {
+    name: string;
+    fieldType: string;
+    isArray?: boolean;
+    documentation?: string;
+    category?: FieldCategory;
+    defaultValue?: any | DefaultValueFunc;
+    schema?: any;
+    switchBit?: number;
+    switchValue?: number;
+}
+export interface StructuredTypeOptions {
+    name: string;
+    id?: number | NodeId;
+    fields: FieldInterfaceOptions[];
+    documentation?: string;
+    baseType: string;
+    _resolved?: boolean;
+    bitFields?: any[];
+    base?: StructuredTypeOptions;
+}
+export interface TypeSchemaConstructorOptions {
+    name: string;
+    category?: FieldCategory;
+    defaultValue?: any;
+    encode?: (value: any, stream: OutputBinaryStream) => void;
+    decode?: (stream: BinaryStream) => any;
+    coerce?: (value: any) => any;
+}
+export interface BasicTypeDefinitionOptions extends TypeSchemaConstructorOptions {
+    subType: string;
+    toJSON?: (value: any) => any;
+    random?: () => any;
+    validate?: (value: any) => void;
+}
+export interface BasicTypeDefinition extends CommonInterface {
+    subType: string;
+}
+export interface BuiltInTypeDefinition extends BasicTypeDefinition {
+}
+export interface EnumerationDefinition extends CommonInterface {
+    typedEnum: Enum;
+    documentation?: string;
+}
+export declare type TypeDefinition = BuiltInTypeDefinition | EnumerationDefinition | BasicTypeDefinition | TypeSchemaBase;
+/**
+ * @class TypeSchemaBase
+ * @param options {Object}
+ * @constructor
+ * create a new type Schema
+ */
+export declare class TypeSchemaBase implements CommonInterface {
+    name: string;
+    defaultValue: any;
+    encode?: (value: any, stream: OutputBinaryStream) => void;
+    decode?: (stream: BinaryStream) => any;
+    coerce?: (value: any) => any;
+    toJSON?: () => string;
+    category: FieldCategory;
+    constructor(options: TypeSchemaConstructorOptions);
+    /**
+     * @method  computer_default_value
+     * @param defaultValue {*} the default value
+     * @return {*}
+     */
+    computer_default_value(defaultValue: unknown): any;
+}

package/dist/types.js

@@ -1,52 +1,52 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeSchemaBase = exports.FieldCategory = void 0;
-/**
- * @module node-opcua-factory
- */
-const node_opcua_assert_1 = require("node-opcua-assert");
-var FieldCategory;
-(function (FieldCategory) {
-    FieldCategory["enumeration"] = "enumeration";
-    FieldCategory["complex"] = "complex";
-    FieldCategory["basic"] = "basic";
-})(FieldCategory = exports.FieldCategory || (exports.FieldCategory = {}));
-/**
- * @class TypeSchemaBase
- * @param options {Object}
- * @constructor
- * create a new type Schema
- */
-class TypeSchemaBase {
-    constructor(options) {
-        (0, node_opcua_assert_1.assert)(options.category !== null);
-        this.encode = options.encode || undefined;
-        this.decode = options.decode || undefined;
-        this.coerce = options.coerce;
-        this.category = options.category || FieldCategory.basic;
-        this.name = options.name;
-        for (const prop in options) {
-            if (Object.prototype.hasOwnProperty.call(options, prop)) {
-                this[prop] = options[prop];
-            }
-        }
-    }
-    /**
-     * @method  computer_default_value
-     * @param defaultValue {*} the default value
-     * @return {*}
-     */
-    computer_default_value(defaultValue) {
-        if (defaultValue === undefined) {
-            defaultValue = this.defaultValue;
-        }
-        if (typeof defaultValue === "function") {
-            // be careful not to cache this value , it must be call each time to make sure
-            // we do not end up with the same value/instance twice.
-            defaultValue = defaultValue();
-        }
-        return defaultValue;
-    }
-}
-exports.TypeSchemaBase = TypeSchemaBase;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeSchemaBase = exports.FieldCategory = void 0;
+/**
+ * @module node-opcua-factory
+ */
+const node_opcua_assert_1 = require("node-opcua-assert");
+var FieldCategory;
+(function (FieldCategory) {
+    FieldCategory["enumeration"] = "enumeration";
+    FieldCategory["complex"] = "complex";
+    FieldCategory["basic"] = "basic";
+})(FieldCategory = exports.FieldCategory || (exports.FieldCategory = {}));
+/**
+ * @class TypeSchemaBase
+ * @param options {Object}
+ * @constructor
+ * create a new type Schema
+ */
+class TypeSchemaBase {
+    constructor(options) {
+        (0, node_opcua_assert_1.assert)(options.category !== null);
+        this.encode = options.encode || undefined;
+        this.decode = options.decode || undefined;
+        this.coerce = options.coerce;
+        this.category = options.category || FieldCategory.basic;
+        this.name = options.name;
+        for (const prop in options) {
+            if (Object.prototype.hasOwnProperty.call(options, prop)) {
+                this[prop] = options[prop];
+            }
+        }
+    }
+    /**
+     * @method  computer_default_value
+     * @param defaultValue {*} the default value
+     * @return {*}
+     */
+    computer_default_value(defaultValue) {
+        if (defaultValue === undefined) {
+            defaultValue = this.defaultValue;
+        }
+        if (typeof defaultValue === "function") {
+            // be careful not to cache this value , it must be call each time to make sure
+            // we do not end up with the same value/instance twice.
+            defaultValue = defaultValue();
+        }
+        return defaultValue;
+    }
+}
+exports.TypeSchemaBase = TypeSchemaBase;
 //# sourceMappingURL=types.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-factory",
-    "version": "2.64.1",
+    "version": "2.68.0",
     "description": "pure nodejs OPCUA SDK - module -factory",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
@@ -8,20 +8,20 @@
         "build": "tsc -b",
         "lint": "eslint source",
         "format": "prettier --write source",
-        "clean": "node -e \"require('rimraf').sync('dist');\"",
+        "clean": "npx rimraf dist *.tsbuildinfo",
         "test": "echo no test"
     },
     "dependencies": {
         "chalk": "4.1.2",
-        "node-opcua-assert": "2.64.1",
-        "node-opcua-basic-types": "2.64.1",
-        "node-opcua-binary-stream": "2.64.1",
-        "node-opcua-debug": "2.64.1",
-        "node-opcua-enum": "2.64.1",
-        "node-opcua-guid": "2.64.1",
-        "node-opcua-nodeid": "2.64.1",
-        "node-opcua-status-code": "2.64.1",
-        "node-opcua-utils": "2.64.1"
+        "node-opcua-assert": "2.66.0",
+        "node-opcua-basic-types": "2.68.0",
+        "node-opcua-binary-stream": "2.67.0",
+        "node-opcua-debug": "2.68.0",
+        "node-opcua-enum": "2.67.0",
+        "node-opcua-guid": "2.66.0",
+        "node-opcua-nodeid": "2.68.0",
+        "node-opcua-status-code": "2.67.0",
+        "node-opcua-utils": "2.67.0"
     },
     "author": "Etienne Rossignon",
     "license": "MIT",
@@ -38,5 +38,5 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "b65b8738603cd475d7d99a2b20b0ae9d32b4110c"
+    "gitHead": "363b466440d0910acddd0cde2c37792ce4724d76"
 }

package/source/factories_baseobject.ts

@@ -20,7 +20,7 @@ import { get_base_schema, StructuredTypeSchema } from "./factories_structuredTyp
 import { EnumerationDefinition, FieldCategory, StructuredTypeField, BuiltInTypeDefinition, FieldType } from "./types";
 
 function r(str: string, length = 30) {
-    return (str + "                                ").substr(0, length);
+    return (str + "                                ").substring(0, length);
 }
 
 function _decode_member_(value: any, field: StructuredTypeField, stream: BinaryStream, options: DecodeDebugOptions) {
@@ -73,8 +73,8 @@ function applyOnAllSchemaFields(self: BaseUAObject, schema: StructuredTypeSchema
     }
 }
 
-const _nbElements = (typeof process === "object") ? (process.env.ARRAYLENGTH ? parseInt(process.env.ARRAYLENGTH, 10) : 10) : 10;
-const fullBuffer = (typeof process === "object") ? !!(process.env?.FULLBUFFER) : false;
+const _nbElements = typeof process === "object" ? (process.env.ARRAYLENGTH ? parseInt(process.env.ARRAYLENGTH, 10) : 10) : 10;
+const fullBuffer = typeof process === "object" ? !!process.env?.FULLBUFFER : false;
 
 function _arrayEllipsis(value: any[] | null, data: ExploreParams): string {
     if (!value) {
@@ -190,6 +190,48 @@ function _exploreObject(self: BaseUAObject, field: StructuredTypeField, data: Ex
         return;
     }
 
+    function _dump_enumeration_value(
+        self: BaseUAObject,
+        field: StructuredTypeField,
+        data: ExploreParams,
+        value: any,
+        fieldType: string
+    ) {
+        const s = field.schema as EnumerationDefinition;
+
+        // istanbul ignore next
+        if (!s.typedEnum) {
+            // tslint:disable:no-console
+            console.log("xxxx cannot find typeEnum", s);
+        }
+        const convert = (value: number) => {
+            // istanbul ignore next
+            if (!s.typedEnum.get(value)) {
+                return [value, s.typedEnum.get(value)] as [number, any];
+            } else {
+                return [value, s.typedEnum.get(value)!.key] as [number, any];
+            }
+        };
+        const toS = ([n, s]: [number, any]) => `${n} /*(${s})*/`;
+        if (field.isArray) {
+            str =
+                fieldNameF +
+                " " +
+                fieldTypeF +
+                ": [" +
+                value
+                    .map((c: number) => 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: BaseUAObject,
         field: StructuredTypeField,
@@ -222,7 +264,11 @@ function _exploreObject(self: BaseUAObject, field: StructuredTypeField, data: Ex
                         value = "" + value + "               " + extra;
                     }
                 } else if (fieldType === "DateTime" || fieldType === "UtcTime") {
-                    value = value && value.toISOString ? value.toISOString() : value;
+                    try {
+                        value = value && value.toISOString ? value.toISOString() : value;
+                    } catch {
+                        value = chalk.red(value?.toString() + " *** ERROR ***");
+                    }
                 } else if (typeof value === "object" && value !== null && value !== undefined) {
                     // eslint-disable-next-line prefer-spread
                     value = value.toString.apply(value, args);
@@ -306,26 +352,7 @@ function _exploreObject(self: BaseUAObject, field: StructuredTypeField, data: Ex
 
     switch (category) {
         case FieldCategory.enumeration:
-            {
-                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);
-                }
-            }
+            _dump_enumeration_value(self, field, data, value, fieldType);
             break;
         case FieldCategory.basic:
             _dump_simple_value(self, field, data, value, fieldType);

package/source/factories_enumerations.ts

@@ -4,7 +4,7 @@
 import { assert } from "node-opcua-assert";
 
 import { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";
-import { Enum, EnumItem } from "node-opcua-enum";
+import { Enum, EnumItem, _TypescriptEnum , adaptTypescriptEnum} from "node-opcua-enum";
 import { EnumerationDefinition, TypeSchemaBase, TypeSchemaConstructorOptions } from "./types";
 
 function _encode_enumeration(typedEnum: Enum, value: number, stream: OutputBinaryStream): void {
@@ -23,9 +23,10 @@ function _decode_enumeration(typedEnum: Enum, stream: BinaryStream): number {
     return value;
 }
 
+
 export interface EnumerationDefinitionOptions extends TypeSchemaConstructorOptions {
-    enumValues: any;
-    typedEnum?: any;
+    enumValues: _TypescriptEnum | string[];
+    typedEnum?: Enum;
     lengthInBits?: number;
 
     // specialized methods
@@ -34,8 +35,9 @@ export interface EnumerationDefinitionOptions extends TypeSchemaConstructorOptio
     decode?: (stream: BinaryStream) => EnumItem;
 }
 
+
 export class EnumerationDefinitionSchema extends TypeSchemaBase implements EnumerationDefinition {
-    public enumValues: any;
+    public enumValues: _TypescriptEnum;
     public typedEnum: Enum;
     public lengthInBits: number;
     // xx encode: (value: EnumItem, stream: OutputBinaryStream) => void;
@@ -44,6 +46,7 @@ export class EnumerationDefinitionSchema extends TypeSchemaBase implements Enume
     constructor(options: EnumerationDefinitionOptions) {
         super(options);
         // create a new Enum
+        this.enumValues = adaptTypescriptEnum(options.enumValues);
         const typedEnum = new Enum(options.enumValues);
         options.typedEnum = typedEnum;
 

package/source/types.ts

@@ -118,7 +118,7 @@ export interface BasicTypeDefinition extends CommonInterface {
 export interface BuiltInTypeDefinition extends BasicTypeDefinition {}
 
 export interface EnumerationDefinition extends CommonInterface {
-    enumValues: any;
+  //  enumValues: any;
     typedEnum: Enum;
     documentation?: string;
 }