rclnodejs 0.33.0 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rclnodejs",
-  "version": "0.33.0",
+  "version": "1.1.0",
   "description": "ROS2.0 JavaScript client with Node.js",
   "main": "index.js",
   "types": "types/index.d.ts",
@@ -26,7 +26,7 @@
     "docs": "cd docs && make",
     "test": "nyc node --expose-gc ./scripts/run_test.js && tsd",
     "lint": "eslint && node ./scripts/cpplint.js",
-    "format": "clang-format -i -style=file ./src/*.cpp ./src/*.hpp && npx --yes prettier --write \"{lib,rosidl_gen,rostsd_gen,rosidl_parser,types,example,test,scripts,benchmark,rostsd_gen}/**/*.{js,md,ts}\" ./*.{js,md,ts}",
+    "format": "clang-format -i -style=file ./src/*.cpp ./src/*.h && npx --yes prettier --write \"{lib,rosidl_gen,rostsd_gen,rosidl_parser,types,example,test,scripts,benchmark,rostsd_gen}/**/*.{js,md,ts}\" ./*.{js,md,ts}",
     "prepare": "husky",
     "coverage": "cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js"
   },
@@ -79,9 +79,9 @@
     "fs-extra": "^11.2.0",
     "is-close": "^1.3.3",
     "json-bigint": "^1.0.0",
-    "nan": "^2.22.0",
     "terser": "^5.39.0",
