rclnodejs 0.32.4 → 0.33.0

package/README.md

@@ -45,7 +45,7 @@ npm i rclnodejs@x.y.z
 
 |                                      RCLNODEJS Version                                       |                                                             Compatible ROS 2 LTS                                                             |
 | :------------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------: |
-| latest version (currently [v0.32.4](https://github.com/RobotWebTools/rclnodejs/tree/0.32.4)) | [Humble](https://github.com/RobotWebTools/rclnodejs/tree/humble-hawksbill)<br>[Jazzy](https://github.com/RobotWebTools/rclnodejs/tree/jazzy) |
+| latest version (currently [v0.33.0](https://github.com/RobotWebTools/rclnodejs/tree/0.33.0)) | [Humble](https://github.com/RobotWebTools/rclnodejs/tree/humble-hawksbill)<br>[Jazzy](https://github.com/RobotWebTools/rclnodejs/tree/jazzy) |
 
 ## Documentation
 

package/binding.gyp

@@ -12,6 +12,7 @@
     'runtime%': 'node',
     'ros_lib_dir': "<!(node -p \"require('./scripts/config.js').getROSLibPath()\")",
     'ros_include_root': "<!(node -p \"require('./scripts/config.js').getROSIncludeRootPath()\")",
+    'node_major_version': '<!(node -p \"process.versions.node.split(\'.\')[0]\")',
   },
   'targets': [
     {
@@ -62,8 +63,21 @@
             'defines': [
               'OS_LINUX'
             ],
-            'cflags_cc': [
-              '-std=c++20'
+            'conditions': [
+              [
+                'node_major_version >= 23', {
+                  'cflags_cc': [
+                    '-std=c++20'
+                  ]
+                }
+              ],
+              [
+                'node_major_version < 23', {
+                  'cflags_cc': [
+                    '-std=c++17'
+                  ]
+                }
+              ]
             ]
           }
         ],
@@ -72,8 +86,21 @@
             'defines': [
               'OS_WINDOWS'
             ],
-            'cflags_cc': [
-              '-std=c++20'
+            'conditions': [
+              [
+                'node_major_version >= 23', {
+                  'cflags_cc': [
+                    '-std=c++20'
+                  ]
+                }
+              ],
+              [
+                'node_major_version < 23', {
+                  'cflags_cc': [
+                    '-std=c++17'
+                  ]
+                }
+              ]
             ],
             'include_dirs': [
               './src/third_party/dlfcn-win32/',

package/lib/node.js

@@ -969,7 +969,7 @@ class Node extends rclnodejs.ShadowNode {
   }
 
   /**
-   * Get the list of service topics discovered by the provided node for the remote node name.
+   * Get service names and types for which a remote node has servers.
    * @param {string} nodeName - The name of the node.
    * @param {string} namespace - The name of the namespace.
    * @return {Array<{name: string, types: Array<string>}>} - An array of the names and types.
@@ -982,6 +982,20 @@ class Node extends rclnodejs.ShadowNode {
     );
   }
 
+  /**
+   * Get service names and types for which a remote node has clients.
+   * @param {string} nodeName - The name of the node.
+   * @param {string} namespace - The name of the namespace.
+   * @return {Array<{name: string, types: Array<string>}>} - An array of the names and types.
+   */
+  getClientNamesAndTypesByNode(nodeName, namespace) {
+    return rclnodejs.getClientNamesAndTypesByNode(
+      this.handle,
+      nodeName,
+      namespace
+    );
+  }
+
   /**
    * Get the list of topics discovered by the provided node.
    * @param {boolean} noDemangle - If true topic names and types returned will not be demangled, default: false.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rclnodejs",
-  "version": "0.32.4",
+  "version": "0.33.0",
   "description": "ROS2.0 JavaScript client with Node.js",
   "main": "index.js",
   "types": "types/index.d.ts",

package/rostsd_gen/index.js

@@ -31,6 +31,8 @@ const fs = require('fs');
 const loader = require('../lib/interface_loader.js');
 const pkgFilters = require('../rosidl_gen/filter.js');
 
+const descriptorInterfaceNamespace = 'descriptor';
+
 async function generateAll() {
   // load pkg and interface info (msgs and srvs)
   const generatedPath = path.join(__dirname, '../generated/');
@@ -119,47 +121,30 @@ function savePkgInfoAsTSD(pkgInfos, fd) {
     for (const subfolder of pkgInfo.subfolders.keys()) {
       fs.writeSync(fd, `    namespace ${subfolder} {\n`);
 
-      for (const rosInterface of pkgInfo.subfolders.get(subfolder)) {
-        const type = rosInterface.type();
-        const fullInterfaceName = `${type.pkgName}/${type.subFolder}/${type.interfaceName}`;
-        const fullInterfacePath = `${type.pkgName}.${type.subFolder}.${type.interfaceName}`;
-        const fullInterfaceConstructor = fullInterfacePath + 'Constructor';
-
-        if (isMsgInterface(rosInterface)) {
-          // create message interface
-          saveMsgAsTSD(rosInterface, fd);
-          saveMsgConstructorAsTSD(rosInterface, fd);
-          messagesMap[fullInterfaceName] = fullInterfacePath;
-        } else if (isSrvInterface(rosInterface)) {
-          if (
-            !isValidService(rosInterface, pkgInfo.subfolders.get(subfolder))
-          ) {
-            let type = rosInterface.type();
-            console.log(
-              `Incomplete service: ${type.pkgName}.${type.subFolder}.${type.interfaceName}.`
-            );
-            continue;
-          }
-
-          // create service interface
-          saveSrvAsTSD(rosInterface, fd);
-          if (!isInternalActionSrvInterface(rosInterface)) {
-            servicesMap[fullInterfaceName] = fullInterfaceConstructor;
-          }
-        } else if (isActionInterface(rosInterface)) {
-          if (!isValidAction(rosInterface, pkgInfo.subfolders.get(subfolder))) {
-            let type = rosInterface.type();
-            console.log(
-              `Incomplete action: ${type.pkgName}.${type.subFolder}.${type.interfaceName}.`
-            );
-            continue;
-          }
-
-          // create action interface
-          saveActionAsTSD(rosInterface, fd);
-          actionsMap[fullInterfaceName] = fullInterfaceConstructor;
-        }
-      }
+      // generate real msg/srv/action interfaces
+      generateRosMsgInterfaces(
+        pkgInfo,
+        subfolder,
+        messagesMap,
+        servicesMap,
+        actionsMap,
+        fd
+      );
+
+      // generate descriptor msg/srv/action interfaces
+      fs.writeSync(fd, `      namespace ${descriptorInterfaceNamespace} {\n`);
+      const willGenerateDescriptorInterface = true;
+      generateRosMsgInterfaces(
+        pkgInfo,
+        subfolder,
+        messagesMap,
+        servicesMap,
+        actionsMap,
+        fd,
+        willGenerateDescriptorInterface
+      );
+      // close namespace descriptor declare
+      fs.writeSync(fd, '      }\n');
 
       // close namespace declare
       fs.writeSync(fd, '    }\n');
@@ -238,16 +223,96 @@ function savePkgInfoAsTSD(pkgInfos, fd) {
   fs.writeSync(fd, '}\n');
 }
 
-function saveMsgAsTSD(rosMsgInterface, fd) {
-  fs.writeSync(
-    fd,
-    `      export interface ${rosMsgInterface.type().interfaceName} {\n`
+function generateRosMsgInterfaces(
+  pkgInfo,
+  subfolder,
+  messagesMap,
+  servicesMap,
+  actionsMap,
+  fd,
+  willGenerateDescriptorInterface = false
+) {
+  const descriptorNamespaceName = willGenerateDescriptorInterface
+    ? `${descriptorInterfaceNamespace}/`
+    : '';
+  const descriptorNamespacePath = willGenerateDescriptorInterface
+    ? `${descriptorInterfaceNamespace}.`
+    : '';
+  for (const rosInterface of pkgInfo.subfolders.get(subfolder)) {
+    const type = rosInterface.type();
+    const fullInterfaceName = `${type.pkgName}/${type.subFolder}/${descriptorNamespaceName}${type.interfaceName}`;
+    const fullInterfacePath = `${type.pkgName}.${type.subFolder}.${descriptorNamespacePath}${type.interfaceName}`;
+    const fullInterfaceConstructor = fullInterfacePath + 'Constructor';
+
+    const indentStartLevel = willGenerateDescriptorInterface ? 4 : 3;
+    if (isMsgInterface(rosInterface)) {
+      // create message interface
+      saveMsgAsTSD(
+        rosInterface,
+        fd,
+        indentStartLevel,
+        willGenerateDescriptorInterface
+      );
+      saveMsgConstructorAsTSD(rosInterface, fd, indentStartLevel);
+      messagesMap[fullInterfaceName] = fullInterfacePath;
+    } else if (isSrvInterface(rosInterface)) {
+      if (!isValidService(rosInterface, pkgInfo.subfolders.get(subfolder))) {
+        let type = rosInterface.type();
+        console.log(
+          `Incomplete service: ${type.pkgName}.${type.subFolder}.${type.interfaceName}.`
+        );
+        continue;
+      }
+
+      // create service interface
+      saveSrvAsTSD(rosInterface, fd, indentStartLevel);
+      if (!isInternalActionSrvInterface(rosInterface)) {
+        servicesMap[fullInterfaceName] = fullInterfaceConstructor;
+      }
+    } else if (isActionInterface(rosInterface)) {
+      if (!isValidAction(rosInterface, pkgInfo.subfolders.get(subfolder))) {
+        let type = rosInterface.type();
+        console.log(
+          `Incomplete action: ${type.pkgName}.${type.subFolder}.${type.interfaceName}.`
+        );
+        continue;
+      }
+
+      // create action interface
+      saveActionAsTSD(rosInterface, fd, indentStartLevel);
+      actionsMap[fullInterfaceName] = fullInterfaceConstructor;
+    }
+  }
+}
+
+function saveMsgAsTSD(
+  rosMsgInterface,
+  fd,
+  indentLevel = 3,
+  willGenerateDescriptorInterface = false
+) {
+  const outerIndentSpacing = getIndentSpacing(indentLevel);
+  const tmpl = indentString(
+    `export interface ${rosMsgInterface.type().interfaceName} {\n`,
+    outerIndentSpacing
   );
+  fs.writeSync(fd, tmpl);
   const useSamePkg =
     isInternalActionMsgInterface(rosMsgInterface) ||
     isInternalServiceEventMsgInterface(rosMsgInterface);
-  saveMsgFieldsAsTSD(rosMsgInterface, fd, 8, ';', '', useSamePkg);
-  fs.writeSync(fd, '      }\n');
+  const innerIndentLevel = indentLevel + 1;
+  const innerIndentSpacing = getIndentSpacing(innerIndentLevel);
+  saveMsgFieldsAsTSD(
+    rosMsgInterface,
+    fd,
+    innerIndentSpacing,
+    ';',
+    '',
+    useSamePkg,
+    willGenerateDescriptorInterface
+  );
+  const tmplEnd = indentString('}\n', outerIndentSpacing);
+  fs.writeSync(fd, tmplEnd);
 }
 
 /**
@@ -261,6 +326,7 @@ function saveMsgAsTSD(rosMsgInterface, fd) {
  * @param {string} typePrefix The prefix to put before the type name for
  * non-primitive types
  * @param {boolean} useSamePackageSubFolder Indicates if the sub folder name should be taken from the message
+ * @param {boolean} willGenerateDescriptorInterface Indicates if descriptor interface is being generated
  * when the field type comes from the same package. This is needed for action interfaces. Defaults to false.
  * @returns {undefined}
  */
@@ -270,7 +336,8 @@ function saveMsgFieldsAsTSD(
   indent = 0,
   lineEnd = ',',
   typePrefix = '',
-  useSamePackageSubFolder = false
+  useSamePackageSubFolder = false,
+  willGenerateDescriptorInterface = false
 ) {
   let type = rosMsgInterface.type();
   let fields = rosMsgInterface.ROSMessageDef.fields;
@@ -280,49 +347,62 @@ function saveMsgFieldsAsTSD(
       useSamePackageSubFolder && field.type.pkgName === type.pkgName
         ? type.subFolder
         : 'msg';
-    let fieldType = fieldType2JSName(field, subFolder);
+    let fieldType = fieldType2JSName(
+      field,
+      subFolder,
+      willGenerateDescriptorInterface
+    );
     let tp = field.type.isPrimitiveType ? '' : typePrefix;
     if (typePrefix === 'rclnodejs.') {
       fieldType = 'any';
       tp = '';
     }
 
-    const tmpl = indentString(`${field.name}: ${tp}${fieldType}`, indent);
-    fs.writeSync(fd, tmpl);
+    let arrayString = '';
     if (field.type.isArray) {
-      fs.writeSync(fd, '[]');
+      arrayString = '[]';
+
+      if (field.type.isFixedSizeArray && willGenerateDescriptorInterface) {
+        arrayString = `[${field.type.arraySize}]`;
+      }
 
-      if (fieldType === 'number') {
+      if (fieldType === 'number' && !willGenerateDescriptorInterface) {
         // for number[] include alternate typed-array types, e.g., number[] | uint8[]
         let jsTypedArrayName = fieldTypeArray2JSTypedArrayName(field.type.type);
 
         if (jsTypedArrayName) {
-          fs.writeSync(fd, ` | ${jsTypedArrayName}`);
+          arrayString += ` | ${jsTypedArrayName}`;
         }
       }
     }
+    const fieldString = willGenerateDescriptorInterface
+      ? `${field.name}: '${tp}${fieldType}${arrayString}'`
+      : `${field.name}: ${tp}${fieldType}${arrayString}`;
+    const tmpl = indentString(fieldString, indent);
+    fs.writeSync(fd, tmpl);
 
     fs.writeSync(fd, lineEnd);
     fs.writeSync(fd, '\n');
   }
 }
 
-function saveMsgConstructorAsTSD(rosMsgInterface, fd) {
+function saveMsgConstructorAsTSD(rosMsgInterface, fd, indentLevel = 3) {
   const type = rosMsgInterface.type();
   const msgName = type.interfaceName;
-
-  fs.writeSync(fd, `      export interface ${msgName}Constructor {\n`);
+  let interfaceTmpl = [`export interface ${msgName}Constructor {`];
 
   for (const constant of rosMsgInterface.ROSMessageDef.constants) {
     const constantType = primitiveType2JSName(constant.type);
-    fs.writeSync(fd, `        readonly ${constant.name}: ${constantType};\n`);
+    interfaceTmpl.push(`  readonly ${constant.name}: ${constantType};`);
   }
-
-  fs.writeSync(fd, `        new(other?: ${msgName}): ${msgName};\n`);
-  fs.writeSync(fd, '      }\n');
+  interfaceTmpl.push(`  new(other?: ${msgName}): ${msgName};`);
+  interfaceTmpl.push('}');
+  interfaceTmpl.push('');
+  const indentSpacing = getIndentSpacing(indentLevel);
+  fs.writeSync(fd, indentLines(interfaceTmpl, indentSpacing).join('\n'));
 }
 
-function saveSrvAsTSD(rosSrvInterface, fd) {
+function saveSrvAsTSD(rosSrvInterface, fd, indentLevel = 3) {
   const serviceName = rosSrvInterface.type().interfaceName;
 
   const interfaceTemplate = [
@@ -332,11 +412,11 @@ function saveSrvAsTSD(rosSrvInterface, fd) {
     '}',
     '',
   ];
-
-  fs.writeSync(fd, indentLines(interfaceTemplate, 6).join('\n'));
+  const indentSpacing = getIndentSpacing(indentLevel);
+  fs.writeSync(fd, indentLines(interfaceTemplate, indentSpacing).join('\n'));
 }
 
-function saveActionAsTSD(rosActionInterface, fd) {
+function saveActionAsTSD(rosActionInterface, fd, indentLevel = 3) {
   const actionName = rosActionInterface.type().interfaceName;
 
   const interfaceTemplate = [
@@ -347,8 +427,19 @@ function saveActionAsTSD(rosActionInterface, fd) {
     '}',
     '',
   ];
+  const indentSpacing = getIndentSpacing(indentLevel);
+  fs.writeSync(fd, indentLines(interfaceTemplate, indentSpacing).join('\n'));
+}
 
-  fs.writeSync(fd, indentLines(interfaceTemplate, 6).join('\n'));
+/**
+ * Get number of indent spaces for given level
+ *
+ * @param {*} indentLevel Indention level
+ * @param {*} spacesPerLevel Number of spaces per level
+ * @returns Total number of space
+ */
+function getIndentSpacing(indentLevel, spacesPerLevel = 2) {
+  return indentLevel * spacesPerLevel;
 }
 
 function isMsgInterface(rosInterface) {
@@ -451,7 +542,16 @@ function isValidAction(rosActionInterface, infos) {
   return matches === SUCCESS_MATCH_COUNT;
 }
 
-function fieldType2JSName(fieldInfo, subFolder = 'msg') {
+function fieldType2JSName(
+  fieldInfo,
+  subFolder = 'msg',
+  willGenerateDescriptorInterface = false
+) {
+  if (willGenerateDescriptorInterface) {
+    return fieldInfo.type.isPrimitiveType
+      ? `${fieldInfo.type.type}`
+      : `${fieldInfo.type.pkgName}/${subFolder}/${fieldInfo.type.type}`;
+  }
   return fieldInfo.type.isPrimitiveType
     ? primitiveType2JSName(fieldInfo.type.type)
     : `${fieldInfo.type.pkgName}.${subFolder}.${fieldInfo.type.type}`;

package/scripts/npmjs-readme.md

@@ -45,7 +45,7 @@ npm i rclnodejs@x.y.z
 
 |                                      RCLNODEJS Version                                       |                                                             Compatible ROS 2 LTS                                                             |
 | :------------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------: |
-| latest version (currently [v0.32.4](https://github.com/RobotWebTools/rclnodejs/tree/0.32.4)) | [Humble](https://github.com/RobotWebTools/rclnodejs/tree/humble-hawksbill)<br>[Jazzy](https://github.com/RobotWebTools/rclnodejs/tree/jazzy) |
+| latest version (currently [v0.33.0](https://github.com/RobotWebTools/rclnodejs/tree/0.33.0)) | [Humble](https://github.com/RobotWebTools/rclnodejs/tree/humble-hawksbill)<br>[Jazzy](https://github.com/RobotWebTools/rclnodejs/tree/jazzy) |
 
 ## Documentation
 

package/src/rcl_bindings.cpp

@@ -1738,15 +1738,45 @@ NAN_METHOD(GetServiceNamesAndTypesByNode) {
       rcl_get_service_names_and_types_by_node(
           node, &allocator, node_name.c_str(), node_namespace.c_str(),
           &service_names_and_types),
-      "Failed to get_publisher_names_and_types.");
+      "Failed to get_service_names_and_types.");
 
   v8::Local<v8::Array> result_list =
       Nan::New<v8::Array>(service_names_and_types.names.size);
   ExtractNamesAndTypes(service_names_and_types, &result_list);
 
+  THROW_ERROR_IF_NOT_EQUAL(
+      RCL_RET_OK, rcl_names_and_types_fini(&service_names_and_types),
+      "Failed to destroy rcl_get_zero_initialized_names_and_types");
+
+  info.GetReturnValue().Set(result_list);
+}
+
+NAN_METHOD(GetClientNamesAndTypesByNode) {
+  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
+  RclHandle* node_handle = RclHandle::Unwrap<RclHandle>(
+      Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
+  std::string node_name =
+      *Nan::Utf8String(info[1]->ToString(currentContent).ToLocalChecked());
+  std::string node_namespace =
+      *Nan::Utf8String(info[2]->ToString(currentContent).ToLocalChecked());
+
+  rcl_names_and_types_t client_names_and_types =
+      rcl_get_zero_initialized_names_and_types();
+  rcl_allocator_t allocator = rcl_get_default_allocator();
   THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
-                           rcl_names_and_types_fini(&service_names_and_types),
-                           "Failed to destroy topic_names_and_types");
+                           rcl_get_client_names_and_types_by_node(
+                               node, &allocator, node_name.c_str(),
+                               node_namespace.c_str(), &client_names_and_types),
+                           "Failed to get_client_names_and_types.");
+
+  v8::Local<v8::Array> result_list =
+      Nan::New<v8::Array>(client_names_and_types.names.size);
+  ExtractNamesAndTypes(client_names_and_types, &result_list);
+
+  THROW_ERROR_IF_NOT_EQUAL(
+      RCL_RET_OK, rcl_names_and_types_fini(&client_names_and_types),
+      "Failed to destroy rcl_get_zero_initialized_names_and_types");
 
   info.GetReturnValue().Set(result_list);
 }
@@ -2033,6 +2063,7 @@ std::vector<BindingMethod> binding_methods = {
     {"getPublisherNamesAndTypesByNode", GetPublisherNamesAndTypesByNode},
     {"getSubscriptionNamesAndTypesByNode", GetSubscriptionNamesAndTypesByNode},
     {"getServiceNamesAndTypesByNode", GetServiceNamesAndTypesByNode},
+    {"getClientNamesAndTypesByNode", GetClientNamesAndTypesByNode},
     {"getTopicNamesAndTypes", GetTopicNamesAndTypes},
     {"getServiceNamesAndTypes", GetServiceNamesAndTypes},
     {"getNodeNames", GetNodeNames},