rclnodejs 1.1.0 → 1.3.0

package/src/rcl_lifecycle_bindings.cpp

@@ -83,12 +83,13 @@ Napi::Value CreateLifecycleStateMachine(const Napi::CallbackInfo& info) {
       rcl_get_error_string().str);
 
   auto js_obj = RclHandle::NewInstance(
-      env, state_machine, node_handle, [node](void* ptr) {
+      env, state_machine, node_handle, [node, env](void* ptr) {
         rcl_lifecycle_state_machine_t* state_machine =
             reinterpret_cast<rcl_lifecycle_state_machine_t*>(ptr);
         rcl_ret_t ret = rcl_lifecycle_state_machine_fini(state_machine, node);
         free(ptr);
-        THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
+        THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(RCL_RET_OK, ret,
+                                           rcl_get_error_string().str);
       });
 #else
   const rcl_node_options_t* node_options =
@@ -101,13 +102,14 @@ Napi::Value CreateLifecycleStateMachine(const Napi::CallbackInfo& info) {
                            rcl_get_error_string().str);
 
   auto js_obj = RclHandle::NewInstance(
-      env, state_machine, node_handle, [node, node_options](void* ptr) {
+      env, state_machine, node_handle, [node, node_options, env](void* ptr) {
         rcl_lifecycle_state_machine_t* state_machine =
             reinterpret_cast<rcl_lifecycle_state_machine_t*>(ptr);
         rcl_ret_t ret = rcl_lifecycle_state_machine_fini(
             state_machine, node, &node_options->allocator);
         free(ptr);
-        THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
+        THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(RCL_RET_OK, ret,
+                                           rcl_get_error_string().str);
       });
 #endif
 
@@ -372,6 +374,17 @@ Napi::Value IsInitialized(const Napi::CallbackInfo& info) {
   return Napi::Boolean::New(env, is_initialized);
 }
 
+Napi::Value Print(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* state_machine_handle =
+      RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_lifecycle_state_machine_t* state_machine =
+      reinterpret_cast<rcl_lifecycle_state_machine_t*>(
+          state_machine_handle->ptr());
+  rcl_print_state_machine(state_machine);
+  return env.Undefined();
+}
+
 Napi::Object InitLifecycleBindings(Napi::Env env, Napi::Object exports) {
   exports.Set("createLifecycleStateMachine",
               Napi::Function::New(env, CreateLifecycleStateMachine));
@@ -396,6 +409,7 @@ Napi::Object InitLifecycleBindings(Napi::Env env, Napi::Object exports) {
   exports.Set("getLifecycleShutdownTransitionLabel",
               Napi::Function::New(env, GetLifecycleShutdownTransitionLabel));
   exports.Set("isInitialized", Napi::Function::New(env, IsInitialized));
+  exports.Set("print", Napi::Function::New(env, Print));
   return exports;
 }
 

package/src/rcl_node_bindings.cpp

@@ -20,10 +20,13 @@
 #include <rcl/arguments.h>
 #include <rcl/error_handling.h>
 #include <rcl/rcl.h>
+#include <rcl/remap.h>
 #include <rcl_action/rcl_action.h>
 #include <rcl_yaml_param_parser/parser.h>
 #include <rcl_yaml_param_parser/types.h>
 
+#include <rcpputils/scope_exit.hpp>
+// NOLINTNEXTLINE
 #include <string>
 
 #include "macros.h"
@@ -180,21 +183,46 @@ Napi::Value CreateNode(const Napi::CallbackInfo& info) {
   rcl_context_t* context =
       reinterpret_cast<rcl_context_t*>(context_handle->ptr());
 
-  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(malloc(sizeof(rcl_node_t)));
+  Napi::Array jsArgv = info[3].As<Napi::Array>();
+  size_t argc = jsArgv.Length();
+  char** argv = AbstractArgsFromNapiArray(jsArgv);
+  RCPPUTILS_SCOPE_EXIT({ FreeArgs(argv, argc); });
+
+  rcl_arguments_t arguments = rcl_get_zero_initialized_arguments();
+  rcl_ret_t ret =
+      rcl_parse_arguments(argc, argv, rcl_get_default_allocator(), &arguments);
+  if ((ret != RCL_RET_OK) || HasUnparsedROSArgs(arguments)) {
+    Napi::Error::New(env, "failed to parse arguments")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
 
+  RCPPUTILS_SCOPE_EXIT({
+    if (RCL_RET_OK != rcl_arguments_fini(&arguments)) {
+      Napi::Error::New(env, "failed to fini arguments")
+          .ThrowAsJavaScriptException();
+      rcl_reset_error();
+    }
+  });
+  bool use_global_arguments = info[4].As<Napi::Boolean>().Value();
+  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(malloc(sizeof(rcl_node_t)));
   *node = rcl_get_zero_initialized_node();
+
   rcl_node_options_t options = rcl_node_get_default_options();
+  options.use_global_arguments = use_global_arguments;
+  options.arguments = arguments;
 
   THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
                            rcl_node_init(node, node_name.c_str(),
                                          name_space.c_str(), context, &options),
                            rcl_get_error_string().str);
 
-  auto handle = RclHandle::NewInstance(env, node, nullptr, [](void* ptr) {
+  auto handle = RclHandle::NewInstance(env, node, nullptr, [env](void* ptr) {
     rcl_node_t* node = reinterpret_cast<rcl_node_t*>(ptr);
     rcl_ret_t ret = rcl_node_fini(node);
     free(ptr);
-    THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
+    THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(RCL_RET_OK, ret,
+                                       rcl_get_error_string().str);
   });
 
   return handle;
@@ -446,6 +474,82 @@ Napi::Value GetFullyQualifiedName(const Napi::CallbackInfo& info) {
   return Napi::String::New(env, fully_qualified_node_name);
 }
 
+Napi::Value GetRMWImplementationIdentifier(const Napi::CallbackInfo& info) {
+  return Napi::String::New(info.Env(), rmw_get_implementation_identifier());
+}
+
+Napi::Value ResolveName(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* node_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
+  const rcl_node_options_t* node_options = rcl_node_get_options(node);
+  std::string topic_name = info[1].As<Napi::String>().Utf8Value();
+  bool only_expand = info[2].As<Napi::Boolean>().Value();
+  bool is_service = info[3].As<Napi::Boolean>().Value();
+
+  char* output_cstr = nullptr;
+  rcl_ret_t ret =
+      rcl_node_resolve_name(node, topic_name.c_str(), node_options->allocator,
+                            is_service, only_expand, &output_cstr);
+
+  auto name_deleter = [&]() {
+    node_options->allocator.deallocate(output_cstr,
+                                       node_options->allocator.state);
+  };
+
+  RCPPUTILS_SCOPE_EXIT({ name_deleter(); });
+
+  if (RCL_RET_OK != ret) {
+    Napi::Error::New(env, ("failed to resolve name"))
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  return Napi::String::New(env, output_cstr);
+}
+
+Napi::Value RemapTopicName(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* node_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
+  std::string topic_name = info[1].As<Napi::String>().Utf8Value();
+
+  const rcl_node_options_t* node_options = rcl_node_get_options(node);
+  if (nullptr == node_options) {
+    Napi::Error::New(env, "failed to get node options")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  const rcl_arguments_t* global_args = nullptr;
+  if (node_options->use_global_arguments) {
+    global_args = &(node->context->global_arguments);
+  }
+
+  char* output_cstr = nullptr;
+  rcl_ret_t ret = rcl_remap_topic_name(
+      &(node_options->arguments), global_args, topic_name.c_str(),
+      rcl_node_get_name(node), rcl_node_get_namespace(node),
+      node_options->allocator, &output_cstr);
+  if (RCL_RET_OK != ret) {
+    Napi::Error::New(env, "failed to remap topic name")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  if (nullptr == output_cstr) {
+    return Napi::String::New(env, topic_name);
+  }
+
+  auto name_deleter = [&]() {
+    node_options->allocator.deallocate(output_cstr,
+                                       node_options->allocator.state);
+  };
+  RCPPUTILS_SCOPE_EXIT({ name_deleter(); });
+
+  return Napi::String::New(env, output_cstr);
+}
+
 Napi::Object InitNodeBindings(Napi::Env env, Napi::Object exports) {
   exports.Set("getParameterOverrides",
               Napi::Function::New(env, GetParameterOverrides));
@@ -468,6 +572,10 @@ Napi::Object InitNodeBindings(Napi::Env env, Napi::Object exports) {
   exports.Set("getNodeNames", Napi::Function::New(env, GetNodeNames));
   exports.Set("getFullyQualifiedName",
               Napi::Function::New(env, GetFullyQualifiedName));
+  exports.Set("getRMWImplementationIdentifier",
+              Napi::Function::New(env, GetRMWImplementationIdentifier));
+  exports.Set("resolveName", Napi::Function::New(env, ResolveName));
+  exports.Set("remapTopicName", Napi::Function::New(env, RemapTopicName));
   return exports;
 }
 

package/src/rcl_publisher_bindings.cpp

@@ -55,12 +55,13 @@ Napi::Value CreatePublisher(const Napi::CallbackInfo& info) {
         rcl_publisher_init(publisher, node, ts, topic.c_str(), &publisher_ops),
         RCL_RET_OK, rcl_get_error_string().str);
 
-    auto js_obj =
-        RclHandle::NewInstance(env, publisher, node_handle, [node](void* ptr) {
+    auto js_obj = RclHandle::NewInstance(
+        env, publisher, node_handle, [node, env](void* ptr) {
           rcl_publisher_t* publisher = reinterpret_cast<rcl_publisher_t*>(ptr);
           rcl_ret_t ret = rcl_publisher_fini(publisher, node);
           free(ptr);
-          THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
+          THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(RCL_RET_OK, ret,
+                                             rcl_get_error_string().str);
         });
 
     return js_obj;

package/src/rcl_serialization_bindings.cpp

@@ -0,0 +1,116 @@
+// 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.
+
+#include "rcl_serialization_bindings.h"
+
+#include <rmw/rmw.h>
+#include <rmw/serialized_message.h>
+#include <rosidl_runtime_c/message_type_support_struct.h>
+
+#include <string>
+
+#include "rcl_utilities.h"
+
+namespace {
+
+struct SerializedMessage {
+  explicit SerializedMessage(Napi::Env env, rcutils_allocator_t allocator)
+      : env(env) {
+    rcl_msg = rmw_get_zero_initialized_serialized_message();
+    rcutils_ret_t rcutils_ret =
+        rmw_serialized_message_init(&rcl_msg, 0u, &allocator);
+    if (RCUTILS_RET_OK != rcutils_ret) {
+      Napi::Error::New(env, "failed to initialize serialized message")
+          .ThrowAsJavaScriptException();
+    }
+  }
+
+  ~SerializedMessage() {
+    rcutils_ret_t ret = rmw_serialized_message_fini(&rcl_msg);
+    if (RCUTILS_RET_OK != ret) {
+      Napi::Error::New(env,
+                       "failed to fini rcl_serialized_msg_t in destructor.")
+          .ThrowAsJavaScriptException();
+      rcutils_reset_error();
+    }
+  }
+
+  rcl_serialized_message_t rcl_msg;
+  Napi::Env env;
+};
+
+}  // namespace
+
+namespace rclnodejs {
+
+Napi::Value Serialize(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  std::string package_name = info[0].As<Napi::String>().Utf8Value();
+  std::string message_sub_folder = info[1].As<Napi::String>().Utf8Value();
+  std::string message_name = info[2].As<Napi::String>().Utf8Value();
+  void* ros_msg = info[3].As<Napi::Buffer<char>>().Data();
+  const rosidl_message_type_support_t* ts =
+      GetMessageTypeSupport(package_name, message_sub_folder, message_name);
+
+  // Create a serialized message object.
+  SerializedMessage serialized_msg(env, rcutils_get_default_allocator());
+
+  rmw_ret_t rmw_ret = rmw_serialize(ros_msg, ts, &serialized_msg.rcl_msg);
+  if (RMW_RET_OK != rmw_ret) {
+    Napi::Error::New(env, "Failed to serialize ROS message")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  Napi::Buffer<char> buffer = Napi::Buffer<char>::Copy(
+      env, reinterpret_cast<const char*>(serialized_msg.rcl_msg.buffer),
+      serialized_msg.rcl_msg.buffer_length);
+  return buffer;
+}
+
+Napi::Value Deserialize(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  std::string package_name = info[0].As<Napi::String>().Utf8Value();
+  std::string message_sub_folder = info[1].As<Napi::String>().Utf8Value();
+  std::string message_name = info[2].As<Napi::String>().Utf8Value();
+  const rosidl_message_type_support_t* ts =
+      GetMessageTypeSupport(package_name, message_sub_folder, message_name);
+  Napi::Buffer<char> serialized = info[3].As<Napi::Buffer<char>>();
+  void* msg_taken = info[4].As<Napi::Buffer<char>>().Data();
+
+  // Create a serialized message object.
+  rcl_serialized_message_t serialized_msg =
+      rmw_get_zero_initialized_serialized_message();
+  serialized_msg.buffer_capacity = serialized.Length();
+  serialized_msg.buffer_length = serialized.Length();
+  serialized_msg.buffer = reinterpret_cast<uint8_t*>(serialized.Data());
+
+  rmw_ret_t rmw_ret = rmw_deserialize(&serialized_msg, ts, msg_taken);
+
+  if (RMW_RET_OK != rmw_ret) {
+    Napi::Error::New(env, "failed to deserialize ROS message")
+        .ThrowAsJavaScriptException();
+  }
+
+  return env.Undefined();
+}
+
+Napi::Object InitSerializationBindings(Napi::Env env, Napi::Object exports) {
+  exports.Set("serialize", Napi::Function::New(env, Serialize));
+  exports.Set("deserialize", Napi::Function::New(env, Deserialize));
+  return exports;
+}
+
+}  // namespace rclnodejs

package/src/rcl_serialization_bindings.h

@@ -0,0 +1,26 @@
+// 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.
+
+#ifndef SRC_RCL_SERIALIZATION_BINDINGS_H_
+#define SRC_RCL_SERIALIZATION_BINDINGS_H_
+
+#include <napi.h>
+
+namespace rclnodejs {
+
+Napi::Object InitSerializationBindings(Napi::Env env, Napi::Object exports);
+
+}
+
+#endif  // SRC_RCL_SERIALIZATION_BINDINGS_H_

package/src/rcl_service_bindings.cpp

@@ -55,12 +55,13 @@ Napi::Value CreateService(const Napi::CallbackInfo& info) {
     THROW_ERROR_IF_NOT_EQUAL(
         rcl_service_init(service, node, ts, service_name.c_str(), &service_ops),
         RCL_RET_OK, rcl_get_error_string().str);
-    auto js_obj =
-        RclHandle::NewInstance(env, service, node_handle, [node](void* ptr) {
+    auto js_obj = RclHandle::NewInstance(
+        env, service, node_handle, [node, env](void* ptr) {
           rcl_service_t* service = reinterpret_cast<rcl_service_t*>(ptr);
           rcl_ret_t ret = rcl_service_fini(service, node);
           free(ptr);
-          THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
+          THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(RCL_RET_OK, ret,
+                                             rcl_get_error_string().str);
         });
 
     return js_obj;

package/src/rcl_subscription_bindings.cpp

@@ -136,12 +136,13 @@ Napi::Value CreateSubscription(const Napi::CallbackInfo& info) {
         rcl_get_error_string().str);
 
     auto js_obj = RclHandle::NewInstance(
-        env, subscription, node_handle, [node](void* ptr) {
+        env, subscription, node_handle, [node, env](void* ptr) {
           rcl_subscription_t* subscription =
               reinterpret_cast<rcl_subscription_t*>(ptr);
           rcl_ret_t ret = rcl_subscription_fini(subscription, node);
           free(ptr);
-          THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
+          THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(RCL_RET_OK, ret,
+                                             rcl_get_error_string().str);
         });
 
     return js_obj;

package/src/rcl_time_point_bindings.cpp

@@ -151,11 +151,12 @@ Napi::Value CreateClock(const Napi::CallbackInfo& info) {
                            rcl_clock_init(clock_type, clock, &allocator),
                            rcl_get_error_string().str);
 
-  return RclHandle::NewInstance(env, clock, nullptr, [](void* ptr) {
+  return RclHandle::NewInstance(env, clock, nullptr, [env](void* ptr) {
     rcl_clock_t* clock = reinterpret_cast<rcl_clock_t*>(ptr);
     rcl_ret_t ret = rcl_clock_fini(clock);
     free(ptr);
-    THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
+    THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(RCL_RET_OK, ret,
+                                       rcl_get_error_string().str);
   });
 }
 

package/src/rcl_timer_bindings.cpp

@@ -58,12 +58,14 @@ Napi::Value CreateTimer(const Napi::CallbackInfo& info) {
                            rcl_get_error_string().str);
 #endif
 
-  auto js_obj = RclHandle::NewInstance(env, timer, clock_handle, [](void* ptr) {
-    rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(ptr);
-    rcl_ret_t ret = rcl_timer_fini(timer);
-    free(ptr);
-    THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
-  });
+  auto js_obj =
+      RclHandle::NewInstance(env, timer, clock_handle, [env](void* ptr) {
+        rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(ptr);
+        rcl_ret_t ret = rcl_timer_fini(timer);
+        free(ptr);
+        THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(RCL_RET_OK, ret,
+                                           rcl_get_error_string().str);
+      });
 
   return js_obj;
 }

package/src/rcl_utilities.cpp

@@ -19,6 +19,7 @@
 #include <rmw/topic_endpoint_info.h>
 #include <uv.h>
 
+#include <cstdio>
 #include <memory>
 #include <string>
 
@@ -260,4 +261,34 @@ Napi::Array ConvertToJSTopicEndpointInfoList(
   return list;
 }
 
+char** AbstractArgsFromNapiArray(const Napi::Array& jsArgv) {
+  size_t argc = jsArgv.Length();
+  char** argv = nullptr;
+
+  if (argc > 0) {
+    argv = reinterpret_cast<char**>(malloc(argc * sizeof(char*)));
+    for (size_t i = 0; i < argc; i++) {
+      std::string arg = jsArgv.Get(i).As<Napi::String>().Utf8Value();
+      int len = arg.length() + 1;
+      argv[i] = reinterpret_cast<char*>(malloc(len * sizeof(char)));
+      snprintf(argv[i], len, "%s", arg.c_str());
+    }
+  }
+  return argv;
+}
+
+void FreeArgs(char** argv, size_t argc) {
+  if (argv) {
+    for (size_t i = 0; i < argc; i++) {
+      free(argv[i]);
+    }
+    free(argv);
+  }
+}
+
+bool HasUnparsedROSArgs(const rcl_arguments_t& rcl_args) {
+  int unparsed_ros_args_count = rcl_arguments_get_count_unparsed_ros(&rcl_args);
+  return unparsed_ros_args_count != 0;
+}
+
 }  // namespace rclnodejs

package/src/rcl_utilities.h

@@ -53,6 +53,13 @@ Napi::Array ConvertToJSTopicEndpointInfoList(
 
 Napi::Value ConvertToQoS(Napi::Env env, const rmw_qos_profile_t* qos_profile);
 
+// `AbstractArgsFromNapiArray` and `FreeArgs` must be called in pairs.
+char** AbstractArgsFromNapiArray(const Napi::Array& jsArgv);
+// `AbstractArgsFromNapiArray` and `FreeArgs` must be called in pairs.
+void FreeArgs(char** argv, size_t argc);
+
+bool HasUnparsedROSArgs(const rcl_arguments_t& rcl_args);
+
 }  // namespace rclnodejs
 
 #endif  // SRC_RCL_UTILITIES_H_

package/tsconfig.json

@@ -2,7 +2,7 @@
   "compilerOptions": {
     "module": "commonjs",
     "moduleResolution": "node",
-    "target": "es6",
+    "target": "es2020",
     /* Strict Type-Checking Options */
     "strict": true,
     /* Additional Checks */
@@ -11,7 +11,7 @@
     "noUnusedParameters": true,
     "noImplicitReturns": true,
     "noFallthroughCasesInSwitch": true,
-    "lib": ["es2017"]
+    "lib": ["es2020"]
   },
   "include": [
         "types/**/*"

package/types/context.d.ts

@@ -38,8 +38,9 @@ declare module 'rclnodejs' {
      * Create a new instance in uninitialized state.
      * Call rcl.init(context) to initialize this context state for
      * use in creating nodes, etc.
+     * @param {bigint} - Optional, The domain ID of this context.
      */
-    constructor();
+    constructor(domainId?: bigint);
 
     /**
      * Test if this context has not been initialized by rcl.init(context).
@@ -92,6 +93,6 @@ declare module 'rclnodejs' {
      * Get the domain ID of this context.
      * @returns domain ID of this context
      */
-    domainId(): number;
+    domainId(): bigint;
   }
 }

package/types/index.d.ts

@@ -1,6 +1,8 @@
 /// <reference path="./base.d.ts" />
 
 declare module 'rclnodejs' {
+  type Class = new (...args: any[]) => any;
+
   /**
    * Create a node.
    *
@@ -11,6 +13,9 @@ declare module 'rclnodejs' {
    * @param namespace - The namespace used in ROS, default is an empty string.
    * @param context - The context, default is Context.defaultContext().
    * @param options - The node options, default is NodeOptions.defaultOptions.
+   * @param args - The arguments to be passed to the node, default is an empty array.
+   * @param useGlobalArguments - If true, the node will use global arguments, default is true.
+   *                            If false, the node will not use global arguments.
    * @returns The new Node instance.
    * @deprecated since 0.18.0, Use new Node constructor.
    */
@@ -18,7 +23,9 @@ declare module 'rclnodejs' {
     nodeName: string,
     namespace?: string,
     context?: Context,
-    options?: NodeOptions
+    options?: NodeOptions,
+    args?: string[],
+    useGlobalArguments?: boolean
   ): Node;
 
   /**
@@ -182,4 +189,22 @@ declare module 'rclnodejs' {
    * @returns An array of the names and types.
    */
   function getActionNamesAndTypes(node: Node): NamesAndTypesQueryResult;
+
+  /**
+   * Serialize a message to a Buffer.
+   *
+   * @param message - The message to be serialized.
+   * @param typeClass - The type class of the message.
+   * @returns A Buffer containing the serialized message.
+   */
+  function serializeMessage(message: object, typeClass: Class): Buffer;
+
+  /**
+   * Deserialize a message from a Buffer.
+   *
+   * @param buffer - The Buffer containing the serialized message.
+   * @param typeClass - The type class of the message.
+   * @returns An Object representing the deserialized message.
+   */
+  function deserializeMessage(buffer: Buffer, typeClass: Class): object;
 }

package/types/lifecycle.d.ts

@@ -333,6 +333,13 @@ declare module 'rclnodejs' {
        * @returns {boolean} true if the state machine is initialized; otherwise false.
        */
       get isInitialized(): boolean;
+
+      /**
+       * Log the state machine data.
+       *
+       * @returns {undefined} void.
+       */
+      print(): void;
     }
   } // lifecycle namespace
 } // rclnodejs namespace