rclnodejs 1.0.0 → 1.2.0

package/src/rcl_node_bindings.cpp

@@ -385,40 +385,71 @@ Napi::Value GetNodeNames(const Napi::CallbackInfo& info) {
 
   RclHandle* node_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
   rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
+  bool get_enclaves = info[1].As<Napi::Boolean>().Value();
   rcutils_string_array_t node_names =
       rcutils_get_zero_initialized_string_array();
   rcutils_string_array_t node_namespaces =
       rcutils_get_zero_initialized_string_array();
+  rcutils_string_array_t enclaves = rcutils_get_zero_initialized_string_array();
   rcl_allocator_t allocator = rcl_get_default_allocator();
 
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK,
-      rcl_get_node_names(node, allocator, &node_names, &node_namespaces),
-      "Failed to get_node_names.");
+  if (get_enclaves) {
+    THROW_ERROR_IF_NOT_EQUAL(
+        RCL_RET_OK,
+        rcl_get_node_names_with_enclaves(node, allocator, &node_names,
+                                         &node_namespaces, &enclaves),
+        "Failed to get_node_names.");
+  } else {
+    THROW_ERROR_IF_NOT_EQUAL(
+        RCL_RET_OK,
+        rcl_get_node_names(node, allocator, &node_names, &node_namespaces),
+        "Failed to get_node_names.");
+  }
 
   Napi::Array result_list = Napi::Array::New(env, node_names.size);
 
   for (size_t i = 0; i < node_names.size; ++i) {
     Napi::Object item = Napi::Object::New(env);
-
     item.Set("name", Napi::String::New(env, node_names.data[i]));
     item.Set("namespace", Napi::String::New(env, node_namespaces.data[i]));
-
+    if (get_enclaves) {
+      item.Set("enclave", Napi::String::New(env, enclaves.data[i]));
+    }
     result_list.Set(i, item);
   }
 
   rcutils_ret_t fini_names_ret = rcutils_string_array_fini(&node_names);
   rcutils_ret_t fini_namespaces_ret =
       rcutils_string_array_fini(&node_namespaces);
-
+  rcutils_ret_t fini_enclaves_ret = rcutils_string_array_fini(&enclaves);
   THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, fini_names_ret,
                            "Failed to destroy node_names");
   THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, fini_namespaces_ret,
                            "Failed to destroy node_namespaces");
-
+  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, fini_enclaves_ret,
+                           "Failed to fini enclaves string array");
   return result_list;
 }
 
+Napi::Value GetFullyQualifiedName(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());
+  const char* fully_qualified_node_name =
+      rcl_node_get_fully_qualified_name(node);
+  if (!fully_qualified_node_name) {
+    Napi::Error::New(env, "Fully qualified name not set")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  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));
@@ -439,6 +470,10 @@ Napi::Object InitNodeBindings(Napi::Env env, Napi::Object exports) {
   exports.Set("countServices", Napi::Function::New(env, CountServices));
 #endif
   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;
 }
 

package/src/rcl_publisher_bindings.cpp

@@ -128,6 +128,24 @@ Napi::Value GetSubscriptionCount(const Napi::CallbackInfo& info) {
   return Napi::Number::New(env, count);
 }
 
