rclnodejs 0.33.0 → 1.0.0

package/src/rcl_time_point_bindings.cpp

@@ -0,0 +1,194 @@
+// 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_time_point_bindings.h"
+
+#include <rcl/error_handling.h>
+#include <rcl/rcl.h>
+
+#include <memory>
+
+#include "macros.h"
+#include "rcl_handle.h"
+#include "rcl_utilities.h"
+
+namespace rclnodejs {
+
+Napi::Value CreateTimePoint(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (!info[0].IsBigInt()) {
+    Napi::TypeError::New(env, "Timer period must be a BigInt")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  bool lossless;
+  int64_t nanoseconds = info[0].As<Napi::BigInt>().Int64Value(&lossless);
+  uint32_t clock_type = info[1].As<Napi::Number>().Uint32Value();
+  rcl_time_point_t* time_point =
+      reinterpret_cast<rcl_time_point_t*>(malloc(sizeof(rcl_time_point_t)));
+
+  time_point->nanoseconds = nanoseconds;
+  time_point->clock_type = static_cast<rcl_clock_type_t>(clock_type);
+
+  auto js_obj = RclHandle::NewInstance(env, time_point, nullptr,
+                                       [](void* ptr) { free(ptr); });
+
+  return js_obj;
+}
+
+Napi::Value GetNanoseconds(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* time_point_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_time_point_t* time_point =
+      reinterpret_cast<rcl_time_point_t*>(time_point_handle->ptr());
+
+  return Napi::BigInt::New(env, time_point->nanoseconds);
+}
+
+Napi::Value CreateDuration(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (!info[0].IsBigInt()) {
+    Napi::TypeError::New(env, "Timer period must be a BigInt")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  bool lossless;
+  int64_t nanoseconds = info[0].As<Napi::BigInt>().Int64Value(&lossless);
+  rcl_duration_t* duration =
+      reinterpret_cast<rcl_duration_t*>(malloc(sizeof(rcl_duration_t)));
+  duration->nanoseconds = nanoseconds;
+
+  auto js_obj = RclHandle::NewInstance(env, duration, nullptr,
+                                       [](void* ptr) { free(ptr); });
+
+  return js_obj;
+}
+
+Napi::Value GetDurationNanoseconds(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* duration_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_duration_t* duration =
+      reinterpret_cast<rcl_duration_t*>(duration_handle->ptr());
+
+  return Napi::BigInt::New(env, duration->nanoseconds);
+}
+
+Napi::Value SetRosTimeOverrideIsEnabled(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* clock_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_clock_t* clock = reinterpret_cast<rcl_clock_t*>(clock_handle->ptr());
+  bool enabled = info[1].As<Napi::Boolean>();
+
+  if (enabled) {
+    THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, rcl_enable_ros_time_override(clock),
+                             rcl_get_error_string().str);
+  } else {
+    THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, rcl_disable_ros_time_override(clock),
+                             rcl_get_error_string().str);
+  }
+
+  return env.Undefined();
+}
+
+Napi::Value SetRosTimeOverride(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* clock_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_clock_t* clock = reinterpret_cast<rcl_clock_t*>(clock_handle->ptr());
+  RclHandle* time_point_handle = RclHandle::Unwrap(info[1].As<Napi::Object>());
+  rcl_time_point_t* time_point =
+      reinterpret_cast<rcl_time_point_t*>(time_point_handle->ptr());
+
+  THROW_ERROR_IF_NOT_EQUAL(
+      RCL_RET_OK, rcl_set_ros_time_override(clock, time_point->nanoseconds),
+      rcl_get_error_string().str);
+
+  return env.Undefined();
+}
+
+Napi::Value GetRosTimeOverrideIsEnabled(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* clock_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_clock_t* clock = reinterpret_cast<rcl_clock_t*>(clock_handle->ptr());
+
+  bool is_enabled;
+  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
+                           rcl_is_enabled_ros_time_override(clock, &is_enabled),
+                           rcl_get_error_string().str);
+
+  return Napi::Boolean::New(env, is_enabled);
+}
+
+Napi::Value CreateClock(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  auto clock_type =
+      static_cast<rcl_clock_type_t>(info[0].As<Napi::Number>().Int32Value());
+  rcl_clock_t* clock =
+      reinterpret_cast<rcl_clock_t*>(malloc(sizeof(rcl_clock_t)));
+  rcl_allocator_t allocator = rcl_get_default_allocator();
+
+  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
+                           rcl_clock_init(clock_type, clock, &allocator),
+                           rcl_get_error_string().str);
+
+  return RclHandle::NewInstance(env, clock, nullptr, [](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);
+  });
+}
+
+Napi::Value ClockGetNow(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  rcl_clock_t* clock = reinterpret_cast<rcl_clock_t*>(
+      RclHandle::Unwrap(info[0].As<Napi::Object>())->ptr());
+  rcl_time_point_t time_point;
+  time_point.clock_type = clock->type;
+
+  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
+                           rcl_clock_get_now(clock, &time_point.nanoseconds),
+                           rcl_get_error_string().str);
+
+  return Napi::BigInt::New(env, time_point.nanoseconds);
+}
+
+Napi::Object InitTimePointBindings(Napi::Env env, Napi::Object exports) {
+  exports.Set("createClock", Napi::Function::New(env, CreateClock));
+  exports.Set("clockGetNow", Napi::Function::New(env, ClockGetNow));
+  exports.Set("createTimePoint", Napi::Function::New(env, CreateTimePoint));
+  exports.Set("getNanoseconds", Napi::Function::New(env, GetNanoseconds));
+  exports.Set("createDuration", Napi::Function::New(env, CreateDuration));
+  exports.Set("getDurationNanoseconds",
+              Napi::Function::New(env, GetDurationNanoseconds));
+  exports.Set("setRosTimeOverrideIsEnabled",
+              Napi::Function::New(env, SetRosTimeOverrideIsEnabled));
+  exports.Set("setRosTimeOverride",
+              Napi::Function::New(env, SetRosTimeOverride));
+  exports.Set("getRosTimeOverrideIsEnabled",
+              Napi::Function::New(env, GetRosTimeOverrideIsEnabled));
+  return exports;
+}
+
+}  // namespace rclnodejs

