rclnodejs 0.33.0 → 1.1.0

package/src/rcl_utilities.cpp

@@ -12,16 +12,115 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "rcl_utilities.hpp"
+#include "rcl_utilities.h"
 
 #include <rcl/rcl.h>
 #include <rcl_action/rcl_action.h>
+#include <rmw/topic_endpoint_info.h>
 #include <uv.h>
 
+#include <memory>
 #include <string>
 
 namespace {
+
+const rmw_qos_profile_t* GetQoSProfileFromString(const std::string& profile) {
+  const rmw_qos_profile_t* qos_profile = nullptr;
+  if (profile == "qos_profile_sensor_data") {
+    qos_profile = &rmw_qos_profile_sensor_data;
+  } else if (profile == "qos_profile_system_default") {
+    qos_profile = &rmw_qos_profile_system_default;
+  } else if (profile == "qos_profile_services_default") {
+    qos_profile = &rmw_qos_profile_services_default;
+  } else if (profile == "qos_profile_parameters") {
+    qos_profile = &rmw_qos_profile_parameters;
+  } else if (profile == "qos_profile_parameter_events") {
+    qos_profile = &rmw_qos_profile_parameter_events;
+  } else if (profile == "qos_profile_action_status_default") {
+    qos_profile = &rcl_action_qos_profile_status_default;
+  } else {
+    return &rmw_qos_profile_default;
+  }
+
+  return qos_profile;
+}
+
+std::unique_ptr<rmw_qos_profile_t> GetQosProfileFromObject(
+    Napi::Object object) {
+  std::unique_ptr<rmw_qos_profile_t> qos_profile =
+      std::make_unique<rmw_qos_profile_t>();
+
+  auto history = object.Get("history");
+  auto depth = object.Get("depth");
+  auto reliability = object.Get("reliability");
+  auto durability = object.Get("durability");
+  auto avoid_ros_namespace_conventions =
+      object.Get("avoidRosNameSpaceConventions");
+
+  qos_profile->history = static_cast<rmw_qos_history_policy_t>(
+      history.As<Napi::Number>().Uint32Value());
+  qos_profile->depth = depth.As<Napi::Number>().Uint32Value();
+  qos_profile->reliability = static_cast<rmw_qos_reliability_policy_t>(
+      reliability.As<Napi::Number>().Uint32Value());
+  qos_profile->durability = static_cast<rmw_qos_durability_policy_t>(
+      durability.As<Napi::Number>().Uint32Value());
+  qos_profile->avoid_ros_namespace_conventions =
+      avoid_ros_namespace_conventions.As<Napi::Boolean>();
+
+  return qos_profile;
+}
+
+Napi::Value ConvertRMWTimeToDuration(Napi::Env env,
+                                     const rmw_time_t* duration) {
+  Napi::Object obj = Napi::Object::New(env);
+  obj.Set("seconds", Napi::BigInt::New(env, duration->sec));
+  obj.Set("nanoseconds", Napi::Number::New(env, duration->nsec));
+  return obj;
+}
+
+#if ROS_VERSION > 2205  // 2205 == Humble
+Napi::Value ConvertToHashObject(Napi::Env env,
+                                const rosidl_type_hash_t* type_hash) {
+  Napi::Object obj = Napi::Object::New(env);
+  obj.Set("version", Napi::Number::New(env, type_hash->version));
+  obj.Set("value", Napi::Buffer<char>::Copy(
+                       env, reinterpret_cast<const char*>(type_hash->value),
+                       ROSIDL_TYPE_HASH_SIZE));
+  return obj;
+}
+#endif
+
+Napi::Value ConvertToJSTopicEndpoint(
+    Napi::Env env, const rmw_topic_endpoint_info_t* topic_endpoint_info) {
+  Napi::Array endpoint_gid = Napi::Array::New(env, RMW_GID_STORAGE_SIZE);
+  for (size_t i = 0; i < RMW_GID_STORAGE_SIZE; i++) {
+    endpoint_gid.Set(
+        i, Napi::Number::New(env, topic_endpoint_info->endpoint_gid[i]));
+  }
+
+  Napi::Object endpoint = Napi::Object::New(env);
+  endpoint.Set("node_name",
+               Napi::String::New(env, topic_endpoint_info->node_name));
+  endpoint.Set("node_namespace",
+               Napi::String::New(env, topic_endpoint_info->node_namespace));
+  endpoint.Set("topic_type",
+               Napi::String::New(env, topic_endpoint_info->topic_type));
+#if ROS_VERSION > 2205  // 2205 == Humble
+  endpoint.Set("topic_type_hash",
+               ConvertToHashObject(env, &topic_endpoint_info->topic_type_hash));
+#endif
+  endpoint.Set("endpoint_type",
+               Napi::Number::New(
+                   env, static_cast<int>(topic_endpoint_info->endpoint_type)));
+  endpoint.Set("endpoint_gid", endpoint_gid);
+  endpoint.Set("qos_profile",
+               rclnodejs::ConvertToQoS(env, &topic_endpoint_info->qos_profile));
+  return endpoint;
+}
+
 uv_lib_t g_lib;
+Napi::Env g_env = nullptr;
+
 }  // namespace
 
 namespace rclnodejs {
@@ -95,4 +194,70 @@ std::string GetErrorMessageAndClear() {
   return std::string(uv_dlerror(&g_lib));
 }
 
+Napi::Env& GetEnv() { return g_env; }
+
+void StoreEnv(Napi::Env current_env) { g_env = current_env; }
+
+std::unique_ptr<rmw_qos_profile_t> GetQoSProfile(Napi::Value qos) {
+  std::unique_ptr<rmw_qos_profile_t> qos_profile =
+      std::make_unique<rmw_qos_profile_t>();
+
+  if (qos.IsString()) {
+    *qos_profile = *GetQoSProfileFromString(qos.As<Napi::String>().Utf8Value());
+  } else if (qos.IsObject()) {
+    qos_profile = GetQosProfileFromObject(qos.As<Napi::Object>());
+  } else {
+    return qos_profile;
+  }
+  return qos_profile;
+}
+
+void ExtractNamesAndTypes(rcl_names_and_types_t names_and_types,
+                          Napi::Array* result_list) {
+  Napi::Env env = result_list->Env();
+
+  for (size_t i = 0; i < names_and_types.names.size; ++i) {
+    Napi::Object item = Napi::Object::New(env);
+    std::string topic_name = names_and_types.names.data[i];
+    item.Set("name", Napi::String::New(env, names_and_types.names.data[i]));
+
+    Napi::Array type_list =
+        Napi::Array::New(env, names_and_types.types[i].size);
+    for (size_t j = 0; j < names_and_types.types[i].size; ++j) {
+      type_list.Set(j,
+                    Napi::String::New(env, names_and_types.types[i].data[j]));
+    }
+    item.Set("types", type_list);
+    result_list->Set(i, item);
+  }
+}
+
+Napi::Value ConvertToQoS(Napi::Env env, const rmw_qos_profile_t* qos_profile) {
+  Napi::Object qos = Napi::Object::New(env);
+  qos.Set("depth", Napi::Number::New(env, qos_profile->depth));
+  qos.Set("history", Napi::Number::New(env, qos_profile->history));
+  qos.Set("reliability", Napi::Number::New(env, qos_profile->reliability));
+  qos.Set("durability", Napi::Number::New(env, qos_profile->durability));
+  qos.Set("lifespan", ConvertRMWTimeToDuration(env, &qos_profile->lifespan));
+  qos.Set("deadline", ConvertRMWTimeToDuration(env, &qos_profile->deadline));
+  qos.Set("liveliness", Napi::Number::New(env, qos_profile->liveliness));
+  qos.Set(
+      "liveliness_lease_duration",
+      ConvertRMWTimeToDuration(env, &qos_profile->liveliness_lease_duration));
+  qos.Set(
+      "avoid_ros_namespace_conventions",
+      Napi::Boolean::New(env, qos_profile->avoid_ros_namespace_conventions));
+  return qos;
+}
+
+Napi::Array ConvertToJSTopicEndpointInfoList(
+    Napi::Env env, const rmw_topic_endpoint_info_array_t* info_array) {
+  Napi::Array list = Napi::Array::New(env, info_array->size);
+  for (size_t i = 0; i < info_array->size; ++i) {
+    rmw_topic_endpoint_info_t topic_endpoint_info = info_array->info_array[i];
+    list.Set(i, ConvertToJSTopicEndpoint(env, &topic_endpoint_info));
+  }
+  return list;
+}
+
 }  // namespace rclnodejs

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