+Napi::Value WaitForAllAcked(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  rcl_publisher_t* publisher = reinterpret_cast<rcl_publisher_t*>(
+      RclHandle::Unwrap(info[0].As<Napi::Object>())->ptr());
+  bool lossless;
+  int64_t nanoseconds = info[1].As<Napi::BigInt>().Int64Value(&lossless);
+
+  rcl_ret_t ret = rcl_publisher_wait_for_all_acked(publisher, nanoseconds);
+  if (RCL_RET_OK == ret) {
+    return Napi::Boolean::New(env, true);
+  } else if (RCL_RET_TIMEOUT == ret) {
+    return Napi::Boolean::New(env, false);
+  }
+  Napi::Error::New(env, "Failed to wait for all acknowledgements")
+      .ThrowAsJavaScriptException();
+  return env.Undefined();
+}
+
 Napi::Object InitPublisherBindings(Napi::Env env, Napi::Object exports) {
   exports.Set("createPublisher", Napi::Function::New(env, CreatePublisher));
   exports.Set("publish", Napi::Function::New(env, Publish));
@@ -135,6 +153,7 @@ Napi::Object InitPublisherBindings(Napi::Env env, Napi::Object exports) {
   exports.Set("publishRawMessage", Napi::Function::New(env, PublishRawMessage));
   exports.Set("getSubscriptionCount",
               Napi::Function::New(env, GetSubscriptionCount));
+  exports.Set("waitForAllAcked", Napi::Function::New(env, WaitForAllAcked));
   return exports;
 }
 

package/src/rcl_type_description_service_bindings.cpp

@@ -0,0 +1,79 @@
+// 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_type_description_service_bindings.h"
+
+#include <napi.h>
+#include <rcl/rcl.h>
+#include <rmw/types.h>
+
+#include "rcl_handle.h"
+
+namespace rclnodejs {
+
+Napi::Value InitTypeDescriptionService(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_service_t* service =
+      reinterpret_cast<rcl_service_t*>(malloc(sizeof(rcl_service_t)));
+  *service = rcl_get_zero_initialized_service();
+  rcl_ret_t ret = rcl_node_type_description_service_init(service, node);
+  if (RCL_RET_OK != ret) {
+    Napi::Error::New(env, "Failed to initialize type description service")
+        .ThrowAsJavaScriptException();
+  }
+
+  auto service_handle =
+      RclHandle::NewInstance(env, service, node_handle, [node, env](void* ptr) {
+        rcl_service_t* service = reinterpret_cast<rcl_service_t*>(ptr);
+        rcl_ret_t ret = rcl_service_fini(service, node);
+        if (RCL_RET_OK != ret) {
+          Napi::Error::New(env, "Failed to destroy type description service")
+              .ThrowAsJavaScriptException();
+        }
+        free(ptr);
+      });
+  return service_handle;
+}
+
+Napi::Value HandleRequest(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(
+      RclHandle::Unwrap(info[0].As<Napi::Object>())->ptr());
+  void* request = info[1].As<Napi::Buffer<char>>().Data();
+  void* taken_response = info[2].As<Napi::Buffer<char>>().Data();
+
+  rmw_request_id_t header;
+  rcl_node_type_description_service_handle_request(
+      node, &header,
+      static_cast<
+          type_description_interfaces__srv__GetTypeDescription_Request*>(
+          request),
+      static_cast<
+          type_description_interfaces__srv__GetTypeDescription_Response*>(
+          taken_response));
+  return env.Undefined();
+}
+
+Napi::Object InitTypeDescriptionServiceBindings(Napi::Env env,
+                                                Napi::Object exports) {
+  exports.Set("handleRequest", Napi::Function::New(env, HandleRequest));
+  exports.Set("initTypeDescriptionService",
+              Napi::Function::New(env, InitTypeDescriptionService));
+
+  return exports;
+}
+
+}  // namespace rclnodejs

package/src/rcl_type_description_service_bindings.h

@@ -0,0 +1,27 @@
+// 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_TYPE_DESCRIPTION_SERVICE_BINDINGS_H_
+#define SRC_RCL_TYPE_DESCRIPTION_SERVICE_BINDINGS_H_
+
+#include <napi.h>
+
+namespace rclnodejs {
+
+Napi::Object InitTypeDescriptionServiceBindings(Napi::Env env,
+                                                Napi::Object exports);
+
+}
+
+#endif  // SRC_RCL_TYPE_DESCRIPTION_SERVICE_BINDINGS_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/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,
@@ -285,12 +303,14 @@ declare module 'rclnodejs' {
      * @param typeClass - Type of message that will be published.
      * @param topic - Name of the topic the publisher will publish to.
      * @param options - Configuration options, see DEFAULT_OPTIONS
+     * @param eventCallbacks - Optional The event callbacks for the publisher.
      * @returns New instance of Publisher.
      */
     createPublisher<T extends TypeClass<MessageTypeClassName>>(
       typeClass: T,
       topic: string,
-      options?: Options
+      options?: Options,
+      eventCallbacks?: (event: object) => void
     ): Publisher<T>;
 
     /**
@@ -315,6 +335,7 @@ declare module 'rclnodejs' {
      * @param topic - Name of the topic the subcription will subscribe to.
      * @param options - Configuration options, see DEFAULT_OPTIONS
      * @param callback - Called when a new message is received. The serialized message will be null-terminated.
+     * @param eventCallbacks - Optional The event callbacks for the subscription.
      * @returns New instance of Subscription.
      * @throws Error - May throw an RMW error if options.content-filter is malformed.
      * @see {@link https://www.omg.org/spec/DDS/1.4/PDF|Content-filter details at DDS 1.4 specification, Annex B}
@@ -323,7 +344,8 @@ declare module 'rclnodejs' {
       typeClass: T,
       topic: string,
       options: Options,
-      callback: SubscriptionCallback<T> | SubscriptionWithRawMessageCallback
+      callback: SubscriptionCallback<T> | SubscriptionWithRawMessageCallback,
+      eventCallbacks?: (event: object) => void
     ): Subscription;
 
     /**
@@ -769,6 +791,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.
@@ -796,5 +825,18 @@ declare module 'rclnodejs' {
      * @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;
+
+    /**
+     * Get the RMW implementation identifier
+     * @returns - The RMW implementation identifier.
+     */
+    getRMWImplementationIdentifier(): string;
   }
 }

package/types/publisher.d.ts

@@ -20,5 +20,22 @@ declare module 'rclnodejs' {
      * @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;
   }
 }