package/src/rcl_time_point_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_TIME_POINT_BINDINGS_H_
+#define SRC_RCL_TIME_POINT_BINDINGS_H_
+
+#include <napi.h>
+
+namespace rclnodejs {
+
+Napi::Object InitTimePointBindings(Napi::Env env, Napi::Object exports);
+
+}
+
+#endif  // SRC_RCL_TIME_POINT_BINDINGS_H_

package/src/rcl_timer_bindings.cpp

@@ -0,0 +1,237 @@
+// 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_timer_bindings.h"
+
+#include <rcl/error_handling.h>
+#include <rcl/rcl.h>
+
+#include "macros.h"
+#include "rcl_handle.h"
+#include "rcl_utilities.h"
+
+namespace rclnodejs {
+
+Napi::Value CreateTimer(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* clock_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_clock_t* clock = reinterpret_cast<rcl_clock_t*>(clock_handle->ptr());
+
+  RclHandle* context_handle = RclHandle::Unwrap(info[1].As<Napi::Object>());
+  rcl_context_t* context =
+      reinterpret_cast<rcl_context_t*>(context_handle->ptr());
+
+  if (!info[2].IsBigInt()) {
+    Napi::TypeError::New(env, "Timer period must be a BigInt")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  bool lossless;
+  int64_t period_nsec = info[2].As<Napi::BigInt>().Int64Value(&lossless);
+  rcl_timer_t* timer =
+      reinterpret_cast<rcl_timer_t*>(malloc(sizeof(rcl_timer_t)));
+  *timer = rcl_get_zero_initialized_timer();
+
+#if ROS_VERSION > 2305  // After Iron.
+  THROW_ERROR_IF_NOT_EQUAL(
+      RCL_RET_OK,
+      rcl_timer_init2(timer, clock, context, period_nsec, nullptr,
+                      rcl_get_default_allocator(), /*autostart=*/true),
+      rcl_get_error_string().str);
+#else
+  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
+                           rcl_timer_init(timer, clock, context, period_nsec,
+                                          nullptr, rcl_get_default_allocator()),
+                           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);
+  });
+
+  return js_obj;
+}
+
+Napi::Value IsTimerReady(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* timer_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(timer_handle->ptr());
+  bool is_ready = false;
+
+  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, rcl_timer_is_ready(timer, &is_ready),
+                           rcl_get_error_string().str);
+
+  return Napi::Boolean::New(env, is_ready);
+}
+
+Napi::Value CallTimer(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* timer_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(timer_handle->ptr());
+
+  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, rcl_timer_call(timer),
+                           rcl_get_error_string().str);
+
+  return env.Undefined();
+}
+
+Napi::Value CancelTimer(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* timer_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(timer_handle->ptr());
+
+  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, rcl_timer_cancel(timer),
+                           rcl_get_error_string().str);
+
+  return env.Undefined();
+}
+
+Napi::Value IsTimerCanceled(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* timer_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(timer_handle->ptr());
+  bool is_canceled = false;
+
+  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
+                           rcl_timer_is_canceled(timer, &is_canceled),
+                           rcl_get_error_string().str);
+
+  return Napi::Boolean::New(env, is_canceled);
+}
+
+Napi::Value ResetTimer(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* timer_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(timer_handle->ptr());
+
+  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, rcl_timer_reset(timer),
+                           rcl_get_error_string().str);
+
+  return env.Undefined();
+}
+
+Napi::Value TimerGetTimeUntilNextCall(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* timer_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(timer_handle->ptr());
+  int64_t remaining_time = 0;
+
+  THROW_ERROR_IF_NOT_EQUAL(
+      RCL_RET_OK, rcl_timer_get_time_until_next_call(timer, &remaining_time),
+      rcl_get_error_string().str);
+
+  return Napi::BigInt::New(env, remaining_time);
+}
+
+Napi::Value TimerGetTimeSinceLastCall(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* timer_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(timer_handle->ptr());
+  int64_t elapsed_time = 0;
+
+  THROW_ERROR_IF_NOT_EQUAL(
+      RCL_RET_OK, rcl_timer_get_time_since_last_call(timer, &elapsed_time),
+      rcl_get_error_string().str);
+
+  return Napi::BigInt::New(env, elapsed_time);
+}
+
+Napi::Value ChangeTimerPeriod(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* timer_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(timer_handle->ptr());
+
+  if (!info[1].IsBigInt()) {
+    Napi::TypeError::New(env, "Timer period must be a BigInt")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  bool lossless;
+  int64_t period_nsec = info[1].As<Napi::BigInt>().Int64Value(&lossless);
+  int64_t old_period;
+  THROW_ERROR_IF_NOT_EQUAL(
+      RCL_RET_OK, rcl_timer_exchange_period(timer, period_nsec, &old_period),
+      rcl_get_error_string().str);
+
+  return env.Undefined();
+}
+
+Napi::Value GetTimerPeriod(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* timer_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(timer_handle->ptr());
+  int64_t period_nsec = 0;
+
+  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
+                           rcl_timer_get_period(timer, &period_nsec),
+                           rcl_get_error_string().str);
+
+  return Napi::BigInt::New(env, period_nsec);
+}
+
+#if ROS_VERSION > 2205  // 2205 == Humble
+Napi::Value CallTimerWithInfo(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* timer_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(timer_handle->ptr());
+  rcl_timer_call_info_t call_info;
+
+  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
+                           rcl_timer_call_with_info(timer, &call_info),
+                           rcl_get_error_string().str);
+
+  Napi::Object timer_info = Napi::Object::New(env);
+  timer_info.Set("expectedCallTime",
+                 Napi::BigInt::New(env, call_info.expected_call_time));
+  timer_info.Set("actualCallTime",
+                 Napi::BigInt::New(env, call_info.actual_call_time));
+  return timer_info;
+}
+#endif
+
+Napi::Object InitTimerBindings(Napi::Env env, Napi::Object exports) {
+  exports.Set("createTimer", Napi::Function::New(env, CreateTimer));
+  exports.Set("isTimerReady", Napi::Function::New(env, IsTimerReady));
+  exports.Set("callTimer", Napi::Function::New(env, CallTimer));
+  exports.Set("cancelTimer", Napi::Function::New(env, CancelTimer));
+  exports.Set("isTimerCanceled", Napi::Function::New(env, IsTimerCanceled));
+  exports.Set("resetTimer", Napi::Function::New(env, ResetTimer));
+  exports.Set("timerGetTimeSinceLastCall",
+              Napi::Function::New(env, TimerGetTimeSinceLastCall));
+  exports.Set("timerGetTimeUntilNextCall",
+              Napi::Function::New(env, TimerGetTimeUntilNextCall));
+  exports.Set("changeTimerPeriod", Napi::Function::New(env, ChangeTimerPeriod));
+  exports.Set("getTimerPeriod", Napi::Function::New(env, GetTimerPeriod));
+#if ROS_VERSION > 2205  // 2205 == Humble
+  exports.Set("callTimerWithInfo", Napi::Function::New(env, CallTimerWithInfo));
+#endif
+  return exports;
+}
+
+}  // namespace rclnodejs