@@ -12,9 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef SRC_RCL_UTILITIES_HPP_
-#define SRC_RCL_UTILITIES_HPP_
+#ifndef SRC_RCL_UTILITIES_H_
+#define SRC_RCL_UTILITIES_H_
 
+#include <napi.h>
+#include <rcl/graph.h>
+#include <rmw/rmw.h>
+
+#include <memory>
 #include <string>
 
 struct rosidl_message_type_support_t;
@@ -35,6 +40,19 @@ const rosidl_action_type_support_t* GetActionTypeSupport(
 
 std::string GetErrorMessageAndClear();
 
+// Store a reference to the environment that can be used for error reporting.
+Napi::Env& GetEnv();
+void StoreEnv(Napi::Env current_env);
+
+std::unique_ptr<rmw_qos_profile_t> GetQoSProfile(Napi::Value qos);
+void ExtractNamesAndTypes(rcl_names_and_types_t names_and_types,
+                          Napi::Array* result_list);
+
+Napi::Array ConvertToJSTopicEndpointInfoList(
+    Napi::Env env, const rmw_topic_endpoint_info_array_t* info_array);
+
+Napi::Value ConvertToQoS(Napi::Env env, const rmw_qos_profile_t* qos_profile);
+
 }  // namespace rclnodejs
 
