rclnodejs 1.8.1 → 1.8.3

package/rosidl_gen/packages.js

@@ -52,7 +52,12 @@ function getSubFolder(filePath, amentExecuted) {
   }
 
   if (amentExecuted) {
-    return filePath.match(/\w+\/share\/\w+\/(\w+)\//)[1];
+    const match = filePath.match(/\w+\/share\/\w+\/([\w-]+)\//);
+    if (match) {
+      // Handle non-standard subfolder names (e.g., msg-common, msg-ros2)
+      // by extracting only the base interface type before any hyphen.
+      return match[1].split('-')[0];
+    }
   }
   // If the |amentExecuted| equals to false, the file's extension will be assigned as
   // the name of sub folder.
@@ -145,9 +150,7 @@ async function generateMsgForSrv(filePath, interfaceInfo, pkgMap) {
   const arr = data.split(/-{3,}/);
   if (arr.length == 2) {
     const packagePath = path.join(serviceMsgPath, interfaceInfo.pkgName);
-    if (!fs.existsSync(packagePath)) {
-      fs.mkdirSync(packagePath);
-    }
+    fs.mkdirSync(packagePath, { recursive: true });
 
     await fsp.writeFile(path.join(packagePath, requestMsgName), arr[0]);
     await fsp.writeFile(path.join(packagePath, responseMsgName), arr[1]);

package/rosidl_gen/primitive_types.js

@@ -26,14 +26,14 @@ const StringRefStruct = StructType({
 
 function initString(str, own = false) {
   if (own) {
-    if ((!str) instanceof Buffer) {
+    if (!(str instanceof Buffer)) {
       throw new TypeError(
         'Invalid argument: should provide a Node Buffer to bindingsStringInit()'
       );
     }
     rclnodejs.initString(str);
   } else {
-    if ((!str) instanceof StringRefStruct) {
+    if (!(str instanceof StringRefStruct)) {
       throw new TypeError(
         'Invalid argument: should provide a type of StringRefStruct'
       );

package/rosidl_parser/idl_parser.py

@@ -0,0 +1,437 @@
+# Copyright (c) 2025, The Robot Web Tools Contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+IDL file parser that uses rosidl_parser to directly parse .idl files and
+produce the same JSON spec format as parser.py does for .msg files.
+
+This eliminates the need for the intermediate .idl -> .msg conversion step.
+"""
+
+import sys
+import json
+
+from rosidl_parser.parser import parse_idl_string
+from rosidl_parser.definition import (
+    AbstractNestedType,
+    Action,
+    Array,
+    BasicType,
+    BoundedSequence,
+    BoundedString,
+    BoundedWString,
+    Message,
+    NamedType,
+    NamespacedType,
+    Service,
+    UnboundedSequence,
+    UnboundedString,
+    UnboundedWString,
+)
+
+# Mapping from IDL basic type names to ROS2 message type names
+IDL_TYPE_TO_ROS2 = {
+    'boolean': 'bool',
+    'octet': 'byte',
+    'char': 'char',
+    'wchar': 'wchar',
+    'int8': 'int8',
+    'uint8': 'uint8',
+    'int16': 'int16',
+    'uint16': 'uint16',
+    'int32': 'int32',
+    'uint32': 'uint32',
+    'int64': 'int64',
+    'uint64': 'uint64',
+    'float': 'float32',
+    'double': 'float64',
+    'long double': 'float64',
+    'short': 'int16',
+    'long': 'int32',
+    'long long': 'int64',
+    'unsigned short': 'uint16',
+    'unsigned long': 'uint32',
+    'unsigned long long': 'uint64',
+}
+
+
+def _map_basic_type(typename):
+    """Map an IDL basic type name to its ROS2 equivalent."""
+    return IDL_TYPE_TO_ROS2.get(typename, typename)
+
+
+def _get_nestable_type_info(type_obj):
+    """
+    Extract type info from a nestable type (the inner type for arrays/sequences,
+    or the type itself for non-nested types).
+
+    Returns a dict with: pkgName, type, stringUpperBound, isPrimitiveType
+    """
+    if isinstance(type_obj, BasicType):
+        ros2_type = _map_basic_type(type_obj.typename)
+        return {
+            'pkgName': None,
+            'type': ros2_type,
+            'stringUpperBound': None,
+            'isPrimitiveType': True,
+        }
+    elif isinstance(type_obj, (UnboundedString, BoundedString)):
+        string_upper_bound = None
+        if isinstance(type_obj, BoundedString):
+            string_upper_bound = type_obj.maximum_size
+        return {
+            'pkgName': None,
+            'type': 'string',
+            'stringUpperBound': string_upper_bound,
+            'isPrimitiveType': True,
+        }
+    elif isinstance(type_obj, (UnboundedWString, BoundedWString)):
+        string_upper_bound = None
+        if isinstance(type_obj, BoundedWString):
+            string_upper_bound = type_obj.maximum_size
+        return {
+            'pkgName': None,
+            'type': 'wstring',
+            'stringUpperBound': string_upper_bound,
+            'isPrimitiveType': True,
+        }
+    elif isinstance(type_obj, NamespacedType):
+        # Convert Token objects to plain strings if needed
+        namespaces = [str(ns) for ns in type_obj.namespaces]
+        pkg_name = namespaces[0] if namespaces else None
+        return {
+            'pkgName': pkg_name,
+            'type': str(type_obj.name),
+            'stringUpperBound': None,
+            'isPrimitiveType': False,
+        }
+    elif isinstance(type_obj, NamedType):
+        # NamedType is typically resolved by typedefs, but handle it just in case
+        return {
+            'pkgName': None,
+            'type': str(type_obj.name),
+            'stringUpperBound': None,
+            'isPrimitiveType': False,
+        }
+    else:
+        raise ValueError(f'Unexpected nestable type: {type(type_obj).__name__}')
+
+
+def _get_type_json(member_type):
+    """
+    Convert a rosidl_parser type object to the JSON format expected by
+    the rclnodejs templates.
+
+    Returns a dict matching the spec.fields[].type format:
+    {isArray, arraySize, isUpperBound, isDynamicArray, isFixedSizeArray,
+     pkgName, type, stringUpperBound, isPrimitiveType}
+    """
+    if isinstance(member_type, Array):
+        # Fixed-size array: e.g., float64[9]
+        inner_info = _get_nestable_type_info(member_type.value_type)
+        return {
+            'isArray': True,
+            'arraySize': member_type.size,
+            'isUpperBound': False,
+            'isDynamicArray': False,
+            'isFixedSizeArray': True,
+            **inner_info,
+        }
+    elif isinstance(member_type, BoundedSequence):
+        # Bounded dynamic array: e.g., sequence<float64, 3>
+        inner_info = _get_nestable_type_info(member_type.value_type)
+        return {
+            'isArray': True,
+            'arraySize': member_type.maximum_size,
+            'isUpperBound': True,
+            'isDynamicArray': True,
+            'isFixedSizeArray': False,
+            **inner_info,
+        }
+    elif isinstance(member_type, UnboundedSequence):
+        # Unbounded dynamic array: e.g., sequence<float64>
+        inner_info = _get_nestable_type_info(member_type.value_type)
+        return {
+            'isArray': True,
+            'arraySize': None,
+            'isUpperBound': False,
+            'isDynamicArray': True,
+            'isFixedSizeArray': False,
+            **inner_info,
+        }
+    else:
+        # Non-array/sequence type
+        inner_info = _get_nestable_type_info(member_type)
+        return {
+            'isArray': False,
+            'arraySize': None,
+            'isUpperBound': False,
+            'isDynamicArray': False,
+            'isFixedSizeArray': False,
+            **inner_info,
+        }
+
+
+def _get_default_value(member):
+    """Extract default value from member annotations.
+
+    rosidl_parser returns array/sequence defaults as tuple-like strings,
+    e.g., "(0, 127, -128)" or "('', 'max value', 'min value')".
+    The .msg parser returns these as Python lists [0, 127, -128].
+    We need to convert the tuple-strings to proper lists.
+    """
+    try:
+        default_annotation = member.get_annotation_value('default')
+        if isinstance(default_annotation, dict) and 'value' in default_annotation:
+            value = default_annotation['value']
+        else:
+            value = default_annotation
+
+        # If the value is a string that looks like a tuple "(a, b, c)",
+        # parse it into a Python list
+        if isinstance(value, str) and value.startswith('(') and value.endswith(')'):
+            value = _parse_tuple_string(value, member)
+
+        return value
+    except ValueError:
+        return None
+
+
+def _parse_tuple_string(s, member):
+    """
+    Parse a tuple-like string from rosidl_parser into a proper Python list.
+
+    Handles formats like:
+      "(0, 127, -128)" -> [0, 127, -128]
+      "(1.125, 0.0, -1.125)" -> [1.125, 0.0, -1.125]
+      "(False, True, False)" -> [False, True, False]
+      "('', 'max value', 'min value')" -> ['', 'max value', 'min value']
+    """
+    inner = s[1:-1]  # Strip outer parentheses
+
+    # Determine the element type from the member's type
+    member_type = member.type
+    if isinstance(member_type, AbstractNestedType):
+        element_type = member_type.value_type
+    else:
+        element_type = member_type
+
+    # Parse string arrays specially (may contain commas in values)
+    if isinstance(element_type, (UnboundedString, BoundedString,
+                                  UnboundedWString, BoundedWString)):
+        return _parse_string_tuple(inner)
+
+    # For boolean arrays
+    if isinstance(element_type, BasicType) and element_type.typename == 'boolean':
+        parts = [p.strip() for p in inner.split(',')]
+        return [p == 'True' for p in parts]
+
+    # For numeric arrays  
+    parts = [p.strip() for p in inner.split(',')]
+    result = []
+    for part in parts:
+        if not part:
+            continue
+        # Try int first, then float
+        try:
+            result.append(int(part))
+        except ValueError:
+            try:
+                result.append(float(part))
+            except ValueError:
+                result.append(part)
+    return result
+
+
+def _parse_string_tuple(inner):
+    """Parse the inside of a tuple containing quoted strings.
+
+    e.g., "'', 'max value', 'min value'" -> ['', 'max value', 'min value']
+    """
+    result = []
+    i = 0
+    while i < len(inner):
+        if inner[i] == "'":
+            # Find matching closing quote
+            j = i + 1
+            while j < len(inner):
+                if inner[j] == "'":
+                    result.append(inner[i + 1:j])
+                    i = j + 1
+                    break
+                j += 1
+            else:
+                break
+        elif inner[i] == '"':
+            j = i + 1
+            while j < len(inner):
+                if inner[j] == '"':
+                    result.append(inner[i + 1:j])
+                    i = j + 1
+                    break
+                j += 1
+            else:
+                break
+        else:
+            i += 1
+    return result
+
+
+def _get_constant_type_str(constant):
+    """Get the ROS2 type string for a constant."""
+    if isinstance(constant.type, BasicType):
+        return _map_basic_type(constant.type.typename)
+    elif isinstance(constant.type, (UnboundedString, BoundedString)):
+        return 'string'
+    elif isinstance(constant.type, (UnboundedWString, BoundedWString)):
+        return 'wstring'
+    return str(constant.type)
+
+
+def get_json_from_message(msg, pkg_name=None):
+    """
+    Convert a rosidl_parser Message object to JSON spec matching
+    what parser.py produces for .msg files.
+    """
+    namespaced_type = msg.structure.namespaced_type
+    namespaces = [str(ns) for ns in namespaced_type.namespaces]
+    msg_name = str(namespaced_type.name)
+
+    if pkg_name is None:
+        pkg_name = namespaces[0] if namespaces else ''
+
+    # Build fields
+    fields = []
+    for member in msg.structure.members:
+        field = {
+            'name': member.name,
+            'type': _get_type_json(member.type),
+            'default_value': _get_default_value(member),
+        }
+        fields.append(field)
+
+    # Build constants
+    constants = []
+    for constant in msg.constants:
+        constants.append({
+            'type': _get_constant_type_str(constant),
+            'name': constant.name,
+            'value': constant.value,
+        })
+
+    return {
+        'constants': constants,
+        'fields': fields,
+        'baseType': {
+            'pkgName': pkg_name,
+            'type': msg_name,
+            'stringUpperBound': None,
+            'isPrimitiveType': False,
+        },
+        'msgName': msg_name,
+    }
+
+
+def get_json_from_service(srv):
+    """
+    Convert a rosidl_parser Service object to JSON spec matching
+    what parser.py produces for .srv files.
+    """
+    namespaces = [str(ns) for ns in srv.namespaced_type.namespaces]
+    pkg_name = namespaces[0] if namespaces else ''
+    srv_name = str(srv.namespaced_type.name)
+
+    return {
+        'pkgName': pkg_name,
+        'srvName': srv_name,
+        'request': get_json_from_message(srv.request_message, pkg_name),
+        'response': get_json_from_message(srv.response_message, pkg_name),
+    }
+
+
+def get_json_from_action(action):
+    """
+    Convert a rosidl_parser Action object to JSON spec matching
+    what parser.py produces for .action files.
+    """
+    namespaces = [str(ns) for ns in action.namespaced_type.namespaces]
+    pkg_name = namespaces[0] if namespaces else ''
+    action_name = str(action.namespaced_type.name)
+
+    return {
+        'pkgName': pkg_name,
+        'actionName': action_name,
+        'goal': get_json_from_message(action.goal, pkg_name),
+        'result': get_json_from_message(action.result, pkg_name),
+        'feedback': get_json_from_message(action.feedback, pkg_name),
+    }
+
+
+def parse_idl_file(idl_file_path):
+    """
+    Parse an .idl file and return a JSON object in the same format
+    as parser.py produces.
+
+    The return value depends on the interface type:
+    - Message: same format as parse_message_file
+    - Service: same format as parse_service_file
+    - Action: same format as parse_action_file
+
+    Returns a dict with 'type' indicating the interface kind and 'spec'
+    containing the JSON spec.
+    """
+    with open(idl_file_path, 'r') as f:
+        content_str = f.read()
+
+    content = parse_idl_string(content_str)
+
+    # Find the main element (Message, Service, or Action)
+    messages = content.get_elements_of_type(Message)
+    services = content.get_elements_of_type(Service)
+    actions = content.get_elements_of_type(Action)
+
+    if actions:
+        action = actions[0]
+        return {
+            'type': 'action',
+            'spec': get_json_from_action(action),
+        }
+    elif services:
+        service = services[0]
+        return {
+            'type': 'service',
+            'spec': get_json_from_service(service),
+        }
+    elif messages:
+        message = messages[0]
+        return {
+            'type': 'message',
+            'spec': get_json_from_message(message),
+        }
+    else:
+        raise ValueError(f'No Message, Service, or Action found in {idl_file_path}')
+
+
+if __name__ == '__main__':
+    if len(sys.argv) < 2:
+        print('Usage: idl_parser.py <idl_file_path>', file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        result = parse_idl_file(sys.argv[1])
+        print(json.dumps(result))
+        sys.exit(0)
+    except Exception as e:
+        print(str(e), file=sys.stderr)
+        sys.exit(1)

package/rosidl_parser/parser.py

@@ -15,7 +15,6 @@
 import sys
 import json
 
-import rosidl_parser
 from rosidl_adapter import parser
 
 def get_json_object_from_base_type_object(base_type_obj):
@@ -41,15 +40,14 @@ def get_json_object_from_msg_spec_object(msg_spec_object):
     for constant in msg_spec_object.constants:
         constants.append({'type': constant.type, 'name': constant.name, 'value': constant.value})
 
-    msg_name = {'msgName': msg_spec_object.msg_name}
     json_obj = {'constants': constants, 'fields': fields, 'baseType': get_json_object_from_base_type_object(msg_spec_object.base_type),
         'msgName': msg_spec_object.msg_name}
 
     return json_obj
 
 if __name__ == '__main__':
-    if len(sys.argv) < 3:
-        print('Wrong number of argments')
+    if len(sys.argv) < 4:
+        print('Usage: {} <command> <packageName> <filePath>'.format(sys.argv[0]), file=sys.stderr)
         sys.exit(1)
     try:
         parser_method = getattr(parser, sys.argv[1])

package/rosidl_parser/rosidl_parser.js

@@ -41,6 +41,33 @@ const rosidlParser = {
     return this._parseFile('parse_action_file', packageName, filePath);
   },
 
+  /**
+   * Parse an .idl file directly using rosidl_parser (no .msg conversion needed).
+   * Returns an object with { type: 'message'|'service'|'action', spec: ... }
+   * where spec matches the same format as parseMessageFile/parseServiceFile/parseActionFile.
+   */
+  parseIdlFile(filePath) {
+    return new Promise((resolve, reject) => {
+      const args = [path.join(__dirname, 'idl_parser.py'), filePath];
+      const [pythonExecutableFile, pythonExecutableArgs] = pythonExecutable;
+      execFile(
+        pythonExecutableFile,
+        pythonExecutableArgs.concat(args),
+        (err, stdout, stderr) => {
+          if (err) {
+            reject(
+              new Error(
+                `There was an error parsing IDL file "${filePath}": "${err}"; stderr was: ${stderr}`
+              )
+            );
+          } else {
+            resolve(this._parseJSONObject(stdout));
+          }
+        }
+      );
+    });
+  },
+
   _parseJSONObject(str) {
     // For nodejs >= `contextSupportedVersion`, we leverage context parameter to
     // convert unsafe integer to string, otherwise, json-bigint is used.

package/src/executor.cpp

@@ -110,6 +110,7 @@ void Executor::Stop() {
 
     if (uv_is_active(reinterpret_cast<uv_handle_t*>(async_))) {
       static bool handle_closed = false;
+      handle_closed = false;
       uv_close(reinterpret_cast<uv_handle_t*>(async_),
                [](uv_handle_t* async) -> void {
                  // Important Notice:

package/src/macros.h

@@ -22,8 +22,8 @@
 #define CHECK_OP_AND_THROW_ERROR_IF_NOT_TRUE(op, lhs, rhs, message) \
   {                                                                 \
     if (lhs op rhs) {                                               \
-      rcl_reset_error();                                            \
       Napi::Error::New(env, message).ThrowAsJavaScriptException();  \
+      rcl_reset_error();                                            \
       return env.Undefined();                                       \
     }                                                               \
   }
@@ -31,8 +31,8 @@
 #define CHECK_OP_AND_THROW_ERROR_IF_NOT_TRUE_NO_RETURN(op, lhs, rhs, message) \
   {                                                                           \
     if (lhs op rhs) {                                                         \
-      rcl_reset_error();                                                      \
       Napi::Error::New(env, message).ThrowAsJavaScriptException();            \
+      rcl_reset_error();                                                      \
     }                                                                         \
   }
 

package/src/rcl_action_client_bindings.cpp

@@ -70,10 +70,17 @@ Napi::Value ActionCreateClient(const Napi::CallbackInfo& info) {
         malloc(sizeof(rcl_action_client_t)));
     *action_client = rcl_action_get_zero_initialized_client();
 
-    THROW_ERROR_IF_NOT_EQUAL(
-        rcl_action_client_init(action_client, node, ts, action_name.c_str(),
-                               &action_client_ops),
-        RCL_RET_OK, rcl_get_error_string().str);
+    {
+      rcl_ret_t ret = rcl_action_client_init(
+          action_client, node, ts, action_name.c_str(), &action_client_ops);
+      if (RCL_RET_OK != ret) {
+        std::string error_msg = rcl_get_error_string().str;
+        rcl_reset_error();
+        free(action_client);
+        Napi::Error::New(env, error_msg).ThrowAsJavaScriptException();
+        return env.Undefined();
+      }
+    }
     auto js_obj = RclHandle::NewInstance(
         env, action_client, node_handle, [node, env](void* ptr) {
           rcl_action_client_t* action_client =
@@ -125,7 +132,7 @@ Napi::Value ActionSendGoalRequest(const Napi::CallbackInfo& info) {
       rcl_action_send_goal_request(action_client, buffer, &sequence_number),
       RCL_RET_OK, rcl_get_error_string().str);
 
-  return Napi::Number::New(env, static_cast<int32_t>(sequence_number));
+  return Napi::Number::New(env, static_cast<double>(sequence_number));
 }
 
 Napi::Value ActionSendResultRequest(const Napi::CallbackInfo& info) {
@@ -142,7 +149,7 @@ Napi::Value ActionSendResultRequest(const Napi::CallbackInfo& info) {
       rcl_action_send_result_request(action_client, buffer, &sequence_number),
       RCL_RET_OK, rcl_get_error_string().str);
 
-  return Napi::Number::New(env, static_cast<int32_t>(sequence_number));
+  return Napi::Number::New(env, static_cast<double>(sequence_number));
 }
 
 Napi::Value ActionTakeFeedback(const Napi::CallbackInfo& info) {
@@ -156,9 +163,9 @@ Napi::Value ActionTakeFeedback(const Napi::CallbackInfo& info) {
 
   rcl_ret_t ret = rcl_action_take_feedback(action_client, buffer);
   if (ret != RCL_RET_OK && ret != RCL_RET_ACTION_CLIENT_TAKE_FAILED) {
-    Napi::Error::New(env, rcl_get_error_string().str)
-        .ThrowAsJavaScriptException();
+    std::string error_msg = rcl_get_error_string().str;
     rcl_reset_error();
+    Napi::Error::New(env, error_msg).ThrowAsJavaScriptException();
     return Napi::Boolean::New(env, false);
   }
 
@@ -179,9 +186,9 @@ Napi::Value ActionTakeStatus(const Napi::CallbackInfo& info) {
 
   rcl_ret_t ret = rcl_action_take_status(action_client, buffer);
   if (ret != RCL_RET_OK && ret != RCL_RET_ACTION_CLIENT_TAKE_FAILED) {
+    std::string error_msg = rcl_get_error_string().str;
     rcl_reset_error();
-    Napi::Error::New(env, rcl_get_error_string().str)
-        .ThrowAsJavaScriptException();
+    Napi::Error::New(env, error_msg).ThrowAsJavaScriptException();
     return Napi::Boolean::New(env, false);
   }
 
@@ -240,7 +247,7 @@ Napi::Value ActionSendCancelRequest(const Napi::CallbackInfo& info) {
       rcl_action_send_cancel_request(action_client, buffer, &sequence_number),
       RCL_RET_OK, rcl_get_error_string().str);
 
-  return Napi::Number::New(env, static_cast<int32_t>(sequence_number));
+  return Napi::Number::New(env, static_cast<double>(sequence_number));
 }
 
 #if ROS_VERSION >= 2505  // ROS2 >= Kilted