rclnodejs 1.6.0 → 1.7.0

package/lib/time_source.js

@@ -19,6 +19,7 @@ const { Clock, ROSClock } = require('./clock.js');
 const { ClockType } = Clock;
 const { Parameter, ParameterType } = require('./parameter.js');
 const Time = require('./time.js');
+const { TypeValidationError, OperationError } = require('./errors.js');
 
 const USE_SIM_TIME_PARAM = 'use_sim_time';
 const CLOCK_TOPIC = '/clock';
@@ -102,7 +103,9 @@ class TimeSource {
    */
   attachNode(node) {
     if ((!node) instanceof rclnodejs.ShadowNode) {
-      throw new TypeError('Invalid argument, must be type of Node');
+      throw new TypeValidationError('node', node, 'Node', {
+        entityType: 'time source',
+      });
     }
 
     if (this._node) {
@@ -150,8 +153,12 @@ class TimeSource {
   detachNode() {
     if (this._clockSubscription) {
       if (!this._node) {
-        throw new Error(
-          'Unable to destroy previously created clock subscription'
+        throw new OperationError(
+          'Unable to destroy previously created clock subscription',
+          {
+            code: 'NO_NODE_ATTACHED',
+            entityType: 'time source',
+          }
         );
       }
       this._node.destroySubscription(this._clockSubscription);
@@ -167,7 +174,9 @@ class TimeSource {
    */
   attachClock(clock) {
     if (!(clock instanceof ROSClock)) {
-      throw new TypeError('Only clocks with type ROS_TIME can be attached.');
+      throw new TypeValidationError('clock', clock, 'ROSClock', {
+        entityType: 'time source',
+      });
     }
     clock.rosTimeOverride = this._lastTimeSet;
     clock.isRosTimeActive = this._isRosTimeActive;

package/lib/utils.js

@@ -15,6 +15,7 @@
 const fs = require('fs');
 const fsPromises = require('fs/promises');
 const path = require('path');
+const { ValidationError } = require('./errors.js');
 
 /**
  * Ensure directory exists, create recursively if needed (async)
@@ -182,6 +183,25 @@ function detectUbuntuCodename() {
   }
 }
 
+/**
+ * Normalize a ROS 2 node name by removing the leading slash if present.
+ *
+ * ROS 2 node names may be specified with or without a leading slash depending
+ * on the context. This utility ensures consistent representation without the
+ * leading slash, which is the standard format for most ROS 2 APIs.
+ *
+ * @param {string} nodeName - The node name to normalize
+ * @returns {string} The normalized node name without leading slash
+ *
+ * @example
+ * normalizeNodeName('my_node')    // 'my_node'
+ * normalizeNodeName('/my_node')   // 'my_node'
+ * normalizeNodeName('/ns/my_node') // 'ns/my_node'
+ */
+function normalizeNodeName(nodeName) {
+  return nodeName.startsWith('/') ? nodeName.substring(1) : nodeName;
+}
+
 /**
  * Check if two numbers are equal within a given tolerance.
  *
@@ -294,7 +314,12 @@ function compareVersions(version1, version2, operator) {
     case '!==':
       return cmp !== 0;
     default:
-      throw new Error(`Invalid operator: ${operator}`);
+      throw new ValidationError(`Invalid operator: ${operator}`, {
+        code: 'INVALID_OPERATOR',
+        argumentName: 'operator',
+        providedValue: operator,
+        expectedType: "'eq' | 'ne' | 'lt' | 'lte' | 'gt' | 'gte'",
+      });
   }
 }
 
@@ -302,6 +327,7 @@ module.exports = {
   // General utilities
   detectUbuntuCodename,
   isClose,
+  normalizeNodeName,
 
   // File system utilities (async)
   ensureDir,

package/lib/validator.js

@@ -15,16 +15,15 @@
 'use strict';
 
 const rclnodejs = require('./native_loader.js');
+const { TypeValidationError, NameValidationError } = require('./errors.js');
 
 /**
  * An object - Representing a validator in ROS.
  * @exports validator
  */
 let validator = {
-  _createErrorFromValidation: function (result) {
-    let err = new Error(result[0]);
-    err.invalidIndex = result[1];
-    return err;
+  _createErrorFromValidation: function (result, nameValue, nameType) {
+    return new NameValidationError(nameValue, nameType, result[0], result[1]);
   },
 
   /**
@@ -34,14 +33,14 @@ let validator = {
    */
   validateFullTopicName(topic) {
     if (typeof topic !== 'string') {
-      throw new TypeError('Invalid argument');
+      throw new TypeValidationError('topic', topic, 'string');
     }
 
     let result = rclnodejs.validateFullTopicName(topic);
     if (result === null) {
       return true;
     }
-    throw this._createErrorFromValidation(result);
+    throw this._createErrorFromValidation(result, topic, 'topic');
   },
 
   /**
@@ -51,14 +50,14 @@ let validator = {
    */
   validateNodeName(name) {
     if (typeof name !== 'string') {
-      throw new TypeError('Invalid argument');
+      throw new TypeValidationError('name', name, 'string');
     }
 
     let result = rclnodejs.validateNodeName(name);
     if (result === null) {
       return true;
     }
-    throw this._createErrorFromValidation(result);
+    throw this._createErrorFromValidation(result, name, 'node');
   },
 
   /**
@@ -68,14 +67,14 @@ let validator = {
    */
   validateTopicName(topic) {
     if (typeof topic !== 'string') {
-      throw new TypeError('Invalid argument');
+      throw new TypeValidationError('topic', topic, 'string');
     }
 
     let result = rclnodejs.validateTopicName(topic);
     if (result === null) {
       return true;
     }
-    throw this._createErrorFromValidation(result);
+    throw this._createErrorFromValidation(result, topic, 'topic');
   },
 
   /**
@@ -85,14 +84,14 @@ let validator = {
    */
   validateNamespace(namespace) {
     if (typeof namespace !== 'string') {
-      throw new TypeError('Invalid argument');
+      throw new TypeValidationError('namespace', namespace, 'string');
     }
 
     let result = rclnodejs.validateNamespace(namespace);
     if (result === null) {
       return true;
     }
-    throw this._createErrorFromValidation(result);
+    throw this._createErrorFromValidation(result, namespace, 'namespace');
   },
 };
 

package/package.json

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

package/types/base.d.ts

@@ -8,6 +8,7 @@
 /// <reference path="./distro.d.ts" />
 /// <reference path="./duration.d.ts" />
 /// <reference path="./entity.d.ts" />
+/// <reference path="./errors.d.ts" />
 /// <reference path="./guard_condition.d.ts" />
 /// <reference path="./interfaces.d.ts" />
 /// <reference path="./lifecycle.d.ts" />
@@ -16,6 +17,8 @@
 /// <reference path="./node.d.ts" />
 /// <reference path="./node_options.d.ts" />
 /// <reference path="./parameter.d.ts" />
+/// <reference path="./parameter_client.d.ts" />
+/// <reference path="./parameter_watcher.d.ts" />
 /// <reference path="./publisher.d.ts" />
 /// <reference path="./qos.d.ts" />
 /// <reference path="./rate.d.ts" />

package/types/client.d.ts

@@ -14,6 +14,21 @@ declare module 'rclnodejs' {
       callback: Client.ResponseCallback<T>
     ): void;
 
+    /**
+     * Make a service request and return a Promise that resolves with the response.
+     *
+     * @param request - Request to be submitted.
+     * @param options - Optional parameters for the request.
+     * @returns Promise that resolves with the service response.
+     * @throws TimeoutError if the request times out (when options.timeout is exceeded).
+     * @throws AbortError if the request is manually aborted (via options.signal).
+     * @throws Error if the request fails for other reasons.
+     */
+    sendRequestAsync(
+      request: ServiceRequestMessage<T>,
+      options?: Client.AsyncRequestOptions
+    ): Promise<ServiceResponseMessage<T>>;
+
     /**
      * Checks if the service is ready.
      *
@@ -74,5 +89,26 @@ declare module 'rclnodejs' {
     export type ResponseCallback<T extends TypeClass<ServiceTypeClassName>> = (
       response: ServiceResponseMessage<T>
     ) => void;
+
+    /**
+     * Options for async service requests
+     */
+    export interface AsyncRequestOptions {
+      /**
+       * Timeout in milliseconds for the request.
+       * Internally uses AbortSignal.timeout() for standards compliance.
+       */
+      timeout?: number;
+
+      /**
+       * AbortSignal to cancel the request.
+       * When the signal is aborted, the request will be cancelled
+       * and the promise will reject with an AbortError.
+       *
+       * Can be combined with timeout parameter - whichever happens first
+       * will abort the request.
+       */
+      signal?: AbortSignal;
+    }
   }
 }