node-opcua-factory 2.71.0 → 2.73.1

package/source/types.ts

@@ -1,11 +1,15 @@
 /**
  * @module node-opcua-factory
  */
-import { assert } from "node-opcua-assert";
 import { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";
-import { Enum, EnumItem } from "node-opcua-enum";
-import { NodeId } from "node-opcua-nodeid";
-import { ConstructorFunc } from "./constructor_type";
+import { Enum } from "node-opcua-enum";
+import { ExpandedNodeId, NodeId } from "node-opcua-nodeid";
+
+export enum FieldCategory {
+    enumeration = "enumeration",
+    complex = "complex",
+    basic = "basic"
+}
 
 // ------------------
 //  @brief CommonInterface
@@ -15,44 +19,93 @@ import { ConstructorFunc } from "./constructor_type";
 //
 export interface CommonInterface {
     name: string;
+    defaultValue?: any;
 
     encode?: (value: any, stream: OutputBinaryStream) => void;
     decode?: (stream: BinaryStream) => any;
-
     coerce?: (value: any) => any;
+
     toJSON?: (value: any) => any;
+    category: FieldCategory;
+
     random?: () => any;
     validate?: (value: any) => void;
+    computer_default_value(defaultValue: any): any;
+    subType: string;
+    isAbstract: boolean;
 
-    defaultValue?: any;
+    isSubTypeOf(type: CommonInterface): boolean;
+}
 
-    computer_default_value(defaultValue: any): any;
+export interface FieldInterfaceOptions {
+    name: string;
+    defaultValue?: any | DefaultValueFunc;
+
+    fieldType: string;
+    isArray?: boolean;
+    documentation?: string;
+    category?: FieldCategory;
+    schema?: CommonInterface;
+    switchBit?: number; // the bit number
+    switchValue?: number;
+    allowSubType?: boolean;
+    dataType?: NodeId;
+    basicDataType?: number;
 }
 
-export enum FieldCategory {
-    enumeration = "enumeration",
-    complex = "complex",
-    basic = "basic"
+export type Func1<T> = (value: any, field: StructuredTypeField, data: T, args?: any) => void;
+export interface DecodeDebugOptions {
+    tracer: any;
+    name: string;
+}
+
+export interface IBaseUAObject {
+    schema: IStructuredTypeSchema;
+    encode(stream: OutputBinaryStream): void;
+    decode(stream: BinaryStream): void;
+    binaryStoreSize(): number;
+    toString(...args: any[]): string;
+    isValid(): boolean;
+    explore(): string;
+    applyOnAllFields<T>(func: Func1<T>, data: T): void;
+    toJSON(): any;
+    decodeDebug(stream: BinaryStream, options: DecodeDebugOptions): void;
+    clone(): IBaseUAObject;
+}
+type BaseUAObjectConstructable = new (options?: any) => IBaseUAObject;
+export type ConstructorFunc = BaseUAObjectConstructable;
+// new (...args: any[]) => BaseUAObjectConstructable;
+
+export interface ConstructorFuncWithSchema extends ConstructorFunc {
+    schema: IStructuredTypeSchema;
+    possibleFields: string[];
+    encodingDefaultBinary: ExpandedNodeId;
+    encodingDefaultXml: ExpandedNodeId;
+    encodingDefaultJson?: ExpandedNodeId;
 }
 
 export interface StructuredTypeField {
-    name: string;
+    
+    name: string;               // the name that may have been lowercased
+    originalName: string;       // the orignal name from the raw OPCUA description
 
     fieldType: string;
-
     isArray?: boolean;
     documentation?: string;
     category: FieldCategory;
+    defaultValue?: any | DefaultValueFunc;
     schema: CommonInterface;
+    switchBit?: number; // the bit number
+    switchValue?: number;
+    allowSubType?: boolean;
+    dataType?: NodeId;
+    basicDataType?: number; // DataType
 
     fieldTypeConstructor?: ConstructorFunc;
+
     subType?: string;
-    defaultValue?: any;
     validate?: (value: any) => boolean;
     decode?: (stream: BinaryStream) => any;
-
-    switchBit?: number; // the bit number
-    switchValue?: number;
 }
 
 // tslint:disable:no-empty-interface
@@ -72,18 +125,6 @@ export type FieldType = FieldEnumeration | FieldComplex | FieldBasic;
 
 export type DefaultValueFunc = () => any;
 
-export interface FieldInterfaceOptions {
-    name: string;
-    fieldType: string;
-    isArray?: boolean;
-    documentation?: string;
-    category?: FieldCategory;
-    defaultValue?: any | DefaultValueFunc;
-    schema?: any;
-    switchBit?: number; // the bit number
-    switchValue?: number;
-}
-
 export interface StructuredTypeOptions {
     name: string;
     id?: number | NodeId;
@@ -97,6 +138,8 @@ export interface StructuredTypeOptions {
 
 export interface TypeSchemaConstructorOptions {
     name: string;
+    subType?: string;
+    isAbstract?: boolean;
     category?: FieldCategory;
     defaultValue?: any;
     encode?: (value: any, stream: OutputBinaryStream) => void;
@@ -104,13 +147,20 @@ export interface TypeSchemaConstructorOptions {
     coerce?: (value: any) => any;
 }
 
-export interface BasicTypeDefinitionOptions extends TypeSchemaConstructorOptions {
-    subType: string;
+export interface BasicTypeDefinitionOptionsB extends TypeSchemaConstructorOptions {
     toJSON?: (value: any) => any;
     random?: () => any;
     validate?: (value: any) => void;
 }
 
+export interface BasicTypeDefinitionOptionsBase extends BasicTypeDefinitionOptionsB {
+    /** */
+}
+
+export interface BasicTypeDefinitionOptions extends BasicTypeDefinitionOptionsB {
+    subType: string;
+}
+
 export interface BasicTypeDefinition extends CommonInterface {
     subType: string;
 }
@@ -118,57 +168,32 @@ export interface BasicTypeDefinition extends CommonInterface {
 export interface BuiltInTypeDefinition extends BasicTypeDefinition {}
 
 export interface EnumerationDefinition extends CommonInterface {
-  //  enumValues: any;
+    //  enumValues: any;
     typedEnum: Enum;
     documentation?: string;
 }
 
-export type TypeDefinition = BuiltInTypeDefinition | EnumerationDefinition | BasicTypeDefinition | TypeSchemaBase;
+export type TypeDefinition = BuiltInTypeDefinition | EnumerationDefinition | BasicTypeDefinition | CommonInterface;
 
-/**
- * @class TypeSchemaBase
- * @param options {Object}
- * @constructor
- * create a new type Schema
- */
-export class TypeSchemaBase implements CommonInterface {
-    public name: string;
-    public defaultValue: any;
-    public encode?: (value: any, stream: OutputBinaryStream) => void;
-    public decode?: (stream: BinaryStream) => any;
-    public coerce?: (value: any) => any;
-    public toJSON?: () => string;
-    public category: FieldCategory;
-
-    constructor(options: TypeSchemaConstructorOptions) {
-        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 as any)[prop] = (options as any)[prop];
-            }
-        }
-    }
-
-    /**
-     * @method  computer_default_value
-     * @param defaultValue {*} the default value
-     * @return {*}
-     */
-    public computer_default_value(defaultValue: unknown): any {
-        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;
-    }
+export interface IStructuredTypeSchema extends CommonInterface {
+    fields: FieldType[];
+    id: NodeId;
+    dataTypeNodeId: NodeId;
+
+    baseType: string;
+    _possibleFields: string[];
+    _baseSchema: IStructuredTypeSchema | 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[];
 }

package/source/constructor_type.ts

@@ -1,18 +0,0 @@
-/**
- * @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;
-}