node-opcua-convert-nodeset-to-javascript 2.135.0 → 2.137.0

package/source/convert_to_typescript.ts

@@ -1,7 +1,7 @@
 /* eslint-disable max-depth */
 import chalk from "chalk";
 import { LocalizedText, NodeClass, QualifiedName } from "node-opcua-data-model";
-import { NodeId } from "node-opcua-nodeid";
+import { NodeId, resolveNodeId } from "node-opcua-nodeid";
 import { IBasicSessionBrowseAsyncSimple, IBasicSessionReadAsyncSimple } from "node-opcua-pseudo-session";
 import {
     ReferenceDescription,
@@ -14,7 +14,6 @@ import assert from "node-opcua-assert";
 import { ModellingRuleType } from "node-opcua-address-space-base";
 import { make_warningLog, make_debugLog } from "node-opcua-debug";
 import {
-    _convertNodeIdToDataTypeAsync,
     getBrowseName,
     getIsAbstract,
     getDefinition,
@@ -25,7 +24,8 @@ import {
     getTypeDefOrBaseType,
     getChildrenOrFolderElements,
     getDataTypeNodeId,
-    extractBasicDataType} from "./private/utils";
+    extractBasicDataType,
+    getValueRank} from "./private/utils";
 
 import {
     Cache,
@@ -57,6 +57,10 @@ const m9 = !doDebug ? "" : `/* 9 */`;
 const mA = !doDebug ? "" : `/* a */`;
 const mB = !doDebug ? "" : `/* b */`;
 const mC = !doDebug ? "" : `/* c */`;
+const mD = !doDebug ? "" : `/* d */`;
+const mE = !doDebug ? "" : `/* e */`;
+const mF = !doDebug ? "" : `/* f */`;
+
 
 export async function convertDataTypeToTypescript(session: IBasicSessionReadAsyncSimple, dataTypeId: NodeId): Promise<void> {
     const definition = await getDefinition(session, dataTypeId);
@@ -92,6 +96,8 @@ interface ClassDefinition {
     dataType: DataType;
     dataTypeName: string;
     dataTypeImport?: Import[];
+    valueRank?: number;
+    dataTypeCombination?: string;
 }
 
 export function makeTypeName2(nodeClass: NodeClass, browseName: QualifiedName, suffix?: string): Import {
@@ -128,19 +134,24 @@ export async function extractClassDefinition(
     let dataTypeName = "";
     let dataType: DataType = DataType.Null;
     let dataTypeImport: Import[] | undefined = undefined;
+    let valueRank: number| undefined;
+    let dataTypeCombination: string| undefined;;
     if (nodeClass === NodeClass.VariableType) {
         dataType = await extractBasicDataType(session, dataTypeNodeId!);
         const importCollector = (i: Import) => {
             extraImports.push(i);
             cache.ensureImported(i);
         };
-        const { jtype } = await getCorrespondingJavascriptType2(session, nodeId, dataTypeNodeId!, cache, importCollector);
+        const info = await getCorrespondingJavascriptType2(session, nodeId, dataTypeNodeId!, cache, importCollector);
+        const jtype = info.jtype;
+        dataTypeCombination = info.dataTypeCombination;
         dataTypeName = jtype; // with decoration
         if (!dataTypeNodeId?.isEmpty()) {
             // "DT" + (await getBrowseName(session, dataTypeNodeId!))?.name! || "";
             // const bn = await getBrowseName(session, dataTypeNodeId!);
             dataTypeImport = extraImports; // makeTypeName2(NodeClass.DataType, bn);
         }
+        valueRank = await getValueRank(session, nodeId);
     }
 
     const baseClassDef = !superType ? null : await extractClassDefinition(session, superType.nodeId, cache);
@@ -177,7 +188,10 @@ export async function extractClassDefinition(
         members,
 
         interfaceName,
-        baseInterfaceName
+        baseInterfaceName,
+        valueRank,
+        dataTypeCombination
+
     };
     _c[nodeId.toString()] = classDef;
 
@@ -236,6 +250,7 @@ interface ClassMember extends ClassMemberBasic {
     suffix2?: string;
     suffix3?: string;
     innerClass?: Import | null;
+    dataTypeCombination?: string;
     childBase?: Import | null;
 }
 
@@ -381,6 +396,7 @@ async function _extractLocalMembers(
     classMember: ClassMember,
     cache: Cache
 ): Promise<ClassMemberBasic[]> {
+
     const children2: ClassMemberBasic[] = [];
     for (const child of classMember.children) {
         const nodeId = child.nodeId;
@@ -446,8 +462,9 @@ async function extractVariableExtra(
     const nodeClass = await getNodeClass(session, nodeId);
     if (nodeClass === NodeClass.Variable) {
         const dataTypeNodeId = await getDataTypeNodeId(session, nodeId);
+        const valueRank = await getValueRank(session, nodeId);
 
-        const { dataType, jtype } = await getCorrespondingJavascriptType2(session, nodeId, dataTypeNodeId!, cache, importCollector);
+        const { dataType, jtype, dataTypeCombination, type } = await getCorrespondingJavascriptType2(session, nodeId, dataTypeNodeId!, cache, importCollector);
 
         cache && cache.referenceBasicType("DataType");
         importCollector({ name: "DataType", namespace: -1, module: "BasicType" });
@@ -457,7 +474,7 @@ async function extractVariableExtra(
         const suffix =
             jtype === "undefined" || isUnspecifiedDataType(dataType)
                 ? `<any, any>`
-                : `<${jtype}${t ? `, ${m0}DataType.${DataType[dataType]}` : ""}>`;
+                : `<${jtype}${t ? `, ${m0}DataType.${DataType[dataType]}` :""}>`;
 
         // const suffix2 = `<T${t ? `, /DT extends DataType` : ""}>`;
         const suffix3 = `<T${t ? `, ${m1}DT` : ""}>`;
@@ -479,13 +496,22 @@ async function extractVariableExtra(
             }
         } else {
             if (!isUnspecifiedDataType(typeDefCD.dataType)) {
-                suffixInstantiate = `<${jtype}>`;
+
+                if (jtype === "number" && (dataTypeNodeId!.value as number> 25)) {
+                    console.log("dataTypeNodeId", dataTypeNodeId?.toString()), dataTypeCombination;   
+                }
+                if (dataTypeCombination) {
+                    suffixInstantiate = `<${jtype}${mD},${dataTypeCombination}>`;
+                } else {
+                    suffixInstantiate = `<${jtype}${mE}>`;
+
+                }
             } else {
-                suffixInstantiate = `<${jtype}, DataType.${DataType[dataType]}>`;
+                suffixInstantiate = `<${jtype}, DataType.${DataType[dataType]}${mF}>`;
             }
         }
 
-        return { suffixInstantiate, suffix, suffix2, suffix3, dataTypeNodeId, dataType, jtype, typeToReference, chevrons };
+        return { suffixInstantiate, suffix, suffix2, suffix3, dataTypeNodeId, dataType, jtype, typeToReference, chevrons , dataTypeCombination};
     }
     return { suffix: "", typeToReference };
 }
@@ -577,7 +603,7 @@ export async function extractClassMemberDef(
         } else {
             // may not expose definition  but we may want to used the augment typescript class defined in the definition
             // we don't need to create an inner class ...
-            childType = sameMemberInBaseClass ? sameMemberInBaseClass?.childType : childType;
+            // xxxx NOT HERE childType = sameMemberInBaseClass ? sameMemberInBaseClass?.childType : childType;
             assert(!innerClass);
             assert(!childBase);
         }
@@ -882,8 +908,11 @@ export async function _convertTypeToTypescript(
     f.write(` * |nodeClass       |${f1(NodeClass[nodeClass])}|`);
     f.write(` * |typedDefinition |${f1(browseName.name!.toString() + " " + n(nodeId))}|`);
     if (nodeClass === NodeClass.VariableType) {
+        const { valueRank } = classDef;
         f.write(` * |dataType        |${f1(DataType[dataType])}|`);
         f.write(` * |dataType Name   |${f1(dataTypeName + " " + n(dataTypeNodeId))}|`);
+        valueRank && f.write(` * |value rank      |${f1(valueRank.toString())}|`);
+
     }
     f.write(` * |isAbstract      |${f1(isAbstract.toString())}|`);
     f.write(` */`);

package/source/main.ts

@@ -1,24 +1,32 @@
 import path from "path";
 import { AddressSpace, PseudoSession } from "node-opcua-address-space";
 import { generateAddressSpace } from "node-opcua-address-space/nodeJS";
-import { allNodesetMeta } from "node-opcua-nodesets";
+import { constructNodesetFilename, nodesetCatalog } from "node-opcua-nodesets";
 import { convertNamespaceTypeToTypescript } from "./convert_namespace_to_typescript";
 import { updateParentTSConfig } from './update_parent_tsconfig';
 
 async function main() {
     const addressSpace = AddressSpace.create();
-    await generateAddressSpace(addressSpace, allNodesetMeta.map((set) => set.xmlFile));
+
+    const xmlFiles = nodesetCatalog.map((set) => constructNodesetFilename(set.xmlFile));
+    await generateAddressSpace(addressSpace, xmlFiles);
 
     const session = new PseudoSession(addressSpace);
     const options = {
         baseFolder: path.join(__dirname, "../../"),
-        prefix: "node-opcua-nodeset-"
+        prefix: "node-opcua-nodeset-",
     };
-    await Promise.all(allNodesetMeta.map((meta) =>
-        convertNamespaceTypeToTypescript(session, addressSpace.getNamespaceIndex(meta.uri), {
+    await Promise.all(nodesetCatalog.map((meta) => {
+        const index = addressSpace.getNamespaceIndex(meta.uri);
+        if (index === -1) {
+            console.log("namespace not found", meta.uri);
+            return;
+        }
+        convertNamespaceTypeToTypescript(session, index, {
             ...options,
             nsName: meta.name,
         })
+    }
     ));
     await updateParentTSConfig();
 }

package/source/private/get_corresponding_data_type.ts

@@ -11,10 +11,24 @@ export async function getCorrespondingJavascriptType2(
     dataTypeNodeId: NodeId,
     cache: Cache,
     importCollect?: (t: Import) => void
-): Promise<{ dataType: DataType; jtype: string }> {
-    const q = await getCorrespondingJavascriptType(session, dataTypeNodeId, cache, importCollect);
+): Promise<{ dataType: DataType; jtype: string, dataTypeCombination?: string, type: "enum" | "basic" | "genericNumber"}> {
+    const { dataType, jtype, dataTypeCombination, type} = await getCorrespondingJavascriptType(session, dataTypeNodeId, cache, importCollect);
     const valueRank = await getValueRank(session, nodeId);
-    return { dataType: q.dataType, jtype: q.jtype + (valueRank >= 1 ? "[]" : "") };
+    let jtype2 = "";
+    if (valueRank >= 0) {
+        jtype2 = jtype + "[]";
+    } else if (valueRank === -1) {
+        jtype2 = jtype;
+    } else if (valueRank === -2) {
+        //  The value can be a scalar or an array with any number of dimensions.
+        jtype2 = `(${jtype} | ${jtype}[])`;
+    } else if (valueRank === -3) {
+        // ScalarOrOneDimension (-3):  The value can be a scalar or a one dimensional array.
+        jtype2 = `(${jtype} | ${jtype}[])`;
+    } else {
+        throw new Error("Invalid valueRank " + valueRank);
+    }
+    return { dataType: dataType, jtype: jtype2, dataTypeCombination, type };
 }
 
 // eslint-disable-next-line complexity
@@ -23,22 +37,30 @@ export async function getCorrespondingJavascriptType(
     dataTypeNodeId: NodeId,
     cache: Cache,
     importCollect?: (t: Import) => void
-): Promise<{ enumerationType?: string; dataType: DataType; jtype: string }> {
-    const { dataType, enumerationType } = await _convertNodeIdToDataTypeAsync(session, dataTypeNodeId);
+): Promise<{ 
+    enumerationType?: string; 
+    dataType: DataType; 
+    jtype: string,
+    type: "enum" | "basic" | "genericNumber",
+    dataTypeCombination?: string
+ }> {
+
+    const info = await _convertNodeIdToDataTypeAsync(session, dataTypeNodeId);
+    const { type } = info;
 
-    if (enumerationType) {
+    if (type == "enum" && info.enumerationType) {
         // we have a enmeration name here
         const jtypeImport = await referenceEnumeration(session, dataTypeNodeId);
         const jtype = jtypeImport.name;
         importCollect && importCollect(jtypeImport);
-        return { dataType, jtype };
+        return { dataType: info.dataType, jtype, type };
     }
 
-    if (dataType === DataType.ExtensionObject) {
+    if (type == "basic" && info.dataType === DataType.ExtensionObject) {
         const jtypeImport = await referenceExtensionObject(session, dataTypeNodeId);
         const jtype = jtypeImport.name;
         importCollect && importCollect(jtypeImport);
-        return { dataType, jtype };
+        return { dataType: info.dataType, jtype, type };
     }
     const referenceBasicType = (name: string): string => {
         const t = { name, namespace: -1, module: "BasicType" };
@@ -46,59 +68,64 @@ export async function getCorrespondingJavascriptType(
         cache.ensureImported(t);
         return t.name;
     };
-
-    switch (dataType) {
-        case DataType.Null:
-            return { dataType: DataType.Variant, jtype: referenceBasicType("VariantOptions") };
-        case DataType.Boolean:
-            return { dataType, jtype: "boolean" };
-        case DataType.Byte:
-            return { dataType, jtype: referenceBasicType("Byte") };
-        case DataType.ByteString:
-            return { dataType, jtype: "Buffer" };
-        case DataType.DataValue:
-            return { dataType, jtype: referenceBasicType("DataValue") };
-        case DataType.DateTime:
-            return { dataType, jtype: "Date" };
-        case DataType.DiagnosticInfo:
-            return { dataType, jtype: referenceBasicType("DiagnosticInfo") };
-        case DataType.Double:
-            return { dataType, jtype: "number" };
-        case DataType.Float:
-            return { dataType, jtype: "number" };
-        case DataType.Guid:
-            return { dataType, jtype: referenceBasicType("Guid") };
-        case DataType.Int16:
-            return { dataType, jtype: referenceBasicType("Int16") };
-        case DataType.Int32:
-            return { dataType, jtype: referenceBasicType("Int32") };
-        case DataType.UInt16:
-            return { dataType, jtype: referenceBasicType("UInt16") };
-        case DataType.UInt32:
-            return { dataType, jtype: referenceBasicType("UInt32") };
-        case DataType.UInt64:
-            return { dataType, jtype: referenceBasicType("UInt64") };
-        case DataType.Int64:
-            return { dataType, jtype: referenceBasicType("Int64") };
-        case DataType.LocalizedText:
-            return { dataType, jtype: referenceBasicType("LocalizedText") };
-        case DataType.NodeId:
-            return { dataType, jtype: referenceBasicType("NodeId") };
-        case DataType.ExpandedNodeId:
-            return { dataType, jtype: referenceBasicType("ExpandedNodeId") };
-        case DataType.QualifiedName:
-            return { dataType, jtype: referenceBasicType("QualifiedName") };
-        case DataType.SByte:
-            return { dataType, jtype: referenceBasicType("SByte") };
-        case DataType.StatusCode:
-            return { dataType, jtype: referenceBasicType("StatusCode") };
-        case DataType.String:
-            return { dataType, jtype: referenceBasicType("UAString") };
-        case DataType.Variant:
-            return { dataType, jtype: referenceBasicType("Variant") };
-        case DataType.XmlElement:
-            return { dataType, jtype: referenceBasicType("String") };
-        default:
-            throw new Error("Unsupported " + dataType + " " + DataType[dataType]);
+    if (type == "genericNumber") {
+        const { dataTypeCombination } = info;   
+        return { dataType: DataType.Variant, jtype: "number", type, dataTypeCombination };
+    } else {
+        const { dataType } = info;
+        switch (dataType) {
+            case DataType.Null:
+                return { dataType: DataType.Variant, jtype: referenceBasicType("VariantOptions"), type };
+            case DataType.Boolean:
+                return { dataType, jtype: "boolean", type };
+            case DataType.Byte:
+                return { dataType, jtype: referenceBasicType("Byte"), type };
+            case DataType.ByteString:
+                return { dataType, jtype: "Buffer", type };
+            case DataType.DataValue:
+                return { dataType, jtype: referenceBasicType("DataValue"), type };
+            case DataType.DateTime:
+                return { dataType, jtype: "Date", type };
+            case DataType.DiagnosticInfo:
+                return { dataType, jtype: referenceBasicType("DiagnosticInfo"), type };
+            case DataType.Double:
+                return { dataType, jtype: "number", type };
+            case DataType.Float:
+                return { dataType, jtype: "number", type };
+            case DataType.Guid:
+                return { dataType, jtype: referenceBasicType("Guid"), type };
+            case DataType.Int16:
+                return { dataType, jtype: referenceBasicType("Int16"), type };
+            case DataType.Int32:
+                return { dataType, jtype: referenceBasicType("Int32"), type };
+            case DataType.UInt16:
+                return { dataType, jtype: referenceBasicType("UInt16"), type };
+            case DataType.UInt32:
+                return { dataType, jtype: referenceBasicType("UInt32"), type };
+            case DataType.UInt64:
+                return { dataType, jtype: referenceBasicType("UInt64"), type };
+            case DataType.Int64:
+                return { dataType, jtype: referenceBasicType("Int64"), type };
+            case DataType.LocalizedText:
+                return { dataType, jtype: referenceBasicType("LocalizedText"), type };
+            case DataType.NodeId:
+                return { dataType, jtype: referenceBasicType("NodeId"), type };
+            case DataType.ExpandedNodeId:
+                return { dataType, jtype: referenceBasicType("ExpandedNodeId"), type };
+            case DataType.QualifiedName:
+                return { dataType, jtype: referenceBasicType("QualifiedName"), type };
+            case DataType.SByte:
+                return { dataType, jtype: referenceBasicType("SByte"), type };
+            case DataType.StatusCode:
+                return { dataType, jtype: referenceBasicType("StatusCode"), type };
+            case DataType.String:
+                return { dataType, jtype: referenceBasicType("UAString"), type };
+            case DataType.Variant:
+                return { dataType, jtype: referenceBasicType("Variant"), type };
+            case DataType.XmlElement:
+                return { dataType, jtype: referenceBasicType("String"), type };
+            default:
+                throw new Error("Unsupported " + dataType + " " + DataType[dataType]);
+        }
     }
 }

package/source/private/utils.ts

@@ -184,11 +184,22 @@ async function readBrowseName(session: IBasicSessionReadAsyncSimple, nodeId: Nod
     return dataTypeName;
 }
 
-interface DataTypeInfo {
+interface DataTypeInfoBasic {
+    type: "basic";
     dataType: DataType;
-    enumerationId?: NodeId;
+}
+interface DataTypeInfoEnum {
+    type: "enum";
+    dataType: DataType.Int32;
+    enumerationId: NodeId;
     enumerationType?: string;
 }
+interface DataTypeInfoGenericNumber {
+    type: "genericNumber";
+    dataTypeCombination: string;
+}
+type DataTypeInfo = DataTypeInfoBasic | DataTypeInfoEnum | DataTypeInfoGenericNumber;
+
 // see also client-proxy
 export async function _convertNodeIdToDataTypeAsync(
     session: IBasicSessionReadAsyncSimple & IBasicSessionBrowseAsyncSimple,
@@ -198,12 +209,32 @@ export async function _convertNodeIdToDataTypeAsync(
 
     let dataType: DataType;
 
+    if (dataTypeId.namespace === 0 && dataTypeId.value === DataTypeIds.Number) {
+        return {
+            type: "genericNumber",
+            dataTypeCombination: "DataType.Float | DataType.Double | " +
+                "DataType.UInt64 | DataType.UInt32 | DataType.UInt16 |  DataType.SByte | " +
+                "DataType.Int64 | DataType.Int32 | DataType.Int16 | DataType.Byte"
+        };
+    }
+    if (dataTypeId.namespace === 0 && dataTypeId.value === DataTypeIds.Integer) {
+        return {
+            type: "genericNumber",
+            dataTypeCombination: "DataType.Int64 | DataType.Int32 | DataType.Int16  | DataType.SByte"
+        };
+    }
+    if (dataTypeId.namespace === 0 && dataTypeId.value === DataTypeIds.UInteger) {
+        return {
+            type: "genericNumber",
+            dataTypeCombination: "DataType.UInt64 | DataType.UInt32 | DataType.UInt16  | DataType.Byte"
+        };
+    }
     if (dataTypeId.namespace === 0 && dataTypeId.value === DataTypeIds.Enumeration) {
-        return { dataType: DataType.Int32, enumerationId: dataTypeId };
+        return { type: "enum", dataType: DataType.Int32, enumerationId: dataTypeId };
     }
     if (dataTypeId.namespace === 0 && DataType[dataTypeId.value as number]) {
         dataType = dataTypeId.value as DataType;
-        return { dataType };
+        return { type: "basic", dataType };
     }
 
     /// example => Duration (i=290) => Double (i=11)
@@ -225,7 +256,7 @@ export async function _convertNodeIdToDataTypeAsync(
     const nodeId = references[0].nodeId;
 
     const info = await _convertNodeIdToDataTypeAsync(session, nodeId);
-    if (info.enumerationId) {
+    if (info.type == "enum" && info.enumerationId) {
         return { ...info, enumerationId: dataTypeId, enumerationType: dataTypeName.name! };
     }
     return info;

package/source/update_parent_tsconfig.ts

@@ -8,7 +8,7 @@ import path from 'path';
 //import { fileURLToPath } from 'url';
 //const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-import { allNodesetMeta } from "node-opcua-nodesets";
+import { nodesetCatalog } from "node-opcua-nodesets";
 
 export async function updateParentTSConfig() {
     const packagesFolder = path.join(__dirname, '..', '..');
@@ -23,15 +23,16 @@ export async function updateParentTSConfig() {
 
     type TSConfigReference = { path: string };
     const unlistedReferences: TSConfigReference[] = [];
-    for (const meta of allNodesetMeta) {
-        const nodesetPackageFolder = path.join(packagesFolder, meta.packageName);
+    for (const meta of nodesetCatalog) {
+        const packageName = `node-opcua-nodeset-${meta.packageName}`;
+        const nodesetPackageFolder = path.join(packagesFolder, packageName);
         if (!existsSync(nodesetPackageFolder)) {
             console.log(`Ignoring ${meta.packageName} since package folder does not exist (${nodesetPackageFolder})`);
             continue;
         }
-        if (!parentTSConfig.references.some((ref: TSConfigReference) => ref.path === meta.packageName)) {
-            console.log(`Found nodeset package that was not listed in tsconfig.json: ${meta.packageName}`);
-            unlistedReferences.push({ path: meta.packageName });
+        if (!parentTSConfig.references.some((ref: TSConfigReference) => ref.path === packageName)) {
+            console.log(`Found nodeset package that was not listed in tsconfig.json: ${packageName}`);
+            unlistedReferences.push({ path: packageName });
         }
     }