package/src/rcl_timer_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_TIMER_BINDINGS_H_
+#define SRC_RCL_TIMER_BINDINGS_H_
+
+#include <napi.h>
+
+namespace rclnodejs {
+
+Napi::Object InitTimerBindings(Napi::Env env, Napi::Object exports);
+
+}
+
+#endif  // SRC_RCL_TIMER_BINDINGS_H_

package/src/rcl_utilities.cpp

@@ -12,16 +12,115 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "rcl_utilities.hpp"
+#include "rcl_utilities.h"
 
 #include <rcl/rcl.h>
 #include <rcl_action/rcl_action.h>
+#include <rmw/topic_endpoint_info.h>
 #include <uv.h>
 
+#include <memory>
 #include <string>
 
 namespace {
+
+const rmw_qos_profile_t* GetQoSProfileFromString(const std::string& profile) {
+  const rmw_qos_profile_t* qos_profile = nullptr;
+  if (profile == "qos_profile_sensor_data") {
+    qos_profile = &rmw_qos_profile_sensor_data;
+  } else if (profile == "qos_profile_system_default") {
+    qos_profile = &rmw_qos_profile_system_default;
+  } else if (profile == "qos_profile_services_default") {
+    qos_profile = &rmw_qos_profile_services_default;
+  } else if (profile == "qos_profile_parameters") {
+    qos_profile = &rmw_qos_profile_parameters;
+  } else if (profile == "qos_profile_parameter_events") {
+    qos_profile = &rmw_qos_profile_parameter_events;
+  } else if (profile == "qos_profile_action_status_default") {
+    qos_profile = &rcl_action_qos_profile_status_default;
+  } else {
+    return &rmw_qos_profile_default;
+  }
+
+  return qos_profile;
+}
+
+std::unique_ptr<rmw_qos_profile_t> GetQosProfileFromObject(
+    Napi::Object object) {
+  std::unique_ptr<rmw_qos_profile_t> qos_profile =
+      std::make_unique<rmw_qos_profile_t>();
+
+  auto history = object.Get("history");
+  auto depth = object.Get("depth");
+  auto reliability = object.Get("reliability");
+  auto durability = object.Get("durability");
+  auto avoid_ros_namespace_conventions =
+      object.Get("avoidRosNameSpaceConventions");
+
+  qos_profile->history = static_cast<rmw_qos_history_policy_t>(
+      history.As<Napi::Number>().Uint32Value());
+  qos_profile->depth = depth.As<Napi::Number>().Uint32Value();
+  qos_profile->reliability = static_cast<rmw_qos_reliability_policy_t>(
+      reliability.As<Napi::Number>().Uint32Value());
+  qos_profile->durability = static_cast<rmw_qos_durability_policy_t>(
+      durability.As<Napi::Number>().Uint32Value());
+  qos_profile->avoid_ros_namespace_conventions =
+      avoid_ros_namespace_conventions.As<Napi::Boolean>();
+
+  return qos_profile;
+}
+
+Napi::Value ConvertRMWTimeToDuration(Napi::Env env,
+                                     const rmw_time_t* duration) {
+  Napi::Object obj = Napi::Object::New(env);
+  obj.Set("seconds", Napi::BigInt::New(env, duration->sec));
+  obj.Set("nanoseconds", Napi::Number::New(env, duration->nsec));
+  return obj;
+}
+
+#if ROS_VERSION > 2205  // 2205 == Humble
+Napi::Value ConvertToHashObject(Napi::Env env,
+                                const rosidl_type_hash_t* type_hash) {
+  Napi::Object obj = Napi::Object::New(env);
+  obj.Set("version", Napi::Number::New(env, type_hash->version));
+  obj.Set("value", Napi::Buffer<char>::Copy(
+                       env, reinterpret_cast<const char*>(type_hash->value),
+                       ROSIDL_TYPE_HASH_SIZE));
+  return obj;
+}
+#endif
+
+Napi::Value ConvertToJSTopicEndpoint(
+    Napi::Env env, const rmw_topic_endpoint_info_t* topic_endpoint_info) {
+  Napi::Array endpoint_gid = Napi::Array::New(env, RMW_GID_STORAGE_SIZE);
+  for (size_t i = 0; i < RMW_GID_STORAGE_SIZE; i++) {
+    endpoint_gid.Set(
+        i, Napi::Number::New(env, topic_endpoint_info->endpoint_gid[i]));
+  }
+
+  Napi::Object endpoint = Napi::Object::New(env);
+  endpoint.Set("node_name",
+               Napi::String::New(env, topic_endpoint_info->node_name));
+  endpoint.Set("node_namespace",
+               Napi::String::New(env, topic_endpoint_info->node_namespace));
+  endpoint.Set("topic_type",
+               Napi::String::New(env, topic_endpoint_info->topic_type));
+#if ROS_VERSION > 2205  // 2205 == Humble
+  endpoint.Set("topic_type_hash",
+               ConvertToHashObject(env, &topic_endpoint_info->topic_type_hash));
+#endif
+  endpoint.Set("endpoint_type",
+               Napi::Number::New(
+                   env, static_cast<int>(topic_endpoint_info->endpoint_type)));
+  endpoint.Set("endpoint_gid", endpoint_gid);
+  endpoint.Set("qos_profile",
+               rclnodejs::ConvertToQoS(env, &topic_endpoint_info->qos_profile));
+  return endpoint;
+}
+
 uv_lib_t g_lib;
+Napi::Env g_env = nullptr;
+
 }  // namespace
 
 namespace rclnodejs {
@@ -95,4 +194,70 @@ std::string GetErrorMessageAndClear() {
   return std::string(uv_dlerror(&g_lib));
 }
 
+Napi::Env& GetEnv() { return g_env; }
+
+void StoreEnv(Napi::Env current_env) { g_env = current_env; }
+
+std::unique_ptr<rmw_qos_profile_t> GetQoSProfile(Napi::Value qos) {
+  std::unique_ptr<rmw_qos_profile_t> qos_profile =
+      std::make_unique<rmw_qos_profile_t>();
+
+  if (qos.IsString()) {
+    *qos_profile = *GetQoSProfileFromString(qos.As<Napi::String>().Utf8Value());
+  } else if (qos.IsObject()) {
+    qos_profile = GetQosProfileFromObject(qos.As<Napi::Object>());
+  } else {
+    return qos_profile;
+  }
+  return qos_profile;
+}
+
+void ExtractNamesAndTypes(rcl_names_and_types_t names_and_types,
+                          Napi::Array* result_list) {
+  Napi::Env env = result_list->Env();
+
+  for (size_t i = 0; i < names_and_types.names.size; ++i) {
+    Napi::Object item = Napi::Object::New(env);
+    std::string topic_name = names_and_types.names.data[i];
+    item.Set("name", Napi::String::New(env, names_and_types.names.data[i]));
+
+    Napi::Array type_list =
+        Napi::Array::New(env, names_and_types.types[i].size);
+    for (size_t j = 0; j < names_and_types.types[i].size; ++j) {
+      type_list.Set(j,
+                    Napi::String::New(env, names_and_types.types[i].data[j]));
+    }
+    item.Set("types", type_list);
+    result_list->Set(i, item);
+  }
+}
+
+Napi::Value ConvertToQoS(Napi::Env env, const rmw_qos_profile_t* qos_profile) {
+  Napi::Object qos = Napi::Object::New(env);
+  qos.Set("depth", Napi::Number::New(env, qos_profile->depth));
+  qos.Set("history", Napi::Number::New(env, qos_profile->history));
+  qos.Set("reliability", Napi::Number::New(env, qos_profile->reliability));
+  qos.Set("durability", Napi::Number::New(env, qos_profile->durability));
+  qos.Set("lifespan", ConvertRMWTimeToDuration(env, &qos_profile->lifespan));
+  qos.Set("deadline", ConvertRMWTimeToDuration(env, &qos_profile->deadline));
+  qos.Set("liveliness", Napi::Number::New(env, qos_profile->liveliness));
+  qos.Set(
+      "liveliness_lease_duration",
+      ConvertRMWTimeToDuration(env, &qos_profile->liveliness_lease_duration));
+  qos.Set(
+      "avoid_ros_namespace_conventions",
+      Napi::Boolean::New(env, qos_profile->avoid_ros_namespace_conventions));
+  return qos;
+}
+
+Napi::Array ConvertToJSTopicEndpointInfoList(
+    Napi::Env env, const rmw_topic_endpoint_info_array_t* info_array) {
+  Napi::Array list = Napi::Array::New(env, info_array->size);
+  for (size_t i = 0; i < info_array->size; ++i) {
+    rmw_topic_endpoint_info_t topic_endpoint_info = info_array->info_array[i];
+    list.Set(i, ConvertToJSTopicEndpoint(env, &topic_endpoint_info));
+  }
+  return list;
+}
+
 }  // namespace rclnodejs