-#endif  // SRC_RCL_UTILITIES_HPP_
+#endif  // SRC_RCL_UTILITIES_H_

package/src/shadow_node.cpp

@@ -12,47 +12,43 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "shadow_node.hpp"
+#include "shadow_node.h"
 
 #include <memory>
 #include <vector>
 
-#include "executor.hpp"
-#include "handle_manager.hpp"
-#include "rcl_handle.hpp"
+#include "executor.h"
+#include "handle_manager.h"
+#include "rcl_handle.h"
 
 namespace rclnodejs {
 
-Nan::Persistent<v8::Function> ShadowNode::constructor;
+Napi::FunctionReference ShadowNode::constructor;
 
-ShadowNode::ShadowNode() : handle_manager_(std::make_unique<HandleManager>()) {
-  executor_ = std::make_unique<Executor>(handle_manager_.get(), this);
+ShadowNode::ShadowNode(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<ShadowNode>(info),
+      handle_manager_(std::make_unique<HandleManager>()) {
+  executor_ =
+      std::make_unique<Executor>(info.Env(), handle_manager_.get(), this);
 }
 
-ShadowNode::~ShadowNode() {
-  Nan::HandleScope scope;
+ShadowNode::~ShadowNode() { StopRunning(); }
 
-  StopRunning();
-}
-
-void ShadowNode::Init(v8::Local<v8::Object> exports) {
-  Nan::HandleScope scope;
-
-  // Prepare constructor template
-  v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
-  tpl->SetClassName(Nan::New("ShadowNode").ToLocalChecked());
-  tpl->InstanceTemplate()->SetInternalFieldCount(1);
+void ShadowNode::Init(Napi::Env env, Napi::Object exports) {
+  Napi::HandleScope scope(env);
 
-  Nan::SetPrototypeMethod(tpl, "start", Start);
-  Nan::SetPrototypeMethod(tpl, "stop", Stop);
-  Nan::SetPrototypeMethod(tpl, "syncHandles", SyncHandles);
-  Nan::SetPrototypeMethod(tpl, "spinOnce", SpinOnce);
+  Napi::Function func =
+      DefineClass(env, "ShadowNode",
+                  {
+                      InstanceMethod("start", &ShadowNode::Start),
+                      InstanceMethod("stop", &ShadowNode::Stop),
+                      InstanceMethod("syncHandles", &ShadowNode::SyncHandles),
+                      InstanceMethod("spinOnce", &ShadowNode::SpinOnce),
+                  });
 
-  v8::Local<v8::Context> context = exports->GetIsolate()->GetCurrentContext();
-
-  constructor.Reset(tpl->GetFunction(context).ToLocalChecked());
-  Nan::Set(exports, Nan::New("ShadowNode").ToLocalChecked(),
-           tpl->GetFunction(context).ToLocalChecked());
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+  exports.Set("ShadowNode", func);
 }
 
 void ShadowNode::StopRunning() {
@@ -61,82 +57,67 @@ void ShadowNode::StopRunning() {
 }
 
 void ShadowNode::StartRunning(rcl_context_t* context, int32_t timeout) {
-  handle_manager_->SynchronizeHandles(this->handle());
+  handle_manager_->SynchronizeHandles(this->Value());
   executor_->Start(context, timeout);
 }
 
 void ShadowNode::RunOnce(rcl_context_t* context, int32_t timeout) {
-  handle_manager_->SynchronizeHandles(this->handle());
+  handle_manager_->SynchronizeHandles(this->Value());
   executor_->SpinOnce(context, timeout);
 }
 
-NAN_METHOD(ShadowNode::Start) {
-  auto* me = Nan::ObjectWrap::Unwrap<ShadowNode>(info.Holder());
-  RclHandle* context_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  auto timeout = Nan::To<int32_t>(info[1]).FromJust();
-  rcl_context_t* context =
-      reinterpret_cast<rcl_context_t*>(context_handle->ptr());
-  if (me) me->StartRunning(context, timeout);
+Napi::Value ShadowNode::Start(const Napi::CallbackInfo& info) {
+  Napi::Object context_handle = info[0].As<Napi::Object>();
+  RclHandle* handle = RclHandle::Unwrap(context_handle);
+  int32_t timeout = info[1].As<Napi::Number>().Int32Value();
 
-  info.GetReturnValue().Set(Nan::Undefined());
-}
+  rcl_context_t* context = reinterpret_cast<rcl_context_t*>(handle->ptr());
+  StartRunning(context, timeout);
 
-NAN_METHOD(ShadowNode::Stop) {
-  auto* me = Nan::ObjectWrap::Unwrap<ShadowNode>(info.Holder());
-  if (me) me->StopRunning();
+  return info.Env().Undefined();
+}
 
-  info.GetReturnValue().Set(Nan::Undefined());
+Napi::Value ShadowNode::Stop(const Napi::CallbackInfo& info) {
+  StopRunning();
+  return info.Env().Undefined();
 }
 
-NAN_METHOD(ShadowNode::SpinOnce) {
-  auto* me = Nan::ObjectWrap::Unwrap<ShadowNode>(info.Holder());
-  RclHandle* context_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  auto timeout = Nan::To<int32_t>(info[1]).FromJust();
-  rcl_context_t* context =
-      reinterpret_cast<rcl_context_t*>(context_handle->ptr());
-  if (me) me->RunOnce(context, timeout);
+Napi::Value ShadowNode::SpinOnce(const Napi::CallbackInfo& info) {
+  Napi::Object context_handle = info[0].As<Napi::Object>();
+  RclHandle* handle = RclHandle::Unwrap(context_handle);
+  int32_t timeout = info[1].As<Napi::Number>().Int32Value();
+
+  rcl_context_t* context = reinterpret_cast<rcl_context_t*>(handle->ptr());
+  RunOnce(context, timeout);
 
-  info.GetReturnValue().Set(Nan::Undefined());
+  return info.Env().Undefined();
 }
 
-NAN_METHOD(ShadowNode::SyncHandles) {
-  auto* me = Nan::ObjectWrap::Unwrap<ShadowNode>(info.Holder());
-  if (me) {
-    me->handle_manager()->SynchronizeHandles(me->handle());
-  }
+Napi::Value ShadowNode::SyncHandles(const Napi::CallbackInfo& info) {
+  handle_manager()->SynchronizeHandles(this->Value());
+  return info.Env().Undefined();
 }
 
 void ShadowNode::Execute(const std::vector<rclnodejs::RclHandle*>& handles) {
-  Nan::HandleScope scope;
-  Nan::AsyncResource res("shadow_node");
+  Napi::Env env = Env();
+  Napi::HandleScope scope(env);
 
-  v8::Local<v8::Array> results = Nan::New<v8::Array>(handles.size());
+  Napi::Array results = Napi::Array::New(env, handles.size());
   for (size_t i = 0; i < handles.size(); ++i) {
     handles[i]->SyncProperties();
-    Nan::Set(results, i, handles[i]->handle());
+    results[i] = handles[i]->Value();
   }
 
-  v8::Local<v8::Value> argv[] = {results};
-
-  res.runInAsyncScope(Nan::New(this->persistent()), "execute", 1, argv);
+  Napi::Function execute =
+      Value().As<Napi::Object>().Get("execute").As<Napi::Function>();
+  execute.Call(Value(), {results});
 }
 
 void ShadowNode::CatchException(std::exception_ptr e_ptr) {
   try {
     std::rethrow_exception(e_ptr);
   } catch (const std::exception& e) {
-    Nan::ThrowError(e.what());
-  }
-}
-
-void ShadowNode::New(const Nan::FunctionCallbackInfo<v8::Value>& info) {
-  if (info.IsConstructCall()) {
-    // Invoked as constructor: `new ShadowNode(...)`
-    ShadowNode* obj = new ShadowNode();
-    obj->Wrap(info.This());
-    info.GetReturnValue().Set(info.This());
+    Napi::Error::New(Env(), e.what()).ThrowAsJavaScriptException();
   }
 }
 

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

@@ -12,25 +12,26 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef SRC_SHADOW_NODE_HPP_
-#define SRC_SHADOW_NODE_HPP_
+#ifndef SRC_SHADOW_NODE_H_
+#define SRC_SHADOW_NODE_H_
 
-#include <nan.h>
+#include <napi.h>
 
 #include <exception>
 #include <memory>
 #include <vector>
 
-#include "executor.hpp"
+#include "executor.h"
 
 namespace rclnodejs {
 
 class HandleManager;
 class Executor;
 
-class ShadowNode : public Nan::ObjectWrap, public Executor::Delegate {
+class ShadowNode : public Napi::ObjectWrap<ShadowNode>,
+                   public Executor::Delegate {
  public:
-  static void Init(v8::Local<v8::Object> exports);
+  static void Init(Napi::Env env, Napi::Object exports);
   void StartRunning(rcl_context_t* context, int32_t timeout);
   void StopRunning();
   void RunOnce(rcl_context_t* context, int32_t timeout);
@@ -41,18 +42,18 @@ class ShadowNode : public Nan::ObjectWrap, public Executor::Delegate {
   void Execute(const std::vector<rclnodejs::RclHandle*>& handles) override;
   void CatchException(std::exception_ptr e_ptr) override;
 
- private:
-  ShadowNode();
+  explicit ShadowNode(const Napi::CallbackInfo& info);
   ~ShadowNode();
 
-  static void New(const Nan::FunctionCallbackInfo<v8::Value>& info);
-  static Nan::Persistent<v8::Function> constructor;
-  static NAN_METHOD(Stop);
-  static NAN_METHOD(Start);
-  static NAN_METHOD(SyncHandles);
-  static NAN_METHOD(SpinOnce);
-  static NAN_GETTER(HandleGetter);
-  static NAN_SETTER(HandleSetter);
+ private:
+  static Napi::FunctionReference constructor;
+
+  Napi::Value Stop(const Napi::CallbackInfo& info);
+  Napi::Value Start(const Napi::CallbackInfo& info);
+  Napi::Value SyncHandles(const Napi::CallbackInfo& info);
+  Napi::Value SpinOnce(const Napi::CallbackInfo& info);
+  Napi::Value HandleGetter(const Napi::CallbackInfo& info);
+  void HandleSetter(const Napi::CallbackInfo& info, const Napi::Value& value);
 
   std::unique_ptr<HandleManager> handle_manager_;
   std::unique_ptr<Executor> executor_;
@@ -60,4 +61,4 @@ class ShadowNode : public Nan::ObjectWrap, public Executor::Delegate {
 
 }  // namespace rclnodejs
 
-#endif  // SRC_SHADOW_NODE_HPP_
+#endif  // SRC_SHADOW_NODE_H_

package/types/action_client.d.ts

@@ -173,5 +173,23 @@ declare module 'rclnodejs' {
      * Destroy the underlying action client handle.
      */
     destroy(): void;
+
+    /**
+     * Get the number of wait set entities that make up an action entity.
+     * @return - The number of subscriptions, guard_conditions, timers, and clients and services.
+     */
+    getNumEntities(): object;
+
+    /**
+     * Configure introspection.
+     * @param clock - Clock to use for service event timestamps
+     * @param QoSProfile - QOS profile for the service event publisher
+     * @param introspectionState - The state to set introspection to
+     */
+    configureIntrospection(
+      clock: Clock,
+      serviceEventPubQOS: QoS,
+      introspectionState: ServiceIntrospectionStates
+    ): void;
   }
 }

package/types/action_server.d.ts

@@ -181,5 +181,17 @@ declare module 'rclnodejs' {
      * Destroy the action server and all goals.
      */
     destroy(): void;
+
+    /**
+     * Configure introspection.
+     * @param clock - Clock to use for service event timestamps
+     * @param QoSProfile - QOS profile for the service event publisher
+     * @param introspectionState - The state to set introspection to
+     */
+    configureIntrospection(
+      clock: Clock,
+      serviceEventPubQOS: QoS,
+      introspectionState: ServiceIntrospectionStates
+    ): void;
   }
 }

package/types/context.d.ts

@@ -87,5 +87,11 @@ declare module 'rclnodejs' {
      * @returns The default Context
      */
     static defaultContext(): Context;
+
+    /**
+     * Get the domain ID of this context.
+     * @returns domain ID of this context
+     */
+    domainId(): number;
   }
 }

package/types/lifecycle.d.ts

@@ -326,6 +326,13 @@ declare module 'rclnodejs' {
         topic: string,
         options?: Options
       ): LifecyclePublisher<T>;
+
+      /**
+       * Check if state machine is initialized.
+       *
+       * @returns {boolean} true if the state machine is initialized; otherwise false.
+       */
+      get isInitialized(): boolean;
     }
   } // lifecycle namespace
 } // rclnodejs namespace

package/types/node.d.ts

@@ -142,6 +142,24 @@ declare module 'rclnodejs' {
     namespace: string;
   };
 
+  /**
+   * Result of Node.getNodeNames() query
+   *
+   * @example
+   * ```
+   * [
+   *   { name: 'gazebo',                namespace: '/', enclave: '/'},
+   *   { name: 'robot_state_publisher', namespace: '/', enclave: '/' },
+   *   { name: 'cam2image',             namespace: '/demo' , enclave: '/'}
+   * ]
+   * ```
+   */
+  type NodeNamesQueryResultWithEnclaves = {
+    name: string;
+    namespace: string;
+    enclave: string;
+  };
+
   /**
    * Node is the primary entrypoint in a ROS system for communication.
    * It can be used to create ROS entities such as publishers, subscribers,
@@ -727,6 +745,29 @@ declare module 'rclnodejs' {
      */
     getServiceNamesAndTypes(): Array<NamesAndTypesQueryResult>;
 
+    /**
+     * Get an array of publishers on a given topic.
+     *
+     * @param topic - The name of the topic.
+     * @param noDemangle - if `true`, `topic_name` needs to be a valid middleware topic name,
+     *       otherwise it should be a valid ROS topic name.
+     * @returns An array of publishers.
+     */
+    getPublishersInfoByTopic(topic: string, noDemangle: boolean): Array<object>;
+
+    /**
+     * Get an array of subscriptions on a given topic.
+     *
+     * @param topic - The name of the topic.
+     * @param noDemangle - if `true`, `topic_name` needs to be a valid middleware topic name,
+     *     otherwise it should be a valid ROS topic name.
+     * @returns An array of subscriptions.
+     */
+    getSubscriptionsInfoByTopic(
+      topic: string,
+      noDemangle: boolean
+    ): Array<object>;
+
     /**
      * Get the list of nodes discovered by the provided node.
      *
@@ -746,6 +787,13 @@ declare module 'rclnodejs' {
      */
     getNodeNamesAndNamespaces(): Array<NodeNamesQueryResult>;
 
+    /**
+     * Get the list of nodes and their namespaces with enclaves discovered by the provided node.
+     *
+     * @returns An array of the names, namespaces and enclaves.
+     */
+    getNodeNamesAndNamespacesWithEnclaves(): Array<NodeNamesQueryResultWithEnclaves>;
+
     /**
      * Return the number of publishers on a given topic.
      * @param topic - The name of the topic.
@@ -759,5 +807,26 @@ declare module 'rclnodejs' {
      * @returns Number of subscribers on the given topic.
      */
     countSubscribers(topic: string): number;
+
+    /**
+     * Get the number of clients on a given service name.
+     * @param serviceName - The service name.
+     * @returns Number of clients.
+     */
+    countClients(serviceName: string): number;
+
+    /**
+     * Get the number of services  on a given service name.
+     * @param serviceName - The service name.
+     * @returns Number of services.
+     */
+    countServices(serviceName: string): number;
+
+    /**
+     * Get the fully qualified name of the node.
+     *
+     * @returns String containing the fully qualified name of the node.
+     */
+    getFullyQualifiedName(): string;
   }
 }

package/types/publisher.d.ts

@@ -14,5 +14,28 @@ declare module 'rclnodejs' {
      * @param message - The message to be sent.
      */
     publish(message: MessageType<T> | Buffer): void;
+
+    /**
+     * Get the number of subscriptions to this publisher.
+     * @returns The number of subscriptions
+     */
+    subscriptionCount(): number;
+
+    /**
+     * Wait until all published message data is acknowledged or until the specified timeout elapses
+     *
+     * If the timeout is negative then this function will block indefinitely until all published
+     * message data is acknowledged.
+     * If the timeout is 0 then it will check if all published message has been acknowledged without
+     * waiting.
+     * If the timeout is greater than 0 then it will return after that period of time has elapsed or
+     * all published message data is acknowledged.
+     *
+     * Raises an error if failed, such as the middleware not supporting this feature.
+     *
+     * @param {timeout} timeout - The duration to wait for all published message data to be acknowledged in nanoseconds.
+     * @return {boolean} `true` if all published message data is acknowledged before the timeout, otherwise `false`.
+     */
+    waitForAllAcked(timeout: bigint): boolean;
   }
 }