rclnodejs 0.33.0 → 1.1.0

package/src/rcl_graph_bindings.cpp

@@ -0,0 +1,280 @@
+// 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_graph_bindings.h"
+
+#include <rcl/error_handling.h>
+#include <rcl/graph.h>
+#include <rcl/rcl.h>
+
+#include <rcpputils/scope_exit.hpp>
+// NOLINTNEXTLINE
+#include <string>
+
+#include "macros.h"
+#include "rcl_handle.h"
+#include "rcl_utilities.h"
+
+namespace rclnodejs {
+
+typedef rcl_ret_t (*rcl_get_info_by_topic_func_t)(
+    const rcl_node_t* node, rcutils_allocator_t* allocator,
+    const char* topic_name, bool no_mangle,
+    rcl_topic_endpoint_info_array_t* info_array);
+
+Napi::Value GetPublisherNamesAndTypesByNode(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 node_name = info[1].As<Napi::String>().Utf8Value();
+  std::string node_namespace = info[2].As<Napi::String>().Utf8Value();
+  bool no_demangle = info[3].As<Napi::Boolean>();
+
+  rcl_names_and_types_t topic_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_get_publisher_names_and_types_by_node(
+                               node, &allocator, no_demangle, node_name.c_str(),
+                               node_namespace.c_str(), &topic_names_and_types),
+                           "Failed to get_publisher_names_and_types.");
+
+  Napi::Array result_list =
+      Napi::Array::New(env, topic_names_and_types.names.size);
+  ExtractNamesAndTypes(topic_names_and_types, &result_list);
+
+  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
+                           rcl_names_and_types_fini(&topic_names_and_types),
+                           "Failed to destroy topic_names_and_types");
+
+  return result_list;
+}
+
+Napi::Value GetSubscriptionNamesAndTypesByNode(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 node_name = info[1].As<Napi::String>().Utf8Value();
+  std::string node_namespace = info[2].As<Napi::String>().Utf8Value();
+  bool no_demangle = info[3].As<Napi::Boolean>();
+
+  rcl_names_and_types_t topic_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_get_subscriber_names_and_types_by_node(
+                               node, &allocator, no_demangle, node_name.c_str(),
+                               node_namespace.c_str(), &topic_names_and_types),
+                           "Failed to get_publisher_names_and_types.");
+
+  Napi::Array result_list =
+      Napi::Array::New(env, topic_names_and_types.names.size);
+  ExtractNamesAndTypes(topic_names_and_types, &result_list);
+
+  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
+                           rcl_names_and_types_fini(&topic_names_and_types),
+                           "Failed to destroy topic_names_and_types");
+
+  return result_list;
+}
+
+Napi::Value GetServiceNamesAndTypesByNode(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 node_name = info[1].As<Napi::String>().Utf8Value();
+  std::string node_namespace = info[2].As<Napi::String>().Utf8Value();
+
+  rcl_names_and_types_t service_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_get_service_names_and_types_by_node(
+          node, &allocator, node_name.c_str(), node_namespace.c_str(),
+          &service_names_and_types),
+      "Failed to get_service_names_and_types.");
+
+  Napi::Array result_list =
+      Napi::Array::New(env, 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");
+
+  return result_list;
+}
+
+Napi::Value GetClientNamesAndTypesByNode(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 node_name = info[1].As<Napi::String>().Utf8Value();
+  std::string node_namespace = info[2].As<Napi::String>().Utf8Value();
+
+  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_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.");
+
+  Napi::Array result_list =
+      Napi::Array::New(env, 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");
+
+  return result_list;
+}
+
+Napi::Value GetTopicNamesAndTypes(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());
+  bool no_demangle = info[1].As<Napi::Boolean>();
+  rcl_names_and_types_t topic_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_get_topic_names_and_types(node, &allocator, no_demangle,
+                                    &topic_names_and_types),
+      "Failed to get_publisher_names_and_types.");
+
+  Napi::Array result_list =
+      Napi::Array::New(env, topic_names_and_types.names.size);
+  ExtractNamesAndTypes(topic_names_and_types, &result_list);
+
+  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
+                           rcl_names_and_types_fini(&topic_names_and_types),
+                           "Failed to destroy topic_names_and_types");
+
+  return result_list;
+}
+
+Napi::Value GetServiceNamesAndTypes(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());
+  rcl_names_and_types_t service_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_get_service_names_and_types(
+                               node, &allocator, &service_names_and_types),
+                           "Failed to get_publisher_names_and_types.");
+
+  Napi::Array result_list =
+      Napi::Array::New(env, 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 topic_names_and_types");
+
+  return result_list;
+}
+
+Napi::Value GetInfoByTopic(Napi::Env env, rcl_node_t* node,
+                           const char* topic_name, bool no_mangle,
+                           const char* type,
+                           rcl_get_info_by_topic_func_t rcl_get_info_by_topic) {
+  rcutils_allocator_t allocator = rcutils_get_default_allocator();
+  rcl_topic_endpoint_info_array_t info_array =
+      rcl_get_zero_initialized_topic_endpoint_info_array();
+
+  RCPPUTILS_SCOPE_EXIT({
+    rcl_ret_t fini_ret =
+        rcl_topic_endpoint_info_array_fini(&info_array, &allocator);
+    if (RCL_RET_OK != fini_ret) {
+      Napi::Error::New(env, rcl_get_error_string().str)
+          .ThrowAsJavaScriptException();
+      rcl_reset_error();
+    }
+  });
+
+  rcl_ret_t ret = rcl_get_info_by_topic(node, &allocator, topic_name, no_mangle,
+                                        &info_array);
+  if (RCL_RET_OK != ret) {
+    if (RCL_RET_UNSUPPORTED == ret) {
+      Napi::Error::New(
+          env, std::string("Failed to get information by topic for ") + type +
+                   ": function not supported by RMW_IMPLEMENTATION")
+          .ThrowAsJavaScriptException();
+      return env.Undefined();
+    }
+    Napi::Error::New(
+        env, std::string("Failed to get information by topic for ") + type)
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  return ConvertToJSTopicEndpointInfoList(env, &info_array);
+}
+
+Napi::Value GetPublishersInfoByTopic(const Napi::CallbackInfo& info) {
+  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();
+  bool no_mangle = info[2].As<Napi::Boolean>();
+
+  return GetInfoByTopic(info.Env(), node, topic_name.c_str(), no_mangle,
+                        "publishers", rcl_get_publishers_info_by_topic);
+}
+
+Napi::Value GetSubscriptionsInfoByTopic(const Napi::CallbackInfo& info) {
+  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();
+  bool no_mangle = info[2].As<Napi::Boolean>();
+
+  return GetInfoByTopic(info.Env(), node, topic_name.c_str(), no_mangle,
+                        "subscriptions", rcl_get_subscriptions_info_by_topic);
+}
+
+Napi::Object InitGraphBindings(Napi::Env env, Napi::Object exports) {
+  exports.Set("getPublisherNamesAndTypesByNode",
+              Napi::Function::New(env, GetPublisherNamesAndTypesByNode));
+  exports.Set("getSubscriptionNamesAndTypesByNode",
+              Napi::Function::New(env, GetSubscriptionNamesAndTypesByNode));
+  exports.Set("getServiceNamesAndTypesByNode",
+              Napi::Function::New(env, GetServiceNamesAndTypesByNode));
+  exports.Set("getClientNamesAndTypesByNode",
+              Napi::Function::New(env, GetClientNamesAndTypesByNode));
+  exports.Set("getTopicNamesAndTypes",
+              Napi::Function::New(env, GetTopicNamesAndTypes));
+  exports.Set("getServiceNamesAndTypes",
+              Napi::Function::New(env, GetServiceNamesAndTypes));
+  exports.Set("getPublishersInfoByTopic",
+              Napi::Function::New(env, GetPublishersInfoByTopic));
+  exports.Set("getSubscriptionsInfoByTopic",
+              Napi::Function::New(env, GetSubscriptionsInfoByTopic));
+  return exports;
+}
+
+}  // namespace rclnodejs

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