-    "walk": "^2.3.15"
+    "walk": "^2.3.15",
+    "node-addon-api": "^8.3.1"
   },
   "husky": {
     "hooks": {

package/scripts/config.js

@@ -29,6 +29,7 @@ const dependencies = [
   'builtin_interfaces',
   'rcl_lifecycle',
   'lifecycle_msgs',
+  'rcpputils',
   'rosidl_runtime_c',
   'rosidl_dynamic_typesupport',
   'type_description_interfaces',

package/scripts/npmjs-readme.md

@@ -43,9 +43,9 @@ npm i rclnodejs@x.y.z
 
 #### RCLNODEJS - ROS 2 Version Compatibility
 
-|                                      RCLNODEJS Version                                       |                                                             Compatible ROS 2 LTS                                                             |
-| :------------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------: |
-| 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) |
+|                                     RCLNODEJS Version                                      |                                                                                               Compatible ROS 2 LTS                                                                                               |
+| :----------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+| latest version (currently [v1.1.0](https://github.com/RobotWebTools/rclnodejs/tree/1.1.0)) | [Kilted](https://github.com/RobotWebTools/rclnodejs/tree/kilted)<br>[Jazzy](https://github.com/RobotWebTools/rclnodejs/tree/jazzy)<br>[Humble](https://github.com/RobotWebTools/rclnodejs/tree/humble-hawksbill) |
 
 ## Documentation
 

package/src/addon.cpp

@@ -12,29 +12,42 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <nan.h>
+#include <node_api.h>
+#include <rcutils/logging.h>
 
-#include "macros.hpp"
-#include "rcl_action_bindings.hpp"
-#include "rcl_bindings.hpp"
-#include "rcl_handle.hpp"
-#include "rcl_lifecycle_bindings.hpp"
-#include "rcutils/logging.h"
-#include "rcutils/macros.h"
-#include "shadow_node.hpp"
+#include "macros.h"
+#include "rcl_action_client_bindings.h"
+#include "rcl_action_goal_bindings.h"
+#include "rcl_action_server_bindings.h"
+#include "rcl_bindings.h"
+#include "rcl_client_bindings.h"
+#include "rcl_context_bindings.h"
+#include "rcl_graph_bindings.h"
+#include "rcl_guard_condition_bindings.h"
+#include "rcl_handle.h"
+#include "rcl_lifecycle_bindings.h"
+#include "rcl_logging_bindings.h"
+#include "rcl_names_bindings.h"
+#include "rcl_node_bindings.h"
+#include "rcl_publisher_bindings.h"
+#include "rcl_service_bindings.h"
+#include "rcl_subscription_bindings.h"
+#include "rcl_time_point_bindings.h"
+#include "rcl_timer_bindings.h"
+#if ROS_VERSION > 2205  // ROS2 > Humble
+#include "rcl_type_description_service_bindings.h"
+#endif
+#include "rcl_utilities.h"
+#include "shadow_node.h"
 
-bool IsRunningInElectronRenderer() {
-  auto global = Nan::GetCurrentContext()->Global();
-  auto process =
-      Nan::To<v8::Object>(Nan::Get(global, Nan::New("process").ToLocalChecked())
-                              .ToLocalChecked())
-          .ToLocalChecked();
-  auto process_type =
-      Nan::Get(process, Nan::New("type").ToLocalChecked()).ToLocalChecked();
-  return process_type->StrictEquals(Nan::New("renderer").ToLocalChecked());
+bool IsRunningInElectronRenderer(const Napi::Env& env) {
+  Napi::Object global = env.Global();
+  Napi::Object process = global.Get("process").As<Napi::Object>();
+  Napi::Value processType = process.Get("type");
+  return processType.StrictEquals(Napi::String::New(env, "renderer"));
 }
 
-void InitModule(v8::Local<v8::Object> exports) {
+Napi::Object InitModule(Napi::Env env, Napi::Object exports) {
 // workaround process name mangling by chromium
 //
 // rcl logging uses `program_invocation_name` to determine the log file,
@@ -43,7 +56,7 @@ void InitModule(v8::Local<v8::Object> exports) {
 // occurence of ' -' with the null terminator. see:
 // https://unix.stackexchange.com/questions/432419/unexpected-non-null-encoding-of-proc-pid-cmdline
 #if defined(__linux__) && defined(__GLIBC__)
-  if (IsRunningInElectronRenderer()) {
+  if (IsRunningInElectronRenderer(env)) {
     auto prog_name = program_invocation_name;
     auto end = strstr(prog_name, " -");
     assert(end);
@@ -51,44 +64,38 @@ void InitModule(v8::Local<v8::Object> exports) {
   }
 #endif
 
-  v8::Local<v8::Context> context = exports->GetIsolate()->GetCurrentContext();
-
-  for (uint32_t i = 0; i < rclnodejs::binding_methods.size(); i++) {
-    Nan::Set(
-        exports, Nan::New(rclnodejs::binding_methods[i].name).ToLocalChecked(),
-        Nan::New<v8::FunctionTemplate>(rclnodejs::binding_methods[i].function)
-            ->GetFunction(context)
-            .ToLocalChecked());
-  }
-
-  for (uint32_t i = 0; i < rclnodejs::action_binding_methods.size(); i++) {
-    Nan::Set(
-        exports,
-        Nan::New(rclnodejs::action_binding_methods[i].name).ToLocalChecked(),
-        Nan::New<v8::FunctionTemplate>(
-            rclnodejs::action_binding_methods[i].function)
-            ->GetFunction(context)
-            .ToLocalChecked());
-  }
-
-  for (uint32_t i = 0; i < rclnodejs::lifecycle_binding_methods.size(); i++) {
-    Nan::Set(
-        exports,
-        Nan::New(rclnodejs::lifecycle_binding_methods[i].name).ToLocalChecked(),
-        Nan::New<v8::FunctionTemplate>(
-            rclnodejs::lifecycle_binding_methods[i].function)
-            ->GetFunction(context)
-            .ToLocalChecked());
-  }
-
-  rclnodejs::ShadowNode::Init(exports);
-  rclnodejs::RclHandle::Init(exports);
+  rclnodejs::StoreEnv(env);
+  // Init the C++ bindings.
+  rclnodejs::InitBindings(env, exports);
+  rclnodejs::InitActionClientBindings(env, exports);
+  rclnodejs::InitActionGoalBindings(env, exports);
+  rclnodejs::InitActionServerBindings(env, exports);
+  rclnodejs::InitClientBindings(env, exports);
+  rclnodejs::InitContextBindings(env, exports);
+  rclnodejs::InitGraphBindings(env, exports);
+  rclnodejs::InitGuardConditionBindings(env, exports);
+  rclnodejs::InitLoggingBindings(env, exports);
+  rclnodejs::InitNamesBindings(env, exports);
+  rclnodejs::InitNodeBindings(env, exports);
+  rclnodejs::InitPublisherBindings(env, exports);
+  rclnodejs::InitServiceBindings(env, exports);
+  rclnodejs::InitSubscriptionBindings(env, exports);
+  rclnodejs::InitTimePointBindings(env, exports);
+  rclnodejs::InitTimerBindings(env, exports);
+#if ROS_VERSION > 2205  // ROS2 > Humble
+  rclnodejs::InitTypeDescriptionServiceBindings(env, exports);
+#endif
+  rclnodejs::InitLifecycleBindings(env, exports);
+  rclnodejs::ShadowNode::Init(env, exports);
+  rclnodejs::RclHandle::Init(env, exports);
 
 #ifdef DEBUG_ON
   int result = rcutils_logging_set_logger_level(PACKAGE_NAME,
                                                 RCUTILS_LOG_SEVERITY_DEBUG);
   RCUTILS_UNUSED(result);
 #endif
+
+  return exports;
 }
 
-NODE_MODULE(rclnodejs, InitModule);
+NODE_API_MODULE(rclnodejs, InitModule)

package/src/executor.cpp

@@ -12,16 +12,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "executor.hpp"
+#include "executor.h"
 
 #include <rcl/error_handling.h>
 
 #include <stdexcept>
 #include <string>
 
-#include "handle_manager.hpp"
-#include "macros.hpp"
-#include "rcl_bindings.hpp"
+#include "handle_manager.h"
+#include "macros.h"
+#include "rcl_bindings.h"
 
 #ifdef WIN32
 #define UNUSED
@@ -41,12 +41,14 @@ struct RclResult {
   std::string error_msg;
 };
 
-Executor::Executor(HandleManager* handle_manager, Delegate* delegate)
+Executor::Executor(Napi::Env env, HandleManager* handle_manager,
+                   Delegate* delegate)
     : async_(nullptr),
       main_thread_(uv_thread_self()),
       handle_manager_(handle_manager),
       delegate_(delegate),
-      context_(nullptr) {
+      context_(nullptr),
+      env_(env) {
   running_.store(false);
 }
 
@@ -74,12 +76,19 @@ void Executor::SpinOnce(rcl_context_t* context, int32_t time_out) {
   rcl_wait_set_t wait_set = rcl_get_zero_initialized_wait_set();
   rcl_ret_t ret = rcl_wait_set_init(&wait_set, 0, 0, 0, 0, 0, 0, context,
                                     rcl_get_default_allocator());
-  if (ret != RCL_RET_OK) Nan::ThrowError(rcl_get_error_string().str);
+  if (ret != RCL_RET_OK) {
+    Napi::Error::New(env_, rcl_get_error_string().str)
+        .ThrowAsJavaScriptException();
+    return;
+  }
 
   RclResult wait_result = WaitForReadyCallbacks(&wait_set, time_out);
 
-  if (wait_result.ret != RCL_RET_OK)
-    Nan::ThrowError(wait_result.error_msg.c_str());
+  if (wait_result.ret != RCL_RET_OK) {
+    Napi::Error::New(env_, wait_result.error_msg.c_str())
+        .ThrowAsJavaScriptException();
+    return;
+  }
 
   if (handle_manager_->ready_handles_count() > 0) ExecuteReadyHandles();
 
@@ -87,7 +96,7 @@ void Executor::SpinOnce(rcl_context_t* context, int32_t time_out) {
     std::string error_message =
         std::string("Failed to destroy guard waitset:") +
         std::string(rcl_get_error_string().str);
-    Nan::ThrowError(error_message.c_str());
+    Napi::Error::New(env_, error_message.c_str()).ThrowAsJavaScriptException();
   }
 }
 

package/src/{executor.hpp → executor.h}

@@ -12,9 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef SRC_EXECUTOR_HPP_
-#define SRC_EXECUTOR_HPP_
+#ifndef SRC_EXECUTOR_H_
+#define SRC_EXECUTOR_H_
 
+#include <napi.h>
 #include <rcl/wait.h>
 #include <uv.h>
 
@@ -22,7 +23,7 @@
 #include <exception>
 #include <vector>
 
-#include "rcl_handle.hpp"
+#include "rcl_handle.h"
 
 namespace rclnodejs {
 
@@ -37,7 +38,7 @@ class Executor {
     virtual void CatchException(std::exception_ptr e_ptr) = 0;
   };
 
-  Executor(HandleManager* handle_manager, Delegate* delegate);
+  Executor(Napi::Env env, HandleManager* handle_manager, Delegate* delegate);
   ~Executor();
 
   void Start(rcl_context_t* context, int32_t time_out);
@@ -68,10 +69,11 @@ class Executor {
   Delegate* delegate_;
   rcl_context_t* context_;
   int32_t time_out_;
+  Napi::Env env_;
 
   std::atomic_bool running_;
 };
 
 }  // namespace rclnodejs
 
-#endif  // SRC_EXECUTOR_HPP_
+#endif  // SRC_EXECUTOR_H_

package/src/handle_manager.cpp

@@ -12,14 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "handle_manager.hpp"
+#include "handle_manager.h"
 
 #include <rcl_action/rcl_action.h>
 
 #include <utility>
 #include <vector>
 
-#include "macros.hpp"
+#include "macros.h"
 
 namespace rclnodejs {
 
@@ -38,22 +38,16 @@ HandleManager::~HandleManager() {
   uv_sem_destroy(&wait_handle_sem_);
 }
 
-void HandleManager::SynchronizeHandles(const v8::Local<v8::Object> node) {
-  Nan::HandleScope scope;
-  Nan::MaybeLocal<v8::Value> timers =
-      Nan::Get(node, Nan::New("_timers").ToLocalChecked());
-  Nan::MaybeLocal<v8::Value> subscriptions =
-      Nan::Get(node, Nan::New("_subscriptions").ToLocalChecked());
-  Nan::MaybeLocal<v8::Value> clients =
-      Nan::Get(node, Nan::New("_clients").ToLocalChecked());
-  Nan::MaybeLocal<v8::Value> services =
-      Nan::Get(node, Nan::New("_services").ToLocalChecked());
-  Nan::MaybeLocal<v8::Value> guard_conditions =
-      Nan::Get(node, Nan::New("_guards").ToLocalChecked());
-  Nan::MaybeLocal<v8::Value> action_clients =
-      Nan::Get(node, Nan::New("_actionClients").ToLocalChecked());
-  Nan::MaybeLocal<v8::Value> action_servers =
-      Nan::Get(node, Nan::New("_actionServers").ToLocalChecked());
+void HandleManager::SynchronizeHandles(const Napi::Object& node) {
+  Napi::HandleScope scope(node.Env());
+
+  Napi::Value timers = node.Get("_timers");
+  Napi::Value subscriptions = node.Get("_subscriptions");
+  Napi::Value clients = node.Get("_clients");
+  Napi::Value services = node.Get("_services");
+  Napi::Value guard_conditions = node.Get("_guards");
+  Napi::Value action_clients = node.Get("_actionClients");
+  Napi::Value action_servers = node.Get("_actionServers");
 
   uint32_t sum = 0;
   is_synchronizing_.store(true);
@@ -61,27 +55,17 @@ void HandleManager::SynchronizeHandles(const v8::Local<v8::Object> node) {
     ScopedReadWriteLock scoped_lock(&sync_handles_rwlock_,
                                     ScopedReadWriteLock::LockType::kWrite);
     ClearHandles();
-    sum += SynchronizeHandlesByType(
-        Nan::To<v8::Object>(timers.ToLocalChecked()).ToLocalChecked(),
-        &timers_);
-    sum += SynchronizeHandlesByType(
-        Nan::To<v8::Object>(subscriptions.ToLocalChecked()).ToLocalChecked(),
-        &subscriptions_);
-    sum += SynchronizeHandlesByType(
-        Nan::To<v8::Object>(clients.ToLocalChecked()).ToLocalChecked(),
-        &clients_);
-    sum += SynchronizeHandlesByType(
-        Nan::To<v8::Object>(services.ToLocalChecked()).ToLocalChecked(),
-        &services_);
-    sum += SynchronizeHandlesByType(
-        Nan::To<v8::Object>(guard_conditions.ToLocalChecked()).ToLocalChecked(),
-        &guard_conditions_);
-    sum += SynchronizeHandlesByType(
-        Nan::To<v8::Object>(action_clients.ToLocalChecked()).ToLocalChecked(),
-        &action_clients_);
-    sum += SynchronizeHandlesByType(
-        Nan::To<v8::Object>(action_servers.ToLocalChecked()).ToLocalChecked(),
-        &action_servers_);
+    sum += SynchronizeHandlesByType(timers.As<Napi::Object>(), &timers_);
+    sum += SynchronizeHandlesByType(subscriptions.As<Napi::Object>(),
+                                    &subscriptions_);
+    sum += SynchronizeHandlesByType(clients.As<Napi::Object>(), &clients_);
+    sum += SynchronizeHandlesByType(services.As<Napi::Object>(), &services_);
+    sum += SynchronizeHandlesByType(guard_conditions.As<Napi::Object>(),
+                                    &guard_conditions_);
+    sum += SynchronizeHandlesByType(action_clients.As<Napi::Object>(),
+                                    &action_clients_);
+    sum += SynchronizeHandlesByType(action_servers.As<Napi::Object>(),
+                                    &action_servers_);
   }
   is_synchronizing_.store(false);
 
@@ -265,26 +249,16 @@ uint32_t HandleManager::ready_handles_count() {
 }
 
 uint32_t HandleManager::SynchronizeHandlesByType(
-    const v8::Local<v8::Object>& typeObject,
-    std::vector<rclnodejs::RclHandle*>* vec) {
-  Nan::HandleScope scope;
-
-  if (typeObject->IsArray()) {
-    uint32_t length =
-        Nan::To<uint32_t>(
-            Nan::Get(typeObject, Nan::New("length").ToLocalChecked())
-                .ToLocalChecked())
-            .FromJust();
+    const Napi::Object& typeObject, std::vector<rclnodejs::RclHandle*>* vec) {
+  if (typeObject.IsArray()) {
+    uint32_t length = typeObject.Get("length").As<Napi::Number>().Uint32Value();
 
     for (uint32_t index = 0; index < length; index++) {
-      v8::Local<v8::Object> obj =
-          Nan::To<v8::Object>(Nan::Get(typeObject, index).ToLocalChecked())
-              .ToLocalChecked();
-      Nan::MaybeLocal<v8::Value> handle =
-          Nan::Get(obj, Nan::New("_handle").ToLocalChecked());
+      Napi::Object obj = typeObject.Get(index).As<Napi::Object>();
+      Napi::Value handle = obj.Get("_handle");
       rclnodejs::RclHandle* rcl_handle =
-          rclnodejs::RclHandle::Unwrap<rclnodejs::RclHandle>(
-              Nan::To<v8::Object>(handle.ToLocalChecked()).ToLocalChecked());
+          Napi::ObjectWrap<rclnodejs::RclHandle>::Unwrap(
+              handle.As<Napi::Object>());
       vec->push_back(rcl_handle);
     }
   }

package/src/{handle_manager.hpp → handle_manager.h}

@@ -12,16 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef SRC_HANDLE_MANAGER_HPP_
-#define SRC_HANDLE_MANAGER_HPP_
+#ifndef SRC_HANDLE_MANAGER_H_
+#define SRC_HANDLE_MANAGER_H_
 
-#include <nan.h>
+#include <napi.h>
 #include <rcl/wait.h>
+#include <uv.h>
 
 #include <atomic>
 #include <vector>
 
-#include "rcl_handle.hpp"
+#include "rcl_handle.h"
 
 namespace rclnodejs {
 
@@ -53,7 +54,7 @@ class HandleManager {
   HandleManager();
   ~HandleManager();
 
-  void SynchronizeHandles(const v8::Local<v8::Object> node);
+  void SynchronizeHandles(const Napi::Object& node);
   void WaitForSynchronizing();
 
   // Waits the handles to be attached from the background thread.
@@ -89,7 +90,7 @@ class HandleManager {
 
  protected:
   // Synchronize the handles from `typeObject`.
-  uint32_t SynchronizeHandlesByType(const v8::Local<v8::Object>& typeObject,
+  uint32_t SynchronizeHandlesByType(const Napi::Object& typeObject,
                                     std::vector<rclnodejs::RclHandle*>* vec);
   template <typename T>
   void CollectReadyHandlesByType(
@@ -132,4 +133,4 @@ class HandleManager {
 
 }  // namespace rclnodejs
 
-#endif  // SRC_HANDLE_MANAGER_HPP_
+#endif  // SRC_HANDLE_MANAGER_H_

package/src/{macros.hpp → macros.h}

@@ -12,17 +12,19 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef SRC_MACROS_HPP_
-#define SRC_MACROS_HPP_
+#ifndef SRC_MACROS_H_
+#define SRC_MACROS_H_
+
+#include <napi.h>
 
 #include "rcutils/logging_macros.h"
 
 #define CHECK_OP_AND_THROW_ERROR_IF_NOT_TRUE(op, lhs, rhs, message) \
   {                                                                 \
     if (lhs op rhs) {                                               \
-      Nan::ThrowError(message);                                     \
       rcl_reset_error();                                            \
-      return;                                                       \
+      Napi::Error::New(rclnodejs::GetEnv(), message)                \
+          .ThrowAsJavaScriptException();                            \
     }                                                               \
   }
 
@@ -43,4 +45,4 @@
 #define RCLNODEJS_DEBUG(...)
 #endif
 
-#endif  // SRC_MACROS_HPP_
+#endif  // SRC_MACROS_H_