node-opcua-client-dynamic-extension-object 2.64.1 → 2.66.0

package/package.json

@@ -1,32 +1,32 @@
 {
     "name": "node-opcua-client-dynamic-extension-object",
-    "version": "2.64.1",
+    "version": "2.66.0",
     "description": "pure nodejs OPCUA SDK - module client-dynamic-extension-object",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
     "scripts": {
         "build": "tsc -b",
-        "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-binary-stream": "2.64.1",
-        "node-opcua-constants": "2.64.1",
-        "node-opcua-data-model": "2.64.1",
-        "node-opcua-data-value": "2.64.1",
-        "node-opcua-debug": "2.64.1",
-        "node-opcua-extension-object": "2.64.1",
-        "node-opcua-factory": "2.64.1",
-        "node-opcua-nodeid": "2.64.1",
-        "node-opcua-pseudo-session": "2.64.1",
-        "node-opcua-schemas": "2.64.1",
-        "node-opcua-service-browse": "2.64.1",
-        "node-opcua-service-translate-browse-path": "2.64.1",
-        "node-opcua-status-code": "2.64.1",
-        "node-opcua-types": "2.64.1",
-        "node-opcua-variant": "2.64.1"
+        "node-opcua-assert": "2.66.0",
+        "node-opcua-binary-stream": "2.66.0",
+        "node-opcua-constants": "2.66.0",
+        "node-opcua-data-model": "2.66.0",
+        "node-opcua-data-value": "2.66.0",
+        "node-opcua-debug": "2.66.0",
+        "node-opcua-extension-object": "2.66.0",
+        "node-opcua-factory": "2.66.0",
+        "node-opcua-nodeid": "2.66.0",
+        "node-opcua-pseudo-session": "2.66.0",
+        "node-opcua-schemas": "2.66.0",
+        "node-opcua-service-browse": "2.66.0",
+        "node-opcua-service-translate-browse-path": "2.66.0",
+        "node-opcua-status-code": "2.66.0",
+        "node-opcua-types": "2.66.0",
+        "node-opcua-variant": "2.66.0"
     },
     "author": "Etienne Rossignon",
     "license": "MIT",
@@ -43,5 +43,5 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "b65b8738603cd475d7d99a2b20b0ae9d32b4110c"
+    "gitHead": "97f47e2e242a1fd737495fd64cb65e8fb7a9964b"
 }

package/source/convert_data_type_definition_to_structuretype_schema.ts