package/src/rcl_guard_condition_bindings.cpp

@@ -0,0 +1,75 @@
+// 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_guard_condition_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 CreateGuardCondition(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* context_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_context_t* context =
+      reinterpret_cast<rcl_context_t*>(context_handle->ptr());
+
+  rcl_guard_condition_t* gc = reinterpret_cast<rcl_guard_condition_t*>(
+      malloc(sizeof(rcl_guard_condition_t)));
+
+  *gc = rcl_get_zero_initialized_guard_condition();
+  rcl_guard_condition_options_t gc_options =
+      rcl_guard_condition_get_default_options();
+
+  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
+                           rcl_guard_condition_init(gc, context, gc_options),
+                           rcl_get_error_string().str);
+
+  auto handle = RclHandle::NewInstance(env, gc, nullptr, [](void* ptr) {
+    rcl_guard_condition_t* gc = reinterpret_cast<rcl_guard_condition_t*>(ptr);
+    rcl_ret_t ret = rcl_guard_condition_fini(gc);
+    free(ptr);
+    THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
+  });
+
+  return handle;
+}
+
+Napi::Value TriggerGuardCondition(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* gc_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_guard_condition_t* gc =
+      reinterpret_cast<rcl_guard_condition_t*>(gc_handle->ptr());
+
+  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, rcl_trigger_guard_condition(gc),
+                           rcl_get_error_string().str);
+
+  return env.Undefined();
+}
+
+Napi::Object InitGuardConditionBindings(Napi::Env env, Napi::Object exports) {
+  exports.Set("createGuardCondition",
+              Napi::Function::New(env, CreateGuardCondition));
+  exports.Set("triggerGuardCondition",
+              Napi::Function::New(env, TriggerGuardCondition));
+  return exports;
+}
+
+}  // namespace rclnodejs

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

