rclnodejs 1.1.0 → 1.2.0

package/lib/publisher.js

@@ -24,8 +24,12 @@ const Entity = require('./entity.js');
  */
 
 class Publisher extends Entity {
-  constructor(handle, typeClass, topic, options) {
+  constructor(handle, typeClass, topic, options, node, eventCallbacks) {
     super(handle, typeClass, options);
+    if (node && eventCallbacks) {
+      this._events = eventCallbacks.createEventHandlers(this.handle);
+      node._events.push(...this._events);
+    }
   }
 
   /**
@@ -60,17 +64,24 @@ class Publisher extends Entity {
     debug(`Message of topic ${this.topic} has been published.`);
   }
 
-  static createPublisher(nodeHandle, typeClass, topic, options) {
+  static createPublisher(node, typeClass, topic, options, eventCallbacks) {
     let type = typeClass.type();
     let handle = rclnodejs.createPublisher(
-      nodeHandle,
+      node.handle,
       type.pkgName,
       type.subFolder,
       type.interfaceName,
       topic,
       options.qos
     );
-    return new Publisher(handle, typeClass, topic, options);
+    return new Publisher(
+      handle,
+      typeClass,
+      topic,
+      options,
+      node,
+      eventCallbacks
+    );
   }
 
   /**
@@ -99,6 +110,22 @@ class Publisher extends Entity {
   waitForAllAcked(timeout) {
     return rclnodejs.waitForAllAcked(this._handle, timeout);
   }
+
+  /**
+   * Get the event handlers for this publisher.
+   * @returns {Array} The array of event handlers for this publisher.
+   */
+  get events() {
+    return this._events;
+  }
+
+  /**
+   * Set the event handlers for this publisher.
+   * @param {Array} events - The array of event handlers to be set for this publisher.
+   */
+  set events(events) {
+    this._events = events;
+  }
 }
 
 module.exports = Publisher;

package/lib/subscription.js

@@ -29,11 +29,24 @@ const debug = require('debug')('rclnodejs:subscription');
  */
 
 class Subscription extends Entity {
-  constructor(handle, typeClass, topic, options, callback) {
+  constructor(
+    handle,
+    typeClass,
+    topic,
+    options,
+    callback,
+    node,
+    eventCallbacks
+  ) {
     super(handle, typeClass, options);
     this._topic = topic;
     this._callback = callback;
     this._isRaw = options.isRaw || false;
+
+    if (node && eventCallbacks) {
+      this._events = eventCallbacks.createEventHandlers(this.handle);
+      node._events.push(...this._events);
+    }
   }
 
   processResponse(msg) {
@@ -45,7 +58,14 @@ class Subscription extends Entity {
     }
   }
 
-  static createSubscription(nodeHandle, typeClass, topic, options, callback) {
+  static createSubscription(
+    node,
+    typeClass,
+    topic,
+    options,
+    callback,
+    eventCallbacks
+  ) {
     let type = typeClass.type();
 
     // convert contentFilter.parameters to a string[]
@@ -56,14 +76,22 @@ class Subscription extends Entity {
     }
 
     let handle = rclnodejs.createSubscription(
-      nodeHandle,
+      node.handle,
       type.pkgName,
       type.subFolder,
       type.interfaceName,
       topic,
       options
     );
-    return new Subscription(handle, typeClass, topic, options, callback);
+    return new Subscription(
+      handle,
+      typeClass,
+      topic,
+      options,
+      callback,
+      node,
+      eventCallbacks
+    );
   }
 
   /**
@@ -124,6 +152,22 @@ class Subscription extends Entity {
   get publisherCount() {
     return rclnodejs.getPublisherCount(this._handle);
   }
+
+  /**
+   * Get the event handlers for this subscription.
+   * @returns {Array} The array of event handlers for this subscription.
+   */
+  get events() {
+    return this._events;
+  }
+
+  /**
+   * Set the event handlers for this subscription.
+   * @param {Array} events - The array of event handlers for this subscription.
+   */
+  set events(events) {
+    this._events = events;
+  }
 }
 
 module.exports = Subscription;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rclnodejs",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "ROS2.0 JavaScript client with Node.js",
   "main": "index.js",
   "types": "types/index.d.ts",

package/scripts/npmjs-readme.md

@@ -1,4 +1,4 @@
-# rclnodejs ![GitHub Workflow Status](https://github.com/RobotWebTools/rclnodejs/actions/workflows/linux-build-and-test.yml/badge.svg?branch=jazzy)
+# rclnodejs [![Linux](https://github.com/RobotWebTools/rclnodejs/actions/workflows/linux-x64-build-and-test.yml/badge.svg?branch=develop)](https://github.com/RobotWebTools/rclnodejs/actions/workflows/linux-x64-build-and-test.yml?query=branch%3Adevelop)[![Linux](https://github.com/RobotWebTools/rclnodejs/actions/workflows/linux-arm64-build-and-test.yml/badge.svg?branch=develop)](https://github.com/RobotWebTools/rclnodejs/actions/workflows/linux-arm64-build-and-test.yml?query=branch%3Adevelop)
 
 `rclnodejs` is a Node.js client for the Robot Operating System (ROS 2). It provides a simple and easy JavaScript API for ROS 2 programming. TypeScript declarations are included to support use of rclnodejs in TypeScript projects.
 
@@ -22,8 +22,8 @@ rclnodejs.init().then(() => {
 
 **ROS 2 SDK**
 
-- See the ROS 2 SDK [Installation Guide](https://docs.ros.org/en/jazzy/Installation.html) for details.
-- **DON'T FORGET TO [SOURCE THE ROS 2 STARTUP FILES](https://docs.ros.org/en/jazzy/Tutorials/Beginner-CLI-Tools/Configuring-ROS2-Environment.html#source-the-setup-files)**
+- See the ROS 2 SDK [Installation Guide](https://docs.ros.org/en/kilted/Installation.html) for details.
+- **DON'T FORGET TO [SOURCE THE ROS 2 STARTUP FILES](https://docs.ros.org/en/kilted/Tutorials/Beginner-CLI-Tools/Configuring-ROS2-Environment.htmls)**
 
 ## Install rclnodejs
 
@@ -45,7 +45,7 @@ npm i rclnodejs@x.y.z
 
 |                                     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) |
+| latest version (currently [v1.2.0](https://github.com/RobotWebTools/rclnodejs/tree/1.2.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

@@ -35,6 +35,7 @@
 #include "rcl_time_point_bindings.h"
 #include "rcl_timer_bindings.h"
 #if ROS_VERSION > 2205  // ROS2 > Humble
+#include "rcl_event_handle_bindings.h"
 #include "rcl_type_description_service_bindings.h"
 #endif
 #include "rcl_utilities.h"
@@ -84,6 +85,7 @@ Napi::Object InitModule(Napi::Env env, Napi::Object exports) {
   rclnodejs::InitTimerBindings(env, exports);
 #if ROS_VERSION > 2205  // ROS2 > Humble
   rclnodejs::InitTypeDescriptionServiceBindings(env, exports);
+  rclnodejs::InitEventHandleBindings(env, exports);
 #endif
   rclnodejs::InitLifecycleBindings(env, exports);
   rclnodejs::ShadowNode::Init(env, exports);

package/src/executor.cpp

@@ -190,10 +190,11 @@ RclResult Executor::WaitForReadyCallbacks(rcl_wait_set_t* wait_set,
     size_t num_timers = 0u;
     size_t num_clients = 0u;
     size_t num_services = 0u;
+    size_t num_events = 0u;
 
     rcl_ret_t get_entity_ret = handle_manager_->GetEntityCounts(
         &num_subscriptions, &num_guard_conditions, &num_timers, &num_clients,
-        &num_services);
+        &num_services, &num_events);
     if (get_entity_ret != RCL_RET_OK) {
       std::string error_message = std::string("Failed to get entity counts: ") +
                                   std::string(rcl_get_error_string().str);
@@ -202,9 +203,7 @@ RclResult Executor::WaitForReadyCallbacks(rcl_wait_set_t* wait_set,
 
     rcl_ret_t resize_ret =
         rcl_wait_set_resize(wait_set, num_subscriptions, num_guard_conditions,
-                            num_timers, num_clients, num_services,
-                            // TODO(minggang): support events.
-                            0u);
+                            num_timers, num_clients, num_services, num_events);
     if (resize_ret != RCL_RET_OK) {
       std::string error_message = std::string("Failed to resize: ") +
                                   std::string(rcl_get_error_string().str);

package/src/handle_manager.cpp

@@ -40,7 +40,6 @@ HandleManager::~HandleManager() {
 
 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");
@@ -48,6 +47,7 @@ void HandleManager::SynchronizeHandles(const Napi::Object& node) {
   Napi::Value guard_conditions = node.Get("_guards");
   Napi::Value action_clients = node.Get("_actionClients");
   Napi::Value action_servers = node.Get("_actionServers");
+  Napi::Value events = node.Get("_events");
 
   uint32_t sum = 0;
   is_synchronizing_.store(true);
@@ -66,6 +66,7 @@ void HandleManager::SynchronizeHandles(const Napi::Object& node) {
                                     &action_clients_);
     sum += SynchronizeHandlesByType(action_servers.As<Napi::Object>(),
                                     &action_servers_);
+    sum += SynchronizeHandlesByType(events.As<Napi::Object>(), &events_);
   }
   is_synchronizing_.store(false);
 
@@ -98,6 +99,7 @@ void HandleManager::ClearHandles() {
   guard_conditions_.clear();
   action_clients_.clear();
   action_servers_.clear();
+  events_.clear();
 }
 
 rcl_ret_t HandleManager::AddHandlesToWaitSet(rcl_wait_set_t* wait_set) {
@@ -152,6 +154,11 @@ rcl_ret_t HandleManager::AddHandlesToWaitSet(rcl_wait_set_t* wait_set) {
     if (ret != RCL_RET_OK) return ret;
   }
 
+  for (auto& event : events_) {
+    rcl_event_t* rcl_event = reinterpret_cast<rcl_event_t*>(event->ptr());
+    rcl_ret_t ret = rcl_wait_set_add_event(wait_set, rcl_event, nullptr);
+    if (ret != RCL_RET_OK) return ret;
+  }
   return RCL_RET_OK;
 }
 
@@ -169,6 +176,8 @@ rcl_ret_t HandleManager::CollectReadyHandles(rcl_wait_set_t* wait_set) {
   CollectReadyHandlesByType(wait_set->guard_conditions,
                             wait_set->size_of_guard_conditions,
                             guard_conditions_, &ready_handles);
+  CollectReadyHandlesByType(wait_set->events, wait_set->size_of_events, events_,
+                            &ready_handles);
 
   rcl_ret_t ret = CollectReadyActionHandles(wait_set, &ready_handles);
   if (!ready_handles.empty()) {
@@ -184,7 +193,8 @@ rcl_ret_t HandleManager::GetEntityCounts(size_t* subscriptions_size,
                                          size_t* guard_conditions_size,
                                          size_t* timers_size,
                                          size_t* clients_size,
-                                         size_t* services_size) {
+                                         size_t* services_size,
+                                         size_t* events_size) {
   size_t num_subscriptions = 0u;
   size_t num_guard_conditions = 0u;
   size_t num_timers = 0u;
@@ -230,6 +240,7 @@ rcl_ret_t HandleManager::GetEntityCounts(size_t* subscriptions_size,
   *timers_size += timer_count();
   *clients_size += client_count();
   *services_size += service_count();
+  *events_size += event_count();
 
   return RCL_RET_OK;
 }

package/src/handle_manager.h

@@ -68,13 +68,15 @@ class HandleManager {
   rcl_ret_t CollectReadyHandles(rcl_wait_set_t* wait_set);
   rcl_ret_t GetEntityCounts(size_t* subscriptions_size,
                             size_t* guard_conditions_size, size_t* timers_size,
-                            size_t* clients_size, size_t* services_size);
+                            size_t* clients_size, size_t* services_size,
+                            size_t* events_size);
 
   uint32_t subscription_count() const { return subscriptions_.size(); }
   uint32_t service_count() const { return services_.size(); }
   uint32_t client_count() const { return clients_.size(); }
   uint32_t timer_count() const { return timers_.size(); }
   uint32_t guard_condition_count() const { return guard_conditions_.size(); }
+  uint32_t event_count() const { return events_.size(); }
   uv_rwlock_t* handle_rwlock() { return &sync_handles_rwlock_; }
 
   uint32_t ready_handles_count();
@@ -110,6 +112,7 @@ class HandleManager {
   std::vector<rclnodejs::RclHandle*> action_servers_;
   std::vector<rclnodejs::RclHandle*> action_clients_;
   std::vector<rclnodejs::RclHandle*> ready_handles_;
+  std::vector<rclnodejs::RclHandle*> events_;
 
   // Protects the handles.
   uv_rwlock_t sync_handles_rwlock_;

package/src/rcl_event_handle_bindings.cpp

@@ -0,0 +1,294 @@
+// 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_event_handle_bindings.h"
+
+#include <rcl/error_handling.h>
+#include <rcl/rcl.h>
+
+#include "rcl_handle.h"
+
+namespace {
+
+typedef union event_callback_data {
+  // Subscription events
+  rmw_requested_deadline_missed_status_t requested_deadline_missed;
+  rmw_liveliness_changed_status_t liveliness_changed;
+  rmw_message_lost_status_t message_lost;
+  rmw_requested_qos_incompatible_event_status_t requested_incompatible_qos;
+  rmw_matched_status_t subscription_matched;
+  // Publisher events
+  rmw_offered_deadline_missed_status_t offered_deadline_missed;
+  rmw_liveliness_lost_status_t liveliness_lost;
+  rmw_offered_qos_incompatible_event_status_t offered_incompatible_qos;
+  rmw_matched_status_t publisher_matched;
+
+  rmw_incompatible_type_status_t incompatible_type;
+} event_callback_data_t;
+
+rcl_event_t* CreateEventHandle() {
+  rcl_event_t* event =
+      reinterpret_cast<rcl_event_t*>(malloc(sizeof(rcl_event_t)));
+  *event = rcl_get_zero_initialized_event();
+  return event;
+}
+
+Napi::Value CreateJSObjectForSubscriptionEvent(
+    Napi::Env env, rcl_subscription_event_type_t subscription_event_type,
+    const event_callback_data_t& data) {
+  Napi::Object obj = Napi::Object::New(env);
+  switch (subscription_event_type) {
+    case RCL_SUBSCRIPTION_REQUESTED_DEADLINE_MISSED: {
+      obj.Set(
+          "total_count",
+          Napi::Number::New(env, data.requested_deadline_missed.total_count));
+      obj.Set("total_count_change",
+              Napi::Number::New(
+                  env, data.requested_deadline_missed.total_count_change));
+      break;
+    }
+    case RCL_SUBSCRIPTION_LIVELINESS_CHANGED: {
+      obj.Set("alive_count",
+              Napi::Number::New(env, data.liveliness_changed.alive_count));
+      obj.Set("not_alive_count",
+              Napi::Number::New(env, data.liveliness_changed.not_alive_count));
+      obj.Set(
+          "alive_count_change",
+          Napi::Number::New(env, data.liveliness_changed.alive_count_change));
+      obj.Set("not_alive_count_change",
+              Napi::Number::New(
+                  env, data.liveliness_changed.not_alive_count_change));
+      break;
+    }
+    case RCL_SUBSCRIPTION_MESSAGE_LOST: {
+      obj.Set("total_count",
+              Napi::Number::New(env, data.message_lost.total_count));
+      obj.Set("total_count_change",
+              Napi::Number::New(env, data.message_lost.total_count_change));
+      break;
+    }
+    case RCL_SUBSCRIPTION_REQUESTED_INCOMPATIBLE_QOS: {
+      obj.Set(
+          "total_count",
+          Napi::Number::New(env, data.requested_incompatible_qos.total_count));
+      obj.Set("total_count_change",
+              Napi::Number::New(
+                  env, data.requested_incompatible_qos.total_count_change));
+      obj.Set("last_policy_kind",
+              Napi::Number::New(
+                  env, data.requested_incompatible_qos.last_policy_kind));
+      break;
+    }
+    case RCL_SUBSCRIPTION_INCOMPATIBLE_TYPE: {
+      obj.Set("total_count",
+              Napi::Number::New(env, data.incompatible_type.total_count));
+      obj.Set(
+          "total_count_change",
+          Napi::Number::New(env, data.incompatible_type.total_count_change));
+      break;
+    }
+    case RCL_SUBSCRIPTION_MATCHED: {
+      obj.Set("total_count",
+              Napi::Number::New(env, data.subscription_matched.total_count));
+      obj.Set(
+          "total_count_change",
+          Napi::Number::New(env, data.subscription_matched.total_count_change));
+      obj.Set("current_count",
+              Napi::Number::New(env, data.subscription_matched.current_count));
+      obj.Set("current_count_change",
+              Napi::Number::New(
+                  env, data.subscription_matched.current_count_change));
+      break;
+    }
+    default:
+      break;
+  }
+  return obj;
+}
+
+Napi::Value CreateJSObjectForPublisherEvent(
+    Napi::Env env, rcl_publisher_event_type_t publisher_event_type,
+    const event_callback_data_t& data) {
+  Napi::Object obj = Napi::Object::New(env);
+  switch (publisher_event_type) {
+    case RCL_PUBLISHER_OFFERED_DEADLINE_MISSED: {
+      obj.Set("total_count",
+              Napi::Number::New(env, data.offered_deadline_missed.total_count));
+      obj.Set("total_count_change",
+              Napi::Number::New(
+                  env, data.offered_deadline_missed.total_count_change));
+      break;
+    }
+    case RCL_PUBLISHER_LIVELINESS_LOST: {
+      obj.Set("total_count",
+              Napi::Number::New(env, data.liveliness_lost.total_count));
+      obj.Set("total_count_change",
+              Napi::Number::New(env, data.liveliness_lost.total_count_change));
+      break;
+    }
+    case RCL_PUBLISHER_OFFERED_INCOMPATIBLE_QOS: {
+      obj.Set(
+          "total_count",
+          Napi::Number::New(env, data.offered_incompatible_qos.total_count));
+      obj.Set("total_count_change",
+              Napi::Number::New(
+                  env, data.offered_incompatible_qos.total_count_change));
+      obj.Set("last_policy_kind",
+              Napi::Number::New(
+                  env, data.offered_incompatible_qos.last_policy_kind));
+      break;
+    }
+    case RCL_PUBLISHER_INCOMPATIBLE_TYPE: {
+      obj.Set("total_count",
+              Napi::Number::New(env, data.incompatible_type.total_count));
+      obj.Set(
+          "total_count_change",
+          Napi::Number::New(env, data.incompatible_type.total_count_change));
+      break;
+    }
+    case RCL_PUBLISHER_MATCHED: {
+      obj.Set("total_count",
+              Napi::Number::New(env, data.publisher_matched.total_count));
+      obj.Set(
+          "total_count_change",
+          Napi::Number::New(env, data.publisher_matched.total_count_change));
+      obj.Set("current_count",
+              Napi::Number::New(env, data.publisher_matched.current_count));
+      obj.Set(
+          "current_count_change",
+          Napi::Number::New(env, data.publisher_matched.current_count_change));
+      break;
+    }
+    default:
+      break;
+  }
+  return obj;
+}
+
+}  // namespace
+
+namespace rclnodejs {
+
+Napi::Value CreateSubscriptionEventHandle(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* subscription_handle =
+      RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_subscription_t* subscription =
+      reinterpret_cast<rcl_subscription_t*>(subscription_handle->ptr());
+  rcl_subscription_event_type_t event_type =
+      static_cast<rcl_subscription_event_type_t>(
+          info[1].As<Napi::Number>().Int32Value());
+
+  rcl_event_t* event = CreateEventHandle();
+  rcl_ret_t ret = rcl_subscription_event_init(event, subscription, event_type);
+
+  if (ret != RCL_RET_OK) {
+    Napi::Error::New(env, "failed to create subscription event")
+        .ThrowAsJavaScriptException();
+    rcl_reset_error();
+    free(event);
+    return env.Undefined();
+  }
+
+  auto js_obj = RclHandle::NewInstance(env, event, nullptr, [env](void* ptr) {
+    rcl_event_t* event = reinterpret_cast<rcl_event_t*>(ptr);
+    rcl_ret_t ret = rcl_event_fini(event);
+    if (ret != RCL_RET_OK) {
+      Napi::Error::New(env, rcl_get_error_string().str)
+          .ThrowAsJavaScriptException();
+      rcl_reset_error();
+    }
+    free(ptr);
+  });
+  return js_obj;
+}
+
+Napi::Value CreatePublisherEventHandle(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* publisher_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_publisher_t* publisher =
+      reinterpret_cast<rcl_publisher_t*>(publisher_handle->ptr());
+  rcl_publisher_event_type_t event_type =
+      static_cast<rcl_publisher_event_type_t>(
+          info[1].As<Napi::Number>().Int32Value());
+
+  rcl_event_t* event = CreateEventHandle();
+  rcl_ret_t ret = rcl_publisher_event_init(event, publisher, event_type);
+
+  if (ret != RCL_RET_OK) {
+    Napi::Error::New(env, "failed to create publisher event")
+        .ThrowAsJavaScriptException();
+    rcl_reset_error();
+    free(event);
+    return env.Undefined();
+  }
+
+  auto js_obj = RclHandle::NewInstance(env, event, nullptr, [env](void* ptr) {
+    rcl_event_t* event = reinterpret_cast<rcl_event_t*>(ptr);
+    rcl_ret_t ret = rcl_event_fini(event);
+    if (ret != RCL_RET_OK) {
+      Napi::Error::New(env, rcl_get_error_string().str)
+          .ThrowAsJavaScriptException();
+      rcl_reset_error();
+    }
+    free(ptr);
+  });
+  return js_obj;
+}
+
+Napi::Value TakeEvent(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* event_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_event_t* event = reinterpret_cast<rcl_event_t*>(event_handle->ptr());
+  auto event_type = info[1].As<Napi::Object>();
+
+  event_callback_data_t data;
+  rcl_ret_t ret;
+  if (event_type.Has("subscription_event_type")) {
+    rcl_subscription_event_type_t subscription_event_type =
+        static_cast<rcl_subscription_event_type_t>(
+            event_type.Get("subscription_event_type")
+                .As<Napi::Number>()
+                .Int32Value());
+    ret = rcl_take_event(event, &data);
+    if (RCL_RET_OK == ret) {
+      return CreateJSObjectForSubscriptionEvent(env, subscription_event_type,
+                                                data);
+    }
+  } else if (event_type.Has("publisher_event_type")) {
+    rcl_publisher_event_type_t publisher_event_type =
+        static_cast<rcl_publisher_event_type_t>(
+            event_type.Get("publisher_event_type")
+                .As<Napi::Number>()
+                .Int32Value());
+    ret = rcl_take_event(event, &data);
+    if (RCL_RET_OK == ret) {
+      return CreateJSObjectForPublisherEvent(env, publisher_event_type, data);
+    }
+  }
+
+  Napi::Error::New(env, "failed to take event").ThrowAsJavaScriptException();
+  return env.Undefined();
+}
+
+Napi::Object InitEventHandleBindings(Napi::Env env, Napi::Object exports) {
+  exports.Set("createSubscriptionEventHandle",
+              Napi::Function::New(env, CreateSubscriptionEventHandle));
+  exports.Set("createPublisherEventHandle",
+              Napi::Function::New(env, CreatePublisherEventHandle));
+  exports.Set("takeEvent", Napi::Function::New(env, TakeEvent));
+  return exports;
+}
+
+}  // namespace rclnodejs

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

package/src/rcl_node_bindings.cpp

@@ -446,6 +446,10 @@ Napi::Value GetFullyQualifiedName(const Napi::CallbackInfo& info) {
   return Napi::String::New(env, fully_qualified_node_name);
 }
 
+Napi::Value GetRMWImplementationIdentifier(const Napi::CallbackInfo& info) {
+  return Napi::String::New(info.Env(), rmw_get_implementation_identifier());
+}
+
 Napi::Object InitNodeBindings(Napi::Env env, Napi::Object exports) {
   exports.Set("getParameterOverrides",
               Napi::Function::New(env, GetParameterOverrides));
@@ -468,6 +472,8 @@ Napi::Object InitNodeBindings(Napi::Env env, Napi::Object exports) {
   exports.Set("getNodeNames", Napi::Function::New(env, GetNodeNames));
   exports.Set("getFullyQualifiedName",
               Napi::Function::New(env, GetFullyQualifiedName));
+  exports.Set("getRMWImplementationIdentifier",
+              Napi::Function::New(env, GetRMWImplementationIdentifier));
   return exports;
 }