@@ -14,7 +14,14 @@ import {
 import { NodeId, makeExpandedNodeId, resolveNodeId } from "node-opcua-nodeid";
 import { browseAll, BrowseDescriptionLike, IBasicSession } from "node-opcua-pseudo-session";
 import { StatusCodes } from "node-opcua-status-code";
-import { EnumDefinition, DataTypeDefinition, StructureDefinition, StructureType, StructureField } from "node-opcua-types";
+import {
+    EnumDefinition,
+    DataTypeDefinition,
+    StructureDefinition,
+    StructureType,
+    StructureField,
+    EnumField
+} from "node-opcua-types";
 import { ExtensionObject } from "node-opcua-extension-object";
 //
 import { _findEncodings } from "./private/find_encodings";
@@ -132,11 +139,11 @@ async function resolve2(
     dataTypeFactory: DataTypeFactory,
     fieldTypeName: string,
     cache: { [key: string]: CacheForFieldResolution }
-): Promise<{ schema: TypeDefinition| undefined, category: FieldCategory}> {
+): Promise<{ schema: TypeDefinition | undefined; category: FieldCategory }> {
     const category = await findDataTypeCategory(session, cache, dataTypeNodeId);
     debugLog(" type " + fieldTypeName + " has not been seen yet, let resolve it => (category = ", category, " )");
 
-    let schema: TypeDefinition|undefined = undefined;
+    let schema: TypeDefinition | undefined = undefined;
     switch (category) {
         case FieldCategory.basic:
             schema = await findDataTypeBasicType(session, cache, dataTypeNodeId);
@@ -160,10 +167,17 @@ async function resolve2(
                 }
                 const definition = dataTypeDefinitionDataValue.value.value;
 
+                const convertIn64ToInteger = (a: number[]) => a[1];
+
+                const convert = (fields: EnumField[] | null) => {
+                    const retVal: Record<string, number> = {};
+                    fields && fields.forEach((field: EnumField) => (retVal[field.name || ""] = convertIn64ToInteger(field.value)));
+                    return retVal;
+                };
                 if (category === FieldCategory.enumeration) {
                     if (definition instanceof EnumDefinition) {
                         const e = new EnumerationDefinitionSchema({
-                            enumValues: definition.fields,
+                            enumValues: convert(definition.fields),
                             name: fieldTypeName
                         });
                         dataTypeFactory.registerEnumeration(e);
@@ -308,22 +322,20 @@ export async function convertDataTypeDefinitionToStructureTypeSchema(
 
         const bitFields: { name: string; length?: number }[] | undefined = isUnion ? undefined : [];
 
-        const postActions: ((schema: StructuredTypeSchema ) => void)[] = [];
+        const postActions: ((schema: StructuredTypeSchema) => void)[] = [];
 
         for (const fieldD of definition.fields!) {
-
             let field: FieldInterfaceOptions | undefined;
             ({ field, switchBit, switchValue } = createField(fieldD, switchBit, bitFields, isUnion, switchValue));
 
-            if (fieldD.dataType.value === dataTypeNodeId.value &&  fieldD.dataType.namespace === dataTypeNodeId.namespace ) {
+            if (fieldD.dataType.value === dataTypeNodeId.value && fieldD.dataType.namespace === dataTypeNodeId.namespace) {
                 // this is a structure with a field of the same type
                 // push an empty placeholder that we will fill later
                 const fieldTypeName = await readBrowseName(session, dataTypeNodeId);
-                field.fieldType= fieldTypeName!,
-                field.category = FieldCategory.complex;
+                (field.fieldType = fieldTypeName!), (field.category = FieldCategory.complex);
                 fields.push(field);
                 const capturedField = field;
-                postActions.push( (schema: StructuredTypeSchema )=> {
+                postActions.push((schema: StructuredTypeSchema) => {
                     capturedField.schema = schema;
                 });
                 continue;
@@ -341,8 +353,7 @@ export async function convertDataTypeDefinitionToStructureTypeSchema(
             }
             const { schema, category, fieldTypeName } = rt;
 
-            field.fieldType= fieldTypeName!,
-            field.category = category;
+            (field.fieldType = fieldTypeName!), (field.category = category);
             field.schema = schema;
             fields.push(field);
         }
@@ -359,13 +370,19 @@ export async function convertDataTypeDefinitionToStructureTypeSchema(
         });
         const structuredTypeSchema = await _setupEncodings(session, dataTypeNodeId, os);
 
-        postActions.forEach((action)=>action(structuredTypeSchema));
+        postActions.forEach((action) => action(structuredTypeSchema));
 
         return structuredTypeSchema;
     }
     throw new Error("Not Implemented");
 
-    function createField(fieldD: StructureField, switchBit: number, bitFields: { name: string; length?: number | undefined; }[] | undefined, isUnion: boolean, switchValue: number) {
+    function createField(
+        fieldD: StructureField,
+        switchBit: number,
+        bitFields: { name: string; length?: number | undefined }[] | undefined,
+        isUnion: boolean,
+        switchValue: number
+    ) {
         const field: FieldInterfaceOptions = {
             fieldType: "",
             name: fieldD.name!,

package/dist/client_dynamic_extension_object.d.ts

@@ -1,25 +0,0 @@
-import { DataTypeFactory, FieldCategory, StructuredTypeSchema, TypeDefinition } from "node-opcua-factory";
-import { NodeId } from "node-opcua-nodeid";
-import { IBasicSession } from "node-opcua-pseudo-session";
-import { AnyConstructorFunc } from "node-opcua-schemas";
-import { DataTypeDefinition } from "node-opcua-types";
-import { ExtraDataTypeManager } from "./extra_data_type_manager";
-/**
- * Extract all custom dataType
- * @param session
- * @param dataTypeManager
- * @async
- */
-export declare function populateDataTypeManager(session: IBasicSession, dataTypeManager: ExtraDataTypeManager): Promise<void>;
-export declare function getDataTypeDefinition(session: IBasicSession, dataTypeNodeId: NodeId, dataTypeManager: ExtraDataTypeManager): Promise<StructuredTypeSchema>;
-interface Cache {
-    fieldTypeName: string;
-    schema: TypeDefinition;
-    category: FieldCategory;
-}
-export declare function convertDataTypeDefinitionToStructureTypeSchema(session: IBasicSession, dataTypeNodeId: NodeId, name: string, definition: DataTypeDefinition, dataTypeFactory: DataTypeFactory, cache: {
-    [key: string]: Cache;
-}): Promise<StructuredTypeSchema>;
-export declare function extractNamespaceDataType(session: IBasicSession): Promise<ExtraDataTypeManager>;
-export declare function getExtensionObjectConstructor(session: IBasicSession, dataTypeNodeId: NodeId): Promise<AnyConstructorFunc>;
-export {};