package/src/rcl_handle.cpp

@@ -12,91 +12,75 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "rcl_handle.hpp"
+#include "rcl_handle.h"
 
 #include <rcl/error_handling.h>
 #include <rcl/rcl.h>
 
+#include "rcl_utilities.h"
+
 namespace rclnodejs {
 
-Nan::Persistent<v8::Function> RclHandle::constructor;
+Napi::FunctionReference RclHandle::constructor;
 
-RclHandle::RclHandle() : pointer_(nullptr), parent_(nullptr) {}
+RclHandle::RclHandle(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<RclHandle>(info), pointer_(nullptr), parent_(nullptr) {}
 
 RclHandle::~RclHandle() {
   if (pointer_) Reset();
 }
 
-void RclHandle::Init(v8::Local<v8::Object> exports) {
-  v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
-  tpl->SetClassName(Nan::New("RclHandle").ToLocalChecked());
-  tpl->InstanceTemplate()->SetInternalFieldCount(1);
+Napi::Object RclHandle::Init(Napi::Env env, Napi::Object exports) {
+  Napi::HandleScope scope(env);
 
-  Nan::SetAccessor(tpl->InstanceTemplate(),
-                   Nan::New("properties").ToLocalChecked(), PropertiesGetter);
-  Nan::SetPrototypeMethod(tpl, "release", Release);
-  Nan::SetPrototypeMethod(tpl, "dismiss", Dismiss);
+  Napi::Function func = DefineClass(
+      env, "RclHandle",
+      {InstanceMethod("release", &RclHandle::Release),
+       InstanceMethod("dismiss", &RclHandle::Dismiss),
+       InstanceAccessor("properties", &RclHandle::PropertiesGetter, nullptr)});
 
-  v8::Local<v8::Context> context = exports->GetIsolate()->GetCurrentContext();
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+  exports.Set("RclHandle", func);
 
-  constructor.Reset(tpl->GetFunction(context).ToLocalChecked());
-  Nan::Set(exports, Nan::New("RclHandle").ToLocalChecked(),
-           tpl->GetFunction(context).ToLocalChecked());
-}
-
-void RclHandle::New(const Nan::FunctionCallbackInfo<v8::Value>& info) {
-  if (info.IsConstructCall()) {
-    RclHandle* obj = new RclHandle();
-    obj->Wrap(info.This());
-    info.GetReturnValue().Set(info.This());
-  }
+  return exports;
 }
 
 void RclHandle::SyncProperties() {
-  auto obj = v8::Object::New(v8::Isolate::GetCurrent());
-
-  for (auto it = properties_.begin(); it != properties_.end(); it++) {
-    Nan::Set(obj, Nan::New(it->first).ToLocalChecked(), Nan::New(it->second));
+  Napi::Env env = rclnodejs::GetEnv();
+  Napi::HandleScope scope(env);
+  Napi::Object obj = Napi::Object::New(env);
+  for (auto& pair : properties_) {
+    obj.Set(pair.first, Napi::Boolean::New(env, pair.second));
   }
-
-  properties_obj_ = obj;
+  properties_obj_ = Napi::Persistent(obj);
 }
 
-NAN_GETTER(RclHandle::PropertiesGetter) {
-  auto* me = RclHandle::Unwrap<RclHandle>(info.Holder());
-
-  if (!me->properties_obj_.IsEmpty())
-    info.GetReturnValue().Set(me->properties_obj_);
-  else
-    info.GetReturnValue().Set(Nan::Undefined());
+Napi::Value RclHandle::PropertiesGetter(const Napi::CallbackInfo& info) {
+  return !properties_obj_.IsEmpty() ? properties_obj_.Value()
+                                    : info.Env().Undefined();
 }
 
-NAN_METHOD(RclHandle::Release) {
-  auto* me = Nan::ObjectWrap::Unwrap<RclHandle>(info.Holder());
-  if (me->ptr()) me->Reset();
-
-  info.GetReturnValue().Set(Nan::Undefined());
+Napi::Value RclHandle::Release(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (ptr()) Reset();
+  return env.Undefined();
 }
 
-NAN_METHOD(RclHandle::Dismiss) {
-  auto* me = Nan::ObjectWrap::Unwrap<RclHandle>(info.Holder());
-  if (me) me->set_ptr(nullptr);
-
-  info.GetReturnValue().Set(Nan::Undefined());
+Napi::Value RclHandle::Dismiss(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  set_ptr(nullptr);
+  return env.Undefined();
 }
 
-v8::Local<v8::Object> RclHandle::NewInstance(
-    void* handle, RclHandle* parent, std::function<void(void*)> deleter) {
-  Nan::EscapableHandleScope scope;
-
-  v8::Local<v8::Function> cons = Nan::New<v8::Function>(constructor);
-  v8::Local<v8::Context> context =
-      v8::Isolate::GetCurrent()->GetCurrentContext();
+Napi::Object RclHandle::NewInstance(Napi::Env env, void* handle,
+                                    RclHandle* parent,
+                                    std::function<void(void*)> deleter) {
+  Napi::EscapableHandleScope scope(env);
 
-  v8::Local<v8::Object> instance =
-      cons->NewInstance(context, 0, nullptr).ToLocalChecked();
+  Napi::Object instance = constructor.New({});
 
-  auto* rcl_handle = Nan::ObjectWrap::Unwrap<RclHandle>(instance);
+  RclHandle* rcl_handle = Napi::ObjectWrap<RclHandle>::Unwrap(instance);
   rcl_handle->set_ptr(handle);
   rcl_handle->set_deleter(deleter);
   if (parent) {
@@ -104,7 +88,7 @@ v8::Local<v8::Object> RclHandle::NewInstance(
     parent->AddChild(rcl_handle);
   }
 
-  return scope.Escape(instance);
+  return scope.Escape(instance).As<Napi::Object>();
 }
 
 void RclHandle::Reset() {

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

@@ -12,10 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef SRC_RCL_HANDLE_HPP_
-#define SRC_RCL_HANDLE_HPP_
+#ifndef SRC_RCL_HANDLE_H_
+#define SRC_RCL_HANDLE_H_
 
-#include <nan.h>
+#include <napi.h>
 
 #include <functional>
 #include <map>
@@ -24,11 +24,15 @@
 
 namespace rclnodejs {
 
-class RclHandle : public Nan::ObjectWrap {
+class RclHandle : public Napi::ObjectWrap<RclHandle> {
  public:
-  static void Init(v8::Local<v8::Object> exports);
-  static v8::Local<v8::Object> NewInstance(void* handle, RclHandle* parent,
-                                           std::function<void(void*)> deleter);
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  static Napi::Object NewInstance(Napi::Env env, void* handle,
+                                  RclHandle* parent,
+                                  std::function<void(void*)> deleter);
+
+  explicit RclHandle(const Napi::CallbackInfo& info);
+  ~RclHandle();
 
   void set_deleter(std::function<void(void*)> deleter) { deleter_ = deleter; }
 
@@ -47,25 +51,22 @@ class RclHandle : public Nan::ObjectWrap {
   void SyncProperties();
 
  private:
-  RclHandle();
-  ~RclHandle();
-
-  static Nan::Persistent<v8::Function> constructor;
-  static void New(const Nan::FunctionCallbackInfo<v8::Value>& info);
-  static NAN_METHOD(Release);
-  static NAN_METHOD(Dismiss);
-  static NAN_GETTER(PropertiesGetter);
+  Napi::Value Release(const Napi::CallbackInfo& info);
+  Napi::Value Dismiss(const Napi::CallbackInfo& info);
+  Napi::Value PropertiesGetter(const Napi::CallbackInfo& info);
 
  private:
   void* pointer_;
   RclHandle* parent_;
   std::map<std::string, bool> properties_;
-  v8::Local<v8::Object> properties_obj_;
+  Napi::ObjectReference properties_obj_;
 
   std::function<void(void*)> deleter_;
   std::set<RclHandle*> children_;
+
+  static Napi::FunctionReference constructor;
 };
 
 }  // namespace rclnodejs
 
-#endif  // SRC_RCL_HANDLE_HPP_
+#endif  // SRC_RCL_HANDLE_H_