rclnodejs 0.32.5 → 1.0.0

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_

package/src/rcl_action_client_bindings.cpp

@@ -0,0 +1,231 @@
+// Copyright (c) 2020 Matt Richard. All rights reserved.
+//
+// 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_action_client_bindings.h"
+
+#include <rcl/error_handling.h>
+#include <rcl/rcl.h>
+#include <rcl_action/rcl_action.h>
+
+#include <string>
+
+#include "handle_manager.h"
+#include "macros.h"
+#include "rcl_handle.h"
+#include "rcl_utilities.h"
+
+namespace rclnodejs {
+
+Napi::Value ActionCreateClient(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 action_name = info[1].As<Napi::String>().Utf8Value();
+  std::string interface_name = info[2].As<Napi::String>().Utf8Value();
+  std::string package_name = info[3].As<Napi::String>().Utf8Value();
+
+  const rosidl_action_type_support_t* ts =
+      GetActionTypeSupport(package_name, interface_name);
+
+  if (ts) {
+    rcl_action_client_options_t action_client_ops =
+        rcl_action_client_get_default_options();
+
+    auto goal_service_qos = GetQoSProfile(info[4]);
+    auto result_service_qos = GetQoSProfile(info[5]);
+    auto cancel_service_qos = GetQoSProfile(info[6]);
+    auto feedback_topic_qos = GetQoSProfile(info[7]);
+    auto status_topic_qos = GetQoSProfile(info[8]);
+
+    if (goal_service_qos) {
+      action_client_ops.goal_service_qos = *goal_service_qos;
+    }
+    if (result_service_qos) {
+      action_client_ops.result_service_qos = *result_service_qos;
+    }
+    if (cancel_service_qos) {
+      action_client_ops.cancel_service_qos = *cancel_service_qos;
+    }
+    if (feedback_topic_qos) {
+      action_client_ops.feedback_topic_qos = *feedback_topic_qos;
+    }
+    if (status_topic_qos) {
+      action_client_ops.status_topic_qos = *status_topic_qos;
+    }
+
+    rcl_action_client_t* action_client = reinterpret_cast<rcl_action_client_t*>(
+        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);
+    auto js_obj = RclHandle::NewInstance(
+        env, action_client, node_handle, [node](void* ptr) {
+          rcl_action_client_t* action_client =
+              reinterpret_cast<rcl_action_client_t*>(ptr);
+          rcl_ret_t ret = rcl_action_client_fini(action_client, node);
+          free(ptr);
+          THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
+        });
+
+    return js_obj;
+  } else {
+    Napi::Error::New(env, GetErrorMessageAndClear())
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+}
+
+Napi::Value ActionServerIsAvailable(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());
+  RclHandle* action_client_handle =
+      RclHandle::Unwrap(info[1].As<Napi::Object>());
+  rcl_action_client_t* action_client =
+      reinterpret_cast<rcl_action_client_t*>(action_client_handle->ptr());
+
+  bool is_available;
+  THROW_ERROR_IF_NOT_EQUAL(
+      RCL_RET_OK,
+      rcl_action_server_is_available(node, action_client, &is_available),
+      rcl_get_error_string().str);
+
+  return Napi::Boolean::New(env, is_available);
+}
+
+Napi::Value ActionSendGoalRequest(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* action_client_handle =
+      RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_action_client_t* action_client =
+      reinterpret_cast<rcl_action_client_t*>(action_client_handle->ptr());
+  void* buffer = info[1].As<Napi::Buffer<char>>().Data();
+
+  int64_t sequence_number;
+  THROW_ERROR_IF_NOT_EQUAL(
+      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));
+}
+
+Napi::Value ActionTakeCancelRequest(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* action_server_handle =
+      RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_action_server_t* action_server =
+      reinterpret_cast<rcl_action_server_t*>(action_server_handle->ptr());
+  rmw_request_id_t* header =
+      reinterpret_cast<rmw_request_id_t*>(malloc(sizeof(rmw_request_id_t)));
+
+  void* taken_request = info[1].As<Napi::Buffer<char>>().Data();
+  rcl_ret_t ret =
+      rcl_action_take_cancel_request(action_server, header, taken_request);
+  if (ret != RCL_RET_ACTION_SERVER_TAKE_FAILED) {
+    auto js_obj = RclHandle::NewInstance(env, header, nullptr,
+                                         [](void* ptr) { free(ptr); });
+    return js_obj;
+  }
+
+  return env.Undefined();
+}
+
+Napi::Value ActionSendResultRequest(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* action_client_handle =
+      RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_action_client_t* action_client =
+      reinterpret_cast<rcl_action_client_t*>(action_client_handle->ptr());
+  void* buffer = info[1].As<Napi::Buffer<char>>().Data();
+
+  int64_t sequence_number;
+  THROW_ERROR_IF_NOT_EQUAL(
+      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));
+}
+
+Napi::Value ActionTakeFeedback(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* action_client_handle =
+      RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_action_client_t* action_client =
+      reinterpret_cast<rcl_action_client_t*>(action_client_handle->ptr());
+  void* buffer = info[1].As<Napi::Buffer<char>>().Data();
+
+  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();
+    rcl_reset_error();
+    return Napi::Boolean::New(env, false);
+  }
+
+  if (ret != RCL_RET_ACTION_CLIENT_TAKE_FAILED) {
+    return Napi::Boolean::New(env, true);
+  }
+  return env.Undefined();
+}
+
+Napi::Value ActionTakeStatus(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* action_client_handle =
+      RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_action_client_t* action_client =
+      reinterpret_cast<rcl_action_client_t*>(action_client_handle->ptr());
+  void* buffer = info[1].As<Napi::Buffer<char>>().Data();
+
+  rcl_ret_t ret = rcl_action_take_status(action_client, buffer);
+  if (ret != RCL_RET_OK && ret != RCL_RET_ACTION_CLIENT_TAKE_FAILED) {
+    rcl_reset_error();
+    Napi::Error::New(env, rcl_get_error_string().str)
+        .ThrowAsJavaScriptException();
+    return Napi::Boolean::New(env, false);
+  }
+
+  if (ret != RCL_RET_ACTION_CLIENT_TAKE_FAILED) {
+    return Napi::Boolean::New(env, true);
+  }
+  return env.Undefined();
+}
+
+Napi::Object InitActionClientBindings(Napi::Env env, Napi::Object exports) {
+  exports.Set("actionCreateClient",
+              Napi::Function::New(env, ActionCreateClient));
+  exports.Set("actionServerIsAvailable",
+              Napi::Function::New(env, ActionServerIsAvailable));
+  exports.Set("actionSendGoalRequest",
+              Napi::Function::New(env, ActionSendGoalRequest));
+  exports.Set("actionTakeCancelRequest",
+              Napi::Function::New(env, ActionTakeCancelRequest));
+  exports.Set("actionSendResultRequest",
+              Napi::Function::New(env, ActionSendResultRequest));
+  exports.Set("actionTakeFeedback",
+              Napi::Function::New(env, ActionTakeFeedback));
+  exports.Set("actionTakeStatus", Napi::Function::New(env, ActionTakeStatus));
+  return exports;
+}
+
+}  // namespace rclnodejs

