rclnodejs 0.33.0 → 1.1.0

package/src/rcl_lifecycle_bindings.cpp

@@ -12,47 +12,45 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "rcl_lifecycle_bindings.hpp"
+#include "rcl_lifecycle_bindings.h"
 
+#include <lifecycle_msgs/msg/transition_event.h>
+#include <lifecycle_msgs/srv/change_state.h>
+#include <lifecycle_msgs/srv/get_available_states.h>
+#include <lifecycle_msgs/srv/get_available_transitions.h>
+#include <lifecycle_msgs/srv/get_state.h>
 #include <rcl/error_handling.h>
 #include <rcl_lifecycle/rcl_lifecycle.h>
 
 #include <memory>
 #include <string>
-#include <vector>
 
-#include "lifecycle_msgs/msg/transition_event.h"
-#include "lifecycle_msgs/srv/change_state.h"
-#include "lifecycle_msgs/srv/get_available_states.h"
-#include "lifecycle_msgs/srv/get_available_transitions.h"
-#include "lifecycle_msgs/srv/get_state.h"
-#include "macros.hpp"
-#include "rcl_handle.hpp"
-#include "rcl_utilities.hpp"
+#include "macros.h"
+#include "rcl_handle.h"
+#include "rcl_utilities.h"
 
 namespace rclnodejs {
 
-static v8::Local<v8::Object> wrapState(const rcl_lifecycle_state_t* state) {
-  v8::Local<v8::Object> jsState = Nan::New<v8::Object>();
-  Nan::Set(jsState, Nan::New("id").ToLocalChecked(), Nan::New(state->id));
-  Nan::Set(jsState, Nan::New("label").ToLocalChecked(),
-           Nan::New(state->label).ToLocalChecked());
+static Napi::Object wrapState(Napi::Env env,
+                              const rcl_lifecycle_state_t* state) {
+  Napi::Object jsState = Napi::Object::New(env);
+  jsState.Set("id", state->id);
+  jsState.Set("label", state->label);
   return jsState;
 }
 
-static v8::Local<v8::Object> wrapTransition(
-    const rcl_lifecycle_transition_t* transition) {
-  v8::Local<v8::Object> jsTransition = Nan::New<v8::Object>();
-  Nan::Set(jsTransition, Nan::New("id").ToLocalChecked(),
-           Nan::New(transition->id));
-  Nan::Set(jsTransition, Nan::New("label").ToLocalChecked(),
-           Nan::New(transition->label).ToLocalChecked());
+static Napi::Object wrapTransition(
+    Napi::Env env, const rcl_lifecycle_transition_t* transition) {
+  Napi::Object jsTransition = Napi::Object::New(env);
+  jsTransition.Set("id", transition->id);
+  jsTransition.Set("label", transition->label);
   return jsTransition;
 }
 
-NAN_METHOD(CreateLifecycleStateMachine) {
-  RclHandle* node_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
+Napi::Value CreateLifecycleStateMachine(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_lifecycle_state_machine_t* state_machine =
@@ -76,7 +74,7 @@ NAN_METHOD(CreateLifecycleStateMachine) {
 #if ROS_VERSION >= 2105
   rcl_lifecycle_state_machine_options_t options =
       rcl_lifecycle_get_default_state_machine_options();
-  options.enable_com_interface = Nan::To<bool>(info[1]).FromJust();
+  options.enable_com_interface = info[1].As<Napi::Boolean>().Value();
 
   THROW_ERROR_IF_NOT_EQUAL(
       RCL_RET_OK,
@@ -84,8 +82,8 @@ NAN_METHOD(CreateLifecycleStateMachine) {
                                        gat, gtg, &options),
       rcl_get_error_string().str);
 
-  auto js_obj =
-      RclHandle::NewInstance(state_machine, node_handle, [node](void* ptr) {
+  auto js_obj = RclHandle::NewInstance(
+      env, state_machine, node_handle, [node](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);
@@ -103,7 +101,7 @@ NAN_METHOD(CreateLifecycleStateMachine) {
                            rcl_get_error_string().str);
 
   auto js_obj = RclHandle::NewInstance(
-      state_machine, node_handle, [node, node_options](void* ptr) {
+      env, state_machine, node_handle, [node, node_options](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(
@@ -113,116 +111,122 @@ NAN_METHOD(CreateLifecycleStateMachine) {
       });
 #endif
 
-  info.GetReturnValue().Set(js_obj);
+  return js_obj;
 }
 
-NAN_METHOD(GetCurrentLifecycleState) {
-  RclHandle* state_machine_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
+Napi::Value GetCurrentLifecycleState(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());
 
   const rcl_lifecycle_state_t* current_state = state_machine->current_state;
-  info.GetReturnValue().Set(wrapState(current_state));
+  return wrapState(env, current_state);
 }
 
-NAN_METHOD(GetLifecycleTransitionByLabel) {
-  RclHandle* state_machine_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
+Napi::Value GetLifecycleTransitionByLabel(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());
 
-  std::string transition_label(*Nan::Utf8String(info[1]));
+  std::string transition_label = info[1].As<Napi::String>();
 
   auto transition = rcl_lifecycle_get_transition_by_label(
       state_machine->current_state, transition_label.c_str());
 
-  info.GetReturnValue().Set(transition == nullptr ? Nan::New<v8::Object>()
-                                                  : wrapTransition(transition));
+  return transition == nullptr ? Napi::Object::New(env)
+                               : wrapTransition(env, transition);
 }
 
 // return all registered states
-NAN_METHOD(GetLifecycleStates) {
-  RclHandle* state_machine_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
+Napi::Value GetLifecycleStates(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());
 
-  v8::Local<v8::Array> states = Nan::New<v8::Array>();
+  Napi::Array states = Napi::Array::New(env);
 
   for (uint8_t i = 0; i < state_machine->transition_map.states_size; ++i) {
     const rcl_lifecycle_state_t state = state_machine->transition_map.states[i];
-    v8::Local<v8::Object> jsState = wrapState(&state);
-    Nan::Set(states, i, jsState);
+    Napi::Object jsState = wrapState(env, &state);
+    states[i] = jsState;
   }
 
-  info.GetReturnValue().Set(states);
+  return states;
 }
 
 // return all registered transitions
-NAN_METHOD(GetLifecycleTransitions) {
-  RclHandle* state_machine_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
+Napi::Value GetLifecycleTransitions(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());
 
-  v8::Local<v8::Array> jsTransitions = Nan::New<v8::Array>();
+  Napi::Array jsTransitions = Napi::Array::New(env);
 
   for (uint8_t i = 0; i < state_machine->transition_map.transitions_size; ++i) {
     auto transition = state_machine->transition_map.transitions[i];
-    v8::Local<v8::Object> jsTransitionDesc = Nan::New<v8::Object>();
-    Nan::Set(jsTransitionDesc, Nan::New("transition").ToLocalChecked(),
-             wrapTransition(&transition));
-    Nan::Set(jsTransitionDesc, Nan::New("start_state").ToLocalChecked(),
-             wrapState(transition.start));
-    Nan::Set(jsTransitionDesc, Nan::New("goal_state").ToLocalChecked(),
-             wrapState(transition.goal));
-
-    Nan::Set(jsTransitions, i, jsTransitionDesc);
+    Napi::Object jsTransitionDesc = Napi::Object::New(env);
+    jsTransitionDesc.Set("transition", wrapTransition(env, &transition));
+    jsTransitionDesc.Set("start_state", wrapState(env, transition.start));
+    jsTransitionDesc.Set("goal_state", wrapState(env, transition.goal));
+
+    jsTransitions[i] = jsTransitionDesc;
   }
 
-  info.GetReturnValue().Set(jsTransitions);
+  return jsTransitions;
 }
 
 // return the transitions available from the current state
-NAN_METHOD(GetAvailableLifecycleTransitions) {
-  RclHandle* state_machine_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
+Napi::Value GetAvailableLifecycleTransitions(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());
 
-  v8::Local<v8::Array> jsTransitions = Nan::New<v8::Array>();
+  Napi::Array jsTransitions = Napi::Array::New(env);
 
   for (uint8_t i = 0; i < state_machine->current_state->valid_transition_size;
        ++i) {
     auto transition = state_machine->current_state->valid_transitions[i];
-    v8::Local<v8::Object> jsTransitionDesc = Nan::New<v8::Object>();
-    Nan::Set(jsTransitionDesc, Nan::New("transition").ToLocalChecked(),
-             wrapTransition(&transition));
-    Nan::Set(jsTransitionDesc, Nan::New("start_state").ToLocalChecked(),
-             wrapState(transition.start));
-    Nan::Set(jsTransitionDesc, Nan::New("goal_state").ToLocalChecked(),
-             wrapState(transition.goal));
-
-    Nan::Set(jsTransitions, i, jsTransitionDesc);
+    Napi::Object jsTransitionDesc = Napi::Object::New(env);
+    jsTransitionDesc.Set("transition", wrapTransition(env, &transition));
+    jsTransitionDesc.Set("start_state", wrapState(env, transition.start));
+    jsTransitionDesc.Set("goal_state", wrapState(env, transition.goal));
+
+    jsTransitions[i] = jsTransitionDesc;
   }
 
-  info.GetReturnValue().Set(jsTransitions);
+  return jsTransitions;
 }
 
-NAN_METHOD(GetLifecycleSrvNameAndHandle) {
-  RclHandle* state_machine_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
+Napi::Value GetLifecycleSrvNameAndHandle(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());
 
-  std::string lifecycle_srv_field_name(*Nan::Utf8String(info[1]));
+  std::string lifecycle_srv_field_name = info[1].As<Napi::String>();
 
   rcl_service_t* service = nullptr;
   if (lifecycle_srv_field_name.compare("srv_get_state") == 0) {
@@ -242,27 +246,28 @@ NAN_METHOD(GetLifecycleSrvNameAndHandle) {
   std::string service_name = rcl_service_get_service_name(service);
 
   // build result object {name: <srv_name>, handle: <rcl handle of service_t>}
-  v8::Local<v8::Object> named_srv_obj = Nan::New<v8::Object>();
-  Nan::Set(named_srv_obj, Nan::New("name").ToLocalChecked(),
-           Nan::New(service_name).ToLocalChecked());
+  Napi::Object named_srv_obj = Napi::Object::New(env);
+  named_srv_obj.Set("name", service_name);
 
   // Note: lifecycle Services are created and managed by their
   // rcl_lifecycle_state_machine. Thus we must not manually
   // free the lifecycle_state_machine's service pointers.
-  auto srv_handle = RclHandle::NewInstance(service, nullptr, nullptr);
+  auto srv_handle = RclHandle::NewInstance(env, service, nullptr, nullptr);
 
-  Nan::Set(named_srv_obj, Nan::New("handle").ToLocalChecked(), srv_handle);
-  info.GetReturnValue().Set(named_srv_obj);
+  named_srv_obj.Set("handle", srv_handle);
+  return named_srv_obj;
 }
 
 // return null if transition exists from current state
-NAN_METHOD(TriggerLifecycleTransitionById) {
-  RclHandle* state_machine_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
+Napi::Value TriggerLifecycleTransitionById(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());
-  int transition_id = Nan::To<int64_t>(info[1]).FromJust();
+  int transition_id = info[1].As<Napi::Number>().Int64Value();
 
   bool publish = true;
 
@@ -272,17 +277,19 @@ NAN_METHOD(TriggerLifecycleTransitionById) {
                            rcl_get_error_string().str);
 
   const rcl_lifecycle_state_t* current_state = state_machine->current_state;
-  info.GetReturnValue().Set(wrapState(current_state));
+  return wrapState(env, current_state);
 }
 
 // return null if transition exists from current state
-NAN_METHOD(TriggerLifecycleTransitionByLabel) {
-  RclHandle* state_machine_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
+Napi::Value TriggerLifecycleTransitionByLabel(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());
-  std::string transition_label(*Nan::Utf8String(info[1]));
+  std::string transition_label = info[1].As<Napi::String>();
 
   bool publish = true;
 
@@ -293,7 +300,7 @@ NAN_METHOD(TriggerLifecycleTransitionByLabel) {
       rcl_get_error_string().str);
 
   const rcl_lifecycle_state_t* current_state = state_machine->current_state;
-  info.GetReturnValue().Set(wrapState(current_state));
+  return wrapState(env, current_state);
 }
 
 static const char* transitionId2Label(int callback_ret) {
@@ -340,29 +347,56 @@ static const char* transitionId2Label(int callback_ret) {
   return rcl_lifecycle_transition_error_label;
 }
 
-NAN_METHOD(GetLifecycleTransitionIdToLabel) {
-  int callback_ret = Nan::To<int64_t>(info[0]).FromJust();
+Napi::Value GetLifecycleTransitionIdToLabel(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  int callback_ret = info[0].As<Napi::Number>().Int64Value();
   const char* transition_label = transitionId2Label(callback_ret);
-  info.GetReturnValue().Set(Nan::New(transition_label).ToLocalChecked());
+  return Napi::String::New(env, transition_label);
 }
 
-NAN_METHOD(GetLifecycleShutdownTransitionLabel) {
-  info.GetReturnValue().Set(
-      Nan::New(rcl_lifecycle_shutdown_label).ToLocalChecked());
+Napi::Value GetLifecycleShutdownTransitionLabel(
+    const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  return Napi::String::New(env, rcl_lifecycle_shutdown_label);
 }
 
-std::vector<BindingMethod> lifecycle_binding_methods = {
-    {"createLifecycleStateMachine", CreateLifecycleStateMachine},
-    {"getCurrentLifecycleState", GetCurrentLifecycleState},
-    {"getLifecycleTransitionByLabel", GetLifecycleTransitionByLabel},
-    {"getLifecycleStates", GetLifecycleStates},
-    {"getLifecycleTransitions", GetLifecycleTransitions},
-    {"getAvailableLifecycleTransitions", GetAvailableLifecycleTransitions},
-    {"triggerLifecycleTransitionById", TriggerLifecycleTransitionById},
-    {"triggerLifecycleTransitionByLabel", TriggerLifecycleTransitionByLabel},
-    {"getLifecycleSrvNameAndHandle", GetLifecycleSrvNameAndHandle},
-    {"getLifecycleTransitionIdToLabel", GetLifecycleTransitionIdToLabel},
-    {"getLifecycleShutdownTransitionLabel",
-     GetLifecycleShutdownTransitionLabel}};
+Napi::Value IsInitialized(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());
+  const bool is_initialized =
+      RCL_RET_OK == rcl_lifecycle_state_machine_is_initialized(state_machine);
+  return Napi::Boolean::New(env, is_initialized);
+}
+
+Napi::Object InitLifecycleBindings(Napi::Env env, Napi::Object exports) {
+  exports.Set("createLifecycleStateMachine",
+              Napi::Function::New(env, CreateLifecycleStateMachine));
+  exports.Set("getCurrentLifecycleState",
+              Napi::Function::New(env, GetCurrentLifecycleState));
+  exports.Set("getLifecycleTransitionByLabel",
+              Napi::Function::New(env, GetLifecycleTransitionByLabel));
+  exports.Set("getLifecycleStates",
+              Napi::Function::New(env, GetLifecycleStates));
+  exports.Set("getLifecycleTransitions",
+              Napi::Function::New(env, GetLifecycleTransitions));
+  exports.Set("getAvailableLifecycleTransitions",
+              Napi::Function::New(env, GetAvailableLifecycleTransitions));
+  exports.Set("triggerLifecycleTransitionById",
+              Napi::Function::New(env, TriggerLifecycleTransitionById));
+  exports.Set("triggerLifecycleTransitionByLabel",
+              Napi::Function::New(env, TriggerLifecycleTransitionByLabel));
+  exports.Set("getLifecycleSrvNameAndHandle",
+              Napi::Function::New(env, GetLifecycleSrvNameAndHandle));
+  exports.Set("getLifecycleTransitionIdToLabel",
+              Napi::Function::New(env, GetLifecycleTransitionIdToLabel));
+  exports.Set("getLifecycleShutdownTransitionLabel",
+              Napi::Function::New(env, GetLifecycleShutdownTransitionLabel));
+  exports.Set("isInitialized", Napi::Function::New(env, IsInitialized));
+  return exports;
+}
 
 }  // namespace rclnodejs

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

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

package/src/rcl_logging_bindings.cpp

@@ -0,0 +1,96 @@
+// 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_logging_bindings.h"
+
+#include <rcl/error_handling.h>
+#include <rcl/rcl.h>
+
+#include <string>
+
+#include "macros.h"
+#include "rcl_utilities.h"
+
+namespace rclnodejs {
+
+Napi::Value setLoggerLevel(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  std::string name = info[0].As<Napi::String>().Utf8Value();
+  int level = info[1].As<Napi::Number>().Int64Value();
+
+  rcutils_ret_t ret = rcutils_logging_set_logger_level(name.c_str(), level);
+  if (ret != RCUTILS_RET_OK) {
+    Napi::Error::New(env, rcutils_get_error_string().str)
+        .ThrowAsJavaScriptException();
+    rcutils_reset_error();
+  }
+  return env.Undefined();
+}
+
+Napi::Value GetLoggerEffectiveLevel(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  std::string name = info[0].As<Napi::String>().Utf8Value();
+  int logger_level = rcutils_logging_get_logger_effective_level(name.c_str());
+
+  if (logger_level < 0) {
+    Napi::Error::New(env, rcutils_get_error_string().str)
+        .ThrowAsJavaScriptException();
+    rcutils_reset_error();
+    return env.Undefined();
+  }
+  return Napi::Number::New(env, logger_level);
+}
+
+Napi::Value Log(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  std::string name = info[0].As<Napi::String>().Utf8Value();
+  int severity = info[1].As<Napi::Number>().Int64Value();
+  std::string message = info[2].As<Napi::String>().Utf8Value();
+  std::string function_name = info[3].As<Napi::String>().Utf8Value();
+  size_t line_number = info[4].As<Napi::Number>().Int64Value();
+  std::string file_name = info[5].As<Napi::String>().Utf8Value();
+  bool enabled = rcutils_logging_logger_is_enabled_for(name.c_str(), severity);
+
+  if (enabled) {
+    rcutils_log_location_t logging_location = {function_name.c_str(),
+                                               file_name.c_str(), line_number};
+    rcutils_log(&logging_location, severity, name.c_str(), "%s",
+                message.c_str());
+  }
+
+  return Napi::Boolean::New(env, enabled);
+}
+
+Napi::Value IsEnableFor(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  std::string name = info[0].As<Napi::String>().Utf8Value();
+  int severity = info[1].As<Napi::Number>().Int64Value();
+  bool enabled = rcutils_logging_logger_is_enabled_for(name.c_str(), severity);
+  return Napi::Boolean::New(env, enabled);
+}
+
+Napi::Object InitLoggingBindings(Napi::Env env, Napi::Object exports) {
+  exports.Set("setLoggerLevel", Napi::Function::New(env, setLoggerLevel));
+  exports.Set("getLoggerEffectiveLevel",
+              Napi::Function::New(env, GetLoggerEffectiveLevel));
+  exports.Set("log", Napi::Function::New(env, Log));
+  exports.Set("isEnableFor", Napi::Function::New(env, IsEnableFor));
+  return exports;
+}
+
+}  // namespace rclnodejs

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