package/src/{rcl_action_bindings.hpp → rcl_action_client_bindings.h}

@@ -12,20 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef SRC_RCL_ACTION_BINDINGS_HPP_
-#define SRC_RCL_ACTION_BINDINGS_HPP_
+#ifndef SRC_RCL_ACTION_CLIENT_BINDINGS_H_
+#define SRC_RCL_ACTION_CLIENT_BINDINGS_H_
 
-#include <nan.h>
-#include <rcl/rcl.h>
-
-#include <vector>
-
-#include "rcl_bindings.hpp"
+#include <napi.h>
 
 namespace rclnodejs {
 
-extern std::vector<BindingMethod> action_binding_methods;
+Napi::Object InitActionClientBindings(Napi::Env env, Napi::Object exports);
 
-}  // namespace rclnodejs
+}
 
-#endif  // SRC_RCL_ACTION_BINDINGS_HPP_
+#endif  // SRC_RCL_ACTION_CLIENT_BINDINGS_H_

package/src/rcl_action_goal_bindings.cpp

@@ -0,0 +1,117 @@
+// Copyright (c) 2020 Matt Richard. All rights reserved.
+//
+// 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_action_goal_bindings.h"
+
+#include <rcl/error_handling.h>
+#include <rcl/rcl.h>
+#include <rcl_action/rcl_action.h>
+
+#include "handle_manager.h"
+#include "macros.h"
+#include "rcl_handle.h"
+#include "rcl_utilities.h"
+
+namespace rclnodejs {
+
+Napi::Value ActionAcceptNewGoal(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* action_server_handle =
+      RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_action_server_t* action_server =
+      reinterpret_cast<rcl_action_server_t*>(action_server_handle->ptr());
+  rcl_action_goal_info_t* buffer = reinterpret_cast<rcl_action_goal_info_t*>(
+      info[1].As<Napi::Buffer<char>>().Data());
+
+  rcl_action_goal_handle_t* new_goal =
+      rcl_action_accept_new_goal(action_server, buffer);
+  if (!new_goal) {
+    Napi::Error::New(env, rcl_get_error_string().str)
+        .ThrowAsJavaScriptException();
+    rcl_reset_error();
+    return env.Undefined();
+  }
+
+  rcl_action_goal_handle_t* goal_handle =
+      reinterpret_cast<rcl_action_goal_handle_t*>(
+          malloc(sizeof(rcl_action_goal_handle_t)));
+  *goal_handle = *new_goal;
+  auto js_obj =
+      RclHandle::NewInstance(env, goal_handle, nullptr, [](void* ptr) {
+        rcl_action_goal_handle_t* goal_handle =
+            reinterpret_cast<rcl_action_goal_handle_t*>(ptr);
+        rcl_ret_t ret = rcl_action_goal_handle_fini(goal_handle);
+        free(ptr);
+        THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
+      });
+
+  return js_obj;
+}
+
+Napi::Value ActionUpdateGoalState(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* goal_handle_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_action_goal_handle_t* goal_handle =
+      reinterpret_cast<rcl_action_goal_handle_t*>(goal_handle_handle->ptr());
+  rcl_action_goal_event_t event = static_cast<rcl_action_goal_event_t>(
+      info[1].As<Napi::Number>().Int32Value());
+
+  THROW_ERROR_IF_NOT_EQUAL(rcl_action_update_goal_state(goal_handle, event),
+                           RCL_RET_OK, rcl_get_error_string().str);
+
+  return env.Undefined();
+}
+
+Napi::Value ActionGoalHandleIsActive(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* goal_handle_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_action_goal_handle_t* goal_handle =
+      reinterpret_cast<rcl_action_goal_handle_t*>(goal_handle_handle->ptr());
+
+  bool is_active = rcl_action_goal_handle_is_active(goal_handle);
+
+  return Napi::Boolean::New(env, is_active);
+}
+
+Napi::Value ActionGoalHandleGetStatus(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* goal_handle_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_action_goal_handle_t* goal_handle =
+      reinterpret_cast<rcl_action_goal_handle_t*>(goal_handle_handle->ptr());
+
+  rcl_action_goal_state_t status;
+  THROW_ERROR_IF_NOT_EQUAL(
+      rcl_action_goal_handle_get_status(goal_handle, &status), RCL_RET_OK,
+      rcl_get_error_string().str);
+
+  return Napi::Number::New(env, static_cast<int32_t>(status));
+}
+
+Napi::Object InitActionGoalBindings(Napi::Env env, Napi::Object exports) {
+  exports.Set("actionAcceptNewGoal",
+              Napi::Function::New(env, ActionAcceptNewGoal));
+  exports.Set("actionUpdateGoalState",
+              Napi::Function::New(env, ActionUpdateGoalState));
+  exports.Set("actionGoalHandleIsActive",
+              Napi::Function::New(env, ActionGoalHandleIsActive));
+  exports.Set("actionGoalHandleGetStatus",
+              Napi::Function::New(env, ActionGoalHandleGetStatus));
+  return exports;
+}
+
+}  // namespace rclnodejs

package/src/rcl_action_goal_bindings.h

@@ -0,0 +1,26 @@
+// Copyright (c) 2020 Matt Richard. All rights reserved.
+//
+// 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_ACTION_GOAL_BINDINGS_H_
+#define SRC_RCL_ACTION_GOAL_BINDINGS_H_
+
+#include <napi.h>
+
+namespace rclnodejs {
+
+Napi::Object InitActionGoalBindings(Napi::Env env, Napi::Object exports);
+
+}
+
+#endif  // SRC_RCL_ACTION_GOAL_BINDINGS_H_